Match forced-stop Summary text exactly, not by substring

Salvage classifiers matched free-text Summary substrings ('no
progress', 'cancelled', etc), so a SUCCESSFUL report whose Summary
happened to contain those words was recorded as a forced stop,
hard-blocking identical re-dispatch. forcedStopReport's summaries are
now a single FORCED_STOP_SUMMARIES lookup shared by both the producer
and the isXxxSubAgentReport classifiers, which compare against it with
exact equality instead of .includes.

A typed marker on the report would need a schema change (CL-6786,
human-gated, out of scope) so this tightens to exact string matching
instead.

Author: TheGreatAxios

src/subagent/brief-dispatch.ts

@@ -1,9 +1,9 @@
 /**
  * Parent-side re-dispatch caps for task briefs (CL-4343 + CL-5203).
  *
- * Leaf stops already salvage thrash / no-progress / turn-budget / etc. This
+ * Leaf stops already salvage no-progress / turn-budget / etc. This
  * module tracks how often the *parent* re-spawns the same brief so:
- * - thrash-class salvages hard-block an identical re-dispatch for the rest of
+ * - hard-block-class salvages refuse an identical re-dispatch for the rest of
  *   the parent chat session (sticky until the fingerprint changes)
  * - turn-budget salvage flips from "raise maxTurns" to "stop" after enough
  *   same-brief dispatches without a successful complete
@@ -12,9 +12,9 @@
  */
 
 import type { TaskIntent } from "./report.js";
-import { parseSubAgentReport } from "./report.js";
 import {
   isDeadlineSubAgentReport,
+  isForcedStopSubAgentReport,
   isNeverActedSubAgentReport,
   isNeverEditedSubAgentReport,
   isNoProgressSubAgentReport,
@@ -66,20 +66,17 @@ export function isHardBlockSalvage(kind: BriefSalvageKind): kind is HardBlockSal
 
 /** True when the worker returned a stall salvage report. */
 export function isStalledSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.toLowerCase().includes("long silence");
+  return isForcedStopSubAgentReport(report, "stalled");
 }
 
 /** True when the worker returned a cancel salvage report. */
 export function isCancelledSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.toLowerCase().includes("cancelled");
+  return isForcedStopSubAgentReport(report, "cancelled");
 }
 
 /** True when the worker returned an incomplete-report salvage (narration, no envelope). */
 export function isIncompleteReportSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.toLowerCase().includes("narrated instead of writing a report envelope");
+  return isForcedStopSubAgentReport(report, "incomplete-report");
 }
 
 /**

src/subagent/index.test.ts

@@ -2235,6 +2235,39 @@ describe("brief re-dispatch ledger (CL-4343 / CL-5203)", () => {
     );
   });
 
+  test("CL-6704: a successful Summary containing forced-stop phrases is not classified as a salvage", () => {
+    const noProgressPhrase = formatSubAgentReport({
+      summary: "Investigated the flaky test; root cause is a race, not no progress on our side.",
+      findings: "Fixed the race in retry logic.",
+      blockers: "None",
+      paths: "src/retry.ts",
+    });
+    expect(classifyBriefSalvage(noProgressPhrase)).toBeNull();
+
+    const cancelledPhrase = formatSubAgentReport({
+      summary: "Implemented the cancelled-order refund flow end to end.",
+      findings: "Added refund handler and tests.",
+      blockers: "None",
+      paths: "src/refunds.ts",
+    });
+    expect(classifyBriefSalvage(cancelledPhrase)).toBeNull();
+
+    const longSilencePhrase = formatSubAgentReport({
+      summary: "Reduced UI flicker with a long silence period before re-render.",
+      findings: "Debounced the re-render.",
+      blockers: "None",
+      paths: "src/ui.ts",
+    });
+    expect(classifyBriefSalvage(longSilencePhrase)).toBeNull();
+  });
+
+  test("CL-6704: true forced-stop Summary strings still classify as their salvage kind", () => {
+    expect(classifyBriefSalvage(forcedStopReport("no-progress", "x"))).toBe("no-progress");
+    expect(classifyBriefSalvage(forcedStopReport("cancelled", "x"))).toBe("cancelled");
+    expect(classifyBriefSalvage(forcedStopReport("stalled", "x"))).toBe("stalled");
+    expect(classifyBriefSalvage(forcedStopReport("deadline", "x"))).toBe("deadline");
+  });
+
   test("turn-budget parent hint flips after re-dispatch threshold", () => {
     const report = forcedStopReport("turn-budget", "partial");
     const first = appendSubAgentParentHints(report, { dispatchCount: 1 });

src/subagent/stop-policy.ts

@@ -436,6 +436,28 @@ export type ForcedStopReason =
   | "repetition"
   | "incomplete-report";
 
+// Exact Summary text for each forced-stop reason. This is the single source
+// of truth for both forcedStopReport (the producer) and the isXxxSubAgentReport
+// classifiers (the consumers) — CL-6704: classifying on a free-text substring
+// like "no progress" or "cancelled" hard-blocks a SUCCESSFUL report whose
+// Summary happens to contain that phrase. Matching the exact string a forced
+// stop actually produces closes that false-positive path without a report
+// schema change (a typed marker would need one; see CL-6786, out of scope).
+const FORCED_STOP_SUMMARIES: Record<ForcedStopReason, string> = {
+  "no-progress": "Stopped: repeated the same tool calls with no progress.",
+  "no-ship": "Stopped: implement intent searched many files without writing any.",
+  "never-acted": "Stopped: completed without using any tools.",
+  "never-edited": "Stopped: implement intent finished without writing any files.",
+  cancelled: "Stopped: cancelled by operator before finishing.",
+  deadline: "Stopped: wall-clock deadline reached before finishing.",
+  stalled:
+    "Stopped after a long silence with no tool activity. The parent can re-dispatch or check the background work directly.",
+  repetition:
+    "Stopped: degenerate repetition in streamed output (same window looping mid-turn).",
+  "incomplete-report": "Stopped: worker narrated instead of writing a report envelope.",
+  "turn-budget": "Turn budget reached before finishing.",
+};
+
 /**
  * Build the parent-facing report when a leaf is force-stopped. There is no
  * further inference, so this must already be a full envelope — not an
@@ -449,26 +471,7 @@ export function forcedStopReport(
   partialText: string,
   detail?: string,
 ): string {
-  const summary =
-    reason === "no-progress"
-      ? "Stopped: repeated the same tool calls with no progress."
-      : reason === "no-ship"
-        ? "Stopped: implement intent searched many files without writing any."
-        : reason === "never-acted"
-          ? "Stopped: completed without using any tools."
-          : reason === "never-edited"
-            ? "Stopped: implement intent finished without writing any files."
-            : reason === "cancelled"
-              ? "Stopped: cancelled by operator before finishing."
-              : reason === "deadline"
-                ? "Stopped: wall-clock deadline reached before finishing."
-                : reason === "stalled"
-                  ? "Stopped after a long silence with no tool activity. The parent can re-dispatch or check the background work directly."
-                  : reason === "repetition"
-                    ? "Stopped: degenerate repetition in streamed output (same window looping mid-turn)."
-                    : reason === "incomplete-report"
-                      ? "Stopped: worker narrated instead of writing a report envelope."
-                      : "Turn budget reached before finishing.";
+  const summary = FORCED_STOP_SUMMARIES[reason];
   const blockers =
     reason === "no-progress"
       ? "Identical tool-call fingerprint repeated consecutively; parent must not re-dispatch the identical brief (it will be refused) — tighten success_criteria/do_not or change approach."
@@ -506,34 +509,40 @@ export function forcedStopReport(
   });
 }
 
+/**
+ * True when a report's Summary is exactly the forced-stop text for `reason`
+ * (CL-6704: exact match, not a free-text substring — a successful report
+ * whose Summary happens to mention the same words must not classify as a
+ * forced stop).
+ */
+export function isForcedStopSubAgentReport(report: string, reason: ForcedStopReason): boolean {
+  const parsed = parseSubAgentReport(report);
+  return parsed.summary === FORCED_STOP_SUMMARIES[reason];
+}
+
 /** True when the worker returned a turn-budget salvage report for the parent. */
 export function isTurnBudgetSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.includes("Turn budget reached");
+  return isForcedStopSubAgentReport(report, "turn-budget");
 }
 
 /** True when the worker returned a never-acted salvage report for the parent. */
 export function isNeverActedSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.includes("without using any tools");
+  return isForcedStopSubAgentReport(report, "never-acted");
 }
 
 /** True when implement intent finished without any write/edit tools. */
 export function isNeverEditedSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.includes("without writing any files");
+  return isForcedStopSubAgentReport(report, "never-edited");
 }
 
 /** True when the worker returned a deadline salvage report for the parent. */
 export function isDeadlineSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.includes("deadline reached");
+  return isForcedStopSubAgentReport(report, "deadline");
 }
 
 /** True when the worker returned a streamed-repetition salvage report. */
 export function isRepetitionSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.includes("degenerate repetition");
+  return isForcedStopSubAgentReport(report, "repetition");
 }
 
 const TURN_BUDGET_PARENT_HINT =
@@ -604,8 +613,7 @@ export function appendDeadlineParentHint(report: string): string {
 
 /** True when the worker returned a no-ship (search-tour) salvage report. */
 export function isNoShipSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.includes("searched many files without writing");
+  return isForcedStopSubAgentReport(report, "no-ship");
 }
 
 export function appendNoShipParentHint(report: string): string {
@@ -620,8 +628,7 @@ export function appendRepetitionParentHint(report: string): string {
 
 /** True when the worker returned a no-progress salvage report. */
 export function isNoProgressSubAgentReport(report: string): boolean {
-  const parsed = parseSubAgentReport(report);
-  return parsed.summary.includes("no progress");
+  return isForcedStopSubAgentReport(report, "no-progress");
 }
 
 export function appendNoProgressParentHint(report: string): string {