@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/validation-block-guard.test.ts

@@ -80,6 +80,19 @@ test("validation block allows recovery, diagnostics, and unrelated commands", ()
     "parallel stop M007",
     "parallel pause M007",
     "parallel watch",
+    "progress",
+    "progress --forensic",
+    // code-review is allowed when not applying fixes
+    "code-review",
+    "code-review --depth deep",
+    // audit-fix is allowed in dry-run mode (read-only review, no commits)
+    "audit-fix --dry-run",
+    // docs-update is allowed in verify-only mode (read-only check, no writes)
+    "docs-update --verify-only",
+    // phase read-only subcommands are fine while validation-blocked
+    "phase",
+    "phase list",
+    "phase status",
   ];
 
   for (const command of allowed) {
@@ -95,7 +108,19 @@ test("validation block rejects workflow-start and advancing commands", () => {
     "next",
     "next M006",
     "do mark all complete",
+    "progress --next",
+    'progress --do "mark all complete"',
     "start bugfix",
+    "plan-phase",
+    "execute-phase --milestone M009",
+    "autonomous --from 1",
+    "spec-phase M009",
+    "mvp-phase --milestone M009",
+    "ui-phase M009",
+    "ai-integration-phase M009",
+    "ultraplan-phase M009",
+    "plan-review-convergence M009",
+    "resume-work",
     "workflow resume",
     "workflow run release-checklist",
     "workflow release-checklist",
@@ -107,6 +132,32 @@ test("validation block rejects workflow-start and advancing commands", () => {
     "dispatch uat",
     "complete-milestone",
     "ship",
+    // code-review --fix applies changes and should be blocked
+    "code-review --fix",
+    "code-review --depth deep --fix",
+    // audit-fix without --dry-run applies fixes and commits
+    "audit-fix",
+    "audit-fix --verbose",
+    // mutating workflow-advancing commands added in v2
+    "discuss-phase",
+    "discuss-phase M006",
+    "import",
+    "import milestones.json",
+    "ingest-docs",
+    "ingest-docs --path docs/",
+    "review-backlog",
+    "secure-phase",
+    "secure-phase --milestone M006",
+    // docs-update without --verify-only applies writes
+    "docs-update",
+    "docs-update --milestone M006",
+    // phase mutating subcommands change milestone queue state and must be blocked
+    "phase add M009",
+    "phase create M009",
+    "phase new",
+    "phase insert M009 after M008",
+    "phase remove M008",
+    "phase edit M008",
   ];
 
   for (const command of blocked) {

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/verification-verdict.test.ts

@@ -24,6 +24,8 @@ test("execute-task fails closed when no host-owned checks are discovered", () =>
   assert.equal(verdict.reason, "no-host-checks");
   assert.equal(verdict.retryable, false);
   assert.match(verdict.failureContext, /No runnable host-owned verification command/);
+  assert.match(verdict.failureContext, /\.gsd\/PREFERENCES\.md/);
+  assert.match(verdict.failureContext, /\/gsd next/);
 });
 
 test("execute-task passes when non-runnable task-plan prose is the verification source", () => {

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

@@ -202,3 +202,93 @@ 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 });
+  }
+});

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/web-app-uat.test.ts

@@ -0,0 +1,193 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  buildWebAppUatGuidanceBlock,
+  detectWebApp,
+  findPlaywrightTestScript,
+  hasPlaywrightTestDependency,
+} from "../web-app-uat.ts";
+
+function scaffoldProject(root: string, pkg: Record<string, unknown>): void {
+  writeFileSync(join(root, "package.json"), JSON.stringify(pkg, null, 2));
+}
+
+const LEGACY_ENGINE = { engine: "legacy", source: "probe", reason: "test" } as const;
+const MANAGED_ENGINE = { engine: "gsd-browser", source: "probe", reason: "test" } as const;
+const OFF_ENGINE = { engine: "off", source: "env", reason: "test" } as const;
+
+describe("web-app-uat guidance", () => {
+  test("returns null for non-web projects", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      writeFileSync(join(root, "README.md"), "# CLI tool\n");
+      assert.equal(detectWebApp(root), false);
+      assert.equal(buildWebAppUatGuidanceBlock(root), null);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("returns guidance for react/vite web apps", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0", "react-dom": "19.0.0" },
+        devDependencies: { vite: "6.0.0" },
+        scripts: { dev: "vite" },
+      });
+      assert.equal(detectWebApp(root), true);
+      const block = buildWebAppUatGuidanceBlock(root, LEGACY_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /browser-executable/);
+      assert.match(block!, /Playwright-backed `browser_\*` tools/);
+      assert.match(block!, /Playwright scaffolding/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("describes the managed gsd-browser engine when it is the resolved backing", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, MANAGED_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /managed gsd-browser engine/);
+      assert.match(block!, /browser-executable/);
+      assert.doesNotMatch(block!, /Playwright-backed/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("steers to runtime-executable UAT when browser tools are off", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        scripts: { dev: "vite" },
+      });
+      const block = buildWebAppUatGuidanceBlock(root, OFF_ENGINE);
+      assert.ok(block);
+      assert.match(block!, /browser tools are disabled/);
+      assert.doesNotMatch(block!, /- `browser-executable`/);
+      // mixed/live-runtime require browser tools per UAT_MODE_POLICIES, so the
+      // bullet must drop out too — recommending them would dead-end at dispatch.
+      assert.doesNotMatch(block!, /- `mixed`/);
+      assert.doesNotMatch(block!, /interactive `browser_\*` checks/);
+      assert.match(block!, /runtime-executable/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("detects existing Playwright and npm script", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { next: "15.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0", playwright: "1.60.0" },
+        scripts: { "test:e2e": "playwright test" },
+      });
+      assert.equal(hasPlaywrightTestDependency(root), true);
+      assert.equal(findPlaywrightTestScript(root), "npm run test:e2e");
+      const block = buildWebAppUatGuidanceBlock(root);
+      assert.ok(block);
+      assert.match(block!, /dependency detected/);
+      assert.match(block!, /npm run test:e2e/);
+      assert.doesNotMatch(block!, /Playwright scaffolding/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("does not mistake a non-playwright e2e script as playwright", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0" },
+        scripts: { e2e: "cypress run", dev: "vite" },
+      });
+      // The e2e script runs Cypress, not Playwright — must not be returned
+      assert.equal(findPlaywrightTestScript(root), null);
+      const block = buildWebAppUatGuidanceBlock(root);
+      assert.ok(block);
+      // Playwright dep is present so guidance shows "dependency detected", not "scaffolding"
+      assert.match(block!, /dependency detected/);
+      assert.doesNotMatch(block!, /Playwright scaffolding/);
+      // Falls back to generic npx command because no playwright-named script exists
+      assert.doesNotMatch(block!, /npm run e2e/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("recognises playwright via script value even without a local dependency", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { next: "15.0.0" },
+        scripts: { "test:e2e": "npx playwright test" },
+      });
+      assert.equal(hasPlaywrightTestDependency(root), false);
+      assert.equal(findPlaywrightTestScript(root), "npm run test:e2e");
+      const block = buildWebAppUatGuidanceBlock(root);
+      assert.ok(block);
+      // Script-based detection should trigger "dependency detected" path, not scaffolding
+      assert.match(block!, /dependency detected/);
+      assert.match(block!, /npm run test:e2e/);
+      assert.doesNotMatch(block!, /Playwright scaffolding/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("does not treat playwright install script as a test command", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0" },
+        // postinstall runs 'playwright install' (browser setup), not a test
+        scripts: { postinstall: "playwright install", "test:e2e": "npx playwright test" },
+      });
+      // install script must not be returned; the real test script should be
+      assert.equal(findPlaywrightTestScript(root), "npm run test:e2e");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("returns null when only an install script mentions playwright", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      scaffoldProject(root, {
+        dependencies: { react: "19.0.0" },
+        devDependencies: { "@playwright/test": "1.60.0" },
+        scripts: { postinstall: "playwright install --with-deps" },
+      });
+      assert.equal(findPlaywrightTestScript(root), null);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  test("detects static sites via index.html", () => {
+    const root = mkdtempSync(join(tmpdir(), "gsd-web-uat-"));
+    try {
+      mkdirSync(join(root, "public"), { recursive: true });
+      writeFileSync(join(root, "public", "index.html"), "<html></html>");
+      assert.equal(detectWebApp(root), true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -13,6 +13,7 @@ import {
   compactMilestoneEvents,
   type WorkflowEvent,
 } from '../workflow-events.ts';
+import { workflowEventLogPath } from '../workflow-event-ledger.ts';
 
 function tempDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-events-'));
@@ -38,6 +39,24 @@ test('workflow-events: appendEvent creates .gsd dir and event-log.jsonl', () =>
   }
 });
 
+test('workflow-events: appendEvent from canonical worktree writes project ledger', () => {
+  const base = tempDir();
+  try {
+    const worktree = path.join(base, '.gsd-worktrees', 'M001');
+    fs.mkdirSync(worktree, { recursive: true });
+
+    appendEvent(worktree, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+
+    const projectLog = path.join(base, '.gsd', 'event-log.jsonl');
+    const worktreeLog = path.join(worktree, '.gsd', 'event-log.jsonl');
+    assert.ok(fs.existsSync(projectLog), 'project event ledger should exist');
+    assert.equal(fs.existsSync(worktreeLog), false, 'worktree-local event log should not be the append target');
+    assert.equal(workflowEventLogPath(worktree), projectLog);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
 test('workflow-events: appendEvent writes valid JSON line', () => {
   const base = tempDir();
   try {

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" }),