@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.965d1788

package/src/resources/extensions/gsd/tests/artifact-retry-cap.test.ts

@@ -29,21 +29,22 @@ test("#2007 bug 1: MAX_ARTIFACT_VERIFICATION_RETRIES constant is defined", () =>
   assert.equal(MAX_ARTIFACT_VERIFICATION_RETRIES, 3);
 });
 
-test("#2007 bug 1: retry state can represent each allowed attempt before exhaustion", () => {
+test("#2007 bug 1: retry state keeps attempt separate from failure context", () => {
   const s = new AutoSession();
   const retryKey = "execute-task:M001/S01/T01";
+  const failureContext = "Missing expected artifact";
 
   for (let attempt = 1; attempt <= MAX_ARTIFACT_VERIFICATION_RETRIES; attempt++) {
     s.verificationRetryCount.set(retryKey, attempt);
     s.pendingVerificationRetry = {
       unitId: "M001/S01/T01",
-      failureContext: `Missing expected artifact (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+      failureContext,
       attempt,
     };
 
     assert.equal(s.verificationRetryCount.get(retryKey), attempt);
     assert.equal(s.pendingVerificationRetry.attempt, attempt);
-    assert.match(s.pendingVerificationRetry.failureContext, /attempt \d\/3/);
+    assert.equal(s.pendingVerificationRetry.failureContext, failureContext);
   }
 });
 

package/src/resources/extensions/gsd/tests/auto-artifact-paths.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "nod
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
+import { resolveExpectedArtifactPath, resolveSliceResearchLocation, resolveExistingSliceResearchPath } from "../auto-artifact-paths.ts";
 import { clearPathCache, _clearGsdRootCache, isLegacyMilestonesLayout, milestonesDir } from "../paths.ts";
 
 test("worktree artifact resolution falls back to project .gsd artifacts", () => {
@@ -359,3 +359,100 @@ test("canonical worktree + project-root legacy dir produces legacy filename (#bu
     rmSync(root, { recursive: true, force: true });
   }
 });
+
+// ── resolveSliceResearchLocation / resolveExistingSliceResearchPath ───────────
+//
+// Added in the code-quality consolidation PR as the shared dual-path resolver
+// for slice RESEARCH files (worktree projection first, then canonical path
+// fallback). These tests guard: missing file → null pair; existing legacy-
+// layout file → correct absolute and relative paths.
+
+test("resolveSliceResearchLocation returns null pair when no RESEARCH file exists", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-research-missing-")));
+  try {
+    const milestoneDir = join(root, ".gsd", "milestones", "M001");
+    mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+    // Content-bearing dir so it is not treated as META-only, but no RESEARCH file.
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# context\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const result = resolveSliceResearchLocation(root, "M001", "S01");
+    assert.strictEqual(result.absolutePath, null, "absolutePath must be null when no RESEARCH exists");
+    assert.strictEqual(result.relativePath, null, "relativePath must be null when no RESEARCH exists");
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("resolveExistingSliceResearchPath returns null when no RESEARCH file exists", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-research-null-")));
+  try {
+    const milestoneDir = join(root, ".gsd", "milestones", "M001");
+    mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# context\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    assert.strictEqual(
+      resolveExistingSliceResearchPath(root, "M001", "S01"),
+      null,
+      "must return null when RESEARCH file is absent",
+    );
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("resolveSliceResearchLocation finds existing RESEARCH in legacy layout", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-research-legacy-")));
+  try {
+    const milestoneDir = join(root, ".gsd", "milestones", "M001");
+    const sliceDir = join(milestoneDir, "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# context\n");
+    const researchFile = join(sliceDir, "S01-RESEARCH.md");
+    writeFileSync(researchFile, "# slice research\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const result = resolveSliceResearchLocation(root, "M001", "S01");
+    assert.ok(result.absolutePath !== null, "absolutePath must be non-null when RESEARCH exists");
+    assert.ok(result.relativePath !== null, "relativePath must be non-null when RESEARCH exists");
+    assert.equal(result.absolutePath, researchFile, "absolutePath must point to the RESEARCH file");
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("resolveExistingSliceResearchPath returns absolute path when RESEARCH exists (legacy layout)", () => {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-research-existing-")));
+  try {
+    const milestoneDir = join(root, ".gsd", "milestones", "M001");
+    const sliceDir = join(milestoneDir, "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# context\n");
+    const researchFile = join(sliceDir, "S01-RESEARCH.md");
+    writeFileSync(researchFile, "# research\n");
+
+    _clearGsdRootCache();
+    clearPathCache();
+
+    const result = resolveExistingSliceResearchPath(root, "M001", "S01");
+    assert.ok(result !== null, "must return non-null when RESEARCH exists");
+    assert.equal(result, researchFile, "must return the absolute path to the RESEARCH file");
+  } finally {
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-recovery.test.ts

@@ -2,7 +2,7 @@
 // File Purpose: Tests auto-mode artifact verification and recovery behavior.
 import test, { afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -964,6 +964,45 @@ function makeGitBase(): string {
   return base;
 }
 
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function withLoggedGitCommands<T>(base: string, action: () => T): { result: T; commands: string[] } {
+  const realGit = execFileSync("which", ["git"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim().split(/\r?\n/)[0];
+  if (!realGit) throw new Error("Unable to resolve git executable for invocation logging test");
+  const binDir = join(base, ".git-wrapper-bin");
+  const logFile = join(base, "git-invocations.log");
+  mkdirSync(binDir, { recursive: true });
+  const wrapper = join(binDir, "git");
+  writeFileSync(
+    wrapper,
+    [
+      "#!/usr/bin/env bash",
+      `printf '%s\\n' "$1" >> ${shellQuote(logFile)}`,
+      `exec ${shellQuote(realGit)} "$@"`,
+      "",
+    ].join("\n"),
+  );
+  chmodSync(wrapper, 0o755);
+
+  const originalPath = process.env.PATH;
+  process.env.PATH = originalPath ? `${binDir}:${originalPath}` : binDir;
+  try {
+    const result = action();
+    const commands = existsSync(logFile)
+      ? readFileSync(logFile, "utf-8").split(/\r?\n/).filter(Boolean)
+      : [];
+    return { result, commands };
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+  }
+}
+
 test("hasImplementationArtifacts returns false when only .gsd/ files committed (#1703)", () => {
   const base = makeGitBase();
   try {
@@ -1344,6 +1383,77 @@ test("hasImplementationArtifacts finds implementation commits when .gsd/ is giti
   }
 });
 
+test("hasImplementationArtifacts scans GSD-tagged history without per-commit diff-tree forks (#892)", { skip: process.platform === "win32" }, () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+      "# Summary",
+    );
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    for (let i = 0; i < 3; i++) {
+      writeFileSync(join(base, "src", `feature-${i}.ts`), `export const feature${i} = true;\n`);
+      execFileSync("git", ["add", "src"], { cwd: base, stdio: "ignore" });
+      execFileSync(
+        "git",
+        ["commit", "-m", `feat: materialize M001 evidence ${i}\n\nGSD-Task: S01/T01`],
+        { cwd: base, stdio: "ignore" },
+      );
+    }
+
+    const { result, commands } = withLoggedGitCommands(base, () => hasImplementationArtifacts(base, "M001"));
+    assert.equal(result, "present", "milestone-tagged commits should still prove implementation evidence");
+    assert.ok(commands.includes("log"), "milestone evidence fallback should scan history with git log");
+    assert.equal(commands.filter((command) => command === "diff-tree").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts backfill scans commit records without per-commit diff-tree forks (#892)", { skip: process.platform === "win32" }, () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+      keyFiles: ["src/expected-0.ts", "src/expected-1.ts"],
+      planning: { files: ["src/expected-0.ts", "src/expected-1.ts"] },
+    });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    for (let i = 0; i < 2; i++) {
+      writeFileSync(join(base, "src", `expected-${i}.ts`), `export const expected${i} = true;\n`);
+      execFileSync("git", ["add", "src"], { cwd: base, stdio: "ignore" });
+      execFileSync("git", ["commit", "-m", `feat: untagged implementation ${i}`], { cwd: base, stdio: "ignore" });
+    }
+
+    const { result, commands } = withLoggedGitCommands(base, () => hasImplementationArtifacts(base, "M001"));
+    assert.equal(result, "present", "completed task file hints should still backfill untagged commits");
+    assert.equal(getMilestoneCommitAttributionShas("M001").length, 2);
+    assert.ok(commands.includes("log"), "backfill should scan commit records with git log");
+    assert.equal(commands.filter((command) => command === "diff-tree").length, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts binds GSD-Task trailer to milestone via DB state when .gsd/ is gitignored", () => {
   const base = makeGitBase();
   try {

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

@@ -101,6 +101,32 @@ test("analyzeSessionContext buckets injections, tool results, and loaded skills"
   assert.equal(result.subagentSpawns, 1);
 });
 
+test("analyzeSessionContext bounds large assistant tool-call arguments", () => {
+  const result = analyzeSessionContext(sessionEntries({
+    role: "assistant",
+    content: [
+      {
+        type: "toolCall",
+        id: "tc-save",
+        name: "gsd_summary_save",
+        arguments: {
+          path: ".gsd/milestones/M001/M001-SUMMARY.md",
+          artifact_type: "SUMMARY",
+          content: "x".repeat(20_000),
+        },
+      },
+    ],
+    timestamp: TS,
+  }), PROVIDER);
+
+  const assistant = result.conversationSections.find((section) => section.label === "Assistant responses");
+  assert.ok(assistant);
+  assert.ok(
+    assistant.tokens < 200,
+    `assistant tool-call arguments should be redacted before token counting, got ${assistant.tokens} tokens`,
+  );
+});
+
 test("formatContextReport lists skills and subagents", () => {
   const report = buildContextBreakdown({
     modelLabel: "claude-code/claude-sonnet-4-6",

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

@@ -460,6 +460,7 @@ describe("Batch 3 prompt templates resolve", () => {
     const out = loadPrompt("code-review", { scope: "s", depth: "deep", fixMode: "off", reviewId: "001" });
     assert.match(out, /deep/);
     assert.match(out, /001/);
+    assert.match(out, /diff-first/i, "code-review prompt should require diff-first context gathering");
   });
   test("review.md loads with target + reviewers", () => {
     const out = loadPrompt("review", { target: "t", reviewers: "claude, codex" });

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/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[]) {
@@ -227,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

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

package/src/resources/extensions/gsd/tests/complete-task-rollback-evidence.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync, promises as fsPromises } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -41,7 +41,7 @@ const VALID_PARAMS = {
   ],
 };
 
-describe("complete-task projection failures keep DB completion committed", () => {
+describe("complete-task projection failures roll back DB completion", () => {
   let base: string;
 
   afterEach(() => {
@@ -75,7 +75,44 @@ describe("complete-task projection failures keep DB completion committed", () =>
     assert.equal(rows.length, 2, "should have 2 evidence rows after success");
   });
 
-  it("keeps task completion and verification_evidence when disk projection write fails", async () => {
+  it("reopens the workflow DB when it disappears between SUMMARY.md write and plan render", async (t) => {
+    base = makeTmpBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001" });
+
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    writeFileSync(
+      planPath,
+      "# S01 Plan\n\n## Tasks\n\n- [ ] **T01: Test task**\n",
+    );
+
+    const originalRename = fsPromises.rename.bind(fsPromises);
+    let closedAfterSummaryWrite = false;
+    t.mock.method(fsPromises, "rename", async (...args: Parameters<typeof fsPromises.rename>) => {
+      await originalRename(...args);
+      const target = String(args[1]);
+      if (!closedAfterSummaryWrite && target.endsWith("T01-SUMMARY.md")) {
+        closedAfterSummaryWrite = true;
+        closeDatabase();
+      }
+    });
+
+    const result = await handleCompleteTask(VALID_PARAMS, base);
+    assert.ok(closedAfterSummaryWrite, "test fixture should close DB after SUMMARY.md atomic rename");
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+
+    const content = readFileSync(planPath, "utf-8");
+    assert.match(content, /\[x\][^\n]*\*\*T01\*\*/, "PLAN.md checkbox should be rendered after DB reopen");
+
+    const adapter = _getAdapter()!;
+    const task = adapter.prepare(
+      `SELECT status FROM tasks WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'`,
+    ).get() as { status: string } | undefined;
+    assert.equal(task?.status, "complete", "task should remain complete after successful projection");
+  });
+
+  it("rolls back DB completion and clears verification_evidence when disk projection write fails", async () => {
     base = makeTmpBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001" });
@@ -87,19 +124,22 @@ describe("complete-task projection failures keep DB completion committed", () =>
     writeFileSync(tasksDir, "not-a-directory");
 
     const result = await handleCompleteTask(VALID_PARAMS, base);
-    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
-    assert.equal(result.stale, true, "result should report stale projection");
+    assert.ok("error" in result, "expected rollback error when projection write fails");
+    assert.ok(
+      (result as { error: string }).error.includes("rolled completion back to pending"),
+      `error should mention rollback; got: ${"error" in result ? result.error : ""}`,
+    );
 
     const adapter = _getAdapter()!;
     const task = adapter.prepare(
       `SELECT status FROM tasks WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'`,
     ).get() as { status: string } | undefined;
-    assert.ok(task, "task row should still exist");
-    assert.equal(task!.status, "complete", "task status should remain complete");
+    assert.ok(task, "task row should still exist after rollback");
+    assert.equal(task!.status, "pending", "task status should be rolled back to pending");
 
     const evidenceRows = adapter.prepare(
       `SELECT * FROM verification_evidence WHERE task_id = 'T01' AND slice_id = 'S01' AND milestone_id = 'M001'`,
     ).all();
-    assert.equal(evidenceRows.length, 2, "verification_evidence should remain committed");
+    assert.equal(evidenceRows.length, 0, "verification_evidence should be deleted after rollback");
   });
 });