[tony]

Why

libtmux-ruby's own docs build failed in libtmux-ruby#90 (step "Build the selected Ruby documentation tree"): core-apis: ruby/send-keys names LibTmux::Server#open_control, but the program never uses open_control. examples/api/capture.rb stopped attaching a control client when the library began requiring tmux 3.7 for one, and now polls pane.capture, but core-apis.json still listed the five control-mode symbols it used to call. Docs CI passed because it reads the example cache, which is bound to the revision of the Ruby API model, and that pin was a week behind libtmux-ruby master. The port's build reads the live file.

A guard for this already exists. apisUsed is run over every cached showcase program by core-apis.test.ts, and programProblems by core-capabilities.test.ts and portCapabilities. The incident was a stale input, not a missing check: with only the model and cache refreshed, core-apis.test.ts fails on exactly the message above.

What

The Ruby pin moves to libtmux-ruby 20744401e (master). The model, the example cache and everything bound to the pin are regenerated with the repository's generators from the committed bytes of a fresh read-only clone. The refresh brings unrelated API changes, kept as generated:

• The four gems move from 0.1.0.alpha.1 to 0.1.1.
• New symbols: LibTmux::Support, Support::Versions, tmux_version and supports_control? on Server and Async::Server, and require_supported and server_version on both support modules. None is removed.
• version_timeout joins Server.new, Server.open and Async::Server.open; environment joins Endpoint.new and MCP::CLI.run; PaneSnapshot#pid may be nil; Pane#break_out documents ProtocolError; the Endpoint and Server docs gain text.
• Complete programs now attach to 55 API pages, up from 19.
• Pane#break_out now also sends list-panes when break-pane prints no window ID, and rename-window after its repaired tmux 3.7 break-pane.
• The "Discussed in" index gains the mentions of the guides master ships.

