@opengsd/gsd-pi 1.3.0 → 1.4.0

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

@@ -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");

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.test.ts

@@ -312,6 +312,34 @@ console.log('\n=== complete-milestone: incomplete slices block closeout ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-milestone: deferred slices are inactive for closeout
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-milestone: deferred slices do not block closeout ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const { basePath } = createTempProject();
+  seedCompletedMilestone({ basePath, validationVerdict: 'pass' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Deferred Slice', status: 'deferred' });
+  insertTask({
+    id: 'T02',
+    sliceId: 'S02',
+    milestoneId: 'M001',
+    status: 'pending',
+    title: 'Deferred Slice Task',
+  });
+
+  const result = await handleCompleteMilestone(makeValidParams(), basePath);
+
+  assertTrue(!('error' in result), 'deferred slice should not block milestone completion');
+  assertEq(getMilestone('M001')!.status, 'complete', 'milestone should complete with deferred inactive slice');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-milestone: deep task check (slice closed, task not)
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -7,6 +7,10 @@ import { join } from "node:path";
 
 import { postUnitPreVerification } from "../auto-post-unit.ts";
 import { AutoSession } from "../auto/session.ts";
+import {
+  decideVerificationRetry,
+  hashVerificationFailureContext,
+} from "../auto/verification-retry-policy.ts";
 import { cleanup, makeTempRepo } from "./test-utils.ts";
 
 function makePostUnitContext(base: string, s: AutoSession, notifications: string[]) {
@@ -67,6 +71,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 +155,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 {
@@ -145,3 +231,68 @@ test("complete-slice with gsd_replan_slice but no REPLAN artifact retries", asyn
     cleanup(base);
   }
 });
+
+test("artifact retry context stays stable across attempts while notifications show attempt count", async () => {
+  const base = makeTempRepo("gsd-artifact-retry-stable-context-");
+  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 pctx = makePostUnitContext(base, s, notifications);
+    const opts = {
+      skipSettleDelay: true,
+      skipWorktreeSync: true,
+      agentEndMessages: [
+        {
+          role: "toolResult",
+          toolName: "gsd_replan_slice",
+          isError: false,
+          content: "Slice replanned with reopened task T02.",
+        },
+      ],
+    };
+
+    assert.equal(await postUnitPreVerification(pctx, opts), "retry");
+    const firstRetry = s.pendingVerificationRetry;
+    assert.ok(firstRetry);
+    assert.equal(firstRetry.attempt, 1);
+    assert.doesNotMatch(firstRetry.failureContext, /\(attempt \d\/3\)\.$/);
+    const firstFailureHash = hashVerificationFailureContext(firstRetry.failureContext);
+
+    assert.equal(await postUnitPreVerification(pctx, opts), "retry");
+    const secondRetry = s.pendingVerificationRetry;
+    assert.ok(secondRetry);
+    assert.equal(secondRetry.attempt, 2);
+    assert.equal(secondRetry.failureContext, firstRetry.failureContext);
+    assert.equal(hashVerificationFailureContext(secondRetry.failureContext), firstFailureHash);
+    assert.deepEqual(
+      decideVerificationRetry({
+        unitType: s.currentUnit.type,
+        retryInfo: secondRetry,
+        previousFailureHash: firstFailureHash,
+        random: () => 0.5,
+      }),
+      {
+        action: "pause",
+        reason: "duplicate-failure-context",
+        key: "complete-slice:M001/S01",
+        failureHash: firstFailureHash,
+      },
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("Retrying (attempt 1/3).")),
+      `expected first attempt notification, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("Retrying (attempt 2/3).")),
+      `expected second attempt notification, got: ${notifications.join("\n")}`,
+    );
+  } finally {
+    cleanup(base);
+  }
+});

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