@opengsd/gsd-pi 1.4.0-dev.5fc22c6f → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/repo-identity.ts

@@ -355,6 +355,23 @@ export function externalProjectsRoot(): string {
   return join(base, "projects");
 }
 
+/**
+ * Check whether this project already has authoritative external state.
+ *
+ * Used by legacy `.gsd/` migration to avoid re-copying a re-materialized local
+ * directory over newer state when an already-migrated symlink was replaced.
+ */
+export function externalStateAlreadyExistsForProject(basePath: string): boolean {
+  const base = process.env.GSD_STATE_DIR || gsdHome();
+  const computedPath = join(base, "projects", repoIdentity(basePath));
+  if (hasProjectState(computedPath)) return true;
+
+  const markerId = readGsdIdMarker(resolveGitRoot(basePath));
+  if (!markerId) return false;
+
+  return hasProjectState(join(base, "projects", markerId));
+}
+
 // ─── Numbered Variant Cleanup ────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/root-write-leak-guard.ts

@@ -65,11 +65,12 @@ export function captureRootDirtySnapshot(rootPath: string): RootDirtySnapshot {
   for (const line of status.split("\n")) {
     if (!line.trim()) continue;
     const code = line.slice(0, 2);
+    if (code !== "??") continue;
     const path = line.slice(3).replace(/^"|"$/g, "");
     if (!path || isRootRuntimePath(path)) continue;
     snapshot.set(path, {
       path,
-      status: code.trim() || code,
+      status: code,
       fingerprint: fileFingerprint(rootPath, path),
     });
   }
@@ -87,7 +88,7 @@ export function detectRootWriteLeak(input: {
   const leaked: RootDirtyEntry[] = [];
   for (const entry of after.values()) {
     const prior = input.before?.get(entry.path);
-    if (!prior || prior.status !== entry.status || prior.fingerprint !== entry.fingerprint) {
+    if (!prior || prior.fingerprint !== entry.fingerprint) {
       leaked.push(entry);
     }
   }

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

@@ -22,7 +22,7 @@ import {
   isSessionSwitchAbortGraceActive,
 } from "../auto/resolve.js";
 import { runUnit, shouldDeferUnitFailsafeTimeout } from "../auto/run-unit.js";
-import { scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
+import { consumeAutoWakeup, scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
 import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from "../unit-runtime.js";
 import { autoLoop as rawAutoLoop } from "../auto/loop.js";
 import { runPreDispatch } from "../auto/pre-dispatch.js";
@@ -67,6 +67,76 @@ async function drainMicrotasks(turns = 20): Promise<void> {
   }
 }
 
+function guardedExitMilestoneForTest(
+  merge: (milestoneId: string, opts: { merge: boolean }) => {
+    ok: boolean;
+    merged?: boolean;
+    codeFilesChanged?: boolean;
+    reason?: string;
+    cause?: unknown;
+  },
+) {
+  return (
+    milestoneId: string,
+    opts: {
+      merge: boolean;
+      guardedMerge?: {
+        projectRoot: string;
+        preflightCleanRoot: (
+          basePath: string,
+          milestoneId: string,
+          notify: (message: string, level: "info" | "warning" | "error") => void,
+        ) => { blocked?: boolean; blockedReason?: string; stashPushed: boolean; stashMarker?: string };
+        postflightPopStash: (
+          basePath: string,
+          milestoneId: string,
+          stashMarker: string | undefined,
+          notify: (message: string, level: "info" | "warning" | "error") => void,
+        ) => { needsManualRecovery?: boolean };
+      };
+    },
+    ctx?: { notify: (message: string, level: "info" | "warning" | "error") => void },
+  ) => {
+    const notify = ctx?.notify ?? (() => {});
+    const guard = opts.guardedMerge;
+    if (opts.merge && guard) {
+      const preflight = guard.preflightCleanRoot(guard.projectRoot, milestoneId, notify);
+      if (preflight.blocked) {
+        return {
+          ok: false,
+          reason: preflight.blockedReason?.startsWith("unmerged-conflicts")
+            ? "preflight-unmerged-conflicts"
+            : "preflight-dirty-overlap",
+        };
+      }
+
+      const mergeResult = merge(milestoneId, { merge: true });
+      const postflight = preflight.stashPushed
+        ? guard.postflightPopStash(
+            guard.projectRoot,
+            milestoneId,
+            preflight.stashMarker,
+            notify,
+          )
+        : undefined;
+
+      if (!mergeResult.ok) {
+        return {
+          ok: false,
+          reason: mergeResult.reason === "merge-conflict" ? "merge-conflict" : "merge-failed",
+          cause: mergeResult.cause,
+          postflight,
+        };
+      }
+      if (postflight?.needsManualRecovery) {
+        return { ok: false, reason: "postflight-stash-restore-failed", postflight };
+      }
+      return mergeResult;
+    }
+    return merge(milestoneId, opts);
+  };
+}
+
 async function waitForMicrotasks(
   condition: () => boolean,
   label: string,
@@ -482,6 +552,62 @@ test("runUnit honors ScheduleWakeup by continuing the same unit session", async
   assert.equal(pi.calls.length, 2);
 });
 
+test("runUnit clears scheduled wakeups when the unit is cancelled", async () => {
+  _resetPendingResolve();
+  _resetAutoWakeupsForTest();
+
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession();
+
+  const resultPromise = runUnit(
+    ctx,
+    pi,
+    s,
+    "execute-task",
+    "M001/S01/T02",
+    "submit external job",
+  );
+
+  await waitForMicrotasks(() => pi.calls.length === 1, "initial unit dispatch");
+  scheduleAutoWakeup({
+    basePath: s.basePath,
+    unitType: "execute-task",
+    unitId: "M001/S01/T02",
+    delayMs: 0,
+    prompt: "stale prompt from cancelled unit",
+    reason: "poll external job",
+    createdAt: Date.now(),
+  });
+  resolveAgentEndCancelled({
+    message: "Auto-mode paused",
+    category: "aborted",
+    isTransient: true,
+  });
+
+  const result = await resultPromise;
+  assert.equal(result.status, "cancelled");
+  assert.equal(
+    consumeAutoWakeup(s.basePath, "execute-task", "M001/S01/T02"),
+    null,
+    "cancelled units must not leave stale ScheduleWakeup prompts for later retries",
+  );
+});
+
 test("runUnit suppresses the global working-message loader for auto dashboard runs", async () => {
   _resetPendingResolve();
   const workingMessages: unknown[] = [];
@@ -1335,11 +1461,11 @@ function makeMockDeps(
     GitServiceImpl: class {} as any,
     lifecycle: {
       enterMilestone: () => ({ ok: true, mode: "worktree", path: "/tmp/project" }),
-      exitMilestone: (_mid: string, opts: { merge: boolean }) => ({
+      exitMilestone: guardedExitMilestoneForTest((_mid, opts) => ({
         ok: true,
         merged: opts.merge,
         codeFilesChanged: false,
-      }),
+      })),
     } as any,
     worktreeProjection: new WorktreeStateProjection(),
     postUnitPreVerification: async () => {
@@ -1762,10 +1888,10 @@ test("autoLoop marks transition merge complete before postflight recovery stop",
       enterMilestone: () => {
         assert.fail("must not enter the next milestone after postflight recovery fails");
       },
-      exitMilestone: (_mid: string, opts: { merge: boolean }) => {
+      exitMilestone: guardedExitMilestoneForTest((_mid, opts) => {
         if (opts.merge) mergeCalls += 1;
         return { ok: true, merged: opts.merge, codeFilesChanged: false };
-      },
+      }),
     } as any,
     stopAuto: async (_ctx, _pi, reason) => {
       deps.callLog.push("stopAuto");

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

@@ -61,6 +61,7 @@ async function runSuccessfulFinalize(s: AutoSession) {
     },
     stopAuto: async () => {},
     pauseAuto: async () => {},
+    checkpointWorkflowDatabase() {},
     updateProgressWidget() {},
     postUnitPreVerification: async () => "continue",
     runPostUnitVerification: async () => "continue",
@@ -410,9 +411,13 @@ test("runFinalize stops before merge when an isolated unit leaks app files into
   const notifications: Array<{ message: string; level?: string }> = [];
   const stopCalls: Array<{ reason?: string; preserve?: boolean }> = [];
   const mergeCalls: string[] = [];
+  const checkpointCalls: string[] = [];
   const result = await runFinalizeWithDeps(
     s,
     {
+      checkpointWorkflowDatabase() {
+        checkpointCalls.push("checkpoint");
+      },
       stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string, options?: { preserveCompletedMilestoneBranch?: boolean }) => {
         stopCalls.push({ reason, preserve: options?.preserveCompletedMilestoneBranch });
       },
@@ -438,16 +443,53 @@ test("runFinalize stops before merge when an isolated unit leaks app files into
 
   assert.equal(result.action, "break");
   assert.equal(result.reason, "root-write-leak");
+  assert.deepEqual(checkpointCalls, ["checkpoint"], "root-write leak should flush DB before stopAuto");
   assert.deepEqual(stopCalls, [{ reason: "Root-write leak during isolated auto-mode", preserve: true }]);
   assert.deepEqual(mergeCalls, [], "root-write leak must stop before merge preflight");
   const message = notifications.find((n) => n.level === "error")?.message ?? "";
   assert.match(message, /execute-task M001\/S01\/T01/);
   assert.match(message, /Project root:/);
   assert.match(message, /Expected worktree:/);
-  assert.match(message, /index\.html/);
+  assert.doesNotMatch(message, /index\.html/);
   assert.match(message, /tests\/verify-s09\.sh/);
 });
 
+test("runFinalize ignores tracked root artifact changes during isolated units", async (t) => {
+  const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-tracked-"));
+  const worktree = join(root, ".gsd", "worktrees", "M001");
+  t.after(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+  initRepo(root);
+  writeFileSync(join(root, "openapi.json"), "{}\n");
+  runGit(root, ["add", "openapi.json"]);
+  runGit(root, ["commit", "-m", "chore: add generated spec"]);
+  mkdirSync(worktree, { recursive: true });
+
+  const s = new AutoSession();
+  s.basePath = worktree;
+  s.originalBasePath = root;
+  s.currentMilestoneId = "M001";
+  s.rootWriteBaseline = captureRootDirtySnapshot(root);
+  s.currentUnit = {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: Date.now(),
+  };
+
+  writeFileSync(join(root, "openapi.json"), "{\"generated\":true}\n");
+
+  const stopCalls: string[] = [];
+  const result = await runFinalizeWithDeps(s, {
+    stopAuto: async (_ctx: unknown, _pi: unknown, reason?: string) => {
+      stopCalls.push(reason ?? "");
+    },
+  });
+
+  assert.equal(result.action, "next");
+  assert.deepEqual(stopCalls, []);
+});
+
 test("runFinalize allows root .gsd-only changes during isolated units", async (t) => {
   const root = mkdtempSync(join(tmpdir(), "gsd-root-leak-gsd-"));
   const worktree = join(root, ".gsd", "worktrees", "M001");

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

@@ -838,6 +838,60 @@ test("verifyExpectedArtifact plan-slice fails when a task plan file is missing (
   }
 });
 
+test("verifyExpectedArtifact accepts flat-phase plan-slice with embedded tasks and no task plan files", () => {
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  try {
+    const phaseDir = join(base, ".gsd", "phases", "01-test");
+    mkdirSync(join(phaseDir, "tasks"), { recursive: true });
+    writeFileSync(join(phaseDir, "01-01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "<tasks>",
+      "- [ ] **T01**: Implement feature _(1h)_",
+      "  - Files: `src/index.ts`",
+      "  - Verify: pnpm test",
+      "- [ ] **T02**: Write tests _(1h)_",
+      "</tasks>",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, true, "flat-phase embedded tasks should not require tasks/T##-PLAN.md files");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact plan-slice still verifies per-task files for legacy ## Tasks plan with a stray empty <tasks> block", () => {
+  const base = makeTmpBase();
+  try {
+    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
+    // Legacy layout: real tasks live in a "## Tasks" section with separate
+    // per-task PLAN files, but the plan also carries an empty <tasks></tasks>
+    // block. The empty block must NOT flip the plan into flat-phase mode and
+    // skip the per-task artifact checks.
+    const planContent = [
+      "# S01: Test Slice",
+      "",
+      "<tasks>",
+      "</tasks>",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: First task** `est:1h`",
+      "- [ ] **T02: Second task** `est:2h`",
+    ].join("\n");
+    writeFileSync(planPath, planContent);
+    // Only T01-PLAN.md exists; T02's artifact is missing.
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n\nDo the thing.");
+
+    const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+    assert.equal(result, false, "a stray <tasks> block must not skip per-task file verification for a legacy ## Tasks plan");
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", () => {
   const base = makeTmpBase();
   try {