@autonoma-ai/planner 0.1.25 → 0.1.26

package/dist/index.js

@@ -9,11 +9,11 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.3_jiti@2.6.1_postcss@8.5.22_tsx@4.21.0_typescript@7.0.2_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.3_jiti@2.6.1_postcss@8.5.25_tsx@4.21.0_typescript@7.0.2_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.3_jiti@2.6.1_postcss@8.5.22_tsx@4.21.0_typescript@7.0.2_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.3_jiti@2.6.1_postcss@8.5.25_tsx@4.21.0_typescript@7.0.2_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
@@ -1019,6 +1019,11 @@ function budgetFor(step, sizes) {
 }
 function runningFraction(step, now, budget) {
   if (step.sub && step.sub.total > 0) {
+    if (step.sub.done === 0 && step.sub.startedAt != null) {
+      const elapsed = now - step.sub.startedAt;
+      const unspendable = Math.min(budget, RUNNING_MIN_REMAINING_MS);
+      return clamp01((budget - unspendable) * (elapsed / budget));
+    }
     return clamp01(step.sub.done / step.sub.total);
   }
   if (step.startedAt != null) {
@@ -1028,8 +1033,9 @@ function runningFraction(step, now, budget) {
 }
 function liveRemainingMs(step, now) {
   if (step.sub == null || step.sub.total <= 0 || step.startedAt == null) return void 0;
+  if (step.sub.done < LIVE_RATE_MIN_DONE) return void 0;
   const elapsed = now - step.startedAt;
-  if (step.sub.done < LIVE_RATE_MIN_DONE || elapsed < LIVE_RATE_MIN_ELAPSED_MS) return void 0;
+  if (elapsed < LIVE_RATE_MIN_ELAPSED_MS) return void 0;
   return elapsed / step.sub.done * Math.max(0, step.sub.total - step.sub.done);
 }
 function paceRatio(state) {
@@ -1316,6 +1322,19 @@ var init_prompt = __esm({
   }
 });
 
+// src/ui/types.ts
+function isReviewStatus(status) {
+  return REVIEW_STATUSES.has(status);
+}
+var REVIEW_STATUSES;
+var init_types = __esm({
+  "src/ui/types.ts"() {
+    "use strict";
+    init_esm_shims();
+    REVIEW_STATUSES = /* @__PURE__ */ new Set(["REVIEWING", "REVIEWED", "FIXING"]);
+  }
+});
+
 // src/ui/store.ts
 import { join as join5 } from "path";
 function initialSteps() {
@@ -1519,7 +1538,7 @@ function createStore(opts) {
       if (status === "done") {
         for (const id of state.steps[name].artifactIds) {
           const art = artifacts[id];
-          if (art) artifacts[id] = { ...art, status: "DONE" };
+          if (art != null && !isReviewStatus(art.status)) artifacts[id] = { ...art, status: "DONE" };
         }
       }
       set({
@@ -1603,6 +1622,23 @@ function createStore(opts) {
     setLiveFile(relPath, text2, kind) {
       setLiveText(relPath, text2, kind);
     },
+    setArtifactReview(path3, status) {
+      const relPath = relOf(path3);
+      const art = state.artifacts[relPath];
+      if (art == null || art.status === status) return;
+      set({ ...state, artifacts: { ...state.artifacts, [relPath]: { ...art, status } } });
+    },
+    settleReviews() {
+      const artifacts = { ...state.artifacts };
+      let changed = false;
+      for (const [id, art] of Object.entries(artifacts)) {
+        if (art.status !== "REVIEWING" && art.status !== "FIXING") continue;
+        artifacts[id] = { ...art, status: "DONE" };
+        changed = true;
+      }
+      if (!changed) return;
+      set({ ...state, artifacts });
+    },
     finish(outcome) {
       store.stopClock();
       set({
@@ -1709,11 +1745,11 @@ function createStore(opts) {
       if (state.countdown != null) set({ ...state, countdown: void 0 });
       resolve6?.();
     },
-    runWelcome({ title, lines, cta }) {
+    runWelcome({ title, lines, cta, eyebrow }) {
       return new Promise((resolve6) => {
         welcomeResolve = resolve6;
         if (process.stdout.isTTY) process.stdout.write(BELL);
-        set({ ...state, welcome: { title, lines, cta } });
+        set({ ...state, welcome: { title, lines, cta, eyebrow } });
       });
     },
     dismissWelcome() {
@@ -1806,6 +1842,7 @@ var init_store = __esm({
     init_nav();
     init_prompt();
     init_steps();
+    init_types();
     LOG_CAP = 500;
     ACTIVITY_CAP = 200;
     EMIT_COALESCE_MS = 16;
@@ -4702,6 +4739,22 @@ var init_app_links = __esm({
   }
 });
 
+// ../../packages/types/src/agent-handoff-links.ts
+var init_agent_handoff_links = __esm({
+  "../../packages/types/src/agent-handoff-links.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../../packages/types/src/sdk-error-signals.ts
+var init_sdk_error_signals = __esm({
+  "../../packages/types/src/sdk-error-signals.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // ../../packages/types/src/designated-run.ts
 var init_designated_run = __esm({
   "../../packages/types/src/designated-run.ts"() {
@@ -4718,6 +4771,14 @@ var init_deployment_signal_template = __esm({
   }
 });
 
+// ../../packages/types/src/constants/analytics-headers.ts
+var init_analytics_headers = __esm({
+  "../../packages/types/src/constants/analytics-headers.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // ../../packages/types/src/constants/pipeline-labels.ts
 var init_pipeline_labels = __esm({
   "../../packages/types/src/constants/pipeline-labels.ts"() {
@@ -4731,6 +4792,7 @@ var init_constants = __esm({
   "../../packages/types/src/constants/index.ts"() {
     "use strict";
     init_esm_shims();
+    init_analytics_headers();
     init_billing();
     init_pipeline_labels();
   }
@@ -4790,6 +4852,8 @@ var init_src = __esm({
     init_sensitive_detection();
     init_preview_url();
     init_app_links();
+    init_agent_handoff_links();
+    init_sdk_error_signals();
     init_designated_run();
     init_deployment_signal_template();
     init_constants();
@@ -5561,6 +5625,98 @@ var init_autonoma_client = __esm({
   }
 });
 
+// src/core/output.ts
+import { mkdir, rm, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { join as join10 } from "path";
+function getOutputDir(projectSlug) {
+  return join10(AUTONOMA_HOME3, projectSlug);
+}
+async function clearOutputDir(projectSlug) {
+  const dir = getOutputDir(projectSlug);
+  await rm(dir, { recursive: true, force: true });
+  await mkdir(dir, { recursive: true });
+  debugLog("Cleared the run directory for a fresh start", { dir });
+}
+function displayPath(absPath) {
+  const home = homedir3();
+  return absPath.startsWith(home) ? `~${absPath.slice(home.length)}` : absPath;
+}
+async function ensureOutputDir(projectSlug) {
+  const dir = getOutputDir(projectSlug);
+  await mkdir(dir, { recursive: true });
+  const probe = join10(dir, WRITE_PROBE_FILE);
+  try {
+    await writeFile2(probe, "ok", "utf-8");
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Cannot write to ${displayPath(dir)} - the planner keeps every artifact it generates there.
+  ${reason}
+  Free up disk space or fix the directory's permissions, then re-run.`
+    );
+  }
+  await rm(probe, { force: true }).catch((err) => {
+    debugLog("Could not remove the write probe", { probe, err });
+  });
+  return dir;
+}
+var AUTONOMA_HOME3, WRITE_PROBE_FILE;
+var init_output = __esm({
+  "src/core/output.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debug();
+    AUTONOMA_HOME3 = join10(homedir3(), ".autonoma");
+    WRITE_PROBE_FILE = ".write-probe";
+  }
+});
+
+// src/core/preferences.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join11 } from "path";
+import { z as z36 } from "zod";
+async function readPreferences() {
+  try {
+    const raw = await readFile4(PREFERENCES_FILE, "utf-8");
+    const parsed = PreferencesSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      debugLog("Ignoring unreadable preferences file", { issues: parsed.error.issues });
+      return {};
+    }
+    return parsed.data;
+  } catch (err) {
+    debugLog("No preferences to read", { err });
+    return {};
+  }
+}
+async function updatePreferences(update) {
+  try {
+    const current = await readPreferences();
+    const next = { ...current, ...update };
+    await mkdir2(AUTONOMA_HOME3, { recursive: true });
+    await writeFile3(PREFERENCES_FILE, `${JSON.stringify(next, null, 2)}
+`, "utf-8");
+    debugLog("Saved preferences", { update });
+  } catch (err) {
+    debugLog("Could not save preferences", { err });
+  }
+}
+var PREFERENCES_FILE, PreferencesSchema;
+var init_preferences = __esm({
+  "src/core/preferences.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_debug();
+    init_output();
+    PREFERENCES_FILE = join11(AUTONOMA_HOME3, "preferences.json");
+    PreferencesSchema = z36.object({
+      /** The coding agent id (`claude`, `codex`) last chosen from the picker. */
+      agentId: z36.string().optional()
+    });
+  }
+});
+
 // src/core/coding-agent.ts
 var coding_agent_exports = {};
 __export(coding_agent_exports, {
@@ -5588,10 +5744,14 @@ async function selectLauncher(launchers, presetId, interactive = true) {
   const availability = await Promise.all(launchers.map((l) => l.isAvailable()));
   const available = launchers.filter((_, i) => availability[i]);
   debugLog("Detected available agents", { available: available.map((l) => l.id), presetId, interactive });
-  if (presetId != null) {
-    const preset = available.find((l) => l.id === presetId);
-    if (preset != null) return preset;
-    log.warn(`Requested agent "${presetId}" is not installed or not supported.`);
+  const remembered = presetId ?? (await readPreferences()).agentId;
+  if (remembered != null) {
+    const preset = available.find((l) => l.id === remembered);
+    if (preset != null) {
+      if (presetId == null) log.info(`Using ${preset.label} - the agent you picked last time.`);
+      return preset;
+    }
+    if (presetId != null) log.warn(`Requested agent "${presetId}" is not installed or not supported.`);
   }
   if (available.length === 0) return void 0;
   if (available.length === 1) {
@@ -5611,6 +5771,7 @@ async function selectLauncher(launchers, presetId, interactive = true) {
     options: available.map((l) => ({ value: l.id, label: l.label }))
   });
   if (isCancel(selected)) throw new Error("Agent selection cancelled");
+  await updatePreferences({ agentId: selected });
   return available.find((l) => l.id === selected);
 }
 async function selectPermissionMode(preset) {
@@ -5641,6 +5802,7 @@ var init_coding_agent = __esm({
     init_esm_shims();
     init_prompts();
     init_debug();
+    init_preferences();
     MCP_COMMAND_TIMEOUT_MS = 6e4;
     SPAWNED_BY_PLANNER_ENV = "AUTONOMA_PLANNER_SPAWNED_AGENT";
     CODEX_BEARER_TOKEN_ENV = "AUTONOMA_MCP_TOKEN";
@@ -6385,16 +6547,16 @@ var init_notify = __esm({
 });
 
 // src/core/project-map.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { join as join12 } from "path";
-import { z as z36 } from "zod";
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join13 } from "path";
+import { z as z37 } from "zod";
 async function saveProjectMap(outputDir, map) {
-  await writeFile4(join12(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
+  await writeFile5(join13(outputDir, PROJECT_MAP_FILE), JSON.stringify(map, null, 2), "utf-8");
 }
 async function loadProjectMap(outputDir) {
-  const path3 = join12(outputDir, PROJECT_MAP_FILE);
+  const path3 = join13(outputDir, PROJECT_MAP_FILE);
   try {
-    const raw = await readFile5(path3, "utf-8");
+    const raw = await readFile6(path3, "utf-8");
     const parsed = ProjectMapSchema.safeParse(JSON.parse(raw));
     if (parsed.success) return parsed.data;
     debugLog("project-map.json failed schema validation, ignoring it", { path: path3, issues: parsed.error.issues });
@@ -6496,34 +6658,34 @@ var init_project_map = __esm({
     "use strict";
     init_esm_shims();
     init_debug();
-    FrontendEntry = z36.object({
-      path: z36.string().min(1).describe("Repo-relative path to the frontend app/directory (the UI surface)."),
-      framework: z36.string().describe("Detected UI framework/stack, or 'unknown' if not obvious (e.g. next, react, vue, svelte)."),
-      dependsOn: z36.array(z36.string()).describe(
+    FrontendEntry = z37.object({
+      path: z37.string().min(1).describe("Repo-relative path to the frontend app/directory (the UI surface)."),
+      framework: z37.string().describe("Detected UI framework/stack, or 'unknown' if not obvious (e.g. next, react, vue, svelte)."),
+      dependsOn: z37.array(z37.string()).describe(
         "Repo-relative paths (each matching a backend in this map) that THIS frontend needs in order to function - the API/service(s) it calls and the data layer(s) that own the records it renders. These are pre-selected when the user picks this frontend, so only list backends this frontend actually depends on. Empty if it needs none."
       ),
-      why: z36.string().min(1).describe("One line: the evidence that made you classify this as a frontend.")
-    });
-    BackendEntry = z36.object({
-      path: z36.string().min(1).describe("Repo-relative path to the backend/API/service or the package that owns the data layer."),
-      language: z36.string().describe("Primary language, or 'unknown' (e.g. typescript, python, go, rust)."),
-      framework: z36.string().describe("Web/service framework or ORM stack, or 'unknown' (e.g. express, hono, fastapi, rails)."),
-      dataLayer: z36.object({
-        kind: z36.string().describe("How models are defined (e.g. prisma, drizzle, sqlalchemy, typeorm, raw-sql, unknown)."),
-        schemaPath: z36.string().optional().describe("Repo-relative path to the schema/models definition, if found.")
+      why: z37.string().min(1).describe("One line: the evidence that made you classify this as a frontend.")
+    });
+    BackendEntry = z37.object({
+      path: z37.string().min(1).describe("Repo-relative path to the backend/API/service or the package that owns the data layer."),
+      language: z37.string().describe("Primary language, or 'unknown' (e.g. typescript, python, go, rust)."),
+      framework: z37.string().describe("Web/service framework or ORM stack, or 'unknown' (e.g. express, hono, fastapi, rails)."),
+      dataLayer: z37.object({
+        kind: z37.string().describe("How models are defined (e.g. prisma, drizzle, sqlalchemy, typeorm, raw-sql, unknown)."),
+        schemaPath: z37.string().optional().describe("Repo-relative path to the schema/models definition, if found.")
       }).optional().describe("Where this backend's database models live. Omit if this backend owns no data layer."),
-      why: z36.string().min(1).describe("One line: the evidence that made you classify this as a backend.")
+      why: z37.string().min(1).describe("One line: the evidence that made you classify this as a backend.")
     });
-    IgnoreEntry = z36.object({
-      path: z36.string().min(1).describe("Repo-relative path to a directory that is NOT relevant to testing this app."),
-      why: z36.string().min(1).describe("One line: why it is irrelevant (e.g. docs site, infra, tooling, examples, unrelated app).")
+    IgnoreEntry = z37.object({
+      path: z37.string().min(1).describe("Repo-relative path to a directory that is NOT relevant to testing this app."),
+      why: z37.string().min(1).describe("One line: why it is irrelevant (e.g. docs site, infra, tooling, examples, unrelated app).")
     });
-    ProjectMapSchema = z36.object({
-      frontends: z36.array(FrontendEntry).describe("The UI surface(s) whose pages/flows get tested. Usually 1; may be more."),
-      backends: z36.array(BackendEntry).describe(
+    ProjectMapSchema = z37.object({
+      frontends: z37.array(FrontendEntry).describe("The UI surface(s) whose pages/flows get tested. Usually 1; may be more."),
+      backends: z37.array(BackendEntry).describe(
         "The API/service(s) and data layer(s) that own the models we seed. May be 0 (frontend-only), 1, or many."
       ),
-      ignore: z36.array(IgnoreEntry).describe("Directories judged irrelevant to this app's tests, so later steps skip them.")
+      ignore: z37.array(IgnoreEntry).describe("Directories judged irrelevant to this app's tests, so later steps skip them.")
     });
     PROJECT_MAP_FILE = "project-map.json";
   }
@@ -6534,11 +6696,11 @@ var parse_entity_audit_exports = {};
 __export(parse_entity_audit_exports, {
   parseEntityNames: () => parseEntityNames
 });
-import { readFile as readFile7 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join15 } from "path";
 async function parseEntityNames(outputDir) {
   try {
-    const content = await readFile7(join14(outputDir, "entity-audit.md"), "utf-8");
+    const content = await readFile8(join15(outputDir, "entity-audit.md"), "utf-8");
     const names = [];
     for (const line of content.split("\n")) {
       const match = line.match(/^\s+-\s+name:\s+(.+)$/);
@@ -6573,7 +6735,7 @@ var init_count_generated_tests = __esm({
 });
 
 // src/core/display.ts
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function formatArgs(input, keys) {
   const parts = [];
   for (const key of keys) {
@@ -6665,7 +6827,7 @@ function logToStore(store, agentId, info, stats) {
       const folder = String(tc.input.folder ?? "");
       const filename = String(tc.input.filename ?? "");
       if (folder && filename) {
-        store.noteWrite(join15(TESTS_DIR, folder, normalizeTestFilename(filename)));
+        store.noteWrite(join16(TESTS_DIR, folder, normalizeTestFilename(filename)));
       }
     }
     if (tc.name === "bash") {
@@ -6917,7 +7079,7 @@ async function runAgent(config, prompt, extractResult) {
           agent: config.id,
           nudge: nudges
         });
-        messages.push(...generation.response.messages);
+        messages.push(...generation.responseMessages);
         messages.push({ role: "user", content: NUDGE_PROMPT });
         generation = await agent.generate({ messages, ...callOptions });
       }
@@ -6973,8 +7135,8 @@ var init_agent = __esm({
 });
 
 // src/core/gitignore.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join16, relative as relative2 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join17, relative as relative2 } from "path";
 import { glob as glob2 } from "glob";
 async function loadGitignorePatterns(projectRoot) {
   const patterns = [
@@ -6994,10 +7156,10 @@ async function loadGitignorePatterns(projectRoot) {
   ];
   const matches = await glob2("**/.gitignore", { cwd: projectRoot, dot: true });
   for (const match of matches) {
-    const fullPath = join16(projectRoot, match);
+    const fullPath = join17(projectRoot, match);
     try {
-      const content = await readFile8(fullPath, "utf-8");
-      const prefix = relative2(projectRoot, join16(projectRoot, match, ".."));
+      const content = await readFile9(fullPath, "utf-8");
+      const prefix = relative2(projectRoot, join17(projectRoot, match, ".."));
       const parsed = parseGitignore(content, prefix);
       patterns.push(...parsed);
     } catch (err) {
@@ -7060,7 +7222,7 @@ var init_exec_error = __esm({
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { tool } from "ai";
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 function validateCommand(command, allowed) {
   const trimmed = command.trim();
   if (trimmed.length === 0) return "Empty command";
@@ -7126,8 +7288,8 @@ var init_bash = __esm({
     DEFAULT_ALLOWED = /* @__PURE__ */ new Set(["git", "wc", "sort", "head", "tail", "cat", "ls", "find", "diff", "echo"]);
     TIMEOUT_MS = 3e4;
     MAX_OUTPUT_BYTES = 1024 * 512;
-    inputSchema = z37.object({
-      command: z37.string().describe("Shell command to execute")
+    inputSchema = z38.object({
+      command: z38.string().describe("Shell command to execute")
     });
   }
 });
@@ -7135,7 +7297,7 @@ var init_bash = __esm({
 // src/tools/glob.ts
 import { tool as tool2 } from "ai";
 import { glob as glob3 } from "glob";
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 async function executeGlob(pattern, cwd, ignorePatterns = DEFAULT_IGNORE) {
   try {
     const matches = await glob3(pattern, {
@@ -7169,9 +7331,9 @@ var init_glob = __esm({
   "src/tools/glob.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema2 = z38.object({
-      pattern: z38.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
-      cwd: z38.string().optional().describe("Directory to search in. Defaults to working directory.")
+    inputSchema2 = z39.object({
+      pattern: z39.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.py')"),
+      cwd: z39.string().optional().describe("Directory to search in. Defaults to working directory.")
     });
     DEFAULT_IGNORE = [
       "**/node_modules/**",
@@ -7189,7 +7351,7 @@ var init_glob = __esm({
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { tool as tool3 } from "ai";
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function buildGrepTool(workingDirectory) {
   return tool3({
     description: "Search file contents with ripgrep. Returns matching lines with file paths and line numbers.",
@@ -7233,10 +7395,10 @@ var init_grep = __esm({
     init_esm_shims();
     init_exec_error();
     execFileAsync3 = promisify3(execFile4);
-    inputSchema3 = z39.object({
-      pattern: z39.string().describe("Regex pattern to search for in file contents"),
-      glob: z39.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
-      path: z39.string().optional().describe("File or directory to search in")
+    inputSchema3 = z40.object({
+      pattern: z40.string().describe("Regex pattern to search for in file contents"),
+      glob: z40.string().optional().describe("Glob to filter files (e.g. '*.ts')"),
+      path: z40.string().optional().describe("File or directory to search in")
     });
   }
 });
@@ -7244,10 +7406,10 @@ var init_grep = __esm({
 // src/tools/list-directory.ts
 import { readdir } from "fs/promises";
 import { stat } from "fs/promises";
-import { join as join17, relative as relative3 } from "path";
+import { join as join18, relative as relative3 } from "path";
 import { tool as tool4 } from "ai";
 import { minimatch } from "minimatch";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 function buildMatcher(patterns) {
   const positive = patterns.filter((p) => !p.startsWith("!"));
   const negative = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
@@ -7269,7 +7431,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
   const withTypes = [];
   for (const name of rawEntries) {
     try {
-      const s = await stat(join17(dirPath, name));
+      const s = await stat(join18(dirPath, name));
       withTypes.push({ name, isDir: s.isDirectory() });
     } catch {
       withTypes.push({ name, isDir: false });
@@ -7289,7 +7451,7 @@ async function buildTree(dirPath, maxDepth, currentDepth, isIgnored, relativeBas
     }
     if (entry.isDir) {
       const children = await buildTree(
-        join17(dirPath, entry.name),
+        join18(dirPath, entry.name),
         maxDepth,
         currentDepth + 1,
         isIgnored,
@@ -7327,10 +7489,10 @@ async function buildListDirectoryTool(workingDirectory) {
   const isIgnored = buildMatcher(patterns);
   return tool4({
     description: "List directory structure as a tree. Use this for an overview of the project layout. Start at the root (path='.') with depth 3, then increase depth or narrow path if needed. Do NOT call this on every subdirectory - use glob to find specific files instead. Returns cached result if the same path+depth was already requested.",
-    inputSchema: z40.object({
-      path: z40.string().default(".").describe("Directory path relative to project root. Defaults to root."),
-      depth: z40.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
-      gitignore: z40.boolean().describe(
+    inputSchema: z41.object({
+      path: z41.string().default(".").describe("Directory path relative to project root. Defaults to root."),
+      depth: z41.number().min(1).max(15).default(10).describe("Max depth to traverse (1-15). Default 10."),
+      gitignore: z41.boolean().describe(
         "Whether to respect the gitignore or to ignore it. true will respect it. false will ignore it. Default true"
       ).default(true)
     }),
@@ -7342,7 +7504,7 @@ async function buildListDirectoryTool(workingDirectory) {
         };
       }
       seen.add(cacheKey);
-      const targetDir = input.path === "." ? workingDirectory : join17(workingDirectory, input.path);
+      const targetDir = input.path === "." ? workingDirectory : join18(workingDirectory, input.path);
       try {
         const s = await stat(targetDir);
         if (!s.isDirectory()) {
@@ -7378,10 +7540,10 @@ var init_list_directory = __esm({
 });
 
 // src/tools/read-file.ts
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { relative as relative4, resolve as resolve2 } from "path";
 import { tool as tool5 } from "ai";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 function resolveSandboxedPath(workingDirectory, filePath) {
   const absolutePath = resolve2(workingDirectory, filePath);
   const relativePath = relative4(workingDirectory, absolutePath);
@@ -7406,7 +7568,7 @@ async function executeReadFile(workingDirectory, filePath, offset, limit) {
   const resolved = resolveSandboxedPath(workingDirectory, filePath);
   if ("error" in resolved) return resolved;
   try {
-    const content = await readFile9(resolved.absolutePath, "utf-8");
+    const content = await readFile10(resolved.absolutePath, "utf-8");
     const sliced = sliceLines(content, offset ?? 0, limit ?? MAX_LINES);
     if (sliced.numbered.length > MAX_OUTPUT_BYTES2) {
       sliced.numbered = sliced.numbered.slice(0, MAX_OUTPUT_BYTES2) + `
@@ -7439,10 +7601,10 @@ var init_read_file = __esm({
     init_esm_shims();
     MAX_LINES = 2e3;
     MAX_OUTPUT_BYTES2 = 256 * 1024;
-    inputSchema4 = z41.object({
-      filePath: z41.string().describe("Path to the file (absolute or relative to working directory)"),
-      offset: z41.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
-      limit: z41.number().int().min(1).optional().describe("Maximum number of lines to read")
+    inputSchema4 = z42.object({
+      filePath: z42.string().describe("Path to the file (absolute or relative to working directory)"),
+      offset: z42.number().int().min(0).optional().describe("Line number to start reading from (0-based)"),
+      limit: z42.number().int().min(1).optional().describe("Maximum number of lines to read")
     });
   }
 });
@@ -7465,10 +7627,10 @@ var init_pick_string = __esm({
 
 // src/tools/subagent.ts
 import { ToolLoopAgent as ToolLoopAgent2, hasToolCall as hasToolCall2, stepCountIs as stepCountIs2, tool as tool6 } from "ai";
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 function buildSubagentTools(workingDirectory, onFileRead) {
   const baseReadFile = buildReadFileTool(workingDirectory);
-  const readFile25 = onFileRead ? tool6({
+  const readFile26 = onFileRead ? tool6({
     description: baseReadFile.description,
     inputSchema: baseReadFile.inputSchema,
     execute: async (input, options) => {
@@ -7481,7 +7643,7 @@ function buildSubagentTools(workingDirectory, onFileRead) {
     bash: buildBashTool(workingDirectory),
     glob: buildGlobTool(workingDirectory),
     grep: buildGrepTool(workingDirectory),
-    read_file: readFile25
+    read_file: readFile26
   };
 }
 function buildSubagentTool(model, workingDirectory, onHeartbeat, onFileRead) {
@@ -7538,11 +7700,11 @@ var init_subagent = __esm({
     init_glob();
     init_grep();
     init_read_file();
-    inputSchema5 = z42.object({
-      instruction: z42.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
+    inputSchema5 = z43.object({
+      instruction: z43.string().describe("Focused task for the subagent. Be specific about files and patterns to investigate.")
     });
-    resultSchema = z42.object({
-      findings: z42.string().describe("Summary of what was found")
+    resultSchema = z43.object({
+      findings: z43.string().describe("Summary of what was found")
     });
     SYSTEM_PROMPT = `You are a code research assistant. You have tools to explore a codebase: bash (shell commands, mainly git), glob (find files), grep (search content), and read_file (read files).
 
@@ -7553,10 +7715,10 @@ Be thorough but focused - only investigate what's relevant to your instruction.`
 });
 
 // src/tools/write-file.ts
-import { writeFile as writeFile5, mkdir as mkdir2 } from "fs/promises";
+import { writeFile as writeFile6, mkdir as mkdir3 } from "fs/promises";
 import { dirname as dirname2, relative as relative5, resolve as resolve3 } from "path";
 import { tool as tool7 } from "ai";
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 async function executeWriteFile(outputDirectory, filePath, content) {
   const cleaned = filePath.replace(/^autonoma\//, "");
   const absolutePath = resolve3(outputDirectory, cleaned);
@@ -7565,8 +7727,8 @@ async function executeWriteFile(outputDirectory, filePath, content) {
     return { error: "Cannot write files outside the output directory" };
   }
   try {
-    await mkdir2(dirname2(absolutePath), { recursive: true });
-    await writeFile5(absolutePath, content, "utf-8");
+    await mkdir3(dirname2(absolutePath), { recursive: true });
+    await writeFile6(absolutePath, content, "utf-8");
     return { path: relativePath, bytesWritten: content.length };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -7585,21 +7747,21 @@ var init_write_file = __esm({
   "src/tools/write-file.ts"() {
     "use strict";
     init_esm_shims();
-    inputSchema6 = z43.object({
-      filePath: z43.string().describe("Path to write (absolute or relative to output directory)"),
-      content: z43.string().describe("File content to write")
+    inputSchema6 = z44.object({
+      filePath: z44.string().describe("Path to write (absolute or relative to output directory)"),
+      content: z44.string().describe("File content to write")
     });
   }
 });
 
 // src/tools/ask-user.ts
 import { tool as tool8 } from "ai";
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 function buildAskUserTool() {
   return tool8({
     description: "Ask the user a question ONLY when the answer is truly unknowable from the codebase. Valid reasons: untyped JSON/JSONB field schemas, business rules not in code, config values not in source. NEVER ask about: field names (read the schema), field types (read the ORM model), enum values (read the code), relationships (read foreign keys), numeric values (read the seed data or defaults). If you can find it by reading a file, DO NOT ask - read the file instead.",
-    inputSchema: z44.object({
-      question: z44.string().describe(
+    inputSchema: z45.object({
+      question: z45.string().describe(
         "A clear, plain-language question. State exactly what you need to know and why you can't find it in code. BAD: 'What are the decimal values for checking_balance?' - GOOD: 'Your Account model has a metadata JSON column with no type definition. What fields go inside it?'"
       )
     }),
@@ -7659,7 +7821,7 @@ var init_tools = __esm({
 
 // src/agents/00-project-mapper/coverage.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function findUncoveredDirs(projectRoot, map) {
   const entries = [...map.frontends, ...map.backends, ...map.ignore].map(
     (e) => e.path.replace(/^\.\//, "").replace(/\/+$/, "")
@@ -7683,7 +7845,7 @@ async function findUncoveredDirs(projectRoot, map) {
       const childRel = rel === "" ? child.name : `${rel}/${child.name}`;
       if (underEntry(childRel)) continue;
       if (hasEntryWithin(childRel)) {
-        if (depth + 1 < MAX_DEPTH) await walk(join18(abs, child.name), childRel, depth + 1);
+        if (depth + 1 < MAX_DEPTH) await walk(join19(abs, child.name), childRel, depth + 1);
       } else {
         out.push(childRel);
       }
@@ -7710,7 +7872,7 @@ __export(project_mapper_exports, {
   runProjectMapper: () => runProjectMapper
 });
 import { tool as tool9 } from "ai";
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 async function runProjectMapper(input) {
   const model = getModel(input.modelId);
   const { logger, onStepFinish } = buildDefaultStepLogger("project-map", MAX_STEPS);
@@ -7744,7 +7906,7 @@ First build the full inventory (workspace/package manifests + top-level director
         }),
         finish: tool9({
           description: "End this step. Call once set_project_map has recorded a complete map.",
-          inputSchema: z45.object({}),
+          inputSchema: z46.object({}),
           execute: () => {
             if (captured == null) {
               return { error: "Cannot finish: no map recorded - call set_project_map first." };
@@ -7788,7 +7950,7 @@ __export(pages_finder_exports, {
 import { existsSync } from "fs";
 import * as path2 from "path";
 import { tool as tool10 } from "ai";
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 async function runPageFinder(input) {
   const model = getModel(input.modelId);
   const pageCollector = new PageCollector();
@@ -7823,12 +7985,12 @@ ${input.extraMessage}`;
         }),
         view_pages: tool10({
           description: "use this tool to view all the pages that you already added",
-          inputSchema: z46.object(),
+          inputSchema: z47.object(),
           execute: () => pageCollector.viewPages()
         }),
         finish: tool10({
           description: "End this step. Call once every page in the codebase has been added via add_page.",
-          inputSchema: z46.object({}),
+          inputSchema: z47.object({}),
           execute: () => {
             if (pageCollector.pages.size === 0) {
               return {
@@ -7855,10 +8017,10 @@ var init_pages_finder = __esm({
     init_agent();
     init_model();
     init_tools();
-    Page = z46.object({
-      route: z46.string().min(1),
-      path: z46.string().min(1),
-      description: z46.string().min(10)
+    Page = z47.object({
+      route: z47.string().min(1),
+      path: z47.string().min(1),
+      description: z47.string().min(10)
     });
     PageCollector = class {
       // the key is the path
@@ -7887,14 +8049,20 @@ var init_pages_finder = __esm({
 });
 
 // src/core/progress.ts
-function reportSubProgress(step, done, total, unit, note2) {
+function activeAgentNow() {
+  const store = getActiveStore();
+  if (store == null) return void 0;
+  return agentNow(store.getState());
+}
+function reportSubProgress(step, done, total, unit, note2, startedAt) {
   if (total <= 0) return;
-  getActiveStore()?.setSubProgress(step, { done: Math.min(done, total), total, unit, note: note2 });
+  getActiveStore()?.setSubProgress(step, { done: Math.min(done, total), total, unit, note: note2, startedAt });
 }
 var init_progress = __esm({
   "src/core/progress.ts"() {
     "use strict";
     init_esm_shims();
+    init_eta();
     init_store();
   }
 });
@@ -8048,15 +8216,15 @@ var kb_generator_exports = {};
 __export(kb_generator_exports, {
   runKBGenerator: () => runKBGenerator
 });
-import { readFile as readFile10 } from "fs/promises";
-import { join as join19, resolve as resolve5 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join20, resolve as resolve5 } from "path";
 import { tool as tool11 } from "ai";
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 function buildRegisterPagesTool(tracker) {
   return tool11({
     description: "Register ALL page/route files discovered via glob. Call this ONCE after globbing for page files. The system will track which ones you've read and block finish until all are covered.",
-    inputSchema: z47.object({
-      pages: z47.array(z47.string()).describe("All page file paths found by glob")
+    inputSchema: z48.object({
+      pages: z48.array(z48.string()).describe("All page file paths found by glob")
     }),
     execute: async (input) => {
       tracker.register(input.pages);
@@ -8070,7 +8238,7 @@ function buildRegisterPagesTool(tracker) {
 function buildPageCoverageTool(tracker) {
   return tool11({
     description: "Check how many registered pages you've read vs how many remain.",
-    inputSchema: z47.object({}),
+    inputSchema: z48.object({}),
     execute: async () => tracker.coverage()
   });
 }
@@ -8081,9 +8249,9 @@ function requiredReads(total) {
 function buildFinishTool(tracker, onFinish) {
   return tool11({
     description: "Call when you have finished generating the knowledge base. BLOCKED until you have read enough of the registered routes (every route on a small app; a strong majority on a large one) - call page_coverage first to check how many remain.",
-    inputSchema: z47.object({
-      summary: z47.string().describe("Summary of what was generated"),
-      artifacts: z47.array(z47.string()).describe("List of files written")
+    inputSchema: z48.object({
+      summary: z48.string().describe("Summary of what was generated"),
+      artifacts: z48.array(z48.string()).describe("List of files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -8162,8 +8330,8 @@ Output files:
   const agentConfig = buildKbAgentConfig(tracker, model, input, onStepFinish, setResult);
   await runAgent(agentConfig, prompt, () => result);
   logger.summary();
-  const autonomaPath = join19(input.outputDir, "AUTONOMA.md");
-  const autonomaExists = await readFile10(autonomaPath, "utf-8").then(() => true).catch((err) => {
+  const autonomaPath = join20(input.outputDir, "AUTONOMA.md");
+  const autonomaExists = await readFile11(autonomaPath, "utf-8").then(() => true).catch((err) => {
     debugLog("AUTONOMA.md not found while checking step completion", { err });
     return false;
   });
@@ -8349,17 +8517,17 @@ var entity_audit_exports = {};
 __export(entity_audit_exports, {
   runEntityAudit: () => runEntityAudit
 });
-import { readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { join as join21 } from "path";
 import { tool as tool12 } from "ai";
 import { glob as glob4 } from "glob";
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 function buildRegisterModelsTool(tracker) {
   return tool12({
     description: "Register ALL database models discovered via grep. Call this ONCE after grepping for model definitions. After registering, use next_model to process them one at a time.",
-    inputSchema: z48.object({
-      models: z48.array(z48.string()).describe("All model/table names found by grep"),
-      framework: z48.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
+    inputSchema: z49.object({
+      models: z49.array(z49.string()).describe("All model/table names found by grep"),
+      framework: z49.string().describe("Database framework detected (e.g. 'sqlalchemy', 'prisma', 'drizzle')")
     }),
     execute: async (input) => {
       tracker.register(input.models);
@@ -8375,7 +8543,7 @@ function buildRegisterModelsTool(tracker) {
 function buildNextModelTool(tracker) {
   return tool12({
     description: "Get the next model to audit from the queue. If you called next_model before without calling mark_model_audited, the previous model is auto-skipped (marked as no creation path found). Returns done:true when all models are processed.",
-    inputSchema: z48.object({}),
+    inputSchema: z49.object({}),
     execute: async () => {
       const next = tracker.nextModel();
       if (!next) {
@@ -8395,17 +8563,17 @@ function buildNextModelTool(tracker) {
 function buildMarkModelAuditedTool(tracker) {
   return tool12({
     description: "Mark a model as audited after you have determined its creation paths. Call this for EACH model after reading its creation code and determining independently_created + created_by. Include creation_function (e.g. 'UserService.create'), side_effects (list of things the creation does beyond the model itself), and for each created_by entry include owner, via (function name), and why (one sentence explaining the relationship).",
-    inputSchema: z48.object({
-      model: z48.string().describe("Model name"),
-      independently_created: z48.boolean(),
-      creation_file: z48.string().optional().describe("File containing the creation function"),
-      creation_function: z48.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
-      side_effects: z48.array(z48.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
-      created_by: z48.array(
-        z48.object({
-          owner: z48.string().describe("Owner model name"),
-          via: z48.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
-          why: z48.string().optional().describe("One sentence explaining why this model is created as a side effect")
+    inputSchema: z49.object({
+      model: z49.string().describe("Model name"),
+      independently_created: z49.boolean(),
+      creation_file: z49.string().optional().describe("File containing the creation function"),
+      creation_function: z49.string().optional().describe("Function/method name (e.g. 'UserService.create' or 'create_user')"),
+      side_effects: z49.array(z49.string()).optional().describe("Side effects of creation (e.g. 'creates default Settings row', 'hashes password')"),
+      created_by: z49.array(
+        z49.object({
+          owner: z49.string().describe("Owner model name"),
+          via: z49.string().optional().describe("Function that creates this model (e.g. 'OrganizationService.create')"),
+          why: z49.string().optional().describe("One sentence explaining why this model is created as a side effect")
         })
       ).describe("List of owner models that create this as a side effect, empty array if none")
     }),
@@ -8444,16 +8612,16 @@ function buildMarkModelAuditedTool(tracker) {
 function buildModelCoverageTool(tracker) {
   return tool12({
     description: "Check how many registered models you've audited vs how many remain.",
-    inputSchema: z48.object({}),
+    inputSchema: z49.object({}),
     execute: async () => tracker.coverage()
   });
 }
 function buildFinishTool2(tracker, onFinish) {
   return tool12({
     description: "Call when entity audit is complete. BLOCKED if there are unaudited models - call model_coverage first to check.",
-    inputSchema: z48.object({
-      summary: z48.string().describe("Summary of the audit"),
-      artifacts: z48.array(z48.string()).describe("Files written")
+    inputSchema: z49.object({
+      summary: z49.string().describe("Summary of the audit"),
+      artifacts: z49.array(z49.string()).describe("Files written")
     }),
     execute: async (input) => {
       const cov = tracker.coverage();
@@ -8481,7 +8649,7 @@ async function findPrismaSchema(projectRoot) {
   return candidates[0] ?? void 0;
 }
 async function extractPrismaModels(schemaPath) {
-  const content = await readFile11(schemaPath, "utf-8");
+  const content = await readFile12(schemaPath, "utf-8");
   return content.split("\n").filter((line) => line.startsWith("model ")).map((line) => line.split(/\s+/)[1]).filter((name) => name != null);
 }
 async function detectFrameworkAndModels(projectRoot) {
@@ -8568,8 +8736,8 @@ ${formatException(err)}`);
   logger.summary();
   const writeCanonicalAudit = async () => {
     if (tracker.auditedModels.size === 0) return void 0;
-    const auditPath = join20(input.outputDir, "entity-audit.md");
-    await writeFile6(auditPath, tracker.generateAuditMarkdown(), "utf-8");
+    const auditPath = join21(input.outputDir, "entity-audit.md");
+    await writeFile7(auditPath, tracker.generateAuditMarkdown(), "utf-8");
     return auditPath;
   };
   const canonicalPath = await writeCanonicalAudit();
@@ -8583,9 +8751,9 @@ ${formatException(err)}`);
   }
   const reviewed = result;
   if (!reviewed) {
-    const auditPath = join20(input.outputDir, "entity-audit.md");
+    const auditPath = join21(input.outputDir, "entity-audit.md");
     try {
-      await readFile11(auditPath, "utf-8");
+      await readFile12(auditPath, "utf-8");
       return {
         success: true,
         artifacts: ["entity-audit.md"],
@@ -8795,8 +8963,8 @@ on a unique constraint. Everything else stays concrete and static, and no other
 });
 
 // src/agents/03-scenario-recipe/scenario-table.ts
-import { readFile as readFile12 } from "fs/promises";
-import { join as join21 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join22 } from "path";
 import matter2 from "gray-matter";
 function validateScenarioIsConcrete(content) {
   const errors = findUnknownRecipeTokens(content).map(
@@ -8831,22 +8999,22 @@ __export(scenario_recipe_exports, {
   feedbackToScenario: () => feedbackToScenario,
   runScenarioRecipe: () => runScenarioRecipe
 });
-import { readFile as readFile13 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join23 } from "path";
 import { tool as tool13 } from "ai";
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 function buildFinishTool3(requiredEntities, outputDir, onFinish) {
   return tool13({
     description: "Call when scenario design is complete and scenarios.md is written. BLOCKED if any required entities are missing from the scenario.",
-    inputSchema: z49.object({
-      summary: z49.string().describe("Summary of the scenario"),
-      entityCount: z49.number().describe("Number of entity types in the scenario"),
-      artifacts: z49.array(z49.string()).describe("Files written")
+    inputSchema: z50.object({
+      summary: z50.string().describe("Summary of the scenario"),
+      entityCount: z50.number().describe("Number of entity types in the scenario"),
+      artifacts: z50.array(z50.string()).describe("Files written")
     }),
     execute: async (input) => {
       let content;
       try {
-        content = await readFile13(join22(outputDir, "scenarios.md"), "utf-8");
+        content = await readFile14(join23(outputDir, "scenarios.md"), "utf-8");
       } catch {
         return { error: "Cannot finish: scenarios.md not found. Write it first." };
       }
@@ -8925,9 +9093,9 @@ When done, call finish.`;
   logger.summary();
   const reviewed = result;
   if (!reviewed) {
-    const scenariosPath = join22(input.outputDir, "scenarios.md");
+    const scenariosPath = join23(input.outputDir, "scenarios.md");
     try {
-      await readFile13(scenariosPath, "utf-8");
+      await readFile14(scenariosPath, "utf-8");
       return {
         success: true,
         artifacts: ["scenarios.md"],
@@ -8986,12 +9154,12 @@ var init_scenario_recipe = __esm({
 });
 
 // src/agents/04-recipe-builder/entity-order.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join23 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join24 } from "path";
 import matter3 from "gray-matter";
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 async function parseEntityAudit(outputDir) {
-  const raw = await readFile14(join23(outputDir, "entity-audit.md"), "utf-8");
+  const raw = await readFile15(join24(outputDir, "entity-audit.md"), "utf-8");
   try {
     const parsed = frontmatterSchema.safeParse(matter3(raw).data);
     if (parsed.success && parsed.data.models.length > 0) {
@@ -9152,34 +9320,34 @@ var init_entity_order = __esm({
   "src/agents/04-recipe-builder/entity-order.ts"() {
     "use strict";
     init_esm_shims();
-    createdBySchema = z50.object({
-      owner: z50.string(),
-      via: z50.string().optional(),
-      why: z50.string().optional()
+    createdBySchema = z51.object({
+      owner: z51.string(),
+      via: z51.string().optional(),
+      why: z51.string().optional()
     });
-    auditedModelSchema = z50.object({
-      name: z50.string(),
-      independently_created: z50.coerce.boolean().default(false),
-      creation_file: z50.string().optional(),
-      creation_function: z50.string().optional(),
-      side_effects: z50.array(z50.string()).optional(),
+    auditedModelSchema = z51.object({
+      name: z51.string(),
+      independently_created: z51.coerce.boolean().default(false),
+      creation_file: z51.string().optional(),
+      creation_function: z51.string().optional(),
+      side_effects: z51.array(z51.string()).optional(),
       // Tolerate a stray `created_by:` with no entries (parsed as null by YAML).
-      created_by: z50.array(createdBySchema).nullish().transform((v) => v ?? [])
+      created_by: z51.array(createdBySchema).nullish().transform((v) => v ?? [])
     });
-    frontmatterSchema = z50.object({
-      models: z50.array(auditedModelSchema).nullish().transform((v) => v ?? [])
+    frontmatterSchema = z51.object({
+      models: z51.array(auditedModelSchema).nullish().transform((v) => v ?? [])
     });
   }
 });
 
 // src/agents/04-recipe-builder/completion.ts
-import { readFile as readFile15 } from "fs/promises";
-import { join as join24 } from "path";
-import { z as z51 } from "zod";
+import { readFile as readFile16 } from "fs/promises";
+import { join as join25 } from "path";
+import { z as z52 } from "zod";
 async function readCompletion(outputDir) {
   let raw;
   try {
-    raw = await readFile15(join24(outputDir, COMPLETION_MARKER_FILE), "utf-8");
+    raw = await readFile16(join25(outputDir, COMPLETION_MARKER_FILE), "utf-8");
   } catch (err) {
     debugLog("No completion marker yet", { err });
     return false;
@@ -9205,7 +9373,7 @@ var init_completion = __esm({
     init_esm_shims();
     init_debug();
     COMPLETION_MARKER_FILE = ".sdk-integration-complete";
-    completionSchema = z51.object({ complete: z51.literal(true) });
+    completionSchema = z52.object({ complete: z52.literal(true) });
   }
 });
 
@@ -9253,8 +9421,8 @@ var init_completion_watch = __esm({
 });
 
 // src/agents/04-recipe-builder/integration-prompt.ts
-import { writeFile as writeFile7 } from "fs/promises";
-import { join as join25 } from "path";
+import { writeFile as writeFile8 } from "fs/promises";
+import { join as join26 } from "path";
 function renderIntegrationPrompt(params) {
   const priorFailureSection = params.priorFailure != null ? `
 \u2550\u2550\u2550 A PRIOR SESSION DID NOT COMPLETE - READ THIS FIRST \u2550\u2550\u2550
@@ -9543,7 +9711,7 @@ Write the completion marker once ALL of these hold:
 A step you documented as genuinely blocked NEVER justifies withholding the marker; a
 checklist item you simply have not finished always does. The marker is how the CLI knows
 the session is done and can upload the recipe:
-    ${join25(params.outputDir, COMPLETION_MARKER_FILE)}
+    ${join26(params.outputDir, COMPLETION_MARKER_FILE)}
 Its contents MUST be exactly:
     { "complete": true }
 Writing it is not optional: the planner watches for this marker and takes the terminal
@@ -9555,8 +9723,8 @@ or the commit you left behind and what blocked the push - and then says:
 Nothing after that message - no further questions, summaries, or work.`;
 }
 async function writeIntegrationPrompt(params) {
-  const path3 = join25(params.outputDir, INTEGRATION_PROMPT_FILE);
-  await writeFile7(path3, renderIntegrationPrompt(params), "utf-8");
+  const path3 = join26(params.outputDir, INTEGRATION_PROMPT_FILE);
+  await writeFile8(path3, renderIntegrationPrompt(params), "utf-8");
   return path3;
 }
 var INTEGRATION_PROMPT_VERSION, INTEGRATION_PROMPT_FILE, DEFAULT_ENDPOINT_PATH, INTEGRATION_BRANCH;
@@ -9574,8 +9742,8 @@ var init_integration_prompt = __esm({
 });
 
 // src/agents/04-recipe-builder/state.ts
-import { readFile as readFile16, writeFile as writeFile8 } from "fs/promises";
-import { join as join26 } from "path";
+import { readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
+import { join as join27 } from "path";
 function initialRecipeState() {
   return {
     phase: "tech-detect",
@@ -9585,7 +9753,7 @@ function initialRecipeState() {
 }
 async function loadRecipeState(outputDir) {
   try {
-    const raw = await readFile16(join26(outputDir, STATE_FILE2), "utf-8");
+    const raw = await readFile17(join27(outputDir, STATE_FILE2), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -9593,7 +9761,7 @@ async function loadRecipeState(outputDir) {
   }
 }
 async function saveRecipeState(outputDir, state) {
-  await writeFile8(join26(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
+  await writeFile9(join27(outputDir, STATE_FILE2), JSON.stringify(state, null, 2), "utf-8");
 }
 var STATE_FILE2;
 var init_state2 = __esm({
@@ -9606,22 +9774,19 @@ var init_state2 = __esm({
 
 // src/agents/04-recipe-builder/phases/handoff.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function launchMessage(promptFile) {
   return `Read the file ${promptFile} and follow its instructions exactly to integrate Autonoma into this application. It is your complete spec. Do not stop until every item in it is done and you have written the completion marker it describes.`;
 }
 async function runHandoffPhase(state, deps, outputDir) {
-  const recipePath = state.recipePath ?? join27(outputDir, RECIPE_FILE);
+  const recipePath = state.recipePath ?? join28(outputDir, RECIPE_FILE);
   state.recipePath = recipePath;
   const launcher = await selectLauncher(deps.launchers, state.agentId ?? deps.presetAgentId, deps.interactive);
   if (launcher == null) {
     if (!deps.interactive) {
-      return {
-        kind: "handback",
-        summary: "--non-interactive SDK implementation requires an installed, supported coding agent, but none was resolved on your PATH (name one with --agent if more than one is present). Install one, or run interactively."
-      };
+      return { kind: "handback", summary: NO_AGENT_FOUND_HEADLESS };
     }
-    return manualFallback(outputDir, recipePath, deps.cliCommand, "No supported agent found on your PATH.");
+    return manualFallback(outputDir, recipePath, deps.cliCommand, NO_AGENT_FOUND);
   }
   const permissionMode = deps.interactive ? await selectPermissionMode(state.permissionMode ?? deps.presetPermissionMode) : state.permissionMode ?? deps.presetPermissionMode ?? DEFAULT_PERMISSION_MODE;
   state.agentId = launcher.id;
@@ -9640,7 +9805,7 @@ async function runHandoffPhase(state, deps, outputDir) {
   return { kind: "advance" };
 }
 async function runCompletionPhase(state, deps, outputDir) {
-  const recipePath = state.recipePath ?? join27(outputDir, RECIPE_FILE);
+  const recipePath = state.recipePath ?? join28(outputDir, RECIPE_FILE);
   while (true) {
     const [complete, read] = await Promise.all([readCompletion(outputDir), loadRecipe(outputDir)]);
     const uploadProblems = read.status === "ok" ? findRecipeUploadProblems(read.recipe) : [];
@@ -9649,8 +9814,13 @@ async function runCompletionPhase(state, deps, outputDir) {
       log.success("The agent reported the integration complete and validated.");
       return { kind: "advance" };
     }
-    const failure = describeIncompleteRecipe(read, uploadProblems, recipePath, deps.cliCommand);
     const launcher = await selectLauncher(deps.launchers, state.agentId ?? deps.presetAgentId, deps.interactive);
+    const nothingEverRan = read.status === "absent" && launcher == null && (state.launchAttempts ?? 0) === 0;
+    if (nothingEverRan) {
+      if (!deps.interactive) return { kind: "handback", summary: NO_AGENT_FOUND_HEADLESS };
+      return await manualFallback(outputDir, recipePath, deps.cliCommand, NO_AGENT_FOUND);
+    }
+    const failure = describeIncompleteRecipe(read, uploadProblems, recipePath, deps.cliCommand);
     if (launcher != null && (state.launchAttempts ?? 0) < MAX_LAUNCH_ATTEMPTS) {
       log.warn("The integration isn't complete yet. Launching the agent to finish it...");
       state.agentId = launcher.id;
@@ -9674,7 +9844,7 @@ async function runCompletionPhase(state, deps, outputDir) {
 function handbackSummary(failure, outputDir) {
   return `${failure}
 
-Finish the integration (see the prompt at ${join27(outputDir, INTEGRATION_PROMPT_FILE)}), then re-run with --resume.`;
+Finish the integration (see the prompt at ${join28(outputDir, INTEGRATION_PROMPT_FILE)}), then re-run with --resume.`;
 }
 async function launchAgent(launcher, permissionMode, target) {
   const promptFile = await writeIntegrationPrompt({
@@ -9684,7 +9854,7 @@ async function launchAgent(launcher, permissionMode, target) {
     priorFailure: target.priorFailure,
     userGuidance: target.userGuidance
   });
-  await rm2(join27(target.outputDir, COMPLETION_MARKER_FILE), { force: true }).catch((err) => {
+  await rm2(join28(target.outputDir, COMPLETION_MARKER_FILE), { force: true }).catch((err) => {
     debugLog("Could not clear a stale completion marker", { err });
   });
   log.info(`Launching ${launcher.label}. It will implement the integration - watch and steer it as it works.`);
@@ -9736,19 +9906,24 @@ ${recheck}`;
 }
 async function manualFallback(outputDir, recipePath, cliCommand, why) {
   const promptFile = await writeIntegrationPrompt({ outputDir, recipePath, cliCommand });
-  note(
-    `${why}
-
-The full integration instructions have been written to:
-  ${promptFile}
-
-Implement them with your AI assistant (or by hand), get your app running locally, then
-re-run with --resume. The CLI will continue to test generation.`,
-    "Implement the integration yourself"
-  );
-  return { kind: "pause", summary: "Integration handed off for manual implementation - resume when it's ready." };
+  await welcome({
+    eyebrow: "NO CODING AGENT FOUND",
+    title: "Finish this step in the coding agent you already use",
+    lines: [
+      why,
+      "Any coding agent can do this step just as well - Cursor, Windsurf, Copilot, Zed, or whatever you have open. Point yours at this project and paste it this:",
+      `Read ${promptFile} and follow its instructions exactly.`,
+      "That file is the complete spec: the endpoint to implement, the factories to register, and the completion marker it must write when it is done.",
+      `When your agent reports it finished, come back here and run:  ${cliCommand} --resume`
+    ],
+    cta: "Press enter once you have handed it over"
+  });
+  return {
+    kind: "pause",
+    summary: `${why} Integration handed off for manual implementation - resume when it's ready.`
+  };
 }
-var MAX_LAUNCH_ATTEMPTS, HANDOFF_COUNTDOWN_SECONDS;
+var MAX_LAUNCH_ATTEMPTS, HANDOFF_COUNTDOWN_SECONDS, NO_AGENT_FOUND, NO_AGENT_FOUND_HEADLESS;
 var init_handoff = __esm({
   "src/agents/04-recipe-builder/phases/handoff.ts"() {
     "use strict";
@@ -9765,6 +9940,8 @@ var init_handoff = __esm({
     init_state2();
     MAX_LAUNCH_ATTEMPTS = 2;
     HANDOFF_COUNTDOWN_SECONDS = 10;
+    NO_AGENT_FOUND = "Autonoma can launch Claude Code or Codex for you, but neither is on your PATH.";
+    NO_AGENT_FOUND_HEADLESS = "--non-interactive SDK implementation requires an installed, supported coding agent, but none was resolved on your PATH (name one with --agent if more than one is present). Install one, or run interactively.";
   }
 });
 
@@ -9875,17 +10052,17 @@ var init_recipe_builder = __esm({
 });
 
 // src/agents/00b-feature-discovery/index.ts
-import { readFile as readFile17, writeFile as writeFile9 } from "fs/promises";
-import { join as join28 } from "path";
+import { readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
+import { join as join29 } from "path";
 import { tool as tool14 } from "ai";
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 async function saveFeatures(outputDir, features) {
   const obj = Object.fromEntries(features);
-  await writeFile9(join28(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile10(join29(outputDir, FEATURES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadFeatures(outputDir) {
   try {
-    const raw = await readFile17(join28(outputDir, FEATURES_FILE), "utf-8");
+    const raw = await readFile18(join29(outputDir, FEATURES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -9919,7 +10096,7 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         add_feature: tool14({
           description: "Add a discovered sub-feature",
           inputSchema: Feature.extend({
-            id: z52.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
+            id: z53.string().min(1).describe("Unique kebab-case ID (e.g. 'settings-notifications-tab')")
           }),
           execute: (featureInput) => {
             const { id, ...rest } = featureInput;
@@ -9933,17 +10110,17 @@ Process every page. Call add_feature for each sub-feature you discover. When don
         }),
         view_features: tool14({
           description: "View all discovered features so far",
-          inputSchema: z52.object({}),
+          inputSchema: z53.object({}),
           execute: () => collector.viewFeatures()
         }),
         view_pages: tool14({
           description: "View the pages list to know what to analyze",
-          inputSchema: z52.object({}),
+          inputSchema: z53.object({}),
           execute: () => pagesDescription
         }),
         finish: tool14({
           description: "Signal that feature discovery is complete",
-          inputSchema: z52.object({ summary: z52.string() }),
+          inputSchema: z53.object({ summary: z53.string() }),
           execute: async (finishInput) => {
             result = {
               success: true,
@@ -9974,13 +10151,13 @@ var init_b_feature_discovery = __esm({
     init_model();
     init_tools();
     FEATURES_FILE = "features.json";
-    Feature = z52.object({
-      name: z52.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
-      type: z52.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
-      parentPagePath: z52.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
-      sourceFiles: z52.array(z52.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
-      interactiveElements: z52.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
-      description: z52.string().min(10).describe("What this sub-feature does")
+    Feature = z53.object({
+      name: z53.string().min(1).describe("Human-readable name (e.g. 'Settings > Notifications Tab', 'Create Project Modal')"),
+      type: z53.enum(["tab", "modal", "form", "table", "wizard", "nested-route", "complex-component"]),
+      parentPagePath: z53.string().min(1).describe("The page path this feature belongs to (from the pages list)"),
+      sourceFiles: z53.array(z53.string()).min(1).describe("Relative paths to the source files for this sub-feature"),
+      interactiveElements: z53.number().int().min(0).describe("Count of interactive elements found (buttons, inputs, toggles, etc.)"),
+      description: z53.string().min(10).describe("What this sub-feature does")
     });
     FeatureCollector = class {
       features = /* @__PURE__ */ new Map();
@@ -10063,21 +10240,21 @@ Use kebab-case IDs that indicate the parent page and feature type:
 });
 
 // src/agents/05-test-generator/graph.ts
-import { readFile as readFile18, writeFile as writeFile10 } from "fs/promises";
-import { join as join29 } from "path";
+import { readFile as readFile19, writeFile as writeFile11 } from "fs/promises";
+import { join as join30 } from "path";
 function estimateExpectedTests(written, processed, totalNodes) {
   if (totalNodes <= 0) return written;
   const rate = written > 0 && processed >= LIVE_RATE_MIN_PROCESSED ? written / processed : TESTS_PER_NODE_PRIOR;
   return Math.max(written, Math.round(rate * totalNodes));
 }
 async function saveBfsState(outputDir, state) {
-  const path3 = join29(outputDir, state.stateFile);
-  await writeFile10(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
+  const path3 = join30(outputDir, state.stateFile);
+  await writeFile11(path3, JSON.stringify(state.serialize(), null, 2), "utf-8");
 }
 async function loadBfsState(outputDir) {
-  const path3 = join29(outputDir, BFS_STATE_FILE);
+  const path3 = join30(outputDir, BFS_STATE_FILE);
   try {
-    const raw = await readFile18(path3, "utf-8");
+    const raw = await readFile19(path3, "utf-8");
     return CoverageState.deserialize(JSON.parse(raw));
   } catch {
     return void 0;
@@ -10089,6 +10266,7 @@ var init_graph = __esm({
     "use strict";
     init_esm_shims();
     init_progress();
+    init_store();
     BFS_STATE_FILE = ".bfs-state.json";
     JOURNEY_STATE_FILE = ".journey-state.json";
     TESTS_PER_NODE_PRIOR = 3;
@@ -10205,6 +10383,29 @@ var init_graph = __esm({
         this.phase = phase;
         this.reportProgress();
       }
+      /**
+       * Report the review pass as its own sub-progress, distinct from node
+       * exploration. The step strip already shows "13/13 nodes" once generation
+       * finishes; this replaces it with "Review 4/10" so the run does not look
+       * done while the longest silent phase is still ahead.
+       *
+       * `done`/`total` count the tests reviewed this cycle. `startedAt` lets the
+       * ETA bridge the gap before the first completion arrives.
+       */
+      setReviewProgress(done, total, startedAt) {
+        if (!this.reportsProgress) return;
+        const note2 = this.phase;
+        reportSubProgress("testGenerator", done, total, "reviewed", note2, startedAt);
+      }
+      /**
+       * The review pass is over: restore the node-exploration sub-progress on the
+       * strip, and settle the per-test rows so nothing is left claiming to be
+       * under review or awaiting a fix that the budget cut off.
+       */
+      clearReviewProgress() {
+        this.reportProgress();
+        getActiveStore()?.settleReviews();
+      }
       /** Processed nodes (tested or skipped) over the known graph size, labelled
        * with the running phase or - while exploring - a live estimate of the final
        * test count, which isn't known upfront (each node's test count is decided as
@@ -10653,13 +10854,13 @@ When you finish, all dimensions are reported so the user knows what's covered an
 });
 
 // src/agents/05-test-generator/recipe-context.ts
-import { readFile as readFile19 } from "fs/promises";
-import { join as join30 } from "path";
-import { z as z53 } from "zod";
+import { readFile as readFile20 } from "fs/promises";
+import { join as join31 } from "path";
+import { z as z54 } from "zod";
 async function loadRecipeContext(outputDir) {
   let raw;
   try {
-    raw = await readFile19(join30(outputDir, "recipe.json"), "utf-8");
+    raw = await readFile20(join31(outputDir, "recipe.json"), "utf-8");
   } catch (err) {
     debugLog("recipe.json not present; test generation falls back to scenarios.md alone", { err });
     return "";
@@ -10717,13 +10918,13 @@ var init_recipe_context = __esm({
     init_debug();
     STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["_alias", "_ref"]);
     TEMPLATE_TOKEN = /\{\{\s*\w+\s*\}\}/;
-    recipeRowSchema = z53.record(z53.string(), z53.unknown());
-    recipeFileSchema = z53.object({
-      recipes: z53.array(
-        z53.object({
-          name: z53.string(),
-          description: z53.string().optional(),
-          create: z53.record(z53.string(), z53.array(recipeRowSchema)).optional()
+    recipeRowSchema = z54.record(z54.string(), z54.unknown());
+    recipeFileSchema = z54.object({
+      recipes: z54.array(
+        z54.object({
+          name: z54.string(),
+          description: z54.string().optional(),
+          create: z54.record(z54.string(), z54.array(recipeRowSchema)).optional()
         })
       )
     });
@@ -10731,7 +10932,7 @@ var init_recipe_context = __esm({
 });
 
 // src/agents/05-test-generator/restore-deleted-test.ts
-import { access, mkdir as mkdir3, writeFile as writeFile11 } from "fs/promises";
+import { access, mkdir as mkdir4, writeFile as writeFile12 } from "fs/promises";
 import { dirname as dirname3 } from "path";
 async function restoreDeletedTest(testPath, originalContent) {
   try {
@@ -10741,8 +10942,8 @@ async function restoreDeletedTest(testPath, originalContent) {
     debugLog("Test absent after its fix pass - restoring the pre-review content", { testPath, err });
   }
   try {
-    await mkdir3(dirname3(testPath), { recursive: true });
-    await writeFile11(testPath, originalContent, "utf-8");
+    await mkdir4(dirname3(testPath), { recursive: true });
+    await writeFile12(testPath, originalContent, "utf-8");
     return true;
   } catch (err) {
     console.warn(`  [fix] Could not restore ${testPath}: ${err instanceof Error ? err.message : String(err)}`);
@@ -10764,19 +10965,25 @@ var init_restore_deleted_test = __esm({
 });
 
 // src/core/pool.ts
-async function runPool(items, { limit, shouldContinue }, work) {
+async function runPool(items, { limit, shouldContinue, onProgress, onStart }, work) {
   const completed = [];
   const failed = [];
   const skipped = [];
   const inFlight2 = /* @__PURE__ */ new Set();
   let next = 0;
+  const total = items.length;
+  const settled = { n: 0 };
+  const fireProgress = () => onProgress?.(settled.n, total);
   const dispatch = (item, index) => {
+    onStart?.(item, index);
     const promise = work(item, index).then((result) => {
       completed.push({ item, index, result });
     }).catch((error) => {
       failed.push({ item, index, error });
     }).finally(() => {
       inFlight2.delete(promise);
+      settled.n++;
+      fireProgress();
     });
     inFlight2.add(promise);
   };
@@ -10803,21 +11010,21 @@ var init_pool = __esm({
 });
 
 // src/agents/05-test-generator/rubrics.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 function reviewResultSchema(shape) {
-  return z54.object(shape);
+  return z55.object(shape);
 }
 var dimensionResultSchema, reviewResultRecordSchema, structuralIntentRubric, flowCompletenessRubric, uiTextRubric, dataAccuracyRubric, ALL_RUBRICS;
 var init_rubrics = __esm({
   "src/agents/05-test-generator/rubrics.ts"() {
     "use strict";
     init_esm_shims();
-    dimensionResultSchema = z54.object({
-      pass: z54.boolean(),
-      evidence: z54.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
-      suggestion: z54.string().optional().describe("What the planner agent should fix, if failing")
+    dimensionResultSchema = z55.object({
+      pass: z55.boolean(),
+      evidence: z55.string().describe("What you checked and found - cite file paths, line content, or specific strings"),
+      suggestion: z55.string().optional().describe("What the planner agent should fix, if failing")
     });
-    reviewResultRecordSchema = z54.record(z54.string(), dimensionResultSchema);
+    reviewResultRecordSchema = z55.record(z55.string(), dimensionResultSchema);
     structuralIntentRubric = {
       name: "structural-intent",
       maxSteps: 8,
@@ -11063,10 +11270,13 @@ var init_review_pass = __esm({
 });
 
 // src/agents/05-test-generator/review.ts
-import { readFile as readFile20 } from "fs/promises";
-import { join as join31, relative as relative7, basename as basename4 } from "path";
+import { readFile as readFile21 } from "fs/promises";
+import { join as join32, relative as relative7, basename as basename4 } from "path";
 import "ai";
 import { glob as glob5 } from "glob";
+function markReview(relativePath, status) {
+  getActiveStore()?.setArtifactReview(join32(TESTS_DIR, relativePath), status);
+}
 function mergeRubricResults(reported) {
   const merged = {};
   for (const rubric of ALL_RUBRICS) {
@@ -11086,6 +11296,7 @@ async function reviewOneTest({
   test,
   dataContract
 }) {
+  markReview(test.relativePath, "REVIEWING");
   const reported = /* @__PURE__ */ new Map();
   await Promise.all(
     ALL_RUBRICS.map(async (rubric) => {
@@ -11106,35 +11317,37 @@ async function reviewOneTest({
     })
   );
   const dimensions = mergeRubricResults(reported);
+  const failedDimensions = Object.entries(dimensions).filter(([, dim]) => !dim.pass).map(([key]) => key);
+  markReview(test.relativePath, failedDimensions.length === 0 ? "REVIEWED" : "FIXING");
   return {
     relativePath: test.relativePath,
     content: test.content,
     dimensions,
-    failedDimensions: Object.entries(dimensions).filter(([, dim]) => !dim.pass).map(([key]) => key)
+    failedDimensions
   };
 }
 async function readDataContract(outputDir) {
   const recipe = await loadRecipeContext(outputDir);
   if (recipe !== "") return recipe;
   try {
-    return await readFile20(join31(outputDir, "scenarios.md"), "utf-8");
+    return await readFile21(join32(outputDir, "scenarios.md"), "utf-8");
   } catch (err) {
     debugLog("No data contract available for review", { err });
     return void 0;
   }
 }
-async function runConsolidatedReview(outputDir, projectRoot, model, deadline, settled = /* @__PURE__ */ new Set(), precomputed = []) {
-  const testsDir = join31(outputDir, TESTS_DIR);
+async function runConsolidatedReview(outputDir, projectRoot, model, deadline, settled = /* @__PURE__ */ new Set(), precomputed = [], onProgress) {
+  const testsDir = join32(outputDir, TESTS_DIR);
   const logger = createStepLogger("review", 5);
   const scenarioData = await readDataContract(outputDir);
-  const testFiles = await glob5(join31(testsDir, TEST_FILE_GLOB));
+  const testFiles = await glob5(join32(testsDir, TEST_FILE_GLOB));
   const tests = [];
   for (const testPath of testFiles) {
     if (!isTestFile(testPath)) continue;
     if (testPath.includes("/_invalid/")) continue;
     const relativePath = relative7(testsDir, testPath);
     if (settled.has(relativePath)) continue;
-    const content = await readFile20(testPath, "utf-8");
+    const content = await readFile21(testPath, "utf-8");
     const flowMatch = content.match(/^---\n[\s\S]*?flow:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
     tests.push({ path: testPath, relativePath, content, flow: flowMatch?.[1]?.trim() ?? "unknown" });
   }
@@ -11153,15 +11366,24 @@ async function runConsolidatedReview(outputDir, projectRoot, model, deadline, se
     toolErrors: [],
     writtenFiles: []
   });
+  getActiveStore()?.pushActivity({ call: "review", arg: `${toReview.length} tests \xD7 ${ALL_RUBRICS.length} rubrics` });
   let passed = 0;
   let failed = 0;
   const feedback = [];
   const passedPaths = [];
   const byTest = /* @__PURE__ */ new Map();
   let reviewed = 0;
+  onProgress?.(0, jobs.length);
   const outcome = await runPool(
     jobs,
-    { limit: REVIEW_CONCURRENCY, shouldContinue: () => Date.now() <= deadline },
+    {
+      limit: REVIEW_CONCURRENCY,
+      shouldContinue: () => Date.now() <= deadline,
+      onProgress,
+      // Jobs are (test, rubric) pairs, so a test's row lights up on its
+      // first dispatched rubric; the store ignores the repeats.
+      onStart: (job) => markReview(job.test.relativePath, "REVIEWING")
+    },
     (job) => runReviewPass(job.test.content, job.test.relativePath, job.rubric, projectRoot, model, scenarioData)
   );
   for (const { item, error } of outcome.failed) {
@@ -11193,8 +11415,10 @@ async function runConsolidatedReview(outputDir, projectRoot, model, deadline, se
     if (failedDimensions.length === 0) {
       passed++;
       passedPaths.push(test.relativePath);
+      markReview(test.relativePath, "REVIEWED");
     } else {
       failed++;
+      markReview(test.relativePath, "FIXING");
       feedback.push({
         testPath: test.path,
         relativePath: test.relativePath,
@@ -11236,6 +11460,7 @@ var init_review = __esm({
     init_logs();
     init_pool();
     init_test_files();
+    init_store();
     init_recipe_context();
     init_review_pass();
     init_rubrics();
@@ -11381,7 +11606,7 @@ var init_validation = __esm({
 });
 
 // src/agents/05-test-generator/test-spec.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 function hasPlaceholder(text2) {
   if (text2 == null) return false;
   return PLACEHOLDER_PATTERNS.some(({ pattern }) => pattern.test(text2));
@@ -11432,12 +11657,12 @@ var init_test_spec = __esm({
       { pattern: /(?<!\{)\{[a-z][a-zA-Z]*\}(?!\})/, name: "bare {variable}" },
       { pattern: /\be\.g\./i, name: '"e.g." example' }
     ];
-    stepSchema = z55.object({
-      verb: z55.enum(STEP_VERBS).describe("The action. Only these verbs exist."),
-      description: z55.string().min(1).describe(
+    stepSchema = z56.object({
+      verb: z56.enum(STEP_VERBS).describe("The action. Only these verbs exist."),
+      description: z56.string().min(1).describe(
         `What to do or check, naming the exact visible text. For assert, the thing expected on screen - e.g. 'text "Transfer Successful"'.`
       ),
-      location: z55.string().optional().describe(
+      location: z56.string().optional().describe(
         'WHERE on screen the target is - "in the modal", "in the toast notification", "on the Sony WH-1000XM5 product card", "in the dashboard header", "as a page heading". REQUIRED for click, type and assert: the same label routinely appears more than once (a header button and the modal button it opens, "Buy" on every card in a list), and acting on the wrong one fails confusingly. Not needed for scroll or refresh, which act on the page.'
       )
     }).refine((step) => !requiresLocation(step.verb) || (step.location?.trim() ?? "") !== "", {
@@ -11447,27 +11672,27 @@ var init_test_spec = __esm({
       message: "steps carry no variables - use the exact value from the test data, not a placeholder or example",
       path: ["description"]
     });
-    testSpecSchema = z55.object({
-      title: z55.string().min(1).describe("Short, descriptive test name."),
-      description: z55.string().min(1).describe("One sentence explaining what the test verifies."),
-      intent: z55.string().min(30).describe(
+    testSpecSchema = z56.object({
+      title: z56.string().min(1).describe("Short, descriptive test name."),
+      description: z56.string().min(1).describe("One sentence explaining what the test verifies."),
+      intent: z56.string().min(30).describe(
         "A specific, falsifiable claim derived from the node's mission: what the user does, what the feature produces, why it matters. Not the steps, not 'the page displays correctly'."
       ),
-      criticality: z55.enum(CRITICALITY_LEVELS),
-      scenario: z55.string().min(1).describe('Which scenario this test uses (usually "standard").'),
-      flow: z55.string().min(1).describe("Which feature/flow this belongs to (must match a flow from AUTONOMA.md)."),
-      verification: z55.string().min(20).describe(
+      criticality: z56.enum(CRITICALITY_LEVELS),
+      scenario: z56.string().min(1).describe('Which scenario this test uses (usually "standard").'),
+      flow: z56.string().min(1).describe("Which feature/flow this belongs to (must match a flow from AUTONOMA.md)."),
+      verification: z56.string().min(20).describe(
         "WHERE to navigate and WHAT to assert to prove the mutation worked. Must name the source of truth - a toast, a confirmation dialog or an inline success indicator is an acknowledgment, not proof."
       ),
-      setup: z55.string().min(1).describe(
+      setup: z56.string().min(1).describe(
         "Which page the user starts on and how they got there. Never authentication - the user is already signed in."
       ),
-      steps: z55.array(stepSchema).min(1).describe("The action sequence, in order."),
-      verificationSteps: z55.array(stepSchema).describe(
+      steps: z56.array(stepSchema).min(1).describe("The action sequence, in order."),
+      verificationSteps: z56.array(stepSchema).describe(
         "Steps that navigate to the source of truth and assert the mutation landed. Implements the `verification` field above."
       ),
-      expectedResult: z55.string().min(1).describe("What should be true when the test passes."),
-      notes: z55.string().optional().describe(
+      expectedResult: z56.string().min(1).describe("What should be true when the test passes."),
+      notes: z56.string().optional().describe(
         "Optional free text for anything you could not resolve or want to flag - an ambiguous default state, a element you could not find in the source, an assumption you had to make. Recorded for humans and NEVER written into the test file, so it will not affect execution. Use it instead of guessing silently."
       )
     }).refine((spec) => spec.steps.filter((step) => isInteractionVerb(step.verb)).length >= MIN_INTERACTIONS, {
@@ -11478,25 +11703,25 @@ var init_test_spec = __esm({
 });
 
 // src/agents/05-test-generator/tools.ts
-import { mkdir as mkdir4, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname4, join as join32 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile13 } from "fs/promises";
+import { dirname as dirname4, join as join33 } from "path";
 import { hasToolCall as hasToolCall3, stepCountIs as stepCountIs3, tool as tool16, ToolLoopAgent as ToolLoopAgent3 } from "ai";
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 function buildWriteTestTool(state, outputDir, onWritten) {
   return tool16({
     description: "Write one test to qa-tests/{folder}/{filename}.md. You supply the test's parts; the file is rendered for you, so do not write markdown or frontmatter yourself.",
-    inputSchema: z56.object({
-      folder: z56.string().describe("Subfolder name under qa-tests/"),
-      filename: z56.string().describe(`File name ending in ${TEST_FILE_EXT} (e.g. login-valid-credentials${TEST_FILE_EXT})`),
-      nodeId: z56.string().describe(
+    inputSchema: z57.object({
+      folder: z57.string().describe("Subfolder name under qa-tests/"),
+      filename: z57.string().describe(`File name ending in ${TEST_FILE_EXT} (e.g. login-valid-credentials${TEST_FILE_EXT})`),
+      nodeId: z57.string().describe(
         "The id next_node returned for this feature, copied verbatim. Not a re-slugged version of it, not a folder path, not the test filename."
       ),
       test: testSpecSchema
     }),
     execute: async (input) => {
       const content = renderTestMarkdown(input.test);
-      const relPath = join32(TESTS_DIR, input.folder, normalizeTestFilename(input.filename));
-      const absPath = join32(outputDir, relPath);
+      const relPath = join33(TESTS_DIR, input.folder, normalizeTestFilename(input.filename));
+      const absPath = join33(outputDir, relPath);
       const nodeId = state.resolveNodeId(input.nodeId, relPath);
       if (nodeId == null) {
         const stats = state.summary();
@@ -11514,8 +11739,8 @@ function buildWriteTestTool(state, outputDir, onWritten) {
         };
       }
       try {
-        await mkdir4(dirname4(absPath), { recursive: true });
-        await writeFile12(absPath, content, "utf-8");
+        await mkdir5(dirname4(absPath), { recursive: true });
+        await writeFile13(absPath, content, "utf-8");
         state.markTested(nodeId, [relPath]);
         await saveBfsState(outputDir, state);
         const notes = input.test.notes?.trim();
@@ -11528,7 +11753,7 @@ function buildWriteTestTool(state, outputDir, onWritten) {
           });
         }
         onWritten?.({
-          relativePath: join32(input.folder, normalizeTestFilename(input.filename)),
+          relativePath: join33(input.folder, normalizeTestFilename(input.filename)),
           content,
           flow: input.test.flow
         });
@@ -11566,14 +11791,14 @@ function buildWriteTestTool(state, outputDir, onWritten) {
 function buildCreateFolderTool(outputDir) {
   return tool16({
     description: "Create a folder under qa-tests/ for organizing tests.",
-    inputSchema: z56.object({
-      folder: z56.string().describe("Folder name (kebab-case)")
+    inputSchema: z57.object({
+      folder: z57.string().describe("Folder name (kebab-case)")
     }),
     execute: async (input) => {
-      const absPath = join32(outputDir, TESTS_DIR, input.folder);
+      const absPath = join33(outputDir, TESTS_DIR, input.folder);
       try {
-        await mkdir4(absPath, { recursive: true });
-        return { path: join32(TESTS_DIR, input.folder) };
+        await mkdir5(absPath, { recursive: true });
+        return { path: join33(TESTS_DIR, input.folder) };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `Failed to create folder: ${message}` };
@@ -11584,7 +11809,7 @@ function buildCreateFolderTool(outputDir) {
 function buildNextNodeTool(state, outputDir) {
   return tool16({
     description: "Get the next node to write tests for. If you called next_node before without writing any tests (via write_test), the previous node is auto-skipped. Returns done:true when all nodes are processed.",
-    inputSchema: z56.object({}),
+    inputSchema: z57.object({}),
     execute: async () => {
       const next = state.nextNode();
       await saveBfsState(outputDir, state);
@@ -11618,7 +11843,7 @@ function buildNextNodeTool(state, outputDir) {
 function buildGetProgressTool(state) {
   return tool16({
     description: "Check how many nodes have been tested vs how many remain.",
-    inputSchema: z56.object({}),
+    inputSchema: z57.object({}),
     execute: async () => {
       const stats = state.summary();
       const nodes = [...state.nodes.values()].map((n) => ({
@@ -11634,12 +11859,12 @@ function buildGetProgressTool(state) {
 function buildSpawnResearcherTool(model, workingDirectory, onHeartbeat) {
   return tool16({
     description: "Spawn a research subagent to read and analyze source files without polluting your context. Use for complex sub-features where you don't want to read 20 files yourself.",
-    inputSchema: z56.object({
-      instruction: z56.string().describe("What to research - be specific about files and what to look for")
+    inputSchema: z57.object({
+      instruction: z57.string().describe("What to research - be specific about files and what to look for")
     }),
     execute: async (input) => {
-      const resultSchema2 = z56.object({
-        findings: z56.string().describe("Summary of what was found")
+      const resultSchema2 = z57.object({
+        findings: z57.string().describe("Summary of what was found")
       });
       let result;
       const subagent = new ToolLoopAgent3({
@@ -11692,11 +11917,11 @@ var init_tools2 = __esm({
 });
 
 // src/agents/05-test-generator/write-index.ts
-import { readFile as readFile21, writeFile as writeFile13 } from "fs/promises";
-import { join as join33 } from "path";
+import { readFile as readFile22, writeFile as writeFile14 } from "fs/promises";
+import { join as join34 } from "path";
 async function scanTest(outputDir, path3) {
   try {
-    const content = await readFile21(join33(outputDir, path3), "utf-8");
+    const content = await readFile22(join34(outputDir, path3), "utf-8");
     return {
       criticality: content.match(/criticality:\s*(\w+)/)?.[1] ?? "",
       steps: content.match(STEP_VERBS2)?.length ?? 0,
@@ -11767,7 +11992,7 @@ ${folders.map((f) => `| ${f.name} | ${f.test_count} |`).join("\n")}
 
 ${[...testsByFolder.entries()].flatMap(([_folder, tests]) => tests.map((t) => `- \`${t}\``)).join("\n")}
 ${renderSection("Features with no tests", "the run walked these and produced no test for them - re-run the planner to cover them", untested)}${renderSection("Tests lost in review", "the review cycle removed these and nothing could put them back - re-run the planner to regenerate them", lost)}`;
-  await writeFile13(join33(outputDir, TESTS_DIR, TEST_INDEX_FILE), content, "utf-8");
+  await writeFile14(join34(outputDir, TESTS_DIR, TEST_INDEX_FILE), content, "utf-8");
 }
 function untestedFeatures(state) {
   const withTests = new Set(state.testsWritten.keys());
@@ -11802,11 +12027,11 @@ __export(test_generator_exports, {
   runTestGenerator: () => runTestGenerator
 });
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir5, readFile as readFile22, rmdir, unlink, writeFile as writeFile14 } from "fs/promises";
-import { basename as basename5, join as join34 } from "path";
+import { mkdir as mkdir6, readFile as readFile23, rmdir, unlink, writeFile as writeFile15 } from "fs/promises";
+import { basename as basename5, join as join35 } from "path";
 import { tool as tool17 } from "ai";
 import { glob as glob6 } from "glob";
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 async function preseedQueue(state, projectRoot, pages, features) {
   let seeded = 0;
   const pageIdByPath = /* @__PURE__ */ new Map();
@@ -11858,8 +12083,8 @@ async function runTestGenerator(input) {
   let result;
   const finishTool = tool17({
     description: "Call when the BFS queue is empty and all routes have been explored.",
-    inputSchema: z57.object({
-      summary: z57.string().describe("Coverage summary")
+    inputSchema: z58.object({
+      summary: z58.string().describe("Coverage summary")
     }),
     execute: async (finishInput) => {
       const stats = state.summary();
@@ -11887,7 +12112,7 @@ async function runTestGenerator(input) {
   });
   let kbContext = "";
   try {
-    const autonomaMd = await readFile22(join34(input.outputDir, "AUTONOMA.md"), "utf-8");
+    const autonomaMd = await readFile23(join35(input.outputDir, "AUTONOMA.md"), "utf-8");
     kbContext += `
 ## Knowledge Base (AUTONOMA.md)
 
@@ -11900,7 +12125,7 @@ ${autonomaMd}
     kbContext += recipeContext;
   } else {
     try {
-      const scenariosMd = await readFile22(join34(input.outputDir, "scenarios.md"), "utf-8");
+      const scenariosMd = await readFile23(join35(input.outputDir, "scenarios.md"), "utf-8");
       kbContext += `
 ## Scenarios
 
@@ -12092,13 +12317,15 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       console.log(`  Review cycle ${cycle + 1}/${MAX_REVIEW_CYCLES}`);
       state.setPhase(`review cycle ${cycle + 1}/${MAX_REVIEW_CYCLES}`);
       const scanDeadline = Date.now() + Math.floor((reviewDeadline - Date.now()) * REVIEW_SCAN_SHARE);
+      const reviewStartedAt = activeAgentNow() ?? Date.now();
       const reviewResult = await runConsolidatedReview(
         input.outputDir,
         input.projectRoot,
         model,
         scanDeadline,
         settled,
-        cycle === 0 ? pipelined : []
+        cycle === 0 ? pipelined : [],
+        (done, total) => state.setReviewProgress(done, total, reviewStartedAt)
       );
       for (const path3 of reviewResult.passedPaths) settled.add(path3);
       console.log(
@@ -12194,21 +12421,22 @@ IMPORTANT: Do NOT try to finish early. Process every node via next_node until it
       console.log(`  Fix pass complete`);
       if (scanCutShort) break;
     }
+    state.clearReviewProgress();
     state.setPhase("checking every test");
-    const allTestFiles = await glob6(join34(input.outputDir, TESTS_DIR, TEST_FILE_GLOB));
+    const allTestFiles = await glob6(join35(input.outputDir, TESTS_DIR, TEST_FILE_GLOB));
     let markedInvalid = 0;
     for (const testPath of allTestFiles) {
       if (!isTestFile(testPath)) continue;
       if (testPath.includes(`/${INVALID_DIR}/`)) continue;
-      const content = await readFile22(testPath, "utf-8");
+      const content = await readFile23(testPath, "utf-8");
       const validation = validateTestContent(content);
       if (!validation.valid) {
-        const invalidDir = join34(input.outputDir, TESTS_DIR, INVALID_DIR);
-        await mkdir5(invalidDir, { recursive: true });
-        const dest = join34(invalidDir, basename5(testPath));
+        const invalidDir = join35(input.outputDir, TESTS_DIR, INVALID_DIR);
+        await mkdir6(invalidDir, { recursive: true });
+        const dest = join35(invalidDir, basename5(testPath));
         const annotated = `<!-- VALIDATION ERRORS: ${validation.errors.join("; ")} -->
 ${content}`;
-        await writeFile14(dest, annotated, "utf-8");
+        await writeFile15(dest, annotated, "utf-8");
         await unlink(testPath);
         markedInvalid++;
       }
@@ -12216,7 +12444,7 @@ ${content}`;
     if (markedInvalid > 0) {
       console.log(`  ${markedInvalid} tests still invalid after review cycles - moved to _invalid/`);
     }
-    const dirs = await glob6(join34(input.outputDir, TESTS_DIR, "**/"), {
+    const dirs = await glob6(join35(input.outputDir, TESTS_DIR, "**/"), {
       dot: false
     });
     for (const dir of dirs.sort((a, b) => b.length - a.length)) {
@@ -12269,21 +12497,21 @@ async function generateJourneyTests(outputDir, model, projectRoot) {
   let autonomaMd = "";
   let scenariosMd = "";
   try {
-    autonomaMd = await readFile22(join34(outputDir, "AUTONOMA.md"), "utf-8");
+    autonomaMd = await readFile23(join35(outputDir, "AUTONOMA.md"), "utf-8");
   } catch (err) {
     debugLog("AUTONOMA.md not present for journey generation", { err });
   }
   try {
-    scenariosMd = await readFile22(join34(outputDir, "scenarios.md"), "utf-8");
+    scenariosMd = await readFile23(join35(outputDir, "scenarios.md"), "utf-8");
   } catch (err) {
     debugLog("scenarios.md not present for journey generation", { err });
   }
   if (!autonomaMd) return 0;
-  const existingTests = await glob6(join34(outputDir, TESTS_DIR, TEST_FILE_GLOB));
+  const existingTests = await glob6(join35(outputDir, TESTS_DIR, TEST_FILE_GLOB));
   const existingTitles = [];
   for (const t of existingTests) {
     if (!isTestFile(t)) continue;
-    const content = await readFile22(t, "utf-8");
+    const content = await readFile23(t, "utf-8");
     const titleMatch = content.match(/title:\s*"([^"]+)"/);
     if (titleMatch) existingTitles.push(titleMatch[1]);
   }
@@ -12329,7 +12557,7 @@ Write 5-8 journey tests using the write_test tool with folder "${JOURNEY_NODE_ID
   let journeyResult;
   const journeyFinish = tool17({
     description: "Signal journey generation is complete.",
-    inputSchema: z57.object({ summary: z57.string() }),
+    inputSchema: z58.object({ summary: z58.string() }),
     execute: async (finishInput) => {
       journeyResult = {
         success: true,
@@ -12377,6 +12605,7 @@ var init_test_generator = __esm({
     init_gitignore();
     init_logs();
     init_model();
+    init_progress();
     init_test_files();
     init_tools();
     init_b_feature_discovery();
@@ -12488,7 +12717,7 @@ var init_ansi_to_rows = __esm({
 
 // src/replay/types.ts
 var NODE_TYPE;
-var init_types = __esm({
+var init_types2 = __esm({
   "src/replay/types.ts"() {
     "use strict";
     init_esm_shims();
@@ -12572,7 +12801,7 @@ var init_frame_differ = __esm({
     "use strict";
     init_esm_shims();
     init_ansi_to_rows();
-    init_types();
+    init_types2();
     DOCUMENT_ID = 1;
     DOCTYPE_ID = 2;
     HTML_ID = 3;
@@ -13199,7 +13428,7 @@ function drawWelcomeModal(g, state) {
   for (let yy = y; yy < y + h; yy++) g.fillBg(x, yy, w, MODAL_FILL5);
   const bg = MODAL_FILL5;
   let cy = y + 1;
-  g.text(x + 4, cy, "\u25C6 WELCOME TO AUTONOMA", { color: theme.accent, bold: true, bg });
+  g.text(x + 4, cy, `\u25C6 ${wel.eyebrow ?? DEFAULT_EYEBROW}`, { color: theme.accent, bold: true, bg });
   cy += 2;
   for (const line of titleLines) {
     g.text(x + 4, cy, line, { color: theme.text, bold: true, bg });
@@ -13213,7 +13442,7 @@ function drawWelcomeModal(g, state) {
   const ly = y + h - 2;
   g.text(x + 4, ly, wel.cta, { color: theme.accent, bold: true, bg });
 }
-var MODAL_MAX_W5, MODAL_FILL5;
+var MODAL_MAX_W5, MODAL_FILL5, DEFAULT_EYEBROW;
 var init_welcome = __esm({
   "src/ui/draw/welcome.ts"() {
     "use strict";
@@ -13222,6 +13451,7 @@ var init_welcome = __esm({
     init_wrap();
     MODAL_MAX_W5 = 84;
     MODAL_FILL5 = "#141414";
+    DEFAULT_EYEBROW = "WELCOME TO AUTONOMA";
   }
 });
 
@@ -13307,6 +13537,14 @@ function artifactStatusCell(a, now) {
       const frame = SPINNER_FRAMES2[Math.floor(now / WRITING_SPINNER_MS) % SPINNER_FRAMES2.length];
       return { t: `${frame} WRITING`, color: theme.sky };
     }
+    // Deliberately no spinner on REVIEWING: 16 review agents run at once, so
+    // a spinner per row would set most of the list twitching at 5fps.
+    case "REVIEWING":
+      return { t: "REVIEWING", color: theme.violet };
+    case "REVIEWED":
+      return { t: "\u2713 REVIEWED", color: theme.green };
+    case "FIXING":
+      return { t: "FIXING", color: theme.amber };
     default:
       return { t: "PENDING", color: theme.faint };
   }
@@ -13337,7 +13575,8 @@ function drawFiles(g, geo, state, base, bottom) {
     g.text(2, row, icon, { color: theme.tertiary, bg });
     const label = a.title ?? a.name;
     const detail = a.title != null ? [a.name, a.description].filter((s) => s != null).join(" \xB7 ") : a.description;
-    const nameColor = highlighted ? theme.accent : active2 || a.status === "DONE" ? theme.text : theme.secondary;
+    const written = a.status !== "PENDING";
+    const nameColor = highlighted ? theme.accent : written ? theme.text : theme.secondary;
     const nameMax = geo.div - 2 - STATUS_CELL_W - 2 - 5;
     const shown = label.length > nameMax ? label.slice(0, Math.max(1, nameMax - 1)) + "\u2026" : label;
     g.text(5, row, shown, { color: nameColor, bold: highlighted || active2, bg });
@@ -13461,6 +13700,7 @@ function callColor(call) {
   if (call === "done" || call === "success") return theme.green;
   if (call === "warn" || call === "checkpoint") return theme.amber;
   if (call === "error") return theme.red;
+  if (call === "review") return theme.violet;
   return theme.secondary;
 }
 function drawActivity(g, state, top, h) {
@@ -13502,7 +13742,8 @@ function drawDashboard(g, state) {
   drawActivity(g, state, panelBottom, activityRows);
   const exitHint = state.ctrlCArmed ? { k: "Ctrl+C", label: "again to exit (progress saved)", color: theme.red } : { k: "^C ^C", label: "exit", color: theme.red };
   if (state.welcome != null) {
-    drawHints(g, H - 1, [{ k: "enter", label: "begin", color: theme.accent }], [exitHint]);
+    const label = state.welcome.eyebrow == null ? "begin" : "continue";
+    drawHints(g, H - 1, [{ k: "enter", label, color: theme.accent }], [exitHint]);
     drawWelcomeModal(g, state);
     return;
   }
@@ -13658,6 +13899,27 @@ var init_grid = __esm({
         this.h = h;
         this.cells = Array.from({ length: h }, () => Array.from({ length: w }, () => ({ ch: " " })));
       }
+      /**
+       * Reset every cell to a blank space, reusing the existing `cells` arrays.
+       *
+       * Allocation is the leak: a 100x30 terminal allocates 3000 Cell objects
+       * per render, and at 10 renders/second (the clock tick) that is
+       * ~30k objects/second of short-lived garbage. V8's GC runs constantly
+       * to reclaim it, and the GC pauses block the event loop, starving the
+       * pipeline. Clearing in place avoids the allocation entirely.
+       */
+      clear() {
+        for (let y = 0; y < this.h; y++) {
+          const row = this.cells[y];
+          for (let x = 0; x < this.w; x++) {
+            const c = row[x];
+            c.ch = " ";
+            c.color = void 0;
+            c.bg = void 0;
+            c.bold = void 0;
+          }
+        }
+      }
       set(x, y, ch, st = {}) {
         if (y < 0 || y >= this.h || x < 0 || x >= this.w) return;
         const safe = ch < " " ? " " : ch;
@@ -13731,23 +13993,50 @@ var init_grid = __esm({
        * Flatten into per-row ANSI strings (24-bit color escapes). One string per
        * row keeps the Ink tree tiny - rendering thousands of nested <Text> spans
        * per frame is what makes large dashboards crawl.
+       *
+       * Builds the string directly from cells, skipping the intermediate Seg[][]
+       * that `rows()` produces. The Seg array was allocated per render and
+       * immediately discarded - avoiding it cuts another ~600 short-lived objects
+       * per frame.
        */
       ansiRows() {
-        return this.rows().map((segs) => {
-          let out = "";
-          for (const s of segs) {
-            const codes = [];
-            if (s.bold) codes.push("1");
-            if (s.color != null) codes.push(fgCode(s.color));
-            if (s.bg != null) codes.push(bgCode(s.bg));
-            if (codes.length === 0) {
-              out += s.text;
+        const out = [];
+        for (let y = 0; y < this.h; y++) {
+          const row = this.cells[y];
+          let line = "";
+          let curCh = "";
+          let curColor;
+          let curBg;
+          let curBold = false;
+          let hasStyle = false;
+          const flush2 = () => {
+            if (!hasStyle) {
+              line += curCh;
             } else {
-              out += `\x1B[${codes.join(";")}m${s.text}\x1B[0m`;
+              const codes = [];
+              if (curBold) codes.push("1");
+              if (curColor != null) codes.push(fgCode(curColor));
+              if (curBg != null) codes.push(bgCode(curBg));
+              line += `\x1B[${codes.join(";")}m${curCh}\x1B[0m`;
+            }
+            curCh = "";
+          };
+          for (let x = 0; x < this.w; x++) {
+            const c = row[x];
+            const cBold = !!c.bold;
+            if (c.color !== curColor || c.bg !== curBg || cBold !== curBold) {
+              if (curCh !== "") flush2();
+              curColor = c.color;
+              curBg = c.bg;
+              curBold = cBold;
+              hasStyle = curColor != null || curBg != null || curBold;
             }
+            curCh += c.ch;
           }
-          return out;
-        });
+          if (curCh !== "") flush2();
+          out.push(line);
+        }
+        return out;
       }
       /** Flatten into per-row spans, merging adjacent cells with identical style. */
       rows() {
@@ -13775,9 +14064,15 @@ var init_grid = __esm({
 
 // src/ui/screens/Dashboard.tsx
 import { Box, Text } from "ink";
+import { useRef } from "react";
 import { jsx } from "react/jsx-runtime";
 function Dashboard({ state, width, rows }) {
-  const g = new Grid(width, rows);
+  const gridRef = useRef(void 0);
+  if (gridRef.current == null || gridRef.current.w !== width || gridRef.current.h !== rows) {
+    gridRef.current = new Grid(width, rows);
+  }
+  const g = gridRef.current;
+  g.clear();
   drawDashboard(g, state);
   return /* @__PURE__ */ jsx(Box, { flexDirection: "column", width, height: rows, children: g.ansiRows().map((row, y) => /* @__PURE__ */ jsx(Text, { children: row }, y)) });
 }
@@ -14109,14 +14404,14 @@ var init_session_recorder = __esm({
 });
 
 // src/ui/artifacts/reader.ts
-import { open, readFile as readFile23, stat as stat2 } from "fs/promises";
+import { open, readFile as readFile24, stat as stat2 } from "fs/promises";
 async function readForLive(absPath) {
   try {
     const info = await stat2(absPath);
     if (!info.isFile()) return void 0;
     const kind = kindOf(absPath);
     if (info.size <= LARGE_BYTES) {
-      const text2 = await readFile23(absPath, "utf-8");
+      const text2 = await readFile24(absPath, "utf-8");
       return { text: text2, kind, truncated: false };
     }
     const fh = await open(absPath, "r");
@@ -14410,8 +14705,8 @@ ensureSupportedNode();
 
 // src/index.ts
 init_submit();
-import { readFile as readFile24, writeFile as writeFile15 } from "fs/promises";
-import { join as join35 } from "path";
+import { readFile as readFile25, writeFile as writeFile16 } from "fs/promises";
+import { join as join36 } from "path";
 
 // src/agents/04-recipe-builder/sdk-command.ts
 init_esm_shims();
@@ -15499,49 +15794,7 @@ function wrap(text2, width) {
 init_interrupt();
 init_logs();
 init_model();
-
-// src/core/output.ts
-init_esm_shims();
-init_debug();
-import { mkdir, rm, writeFile as writeFile2 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join10 } from "path";
-var AUTONOMA_HOME3 = join10(homedir3(), ".autonoma");
-var WRITE_PROBE_FILE = ".write-probe";
-function getOutputDir(projectSlug) {
-  return join10(AUTONOMA_HOME3, projectSlug);
-}
-async function clearOutputDir(projectSlug) {
-  const dir = getOutputDir(projectSlug);
-  await rm(dir, { recursive: true, force: true });
-  await mkdir(dir, { recursive: true });
-  debugLog("Cleared the run directory for a fresh start", { dir });
-}
-function displayPath(absPath) {
-  const home = homedir3();
-  return absPath.startsWith(home) ? `~${absPath.slice(home.length)}` : absPath;
-}
-async function ensureOutputDir(projectSlug) {
-  const dir = getOutputDir(projectSlug);
-  await mkdir(dir, { recursive: true });
-  const probe = join10(dir, WRITE_PROBE_FILE);
-  try {
-    await writeFile2(probe, "ok", "utf-8");
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(
-      `Cannot write to ${displayPath(dir)} - the planner keeps every artifact it generates there.
-  ${reason}
-  Free up disk space or fix the directory's permissions, then re-run.`
-    );
-  }
-  await rm(probe, { force: true }).catch((err) => {
-    debugLog("Could not remove the write probe", { probe, err });
-  });
-  return dir;
-}
-
-// src/index.ts
+init_output();
 init_session();
 init_ui_lifecycle();
 init_env();
@@ -15550,8 +15803,8 @@ init_prompts();
 // src/core/git.ts
 init_esm_shims();
 import { execFile } from "child_process";
-import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { join as join12 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var GIT_INFO_FILE = ".git-info.json";
@@ -15575,11 +15828,11 @@ async function readGitInfo(projectRoot) {
   };
 }
 async function saveGitInfo(outputDir, info) {
-  await writeFile3(join11(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
+  await writeFile4(join12(outputDir, GIT_INFO_FILE), JSON.stringify(info, null, 2), "utf-8");
 }
 async function loadGitInfo(outputDir) {
   try {
-    const raw = await readFile4(join11(outputDir, GIT_INFO_FILE), "utf-8");
+    const raw = await readFile5(join12(outputDir, GIT_INFO_FILE), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed != null && "sha" in parsed && typeof parsed.sha === "string") {
       const branch = "branch" in parsed && typeof parsed.branch === "string" ? parsed.branch : void 0;
@@ -15601,15 +15854,15 @@ init_state();
 init_esm_shims();
 init_prompts();
 init_debug();
-import { readFile as readFile6 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join14 } from "path";
 init_test_files();
 var ARTIFACT_FILES = ["AUTONOMA.md", "scenarios.md", "entity-audit.md"];
 async function readArtifacts(outputDir) {
   const files = await Promise.all(
     ARTIFACT_FILES.map(async (name) => {
       try {
-        return { name, content: await readFile6(join13(outputDir, name), "utf-8") };
+        return { name, content: await readFile7(join14(outputDir, name), "utf-8") };
       } catch (err) {
         debugLog(`Artifact ${name} not on disk; skipping upload`, { err });
         return void 0;
@@ -15625,7 +15878,7 @@ async function readTestCases(outputDir) {
       const segments = testPath.split("/").slice(1);
       const name = segments[segments.length - 1];
       const folder = segments.slice(0, -1).join("/");
-      const content = await readFile6(join13(outputDir, testPath), "utf-8");
+      const content = await readFile7(join14(outputDir, testPath), "utf-8");
       return { name, content, folder: folder.length > 0 ? folder : void 0 };
     })
   );
@@ -15690,11 +15943,11 @@ process.setSourceMapsEnabled(true);
 var PAGES_FILE = "pages.json";
 async function savePages(outputDir, pages) {
   const obj = Object.fromEntries(pages);
-  await writeFile15(join35(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
+  await writeFile16(join36(outputDir, PAGES_FILE), JSON.stringify(obj, null, 2), "utf-8");
 }
 async function loadPages(outputDir) {
   try {
-    const raw = await readFile24(join35(outputDir, PAGES_FILE), "utf-8");
+    const raw = await readFile25(join36(outputDir, PAGES_FILE), "utf-8");
     const obj = JSON.parse(raw);
     return new Map(Object.entries(obj));
   } catch {
@@ -15745,14 +15998,32 @@ async function resolveScopeSelection(map, config, nonInteractive) {
   return pickDefaultSelection(map);
 }
 async function promptScopeSelection(map) {
+  const onlyFrontend = map.frontends.length === 1 ? map.frontends[0] : void 0;
+  const onlyBackend = map.backends.length === 1 ? map.backends[0] : void 0;
+  if (onlyFrontend != null) {
+    log.info(`Planning tests for ${onlyFrontend.path} [${onlyFrontend.framework}] - the only frontend found.`);
+    if (map.backends.length === 0) return { frontend: onlyFrontend.path, backends: [] };
+    if (onlyBackend != null) {
+      log.info(`Using ${onlyBackend.path} - the only backend found.`);
+      return { frontend: onlyFrontend.path, backends: [onlyBackend.path] };
+    }
+  }
   while (true) {
-    const frontend = await select({
+    const frontend = onlyFrontend?.path ?? await select({
       message: "Which frontend do you want to plan tests for?",
       detail: "One frontend per run - the whole test suite is planned against it.",
-      options: map.frontends.map((f) => ({ value: f.path, label: `${f.path}  [${f.framework}]`, hint: f.why }))
+      options: map.frontends.map((f) => ({
+        value: f.path,
+        label: `${f.path}  [${f.framework}]`,
+        hint: f.why
+      }))
     });
     if (isCancel(frontend)) continue;
     if (map.backends.length === 0) return { frontend, backends: [] };
+    if (onlyBackend != null) {
+      log.info(`Using ${onlyBackend.path} - the only backend found.`);
+      return { frontend, backends: [onlyBackend.path] };
+    }
     const needed = defaultBackendsFor(map, frontend);
     const backends = await multiselect({
       message: "Which backends does this frontend talk to?",
@@ -16117,6 +16388,7 @@ async function main() {
   const projectArg = args.value("project");
   const resumeCommand = `autonoma-planner --resume` + (projectArg != null ? ` --project ${projectArg}` : "");
   let mountedUi;
+  let stoppedAt;
   installInterruptHandler({
     // exitCode defaults to 0 for a user-initiated Ctrl+C (progress saved, a clean stop);
     // an external SIGTERM/SIGHUP passes the conventional 143/129 so the flushed exit still
@@ -16290,9 +16562,11 @@ All of it runs from this one command - there is nothing to launch step by step.`
       const step = steps[i];
       state = await runStepWithRecovery(step, outputDir, state, config, nonInteractive);
       if (state.steps[step] === "paused") {
+        stoppedAt = { label: STEP_LABELS[step], kind: "paused" };
         break;
       }
       if (state.steps[step] === "failed") {
+        stoppedAt = { label: STEP_LABELS[step], kind: "failed" };
         log.error("Pipeline stopped due to failure.");
         log.warn(`Your progress is saved. To retry this step, run:
   ${resumeCommand}`);
@@ -16352,6 +16626,11 @@ All of it runs from this one command - there is nothing to launch step by step.`
     log.info(`Saved in ${displayPath(outputDir)}`);
     if (finish != null) for (const line of describeFinishPhase(finish)) log.info(line);
     log.info(nextStepLine(finish, nonInteractive));
+  } else if (stoppedAt != null) {
+    const verb = stoppedAt.kind === "paused" ? "paused at" : "stopped at";
+    log.warn(`The run ${verb} "${stoppedAt.label}" and did not finish.`);
+    log.info(`Your progress is saved. Continue with:
+  ${resumeCommand}`);
   }
   outro("Done");
 }