@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/tests/validation-gate-patterns.test.ts

@@ -1,11 +1,11 @@
 /**
  * Unit tests for the milestone completion validation gate pattern matching.
  *
- * The gate in auto-dispatch accepts two evidence formats:
- *   1. Structured template: content contains "Operational" AND ("MET" or "N/A")
- *   2. Prose evidence: matches /[Oo]perational[\s:][^\n]*(?:pass|verified|...)/i
+ * The milestone closeout gate accepts two evidence formats:
+ *   1. Structured template: content contains "Operational" AND an accepted verdict
+ *   2. Prose evidence: matches an Operational-local accepted verdict
  *
- * These tests exercise the exact same expressions used in auto-dispatch.ts
+ * These tests exercise the exact same expressions used in milestone-closeout.ts
  * to ensure both formats are correctly recognized, and that content without
  * operational evidence is properly rejected.
  */
@@ -23,9 +23,9 @@ import assert from "node:assert/strict";
 function hasOperationalEvidence(validationContent: string): boolean {
   const structuredMatch =
     validationContent.includes("Operational") &&
-    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED"));
+    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED") || validationContent.includes("PASS") || validationContent.includes("COVERED"));
   const proseMatch =
-    /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(
+    /[Oo]perational[\s\S]{0,2000}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(
       validationContent,
     );
   return structuredMatch || proseMatch;
@@ -116,6 +116,34 @@ test("structured: Operational + DEFERRED passes", () => {
   assert.ok(hasOperationalEvidence(content));
 });
 
+test("structured: Operational + PASS passes", () => {
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Process lifecycle proof | Validation command exited cleanly. | PASS |`;
+  assert.ok(content.includes("PASS"));
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("structured: Operational + COVERED passes", () => {
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Process lifecycle proof | Validation command exited cleanly. | COVERED |`;
+  assert.ok(content.includes("COVERED"));
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("prose: evidence-rich Operational row can place verdict after 500 characters", () => {
+  const evidence = "Lifecycle evidence from restart, reconnect, supervision, cleanup, and operator notification checks. ".repeat(7);
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Headless process exits cleanly without orphaned subprocesses and preserves operator-visible state through restart. | ${evidence} | pass |`;
+  assert.ok(
+    content.toLowerCase().indexOf("pass", content.indexOf("Operational")) > content.indexOf("Operational") + 500,
+    "test fixture should place pass beyond the old 500-character window",
+  );
+  assert.ok(hasOperationalEvidence(content));
+});
+
 // ─── Issue #2862: checkmark emoji ────────────────────────────────────────────
 
 test('prose: "Operational: ✅" checkmark emoji passes (issue #2862)', () => {

package/src/resources/extensions/gsd/tests/validator-scope-parity.test.ts

@@ -23,7 +23,7 @@ import {
 
 function makeProjectDir(label = "gsd-vsp-"): string {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), label)));
-  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(dir, ".gsd", "phases", "01-m001"), { recursive: true });
   return dir;
 }
 
@@ -236,4 +236,56 @@ describe("validator-scope-parity: scope uses canonical projectRoot not worktree
       "verifyExpectedArtifactForScope should return false when artifact is absent",
     );
   });
+
+  test("verifyExpectedArtifactForScope rejects zero-slice scoped plan-milestone roadmaps", () => {
+    const ws = createWorkspace(base);
+    const scope = scopeMilestone(ws, "M001");
+
+    writeFileSync(scope.roadmapFile(), [
+      "# M001: Placeholder",
+      "",
+      "## Slices",
+      "",
+      "_TBD_",
+      "",
+    ].join("\n"));
+
+    const ready = verifyExpectedArtifactForScope(scope, "plan-milestone", "M001");
+    assert.equal(
+      ready,
+      false,
+      "scoped plan-milestone verification must parse roadmap content, not only check existence",
+    );
+  });
+
+  test("verifyExpectedArtifactForScope verifies the scoped plan-milestone roadmap path", () => {
+    const ws = createWorkspace(base);
+    const realScope = scopeMilestone(ws, "M001");
+    const scopedRoadmap = join(base, "scoped-M001-ROADMAP.md");
+    const scope = {
+      ...realScope,
+      roadmapFile: () => scopedRoadmap,
+    };
+
+    writeFileSync(scopedRoadmap, [
+      "# M001: Scoped roadmap",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+      "  > After this: a real slice exists.",
+      "",
+    ].join("\n"));
+
+    assert.equal(
+      resolveExpectedArtifactPathForScope(scope, "plan-milestone", "M001"),
+      scopedRoadmap,
+      "scoped plan-milestone artifact path must come from scope.roadmapFile()",
+    );
+    assert.equal(
+      verifyExpectedArtifactForScope(scope, "plan-milestone", "M001"),
+      true,
+      "scoped plan-milestone verification must read the roadmap from scope.roadmapFile()",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/verification-retry-policy.test.ts

@@ -11,6 +11,8 @@ import {
   verificationRetryKey,
   VERIFICATION_RETRY_MAX_DELAY_MS,
 } from "../auto/verification-retry-policy.ts";
+import { formatFailureContext, formatFailureSignature } from "../verification-gate.ts";
+import type { VerificationResult } from "../types.ts";
 
 test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   assert.deepEqual(verificationRetryDelayMs(1, () => 0.5), {
@@ -31,9 +33,22 @@ test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   });
 });
 
-test("decideVerificationRetry pauses on duplicate failure context", () => {
+test("decideVerificationRetry pauses on repeated failure context across attempts", () => {
   const failureContext = "lint failed\n";
-  const failureHash = hashVerificationFailureContext(failureContext);
+  const firstDecision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext,
+      attempt: 1,
+    },
+    previousFailureHash: undefined,
+    random: () => 0.5,
+  });
+
+  assert.equal(firstDecision.action, "delay");
+  assert.equal(firstDecision.failureHash, hashVerificationFailureContext(failureContext));
+
   const decision = decideVerificationRetry({
     unitType: "execute-task",
     retryInfo: {
@@ -41,7 +56,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
       failureContext,
       attempt: 2,
     },
-    previousFailureHash: failureHash,
+    previousFailureHash: firstDecision.failureHash,
     random: () => 0.5,
   });
 
@@ -49,7 +64,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
     action: "pause",
     reason: "duplicate-failure-context",
     key: verificationRetryKey("execute-task", "M001/S01/T01"),
-    failureHash,
+    failureHash: firstDecision.failureHash,
   });
 });
 
@@ -71,6 +86,56 @@ test("decideVerificationRetry delays changed failure context", () => {
   assert.equal(decision.baseDelayMs, 4_000);
 });
 
+test("decideVerificationRetry pauses duplicate host-check failures with volatile stderr", () => {
+  const makeResult = (stderr: string): VerificationResult => ({
+    passed: false,
+    discoverySource: "package-json",
+    timestamp: Date.now(),
+    checks: [
+      {
+        command: "npm test",
+        exitCode: 1,
+        stdout: "",
+        stderr,
+        durationMs: 100,
+      },
+    ],
+  });
+  const first = makeResult("failed after 120ms in /tmp/gsd-a worker pid 101");
+  const second = makeResult("failed after 133ms in /tmp/gsd-b worker pid 202");
+  const firstContext = formatFailureContext(first);
+  const secondContext = formatFailureContext(second);
+
+  assert.notEqual(
+    hashVerificationFailureContext(firstContext),
+    hashVerificationFailureContext(secondContext),
+  );
+
+  const signature = formatFailureSignature(first);
+  assert.equal(signature, "npm test#1");
+  assert.equal(formatFailureSignature(second), signature);
+
+  const failureHash = hashVerificationFailureContext(signature);
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext: secondContext,
+      signature: formatFailureSignature(second),
+      attempt: 2,
+    },
+    previousFailureHash: failureHash,
+    random: () => 0.5,
+  });
+
+  assert.deepEqual(decision, {
+    action: "pause",
+    reason: "duplicate-failure-context",
+    key: verificationRetryKey("execute-task", "M001/S01/T01"),
+    failureHash,
+  });
+});
+
 test("decideVerificationRetry pauses when retry context is missing", () => {
   assert.deepEqual(
     decideVerificationRetry({

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -202,3 +202,159 @@ test("execute-task DB lag branch — summary without checked plan still fails",
     "pending DB status plus summary is insufficient without a checked task checkbox",
   );
 });
+
+// ── #852 follow-up: worktree→project-root artifact fallback ──────────────────
+//
+// A milestone running in a worktree may not have its CONTEXT projected into the
+// worktree (the worktree only has the META dir until planning writes its
+// projections). When verifyExpectedArtifact can't find the artifact at the
+// worktree base, it must fall back to the project root — where the artifact
+// genuinely lives. Without this, discuss-milestone verification returned false
+// ("resolveExpectedArtifactPath returned null") and trapped the unit in a
+// finalize-retry loop.
+
+test("#852: discuss-milestone falls back to project root when CONTEXT not in worktree", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-fallback-proj-"));
+  try {
+    // Flat-phase CONTEXT lives at the project root.
+    const phaseDir = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "15-CONTEXT.md"), "# M015 context\n");
+
+    // Simulate the worktree: exists, registered with git (.git file), but has
+    // NO phases/ dir and no real CONTEXT — only the META dir git-service.ts
+    // created. resolveCanonicalMilestoneRoot redirects here.
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    const wtGsd = join(wtRoot, ".gsd");
+    mkdirSync(join(wtGsd, "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtGsd, "milestones", "M015", "M015-META.json"), '{"branch":"milestone/M015"}');
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    // Verification with the worktree as base must fall back to the project root
+    // and find 15-CONTEXT.md there.
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      true,
+      "must fall back to project root when CONTEXT is not in the worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#852: discuss-milestone passes when CONTEXT is in the worktree (no fallback needed)", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-present-"));
+  try {
+    // CONTEXT lives in BOTH the project root AND the worktree.
+    const projPhase = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(projPhase, { recursive: true });
+    writeFileSync(join(projPhase, "15-CONTEXT.md"), "# project context\n");
+
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    const wtGsd = join(wtRoot, ".gsd");
+    const wtPhase = join(wtGsd, "phases", "15-m015");
+    mkdirSync(wtPhase, { recursive: true });
+    writeFileSync(join(wtPhase, "15-CONTEXT.md"), "# worktree context\n");
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      true,
+      "must pass when CONTEXT is in the worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#852: discuss-milestone fails when CONTEXT is in neither worktree nor project root", () => {
+  // If the artifact genuinely doesn't exist anywhere, verification must still
+  // fail (fail-closed) — the fallback must not mask a real absence.
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-absent-"));
+  try {
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    mkdirSync(join(wtRoot, ".gsd", "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+    // No phases/ anywhere, no CONTEXT anywhere.
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      false,
+      "must fail when CONTEXT exists in neither root",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// #870: discuss-milestone verify-fail when the unit runs IN the worktree.
+//
+// The #852 tests above all pass `projectRoot` as the base. But the real call
+// site (auto-post-unit.ts:1726) passes `s.currentUnit.workspaceRoot ?? s.basePath`
+// — i.e. the WORKTREE path when the unit executed in a worktree. In the
+// canonical layout (`<root>/.gsd-worktrees/<MID>/`) resolveCanonicalMilestoneRoot
+// round-trips the worktree path back to itself, so `artifactBase === base` and
+// the worktree→project-root fallback (guarded by `artifactBase !== base`) is
+// skipped. CONTEXT is written to the project root, not projected into the
+// worktree, so verification finds nothing → "existsSync false" → re-dispatch
+// 3× → stuck-loop stop. These tests pin the real call site.
+// ---------------------------------------------------------------------------
+
+test("#870: discuss-milestone falls back to project root when base IS the canonical-layout worktree", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-canonical-wt-"));
+  try {
+    // CONTEXT lives ONLY at the project root (flat-phase layout).
+    const phaseDir = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "15-CONTEXT.md"), "# M015 context\n");
+
+    // Canonical-layout worktree: <root>/.gsd-worktrees/<MID>/. Registered
+    // with git (.git file) so resolveCanonicalMilestoneRoot treats it as the
+    // canonical milestone root — but it has NO phases/ projection.
+    const wtRoot = join(projectRoot, ".gsd-worktrees", "M015");
+    mkdirSync(join(wtRoot, ".gsd", "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtRoot, ".gsd", "milestones", "M015", "M015-META.json"), '{"branch":"milestone/M015"}');
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    // Real call site: base = worktree path (workspaceRoot).
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", wtRoot),
+      true,
+      "must fall back to project root when base is the canonical-layout worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#870: discuss-milestone also falls back when base is the legacy-layout worktree", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-legacy-wt-"));
+  try {
+    const phaseDir = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "15-CONTEXT.md"), "# M015 context\n");
+
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    mkdirSync(join(wtRoot, ".gsd", "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", wtRoot),
+      true,
+      "must fall back to project root when base is the legacy-layout worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/visualizer-data.test.ts

@@ -11,6 +11,8 @@ import {
   loadVisualizerData,
   type VisualizerMilestone,
 } from "../visualizer-data.ts";
+import { _getAdapter, closeDatabase, openDatabase } from "../gsd-db.ts";
+import { createMemory } from "../memory-store.ts";
 
 test("computeCriticalPath follows milestone dependencies", () => {
   const milestones: VisualizerMilestone[] = [
@@ -82,3 +84,88 @@ test("loadVisualizerData hydrates milestones, captures, stats, and health fields
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("loadVisualizerData includes active memory-store entries", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memories-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(":memory:");
+
+    createMemory({
+      category: "gotcha",
+      content: "Visualizer memory rows must come from the memory store",
+      confidence: 0.92,
+      scope: "M001/S01",
+      tags: ["visualizer", "memory"],
+    });
+    createMemory({
+      category: "pattern",
+      content: "Superseded rows should stay out of the visualizer",
+      confidence: 0.2,
+    });
+
+    const adapter = _getAdapter();
+    adapter?.prepare("UPDATE memories SET superseded_by = 'MEM999' WHERE id = 'MEM002'").run();
+
+    const data = await loadVisualizerData(base);
+
+    assert.equal(data.memories.totalCount, 1);
+    assert.equal(data.memories.entries[0]?.id, "MEM001");
+    assert.equal(data.memories.entries[0]?.category, "gotcha");
+    assert.equal(data.memories.entries[0]?.content, "Visualizer memory rows must come from the memory store");
+    assert.equal(data.memories.entries[0]?.scope, "M001/S01");
+    assert.deepEqual(data.memories.entries[0]?.tags, ["visualizer", "memory"]);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("loadVisualizerData opens the project DB for memory entries when none is open", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memories-db-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    createMemory({
+      category: "gotcha",
+      content: "Browser visualizer child processes must open the project DB",
+      confidence: 0.88,
+      tags: ["browser", "visualizer"],
+    });
+    closeDatabase();
+
+    const data = await loadVisualizerData(base);
+
+    assert.equal(data.memories.totalCount, 1);
+    assert.equal(data.memories.entries[0]?.id, "MEM001");
+    assert.equal(data.memories.entries[0]?.content, "Browser visualizer child processes must open the project DB");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("loadVisualizerData caps memory content for visualizer payloads", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memory-cap-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(":memory:");
+    const largeContent = "A".repeat(2500);
+    createMemory({
+      category: "gotcha",
+      content: largeContent,
+      confidence: 0.9,
+    });
+
+    const data = await loadVisualizerData(base);
+
+    const content = data.memories.entries[0]?.content ?? "";
+    assert.equal(data.memories.totalCount, 1);
+    assert.ok(content.length < largeContent.length);
+    assert.ok(content.length <= 2003);
+    assert.ok(content.endsWith("..."));
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -49,6 +49,7 @@ function makeVisualizerData(overrides: Partial<VisualizerData> = {}): Visualizer
     changelog: { entries: [] },
     sliceVerifications: [],
     knowledge: { rules: [], patterns: [], lessons: [], exists: false },
+    memories: { entries: [], totalCount: 0 },
     captures: { entries: [], pendingCount: 0, totalCount: 0 },
     health: {
       budgetCeiling: undefined,
@@ -617,6 +618,32 @@ console.log("\n=== renderKnowledgeView ===");
   assert.ok(lines.some(l => l.includes("No KNOWLEDGE.md found")), "shows no-knowledge message");
 }
 
+{
+  const data = makeVisualizerData({
+    memories: {
+      totalCount: 1,
+      entries: [
+        {
+          id: "MEM001",
+          category: "gotcha",
+          content: "Use memory store rows for durable project facts",
+          confidence: 0.91,
+          hitCount: 3,
+          scope: "M001/S01",
+          tags: ["visualizer"],
+          updatedAt: "2026-06-21T12:00:00.000Z",
+        },
+      ],
+    },
+  });
+  const lines = renderKnowledgeView(data, mockTheme, 100);
+  assert.ok(lines.some(l => l.includes("Memories")), "shows memories section");
+  assert.ok(lines.some(l => l.includes("MEM001")), "shows memory ID");
+  assert.ok(lines.some(l => l.includes("(gotcha")), "shows memory category");
+  assert.ok(lines.some(l => l.includes("Use memory store rows")), "shows memory content");
+  assert.ok(lines.some(l => l.includes("M001/S01")), "shows memory scope");
+}
+
 // ─── renderCapturesView ─────────────────────────────────────────────────────
 
 console.log("\n=== renderCapturesView ===");

package/src/resources/extensions/gsd/tests/workflow-kernel.test.ts

@@ -203,6 +203,57 @@ test("decideFinalizeResult maps continue and next results", () => {
   assert.deepEqual(decideFinalizeResult({ action: "next" }), { action: "complete" });
 });
 
+// ── #852 follow-up: carry the specific verification failure into the ledger ──
+//
+// A bare "finalize-retry" ledger summary makes the stuck-loop kill message
+// ("Same error repeated: finalize-retry") opaque — it took a full forensics
+// dive to learn the real reason was "roadmap has zero slices". The retry
+// decision now appends the failureDetail so the summary is actionable while
+// preserving the stable "finalize-retry" prefix for legacy filters.
+
+test("decideFinalizeResult appends failureDetail to the retry ledger summary (#852)", () => {
+  assert.deepEqual(
+    decideFinalizeResult({ action: "continue", failureDetail: "roadmap has zero slices" }),
+    { action: "retry", ledgerErrorSummary: "finalize-retry: roadmap has zero slices" },
+  );
+  // The prefix is preserved so dashboards/filters matching "finalize-retry" still hit.
+  // Narrow to the retry arm before accessing ledgerErrorSummary (FinalizeDecision is a union).
+  const suffixed = decideFinalizeResult({ action: "continue", failureDetail: "15-SUMMARY.md was not found on disk" });
+  assert.strictEqual(suffixed.action, "retry");
+  assert.match(
+    (suffixed as { action: "retry"; ledgerErrorSummary: string }).ledgerErrorSummary,
+    /^finalize-retry:/,
+  );
+});
+
+test("decideFinalizeResult collapses whitespace-only / empty failureDetail to the bare token (#852)", () => {
+  assert.deepEqual(
+    decideFinalizeResult({ action: "continue", failureDetail: "   " }),
+    { action: "retry", ledgerErrorSummary: "finalize-retry" },
+  );
+  assert.deepEqual(
+    decideFinalizeResult({ action: "continue", failureDetail: "" }),
+    { action: "retry", ledgerErrorSummary: "finalize-retry" },
+  );
+});
+
+test("decideFinalizeResult strips per-attempt suffixes for stable repeat-error detection (#852)", () => {
+  const base = "Artifact verification failed: roadmap has zero slices";
+  const attempt1 = decideFinalizeResult({
+    action: "continue",
+    failureDetail: `${base} (attempt 1/3).`,
+  });
+  const attempt2 = decideFinalizeResult({
+    action: "continue",
+    failureDetail: `${base} (attempt 2/3).`,
+  });
+  assert.deepEqual(attempt1, attempt2);
+  assert.deepEqual(attempt1, {
+    action: "retry",
+    ledgerErrorSummary: `finalize-retry: ${base}`,
+  });
+});
+
 test("decideEngineReconcile maps terminal outcomes", () => {
   assert.deepEqual(
     decideEngineReconcile({ outcome: "milestone-complete" }),