gsd-pi 2.80.0-dev.8b3a59f5c → 2.80.0-dev.b0acf17e9

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -7,91 +7,107 @@
  * call stopAuto and return { action: "break" } for non-conflict errors.
  */
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { createTestContext } from "./test-helpers.ts";
+import { runPreDispatch } from "../auto/phases.ts";
 
 const { assertTrue, report } = createTestContext();
 
-const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesPath, "utf-8");
-
 console.log("\n=== #2766: Non-MergeConflictError stops auto mode ===");
 
-// ── Test 1: every mergeAndExit call site has a catch (mergeErr) block ──
-
-// Count all mergeAndExit catch blocks by finding "} catch (mergeErr)" patterns
-const mergeAndExitCallCount = [...phasesSrc.matchAll(/\.mergeAndExit\(/g)].length;
-const mergeErrCatchCount = [...phasesSrc.matchAll(/\} catch \(mergeErr\)/g)].length;
-assertTrue(
-  mergeErrCatchCount === mergeAndExitCallCount && mergeAndExitCallCount > 0,
-  `every mergeAndExit call site has a catch (mergeErr) block (calls=${mergeAndExitCallCount}, catches=${mergeErrCatchCount})`,
-);
-
-// ── Test 2: Every mergeErr catch block handles non-MergeConflictError ───
-
-// Find each catch block and verify it has the non-conflict error handling pattern
-const catchPattern = /\} catch \(mergeErr\) \{/g;
-let match;
-let blocksWithNonConflictHandling = 0;
-let blocksTotal = 0;
-
-while ((match = catchPattern.exec(phasesSrc)) !== null) {
-  blocksTotal++;
-  // Look at the ~800 chars after the catch to find both the MergeConflictError
-  // instanceof check AND the non-conflict handling
-  const afterCatch = phasesSrc.slice(match.index, match.index + 1200);
-
-  const hasInstanceofCheck = afterCatch.includes("instanceof MergeConflictError");
-  const hasNonConflictStop = afterCatch.includes('reason: "merge-failed"');
-  const hasStopAuto = afterCatch.includes("stopAuto");
-  const hasLogError = afterCatch.includes("logError");
-
-  if (hasInstanceofCheck && hasNonConflictStop && hasStopAuto && hasLogError) {
-    blocksWithNonConflictHandling++;
-  }
+const notifications: Array<{ message: string; level?: string }> = [];
+const calls: string[] = [];
+const basePath = "/tmp/gsd-test";
+const ic = {
+  ctx: {
+    ui: {
+      notify(message: string, level?: string) {
+        notifications.push({ message, level });
+      },
+    },
+  },
+  pi: {},
+  s: {
+    basePath,
+    originalBasePath: basePath,
+    canonicalProjectRoot: basePath,
+    resourceVersionOnStart: "test",
+    currentMilestoneId: "M001",
+    currentUnit: null,
+    milestoneMergedInPhases: false,
+  },
+  prefs: undefined,
+  iteration: 1,
+  flowId: "test-flow",
+  nextSeq: () => 1,
+  deps: {
+    checkResourcesStale() {
+      return null;
+    },
+    invalidateAllCaches() {
+      calls.push("invalidate");
+    },
+    async preDispatchHealthGate() {
+      calls.push("health");
+      return { proceed: true, fixesApplied: [] };
+    },
+    async deriveState(projectRoot: string) {
+      calls.push(`derive:${projectRoot}`);
+      return {
+        phase: "complete",
+        activeMilestone: { id: "M001", title: "Milestone one" },
+        activeSlice: null,
+        activeTask: null,
+        registry: [{ id: "M001", status: "complete" }],
+        nextAction: "complete",
+      };
+    },
+    syncCmuxSidebar() {
+      calls.push("sync-sidebar");
+    },
+    setActiveMilestoneId(_basePath: string, mid: string) {
+      calls.push(`set-active:${mid}`);
+    },
+    reconcileMergeState() {
+      calls.push("reconcile");
+      return "clean";
+    },
+    preflightCleanRoot() {
+      calls.push("preflight");
+      return { ok: true, stashPushed: true, stashMarker: "marker" };
+    },
+    postflightPopStash() {
+      calls.push("postflight");
+      return { ok: true, needsManualRecovery: false };
+    },
+    resolver: {
+      mergeAndExit() {
+        calls.push("merge");
+        throw new Error("remote rejected push");
+      },
+    },
+    async stopAuto(_ctx: unknown, _pi: unknown, reason?: string) {
+      calls.push(`stop:${reason}`);
+    },
+  },
+} as any;
+
+const result = await runPreDispatch(ic, {
+  recentUnits: [],
+  stuckRecoveryAttempts: 0,
+  consecutiveFinalizeTimeouts: 0,
+});
+
+assertTrue(result.action === "break", "non-conflict merge error returns break");
+if (result.action === "break") {
+  assertTrue(result.reason === "merge-failed", "non-conflict merge error uses merge-failed reason");
 }
-
 assertTrue(
-  blocksWithNonConflictHandling === blocksTotal && blocksTotal >= 3,
-  `all ${blocksTotal} mergeAndExit catch blocks stop auto on non-conflict errors (${blocksWithNonConflictHandling}/${blocksTotal})`,
+  calls.join(" > ") === "invalidate > health > derive:/tmp/gsd-test > sync-sidebar > set-active:M001 > reconcile > preflight > merge > postflight > stop:Merge error on milestone M001: Error: remote rejected push",
+  `pre-dispatch stops immediately after non-conflict merge failure (${calls.join(" > ")})`,
 );
-
-// ── Test 3: Non-conflict handler returns break (does not continue) ──────
-
-// Verify the pattern: after the MergeConflictError instanceof block,
-// the non-conflict path returns { action: "break", reason: "merge-failed" }
-const mergeFailedReasons = [...phasesSrc.matchAll(/reason: "merge-failed"/g)].length;
-assertTrue(
-  mergeFailedReasons >= 3,
-  `all catch blocks return reason: "merge-failed" (found ${mergeFailedReasons}, expected >= 3)`,
-);
-
-// ── Test 4: Non-conflict handler notifies user ──────────────────────────
-
-// Each non-conflict block should call ctx.ui.notify with error severity
-const notifyErrorPattern = /Merge failed:.*Resolve and run \/gsd auto to resume/g;
-const notifyCount = [...phasesSrc.matchAll(notifyErrorPattern)].length;
-assertTrue(
-  notifyCount >= 3,
-  `all catch blocks notify user about merge failure (found ${notifyCount}, expected >= 3)`,
-);
-
-// ── Test 5: logError replaces logWarning for non-conflict merge errors ──
-
-// The old code used logWarning — verify logError is used instead
-const logWarningMergePattern = /logWarning\(.*Milestone merge failed with non-conflict error/g;
-const logWarningCount = [...phasesSrc.matchAll(logWarningMergePattern)].length;
-assertTrue(
-  logWarningCount === 0,
-  "logWarning is no longer used for non-conflict merge errors (replaced by logError)",
-);
-
-const logErrorMergePattern = /logError\(.*Milestone merge failed with non-conflict error/g;
-const logErrorCount = [...phasesSrc.matchAll(logErrorMergePattern)].length;
 assertTrue(
-  logErrorCount >= 3,
-  `logError is used for non-conflict merge errors (found ${logErrorCount}, expected >= 3)`,
+  notifications.some((n) => n.level === "error" && n.message.includes("Merge failed: remote rejected push")),
+  "user is notified with an error that merge failed",
 );
 
 report();

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

@@ -172,6 +172,56 @@ test('handlePlanSlice rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanSlice rejects absolute task IO paths outside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const outside = join(tmpdir(), 'outside-checkout', 'index.html');
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: [outside],
+          expectedOutput: [outside],
+        },
+      ],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: tasks\[0\]\.inputs contains absolute path outside working directory/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid planning IO must not persist tasks');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice accepts absolute task IO paths inside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const inside = join(base, 'index.html');
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: [inside],
+          expectedOutput: [inside],
+        },
+      ],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -79,6 +79,27 @@ test('handlePlanTask rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanTask rejects absolute task IO paths outside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const outside = join(tmpdir(), 'outside-checkout', 'index.html');
+    const result = await handlePlanTask({
+      ...validParams(),
+      inputs: [outside],
+      expectedOutput: [outside],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: inputs contains absolute path outside working directory/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid planning IO must not persist the task');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -5,31 +5,45 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { AutoSession } from "../auto/session.ts";
+import { postUnitPreVerification } from "../auto-post-unit.ts";
 
-const source = readFileSync(join(import.meta.dirname, "..", "auto-post-unit.ts"), "utf-8");
+test("postUnitPreVerification rebuilds STATE.md after a completed unit", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-state-"));
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# Roadmap\n\n## Slices\n\n- [ ] **S01: Discussed slice** `risk:low` `depends:[]`\n",
+    );
+    writeFileSync(join(sliceDir, "S01-CONTEXT.md"), "# Slice Context\n\nReady.\n");
 
-test("auto-post-unit imports rebuildState", () => {
-  assert.ok(
-    source.includes('import { rebuildState } from "./doctor.js";'),
-    "auto-post-unit.ts should import rebuildState from doctor.ts",
-  );
-});
-
-test("postUnitPreVerification rebuilds STATE.md before worktree sync", () => {
-  const fnStart = source.indexOf("export async function postUnitPreVerification");
-  assert.ok(fnStart > 0, "postUnitPreVerification should exist");
+    const s = new AutoSession();
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentMilestoneId = "M001";
+    s.currentUnit = { type: "discuss-slice", id: "M001/S01", startedAt: Date.now() };
 
-  const fnEnd = source.indexOf("export async function postUnitPostVerification", fnStart);
-  const section = source.slice(fnStart, fnEnd > fnStart ? fnEnd : undefined);
-  const rebuildIdx = section.indexOf('await runSafely("postUnit", "state-rebuild"');
-  const syncIdx = section.indexOf('await runSafely("postUnit", "worktree-sync"');
+    const result = await postUnitPreVerification({
+      s,
+      ctx: { ui: { notify() {} } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {},
+      updateProgressWidget: () => {},
+    }, { skipSettleDelay: true, skipWorktreeSync: true });
 
-  assert.ok(rebuildIdx > 0, "postUnitPreVerification should rebuild STATE.md after unit completion");
-  assert.ok(syncIdx > 0, "postUnitPreVerification should sync worktree state back to the project root");
-  assert.ok(
-    rebuildIdx < syncIdx,
-    "STATE.md rebuild should happen before worktree sync so synced state is fresh",
-  );
+    assert.equal(result, "continue");
+    const statePath = join(base, ".gsd", "STATE.md");
+    assert.equal(existsSync(statePath), true);
+    assert.ok(readFileSync(statePath, "utf-8").includes("M001"));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -12,14 +12,9 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { normalizeFilePath, checkFilePathConsistency } from '../pre-execution-checks.ts'
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'pre-execution-checks.ts'),
-  'utf-8',
-)
-
 describe('normalizeFilePath backtick stripping (#3649)', () => {
   it('strips backticks from file paths', () => {
     assert.equal(normalizeFilePath('`src/foo.ts`'), 'src/foo.ts')
@@ -58,31 +53,42 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
 })
 
 describe('checkFilePathConsistency checks task.inputs not task.files (#3626)', () => {
-  it('source uses only task.inputs in filesToCheck', () => {
-    // Verify the fix structurally: the spread should be [...task.inputs] only
-    const fnStart = src.indexOf('export function checkFilePathConsistency(')
-    assert.ok(fnStart !== -1, 'checkFilePathConsistency function must exist')
-
-    // Find the filesToCheck assignment
-    const filesToCheckLine = src.indexOf('filesToCheck', fnStart)
-    assert.ok(filesToCheckLine !== -1, 'filesToCheck assignment must exist')
-
-    // Extract the line
-    const lineEnd = src.indexOf('\n', filesToCheckLine)
-    const line = src.slice(filesToCheckLine, lineEnd)
-
-    // Must include task.inputs
-    assert.ok(
-      line.includes('task.inputs'),
-      'filesToCheck must reference task.inputs',
-    )
+  it('ignores missing task.files entries that are only likely outputs', () => {
+    const task = {
+      milestone_id: 'M001',
+      slice_id: 'S01',
+      id: 'T01',
+      title: 'Create missing file',
+      status: 'pending',
+      one_liner: '',
+      narrative: '',
+      verification_result: '',
+      duration: '',
+      completed_at: null,
+      blocker_discovered: false,
+      deviations: '',
+      known_issues: '',
+      key_files: [],
+      key_decisions: [],
+      full_summary_md: '',
+      description: '',
+      estimate: '',
+      files: ['src/new-file.ts'],
+      verify: '',
+      inputs: [],
+      expected_output: ['src/new-file.ts'],
+      observability_impact: '',
+      full_plan_md: '',
+      sequence: 0,
+    }
 
-    // Must NOT include task.files
-    assert.ok(
-      !line.includes('task.files'),
-      'filesToCheck must NOT reference task.files — files likely touched include ' +
-        'files the task will create, so they do not need to pre-exist',
-    )
+    const tmp = resolve(process.cwd(), '.tmp-pre-exec-files-ignore')
+    try {
+      mkdirSync(tmp, { recursive: true })
+      assert.deepEqual(checkFilePathConsistency([task as any], tmp), [])
+    } finally {
+      rmSync(tmp, { recursive: true, force: true })
+    }
   })
 })
 

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for pre-execution validation checks.
+
 /**
  * pre-execution-checks.test.ts — Unit tests for pre-execution validation checks.
  *
@@ -1542,6 +1545,27 @@ describe("checkFilePathConsistency directory inputs (#4446)", () => {
     assert.equal(results[0].blocking, true);
   });
 
+  test("runtime directory annotation is skipped as a pre-execution file dependency", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-dir-runtime-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        inputs: ["entries/ directory (runtime)"],
+        expected_output: ["src/commands/delete.ts", "src/index.ts"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.deepEqual(
+      results,
+      [],
+      "Runtime-only directory inputs are created during command execution, not required before the task starts",
+    );
+  });
+
   test("tilde-prefixed input is matched against $HOME, not the project basePath", (t) => {
     const fakeHome = join(tmpdir(), `pre-exec-tilde-home-${Date.now()}`);
     const projectDir = join(tmpdir(), `pre-exec-tilde-proj-${Date.now()}`);
@@ -1597,6 +1621,20 @@ describe("checkTaskOrdering directory inputs (#4446)", () => {
       "Directory reference should not be treated as reading a file created later",
     );
   });
+
+  test("runtime directory annotation does not produce an ordering violation", () => {
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["entries/ directory (runtime)"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.deepEqual(results, []);
+  });
 });
 
 // ─── Regression Tests: checkTaskOrdering false positive for pre-execution refs (#4071) ──
@@ -1781,7 +1819,7 @@ describe("checkFilePathConsistency completed-task output exemption (#4071)", ()
     );
   });
 
-  test("pending task at higher index still causes a missing-file error", (t) => {
+  test("pending task at higher index does NOT cause a duplicate consistency error (ordering check handles it)", (t) => {
     const tempDir = join(tmpdir(), `pre-exec-fc-pending-${Date.now()}`);
     mkdirSync(tempDir, { recursive: true });
     t.after(() => rmSync(tempDir, { recursive: true, force: true }));
@@ -1803,14 +1841,16 @@ describe("checkFilePathConsistency completed-task output exemption (#4071)", ()
       }),
     ];
 
+    // checkFilePathConsistency suppresses the error here because checkTaskOrdering
+    // will fire a more precise "sequence violation" error for the same file.
+    // The combined output of runPreExecutionChecks still flags the issue — just
+    // once, via the ordering check, instead of twice.
     const results = checkFilePathConsistency(tasks, tempDir);
     assert.equal(
       results.length,
-      1,
-      "pending task at higher index must still be flagged — the file is not available yet",
+      0,
+      "consistency check must not duplicate what the ordering check already reports",
     );
-    assert.equal(results[0].blocking, true);
-    assert.equal(results[0].target, "artifacts/output.json");
   });
 });
 

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

@@ -12,32 +12,30 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { syncWorktreeStateBack } from "../auto-worktree.ts";
 
-test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
-  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const src = readFileSync(srcPath, "utf-8");
+test("#2684: syncWorktreeStateBack does not overwrite project PREFERENCES.md", () => {
+  const mainBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-main-"));
+  const wtBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-worktree-"));
+  const mainGsd = join(mainBase, ".gsd");
+  const wtGsd = join(wtBase, ".gsd");
+  mkdirSync(mainGsd, { recursive: true });
+  mkdirSync(wtGsd, { recursive: true });
 
-  const constIdx = src.indexOf("ROOT_STATE_FILES");
-  assert.ok(constIdx !== -1, "ROOT_STATE_FILES constant exists");
+  try {
+    const authoritative = "---\nversion: 1\n---\n\nmode: team\n";
+    writeFileSync(join(mainGsd, "PREFERENCES.md"), authoritative);
+    writeFileSync(join(wtGsd, "PREFERENCES.md"), "---\nversion: 1\n---\n\nmode: solo\n");
 
-  const arrayStart = src.indexOf("[", constIdx);
-  const arrayEnd = src.indexOf("] as const", arrayStart);
-  const block = src.slice(arrayStart, arrayEnd);
+    const result = syncWorktreeStateBack(mainBase, wtBase, "M001");
 
-  // Project preferences must NOT be in ROOT_STATE_FILES — they are handled separately
-  // in syncGsdStateToWorktree() (forward-only, additive). Including it in
-  // ROOT_STATE_FILES would cause syncWorktreeStateBack() to overwrite the
-  // authoritative project root copy (#2684).
-  const entries = block.split("\n")
-    .map(l => l.trim())
-    .filter(l => l.startsWith('"') && l.includes(".md"));
-  const hasPrefs = entries.some(
-    l => l.includes("PREFERENCES.md") || l.includes("preferences.md"),
-  );
-  assert.ok(
-    !hasPrefs,
-    "preferences files must NOT be in ROOT_STATE_FILES (back-sync would overwrite root)",
-  );
+    assert.equal(readFileSync(join(mainGsd, "PREFERENCES.md"), "utf-8"), authoritative);
+    assert.ok(!result.synced.includes("PREFERENCES.md"));
+    assert.ok(!result.synced.includes("preferences.md"));
+  } finally {
+    rmSync(mainBase, { recursive: true, force: true });
+    rmSync(wtBase, { recursive: true, force: true });
+  }
 });
 
 // Phase C: copyPlanningArtifacts was deleted. Worktrees no longer