feat(mt#4970): Exclude log-only-family records from the injected fire count

## Summary

`injectedFiresSinceLastReview` is the count the review thresholds key off, and its whole purpose (mt#3197) is to exclude detections the operator never saw. It computed that from `suppressionReasons` alone.

That is one of two ways a fire fails to reach the operator. The other is **per-FAMILY log-only gating inside a LIVE detector**: `turn-end-untaken-action-scan.ts` declares `LOG_ONLY_FAMILIES`, whose matches reach the calibration record and never `additionalContext`. Those records carry no suppression reason — nothing suppressed them; they were never eligible — and are otherwise **byte-identical** to an injecting family's.

So `untaken-action`'s 2026-09-04 window reported **120 injected fires where 23 reached the agent**. Every FP rate a reviewer computed over that denominator was 5x off, and the threshold that declared the log review-due fired on a population 81% invisible to the agent it was measuring.

## Key changes

- **Writer declares, sweep reads.** `toCalibrationMatches` marks each match whose family is log-only; the sweep excludes it via `isLogOnlyFamilyRecord` and reports it under `logOnlyFamilySinceLastReview`. A per-detector family table on the *reading* side is the drift hazard mt#4465 recorded for `judgedText` — two places would have to agree about `LOG_ONLY_FAMILIES` forever, and only one is edited when an arm flips.
- **`every`, not `some`.** A record carrying a log-only match *alongside* an injecting one DID reach the agent. 8 of the live window's 23 injected records are that shape; a `some` test would have swung the count wrong the other way.
- **`allWithheld` closes the cliff this exclusion opens.** See below.
- **Counted, not dropped.** The log-only arm's fire volume is exactly the evidence a decision to promote it would rest on.

### The cliff, and why it needed closing in the same PR

mt#4049 shipped `allSuppressed` days ago because keying cadence off the injected count inverts for a detector suppressing *all* its fires — the count pins at 0 and no count-bearing leg can fire.

Adding this exclusion opens the identical cliff through a **third column**: an all-log-only detector has `injectedFires === 0` **and** `suppressedSinceLastReview === 0`, so `atCountThreshold` is false, `allSuppressed` is false, and the log falls out of review entirely.

`allWithheld` (`injected === 0 && suppressed + logOnly >= FIRES_THRESHOLD`) **replaces** `allSuppressed` in the routing and equals it wherever no log-only family exists — every detector but `untaken-action` today, asserted as a test. `evaluatedOnly` is deliberately **outside** the union: those records never matched, so nothing is there to classify and their absence from review is correct rather than a gap.

## Testing

Execution evidence:

```
$ bun test --preload ./tests/setup.ts ./src/domain/calibration/calibration-sweep.log-only.test.ts
 13 pass
 0 fail
 32 expect() calls
```

**AT2** (`a mixed record counts as injected, not log-only`), **AT3** (`a detector with no log-only families reports an unchanged count`, which also asserts `allWithheld === allSuppressed`), **AT4** (`false when the marker is ABSENT`) and **AT5** (`an all-log-only log at volume stays routable and keeps its records`) all pass in that run, named by number.

`calibration-sweep.ts` and the untaken-action hook are both widely imported, so the full related-test closure was run:

```
$ bun scripts/run-related-tests.ts src/domain/calibration/calibration-sweep.ts \
    .minsky/hooks/turn-end-untaken-action-scan.ts \
    src/domain/calibration/calibration-sweep.log-only.test.ts scripts/verify-log-only-exclusion.ts
 3631 pass
 0 fail
Ran 3631 tests across 93 files. [27.41s]
```

**AT1** — the live corpus, via the shipped predicate:

```
$ bun scripts/verify-log-only-exclusion.ts --log <state-dir>/untaken-action-calibration.jsonl
  window: first 190 of 217 records

  as-is (pre-declaration)    injected= 120  logOnly=   0  suppressed=  70  evalOnly=   0
  with declaration applied   injected=  23  logOnly=  97  suppressed=  70  evalOnly=   0

OK: 97 records move from injected to log-only once the writer's declaration is present
(120 -> 23); the columns balance, and the as-is pass is unchanged at 120 because an absent
marker is not a declaration (AT4).
```

Guard canaries: `[PASS] turn-end-untaken-action-scan (registry, expects=warn)` — 74 total, 0 failed. Typecheck: 0 errors across 8 projects. Lint: 0 errors, 0 warnings.

Negative control — removing `!isLogOnlyFamilyRecord(r)` from the injected filter, restoring the pre-fix count exactly:

```
(fail) AT1: log-only records are counted under their own name, not as injected
(fail) AT2 end-to-end: a mixed record counts as injected, not log-only
(fail) a SUPPRESSED log-only record counts as suppressed, not log-only
(fail) AT5: an all-log-only log at volume stays routable and keeps its records
(fail) suppressed and log-only volume COMBINE to clear the bar
 8 pass
 5 fail
```

and the live artifact fails diagnostically rather than silently:

```
  with declaration applied   injected= 120  logOnly=  97
FAIL: 0 records left the injected column but 97 arrived in the log-only column. The two must
balance — a record may not be dropped from both or counted in both.
```

Reverted; the passing runs above are on the shipped tree.

## Deploy verification

`src/domain/calibration/calibration-sweep.ts` and its two test files return **true** from `isDeploySurfaceFile` (predicate run over the full changed set before writing this — the other 8 files return false, so no `[no-deploy-impact]` tag is claimed). Post-merge I will run `deployment_wait-for-latest` for `minsky-mcp` with `notBefore` set to the merge timestamp and `expectCommitSha` set to the merge SHA, and read `buildIdentity` rather than the status alone.

## Spec-decision reconciliation

Two calls, both recorded in the spec rather than left for review:

**SC3 vs AT4 — a genuine conflict, resolved in AT4's favour.** SC3 asks that the 2026-09-04 window report 23. AT4 requires a pre-declaration record to count as injected so historical FP rates do not shift under a reader. Every record in that window predates the declaration, so both cannot hold of the same run. The sweep treats an absent marker as "not declared"; reclassifying 97 already-acked records would move an FP rate under anyone who had computed one. Practical impact is nil — the watermark was advanced to 215 on 2026-09-04, so that window is acked and will not be swept again. SC3's figure is instead produced by the verification artifact above. Read SC3 as *"a window whose records carry the declaration reports 23."*

**SC5's "prefer generalizing over a parallel gate."** `allSuppressed` keeps its exact prior meaning and name; the generalization is `allWithheld`, which replaces it in the routing rather than sitting beside it. Widening `allSuppressed`'s own predicate was rejected: it would make `allSuppressed: true` for a log that suppressed nothing, which is a false statement to its six existing readers (including `scripts/verify-all-suppressed-routing.ts` from mt#4049) rather than a cosmetic naming issue.

## Notes for review

- Consumer enumeration was done at plan time and typecheck confirmed it: the only two sites needing changes were the fixture builders in `calibration-sweep.review-due.test.ts` and `calibration-review-cadence-detector.test.ts`, both of which now DERIVE the new fields the way they already derive `allSuppressed`, so no existing fixture changes behavior.
- `logOnly` is added to `CONSUMED_MATCH_KEYS` so it cannot also ride in `detectorFields` — mem#827 records reviewers reading that sub-object as if it were the record, and this field is read by the counting path.
- **mt#4318 does not subsume this** and vice-versa: that task surfaces a whole DETECTOR's `injection_enabled` posture; this is a per-FAMILY gate inside a detector that is live. `untaken-action` would read `injection_enabled: true` under mt#4318's fix and the 97 would still be miscounted. Both specs already reconcile each other; the skill note added here points at mt#4318 for the sibling case.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01TPNyYTreM4F7PRbvh4xA5b

Co-Authored-By: minsky-ai[bot] <minsky-ai[bot]@users.noreply.github.com>

Author: edobry

.claude/hooks/calibration-review-cadence-detector.ts

@@ -358,6 +358,19 @@ export function formatCadenceWarning(due: ReviewDueLog[]): string {
         `Judge the suppressions, not a false-positive rate: there are no fires to rate.`
       );
     }
+    // mt#4970: the same shape one column over, and it needs its own sentence for
+    // the same reason the leg above does. Saying "suppressed N" here would be
+    // false — nothing was suppressed; these matches were never eligible to
+    // inject — and the number to judge is the log-only volume, not a
+    // suppression count that is 0 on this leg by construction.
+    if (d.reason === "all-withheld") {
+      return (
+        `  - ${d.name}: matched ${d.logOnlyFamilySinceLastReview} of ` +
+        `${d.firesSinceLastReview} detection(s) in LOG-ONLY families and injected NONE — the ` +
+        `detector is running and the operator has seen nothing. Is this arm too broad? ` +
+        `Judge the matches, not a false-positive rate: there are no fires to rate.`
+      );
+    }
     const reasonLabel =
       d.reason === "past-threshold"
         ? "past review threshold (fires + diversity)"

.claude/hooks/turn-end-untaken-action-scan.ts

@@ -1124,11 +1124,45 @@ export const STRANDED_TASK_FAMILY = "stranded-task-state";
  * A family is added here by a DELIBERATE edit, so promoting an arm to injecting
  * is a one-line removal that shows up in review rather than an emergent effect.
  */
-const LOG_ONLY_FAMILIES: ReadonlySet<string> = new Set([
+export const LOG_ONLY_FAMILIES: ReadonlySet<string> = new Set([
   STRANDED_TASK_FAMILY,
   PRESENT_PROGRESSIVE_FAMILY,
 ]);
 
+/**
+ * Project matches into the calibration record, DECLARING which of them could
+ * never have injected (mt#4970).
+ *
+ * The sweep's `injectedFiresSinceLastReview` excludes what the operator never
+ * saw, and it derived that from `suppressionReasons` alone. A log-only family
+ * is the other way a fire fails to reach the operator, and it leaves no
+ * suppression reason — nothing suppressed it; it was never eligible. So the
+ * sweep counted 120 injected fires in a window where 23 reached the agent.
+ *
+ * The fact is declared HERE, by the writer, rather than inferred there. A
+ * per-detector family table in the sweep is the drift hazard mt#4465 recorded
+ * for `judgedText`: two places would have to agree about
+ * {@link LOG_ONLY_FAMILIES} forever, and only one of them is edited when an arm
+ * flips. Marking the match means promoting an arm to injecting stays the
+ * one-line removal from that set which this module already documents.
+ *
+ * `logOnly` is written ONLY when true — never `false`. Absent means "this
+ * writer does not declare the fact", which the sweep must treat as the status
+ * quo (counted as injected), exactly as `deferralOverlap`'s docblock in
+ * `calibration-sweep.ts` requires for the same reason: a projection that
+ * defaulted the field would manufacture a measurement for every record written
+ * before this change.
+ */
+function toCalibrationMatches(
+  matches: readonly { family: string; matchedPhrase: string }[]
+): Array<{ family: string; phrase: string; logOnly?: true }> {
+  return matches.map((m) => ({
+    family: m.family,
+    phrase: m.matchedPhrase,
+    ...(LOG_ONLY_FAMILIES.has(m.family) ? { logOnly: true as const } : {}),
+  }));
+}
+
 /**
  * Calls whose RESULT carries a task's current status.
  *
@@ -1511,7 +1545,7 @@ export function run(
         timestamp: new Date().toISOString(),
         session_id: input.session_id,
         stop_hook_active: input.stop_hook_active === true,
-        matches: newMatches.map((m) => ({ family: m.family, phrase: m.matchedPhrase })),
+        matches: toCalibrationMatches(newMatches),
         final_message_tail: finalMessage.slice(-TAIL_WINDOW_CHARS),
         deferralOverlap: detectDeferralPhrases(finalMessage).length > 0,
         suppressionReasons: [reason],
@@ -1644,7 +1678,7 @@ export function run(
       timestamp: new Date().toISOString(),
       session_id: input.session_id,
       stop_hook_active: input.stop_hook_active === true,
-      matches: newMatches.map((m) => ({ family: m.family, phrase: m.matchedPhrase })),
+      matches: toCalibrationMatches(newMatches),
       final_message_tail: finalMessage.slice(-TAIL_WINDOW_CHARS),
       // Retained (mt#3620) so the overlap rate stays measurable across the
       // direction change — but it no longer suppresses, so it is reported

.claude/skills/calibration-review/SKILL.md

@@ -240,11 +240,33 @@ rather than recording "cannot classify" from the empty array — the
 say `classifiable`. See §"Cannot classify" is a claim about the corpus.
 
 **An `all-suppressed` log is the exception: it DOES carry its records (mt#4049).**
-That gate is `atCountThreshold || allSuppressed`, because routing a log for
+That gate is `atCountThreshold || allWithheld`, because routing a log for
 review and then handing the reviewer an empty array would be a warning with no
 evidence attached. So read `newRecords` directly for this leg rather than
 reaching for the raw JSONL.
 
+**`allWithheld` generalizes `allSuppressed` (mt#4970), and the two are equal for
+every log without a log-only family.** It fires when the injected count is 0 and
+the volume the operator never saw — SUPPRESSED plus LOG-ONLY-family — clears the
+same bar. Both columns mean "the record matched and nobody saw it", which is what
+keeps "is this gate too broad?" answerable. `evaluatedOnlySinceLastReview` is
+deliberately outside the union: those records never matched, so there is nothing
+to classify and their absence from review is correct.
+
+**Bound the FP rate by `injectedFiresSinceLastReview`, and read
+`logOnlyFamilySinceLastReview` beside it (mt#4970).** A per-FAMILY log-only arm
+inside a LIVE detector produces records byte-identical to injecting ones — the
+gating lives in the hook's own family set, not in the record — so before mt#4970
+`untaken-action`'s 2026-09-04 window reported **120 injected where 23 reached the
+agent**, and any FP rate computed over that denominator was 5x off. The two
+counts now sit side by side: divide by the injected one, and treat the log-only
+one as what it is — the fire volume a decision to promote that arm would rest on,
+not warnings anyone received.
+
+Note this is the per-FAMILY case. The per-DETECTOR sibling — a whole detector
+quieted via `injection_enabled` — is still unsurfaced and owned by mt#4318; a
+log can be affected by one, the other, or both.
+
 ### Step 1b — Coverage-receipt check (mt#2554)
 
 Independent of the past-threshold gate above (a DEAD detector fires rarely, so it

.minsky/hooks/calibration-review-cadence-detector.test.ts

@@ -123,6 +123,17 @@ function makeResult(
       ((overrides.injectedFiresSinceLastReview ??
         merged.firesSinceLastReview - merged.suppressedSinceLastReview) === 0 &&
         merged.suppressedSinceLastReview >= FIRES_THRESHOLD),
+    // mt#4970: defaults to 0 — a fixture that names no log-only family has none.
+    logOnlyFamilySinceLastReview: overrides.logOnlyFamilySinceLastReview ?? 0,
+    // mt#4970: DERIVED, same reasoning as the three above. With the 0 default it
+    // reduces to `allSuppressed` for every existing fixture, so no prior case
+    // changes behavior.
+    allWithheld:
+      overrides.allWithheld ??
+      ((overrides.injectedFiresSinceLastReview ??
+        merged.firesSinceLastReview - merged.suppressedSinceLastReview) === 0 &&
+        merged.suppressedSinceLastReview + (overrides.logOnlyFamilySinceLastReview ?? 0) >=
+          FIRES_THRESHOLD),
   };
 }
 
@@ -217,6 +228,7 @@ describe("shouldReWarn", () => {
     firesSinceLastReview: 43,
     injectedFiresSinceLastReview: 43,
     suppressedSinceLastReview: 0,
+    logOnlyFamilySinceLastReview: 0,
     totalFires: 43,
     distinctPhrases: 31,
     reason: "past-threshold",
@@ -271,6 +283,7 @@ describe("shouldReWarn — policy-coverage kind (mt#2659)", () => {
     firesSinceLastReview: 1457,
     injectedFiresSinceLastReview: 1457,
     suppressedSinceLastReview: 0,
+    logOnlyFamilySinceLastReview: 0,
     totalFires: 1457,
     distinctPhrases: 5,
     reason: "past-threshold",
@@ -342,6 +355,7 @@ describe("suppression-aware review-due legs (mt#3197, PR #2300 R1)", () => {
       makeResult(entry, {
         firesSinceLastReview: 12,
         suppressedSinceLastReview: 11,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 40,
       }),
     ];
@@ -394,6 +408,7 @@ describe("all-suppressed review-due leg (mt#4049)", () => {
       makeResult(entry, {
         firesSinceLastReview: 12,
         suppressedSinceLastReview: 12,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 12,
       }),
     ];
@@ -415,6 +430,7 @@ describe("all-suppressed review-due leg (mt#4049)", () => {
       makeResult(entry, {
         firesSinceLastReview: 12,
         suppressedSinceLastReview: 12,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 40,
       }),
     ];
@@ -436,6 +452,7 @@ describe("all-suppressed review-due leg (mt#4049)", () => {
       makeResult(entry, {
         firesSinceLastReview: 12,
         suppressedSinceLastReview: 11,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 12,
       }),
     ];
@@ -489,6 +506,7 @@ describe("all-suppressed review-due leg (mt#4049)", () => {
       makeResult(entry, {
         firesSinceLastReview: 12,
         suppressedSinceLastReview: 12,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 12,
         distinctPhrases: 1,
       }),
@@ -503,6 +521,7 @@ describe("all-suppressed review-due leg (mt#4049)", () => {
       makeResult(entry, {
         firesSinceLastReview: 12,
         suppressedSinceLastReview: 12,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 12,
         watermarkCount: 99,
       }),
@@ -522,6 +541,7 @@ describe("formatCadenceWarning — the all-suppressed line (mt#4049)", () => {
         firesSinceLastReview: 15,
         injectedFiresSinceLastReview: 0,
         suppressedSinceLastReview: 13,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 15,
         distinctPhrases: 13,
         reason: "all-suppressed",
@@ -553,6 +573,7 @@ describe("formatCadenceWarning", () => {
         // mt#3197: no suppression outcome recorded -> every fire is injected.
         injectedFiresSinceLastReview: 43,
         suppressedSinceLastReview: 0,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 43,
         distinctPhrases: 31,
         reason: "past-threshold",
@@ -565,6 +586,7 @@ describe("formatCadenceWarning", () => {
         firesSinceLastReview: 8,
         injectedFiresSinceLastReview: 8,
         suppressedSinceLastReview: 0,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 20,
         distinctPhrases: 3,
         reason: "time-stale",
@@ -599,6 +621,7 @@ describe("formatCadenceWarning", () => {
         firesSinceLastReview: 0,
         injectedFiresSinceLastReview: 0,
         suppressedSinceLastReview: 0,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 121,
         distinctPhrases: 0,
         reason: "watermark-stranded",
@@ -628,6 +651,7 @@ describe("formatCadenceWarning", () => {
         firesSinceLastReview: 1,
         injectedFiresSinceLastReview: 1,
         suppressedSinceLastReview: 0,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 1,
         distinctPhrases: 1,
         reason: "never-reviewed",
@@ -665,6 +689,7 @@ describe("formatCadenceWarning", () => {
         firesSinceLastReview: 999,
         injectedFiresSinceLastReview: 999,
         suppressedSinceLastReview: 999,
+        logOnlyFamilySinceLastReview: 0,
         totalFires: 9999,
         distinctPhrases: 999,
         reason: "never-fired",
@@ -794,6 +819,7 @@ describe("selectPendingAskLogs", () => {
     firesSinceLastReview: 20,
     injectedFiresSinceLastReview: 20,
     suppressedSinceLastReview: 0,
+    logOnlyFamilySinceLastReview: 0,
     totalFires: 1477,
     distinctPhrases: 5,
     reason: "past-threshold",
@@ -854,6 +880,7 @@ describe("formatPendingAskLines", () => {
     firesSinceLastReview: 20,
     injectedFiresSinceLastReview: 20,
     suppressedSinceLastReview: 0,
+    logOnlyFamilySinceLastReview: 0,
     totalFires: 1477,
     distinctPhrases: 5,
     reason: "past-threshold",

.minsky/hooks/calibration-review-cadence-detector.ts

@@ -355,6 +355,19 @@ export function formatCadenceWarning(due: ReviewDueLog[]): string {
         `Judge the suppressions, not a false-positive rate: there are no fires to rate.`
       );
     }
+    // mt#4970: the same shape one column over, and it needs its own sentence for
+    // the same reason the leg above does. Saying "suppressed N" here would be
+    // false — nothing was suppressed; these matches were never eligible to
+    // inject — and the number to judge is the log-only volume, not a
+    // suppression count that is 0 on this leg by construction.
+    if (d.reason === "all-withheld") {
+      return (
+        `  - ${d.name}: matched ${d.logOnlyFamilySinceLastReview} of ` +
+        `${d.firesSinceLastReview} detection(s) in LOG-ONLY families and injected NONE — the ` +
+        `detector is running and the operator has seen nothing. Is this arm too broad? ` +
+        `Judge the matches, not a false-positive rate: there are no fires to rate.`
+      );
+    }
     const reasonLabel =
       d.reason === "past-threshold"
         ? "past review threshold (fires + diversity)"

.minsky/hooks/turn-end-untaken-action-scan.ts

@@ -1121,11 +1121,45 @@ export const STRANDED_TASK_FAMILY = "stranded-task-state";
  * A family is added here by a DELIBERATE edit, so promoting an arm to injecting
  * is a one-line removal that shows up in review rather than an emergent effect.
  */
-const LOG_ONLY_FAMILIES: ReadonlySet<string> = new Set([
+export const LOG_ONLY_FAMILIES: ReadonlySet<string> = new Set([
   STRANDED_TASK_FAMILY,
   PRESENT_PROGRESSIVE_FAMILY,
 ]);
 
+/**
+ * Project matches into the calibration record, DECLARING which of them could
+ * never have injected (mt#4970).
+ *
+ * The sweep's `injectedFiresSinceLastReview` excludes what the operator never
+ * saw, and it derived that from `suppressionReasons` alone. A log-only family
+ * is the other way a fire fails to reach the operator, and it leaves no
+ * suppression reason — nothing suppressed it; it was never eligible. So the
+ * sweep counted 120 injected fires in a window where 23 reached the agent.
+ *
+ * The fact is declared HERE, by the writer, rather than inferred there. A
+ * per-detector family table in the sweep is the drift hazard mt#4465 recorded
+ * for `judgedText`: two places would have to agree about
+ * {@link LOG_ONLY_FAMILIES} forever, and only one of them is edited when an arm
+ * flips. Marking the match means promoting an arm to injecting stays the
+ * one-line removal from that set which this module already documents.
+ *
+ * `logOnly` is written ONLY when true — never `false`. Absent means "this
+ * writer does not declare the fact", which the sweep must treat as the status
+ * quo (counted as injected), exactly as `deferralOverlap`'s docblock in
+ * `calibration-sweep.ts` requires for the same reason: a projection that
+ * defaulted the field would manufacture a measurement for every record written
+ * before this change.
+ */
+function toCalibrationMatches(
+  matches: readonly { family: string; matchedPhrase: string }[]
+): Array<{ family: string; phrase: string; logOnly?: true }> {
+  return matches.map((m) => ({
+    family: m.family,
+    phrase: m.matchedPhrase,
+    ...(LOG_ONLY_FAMILIES.has(m.family) ? { logOnly: true as const } : {}),
+  }));
+}
+
 /**
  * Calls whose RESULT carries a task's current status.
  *
@@ -1508,7 +1542,7 @@ export function run(
         timestamp: new Date().toISOString(),
         session_id: input.session_id,
         stop_hook_active: input.stop_hook_active === true,
-        matches: newMatches.map((m) => ({ family: m.family, phrase: m.matchedPhrase })),
+        matches: toCalibrationMatches(newMatches),
         final_message_tail: finalMessage.slice(-TAIL_WINDOW_CHARS),
         deferralOverlap: detectDeferralPhrases(finalMessage).length > 0,
         suppressionReasons: [reason],
@@ -1641,7 +1675,7 @@ export function run(
       timestamp: new Date().toISOString(),
       session_id: input.session_id,
       stop_hook_active: input.stop_hook_active === true,
-      matches: newMatches.map((m) => ({ family: m.family, phrase: m.matchedPhrase })),
+      matches: toCalibrationMatches(newMatches),
       final_message_tail: finalMessage.slice(-TAIL_WINDOW_CHARS),
       // Retained (mt#3620) so the overlap rate stays measurable across the
       // direction change — but it no longer suppresses, so it is reported

.minsky/skills/calibration-review/SKILL.md

@@ -238,11 +238,33 @@ rather than recording "cannot classify" from the empty array — the
 say `classifiable`. See §"Cannot classify" is a claim about the corpus.
 
 **An `all-suppressed` log is the exception: it DOES carry its records (mt#4049).**
-That gate is `atCountThreshold || allSuppressed`, because routing a log for
+That gate is `atCountThreshold || allWithheld`, because routing a log for
 review and then handing the reviewer an empty array would be a warning with no
 evidence attached. So read `newRecords` directly for this leg rather than
 reaching for the raw JSONL.
 
+**`allWithheld` generalizes `allSuppressed` (mt#4970), and the two are equal for
+every log without a log-only family.** It fires when the injected count is 0 and
+the volume the operator never saw — SUPPRESSED plus LOG-ONLY-family — clears the
+same bar. Both columns mean "the record matched and nobody saw it", which is what
+keeps "is this gate too broad?" answerable. `evaluatedOnlySinceLastReview` is
+deliberately outside the union: those records never matched, so there is nothing
+to classify and their absence from review is correct.
+
+**Bound the FP rate by `injectedFiresSinceLastReview`, and read
+`logOnlyFamilySinceLastReview` beside it (mt#4970).** A per-FAMILY log-only arm
+inside a LIVE detector produces records byte-identical to injecting ones — the
+gating lives in the hook's own family set, not in the record — so before mt#4970
+`untaken-action`'s 2026-09-04 window reported **120 injected where 23 reached the
+agent**, and any FP rate computed over that denominator was 5x off. The two
+counts now sit side by side: divide by the injected one, and treat the log-only
+one as what it is — the fire volume a decision to promote that arm would rest on,
+not warnings anyone received.
+
+Note this is the per-FAMILY case. The per-DETECTOR sibling — a whole detector
+quieted via `injection_enabled` — is still unsurfaced and owned by mt#4318; a
+log can be affected by one, the other, or both.
+
 ### Step 1b — Coverage-receipt check (mt#2554)
 
 Independent of the past-threshold gate above (a DEAD detector fires rarely, so it