ruby/send-keys lists what the program calls. The five control-mode symbols (Server#open_control, ControlConnection#exchange, ControlConnection#subscribe, ControlSubscription#next, ControlEvent#data) are gone. The list is Server, Server.start, Server#new_session, CreationReceipt#pane, Pane#send_text, Pane#send_keys, Pane#capture and CommandResult#stdout, each resolved against the refreshed model. The capability's title is "Send keys" and the data holds no summary, so nothing on the Core page claimed the program watches through control mode, and core-capabilities.json and core-home.json needed no change. The Core home still says Ruby can watch via control mode, which stays true: LibTmux::ControlConnection is in the model.

The guard now covers its own incident. core-apis.test.ts takes the ports to check from the capability table instead of a list of three, and pins the polling program as a frozen fixture: the corrected list resolves against it, and a list that still names any of the five control-mode symbols is refused with that symbol's name.

What the refresh forced (each its own commit):

• tmux-usage: the Ruby rules cite lines of the old source. 219 citations were carried to where the same text sits at the new revision, and the eight dispatcher chains gain the run to dispatch hop that Server#run now has.
• API example receipt: 36 new Ruby pages and 19 rebound ones, with native runs (see Verification).
• Extractor: RBS allows a name after a positional type ((::String value)), which the new Support methods use. rbsSignature kept ::String value as the type; it now reads the name, and a union still ends in its last member.
• Navigation: LibTmux::Support is recorded as unsettled in nav-config.ts.
• manifest-packages.json and the destination evidence move to 0.1.1; the evidence is re-verified whole because its tests hold every record to one check date.

Decision for the reviewer

The Ruby cell job now carries if: needs.plan.outputs.run_cells == 'true', and the old workflowStep refused any job-level if, so ruby/create-windows and ruby/send-keys could no longer be shown as run by CI. The commit "Accept a job that waits on its workflow's plan" added plannedRun, and the review follow-up below narrowed it. It now allows one form only. The capability entry names the flag (ci.planOutput, run_cells for both Ruby entries). The job's if must be that flag from a job it needs, compared with 'true'. That plan job must have no needs, if or tolerated failure, and must publish the flag as ${{ steps.<id>.outputs.<flag> }} of a step that exists and carries no condition. Every other condition is still refused, with a test for each. The port's ci-plan selects cells for every push and pull request; this check cannot read that. If you would rather keep the rule strict, drop that commit and the two Ruby capabilities leave the showcase.

For the wave tooling (outside this repository)

The r12 packet's check-core-capabilities-heads.py should also run apisUsed over the programs it reads at each port's head, with the same lists as core-apis.json, so a port-side change that drops a listed symbol is caught before the port's build is. Port the function as it is: comments and strings are blanked first, a method counts only in its call forms (.name, ::name, &:name), and a type or constant counts as a bare word.

Verification

• Focused suites (core-apis, core-capabilities, core-home, port-landing-page, product-copy, example-sources, ruby-api-examples) passed 182 tests on main. With only the model and cache refreshed they failed 24, among them core-apis on ruby/send-keys names LibTmux::Server#open_control, but the program never uses open_control. On this branch they pass.
• The whole site unit suite passes (229 files, 8003 tests; the five assembled-tree files are skipped because nothing is assembled) and so does the api-model suite (59 files, 1299 tests). The new extractor test fails without the extractor change, and the two Ruby workflow-step tests failed until plannedRun was added.
• gen-tmux-usage --check --source --ports ruby regenerates Ruby from the checkout and matches; gen-tmux-usage.negative.mjs, check-example-blocks.negative.mjs, gen-product-copy.negative.mjs and gen-workspace-showcase.negative.mjs pass; check-nav, check-api-links, and the --check modes of the model, example-source, mentions, workspace-showcase, workspace-entities, product-copy, tmux-catalog and shell-ports generators pass. astro check reports no errors and oxlint --type-aware no warnings in the changed files.
• Native runs with scripts/check-example-prose.py --example api --port ruby, one per program on tmux 3.3a and 3.7c, restoring the gems from rubygems.org with Ruby 4.0.7: 15 programs passed on both releases, and the two control-mode programs passed on 3.7c and stop on 3.3a with control connections require tmux 3.7 or newer.
• Source checkout: the Ruby generators and tests ran against a read-only clone of libtmux-ruby master, set through LIBTMUX_DOCS_CHECKOUT_RUBY.

Not done or failing:

• workspace_apply.rb fails on both tmux releases with LibTmux::Workspace::ConfigError: workspace file could not be read. It is new at this pin and loads ../workspace.yaml, which no page displays, so the four pages that show it are not self-contained. Their receipt entries say "Not verified" and list no tmux release. This needs a fix in libtmux-ruby; I made no port change.
• The intros of the two control-mode pages say "tmux 3.3a or newer" although the library refuses a control client below 3.7. Also a libtmux-ruby fix.
• gen-manifest-packages --check still reports Elixir, as on main: its committed entry names an older revision than its model.
• Not run: the site build, the publication audit, check-clipboard, and the browser checks. The full destination run also moved registry versions for other ports, recorded as found.
• The Rust and Go Core caches were not refreshed or compared with their port heads.

Review follow-ups

An independent review returned changes needed. The findings and what this branch does about each:

The Ruby source-guide cache was stale (high). site/src/data/port-guides/ruby.json still recorded libtmux-ruby 9b1545562 while the model recorded 20744401e. stage-port-docs.mjs refuses that (ruby: guide source ... differs from integrated model ...) and build-site.sh runs it with --cached on every build, so every port's publisher build and this PR's test job failed, at "Stage integrated source guides". The cache is regenerated with --port ruby --from-source --refresh-cache from a clean clone at 20744401e. From the committed bytes, --from-source with the CI checkouts, --cached --check, --cached (a plain build and with LIBTMUX_DOCS_PORT=rs) and gen-mentions --check pass.

The Ruby MCP caches were stale (high). The protocol snapshot, the Ruby rows of the tool matrix and the recorded transcript are regenerated at 20744401e with gen-mcp-protocol.mjs --port ruby, gen-mcp-tools.mjs --port ruby and gen-mcp-transcript.mjs --port ruby, each followed by its --check. The other ports' matrix rows are unchanged.

The Rust and TypeScript replays fell back to "Requests only". After the r12 wave the recorded contracts of both transcripts differed from the tool schemas at each port's master: run_shell_command's output schema for Rust, and run_shell_command's and list_windows's for TypeScript. All input schemas matched. Both are recorded again at libtmux-rs 6942c1e60 and libtmux-ts 073b9d7de, each built and run by the repository's own generators from a clean read-only clone, in a private tmux sandbox. Every contract in each transcript now equals the snapshot's and the matrix row's for that tool, for all three of Ruby, Rust and TypeScript. TypeScript's master also registers five program tools (start_program, read_program, run_program, wait_for_exit, stop_program) that the committed snapshot predates, so the matrix lists them. The first Rust recording caught the split pane's command as tmux, the moment before its shell started; three repeats gave sh, as the previous recording and TypeScript's show, and the committed file is one of those repeats.

plannedRun accepted too much (medium). A cell gated on run_development, a plan output hard-wired to 'false' or reading a step that does not exist, needs: [other] # plan, a plan that needs a conditional job, and a plan whose only step is if: false all counted as run by CI. See the rule under "Decision for the reviewer". Comments are stripped before needs is read. A job-level if whose comment reads continue-on-error: false is refused too; the old check let it through. Each counterexample has a test, needs: other has one that pins the membership check, and the real Ruby compatibility.yml at 20744401e still passes for both entries and is refused once the entry names no flag. Sixteen of the new tests fail against the previous predicate.

A hard-coded count in ruby-api-examples.test.ts (low). toBe(18) is now a comparison, as sets, of the receipt's source files with the files the model's example blocks link, so a mismatch names the file.

Destination-evidence churn (low). Left as is. Keeping only the four RubyGems records and main's other records fails three age and future-date tests in destination-evidence.test.ts, which hold every record to the file's one check date, so the file cannot be split cleanly. The churn is the checkedAt bump on every record plus the versions the registries of other ports now report (Maven Central, crates.io, hex.pm, LuaRocks, the Swift Package Index).

Verification of this follow-up (it supersedes the counts above):

• The full site unit suite passes with workers capped, run through the heavy-job wrapper: 256 files and 8242 tests passed; the five assembled-tree files and 351 tests are skipped because nothing is assembled. The seven focused suites pass, and so does the api-model suite (60 files, 1305 tests, one skipped).
• astro check reports no errors or warnings, and oxlint --type-aware is clean on the changed files.
• The source checks of the publication audit that run offline pass: example sources, mention index, workspace entities, navigation, workspace showcase, product copy, tmux library usage for Ruby (regenerated and compared), shell ports, tmux catalog, destination evidence, API destination evidence, source links, example blocks, example indentation and API links in prose. gen-manifest-packages --check still reports Elixir, as on main.
• Not run: gen-mcp-tools.mjs --check and gen-mcp-protocol.mjs --check without --port, because this machine's Python, Julia and Go checkouts sit at other heads than their committed snapshots, which fails the same way on main. The --port checks for Ruby, Rust and TypeScript pass. Also not run: the site build, the full publication audit and the browser checks.

Port follow-ups (libtmux-ruby)

Two problems in the Ruby API example pages need a change in libtmux-ruby; this branch makes none. It holds the eleven pages that show the affected programs back (see "Third review follow-ups"), so no page states the wrong text, and they come back when these fixes land. The native runs record the problems.

Four reference pages tell readers to save a program that needs a file they were not shown. Workspace.load, Workspace#plan, Workspace::Plan#steps and Workspace::Plan#apply show examples/api/workspace_apply.rb after a Gemfile. The program calls LibTmux::Workspace.load(File.expand_path("../workspace.yaml", __dir__)), which is examples/workspace.yaml, and no page displays it. Saved alone, the program stops with LibTmux::Workspace::ConfigError: workspace file could not be read. Fix in examples/api/workspace_apply.rb: write the document to a temporary directory inside the program and load it from there, which keeps Workspace.load in use and the expected output (planned steps: 11, applied: true, sessions: work) unchanged.

require "libtmux"
require "libtmux/workspace"
require "tmpdir"

LibTmux::Server.start do |server|
  Dir.mktmpdir do |directory|
    path = File.join(directory, "workspace.yaml")
    File.write(path, <<~'YAML')
      session_name: work
      environment:
        PROJECT_MODE: development
      windows:
        - window_name: editor
          window_index: 1
          layout: tiled
          panes:
            - shell_command: printf 'editor ready\n'
            - {}
    YAML
    workspace = LibTmux::Workspace.load(path)
    plan = workspace.plan(snapshot: server.snapshot)
    puts "planned steps: #{plan.steps.length}"
    result = plan.apply(server: server)
    puts "applied: #{result.success?}"
    puts "sessions: #{server.list_sessions.map { |session| session.snapshot.name }.join(', ')}"
  end
end

Keep the begin, docs:begin main and rescue frame the file has now. The raw heredoc (<<~'YAML') keeps the \n in printf literal. Saved alone in an empty directory, the file at the pin stops with the ConfigError above, and this version prints the expected three lines (checked on tmux 3.8a, not on the receipt's 3.3a and 3.7c). After the port moves its pin, refresh this repository's example receipt so the four entries are verified on both tmux releases.

Two control-mode programs say "tmux 3.3a or newer" although the library needs 3.7. examples/api/control.rb and examples/api/async_control.rb show on seven pages (Server#open_control, ControlConnection#exchange, ControlConnection#subscribe, ControlSubscription#next, Async::Server#open_control, Async::ControlConnection#events, Async::ControlSubscription#next). A control client below tmux 3.7 is refused with control connections require tmux 3.7 or newer (gems/libtmux/lib/libtmux/capabilities.rb, capability control-mode, since: "3.7"). The sentence is not in libtmux-ruby: attachCompleteRubyExamples in packages/api-model/src/languages/ruby-examples.ts writes the same floor into the intro of every complete program, and the port's manifest has nowhere to say otherwise. The fix therefore has two halves. In libtmux-ruby, add the floor to the two manifest entries api_control and api_async_control in examples/manifest.json, as "tmux": "3.7" beside description and output under api; the other programs omit it. In this repository, once that lands, read api.tmux in attachCompleteRubyExamples and use it in place of the fixed 3.3a, defaulting to 3.3a, and regenerate the Ruby model and receipt.

These 11 pages come back when the fixes land. HELD_RUBY_PROGRAMS in packages/api-model/src/languages/ruby-examples.ts lists examples/api/workspace_apply.rb, examples/api/control.rb and examples/api/async_control.rb, each with its reason. When libtmux-ruby merges the workspace_apply.rb change, move the Ruby pin, delete that entry, regenerate the model (gen-api-model --port ruby) and refresh the example receipt for the four Workspace pages. When its manifest declares api.tmux for api_control and api_async_control, read it in attachCompleteRubyExamples in place of the fixed 3.3a, delete the other two entries and refresh the receipt for the seven control-mode pages. An entry left behind after the manifest drops its program fails the generator and ruby-api-examples.test.ts.

Second review follow-ups

A second independent review at f12be07 confirmed the earlier fixes and asked for four more changes. CI at that head also failed in the browser matrix. This section supersedes the statements above where it differs: the Rust Core cache is now refreshed at the Rust pin (Go's is not), and check-clipboard's complete-examples check has been run.

The TypeScript and Rust API models now match the MCP matrix (medium). The matrix and snapshots were recorded at libtmux-ts 073b9d7de and libtmux-rs 6942c1e60, while the models still described 46cccfef2 and a6fc2a656, and a tool page builds its source link from the model's revision. So read_program, start_program and stop_program linked packages/mcp/src/tools/programs.ts, which does not exist at 46cccfef2, and run_program and wait_for_exit cited files that do not register them and kept no line. Both models are regenerated with gen-api-model from clean read-only clones of the two masters, and everything bound to the pin follows, each from its own generator and checked in its --check mode: the example cache, product copy, workspace showcase (which drops its TypeScript pin, as the generator requires once the model has caught up), the manifest index at 0.1.2 and the destination evidence for it (a live read-only run: crates.io lists 0.1.2 for all four crates, the npm pages answer 403 as before), the tmux usage rules and data, the navigation sidecars, the Rust example receipt, the prose-link review lists, and the MCP matrix rows. TypeScript gains 68 symbols and loses none (the Server.spawn program API). Rust gains 13 and loses three constants (PANE_BORDER_FORMAT_PER_PANE, PROMPT_HISTORY, SERVER_ACCESS).

• New check. registrationFileProblems holds every registration's file to the committed file list of its model, and mcp-source-links.test.ts runs it over the committed matrix, so it runs in CI with no checkout. It also requires the TypeScript and Rust registrations to sit on their model's revision, so it cannot pass by judging nothing. registrationLinkProblems and scripts/check-mcp-source-links.mjs, added to the publication audit, read each registration from a checkout at the revision it cites: the file exists, the line is inside it, and the wire name is a whole word within its own registration. A port with no checkout, or without the revision, is reported as skipped. Negative cases cover a missing file, another revision, a file that does not register the tool, a line past the end or none, a name that is only part of another or belongs to the next registration, and the script run over a repository that lacks the cited file.
• Measured against the old state. Run on this branch's previous head, the script reports exactly the five tools above for TypeScript (three missing files, two with no line) and nothing for Rust. On this head every registration of the ten ports resolves at the revision it cites.
• Navigation. The new TypeScript declarations Server.spawn brings (program.Program, types.ProgramPlacement, types.ProgramExit) and common.assertSupportedTmux, and Rust's src.SandboxCanary, are recorded as unsettled with their reasons, as LibTmux::Support was. A reviewer who wants a TypeScript "Programs" bucket would replace those three entries.
• Native runs. The Rust receipt records seven programs run as displayed with check-example-prose.py --example api --port rs on tmux 3.3a and 3.7c, Rust 1.99.0, cargo add libtmux@0.1.2 resolving to 0.1.2 on crates.io: 14 runs, all exited 0 with their expected output. TypeScript has no complete API programs.

The Rust split-pane answer no longer races (low). The Rust server describes a pane the moment it splits it, and tmux names the forked child tmux and reports no path until the shell has replaced it. Of thirteen recordings, five caught the tmux form; the committed file held the other unsettled form (sh with a null path). A server cannot be waited on from outside its answer, so the recorder now rejects an unsettled answer and records again: verifySettledPanes requires every pane an answer describes to run the shell (cat for the Ruby session that borrows one) and to name a path, and gen-mcp-transcript.mjs records up to six times before it fails, stopping only the servers of its own sandbox between attempts. The Rust transcript is recorded again with a settled pane, and a unit test requires every committed recording to satisfy the check. mcp-replay.test.ts keeps pinning sh, which is now what the recorder guarantees.

plannedRun refuses a cell that waits on a skippable job (low). 54147eb is kept as written and pushed. alwaysRuns follows every other job in needs to the end and refuses an if, a tolerated failure, a job the workflow does not define, and a cycle. Its six new tests fail against the previous predicate (checked by putting the previous file back) and pass with it; the real Ruby compatibility.yml still passes for both entries.

The CI failure was a wrong route in the receipt. checkCompleteApiExamples failed with LibTmux::Workspace#plan: HTTP 404. The nine Ruby programs on Workspace declarations named ports/ruby/reference/<slug>, but the site serves a workspace declaration under its product, ruby/latest/workspace/reference/<slug> (productApiHref). The check reads the route from the receipt and stops at the first failure, so it had not looked at the pages after that one, and ruby-api-examples.test.ts spelled the same core path and agreed with the receipt. The nine entries now name the workspace reference. A test over every receipt entry requires the page to be the one productApiHref gives the declaration, plus one that a workspace declaration is served under the workspace reference. The browser matrix's other checks had passed in that run; the log held no other failure.

Verification of this follow-up

• Run from this tree against a development server: checkCompleteApiExamples passes for all 295 programs on 285 pages. With the nine old pages put back it fails with LibTmux::Workspace#plan: HTTP 404, as in CI. The server mirrors check-dev.mjs's own setup; the rest of that matrix was not run.
• Full site suite with the pinned clones of ts, rs and ruby set through LIBTMUX_DOCS_CHECKOUT_<PORT>: 256 files and 8267 tests passed; 5 files and 351 tests are skipped because nothing is assembled. Without them, six tests fail on this machine only because its standard ts and rs checkouts lack the new commits (port-landing and core-capabilities read the workflow at the model's revision); CI has no such checkout and skips them. The api-model suite passes (60 files, 1305 tests, one skipped). astro check reports 0 errors and 0 warnings; it needs --max-old-space-size=8192 here. oxlint reports nothing new in the changed files.
• Per port (ruby, rs, ts), each with its checkout at the recorded revision: gen-mcp-protocol --check, gen-mcp-tools --check and gen-mcp-transcript --check pass. gen-api-model --check passes for ts and rs; gen-example-sources, gen-product-copy, gen-workspace-showcase, gen-mentions and verify-destinations pass in their --check modes; gen-tmux-usage --check --source --ports ts,rs regenerates both and matches; check-nav, check-api-links, check-source-links for ts, rs and ruby, and check-mcp-source-links pass, and so do the negative controls of tmux usage, the workspace showcase, product copy and example sources. stage-port-docs.mjs --cached passes plain and with LIBTMUX_DOCS_PORT=rs.
• Not run: the site build, the full publication audit, the rest of the browser matrix, and gen-mcp-tools and gen-mcp-protocol without --port (this machine's other checkouts sit at other heads). gen-manifest-packages --check still reports Elixir, as on main. The line and wire-name half of check-mcp-source-links needs a checkout, so CI runs only its file half.

Third review follow-ups

A third independent review at b2d6807 confirmed the pins, regenerations, transcripts, the retry loop and the receipt routes, and asked for the changes below. Root ruled that text known to be wrong is not published. CI at b2d6807 also failed in the Astro build; that is the last item. This section supersedes the statements above where it differs.

Eleven Ruby pages no longer show a program (medium). The pages of Workspace.load, Workspace#plan, Workspace::Plan#steps and Workspace::Plan#apply told readers to save workspace_apply.rb, which fails alone with ConfigError. The seven control-mode pages (Server#open_control, ControlConnection#exchange and #subscribe, ControlSubscription#next, Async::Server#open_control, Async::ControlConnection#events, Async::ControlSubscription#next) said "tmux 3.3a or newer" while the library refuses a control client below 3.7. attachCompleteRubyExamples now takes a list of held programs, each with a reason, and attaches none of a held program's symbols. A list entry the manifest does not select fails the generator, and ruby-api-examples.test.ts fails if a held program is attached to any page, if a held program is no longer selected by the manifest at the model's revision, or if a program that is not held is missing. The Ruby model is regenerated with gen-api-model --port ruby (only the eleven symbols change, each losing its four example blocks) and the eleven receipt entries are removed. Complete programs now attach to 44 Ruby pages, not 55. The other programs keep their receipt entries.

I did not derive a floor for the control programs. The manifest entries have no tmux field, and the 3.7 the docs hold is prose: the Ruby model says "tmux 3.7 and newer" in the doc of Server#supports_control?, and the cached source guides say "Control connections need tmux 3.7 or newer". Reading a version out of prose would be a guess, so the pages hold back instead.

A link into a neighbouring tool's registration passed (medium). registrationLinkProblems ended a span at the next line that any cited registration named, so a tool that cited its neighbour's line no longer cited its own, and the span ran on into its own registration. get_window_info citing get_session_info's line in TypeScript, contract.rs line 555 for 579 in Rust, and tmux_run citing tmux_snapshot's line in Ruby all passed. A registration now reaches from its cited line to the first line that names its tool, read from the file, and no two reaches in a file may share a line. Negative cases shaped like the three ports (TypeScript's name after registerTool(, Rust's after an attribute whose description names the next tool, Ruby's in constant lists far from the branch) pass at each tool's own line and refuse the neighbour's line and the lines before its name. With the pinned checkouts, in a copy of the matrix with those three citations altered, check-mcp-source-links.mjs --port ts, rs and ruby exited 0 before and exit 1 now; the committed matrix resolves for all ten ports, and moving each tool of each port to each neighbour's cited line is refused in all ten. A line in a neighbour's body, past the line that names it, is not refused: the file alone does not say where that body ends. The existing case of a name that lies in the next registration now reports the overlap in one message naming both tools.

Smaller changes. mcp-source-links.test.ts now requires Ruby, not only TypeScript and Rust, among the registrations on their model's revision (low). neededJobs reads a flow list that wraps onto further lines through its closing bracket, so needs: [plan, with lint] below is read as both (low). The header of gen-mcp-transcript.mjs describes the settle-and-retry (low). The branch history is out of the core-apis.test.ts comment and in the commit message (low). The Rust justfile evidence text in core-capabilities.json changed to script-env examples example-tables; it is true at 6942c1e60, where the check recipe lists script-env examples example-tables in place of the earlier doctest api-examples examples example-tables (low).

The dangling-reference ceiling. The Astro build failed with "62 unresolved mentions exceeds the ceiling of 60". The tally by port in the CI log (fsharp 28, swift 10, ruby 6, scala 6, kotlin 4, lua 3, powershell 2, csharp 1, py 1, ts 1) is the 60 unresolved mentions the committed mentions.json holds plus two PowerShell mentions it does not; main's list holds 57. The Ruby guides cached at the new pin added four spans that name nothing in the Ruby model and dropped one: Enter ("tmux key names such as Enter"), Example.check on two pages ("the Example.check assertion helper from the complete program") and error.message ("With --json, the refusal is in error.message"). The TypeScript and Rust refreshes added none; TypeScript's [Symbol.asyncDispose] is on main too. Each of the four is not API, and the resolver now says so rather than the ceiling moving. Example.<member> is the example fixture, as Example already was. A capitalised word in a sentence about "key names" names a tmux key, and a dotted lowercase path in a sentence about JSON is a field of that output; this is read from the span's own sentence and only after the name failed to resolve, so a name a port defines still links. The ceiling is unchanged at 60. Run through the real linking plugin over the staged Ruby guides, Ruby reports six unresolved before and two after (Enumerable and LibTmux, both on main); the committed list goes from 60 to 56, so the build reports 58. Cases cover each rule, the same spellings without the cue, a cue in the previous sentence and a span shaped unlike what the cue names.

Verification of this follow-up

• Full site suite with the pinned clones of ts, rs and ruby set through LIBTMUX_DOCS_CHECKOUT_<PORT>, through the heavy-job wrapper with two workers: 256 files and 8272 tests passed; 5 files and 351 tests are skipped because nothing is assembled. The api-model suite passes (60 files, 1316 tests, one skipped). oxlint reports nothing new in the changed files.
• Before and after, per change: the six neighbour cases of the source-link check failed on the old function and pass; four of the wrapped needs cases failed on the old neededJobs and pass; the first and third of the new tests over the committed Ruby model failed with the eleven programs attached and pass; the Ruby coverage assertion fails when the Ruby model's recorded revision moves, where the old one passed.
• gen-api-model --port ruby and gen-mcp-transcript --port ruby (a comment-only change, but run) pass in their --check modes against a clean clone of libtmux-ruby at 20744401e, and gen-mentions --check passes; check-mcp-source-links.mjs resolves all ten ports at the revisions the matrix cites, with ts, rs and ruby cloned read-only at their pins and deleted afterwards. The TypeScript and Rust transcript checks were not re-run: the change to that script is a comment. check-api-links, check-nav, check-example-blocks, check-example-indentation and the --check modes of the example-source, workspace-showcase, workspace-entities and product-copy generators pass.
• Not run: the site build and the publication audit. The dangling count above is measured with the linking plugin over the Ruby guides and read from the CI tally and the committed list for the other ports, not from a build; the full build took 53 minutes in CI.
• The rest of the CI log of run 41739010615 holds no other failure: the only failed step is the root build, which ended at that hook, and the preview jobs were skipped.