dispatch-gates classifies check:type-check-coverage as SILENT (known-irrelevant) for a card editing check-test-typecheck.mts, though the coupling is real and the path literal is in the gate's own source — it sits inside a prose sentence, so extractWatchHints discards it

[qq9340100]

Filed by the dev seat implementing #8538 (PR #8549). Unassigned and unlabeled for triage. Measured, not reasoned — a near-miss I hit on that card and worked around by hand.

⚠️ No gate is asked to be weakened, and dispatch-gates.mjs is accurate to its design. It derives families from each check's own source, and this coupling genuinely is not expressed there. The defect is that a real coupling exists and the derivation's output cannot express it, so silence reads as "no gates apply" when it means "no gate names this path".

The near-miss

#8538 changes exactly one file, scripts/check-test-typecheck.mts. The derivation says nothing applies:

$ node scripts/pm/dispatch-gates.mjs scripts/check-test-typecheck.mts
dispatch-gates: 93 check famil(ies) discovered across 25 workflow file(s) — derived at runtime, nothing listed in this script.

No check family names the given paths in its own source.

Repo-wide / undetermined (no path literals discoverable — not known irrelevant): 34 famil(ies).
Convention-scoped gates match by what the change IS, not where it lives. …

But check:type-check-coverage is genuinely coupled to that file, and I added it to my local run on my own reading. It went green only because I designed the change around the coupling. A dev who trusted the derivation would have skipped the one gate most likely to redden this diff.

Why the coupling is real — the 29-of-80 accounting

scripts/check-type-check-coverage.mjs holds a root entry @objectstack/spec-monorepo recorded at 80 errors, and its own note says:

> scripts/check-test-typecheck.mts alone accounts for 29 of the 80, and the analytics-reconcile tree for 32.

The note also records that 80 was re-measured exactly, with no bootstrap margin. Under the root tsconfig that program has no types:["node"], so in that file every console. reference costs +1 TS2584 and every process. reference +1 TS2591. Editing check-test-typecheck.mts therefore moves a number a different gate ratchets on, and ordinary additions move it: a self-test block that logged its own failures would have added several errors and turned check:type-check-coverage red.

Measured on the #8538 branch, before and after: 29 and 29, and check:type-check-coverage green. That is a designed-around result, not a free one.

The mechanism — SILENT, not undetermined

Sharper than "invisible", and worth stating precisely because it changes which remedy makes sense. Measured on main at 427344c using the script's own exported functions:

REAL exported extractWatchHints() on check-type-check-coverage.mjs
 hints extracted: 36
 sample: ["scripts/check-type-check-coverage.mjs","@objectstack/cloud-connection","@objectstack/core", …]
 any hint naming check-test-typecheck? NO
 classifyEntry verdict for this card: silent

Two consequences:

1. The path literal IS in the gate's own module body — scripts/check-type-check-coverage.mjs:427 contains the characters scripts/check-test-typecheck.mts. extractWatchHints still discards it, because it accepts a quoted literal only when the whole string is path-shaped (/^[\w.@][\w.@/*-]*$/). Here the path sits inside a prose sentence — 'scripts/check-test-typecheck.mts alone accounts for 29 of the 80, and the analytics-reconcile ' — so the spaces disqualify the entire literal and the path never becomes a hint. This is not the comment/self-test masking from [finding] dispatch-gates watch hints are read from self-test fixtures and comments, so gates are printed as MATCHED for paths they never read #8478; the string is a live module-body constant.
2. The family lands in the silent bucket, not undetermined. classifyEntry returns undetermined only when hints.length === 0; this file yields 36 hints (mostly package names), so the verdict is silent — neither matched nor undetermined, and therefore printed nowhere at all. The gate is actively judged known-irrelevant and dropped. That is why re-reading the "undetermined 34" would not have rescued it either.

So this is the mirror image of #8478, which recorded gates printed as MATCHED for paths they never read: this is a gate suppressed as irrelevant for a path it demonstrably does read.

Not a duplicate of the neighbouring cards

