gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -33,43 +33,6 @@ import {
   teardownAutoWorktree,
 } from "../auto-worktree.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
-import {
-  WorktreeLifecycle,
-  type WorktreeLifecycleDeps,
-  type NotifyCtx,
-} from "../worktree-lifecycle.ts";
-import { WorktreeStateProjection } from "../worktree-state-projection.ts";
-import { resolveWorktreeProjectRoot } from "../worktree-root.ts";
-import { AutoSession } from "../auto/session.ts";
-
-// Test-local: LegacyTestDeps had three fields Lifecycle does not need
-// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
-// Permit them in test fixtures so existing override patterns keep working —
-// Lifecycle ignores the extras via structural typing.
-type LegacyTestDeps = WorktreeLifecycleDeps & {
-  shouldUseWorktreeIsolation?: () => boolean;
-  syncWorktreeStateBack?: (
-    mainBasePath: string,
-    worktreePath: string,
-    milestoneId: string,
-  ) => { synced: string[] };
-  captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
-};
-
-/** Shim factory preserving the legacy WorktreeResolver throw shape for tests. */
-function makeResolver(s: AutoSession, deps: LegacyTestDeps) {
-  const lifecycle = new WorktreeLifecycle(s, deps);
-  return {
-    get workPath(): string { return s.basePath; },
-    get projectRoot(): string {
-      return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
-    },
-    mergeAndExit: (mid: string, ctx: NotifyCtx) => {
-      const r = lifecycle.exitMilestone(mid, { merge: true }, ctx);
-      if (!r.ok && r.cause instanceof Error) throw r.cause;
-    },
-  };
-}
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -91,97 +54,6 @@ function createTempRepo(t: { after: (fn: () => void) => void }): string {
   return dir;
 }
 
