@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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");
@@ -3358,6 +3484,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,54 @@ 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 a real intact directory", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrating-real-orphan-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const localGsd = join(base, ".gsd");
+  mkdirSync(join(localGsd, "phases"), { recursive: true });
+  mkdirSync(join(localGsd, "activity"), { recursive: true });
+  writeFileSync(join(localGsd, "STATE.md"), "# State\n", "utf-8");
+  writeFileSync(join(localGsd, "gsd.db"), "not empty\n", "utf-8");
+  mkdirSync(join(base, ".gsd.migrating"), { recursive: true });
+
+  const recovered = recoverFailedMigration(base);
+
+  assert.equal(recovered, true, "expected orphan cleanup to succeed");
+  assert.ok(existsSync(localGsd), ".gsd real directory must remain");
+  assert.ok(!existsSync(join(base, ".gsd.migrating")), ".gsd.migrating orphan must be removed");
+});
+
+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-model-selection.test.ts

@@ -63,6 +63,62 @@ test("resolvePreferredModelConfig synthesizes heavy routing ceiling when models
   }
 });
 
+test("resolvePreferredModelConfig treats token-profile model defaults as synthesized routing", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-profile-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-profile-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: quality",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: claude-haiku-4-5",
+        "    standard: claude-sonnet-4-6",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig(
+      "plan-slice",
+      {
+        provider: "anthropic",
+        id: "claude-sonnet-4-6",
+      },
+      true,
+      tempProject,
+      [
+        "anthropic/claude-haiku-4-5",
+        "anthropic/claude-sonnet-4-6",
+        "anthropic/claude-opus-4-6",
+      ],
+      "anthropic/claude-sonnet-4-6",
+    );
+
+    assert.deepEqual(config, {
+      primary: "claude-opus-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("resolvePreferredModelConfig falls back to auto start model when heavy tier is absent", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -152,6 +208,128 @@ test("resolvePreferredModelConfig keeps explicit phase models as the ceiling", (
   }
 });
 
+// #1115 regression: a token_profile with dynamic_routing enabled but NO
+// tier_models pins must still resolve the profile's per-phase model as a
+// synthesized routing ceiling. Before the fix, resolvePreferredModelConfig
+// bailed to undefined here (explicit detection skips profile defaults, and the
+// synthesis path required tier_models), so auto dispatch fell back to the
+// start model for every unit and silently discarded the profile.
+test("resolvePreferredModelConfig resolves profile per-phase models as synthesized when tier_models are absent", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-profile-notier-");
+  const tempGsdHome = makeTempDir("gsd-routing-profile-notier-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: budget",
+        "dynamic_routing:",
+        "  enabled: true",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const availableModelIds = [
+      "anthropic/claude-haiku-4-5",
+      "anthropic/claude-sonnet-4-6",
+      "anthropic/claude-opus-4-6",
+    ];
+    const start = { provider: "anthropic", id: "claude-sonnet-4-6" };
+    // preferredModelId is intentionally left undefined so profile tier
+    // resolution is exercised rather than pinning every tier to the session
+    // model (a heavy session model can satisfy every tier).
+    const resolve = (unitType: string) =>
+      resolvePreferredModelConfig(unitType, start, true, tempProject, availableModelIds);
+
+    // budget profile: research=light, planning=standard, execution=standard,
+    // execution_simple=light, completion=light (PROFILE_TIER_MAP).
+    assert.deepEqual(resolve("research-milestone"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("plan-milestone"), {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("execute-task"), {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("execute-task-simple"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+    assert.deepEqual(resolve("complete-slice"), {
+      primary: "claude-haiku-4-5",
+      fallbacks: [],
+      source: "synthesized",
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
+// #1115 guard: the explicit flat-rate opt-out must suppress synthesized routing
+// even on the profile-derived (no tier_models) path — the opt-out moved ahead
+// of both synthesis branches, so a flat-rate start model with
+// allow_flat_rate_providers:false yields no config (start model is used as-is).
+test("resolvePreferredModelConfig honors flat-rate opt-out on the profile path (no tier_models)", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-flatrate-notier-");
+  const tempGsdHome = makeTempDir("gsd-routing-flatrate-notier-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "token_profile: budget",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  allow_flat_rate_providers: false",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig(
+      "execute-task",
+      // claude-code is a built-in flat-rate provider.
+      { provider: "claude-code", id: "claude-opus-4-6" },
+      true,
+      tempProject,
+      ["anthropic/claude-haiku-4-5", "anthropic/claude-sonnet-4-6", "anthropic/claude-opus-4-6"],
+    );
+
+    assert.equal(config, undefined);
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("selectAndApplyModel honors explicit phase models without downgrading (#3617)", async () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

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