@opengsd/gsd-pi 1.3.0 → 1.4.0

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

@@ -3358,6 +3358,110 @@ test("autoLoop handles dispatch skip action by continuing", async (t) => {
   );
 });
 
+test("autoLoop pauses after repeated orchestration skips", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return { action: "skip" as const, reason: "gate-marker-drift" as const };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  const dispatchCalls = deps.callLog.filter((c) => c === "resolveDispatch");
+  assert.equal(dispatchCalls.length, 3, "persistent orchestration skips should pause before the runaway cap");
+  assert.equal(deps.callLog.includes("pauseAuto"), true, "persistent orchestration skips should pause auto-mode");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "persistent orchestration skips should not hit the max-iteration stop");
+});
+
+test("autoLoop does not pause on repeated idempotent advance skips", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({
+    currentMilestoneId: "M001",
+    orchestration: {
+      start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      advance: async () => {
+        advanceCalls++;
+        if (advanceCalls >= 5) s.active = false;
+        return { kind: "skipped" as const, reason: "idempotent advance: unit already active" };
+      },
+      completeActiveUnit: async () => {},
+      retryActiveUnit: async () => {},
+      resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      stop: async (reason: string) => ({ kind: "stopped" as const, reason }),
+      getStatus: () => ({ phase: "running" as const, transitionCount: 1 }),
+    } satisfies AutoOrchestrationModule,
+  });
+
+  const deps = makeMockDeps();
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.ok(advanceCalls >= 5, "loop should complete multiple idempotent skips before deactivating");
+  assert.equal(deps.callLog.includes("pauseAuto"), false, "idempotent advance skips must not trigger the consecutive-skip pause");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "idempotent advance skips must not reach the max-iteration stop");
+});
+
+test("autoLoop skip streak survives sidecar iteration without resetting", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({ currentMilestoneId: "M001" });
+  s.orchestration = {
+    start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+    advance: async () => {
+      advanceCalls++;
+      if (advanceCalls === 2) {
+        // Inject a sidecar so the *next* iteration takes the sidecar path rather than
+        // calling orchestration.advance() — which must NOT reset the skip streak.
+        s.sidecarQueue.push({
+          kind: "hook" as const,
+          unitType: "run-uat",
+          unitId: "M001/S01/T01/review",
+          prompt: "review",
+        });
+      }
+      return { kind: "skipped" as const, reason: "gate-marker-drift" };
+    },
+    completeActiveUnit: async () => {},
+    retryActiveUnit: async () => {},
+    resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+    stop: async (reason: string) => ({ kind: "stopped" as const, reason }),
+    getStatus: () => ({ phase: "running" as const, transitionCount: advanceCalls }),
+  } satisfies AutoOrchestrationModule;
+
+  const deps = makeMockDeps();
+  const loopPromise = autoLoop(ctx, pi, s, deps);
+
+  // Wait for the sidecar unit to call newSession (pi.calls grows)
+  await waitForMicrotasks(() => pi.calls.length >= 1, "sidecar unit to start");
+  resolveAgentEnd(makeEvent()); // resolve the sidecar unit
+
+  await loopPromise;
+
+  // Skip 1 (call 1) + sidecar iteration (no advance) + skip 3 (call 3, matches key) → pause.
+  // The old reset at the dispatch boundary would have zeroed the counter during the sidecar,
+  // requiring 3 more skips (calls 3,4,5) before pausing. With the fix, 3 total → call 3.
+  assert.equal(advanceCalls, 3, "skip streak must survive the sidecar iteration: pause on the 3rd total skip");
+  assert.ok(deps.callLog.includes("pauseAuto"), "persistent skips must still pause after an interleaved sidecar");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "must not hit the max-iteration stop");
+});
+
 test("autoLoop drains sidecar queue after postUnitPostVerification enqueues items", async (t) => {
   _resetPendingResolve();
 

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

@@ -1,10 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { recoverFailedMigration } from "../migrate-external.ts";
+import { externalGsdRoot } from "../repo-identity.ts";
 
 // Regression tests for #4416: `.gsd.migrating` must be healed before auto-mode
 // proceeds, including on the resume path in auto.ts (fixed at auto.ts:1325).
@@ -48,6 +49,36 @@ test("recoverFailedMigration returns false when both .gsd and .gsd.migrating exi
   assert.ok(existsSync(join(base, ".gsd.migrating")), ".gsd.migrating must still exist");
 });
 
+test("recoverFailedMigration removes orphan when .gsd is an intact external-state junction", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-orphan-"));
+  const stateDir = mkdtempSync(join(tmpdir(), "gsd-migrating-state-"));
+  const previousStateDir = process.env.GSD_STATE_DIR;
+  const previousProjectId = process.env.GSD_PROJECT_ID;
+  process.env.GSD_STATE_DIR = stateDir;
+  process.env.GSD_PROJECT_ID = "recover-orphan";
+  t.after(() => {
+    if (previousStateDir === undefined) delete process.env.GSD_STATE_DIR;
+    else process.env.GSD_STATE_DIR = previousStateDir;
+    if (previousProjectId === undefined) delete process.env.GSD_PROJECT_ID;
+    else process.env.GSD_PROJECT_ID = previousProjectId;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+  });
+
+  const externalPath = externalGsdRoot(base);
+  mkdirSync(join(externalPath, "phases"), { recursive: true });
+  writeFileSync(join(externalPath, "STATE.md"), "# State\n", "utf-8");
+  writeFileSync(join(externalPath, "gsd.db"), "not empty\n", "utf-8");
+  symlinkSync(externalPath, join(base, ".gsd"), "junction");
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected orphan cleanup to succeed");
+  assert.ok(existsSync(join(base, ".gsd")), ".gsd junction must remain");
+  assert.ok(!existsSync(join(base, ".gsd.migrating")), ".gsd.migrating orphan must be removed");
+});
+
 test("recoverFailedMigration preserves contents of .gsd.migrating", (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-migrating-contents-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

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

@@ -920,15 +920,21 @@ test("stuck-loop: stop('user-request') resets the ring (hard stop)", async (t) =
   assert.equal(next.kind, "advanced");
 });
 
-test("stuck-loop #482 regression: start() rehydrates the window from the dispatch ledger so cross-session re-dispatch loops are detected", async (t) => {
+test("stuck-loop #852 fix: start() does NOT rehydrate so prior-session failures cannot false-positive on a fresh session", async (t) => {
   const f = makeFixture();
   t.after(() => f.cleanup());
 
-  // Simulate a PRIOR session: the dispatch ledger recorded the same unit
-  // being re-dispatched repeatedly without progress. The orchestrator under test is a
-  // fresh instance (as it would be after a session restart) — before the
-  // Dispatch History module, start() reset the window to [] and the loop
-  // would silently re-dispatch the unit forever (#482: 146 re-dispatches).
+  // Simulate a PRIOR session: STUCK_WINDOW_SIZE-1 consecutive dispatches of
+  // the same unit, all failed. Before #852 was fixed, start() would rehydrate
+  // these stale entries and the very next advance() would declare stuck —
+  // killing the new session before a single dispatch ran. The fix: start()
+  // clears the window WITHOUT rehydrating, so prior-session failures are
+  // invisible to the fresh session.
+  //
+  // Cross-session stuck detection is preserved by resume() (which rehydrates
+  // when the window is empty after a crash) and by within-session accumulation
+  // (STUCK_WINDOW_SIZE dispatches of the same unit within one session still
+  // trigger stuck detection). See the resume() test below.
   const worker = registerAutoWorker({ projectRootRealpath: normalizeRealPath(f.base) });
   const lease = claimMilestoneLease(worker, "M001");
   assert.equal(lease.ok, true);
@@ -950,13 +956,10 @@ test("stuck-loop #482 regression: start() rehydrates the window from the dispatc
   const started = await f.orchestrator.start(SESSION_CONTEXT);
   assert.equal(started.kind, "started");
 
-  // The very next decision for the same unit must trip the stuck verdict
-  // instead of advancing.
+  // The fresh session must advance past the prior-session history: window is
+  // empty after start(), so the first advance dispatches normally.
   const result = await f.orchestrator.advance();
-  assert.equal(result.kind, "blocked");
-  if (result.kind !== "blocked") return;
-  assert.equal(result.action, "stop");
-  assert.ok(result.reason.startsWith("stuck-loop:"), `expected stuck-loop reason, got: ${result.reason}`);
+  assert.equal(result.kind, "advanced", "fresh session must not be blocked by stale prior-session dispatch history");
 });
 
 test("stuck-loop #482: resume() with an empty window rehydrates from the dispatch ledger", async (t) => {

package/src/resources/extensions/gsd/tests/auto-pause-double-entry-guard.test.ts

@@ -14,6 +14,7 @@ import { capturePauseAutoUnitIdentity, pauseAuto, isAutoActive } from "../auto.t
 import { _resetPendingResolve, _setCurrentResolve } from "../auto/resolve.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { _isPauseOriginCancelledResult } from "../auto/phase-helpers.ts";
+import { handleAutoCommand } from "../commands/handlers/auto.ts";
 
 test("pauseAuto sets s.active = false synchronously before first await (blocks concurrent re-entry)", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-double-pause-guard-"));
@@ -80,6 +81,41 @@ test("pauseAuto marks paused and cancels the in-flight unit before first await",
   }
 });
 
+test("/gsd pause aborts the active pi turn before first await", async () => {
+  autoSession.reset();
+  autoSession.active = true;
+  let abortCount = 0;
+  const ctx = {
+    hasUI: false,
+    isIdle: () => false,
+    abort: () => {
+      abortCount += 1;
+    },
+    sessionManager: {
+      getSessionFile: () => null,
+    },
+    ui: {
+      setStatus() {},
+      setWidget() {},
+      notify() {},
+    },
+  } as any;
+
+  try {
+    const pausePromise = handleAutoCommand("pause", ctx, {} as any);
+
+    assert.equal(
+      abortCount,
+      1,
+      "pauseAuto must abort the active pi turn before reporting auto-mode paused",
+    );
+
+    await pausePromise.catch(() => {});
+  } finally {
+    autoSession.reset();
+  }
+});
+
 test("transient-abort errorContext is not classified as pause-origin cancellation", () => {
   // The phases.ts fix passes unitResult.errorContext to pauseAuto for transient aborts.
   // _isPauseOriginCancelledResult must return false when errorContext is present, ensuring

package/src/resources/extensions/gsd/tests/auto-paused-session-validation.test.ts

@@ -36,7 +36,12 @@ test("resolveMilestonePath returns null for missing milestone", (t) => {
 
 test("resolveMilestonePath returns path for existing milestone", (t) => {
   const base = makeTmpBase();
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(mDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone); an empty dir is now treated as a
+  // metadata-only placeholder left by git-service.ts and is not legacy layout.
+  writeFileSync(join(mDir, "M001-CONTEXT.md"), "# M001\n");
   t.after(() => cleanup(base));
 
   const result = resolveMilestonePath(base, "M001");
@@ -93,7 +98,11 @@ test("stale milestone: completed (has SUMMARY) means paused session should be di
 
 test("valid milestone: exists and has no SUMMARY means paused session is valid", (t) => {
   const base = makeTmpBase();
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(mDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file;
+  // use CONTEXT as the existing content, with no SUMMARY (milestone still active).
+  writeFileSync(join(mDir, "M001-CONTEXT.md"), "# M001\n");
   t.after(() => cleanup(base));
 
   const dir = resolveMilestonePath(base, "M001");

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -3,13 +3,14 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 
 import {
   anchorProcessCwdForAutoResume,
   cleanupAfterLoopExit,
+  maybeRerootStepSessionForHighContext,
   pauseAuto,
   rerootCommandSession,
   stopAuto,
@@ -478,8 +479,8 @@ test("cleanupAfterLoopExit preserves step-mode surface and worktree session afte
   }
 });
 
-test("cleanupAfterLoopExit re-roots step-mode session when context exceeds compaction threshold", async (t) => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-step-reroot-"));
+test("cleanupAfterLoopExit warns but does not re-root step-mode session at soft compaction threshold", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-step-soft-context-"));
   const worktree = join(base, ".gsd", "worktrees", "M001");
   const previousCwd = process.cwd();
   const newSessionWorkspaces: string[] = [];
@@ -515,7 +516,59 @@ test("cleanupAfterLoopExit re-roots step-mode session when context exceeds compa
       },
     } as any);
 
-    assert.deepEqual(newSessionWorkspaces, [worktree], "hot step-mode cleanup should re-root in the active worktree");
+    assert.deepEqual(newSessionWorkspaces, [], "soft context pressure must not force a new command session");
+    assert.equal(
+      notifyMessages.some((msg) => msg.includes("context at 72.0%") && msg.includes("Use /compact")),
+      true,
+      "soft threshold should warn with a non-disruptive compaction prompt",
+    );
+    assert.equal(autoSession.basePath, worktree);
+    assert.equal(realpathSync(process.cwd()), realpathSync(worktree));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit re-roots step-mode session at hard context threshold", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-step-reroot-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  const newSessionWorkspaces: string[] = [];
+  const notifyMessages: string[] = [];
+
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function () {});
+
+  mkdirSync(worktree, { recursive: true });
+  process.chdir(worktree);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.stepMode = true;
+  autoSession.preserveStepSurfaceAfterLoopExit = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+  autoSession.cmdCtx = {
+    getContextUsage: () => ({ percent: 92, tokens: 920_000, contextWindow: 1_000_000 }),
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        setHeader: () => {},
+        notify: (_msg: string) => notifyMessages.push(_msg),
+      },
+    } as any);
+
+    assert.deepEqual(newSessionWorkspaces, [worktree], "critical context pressure should re-root in the active worktree");
     assert.equal(
       notifyMessages.some((msg) => msg.includes("Fresh session ready for /gsd next")),
       true,
@@ -530,6 +583,131 @@ test("cleanupAfterLoopExit re-roots step-mode session when context exceeds compa
   }
 });
 
+test("maybeRerootStepSessionForHighContext re-roots at the hard threshold even when the soft pref is set above it", async () => {
+  // Regression: the hard 90% re-root must not be gated behind the configurable
+  // soft warn threshold, which is allowed up to 0.95. At 92% usage with a 0.95
+  // soft pref the soft warn predicate is false, but the session must still
+  // re-root because usage crossed the fixed hard boundary.
+  const dir = mkdtempSync(join(tmpdir(), "gsd-hard-reroot-high-soft-"));
+  const project = join(dir, "project");
+  const gsdHomeDir = join(dir, "home");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHomeDir, { recursive: true });
+  writeFileSync(
+    join(project, ".gsd", "PREFERENCES.md"),
+    ["---", "version: 1", "context_management:", "  compaction_threshold_percent: 0.95", "---", ""].join("\n"),
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = gsdHomeDir;
+  process.chdir(project);
+
+  const newSessionWorkspaces: string[] = [];
+  const notifyMessages: string[] = [];
+  const cmdCtx = {
+    getContextUsage: () => ({ percent: 92, tokens: 920_000, contextWindow: 1_000_000 }),
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+  const ctx = { ui: { notify: (msg: string) => notifyMessages.push(msg) } } as any;
+
+  try {
+    const result = await maybeRerootStepSessionForHighContext(ctx, project, cmdCtx, project);
+
+    assert.equal(result.rerooted, true, "92% usage must re-root even when the soft pref is 95%");
+    assert.deepEqual(newSessionWorkspaces, [project], "hard context pressure must re-root the command session");
+    const rerootMessage = notifyMessages.find((msg) => msg.includes("Fresh session ready for /gsd next"));
+    assert.ok(rerootMessage, "hard re-root should notify the user");
+    // The re-root was triggered by the 90% hard limit, so the notification must
+    // cite that limit and not the configured 95% soft compaction threshold.
+    assert.match(
+      rerootMessage,
+      /hard threshold: 90%/,
+      "hard re-root notification must cite the 90% hard threshold",
+    );
+    assert.equal(
+      rerootMessage.includes("95%"),
+      false,
+      "hard re-root notification must not cite the configured soft compaction threshold",
+    );
+  } finally {
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("maybeRerootStepSessionForHighContext writes a compaction snapshot only at the hard boundary", async () => {
+  // Regression: the snapshot is reserved for the hard re-root. Soft-only
+  // pressure must warn without writing a compaction snapshot.
+  const dir = mkdtempSync(join(tmpdir(), "gsd-soft-no-snapshot-"));
+  const project = join(dir, "project");
+  const gsdHomeDir = join(dir, "home");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHomeDir, { recursive: true });
+  writeFileSync(
+    join(project, ".gsd", "PREFERENCES.md"),
+    ["---", "version: 1", "context_management:", "  compaction_threshold_percent: 0.6", "---", ""].join("\n"),
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = gsdHomeDir;
+  process.chdir(project);
+
+  const newSessionWorkspaces: string[] = [];
+  const notifyMessages: string[] = [];
+  let contextPercent = 72;
+  const cmdCtx = {
+    getContextUsage: () => ({ percent: contextPercent, tokens: contextPercent * 10_000, contextWindow: 1_000_000 }),
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+  const ctx = { ui: { notify: (msg: string) => notifyMessages.push(msg) } } as any;
+  const snapshotPath = join(project, ".gsd", "last-snapshot.md");
+
+  try {
+    const softResult = await maybeRerootStepSessionForHighContext(ctx, project, cmdCtx, project);
+    assert.equal(softResult.rerooted, false, "soft pressure must not re-root");
+    assert.deepEqual(newSessionWorkspaces, [], "soft pressure must not open a new session");
+    assert.equal(
+      existsSync(snapshotPath),
+      false,
+      "soft-only pressure must not write a compaction snapshot",
+    );
+    assert.equal(
+      notifyMessages.some((msg) => msg.includes("context at 72.0%") && msg.includes("Use /compact")),
+      true,
+      "soft threshold should warn with a non-disruptive compaction prompt",
+    );
+
+    contextPercent = 92;
+    const hardResult = await maybeRerootStepSessionForHighContext(ctx, project, cmdCtx, project);
+    assert.equal(hardResult.rerooted, true, "hard pressure must re-root");
+    assert.deepEqual(newSessionWorkspaces, [project], "hard pressure should re-root once");
+    assert.equal(
+      existsSync(snapshotPath),
+      true,
+      "hard boundary must write the compaction snapshot",
+    );
+  } finally {
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("cleanupAfterLoopExit restores project root through lifecycle and preserves chdir", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-lifecycle-"));
   const worktree = join(base, ".gsd", "worktrees", "M001");