-function makeSession(overrides?: Partial<{ basePath: string; originalBasePath: string }>): AutoSession {
-  const s = new AutoSession();
-  s.basePath = overrides?.basePath ?? "/project";
-  s.originalBasePath = overrides?.originalBasePath ?? "/project";
-  return s;
-}
-
-interface CallLog { fn: string; args: unknown[] }
-
-function makeDeps(overrides?: Partial<LegacyTestDeps>): LegacyTestDeps & { calls: CallLog[] } {
-  const calls: CallLog[] = [];
-
-  const deps: LegacyTestDeps & { calls: CallLog[] } = {
-    calls,
-    isInAutoWorktree: (basePath: string) => {
-      calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-      return basePath.includes("worktrees");
-    },
-    shouldUseWorktreeIsolation: () => true,
-    getIsolationMode: () => "worktree",
-    mergeMilestoneToMain: (basePath: string, milestoneId: string, roadmapContent: string) => {
-      calls.push({ fn: "mergeMilestoneToMain", args: [basePath, milestoneId, roadmapContent] });
-      return { pushed: false, codeFilesChanged: true };
-    },
-    syncWorktreeStateBack: (mainBasePath: string, worktreePath: string, milestoneId: string) => {
-      calls.push({ fn: "syncWorktreeStateBack", args: [mainBasePath, worktreePath, milestoneId] });
-      return { synced: [] };
-    },
-    teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-      calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-    },
-    createAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "createAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    enterAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "enterAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    getAutoWorktreePath: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "getAutoWorktreePath", args: [basePath, milestoneId] });
-      return null;
-    },
-    autoCommitCurrentBranch: (basePath: string, reason: string, milestoneId: string) => {
-      calls.push({ fn: "autoCommitCurrentBranch", args: [basePath, reason, milestoneId] });
-    },
-    getCurrentBranch: (basePath: string) => {
-      calls.push({ fn: "getCurrentBranch", args: [basePath] });
-      return "main";
-    },
-    checkoutBranch: (basePath: string, branch: string) => {
-      calls.push({ fn: "checkoutBranch", args: [basePath, branch] });
-    },
-    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
-    resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-      calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-      return null;
-    },
-    readFileSync: (path: string, _enc: string) => {
-      calls.push({ fn: "readFileSync", args: [path] });
-      return "# Roadmap\n";
-    },
-    GitServiceImpl: class {
-      constructor(_basePath: string, _gitConfig: unknown) {}
-    } as unknown as LegacyTestDeps["GitServiceImpl"],
-    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
-    invalidateAllCaches: () => { calls.push({ fn: "invalidateAllCaches", args: [] }); },
-    captureIntegrationBranch: (_basePath: string, _mid: string | undefined) => {},
-    enterBranchModeForMilestone: (_basePath: string, _milestoneId: string) => {},
-    worktreeProjection: new WorktreeStateProjection(),
-    ...overrides,
-  };
-
-  if (overrides) {
-    for (const [key, val] of Object.entries(overrides)) {
-      if (key !== "calls") (deps as unknown as Record<string, unknown>)[key] = val;
-    }
-  }
-  return deps;
-}
-
-function makeNotifyCtx(): NotifyCtx & { messages: Array<{ msg: string; level?: string }> } {
-  const messages: Array<{ msg: string; level?: string }> = [];
-  return {
-    messages,
-    notify: (msg: string, level?: "info" | "warning" | "error" | "success") => {
-      messages.push({ msg, level });
-    },
-  };
-}
-
 // ─── Suite 1: getAutoWorktreeOriginalBase() returns realpath-canonical path ──
 
 describe("getAutoWorktreeOriginalBase() is realpath-normalised", () => {
@@ -273,92 +145,15 @@ describe("normalizeWorktreePathForCompare equalises canonical vs non-canonical f
 // resolveMilestoneFile call against the "worktree" path that is actually the
 // same directory). The new code correctly skips the fallback.
 
-describe("WorktreeResolver: roadmap-fallback skipped when basePath is same physical path as originalBase", () => {
-  test("with trailing-slash basePath equal to originalBase: resolveMilestoneFile called once", () => {
-    // originalBase is canonical (as returned by workspace registry)
-    const canonicalBase = "/tmp/m5-test-project";
-    // s.basePath has a trailing slash — same physical dir, non-canonical string
-    const trailingSlashBase = canonicalBase + "/";
-
-    const s = makeSession({
-      basePath: trailingSlashBase,
-      originalBasePath: canonicalBase,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      // isInAutoWorktree: basePath has trailing slash but is NOT a worktree
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return false;
-      },
-      // resolveMilestoneFile always returns null (no roadmap found)
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null;
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-
-    // Override calls ref so we can inspect it directly
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    // mergeAndExit → _mergeWorktreeMode
-    // originalBase = s.originalBasePath = canonicalBase
-    // s.basePath = trailingSlashBase — physically same as canonicalBase
-    // Post-fix: isSamePath(trailingSlashBase, canonicalBase) is true
-    //   → roadmap fallback branch is skipped (resolveMilestoneFile called once)
-    // Pre-fix (bug): trailingSlashBase !== canonicalBase → fallback entered
-    //   → resolveMilestoneFile called twice
-
-    resolver.mergeAndExit("M001", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 1,
-      "resolveMilestoneFile must be called exactly once — fallback should be skipped when " +
-      "s.basePath is the same physical path as originalBase (isSamePath fix)");
-  });
-
-  test("with genuinely different basePath (inside worktree): resolveMilestoneFile called twice", () => {
-    // originalBase is the project root
-    const projectRoot = "/tmp/m5-test-project";
-    // s.basePath is inside a worktree — a physically different path
-    const worktreePath = projectRoot + "/.gsd/worktrees/M002";
-
-    const s = makeSession({
-      basePath: worktreePath,
-      originalBasePath: projectRoot,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return basePath.includes("worktrees");
-      },
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null; // no roadmap in either location
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = makeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    resolver.mergeAndExit("M002", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 2,
-      "resolveMilestoneFile must be called twice when basePath is a genuine worktree path " +
-      "(fallback should run for different physical paths)");
-  });
-});
+// ADR-016 phase 2 / C2 + C3 (#5625, #5626): the prior two tests in this
+// suite asserted call counts on `deps.resolveMilestoneFile` /
+// `deps.isInAutoWorktree` / `deps.teardownAutoWorktree` to verify that the
+// roadmap-fallback branch was skipped when basePath was a non-canonical
+// form of originalBase (trailing slash). After C2/C3 those fields are
+// inlined into worktree-lifecycle.ts as direct imports — the mocks no
+// longer fire and the call-count assertions test nothing meaningful. The
+// underlying invariant (isSamePathPhysical normalises trailing slashes,
+// canonical/non-canonical pairs, and case differences) is preserved
+// inside worktree-lifecycle.ts and covered indirectly by the merge-area
+// integration tests, which exercise real worktree merges where the
+// fallback choice matters.

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

@@ -243,7 +243,7 @@ describe("auditOrphanedMilestoneBranches", () => {
     );
   });
 
-  test("handles milestone in DB but no branch (no-op)", () => {
+  test("milestone in DB, no branch, no worktree dir → no-op", () => {
     insertMilestone({ id: "M001", title: "Test", status: "complete" });
 
     const result = auditOrphanedMilestoneBranches(dir, "worktree");
@@ -251,4 +251,124 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.deepStrictEqual(result.recovered, []);
     assert.deepStrictEqual(result.warnings, []);
   });
+
+  test("#5879 — cleans orphaned worktree dir for complete milestone whose branch was already deleted", () => {
+    // Reproduces the postflight-stash-restore-failed scenario:
+    // 1. An earlier audit deleted milestone/M001 (merged + complete).
+    // 2. The worktree dir cleanup failed silently (logWarning only).
+    // 3. On the next startup the branch is gone, so the existing branch-keyed
+    //    loop is invisible to the orphan dir. Without the second pass, the
+    //    directory lives forever.
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "stranded from a prior session\n");
+
+    // No milestone/M001 branch — already deleted on a previous run.
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.equal(branches, "", "test fixture: branch should not exist");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.ok(
+      result.recovered.some((r) => r.includes("M001") && r.includes("branch already deleted")),
+      `should report branch-less orphan cleanup; got: ${JSON.stringify(result.recovered)}`,
+    );
+    assert.ok(!existsSync(wtDir), "branch-less orphan worktree dir should be removed");
+  });
+
+  test("#5879 — branch list failure still cleans complete orphan only after branch absence is verified", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "stranded from a prior session\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree", {
+      branchList: () => {
+        throw new Error("branch list failed");
+      },
+      branchExists: (_basePath, branch) => {
+        assert.equal(branch, "milestone/M001");
+        return false;
+      },
+    });
+
+    assert.ok(
+      result.recovered.some((r) => r.includes("M001") && r.includes("branch already deleted")),
+      `should report verified branch-less orphan cleanup; got: ${JSON.stringify(result.recovered)}`,
+    );
+    assert.ok(!existsSync(wtDir), "verified branch-less orphan worktree dir should be removed");
+  });
+
+  test("#5879 — branch list failure preserves complete worktree when branch still exists", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "live-work.txt"), "do not delete\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree", {
+      branchList: () => {
+        throw new Error("branch list failed");
+      },
+      branchExists: (_basePath, branch) => {
+        assert.equal(branch, "milestone/M001");
+        return true;
+      },
+    });
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "worktree dir must be preserved when branch existence is verified");
+  });
+
+  test("#5879 — skips branch-less orphan for milestone that is not complete", () => {
+    // Defensive: only `complete` milestones get the branch-less cleanup. An
+    // `active` milestone with no branch but a worktree dir is a different
+    // state (probably mid-recovery) and should not be silently wiped.
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "live-work.txt"), "do not delete\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "active milestone worktree dir must be preserved");
+  });
+
+  test("#5879 — branch list failure does not delete worktree for milestone that is not complete", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "live-work.txt"), "do not delete\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree", {
+      branchList: () => {
+        throw new Error("branch list failed");
+      },
+      branchExists: () => {
+        throw new Error("branchExists should not be called for active milestones");
+      },
+    });
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "active milestone worktree dir must be preserved");
+  });
+
+  test("#5879 — skips branch-less orphan in 'none' isolation mode", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "stranded\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "none");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "'none' mode must not touch worktree dirs");
+  });
 });

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -1,11 +1,19 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for parallel monitor overlay rendering and input handling.
+
 import { describe, it } from "node:test";
