gsd-pi 2.80.0-dev.2848d9009 → 2.80.0-dev.3065f7bfa

package/src/resources/extensions/gsd/tests/orphan-stash-audit.test.ts

@@ -0,0 +1,201 @@
+// GSD-2 + src/resources/extensions/gsd/tests/orphan-stash-audit.test.ts
+// Regression: orphaned gsd-preflight-stash entries from completed milestones
+// must be auto-applied at startup so the user's pre-merge work returns.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  auditOrphanedPreflightStashes,
+  _isAlreadyRestoredApplyError,
+} from "../orphan-stash-audit.js";
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_AUTHOR_NAME: "test",
+      GIT_AUTHOR_EMAIL: "test@example.com",
+      GIT_COMMITTER_NAME: "test",
+      GIT_COMMITTER_EMAIL: "test@example.com",
+    },
+  });
+}
+
+function pushPreflightStash(repo: string, milestoneId: string, fileName: string, content: string): string {
+  writeFileSync(join(repo, fileName), content);
+  const marker = `gsd-preflight-stash:${milestoneId}:42:1700000000000:abcd`;
+  git(repo, "stash", "push", "--include-untracked", "-m", `gsd-preflight-stash [${marker}]`);
+  return marker;
+}
+
+describe("auditOrphanedPreflightStashes", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "orphan-stash-audit-"));
+    git(repo, "init", "-q");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+  });
+
+  afterEach(() => {
+    if (repo && existsSync(repo)) {
+      rmSync(repo, { recursive: true, force: true });
+    }
+  });
+
+  test("returns empty result when there are no stashes", () => {
+    const result = auditOrphanedPreflightStashes(repo, () => true);
+    assert.deepEqual(result, { applied: [], warnings: [] });
+  });
+
+  test("applies an orphan preflight stash when its milestone is complete", () => {
+    pushPreflightStash(repo, "M002", "leftover.txt", "lost work\n");
+
+    // Verify the file is gone (stashed away) before the audit runs.
+    assert.equal(existsSync(join(repo, "leftover.txt")), false, "stash push must remove the file");
+
+    const result = auditOrphanedPreflightStashes(repo, (id) => id === "M002");
+
+    assert.equal(result.applied.length, 1, "expected exactly one stash applied");
+    assert.equal(result.applied[0].milestoneId, "M002");
+    assert.match(result.applied[0].stashRef, /^stash@\{\d+\}$/);
+    assert.equal(result.warnings.length, 0);
+
+    // The user's pre-merge content must be back in the working tree.
+    assert.equal(existsSync(join(repo, "leftover.txt")), true);
+    assert.equal(readFileSync(join(repo, "leftover.txt"), "utf-8"), "lost work\n");
+
+    // The stash entry must remain (apply, not pop) so the user has a backup.
+    const list = git(repo, "stash", "list");
+    assert.match(list, /gsd-preflight-stash:M002:/);
+  });
+
+  test("ignores stashes whose milestone is not complete", () => {
+    pushPreflightStash(repo, "M003", "wip.txt", "still-working\n");
+
+    const result = auditOrphanedPreflightStashes(repo, () => false);
+
+    assert.deepEqual(result, { applied: [], warnings: [] });
+    // File stays stashed.
+    assert.equal(existsSync(join(repo, "wip.txt")), false);
+  });
+
+  test("ignores non-gsd stash entries", () => {
+    writeFileSync(join(repo, "manual.txt"), "manual\n");
+    git(repo, "stash", "push", "--include-untracked", "-m", "user manual stash");
+
+    const result = auditOrphanedPreflightStashes(repo, () => true);
+
+    assert.deepEqual(result, { applied: [], warnings: [] });
+  });
+
+  test("collects a warning when the completion callback throws", () => {
+    pushPreflightStash(repo, "M004", "danger.txt", "boom\n");
+
+    const result = auditOrphanedPreflightStashes(repo, () => {
+      throw new Error("db unavailable");
+    });
+
+    assert.equal(result.applied.length, 0);
+    assert.equal(result.warnings.length, 1);
+    assert.match(result.warnings[0], /Could not determine completion status for M004/);
+    assert.match(result.warnings[0], /db unavailable/);
+  });
+
+  test("collects a warning when stash apply fails (conflicting working tree)", () => {
+    // Push a stash containing a change to seed.txt; then dirty seed.txt with
+    // a conflicting modification before the audit runs so apply fails.
+    writeFileSync(join(repo, "seed.txt"), "stashed\n");
+    const marker = `gsd-preflight-stash:M005:42:1700:zz`;
+    git(repo, "stash", "push", "-m", `gsd-preflight-stash [${marker}]`);
+
+    // Dirty the working tree so apply will conflict.
+    writeFileSync(join(repo, "seed.txt"), "conflicting modification\n");
+
+    const result = auditOrphanedPreflightStashes(repo, () => true);
+
+    assert.equal(result.applied.length, 0);
+    assert.equal(result.warnings.length, 1);
+    assert.match(result.warnings[0], /Could not apply orphaned preflight stash/);
+    assert.match(result.warnings[0], /M005/);
+    assert.match(result.warnings[0], /git stash apply/);
+
+    const list = git(repo, "stash", "list");
+    assert.match(list, /gsd-preflight-stash:M005:/);
+  });
+
+  test("returns empty result when basePath is not a git repo", () => {
+    const nonRepo = mkdtempSync(join(tmpdir(), "orphan-stash-not-repo-"));
+    try {
+      const result = auditOrphanedPreflightStashes(nonRepo, () => true);
+      assert.deepEqual(result, { applied: [], warnings: [] });
+    } finally {
+      rmSync(nonRepo, { recursive: true, force: true });
+    }
+  });
+
+  test("repeat run is a silent no-op when files were already restored (peer-review regression)", () => {
+    // Codex peer review caught: the first audit applies the stash and the
+    // file appears in the working tree. The stash entry stays in `git stash
+    // list` (apply, not pop). On the next audit, `git stash apply` exits
+    // non-zero with "already exists, no checkout" because the untracked file
+    // already exists. The original code surfaced that as a warning every
+    // startup. The fix detects that error and treats it as the idempotent
+    // steady state.
+    pushPreflightStash(repo, "M002", "leftover.txt", "lost work\n");
+
+    const first = auditOrphanedPreflightStashes(repo, () => true);
+    assert.equal(first.applied.length, 1, "first run applies");
+    assert.equal(first.warnings.length, 0);
+
+    const second = auditOrphanedPreflightStashes(repo, () => true);
+    assert.equal(second.applied.length, 0, "second run skips silently");
+    assert.equal(
+      second.warnings.length,
+      0,
+      "second run must NOT warn — files are already restored from first run",
+    );
+  });
+});
+
+test("_isAlreadyRestoredApplyError detects the git stash apply already-exists error", () => {
+  // Real-world stderr produced by git when an --include-untracked stash is
+  // applied while the file already exists in the working tree.
+  const realError: { stderr: string } = {
+    stderr: "leftover.txt already exists, no checkout\nCould not restore untracked files from stash entry\n",
+  };
+  assert.equal(_isAlreadyRestoredApplyError(realError), true);
+
+  // Buffer-form stderr (when encoding is not set explicitly).
+  const bufErr = { stderr: Buffer.from("foo.ts already exists, no checkout\n") };
+  assert.equal(_isAlreadyRestoredApplyError(bufErr), true);
+
+  // Some Node versions surface the message in err.message.
+  const messageOnly = new Error("Command failed: git stash apply\nfoo.ts already exists, no checkout");
+  assert.equal(_isAlreadyRestoredApplyError(messageOnly), true);
+
+  // Unrelated errors must NOT be classified as already-restored.
+  const realConflict: { stderr: string } = {
+    stderr: "CONFLICT (content): Merge conflict in lib/models.ts\n",
+  };
+  assert.equal(_isAlreadyRestoredApplyError(realConflict), false);
+
+  // Defensive null/undefined handling.
+  assert.equal(_isAlreadyRestoredApplyError(null), false);
+  assert.equal(_isAlreadyRestoredApplyError(undefined), false);
+  assert.equal(_isAlreadyRestoredApplyError("not an error"), false);
+  assert.equal(_isAlreadyRestoredApplyError({}), false);
+});