• dispatch-gates never derives a gate for a card that edits the gate's OWN check script — the resolved script paths are already in hand and unused #8509 — a gate not deriving its own check script. Already completed, landed via PR fix(pm): derive a gate family for a card that edits the gate's own check script (#8509) #8532, and that fix is present in the tree measured above. It does not help here: the coupled gate is a different script from the edited one.
• dispatch-gates.mjs cannot derive check:i18n from an object-definition edit — the checker discovers its population at runtime, so no path literal exists to match #8352 — gates whose population is computed at runtime, so no literal exists. Here a literal does exist and is thrown away.
• [finding] dispatch-gates watch hints are read from self-test fixtures and comments, so gates are printed as MATCHED for paths they never read #8478 — the module-body narrowing; the false-MATCHED direction. This is the false-SILENT direction.
• [finding] The two gates that most often redden a PR adding tests are not path-derivable, so no per-card gate list can ever name them #8117 — gates that are not path-derivable at all, hence unnameable per card. This one is derivable in principle; the coupling is written down, just not in a shape the extractor reads.

Two candidate remedies, deliberately not chosen and not built

Recording both so triage can rule rather than inherit a decision:

• A. Teach the derivation this coupling. Any mechanism that lets a gate's data ledger contribute hints — e.g. treating an embedded path-shaped substring inside a longer literal as a hint. Cost to weigh: relaxing the whole-literal rule is exactly what invites the [finding] dispatch-gates watch hints are read from self-test fixtures and comments, so gates are printed as MATCHED for paths they never read #8478 false-MATCHED failure back, since prose mentions a path without reading it. Whether "mentions" and "reads" can be told apart mechanically is the open question.
• B. Express the coupling in check-type-check-coverage.mjs's own source, in a shape the existing extractor already finds — a module-body constant holding the bare path, referenced by the note rather than spelled inside it. Cost to weigh: it is per-coupling manual upkeep, and a coupling nobody remembers to declare stays invisible, which is the same class of gap one level up.

⛔ Neither is attempted here, and this card does not ask for the gate or the derivation to be loosened.

Related

• check-test-typecheck.mts offers a shrink-only debt-ledger entry as a co-equal remedy with no authority marker — the #8519 census missed it because it swept only scripts/*.mjs #8538 / PR fix(devx): mark the ledger-expanding remedy maintainer-only in check-test-typecheck (#8538) #8549 — where this was hit; that PR's body carries the 29-before / 29-after measurement.
• dispatch-gates never derives a gate for a card that edits the gate's OWN check script — the resolved script paths are already in hand and unused #8509, [finding] dispatch-gates watch hints are read from self-test fixtures and comments, so gates are printed as MATCHED for paths they never read #8478, dispatch-gates.mjs cannot derive check:i18n from an object-definition edit — the checker discovers its population at runtime, so no path literal exists to match #8352, [finding] The two gates that most often redden a PR adding tests are not path-derivable, so no per-card gate list can ever name them #8117 — the neighbouring dispatch-gates findings, distinguished above. Each remains as triage left it; none is addressed here.

---

Generated by Claude Code

[hotlong]

Triage: pm:queue + domain:skills; type Task confirmed (the derivation is accurate to its design per the card's own statement — a capability gap in hint extraction, not a violated contract). Lands in scripts/pm/dispatch-gates.mjs territory (PM tooling → skills lane, per the #8534 precedent). — triage seat Routine.

Route guidance (PM-suggested route, measurement wins): prefer remedy B — declare the coupling as a bare path-shaped module-body constant in check-type-check-coverage.mjs, referenced by the prose note — over A; relaxing the whole-literal rule re-opens the #8478 false-MATCHED direction, and "mentions a path" vs "reads a path" is not mechanically separable today. B's per-coupling upkeep cost is real; if the dev finds a narrow A-variant with a control set proving no false-MATCHED regression, that wins. Note the cross-surface touch: taking B means the diff lands in scripts/check-type-check-coverage.mjs (devx gate farm) — declare it in the claim's file surface so the devx seat sees it.

Serial constraint: same-territory as #8545 (both cards are about dispatch-gates.mjs output) — hard serial across rounds, do not co-dispatch. In-flight #8538 (PR #8549) edits check-test-typecheck.mts itself; expected no overlap with route B's fix surface, but re-check at dispatch.

Size/model suggestion: S–M, mode:subagent. Not fable-mandatory (scripts/pm/, not .claude/skills/pm-dispatch/**).

---

Generated by Claude Code

[hotlong]

Claim: PM loop round 7
Session: session_018WuTtyckQa1VcXwgd52JpN
Branch: claude/issue-8551-coverage-coupling-hint
Worktree: objectstack-issue-8551
Domain: domain:skills
File surface: scripts/check-type-check-coverage.mjs (the coupling constant) + scripts/pm/dispatch-gates.mjs self-test only (a live pin that the coupling now derives) (stop on breach; explain in the report)
Container & model: S, mode:subagent, model: opus
Serial constraints cleared: dispatch-gates.mjs free (its last holder's PR merged 18:06Z; the in-flight findings-pipeline card touches SKILL.md/references only); check-type-check-coverage.mjs has no in-flight claim (lane + PR inventory current this hour). The sibling queue card about CHANGE_KIND_GATES rationale is serialized BEHIND this one (same dispatch-gates.mjs file).

Seat ruling recorded (direction B, not A): express the real coupling in check-type-check-coverage.mjs's own source in a shape the existing extractor already reads — a module-body constant holding the bare path, referenced by the prose note instead of spelled inside it. ⛔ Direction A (accepting path-shaped substrings inside longer literals) is declined: relaxing the whole-literal rule is precisely what re-invites the false-MATCHED failure the precision PR just removed, and "mentions vs reads" has no mechanical separator. B's per-coupling-manual cost is accepted for the one measured coupling; the dispatch-gates self-test live pin makes the declared coupling self-verifying (if the constant is ever deleted, the pin reddens). The card's own honest framing — silence must not read as no-gates-apply — is answered for this instance; the general SILENT-vs-undetermined presentation question stays open on the card family, not smuggled into this fix.

---

Generated by Claude Code

[hotlong]

{
 "issue": 8551,
 "status": "done",
 "branch": "claude/issue-8551-coverage-coupling-hint",
 "pr": "https://github.com/objectstack-ai/objectstack/pull/8603",
 "premise_still_valid": true,
 "summary": "Direction B as ruled. In scripts/check-type-check-coverage.mjs the coupled path is hoisted into a module-body constant ROOT_PROGRAM_COUPLED_SCRIPT = 'scripts/check-test-typecheck.mts', and the spec-monorepo ledger note now references that constant instead of spelling the path inside its sentence; the 29-of-80 accounting is preserved byte-for-byte (note string 950 chars, same sha256 prefix 80a7e1d9f4f3bb45, before and after). A live pin was added to dispatch-gates' self-test section only, reading both real files, so deleting the declaration reddens check:pm-dispatch-gates instead of going quietly SILENT again. extractWatchHints' whole-literal rule, hintCovers and the masking are untouched (direction A declined), and no ledger number moves. One surprise worth the PM's eye: check:type-check-debt now matches the same card too, because it resolves to the same script and inherits its hints — accurate, not fabricated, and the card's own gate list already named it.",
 "tests": "RED BASELINE, re-measured live on origin/main @ 8c433a8fd7 (three PRs after the card's measurements): `node scripts/pm/dispatch-gates.mjs scripts/check-test-typecheck.mts` -> 'No check family names the given paths in its own source.'; via the script's own exported functions, 36 hints extracted, none naming the coupled script, classifyEntry verdict `silent`. AFTER: the same command prints 'pnpm check:type-check-coverage [lint.yml] matched via scripts/check-test-typecheck.mts => scripts/check-test-typecheck.mts' plus check:type-check-debt; 37 hints (+1, exactly the new constant, none lost), verdict `matched`, provenance the constant. REVERSE VERIFICATION, direction predicted before running (SILENT returns, exactly the 2 new cases redden, coverage-gate numbers unchanged) — all three confirmed: '✗ dispatch-gates self-test: 2 of 103 case(s) failed', exit 1, and check:type-check-coverage printed identical counts and exited 0. Restored via `git checkout HEAD -- ...` from the commit (fix committed first), tree clean, green again. GATES, all green: check:pm-dispatch-gates '✓ dispatch-gates self-test: 103 cases pass' (101 before); check:type-check-coverage 'OK — 64/77 workspace packages type-checked (plus the root), 13 in the DEBT ledger (436 frozen raw errors), 1 exempt' + 'test layer: 20 package(s) ... 867 files hidden ... 1533 frozen raw errors in TEST_DEBT' — byte-identical before and after; check:type-check-debt refused loudly without the built closure ('--re-measure cannot run: 55 workspace dependenc(ies) ... have no built type entry point on disk'), so the closure was built as lint.yml does (turbo run build --filter=./packages/* --filter=./packages/*/*, 'Tasks: 70 successful, 70 total') and the gate then reported 'OK — 33 ledger entr(ies) re-measured in 302.4s, 1969 raw tsc error(s) total, none above its recorded number' / 'surplus: none — every entry sits exactly at its measurement'; check:nul-bytes 'OK (scanned 7740 text file(s) ... no raw ASCII control bytes)'; eslint on both changed files exit 0. Heavy phase ran under flock /tmp/os-heavy-verify.lock, foreground. GATE LIST: the prompt named check:pm-dispatch-gates, check:type-check-coverage, check:type-check-debt, check:nul-bytes and eslint; re-derived against the actual diff (`node scripts/pm/dispatch-gates.mjs scripts/check-type-check-coverage.mjs scripts/pm/dispatch-gates.mjs`) the tool returns exactly those three families and nothing further, so no addition was needed. Structural note: both edited files are .mjs and the root tsconfig.json sets no allowJs, so neither can contribute an error to the root program's 80 in either direction. Labels on PR #8603 read back after the write: ['skip-changeset'] (scripts/-only, releases nothing); it was the only label, nothing was clobbered. CI not waited on, per the report-at-draft-PR-time contract.",
 "open_questions": [],
 "out_of_scope_findings": [
 "filed as #8604: check-dispatch-gates.mjs's header still states hint extraction 'does not skip comments' and justifies its unquoted-paths workaround on that basis, but maskComments retired it — and maskComments' own docblock says so, naming that file; comment-only, no gate moves, filed with the `finding` label and no pm:queue"
 ]
}

---

Generated by Claude Code