-import assert from "node:assert";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
 
-/**
- * Basic tests for the parallel monitor overlay data helpers.
- * The overlay is primarily a rendering component that reads existing
- * status files — these tests verify the helper logic in isolation.
- */
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
 
 describe("parallel-monitor-overlay", () => {
   it("progressBar generates correct width", async () => {
@@ -37,6 +45,7 @@ describe("parallel-monitor-overlay", () => {
     const lines = overlay.render(80);
     assert.ok(Array.isArray(lines), "render should return an array");
     assert.ok(lines.length > 0, "render should return at least one line");
+    assertLinesFit(lines, 80);
 
     // Should contain header text
     const joined = lines.join("\n");
@@ -79,4 +88,27 @@ describe("parallel-monitor-overlay", () => {
     assert.equal((overlay as any).scrollOffset, 0, "empty overlays clamp scroll to zero");
     overlay.dispose();
   });
+
+  it("ParallelMonitorOverlay empty state fits narrow and wide widths", async () => {
+    const mod = await import("../parallel-monitor-overlay.js");
+
+    const mockTui = { requestRender: () => {} };
+    const mockTheme = {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const overlay = new mod.ParallelMonitorOverlay(
+      mockTui,
+      mockTheme as any,
+      () => {},
+      "/nonexistent/path",
+    );
+
+    for (const width of [40, 80, 120]) {
+      assertLinesFit(overlay.render(width), width);
+      overlay.invalidate();
+    }
+
+    overlay.dispose();
+  });
 });

package/src/resources/extensions/gsd/tests/park-db-sync.test.ts

@@ -7,7 +7,7 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -48,6 +48,60 @@ test("parkMilestone updates DB status to 'parked' (#2694)", () => {
   }
 });
 
+test("parkMilestone ignores blocked SUMMARY.md when DB milestone is active (#5828)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
+      [
+        "---",
+        "status: closeout_blocked",
+        "---",
+        "",
+        "# M001 Summary",
+        "",
+        "Completion was not persisted.",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const parked = parkMilestone(base, "M001", "test");
+
+    assert.ok(parked, "active DB row should allow parking despite a blocked SUMMARY.md");
+    assert.ok(
+      existsSync(join(base, ".gsd", "milestones", "M001", "M001-PARKED.md")),
+      "PARKED.md should be written",
+    );
+    assert.equal(getMilestone("M001")!.status, "parked", "DB status should be parked");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("parkMilestone refuses DB-complete milestones (#5828)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const parked = parkMilestone(base, "M001", "test");
+
+    assert.equal(parked, false, "complete DB row should not be parkable");
+    assert.equal(
+      existsSync(join(base, ".gsd", "milestones", "M001", "M001-PARKED.md")),
+      false,
+      "PARKED.md should not be written",
+    );
+    assert.equal(getMilestone("M001")!.status, "complete", "DB status should remain complete");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("unparkMilestone updates DB status to 'active' (#2694)", () => {
   const base = createBase();
   try {

package/src/resources/extensions/gsd/tests/pending-autostart-scope.test.ts

@@ -11,6 +11,7 @@ import {
   clearPendingAutoStart,
   _getPendingAutoStart,
 } from "../guided-flow.ts";
+import type { PendingAutoStartInput } from "../pending-auto-start.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -20,6 +21,15 @@ function makeProjectDir(): string {
   return dir;
 }
 
+function pendingInput(basePath: string, milestoneId: string) {
+  return {
+    basePath,
+    milestoneId,
+    ctx: { ui: { notify: () => undefined } } as any,
+    pi: { sendMessage: () => undefined } as any,
+  };
+}
+
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("pendingAutoStart scope pinning (C1)", () => {
@@ -38,7 +48,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
   });
 
   test("setPendingAutoStart stores a scope whose paths derive from the basePath at reservation time", () => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry, "entry should exist");
@@ -54,8 +64,22 @@ describe("pendingAutoStart scope pinning (C1)", () => {
     assert.equal(entry.scope.stateFile(), expectedState);
   });
 
+  test("setPendingAutoStart rejects entries without ctx and pi before storing them", () => {
+    assert.throws(
+      () =>
+        setPendingAutoStart(base, {
+          basePath: base,
+          milestoneId: "M001",
+        } as PendingAutoStartInput),
+      /requires ctx and pi/,
+      "pending entries must include the handles later used by auto-start recovery",
+    );
+
+    assert.equal(_getPendingAutoStart(base), null);
+  });
+
   test("scope paths are unaffected by process.chdir after reservation", (t) => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M002" });
+    setPendingAutoStart(base, pendingInput(base, "M002"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry, "entry should exist");
@@ -82,7 +106,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
 
   test("scope identityKey matches the realpath of the original basePath even with trailing slash", () => {
     const baseWithSlash = base + "/";
-    setPendingAutoStart(base, { basePath: baseWithSlash, milestoneId: "M003" });
+    setPendingAutoStart(base, pendingInput(baseWithSlash, "M003"));
 
     const entry = _getPendingAutoStart(base);
     assert.ok(entry, "entry should exist");
@@ -96,7 +120,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
   });
 
   test("clearPendingAutoStart removes the entry", () => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     const before = _getPendingAutoStart(base);
     assert.ok(before, "entry should exist before clear");
@@ -108,7 +132,7 @@ describe("pendingAutoStart scope pinning (C1)", () => {
   });
 
   test("_getPendingAutoStart with no basePath argument returns the sole entry", () => {
-    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+    setPendingAutoStart(base, pendingInput(base, "M001"));
 
     // No argument — should return the sole entry
     const entry = _getPendingAutoStart();