package/src/resources/extensions/gsd/tests/parallel-orchestrator-fast-forward.test.ts

@@ -0,0 +1,113 @@
+// GSD-2 + src/resources/extensions/gsd/tests/parallel-orchestrator-fast-forward.test.ts
+// Regression: parallel-orchestrator's `_createMilestoneWorktree` must
+// fast-forward a reused milestone branch onto integration before creating
+// the worktree, matching the behavior added to the auto-mode path in
+// commit 8996cb68e (#5549 post-merge audit, R3).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { _createMilestoneWorktree } from "../parallel-orchestrator.js";
+
+const NO_PROMPT_ENV = {
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_AUTHOR_NAME: "test",
+  GIT_AUTHOR_EMAIL: "test@example.com",
+  GIT_COMMITTER_NAME: "test",
+  GIT_COMMITTER_EMAIL: "test@example.com",
+};
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: NO_PROMPT_ENV,
+  });
+}
+
+function rev(cwd: string, ref: string): string {
+  return git(cwd, "rev-parse", ref).trim();
+}
+
+describe("_createMilestoneWorktree fast-forwards reused milestone branches (#5549 R3)", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "parallel-orch-ff-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+    // Minimal .gsd/ structure so syncGsdStateToWorktree doesn't crash on a
+    // bare repo. We don't care if it copies anything — only that the FF ran.
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("reused milestone branch behind main is fast-forwarded before worktree creation", () => {
+    // Worker N drained M001 in a previous run, leaving milestone/M001 forked
+    // from old main. Worker N+1 picks up M002 — but the milestone/M002 branch
+    // was created from old main in a sibling run, so it's now N commits behind.
+    git(repo, "branch", "milestone/M002");
+    const m002Initial = rev(repo, "milestone/M002");
+
+    writeFileSync(join(repo, "seed.txt"), "main moved forward\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main advanced");
+    const mainTip = rev(repo, "main");
+
+    assert.notEqual(m002Initial, mainTip, "main must be ahead before the test");
+
+    // _createMilestoneWorktree may throw inside createWorktree/syncGsdStateToWorktree
+    // (e.g. if the worktree-manager has stricter requirements than this minimal
+    // repo provides). The fast-forward runs BEFORE those calls, so the branch
+    // ref should have moved regardless. Catch and assert on observable state.
+    try {
+      _createMilestoneWorktree(repo, "M002");
+    } catch {
+      // Fine — we only care that FF executed.
+    }
+
+    assert.equal(
+      rev(repo, "milestone/M002"),
+      mainTip,
+      "milestone/M002 must be fast-forwarded to main's tip before worktree is built",
+    );
+  });
+
+  test("diverged milestone branch is NOT touched (would lose work)", () => {
+    git(repo, "checkout", "-q", "-b", "milestone/M002");
+    writeFileSync(join(repo, "wip.txt"), "milestone-only work\n");
+    git(repo, "add", "wip.txt");
+    git(repo, "commit", "-q", "-m", "M002 work");
+    const m002Tip = rev(repo, "milestone/M002");
+
+    git(repo, "checkout", "-q", "main");
+    writeFileSync(join(repo, "seed.txt"), "main moved forward\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main advanced");
+
+    try {
+      _createMilestoneWorktree(repo, "M002");
+    } catch {
+      // ignored
+    }
+
+    assert.equal(
+      rev(repo, "milestone/M002"),
+      m002Tip,
+      "diverged milestone branch must NOT be touched — would lose committed work",
+    );
+  });
+});

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/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");
   });
 });