@iamu-dev/iamu 0.2.0-beta.10 → 0.2.0-beta.11

package/dist/index.js

@@ -5363,9 +5363,9 @@ function pidIsDead(rec) {
 async function isStale(lockPath, rec, staleMs, now) {
   if (rec === null) {
     try {
-      const stat2 = await fs5.stat(lockPath);
-      if (stat2.size === 0) {
-        const mtime = stat2.birthtimeMs && stat2.birthtimeMs > 0 ? stat2.birthtimeMs : stat2.mtimeMs;
+      const stat3 = await fs5.stat(lockPath);
+      if (stat3.size === 0) {
+        const mtime = stat3.birthtimeMs && stat3.birthtimeMs > 0 ? stat3.birthtimeMs : stat3.mtimeMs;
         if (now - mtime <= staleMs) {
           return false;
         }
@@ -12184,15 +12184,15 @@ function resolveApiUrl(configured) {
   assertSecureApiUrl(url, configured ? "API URL" : "IAMU_API_URL");
   return url;
 }
-function parseStore(raw, path30) {
+function parseStore(raw, path31) {
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    throw new CredentialsFileError(path30, "not valid JSON", err);
+    throw new CredentialsFileError(path31, "not valid JSON", err);
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new CredentialsFileError(path30, "expected a JSON object");
+    throw new CredentialsFileError(path31, "expected a JSON object");
   }
   return parsed;
 }
@@ -12200,26 +12200,26 @@ function isNotFound(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
 async function readCredentialsStore() {
-  const path30 = getCredentialsPath();
+  const path31 = getCredentialsPath();
   let raw;
   try {
-    raw = await readFile(path30, "utf-8");
+    raw = await readFile(path31, "utf-8");
   } catch (err) {
     if (isNotFound(err)) return {};
     warnUnreadableStoreOnce(err);
     throw err;
   }
   try {
-    return parseStore(raw, path30);
+    return parseStore(raw, path31);
   } catch (err) {
     warnUnreadableStoreOnce(err);
     throw err;
   }
 }
 async function writeCredentialsStore(store) {
-  const path30 = getCredentialsPath();
-  await mkdir(dirname(path30), { recursive: true, mode: 448 });
-  await atomicWriteFile(path30, `${JSON.stringify(store, null, 2)}
+  const path31 = getCredentialsPath();
+  await mkdir(dirname(path31), { recursive: true, mode: 448 });
+  await atomicWriteFile(path31, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
@@ -12239,16 +12239,16 @@ function resolveApiKey(apiUrl) {
   } catch {
     return null;
   }
-  const path30 = getCredentialsPath();
+  const path31 = getCredentialsPath();
   let raw;
   try {
-    raw = readFileSync(path30, "utf-8");
+    raw = readFileSync(path31, "utf-8");
   } catch (err) {
     if (!isNotFound(err)) warnUnreadableStoreOnce(err);
     return null;
   }
   try {
-    const entry = parseStore(raw, path30)[url];
+    const entry = parseStore(raw, path31)[url];
     if (typeof entry !== "object" || entry === null) return null;
     const token = entry.token;
     return typeof token === "string" && token ? token : null;
@@ -12287,12 +12287,12 @@ var init_credentials = __esm({
        * @param reason - What is wrong with it.
        * @param cause - Underlying parse error, if any.
        */
-      constructor(path30, reason, cause) {
+      constructor(path31, reason, cause) {
         super(
-          `Credentials file ${path30} is corrupt (${reason}). Fix it by hand, or delete it and run \`iamu auth login\` again.`,
+          `Credentials file ${path31} is corrupt (${reason}). Fix it by hand, or delete it and run \`iamu auth login\` again.`,
           {
             cause,
-            suggestedAction: `Delete ${path30} and run \`iamu auth login\`, or set IAMU_TOKEN.`
+            suggestedAction: `Delete ${path31} and run \`iamu auth login\`, or set IAMU_TOKEN.`
           }
         );
       }
@@ -12301,84 +12301,11 @@ var init_credentials = __esm({
   }
 });
 
-// src/commands/cloud-push.ts
-import chalk3 from "chalk";
-async function pushRunToCloud(projectRoot, runId) {
-  const config = await readConfig(projectRoot);
-  if (!config.cloud_linked) return void 0;
-  const apiKey = resolveApiKey(config.cloud_api_url) ?? void 0;
-  const result = await mirrorLocalWalkthrough(projectRoot, runId, { apiKey });
-  const onCloud = result.mirrored || result.status === "already_pushed";
-  return {
-    mirrored: result.mirrored,
-    status: result.status,
-    ...result.skippedReason ? { skipped_reason: result.skippedReason } : {},
-    ...onCloud ? {
-      url: getCloudDashboardUrl(
-        config.cloud_api_url,
-        config.cloud_project_id,
-        result.runCloudId ?? toCloudRunUuid(runId)
-      )
-    } : {}
-  };
-}
-async function projectDashboardUrl(projectRoot) {
-  const config = await readConfig(projectRoot);
-  if (!config.cloud_linked) return null;
-  return getCloudDashboardUrl(config.cloud_api_url, config.cloud_project_id);
-}
-async function pushedRunUrl(projectRoot, runId) {
-  const config = await readConfig(projectRoot);
-  if (!config.cloud_linked) return null;
-  const lastPush = await readLastPush(projectRoot);
-  if (!lastPush[`walkthrough:${runId}`]) return null;
-  return getCloudDashboardUrl(
-    config.cloud_api_url,
-    config.cloud_project_id,
-    toCloudRunUuid(runId)
-  );
-}
-function printCloudRunInfo(info) {
-  if (!info) return;
-  console.log();
-  if (info.url) {
-    const state = info.mirrored ? "pushed" : "already pushed";
-    console.log(`  ${chalk3.dim("cloud:")}     ${chalk3.green(state)}`);
-    console.log(`  ${chalk3.dim("view:")}      ${chalk3.underline(info.url)}`);
-    return;
-  }
-  if (info.status === "enqueued") {
-    console.log(
-      `  ${chalk3.dim("cloud:")}     ${chalk3.yellow("queued")} ${chalk3.dim("(will retry on next `iamu sync`)")}`
-    );
-    return;
-  }
-  const reason = info.skipped_reason ?? "unknown";
-  const remedy = SKIP_REMEDY[reason];
-  console.log(
-    `  ${chalk3.dim("cloud:")}     ${chalk3.dim(`skipped (${reason})`)}${remedy ? chalk3.dim(` \u2014 ${remedy}`) : ""}`
-  );
-}
-var SKIP_REMEDY;
-var init_cloud_push = __esm({
-  "src/commands/cloud-push.ts"() {
-    "use strict";
-    init_dist2();
-    init_cloud_url();
-    init_credentials();
-    SKIP_REMEDY = {
-      no_api_key: "run `iamu auth login` to restore credentials",
-      bundle_too_large: "reduce screenshot count or resolution, then `iamu sync`",
-      cloud_conflict: "this cloud does not accept updates to a pushed run yet"
-    };
-  }
-});
-
 // src/commands/context.ts
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 import { ZodError } from "zod";
 function commandError(message, opts) {
-  const formatted = opts?.json ? JSON.stringify({ error: message }) : chalk4.red(`  ${message}`);
+  const formatted = opts?.json ? JSON.stringify({ error: message }) : chalk3.red(`  ${message}`);
   console.error(formatted);
   process.exitCode = 1;
 }
@@ -12400,7 +12327,7 @@ async function resolveProject(opts) {
       commandError("No iamu/ found. Run: iamu init", opts);
     } else {
       console.error(
-        chalk4.red("  No iamu/ found.") + chalk4.dim(" Run: iamu init")
+        chalk3.red("  No iamu/ found.") + chalk3.dim(" Run: iamu init")
       );
       process.exitCode = 1;
     }
@@ -12443,7 +12370,7 @@ async function resolveCloudProject(opts) {
       commandError("Not authenticated. Run `iamu auth login` first.", opts);
     } else {
       console.error(
-        chalk4.red("  Not authenticated.") + chalk4.dim(" Run `iamu auth login` first.")
+        chalk3.red("  Not authenticated.") + chalk3.dim(" Run `iamu auth login` first.")
       );
       process.exitCode = 1;
     }
@@ -12481,6 +12408,334 @@ var init_context4 = __esm({
   }
 });
 
+// src/commands/live-run-client.ts
+import { readFile as readFile2, stat } from "fs/promises";
+import path18 from "path";
+import chalk4 from "chalk";
+async function loadLiveRunMeta(runDirPath) {
+  try {
+    const raw = await readFile2(path18.join(runDirPath, "live.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.walkthrough_id === "string" && typeof parsed?.viewer_url === "string" && typeof parsed?.project_id === "string" && typeof parsed?.api_url === "string" && typeof parsed?.last_seq === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveLiveRunMeta(runDirPath, meta) {
+  await atomicWriteFile(
+    path18.join(runDirPath, "live.json"),
+    JSON.stringify(meta, null, 2) + "\n"
+  );
+}
+async function registerLiveRun(params) {
+  if (process.env.IAMU_LIVE === "0") {
+    return null;
+  }
+  try {
+    const config = await readConfig(params.projectRoot).catch(() => null);
+    if (!config?.cloud_linked || !config.cloud_project_id || !config.cloud_api_url) {
+      return null;
+    }
+    const apiKey = resolveApiKey(config.cloud_api_url);
+    if (!apiKey) {
+      return null;
+    }
+    const scenario = await readEntity(
+      params.projectRoot,
+      "scenario",
+      params.scenarioSlug
+    ).catch(() => null);
+    const scenarioId = scenario?.frontmatter?.id;
+    if (!scenarioId) {
+      return null;
+    }
+    const runDirPath = resolveRunDir(params.projectRoot, params.runId);
+    if (!runDirPath) {
+      return null;
+    }
+    const walkthroughId = toCloudRunUuid(params.runId);
+    const apiUrl = config.cloud_api_url.replace(/\/$/, "");
+    const endpoint = `${apiUrl}/api/projects/${encodeURIComponent(config.cloud_project_id)}/live-runs`;
+    const fetcher = params.fetchFn ?? globalThis.fetch;
+    const postLiveRun = () => fetcher(endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        run_id: walkthroughId,
+        scenario_id: scenarioId,
+        target_url: params.targetUrl,
+        started_at: params.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        lenses: params.lenses ?? ["persona"]
+      }),
+      signal: AbortSignal.timeout(REGISTER_TIMEOUT_MS)
+    });
+    let res = await postLiveRun();
+    if (res.status === 422) {
+      const data2 = await res.json().catch(() => null);
+      if (data2?.code === "unknown_scenario") {
+        console.log(
+          chalk4.dim(
+            `  ${symbols.info} Scenario not on cloud yet. Auto-syncing to enable live stream...`
+          )
+        );
+        try {
+          await runSync(params.projectRoot, {
+            apiKey,
+            fetch: fetcher,
+            timeoutMs: REGISTER_TIMEOUT_MS
+          });
+          res = await postLiveRun();
+          if (!res.ok) {
+            console.log(
+              chalk4.dim(
+                `  ${symbols.info} Scenario sync deferred. Run \`iamu sync\` to follow future runs live.`
+              )
+            );
+            return null;
+          }
+        } catch {
+          console.log(
+            chalk4.dim(
+              `  ${symbols.info} Scenario sync deferred. Run \`iamu sync\` to follow future runs live.`
+            )
+          );
+          return null;
+        }
+      } else {
+        return null;
+      }
+    }
+    if (!res.ok) {
+      return null;
+    }
+    const data = await res.json();
+    const meta = {
+      walkthrough_id: data.walkthrough_id,
+      viewer_url: data.viewer_url,
+      project_id: config.cloud_project_id,
+      api_url: config.cloud_api_url,
+      last_seq: 0
+    };
+    await saveLiveRunMeta(runDirPath, meta);
+    return {
+      walkthroughId: data.walkthrough_id,
+      viewerUrl: data.viewer_url,
+      status: data.status
+    };
+  } catch {
+    return null;
+  }
+}
+async function sendLiveEvents(projectRoot, runId, buildEvents, fetchFn) {
+  try {
+    const runDirPath = resolveRunDir(projectRoot, runId);
+    if (!runDirPath) return {};
+    const meta = await loadLiveRunMeta(runDirPath);
+    if (!meta) return {};
+    const config = await readConfig(projectRoot).catch(() => null);
+    if (!config?.cloud_linked) return {};
+    const apiKey = resolveApiKey(meta.api_url) ?? resolveApiKey(config.cloud_api_url);
+    if (!apiKey) return {};
+    const raw = buildEvents(meta.last_seq + 1);
+    const events = Array.isArray(raw) ? raw : [raw];
+    if (events.length === 0) return {};
+    const maxSeq = Math.max(...events.map((e) => e.seq));
+    meta.last_seq = Math.max(meta.last_seq, maxSeq);
+    await saveLiveRunMeta(runDirPath, meta).catch(() => {
+    });
+    const apiUrl = meta.api_url.replace(/\/$/, "");
+    const endpoint = `${apiUrl}/api/projects/${encodeURIComponent(meta.project_id)}/live-runs/${encodeURIComponent(meta.walkthrough_id)}/events`;
+    const fetcher = fetchFn ?? globalThis.fetch;
+    const res = await fetcher(endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ events }),
+      signal: AbortSignal.timeout(EVENT_TIMEOUT_MS)
+    });
+    if (!res.ok) {
+      return {};
+    }
+    const data = await res.json().catch(() => null);
+    return {
+      accepted_seq: data?.accepted_seq,
+      cancelled: data?.cancelled === true
+    };
+  } catch {
+    return {};
+  }
+}
+async function sendLiveStep(projectRoot, runId, step, screenshotPath, fetchFn) {
+  try {
+    const runDirPath = resolveRunDir(projectRoot, runId);
+    if (!runDirPath) return {};
+    const meta = await loadLiveRunMeta(runDirPath);
+    if (!meta) return {};
+    let screenshot_base64;
+    if (screenshotPath) {
+      try {
+        const fileStat = await stat(screenshotPath);
+        if (fileStat.isFile() && fileStat.size <= MAX_LIVE_SCREENSHOT_BYTES) {
+          const buf = await readFile2(screenshotPath);
+          screenshot_base64 = buf.toString("base64");
+        }
+      } catch {
+      }
+    }
+    return await sendLiveEvents(
+      projectRoot,
+      runId,
+      (seq2) => ({
+        seq: seq2,
+        type: "step",
+        step: {
+          number: step.step_number,
+          title: step.action,
+          persona_reasoning: step.note ?? void 0,
+          grounding: step.grounding ?? void 0,
+          page_url: step.url ?? void 0,
+          surface: step.surface ?? void 0,
+          ...screenshot_base64 ? { screenshot_base64 } : {}
+        }
+      }),
+      fetchFn
+    );
+  } catch {
+    return {};
+  }
+}
+async function sendLivePhase(projectRoot, runId, phase, fetchFn) {
+  return sendLiveEvents(
+    projectRoot,
+    runId,
+    (seq2) => ({
+      seq: seq2,
+      type: "phase",
+      phase
+    }),
+    fetchFn
+  );
+}
+async function sendLiveFinding(projectRoot, runId, finding, fetchFn) {
+  return sendLiveEvents(
+    projectRoot,
+    runId,
+    (seq2) => ({
+      seq: seq2,
+      type: "finding",
+      finding: {
+        id: finding.id,
+        title: finding.title,
+        type: finding.type,
+        severity: finding.severity,
+        ui_fact: finding.ui_fact ?? void 0,
+        consequence: finding.consequence ?? void 0,
+        step_number: finding.step_number ?? void 0,
+        task_impact: finding.task_impact ?? void 0,
+        confidence: finding.confidence ?? void 0
+      }
+    }),
+    fetchFn
+  );
+}
+var REGISTER_TIMEOUT_MS, EVENT_TIMEOUT_MS, MAX_LIVE_SCREENSHOT_BYTES;
+var init_live_run_client = __esm({
+  "src/commands/live-run-client.ts"() {
+    "use strict";
+    init_dist2();
+    init_symbols();
+    init_context4();
+    init_credentials();
+    REGISTER_TIMEOUT_MS = 3e3;
+    EVENT_TIMEOUT_MS = 1500;
+    MAX_LIVE_SCREENSHOT_BYTES = 5 * 1024 * 1024;
+  }
+});
+
+// src/commands/cloud-push.ts
+import chalk5 from "chalk";
+async function pushRunToCloud(projectRoot, runId) {
+  const config = await readConfig(projectRoot);
+  if (!config.cloud_linked) return void 0;
+  await sendLivePhase(projectRoot, runId, "publishing").catch(() => {
+  });
+  const apiKey = resolveApiKey(config.cloud_api_url) ?? void 0;
+  const result = await mirrorLocalWalkthrough(projectRoot, runId, { apiKey });
+  const onCloud = result.mirrored || result.status === "already_pushed";
+  return {
+    mirrored: result.mirrored,
+    status: result.status,
+    ...result.skippedReason ? { skipped_reason: result.skippedReason } : {},
+    ...onCloud ? {
+      url: getCloudDashboardUrl(
+        config.cloud_api_url,
+        config.cloud_project_id,
+        result.runCloudId ?? toCloudRunUuid(runId)
+      )
+    } : {}
+  };
+}
+async function projectDashboardUrl(projectRoot) {
+  const config = await readConfig(projectRoot);
+  if (!config.cloud_linked) return null;
+  return getCloudDashboardUrl(config.cloud_api_url, config.cloud_project_id);
+}
+async function pushedRunUrl(projectRoot, runId) {
+  const config = await readConfig(projectRoot);
+  if (!config.cloud_linked) return null;
+  const lastPush = await readLastPush(projectRoot);
+  if (!lastPush[`walkthrough:${runId}`]) return null;
+  return getCloudDashboardUrl(
+    config.cloud_api_url,
+    config.cloud_project_id,
+    toCloudRunUuid(runId)
+  );
+}
+function printCloudRunInfo(info) {
+  if (!info) return;
+  console.log();
+  if (info.url) {
+    const state = info.mirrored ? "pushed" : "already pushed";
+    console.log(`  ${chalk5.dim("cloud:")}     ${chalk5.green(state)}`);
+    console.log(`  ${chalk5.dim("view:")}      ${chalk5.underline(info.url)}`);
+    return;
+  }
+  if (info.status === "enqueued") {
+    console.log(
+      `  ${chalk5.dim("cloud:")}     ${chalk5.yellow("queued")} ${chalk5.dim("(will retry on next `iamu sync`)")}`
+    );
+    return;
+  }
+  const reason = info.skipped_reason ?? "unknown";
+  const remedy = SKIP_REMEDY[reason];
+  console.log(
+    `  ${chalk5.dim("cloud:")}     ${chalk5.dim(`skipped (${reason})`)}${remedy ? chalk5.dim(` \u2014 ${remedy}`) : ""}`
+  );
+}
+var SKIP_REMEDY;
+var init_cloud_push = __esm({
+  "src/commands/cloud-push.ts"() {
+    "use strict";
+    init_dist2();
+    init_cloud_url();
+    init_credentials();
+    init_live_run_client();
+    SKIP_REMEDY = {
+      no_api_key: "run `iamu auth login` to restore credentials",
+      bundle_too_large: "reduce screenshot count or resolution, then `iamu sync`",
+      cloud_conflict: "this cloud does not accept updates to a pushed run yet"
+    };
+  }
+});
+
 // src/adapters/claude-plugin.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -12712,10 +12967,10 @@ var init_templates = __esm({
 
 // src/commands/skills.ts
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { mkdir as mkdir2, readFile as readFile2, rm, rmdir, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, rm, rmdir, writeFile } from "fs/promises";
 import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 function getVersion() {
   try {
     const thisDir = dirname3(fileURLToPath2(import.meta.url));
@@ -12805,22 +13060,22 @@ function commandsFromSkills(templates) {
 }
 async function needsWrite(filePath, content) {
   try {
-    const existing = await readFile2(filePath, "utf-8");
+    const existing = await readFile3(filePath, "utf-8");
     return existing !== content;
   } catch {
     return true;
   }
 }
-function isCliWrittenSkill(path30) {
+function isCliWrittenSkill(path31) {
   try {
-    return /^generatedBy:/m.test(readFileSync3(path30, "utf-8"));
+    return /^generatedBy:/m.test(readFileSync3(path31, "utf-8"));
   } catch {
     return false;
   }
 }
-function isCliWrittenPrompt(path30) {
+function isCliWrittenPrompt(path31) {
   try {
-    const content = readFileSync3(path30, "utf-8");
+    const content = readFileSync3(path31, "utf-8");
     return content.includes("iamu") || /^generatedBy:/m.test(content);
   } catch {
     return false;
@@ -12832,8 +13087,8 @@ function planSkillFiles(hosts, projectRoot, version) {
   for (const host of hosts) {
     if (pluginProvidesSkills(host, projectRoot)) {
       for (const name of skillTemplates.keys()) {
-        const path30 = join4(host.getSkillsDir(projectRoot), name, "SKILL.md");
-        if (isCliWrittenSkill(path30)) files.push({ host, path: path30, content: null });
+        const path31 = join4(host.getSkillsDir(projectRoot), name, "SKILL.md");
+        if (isCliWrittenSkill(path31)) files.push({ host, path: path31, content: null });
       }
     } else if (host.supportsSkills) {
       const skillsDir = host.getSkillsDir(projectRoot);
@@ -12989,7 +13244,7 @@ async function installSkillsForHosts(hosts, projectRoot, version, opts) {
         );
       } else {
         console.log(
-          `  ${symbols.success} ${chalk5.dim(`${host.name} \u2014 up to date`)}`
+          `  ${symbols.success} ${chalk6.dim(`${host.name} \u2014 up to date`)}`
         );
       }
     }
@@ -13014,11 +13269,11 @@ var sync_exports = {};
 __export(sync_exports, {
   sync: () => sync
 });
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 async function warnStaleSkills(projectRoot) {
   try {
     if ((await findStaleSkills(projectRoot)).length > 0) {
-      console.log(chalk6.yellow(`  ${STALE_SKILLS_MESSAGE}`));
+      console.log(chalk7.yellow(`  ${STALE_SKILLS_MESSAGE}`));
     }
   } catch {
   }
@@ -13046,11 +13301,11 @@ function describeCounts(byType) {
 function printPendingDeletes(pending) {
   console.log();
   console.log(
-    chalk6.yellow(
+    chalk7.yellow(
       `  \u26A0 ${pending.total} local deletion${pending.total !== 1 ? "s" : ""} not sent to the cloud \u2014 check the list, then run \`iamu sync --confirm-deletes\``
     )
   );
-  console.log(chalk6.dim(`    Why: ${pending.reasons.join("; ")}`));
+  console.log(chalk7.dim(`    Why: ${pending.reasons.join("; ")}`));
   const byType = /* @__PURE__ */ new Map();
   for (const e of pending.entities) {
     const list2 = byType.get(e.type) ?? [];
@@ -13062,18 +13317,18 @@ function printPendingDeletes(pending) {
       `    ${describeDeletionCount(type2, list2.length)}${type2 === "unknown" ? " (synced before this CLI recorded types; by id)" : ""}:`
     );
     for (const e of list2.slice(0, MAX_LISTED_PER_TYPE)) {
-      console.log(chalk6.dim(`      ${e.label}`));
+      console.log(chalk7.dim(`      ${e.label}`));
     }
     if (list2.length > MAX_LISTED_PER_TYPE) {
       console.log(
-        chalk6.dim(
+        chalk7.dim(
           `      \u2026 and ${list2.length - MAX_LISTED_PER_TYPE} more (\`iamu sync --json\` lists all)`
         )
       );
     }
   }
   console.log(
-    chalk6.dim(
+    chalk7.dim(
       "    To keep an entity on the cloud instead, restore its file (`iamu pull` brings entities back; runs cannot be pulled)."
     )
   );
@@ -13112,24 +13367,24 @@ async function sync(opts) {
     } else {
       if (!quiet) console.log();
       console.log(
-        `  ${chalk6.bold("Sync Status:")} ${totalPending === 0 ? chalk6.green("in sync") : chalk6.yellow(`${totalPending} item(s) to sync`)}`
+        `  ${chalk7.bold("Sync Status:")} ${totalPending === 0 ? chalk7.green("in sync") : chalk7.yellow(`${totalPending} item(s) to sync`)}`
       );
       if (totalPending > 0) {
         if (pendingNew > 0)
-          console.log(chalk6.dim(`    ${pendingNew} new entity file(s)`));
+          console.log(chalk7.dim(`    ${pendingNew} new entity file(s)`));
         if (pendingUpdates > 0)
           console.log(
-            chalk6.dim(`    ${pendingUpdates} modified entity file(s)`)
+            chalk7.dim(`    ${pendingUpdates} modified entity file(s)`)
           );
         if (pendingWalkthroughs > 0)
           console.log(
-            chalk6.dim(`    ${pendingWalkthroughs} unpushed walkthrough run(s)`)
+            chalk7.dim(`    ${pendingWalkthroughs} unpushed walkthrough run(s)`)
           );
         if (pendingRetries > 0)
-          console.log(chalk6.dim(`    ${pendingRetries} queued retry item(s)`));
+          console.log(chalk7.dim(`    ${pendingRetries} queued retry item(s)`));
         if (deletions && pendingDeletions > 0)
           console.log(
-            chalk6.dim(
+            chalk7.dim(
               `    ${pendingDeletions} local deletion(s): ${describeCounts(deletions.by_type)}${deletions.needs_confirm ? " \u2014 needs `iamu sync --confirm-deletes`" : ""}`
             )
           );
@@ -13186,23 +13441,23 @@ async function sync(opts) {
       Object.entries(result.deleted.cloud_by_type).filter(([, n]) => n > 0)
     );
     console.log(
-      Object.keys(removed).length > 0 ? `  ${chalk6.green("\u2713")} Deleted on cloud: ${describeCounts(removed)}` : `  ${chalk6.green("\u2713")} Nothing left to delete on the cloud \u2014 ${describeCounts(result.deleted.by_type)} ${result.deleted.total === 1 ? "was" : "were"} already gone there`
+      Object.keys(removed).length > 0 ? `  ${chalk7.green("\u2713")} Deleted on cloud: ${describeCounts(removed)}` : `  ${chalk7.green("\u2713")} Nothing left to delete on the cloud \u2014 ${describeCounts(result.deleted.by_type)} ${result.deleted.total === 1 ? "was" : "were"} already gone there`
     );
   }
   if (result.pending_deletes) printPendingDeletes(result.pending_deletes);
   if (result.held_deletes) {
     const n = result.held_deletes.length;
     console.log(
-      chalk6.yellow(`  ${n} local deletion${n !== 1 ? "s" : ""} held back:`)
+      chalk7.yellow(`  ${n} local deletion${n !== 1 ? "s" : ""} held back:`)
     );
     for (const h of result.held_deletes) {
       console.log(
-        `    ${describeDeletionCount(h.type, 1).replace(/^1 /, "")} ${h.label}${chalk6.dim(` \u2014 ${h.reason}`)}`
+        `    ${describeDeletionCount(h.type, 1).replace(/^1 /, "")} ${h.label}${chalk7.dim(` \u2014 ${h.reason}`)}`
       );
     }
     if (result.held_deletes.some((h) => h.branches)) {
       console.log(
-        chalk6.dim(
+        chalk7.dim(
           "    A file still on another branch usually means you switched branches, not that you deleted it. If you did delete it, `iamu sync --confirm-deletes` sends it anyway."
         )
       );
@@ -13210,12 +13465,12 @@ async function sync(opts) {
   }
   if (result.drain.drained > 0) {
     console.log(
-      chalk6.dim(`  Drained ${result.drain.drained} retry-queue items`)
+      chalk7.dim(`  Drained ${result.drain.drained} retry-queue items`)
     );
   }
   if (result.draftsSkipped > 0) {
     console.log(
-      chalk6.dim(
+      chalk7.dim(
         `  ${result.draftsSkipped} draft scenarios skipped \u2014 bind a persona to push`
       )
     );
@@ -13224,7 +13479,7 @@ async function sync(opts) {
   if (enqueuedTotal > 0) {
     const total = enqueuedTotal;
     console.log(
-      chalk6.yellow(
+      chalk7.yellow(
         `  ${total} items enqueued for retry (will retry next sync)`
       )
     );
@@ -13237,7 +13492,7 @@ async function sync(opts) {
     );
     console.log();
     console.log(
-      chalk6.yellow(
+      chalk7.yellow(
         `  \u26A0 --keep-mine replaced ${n} cloud change${n !== 1 ? "s" : ""}:`
       )
     );
@@ -13247,11 +13502,11 @@ async function sync(opts) {
       const slug = slugs.get(o.entity_id);
       const named = slug ? `${slug} (${o.entity_id})` : o.entity_id;
       console.log(
-        `  ${chalk6.yellow("\u26A0")} ${o.type} ${named} \u2014 overwrote ${who}'s change from ${when}`
+        `  ${chalk7.yellow("\u26A0")} ${o.type} ${named} \u2014 overwrote ${who}'s change from ${when}`
       );
     }
     console.log(
-      chalk6.dim(
+      chalk7.dim(
         "  Their version is gone from cloud \u2014 `iamu pull --force` now returns yours."
       )
     );
@@ -13259,7 +13514,7 @@ async function sync(opts) {
   if (result.conflicts.length > 0) {
     console.log();
     console.log(
-      chalk6.yellow(
+      chalk7.yellow(
         `  ${result.conflicts.length} conflict${result.conflicts.length !== 1 ? "s" : ""} detected:`
       )
     );
@@ -13271,12 +13526,12 @@ async function sync(opts) {
       );
     }
     console.log(
-      chalk6.dim(
+      chalk7.dim(
         "  Resolve: copy your edits aside, run `iamu pull --force` to take the cloud version, re-apply, then sync"
       )
     );
     console.log(
-      chalk6.dim(
+      chalk7.dim(
         "  Or keep yours: `iamu sync --keep-mine` re-pushes your version over theirs"
       )
     );
@@ -13286,26 +13541,26 @@ async function sync(opts) {
   }
   for (const f of result.drain.failures) {
     console.error(
-      `  ${symbols.error} ${f.label ?? f.entity_id}: ${chalk6.dim(f.error)}`
+      `  ${symbols.error} ${f.label ?? f.entity_id}: ${chalk7.dim(f.error)}`
     );
   }
   if (result.drain.dropped > 0) {
     console.error(
-      chalk6.yellow(
+      chalk7.yellow(
         `  ${result.drain.dropped} queued push${result.drain.dropped !== 1 ? "es were" : " was"} dropped from the retry queue \u2014 they can never succeed as queued (see above)`
       )
     );
   }
   for (const w of result.drain.warnings) {
-    console.error(`  ${symbols.warning} retry queue: ${chalk6.dim(w)}`);
+    console.error(`  ${symbols.warning} retry queue: ${chalk7.dim(w)}`);
   }
   for (const n of result.notices ?? []) {
-    console.log(chalk6.dim(`  ${n}`));
+    console.log(chalk7.dim(`  ${n}`));
   }
   if (totalPushed > 0) {
     const dashboard = await projectDashboardUrl(projectRoot);
     if (dashboard) {
-      console.log(`  ${chalk6.dim("view:")} ${chalk6.underline(dashboard)}`);
+      console.log(`  ${chalk7.dim("view:")} ${chalk7.underline(dashboard)}`);
     }
   }
   if (failed) {
@@ -13336,7 +13591,7 @@ var pull_exports = {};
 __export(pull_exports, {
   pull: () => pull
 });
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 async function pull(opts) {
   if (opts?.force && opts?.preview) {
     commandError("--force and --preview are mutually exclusive.", opts);
@@ -13366,13 +13621,13 @@ async function pull(opts) {
   if (result.drain.failures.length > 0) {
     for (const f of result.drain.failures) {
       console.error(
-        `  ${symbols.error} drain: ${f.entity_id}: ${chalk7.dim(f.error)}`
+        `  ${symbols.error} drain: ${f.entity_id}: ${chalk8.dim(f.error)}`
       );
     }
   }
   if (!quiet) console.log();
   if (result.preview) {
-    console.log(chalk7.dim("  Preview mode \u2014 no files written."));
+    console.log(chalk8.dim("  Preview mode \u2014 no files written."));
   }
   const types2 = Object.entries(result.pulls);
   let totalWritten = 0;
@@ -13399,11 +13654,11 @@ async function pull(opts) {
       console.error(`  ${symbols.error} ${type2}: ${err}`);
     }
     for (const warning of summary.warnings) {
-      console.error(`  ${chalk7.yellow("\u26A0")} ${type2}: ${warning}`);
+      console.error(`  ${chalk8.yellow("\u26A0")} ${type2}: ${warning}`);
     }
     for (const { slug } of summary.diverged) {
       console.error(
-        `  ${chalk7.yellow("\u26A0")} ${type2} ${slug}: changed locally and in the cloud \u2014 keep yours with \`iamu sync --keep-mine\`, or take the cloud copy with \`iamu pull --force\``
+        `  ${chalk8.yellow("\u26A0")} ${type2} ${slug}: changed locally and in the cloud \u2014 keep yours with \`iamu sync --keep-mine\`, or take the cloud copy with \`iamu pull --force\``
       );
     }
   }
@@ -13418,7 +13673,7 @@ async function pull(opts) {
   }
   if (totalSkipped > 0) {
     console.log(
-      chalk7.dim(
+      chalk8.dim(
         `  ${totalSkipped} entities skipped (up to date or kept local)`
       )
     );
@@ -13569,7 +13824,7 @@ var init_auth_token_input = __esm({
 });
 
 // src/commands/mcp-config.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
 import { basename, dirname as dirname4 } from "path";
 import { mkdir as mkdir3 } from "fs/promises";
 function isVscodePath(mcpPath) {
@@ -13578,7 +13833,7 @@ function isVscodePath(mcpPath) {
 async function writeSyncMcpEntry(mcpPath) {
   let existing = {};
   try {
-    const raw = await readFile3(mcpPath, "utf-8");
+    const raw = await readFile4(mcpPath, "utf-8");
     existing = JSON.parse(raw);
   } catch (err) {
     if (err.code === "ENOENT") {
@@ -13635,7 +13890,7 @@ __export(auth_exports, {
 import { execFile as execFile2 } from "child_process";
 import { platform } from "os";
 import { isCancel, select, spinner } from "@clack/prompts";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 function openBrowser(url, run = spawnDetached) {
   try {
     const parsed = new URL(url);
@@ -13759,8 +14014,8 @@ async function reportAlreadyLinked(projectRoot, config, apiUrl, requested) {
   }
   console.log();
   console.log(`  ${symbols.success} Already authenticated and cloud-linked.`);
-  console.log(`  ${chalk8.dim("API:")} ${apiUrl}`);
-  console.log(`  ${chalk8.dim("Project:")} ${config.cloud_project_id}`);
+  console.log(`  ${chalk9.dim("API:")} ${apiUrl}`);
+  console.log(`  ${chalk9.dim("Project:")} ${config.cloud_project_id}`);
   await registerSyncServer(projectRoot);
   console.log();
 }
@@ -13768,8 +14023,8 @@ async function obtainToken(apiUrl, providedToken, reusedToken, opts, t) {
   if (providedToken) {
     console.log();
     console.log(
-      chalk8.bold(
-        `  Authenticating with provided token for ${chalk8.cyan(apiUrl)}...`
+      chalk9.bold(
+        `  Authenticating with provided token for ${chalk9.cyan(apiUrl)}...`
       )
     );
     return { token: providedToken, email: null, tenantId: null };
@@ -13777,7 +14032,7 @@ async function obtainToken(apiUrl, providedToken, reusedToken, opts, t) {
   if (reusedToken) {
     console.log();
     console.log(
-      chalk8.bold(`  Using stored credentials for ${chalk8.cyan(apiUrl)}...`)
+      chalk9.bold(`  Using stored credentials for ${chalk9.cyan(apiUrl)}...`)
     );
     return { token: reusedToken, email: null, tenantId: null };
   }
@@ -13797,17 +14052,17 @@ async function browserLogin(apiUrl, opts, t) {
   const isLocal = isLoopbackHost(new URL(apiUrl).hostname);
   console.log();
   console.log(
-    chalk8.bold(
-      `  Authenticating with ${isLocal ? "local " : ""}Iamu Cloud (${chalk8.cyan(apiUrl)})...`
+    chalk9.bold(
+      `  Authenticating with ${isLocal ? "local " : ""}Iamu Cloud (${chalk9.cyan(apiUrl)})...`
     )
   );
   const started = await startAuthSession(apiUrl, t.requestTimeoutMs);
   if (!started) return null;
   if (opts.browser !== false) {
-    console.log(`  Opening browser: ${chalk8.cyan(started.loginUrl)}`);
+    console.log(`  Opening browser: ${chalk9.cyan(started.loginUrl)}`);
     openBrowser(started.loginUrl);
   } else {
-    console.log(`  Log in at: ${chalk8.cyan(started.loginUrl)}`);
+    console.log(`  Log in at: ${chalk9.cyan(started.loginUrl)}`);
   }
   const s = spinner();
   s.start("Waiting for you to log in in browser...");
@@ -13815,11 +14070,11 @@ async function browserLogin(apiUrl, opts, t) {
   if (result.kind === "expired") {
     s.stop("Auth session expired.");
     console.error(
-      chalk8.red(`
+      chalk9.red(`
   Auth session expired or failed (HTTP ${result.status}).`)
     );
     console.error(
-      chalk8.dim("  Re-run `iamu auth login` to start a new login session.\n")
+      chalk9.dim("  Re-run `iamu auth login` to start a new login session.\n")
     );
     process.exitCode = 1;
     return null;
@@ -13827,12 +14082,12 @@ async function browserLogin(apiUrl, opts, t) {
   if (result.kind === "timeout") {
     s.stop("Authentication timed out.");
     console.error(
-      chalk8.red(
+      chalk9.red(
         "\n  Authentication timed out (no approval received within 2 minutes)."
       )
     );
     console.error(
-      chalk8.dim(
+      chalk9.dim(
         "  \u2022 Complete browser authorization faster, or authenticate non-interactively with --token <key>.\n  \u2022 Local setup is unaffected \u2014 re-run `iamu auth login` anytime.\n"
       )
     );
@@ -13860,12 +14115,12 @@ async function startAuthSession(apiUrl, timeoutMs) {
     });
     if (!res.ok) {
       console.error(
-        chalk8.red(
+        chalk9.red(
           `  Failed to start auth session at ${apiUrl}: ${res.text || `HTTP ${res.status}`}`
         )
       );
       console.error(
-        chalk8.dim(
+        chalk9.dim(
           "  \u2022 The cloud service may be experiencing downtime or maintenance.\n  \u2022 Local setup is unaffected; continue with local workflows or retry later with `iamu auth login`.\n"
         )
       );
@@ -13880,11 +14135,11 @@ async function startAuthSession(apiUrl, timeoutMs) {
     return { sessionId: data.sessionId, loginUrl: data.loginUrl };
   } catch (err) {
     console.error(
-      chalk8.red(`  Cannot reach Iamu Cloud (${apiUrl}).`) + chalk8.dim(`
+      chalk9.red(`  Cannot reach Iamu Cloud (${apiUrl}).`) + chalk9.dim(`
   Reason: ${errorMessage(err)}`)
     );
     console.error(
-      chalk8.dim(
+      chalk9.dim(
         "\n  \u2022 Check your internet connection or proxy settings.\n  \u2022 If using a custom instance, pass --url <api-url> or set IAMU_API_URL.\n  \u2022 Local setup is unaffected; continue with local workflows or retry later with `iamu auth login`.\n"
       )
     );
@@ -13932,22 +14187,22 @@ async function linkCloudProject(args) {
       cloudApiUrl: args.apiUrl,
       apiKey: args.token
     });
-    console.log(`  ${symbols.success} Linked to ${chalk8.cyan(args.apiUrl)}`);
+    console.log(`  ${symbols.success} Linked to ${chalk9.cyan(args.apiUrl)}`);
     if (result.sync?.push?.pushed) {
       console.log(
-        `  ${chalk8.dim("Initial sync:")} ${result.sync.push.pushed} pushed`
+        `  ${chalk9.dim("Initial sync:")} ${result.sync.push.pushed} pushed`
       );
     }
   } catch (err) {
     console.error(
-      chalk8.red("  Credentials saved, but linking the project failed.") + chalk8.dim(` (${errorMessage(err)})`)
+      chalk9.red("  Credentials saved, but linking the project failed.") + chalk9.dim(` (${errorMessage(err)})`)
     );
     process.exitCode = 1;
     return;
   }
   await registerSyncServer(args.projectRoot);
   console.log(
-    `  ${chalk8.dim("Dashboard:")} ${chalk8.underline(getCloudDashboardUrl(args.apiUrl, cloudProjectId))}`
+    `  ${chalk9.dim("Dashboard:")} ${chalk9.underline(getCloudDashboardUrl(args.apiUrl, cloudProjectId))}`
   );
 }
 async function listCloudProjects(args) {
@@ -13963,9 +14218,9 @@ async function listCloudProjects(args) {
     }
     if (!res.ok) {
       console.error(
-        chalk8.red(
+        chalk9.red(
           `  Credentials saved, but could not list cloud projects (HTTP ${res.status}).`
-        ) + chalk8.dim(" Re-run iamu auth login.")
+        ) + chalk9.dim(" Re-run iamu auth login.")
       );
       process.exitCode = 1;
       return null;
@@ -13975,7 +14230,7 @@ async function listCloudProjects(args) {
     return projects;
   } catch (err) {
     console.error(
-      chalk8.yellow("  Credentials saved but could not list projects.") + chalk8.dim(` (${errorMessage(err)})`)
+      chalk9.yellow("  Credentials saved but could not list projects.") + chalk9.dim(` (${errorMessage(err)})`)
     );
     process.exitCode = 1;
     return null;
@@ -13988,7 +14243,7 @@ async function dropRejectedToken(apiUrl) {
     await writeCredentialsStore(store);
   }
   console.error(
-    chalk8.red("  Stored credentials were rejected and have been removed.") + chalk8.dim(" Run iamu auth login again to sign in.")
+    chalk9.red("  Stored credentials were rejected and have been removed.") + chalk9.dim(" Run iamu auth login again to sign in.")
   );
   process.exitCode = 1;
 }
@@ -14016,34 +14271,34 @@ async function chooseCloudProject(args, projects) {
 function printProjectRefusal(reason, projects, { config, opts }) {
   if (reason === "unknown_project") {
     console.error(
-      chalk8.red(
+      chalk9.red(
         `  Cloud project ${opts.project} is not one this account can see.`
-      ) + chalk8.dim(" Pick one of:")
+      ) + chalk9.dim(" Pick one of:")
     );
   } else {
     if (opts.yes) {
       console.error(
-        chalk8.yellow(
+        chalk9.yellow(
           `  --yes only links when the account has exactly one cloud project; it has ${projects.length}.`
         )
       );
     }
     console.error(
-      chalk8.yellow(
+      chalk9.yellow(
         "  Signed in. Choose the cloud project to link \u2014 re-run with --project:"
       )
     );
   }
   for (const p of projects) {
     console.error(
-      `    iamu auth login --project ${p.id}   ${chalk8.dim(`${p.name} (${p.slug})`)}`
+      `    iamu auth login --project ${p.id}   ${chalk9.dim(`${p.name} (${p.slug})`)}`
     );
   }
   console.error(
-    `    iamu auth login --project new   ${chalk8.dim(`create "${config.project_name}"`)}`
+    `    iamu auth login --project new   ${chalk9.dim(`create "${config.project_name}"`)}`
   );
   console.error(
-    chalk8.dim("  Credentials are stored; the re-run skips the browser.")
+    chalk9.dim("  Credentials are stored; the re-run skips the browser.")
   );
   process.exitCode = 1;
 }
@@ -14062,7 +14317,7 @@ async function promptForProject(projects, args) {
   });
   if (isCancel(choice)) {
     process.exitCode = 130;
-    console.log(chalk8.dim("  Login cancelled."));
+    console.log(chalk9.dim("  Login cancelled."));
     return null;
   }
   return choice === CREATE_NEW ? createCloudProject(args) : String(choice);
@@ -14089,7 +14344,7 @@ async function createCloudProject(args) {
     return id;
   } catch (err) {
     console.error(
-      chalk8.red("  Failed to create cloud project.") + chalk8.dim(` (${errorMessage(err)}) Try again with iamu auth login.`)
+      chalk9.red("  Failed to create cloud project.") + chalk9.dim(` (${errorMessage(err)}) Try again with iamu auth login.`)
     );
     process.exitCode = 1;
     return null;
@@ -14104,13 +14359,13 @@ async function registerSyncServer(projectRoot) {
       registered.push(host.name);
     } catch (err) {
       console.error(
-        chalk8.yellow(`  ${host.name}: iamu-sync MCP not registered`) + chalk8.dim(` (${err.message})`)
+        chalk9.yellow(`  ${host.name}: iamu-sync MCP not registered`) + chalk9.dim(` (${err.message})`)
       );
     }
   }
   if (registered.length > 0) {
     console.log(
-      `  ${symbols.success} iamu-sync MCP server registered for ${registered.join(", ")} ${chalk8.dim("\u2014 restart your agent session to load the team tools")}`
+      `  ${symbols.success} iamu-sync MCP server registered for ${registered.join(", ")} ${chalk9.dim("\u2014 restart your agent session to load the team tools")}`
     );
   }
 }
@@ -14131,10 +14386,10 @@ async function authDisconnect() {
     }
     console.log();
     console.log(`  ${symbols.success} Disconnected from cloud.`);
-    console.log(chalk8.dim("  Local entities preserved. Re-link anytime."));
+    console.log(chalk9.dim("  Local entities preserved. Re-link anytime."));
     console.log();
   } catch (err) {
-    console.error(chalk8.red(`  ${err.message}`));
+    console.error(chalk9.red(`  ${err.message}`));
     process.exitCode = 1;
   }
 }
@@ -14166,17 +14421,17 @@ async function authStatus(opts) {
     console.log();
     if (config.cloud_linked) {
       console.log(
-        `  ${symbols.success} Cloud-linked: ${chalk8.cyan(config.cloud_api_url)}`
+        `  ${symbols.success} Cloud-linked: ${chalk9.cyan(config.cloud_api_url)}`
       );
-      console.log(`  ${chalk8.dim("Project:")} ${config.cloud_project_id}`);
+      console.log(`  ${chalk9.dim("Project:")} ${config.cloud_project_id}`);
       console.log(
-        `  ${chalk8.dim("Token:")} ${token ? "stored" : chalk8.yellow("missing")}`
+        `  ${chalk9.dim("Token:")} ${token ? "stored" : chalk9.yellow("missing")}`
       );
     } else {
-      console.log(`  ${chalk8.dim("Local-only \u2014 not cloud-linked.")}`);
+      console.log(`  ${chalk9.dim("Local-only \u2014 not cloud-linked.")}`);
       if (token) {
         console.log(
-          `  ${chalk8.dim("Token stored for")} ${apiUrl} ${chalk8.dim("\u2014 run iamu auth login to link.")}`
+          `  ${chalk9.dim("Token stored for")} ${apiUrl} ${chalk9.dim("\u2014 run iamu auth login to link.")}`
         );
       }
     }
@@ -14212,11 +14467,11 @@ var init_auth = __esm({
 });
 
 // src/ui/journey-diff.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function formatJourneyDiffTerminal(diff) {
   const lines = [];
   lines.push(
-    chalk9.bold("  Journey diff") + chalk9.dim(` (vs ${diff.baselineRunId.slice(0, 30)}\u2026):`)
+    chalk10.bold("  Journey diff") + chalk10.dim(` (vs ${diff.baselineRunId.slice(0, 30)}\u2026):`)
   );
   for (const step of diff.steps) {
     let sym = " ";
@@ -14224,40 +14479,40 @@ function formatJourneyDiffTerminal(diff) {
     let statusColored = statusLabel;
     switch (step.status) {
       case "resolved":
-        sym = chalk9.green("\u2713");
-        statusColored = chalk9.green(statusLabel);
+        sym = chalk10.green("\u2713");
+        statusColored = chalk10.green(statusLabel);
         break;
       case "persists":
-        sym = chalk9.red("\u2716");
-        statusColored = chalk9.red(statusLabel);
+        sym = chalk10.red("\u2716");
+        statusColored = chalk10.red(statusLabel);
         break;
       case "regression":
-        sym = chalk9.yellow("!");
-        statusColored = chalk9.yellow(statusLabel);
+        sym = chalk10.yellow("!");
+        statusColored = chalk10.yellow(statusLabel);
         break;
       case "stalled":
-        sym = chalk9.red("\xD7");
-        statusColored = chalk9.red(statusLabel);
+        sym = chalk10.red("\xD7");
+        statusColored = chalk10.red(statusLabel);
         break;
       case "new_path":
-        sym = chalk9.cyan("+");
-        statusColored = chalk9.cyan(statusLabel);
+        sym = chalk10.cyan("+");
+        statusColored = chalk10.cyan(statusLabel);
         break;
       case "bypassed":
-        sym = chalk9.dim("\u25CB");
-        statusColored = chalk9.dim(statusLabel);
+        sym = chalk10.dim("\u25CB");
+        statusColored = chalk10.dim(statusLabel);
         break;
       default:
-        sym = chalk9.dim("\xB7");
-        statusColored = chalk9.dim(statusLabel);
+        sym = chalk10.dim("\xB7");
+        statusColored = chalk10.dim(statusLabel);
         break;
     }
     const route = journeyStepRoute(step);
     const action = step.currentStep?.action || step.baselineStep?.action || "(no action)";
     const stepNum = step.currentStep ? `[${step.currentStep.step_number}]` : step.baselineStep ? `[${step.baselineStep.step_number}b]` : `[${step.index}]`;
-    const note = step.status === "same" ? "" : chalk9.dim(` (${step.summary})`);
+    const note = step.status === "same" ? "" : chalk10.dim(` (${step.summary})`);
     lines.push(
-      `    ${sym} ${chalk9.dim(stepNum.padEnd(5))} ${chalk9.dim(route.slice(0, 20).padEnd(21))} ${action.slice(0, 35).padEnd(36)} ${statusColored}${note}`
+      `    ${sym} ${chalk10.dim(stepNum.padEnd(5))} ${chalk10.dim(route.slice(0, 20).padEnd(21))} ${action.slice(0, 35).padEnd(36)} ${statusColored}${note}`
     );
   }
   return lines.join("\n");
@@ -14274,7 +14529,7 @@ var init_journey_diff2 = __esm({
 });
 
 // src/ui/table.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 function stripAnsi(str2) {
   return str2.replace(ANSI_REGEX, "");
 }
@@ -14320,7 +14575,7 @@ function formatTable(items, columns, options) {
   const headerParts = columns.map(
     (col, i) => padRight(col.header, colWidths[i])
   );
-  lines.push(`  ${chalk10.dim(headerParts.join(" "))}`);
+  lines.push(`  ${chalk11.dim(headerParts.join(" "))}`);
   for (const item of items) {
     const rowParts = columns.map((col, i) => {
       let val = col.value(item);
@@ -14353,7 +14608,7 @@ import {
   readlinkSync,
   realpathSync as realpathSync2
 } from "fs";
-import path18 from "path";
+import path19 from "path";
 function git(args, cwd) {
   return execFileSync("git", args, {
     cwd,
@@ -14364,13 +14619,13 @@ function git(args, cwd) {
 }
 function hashFile(absPath) {
   const hash = createHash4("sha256");
-  const stat2 = lstatSync(absPath);
-  if (stat2.isSymbolicLink()) {
+  const stat3 = lstatSync(absPath);
+  if (stat3.isSymbolicLink()) {
     hash.update(`symlink:${readlinkSync(absPath)}`);
     return hash.digest("hex");
   }
-  if (!stat2.isFile()) {
-    hash.update(`${stat2.isDirectory() ? "dir" : "other"}`);
+  if (!stat3.isFile()) {
+    hash.update(`${stat3.isDirectory() ? "dir" : "other"}`);
     return hash.digest("hex");
   }
   const fd = openSync(absPath, "r");
@@ -14406,8 +14661,8 @@ function detectWorktreeState(projectRoot, iamuDirName = IAMU_DIR) {
     const top = git(["rev-parse", "--show-toplevel"], projectRoot).toString("utf8").trim();
     if (!top) return void 0;
     const realTop = realpathSync2(top);
-    const realIamu = path18.join(realpathSync2(projectRoot), iamuDirName);
-    const iamuRel = path18.relative(realTop, realIamu).split(path18.sep).join("/");
+    const realIamu = path19.join(realpathSync2(projectRoot), iamuDirName);
+    const iamuRel = path19.relative(realTop, realIamu).split(path19.sep).join("/");
     const pathspec = iamuRel.startsWith("..") ? [":(top)"] : [":(top)", `:(top,exclude,literal)${iamuRel}`];
     const status2 = git(
       [
@@ -14437,7 +14692,7 @@ function detectWorktreeState(projectRoot, iamuDirName = IAMU_DIR) {
     );
     for (const file of sorted.slice(0, MAX_UNTRACKED_HASHED)) {
       const rel = file.replace(/\/$/, "");
-      hash.update(`${file}\0${hashFile(path18.join(realTop, rel))}
+      hash.update(`${file}\0${hashFile(path19.join(realTop, rel))}
 `);
     }
     if (sorted.length > MAX_UNTRACKED_HASHED) {
@@ -14612,12 +14867,12 @@ __export(start_run_exports, {
   testabilityTarget: () => testabilityTarget
 });
 import fs24 from "fs/promises";
-import path19 from "path";
-import chalk11 from "chalk";
+import path20 from "path";
+import chalk12 from "chalk";
 async function testabilityTarget(projectRoot) {
   try {
     const raw = await fs24.readFile(
-      path19.join(projectRoot, "iamu", "testability.md"),
+      path20.join(projectRoot, "iamu", "testability.md"),
       "utf8"
     );
     const { frontmatter } = parseFrontmatter(raw);
@@ -14801,19 +15056,28 @@ async function startRun(scenarioSlug, opts) {
     ...viewport ? { viewport } : {}
   };
   await atomicWriteFile(
-    path19.join(run.absPath, "walkthrough.json"),
+    path20.join(run.absPath, "walkthrough.json"),
     JSON.stringify(manifest, null, 2) + "\n"
   );
+  const liveRes = await registerLiveRun({
+    projectRoot,
+    runId: run.runId,
+    scenarioSlug,
+    targetUrl: start2.url,
+    startedAt: manifest.created_at,
+    lenses: manifest.lenses
+  });
   if (opts.json) {
     console.log(
       JSON.stringify(
         {
           run_id: run.runId,
-          path: path19.relative(projectRoot, run.absPath),
+          path: path20.relative(projectRoot, run.absPath),
           scenario_slug: scenarioSlug,
           target_url: start2.url,
           target_reachable: targetReachable,
           ...targetWarning ? { target_warning: targetWarning } : {},
+          ...liveRes?.viewerUrl ? { live_viewer_url: liveRes.viewerUrl } : {},
           persona_slug: fm.persona,
           outline_slug: fm.outline,
           models,
@@ -14830,55 +15094,60 @@ async function startRun(scenarioSlug, opts) {
     return;
   }
   console.log();
-  console.log(`  ${symbols.success} Run started: ${chalk11.cyan(run.runId)}`);
-  console.log(`  ${chalk11.dim("scenario:")} ${scenarioSlug}`);
-  console.log(`  ${chalk11.dim("persona:")}  ${fm.persona}`);
-  console.log(`  ${chalk11.dim("outline:")}  ${fm.outline}`);
-  console.log(`  ${chalk11.dim("target:")}   ${start2.url}`);
+  console.log(`  ${symbols.success} Run started: ${chalk12.cyan(run.runId)}`);
+  if (liveRes?.viewerUrl) {
+    console.log(
+      `  Follow this run live (beta): ${chalk12.cyan(liveRes.viewerUrl)}`
+    );
+  }
+  console.log(`  ${chalk12.dim("scenario:")} ${scenarioSlug}`);
+  console.log(`  ${chalk12.dim("persona:")}  ${fm.persona}`);
+  console.log(`  ${chalk12.dim("outline:")}  ${fm.outline}`);
+  console.log(`  ${chalk12.dim("target:")}   ${start2.url}`);
   console.log(
-    `  ${chalk11.dim("models:")}   walker: ${chalk11.cyan(walker)} \xB7 judge: ${chalk11.cyan(judge)} \xB7 matcher: ${chalk11.cyan(matcher)}`
+    `  ${chalk12.dim("models:")}   walker: ${chalk12.cyan(walker)} \xB7 judge: ${chalk12.cyan(judge)} \xB7 matcher: ${chalk12.cyan(matcher)}`
   );
   if (targetWarning) {
-    console.log(`  ${symbols.warning} ${chalk11.yellow(targetWarning)}`);
+    console.log(`  ${symbols.warning} ${chalk12.yellow(targetWarning)}`);
   }
-  if (environment) console.log(`  ${chalk11.dim("env:")}      ${environment}`);
+  if (environment) console.log(`  ${chalk12.dim("env:")}      ${environment}`);
   if (build) {
-    console.log(`  ${chalk11.dim("build:")}    ${formatBuild(build)}`);
+    console.log(`  ${chalk12.dim("build:")}    ${formatBuild(build)}`);
   }
   if (viewport) {
-    console.log(`  ${chalk11.dim("device:")}   ${formatViewport(viewport)}`);
+    console.log(`  ${chalk12.dim("device:")}   ${formatViewport(viewport)}`);
   }
   if (device?.warning) {
-    console.log(`  ${chalk11.yellow("!")} ${device.warning}`);
+    console.log(`  ${chalk12.yellow("!")} ${device.warning}`);
   }
   if (revisit.length > 0) {
     console.log(
-      `  ${chalk11.dim("re-check:")} ${revisit.length} place${revisit.length === 1 ? "" : "s"} where fixes await a re-run`
+      `  ${chalk12.dim("re-check:")} ${revisit.length} place${revisit.length === 1 ? "" : "s"} where fixes await a re-run`
     );
   }
   console.log(
-    `  ${chalk11.dim("path:")}     ${path19.relative(projectRoot, run.absPath)}`
+    `  ${chalk12.dim("path:")}     ${path20.relative(projectRoot, run.absPath)}`
   );
   console.log();
-  console.log(`  ${chalk11.bold("Next steps for blind execution:")}`);
+  console.log(`  ${chalk12.bold("Next steps for blind execution:")}`);
   console.log(
-    `    1. Size browser:    ${chalk11.cyan(`iamu browse start --run ${run.runId}`)}`
+    `    1. Size browser:    ${chalk12.cyan(`iamu browse start --run ${run.runId}`)}`
   );
   console.log(
-    `    2. Get walk prompt: ${chalk11.cyan(`iamu instructions walk --scenario ${scenarioSlug} --run ${run.runId}`)}`
+    `    2. Get walk prompt: ${chalk12.cyan(`iamu instructions walk --scenario ${scenarioSlug} --run ${run.runId}`)}`
   );
   console.log(
-    `    3. Dispatch walker: Spawn a ${chalk11.yellow("fresh blind subagent")} with that prompt (do NOT script steps locally)`
+    `    3. Dispatch walker: Spawn a ${chalk12.yellow("fresh blind subagent")} with that prompt (do NOT script steps locally)`
   );
   console.log(
-    `    4. Drive product:   Walker records via ${chalk11.cyan(`iamu browse step --run ${run.runId} ...`)}`
+    `    4. Drive product:   Walker records via ${chalk12.cyan(`iamu browse step --run ${run.runId} ...`)}`
   );
   console.log(
-    `    5. Complete run:    ${chalk11.cyan(`iamu complete ${run.runId}`)}`
+    `    5. Complete run:    ${chalk12.cyan(`iamu complete ${run.runId}`)}`
   );
   console.log();
   console.log(
-    `  ${chalk11.dim("Tip: Ensure your agent session has terminal auto-approval enabled so walkthrough steps run unattended.")}`
+    `  ${chalk12.dim("Tip: Ensure your agent session has terminal auto-approval enabled so walkthrough steps run unattended.")}`
   );
   console.log();
 }
@@ -14890,6 +15159,7 @@ var init_start_run = __esm({
     init_build_info();
     init_symbols();
     init_context4();
+    init_live_run_client();
   }
 });
 
@@ -14899,8 +15169,8 @@ __export(report_exports, {
   report: () => report
 });
 import { promises as fs25 } from "fs";
-import path20 from "path";
-import chalk12 from "chalk";
+import path21 from "path";
+import chalk13 from "chalk";
 async function report(scenario, opts) {
   const ctx = await resolveProject(opts);
   if (!ctx) return;
@@ -14910,7 +15180,7 @@ async function report(scenario, opts) {
     if (opts?.json) {
       console.log("[]");
     } else {
-      console.log(chalk12.dim("  No runs yet. Run a walkthrough first."));
+      console.log(chalk13.dim("  No runs yet. Run a walkthrough first."));
     }
     return;
   }
@@ -14919,7 +15189,7 @@ async function report(scenario, opts) {
     try {
       const dir = runDir(projectRoot, rid);
       const mRaw = await fs25.readFile(
-        path20.join(dir, "walkthrough.json"),
+        path21.join(dir, "walkthrough.json"),
         "utf8"
       );
       const manifest = JSON.parse(mRaw);
@@ -14928,7 +15198,7 @@ async function report(scenario, opts) {
       let canonical = null;
       try {
         const cRaw = await fs25.readFile(
-          path20.join(dir, "canonical.json"),
+          path21.join(dir, "canonical.json"),
           "utf8"
         );
         canonical = JSON.parse(cRaw);
@@ -14943,7 +15213,7 @@ async function report(scenario, opts) {
       console.log("[]");
     } else {
       const msg = scenario ? `No completed runs for scenario: ${scenario}` : "No completed runs yet.";
-      console.log(chalk12.dim(`  ${msg}`));
+      console.log(chalk13.dim(`  ${msg}`));
     }
     return;
   }
@@ -14975,37 +15245,37 @@ async function report(scenario, opts) {
     const c = run.canonical;
     console.log();
     console.log(
-      chalk12.bold(`  ${run.manifest.scenario_slug}`) + chalk12.dim(` \u2014 ${run.runId.slice(0, 30)}\u2026`)
+      chalk13.bold(`  ${run.manifest.scenario_slug}`) + chalk13.dim(` \u2014 ${run.runId.slice(0, 30)}\u2026`)
     );
     console.log(
-      `  ${chalk12.dim("url:")} ${run.manifest.target_url}  ${chalk12.dim("completed:")} ${run.manifest.completed_at}`
+      `  ${chalk13.dim("url:")} ${run.manifest.target_url}  ${chalk13.dim("completed:")} ${run.manifest.completed_at}`
     );
     const env = run.manifest.environment ?? c?.environment;
     if (env) {
-      console.log(`  ${chalk12.dim("env:")}       ${env}`);
+      console.log(`  ${chalk13.dim("env:")}       ${env}`);
     }
     const build = run.manifest.build ?? c?.build;
     if (build) {
-      console.log(`  ${chalk12.dim("build:")}     ${formatBuild(build)}`);
+      console.log(`  ${chalk13.dim("build:")}     ${formatBuild(build)}`);
     }
     const viewport = run.manifest.viewport ?? c?.viewport;
     if (viewport) {
-      console.log(`  ${chalk12.dim("device:")}    ${formatViewport(viewport)}`);
+      console.log(`  ${chalk13.dim("device:")}    ${formatViewport(viewport)}`);
     }
     const viewUrl = await pushedRunUrl(projectRoot, run.runId);
     if (viewUrl) {
-      console.log(`  ${chalk12.dim("view:")} ${chalk12.underline(viewUrl)}`);
+      console.log(`  ${chalk13.dim("view:")} ${chalk13.underline(viewUrl)}`);
     }
     if (c) {
       const v = c.verification;
       if (v) {
         console.log();
-        console.log(chalk12.bold("  Since this scenario's last run:"));
+        console.log(chalk13.bold("  Since this scenario's last run:"));
         if (v.resolved.length > 0)
           console.log(`    ${symbols.success} ${v.resolved.length} resolved`);
         if (v.not_observed && v.not_observed.length > 0)
           console.log(
-            `    ${symbols.pending} ${v.not_observed.length} not seen this run ${chalk12.dim("(not evidence of a fix)")}`
+            `    ${symbols.pending} ${v.not_observed.length} not seen this run ${chalk13.dim("(not evidence of a fix)")}`
           );
         if (v.persists.length > 0)
           console.log(`    ${symbols.error} ${v.persists.length} persists`);
@@ -15031,20 +15301,20 @@ async function report(scenario, opts) {
       }
       console.log();
       if (c.findings.length === 0) {
-        console.log(chalk12.dim("  No findings."));
+        console.log(chalk13.dim("  No findings."));
       } else {
         const hinders = c.findings.filter(
           (f) => f.type === "hinders" || f.type === "missing" || f.type === "incorrect"
         );
         const helps = c.findings.filter((f) => f.type === "helps");
         if (hinders.length > 0) {
-          console.log(chalk12.bold("  Issues:"));
+          console.log(chalk13.bold("  Issues:"));
           const rows = formatTable(hinders, [
             {
               header: "severity",
               value: (f) => {
                 const sev = f.severity ?? "\u2014";
-                return sev === "critical" ? chalk12.red(sev) : sev === "major" ? chalk12.yellow(sev) : chalk12.dim(sev);
+                return sev === "critical" ? chalk13.red(sev) : sev === "major" ? chalk13.yellow(sev) : chalk13.dim(sev);
               }
             },
             { header: "type", value: (f) => f.type },
@@ -15054,24 +15324,24 @@ async function report(scenario, opts) {
         }
         if (helps.length > 0) {
           console.log();
-          console.log(chalk12.bold("  Strengths:"));
+          console.log(chalk13.bold("  Strengths:"));
           for (const f of helps) {
             console.log(
-              `    ${chalk12.green("helps")}       ${f.ui_fact ?? f.id}`
+              `    ${chalk13.green("helps")}       ${f.ui_fact ?? f.id}`
             );
           }
         }
       }
       if (c.human_test_overall?.answer) {
         console.log();
-        console.log(chalk12.bold("  Verdict: ") + c.human_test_overall.answer);
+        console.log(chalk13.bold("  Verdict: ") + c.human_test_overall.answer);
       }
     }
     console.log();
     return;
   }
   console.log();
-  console.log(chalk12.bold("  Recent runs:"));
+  console.log(chalk13.bold("  Recent runs:"));
   console.log();
   for (const run of completedRuns.slice(0, 10)) {
     const c = run.canonical;
@@ -15081,13 +15351,13 @@ async function report(scenario, opts) {
     ).length ?? 0;
     const verdict = c?.human_test_overall?.answer?.slice(0, 40) ?? "\u2014";
     console.log(
-      `  ${chalk12.cyan(String(run.manifest.scenario_slug).padEnd(35))} ${chalk12.dim("findings:")} ${hinders > 0 ? chalk12.yellow(String(hinders)) : chalk12.dim("0")}/${findings2}  ${chalk12.dim(verdict)}`
+      `  ${chalk13.cyan(String(run.manifest.scenario_slug).padEnd(35))} ${chalk13.dim("findings:")} ${hinders > 0 ? chalk13.yellow(String(hinders)) : chalk13.dim("0")}/${findings2}  ${chalk13.dim(verdict)}`
     );
   }
   const dashboard = await projectDashboardUrl(projectRoot);
   if (dashboard) {
     console.log();
-    console.log(`  ${chalk12.dim("cloud:")} ${chalk12.underline(dashboard)}`);
+    console.log(`  ${chalk13.dim("cloud:")} ${chalk13.underline(dashboard)}`);
   }
   console.log();
 }
@@ -15111,7 +15381,7 @@ __export(open_exports, {
 });
 import { existsSync as existsSync6 } from "fs";
 import { isCancel as isCancel2, select as select2 } from "@clack/prompts";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 async function openDashboard(runId, opts) {
   const ctx = await resolveProject();
   if (!ctx) return;
@@ -15122,7 +15392,7 @@ async function openDashboard(runId, opts) {
       const pushed = await pushedRunUrl(projectRoot, runId);
       if (!pushed) {
         console.error(
-          `  ${chalk13.yellow(symbols.info)} Run ${runId} is not on Iamu Cloud yet. Run ${chalk13.cyan("iamu sync")} to push it.`
+          `  ${chalk14.yellow(symbols.info)} Run ${runId} is not on Iamu Cloud yet. Run ${chalk14.cyan("iamu sync")} to push it.`
         );
         process.exitCode = 1;
         return;
@@ -15142,19 +15412,19 @@ async function openDashboard(runId, opts) {
     console.log(
       `  ${symbols.success} Opening Iamu Cloud ${runId ? "walkthrough" : "dashboard"}:`
     );
-    console.log(`  ${chalk13.cyan(url)}`);
+    console.log(`  ${chalk14.cyan(url)}`);
     console.log();
     openBrowser(url);
     return;
   }
   const say = opts?.printOnly ? console.error : console.log;
   say();
-  say(`  ${chalk13.yellow(symbols.info)} Project is not linked to Iamu Cloud.`);
+  say(`  ${chalk14.yellow(symbols.info)} Project is not linked to Iamu Cloud.`);
   say(
-    `  Run ${chalk13.cyan("iamu auth login")} to link and view live collaborative reports.`
+    `  Run ${chalk14.cyan("iamu auth login")} to link and view live collaborative reports.`
   );
   say(
-    `  Or run ${chalk13.cyan("iamu report")} to inspect results in your terminal.
+    `  Or run ${chalk14.cyan("iamu report")} to inspect results in your terminal.
 `
   );
   if (opts?.printOnly) {
@@ -15779,7 +16049,7 @@ var findings_exports = {};
 __export(findings_exports, {
   findings: () => findings
 });
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 async function findings(opts) {
   const ctx = await resolveProject(opts);
   if (!ctx) return;
@@ -15831,7 +16101,7 @@ async function findings(opts) {
   }
   if (filtered.length === 0) {
     const qualifier = opts?.open ? "open " : opts?.resolved ? "resolved " : opts?.dismissed ? "dismissed " : "";
-    console.log(chalk14.dim(`  No ${qualifier}findings.`));
+    console.log(chalk15.dim(`  No ${qualifier}findings.`));
     return;
   }
   const groups = /* @__PURE__ */ new Map();
@@ -15863,13 +16133,13 @@ async function findings(opts) {
       const tb = typeOrder[b.frontmatter.type] ?? 9;
       return ta - tb;
     });
-    console.log(chalk14.bold(`  ${scenario}`) + chalk14.dim(` (${items.length})`));
+    console.log(chalk15.bold(`  ${scenario}`) + chalk15.dim(` (${items.length})`));
     for (const e of items) {
       const sev = (e.frontmatter.severity ?? "\u2014").padEnd(11);
-      const sevColor = e.frontmatter.severity === "critical" ? chalk14.red : e.frontmatter.severity === "major" ? chalk14.yellow : chalk14.dim;
+      const sevColor = e.frontmatter.severity === "critical" ? chalk15.red : e.frontmatter.severity === "major" ? chalk15.yellow : chalk15.dim;
       const fixState = fixStateOf(e.frontmatter.slug);
       const status2 = fixState ? FIX_STATE_LABEL[fixState] : e.frontmatter.triage_status ?? "open";
-      const statusColor = fixState === "verified" ? chalk14.green : fixState === "recurred" ? chalk14.red : fixState === "awaiting_rerun" ? chalk14.yellow : status2 === "dismissed" ? chalk14.dim : chalk14.white;
+      const statusColor = fixState === "verified" ? chalk15.green : fixState === "recurred" ? chalk15.red : fixState === "awaiting_rerun" ? chalk15.yellow : status2 === "dismissed" ? chalk15.dim : chalk15.white;
       const title = e.frontmatter.title ?? e.frontmatter.ui_fact ?? e.frontmatter.slug;
       console.log(
         `    ${sevColor(sev)} ${e.frontmatter.type.padEnd(10)} ${statusColor(status2.padEnd(15))} ${title}`
@@ -15889,13 +16159,13 @@ async function findings(opts) {
     (e) => e.frontmatter.triage_status === "dismissed" || e.frontmatter.triage_status === "wont_fix"
   ).length;
   console.log(
-    chalk14.dim(
+    chalk15.dim(
       `  ${total} total: ${open2} open, ${awaiting} awaiting re-run, ${verified} verified${recurred > 0 ? `, ${recurred} recurred` : ""}, ${dismissed} dismissed`
     )
   );
   if (awaiting > 0) {
     console.log(
-      chalk14.dim(
+      chalk15.dim(
         "  awaiting re-run = fix applied, no later run has shown it working yet \u2014 `iamu status` lists the scenarios to re-run"
       )
     );
@@ -15922,7 +16192,7 @@ var triage_exports = {};
 __export(triage_exports, {
   triage: () => triage
 });
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 function defaultRule(kind, findings2) {
   const titles = findings2.map((f) => f.frontmatter.title ?? f.frontmatter.ui_fact ?? f.slug).join("; ");
   return kind === "walker_error" ? `Earlier walkers got this wrong: ${titles}` : `Don't report: ${titles}`;
@@ -16084,13 +16354,13 @@ async function triage(refs, opts) {
   console.log();
   for (const f of loaded) {
     console.log(
-      `  ${chalk15.green("\u2713")} ${status2.data}${reason ? ` (${reason})` : ""}: ${chalk15.cyan(f.slug)}`
+      `  ${chalk16.green("\u2713")} ${status2.data}${reason ? ` (${reason})` : ""}: ${chalk16.cyan(f.slug)}`
     );
   }
   if (guidance) {
     const where = scope.outline ? `outline ${scope.outline}` : scope.capability ? `capability ${scope.capability}` : "the whole project";
     console.log(
-      `  ${chalk15.green("\u2713")} Tester guidance: iamu/guidance/${guidance.slug}.md (${where}) \u2014 the next walk will not report this`
+      `  ${chalk16.green("\u2713")} Tester guidance: iamu/guidance/${guidance.slug}.md (${where}) \u2014 the next walk will not report this`
     );
   }
   console.log();
@@ -16112,14 +16382,14 @@ var serve_exports = {};
 __export(serve_exports, {
   serve: () => serve
 });
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 async function serve(opts) {
   const printOnly = opts?.open === false;
   const say = printOnly ? console.error : console.log;
   say();
-  say(`  ${chalk16.yellow(symbols.info)} The local web UI has been retired.`);
+  say(`  ${chalk17.yellow(symbols.info)} The local web UI has been retired.`);
   say(
-    `  ${printOnly ? "Printing the Iamu Cloud dashboard URL instead" : "Opening Iamu Cloud dashboard instead"}... (use ${chalk16.cyan("iamu open")} or ${chalk16.cyan("iamu report")})`
+    `  ${printOnly ? "Printing the Iamu Cloud dashboard URL instead" : "Opening Iamu Cloud dashboard instead"}... (use ${chalk17.cyan("iamu open")} or ${chalk17.cyan("iamu report")})`
   );
   say();
   await openDashboard(void 0, { printOnly });
@@ -16142,7 +16412,7 @@ import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
 import { basename as basename2, join as join5 } from "path";
 import { isCancel as isCancel3, multiselect, select as select3 } from "@clack/prompts";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 function loadPromptTemplates() {
   const templates = /* @__PURE__ */ new Map();
   const templateDir = getTemplateDir("prompts");
@@ -16175,9 +16445,9 @@ async function init(opts) {
   const version = getVersion();
   if (!options.json) {
     console.log();
-    console.log(chalk17.bold("  Welcome to iamu"));
+    console.log(chalk18.bold("  Welcome to iamu"));
     console.log(
-      chalk17.dim(
+      chalk18.dim(
         "  Scenario-driven development \u2014 test your product as realistic personas"
       )
     );
@@ -16188,7 +16458,7 @@ async function init(opts) {
     const config2 = await readConfig(projectRoot);
     if (!options.json) {
       console.log(
-        chalk17.yellow("  iamu/ already exists") + chalk17.dim(` (${config2?.project_name ?? "unknown"})`)
+        chalk18.yellow("  iamu/ already exists") + chalk18.dim(` (${config2?.project_name ?? "unknown"})`)
       );
     }
   } else {
@@ -16244,7 +16514,7 @@ Audited and populated during /iamu:init.
   const detected = detectHosts(projectRoot);
   if (!options.json && detected.length > 0) {
     console.log(
-      chalk17.dim("  Detected: ") + detected.map((h) => h.name).join(", ") + chalk17.dim(" (pre-selected)")
+      chalk18.dim("  Detected: ") + detected.map((h) => h.name).join(", ") + chalk18.dim(" (pre-selected)")
     );
     console.log();
   }
@@ -16265,7 +16535,7 @@ Audited and populated during /iamu:init.
     if (isCancel3(selected)) {
       process.exitCode = 130;
       if (!options.json) {
-        console.log(chalk17.dim("  Operation cancelled."));
+        console.log(chalk18.dim("  Operation cancelled."));
       }
       return;
     }
@@ -16277,10 +16547,10 @@ Audited and populated during /iamu:init.
   }
   if (!options.json && selectedHosts.length === 0 && detected.length === 0) {
     console.log(
-      chalk17.dim("  No supported tools detected. Skills not installed.")
+      chalk18.dim("  No supported tools detected. Skills not installed.")
     );
     console.log(
-      chalk17.dim("  Re-run `iamu init` after setting up your editor.")
+      chalk18.dim("  Re-run `iamu init` after setting up your editor.")
     );
   }
   if (!options.json) console.log();
@@ -16325,7 +16595,7 @@ Audited and populated during /iamu:init.
         process.exitCode = prevExitCode;
         if (!options.json) {
           console.log(
-            chalk17.dim(
+            chalk18.dim(
               "  Cloud linking skipped. Your local setup is complete and fully functional."
             )
           );
@@ -16366,15 +16636,15 @@ Audited and populated during /iamu:init.
   if (!options.json) {
     console.log();
     console.log(
-      chalk17.bold(
-        `  ${symbols.success} Project configured: ${chalk17.cyan(projectName)}`
+      chalk18.bold(
+        `  ${symbols.success} Project configured: ${chalk18.cyan(projectName)}`
       )
     );
     console.log();
     if (selectedHosts.length > 0) {
       const toolNames = selectedHosts.map((h) => h.name).join(", ");
       console.log(
-        `  ${chalk17.dim("Tools:")}     ${toolNames} ${chalk17.dim(`(${totalSkills} skills + ${totalCommands} commands installed)`)}`
+        `  ${chalk18.dim("Tools:")}     ${toolNames} ${chalk18.dim(`(${totalSkills} skills + ${totalCommands} commands installed)`)}`
       );
     }
     if (config.cloud_linked && config.cloud_project_id) {
@@ -16383,65 +16653,65 @@ Audited and populated during /iamu:init.
         config.cloud_project_id
       );
       console.log(
-        `  ${chalk17.dim("Cloud:")}     ${chalk17.green("Linked")} \xB7 ${chalk17.cyan(dashboardUrl)}`
+        `  ${chalk18.dim("Cloud:")}     ${chalk18.green("Linked")} \xB7 ${chalk18.cyan(dashboardUrl)}`
       );
     } else {
       console.log(
-        `  ${chalk17.dim("Cloud:")}     Local-only ${chalk17.dim("(link anytime with `iamu auth login`)")}`
+        `  ${chalk18.dim("Cloud:")}     Local-only ${chalk18.dim("(link anytime with `iamu auth login`)")}`
       );
     }
     console.log();
     if (freshInit) {
-      console.log(chalk17.bold("  Next steps:"));
+      console.log(chalk18.bold("  Next steps:"));
       console.log();
       console.log(
-        `    ${chalk17.bold("1.")} Start your application's dev server:`
+        `    ${chalk18.bold("1.")} Start your application's dev server:`
       );
       console.log(
-        `       ${chalk17.cyan("$ pnpm dev")} ${chalk17.dim("(or npm run dev)")}`
+        `       ${chalk18.cyan("$ pnpm dev")} ${chalk18.dim("(or npm run dev)")}`
       );
       console.log();
-      console.log(`    ${chalk17.bold("2.")} In your AI agent chat, run:`);
+      console.log(`    ${chalk18.bold("2.")} In your AI agent chat, run:`);
       console.log(
-        `       ${chalk17.cyan(setupCommand(projectRoot, selectedHosts))}`
+        `       ${chalk18.cyan(setupCommand(projectRoot, selectedHosts))}`
       );
       console.log();
       console.log(
-        chalk17.dim(
+        chalk18.dim(
           "       Your agent will analyze your codebase, map user roles, and generate your first walkthrough scenario."
         )
       );
       console.log();
-      console.log(chalk17.bold("  Core workflow:"));
+      console.log(chalk18.bold("  Core workflow:"));
       console.log(
-        chalk17.dim("    \u2022 ") + chalk17.cyan("/iamu:init") + chalk17.dim("        Map domain & scaffold inaugural scenario")
+        chalk18.dim("    \u2022 ") + chalk18.cyan("/iamu:init") + chalk18.dim("        Map domain & scaffold inaugural scenario")
       );
       console.log(
-        chalk17.dim("    \u2022 ") + chalk17.cyan("iamu-run <slug>") + chalk17.dim("   Walk scenario in browser & record findings")
+        chalk18.dim("    \u2022 ") + chalk18.cyan("iamu-run <slug>") + chalk18.dim("   Walk scenario in browser & record findings")
       );
       console.log(
-        chalk17.dim("    \u2022 ") + chalk17.cyan("iamu-findings") + chalk17.dim("     Triage persona feedback & apply code fixes")
+        chalk18.dim("    \u2022 ") + chalk18.cyan("iamu-findings") + chalk18.dim("     Triage persona feedback & apply code fixes")
       );
       console.log(
-        chalk17.dim("    \u2022 ") + chalk17.cyan("iamu-propose") + chalk17.dim("      Brainstorm high-risk workflows & new personas")
+        chalk18.dim("    \u2022 ") + chalk18.cyan("iamu-propose") + chalk18.dim("      Brainstorm high-risk workflows & new personas")
       );
     } else {
-      console.log(chalk17.bold("  Updated:"));
+      console.log(chalk18.bold("  Updated:"));
       console.log();
       console.log(
-        chalk17.dim("  Skills and commands regenerated to latest version.")
+        chalk18.dim("  Skills and commands regenerated to latest version.")
       );
     }
     console.log();
     console.log(
-      `  ${chalk17.dim("Docs:")}       ${chalk17.underline("https://iamu.dev/docs")}`
+      `  ${chalk18.dim("Docs:")}       ${chalk18.underline("https://iamu.dev/docs")}`
     );
     console.log(
-      `  ${chalk17.dim("Quickstart:")} ${chalk17.underline("https://iamu.dev/quickstart")}`
+      `  ${chalk18.dim("Quickstart:")} ${chalk18.underline("https://iamu.dev/quickstart")}`
     );
     if (config.cloud_linked && config.cloud_project_id) {
       console.log(
-        `  ${chalk17.dim("Dashboard:")}  ${chalk17.underline(getCloudDashboardUrl(void 0, config.cloud_project_id))}`
+        `  ${chalk18.dim("Dashboard:")}  ${chalk18.underline(getCloudDashboardUrl(void 0, config.cloud_project_id))}`
       );
     }
     console.log();
@@ -16469,7 +16739,7 @@ __export(status_exports, {
 });
 import { existsSync as existsSync8 } from "fs";
 import { join as join6 } from "path";
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 function rerunCommand(projectRoot, scenario) {
   const claude = join6(projectRoot, ".claude");
   const skillOnly = existsSync8(join6(claude, "skills", "iamu-run")) && !existsSync8(join6(claude, "commands", "iamu", "run.md"));
@@ -16479,19 +16749,19 @@ function printRerun(projectRoot, rerun) {
   if (rerun.length === 0) return;
   const total = rerun.reduce((n, r) => n + r.awaiting, 0);
   console.log(
-    chalk18.bold("  Needs a re-run") + chalk18.dim(
+    chalk19.bold("  Needs a re-run") + chalk19.dim(
       `  ${total} fix${total === 1 ? "" : "es"} awaiting proof from a later run`
     )
   );
   const width = Math.max(...rerun.map((r) => r.scenario.length));
   for (const r of rerun) {
     console.log(
-      `    ${chalk18.cyan(String(r.awaiting).padStart(2))}  ${r.scenario.padEnd(width)}` + chalk18.dim(`  ${r.reason}`)
+      `    ${chalk19.cyan(String(r.awaiting).padStart(2))}  ${r.scenario.padEnd(width)}` + chalk19.dim(`  ${r.reason}`)
     );
   }
   const first = rerun[0].scenario;
   console.log(
-    chalk18.dim("  Next: in your agent, ") + rerunCommand(projectRoot, first) + chalk18.dim(
+    chalk19.dim("  Next: in your agent, ") + rerunCommand(projectRoot, first) + chalk19.dim(
       rerun.length > 1 ? "  (then the others, most fixes first)" : ""
     )
   );
@@ -16561,10 +16831,10 @@ async function status(opts) {
   }
   const quiet = isQuiet();
   if (!quiet) console.log();
-  console.log(chalk18.bold("  " + projectStatus.project.name));
+  console.log(chalk19.bold("  " + projectStatus.project.name));
   if (!quiet) {
     console.log(
-      chalk18.dim(
+      chalk19.dim(
         "  " + (projectStatus.cloud.linked ? "cloud-linked" : "local-only")
       )
     );
@@ -16603,43 +16873,43 @@ async function status(opts) {
     ]
   ];
   for (const [label, count, invalid] of rows) {
-    const num = count === 0 ? chalk18.dim("0") : chalk18.cyan(String(count));
-    const inv = invalid > 0 ? chalk18.yellow(` (${symbols.warning} ${invalid} invalid)`) : "";
+    const num = count === 0 ? chalk19.dim("0") : chalk19.cyan(String(count));
+    const inv = invalid > 0 ? chalk19.yellow(` (${symbols.warning} ${invalid} invalid)`) : "";
     console.log(`  ${padRight(label, 14)} ${num}${inv}`);
   }
   if (!quiet) console.log();
-  let ctxLabel = chalk18.dim("none");
+  let ctxLabel = chalk19.dim("none");
   if (projectStatus.context.present) {
     if (projectStatus.context.richness === "thin") {
       const reasons = projectStatus.context.thin_reasons && projectStatus.context.thin_reasons.length > 0 ? ` (${projectStatus.context.thin_reasons.join(", ")})` : "";
-      ctxLabel = chalk18.yellow(`thin${reasons}`) + ` ${symbols.warning}`;
+      ctxLabel = chalk19.yellow(`thin${reasons}`) + ` ${symbols.warning}`;
     } else {
-      ctxLabel = chalk18.green("complete");
+      ctxLabel = chalk19.green("complete");
     }
   }
   console.log(`  ${padRight("context", 14)} ${ctxLabel}`);
   console.log(
-    `  ${padRight("runs", 14)} ${runs.length === 0 ? chalk18.dim("0") : chalk18.cyan(String(runs.length))}${runs.length > 0 ? chalk18.dim("  last: " + runs.at(-1)) : ""}`
+    `  ${padRight("runs", 14)} ${runs.length === 0 ? chalk19.dim("0") : chalk19.cyan(String(runs.length))}${runs.length > 0 ? chalk19.dim("  last: " + runs.at(-1)) : ""}`
   );
   if (incompleteRuns.length > 0) {
     console.log(
-      chalk18.yellow(`  ${padRight("unfinished", 14)} ${incompleteRuns.length}`) + chalk18.dim(
+      chalk19.yellow(`  ${padRight("unfinished", 14)} ${incompleteRuns.length}`) + chalk19.dim(
         "  never reached `iamu complete` \u2014 `iamu status --json` lists them"
       )
     );
   }
   if (projectStatus.requests && projectStatus.requests.open > 0) {
     console.log(
-      chalk18.cyan(
+      chalk19.cyan(
         `  ${padRight("requests", 14)} ${projectStatus.requests.open}`
-      ) + chalk18.dim("  queued by the team \u2014 `/iamu:findings` to pick one up")
+      ) + chalk19.dim("  queued by the team \u2014 `/iamu:findings` to pick one up")
     );
   }
   if (projectStatus.sync) {
     const { pending_new, pending_updates, pending_retries } = projectStatus.sync;
     if (pending_new > 0 || pending_updates > 0 || pending_retries > 0) {
       console.log(
-        chalk18.yellow(
+        chalk19.yellow(
           `  ${padRight("unpushed", 14)} ${pending_new} new, ${pending_updates} modified, ${pending_retries} retries`
         )
       );
@@ -16649,14 +16919,14 @@ async function status(opts) {
       const n = deletions.count;
       const noun = `${n} local deletion${n === 1 ? "" : "s"}`;
       console.log(
-        chalk18.yellow(
+        chalk19.yellow(
           deletions.needs_confirm ? `  ${padRight("deletions", 14)} ${noun} not yet synced \u2014 they need \`iamu sync --confirm-deletes\`` : `  ${padRight("deletions", 14)} ${noun} not yet synced \u2014 run \`iamu sync\``
         )
       );
     }
     if (deletions.held > 0) {
       console.log(
-        chalk18.dim(
+        chalk19.dim(
           `  ${padRight("held", 14)} ${deletions.held} local deletion(s) will not be sent yet \u2014 \`iamu sync\` says why`
         )
       );
@@ -16671,17 +16941,17 @@ async function status(opts) {
   if (allWarnings.length > 0) {
     if (!quiet) console.log();
     console.log(
-      chalk18.yellow(`  ${symbols.warning} Warnings (${allWarnings.length}):`)
+      chalk19.yellow(`  ${symbols.warning} Warnings (${allWarnings.length}):`)
     );
     for (const w of allWarnings) {
-      console.log(chalk18.dim(`    \u2022 ${w}`));
+      console.log(chalk19.dim(`    \u2022 ${w}`));
     }
   }
   if (!quiet) {
     console.log();
     printRerun(projectRoot, rerun);
     if (staleSkills.length > 0) {
-      console.log(chalk18.yellow(`  ${STALE_SKILLS_MESSAGE}`));
+      console.log(chalk19.yellow(`  ${STALE_SKILLS_MESSAGE}`));
       console.log();
     }
     console.log();
@@ -16804,7 +17074,7 @@ var init_browse_actions = __esm({
 
 // src/commands/browse-driver.ts
 import { execFile as execFile3, spawn } from "child_process";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 async function probeCdp(port, timeoutMs = CDP_PROBE_TIMEOUT_MS) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
@@ -16820,7 +17090,7 @@ async function probeCdp(port, timeoutMs = CDP_PROBE_TIMEOUT_MS) {
 async function readProcessCommandLine(pid, platform2 = process.platform) {
   if (!Number.isInteger(pid) || pid <= 0 || platform2 === "win32") return null;
   if (platform2 === "linux") {
-    const raw = await readFile4(`/proc/${pid}/cmdline`, "utf8").catch(() => "");
+    const raw = await readFile5(`/proc/${pid}/cmdline`, "utf8").catch(() => "");
     if (raw) return raw.split("\0").join(" ").trim();
   }
   return new Promise((resolve3) => {
@@ -16931,7 +17201,7 @@ var init_browse_driver = __esm({
 
 // src/commands/step-numbering.ts
 import { open, readdir, unlink } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 function stepFileName(stepNumber2) {
   return `${String(stepNumber2).padStart(3, "0")}.json`;
 }
@@ -16953,7 +17223,7 @@ async function reserveStepFile(stepsDir, limit) {
     if (candidate > limit.maxSteps) {
       throw new Error(stepLimitMessage(limit.maxSteps, limit.runId));
     }
-    const stepPath = path21.join(stepsDir, stepFileName(candidate));
+    const stepPath = path22.join(stepsDir, stepFileName(candidate));
     try {
       const handle = await open(stepPath, "wx");
       await handle.close();
@@ -16984,9 +17254,9 @@ __export(step_exports, {
   recordStep: () => recordStep,
   stepCommand: () => stepCommand
 });
-import { copyFile, mkdir as mkdir5, stat } from "fs/promises";
-import path22 from "path";
-import chalk19 from "chalk";
+import { copyFile, mkdir as mkdir5, stat as stat2 } from "fs/promises";
+import path23 from "path";
+import chalk20 from "chalk";
 function parseMaxSteps(val) {
   if (typeof val === "number" && Number.isFinite(val) && val > 0) return val;
   if (typeof val === "string" && val.trim().length > 0) {
@@ -17004,8 +17274,8 @@ async function recordStep(input) {
   if (!runDirPath) {
     throw new Error(`Run directory not found for run "${input.runId}"`);
   }
-  const stepsDir = path22.join(runDirPath, "steps");
-  const screenshotsDir = path22.join(runDirPath, "screenshots");
+  const stepsDir = path23.join(runDirPath, "steps");
+  const screenshotsDir = path23.join(runDirPath, "screenshots");
   await mkdir5(stepsDir, { recursive: true });
   await mkdir5(screenshotsDir, { recursive: true });
   const shotSource = input.shot ? await existingShot(input.shot) : null;
@@ -17019,11 +17289,11 @@ async function recordStep(input) {
     let finalScreenshotPath = null;
     if (shotSource) {
       const destName = `step-${stepNumber2}.png`;
-      finalScreenshotPath = path22.join(screenshotsDir, destName);
-      if (path22.resolve(finalScreenshotPath) !== shotSource) {
+      finalScreenshotPath = path23.join(screenshotsDir, destName);
+      if (path23.resolve(finalScreenshotPath) !== shotSource) {
         await copyFile(shotSource, finalScreenshotPath);
       }
-      screenshotRef = path22.join("screenshots", destName);
+      screenshotRef = path23.join("screenshots", destName);
     }
     const parsedStep = runStepSchema.parse({
       step_number: stepNumber2,
@@ -17037,10 +17307,24 @@ async function recordStep(input) {
       ...input.extra ? { extra: input.extra } : {}
     });
     await writeStep(runDirPath, parsedStep);
+    let cancelled = false;
+    try {
+      const liveRes = await sendLiveStep(
+        input.projectRoot,
+        input.runId,
+        parsedStep,
+        finalScreenshotPath
+      );
+      if (liveRes.cancelled) {
+        cancelled = true;
+      }
+    } catch {
+    }
     return {
       step: parsedStep,
       stepPath,
-      screenshotPath: finalScreenshotPath
+      screenshotPath: finalScreenshotPath,
+      cancelled
     };
   } catch (err) {
     await reservation.release();
@@ -17048,8 +17332,8 @@ async function recordStep(input) {
   }
 }
 async function existingShot(shot) {
-  const resolved = path22.resolve(shot);
-  const isFile = await stat(resolved).then((s) => s.isFile()).catch(() => false);
+  const resolved = path23.resolve(shot);
+  const isFile = await stat2(resolved).then((s) => s.isFile()).catch(() => false);
   if (!isFile) {
     throw new Error(
       `Screenshot not found: ${resolved} \u2014 save the screenshot first, or omit --shot.`
@@ -17085,12 +17369,42 @@ async function stepCommand(runArg, opts) {
       grounding: opts.grounding,
       maxSteps: opts.maxSteps
     });
+    if (res.cancelled) {
+      if (opts.json) {
+        console.log(
+          JSON.stringify(
+            {
+              step_number: res.step.step_number,
+              cancelled: true,
+              path: path23.relative(projectRoot, res.stepPath),
+              action: res.step.action,
+              note: res.step.note,
+              url: res.step.url,
+              screenshot: res.step.screenshot,
+              surface: res.step.surface
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log();
+        console.log(
+          chalk20.red(
+            "The user stopped this run from the live viewer. End the walk now."
+          )
+        );
+        console.log();
+      }
+      process.exitCode = 1;
+      return;
+    }
     if (opts.json) {
       console.log(
         JSON.stringify(
           {
             step_number: res.step.step_number,
-            path: path22.relative(projectRoot, res.stepPath),
+            path: path23.relative(projectRoot, res.stepPath),
             action: res.step.action,
             note: res.step.note,
             url: res.step.url,
@@ -17105,19 +17419,19 @@ async function stepCommand(runArg, opts) {
     }
     console.log();
     console.log(
-      `  ${symbols.success} Step ${chalk19.cyan(String(res.step.step_number))} recorded: ${res.step.action}`
+      `  ${symbols.success} Step ${chalk20.cyan(String(res.step.step_number))} recorded: ${res.step.action}`
     );
     if (res.step.note) {
-      console.log(`  ${chalk19.dim("note:")}       ${res.step.note}`);
+      console.log(`  ${chalk20.dim("note:")}       ${res.step.note}`);
     }
     if (res.step.url) {
-      console.log(`  ${chalk19.dim("url:")}        ${res.step.url}`);
+      console.log(`  ${chalk20.dim("url:")}        ${res.step.url}`);
     }
     if (res.step.screenshot) {
-      console.log(`  ${chalk19.dim("shot:")}       ${res.step.screenshot}`);
+      console.log(`  ${chalk20.dim("shot:")}       ${res.step.screenshot}`);
     }
     console.log(
-      `  ${chalk19.dim("file:")}       ${path22.relative(projectRoot, res.stepPath)}`
+      `  ${chalk20.dim("file:")}       ${path23.relative(projectRoot, res.stepPath)}`
     );
     console.log();
   } catch (err) {
@@ -17132,6 +17446,7 @@ var init_step = __esm({
     init_dist();
     init_symbols();
     init_context4();
+    init_live_run_client();
     init_step_numbering();
     DEFAULT_MAX_STEPS = 50;
   }
@@ -17160,21 +17475,21 @@ import {
 } from "fs";
 import { rm as rm2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import path23 from "path";
-import chalk20 from "chalk";
+import path24 from "path";
+import chalk21 from "chalk";
 function stateDir() {
-  return path23.join(
-    process.env.IAMU_HOME ?? path23.join(homedir3(), ".iamu"),
+  return path24.join(
+    process.env.IAMU_HOME ?? path24.join(homedir3(), ".iamu"),
     "browse"
   );
 }
 function profileDir() {
-  return path23.join(stateDir(), "profile");
+  return path24.join(stateDir(), "profile");
 }
 function readBrowseState() {
   try {
     return JSON.parse(
-      readFileSync6(path23.join(stateDir(), "state.json"), "utf8")
+      readFileSync6(path24.join(stateDir(), "state.json"), "utf8")
     );
   } catch {
     return null;
@@ -17182,13 +17497,13 @@ function readBrowseState() {
 }
 function writeState(state) {
   mkdirSync(stateDir(), { recursive: true });
-  writeFileSync(path23.join(stateDir(), "state.json"), JSON.stringify(state));
+  writeFileSync(path24.join(stateDir(), "state.json"), JSON.stringify(state));
 }
 function fail(message, opts) {
   if (opts?.json) {
     console.error(JSON.stringify({ error: message }));
   } else {
-    console.error(chalk20.red(`  ${message}`));
+    console.error(chalk21.red(`  ${message}`));
   }
   process.exitCode = 1;
 }
@@ -17245,7 +17560,7 @@ async function requestedViewport(opts) {
   let manifest;
   try {
     manifest = JSON.parse(
-      readFileSync6(path23.join(dir, "walkthrough.json"), "utf8")
+      readFileSync6(path24.join(dir, "walkthrough.json"), "utf8")
     );
   } catch {
     fail(
@@ -17277,7 +17592,7 @@ async function convergeRunning(opts, driver, port, requested, previous) {
   writeState({ port, viewport, pid: previous?.pid });
   if (sameSize(current, viewport)) {
     report2(opts, { reused: true, port, viewport }, [
-      `  ${chalk20.green("\u2713")} Browser reused ${chalk20.dim(`(CDP :${port}, viewport ${sizeLabel(viewport)})`)}`
+      `  ${chalk21.green("\u2713")} Browser reused ${chalk21.dim(`(CDP :${port}, viewport ${sizeLabel(viewport)})`)}`
     ]);
     return;
   }
@@ -17286,7 +17601,7 @@ async function convergeRunning(opts, driver, port, requested, previous) {
   } catch {
   }
   report2(opts, { resized: true, from: current, to: viewport, port }, [
-    `  ${chalk20.green("\u2713")} Browser resized ${sizeLabel(current)} \u2192 ${sizeLabel(viewport)} ${chalk20.dim(`(CDP :${port})`)}`
+    `  ${chalk21.green("\u2713")} Browser resized ${sizeLabel(current)} \u2192 ${sizeLabel(viewport)} ${chalk21.dim(`(CDP :${port})`)}`
   ]);
 }
 function chromeArgs(opts, port, headless) {
@@ -17330,7 +17645,7 @@ async function start(opts, driver = cdpDriver) {
   for (let i = 0; i < 75; i++) {
     if (await driver.isRunning(port)) {
       report2(opts, { ready: true, port, viewport, headless }, [
-        `  ${chalk20.green("\u2713")} Browser ready ${chalk20.dim(`(CDP :${port}${viewport ? `, viewport ${sizeLabel(viewport)}` : ""}${headless ? ", headless" : ""})`)}`
+        `  ${chalk21.green("\u2713")} Browser ready ${chalk21.dim(`(CDP :${port}${viewport ? `, viewport ${sizeLabel(viewport)}` : ""}${headless ? ", headless" : ""})`)}`
       ]);
       return;
     }
@@ -17351,10 +17666,10 @@ async function stop(opts, driver) {
   await driver.closeBrowser(state.port);
   if (state.pid) await reapBrowser(state.pid, profileDir(), driver);
   try {
-    unlinkSync(path23.join(stateDir(), "state.json"));
+    unlinkSync(path24.join(stateDir(), "state.json"));
   } catch {
   }
-  report2(opts, { stopped: true }, [`  ${chalk20.green("\u2713")} Browser stopped`]);
+  report2(opts, { stopped: true }, [`  ${chalk21.green("\u2713")} Browser stopped`]);
 }
 async function waitForVisualStability(page, maxWaitMs = 300) {
   let timer;
@@ -17417,8 +17732,8 @@ async function withPage(opts, driver, fn, target) {
     let screenshot = null;
     if (opts.shot) {
       await waitForVisualStability(page);
-      screenshot = path23.resolve(opts.shot);
-      mkdirSync(path23.dirname(screenshot), { recursive: true });
+      screenshot = path24.resolve(opts.shot);
+      mkdirSync(path24.dirname(screenshot), { recursive: true });
       await page.screenshot({ path: screenshot, fullPage: Boolean(opts.full) });
     }
     return { url: page.url(), title: await page.title(), screenshot };
@@ -17497,23 +17812,24 @@ function printStep(opts, record, projectRoot) {
   if (opts.json) {
     const doc = {
       step_number: step.step_number,
-      path: path23.relative(projectRoot, record.stepPath),
+      path: path24.relative(projectRoot, record.stepPath),
       action: step.action,
       note: step.note,
       url: step.url,
       screenshot: step.screenshot,
-      surface: step.surface
+      surface: step.surface,
+      ...record.cancelled ? { cancelled: true } : {}
     };
     console.log(JSON.stringify(doc, null, 2));
     return;
   }
   console.log(
-    `  ${chalk20.green("\u2713")} Step ${chalk20.cyan(String(step.step_number))} recorded: ${step.action}`
+    `  ${chalk21.green("\u2713")} Step ${chalk21.cyan(String(step.step_number))} recorded: ${step.action}`
   );
-  if (step.note) console.log(`    ${chalk20.dim("note:")}       ${step.note}`);
-  if (step.url) console.log(`    ${chalk20.dim("url:")}        ${step.url}`);
+  if (step.note) console.log(`    ${chalk21.dim("note:")}       ${step.note}`);
+  if (step.url) console.log(`    ${chalk21.dim("url:")}        ${step.url}`);
   if (step.screenshot) {
-    console.log(`    ${chalk20.dim("screenshot:")} ${step.screenshot}`);
+    console.log(`    ${chalk21.dim("screenshot:")} ${step.screenshot}`);
   }
 }
 async function browseStep(args, opts, driver) {
@@ -17571,10 +17887,10 @@ async function browseStep(args, opts, driver) {
   const runDirPath = resolveRunDir(ctx.projectRoot, opts.run);
   if (!runDirPath) return;
   const maxSteps = parseMaxSteps(opts.maxSteps);
-  if (await peekNextStepNumber(path23.join(runDirPath, "steps")) > maxSteps) {
+  if (await peekNextStepNumber(path24.join(runDirPath, "steps")) > maxSteps) {
     return fail(stepLimitMessage(maxSteps, opts.run), opts);
   }
-  const pendingShot = path23.join(
+  const pendingShot = path24.join(
     runDirPath,
     "screenshots",
     `.pending-${randomUUID7()}.png`
@@ -17598,6 +17914,19 @@ async function browseStep(args, opts, driver) {
       maxSteps
     });
     printStep(opts, record, ctx.projectRoot);
+    if (record.cancelled) {
+      if (!opts.json) {
+        console.log();
+        console.log(
+          chalk21.red(
+            "The user stopped this run from the live viewer. End the walk now."
+          )
+        );
+        console.log();
+      }
+      process.exitCode = 1;
+      return;
+    }
   } catch (err) {
     fail(err instanceof Error ? err.message : String(err), opts);
   } finally {
@@ -17654,7 +17983,7 @@ __export(doctor_exports, {
 import { createServer } from "net";
 import { existsSync as existsSync10, promises as fs26 } from "fs";
 import { join as join7 } from "path";
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 function checkPortAvailable(port) {
   return new Promise((resolve3) => {
     const server = createServer();
@@ -18161,7 +18490,7 @@ async function doctor(opts) {
     return;
   }
   console.log();
-  console.log(chalk21.bold("  Iamu System Diagnostics"));
+  console.log(chalk22.bold("  Iamu System Diagnostics"));
   console.log();
   const categories = [
     { key: "runtime", title: "Runtime & System" },
@@ -18174,13 +18503,13 @@ async function doctor(opts) {
   for (const cat of categories) {
     const catChecks = result.checks.filter((c) => c.category === cat.key);
     if (catChecks.length === 0) continue;
-    console.log(chalk21.bold(`  ${cat.title}:`));
+    console.log(chalk22.bold(`  ${cat.title}:`));
     for (const check of catChecks) {
-      const sym = check.status === "ok" ? symbols.success : check.status === "warn" ? chalk21.yellow("\u25CB") : symbols.error;
-      console.log(`    ${sym} ${check.name}: ${chalk21.dim(check.message)}`);
+      const sym = check.status === "ok" ? symbols.success : check.status === "warn" ? chalk22.yellow("\u25CB") : symbols.error;
+      console.log(`    ${sym} ${check.name}: ${chalk22.dim(check.message)}`);
       if (check.remedy) {
         console.log(
-          `      ${chalk21.cyan("\u21B3 Remedy:")} ${chalk21.dim(check.remedy)}`
+          `      ${chalk22.cyan("\u21B3 Remedy:")} ${chalk22.dim(check.remedy)}`
         );
       }
     }
@@ -18188,15 +18517,15 @@ async function doctor(opts) {
   }
   if (result.ok && result.summary.warn === 0) {
     console.log(
-      `  ${symbols.success} ${chalk21.green.bold("All systems operational.")}`
+      `  ${symbols.success} ${chalk22.green.bold("All systems operational.")}`
     );
   } else if (result.ok) {
     console.log(
-      `  ${symbols.warning} ${chalk21.yellow.bold(`${result.summary.warn} warning(s) detected.`)} (Walkthroughs can still run)`
+      `  ${symbols.warning} ${chalk22.yellow.bold(`${result.summary.warn} warning(s) detected.`)} (Walkthroughs can still run)`
     );
   } else {
     console.log(
-      `  ${symbols.error} ${chalk21.red.bold(`${result.summary.error} error(s) and ${result.summary.warn} warning(s) detected.`)}`
+      `  ${symbols.error} ${chalk22.red.bold(`${result.summary.error} error(s) and ${result.summary.warn} warning(s) detected.`)}`
     );
     process.exitCode = 1;
   }
@@ -18293,20 +18622,20 @@ var list_exports = {};
 __export(list_exports, {
   list: () => list
 });
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 function severityColor(severity) {
   const raw = (severity ?? "\u2014").trim();
   switch (raw) {
     case "critical":
-      return chalk22.red(raw);
+      return chalk23.red(raw);
     case "major":
-      return chalk22.yellow(raw);
+      return chalk23.yellow(raw);
     case "minor":
-      return chalk22.cyan(raw);
+      return chalk23.cyan(raw);
     case "observation":
-      return chalk22.dim(raw);
+      return chalk23.dim(raw);
     default:
-      return chalk22.dim(raw);
+      return chalk23.dim(raw);
   }
 }
 async function list(type2, opts) {
@@ -18361,16 +18690,16 @@ async function list(type2, opts) {
   for (const [t, c] of counts) {
     const label = PLURAL_LABELS[t].padEnd(14);
     if (!c) {
-      console.log(`  ${label} ${chalk22.dim("error")}`);
+      console.log(`  ${label} ${chalk23.dim("error")}`);
       continue;
     }
-    const count = c.count === 0 ? chalk22.dim("0") : chalk22.cyan(String(c.count));
-    const warn = c.invalid > 0 ? chalk22.yellow(` (${c.invalid} invalid)`) : "";
+    const count = c.count === 0 ? chalk23.dim("0") : chalk23.cyan(String(c.count));
+    const warn = c.invalid > 0 ? chalk23.yellow(` (${c.invalid} invalid)`) : "";
     console.log(`  ${label} ${count}${warn}`);
   }
   console.log();
   console.log(
-    chalk22.dim("  Run 'iamu list <type>' for details (e.g. iamu list personas)")
+    chalk23.dim("  Run 'iamu list <type>' for details (e.g. iamu list personas)")
   );
   console.log();
 }
@@ -18396,7 +18725,7 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
     if (!diffResult || diffResult.files.length === 0) {
       if (!opts.json) {
         console.log(
-          chalk22.dim(
+          chalk23.dim(
             `  No git diff detected against ${diffResult?.baseRef ?? "base ref"}.`
           )
         );
@@ -18443,10 +18772,10 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
     return;
   }
   if (entities.length === 0) {
-    console.log(chalk22.dim(`  No ${PLURAL_LABELS[type2]} found.`));
+    console.log(chalk23.dim(`  No ${PLURAL_LABELS[type2]} found.`));
     if (!diffFilter) {
       console.log(
-        chalk22.dim(
+        chalk23.dim(
           `  Run \`iamu new ${type2} --name "..."\` to create your first ${type2}.`
         )
       );
@@ -18457,10 +18786,10 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
   if (isTty) {
     console.log();
     console.log(
-      chalk22.bold(`  ${PLURAL_LABELS[type2]}`) + chalk22.dim(` (${entities.length})`)
+      chalk23.bold(`  ${PLURAL_LABELS[type2]}`) + chalk23.dim(` (${entities.length})`)
     );
     if (diffNotice) {
-      console.log(chalk22.cyan(`  ${diffNotice}`));
+      console.log(chalk23.cyan(`  ${diffNotice}`));
     }
     console.log();
   }
@@ -18478,7 +18807,7 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
         },
         {
           header: "role",
-          value: (e) => chalk22.dim(e.frontmatter.role ?? "")
+          value: (e) => chalk23.dim(e.frontmatter.role ?? "")
         }
       ]);
       break;
@@ -18518,7 +18847,7 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
         },
         {
           header: "title",
-          value: (e) => e.frontmatter.title ?? chalk22.dim("(no title)")
+          value: (e) => e.frontmatter.title ?? chalk23.dim("(no title)")
         }
       ]);
       break;
@@ -18544,7 +18873,7 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
         },
         {
           header: "capability",
-          value: (e) => chalk22.dim(
+          value: (e) => chalk23.dim(
             e.frontmatter.primary_capability ?? e.frontmatter.capability ?? ""
           )
         },
@@ -18593,7 +18922,7 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
         },
         {
           header: "rule",
-          value: (e) => parseGuidanceBody(e.body).rule || chalk22.dim("(no rule)")
+          value: (e) => parseGuidanceBody(e.body).rule || chalk23.dim("(no rule)")
         }
       ]);
       break;
@@ -18606,10 +18935,10 @@ async function listSingleType(projectRoot, type2, capabilityFilter, diffFilter,
     if (isTty) {
       console.log();
       console.log(
-        chalk22.yellow(`  ${warnings.length} invalid file(s) skipped:`)
+        chalk23.yellow(`  ${warnings.length} invalid file(s) skipped:`)
       );
       for (const w of warnings) {
-        console.log(chalk22.dim(`    ${w.path}: ${w.error}`));
+        console.log(chalk23.dim(`    ${w.path}: ${w.error}`));
       }
     } else {
       for (const w of warnings) {
@@ -18648,12 +18977,12 @@ __export(validate_exports, {
 });
 import { randomUUID as randomUUID8 } from "crypto";
 import { promises as fs27 } from "fs";
-import path24 from "path";
-import chalk23 from "chalk";
+import path25 from "path";
+import chalk24 from "chalk";
 function inferTypeFromPath(filePath, projectRoot) {
-  const rel = path24.relative(path24.join(projectRoot, "iamu"), filePath);
-  if (rel.startsWith("..") || path24.isAbsolute(rel)) return null;
-  const segments = rel.split(path24.sep);
+  const rel = path25.relative(path25.join(projectRoot, "iamu"), filePath);
+  if (rel.startsWith("..") || path25.isAbsolute(rel)) return null;
+  const segments = rel.split(path25.sep);
   if (segments.length < 2) return null;
   return TYPE_BY_ALIAS.get(segments[0]) ?? null;
 }
@@ -18683,7 +19012,7 @@ function validateFile(filePath, raw, projectRoot) {
     );
     return result;
   }
-  if (path24.basename(filePath) === "context.yml") {
+  if (path25.basename(filePath) === "context.yml") {
     applyZodValidation(contextFrontmatterSchema, frontmatter, result);
     const warnings = [];
     const hasNotes = Boolean(
@@ -18743,7 +19072,7 @@ async function buildRepairLookups(projectRoot) {
     }
   }
   const runScenario = /* @__PURE__ */ new Map();
-  const runsDir2 = path24.join(projectRoot, "iamu", ".runs");
+  const runsDir2 = path25.join(projectRoot, "iamu", ".runs");
   let runIds = [];
   try {
     runIds = await fs27.readdir(runsDir2);
@@ -18753,7 +19082,7 @@ async function buildRepairLookups(projectRoot) {
     try {
       const manifest = JSON.parse(
         await fs27.readFile(
-          path24.join(runsDir2, runId, "walkthrough.json"),
+          path25.join(runsDir2, runId, "walkthrough.json"),
           "utf8"
         )
       );
@@ -18784,7 +19113,7 @@ async function fixFindings(projectRoot, results, dryRun) {
       parsed.frontmatter,
       {
         ...lookups,
-        fileSlug: path24.basename(result.path, ".md"),
+        fileSlug: path25.basename(result.path, ".md"),
         newId: randomUUID8,
         body: parsed.body
       }
@@ -18819,7 +19148,7 @@ async function validate(filePath, opts) {
   if (process.exitCode === 1) return;
   const results = [];
   if (filePath) {
-    const abs = path24.isAbsolute(filePath) ? filePath : path24.resolve(process.cwd(), filePath);
+    const abs = path25.isAbsolute(filePath) ? filePath : path25.resolve(process.cwd(), filePath);
     try {
       const raw = await fs27.readFile(abs, "utf8");
       results.push(validateFile(abs, raw, projectRoot));
@@ -18831,7 +19160,7 @@ async function validate(filePath, opts) {
       return;
     }
   } else if (opts.run) {
-    const findingsDir = path24.join(projectRoot, "iamu", ENTITY_DIRS.finding);
+    const findingsDir = path25.join(projectRoot, "iamu", ENTITY_DIRS.finding);
     let names = [];
     try {
       names = await fs27.readdir(findingsDir);
@@ -18839,7 +19168,7 @@ async function validate(filePath, opts) {
     }
     for (const name of names) {
       if (!name.endsWith(".md")) continue;
-      const abs = path24.join(findingsDir, name);
+      const abs = path25.join(findingsDir, name);
       try {
         const raw = await fs27.readFile(abs, "utf8");
         const { frontmatter } = parseFrontmatter(raw);
@@ -18848,7 +19177,7 @@ async function validate(filePath, opts) {
         }
       } catch {
         results.push({
-          path: path24.relative(projectRoot, abs),
+          path: path25.relative(projectRoot, abs),
           valid: false,
           errors: ["Cannot read file or parse frontmatter"]
         });
@@ -18874,14 +19203,14 @@ async function validate(filePath, opts) {
           )
         );
       } else {
-        console.log(chalk23.dim(`  No findings found for run "${opts.run}".`));
+        console.log(chalk24.dim(`  No findings found for run "${opts.run}".`));
       }
       return;
     }
   } else {
     const typesToCheck = typeFilter ? ENTITY_TYPES.filter((t) => typeFilter.has(t)) : ENTITY_TYPES;
     for (const type2 of typesToCheck) {
-      const iamuTypeDir = path24.join(projectRoot, "iamu", ENTITY_DIRS[type2]);
+      const iamuTypeDir = path25.join(projectRoot, "iamu", ENTITY_DIRS[type2]);
       let names;
       try {
         names = await fs27.readdir(iamuTypeDir);
@@ -18890,20 +19219,20 @@ async function validate(filePath, opts) {
       }
       for (const name of names) {
         if (!name.endsWith(".md")) continue;
-        const abs = path24.join(iamuTypeDir, name);
+        const abs = path25.join(iamuTypeDir, name);
         try {
           const raw = await fs27.readFile(abs, "utf8");
           results.push(validateFile(abs, raw, projectRoot));
         } catch {
           results.push({
-            path: path24.relative(projectRoot, abs),
+            path: path25.relative(projectRoot, abs),
             valid: false,
             errors: ["Cannot read file"]
           });
         }
       }
     }
-    const ctxPath = path24.join(projectRoot, "iamu", "context.yml");
+    const ctxPath = path25.join(projectRoot, "iamu", "context.yml");
     try {
       const raw = await fs27.readFile(ctxPath, "utf8");
       results.push(validateFile(ctxPath, raw, projectRoot));
@@ -18924,19 +19253,19 @@ async function validate(filePath, opts) {
           valid,
           errors: results.filter((r) => !r.valid).flatMap(
             (r) => r.errors.map((e) => ({
-              path: path24.relative(projectRoot, r.path),
+              path: path25.relative(projectRoot, r.path),
               message: e
             }))
           ),
           warnings: results.filter((r) => r.warnings && r.warnings.length > 0).flatMap(
             (r) => (r.warnings ?? []).map((w) => ({
-              path: path24.relative(projectRoot, r.path),
+              path: path25.relative(projectRoot, r.path),
               message: w
             }))
           ),
           ...opts.fix ? {
             repaired: repaired.map((r) => ({
-              path: path24.relative(projectRoot, r.path),
+              path: path25.relative(projectRoot, r.path),
               changes: r.repairs,
               valid: r.valid
             }))
@@ -18958,30 +19287,30 @@ async function validate(filePath, opts) {
   }
   let hasErrors = false;
   for (const r of results) {
-    const relPath = path24.relative(projectRoot, r.path);
+    const relPath = path25.relative(projectRoot, r.path);
     if (r.valid) {
       if (r.warnings && r.warnings.length > 0) {
-        console.log(`  ${symbols.warning} ` + chalk23.yellow(relPath));
+        console.log(`  ${symbols.warning} ` + chalk24.yellow(relPath));
         for (const w of r.warnings) {
-          console.log(chalk23.yellow(`      \u2022 ${w}`));
+          console.log(chalk24.yellow(`      \u2022 ${w}`));
         }
       } else {
-        console.log(`  ${symbols.success} ` + chalk23.dim(relPath));
+        console.log(`  ${symbols.success} ` + chalk24.dim(relPath));
       }
       for (const change of r.repairs ?? []) {
-        console.log(`      ${symbols.modified} ` + chalk23.dim(change));
+        console.log(`      ${symbols.modified} ` + chalk24.dim(change));
       }
     } else {
       hasErrors = true;
       console.log(`  ${symbols.error} ` + relPath);
       for (const change of r.repairs ?? []) {
-        console.log(`      ${symbols.modified} ` + chalk23.dim(change));
+        console.log(`      ${symbols.modified} ` + chalk24.dim(change));
       }
       for (const e of r.errors) {
-        console.log(chalk23.dim("      " + e));
+        console.log(chalk24.dim("      " + e));
       }
       for (const w of r.warnings ?? []) {
-        console.log(chalk23.yellow("      \u2022 " + w));
+        console.log(chalk24.yellow("      \u2022 " + w));
       }
     }
   }
@@ -18994,7 +19323,7 @@ async function validate(filePath, opts) {
     );
   }
   if (results.length === 0) {
-    console.log(chalk23.dim("  No files to validate."));
+    console.log(chalk24.dim("  No files to validate."));
   }
   if (hasErrors) {
     process.exitCode = 1;
@@ -19032,9 +19361,9 @@ __export(update_exports, {
   update: () => update
 });
 import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
-import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
 import { join as join8 } from "path";
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 async function update(opts) {
   const ctx = await resolveProject();
   if (!ctx) return;
@@ -19061,7 +19390,7 @@ async function update(opts) {
         const dest = join8(promptsDir, file);
         let existing = "";
         try {
-          existing = await readFile5(dest, "utf-8");
+          existing = await readFile6(dest, "utf-8");
         } catch {
         }
         if (existing !== content) {
@@ -19079,13 +19408,13 @@ async function update(opts) {
     opts?.host
   );
   if (error) {
-    console.error(chalk24.red(`  ${symbols.error} ${error}`));
+    console.error(chalk25.red(`  ${symbols.error} ${error}`));
     process.exitCode = 1;
     return;
   }
   if (targetHosts.length === 0) {
     console.log(
-      chalk24.dim(
+      chalk25.dim(
         "  No supported agent hosts detected. Specify with `iamu update --host <name>` or run `iamu init`."
       )
     );
@@ -19139,7 +19468,7 @@ __export(new_entity_exports, {
   newEntity: () => newEntity
 });
 import { randomUUID as randomUUID9 } from "crypto";
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 function defaultFrontmatter(type2, id, slug, name, opts) {
   const base = { id, slug };
   const description = opts.description ? { description: opts.description } : {};
@@ -19265,9 +19594,9 @@ async function newEntity(type2, opts) {
     }
     console.log();
     console.log(
-      `  ${symbols.success} Created ${entityType}: ${chalk25.cyan(slug)}`
+      `  ${symbols.success} Created ${entityType}: ${chalk26.cyan(slug)}`
     );
-    console.log(`  ${chalk25.dim("path:")} ${record.path}`);
+    console.log(`  ${chalk26.dim("path:")} ${record.path}`);
     console.log();
   } catch (err) {
     commandError(
@@ -19408,7 +19737,7 @@ async function crawlFrom(page, opts, origin, takeBlocked) {
   const byKey = /* @__PURE__ */ new Map();
   const byPlaceView = /* @__PURE__ */ new Map();
   const signatureOf = (s) => exploreSignature(s.headings, s.title);
-  function addSurface(state, place, view, path30, depth) {
+  function addSurface(state, place, view, path31, depth) {
     const key = exploreSurfaceKey(place, view);
     const surface = {
       key,
@@ -19420,7 +19749,7 @@ async function crawlFrom(page, opts, origin, takeBlocked) {
       headings: state.headings,
       fields: state.fields,
       depth,
-      path: path30,
+      path: path31,
       actions: []
     };
     surfaces.push(surface);
@@ -19438,9 +19767,9 @@ ${surface.signature}`, key);
     });
     await settle(page, settleMs);
   }
-  async function replay(path30) {
-    if (!("goto" in (path30[0] ?? {}))) await goto(opts.startUrl);
-    for (const step of path30) {
+  async function replay(path31) {
+    if (!("goto" in (path31[0] ?? {}))) await goto(opts.startUrl);
+    for (const step of path31) {
       if ("goto" in step) {
         await goto(step.goto);
       } else {
@@ -19564,8 +19893,8 @@ ${sig}`, key);
               if (stats.surfaces >= budget.max_surfaces) {
                 stats.truncated = true;
               } else {
-                const path30 = !sameDoc && view === null ? [{ goto: after.url }] : [...surface.path, ...via, click];
-                addSurface(after, place, view, path30, surface.depth + 1);
+                const path31 = !sameDoc && view === null ? [{ goto: after.url }] : [...surface.path, ...via, click];
+                addSurface(after, place, view, path31, surface.depth + 1);
               }
             }
           }
@@ -19766,11 +20095,11 @@ __export(explore_exports, {
   exploreRun: () => exploreRun
 });
 import { promises as fs28 } from "fs";
-import path25 from "path";
-import chalk26 from "chalk";
+import path26 from "path";
+import chalk27 from "chalk";
 function fail2(message, json2) {
   if (json2) console.error(JSON.stringify({ error: message }));
-  else console.error(chalk26.red(`  ${message}`));
+  else console.error(chalk27.red(`  ${message}`));
   process.exitCode = 1;
 }
 function positiveInt(raw, fallback, flag) {
@@ -19784,7 +20113,7 @@ function positiveInt(raw, fallback, flag) {
 async function testabilityTarget2(projectRoot) {
   try {
     const raw = await fs28.readFile(
-      path25.join(projectRoot, "iamu", "testability.md"),
+      path26.join(projectRoot, "iamu", "testability.md"),
       "utf8"
     );
     const { frontmatter } = parseFrontmatter(raw);
@@ -19873,7 +20202,7 @@ async function exploreRun(url, opts) {
   }
   const quiet = opts.json || process.env.IAMU_QUIET === "1";
   if (!quiet) {
-    console.error(chalk26.dim(`  Exploring ${startUrl} (read-only)\u2026`));
+    console.error(chalk27.dim(`  Exploring ${startUrl} (read-only)\u2026`));
   }
   const now = /* @__PURE__ */ new Date();
   let opened = null;
@@ -19884,7 +20213,7 @@ async function exploreRun(url, opts) {
       startUrl,
       budget,
       deny,
-      log: quiet ? void 0 : (line) => console.error(chalk26.dim(line))
+      log: quiet ? void 0 : (line) => console.error(chalk27.dim(line))
     });
   } catch (err) {
     fail2(err.message.split("\n")[0], opts.json);
@@ -19904,7 +20233,7 @@ async function exploreRun(url, opts) {
     surfaces: result.surfaces
   };
   const file = await writeExploreMap(ctx.projectRoot, map2);
-  const rel = path25.relative(process.cwd(), file);
+  const rel = path26.relative(process.cwd(), file);
   if (opts.json) {
     console.log(JSON.stringify({ id: map2.id, path: rel, stats: map2.stats }));
     return;
@@ -19912,17 +20241,17 @@ async function exploreRun(url, opts) {
   const s = map2.stats;
   console.log(
     `
-  ${chalk26.bold(`${s.surfaces} surfaces`)} \xB7 ${s.actions_tried} controls tried \xB7 ${s.skipped} skipped \xB7 ${s.blocked_requests} writes blocked${s.errors ? ` \xB7 ${s.errors} errors` : ""}`
+  ${chalk27.bold(`${s.surfaces} surfaces`)} \xB7 ${s.actions_tried} controls tried \xB7 ${s.skipped} skipped \xB7 ${s.blocked_requests} writes blocked${s.errors ? ` \xB7 ${s.errors} errors` : ""}`
   );
   if (s.truncated) {
     console.log(
-      chalk26.yellow(
+      chalk27.yellow(
         "  Stopped by the budget before the product ran out \u2014 raise --max-surfaces / --max-actions / --max-depth to go further."
       )
     );
   }
   console.log(`  Map: ${rel}`);
-  console.log(chalk26.dim("  Next: iamu explore coverage"));
+  console.log(chalk27.dim("  Next: iamu explore coverage"));
 }
 async function resolveMapId(projectRoot, id, offsetFromEnd = 1) {
   if (id && id !== "latest") return id;
@@ -19950,7 +20279,7 @@ async function exploreList(opts) {
   }
   for (const r of rows) {
     console.log(
-      `  ${r.id}  ${r.surfaces} surfaces  ${chalk26.dim(r.target_url)}`
+      `  ${r.id}  ${r.surfaces} surfaces  ${chalk27.dim(r.target_url)}`
     );
   }
 }
@@ -19979,7 +20308,7 @@ async function exploreCoverageCommand(mapId, opts) {
   Map ${id} (${map2.surfaces.length} surfaces) against ${cov.runs} runs, ${cov.steps} steps`
   );
   console.log(
-    `  ${chalk26.green(`${cov.reached} reached`)} \xB7 ${chalk26.yellow(`${cov.place_only} URL reached, view unclear`)} \xB7 ${chalk26.red(`${cov.unreached} never reached`)}`
+    `  ${chalk27.green(`${cov.reached} reached`)} \xB7 ${chalk27.yellow(`${cov.place_only} URL reached, view unclear`)} \xB7 ${chalk27.red(`${cov.unreached} never reached`)}`
   );
   const section = (title, rows, color) => {
     if (rows.length === 0) return;
@@ -19987,23 +20316,23 @@ async function exploreCoverageCommand(mapId, opts) {
   ${color(title)}`);
     for (const r of rows) {
       console.log(
-        `    ${r.key.padEnd(32)} ${r.label}${chalk26.dim(`  (depth ${r.depth})`)}`
+        `    ${r.key.padEnd(32)} ${r.label}${chalk27.dim(`  (depth ${r.depth})`)}`
       );
     }
   };
   section(
     "Never reached by a run",
     cov.surfaces.filter((s) => s.status === "unreached"),
-    chalk26.red
+    chalk27.red
   );
   section(
     "URL reached, but no step names this view",
     cov.surfaces.filter((s) => s.status === "place_only"),
-    chalk26.yellow
+    chalk27.yellow
   );
   if (cov.run_only_places.length > 0) {
     console.log(`
-  ${chalk26.cyan("Walked by runs, not in the map")}`);
+  ${chalk27.cyan("Walked by runs, not in the map")}`);
     for (const p of cov.run_only_places) {
       console.log(
         `    ${p.place.padEnd(32)} ${p.steps} steps, ${p.runs.length} runs`
@@ -20012,7 +20341,7 @@ async function exploreCoverageCommand(mapId, opts) {
   }
   if (cov.runs === 0) {
     console.log(
-      chalk26.dim(
+      chalk27.dim(
         "\n  No runs yet \u2014 every surface counts as never reached. Walk a scenario first (iamu-run)."
       )
     );
@@ -20048,27 +20377,27 @@ async function exploreDiffCommand(a, b, opts) {
   console.log(`
   ${idA} \u2192 ${idB}`);
   console.log(
-    `  ${chalk26.bold(`${pct}% of surfaces match`)} (${d.common} shared, ${d.only_a.length} only in the first, ${d.only_b.length} only in the second)`
+    `  ${chalk27.bold(`${pct}% of surfaces match`)} (${d.common} shared, ${d.only_a.length} only in the first, ${d.only_b.length} only in the second)`
   );
   if (d.only_a.length > 0) {
     console.log(`
-  ${chalk26.red("Only in the first")}`);
+  ${chalk27.red("Only in the first")}`);
     for (const s of d.only_a) console.log(`    ${s.key.padEnd(32)} ${s.label}`);
   }
   if (d.only_b.length > 0) {
     console.log(`
-  ${chalk26.green("Only in the second")}`);
+  ${chalk27.green("Only in the second")}`);
     for (const s of d.only_b) console.log(`    ${s.key.padEnd(32)} ${s.label}`);
   }
   if (d.changed_actions.length > 0) {
     console.log(
       `
-  ${chalk26.yellow(`Controls differ on ${d.changed_actions.length} shared surfaces`)}`
+  ${chalk27.yellow(`Controls differ on ${d.changed_actions.length} shared surfaces`)}`
     );
     for (const c of d.changed_actions) {
       console.log(`    ${c.key}  ${c.label}`);
-      for (const x of c.only_a) console.log(chalk26.red(`      - ${x}`));
-      for (const x of c.only_b) console.log(chalk26.green(`      + ${x}`));
+      for (const x of c.only_a) console.log(chalk27.red(`      - ${x}`));
+      for (const x of c.only_b) console.log(chalk27.green(`      + ${x}`));
     }
   }
 }
@@ -20282,7 +20611,7 @@ __export(instructions_walk_exports, {
 });
 import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
 import { join as join9 } from "path";
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 function selfCommand() {
   const q = (p) => /[\s"'$]/.test(p) ? JSON.stringify(p) : p;
   return `${q(process.execPath)} ${q(process.argv[1] ?? "iamu")}`;
@@ -20654,40 +20983,40 @@ async function instructionsWalk(opts) {
     return;
   }
   console.log();
-  console.log(chalk27.bold("  Walk instructions"));
-  console.log(`  ${chalk27.dim("scenario:")}  ${sfm.slug}`);
-  console.log(`  ${chalk27.dim("persona:")}   ${pfm.name} (${pfm.role})`);
-  console.log(`  ${chalk27.dim("outline:")}   ${ofm.title}`);
+  console.log(chalk28.bold("  Walk instructions"));
+  console.log(`  ${chalk28.dim("scenario:")}  ${sfm.slug}`);
+  console.log(`  ${chalk28.dim("persona:")}   ${pfm.name} (${pfm.role})`);
+  console.log(`  ${chalk28.dim("outline:")}   ${ofm.title}`);
   if (sfm.state?.description || sfm.state?.approximation) {
     console.log(
-      `  ${chalk27.dim("state:")}     ${sfm.state.description ? sfm.state.description : sfm.state.approximation ?? ""}`
+      `  ${chalk28.dim("state:")}     ${sfm.state.description ? sfm.state.description : sfm.state.approximation ?? ""}`
     );
   }
-  if (targetUrl) console.log(`  ${chalk27.dim("target:")}    ${targetUrl}`);
+  if (targetUrl) console.log(`  ${chalk28.dim("target:")}    ${targetUrl}`);
   console.log(
-    `  ${chalk27.dim("access:")}    ${projectAccess || personaAccess ? `${projectAccess ? "project" : ""}${projectAccess && personaAccess ? " + " : ""}${personaAccess ? "persona" : ""}` : "not recorded (walker would run as whoever is signed in)"}`
+    `  ${chalk28.dim("access:")}    ${projectAccess || personaAccess ? `${projectAccess ? "project" : ""}${projectAccess && personaAccess ? " + " : ""}${personaAccess ? "persona" : ""}` : "not recorded (walker would run as whoever is signed in)"}`
   );
   console.log(
-    `  ${chalk27.dim("dismissed:")} ${dismissedFacts.length} findings to skip`
+    `  ${chalk28.dim("dismissed:")} ${dismissedFacts.length} findings to skip`
   );
   console.log(
-    `  ${chalk27.dim("guidance:")}  ${guidance.length} tester guidance rule${guidance.length === 1 ? "" : "s"}`
+    `  ${chalk28.dim("guidance:")}  ${guidance.length} tester guidance rule${guidance.length === 1 ? "" : "s"}`
   );
   if (untestableBoundaries.length > 0) {
     console.log(
-      `  ${chalk27.dim("boundaries:")} ${untestableBoundaries.length} untestable boundaries to avoid`
+      `  ${chalk28.dim("boundaries:")} ${untestableBoundaries.length} untestable boundaries to avoid`
     );
   }
   if (revisit.length > 0) {
     console.log(
-      `  ${chalk27.dim("re-check:")}  ${revisit.length} place${revisit.length === 1 ? "" : "s"} where fixes await a re-run`
+      `  ${chalk28.dim("re-check:")}  ${revisit.length} place${revisit.length === 1 ? "" : "s"} where fixes await a re-run`
     );
   }
   console.log(
-    `  ${chalk27.dim("methodology:")} ${methodology ? "loaded" : "missing (run iamu update)"}`
+    `  ${chalk28.dim("methodology:")} ${methodology ? "loaded" : "missing (run iamu update)"}`
   );
   console.log();
-  console.log(chalk27.dim("  Use --json to get the full instruction bundle."));
+  console.log(chalk28.dim("  Use --json to get the full instruction bundle."));
   console.log();
 }
 var SCREEN;
@@ -20712,9 +21041,9 @@ __export(new_finding_exports, {
   newFinding: () => newFinding
 });
 import { randomUUID as randomUUID10 } from "crypto";
-import { access, readFile as readFile6 } from "fs/promises";
-import path26 from "path";
-import chalk28 from "chalk";
+import { access, readFile as readFile7 } from "fs/promises";
+import path27 from "path";
+import chalk29 from "chalk";
 async function newFinding(opts) {
   const ctx = await resolveProject(opts);
   if (!ctx) return;
@@ -20780,7 +21109,7 @@ async function newFinding(opts) {
     }
     try {
       await access(
-        path26.join(runDirPath, "steps", `${String(n).padStart(3, "0")}.json`)
+        path27.join(runDirPath, "steps", `${String(n).padStart(3, "0")}.json`)
       );
     } catch {
       commandError(
@@ -20794,8 +21123,8 @@ async function newFinding(opts) {
   let scenarioSlug = opts.scenario;
   if (!scenarioSlug) {
     try {
-      const manifestRaw = await readFile6(
-        path26.join(runDirPath, "walkthrough.json"),
+      const manifestRaw = await readFile7(
+        path27.join(runDirPath, "walkthrough.json"),
         "utf8"
       );
       const manifest = JSON.parse(manifestRaw);
@@ -20868,6 +21197,18 @@ async function newFinding(opts) {
   ].join("\n");
   try {
     const record = await writeEntity(projectRoot, "finding", frontmatter, body);
+    sendLiveFinding(projectRoot, opts.run, {
+      id,
+      title: opts.title,
+      type: opts.type,
+      severity: opts.severity,
+      ui_fact: uiFact,
+      consequence,
+      step_number: opts.step ? Number(opts.step) : void 0,
+      task_impact: opts.taskImpact,
+      confidence: opts.confidence
+    }).catch(() => {
+    });
     if (opts.json) {
       console.log(
         JSON.stringify(
@@ -20884,10 +21225,10 @@ async function newFinding(opts) {
       return;
     }
     console.log();
-    console.log(`  ${symbols.success} Created finding: ${chalk28.cyan(slug)}`);
-    console.log(`  ${chalk28.dim("path:")} ${record.path}`);
-    console.log(`  ${chalk28.dim("id:")}   ${id}`);
-    for (const w of warnings) console.log(`  ${chalk28.yellow("!")} ${w}`);
+    console.log(`  ${symbols.success} Created finding: ${chalk29.cyan(slug)}`);
+    console.log(`  ${chalk29.dim("path:")} ${record.path}`);
+    console.log(`  ${chalk29.dim("id:")}   ${id}`);
+    for (const w of warnings) console.log(`  ${chalk29.yellow("!")} ${w}`);
     console.log();
   } catch (err) {
     commandError(
@@ -20903,6 +21244,7 @@ var init_new_finding = __esm({
     init_dist();
     init_symbols();
     init_context4();
+    init_live_run_client();
   }
 });
 
@@ -20913,7 +21255,7 @@ __export(view_results_exports, {
   promptViewResults: () => promptViewResults
 });
 import { isCancel as isCancel4, select as select4 } from "@clack/prompts";
-import chalk29 from "chalk";
+import chalk30 from "chalk";
 function launchCloudDashboard(config, runId) {
   const cloudRunId = runId ? toCloudRunUuid(runId) : void 0;
   const url = getCloudDashboardUrl(
@@ -20922,7 +21264,7 @@ function launchCloudDashboard(config, runId) {
     cloudRunId
   );
   console.log();
-  console.log(`  ${symbols.success} Opening Iamu Cloud: ${chalk29.cyan(url)}
+  console.log(`  ${symbols.success} Opening Iamu Cloud: ${chalk30.cyan(url)}
 `);
   openBrowser(url);
 }
@@ -20991,8 +21333,8 @@ __export(evaluate_exports, {
   evaluateRecord: () => evaluateRecord
 });
 import { promises as fs29 } from "fs";
-import path27 from "path";
-import chalk30 from "chalk";
+import path28 from "path";
+import chalk31 from "chalk";
 import { z as z25 } from "zod";
 function formatIssues(error) {
   return error.issues.map(
@@ -21022,7 +21364,7 @@ async function evaluate(runId, opts) {
   const resolved = await resolveProjectAndRunDir(runId, opts);
   if (!resolved) return;
   const { projectRoot, runDirPath } = resolved;
-  const canonicalPath = path27.join(runDirPath, "canonical.json");
+  const canonicalPath = path28.join(runDirPath, "canonical.json");
   let canonical;
   try {
     const raw = await fs29.readFile(canonicalPath, "utf8");
@@ -21081,15 +21423,15 @@ async function evaluate(runId, opts) {
     )
   };
   const prompt = composeJudgePrompt(input);
-  const promptFilePath = opts?.promptFile ?? path27.join(runDirPath, "judge_prompt.md");
+  const promptFilePath = opts?.promptFile ?? path28.join(runDirPath, "judge_prompt.md");
   await fs29.writeFile(promptFilePath, prompt, "utf8");
   if (opts?.json) {
     console.log(
       JSON.stringify(
         {
           ...input,
-          prompt_file: path27.relative(projectRoot, promptFilePath),
-          prompt_file_abs: path27.resolve(promptFilePath),
+          prompt_file: path28.relative(projectRoot, promptFilePath),
+          prompt_file_abs: path28.resolve(promptFilePath),
           judge_prompt: prompt
         },
         null,
@@ -21104,7 +21446,9 @@ async function evaluateRecord(runId, opts) {
   const resolved = await resolveProjectAndRunDir(runId, opts);
   if (!resolved) return;
   const { projectRoot, runDirPath } = resolved;
-  const canonicalPath = path27.join(runDirPath, "canonical.json");
+  sendLivePhase(projectRoot, runId, "judging").catch(() => {
+  });
+  const canonicalPath = path28.join(runDirPath, "canonical.json");
   let canonical;
   try {
     const raw = await fs29.readFile(canonicalPath, "utf8");
@@ -21172,8 +21516,8 @@ ${formatIssues(fileResult.error)}`,
     overall: inputVerdicts.overall
   });
   const reportContent = renderCanonicalMarkdown(canonicalForReport);
-  const verdictsPath = path27.join(runDirPath, "verdicts.json");
-  const reportPath = path27.join(runDirPath, "report.md");
+  const verdictsPath = path28.join(runDirPath, "verdicts.json");
+  const reportPath = path28.join(runDirPath, "report.md");
   await Promise.all([
     atomicWriteFile(
       verdictsPath,
@@ -21193,8 +21537,8 @@ ${formatIssues(fileResult.error)}`,
       JSON.stringify(
         {
           runId,
-          verdictsPath: path27.relative(projectRoot, verdictsPath),
-          reportPath: path27.relative(projectRoot, reportPath),
+          verdictsPath: path28.relative(projectRoot, verdictsPath),
+          reportPath: path28.relative(projectRoot, reportPath),
           verdictsCount: validatedVerdicts.length,
           linkedCount: linked.length,
           ...cloudInfo ? { cloud: cloudInfo } : {}
@@ -21207,18 +21551,18 @@ ${formatIssues(fileResult.error)}`,
   }
   console.log();
   console.log(
-    `  ${symbols.success} Recorded ${validatedVerdicts.length} verdicts for run ${chalk30.cyan(runId)}`
+    `  ${symbols.success} Recorded ${validatedVerdicts.length} verdicts for run ${chalk31.cyan(runId)}`
   );
   if (linked.length > 0) {
     console.log(
-      `  ${chalk30.dim("linked:")}  ${linked.length} finding${linked.length === 1 ? "" : "s"} to the human test${linked.length === 1 ? "" : "s"} citing ${linked.length === 1 ? "it" : "them"}`
+      `  ${chalk31.dim("linked:")}  ${linked.length} finding${linked.length === 1 ? "" : "s"} to the human test${linked.length === 1 ? "" : "s"} citing ${linked.length === 1 ? "it" : "them"}`
     );
   }
   console.log(
-    `  ${chalk30.dim("verdicts:")} ${path27.relative(projectRoot, verdictsPath)}`
+    `  ${chalk31.dim("verdicts:")} ${path28.relative(projectRoot, verdictsPath)}`
   );
   console.log(
-    `  ${chalk30.dim("report:")}  ${path27.relative(projectRoot, reportPath)}`
+    `  ${chalk31.dim("report:")}  ${path28.relative(projectRoot, reportPath)}`
   );
   printCloudRunInfo(cloudInfo);
   await promptViewResults(projectRoot, { ...opts, runId });
@@ -21232,6 +21576,7 @@ var init_evaluate = __esm({
     init_symbols();
     init_cloud_push();
     init_context4();
+    init_live_run_client();
     init_view_results();
     verdictValueSchema = z25.enum(["yes", "partial", "no", "not_applicable"]);
     idList = z25.array(z25.string()).optional();
@@ -21283,18 +21628,20 @@ __export(complete_exports, {
   validateCanonicalWalkthrough: () => validateCanonicalWalkthrough
 });
 import { promises as fs30 } from "fs";
-import path28 from "path";
-import chalk31 from "chalk";
+import path29 from "path";
+import chalk32 from "chalk";
 async function complete(runId, opts) {
   const run = await loadRun(runId, opts);
   if (!run) return;
+  sendLivePhase(run.projectRoot, runId, "completing").catch(() => {
+  });
   if (run.manifest.status === "completed" && !opts?.force) {
     await reportAlreadyCompleted(run, opts);
     return;
   }
   if (!opts?.json) {
     console.log();
-    console.log(chalk31.bold("  Assembling canonical JSON\u2026"));
+    console.log(chalk32.bold("  Assembling canonical JSON\u2026"));
   }
   const provenanceAudit = auditStepProvenance(
     await readStepsForRun(run.projectRoot, runId)
@@ -21308,7 +21655,7 @@ async function complete(runId, opts) {
   let judgeReported;
   try {
     const verdictsRaw = await fs30.readFile(
-      path28.join(run.runDirPath, "verdicts.json"),
+      path29.join(run.runDirPath, "verdicts.json"),
       "utf8"
     );
     const parsed = JSON.parse(verdictsRaw);
@@ -21365,7 +21712,7 @@ async function loadRun(runId, opts) {
     commandError(`Run not found: ${runId}`, opts);
     return null;
   }
-  const manifestPath = path28.join(runDirPath, "walkthrough.json");
+  const manifestPath = path29.join(runDirPath, "walkthrough.json");
   let manifest;
   try {
     manifest = JSON.parse(
@@ -21382,7 +21729,7 @@ async function reportAlreadyCompleted(run, opts) {
   if (opts?.json) {
     try {
       const raw = await fs30.readFile(
-        path28.join(run.runDirPath, "canonical.json"),
+        path29.join(run.runDirPath, "canonical.json"),
         "utf8"
       );
       console.log(raw.trim());
@@ -21402,18 +21749,18 @@ async function reportAlreadyCompleted(run, opts) {
     return;
   }
   console.log();
-  console.log(chalk31.bold("  Run: ") + chalk31.cyan(runId));
-  console.log(`  status     ${chalk31.green("completed")}`);
+  console.log(chalk32.bold("  Run: ") + chalk32.cyan(runId));
+  console.log(`  status     ${chalk32.green("completed")}`);
   if (manifest.completed_at) {
-    console.log(`  completed  ${chalk31.dim(manifest.completed_at)}`);
+    console.log(`  completed  ${chalk32.dim(manifest.completed_at)}`);
   }
   const viewUrl = await pushedRunUrl(run.projectRoot, runId);
   if (viewUrl) {
-    console.log(`  view       ${chalk31.underline(viewUrl)}`);
+    console.log(`  view       ${chalk32.underline(viewUrl)}`);
   }
   console.log();
   console.log(
-    chalk31.dim(
+    chalk32.dim(
       "  Already completed \u2014 nothing to do. Use --force to reassemble the report."
     )
   );
@@ -21429,13 +21776,13 @@ function reportStrictProvenanceFailure(audit, opts) {
   }
   console.error();
   console.error(
-    chalk31.red(`  ${symbols.error} Strict provenance audit failed:`)
+    chalk32.red(`  ${symbols.error} Strict provenance audit failed:`)
   );
   for (const w of audit.warnings) {
-    console.error(chalk31.red(`    \u2022 ${w}`));
+    console.error(chalk32.red(`    \u2022 ${w}`));
   }
   console.error(
-    chalk31.dim(
+    chalk32.dim(
       "  Run was flagged as synthetic / scripted. Remove --strict-provenance to complete anyway."
     )
   );
@@ -21476,41 +21823,41 @@ function completeJsonPayload(canonical, extras) {
 function printCompletionSummary(run, completedAt, assembled, extras, provenanceAudit) {
   const { runId, projectRoot, manifest } = run;
   const { canonical } = assembled;
-  const count = (n) => n === 0 ? chalk31.dim("0") : chalk31.cyan(String(n));
-  console.log(chalk31.bold("  Run: ") + chalk31.cyan(runId));
-  console.log(`  scenario   ${chalk31.dim(manifest.scenario_slug)}`);
-  console.log(`  url        ${chalk31.dim(manifest.target_url)}`);
+  const count = (n) => n === 0 ? chalk32.dim("0") : chalk32.cyan(String(n));
+  console.log(chalk32.bold("  Run: ") + chalk32.cyan(runId));
+  console.log(`  scenario   ${chalk32.dim(manifest.scenario_slug)}`);
+  console.log(`  url        ${chalk32.dim(manifest.target_url)}`);
   if (manifest.environment) {
-    console.log(`  env        ${chalk31.dim(manifest.environment)}`);
+    console.log(`  env        ${chalk32.dim(manifest.environment)}`);
   }
   if (manifest.build) {
-    console.log(`  build      ${chalk31.dim(formatBuild(manifest.build))}`);
+    console.log(`  build      ${chalk32.dim(formatBuild(manifest.build))}`);
   }
   if (manifest.viewport) {
-    console.log(`  device     ${chalk31.dim(formatViewport(manifest.viewport))}`);
+    console.log(`  device     ${chalk32.dim(formatViewport(manifest.viewport))}`);
   }
-  console.log(`  status     ${chalk31.green("completed")}`);
+  console.log(`  status     ${chalk32.green("completed")}`);
   console.log(`  findings   ${count(canonical.findings.length)}`);
   console.log(`  steps      ${count(canonical.steps.length)}`);
-  console.log(`  started    ${chalk31.dim(manifest.created_at)}`);
-  console.log(`  completed  ${chalk31.dim(completedAt)}`);
+  console.log(`  started    ${chalk32.dim(manifest.created_at)}`);
+  console.log(`  completed  ${chalk32.dim(completedAt)}`);
   const models = manifest.models;
   if (models?.velocity_sec_per_step != null) {
     console.log(
-      `  velocity   ${chalk31.cyan(`~${models.velocity_sec_per_step}s/step`)} ${chalk31.dim(`(${models.total_duration_sec}s total)`)}`
+      `  velocity   ${chalk32.cyan(`~${models.velocity_sec_per_step}s/step`)} ${chalk32.dim(`(${models.total_duration_sec}s total)`)}`
     );
   }
   if (models && (models.walker || models.judge || models.matcher)) {
     const w = models.walker_reported ? `${models.walker} (${models.walker_reported})` : models.walker ?? "fast";
     const j = models.judge_reported ? `${models.judge} (${models.judge_reported})` : models.judge ?? "thorough";
-    console.log(`  models     ${chalk31.dim(`walker: ${w} \xB7 judge: ${j}`)}`);
+    console.log(`  models     ${chalk32.dim(`walker: ${w} \xB7 judge: ${j}`)}`);
   }
   console.log();
   console.log(
-    `  ${chalk31.dim("canonical:")} ${chalk31.dim(path28.relative(projectRoot, assembled.canonicalPath))}`
+    `  ${chalk32.dim("canonical:")} ${chalk32.dim(path29.relative(projectRoot, assembled.canonicalPath))}`
   );
   console.log(
-    `  ${chalk31.dim("report:")}    ${chalk31.dim(path28.relative(projectRoot, assembled.reportPath))}`
+    `  ${chalk32.dim("report:")}    ${chalk32.dim(path29.relative(projectRoot, assembled.reportPath))}`
   );
   if (extras.viewportWarning) {
     console.log();
@@ -21518,7 +21865,7 @@ function printCompletionSummary(run, completedAt, assembled, extras, provenanceA
   }
   if (extras.codeWarning) {
     console.log();
-    console.log(`  ${chalk31.yellow("!")} ${extras.codeWarning}`);
+    console.log(`  ${chalk32.yellow("!")} ${extras.codeWarning}`);
   }
   if (extras.revisit) printRevisit(extras.revisit);
   if (assembled.verification) printVerification(assembled.verification);
@@ -21530,13 +21877,13 @@ function printProvenanceWarnings(audit) {
   if (audit.warnings.length === 0) return;
   console.log();
   console.log(
-    `  ${symbols.warning} ${chalk31.yellow("Step provenance audit flagged suspicious timing:")}`
+    `  ${symbols.warning} ${chalk32.yellow("Step provenance audit flagged suspicious timing:")}`
   );
   for (const w of audit.warnings) {
-    console.log(`    ${chalk31.dim("\u2022")} ${w}`);
+    console.log(`    ${chalk32.dim("\u2022")} ${w}`);
   }
   console.log(
-    chalk31.dim(
+    chalk32.dim(
       "    Run appears to be programmatically batch-generated rather than an interactive walkthrough."
     )
   );
@@ -21568,7 +21915,7 @@ function screenshotFitsViewport(width, expected) {
 }
 async function screenshotSizeWarning(runDirPath, viewport) {
   if (!viewport) return null;
-  const dir = path28.join(runDirPath, "screenshots");
+  const dir = path29.join(runDirPath, "screenshots");
   let first;
   try {
     first = (await fs30.readdir(dir)).filter((f) => f.toLowerCase().endsWith(".png")).sort((a, b) => a.localeCompare(b, void 0, { numeric: true }))[0];
@@ -21578,7 +21925,7 @@ async function screenshotSizeWarning(runDirPath, viewport) {
   if (!first) return null;
   let size = null;
   try {
-    const handle = await fs30.open(path28.join(dir, first), "r");
+    const handle = await fs30.open(path29.join(dir, first), "r");
     try {
       const head = Buffer.alloc(24);
       const { bytesRead } = await handle.read(head, 0, 24, 0);
@@ -21595,7 +21942,7 @@ async function screenshotSizeWarning(runDirPath, viewport) {
 async function readWalkerSummary(runDirPath) {
   try {
     const data = JSON.parse(
-      await fs30.readFile(path28.join(runDirPath, "summary.json"), "utf8")
+      await fs30.readFile(path29.join(runDirPath, "summary.json"), "utf8")
     );
     const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x.trim() !== "") : void 0;
     const model = typeof data.model === "string" && data.model.trim() !== "" ? data.model.trim() : void 0;
@@ -21704,7 +22051,7 @@ function validateCanonicalWalkthrough(canonical) {
 async function applyRecordedVerdicts(canonical, runDirPath) {
   try {
     const recorded = JSON.parse(
-      await fs30.readFile(path28.join(runDirPath, "verdicts.json"), "utf8")
+      await fs30.readFile(path29.join(runDirPath, "verdicts.json"), "utf8")
     );
     if (Array.isArray(recorded.verdicts)) {
       return applyVerdicts(canonical, recorded);
@@ -21714,7 +22061,7 @@ async function applyRecordedVerdicts(canonical, runDirPath) {
   return canonical;
 }
 async function persistCanonical(runDirPath, canonical) {
-  const canonicalPath = path28.join(runDirPath, "canonical.json");
+  const canonicalPath = path29.join(runDirPath, "canonical.json");
   await atomicWriteFile(
     canonicalPath,
     `${JSON.stringify(canonical, null, 2)}
@@ -21723,7 +22070,7 @@ async function persistCanonical(runDirPath, canonical) {
   return canonicalPath;
 }
 async function persistReport(runDirPath, canonical) {
-  const reportPath = path28.join(runDirPath, "report.md");
+  const reportPath = path29.join(runDirPath, "report.md");
   await atomicWriteFile(reportPath, renderCanonicalMarkdown(canonical));
   return reportPath;
 }
@@ -21823,17 +22170,17 @@ function placeLabel(p) {
 function printRevisit(r) {
   const missed = r.places.filter((p) => !p.reached);
   console.log();
-  const head = `  ${chalk31.bold("Re-check places:")} reached ${r.reached} of ${r.requested}`;
+  const head = `  ${chalk32.bold("Re-check places:")} reached ${r.reached} of ${r.requested}`;
   if (missed.length === 0) {
-    console.log(`${head} ${chalk31.green("\u2713")}`);
+    console.log(`${head} ${chalk32.green("\u2713")}`);
     return;
   }
   console.log(`${head} \u2014 not reached:`);
   for (const p of missed) {
-    console.log(`    ${chalk31.yellow("\u25CB")} ${placeLabel(p)}`);
+    console.log(`    ${chalk32.yellow("\u25CB")} ${placeLabel(p)}`);
   }
   console.log(
-    chalk31.dim(
+    chalk32.dim(
       "    Fixes there stay awaiting a re-run until a walk gets there."
     )
   );
@@ -21841,7 +22188,7 @@ function printRevisit(r) {
 function printVerification(verification) {
   console.log();
   console.log(
-    chalk31.bold("  Since this scenario's last run") + chalk31.dim(` (${verification.baseline_run_id.slice(0, 30)}\u2026)`) + chalk31.bold(":")
+    chalk32.bold("  Since this scenario's last run") + chalk32.dim(` (${verification.baseline_run_id.slice(0, 30)}\u2026)`) + chalk32.bold(":")
   );
   if (verification.resolved.length > 0) {
     console.log(
@@ -21850,7 +22197,7 @@ function printVerification(verification) {
   }
   if (verification.not_observed.length > 0) {
     console.log(
-      `    ${symbols.pending} ${verification.not_observed.length} not seen this run ${chalk31.dim("(not evidence of a fix)")}`
+      `    ${symbols.pending} ${verification.not_observed.length} not seen this run ${chalk32.dim("(not evidence of a fix)")}`
     );
   }
   if (verification.persists.length > 0) {
@@ -21879,6 +22226,7 @@ var init_complete = __esm({
     init_cloud_push();
     init_context4();
     init_evaluate();
+    init_live_run_client();
     init_worktree_state();
     init_start_run();
     init_view_results();
@@ -21892,13 +22240,13 @@ __export(match_exports, {
   matchRecord: () => matchRecord
 });
 import { promises as fs31 } from "fs";
-import path29 from "path";
-import chalk32 from "chalk";
+import path30 from "path";
+import chalk33 from "chalk";
 async function completedManifest2(runDirPath, runId, opts) {
   let manifest;
   try {
     manifest = JSON.parse(
-      await fs31.readFile(path29.join(runDirPath, "walkthrough.json"), "utf8")
+      await fs31.readFile(path30.join(runDirPath, "walkthrough.json"), "utf8")
     );
   } catch {
     commandError(`Run not found: ${runId}`, opts);
@@ -21927,7 +22275,7 @@ async function match(runId, opts) {
   );
   const needed = input.current.length > 0 && (input.prior.length > 0 || (input.guidance ?? []).length > 0);
   const prompt = needed ? composeMatchPrompt(input) : null;
-  const promptFilePath = opts?.promptFile ?? path29.join(runDirPath, "match_prompt.md");
+  const promptFilePath = opts?.promptFile ?? path30.join(runDirPath, "match_prompt.md");
   if (prompt) {
     await fs31.writeFile(promptFilePath, prompt, "utf8");
   } else {
@@ -21942,8 +22290,8 @@ async function match(runId, opts) {
         {
           ...input,
           needed,
-          prompt_file: prompt ? path29.relative(ctx.projectRoot, promptFilePath) : null,
-          prompt_file_abs: prompt ? path29.resolve(promptFilePath) : null,
+          prompt_file: prompt ? path30.relative(ctx.projectRoot, promptFilePath) : null,
+          prompt_file_abs: prompt ? path30.resolve(promptFilePath) : null,
           match_prompt: prompt
         },
         null,
@@ -21954,7 +22302,7 @@ async function match(runId, opts) {
   }
   if (!prompt) {
     console.log(
-      chalk32.dim(
+      chalk33.dim(
         "  No earlier findings or tester guidance for this scenario to match against \u2014 nothing to do."
       )
     );
@@ -21966,6 +22314,8 @@ async function matchRecord(runId, opts) {
   const resolved = await resolveProjectAndRunDir(runId, opts);
   if (!resolved) return;
   const { projectRoot, runDirPath } = resolved;
+  sendLivePhase(projectRoot, runId, "matching").catch(() => {
+  });
   const manifest = await completedManifest2(runDirPath, runId, opts);
   if (!manifest) return;
   let answer;
@@ -22011,17 +22361,17 @@ async function matchRecord(runId, opts) {
   }
   console.log();
   console.log(
-    `  ${chalk32.green("\u2713")} Matched ${result.linked} finding${result.linked === 1 ? "" : "s"} to earlier ones, ${result.new} first seen, ${result.rechecked_fixed} earlier re-checked fixed`
+    `  ${chalk33.green("\u2713")} Matched ${result.linked} finding${result.linked === 1 ? "" : "s"} to earlier ones, ${result.new} first seen, ${result.rechecked_fixed} earlier re-checked fixed`
   );
   if (result.suppressed > 0) {
     console.log(
-      `  ${chalk32.yellow("!")} ${result.suppressed} finding${result.suppressed === 1 ? "" : "s"} match tester guidance (flagged with suppressed_by_guidance \u2014 dismiss them in triage if the rule holds)`
+      `  ${chalk33.yellow("!")} ${result.suppressed} finding${result.suppressed === 1 ? "" : "s"} match tester guidance (flagged with suppressed_by_guidance \u2014 dismiss them in triage if the rule holds)`
     );
   }
   if (verification) printVerification(verification);
   console.log();
   console.log(
-    chalk32.dim("  Run `iamu sync` to push the linked findings to the cloud.")
+    chalk33.dim("  Run `iamu sync` to push the linked findings to the cloud.")
   );
   console.log();
 }
@@ -22032,6 +22382,7 @@ var init_match = __esm({
     init_dist();
     init_complete();
     init_context4();
+    init_live_run_client();
   }
 });
 
@@ -22042,7 +22393,7 @@ __export(prune_exports, {
   prune: () => prune
 });
 import { confirm, isCancel as isCancel5 } from "@clack/prompts";
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 function formatBytes(bytes) {
   if (bytes <= 0) return "0 B";
   if (bytes < 1024) return `${bytes} B`;
@@ -22088,7 +22439,7 @@ async function prune(opts = {}) {
     });
     if (preview.prunedRuns.length === 0) {
       console.log(
-        chalk33.dim("  No runs match the pruning criteria. Nothing to prune.")
+        chalk34.dim("  No runs match the pruning criteria. Nothing to prune.")
       );
       return preview;
     }
@@ -22097,7 +22448,7 @@ async function prune(opts = {}) {
       message: `Prune ${mode} ${preview.prunedRuns.length} run(s) and reclaim ${formatBytes(preview.totalBytesReclaimed)}?`
     });
     if (isCancel5(confirmed) || !confirmed) {
-      console.log(chalk33.yellow("  Pruning cancelled."));
+      console.log(chalk34.yellow("  Pruning cancelled."));
       return;
     }
   }
@@ -22108,14 +22459,14 @@ async function prune(opts = {}) {
   }
   if (result.dryRun) {
     console.log(
-      chalk33.cyan(
+      chalk34.cyan(
         `
   [DRY RUN] Would prune ${result.prunedRuns.length} of ${result.totalRunsScanned} run(s):`
       )
     );
   } else {
     console.log(
-      chalk33.bold(
+      chalk34.bold(
         `
   ${symbols.success} Pruned ${result.prunedRuns.length} of ${result.totalRunsScanned} run(s):`
       )
@@ -22123,18 +22474,18 @@ async function prune(opts = {}) {
   }
   if (result.prunedRuns.length === 0) {
     console.log(
-      chalk33.dim("    No runs matched the pruning criteria. Nothing pruned.")
+      chalk34.dim("    No runs matched the pruning criteria. Nothing pruned.")
     );
   } else {
     for (const run of result.prunedRuns) {
       const mode = run.fullyDeleted ? "removed" : "screenshots purged";
       const count = run.screenshotsDeleted > 0 ? `${run.screenshotsDeleted} screenshots, ` : "";
       console.log(
-        `    ${chalk33.dim("\u2022")} ${chalk33.bold(run.runId)} ${chalk33.dim(`(${run.scenarioSlug ?? "unknown scenario"})`)}: ${chalk33.yellow(formatBytes(run.bytesReclaimed))} (${count}${mode})`
+        `    ${chalk34.dim("\u2022")} ${chalk34.bold(run.runId)} ${chalk34.dim(`(${run.scenarioSlug ?? "unknown scenario"})`)}: ${chalk34.yellow(formatBytes(run.bytesReclaimed))} (${count}${mode})`
       );
     }
     console.log(
-      chalk33.dim(
+      chalk34.dim(
         `
   Total reclaimed: ${formatBytes(result.totalBytesReclaimed)} (${result.totalScreenshotsDeleted} screenshots deleted)
 `
@@ -22323,9 +22674,9 @@ function registerProjectCommands(program) {
     "after",
     "\nExamples:\n  $ iamu validate --all\n  $ iamu validate --all --fix --dry-run\n  $ iamu validate iamu/personas/maria.md"
   ).action(
-    async (path30, opts) => {
+    async (path31, opts) => {
       const { validate: validate2 } = await Promise.resolve().then(() => (init_validate(), validate_exports));
-      await validate2(path30, opts);
+      await validate2(path31, opts);
     }
   );
   program.command("update").helpGroup("Project:").description("Update and repair agent skills and prompts to latest version").option(
@@ -22626,7 +22977,7 @@ function registerAllCommands(program) {
 
 // src/ui/panic.ts
 init_logger();
-import chalk34 from "chalk";
+import chalk35 from "chalk";
 var handlersRegistered = false;
 var customSigintHandler = null;
 function registerSigintCleanup(handler) {
@@ -22638,17 +22989,17 @@ function registerSigintCleanup(handler) {
 function logFatalAndExit(title, errOrReason) {
   process.stderr.write("\x1B[?25h");
   if (isVerbose()) {
-    console.error(chalk34.red(`
+    console.error(chalk35.red(`
   ${title}:`));
     console.error(
       errOrReason instanceof Error ? errOrReason.stack || errOrReason : errOrReason
     );
   } else {
     const msg = errOrReason instanceof Error ? errOrReason.message : String(errOrReason);
-    console.error(chalk34.red(`
+    console.error(chalk35.red(`
   Fatal Error: ${msg}`));
     console.error(
-      chalk34.dim(
+      chalk35.dim(
         "  Run with --verbose or DEBUG=1 to view the full stack trace.\n"
       )
     );
@@ -22667,7 +23018,7 @@ function setupProcessHandlers() {
       }
       process.exit(130);
     } else {
-      console.error(chalk34.dim("\n  Operation cancelled."));
+      console.error(chalk35.dim("\n  Operation cancelled."));
       process.exit(130);
     }
   });