gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/auto-start-cold-db-bootstrap.test.ts

@@ -1,37 +1,27 @@
-import { readFileSync } from "node:fs";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
+import { openProjectDbIfPresent } from "../auto-start.ts";
+import { closeDatabase, isDbAvailable, openDatabase } from "../gsd-db.ts";
 
-const { assertTrue, report } = createTestContext();
+test.afterEach(() => {
+  if (isDbAvailable()) closeDatabase();
+});
 
-const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
-const src = readFileSync(srcPath, "utf-8");
+test("#2841: cold DB bootstrap opens an existing project database before state derivation", async (t) => {
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cold-db-")));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const dbPath = join(base, ".gsd", "gsd.db");
 
-console.log("\n=== #2841: cold DB opened before initial deriveState ===");
+  assert.equal(openDatabase(dbPath), true);
+  closeDatabase();
+  assert.equal(isDbAvailable(), false);
 
-const helperIdx = src.indexOf("async function openProjectDbIfPresent");
-assertTrue(helperIdx >= 0, "auto-start.ts defines a helper for pre-derive DB open (#2841)");
+  await openProjectDbIfPresent(base);
 
-const helperRegion = helperIdx >= 0 ? extractSourceRegion(src, "async function openProjectDbIfPresent") : "";
-assertTrue(
-  helperRegion.includes("resolveProjectRootDbPath(basePath)"),
-  "pre-derive DB helper resolves the project-root DB path (#2841)",
-);
-assertTrue(
-  helperRegion.includes("openDatabase(gsdDbPath)"),
-  "pre-derive DB helper opens the resolved DB path (#2841)",
-);
-
-const firstDeriveIdx = src.indexOf("let state = await deriveState(base);");
-assertTrue(firstDeriveIdx > 0, "auto-start.ts has the initial deriveState(base) call");
-
-const preDeriveRegion = firstDeriveIdx > 0 ? src.slice(0, firstDeriveIdx) : "";
-const preDeriveOpenIdx = preDeriveRegion.lastIndexOf("await openProjectDbIfPresent(base);");
-
-assertTrue(
-  preDeriveOpenIdx > 0,
-  "bootstrapAutoSession opens the DB before the first deriveState(base) call (#2841)",
-);
-
-report();
+  assert.equal(isDbAvailable(), true);
+});

package/src/resources/extensions/gsd/tests/auto-start-index-lock.test.ts

@@ -1,38 +1,26 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
-const source = readFileSync(sourcePath, "utf-8");
+import { hasGitIndexLockForTest } from "../auto-start.ts";
 
-test("bootstrapAutoSession blocks on .git/index.lock before git mutations", () => {
-  const preflightIdx = source.indexOf('join(base, ".git", "index.lock")');
-  const initIdx = source.indexOf("nativeInit(base, mainBranch)");
-  const addIdx = source.indexOf("nativeAddAll(base)");
-  const commitIdx = source.indexOf('nativeCommit(base, "chore: init gsd")');
+test("bootstrapAutoSession detects .git/index.lock without deleting it", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-index-lock-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  const lockPath = join(base, ".git", "index.lock");
+  mkdirSync(join(base, ".git"), { recursive: true });
+  writeFileSync(lockPath, "locked\n", "utf-8");
 
-  assert.ok(preflightIdx > -1, "bootstrap must check for .git/index.lock");
-  assert.ok(initIdx > -1, "bootstrap still initializes git when safe");
-  assert.ok(addIdx > -1, "bootstrap still stages bootstrap files when safe");
-  assert.ok(commitIdx > -1, "bootstrap still commits bootstrap files when safe");
-
-  assert.ok(preflightIdx < initIdx, "index.lock preflight must run before git init");
-  assert.ok(preflightIdx < addIdx, "index.lock preflight must run before git add");
-  assert.ok(preflightIdx < commitIdx, "index.lock preflight must run before git commit");
+  assert.equal(hasGitIndexLockForTest(base), true);
+  assert.equal(existsSync(lockPath), true);
 });
 
-test("bootstrapAutoSession never deletes .git/index.lock", () => {
-  assert.ok(
-    !source.includes("unlinkSync(gitLockFile)") && !source.includes("rmSync(gitLockFile"),
-    "bootstrap must not remove .git/index.lock because git lock staleness is not safe to infer",
-  );
-  assert.ok(
-    !source.includes("STALE_GIT_LOCK_THRESHOLD_MS"),
-    "bootstrap must not use lock age as a deletion heuristic",
-  );
-  assert.ok(
-    source.includes("return releaseLockAndReturn();"),
-    "bootstrap must abort and release the session lock when the git index is locked",
-  );
+test("bootstrapAutoSession reports no index lock when the lock file is absent", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-index-lock-missing-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".git"), { recursive: true });
+
+  assert.equal(hasGitIndexLockForTest(base), false);
 });

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -0,0 +1,138 @@
+// Project/App: GSD-2
+// File Purpose: Bootstrap behavior tests for completed milestone orphan merges.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { bootstrapAutoSession } from "../auto-start.ts";
+import { AutoSession } from "../auto/session.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
+
+function runGit(base: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd: base,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim();
+}
+
+function makeRepoWithUnmergedCompletedMilestone(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orphan-bootstrap-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: \"branch\"\n---\n",
+  );
+  runGit(base, ["init"]);
+  runGit(base, ["config", "user.email", "test@test.com"]);
+  runGit(base, ["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "init"]);
+  runGit(base, ["branch", "-M", "main"]);
+
+  runGit(base, ["checkout", "-b", "milestone/M002"]);
+  writeFileSync(join(base, "m002.txt"), "complete but unmerged\n");
+  runGit(base, ["add", "-A"]);
+  runGit(base, ["commit", "-m", "feat: M002 work"]);
+  runGit(base, ["checkout", "main"]);
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M002", title: "Completed milestone", status: "complete" });
+  insertMilestone({ id: "M003", title: "Next milestone", status: "active" });
+  closeDatabase();
+
+  return base;
+}
+
+function makeCtx(notifications: Array<{ message: string; level?: string }>) {
+  const model = { provider: "claude-code", id: "claude-sonnet-4-6", contextWindow: 128000 };
+  return {
+    ui: {
+      notify: (message: string, level?: string) => {
+        notifications.push({ message, level });
+      },
+      setStatus: () => {},
+      setWidget: () => {},
+    },
+    model,
+    modelRegistry: {
+      getAvailable: () => [model],
+      isProviderRequestReady: () => true,
+      getProviderAuthMode: () => "oauth",
+    },
+    sessionManager: {
+      getSessionId: () => "orphan-bootstrap-test",
+      getSessionFile: () => null,
+      getEntries: () => [],
+    },
+  };
+}
+
+test("bootstrap aborts before starting next milestone when completed orphan merge fails", async () => {
+  const base = makeRepoWithUnmergedCompletedMilestone();
+  const previousCwd = process.cwd();
+  const s = new AutoSession();
+  const mergeCalls: string[] = [];
+  const notifications: Array<{ message: string; level?: string }> = [];
+
+  try {
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(notifications) as any,
+      {
+        getThinkingLevel: () => "medium",
+        getActiveTools: () => [],
+        events: { emit: () => {} },
+      } as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => true,
+        registerSigtermHandler: () => {},
+        lockBase: () => base,
+        buildResolver: () => ({
+          mergeAndExit: (milestoneId: string) => {
+            mergeCalls.push(milestoneId);
+            throw new Error("synthetic merge failure");
+          },
+        }) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    assert.equal(ready, false);
+    assert.deepEqual(mergeCalls, ["M002"]);
+    assert.equal(s.active, false);
+    assert.match(
+      notifications.map((entry) => entry.message).join("\n"),
+      /Could not merge orphan milestone M002: synthetic merge failure/,
+    );
+  } finally {
+    try {
+      closeDatabase();
+    } catch {}
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+

package/src/resources/extensions/gsd/tests/auto-start-time-persistence.test.ts

@@ -1,50 +1,32 @@
-// GSD2 — Verify autoStartTime is persisted in paused-session.json and restored on resume
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-
-/**
- * auto-start-time-persistence.test.ts — Ensures autoStartTime survives
- * cross-session resume via paused-session.json (#3585).
- *
- * Source-code regression guards: verify auto.ts saves and restores
- * autoStartTime so the elapsed timer doesn't vanish after /exit + resume.
- */
+// GSD2 — Verify autoStartTime is carried through dashboard state
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
 
-const source = readFileSync(AUTO_TS_PATH, "utf-8");
+import { getAutoDashboardData } from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.ts";
 
-test("pauseAuto persists autoStartTime in paused-session.json (#3585)", () => {
-  assert.ok(
-    source.includes("autoStartTime: s.autoStartTime"),
-    "pausedMeta must include autoStartTime so the timer survives /exit",
-  );
+test.afterEach(() => {
+  autoSession.reset();
 });
 
-test("cross-session resume restores autoStartTime from paused-session.json (#3585)", () => {
-  const matches = source.match(/s\.autoStartTime\s*=\s*meta\.autoStartTime/g);
-  assert.ok(
-    matches && matches.length >= 2,
-    "both resume paths (custom workflow + milestone) must restore autoStartTime from meta",
-  );
-});
+test("getAutoDashboardData exposes the active autoStartTime (#3585)", () => {
+  const start = Date.now() - 5_000;
+  autoSession.active = true;
+  autoSession.autoStartTime = start;
 
-test("resume path falls back to Date.now() when autoStartTime is missing (#3585)", () => {
-  assert.ok(
-    source.includes("meta.autoStartTime || Date.now()"),
-    "restore should fall back to Date.now() for old paused-session files without autoStartTime",
-  );
+  const data = getAutoDashboardData();
+
+  assert.equal(data.startTime, start);
+  assert.ok(data.elapsed >= 0);
 });
 
-test("resume path guards against zero autoStartTime (#3585)", () => {
-  assert.ok(
-    source.includes("if (!s.autoStartTime || s.autoStartTime <= 0) s.autoStartTime = Date.now()"),
-    "resume path must set autoStartTime to Date.now() if still zero after restore",
-  );
+test("getAutoDashboardData suppresses elapsed time when autoStartTime is zero (#3585)", () => {
+  autoSession.active = true;
+  autoSession.autoStartTime = 0;
+
+  const data = getAutoDashboardData();
+
+  assert.equal(data.startTime, 0);
+  assert.equal(data.elapsed, 0);
 });

package/src/resources/extensions/gsd/tests/auto-start-worktree-db-path.test.ts

@@ -1,28 +1,19 @@
-import { readFileSync } from "node:fs";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
+import { resolveProjectRootDbPath } from "../bootstrap/dynamic-tools.ts";
 
-const { assertTrue, report } = createTestContext();
+test("#3822: worktree bootstrap resolves the project-root DB path", (t) => {
+  const project = realpathSync(mkdtempSync(join(tmpdir(), "gsd-project-db-")));
+  t.after(() => rmSync(project, { recursive: true, force: true }));
+  const worktree = join(project, ".gsd", "worktrees", "M001");
+  mkdirSync(worktree, { recursive: true });
 
-const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
-const src = readFileSync(srcPath, "utf-8");
-
-console.log("\n=== #3822: worktree bootstrap uses project DB path ===");
-
-const dbLifecycleIdx = src.indexOf("// ── DB lifecycle ──");
-assertTrue(dbLifecycleIdx > 0, "auto-start.ts has a DB lifecycle section");
-
-const dbLifecycleRegion = dbLifecycleIdx > 0 ? extractSourceRegion(src, "// ── DB lifecycle ──") : "";
-
-assertTrue(
-  dbLifecycleRegion.includes("const gsdDbPath = resolveProjectRootDbPath(s.basePath);"),
-  "DB lifecycle resolves the project-root DB path after worktree entry (#3822)",
-);
-
-assertTrue(
-  !dbLifecycleRegion.includes('join(s.basePath, ".gsd", "gsd.db")'),
-  "DB lifecycle no longer derives gsd.db directly from the worktree path (#3822)",
-);
-
-report();
+  assert.equal(
+    resolveProjectRootDbPath(worktree),
+    join(project, ".gsd", "gsd.db"),
+  );
+});

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

@@ -1,39 +1,54 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { tmpdir } from "node:os";
 
-const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
-const phasesSrc = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
+import { selectAndApplyModel } from "../auto-model-selection.ts";
 
-test("stopAuto restores original thinking level", () => {
-  assert.ok(
-    autoSrc.includes("if (pi && s.originalThinkingLevel)"),
-    "auto.ts should conditionally restore original thinking level in stopAuto",
+test("selectAndApplyModel restores captured thinking level after model selection", async (t) => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-thinking-restore-"));
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning: anthropic/claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
   );
-  assert.ok(
-    autoSrc.includes("pi.setThinkingLevel(s.originalThinkingLevel)"),
-    "auto.ts should call pi.setThinkingLevel with originalThinkingLevel",
-  );
-});
+  process.chdir(base);
 
-test("runUnitPhase threads captured thinking level into selectAndApplyModel", () => {
-  const callIdx = phasesSrc.indexOf("deps.selectAndApplyModel(");
-  assert.ok(callIdx > -1, "phases.ts should call selectAndApplyModel");
-  const callBlock = extractSourceRegion(phasesSrc, "deps.selectAndApplyModel(");
-  assert.ok(
-    callBlock.includes("s.autoModeStartThinkingLevel"),
-    "runUnitPhase should pass autoModeStartThinkingLevel to selectAndApplyModel",
+  const result = await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [{ id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" }] },
+      sessionManager: { getSessionId: () => "thinking-test" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    base,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    { effort: "medium" } as any,
   );
-});
 
-test("hook model override preserves captured thinking level", () => {
-  const hookIdx = phasesSrc.indexOf("const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
-  assert.ok(hookIdx > -1, "phases.ts should include hook model override handling");
-  const hookBlock = extractSourceRegion(phasesSrc, "const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;");
-  assert.ok(
-    hookBlock.includes("pi.setThinkingLevel(s.autoModeStartThinkingLevel)"),
-    "hook model override should re-apply captured thinking level after setModel",
-  );
+  assert.equal(result.appliedModel?.provider, "anthropic");
+  assert.deepEqual(thinkingLevels, [{ effort: "medium" }]);
 });

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -23,11 +23,17 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { buildFlatRateContext } from "../auto-model-selection.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
+import { _isSamePathForTest, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import {
+  checkAutoStartAfterDiscuss,
+  clearPendingAutoStart,
+  setPendingAutoStart,
+} from "../guided-flow.ts";
 
 // ─── Bug 2: this-binding regression ─────────────────────────────────────
 
@@ -62,57 +68,39 @@ test("buildFlatRateContext invokes getProviderAuthMode with correct `this`", ()
 
 // ─── Bug 1: isSamePath source check ─────────────────────────────────────
 
-test("isSamePath short-circuits ENOENT before logging a warning", () => {
-  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const src = readFileSync(srcPath, "utf-8");
-
-  const fnIdx = src.indexOf("function isSamePath");
-  assert.ok(fnIdx !== -1, "isSamePath function exists");
-
-  // Grab the function body (enough to cover the catch block).
-  const fnBody = extractSourceRegion(src, "function isSamePath", { fromIdx: fnIdx });
-
-  const catchIdx = fnBody.indexOf("catch");
-  assert.ok(catchIdx !== -1, "isSamePath has a catch block");
-
-  const enoentIdx = fnBody.indexOf("ENOENT", catchIdx);
-  const warnIdx = fnBody.indexOf("logWarning", catchIdx);
-
-  assert.ok(enoentIdx !== -1, "catch block must handle ENOENT explicitly");
-  assert.ok(warnIdx !== -1, "catch block still warns on non-ENOENT errors");
-  assert.ok(
-    enoentIdx < warnIdx,
-    "ENOENT early-return must precede the logWarning call",
-  );
+test("isSamePath returns false for missing paths without throwing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-same-path-"));
+  try {
+    assert.equal(_isSamePathForTest(join(dir, "missing-a"), join(dir, "missing-b")), false);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+    _resetAutoWorktreeOriginalBaseForTests();
+  }
 });
 
 // ─── Bug 3: guided-flow manifest unlink source check ────────────────────
 
-test("checkAutoStartAfterDiscuss guards DISCUSSION-MANIFEST.json unlink with existsSync", () => {
-  const srcPath = join(import.meta.dirname, "..", "guided-flow.ts");
-  const src = readFileSync(srcPath, "utf-8");
-
-  const fnIdx = src.indexOf("function checkAutoStartAfterDiscuss");
-  assert.ok(fnIdx !== -1, "checkAutoStartAfterDiscuss function exists");
-
-  // Locate the manifest cleanup comment and its surrounding block.
-  const cleanupIdx = src.indexOf(
-    "remove discussion manifest after auto-start",
-    fnIdx,
-  );
-  assert.ok(cleanupIdx !== -1, "manifest cleanup block still exists");
-
-  // Everything from the comment to a short distance below should contain
-  // the existsSync guard before the unlinkSync call.
-  const block = extractSourceRegion(src, "remove discussion manifest after auto-start", { fromIdx: cleanupIdx });
-
-  const existsIdx = block.indexOf("existsSync(manifestPath)");
-  const unlinkIdx = block.indexOf("unlinkSync(manifestPath)");
-
-  assert.ok(existsIdx !== -1, "manifest unlink must be guarded by existsSync");
-  assert.ok(unlinkIdx !== -1, "manifest unlink still happens when file exists");
-  assert.ok(
-    existsIdx < unlinkIdx,
-    "existsSync guard must precede the unlinkSync call",
-  );
+test("checkAutoStartAfterDiscuss completes when discussion manifest is absent", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-discuss-manifest-"));
+  const notifications: Array<{ message: string; level: string }> = [];
+  let scheduled = false;
+  try {
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-CONTEXT.md"), "# Context\n", "utf-8");
+    writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: { ui: { notify: (message: string, level: string) => notifications.push({ message, level }) } } as any,
+      pi: { sendMessage: () => { scheduled = true; } } as any,
+    });
+
+    assert.equal(checkAutoStartAfterDiscuss(), true);
+    assert.equal(scheduled, false);
+    assert.deepEqual(notifications, [{ message: "Milestone M001 ready.", level: "success" }]);
+  } finally {
+    clearPendingAutoStart(base);
+    rmSync(base, { recursive: true, force: true });
+  }
 });