@avasapp/agent-bridge 0.5.0 → 0.6.0

package/dist/cli.js

@@ -2,7 +2,9 @@
 import {
   AgentBridgeCallError,
   RUNTIME_MARKER,
+  SessionLinkError,
   assertListening,
+  callTimeout,
   checkName,
   connect,
   connectSession,
@@ -24,27 +26,201 @@ import {
   projectRoot,
   readSession,
   removeSessionFiles,
-  runFlow,
+  runFlows,
   sessionFiles,
   sessionRequest,
   stateDir,
   writePrivate
-} from "./chunk-3QIG7A5W.js";
+} from "./chunk-Y6QFU5ON.js";
 
 // src/cli.ts
-import { readFile } from "fs/promises";
-import { resolve as resolve2 } 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) {
@@ -76,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);
   }
@@ -88,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);
   }
@@ -96,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) {
@@ -123,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})`
@@ -149,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);
@@ -292,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`
     );
@@ -309,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;
@@ -326,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
@@ -355,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"
@@ -413,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
@@ -423,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 {
@@ -435,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);
@@ -590,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((resolve3) => {
+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);
-    resolve3();
+    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();
@@ -612,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
   });
@@ -669,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 = [];
@@ -691,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);
@@ -712,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);
@@ -721,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);
@@ -733,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 {
@@ -755,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;
@@ -773,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();
@@ -791,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;
@@ -827,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);
@@ -847,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();
@@ -864,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();
@@ -889,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--;
@@ -941,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);
@@ -958,11 +1446,11 @@ async function runSessionDaemon(options) {
   });
   if (process.platform !== "win32") rmSync(files.socket, { force: true });
   try {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       server.once("error", reject);
       server.listen(files.socket, () => {
         server.off("error", reject);
-        resolve3();
+        resolve4();
       });
     });
   } catch (error) {
@@ -989,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) => {
@@ -1049,7 +1538,7 @@ async function start(flags) {
     [...process.execArgv, process.argv[1], ...args],
     { detached: true, stdio: "ignore", windowsHide: true }
   );
-  const state = await new Promise((resolve3, reject) => {
+  const state = await new Promise((resolve4, reject) => {
     const deadline = Date.now() + 3e4;
     let exited = false;
     child.once("exit", () => {
@@ -1060,13 +1549,13 @@ async function start(flags) {
       const failed = existsSync(files.error);
       if (ready && ready.pid === child.pid) {
         clearInterval(tick);
-        resolve3(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);
   });
@@ -1192,17 +1681,17 @@ import {
   readFileSync as readFileSync4,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname5, relative as relative4, resolve, sep as sep2 } from "path";
+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.5.0";
+var version = "0.6.0";
 
 // src/init/detect.ts
-import { dirname as dirname3, join as join4, relative } from "path";
+import { dirname as dirname4, join as join6, relative as relative3 } from "path";
 
 // src/init/package-manager.ts
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 var LOCKFILES = [
   ["bun.lock", "bun"],
   ["bun.lockb", "bun"],
@@ -1216,12 +1705,12 @@ var fromName = (value) => {
 };
 function detectPackageManager(dir, root, fs, userAgent = "") {
   for (const d of [dir, root]) {
-    const pm = fromName(fs.readJson(join3(d, "package.json"))?.packageManager);
+    const pm = fromName(fs.readJson(join5(d, "package.json"))?.packageManager);
     if (pm) return pm;
   }
-  for (let d = dir; ; d = dirname2(d)) {
-    for (const [file, pm] of LOCKFILES) if (fs.exists(join3(d, file))) return pm;
-    if (d === root || dirname2(d) === d) break;
+  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";
 }
@@ -1258,7 +1747,12 @@ var LIBRARIES = {
   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",
@@ -1270,18 +1764,18 @@ var depsOf = (pkg) => ({
   ...pkg?.devDependencies,
   ...pkg?.dependencies
 });
-var isApp = (dir, fs) => !!fs.readJson(join4(dir, "package.json"))?.dependencies?.["react-native"] || ["app.json", "app.config.js", "app.config.ts", "ios", "android"].some((f) => fs.exists(join4(dir, f)));
-var isWorkspaceRoot = (dir, fs) => !!fs.readJson(join4(dir, "package.json"))?.workspaces || fs.exists(join4(dir, "pnpm-workspace.yaml"));
+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 = dirname3(d)) {
+  for (let d = dir; ; d = dirname4(d)) {
     if (test(d)) return d;
-    if (fs.exists(join4(d, ".git")) || dirname3(d) === d) return void 0;
+    if (fs.exists(join6(d, ".git")) || dirname4(d) === d) return void 0;
   }
 }
 function workspacePatterns(root, fs) {
-  const ws = fs.readJson(join4(root, "package.json"))?.workspaces;
+  const ws = fs.readJson(join6(root, "package.json"))?.workspaces;
   const fromPkg = Array.isArray(ws) ? ws : ws?.packages ?? [];
-  const yaml = fs.read(join4(root, "pnpm-workspace.yaml")) ?? "";
+  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]
@@ -1292,40 +1786,40 @@ function workspacePatterns(root, fs) {
 }
 function expandWorkspaces(root, patterns, fs) {
   const found = /* @__PURE__ */ new Set();
-  const walk = (dir, segments, depth) => {
+  const walk2 = (dir, segments, depth) => {
     if (!segments.length) {
-      if (fs.exists(join4(dir, "package.json"))) found.add(dir);
+      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 === "**") {
-      walk(dir, rest, depth);
+      walk2(dir, rest, depth);
       if (depth < 4)
-        for (const c of children()) walk(join4(dir, c.name), segments, depth + 1);
+        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)) walk(join4(dir, c.name), rest, depth);
+        if (re.test(c.name)) walk2(join6(dir, c.name), rest, depth);
     } else {
-      walk(join4(dir, head), rest, depth);
+      walk2(join6(dir, head), rest, depth);
     }
   };
   for (const p of patterns)
-    walk(root, p.replace(/\/+$/, "").split("/").filter((s) => s && s !== "."), 0);
+    walk2(root, p.replace(/\/+$/, "").split("/").filter((s) => s && s !== "."), 0);
   return [...found].sort();
 }
-var firstExisting = (dir, fs, candidates) => candidates.find((c) => fs.exists(join4(dir, c)));
+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(join4(dir, "package.json"));
+  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) => relative(dir, d));
+      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
@@ -1336,11 +1830,11 @@ function detect(dir, fs, env = {}) {
     };
   }
   const root = findUp(dir, fs, (d) => isWorkspaceRoot(d, fs)) ?? dir;
-  const repoRoot = findUp(dir, fs, (d) => fs.exists(join4(d, ".git"))) ?? root;
+  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(join4(dir, "app.json"));
+  const appJson = fs.readJson(join6(dir, "app.json"));
   const appName = [appJson?.expo?.name, appJson?.name, pkg.name].find(
     (n) => typeof n === "string" && !!n
   ) ?? "app";
@@ -1350,15 +1844,15 @@ function detect(dir, fs, env = {}) {
     fs,
     has.expoRouter ? [...withExts("app/_layout"), ...withExts("src/app/_layout")] : [...withExts("App"), ...withExts("src/App")]
   );
-  const agentsFile = [.../* @__PURE__ */ new Set([dir, repoRoot])].flatMap((d) => [join4(d, "AGENTS.md"), join4(d, "CLAUDE.md")]).find((f) => fs.exists(f));
+  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 = dirname3(d)) {
-    const candidate = join4(d, "node_modules", ".bin", "agent-bridge");
+  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 || dirname3(d) === d) break;
+    if (d === repoRoot || dirname4(d) === d) break;
   }
   return {
     dir,
@@ -1369,7 +1863,7 @@ function detect(dir, fs, env = {}) {
     has,
     installed: !!deps[PACKAGE],
     typescript: !!tsconfig || has.typescript,
-    srcDir: fs.exists(join4(dir, "src")),
+    srcDir: fs.exists(join6(dir, "src")),
     rootFile,
     tsconfig,
     oxlint: firstExisting(dir, fs, [".oxlintrc.json"]),
@@ -1385,28 +1879,28 @@ function detect(dir, fs, env = {}) {
 }
 
 // src/init/plan.ts
-import { dirname as dirname4, isAbsolute, join as join5, relative as relative2, sep } from "path";
+import { dirname as dirname5, isAbsolute, join as join7, relative as relative4, sep } from "path";
 
 // src/init/jsonc.ts
-function strip(text) {
+function strip(text2) {
   let out = "";
   let i = 0;
-  while (i < text.length) {
-    const c = text[i];
+  while (i < text2.length) {
+    const c = text2[i];
     if (c === '"') {
       let j = i + 1;
-      while (j < text.length && text[j] !== '"') j += text[j] === "\\" ? 2 : 1;
-      out += text.slice(i, j + 1);
+      while (j < text2.length && text2[j] !== '"') j += text2[j] === "\\" ? 2 : 1;
+      out += text2.slice(i, j + 1);
       i = j + 1;
-    } else if (c === "/" && text[i + 1] === "/") {
-      const end = text.indexOf("\n", i);
-      const j = end === -1 ? text.length : end;
+    } 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 === "/" && text[i + 1] === "*") {
-      const end = text.indexOf("*/", i + 2);
-      const j = end === -1 ? text.length : end + 2;
-      out += text.slice(i, j).replace(/[^\n]/g, " ");
+    } 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;
@@ -1415,37 +1909,37 @@ function strip(text) {
   }
   return out.replace(/,(\s*[}\]])/g, " $1");
 }
-function parseJsonc(text) {
+function parseJsonc(text2) {
   try {
-    return JSON.parse(strip(text));
+    return JSON.parse(strip(text2));
   } catch {
     return void 0;
   }
 }
-function addToArray(text, key, value, initial = []) {
-  const json = parseJsonc(text);
+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(text);
+  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 = text.slice(at);
+    const after = text2.slice(at);
     const multiline = after.match(/^[ \t]*\n([ \t]*)/);
-    if (!current.length) return `${text.slice(0, at)}${item}${after}`;
-    if (multiline) return `${text.slice(0, at)}
+    if (!current.length) return `${text2.slice(0, at)}${item}${after}`;
+    if (multiline) return `${text2.slice(0, at)}
 ${multiline[1]}${item},${after}`;
-    return `${text.slice(0, at)}${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 = text.match(/^([ \t]+)"/m)?.[1] ?? "  ";
+  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 `${text.slice(0, end)}${comma}
-${indent}"${key}": [${list2}]${text.slice(end)}`;
+  return `${text2.slice(0, end)}${comma}
+${indent}"${key}": [${list2}]${text2.slice(end)}`;
 }
 
 // src/init/render.ts
@@ -1458,6 +1952,10 @@ var REALTIME = {
 };
 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";
@@ -1495,6 +1993,13 @@ function renderBridgeFile(o) {
   }
   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) {
@@ -1519,6 +2024,48 @@ function renderBridgeFile(o) {
       ...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(
@@ -1591,16 +2138,17 @@ function renderBridgeFile(o) {
     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) {
-    const params = o.ts ? "name: string, params?: object" : "name, params";
+  if (o.reactNavigation)
     L.push(
-      "      // React Navigation has no adapter. With your container ref",
-      "      // (createNavigationContainerRef from @react-navigation/native), tools like these work:",
-      `      // 'nav.navigate': (${params}) => navigationRef.navigate(name, params),`,
-      `      // 'nav.current': () => navigationRef.getCurrentRoute(),`
+      "      // 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(),`,
     "    },",
@@ -1621,12 +2169,11 @@ function renderSmokeFlow(o) {
     `// 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 }) => {",
+    "const smoke = async ({ step, expect }) => {",
     `  await step('snapshot', 'screen.snapshot')`,
     ...o.expoRouter ? [`  await step('open home', 'router.navigate', '/')`] : [],
-    "  // TODO: wait for text your first screen always shows, for example:",
-    `  // await step('home shown', 'screen.waitFor', 'Welcome')`,
-    `  await step('undo', 'bridge.restore')`,
+    "  // TODO: check text your first screen always shows, for example:",
+    `  // await expect.text('Welcome')`,
     "}",
     "",
     "export default smoke",
@@ -1648,32 +2195,32 @@ 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(text) {
-  const nl = text.indexOf("\n");
-  const recorded = text.slice(0, nl).match(HEADER)?.[3];
-  return !!recorded && recorded === hash(text.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 = (text) => text.match(/^([ \t]+)"/m)?.[1] ?? "  ";
-function patchJson(text, edit, manual) {
+var indentOf = (text2) => text2.match(/^([ \t]+)"/m)?.[1] ?? "  ";
+function patchJson(text2, edit, manual) {
   let json;
   try {
-    json = JSON.parse(text);
+    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(text)) + (text.endsWith("\n") ? "\n" : "")
+    text: JSON.stringify(json, null, indentOf(text2)) + (text2.endsWith("\n") ? "\n" : "")
   };
 }
-function patchPackageScripts(text) {
+function patchPackageScripts(text2) {
   return patchJson(
-    text,
+    text2,
     (pkg) => {
       if (pkg.scripts?.flow !== void 0) return false;
       pkg.scripts = { ...pkg.scripts, flow: "agent-bridge run" };
@@ -1690,9 +2237,9 @@ function includesFlows(pattern) {
   const glob = last.includes(".") ? pattern : `${pattern.replace(/\/+$/, "")}${last === "*" ? "" : "/**/*"}`;
   return globRe(glob).test("flows/smoke.flow.mjs");
 }
-function patchTsconfig(text, baseAllowJs) {
+function patchTsconfig(text2, baseAllowJs) {
   const manual = `Add "${FLOW_GLOB}" to "exclude" in tsconfig.json`;
-  const json = parseJsonc(text);
+  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;
@@ -1703,25 +2250,25 @@ function patchTsconfig(text, baseAllowJs) {
     return {
       manual: `${manual}, along with what it inherits from ${JSON.stringify(json.extends)}: an "exclude" here replaces the inherited one`
     };
-  const patched = addToArray(text, "exclude", FLOW_GLOB, ["node_modules"]);
+  const patched = addToArray(text2, "exclude", FLOW_GLOB, ["node_modules"]);
   return patched ? { text: patched } : { manual };
 }
-function patchOxlint(text) {
-  const ignore = parseJsonc(text)?.ignorePatterns;
+function patchOxlint(text2) {
+  const ignore = parseJsonc(text2)?.ignorePatterns;
   if (Array.isArray(ignore) && ignore.includes(FLOW_GLOB)) return { unchanged: true };
-  const patched = addToArray(text, "ignorePatterns", FLOW_GLOB);
+  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(text) {
-  if (text.includes(FLOW_GLOB)) return { unchanged: true };
+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 = [...text.matchAll(re)];
+  const matches = [...text2.matchAll(re)];
   if (matches.length !== 1) return { manual };
   const at = matches[0].index + matches[0][1].length;
-  return { text: `${text.slice(0, at)}
-  ${ESLINT_SNIPPET}${text.slice(at)}` };
+  return { text: `${text2.slice(0, at)}
+  ${ESLINT_SNIPPET}${text2.slice(at)}` };
 }
 
 // src/init/plan.ts
@@ -1737,27 +2284,32 @@ var MARKERS = [
   ["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 posix = (p) => p.split(sep).join("/");
+var posix2 = (p) => p.split(sep).join("/");
 function importPath(fromFile, toFile) {
-  const rel = posix(relative2(dirname4(fromFile), toFile)).replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+  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 = posix(relative2(d.dir, d.bin));
+    const rel = posix2(relative4(d.dir, d.bin));
     return rel.startsWith(".") ? rel : `./${rel}`;
   }
   if (d.pm === "npm" && d.root !== d.dir)
-    return `${posix(relative2(d.dir, d.root))}/node_modules/.bin/agent-bridge`;
+    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 : join5(d.dir, out);
-  return join5(d.dir, d.srcDir ? "src/dev" : "dev", `agent-bridge.${d.typescript ? "tsx" : "js"}`);
+  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;
@@ -1784,13 +2336,13 @@ function nextSteps(bin, o) {
 var stripExt = (p) => p.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "").replace(/\/index$/, "");
 function readTsconfig(d, fs) {
   if (!d.tsconfig) return { aliases: [] };
-  const file = join5(d.dir, d.tsconfig);
+  const file = join7(d.dir, d.tsconfig);
   const json = parseJsonc(fs.read(file) ?? "");
   if (!json) return { aliases: [] };
   const findExtended = (from2, ext2) => {
-    const names = ext2.endsWith(".json") ? [ext2] : [ext2, `${ext2}.json`];
-    const roots = ext2.startsWith(".") ? [dirname4(from2)] : ancestors(dirname4(from2), d.repoRoot).map((a) => join5(a, "node_modules"));
-    for (const r of roots) for (const n of names) if (fs.exists(join5(r, n)) && !fs.list(join5(r, n)).length) return join5(r, n);
+    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;
@@ -1807,30 +2359,30 @@ function readTsconfig(d, fs) {
     ext = base.extends;
     from = path;
   }
-  const baseDir = join5(d.dir, json.compilerOptions?.baseUrl ?? ".");
+  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(/\*$/, ""), join5(baseDir, targets[0].replace(/\*$/, ""))]] : []
+    ([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 = dirname4(d)) {
+  for (let d = dir; ; d = dirname5(d)) {
     out.push(d);
-    if (d === stop2 || dirname4(d) === d) return out;
+    if (d === stop2 || dirname5(d) === d) return out;
   }
 }
-function importedFiles(file, text, aliases) {
-  const specs = [...text.matchAll(/(?:from\s+|import\s+|require\(\s*)['"]([^'"]+)['"]/g)].map((m) => m[1]);
+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(join5(dirname4(file), spec))];
+    if (spec.startsWith(".")) return [stripExt(join7(dirname5(file), spec))];
     const alias = aliases.find(([prefix]) => prefix && spec.startsWith(prefix));
-    return alias ? [stripExt(join5(alias[1], spec.slice(alias[0].length)))] : [];
+    return alias ? [stripExt(join7(alias[1], spec.slice(alias[0].length)))] : [];
   });
 }
 function plan(d, found, fs, o, cwd) {
-  const rel = (p) => posix(relative2(d.dir, p));
+  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}).` };
@@ -1840,7 +2392,7 @@ function plan(d, found, fs, o, cwd) {
     };
   const ts = /\.tsx?$/.test(out);
   const bin = binFor(d);
-  const runFrom = posix(relative2(cwd, d.dir)) || ".";
+  const runFrom = posix2(relative4(cwd, d.dir)) || ".";
   const tsconfig = readTsconfig(d, fs);
   const actions = [];
   const files = [];
@@ -1877,14 +2429,14 @@ function plan(d, found, fs, o, cwd) {
     files.push({ path: `${rel(path)}.new`, status: "written" });
     return "edited";
   };
-  const imported = (list2) => list2.map((f) => ({ name: f.name, from: importPath(out, join5(d.dir, f.file)) }));
+  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(join5(d.dir, f)) !== stripExt(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) {
@@ -1908,13 +2460,17 @@ function plan(d, found, fs, o, cwd) {
         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(join5(d.dir, f)) ?? "").join("\n") : existingText;
+  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) {
@@ -1930,21 +2486,45 @@ function plan(d, found, fs, o, cwd) {
         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: ["nav.navigate", "nav.current"],
-        why: "there is no React Navigation adapter; the sample tools need your container ref"
+        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 = join5(d.dir, "flows");
+  const flows = join7(d.dir, "flows");
   generate(
-    join5(flows, "smoke.flow.mjs"),
+    join7(flows, "smoke.flow.mjs"),
     renderSmokeFlow({ version: o.version, expoRouter: d.has.expoRouter, bin })
   );
-  const readme = join5(flows, "README.md");
+  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) });
@@ -1952,7 +2532,7 @@ function plan(d, found, fs, o, cwd) {
   }
   const patch = (path, fn) => {
     if (!path) return;
-    const abs = join5(d.dir, path);
+    const abs = join7(d.dir, path);
     const result = fn(fs.read(abs) ?? "");
     if ("text" in result) {
       actions.push({ kind: "patch", path: abs, patch: fn });
@@ -1964,15 +2544,15 @@ function plan(d, found, fs, o, cwd) {
     }
   };
   patch("package.json", patchPackageScripts);
-  patch(d.tsconfig, (text) => patchTsconfig(text, tsconfig.baseAllowJs));
+  patch(d.tsconfig, (text2) => patchTsconfig(text2, tsconfig.baseAllowJs));
   patch(d.oxlint, patchOxlint);
   patch(d.eslint, patchEslint);
   if (d.agentsFile) {
-    const text = fs.read(d.agentsFile) ?? "";
-    const path = posix(relative2(d.dir, d.agentsFile));
-    if (text.includes(".flow.mjs")) files.push({ path, status: "unchanged" });
+    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 = posix(relative2(dirname4(d.agentsFile), d.dir));
+      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" });
     }
@@ -1982,11 +2562,11 @@ function plan(d, found, fs, o, cwd) {
   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 ? join5(d.dir, d.rootFile) : void 0;
+  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(join5(d.dir, f))) : rootImports.includes(stripExt(out));
-  const snippet = renderMountSnippet(importPath(rootFile ?? join5(d.dir, "App.tsx"), out));
+  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";
@@ -2028,12 +2608,12 @@ function plan(d, found, fs, o, cwd) {
 }
 
 // src/init/scan.ts
-import { join as join6, relative as relative3 } from "path";
+import { join as join8, relative as relative5 } from "path";
 var CODE = /\.(tsx?|jsx?|mjs|cjs)$/;
 var TESTS = /\.(test|spec)\.|(^|\/)__tests__\//;
-var imports = (text, module) => new RegExp(
+var imports = (text2, module) => new RegExp(
   `(from\\s+|require\\(\\s*)['"]${module.replace(/[.]/g, "\\.")}(/[\\w./-]+)?['"]`
-).test(text);
+).test(text2);
 var TYPED = "(?:\\s*:[^=]+)?";
 var PATTERNS = [
   ["stores", "zustand", new RegExp(`export\\s+const\\s+(use\\w+)${TYPED}\\s*=\\s*create\\w*\\s*[<(]`, "g")],
@@ -2044,31 +2624,31 @@ var PATTERNS = [
 ];
 function scan(dir, fs, { maxFiles = 2e3, maxBytes = 512 * 1024 } = {}) {
   const files = [];
-  const walk = (d, deep) => {
+  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 = join6(d, e.name);
+      const path = join8(d, e.name);
       if (e.dir) {
-        if (deep) walk(path, true);
-      } else if (CODE.test(e.name) && !TESTS.test(relative3(dir, path))) {
+        if (deep) walk2(path, true);
+      } else if (CODE.test(e.name) && !TESTS.test(relative5(dir, path))) {
         files.push(path);
       }
     }
   };
-  walk(dir, false);
-  for (const sub of ["src", "app", "lib"]) walk(join6(dir, sub), true);
+  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 text = fs.read(path);
-    if (!text || text.length > maxBytes) continue;
-    if (/\buseAgentBridge\s*\(|(from\s+|require\(\s*)['"]@avasapp\/agent-bridge['"]/.test(text))
-      result.bridgeUsers.push(relative3(dir, path));
+    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(text, module)) continue;
-      for (const m of text.matchAll(re))
-        result[key].push({ name: m[1], file: relative3(dir, path) });
+      if (!imports(text2, module)) continue;
+      for (const m of text2.matchAll(re))
+        result[key].push({ name: m[1], file: relative5(dir, path) });
     }
   }
   return result;
@@ -2077,7 +2657,7 @@ function scan(dir, fs, { maxFiles = 2e3, maxBytes = 512 * 1024 } = {}) {
 // src/init/index.ts
 var INSTALL_TIMEOUT_MS = 5 * 6e4;
 var SKILL_TIMEOUT_MS = 2 * 6e4;
-var posix2 = (p) => p.split(sep2).join("/");
+var posix3 = (p) => p.split(sep2).join("/");
 var nodeFs = {
   exists: existsSync2,
   read: (path) => {
@@ -2109,10 +2689,10 @@ function nodeIo() {
   return {
     fs: nodeFs,
     write: (path, content) => {
-      mkdirSync2(dirname5(path), { recursive: true });
+      mkdirSync2(dirname6(path), { recursive: true });
       writeFileSync2(path, content);
     },
-    append: (path, text) => appendFileSync3(path, text),
+    append: (path, text2) => appendFileSync3(path, text2),
     exec: (command, cwd, interactive, timeoutMs) => new Promise((done) => {
       const [cmd, ...args] = command;
       const child = spawn2(cmd, args, {
@@ -2141,9 +2721,9 @@ function nodeIo() {
         rl.close();
       }
     },
-    print: (text) => process.stdout.write(`${text}
+    print: (text2) => process.stdout.write(`${text2}
 `),
-    warn: (text) => process.stderr.write(`${text}
+    warn: (text2) => process.stderr.write(`${text2}
 `),
     interactive: !!process.stdin.isTTY && !!process.stdout.isTTY && !/^(1|true)$/i.test(process.env.CI ?? ""),
     cwd: process.cwd(),
@@ -2182,8 +2762,8 @@ async function apply(actions, report, io, interactive) {
         break;
       }
       case "append": {
-        const text = io.fs.read(a.path) ?? "";
-        io.append(a.path, `${text.endsWith("\n") || !text ? "" : "\n"}${a.line}
+        const text2 = io.fs.read(a.path) ?? "";
+        io.append(a.path, `${text2.endsWith("\n") || !text2 ? "" : "\n"}${a.line}
 `);
         break;
       }
@@ -2191,7 +2771,7 @@ async function apply(actions, report, io, interactive) {
   }
 }
 var describe = (a, dir) => {
-  const rel = (p) => relative4(dir, p) || ".";
+  const rel = (p) => relative6(dir, p) || ".";
   switch (a.kind) {
     case "install":
       return `install   ${a.command.join(" ")}`;
@@ -2217,7 +2797,7 @@ function formatReport(r, actions) {
     L.push("Would run:", ...actions.map((a) => `  ${describe(a, r.app.dir)}`), "");
     for (const a of actions)
       if (a.kind === "write")
-        L.push(`--- ${relative4(r.app.dir, a.path)}`, a.content.trimEnd(), "");
+        L.push(`--- ${relative6(r.app.dir, a.path)}`, a.content.trimEnd(), "");
   }
   L.push("Files");
   for (const f of r.files)
@@ -2263,7 +2843,7 @@ function formatReport(r, actions) {
   return L.join("\n");
 }
 async function runInit(args, io) {
-  const dir = resolve(io.cwd, args.dir ?? ".");
+  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);
@@ -2274,7 +2854,7 @@ async function runInit(args, io) {
   const interactive = io.interactive && !args.json && !args.yes;
   const options = (network2) => ({
     version,
-    out: args.out === void 0 ? void 0 : resolve(io.cwd, args.out),
+    out: args.out === void 0 ? void 0 : resolve2(io.cwd, args.out),
     force: args.force,
     install: args.install !== false,
     skill: args.skill !== false,
@@ -2290,13 +2870,13 @@ async function runInit(args, io) {
     report2.dryRun = true;
     if (args.json) {
       const contents = Object.fromEntries(
-        actions2.flatMap((a) => a.kind === "write" ? [[relative4(dir, a.path), a.content]] : [])
+        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 = posix2(relative4(dir, bridgePath(d, options(network).out)));
+  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] `);
@@ -2321,6 +2901,439 @@ async function runInit(args, io) {
   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
 
@@ -2337,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>             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
@@ -2356,11 +3374,18 @@ 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)
@@ -2402,6 +3427,9 @@ 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" },
@@ -2507,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}`);
@@ -2537,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(resolve2(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) => {
@@ -2568,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: