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

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

@@ -5,13 +5,14 @@
  * that getWorktreeHealth and formatWorktreeStatusLine return correct results.
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
-import { join } from "node:path";
+import { chmodSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
+import { getAllWorktreeHealth, getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
 import { listWorktrees } from "../worktree-manager.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -173,6 +174,45 @@ describe('worktree-health', async () => {
       assert.ok(line.includes("last commit"), "shows last commit age for active worktree");
     }
 
+    // ─── Test: batch health detects main branch once ───────────────────
+    console.log("\n=== worktree health: batch main branch detection ===");
+    {
+      const dir = createBaseRepo();
+      cleanups.push(dir);
+
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b worktree/batch-a .gsd/worktrees/batch-a", dir);
+      run("git worktree add -b worktree/batch-b .gsd/worktrees/batch-b", dir);
+
+      const bin = mkdtempSync(join(tmpdir(), "wt-health-git-shim-"));
+      cleanups.push(bin);
+      const logPath = join(bin, "git.log");
+      const realGit = execSync("command -v git", { encoding: "utf-8" }).trim();
+      const shim = join(bin, "git");
+      writeFileSync(shim, `#!/bin/sh\nprintf '%s\\n' "$*" >> ${JSON.stringify(logPath)}\nexec ${JSON.stringify(realGit)} "$@"\n`, "utf-8");
+      chmodSync(shim, 0o755);
+
+      const originalPath = process.env.PATH ?? "";
+      const originalGitEnvPath = GIT_NO_PROMPT_ENV.PATH;
+      try {
+        process.env.PATH = `${bin}${delimiter}${originalPath}`;
+        GIT_NO_PROMPT_ENV.PATH = process.env.PATH;
+
+        const health = getAllWorktreeHealth(dir);
+        assert.equal(health.length, 2, "both worktrees have health entries");
+      } finally {
+        process.env.PATH = originalPath;
+        GIT_NO_PROMPT_ENV.PATH = originalGitEnvPath;
+      }
+
+      const invocations = readFileSync(logPath, "utf-8")
+        .trim()
+        .split("\n")
+        .filter(Boolean);
+      const mainBranchDetections = invocations.filter(line => line === "symbolic-ref refs/remotes/origin/HEAD");
+      assert.equal(mainBranchDetections.length, 1, "batch health detects main branch once");
+    }
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }

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

@@ -107,7 +107,7 @@ function makeDeps(
   // real `getAutoWorktreePath` / `createAutoWorktree` / etc. and the
   // success/existing/failure branches won't fire as expected.
   const deps: LegacyTestDeps = {
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     worktreeProjection: new WorktreeStateProjection(),
     // ADR-016 phase 2 / C4 (#5627): GitServiceImpl constructor → factory.
     gitServiceFactory: () => ({}) as unknown as ReturnType<
@@ -283,7 +283,7 @@ describe("worktree journal events", () => {
 
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     const deps = makeDeps({
-      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+      mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     });
     process.chdir(wt);
 
@@ -304,7 +304,7 @@ describe("worktree journal events", () => {
     const wt = setupMergeWorktree(tmp, "M001");
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     const deps = makeDeps({
-      mergeMilestoneToMain: () => { throw new Error("conflict in main"); },
+      mergeMilestone: () => { throw new Error("conflict in main"); },
     });
     // Since #4380, mergeAndExit re-throws all errors after emitting the journal
     // event and restoring state. Lifecycle now wraps that throw in a typed
@@ -347,7 +347,7 @@ describe("worktree journal events", () => {
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     let attempt = 0;
     const deps = makeDeps({
-      mergeMilestoneToMain: () => {
+      mergeMilestone: () => {
         attempt += 1;
         throw new MergeConflictError(
           attempt === 1 ? ["src/a.ts"] : ["src/b.ts", "src/c.ts"],

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

@@ -46,7 +46,7 @@ function makeDeps(
 ): LegacyTestDeps & { calls: CallLog[] } {
   const calls: CallLog[] = [];
   // ADR-016 phase 2 / C-track close-out: WorktreeLifecycleDeps is now a
-  // 3-field bag (gitServiceFactory, worktreeProjection, mergeMilestoneToMain).
+  // 3-field bag (gitServiceFactory, worktreeProjection, mergeMilestone).
   // Tests still pass legacy override hooks via `LegacyTestDeps` — Lifecycle
   // ignores the extras structurally and reads them through the C1-healing
   // primitive-override pattern when stubs are needed.
@@ -73,7 +73,7 @@ function makeDeps(
     },
     autoWorktreeBranch: (mid: string) => `milestone/${mid}`,
     teardownAutoWorktree: () => {},
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     ...overrides,
   };
   return deps;

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

@@ -10,8 +10,10 @@ import {
   listWorktrees,
   removeWorktree,
   diffWorktreeGSD,
+  diffWorktreeNumstat,
   getWorktreeGSDDiff,
   getWorktreeLog,
+  mergeWorktreeToMain,
   worktreeBranchName,
   worktreePath,
   pruneEphemeralGhostWorktreeDirectories,
@@ -291,6 +293,31 @@ describe("diffWorktreeGSD and getWorktreeGSDDiff", () => {
   });
 });
 
+describe("worktree diff target branch override", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithChanges("feature-x");
+    base = repo.base;
+
+    run("git checkout -b integration main", base);
+    writeFileSync(join(base, "TARGET_ONLY.md"), "target branch only\n", "utf-8");
+    run("git add TARGET_ONLY.md", base);
+    run('git commit -m "chore: target branch only"', base);
+    run("git checkout main", base);
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("uses supplied main branch for merge preview helper overrides", () => {
+    const defaultStats = diffWorktreeNumstat(base, "feature-x", undefined, "main");
+    const overrideStats = diffWorktreeNumstat(base, "feature-x", undefined, "integration");
+    const selfLog = getWorktreeLog(base, "feature-x", worktreeBranchName("feature-x"));
+
+    assert.ok(!defaultStats.some(s => s.file === "TARGET_ONLY.md"), "default main stats should not include target-only file");
+    assert.ok(overrideStats.some(s => s.file === "TARGET_ONLY.md"), "override stats should use the supplied target branch");
+    assert.strictEqual(selfLog, "", "override log should use the supplied branch");
+  });
+});
+
 // ─── getWorktreeLog ───────────────────────────────────────────────────────────
 
 describe("getWorktreeLog", () => {
@@ -307,6 +334,44 @@ describe("getWorktreeLog", () => {
   });
 });
 
+// ─── mergeWorktreeToMain ─────────────────────────────────────────────────────
+
+describe("mergeWorktreeToMain", () => {
+  let base: string;
+  let wtPath: string;
+
+  beforeEach(() => {
+    base = makeBaseRepo();
+    wtPath = worktreePath(base, "M900");
+    mkdirSync(join(base, ".gsd-worktrees"), { recursive: true });
+    run(`git worktree add -b milestone/M900 "${wtPath}"`, base);
+  });
+
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("cleans failed milestone squash state and deletes orphan branch", () => {
+    writeFileSync(join(wtPath, "README.md"), "# Milestone change\n", "utf-8");
+    run("git add README.md", wtPath);
+    run('git commit -m "feat: milestone change"', wtPath);
+
+    writeFileSync(join(base, "README.md"), "# Main change\n", "utf-8");
+    run("git add README.md", base);
+    run('git commit -m "feat: main change"', base);
+
+    assert.throws(
+      () => mergeWorktreeToMain(base, "M900", "feat: merge M900", "milestone/M900"),
+      /Merge conflicts detected/,
+    );
+
+    assert.equal(run("git status --porcelain", base), "", "failed squash cleanup should leave main clean");
+    assert.ok(!existsSync(wtPath), "failed milestone worktree should be removed");
+    assert.ok(
+      !run("git branch", base).includes("milestone/M900"),
+      "failed milestone branch should be deleted after worktree removal",
+    );
+  });
+});
+
 // ─── removeWorktree ───────────────────────────────────────────────────────────
 
 describe("removeWorktree", () => {

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

@@ -307,22 +307,26 @@ describe("Worktree Safety module", () => {
     assert.equal(result.kind, "worktree-unregistered");
   });
 
-  test("attempts prune recovery once for unregistered worktrees and tracks failed roots", () => {
+  test("removes an orphaned worktree directory when prune cannot recover it", () => {
     let pruneCalls = 0;
-    let listCalls = 0;
+    let removeCalls = 0;
+    let removedUnitRoot: string | undefined;
+    let removedMilestoneId: string | undefined;
     const safety = createWorktreeSafetyModule({
       existsSync: () => true,
       lstatSync: () => ({ isFile: () => true }),
       pruneRegisteredWorktrees: () => {
         pruneCalls += 1;
       },
-      listRegisteredWorktrees: () => {
-        listCalls += 1;
-        return [];
+      listRegisteredWorktrees: () => [],
+      removeStaleWorktreeDirectory: (root, milestoneId) => {
+        removeCalls += 1;
+        removedUnitRoot = root;
+        removedMilestoneId = milestoneId;
       },
     });
 
-    const first = safety.validateUnitRoot({
+    const result = safety.validateUnitRoot({
       unitType: "execute-task",
       unitId: "M001/S01/T01",
       writeScope: "source-writing",
@@ -330,14 +334,32 @@ describe("Worktree Safety module", () => {
       unitRoot,
       milestoneId: "M001",
     });
-    assert.equal(first.ok, false);
-    assert.equal(first.kind, "worktree-unregistered");
-    assert.equal(first.details?.attemptedPrune, true);
-    assert.equal(first.details?.trackedAsFailed, true);
+
+    // Orphaned directory is cleaned up and the failure degrades to the
+    // recoverable worktree-missing kind so the next dispatch can recreate it,
+    // instead of looping forever on worktree-unregistered (#803).
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-missing");
+    assert.equal(result.details?.removedStaleDirectory, true);
+    assert.equal(result.details?.attemptedPrune, true);
     assert.equal(pruneCalls, 1);
-    assert.equal(listCalls, 2);
+    assert.equal(removeCalls, 1);
+    assert.equal(removedUnitRoot, unitRoot);
+    assert.equal(removedMilestoneId, "M001");
+  });
 
-    const second = safety.validateUnitRoot({
+  test("keeps worktree-unregistered when the orphaned directory cannot be removed", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      pruneRegisteredWorktrees: () => {},
+      listRegisteredWorktrees: () => [],
+      removeStaleWorktreeDirectory: () => {
+        throw new Error("directory may be locked by another process");
+      },
+    });
+
+    const result = safety.validateUnitRoot({
       unitType: "execute-task",
       unitId: "M001/S01/T01",
       writeScope: "source-writing",
@@ -345,12 +367,11 @@ describe("Worktree Safety module", () => {
       unitRoot,
       milestoneId: "M001",
     });
-    assert.equal(second.ok, false);
-    assert.equal(second.kind, "worktree-unregistered");
-    assert.equal(second.details?.attemptedPrune, false);
-    assert.equal(second.details?.trackedAsFailed, true);
-    assert.equal(pruneCalls, 1);
-    assert.equal(listCalls, 3);
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-unregistered");
+    assert.equal(result.details?.removedStaleDirectory, false);
+    assert.match(String(result.details?.error), /locked by another process/);
   });
 
   test("converts registered worktree list failures into typed failures", () => {

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -23,7 +23,7 @@
  *   - syncWorktreeStateBack skips non-standard milestone projection dir names
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -148,6 +148,36 @@ describe('worktree-sync-milestones', async () => {
     }
   }
 
+  // ─── 3c. artifact file/dir collisions preserve existing worktree files ─
+  console.log('\n=== 3c. artifact file/dir collisions preserve existing worktree files (#1157) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      const mainSliceDir = join(mainBase, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+      mkdirSync(join(mainSliceDir, 'S01-SUMMARY.md'), { recursive: true });
+      mkdirSync(join(mainSliceDir, 'S01-ASSESSMENT.md'), { recursive: true });
+
+      const wtSliceDir = join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+      mkdirSync(wtSliceDir, { recursive: true });
+      writeFileSync(join(wtSliceDir, 'S01-SUMMARY.md'), '# Valid summary\n');
+      writeFileSync(join(wtSliceDir, 'S01-ASSESSMENT.md'), '---\nverdict: pass\n---\n# Valid assessment\n');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      const summaryPath = join(wtSliceDir, 'S01-SUMMARY.md');
+      const assessmentPath = join(wtSliceDir, 'S01-ASSESSMENT.md');
+      assert.ok(statSync(summaryPath).isFile(), 'existing SUMMARY.md stays a file');
+      assert.ok(statSync(assessmentPath).isFile(), 'existing ASSESSMENT.md stays a file');
+      assert.equal(readFileSync(summaryPath, 'utf-8'), '# Valid summary\n');
+      assert.equal(readFileSync(assessmentPath, 'utf-8'), '---\nverdict: pass\n---\n# Valid assessment\n');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
   // ─── 4. No-op when paths are equal ────────────────────────────────────
   console.log('\n=== 4. no-op when paths are equal ===');
   {

package/src/resources/extensions/gsd/tests/worktree-teardown-safety.test.ts

@@ -20,6 +20,7 @@ import {
   existsSync,
   realpathSync,
   readFileSync,
+  readdirSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -132,6 +133,37 @@ describe("worktree-teardown-safety", () => {
     );
   });
 
+  it("removeWorktree quarantines dirty worktree contents before forced cleanup", () => {
+    const tempDir = createTempRepo();
+    dirs.push(tempDir);
+
+    const wt = createWorktree(tempDir, "dirty-wt");
+    writeFileSync(join(wt.path, "generated-feature.ts"), "export const answer = 42;\n");
+    writeFileSync(join(wt.path, "README.md"), "# changed in worktree\n");
+
+    removeWorktree(tempDir, "dirty-wt", { deleteBranch: false });
+
+    assertTrue(!existsSync(wt.path), "original dirty worktree path removed after quarantine");
+    const quarantineRoot = join(tempDir, ".gsd", "quarantine", "worktrees");
+    const entries = readdirSync(quarantineRoot).filter((entry) => entry.startsWith("dirty-wt-"));
+    assertEq(entries.length, 1, "dirty worktree snapshot quarantined");
+    const quarantineDir = join(quarantineRoot, entries[0]!);
+    assertEq(
+      readFileSync(join(quarantineDir, "generated-feature.ts"), "utf-8"),
+      "export const answer = 42;\n",
+      "untracked source file survives in quarantine",
+    );
+    assertEq(
+      readFileSync(join(quarantineDir, "README.md"), "utf-8"),
+      "# changed in worktree\n",
+      "modified tracked file survives in quarantine",
+    );
+    assertTrue(
+      existsSync(join(quarantineDir, ".gsd-quarantine.json")),
+      "quarantine metadata written",
+    );
+  });
+
   it("worktreePath always returns paths under .gsd/worktrees/", () => {
     const tempDir = createTempRepo();
     dirs.push(tempDir);

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -431,7 +431,10 @@ test('auto-unit scope: execute-task blocks slice and milestone lifecycle aliases
   assert.match(reopen.reason!, /gsd_milestone_reopen/);
 });
 
-test('auto-unit scope: complete-slice blocks milestone validation and native Workflow', () => {
+test('auto-unit scope: complete-slice allows milestone status but blocks milestone validation and native Workflow', () => {
+  const status = shouldBlockPlanningUnit('gsd_milestone_status', '', BASE, 'complete-slice', ALL);
+  assert.strictEqual(status.block, false);
+
   const closeSlice = shouldBlockPlanningUnit('gsd_slice_complete', '', BASE, 'complete-slice', ALL);
   assert.strictEqual(closeSlice.block, false);
 

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

@@ -140,6 +140,7 @@ test('write-gate: blocked reason contains depth_verification keyword and anti-by
   );
   assert.strictEqual(result.block, true);
   assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification question id');
+  assert.ok(result.reason!.includes('depth_verification_M999_confirm'), 'reason should mention the exact milestone gate id');
   assert.ok(result.reason!.includes('ask_user_questions'), 'reason should mention ask_user_questions tool');
   assert.ok(result.reason!.includes('MUST NOT'), 'reason should include anti-bypass language');
   assert.ok(result.reason!.includes('(Recommended)'), 'reason should specify the required confirmation option');
@@ -347,6 +348,7 @@ test('write-gate: reopening a gate revokes its previous verified approval', () =
 import {
   applyAskUserQuestionsGateResult,
   formatPendingAskUserQuestionsGateMessage,
+  formatTimedOutAskUserQuestionsGateMessage,
   isGateQuestionId,
   shouldBlockPendingGate,
   shouldBlockPendingGateBash,
@@ -523,6 +525,107 @@ test('write-gate: applyAskUserQuestionsGateResult keeps empty-selection pending
   }
 });
 
+// ─── Scenario 20d: applyAskUserQuestionsGateResult reports timed_out gate (#852) ──
+//
+// A host elicitation timeout must NOT be laundered into "waiting" (which tells
+// the model to re-ask — that just hits the same timeout again) nor into
+// "verified" (a timeout is never approval). The gate stays pending (fail-
+// closed) but the status is "timeout" so the caller pauses-and-waits.
+
+test('write-gate: applyAskUserQuestionsGateResult reports timed_out pending gate (#852)', () => {
+  const base = join(tmpdir(), `gsd-write-gate-ask-timeout-${randomUUID()}`);
+  const gateId = 'depth_verification_M001_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      // A timed-out round is marked cancelled:true + timed_out:true (the
+      // structuredContent the MCP child returns on host timeout).
+      details: { cancelled: true, timed_out: true, interrupted: false },
+    });
+
+    assert.deepEqual(result, {
+      status: 'timeout',
+      pendingGateId: gateId,
+      interrupted: false,
+    });
+    assert.strictEqual(getPendingGate(base), gateId, 'timed-out gate must stay pending (fail-closed)');
+    assert.strictEqual(isMilestoneDepthVerified('M001', base), false, 'timed-out gate must not verify depth');
+    // The timeout message must NOT tell the model to immediately re-ask.
+    const message = formatTimedOutAskUserQuestionsGateMessage(gateId);
+    assert.match(message, /timed out/, 'message says timed out');
+    assert.doesNotMatch(message, /Re-call ask_user_questions/, 'message must NOT invite immediate re-ask');
+    assert.match(message, /do not re-ask/i, 'message explicitly says do not re-ask');
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: applyAskUserQuestionsGateResult reports timed_out even with interrupted:true', () => {
+  // timed_out wins over the interrupted flag — both are host-side failures,
+  // but timeout is the more specific signal and must reach the caller.
+  const base = join(tmpdir(), `gsd-write-gate-ask-timeout-interrupted-${randomUUID()}`);
+  const gateId = 'depth_verification_M002_confirm';
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+    setPendingGate(gateId, base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: gateId,
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: { cancelled: true, timed_out: true, interrupted: true },
+    });
+
+    assert.deepEqual(result, {
+      status: 'timeout',
+      pendingGateId: gateId,
+      interrupted: true,
+    });
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('write-gate: timed_out gate with no pending gate returns not-gate', () => {
+  // A timed-out round arriving when no gate is armed (e.g. informational
+  // question) is not a gate concern — fail-open here, matching cancelled.
+  const base = join(tmpdir(), `gsd-write-gate-ask-timeout-nogate-${randomUUID()}`);
+
+  try {
+    mkdirSync(base, { recursive: true });
+    clearDiscussionFlowState(base);
+
+    const result = applyAskUserQuestionsGateResult({
+      basePath: base,
+      questions: [{
+        id: 'depth_verification_M001_confirm',
+        options: [{ label: 'Confirm depth (Recommended)' }, { label: 'Needs adjustment' }],
+      }],
+      details: { cancelled: true, timed_out: true },
+    });
+
+    assert.deepEqual(result, { status: 'not-gate' });
+  } finally {
+    clearDiscussionFlowState(base);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 // ─── Scenario 21: shouldBlockPendingGate blocks non-safe tools when gate is pending ──
 
 test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {