@avasapp/agent-bridge 0.4.2 → 0.6.0

package/dist/cli.js

@@ -2,10 +2,14 @@
 import {
   AgentBridgeCallError,
   RUNTIME_MARKER,
+  SessionLinkError,
+  assertListening,
+  callTimeout,
   checkName,
   connect,
   connectSession,
   encodeLine,
+  explainConnectError,
   explicitMetro,
   flowScenarios,
   formatDuration,
@@ -14,6 +18,7 @@ import {
   listSessions,
   logLine,
   metroHost,
+  noAppHint,
   openConnection,
   parseDuration,
   parseScenarioFlag,
@@ -21,27 +26,201 @@ import {
   projectRoot,
   readSession,
   removeSessionFiles,
-  runFlow,
+  runFlows,
   sessionFiles,
   sessionRequest,
   stateDir,
   writePrivate
-} from "./chunk-TA2OLPPT.js";
+} from "./chunk-Y6QFU5ON.js";
 
 // src/cli.ts
-import { readFile } from "fs/promises";
-import { resolve } from "path";
-import { pathToFileURL } from "url";
+import { createRequire } from "module";
+import { mkdir as mkdir3, readFile } from "fs/promises";
+import { dirname as dirname7 } from "path";
 import { parseArgs } from "util";
 
+// src/client/flow-cli.ts
+import { mkdir, realpath as realpath2, rename, writeFile } from "fs/promises";
+import { dirname, join as join2, relative as relative2 } from "path";
+import { pathToFileURL } from "url";
+
+// src/client/flow-files.ts
+import { readdir, realpath, stat } from "fs/promises";
+import { basename, join, relative, resolve } from "path";
+var FLOW_SUFFIX = /\.flow\.mjs$/;
+function globRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*" && glob[i + 1] === "*") {
+      i++;
+      if (glob[i + 1] === "/") {
+        i++;
+        re += "(?:.*/)?";
+      } else re += ".*";
+    } else if (c === "*") re += "[^/]*";
+    else if (c === "?") re += "[^/]";
+    else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`);
+}
+var collator = new Intl.Collator("en", { numeric: true });
+var posix = (p) => p.split("\\").join("/");
+var byPath = (a, b) => collator.compare(posix(a), posix(b));
+async function walk(dir, seen = /* @__PURE__ */ new Set()) {
+  const real = await realpath(dir);
+  if (seen.has(real)) return [];
+  seen.add(real);
+  const out = [];
+  for (const e of await readdir(dir, { withFileTypes: true })) {
+    if (e.name === "node_modules" || e.name.startsWith(".")) continue;
+    const full = join(dir, e.name);
+    const isDir = e.isDirectory() || e.isSymbolicLink() && (await stat(full).catch(() => null))?.isDirectory();
+    if (isDir) out.push(...await walk(full, seen));
+    else out.push(full);
+  }
+  return out;
+}
+async function resolveFlowFiles(args, cwd = process.cwd()) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const given of args) {
+    const arg = process.platform === "win32" ? given.split("\\").join("/") : given;
+    const path = resolve(cwd, arg);
+    const info = await stat(path).catch(() => null);
+    let found;
+    if (info?.isDirectory())
+      found = (await walk(path)).filter((f) => FLOW_SUFFIX.test(f)).sort(byPath);
+    else if (info) found = [path];
+    else if (/[*?]/.test(arg)) {
+      const fixed2 = arg.split("/").findIndex((seg) => /[*?]/.test(seg));
+      const base = resolve(cwd, arg.split("/").slice(0, fixed2).join("/") || ".");
+      const re = globRegExp(posix(relative(cwd, resolve(cwd, arg))));
+      found = (await walk(base).catch(() => [])).filter((f) => FLOW_SUFFIX.test(f) && re.test(posix(relative(cwd, f)))).sort(byPath);
+    } else throw new Error(`No such flow file or directory: ${given}`);
+    if (!found.length) throw new Error(`No flow files match ${given} (a directory or glob only finds *.flow.mjs)`);
+    for (const f of found) {
+      const real = await realpath(f);
+      if (!seen.has(real)) {
+        seen.add(real);
+        files.push(real);
+      }
+    }
+  }
+  return files;
+}
+var flowName = (file, exported) => exported ?? basename(file).replace(FLOW_SUFFIX, "").replace(/\.[mc]?[jt]s$/, "");
+
+// src/client/flow-cli.ts
+var REPORTERS = ["text", "json", "junit"];
+function checkRunFlags(flags) {
+  const reporter = flags.reporter ?? "text";
+  if (!REPORTERS.includes(reporter))
+    throw new Error(`--reporter is text, json or junit, not ${reporter}`);
+  if (flags.out && reporter === "text")
+    throw new Error("--out needs --reporter json or junit (run: --out is the report file)");
+  return reporter !== "text";
+}
+var failedRun = (file, name, error) => ({
+  file,
+  name,
+  status: "failed",
+  ms: 0,
+  steps: 0,
+  errors: 0,
+  error,
+  restoreErrors: [],
+  notices: []
+});
+var reason = (error) => error instanceof Error ? error.message : String(error);
+async function loadFlows(files, cwd = process.cwd()) {
+  const root = await realpath2(cwd).catch(() => cwd);
+  const entries = [];
+  const failures = [];
+  for (const abs of files) {
+    const file = relative2(root, abs).split("\\").join("/");
+    try {
+      const module = await import(pathToFileURL(abs).href);
+      if (typeof module.default !== "function")
+        throw new Error(`${file} has no \`export default async ({ step }) => {}\``);
+      if (module.name !== void 0 && typeof module.name !== "string")
+        throw new Error(`${file}: \`export const name\` must be a string, not ${typeof module.name}`);
+      flowScenarios(module);
+      entries.push({ file, name: flowName(abs, module.name), module });
+    } catch (error) {
+      failures.push(failedRun(file, flowName(abs), reason(error)));
+    }
+  }
+  return { entries, failures };
+}
+function selectFlows(entries, grep) {
+  if (!grep) return entries;
+  const needle = grep.toLowerCase();
+  return entries.filter((e) => `${e.name}
+${e.file}`.toLowerCase().includes(needle));
+}
+async function writeReport(out, doc) {
+  await mkdir(dirname(out), { recursive: true });
+  const tmp = join2(dirname(out), `.${process.pid}-${Date.now()}.tmp`);
+  await writeFile(tmp, doc.endsWith("\n") ? doc : `${doc}
+`);
+  await rename(tmp, out);
+}
+async function logToStderr(fn) {
+  const log = console.log;
+  console.log = (...args) => console.error(...args);
+  try {
+    return await fn();
+  } finally {
+    console.log = log;
+  }
+}
+
+// src/client/flow-report.ts
+var ANSI = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b[@-Z\\-_]/g;
+var escape = (s) => s.replace(ANSI, "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\ufffe\uffff]/g, "").replace(/[<>&"']/g, (c) => `&#${c.charCodeAt(0)};`);
+var classname = (file) => {
+  const at = file.lastIndexOf("/");
+  return at > 0 ? file.slice(0, at) : "agent-bridge";
+};
+function renderJson(runs) {
+  const count = (s) => runs.filter((r) => r.status === s).length;
+  return JSON.stringify(
+    { passed: count("passed"), failed: count("failed"), skipped: count("skipped"), flows: runs },
+    null,
+    2
+  );
+}
+function renderJunit(runs) {
+  const failed = runs.filter((r) => r.status === "failed").length;
+  const skipped = runs.filter((r) => r.status === "skipped").length;
+  const time = runs.reduce((t, r) => t + r.ms, 0) / 1e3;
+  const cases = runs.map((r) => {
+    const open = `<testcase classname="${escape(classname(r.file))}" name="${escape(r.name)}" file="${escape(r.file)}" time="${(r.ms / 1e3).toFixed(3)}"`;
+    if (r.status === "skipped") return `${open}><skipped/></testcase>`;
+    if (r.status === "passed") return `${open}/>`;
+    const screen = r.state?.screen?.length ? `
+on screen:
+${r.state.screen.join("\n")}` : "";
+    const route = r.state?.route !== void 0 ? `
+route: ${JSON.stringify(r.state.route)}` : "";
+    return `${open}><failure message="${escape(r.error ?? "failed")}">${escape((r.error ?? "") + route + screen)}</failure></testcase>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<testsuite name="agent-bridge" tests="${runs.length}" failures="${failed}" skipped="${skipped}" time="${time.toFixed(3)}">
+${cases.join("\n")}
+</testsuite>
+`;
+}
+
 // src/client/batch.ts
 import { readFileSync } from "fs";
-import { mkdir, readdir, stat } from "fs/promises";
-import { join } from "path";
+import { mkdir as mkdir2, readdir as readdir2, stat as stat2 } from "fs/promises";
+import { join as join3 } from "path";
 import { createInterface } from "readline";
 
 // src/client/output.ts
-import { writeFile } from "fs/promises";
+import { writeFile as writeFile2 } from "fs/promises";
 var OUTPUT_LIMIT_BYTES = 32 * 1024;
 var kb = (bytes) => bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 function shapeOf(value) {
@@ -73,7 +252,7 @@ async function shapedResult(value, options = {}) {
   const json = JSON.stringify(value, null, 2) ?? "null";
   const bytes = Buffer.byteLength(json);
   if (options.out) {
-    await writeFile(options.out, `${json}
+    await writeFile2(options.out, `${json}
 `);
     return fileSummary(options.out, bytes, value);
   }
@@ -85,7 +264,7 @@ async function renderResult(value, options = {}) {
   const json = JSON.stringify(value, null, 2) ?? "null";
   const bytes = Buffer.byteLength(json);
   if (options.out) {
-    await writeFile(options.out, `${json}
+    await writeFile2(options.out, `${json}
 `);
     return JSON.stringify(fileSummary(options.out, bytes, value), null, 2);
   }
@@ -93,6 +272,16 @@ async function renderResult(value, options = {}) {
     return json;
   return JSON.stringify(tooLarge(bytes, value), null, 2);
 }
+async function renderText(text2, options = {}) {
+  const bytes = Buffer.byteLength(text2);
+  if (options.out) {
+    await writeFile2(options.out, `${text2}
+`);
+    return JSON.stringify(fileSummary(options.out, bytes, text2), null, 2);
+  }
+  if (options.full || bytes <= (options.limit ?? OUTPUT_LIMIT_BYTES)) return text2;
+  return JSON.stringify(tooLarge(bytes, text2), null, 2);
+}
 
 // src/client/batch.ts
 function parseCallArgs(raw) {
@@ -120,9 +309,9 @@ function fileJson(ref, read) {
     throw new Error(
       `An argument that is just "@" needs a path (@file, or @- for stdin). To pass the text itself, quote it as JSON: '"@"'`
     );
-  const text = read(path);
+  const text2 = read(path);
   try {
-    return JSON.parse(text);
+    return JSON.parse(text2);
   } catch (error) {
     throw new Error(
       `${path === "-" ? "stdin" : path} is not valid JSON (${error instanceof Error ? error.message : error})`
@@ -146,19 +335,19 @@ function parseCallArgv(argv, read = readArgFile) {
   });
 }
 var BatchParseError = class extends Error {
-  constructor(tool, message2) {
-    super(message2);
+  constructor(tool, message3) {
+    super(message3);
     this.tool = tool;
   }
   tool;
 };
 function parseBatchLine(line) {
-  const text = line.trim();
-  if (!text || text.startsWith("#")) return null;
-  const at = text.search(/\s/);
-  if (at < 0) return { tool: text, args: [] };
-  const tool = text.slice(0, at);
-  const raw = text.slice(at).trim();
+  const text2 = line.trim();
+  if (!text2 || text2.startsWith("#")) return null;
+  const at = text2.search(/\s/);
+  if (at < 0) return { tool: text2, args: [] };
+  const tool = text2.slice(0, at);
+  const raw = text2.slice(at).trim();
   if (/^[[{"]/.test(raw)) {
     try {
       JSON.parse(raw);
@@ -289,11 +478,11 @@ async function dotLine(bridge, line) {
   }
 }
 async function checkOutDir(dir) {
-  const info = await stat(dir).catch(() => null);
-  if (!info) return mkdir(dir, { recursive: true });
+  const info = await stat2(dir).catch(() => null);
+  if (!info) return mkdir2(dir, { recursive: true });
   if (!info.isDirectory())
     throw new Error(`--out ${dir} is a file; with --batch it must be a directory`);
-  if ((await readdir(dir)).length)
+  if ((await readdir2(dir)).length)
     throw new Error(
       `--out ${dir} is not empty; use a new or empty directory so old files aren't mistaken for this run's`
     );
@@ -306,9 +495,9 @@ async function runBatch(bridge, input, options = {}) {
   let stopped = false;
   try {
     for await (const line of rl) {
-      const text = line.trim();
-      const outcome = text.startsWith(".") ? await dotLine(bridge, text) : await runLine(bridge, line);
-      if (text.startsWith(".") && outcome === null) break;
+      const text2 = line.trim();
+      const outcome = text2.startsWith(".") ? await dotLine(bridge, text2) : await runLine(bridge, line);
+      if (text2.startsWith(".") && outcome === null) break;
       if (!outcome) continue;
       result.calls++;
       const raw = outcome;
@@ -323,7 +512,7 @@ async function runBatch(bridge, input, options = {}) {
           record.value = await shapedResult(raw.value, {
             full: options.full,
             outKind: "dir",
-            out: options.outDir ? join(
+            out: options.outDir ? join3(
               options.outDir,
               `${result.calls}-${String(raw.tool).replace(/[^\w.-]/g, "_")}.json`
             ) : void 0
@@ -352,13 +541,27 @@ async function runBatch(bridge, input, options = {}) {
   return result;
 }
 
+// src/client/snapshot-format.ts
+function withCompactSnapshot(tool, args, json = false) {
+  if (tool !== "screen.snapshot" || args.length > 1) return args;
+  const options = args[0];
+  if (options !== void 0 && (options === null || typeof options !== "object" || Array.isArray(options)))
+    return args;
+  const given = options ?? {};
+  if (given.format === "text" && json)
+    throw new Error('--json and {"format":"text"} ask for different formats; drop one');
+  if (given.format !== void 0) return args;
+  return [{ ...given, format: json ? "json" : "text" }];
+}
+var isSnapshotText = (tool, value) => tool === "screen.snapshot" && typeof value === "string";
+
 // src/client/repl.ts
 import { appendFileSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { homedir } from "os";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 var HISTORY_LIMIT = 500;
-var DEFAULT_HISTORY_FILE = join2(
+var DEFAULT_HISTORY_FILE = join4(
   homedir(),
   ".agent-bridge",
   "repl_history"
@@ -410,7 +613,7 @@ function loadHistory(file) {
 }
 function saveHistory(file, lines) {
   try {
-    mkdirSync(dirname(file), { recursive: true });
+    mkdirSync(dirname2(file), { recursive: true });
     writeFileSync(file, `${lines.slice(-HISTORY_LIMIT).join("\n")}
 `, {
       mode: 384
@@ -420,7 +623,7 @@ function saveHistory(file, lines) {
 }
 function appendHistory(file, line) {
   try {
-    mkdirSync(dirname(file), { recursive: true });
+    mkdirSync(dirname2(file), { recursive: true });
     appendFileSync(file, `${line}
 `, { mode: 384 });
   } catch {
@@ -432,9 +635,9 @@ async function runRepl(bridge, options) {
   const { output } = options;
   const tty = !!options.tty;
   const { historyFile } = options;
-  const paint = (code, text) => tty && !process.env.NO_COLOR ? `\x1B[${code}m${text}\x1B[0m` : text;
-  const print = (text = "") => {
-    output.write(`${text}
+  const paint = (code, text2) => tty && !process.env.NO_COLOR ? `\x1B[${code}m${text2}\x1B[0m` : text2;
+  const print = (text2 = "") => {
+    output.write(`${text2}
 `);
   };
   const toolNames = () => bridge.tools().map((t) => t.name);
@@ -587,21 +790,201 @@ import { spawn } from "child_process";
 import { existsSync, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
 
 // src/client/session/daemon.ts
+import { randomBytes } from "crypto";
 import { appendFileSync as appendFileSync2, chmodSync, rmSync } from "fs";
 import { createServer } from "net";
 import { createInterface as createInterface3 } from "readline";
+
+// src/client/session/journal.ts
+var MAX_TRIES = 3;
+var lostConnection = (r) => !r.ok && (r.from === "" || /socket closed|closed the debugger|not open/i.test(r.error));
+var plain = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isStore = (v) => plain(v.original) && plain(v.after);
+function mergeStore(old, next) {
+  const known = /* @__PURE__ */ new Set([...Object.keys(old.original), ...Object.keys(old.after), ...old.skipped ?? []]);
+  const original = { ...old.original };
+  const after = { ...old.after };
+  const touched = /* @__PURE__ */ new Set([...Object.keys(next.original), ...Object.keys(next.after), ...next.skipped ?? []]);
+  for (const k of touched) {
+    if (!known.has(k) && k in next.original) original[k] = next.original[k];
+    if (k in next.after) after[k] = next.after[k];
+    else delete after[k];
+  }
+  const skipped = [.../* @__PURE__ */ new Set([...old.skipped ?? [], ...next.skipped ?? []])];
+  return { original, after, ...skipped.length && { skipped } };
+}
+function merge(carry, data) {
+  for (const [area, part] of Object.entries(data)) {
+    const old = carry[area];
+    if (!plain(old) || !plain(part)) {
+      carry[area] = part;
+      continue;
+    }
+    const next = { ...old };
+    for (const [name, value] of Object.entries(part)) {
+      const was = old[name];
+      next[name] = plain(was) && plain(value) ? isStore(was) && isStore(value) ? mergeStore(was, value) : { ...value, ...was } : value;
+    }
+    carry[area] = next;
+  }
+}
+var names = (part) => plain(part) ? Object.keys(part) : [];
+function createJournal(call, firstLoad, alive = async () => false) {
+  let data = {};
+  let tag = "";
+  let load = firstLoad;
+  const carry = {};
+  let tries = 0;
+  let lastWaiting = "";
+  const why = (area, part, reason2) => {
+    const keys = names(part);
+    return keys.length ? keys.map((n) => `${area}:${n} (${reason2(n)})`) : [`${area} (${reason2(area)})`];
+  };
+  const gaveUp = (reasons) => {
+    const left = Object.entries(carry).flatMap(
+      ([area, part]) => why(area, part, () => reasons[area] ?? "not ready")
+    );
+    for (const k of Object.keys(carry)) delete carry[k];
+    return left.length ? `could not re-arm after the reload: ${left.join(", ")}` : "";
+  };
+  return {
+    /** The tag to send with every call. */
+    ack: () => tag,
+    /** Takes the journal a reply carries; one from another load is dropped. */
+    accept(r) {
+      if (r.journalData === void 0 || !r.loadId || r.loadId !== load) return;
+      data = r.journalData;
+      tag = `${r.loadId}:${r.journal ?? 0}`;
+    },
+    /** The app reloaded into `newLoad`: what the old load held moves to `carry`. Returns the pending areas that had nothing persistent. */
+    reloaded(lastPending, newLoad) {
+      merge(carry, data);
+      data = {};
+      tag = "";
+      load = newLoad;
+      tries = 0;
+      lastWaiting = "";
+      return lastPending.filter((area) => !(area in carry));
+    },
+    hasCarry: () => Object.keys(carry).length > 0,
+    /** The load the journal is for now. */
+    currentLoad: () => load,
+    /** Hands `carry` to the new load. Resolves to a note ('' when there was nothing to say). */
+    async adopt() {
+      if (!Object.keys(carry).length) return "";
+      const sent = structuredClone(carry);
+      const sentLoad = load;
+      let r;
+      try {
+        r = await call("bridge.adopt", [sent]);
+      } catch {
+        if (!await alive().catch(() => false)) return "";
+        r = { id: "", from: "app", ok: false, error: "timed out", ms: 0 };
+      }
+      if (lostConnection({ ...r })) return "";
+      if (load !== sentLoad || r.loadId && sentLoad && r.loadId !== sentLoad) return "";
+      this.accept(r);
+      tries += 1;
+      const bits = [];
+      const reasons = {};
+      if (!r.ok) {
+        for (const area of Object.keys(sent)) reasons[area] = r.error;
+      } else {
+        const reply = r.value;
+        const adopted = [];
+        const already = [];
+        const changed = [];
+        const invalid = [];
+        const skipped = [];
+        const notKept = [];
+        for (const area of Object.keys(sent)) {
+          const part = reply[area];
+          if (!part) continue;
+          adopted.push(...part.adopted ?? []);
+          already.push(...part.already ?? []);
+          changed.push(...part.changed ?? []);
+          invalid.push(...part.invalid ?? []);
+          skipped.push(...part.skipped ?? []);
+          notKept.push(...part.notKept ?? []);
+          if (part.retry !== void 0) {
+            carry[area] = part.retry;
+            reasons[area] = part.error ?? "not ready";
+          } else delete carry[area];
+        }
+        if (adopted.length)
+          bits.push(`kept ${adopted.length} undo${adopted.length === 1 ? "" : "s"} across the reload (${adopted.join(", ")}); bridge.restore still puts them back`);
+        if (already.length) bits.push(`already back to the original: ${already.join(", ")}`);
+        if (changed.length) bits.push(`left alone, the app changed them since: ${changed.join(", ")}`);
+        if (skipped.length) bits.push(`left alone, a different storage instance than the one you wrote: ${skipped.join(", ")}`);
+        if (notKept.length) bits.push(`not kept across reload (not plain JSON, renamed by partialize, or hidden by redact): ${notKept.join(", ")}`);
+        if (invalid.length) bits.push(`ignored, not a value this session saved: ${invalid.join(", ")}`);
+      }
+      if (Object.keys(carry).length) {
+        if (tries >= MAX_TRIES) {
+          bits.push(gaveUp(reasons));
+          lastWaiting = "";
+        } else {
+          const waiting = Object.entries(carry).flatMap(([area, part]) => why(area, part, () => reasons[area] ?? "not ready")).join(", ");
+          if (waiting !== lastWaiting) bits.push(`not ready yet, will retry: ${waiting}`);
+          lastWaiting = waiting;
+        }
+      }
+      return bits.join("; ");
+    },
+    /** At session end: drops what is still waiting and says so. */
+    giveUp: () => gaveUp({})
+  };
+}
+
+// src/client/session/daemon.ts
 var RELOAD = "app.reload";
-var pause = (ms, signal) => new Promise((resolve2) => {
+var REPEATABLE = /* @__PURE__ */ new Set([
+  "bridge.ping",
+  "bridge.pending",
+  "bridge.tools",
+  "screen.snapshot",
+  "screen.findText",
+  "screen.waitFor",
+  "screen.capture",
+  "store.get",
+  "store.list",
+  "query.get",
+  "query.list",
+  "mmkv.get",
+  "mmkv.keys",
+  "mmkv.list",
+  "net.entry",
+  "net.mocks",
+  "router.current",
+  "scenario.list",
+  "webview.list",
+  "webview.url",
+  "webview.messages",
+  "webview.message",
+  "webview.snapshot",
+  "webview.waitFor",
+  "realtime.channels"
+]);
+var LOG_TOOLS = /* @__PURE__ */ new Set(["net.log", "realtime.log", "bridge.logs"]);
+var WAIT_TOOLS = /* @__PURE__ */ new Set(["screen.waitFor", "webview.waitFor"]);
+var WAIT_DEFAULT_MS = 5e3;
+var repeatable = (tool, args) => REPEATABLE.has(tool) || LOG_TOOLS.has(tool) && !args.some((a) => a?.clear);
+var withTimeLeft = (args, leftMs) => {
+  const next = [...args];
+  const options = next[1] ?? {};
+  next[1] = { ...options, timeoutMs: Math.max(1, Math.round(leftMs)) };
+  return next;
+};
+var pause = (ms, signal) => new Promise((resolve4) => {
   const done = () => {
     clearTimeout(timer);
     signal.removeEventListener("abort", done);
-    resolve2();
+    resolve4();
   };
   const timer = setTimeout(done, ms);
   signal.addEventListener("abort", done, { once: true });
 });
 var message = (error) => error instanceof Error ? error.message : String(error);
-var lostConnection = (r) => !r.ok && (r.from === "" || /socket closed|closed the debugger|not open/i.test(r.error));
 async function runSessionDaemon(options) {
   const name = checkName(options.name);
   const dir = stateDir();
@@ -609,7 +992,7 @@ async function runSessionDaemon(options) {
   const metro = metroHost(options.metro);
   const timeoutMs = options.timeoutMs ?? 1e4;
   const reloadWaitMs = options.reloadWaitMs ?? 2e4;
-  const log = (text) => appendFileSync2(files.log, `${(/* @__PURE__ */ new Date()).toISOString()} ${text}
+  const log = (text2) => appendFileSync2(files.log, `${(/* @__PURE__ */ new Date()).toISOString()} ${text2}
 `, {
     mode: 384
   });
@@ -636,7 +1019,9 @@ async function runSessionDaemon(options) {
       `${c.device.name} already belongs to session "${owner.name}". Use --session ${owner.name}, or stop it first.`
     );
   };
-  let conn = await reach();
+  let conn = await reach().catch(async (error) => {
+    throw await explainConnectError(error, metro, options.device);
+  });
   claim(conn);
   const pin = conn.pin;
   const deviceOf = (c) => ({
@@ -664,20 +1049,68 @@ async function runSessionDaemon(options) {
   let lastPending = [];
   const reloads = [];
   let unseen = [];
-  const noteReload = () => {
-    const lost = lastPending;
-    lastPending = [];
-    const note = `app reloaded; ${lost.length} pending restore${lost.length === 1 ? "" : "s"} lost${lost.length ? `: ${lost.join(", ")}` : ""}`;
+  const journalKey = randomBytes(16).toString("hex");
+  const send = (tool, args, ms) => conn.call(tool, args, ms, { journalAck: journal.ack(), journalKey });
+  const adoptTimeoutMs = options.adoptTimeoutMs ?? Math.max(timeoutMs, 3500);
+  const journal = createJournal(
+    (tool, args) => send(tool, args, adoptTimeoutMs),
+    conn.device.loadId,
+    () => ping()
+  );
+  const addNote = (note) => {
     reloads.push(note);
     unseen.push(note);
     log(`warning: ${note}`);
   };
+  const adoptRetryMs = options.adoptRetryMs ?? 1e3;
+  let adoptRun = null;
+  let adoptLoad;
+  let nextAdopt = 0;
+  const adoptJournal = async (force = false) => {
+    if (adoptRun) {
+      const startedFor = adoptLoad;
+      await adoptRun;
+      if (!force || startedFor === journal.currentLoad()) return;
+      if (adoptRun) return adoptRun;
+    }
+    if (!journal.hasCarry() || !force && Date.now() < nextAdopt) return;
+    inflight++;
+    adoptLoad = journal.currentLoad();
+    adoptRun = journal.adopt().then(
+      (note) => {
+        if (note) addNote(`app reloaded; ${note}`);
+      },
+      () => {
+      }
+    ).finally(() => {
+      inflight--;
+      nextAdopt = Date.now() + adoptRetryMs;
+      adoptRun = null;
+    });
+    return adoptRun;
+  };
+  const noteReload = (newLoad) => {
+    const lost = journal.reloaded(lastPending, newLoad);
+    lastPending = [];
+    if (lost.length || !journal.hasCarry())
+      addNote(
+        `app reloaded; ${lost.length} pending restore${lost.length === 1 ? "" : "s"} lost${lost.length ? `: ${lost.join(", ")}` : ""}`
+      );
+    nextAdopt = 0;
+    void adoptJournal(true);
+  };
   const observe = (r) => {
     if (!r.loadId) return;
-    if (knownLoad && r.loadId !== knownLoad) noteReload();
+    if (knownLoad && r.loadId !== knownLoad) noteReload(r.loadId);
     knownLoad = r.loadId;
     lastPending = r.pending ?? [];
   };
+  const seen = (r) => {
+    observe(r);
+    journal.accept(r);
+    const { journalData: _, ...rest } = r;
+    return rest;
+  };
   const takeNotice = () => {
     const notice = unseen.join("; ");
     unseen = [];
@@ -686,9 +1119,9 @@ async function runSessionDaemon(options) {
   let reloadingUntil = 0;
   let stale = false;
   let reconnecting = null;
-  const reconnect = (reason) => {
+  const reconnect = (reason2) => {
     reconnecting ??= (async () => {
-      log(`reconnecting: ${reason}`);
+      log(`reconnecting: ${reason2}`);
       conn.close();
       const patient = Date.now() < reloadingUntil;
       const deadline = Date.now() + (patient ? reloadWaitMs : 0);
@@ -707,7 +1140,7 @@ async function runSessionDaemon(options) {
             stale = true;
             log(`reconnect failed: ${message(error)}`);
             throw new Error(
-              patient ? `The app is reloading; its bridge isn't ready yet (${message(error)})` : `The app is gone (${reason}). Reconnecting failed: ${message(error)}`
+              patient ? `The app is reloading; its bridge isn't ready yet (${message(error)})` : `The app is gone (${reason2}). Reconnecting failed: ${message(error)}`
             );
           }
           await pause(300, stopping.signal);
@@ -716,7 +1149,7 @@ async function runSessionDaemon(options) {
       stale = false;
       reloadingUntil = 0;
       if (conn.device.loadId) {
-        if (knownLoad && conn.device.loadId !== knownLoad) noteReload();
+        if (knownLoad && conn.device.loadId !== knownLoad) noteReload(conn.device.loadId);
         knownLoad = conn.device.loadId;
       }
       state.device = deviceOf(conn);
@@ -728,8 +1161,8 @@ async function runSessionDaemon(options) {
     });
     return reconnecting;
   };
-  const connected = async (reason = "app stopped answering") => {
-    const attempt2 = reconnecting ?? reconnect(reason);
+  const connected = async (reason2 = "app stopped answering") => {
+    const attempt2 = reconnecting ?? reconnect(reason2);
     const wait = Date.now() < reloadingUntil ? reloadWaitMs + 2 * attemptMs + 500 : 2 * attemptMs + 500;
     let timer2;
     try {
@@ -750,16 +1183,16 @@ async function runSessionDaemon(options) {
       clearTimeout(timer2);
     }
   };
-  const ping = (ms = 1500) => conn.call("bridge.ping", [], Math.min(ms, 1500)).then(
+  const ping = (ms = 1500) => send("bridge.ping", [], Math.min(ms, 1500)).then(
     (r) => {
-      if (r.ok) observe(r);
+      if (r.ok) seen(r);
       return r.ok;
     },
     () => false
   );
   const attempt = async (tool, args, ms) => {
     try {
-      const result = await conn.call(tool, args, ms);
+      const result = await send(tool, args, ms);
       return lostConnection(result) ? { lost: result.error } : { result };
     } catch (error) {
       if (await ping(ms)) throw error;
@@ -768,12 +1201,15 @@ async function runSessionDaemon(options) {
   };
   const callApp = async (tool, args, ms) => {
     if (stale || reconnecting) await connected();
+    await adoptJournal(tool === "bridge.restore");
+    if (tool === RELOAD) await ping();
     let t0 = performance.now();
+    const start2 = t0;
     const first = await attempt(tool, args, ms);
     if (first.result) {
-      observe(first.result);
-      if (tool === RELOAD && first.result.ok) waitForReload();
-      return { result: first.result, ms: performance.now() - t0 };
+      const result = seen(first.result);
+      if (tool === RELOAD && result.ok) waitForReload();
+      return { result, ms: performance.now() - t0 };
     }
     if (tool === RELOAD) {
       waitForReload();
@@ -786,20 +1222,48 @@ async function runSessionDaemon(options) {
       };
       return { result, ms: performance.now() - t0 };
     }
-    await connected(first.lost);
+    const before = knownLoad;
+    const goneWait = WAIT_TOOLS.has(tool) && args[1]?.gone;
+    let reconnectFailure = "";
+    try {
+      await connected(first.lost);
+    } catch (error) {
+      reconnectFailure = message(error);
+    }
+    const reloaded = knownLoad !== before;
+    if (!reconnectFailure) await sync();
+    const again = repeatable(tool, args) && !(goneWait && reloaded);
+    if (again && reconnectFailure) throw new Error(reconnectFailure);
+    if (!again) {
+      if ((reloaded || reconnectFailure) && /^(mmkv|store)\./.test(tool))
+        addNote(
+          `${tool} was cut off; if it wrote to MMKV or a persisted store, that undo may be lost`
+        );
+      const how = reloaded ? "the app reloaded" : before ? "the app disconnected" : "the connection dropped";
+      throw new Error(
+        `${how} during ${tool}; it may or may not have run (${first.lost})${reconnectFailure ? `; reconnecting failed: ${reconnectFailure}` : ""}`
+      );
+    }
     t0 = performance.now();
-    const second = await attempt(tool, args, ms);
+    const retryArgs = WAIT_TOOLS.has(tool) ? withTimeLeft(
+      args,
+      (args[1]?.timeoutMs ?? WAIT_DEFAULT_MS) - (t0 - start2)
+    ) : args;
+    const second = await attempt(tool, retryArgs, ms);
     if (!second.result)
       throw new Error(
         `The app stopped answering after a reconnect: ${second.lost}`
       );
-    observe(second.result);
     return {
-      result: second.result,
+      result: seen(second.result),
       ms: performance.now() - t0,
       reconnected: true
     };
   };
+  const sync = async () => {
+    if (journal.hasCarry()) await adoptJournal(true);
+    else await ping();
+  };
   const waitForReload = () => {
     reloadingUntil = Date.now() + reloadWaitMs;
     stale = true;
@@ -822,19 +1286,47 @@ async function runSessionDaemon(options) {
   };
   const health = options.healthMs === 0 ? void 0 : setInterval(async () => {
     if (inflight || reconnecting || finishing) return;
-    if (stale || !await ping())
+    const pinged = conn;
+    const answered = await ping();
+    if (inflight || reconnecting || finishing || conn !== pinged) return;
+    if (stale || !answered)
       await reconnect("no answer to bridge.ping").catch(() => {
       });
   }, options.healthMs ?? 5e3);
   const timer = health;
   timer?.unref?.();
+  const restoreOnce = async () => {
+    const fail = (error) => ({ id: "restore", from: "", ok: false, error, ms: 0 });
+    const run = (tool) => attempt(tool, [], timeoutMs);
+    try {
+      if (stale || reconnecting || !await ping()) await connected("no answer before restore");
+      for (let i = 0; i < 3 && journal.hasCarry(); i++) {
+        if (i) await new Promise((r) => setTimeout(r, Math.min(adoptRetryMs, 500)));
+        await adoptJournal(true);
+      }
+      const first = await run("bridge.restore");
+      if (first.result) return seen(first.result);
+      await connected(first.lost);
+      await adoptJournal(true);
+      const check = await run("bridge.pending");
+      if (!check.result) return fail(`restore may or may not have run (${first.lost})`);
+      const left = seen(check.result);
+      if (!left.ok) return fail(`restore may or may not have run (${first.lost}); ${left.error}`);
+      if (!Object.keys(left.value).length)
+        return { ...left, id: "restore", value: { note: "the reply was lost; nothing is pending now" } };
+      const second = await run("bridge.restore");
+      return second.result ? seen(second.result) : fail(`The app stopped answering after a reconnect: ${second.lost}`);
+    } catch (error) {
+      return fail(message(error));
+    }
+  };
   let finishing = null;
   let resolveDone = () => {
   };
   const done = new Promise((r) => {
     resolveDone = r;
   });
-  const teardown = (reason, keep) => {
+  const teardown = (reason2, keep) => {
     finishing ??= (async () => {
       clearTimeout(idleTimer);
       clearInterval(health);
@@ -842,16 +1334,9 @@ async function runSessionDaemon(options) {
       const cut = setTimeout(() => cutOff.abort(), Math.min(attemptMs, 5e3));
       let restore = null;
       if (!keep) {
-        restore = await callApp("bridge.restore", [], timeoutMs).then(
-          (r) => r.result,
-          (error) => ({
-            id: "restore",
-            from: "",
-            ok: false,
-            error: message(error),
-            ms: 0
-          })
-        );
+        restore = await restoreOnce();
+        const left = journal.giveUp();
+        if (left) addNote(`app reloaded; ${left}`);
       }
       clearTimeout(cut);
       cutOff.abort();
@@ -859,10 +1344,10 @@ async function runSessionDaemon(options) {
       server.close();
       removeSessionFiles(name, dir);
       const outcome = !restore ? "kept app state" : restore.ok ? `restore: ${JSON.stringify(restore.value)}` : `restore: ${restore.error}`;
-      log(`stopped (${reason}); ${outcome}`);
+      log(`stopped (${reason2}); ${outcome}`);
       const deadline = Date.now() + 2e3;
       const settle = () => {
-        if (!clients.size || Date.now() > deadline) resolveDone(reason);
+        if (!clients.size || Date.now() > deadline) resolveDone(reason2);
         else setTimeout(settle, 10);
       };
       settle();
@@ -884,16 +1369,21 @@ async function runSessionDaemon(options) {
     switch (req.op) {
       case "call": {
         if (!req.tool) return { id: req.id, error: "call needs a tool" };
+        if (req.tool === "bridge.adopt")
+          return { id: req.id, error: "bridge.adopt is for a session's own use" };
         inflight++;
         touch();
         try {
+          const args = req.args ?? [];
           const answer = await callApp(
             req.tool,
-            req.args ?? [],
-            req.timeoutMs ?? timeoutMs
+            args,
+            callTimeout(req.timeoutMs ?? timeoutMs, req.tool, args)
           );
+          await adoptRun;
           return { id: req.id, ...answer, ...takeNotice() };
         } catch (error) {
+          await adoptRun;
           return { id: req.id, error: message(error), ...takeNotice() };
         } finally {
           inflight--;
@@ -936,7 +1426,10 @@ async function runSessionDaemon(options) {
     socket.on("close", () => clients.delete(socket));
     socket.on("error", () => {
     });
-    createInterface3({ input: socket }).on("line", async (line) => {
+    const lines = createInterface3({ input: socket });
+    lines.on("error", () => {
+    });
+    lines.on("line", async (line) => {
       let req;
       try {
         req = JSON.parse(line);
@@ -953,11 +1446,11 @@ async function runSessionDaemon(options) {
   });
   if (process.platform !== "win32") rmSync(files.socket, { force: true });
   try {
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve4, reject) => {
       server.once("error", reject);
       server.listen(files.socket, () => {
         server.off("error", reject);
-        resolve2();
+        resolve4();
       });
     });
   } catch (error) {
@@ -984,13 +1477,14 @@ async function runSessionDaemon(options) {
 
 // src/client/session/cli.ts
 var DAEMON_COMMAND = "__session-daemon";
-function sessionFor(flags) {
+function sessionFor(flags, skip) {
   if (flags["no-session"]) return null;
   return pickSession({
     name: flags.session ?? process.env.AGENT_BRIDGE_SESSION,
     metro: explicitMetro(flags.metro),
     device: flags.device,
-    transport: flags.transport
+    transport: flags.transport,
+    skip
   });
 }
 var describeRestore = (restore) => {
@@ -1044,7 +1538,7 @@ async function start(flags) {
     [...process.execArgv, process.argv[1], ...args],
     { detached: true, stdio: "ignore", windowsHide: true }
   );
-  const state = await new Promise((resolve2, reject) => {
+  const state = await new Promise((resolve4, reject) => {
     const deadline = Date.now() + 3e4;
     let exited = false;
     child.once("exit", () => {
@@ -1055,13 +1549,13 @@ async function start(flags) {
       const failed = existsSync(files.error);
       if (ready && ready.pid === child.pid) {
         clearInterval(tick);
-        resolve2(ready);
+        resolve4(ready);
       } else if (failed || exited || Date.now() > deadline) {
         clearInterval(tick);
         if (!exited) child.kill();
-        const reason = failed ? readFileSync3(files.error, "utf8") : exited ? `The session exited early; see ${files.log}` : `The session didn't connect within 30 s; see ${files.log}`;
+        const reason2 = failed ? readFileSync3(files.error, "utf8") : exited ? `The session exited early; see ${files.log}` : `The session didn't connect within 30 s; see ${files.log}`;
         rmSync2(files.error, { force: true });
-        reject(new Error(reason));
+        reject(new Error(reason2));
       }
     }, 50);
   });
@@ -1177,10 +1671,1675 @@ async function daemonMain(flags) {
   process.exit(0);
 }
 
+// src/init/index.ts
+import { spawn as spawn2 } from "child_process";
+import {
+  appendFileSync as appendFileSync3,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname6, relative as relative6, resolve as resolve2, sep as sep2 } from "path";
+import { createInterface as createInterface4 } from "readline/promises";
+
+// package.json
+var version = "0.6.0";
+
+// src/init/detect.ts
+import { dirname as dirname4, join as join6, relative as relative3 } from "path";
+
+// src/init/package-manager.ts
+import { dirname as dirname3, join as join5 } from "path";
+var LOCKFILES = [
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+var fromName = (value) => {
+  const name = typeof value === "string" ? value.split("@")[0] : void 0;
+  return name === "bun" || name === "pnpm" || name === "yarn" || name === "npm" ? name : void 0;
+};
+function detectPackageManager(dir, root, fs, userAgent = "") {
+  for (const d of [dir, root]) {
+    const pm = fromName(fs.readJson(join5(d, "package.json"))?.packageManager);
+    if (pm) return pm;
+  }
+  for (let d = dir; ; d = dirname3(d)) {
+    for (const [file, pm] of LOCKFILES) if (fs.exists(join5(d, file))) return pm;
+    if (d === root || dirname3(d) === d) break;
+  }
+  return fromName(userAgent.split("/")[0]) ?? "npm";
+}
+function installCommand(pm, spec) {
+  switch (pm) {
+    case "bun":
+      return ["bun", "add", "-d", spec];
+    case "pnpm":
+      return ["pnpm", "add", "-D", spec];
+    case "yarn":
+      return ["yarn", "add", "-D", spec];
+    case "npm":
+      return ["npm", "install", "-D", spec];
+  }
+}
+function binFallback(pm) {
+  switch (pm) {
+    case "bun":
+      return "bunx @avasapp/agent-bridge";
+    case "pnpm":
+      return "pnpm exec agent-bridge";
+    case "yarn":
+      return "yarn agent-bridge";
+    case "npm":
+      return "./node_modules/.bin/agent-bridge";
+  }
+}
+
+// src/init/detect.ts
+var PACKAGE = "@avasapp/agent-bridge";
+var LIBRARIES = {
+  expo: "expo",
+  expoRouter: "expo-router",
+  reactQuery: "@tanstack/react-query",
+  webview: "react-native-webview",
+  zustand: "zustand",
+  redux: "@reduxjs/toolkit",
+  reduxCore: "redux",
+  jotai: "jotai",
+  mmkv: "react-native-mmkv",
+  asyncStorage: "@react-native-async-storage/async-storage",
+  secureStore: "expo-secure-store",
+  ably: "ably",
+  socketIo: "socket.io-client",
+  reactNavigation: "@react-navigation/native",
+  typescript: "typescript"
+};
+var SOURCE_EXTS = ["tsx", "ts", "jsx", "js"];
+var depsOf = (pkg) => ({
+  ...pkg?.peerDependencies,
+  ...pkg?.devDependencies,
+  ...pkg?.dependencies
+});
+var isApp = (dir, fs) => !!fs.readJson(join6(dir, "package.json"))?.dependencies?.["react-native"] || ["app.json", "app.config.js", "app.config.ts", "ios", "android"].some((f) => fs.exists(join6(dir, f)));
+var isWorkspaceRoot = (dir, fs) => !!fs.readJson(join6(dir, "package.json"))?.workspaces || fs.exists(join6(dir, "pnpm-workspace.yaml"));
+function findUp(dir, fs, test) {
+  for (let d = dir; ; d = dirname4(d)) {
+    if (test(d)) return d;
+    if (fs.exists(join6(d, ".git")) || dirname4(d) === d) return void 0;
+  }
+}
+function workspacePatterns(root, fs) {
+  const ws = fs.readJson(join6(root, "package.json"))?.workspaces;
+  const fromPkg = Array.isArray(ws) ? ws : ws?.packages ?? [];
+  const yaml = fs.read(join6(root, "pnpm-workspace.yaml")) ?? "";
+  const block = yaml.match(/^packages:\s*\n((?:[ \t]*(?:-.*|#.*)?\n?)*)/m)?.[1] ?? "";
+  const fromYaml = [...block.matchAll(/^[ \t]*-[ \t]*['"]?([^'"#\n]+?)['"]?[ \t]*$/gm)].map(
+    (m) => m[1]
+  );
+  return [...fromPkg, ...fromYaml].filter(
+    (p) => typeof p === "string" && !p.startsWith("!")
+  );
+}
+function expandWorkspaces(root, patterns, fs) {
+  const found = /* @__PURE__ */ new Set();
+  const walk2 = (dir, segments, depth) => {
+    if (!segments.length) {
+      if (fs.exists(join6(dir, "package.json"))) found.add(dir);
+      return;
+    }
+    const [head, ...rest] = segments;
+    const children = () => fs.list(dir).filter((e) => e.dir && e.name !== "node_modules" && !e.name.startsWith("."));
+    if (head === "**") {
+      walk2(dir, rest, depth);
+      if (depth < 4)
+        for (const c of children()) walk2(join6(dir, c.name), segments, depth + 1);
+    } else if (head.includes("*")) {
+      const re = new RegExp(
+        `^${head.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`
+      );
+      for (const c of children())
+        if (re.test(c.name)) walk2(join6(dir, c.name), rest, depth);
+    } else {
+      walk2(join6(dir, head), rest, depth);
+    }
+  };
+  for (const p of patterns)
+    walk2(root, p.replace(/\/+$/, "").split("/").filter((s) => s && s !== "."), 0);
+  return [...found].sort();
+}
+var firstExisting = (dir, fs, candidates) => candidates.find((c) => fs.exists(join6(dir, c)));
+var withExts = (base) => SOURCE_EXTS.map((e) => `${base}.${e}`);
+function detect(dir, fs, env = {}) {
+  const pkg = fs.readJson(join6(dir, "package.json"));
+  if (!pkg) return { error: `No package.json in ${dir}.` };
+  const deps = depsOf(pkg);
+  if (!deps["react-native"]) {
+    if (isWorkspaceRoot(dir, fs)) {
+      const apps = expandWorkspaces(dir, workspacePatterns(dir, fs), fs).filter((d) => isApp(d, fs)).map((d) => relative3(dir, d));
+      return {
+        error: apps.length ? `${dir} is a monorepo root. Rerun with --dir pointing at the app: ${apps.map((a) => `--dir ${a}`).join(", ")}` : `${dir} is a monorepo root and no workspace package depends on react-native.`,
+        workspaces: apps
+      };
+    }
+    return {
+      error: `${dir} isn't a React Native app: its package.json has no react-native dependency. Pass --dir <app>.`
+    };
+  }
+  const root = findUp(dir, fs, (d) => isWorkspaceRoot(d, fs)) ?? dir;
+  const repoRoot = findUp(dir, fs, (d) => fs.exists(join6(d, ".git"))) ?? root;
+  const has = Object.fromEntries(
+    Object.entries(LIBRARIES).map(([k, dep]) => [k, !!deps[dep]])
+  );
+  const appJson = fs.readJson(join6(dir, "app.json"));
+  const appName = [appJson?.expo?.name, appJson?.name, pkg.name].find(
+    (n) => typeof n === "string" && !!n
+  ) ?? "app";
+  const tsconfig = firstExisting(dir, fs, ["tsconfig.json"]);
+  const rootFile = firstExisting(
+    dir,
+    fs,
+    has.expoRouter ? [...withExts("app/_layout"), ...withExts("src/app/_layout")] : [...withExts("App"), ...withExts("src/App")]
+  );
+  const agentsFile = [.../* @__PURE__ */ new Set([dir, repoRoot])].flatMap((d) => [join6(d, "AGENTS.md"), join6(d, "CLAUDE.md")]).find((f) => fs.exists(f));
+  let bin;
+  for (let d = dir; ; d = dirname4(d)) {
+    const candidate = join6(d, "node_modules", ".bin", "agent-bridge");
+    if (fs.exists(candidate)) {
+      bin = candidate;
+      break;
+    }
+    if (d === repoRoot || dirname4(d) === d) break;
+  }
+  return {
+    dir,
+    root,
+    repoRoot,
+    appName,
+    pm: detectPackageManager(dir, root, fs, env.userAgent),
+    has,
+    installed: !!deps[PACKAGE],
+    typescript: !!tsconfig || has.typescript,
+    srcDir: fs.exists(join6(dir, "src")),
+    rootFile,
+    tsconfig,
+    oxlint: firstExisting(dir, fs, [".oxlintrc.json"]),
+    eslint: firstExisting(dir, fs, [
+      "eslint.config.js",
+      "eslint.config.mjs",
+      "eslint.config.cjs",
+      "eslint.config.ts"
+    ]),
+    agentsFile,
+    bin
+  };
+}
+
+// src/init/plan.ts
+import { dirname as dirname5, isAbsolute, join as join7, relative as relative4, sep } from "path";
+
+// src/init/jsonc.ts
+function strip(text2) {
+  let out = "";
+  let i = 0;
+  while (i < text2.length) {
+    const c = text2[i];
+    if (c === '"') {
+      let j = i + 1;
+      while (j < text2.length && text2[j] !== '"') j += text2[j] === "\\" ? 2 : 1;
+      out += text2.slice(i, j + 1);
+      i = j + 1;
+    } else if (c === "/" && text2[i + 1] === "/") {
+      const end = text2.indexOf("\n", i);
+      const j = end === -1 ? text2.length : end;
+      out += " ".repeat(j - i);
+      i = j;
+    } else if (c === "/" && text2[i + 1] === "*") {
+      const end = text2.indexOf("*/", i + 2);
+      const j = end === -1 ? text2.length : end + 2;
+      out += text2.slice(i, j).replace(/[^\n]/g, " ");
+      i = j;
+    } else {
+      out += c;
+      i++;
+    }
+  }
+  return out.replace(/,(\s*[}\]])/g, " $1");
+}
+function parseJsonc(text2) {
+  try {
+    return JSON.parse(strip(text2));
+  } catch {
+    return void 0;
+  }
+}
+function addToArray(text2, key, value, initial = []) {
+  const json = parseJsonc(text2);
+  if (!json || typeof json !== "object" || Array.isArray(json)) return void 0;
+  const current = json[key];
+  const clean = strip(text2);
+  const item = JSON.stringify(value);
+  if (Array.isArray(current)) {
+    const matches = [...clean.matchAll(new RegExp(`"${key}"\\s*:\\s*\\[`, "g"))];
+    if (matches.length !== 1) return void 0;
+    const at = matches[0].index + matches[0][0].length;
+    const after = text2.slice(at);
+    const multiline = after.match(/^[ \t]*\n([ \t]*)/);
+    if (!current.length) return `${text2.slice(0, at)}${item}${after}`;
+    if (multiline) return `${text2.slice(0, at)}
+${multiline[1]}${item},${after}`;
+    return `${text2.slice(0, at)}${item}, ${after}`;
+  }
+  if (current !== void 0) return void 0;
+  const end = clean.slice(0, clean.lastIndexOf("}")).trimEnd().length;
+  const indent = text2.match(/^([ \t]+)"/m)?.[1] ?? "  ";
+  const comma = clean.slice(0, end).endsWith("{") ? "" : ",";
+  const list2 = [...initial, value].map((v) => JSON.stringify(v)).join(", ");
+  return `${text2.slice(0, end)}${comma}
+${indent}"${key}": [${list2}]${text2.slice(end)}`;
+}
+
+// src/init/render.ts
+import { createHash } from "crypto";
+var DOCS = "https://github.com/avas-app/agent-bridge/blob/main/docs";
+var FLOW_GLOB = "**/*.flow.*";
+var REALTIME = {
+  "socket.io": { fn: "socketIoTools", from: "@avasapp/agent-bridge/socket.io", client: "socket" },
+  ably: { fn: "ablyTools", from: "@avasapp/agent-bridge/ably", client: "ably" }
+};
+var STORES_WHY = "stores often hold tokens: add `redact` for those paths before wiring them";
+var MMKV_WHY = "MMKV often holds tokens and mmkv.get returns values as they are: wire only instances without secrets";
+var ASYNC_STORAGE_WHY = "AsyncStorage often holds tokens and asyncStorage.get returns values as they are: wire it only if it holds no secrets";
+var SECURE_STORE_WHY = "SecureStore holds secrets: secureStore.get hides values unless the agent asks for {full:true}, but secureStore.set can still overwrite them";
+var REDUX_WHY = "the Redux state often holds tokens: add `redact` for those slices and paths, and wrap the root reducer in bridgeReducer() (inside persistReducer) before wiring it";
+var JOTAI_WHY = "atoms often hold tokens: list only the atoms you want the agent to read and set, and add `redact` for secret ones";
+var REALTIME_WHY = "the adapter must wrap the client where it is created, before the app subscribes";
+var NETWORK_PROMPT = "Wire network tools? In dev builds they patch fetch and XMLHttpRequest so the agent can log and mock requests.";
+var NETWORK_WHY = "networkTools patches fetch and XMLHttpRequest in dev builds so the agent can log and mock requests (net.*); it also enables the offline scenario";
+var storeKey = (name) => {
+  const bare = name.replace(/^use/, "").replace(/Store$/, "") || name;
+  return bare[0].toLowerCase() + bare.slice(1);
+};
+function realtimeLine(todo) {
+  const r = REALTIME[todo.kind];
+  return `export const realtimeDevTools = ${r.fn}(${todo.name ?? r.client})`;
+}
+function realtimeTodoText(todo) {
+  const r = REALTIME[todo.kind];
+  const where = todo.file ? `In ${todo.file}, right after \`${todo.name}\` is created` : `Where your ${todo.kind} client is created`;
+  return `${where}, add \`${realtimeLine(todo)}\` (import { ${r.fn} } from '${r.from}'), then spread realtimeDevTools into tools`;
+}
+function renderBridgeFile(o) {
+  const L = [];
+  const core = ["cdpTransport", ...o.ts ? ["type Scenarios"] : [], "useAgentBridge"];
+  L.push(
+    `// Generated by agent-bridge init ${o.version}. Yours to edit: once changed, init never overwrites it.`,
+    `import { ${core.join(", ")} } from '@avasapp/agent-bridge'`
+  );
+  if (o.expo) L.push(`import { expoTransport } from '@avasapp/agent-bridge/expo'`);
+  if (o.expoRouter) L.push(`import { routerTools } from '@avasapp/agent-bridge/expo-router'`);
+  if (o.network)
+    L.push(`import { networkTools, strictNetwork } from '@avasapp/agent-bridge/network'`);
+  if (o.webview)
+    L.push(`import { webviewTools } from '@avasapp/agent-bridge/react-native-webview'`);
+  if (o.reactQuery) {
+    L.push(
+      `import { queryTools } from '@avasapp/agent-bridge/tanstack-query'`,
+      `import { QueryClientContext } from '@tanstack/react-query'`
+    );
+  }
+  if (o.expoRouter) L.push(`import { router, useNavigationContainerRef } from 'expo-router'`);
+  if (o.reactQuery) L.push(`import { useContext } from 'react'`);
+  if (o.reactNavigation)
+    L.push(
+      "",
+      "// Pass the ref you give to <NavigationContainer ref={\u2026}>, then uncomment navTools below.",
+      `// import { navTools } from '@avasapp/agent-bridge/react-navigation'`,
+      `// import { navigationRef } from './path-to-your-navigation-ref'`
+    );
+  if (o.realtimeTools?.length)
+    L.push("", ...o.realtimeTools.map((t) => `import { ${t.name} } from '${t.from}'`));
+  if (o.stores) {
+    const stores = o.stores.length ? o.stores : [{ name: "useAuthStore", from: "../stores/auth" }];
+    L.push(
+      "",
+      "// Zustand stores are left out: they often hold tokens. Add `redact` for those",
+      "// paths, then uncomment these and storeTools below. See",
+      `// ${DOCS}/adapters.md`,
+      `// import { storeTools } from '@avasapp/agent-bridge/zustand'`,
+      ...stores.map((s) => `// import { ${s.name} } from '${s.from}'`)
+    );
+  }
+  if (o.mmkv) {
+    const mmkv = o.mmkv.length ? o.mmkv : [{ name: "storage", from: "../storage" }];
+    L.push(
+      "",
+      "// MMKV is left out: it often holds tokens, and mmkv.get returns values as they",
+      "// are. Wire only instances without secrets: uncomment these and mmkvTools below.",
+      `// See ${DOCS}/adapters.md`,
+      `// import { mmkvTools } from '@avasapp/agent-bridge/react-native-mmkv'`,
+      ...mmkv.map((m) => `// import { ${m.name} } from '${m.from}'`)
+    );
+  }
+  if (o.asyncStorage)
+    L.push(
+      "",
+      "// AsyncStorage is left out: it often holds tokens, and asyncStorage.get returns",
+      "// values as they are. Uncomment these and asyncStorageTools below if it holds none,",
+      "// passing the storage the app uses (a createAsyncStorage(name) instance, if it has one).",
+      `// See ${DOCS}/adapters.md`,
+      `// import { asyncStorageTools } from '@avasapp/agent-bridge/async-storage'`,
+      `// import AsyncStorage from '@react-native-async-storage/async-storage'`
+    );
+  if (o.secureStore)
+    L.push(
+      "",
+      "// SecureStore is left out: it holds secrets. secureStore.get hides values unless",
+      "// the agent asks for {full:true}. Uncomment these and secureStoreTools below,",
+      "// passing the keys the app uses so secureStore.list can show them, and the same",
+      "// options the app passes to SecureStore (keychainService, requireAuthentication).",
+      `// See ${DOCS}/adapters.md`,
+      `// import { secureStoreTools } from '@avasapp/agent-bridge/secure-store'`,
+      `// import * as SecureStore from 'expo-secure-store'`
+    );
+  if (o.redux)
+    L.push(
+      "",
+      "// Redux is left out: the state often holds tokens. Add `redact` for those slices,",
+      "// wrap the root reducer in bridgeReducer() (inside persistReducer) where the store",
+      "// is created, then uncomment these and reduxTools below.",
+      `// See ${DOCS}/adapters.md`,
+      `// import { reduxTools } from '@avasapp/agent-bridge/redux'`,
+      `// import { store } from '../store'`
+    );
+  if (o.jotai)
+    L.push(
+      "",
+      "// Jotai is left out: atoms often hold tokens. List the atoms the agent may read and",
+      "// set, add `redact` for secret ones, then uncomment these and jotaiTools below.",
+      "// Use the store your app uses: a <Provider> without a store prop has its own, out of reach here.",
+      `// See ${DOCS}/adapters.md`,
+      `// import { jotaiTools } from '@avasapp/agent-bridge/jotai'`,
+      `// import { getDefaultStore } from 'jotai'`,
+      `// import { userAtom } from '../atoms'`
+    );
+  for (const todo of o.realtime) {
+    const r = REALTIME[todo.kind];
+    L.push(
+      "",
+      `// TODO ${todo.kind}: the adapter must wrap the client where it is created,`,
+      `// before the app subscribes (${DOCS}/realtime.md).`,
+      todo.file ? `// In ${todo.file}, right after \`${todo.name}\` is created, add:` : `// Where your ${todo.kind} client is created, add:`,
+      `//   import { ${r.fn} } from '${r.from}'`,
+      `//   ${realtimeLine(todo)}`,
+      `// then import realtimeDevTools here and uncomment it in tools.`
+    );
+  }
+  L.push("");
+  if (o.ts) L.push("const scenarios: Scenarios = {");
+  else L.push(`/** @type {import('@avasapp/agent-bridge').Scenarios} */`, "const scenarios = {");
+  if (o.network) {
+    L.push(
+      "  offline: {",
+      `    description: 'Every request fails like a network failure; Metro still gets through.',`,
+      "    apply: ({ onUndo }) => {",
+      "      onUndo(strictNetwork({ offline: true }))",
+      "    },",
+      "  },"
+    );
+  }
+  L.push(
+    "  // A user signed in locally with every request mocked: the state most flows",
+    `  // start from. See ${DOCS}/scenarios.md`,
+    "  // signedIn: {",
+    `  //   description: 'Signed in locally; no request reaches a server.',`,
+    "  //   apply: async ({ call, onUndo }) => {",
+    `  //     onUndo(strictNetwork())  // and mockApi, both from '@avasapp/agent-bridge/network'`,
+    `  //     onUndo(mockApi(API_URL, { 'GET /me': { json: user } }))`,
+    `  //     await call('store.set', 'auth', { token: 'local', user })`,
+    "  //     return { user }",
+    "  //   },",
+    "  // },",
+    "}",
+    "",
+    "export function AgentBridge() {"
+  );
+  if (o.reactQuery)
+    L.push(
+      "  // Undefined outside a QueryClientProvider: mount this inside one for query.* tools.",
+      "  const queryClient = useContext(QueryClientContext)"
+    );
+  L.push(
+    "  useAgentBridge({",
+    `    name: '${o.appName.replace(/[\\']/g, "\\$&")}',`,
+    `    transports: [${o.expo ? "expoTransport(), " : ""}cdpTransport()],`,
+    "    tools: {"
+  );
+  if (o.reactQuery) L.push("      ...(queryClient ? queryTools(queryClient) : {}),");
+  if (o.expoRouter)
+    L.push("      ...routerTools(router, { navigation: useNavigationContainerRef() }),");
+  if (o.webview)
+    L.push(
+      `      // Each WebView also needs useWebViewTools (${DOCS}/webviews.md).`,
+      "      ...webviewTools(),"
+    );
+  if (o.network) L.push("      ...networkTools(),");
+  for (const t of o.realtimeTools ?? []) L.push(`      ...${t.name},`);
+  if (o.stores) {
+    const stores = o.stores.length ? o.stores : [{ name: "useAuthStore", from: "" }];
+    const map = stores.map((s) => `${storeKey(s.name)}: ${s.name}`).join(", ");
+    const first = storeKey(stores[0].name);
+    L.push(`      // ...storeTools({ ${map} }, { redact: { ${first}: ['token'] } }),`);
+  }
+  if (o.mmkv) {
+    const mmkv = o.mmkv.length ? o.mmkv : [{ name: "storage", from: "" }];
+    L.push(`      // ...mmkvTools({ ${mmkv.map((m) => m.name).join(", ")} }),`);
+  }
+  if (o.asyncStorage) L.push("      // ...asyncStorageTools(AsyncStorage),");
+  if (o.secureStore) L.push(`      // ...secureStoreTools(SecureStore, ['authToken']),`);
+  if (o.redux) L.push(`      // ...reduxTools(store, { redact: { auth: ['token'] } }),`);
+  if (o.jotai) L.push("      // ...jotaiTools(getDefaultStore(), { user: userAtom }),");
+  if (o.realtime.length) L.push("      // ...realtimeDevTools,");
+  if (o.reactNavigation)
+    L.push(
+      "      // React Navigation: uncomment this and the imports above, with the ref you pass to",
+      "      // <NavigationContainer ref={\u2026}> (createNavigationContainerRef from @react-navigation/native).",
+      "      // ...navTools(navigationRef),"
+    );
+  L.push(
+    `      // Your own tools: any function, JSON in and out, e.g. 'cart.clear': () => clearCart(),`,
+    "    },",
+    "    scenarios,",
+    "  })",
+    "  return null",
+    "}",
+    ""
+  );
+  return stamp(L.join("\n"));
+}
+function renderMountSnippet(importPath2) {
+  return `import { AgentBridge } from '${importPath2}'
+{__DEV__ ? <AgentBridge /> : null}`;
+}
+function renderSmokeFlow(o) {
+  return stamp([
+    `// Generated by agent-bridge init ${o.version}. Run it with:`,
+    `//   ${o.bin} run flows/smoke.flow.mjs`,
+    `/** @type {import('@avasapp/agent-bridge/client').FlowModule['default']} */`,
+    "const smoke = async ({ step, expect }) => {",
+    `  await step('snapshot', 'screen.snapshot')`,
+    ...o.expoRouter ? [`  await step('open home', 'router.navigate', '/')`] : [],
+    "  // TODO: check text your first screen always shows, for example:",
+    `  // await expect.text('Welcome')`,
+    "}",
+    "",
+    "export default smoke",
+    ""
+  ].join("\n"));
+}
+function renderFlowsReadme(bin) {
+  return `Flows for \`${bin} run flows/<name>.flow.mjs\`: plain .mjs files named \`*.flow.mjs\`, kept out of \`app/\` and test globs. See ${DOCS}/cli.md#flows-where-they-go.
+`;
+}
+function agentsLine(appDir, bin) {
+  const where = appDir ? `${appDir}/flows` : "flows";
+  const run = `\`${bin} run flows/smoke.flow.mjs\``;
+  return `- Flows for agent-bridge live in \`${where}/<name>.flow.mjs\` (never under \`app/\`, never \`*.test.*\`); run one ${appDir ? `from \`${appDir}\` with ${run}` : `with ${run}`}.`;
+}
+var HEADER = /^(\/\/ Generated by agent-bridge init \d+\.\d+\.\d+(?:-[\w.]+)?)( \(#([0-9a-f]{12})\))?\./;
+var hash = (body) => createHash("sha256").update(body).digest("hex").slice(0, 12);
+function stamp(content) {
+  const nl = content.indexOf("\n");
+  return content.slice(0, nl).replace(HEADER, `$1 (#${hash(content.slice(nl))}).`) + content.slice(nl);
+}
+function isPristine(text2) {
+  const nl = text2.indexOf("\n");
+  const recorded = text2.slice(0, nl).match(HEADER)?.[3];
+  return !!recorded && recorded === hash(text2.slice(nl));
+}
+var NETWORK_LINES = [
+  `import { networkTools } from '@avasapp/agent-bridge/network'`,
+  "...networkTools(),  // in useAgentBridge({ tools })"
+];
+var indentOf = (text2) => text2.match(/^([ \t]+)"/m)?.[1] ?? "  ";
+function patchJson(text2, edit, manual) {
+  let json;
+  try {
+    json = JSON.parse(text2);
+  } catch {
+    return { manual };
+  }
+  if (!json || typeof json !== "object" || Array.isArray(json)) return { manual };
+  if (!edit(json)) return { unchanged: true };
+  return {
+    text: JSON.stringify(json, null, indentOf(text2)) + (text2.endsWith("\n") ? "\n" : "")
+  };
+}
+function patchPackageScripts(text2) {
+  return patchJson(
+    text2,
+    (pkg) => {
+      if (pkg.scripts?.flow !== void 0) return false;
+      pkg.scripts = { ...pkg.scripts, flow: "agent-bridge run" };
+      return true;
+    },
+    `Add to package.json scripts: "flow": "agent-bridge run"`
+  );
+}
+var globRe = (glob) => new RegExp(
+  `^${glob.replace(/^\.\//, "").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\u0000/g, "(?:.*/)?")}$`
+);
+function includesFlows(pattern) {
+  const last = pattern.split("/").pop() ?? "";
+  const glob = last.includes(".") ? pattern : `${pattern.replace(/\/+$/, "")}${last === "*" ? "" : "/**/*"}`;
+  return globRe(glob).test("flows/smoke.flow.mjs");
+}
+function patchTsconfig(text2, baseAllowJs) {
+  const manual = `Add "${FLOW_GLOB}" to "exclude" in tsconfig.json`;
+  const json = parseJsonc(text2);
+  if (!json || typeof json !== "object") return { manual };
+  if (Array.isArray(json.exclude) && json.exclude.includes(FLOW_GLOB)) return { unchanged: true };
+  const allowJs = json.compilerOptions?.allowJs ?? baseAllowJs ?? true;
+  const include = Array.isArray(json.include) ? json.include : json.files ? [] : ["**/*"];
+  if (!allowJs || !include.some((p) => typeof p === "string" && includesFlows(p)))
+    return { unchanged: true, note: "doesn't include .mjs files" };
+  if (json.extends && !Array.isArray(json.exclude))
+    return {
+      manual: `${manual}, along with what it inherits from ${JSON.stringify(json.extends)}: an "exclude" here replaces the inherited one`
+    };
+  const patched = addToArray(text2, "exclude", FLOW_GLOB, ["node_modules"]);
+  return patched ? { text: patched } : { manual };
+}
+function patchOxlint(text2) {
+  const ignore = parseJsonc(text2)?.ignorePatterns;
+  if (Array.isArray(ignore) && ignore.includes(FLOW_GLOB)) return { unchanged: true };
+  const patched = addToArray(text2, "ignorePatterns", FLOW_GLOB);
+  return patched ? { text: patched } : { manual: `Add "${FLOW_GLOB}" to "ignorePatterns" in .oxlintrc.json` };
+}
+var ESLINT_SNIPPET = `{ ignores: ['${FLOW_GLOB}'] },`;
+function patchEslint(text2) {
+  if (text2.includes(FLOW_GLOB)) return { unchanged: true };
+  const manual = `Add to the start of your ESLint flat config array: ${ESLINT_SNIPPET}`;
+  const re = /^((?:module\.exports\s*=|export\s+default)\s*(?:defineConfig\(\s*)?\[)/gm;
+  const matches = [...text2.matchAll(re)];
+  if (matches.length !== 1) return { manual };
+  const at = matches[0].index + matches[0][1].length;
+  return { text: `${text2.slice(0, at)}
+  ${ESLINT_SNIPPET}${text2.slice(at)}` };
+}
+
+// src/init/plan.ts
+var SKILL_COMMAND = ["npx", "skills", "add", "avas-app/agent-bridge"];
+var SKILL_RUN = ["npx", "--yes", "skills", "add", "avas-app/agent-bridge"];
+var PLUGIN_LINES = [
+  "/plugin marketplace add avas-app/agent-bridge",
+  "/plugin install agent-bridge@agent-bridge"
+];
+var MARKERS = [
+  ["expo", /expoTransport/, "expo"],
+  ["expoRouter", /routerTools/, "expo-router"],
+  ["reactQuery", /queryTools/, "@tanstack/react-query"],
+  ["webview", /webviewTools/, "react-native-webview"],
+  ["zustand", /storeTools/, "zustand"],
+  ["redux", /reduxTools/, "@reduxjs/toolkit"],
+  ["reduxCore", /reduxTools/, "redux"],
+  ["jotai", /jotaiTools/, "jotai"],
+  ["mmkv", /mmkvTools/, "react-native-mmkv"],
+  ["asyncStorage", /asyncStorageTools/, "@react-native-async-storage/async-storage"],
+  ["secureStore", /secureStoreTools/, "expo-secure-store"],
+  ["socketIo", /realtimeDevTools|socketIoTools|realtime/i, "socket.io-client"],
+  ["ably", /realtimeDevTools|ablyTools|realtime/i, "ably"]
+];
+var posix2 = (p) => p.split(sep).join("/");
+function importPath(fromFile, toFile) {
+  const rel = posix2(relative4(dirname5(fromFile), toFile)).replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function binFor(d) {
+  if (d.bin) {
+    const rel = posix2(relative4(d.dir, d.bin));
+    return rel.startsWith(".") ? rel : `./${rel}`;
+  }
+  if (d.pm === "npm" && d.root !== d.dir)
+    return `${posix2(relative4(d.dir, d.root))}/node_modules/.bin/agent-bridge`;
+  return binFallback(d.pm);
+}
+function bridgePath(d, out) {
+  if (out) return isAbsolute(out) ? out : join7(d.dir, out);
+  return join7(d.dir, d.srcDir ? "src/dev" : "dev", `agent-bridge.${d.typescript ? "tsx" : "js"}`);
+}
+function nextSteps(bin, o) {
+  const { offline, runFrom } = o;
+  const next = [];
+  if (!o.mounted)
+    next.push({
+      step: o.elsewhere ? "Make sure the root component renders the component that calls useAgentBridge" : "Mount it: paste the snippet above"
+    });
+  next.push(
+    { step: "Reload the app (press r in Metro)" },
+    { step: "Start a session", command: `${bin} session start` },
+    { step: "List the tools", command: `${bin} tools` },
+    { step: "See what's on screen", command: `${bin} call screen.snapshot` }
+  );
+  if (offline)
+    next.push({ step: "Try a scenario", command: `${bin} call scenario.apply '"offline"'` });
+  next.push({ step: "Undo everything and disconnect", command: `${bin} session stop` });
+  const from = runFrom === "." ? "" : `From \`${runFrom}\`: `;
+  return {
+    next,
+    prompt: `This app has agent-bridge. ${from ? `${from}s` : "S"}tart a session with \`${bin} session start\`, see the screen with \`${bin} call screen.snapshot\`, and check changes through the bridge instead of tapping; stop the session when done.`
+  };
+}
+var stripExt = (p) => p.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "").replace(/\/index$/, "");
+function readTsconfig(d, fs) {
+  if (!d.tsconfig) return { aliases: [] };
+  const file = join7(d.dir, d.tsconfig);
+  const json = parseJsonc(fs.read(file) ?? "");
+  if (!json) return { aliases: [] };
+  const findExtended = (from2, ext2) => {
+    const names2 = ext2.endsWith(".json") ? [ext2] : [ext2, `${ext2}.json`];
+    const roots = ext2.startsWith(".") ? [dirname5(from2)] : ancestors(dirname5(from2), d.repoRoot).map((a) => join7(a, "node_modules"));
+    for (const r of roots) for (const n of names2) if (fs.exists(join7(r, n)) && !fs.list(join7(r, n)).length) return join7(r, n);
+    return void 0;
+  };
+  let baseAllowJs;
+  let ext = json.extends;
+  let from = file;
+  for (let depth = 0; typeof ext === "string" && depth < 4; depth++) {
+    const path = findExtended(from, ext);
+    const base = path ? parseJsonc(fs.read(path) ?? "") : void 0;
+    if (!base) break;
+    if (typeof base.compilerOptions?.allowJs === "boolean") {
+      baseAllowJs = base.compilerOptions.allowJs;
+      break;
+    }
+    ext = base.extends;
+    from = path;
+  }
+  const baseDir = join7(d.dir, json.compilerOptions?.baseUrl ?? ".");
+  const paths = json.compilerOptions?.paths ?? {};
+  const aliases = Object.entries(paths).flatMap(
+    ([pattern, targets]) => Array.isArray(targets) && typeof targets[0] === "string" ? [[pattern.replace(/\*$/, ""), join7(baseDir, targets[0].replace(/\*$/, ""))]] : []
+  );
+  return { json, baseAllowJs, aliases };
+}
+function ancestors(dir, stop2) {
+  const out = [];
+  for (let d = dir; ; d = dirname5(d)) {
+    out.push(d);
+    if (d === stop2 || dirname5(d) === d) return out;
+  }
+}
+function importedFiles(file, text2, aliases) {
+  const specs = [...text2.matchAll(/(?:from\s+|import\s+|require\(\s*)['"]([^'"]+)['"]/g)].map((m) => m[1]);
+  return specs.flatMap((spec) => {
+    if (spec.startsWith(".")) return [stripExt(join7(dirname5(file), spec))];
+    const alias = aliases.find(([prefix]) => prefix && spec.startsWith(prefix));
+    return alias ? [stripExt(join7(alias[1], spec.slice(alias[0].length)))] : [];
+  });
+}
+function plan(d, found, fs, o, cwd) {
+  const rel = (p) => posix2(relative4(d.dir, p));
+  const out = bridgePath(d, o.out);
+  if (rel(out).startsWith("..") || isAbsolute(rel(out)))
+    return { error: `--out ${o.out} is outside the app (${d.dir}).` };
+  if (/^(src\/)?app\//.test(rel(out)))
+    return {
+      error: `${rel(out)} is under app/, where expo-router treats every file as a route. Pick another --out.`
+    };
+  const ts = /\.tsx?$/.test(out);
+  const bin = binFor(d);
+  const runFrom = posix2(relative4(cwd, d.dir)) || ".";
+  const tsconfig = readTsconfig(d, fs);
+  const actions = [];
+  const files = [];
+  const commented = [];
+  const todos = [];
+  const generate = (path, content) => {
+    const current = fs.read(path);
+    if (current === void 0) {
+      actions.push({ kind: "write", path, content });
+      files.push({ path: rel(path), status: "written" });
+      return "written";
+    }
+    const pristine = isPristine(current);
+    if (!o.force) {
+      files.push({
+        path: rel(path),
+        status: "skipped",
+        note: pristine ? "exists; --force regenerates it" : "exists, edited since init wrote it"
+      });
+      return pristine ? "kept" : "edited";
+    }
+    if (pristine) {
+      const same = current === content;
+      if (!same) actions.push({ kind: "write", path, content });
+      files.push({ path: rel(path), status: same ? "unchanged" : "written" });
+      return "written";
+    }
+    actions.push({ kind: "write", path: `${path}.new`, content });
+    files.push({
+      path: rel(path),
+      status: "skipped",
+      note: `edited since init wrote it, so --force left it; wrote ${rel(path)}.new to compare`
+    });
+    files.push({ path: `${rel(path)}.new`, status: "written" });
+    return "edited";
+  };
+  const imported = (list2) => list2.map((f) => ({ name: f.name, from: importPath(out, join7(d.dir, f.file)) }));
+  const realtimeTools = imported(found.realtimeTools);
+  const realtime = realtimeTools.length ? [] : [
+    ...d.has.socketIo ? found.socketIo.length ? found.socketIo.map((f) => ({ kind: "socket.io", ...f })) : [{ kind: "socket.io" }] : [],
+    ...d.has.ably ? found.ably.length ? found.ably.map((f) => ({ kind: "ably", ...f })) : [{ kind: "ably" }] : []
+  ];
+  const existingText = fs.read(out);
+  const existing = found.bridgeUsers.filter((f) => stripExt(join7(d.dir, f)) !== stripExt(out));
+  const elsewhere = existingText === void 0 && existing.length > 0 && !o.out;
+  let state = "elsewhere";
+  if (elsewhere) {
+    files.push({
+      path: rel(out),
+      status: "skipped",
+      note: `the app already uses the bridge in ${existing.join(", ")}; pass --out to write one anyway`
+    });
+  } else {
+    state = generate(
+      out,
+      renderBridgeFile({
+        version: o.version,
+        appName: d.appName,
+        ts,
+        expo: d.has.expo,
+        expoRouter: d.has.expoRouter,
+        reactQuery: d.has.reactQuery,
+        webview: d.has.webview,
+        network: o.network.enabled,
+        reactNavigation: d.has.reactNavigation && !d.has.expoRouter,
+        stores: d.has.zustand ? imported(found.stores) : void 0,
+        mmkv: d.has.mmkv ? imported(found.mmkv) : void 0,
+        asyncStorage: d.has.asyncStorage,
+        secureStore: d.has.secureStore,
+        redux: d.has.redux || d.has.reduxCore,
+        jotai: d.has.jotai,
+        realtime,
+        realtimeTools
+      })
+    );
+  }
+  const wrote = state === "written";
+  const liveText = wrote ? void 0 : elsewhere ? existing.map((f) => fs.read(join7(d.dir, f)) ?? "").join("\n") : existingText;
+  const network = wrote ? o.network.enabled : /networkTools\s*\(/.test(liveText ?? "");
+  const offline = wrote ? o.network.enabled : /\boffline\s*:/.test(liveText ?? "");
+  if (wrote) {
+    if (d.has.zustand)
+      commented.push({
+        adapter: "zustand",
+        items: found.stores.map((s) => `${s.name} (${s.file})`),
+        why: `${STORES_WHY} (${DOCS}/adapters.md)`
+      });
+    if (d.has.mmkv)
+      commented.push({
+        adapter: "react-native-mmkv",
+        items: found.mmkv.map((s) => `${s.name} (${s.file})`),
+        why: `${MMKV_WHY} (${DOCS}/adapters.md)`
+      });
+    if (d.has.asyncStorage)
+      commented.push({
+        adapter: "async-storage",
+        items: ["AsyncStorage"],
+        why: `${ASYNC_STORAGE_WHY} (${DOCS}/adapters.md)`
+      });
+    if (d.has.secureStore)
+      commented.push({
+        adapter: "secure-store",
+        items: ["SecureStore"],
+        why: `${SECURE_STORE_WHY} (${DOCS}/adapters.md)`
+      });
+    if (d.has.redux || d.has.reduxCore)
+      commented.push({
+        adapter: "redux",
+        items: ["reduxTools(store)"],
+        why: `${REDUX_WHY} (${DOCS}/adapters.md)`
+      });
+    if (d.has.jotai)
+      commented.push({
+        adapter: "jotai",
+        items: ["jotaiTools(store, atoms)"],
+        why: `${JOTAI_WHY} (${DOCS}/adapters.md)`
+      });
+    if (d.has.reactNavigation && !d.has.expoRouter)
+      commented.push({
+        adapter: "@react-navigation/native",
+        items: ["navTools(navigationRef)"],
+        why: `navTools needs the container ref you pass to <NavigationContainer> (${DOCS}/adapters.md)`
+      });
+    for (const t of realtime) todos.push(`${realtimeTodoText(t)}: ${REALTIME_WHY} (${DOCS}/realtime.md).`);
+  }
+  const missing = !wrote && liveText !== void 0 ? MARKERS.filter(([lib, marker]) => d.has[lib] && !marker.test(liveText)).map(([, , dep]) => dep) : [];
+  const flows = join7(d.dir, "flows");
+  generate(
+    join7(flows, "smoke.flow.mjs"),
+    renderSmokeFlow({ version: o.version, expoRouter: d.has.expoRouter, bin })
+  );
+  const readme = join7(flows, "README.md");
+  if (fs.exists(readme)) files.push({ path: rel(readme), status: "skipped", note: "exists" });
+  else {
+    actions.push({ kind: "write", path: readme, content: renderFlowsReadme(bin) });
+    files.push({ path: rel(readme), status: "written" });
+  }
+  const patch = (path, fn) => {
+    if (!path) return;
+    const abs = join7(d.dir, path);
+    const result = fn(fs.read(abs) ?? "");
+    if ("text" in result) {
+      actions.push({ kind: "patch", path: abs, patch: fn });
+      files.push({ path, status: "patched" });
+    } else if ("manual" in result) {
+      files.push({ path, status: "manual", note: result.manual });
+    } else {
+      files.push({ path, status: "unchanged", ...result.note && { note: result.note } });
+    }
+  };
+  patch("package.json", patchPackageScripts);
+  patch(d.tsconfig, (text2) => patchTsconfig(text2, tsconfig.baseAllowJs));
+  patch(d.oxlint, patchOxlint);
+  patch(d.eslint, patchEslint);
+  if (d.agentsFile) {
+    const text2 = fs.read(d.agentsFile) ?? "";
+    const path = posix2(relative4(d.dir, d.agentsFile));
+    if (text2.includes(".flow.mjs")) files.push({ path, status: "unchanged" });
+    else {
+      const appDir = posix2(relative4(dirname5(d.agentsFile), d.dir));
+      actions.push({ kind: "append", path: d.agentsFile, line: agentsLine(appDir, bin) });
+      files.push({ path, status: "appended" });
+    }
+  }
+  const spec = `${PACKAGE}@^${o.version}`;
+  const install = installCommand(d.pm, spec);
+  if (!d.installed && o.install) actions.unshift({ kind: "install", command: install, cwd: d.dir });
+  const skill = o.skillYes ? [...SKILL_RUN, "-y"] : SKILL_RUN;
+  if (o.skill) actions.push({ kind: "skill", command: skill, cwd: d.repoRoot });
+  const rootFile = d.rootFile ? join7(d.dir, d.rootFile) : void 0;
+  const rootImports = rootFile ? importedFiles(rootFile, fs.read(rootFile) ?? "", tsconfig.aliases) : [];
+  const reachedFromRoot = (file) => stripExt(file) === stripExt(rootFile ?? "") || rootImports.includes(stripExt(file));
+  const mounted = elsewhere ? existing.some((f) => reachedFromRoot(join7(d.dir, f))) : rootImports.includes(stripExt(out));
+  const snippet = renderMountSnippet(importPath(rootFile ?? join7(d.dir, "App.tsx"), out));
+  const where = elsewhere ? `The app already uses the bridge in ${existing.join(", ")}; make sure the root component renders it` : d.rootFile ? `Paste the import into ${d.rootFile} and the element into the root component's JSX` : `No root component found (looked for ${d.has.expoRouter ? "app/_layout or src/app/_layout" : "App or src/App"}): paste it into yours, fixing the import path`;
+  const note = `${where}${d.has.reactQuery && !elsewhere ? ", inside QueryClientProvider so query.* tools work" : ""}.`;
+  const regenerable = state === "written" || state === "kept";
+  const ignored = o.network.chosen && !wrote && o.network.enabled !== network ? `${o.network.enabled ? "--network" : "--no-network"} had no effect: ${elsewhere ? existing.join(", ") : rel(out)} already exists${regenerable ? "; add --force to regenerate it" : "; edit it by hand"}.` : void 0;
+  const choice = {
+    enabled: network,
+    open: !network && !(o.network.chosen && wrote),
+    why: NETWORK_WHY,
+    ...regenerable && { flag: network ? "--no-network --force" : "--network --force" },
+    ...!network && { lines: NETWORK_LINES },
+    ...ignored && { note: ignored }
+  };
+  const detected = MARKERS.filter(([lib]) => d.has[lib]).map(([, , dep]) => dep);
+  if (d.has.reactNavigation && !d.has.expoRouter) detected.push("@react-navigation/native");
+  return {
+    actions,
+    report: {
+      ok: true,
+      version: o.version,
+      dryRun: false,
+      app: { dir: d.dir, name: d.appName, packageManager: d.pm, detected },
+      files,
+      install: {
+        status: d.installed ? "present" : "not-run",
+        command: install.join(" ")
+      },
+      skill: { status: "not-run", command: SKILL_COMMAND.join(" "), plugin: PLUGIN_LINES },
+      mount: { file: d.rootFile ?? null, mounted, snippet, note },
+      choices: { network: choice },
+      commented,
+      todos,
+      missing,
+      existing,
+      runFrom,
+      scenarios: offline ? ["offline"] : [],
+      ...nextSteps(bin, { mounted, offline, runFrom, elsewhere })
+    }
+  };
+}
+
+// src/init/scan.ts
+import { join as join8, relative as relative5 } from "path";
+var CODE = /\.(tsx?|jsx?|mjs|cjs)$/;
+var TESTS = /\.(test|spec)\.|(^|\/)__tests__\//;
+var imports = (text2, module) => new RegExp(
+  `(from\\s+|require\\(\\s*)['"]${module.replace(/[.]/g, "\\.")}(/[\\w./-]+)?['"]`
+).test(text2);
+var TYPED = "(?:\\s*:[^=]+)?";
+var PATTERNS = [
+  ["stores", "zustand", new RegExp(`export\\s+const\\s+(use\\w+)${TYPED}\\s*=\\s*create\\w*\\s*[<(]`, "g")],
+  ["mmkv", "react-native-mmkv", new RegExp(`export\\s+const\\s+(\\w+)${TYPED}\\s*=\\s*(?:new\\s+MMKV|createMMKV)\\s*[<(]`, "g")],
+  ["socketIo", "socket.io-client", new RegExp(`(?:const|let)\\s+(\\w+)${TYPED}\\s*=\\s*io\\s*\\(`, "g")],
+  ["ably", "ably", new RegExp(`(?:const|let)\\s+(\\w+)${TYPED}\\s*=\\s*new\\s+(?:Ably\\.)?Realtime(?:\\.Promise)?\\s*\\(`, "g")],
+  ["realtimeTools", "@avasapp/agent-bridge", /export\s+const\s+(\w+)\s*=\s*(?:socketIoTools|ablyTools)\s*\(/g]
+];
+function scan(dir, fs, { maxFiles = 2e3, maxBytes = 512 * 1024 } = {}) {
+  const files = [];
+  const walk2 = (d, deep) => {
+    const entries = fs.list(d).sort((a, b) => a.name < b.name ? -1 : 1);
+    for (const e of entries) {
+      if (files.length >= maxFiles) return;
+      if (e.name.startsWith(".") || e.name === "node_modules") continue;
+      const path = join8(d, e.name);
+      if (e.dir) {
+        if (deep) walk2(path, true);
+      } else if (CODE.test(e.name) && !TESTS.test(relative5(dir, path))) {
+        files.push(path);
+      }
+    }
+  };
+  walk2(dir, false);
+  for (const sub of ["src", "app", "lib"]) walk2(join8(dir, sub), true);
+  const result = { stores: [], mmkv: [], socketIo: [], ably: [], realtimeTools: [], bridgeUsers: [] };
+  for (const path of files) {
+    const text2 = fs.read(path);
+    if (!text2 || text2.length > maxBytes) continue;
+    if (/\buseAgentBridge\s*\(|(from\s+|require\(\s*)['"]@avasapp\/agent-bridge['"]/.test(text2))
+      result.bridgeUsers.push(relative5(dir, path));
+    for (const [key, module, re] of PATTERNS) {
+      if (!imports(text2, module)) continue;
+      for (const m of text2.matchAll(re))
+        result[key].push({ name: m[1], file: relative5(dir, path) });
+    }
+  }
+  return result;
+}
+
+// src/init/index.ts
+var INSTALL_TIMEOUT_MS = 5 * 6e4;
+var SKILL_TIMEOUT_MS = 2 * 6e4;
+var posix3 = (p) => p.split(sep2).join("/");
+var nodeFs = {
+  exists: existsSync2,
+  read: (path) => {
+    try {
+      return readFileSync4(path, "utf8");
+    } catch {
+      return void 0;
+    }
+  },
+  readJson: (path) => {
+    try {
+      return JSON.parse(readFileSync4(path, "utf8"));
+    } catch {
+      return void 0;
+    }
+  },
+  list: (dir) => {
+    try {
+      return readdirSync(dir, { withFileTypes: true }).map((e) => ({
+        name: e.name,
+        dir: e.isDirectory()
+      }));
+    } catch {
+      return [];
+    }
+  }
+};
+function nodeIo() {
+  return {
+    fs: nodeFs,
+    write: (path, content) => {
+      mkdirSync2(dirname6(path), { recursive: true });
+      writeFileSync2(path, content);
+    },
+    append: (path, text2) => appendFileSync3(path, text2),
+    exec: (command, cwd, interactive, timeoutMs) => new Promise((done) => {
+      const [cmd, ...args] = command;
+      const child = spawn2(cmd, args, {
+        cwd,
+        stdio: [interactive ? "inherit" : "ignore", 2, 2],
+        shell: process.platform === "win32"
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        done("timeout");
+      }, timeoutMs);
+      child.on("error", () => {
+        clearTimeout(timer);
+        done(127);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        done(code ?? 1);
+      });
+    }),
+    prompt: async (question) => {
+      const rl = createInterface4({ input: process.stdin, output: process.stderr });
+      try {
+        return await rl.question(question);
+      } finally {
+        rl.close();
+      }
+    },
+    print: (text2) => process.stdout.write(`${text2}
+`),
+    warn: (text2) => process.stderr.write(`${text2}
+`),
+    interactive: !!process.stdin.isTTY && !!process.stdout.isTTY && !/^(1|true)$/i.test(process.env.CI ?? ""),
+    cwd: process.cwd(),
+    userAgent: process.env.npm_config_user_agent
+  };
+}
+async function apply(actions, report, io, interactive) {
+  const why = (code, ms) => code === "timeout" ? `timed out after ${ms / 6e4} min` : `exit code ${code}`;
+  for (const a of actions) {
+    switch (a.kind) {
+      case "install": {
+        const code = await io.exec(a.command, a.cwd, false, INSTALL_TIMEOUT_MS);
+        report.install.status = code === 0 ? "installed" : "failed";
+        if (code !== 0) {
+          report.ok = false;
+          report.install.error = why(code, INSTALL_TIMEOUT_MS);
+          io.warn(`Install failed (${a.command.join(" ")}): ${report.install.error}`);
+        }
+        break;
+      }
+      case "skill": {
+        const code = await io.exec(a.command, a.cwd, interactive, SKILL_TIMEOUT_MS);
+        report.skill.status = code === 0 ? "added" : "failed";
+        if (code !== 0) {
+          report.skill.error = why(code, SKILL_TIMEOUT_MS);
+          io.warn(`Adding the skill failed (${report.skill.error}); add it later with ${report.skill.command}`);
+        }
+        break;
+      }
+      case "write":
+        io.write(a.path, a.content);
+        break;
+      case "patch": {
+        const result = a.patch(io.fs.read(a.path) ?? "");
+        if ("text" in result) io.write(a.path, result.text);
+        break;
+      }
+      case "append": {
+        const text2 = io.fs.read(a.path) ?? "";
+        io.append(a.path, `${text2.endsWith("\n") || !text2 ? "" : "\n"}${a.line}
+`);
+        break;
+      }
+    }
+  }
+}
+var describe = (a, dir) => {
+  const rel = (p) => relative6(dir, p) || ".";
+  switch (a.kind) {
+    case "install":
+      return `install   ${a.command.join(" ")}`;
+    case "skill":
+      return `skill     ${a.command.join(" ")}  (in ${a.cwd})`;
+    case "write":
+      return `write     ${rel(a.path)}`;
+    case "patch":
+      return `patch     ${rel(a.path)}`;
+    case "append":
+      return `append    ${rel(a.path)}: ${a.line}`;
+  }
+};
+function formatReport(r, actions) {
+  const L = [];
+  const detected = r.app.detected.length ? ` (${r.app.detected.join(", ")})` : "";
+  L.push(
+    `agent-bridge init ${r.version}${r.dryRun ? " --dry-run: nothing changed" : ""}`,
+    `App "${r.app.name}"${detected}, ${r.app.packageManager}`,
+    ""
+  );
+  if (r.dryRun) {
+    L.push("Would run:", ...actions.map((a) => `  ${describe(a, r.app.dir)}`), "");
+    for (const a of actions)
+      if (a.kind === "write")
+        L.push(`--- ${relative6(r.app.dir, a.path)}`, a.content.trimEnd(), "");
+  }
+  L.push("Files");
+  for (const f of r.files)
+    L.push(`  ${f.status.padEnd(9)} ${f.path}${f.note ? `: ${f.note}` : ""}`);
+  L.push(
+    "",
+    `Install: ${r.install.status} (${r.install.command})`,
+    `Skill:   ${r.skill.status} (${r.skill.command})`,
+    "         In Claude Code, install it as a plugin instead:",
+    ...r.skill.plugin.map((l) => `           ${l}`)
+  );
+  if (r.existing.length)
+    L.push("", `Already uses the bridge: ${r.existing.join(", ")}`);
+  if (r.missing.length)
+    L.push("", `Detected but not wired in the bridge file: ${r.missing.join(", ")} (see ${DOCS}/adapters.md)`);
+  if (r.commented.length) {
+    L.push("", "Left as comments in the bridge file:");
+    for (const c of r.commented)
+      L.push(`  ${c.adapter}${c.items.length ? `: ${c.items.join(", ")}` : ""}. Why: ${c.why}`);
+  }
+  if (r.todos.length) L.push("", "TODO:", ...r.todos.map((t) => `  ${t}`));
+  const n = r.choices.network;
+  L.push("");
+  if (n.enabled) L.push("Network tools: on (net.*).");
+  else {
+    const how = [n.flag && `rerun with ${n.flag}`, n.lines && "add these lines"].filter(Boolean).join(", or ");
+    L.push(`Network tools: off. ${n.open ? "Open choice: " : ""}${n.why}. To wire them, ${how}:`);
+    L.push(...(n.lines ?? []).map((l) => `  ${l}`));
+  }
+  if (n.note) L.push(n.note);
+  L.push(
+    "",
+    r.mount.mounted ? `Mounted: yes (from ${r.mount.file}).` : `Mounted: no. ${r.mount.note}`
+  );
+  if (!r.mount.mounted && !r.existing.length)
+    L.push(...r.mount.snippet.split("\n").map((l) => `  ${l}`));
+  L.push("", `First run${r.runFrom === "." ? "" : ` (from ${r.runFrom})`}:`);
+  r.next.forEach(
+    (s, i) => L.push(`  ${i + 1}. ${s.step}${s.command ? `
+       ${s.command}` : ""}`)
+  );
+  L.push("", "Prompt for your agent:", `  ${r.prompt}`);
+  return L.join("\n");
+}
+async function runInit(args, io) {
+  const dir = resolve2(io.cwd, args.dir ?? ".");
+  const fail = (error) => {
+    if (args.json) io.print(JSON.stringify({ ok: false, ...error }, null, 2));
+    else io.warn(error.error);
+    return 1;
+  };
+  let d = detect(dir, io.fs, { userAgent: io.userAgent });
+  if ("error" in d) return fail(d);
+  const interactive = io.interactive && !args.json && !args.yes;
+  const options = (network2) => ({
+    version,
+    out: args.out === void 0 ? void 0 : resolve2(io.cwd, args.out),
+    force: args.force,
+    install: args.install !== false,
+    skill: args.skill !== false,
+    network: network2,
+    skillYes: !interactive
+  });
+  const planFor = (det, network2, install2 = true) => plan(det, scan(dir, io.fs), io.fs, { ...options(network2), install: install2 && args.install !== false }, io.cwd);
+  let network = { enabled: args.network ?? false, chosen: args.network !== void 0 };
+  const first = planFor(d, network);
+  if ("error" in first) return fail(first);
+  if (args.dryRun) {
+    const { actions: actions2, report: report2 } = first;
+    report2.dryRun = true;
+    if (args.json) {
+      const contents = Object.fromEntries(
+        actions2.flatMap((a) => a.kind === "write" ? [[relative6(dir, a.path), a.content]] : [])
+      );
+      io.print(JSON.stringify({ ...report2, contents }, null, 2));
+    } else io.print(formatReport(report2, actions2));
+    return 0;
+  }
+  const bridge = posix3(relative6(dir, bridgePath(d, options(network).out)));
+  const writesBridge = first.report.files.some((f) => f.path === bridge && f.status === "written");
+  if (!network.chosen && interactive && writesBridge) {
+    const answer = await io.prompt(`${NETWORK_PROMPT} [y/N] `);
+    network = { enabled: /^y(es)?$/i.test(answer.trim()), chosen: true };
+  }
+  const install = first.actions.find((a) => a.kind === "install");
+  const installReport = first.report.install;
+  if (install) {
+    await apply([install], first.report, io, interactive);
+    const after = detect(dir, io.fs, { userAgent: io.userAgent });
+    if (!("error" in after)) d = after;
+  }
+  const p = planFor(d, network, false);
+  if ("error" in p) return fail(p);
+  const { actions, report } = p;
+  if (install) {
+    report.install = installReport;
+    report.ok = first.report.ok;
+  }
+  await apply(actions, report, io, interactive);
+  io.print(args.json ? JSON.stringify(report, null, 2) : formatReport(report, actions));
+  return report.ok ? 0 : 1;
+}
+
+// src/mcp/server.ts
+import { createInterface as createInterface5 } from "readline";
+var SUPPORTED = ["2025-06-18", "2024-11-05"];
+var STATUS_TOOL = "agent_bridge_status";
+var MAX_NAME = 64;
+function mcpNames(tools, reserved = []) {
+  const out = /* @__PURE__ */ new Map();
+  const taken = new Set(reserved);
+  const sorted = [...tools].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  for (const { name } of sorted) {
+    const base = name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, MAX_NAME - 4) || "_";
+    let mcp = base;
+    for (let n = 2; taken.has(mcp); n++) mcp = `${base}_${n}`;
+    taken.add(mcp);
+    out.set(mcp, name);
+  }
+  return out;
+}
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    args: {
+      type: "array",
+      items: {},
+      description: "The tool's arguments, in order (each any JSON value). Leave out for none."
+    },
+    full: {
+      type: "boolean",
+      description: `Return a result over ${OUTPUT_LIMIT_BYTES / 1024} KB whole instead of a summary of its size and shape.`
+    }
+  },
+  additionalProperties: false
+};
+var text = (t) => ({ type: "text", text: t });
+var logBlock = (logs) => logs.length ? [text(`App errors:
+${logs.map(logLine).join("\n")}`)] : [];
+var IMAGE_MAGIC = [
+  ["iVBORw0KGgo", "image/png"],
+  ["/9j/", "image/jpeg"],
+  ["UklGR", "image/webp"],
+  ["R0lGOD", "image/gif"]
+];
+function withImage(tool, value) {
+  if (tool !== "screen.capture" || !value || typeof value !== "object") return null;
+  const { base64, ...rest } = value;
+  if (typeof base64 !== "string" || !base64) return null;
+  const url = /^data:([^;,]*)[^,]*,/.exec(base64);
+  const data = url ? base64.slice(url[0].length) : base64;
+  const mimeType = IMAGE_MAGIC.find(([magic]) => data.startsWith(magic))?.[1];
+  if (!mimeType) return null;
+  const image = { type: "image", data, mimeType };
+  return Object.keys(rest).length ? [image, text(JSON.stringify(rest, null, 2))] : [image];
+}
+async function resultContent(tool, value, full) {
+  const image = withImage(tool, value);
+  if (image) return image;
+  if (isSnapshotText(tool, value) && (full || Buffer.byteLength(value) <= OUTPUT_LIMIT_BYTES)) return [text(value)];
+  const shaped = await shapedResult(value, { full });
+  const json = JSON.stringify(shaped, null, 2) ?? "null";
+  if (!full && shaped && typeof shaped === "object" && shaped.resultTooLarge)
+    return [
+      text(
+        JSON.stringify(
+          {
+            ...shaped,
+            hint: "Not returned: the result is large. Call again with full: true to get it whole, or narrow the call (a path, a filter, a smaller page)."
+          },
+          null,
+          2
+        )
+      )
+    ];
+  return [text(json)];
+}
+var message2 = (error) => error instanceof Error ? error.message : String(error);
+function startMcpServer(options) {
+  const pollMs = options.pollMs ?? 5e3;
+  let bridge = null;
+  let opening = null;
+  let tools = [];
+  let names2 = /* @__PURE__ */ new Map();
+  let signature = "";
+  let listed = null;
+  let announced = "";
+  let initialized = false;
+  let closed = false;
+  let inflight = 0;
+  let lastError;
+  const send = (message3) => {
+    if (!closed) options.output.write(encodeLine(message3));
+  };
+  const reply = (id, result) => send({ jsonrpc: "2.0", id, result });
+  const fail = (id, code, error) => send({ jsonrpc: "2.0", id, error: { code, message: error } });
+  const noteError = (error) => {
+    const now = message2(error);
+    if (now === lastError) return;
+    lastError = now;
+    options.log?.(`agent-bridge mcp: not connected: ${now}`);
+  };
+  const announce = () => {
+    if (!initialized || listed === null || signature === listed || signature === announced)
+      return;
+    announced = signature;
+    send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+  };
+  const adopt = (next) => {
+    const list2 = next.tools();
+    const sig = JSON.stringify([next.device.deviceId, list2]);
+    bridge = next;
+    lastError = void 0;
+    if (sig !== signature) {
+      signature = sig;
+      names2 = mcpNames(list2, [STATUS_TOOL]);
+      tools = [...names2].map(([mcp, name]) => ({
+        name,
+        mcp,
+        description: list2.find((t) => t.name === name)?.description
+      }));
+      announce();
+    }
+  };
+  const ensure = () => {
+    if (bridge) return Promise.resolve(bridge);
+    opening ??= options.connect().then((next) => {
+      adopt(next);
+      return next;
+    }).catch((error) => {
+      noteError(error);
+      throw error;
+    }).finally(() => {
+      opening = null;
+    });
+    return opening;
+  };
+  const drop = () => {
+    const old = bridge;
+    bridge = null;
+    try {
+      old?.close();
+    } catch {
+    }
+  };
+  let polling = false;
+  const poll = async () => {
+    if (polling || inflight || closed) return;
+    polling = true;
+    try {
+      if (!bridge) {
+        await ensure();
+        return;
+      }
+      const next = await options.connect();
+      if (inflight || closed) return next.close();
+      const old = bridge;
+      adopt(next);
+      if (old !== next) old.close();
+    } catch (error) {
+      noteError(error);
+    } finally {
+      polling = false;
+    }
+  };
+  const timer = pollMs > 0 ? setInterval(() => void poll(), pollMs) : void 0;
+  timer?.unref?.();
+  const statusTool = {
+    name: STATUS_TOOL,
+    title: "agent-bridge status",
+    description: "Whether this server is connected to the app, which app and session, how many tools it has, and why the last connect failed. Works with no app connected.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  };
+  const listTools = () => {
+    listed = signature;
+    return {
+      tools: [
+        ...tools.map((t) => ({
+          name: t.mcp,
+          title: t.name,
+          description: t.description ?? t.name,
+          inputSchema: INPUT_SCHEMA
+        })),
+        statusTool
+      ]
+    };
+  };
+  const statusResult = async () => {
+    await ensure().catch(() => {
+    });
+    const json = {
+      connected: !!bridge,
+      ...bridge && {
+        app: { name: bridge.device.name, deviceId: bridge.device.deviceId },
+        tools: tools.length
+      },
+      ...options.sessionName?.() && { session: options.sessionName() },
+      ...lastError && { lastError }
+    };
+    return { content: [text(JSON.stringify(json, null, 2))] };
+  };
+  const callTool = async (params) => {
+    const failure = (...content) => ({ isError: true, content });
+    if (params.name === STATUS_TOOL) return statusResult();
+    const notice = options.takeNotice?.();
+    if (notice) {
+      drop();
+      return failure(text(notice));
+    }
+    inflight++;
+    try {
+      let b;
+      try {
+        b = await ensure();
+      } catch (error) {
+        return failure(
+          text(
+            `Not connected to the app: ${message2(error)}
+Start the app and call again; the server reconnects on the next call. The ${STATUS_TOOL} tool says what state it is in.`
+          )
+        );
+      }
+      const tool = typeof params.name === "string" ? names2.get(params.name) : void 0;
+      if (!tool) return null;
+      const input = params.arguments ?? {};
+      let args = input.args ?? [];
+      if (typeof args === "string") {
+        try {
+          args = JSON.parse(args);
+        } catch {
+        }
+      }
+      if (!Array.isArray(args))
+        return failure(text("`args` must be an array of the tool's arguments."));
+      try {
+        const timed = await b.timed(tool, ...withCompactSnapshot(tool, args));
+        const content = await resultContent(tool, timed.value, input.full === true);
+        content.push(...logBlock(timed.logs));
+        if (timed.notice) content.push(text(`Warning: ${timed.notice}`));
+        return { content };
+      } catch (error) {
+        if (error instanceof AgentBridgeCallError)
+          return failure(text(error.message), ...logBlock(error.logs));
+        if (error instanceof SessionLinkError) {
+          drop();
+          return failure(
+            text(
+              `${error.message}
+The call may or may not have run; check before repeating one that changes state. The server reconnects on the next call.`
+            )
+          );
+        }
+        if (/^No reply to "/.test(message2(error))) drop();
+        return failure(text(message2(error)));
+      }
+    } finally {
+      inflight--;
+    }
+  };
+  const active = /* @__PURE__ */ new Map();
+  const dispatch = async (method, params, id, isRequest) => {
+    switch (method) {
+      case "initialize": {
+        if (!isRequest) return null;
+        const asked = params?.protocolVersion;
+        void ensure().catch(() => {
+        });
+        return {
+          result: {
+            protocolVersion: SUPPORTED.includes(asked) ? asked : SUPPORTED[0],
+            capabilities: { tools: { listChanged: true } },
+            serverInfo: { name: "agent-bridge", version: options.version ?? "0.0.0" },
+            instructions: `Tools of the connected React Native app. Each takes \`args\`, an array of the tool's arguments. Results over 32 KB come back as a summary unless \`full\` is true. If the list is empty or calls fail, call ${STATUS_TOOL}.`
+          }
+        };
+      }
+      case "notifications/initialized":
+        initialized = true;
+        return null;
+      case "ping":
+        return isRequest ? { result: {} } : null;
+      case "tools/list":
+        if (!isRequest) return null;
+        await Promise.race([
+          ensure().catch(() => {
+          }),
+          new Promise((r) => {
+            const t = setTimeout(r, 5e3);
+            if (typeof t === "object") t.unref();
+          })
+        ]);
+        return { result: listTools() };
+      case "tools/call": {
+        if (!isRequest) return null;
+        const result = await callTool(params ?? {});
+        return result ? { result } : { code: -32602, error: `Unknown tool: ${String(params?.name)}` };
+      }
+      default:
+        return isRequest ? { code: -32601, error: `Method not found: ${method}` } : null;
+    }
+  };
+  const handle = async (raw) => {
+    let req;
+    try {
+      req = JSON.parse(raw);
+    } catch {
+      return void fail(null, -32700, "Parse error");
+    }
+    if (!req || typeof req !== "object" || Array.isArray(req))
+      return void fail(null, -32600, "Invalid request");
+    if (req.method === void 0 && req.id !== void 0) return;
+    if (typeof req.method !== "string")
+      return void fail(req.id ?? null, -32600, "Invalid request");
+    const { id, method, params } = req;
+    const isRequest = id !== void 0 && id !== null;
+    if (method === "notifications/cancelled") {
+      active.get(JSON.stringify(params?.requestId))?.();
+      return;
+    }
+    const key = JSON.stringify(id);
+    let cancel = () => {
+    };
+    const cancelled = new Promise((r) => {
+      cancel = () => r("cancelled");
+    });
+    if (isRequest) active.set(key, cancel);
+    try {
+      const outcome = await Promise.race([dispatch(method, params, id, isRequest), cancelled]);
+      if (outcome === "cancelled" || !outcome) return;
+      if ("result" in outcome) reply(id, outcome.result);
+      else fail(id, outcome.code, outcome.error);
+    } catch (error) {
+      if (isRequest) fail(id, -32603, message2(error));
+    } finally {
+      if (isRequest) active.delete(key);
+    }
+  };
+  const lines = createInterface5({ input: options.input });
+  const pending = /* @__PURE__ */ new Set();
+  lines.on("line", (line) => {
+    if (!line.trim()) return;
+    const p = handle(line).finally(() => pending.delete(p));
+    pending.add(p);
+  });
+  const done = new Promise((resolve4) => {
+    lines.once("close", () => {
+      void Promise.allSettled([...pending]).then(() => {
+        close();
+        resolve4();
+      });
+    });
+  });
+  function close() {
+    if (closed) return;
+    closed = true;
+    if (timer) clearInterval(timer);
+    lines.close();
+    drop();
+  }
+  return { done, close };
+}
+
+// src/mcp/run.ts
+function createConnector(flags, options) {
+  let daemon;
+  let pinned;
+  let ending = false;
+  let notice;
+  const ownName = `mcp-${process.pid}`;
+  const stopped = (name) => {
+    notice = `The session "${name}" this server was using stopped (session stop, or its idle time ran out). Stopping runs bridge.restore, so state changed through it was most likely undone. This call did not run; call again and the server uses a new session.`;
+  };
+  const connectBridge = async () => {
+    if (flags["no-session"]) return connect(options);
+    const timeoutMs = options.timeoutMs;
+    if (daemon) return connectSession({ name: daemon.state.name, timeoutMs });
+    if (pinned) {
+      if (readSession(pinned)) return connectSession({ name: pinned, timeoutMs });
+      stopped(pinned);
+      pinned = void 0;
+    }
+    const existing = sessionFor(flags, (s) => s.name.startsWith("mcp-") && s.name !== ownName);
+    if (existing) {
+      pinned = existing.name;
+      return connectSession({ name: pinned, timeoutMs });
+    }
+    const started = await runSessionDaemon({
+      name: ownName,
+      metro: options.metro,
+      device: options.device,
+      transport: options.transport,
+      idleMs: 0,
+      timeoutMs
+    });
+    daemon = started;
+    void started.done.then(() => {
+      if (daemon !== started) return;
+      daemon = void 0;
+      if (!ending) stopped(started.state.name);
+    });
+    return connectSession({ name: started.state.name, timeoutMs });
+  };
+  return {
+    connect: connectBridge,
+    takeNotice: () => {
+      const n = notice;
+      notice = void 0;
+      return n;
+    },
+    stop: async () => {
+      ending = true;
+      return daemon?.stop(flags.keep).catch(() => null);
+    },
+    sessionName: () => daemon?.state.name ?? pinned
+  };
+}
+async function mcpMain(flags, options, version2) {
+  const connector = createConnector(flags, options);
+  const server = startMcpServer({
+    input: process.stdin,
+    output: process.stdout,
+    connect: connector.connect,
+    takeNotice: connector.takeNotice,
+    sessionName: connector.sessionName,
+    log: (line) => console.error(line),
+    pollMs: flags["no-session"] ? 0 : void 0,
+    version: version2
+  });
+  const quit = () => server.close();
+  for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"])
+    process.on(signal, quit);
+  await server.done;
+  const restore = await connector.stop();
+  if (restore && !restore.ok) console.error(`bridge.restore failed: ${restore.error}`);
+}
+
 // src/cli.ts
 var HELP2 = `agent-bridge: drive a running React Native app from an agent
 
 Usage
+  agent-bridge init                       Set up this app: install, write the dev-only bridge
+                                          file and a smoke flow, print the line to mount it
   agent-bridge devices                    Apps connected to Metro
   agent-bridge tools                      Tools the app exposes
   agent-bridge call <tool> [args]         Call a tool. args: a JSON array, or one JSON value
@@ -1191,10 +3350,15 @@ Usage
   agent-bridge call --batch               Read \`tool args\` lines from stdin (args may be @file); one JSON line per call, one connection
   agent-bridge repl                       Interactive prompt (history, tab completion, .help). With
                                           stdin not a terminal it behaves like call --batch
-  agent-bridge run <flow.mjs|.ts>         Run a flow: export default async ({ step, call }) => {}
-                                          export const scenario = 'signedIn' applies it first
-                                          and runs bridge.restore after, even on failure
+  agent-bridge run <flow|dir|glob>...     Run flows in order on one connection: export default
+                                          async ({ step, call, expect }) => {}. A directory means
+                                          its *.flow.mjs. Each flow ends with bridge.restore, even
+                                          on failure (--keep skips it); a scenario export is
+                                          applied first. Exits 1 if any flow failed
   agent-bridge scenarios                  Scenarios the app defines (scenario.apply applies one)
+  agent-bridge mcp                        Serve the app's tools as an MCP server on stdio (add to your agent's MCP
+                                          config). Uses this project's session, or starts one and
+                                          runs bridge.restore on exit (--keep: don't)
   agent-bridge assert-absent <files...>   Fail if a release bundle contains the bridge
 
 Sessions: one connection for all of an agent's calls
@@ -1210,15 +3374,33 @@ Options
   --device <text>        Pick an app when several are connected
   --transport <name>     auto (default), expo or cdp
   --timeout <ms>         Per-call timeout (default 10000)
-  --out <file>           call: write the result to a file; print its size and shape
+  --out <file>           call: write the result to a file and print its size and shape
                          (--batch: a directory, one <n>-<tool>.json per call)
+                         run: the report file (with --reporter json|junit)
   --stop-on-error        call --batch: stop after the first failed call
   --full                 call: print results over 32 KB instead of a summary
-  --strict               run: exit non-zero if the app logged an error
+  --json                 call screen.snapshot: print JSON with rects, not one line per element (call --batch and repl stay JSON)
+                         (--out also writes JSON)
+  --strict               run: fail a flow if the app logged an error
+  --bail                 run: stop at the first failed flow
+  --grep <text>          run: only flows whose name or path (relative to here) contains text
+  --keep                 run: no bridge.restore after each flow (session stop: keep the session)
+  --reporter <name>      run: text (default), json or junit; step lines and flow output go to stderr
   --scenario <name>      run: also apply this scenario (repeatable). Options as
                          JSON after "=": --scenario 'signedIn={"user":{"name":"Ada"}}'
   --session <name>       Use this session (env AGENT_BRIDGE_SESSION)
   --no-session           Connect directly even if a session is running
+
+init options
+  --dir <path>           The app (default: the current directory)
+  --out <file>           Bridge file path, inside the app (default src/dev/agent-bridge.tsx, or dev/)
+  --dry-run              Print what it would do and the files; change nothing
+  --force                Regenerate files init wrote that are still unedited (edited ones get a .new copy)
+  --no-install           Print the install command instead of running it
+  --no-skill             Don't run \`npx skills add avas-app/agent-bridge\`
+  --network, --no-network  Wire networkTools into a new bridge file (asked in a terminal; off otherwise)
+  --json                 Machine-readable report on stdout; never prompts
+  --yes, -y              Never prompt
 `;
 var failedLogs = (error) => error instanceof AgentBridgeCallError ? error.logs : [];
 async function readStdin() {
@@ -1245,12 +3427,23 @@ async function main() {
       batch: { type: "boolean" },
       "stop-on-error": { type: "boolean" },
       scenario: { type: "string", multiple: true },
+      bail: { type: "boolean" },
+      grep: { type: "string" },
+      reporter: { type: "string" },
       name: { type: "string" },
       idle: { type: "string" },
       keep: { type: "boolean" },
       "dry-run": { type: "boolean" },
       session: { type: "string" },
       "no-session": { type: "boolean" },
+      dir: { type: "string" },
+      force: { type: "boolean" },
+      "no-install": { type: "boolean" },
+      "no-skill": { type: "boolean" },
+      network: { type: "boolean" },
+      "no-network": { type: "boolean" },
+      json: { type: "boolean" },
+      yes: { type: "boolean", short: "y" },
       help: { type: "boolean", short: "h" }
     }
   });
@@ -1290,9 +3483,30 @@ async function main() {
     if (failed) process.exitCode = 1;
   };
   switch (command) {
+    case "init":
+      process.exitCode = await runInit(
+        {
+          dir: values.dir,
+          out: values.out,
+          dryRun: values["dry-run"],
+          force: values.force,
+          install: !values["no-install"],
+          skill: !values["no-skill"],
+          network: values.network ? true : values["no-network"] ? false : void 0,
+          json: values.json,
+          yes: values.yes
+        },
+        nodeIo()
+      );
+      return;
     case "devices": {
       const devices = await listDevices(options);
-      if (!devices.length) console.log("No apps connected.");
+      if (!devices.length) {
+        const metro = metroHost(options.metro);
+        await assertListening(metro);
+        console.log("No apps connected.");
+        console.error(await noAppHint(metro));
+      }
       for (const d of devices) {
         const extra = d.tools !== void 0 ? `  ${d.tools} tools  ${d.deviceId}` : "";
         console.log(`${d.transport.padEnd(5)} ${d.name}${extra}`);
@@ -1321,12 +3535,12 @@ async function main() {
         (path) => path === "-" ? stdin : readArgFile(path)
       );
       return withBridge(async (bridge) => {
-        const { value, ms, appMs, logs, notice } = await bridge.timed(tool, ...args).catch((error) => {
+        const { value, ms, appMs, logs, notice } = await bridge.timed(tool, ...withCompactSnapshot(tool, args, values.json || !!values.out)).catch((error) => {
           for (const e of failedLogs(error)) console.error(logLine(e));
           throw error;
         });
         console.log(
-          await renderResult(value, { out: values.out, full: values.full })
+          isSnapshotText(tool, value) ? await renderText(value, { out: values.out, full: values.full }) : await renderResult(value, { out: values.out, full: values.full })
         );
         for (const e of logs) console.error(logLine(e));
         if (notice) console.error(`Warning: ${notice}`);
@@ -1351,18 +3565,65 @@ async function main() {
         });
       });
     case "run": {
-      const [file] = rest;
-      if (!file) throw new Error("Usage: agent-bridge run <flow file>");
-      const flow = await import(pathToFileURL(resolve(file)).href);
-      flowScenarios(flow);
+      if (!rest.length)
+        throw new Error("Usage: agent-bridge run <flow file | directory | glob>...");
+      const machine = checkRunFlags({ reporter: values.reporter, out: values.out });
+      const reporter = values.reporter ?? "text";
+      const files = await resolveFlowFiles(rest);
+      const { entries: loaded, failures } = await loadFlows(files);
+      const entries = selectFlows(loaded, values.grep);
+      if (!entries.length && !failures.length) {
+        if (!machine) throw new Error(`--grep ${values.grep}: no flow matches`);
+        failures.push(failedRun("", `--grep ${values.grep}`, "no flow matches"));
+      }
+      if (machine && values.out) await mkdir3(dirname7(values.out), { recursive: true });
       const extra = (values.scenario ?? []).map(parseScenarioFlag);
-      return withBridge(async (bridge) => {
-        const { errors, restoreErrors } = await runFlow(bridge, flow, {
-          scenarios: extra
-        });
-        if (values.strict && errors || restoreErrors.length)
-          process.exitCode = 1;
+      const finish = async (runs2) => {
+        const failed = runs2.filter((r) => r.status === "failed");
+        if (machine) {
+          const doc = reporter === "json" ? renderJson(runs2) : renderJunit(runs2);
+          if (values.out) await writeReport(values.out, doc);
+          else console.log(doc);
+        }
+        const log = machine ? console.error : console.log;
+        if (runs2.length > 1 || machine) {
+          log("");
+          for (const r of runs2)
+            log(
+              `${r.status === "passed" ? "PASS" : r.status === "failed" ? "FAIL" : "SKIP"} ${r.name}${r.status === "skipped" ? "" : ` (${(r.ms / 1e3).toFixed(1)} s)`}${r.error ? `: ${r.error}` : ""}`
+            );
+          const count = (st) => runs2.filter((r) => r.status === st).length;
+          log(
+            `${count("passed")} passed, ${failed.length} failed${count("skipped") ? `, ${count("skipped")} skipped` : ""}`
+          );
+        }
+        if (failed.length) process.exitCode = 1;
+      };
+      const execute = (bridge) => runFlows(bridge, entries, {
+        scenarios: extra,
+        strict: values.strict,
+        bail: values.bail,
+        keep: values.keep,
+        single: entries.length === 1 && !machine,
+        print: machine ? (line) => console.error(line) : void 0
       });
+      let runs;
+      if (!entries.length) runs = [];
+      else {
+        try {
+          const run = (bridge) => machine ? logToStderr(() => execute(bridge)) : execute(bridge);
+          let result = [];
+          await withBridge(async (bridge) => {
+            result = await run(bridge);
+          });
+          runs = result;
+        } catch (error) {
+          if (!machine) throw error;
+          const why = error instanceof Error ? error.message : String(error);
+          runs = entries.map((e) => failedRun(e.file, e.name, why));
+        }
+      }
+      return finish([...failures, ...runs]);
     }
     case "scenarios":
       return withBridge(async (bridge) => {
@@ -1382,6 +3643,12 @@ async function main() {
             console.log(`  ${"".padEnd(20)} options: ${JSON.stringify(s.options)}`);
         }
       });
+    case "mcp":
+      return mcpMain(
+        values,
+        options,
+        createRequire(import.meta.url)("../package.json").version
+      );
     case "session":
       return sessionCommand(rest[0], values);
     case DAEMON_COMMAND: