gsd-pi 2.79.0 → 2.80.0

package/src/resources/extensions/gsd/guided-flow.ts

@@ -70,6 +70,7 @@ import {
 } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
 import { createWorkspace, scopeMilestone, type MilestoneScope } from "./workspace.js";
+import { getPendingGate, extractDepthVerificationMilestoneId } from "./bootstrap/write-gate.js";
 
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export {
@@ -410,6 +411,15 @@ export async function checkDeepProjectSetupAfterTurn(
     }
   }
 
+  // R2: a depth-verification gate is still pending — the LLM emitted the
+  // confirmation question (via ask_user_questions or plain chat) but the user
+  // has not approved yet. Returning false keeps the entry in the
+  // pendingDeepProjectSetupMap so the next user message can resume.
+  const pendingGateId = getPendingGate(entry.basePath);
+  if (pendingGateId) {
+    return false;
+  }
+
   return dispatchNextDeepProjectSetupStage(entry);
 }
 
@@ -494,6 +504,25 @@ export function checkAutoStartAfterDiscuss(): boolean {
   const roadmapFile = existsSync(roadmapFilePath) ? roadmapFilePath : null;
   if (!contextFile && !roadmapFile) return false; // neither artifact yet — keep waiting
 
+  // Gate 1a: a depth-verification gate is still pending for THIS milestone — the
+  // LLM emitted the confirmation question (via ask_user_questions or plain chat)
+  // but the user has not answered yet. Advancing now would skip the gate and
+  // race ahead with unverified context.
+  const basePathForGate = entry.scope.workspace.projectRoot;
+  const pendingGateId = getPendingGate(basePathForGate);
+  if (pendingGateId) {
+    const pendingMilestoneId = extractDepthVerificationMilestoneId(pendingGateId);
+    // Block advancement if the gate is for THIS milestone, OR if it's a
+    // project/requirements gate (no milestone id encoded) for the deep setup flow.
+    const isProjectGate =
+      pendingGateId === "depth_verification_project_confirm" ||
+      pendingGateId === "depth_verification_requirements_confirm" ||
+      pendingGateId === "depth_verification_research_decision_confirm";
+    if (pendingMilestoneId === milestoneId || isProjectGate) {
+      return false;
+    }
+  }
+
   // Gate 1b: Discriminate plan-blocked from discuss-incomplete when the DB row is queued.
   // If the DB is available and the row is still "queued" but CONTEXT.md already exists on
   // disk, the discuss phase completed but gsd_plan_milestone was hard-blocked by the
@@ -628,6 +657,24 @@ export function checkAutoStartAfterDiscuss(): boolean {
     try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
   }
 
+  // R3b: belt-and-suspenders for silent registration failure. The discuss flow
+  // finished and STATE.md exists, but the milestone may never have landed in
+  // the DB. Without this guard, the user sees "Milestone M001 ready." and then
+  // /gsd reports "No Active Milestone".
+  if (isDbAvailable()) {
+    const milestoneRow = getMilestone(milestoneId);
+    if (!milestoneRow) {
+      ctx.ui.notify(
+        `Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
+        `PROJECT.md may have failed to register milestones. ` +
+        `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
+        `then re-run /gsd to recover.`,
+        "error",
+      );
+      return false;
+    }
+  }
+
   pendingAutoStartMap.delete(basePath);
   ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
   startAutoDetached(ctx, pi, basePath, false, { step });

package/src/resources/extensions/gsd/interrupted-session.ts

@@ -37,6 +37,7 @@ export interface PausedSessionMetadata {
   activeRunDir?: string | null;
   autoStartTime?: number;
   milestoneLock?: string | null;
+  pauseReason?: string;
 }
 
 export interface InterruptedSessionAssessment {

package/src/resources/extensions/gsd/paths.ts

@@ -188,9 +188,14 @@ export function resolveDir(parentDir: string, idPrefix: string): string | null {
     // Exact match first (current convention: bare ID)
     const exact = entries.find(e => e.isDirectory() && e.name === idPrefix);
     if (exact) return exact.name;
+    const idLower = idPrefix.toLowerCase();
+    const exactCaseInsensitive = entries.find(
+      e => e.isDirectory() && e.name.toLowerCase() === idLower
+    );
+    if (exactCaseInsensitive) return exactCaseInsensitive.name;
     // Prefix match for legacy descriptor dirs: M001-SOMETHING
     const prefixed = entries.find(
-      e => e.isDirectory() && e.name.startsWith(idPrefix + "-")
+      e => e.isDirectory() && e.name.toLowerCase().startsWith(idLower + "-")
     );
     return prefixed ? prefixed.name : null;
   } catch {

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -144,12 +144,30 @@ export function resolveImportPath(
     if (existsSync(directPath)) {
       return { exists: true, resolvedPath: directPath };
     }
-    // Only .js/.jsx/.mjs/.cjs imports legitimately fall through for the TS
-    // ESM convention (.js → .ts). Any other explicit extension (.css, .json,
-    // .svg, images, fonts, .ts, .tsx, …) must stay unresolved when the direct
-    // path is missing — otherwise a stray `./missing.css.ts` could shadow a
-    // genuinely missing `./missing.css` import.
-    if (![".js", ".jsx", ".mjs", ".cjs"].includes(explicitExt)) {
+
+    // Known concrete extensions that should NOT fall through to code-shadow
+    // probing when missing. This preserves the "missing.css must stay missing"
+    // guarantee while still allowing dotted module stems like ./route.server
+    // to resolve as ./route.server.ts.
+    const nonFallbackExtensions = new Set([
+      ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+      ".json", ".css", ".scss", ".sass", ".less", ".styl",
+      ".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".bmp",
+      ".woff", ".woff2", ".ttf", ".otf", ".eot",
+    ]);
+    const runtimeFallbackExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
+    const dottedStemFallbackExtensions = new Set([".server", ".client", ".webhook"]);
+
+    if (
+      explicitExt !== "" &&
+      !runtimeFallbackExtensions.has(explicitExt) &&
+      !nonFallbackExtensions.has(explicitExt) &&
+      !dottedStemFallbackExtensions.has(explicitExt)
+    ) {
+      return { exists: false, resolvedPath: null };
+    }
+
+    if (nonFallbackExtensions.has(explicitExt) && !runtimeFallbackExtensions.has(explicitExt)) {
       return { exists: false, resolvedPath: null };
     }
   }
@@ -222,6 +240,13 @@ export function checkImportResolution(
     const imports = extractRelativeImports(source);
 
     for (const { importPath, lineNum } of imports) {
+      // React Router generated +types modules may not exist on disk during
+      // post-exec checks (generated during framework build). Don't block task
+      // completion on these imports.
+      if (/^\.{1,2}\/\+types\//.test(importPath)) {
+        continue;
+      }
+
       const resolution = resolveImportPath(importPath, file, basePath);
 
       if (!resolution.exists) {

package/src/resources/extensions/gsd/preferences-types.ts

@@ -154,8 +154,26 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "planning_depth",
 ]);
 
-/** Canonical list of all dispatch unit types. */
-export const KNOWN_UNIT_TYPES = [
+/**
+ * Broad union of every recognized unit-type *label* used across the codebase.
+ *
+ * This intentionally covers more than the manifest-tracked dispatch units in
+ * `unit-context-manifest.ts:KNOWN_UNIT_TYPES`. Examples that live here but not
+ * in the manifest:
+ * - `discuss-slice` — dispatched by `guided-flow.ts` rather than auto-mode;
+ *   composer falls through to default behavior via `resolveManifest()` null path.
+ * - `worktree-merge` — used as a model-routing case, prompt-template name, and
+ *   commit-message label, not as an LLM-dispatched unit.
+ *
+ * Used by `preferences-validation.ts` to validate user-provided unit-type
+ * references in preferences (model overrides, skill rules, etc.) — preferences
+ * may legitimately reference any label, including non-dispatched ones.
+ *
+ * The manifest-strict subset lives in `unit-context-manifest.ts:KNOWN_UNIT_TYPES`
+ * and is enforced 1:1 against `UNIT_MANIFESTS` by the parity test in
+ * `tests/unit-context-manifest.test.ts`.
+ */
+export const KNOWN_UNIT_LABELS = [
   "research-milestone", "plan-milestone", "research-slice", "plan-slice", "refine-slice",
   "execute-task", "reactive-execute", "gate-evaluate", "complete-slice", "replan-slice", "reassess-roadmap",
   "run-uat", "complete-milestone", "validate-milestone", "rewrite-docs",
@@ -164,7 +182,7 @@ export const KNOWN_UNIT_TYPES = [
   "workflow-preferences", "discuss-project", "discuss-requirements",
   "research-decision", "research-project",
 ] as const;
-export type UnitType = (typeof KNOWN_UNIT_TYPES)[number];
+export type UnitLabel = (typeof KNOWN_UNIT_LABELS)[number];
 
 
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
@@ -343,7 +361,8 @@ export interface GSDPreferences {
   /**
    * Tool-output sandboxing via gsd_exec. Keeps sub-session context windows
    * clean by running scripts in a subprocess and only surfacing a short
-   * digest. See `ContextModeConfig`. Default: disabled.
+   * digest. See `ContextModeConfig`. Default: enabled unless explicitly
+   * disabled with `context_mode.enabled: false`.
    */
   context_mode?: ContextModeConfig;
   token_profile?: TokenProfile;

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -14,7 +14,7 @@ import { normalizeStringArray } from "../shared/format-utils.js";
 
 import {
   KNOWN_PREFERENCE_KEYS,
-  KNOWN_UNIT_TYPES,
+  KNOWN_UNIT_LABELS,
 
   SKILL_ACTIONS,
   type WorkflowMode,
@@ -441,7 +441,7 @@ export function validatePreferences(preferences: GSDPreferences): {
   if (preferences.post_unit_hooks && Array.isArray(preferences.post_unit_hooks)) {
     const validHooks: PostUnitHookConfig[] = [];
     const seenNames = new Set<string>();
-    const knownUnitTypes = new Set<string>(KNOWN_UNIT_TYPES);
+    const knownUnitTypes = new Set<string>(KNOWN_UNIT_LABELS);
     for (const hook of preferences.post_unit_hooks) {
       if (!hook || typeof hook !== "object") {
         errors.push("post_unit_hooks entry must be an object");
@@ -503,7 +503,7 @@ export function validatePreferences(preferences: GSDPreferences): {
   if (preferences.pre_dispatch_hooks && Array.isArray(preferences.pre_dispatch_hooks)) {
     const validPreHooks: PreDispatchHookConfig[] = [];
     const seenPreNames = new Set<string>();
-    const knownUnitTypes = new Set<string>(KNOWN_UNIT_TYPES);
+    const knownUnitTypes = new Set<string>(KNOWN_UNIT_LABELS);
     const validActions = new Set(["modify", "skip", "replace"]);
     for (const hook of preferences.pre_dispatch_hooks) {
       if (!hook || typeof hook !== "object") {

package/src/resources/extensions/gsd/tests/auto-abort-pause-regression.test.ts

@@ -0,0 +1,32 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _buildAbortedPauseContext } from "../bootstrap/agent-end-recovery.js";
+import { _buildCancelledUnitStopReason } from "../auto/phases.js";
+
+test("aborted agent_end maps errorMessage into structured aborted pause context", () => {
+  const withMessage = _buildAbortedPauseContext({ errorMessage: "provider aborted request" });
+  assert.deepEqual(withMessage, {
+    message: "provider aborted request",
+    category: "aborted",
+    isTransient: true,
+  });
+
+  const withoutMessage = _buildAbortedPauseContext({});
+  assert.deepEqual(withoutMessage, {
+    message: "Operation aborted",
+    category: "aborted",
+    isTransient: true,
+  });
+});
+
+test("cancelled non-session failures are labeled as unit aborts (not session-creation failures)", () => {
+  const cancelled = _buildCancelledUnitStopReason("execute-task", "M001-S001-T001", {
+    category: "aborted",
+    message: "tool invocation cancelled",
+  });
+
+  assert.match(cancelled.notifyMessage, /aborted after dispatch/);
+  assert.equal(cancelled.stopReason, "Unit aborted: tool invocation cancelled");
+  assert.equal(cancelled.loopReason, "unit-aborted");
+});

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

@@ -0,0 +1,353 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createAutoOrchestrator } from "../auto/orchestrator.js";
+import type { AutoOrchestratorDeps } from "../auto/contracts.js";
+
+function makeDeps(overrides: Partial<AutoOrchestratorDeps> = {}): { deps: AutoOrchestratorDeps; calls: string[] } {
+  const calls: string[] = [];
+
+  const deps: AutoOrchestratorDeps = {
+    dispatch: {
+      async decideNextUnit() {
+        calls.push("dispatch.decide");
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+    recovery: {
+      async classifyAndRecover() {
+        calls.push("recovery.classify");
+        return { action: "stop", reason: "fatal" };
+      },
+    },
+    worktree: {
+      async prepareForUnit() { calls.push("worktree.prepare"); },
+      async syncAfterUnit() { calls.push("worktree.sync"); },
+      async cleanupOnStop() { calls.push("worktree.cleanup"); },
+    },
+    health: {
+      async preAdvanceGate() {
+        calls.push("health.pre");
+        return { allow: true };
+      },
+      async postAdvanceRecord() { calls.push("health.post"); },
+    },
+    runtime: {
+      async ensureLockOwnership() { calls.push("runtime.lock"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    notifications: {
+      async notifyLifecycle(event) { calls.push(`notify:${event.name}`); },
+    },
+  };
+
+  return { deps: { ...deps, ...overrides }, calls };
+}
+
+test("start() advances and records active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(result.kind, "advanced");
+  const status = orchestrator.getStatus();
+  assert.equal(status.phase, "running");
+  assert.deepEqual(status.activeUnit, { unitType: "execute-task", unitId: "T01" });
+  assert.ok(calls.includes("journal:start"));
+  assert.ok(calls.includes("journal:advance"));
+});
+
+test("advance() returns blocked when health gate denies", async () => {
+  const { deps } = makeDeps({
+    health: {
+      async preAdvanceGate() { return { allow: false, reason: "doctor-block" }; },
+      async postAdvanceRecord() {},
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "blocked");
+  assert.equal(result.reason, "doctor-block");
+});
+
+test("advance() stops when dispatch has no next unit", async () => {
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() { return null; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+});
+
+test("advance() uses recovery on error", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("lock lost"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "error");
+  assert.equal(result.reason, "needs manual");
+  assert.equal(orchestrator.getStatus().phase, "error");
+  assert.ok(calls.includes("journal:advance-error"));
+});
+
+test("advance() is idempotent for the same active unit", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(second.kind, "blocked");
+  assert.equal(second.reason, "idempotent advance: unit already active");
+
+  const prepareCalls = calls.filter((c) => c === "worktree.prepare").length;
+  assert.equal(prepareCalls, 1);
+});
+
+test("resume() re-enters running flow via advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.resume();
+
+  assert.equal(result.kind, "advanced");
+  assert.equal(orchestrator.getStatus().phase, "running");
+});
+
+test("resume() clears idempotent lock and allows re-advance", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const resumed = await orchestrator.resume();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(resumed.kind, "advanced");
+});
+
+test("transitionCount increases across lifecycle transitions", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const before = orchestrator.getStatus().transitionCount;
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+  const afterStart = orchestrator.getStatus().transitionCount;
+  await orchestrator.stop("done");
+  const afterStop = orchestrator.getStatus().transitionCount;
+
+  assert.ok(afterStart > before);
+  assert.ok(afterStop > afterStart);
+});
+
+test("stop() clears idempotent unit lock so advance can run again", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const stopped = await orchestrator.stop("reset");
+  const second = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(second.kind, "advanced");
+});
+
+test("advance() stopped clears previous activeUnit", async () => {
+  let first = true;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        if (first) {
+          first = false;
+          return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+        }
+        return null;
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+});
+
+test("recovery stop clears activeUnit", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "stop", reason: "fatal" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().activeUnit, undefined);
+  assert.ok(calls.includes("journal:advance-stopped"));
+  assert.ok(calls.includes("notify:stopped"));
+  assert.ok(!calls.includes("notify:error"));
+});
+
+test("recovery retry maps to paused result", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "retry", reason: "transient" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "paused");
+  assert.equal(result.reason, "transient");
+  assert.equal(orchestrator.getStatus().phase, "paused");
+  assert.ok(calls.includes("journal:advance-paused"));
+  assert.ok(calls.includes("notify:pause"));
+});
+
+test("getStatus() returns defensive copy of activeUnit", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const snap1 = orchestrator.getStatus();
+  if (snap1.activeUnit) snap1.activeUnit.unitId = "MUTATED";
+  const snap2 = orchestrator.getStatus();
+
+  assert.equal(snap2.activeUnit?.unitId, "T01");
+});
+
+test("start() clears prior idempotent lock", async () => {
+  const { deps } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  const blocked = await orchestrator.advance();
+  const restarted = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.equal(blocked.kind, "blocked");
+  assert.equal(restarted.kind, "advanced");
+});
+
+test("error path emits error notification", async () => {
+  const { deps, calls } = makeDeps({
+    runtime: {
+      async ensureLockOwnership() { throw new Error("boom"); },
+      async journalTransition(event) { calls.push(`journal:${event.name}`); },
+    },
+    recovery: {
+      async classifyAndRecover() { return { action: "escalate", reason: "needs manual" }; },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("notify:error"));
+});
+
+test("blocked path journals advance-blocked", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("journal:advance-blocked"));
+});
+
+test("health post hook runs on blocked result", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.advance();
+  await orchestrator.advance();
+
+  assert.ok(calls.includes("health.post"));
+});
+
+test("start() emits start notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+
+  assert.ok(calls.includes("notify:start"));
+});
+
+test("resume() emits resume notification", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  await orchestrator.resume();
+
+  assert.ok(calls.includes("notify:resume"));
+});
+
+test("stopped with no remaining units clears idempotent lock for next advance", async () => {
+  let callCount = 0;
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        callCount += 1;
+        if (callCount === 2) return null;
+        return { unitType: "execute-task", unitId: "T01", reason: "ready", preconditions: [] };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const first = await orchestrator.advance();
+  const stopped = await orchestrator.advance();
+  const after = await orchestrator.advance();
+
+  assert.equal(first.kind, "advanced");
+  assert.equal(stopped.kind, "stopped");
+  assert.equal(after.kind, "advanced");
+});
+
+test("stop() cleans up worktree and transitions to stopped", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.stop("user-request");
+
+  assert.equal(result.kind, "stopped");
+  assert.equal(orchestrator.getStatus().phase, "stopped");
+  assert.ok(calls.includes("worktree.cleanup"));
+  assert.ok(calls.includes("journal:stop"));
+  assert.ok(calls.includes("notify:stop"));
+});