@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.72e3af2a

package/src/resources/extensions/gsd/tests/commands-verdict.test.ts

@@ -10,7 +10,7 @@
  */
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -363,7 +363,7 @@ test("handleVerdict pass override works when validation only exists in DB", asyn
     const { ctx, calls } = makeMockCtx();
     await handleVerdict('pass --milestone M001 --rationale "reviewed and accepted"', ctx, base);
 
-    const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    const validationPath = join(base, ".gsd", "phases", "01-m001", "01-VALIDATION.md");
     const rewritten = readFileSync(validationPath, "utf-8");
     assert.match(rewritten, /^verdict: pass$/m, "DB-backed validation should be rewritten as pass");
     assert.match(rewritten, /reviewed and accepted/, "explicit rationale should be persisted");
@@ -472,17 +472,55 @@ test("auto-dispatch needs-attention pause message references /gsd verdict", asyn
   }
 });
 
-test("state.ts needs-remediation blocker messages reference /gsd verdict", async () => {
+test("guidance.ts needs-remediation blocker messages reference /gsd verdict", async () => {
   // We don't need to invoke deriveState — just assert the substring is in the
-  // source. The blocker strings are constructed inline and shipped to the user
-  // verbatim, so a static check is sufficient and avoids fragile DB setup.
-  const stateSource = readFileSync(
-    new URL("../state.ts", import.meta.url).pathname,
+  // source. The blocker strings are constructed in the guidance catalog and
+  // shipped to the user verbatim, so a static check is sufficient and avoids
+  // fragile DB setup.
+  const guidanceSource = readFileSync(
+    new URL("../guidance.ts", import.meta.url).pathname,
     "utf-8",
   );
-  const occurrences = stateSource.match(/`\/gsd verdict /g) ?? [];
+  const occurrences = guidanceSource.match(/`\/gsd verdict /g) ?? [];
   assert.ok(
     occurrences.length >= 2,
-    `expected at least 2 references to /gsd verdict in state.ts blockers, found ${occurrences.length}`,
+    `expected at least 2 references to /gsd verdict in guidance.ts blockers, found ${occurrences.length}`,
   );
 });
+
+// ─── WAL checkpoint regression (#563) ───────────────────────────────────
+
+test("handleVerdict pass checkpoints WAL so subsequent processes see the updated verdict (#563)", async () => {
+  // Regression: before the fix, executeValidateMilestone wrote the assessment
+  // only into the WAL file.  The next /gsd auto invocation (a new process)
+  // opened gsd.db directly and saw stale pre-verdict data because the WAL
+  // had not been flushed.  The fix adds checkpointDatabase() after a
+  // successful verdict so the WAL is truncated and gsd.db is self-contained.
+  const base = makeBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Checkpoint Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    writeValidation(base, "M001", "needs-attention");
+
+    const { ctx } = makeMockCtx();
+    await handleVerdict("pass --milestone M001", ctx, base);
+
+    // After handleVerdict succeeds, PRAGMA wal_checkpoint(TRUNCATE) must have
+    // run.  The WAL file is truncated to zero bytes — a new process reading
+    // gsd.db directly sees the updated verdict without needing the WAL.
+    const walPath = join(base, ".gsd", "gsd.db-wal");
+    if (existsSync(walPath)) {
+      const { size } = statSync(walPath);
+      assert.equal(
+        size,
+        0,
+        "WAL must be zero bytes after handleVerdict pass — checkpointDatabase() was not called (#563)",
+      );
+    }
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-worktree-clean.test.ts

@@ -1,10 +1,22 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   formatCleanKeepReason,
+  handleWorktree,
   type WorktreeStatus,
 } from "../commands-worktree.ts";
+import { withCommandCwd } from "../commands/context.ts";
+import { createWorktree } from "../worktree-manager.ts";
+import {
+  disableDebug,
+  enableDebug,
+  getDebugCounters,
+} from "../debug-logger.ts";
 
 function mkStatus(over: Partial<WorktreeStatus>): WorktreeStatus {
   const name = over.name ?? "feat-x";
@@ -22,6 +34,45 @@ function mkStatus(over: Partial<WorktreeStatus>): WorktreeStatus {
   };
 }
 
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-worktree-command-"));
+  git(base, ["init", "-b", "main"]);
+  git(base, ["config", "user.name", "Test User"]);
+  git(base, ["config", "user.email", "test@example.com"]);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
+  git(base, ["add", "."]);
+  git(base, ["commit", "-m", "chore: init"]);
+  return base;
+}
+
+function createCommittedWorktree(base: string, name: string): void {
+  const wt = createWorktree(base, name);
+  writeFileSync(join(wt.path, `${name}.txt`), `${name}\n`, "utf-8");
+  git(wt.path, ["add", "."]);
+  git(wt.path, ["commit", "-m", `feat: ${name}`]);
+}
+
+function createMockCtx() {
+  const notifications: { message: string; level: string }[] = [];
+  return {
+    notifications,
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+    },
+  };
+}
+
 test("clean keep reason shows uncommitted-only worktrees clearly", () => {
   const reason = formatCleanKeepReason(mkStatus({ uncommitted: true }));
   assert.equal(reason, "uncommitted changes");
@@ -46,3 +97,32 @@ test("clean keep reason uses singular form for a single changed file", () => {
   const reason = formatCleanKeepReason(mkStatus({ filesChanged: 1, uncommitted: false }));
   assert.equal(reason, "1 changed file");
 });
+
+test("worktree list detects main branch once for the command", async (t) => {
+  if (process.env.GSD_ENABLE_NATIVE_GSD_GIT === "1") {
+    t.skip("git invocation regression is specific to the CLI fallback path");
+    return;
+  }
+
+  const base = makeRepo();
+  try {
+    createCommittedWorktree(base, "feature-a");
+    createCommittedWorktree(base, "feature-b");
+
+    const ctx = createMockCtx();
+    enableDebug(base);
+    try {
+      await withCommandCwd(base, async () => {
+        await handleWorktree("list", ctx as any);
+      });
+
+      assert.equal(ctx.notifications.length, 1);
+      assert.match(ctx.notifications[0].message, /Worktrees — 2/);
+      assert.equal(getDebugCounters().gitInvocations, 12);
+    } finally {
+      disableDebug();
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/compat-health-line.test.ts

@@ -0,0 +1,102 @@
+// Project/App: gsd-pi
+// File Purpose: Unit tests for formatCompatHealthLine (doctor compat output).
+// Covers the per-section "no baseline" signal introduced to fix COMMENT:3449128458.
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { formatCompatHealthLine } from "../commands-handlers.ts";
+import { writeCompatMarker } from "../compat/compat-marker.ts";
+
+const tmpDirs: string[] = [];
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-chl-${randomUUID()}`));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  tmpDirs.push(base);
+  return base;
+}
+afterEach(() => {
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+test("returns unified no-baseline when projections empty and planning inactive", async () => {
+  const base = makeTmpBase();
+  // No marker written → EMPTY_MARKER → projections={}, planning.active=false
+  const line = await formatCompatHealthLine(base);
+  assert.ok(line.includes("no baseline"), `expected no-baseline, got: ${line}`);
+  // Should be the unified single line, not separate .gsd/.planning sections.
+  assert.ok(!line.includes("(.gsd)"), `expected unified line, got: ${line}`);
+});
+
+test("returns per-section no-baseline for .gsd when planning active but gsd projections empty", async () => {
+  // Regression: COMMENT:3449128458 — after auto-activation, marker has
+  // planning.active=true but marker.projections={} (no .gsd/ baseline yet).
+  // Old code reported ".gsd: OK" (misleading). New code: per-section no-baseline.
+  const base = makeTmpBase();
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "",
+    projections: {},
+    planning: { active: true, layout: "flat-phases", projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  });
+
+  const line = await formatCompatHealthLine(base);
+  // Both sections should show no-baseline.
+  const gsdLine = line.split("\n").find((l) => l.includes("(.gsd)"));
+  const planningLine = line.split("\n").find((l) => l.includes("(.planning)"));
+  assert.ok(gsdLine, "expected a (.gsd) line");
+  assert.ok(planningLine, "expected a (.planning) line");
+  assert.ok(gsdLine!.includes("no baseline"), `(.gsd) should say no baseline, got: ${gsdLine}`);
+  assert.ok(planningLine!.includes("no baseline"), `(.planning) should say no baseline, got: ${planningLine}`);
+});
+
+test("returns no-baseline for .planning section when active but planning projections empty", async () => {
+  // Mixed: .gsd/ has a baseline but .planning/ has been auto-activated with
+  // empty projections (sync ran for .gsd but not yet for .planning/).
+  const base = makeTmpBase();
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: {
+      "milestones/M001/M001-ROADMAP.md": { sha: "abc123", entities: ["M001"] },
+    },
+    planning: { active: true, layout: "flat-phases", projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  });
+
+  const line = await formatCompatHealthLine(base);
+  const gsdLine = line.split("\n").find((l) => l.includes("(.gsd)"));
+  const planningLine = line.split("\n").find((l) => l.includes("(.planning)"));
+  assert.ok(gsdLine, "expected a (.gsd) line");
+  assert.ok(planningLine, "expected a (.planning) line");
+  // .gsd/ has a baseline (1 entry), file is absent → 0 drift → OK
+  assert.ok(gsdLine!.includes("OK"), `(.gsd) should say OK, got: ${gsdLine}`);
+  // .planning/ has no SHAs at all → no baseline
+  assert.ok(planningLine!.includes("no baseline"), `(.planning) should say no baseline, got: ${planningLine}`);
+});
+
+test("reports not-active for .planning when planning is inactive", async () => {
+  const base = makeTmpBase();
+  writeCompatMarker(base, {
+    schema: 2,
+    lastWriter: "gsd-pi",
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: {
+      "milestones/M001/M001-ROADMAP.md": { sha: "abc123", entities: ["M001"] },
+    },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  });
+
+  const line = await formatCompatHealthLine(base);
+  const planningLine = line.split("\n").find((l) => l.includes("(.planning)"));
+  assert.ok(planningLine, "expected a (.planning) line");
+  assert.ok(planningLine!.includes("not active"), `(.planning) should say not active, got: ${planningLine}`);
+});

package/src/resources/extensions/gsd/tests/compat-marker-invalidation.test.ts

@@ -0,0 +1,51 @@
+// Project/App: gsd-pi
+// File Purpose: Verifies that projection writes update .gsd/.compat.json.
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { renderRoadmapFromDb } from "../markdown-renderer.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
+import { readCompatMarker } from "../compat/compat-marker.ts";
+
+const tmpDirs: string[] = [];
+function makeTmp(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-inv-${randomUUID()}`));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  insertSlice({ milestoneId: "M001", id: "S01", title: "T", status: "pending", risk: "low", depends: [] });
+  tmpDirs.push(base);
+  return base;
+}
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+test("renderRoadmapFromDb writes a compat marker entry for the roadmap file", async () => {
+  const base = makeTmp();
+  await renderRoadmapFromDb(base, "M001");
+  const marker = readCompatMarker(base);
+  const rels = Object.keys(marker.projections);
+  assert.ok(
+    rels.some((r) => r.includes("M001") && r.endsWith("ROADMAP.md")),
+    `expected roadmap entry, got ${JSON.stringify(rels)}`,
+  );
+  // Marker should record gsd-pi as last writer and a non-empty timestamp.
+  assert.equal(marker.lastWriter, "gsd-pi");
+  assert.ok(marker.lastProjectedAt.length > 0, "expected non-empty lastProjectedAt");
+});
+
+test("re-rendering the same file updates the marker entry (not duplicates)", async () => {
+  const base = makeTmp();
+  await renderRoadmapFromDb(base, "M001");
+  await renderRoadmapFromDb(base, "M001");
+  const marker = readCompatMarker(base);
+  const roadmapEntries = Object.keys(marker.projections).filter((r) => r.endsWith("ROADMAP.md"));
+  assert.equal(roadmapEntries.length, 1, "expected exactly one roadmap entry after re-render");
+});

package/src/resources/extensions/gsd/tests/compat-marker.test.ts

@@ -0,0 +1,105 @@
+// Project/App: gsd-pi
+// File Purpose: Unit tests for the gsd-core compat marker (`.gsd/.compat.json`).
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  readCompatMarker,
+  writeCompatMarker,
+  normalizeForHash,
+  computeProjectionSha,
+  EMPTY_MARKER,
+  compatMarkerPath,
+} from "../compat/compat-marker.ts";
+
+const tmpDirs: string[] = [];
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-compat-${randomUUID()}`));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  tmpDirs.push(base);
+  return base;
+}
+
+afterEach(() => {
+  for (const dir of tmpDirs) {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+  }
+  tmpDirs.length = 0;
+});
+
+test("readCompatMarker returns EMPTY_MARKER when file is missing", () => {
+  const base = makeTmpBase();
+  const marker = readCompatMarker(base);
+  assert.deepEqual(marker, EMPTY_MARKER);
+});
+
+test("writeCompatMarker then readCompatMarker round-trips", () => {
+  const base = makeTmpBase();
+  const marker = {
+    schema: 2,
+    lastWriter: "gsd-pi" as const,
+    lastProjectedAt: "2026-06-21T00:00:00.000Z",
+    projections: {
+      "roadmap.md": { sha: "abc123", entities: ["m1"] },
+    },
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: "1.4.0",
+  };
+  writeCompatMarker(base, marker);
+  const read = readCompatMarker(base);
+  assert.deepEqual(read, marker);
+});
+
+test("readCompatMarker quarantines malformed JSON and returns EMPTY_MARKER", () => {
+  const base = makeTmpBase();
+  writeFileSync(compatMarkerPath(base), "{ not valid json", "utf-8");
+  const marker = readCompatMarker(base);
+  assert.deepEqual(marker, EMPTY_MARKER);
+  const files = readdirSync(join(base, ".gsd"));
+  // Quarantine backup should exist.
+  const quarantined = files.some((f: string) => f.startsWith(".compat.json.bad-"));
+  assert.ok(quarantined, "expected a quarantined .compat.json.bad-* file");
+  // Original should be gone — the quarantine fix removes it so repeated reads
+  // don't accumulate unbounded .bad-* files.
+  assert.ok(!files.includes(".compat.json"), "corrupt original should be deleted after quarantine");
+});
+
+test("quarantine does not grow unbounded .bad-* files on repeated reads", () => {
+  const base = makeTmpBase();
+  writeFileSync(compatMarkerPath(base), "not valid json at all", "utf-8");
+
+  // First read quarantines and removes the original.
+  readCompatMarker(base);
+  const filesAfterFirst = readdirSync(join(base, ".gsd"));
+  const badCountAfterFirst = filesAfterFirst.filter((f: string) => f.startsWith(".compat.json.bad-")).length;
+  assert.equal(badCountAfterFirst, 1, "expected exactly one .bad-* file after first read");
+  assert.ok(!filesAfterFirst.includes(".compat.json"), "corrupt original should be gone after first read");
+
+  // Second read sees no file → EMPTY_MARKER fast path, no new .bad-* created.
+  readCompatMarker(base);
+  const filesAfterSecond = readdirSync(join(base, ".gsd"));
+  const badCountAfterSecond = filesAfterSecond.filter((f: string) => f.startsWith(".compat.json.bad-")).length;
+  assert.equal(badCountAfterSecond, 1, "second read must not create an additional .bad-* file");
+});
+
+test("normalizeForHash trims trailing whitespace and converts CRLF to LF", () => {
+  const input = "line one  \r\nline two\r\n";
+  const out = normalizeForHash(input);
+  assert.equal(out, "line one\nline two\n");
+});
+
+test("computeProjectionSha is stable for cosmetically different but equivalent content", () => {
+  const a = computeProjectionSha("hello\r\nworld  \n");
+  const b = computeProjectionSha("hello\nworld\n");
+  assert.equal(a, b);
+});
+
+test("compatMarkerPath resolves under .gsd", () => {
+  const base = makeTmpBase();
+  assert.equal(compatMarkerPath(base), join(base, ".gsd", ".compat.json"));
+});

package/src/resources/extensions/gsd/tests/complete-milestone-prompt-rendering.test.ts

@@ -42,7 +42,11 @@ test("complete milestone prompt renders compact verification and completion guid
   assert.match(prompt, /Decision Re-evaluation/);
   assert.match(prompt, /self-diff/i);
   assert.match(prompt, /GSD-(?:Task|Unit)/);
-  assert.match(prompt, /Milestone M001 complete/);
-  assert.match(prompt, /Do not add a second final-status block/);
+  assert.match(prompt, /Closeout messaging \(auto-mode\)/);
+  assert.match(prompt, /Never say "Milestone M001 is complete"/);
+  assert.match(prompt, /Milestone M001 closeout submitted/);
+  assert.match(prompt, /Do not say the milestone is complete/);
+  assert.match(prompt, /VERIFICATION FAILED/);
+  assert.doesNotMatch(prompt, /emit only one closeout line: "Milestone M001 complete\."/);
   assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
 });

package/src/resources/extensions/gsd/tests/complete-slice-reopen-handoff.test.ts

@@ -67,6 +67,46 @@ test("complete-slice with gsd_task_reopen handoff continues instead of artifact-
   }
 });
 
+test("complete-slice text mentioning gsd_task_reopen does not count as a handoff", async () => {
+  const base = makeTempRepo("gsd-complete-slice-reopen-text-");
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "complete-slice", id: "M001/S01", startedAt: Date.now() };
+
+    const notifications: string[] = [];
+    const result = await postUnitPreVerification(
+      makePostUnitContext(base, s, notifications),
+      {
+        skipSettleDelay: true,
+        skipWorktreeSync: true,
+        agentEndMessages: [
+          {
+            role: "assistant",
+            content: "I should call gsd_task_reopen for T01, then stop.",
+          },
+        ],
+      },
+    );
+
+    assert.equal(result, "continue");
+    assert.equal(s.pendingVerificationRetry, null);
+    assert.ok(
+      notifications.every((message) => !message.includes("handed off via reopen/replan")),
+      `plain text must not be treated as handoff, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("DB unavailable")),
+      `expected DB-unavailable fallback, got: ${notifications.join("\n")}`,
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("complete-slice with gsd_replan_slice tool result continues instead of artifact-retrying", async () => {
   const base = makeTempRepo("gsd-complete-slice-replan-");
   try {
@@ -111,6 +151,48 @@ test("complete-slice with gsd_replan_slice tool result continues instead of arti
   }
 });
 
+test("complete-slice text mentioning gsd_replan_slice does not count as a valid replan outcome", async () => {
+  const base = makeTempRepo("gsd-complete-slice-replan-text-");
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(sliceDir, "S01-REPLAN.md"), "# Replan\n");
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "complete-slice", id: "M001/S01", startedAt: Date.now() };
+
+    const notifications: string[] = [];
+    const result = await postUnitPreVerification(
+      makePostUnitContext(base, s, notifications),
+      {
+        skipSettleDelay: true,
+        skipWorktreeSync: true,
+        agentEndMessages: [
+          {
+            role: "assistant",
+            content: "I will use gsd_replan_slice and let execution follow up.",
+          },
+        ],
+      },
+    );
+
+    assert.equal(result, "continue");
+    assert.equal(s.pendingVerificationRetry, null);
+    assert.ok(
+      notifications.every((message) => !message.includes("valid replan outcome")),
+      `plain text must not be treated as replan outcome, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("DB unavailable")),
+      `expected DB-unavailable fallback, got: ${notifications.join("\n")}`,
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("complete-slice with gsd_replan_slice but no REPLAN artifact retries", async () => {
   const base = makeTempRepo("gsd-complete-slice-replan-missing-artifact-");
   try {

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -258,6 +258,48 @@ describe('complete-slice verification gate (#3580)', () => {
     }
   });
 
+  test('allows a browser UAT declared as a bare keyword under ## UAT Type (M006/S01 format drift)', async () => {
+    // Regression: the agent wrote `## UAT Type\nbrowser-executable` (no
+    // `- UAT mode:` bullet). The old parser defaulted that to artifact-driven
+    // and the gate rejected the slice in a loop.
+    const body = [
+      '## UAT Type',
+      'browser-executable',
+      '',
+      '## Smoke Test',
+      '1. Open the page in a browser and perform add/edit/complete/delete once.',
+    ].join('\n');
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: body }),
+      basePath,
+    );
+    if ('error' in result) {
+      assert.doesNotMatch(
+        result.error,
+        /requires browser verification/i,
+        `bare browser-executable declaration must pass the browser gate, got: ${result.error}`,
+      );
+    }
+  });
+
+  test('explains the missing declaration when a browser UAT has no parseable UAT mode', async () => {
+    // When nothing was declared, the error must not claim the agent
+    // "declared artifact-driven" — it must show the expected bullet format.
+    const body = [
+      '## Smoke Test',
+      '1. Open the page in a browser and perform add/edit/complete/delete once.',
+    ].join('\n');
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: body }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to reject an undeclared browser UAT');
+    const error = (result as { error: string }).error;
+    assert.match(error, /no parseable UAT mode declaration/i);
+    assert.match(error, /- UAT mode: browser-executable/);
+    assert.doesNotMatch(error, /but declares "UAT mode: artifact-driven"/);
+  });
+
   test('allows a browser UAT when it is declared mixed (mixed receives browser tools)', async () => {
     const body = BROWSER_UAT_BODY.replace('artifact-driven', 'mixed (artifact-driven + browser)');
     const result = await handleCompleteSlice(

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -61,11 +61,11 @@ function cleanupDir(dirPath: string): void {
  */
 function createTempProject(): { basePath: string; roadmapPath: string } {
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-slice-handler-'));
-  const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+  const sliceDir = path.join(basePath, '.gsd', 'phases', '01-test');
   const tasksDir = path.join(sliceDir, 'tasks');
   fs.mkdirSync(tasksDir, { recursive: true });
 
-  const roadmapPath = path.join(basePath, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+  const roadmapPath = path.join(basePath, '.gsd', 'phases', '01-test', '01-ROADMAP.md');
   fs.writeFileSync(roadmapPath, `# M001: Test Milestone
 
 ## Slices
@@ -203,6 +203,10 @@ console.log('\n=== complete-slice: handler happy path ===');
   insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Second Slice', risk: 'low', depends: ['S01'], demo: 'advanced stuff', sequence: 2 });
   insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 1' });
   insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'Task 2' });
+  insertTask({ id: 'T99', sliceId: 'S02', milestoneId: 'M001', status: 'complete', title: 'Sibling Task' });
+  const siblingSummaryPath = path.join(path.dirname(roadmapPath), 'T99-SUMMARY.md');
+  const siblingSummaryBefore = '# Existing sibling task summary\n\nDo not rewrite this file.\n';
+  fs.writeFileSync(siblingSummaryPath, siblingSummaryBefore);
 
   const params = makeValidSliceParams();
   const result = await handleCompleteSlice(params, basePath);
@@ -211,8 +215,8 @@ console.log('\n=== complete-slice: handler happy path ===');
   if (!('error' in result)) {
     assertEq(result.sliceId, 'S01', 'result sliceId');
     assertEq(result.milestoneId, 'M001', 'result milestoneId');
-    assertTrue(result.summaryPath.endsWith('S01-SUMMARY.md'), 'summaryPath should end with S01-SUMMARY.md');
-    assertTrue(result.uatPath.endsWith('S01-UAT.md'), 'uatPath should end with S01-UAT.md');
+    assertTrue(result.summaryPath.endsWith('01-01-SUMMARY.md'), 'summaryPath should end with 01-01-SUMMARY.md');
+    assertTrue(result.uatPath.endsWith('01-01-UAT.md'), 'uatPath should end with 01-01-UAT.md');
 
     // (a) Verify SUMMARY.md exists on disk with correct YAML frontmatter
     assertTrue(fs.existsSync(result.summaryPath), 'summary file should exist on disk');
@@ -267,6 +271,13 @@ console.log('\n=== complete-slice: handler happy path ===');
     // (e) Verify slice status is complete in DB
     assertEq(sliceAfter!.status, 'complete', 'slice status should be complete in DB');
     assertTrue(sliceAfter!.completed_at !== null, 'completed_at should be set in DB');
+
+    // (f) Verify unrelated completed task summaries are not re-rendered during slice completion
+    assertEq(
+      fs.readFileSync(siblingSummaryPath, 'utf-8'),
+      siblingSummaryBefore,
+      'complete-slice should not re-render sibling completed task summaries',
+    );
   }
 
   cleanupDir(basePath);
@@ -416,8 +427,8 @@ console.log('\n=== complete-slice: handler idempotency ===');
   if (!('error' in r2)) {
     assertEq(r2.duplicate, true, 'second call should be marked duplicate');
     assertEq(
-      fs.readFileSync(r2.summaryPath, 'utf-8'),
-      summaryBefore,
+      fs.readFileSync(r2.summaryPath, 'utf-8').replace(/completed_at: "[^"]*"/g, 'completed_at: "<ts>"'),
+      summaryBefore.replace(/completed_at: "[^"]*"/g, 'completed_at: "<ts>"'),
       'healthy duplicate should not rewrite the existing summary',
     );
   }
@@ -488,7 +499,7 @@ console.log('\n=== complete-slice: handler with missing roadmap ===');
 
   // Create a temp dir WITHOUT a roadmap file
   const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-no-roadmap-'));
-  const sliceDir = path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+  const sliceDir = path.join(basePath, '.gsd', 'phases', '01-test');
   fs.mkdirSync(sliceDir, { recursive: true });
 
   // Set up DB state