@flowriki/agent 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/{chunk-ZUHML4TR.js → chunk-VN4KB4YX.js}

@@ -2,22 +2,22 @@
 
 // src/engine.ts
 import os5 from "os";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire4 } from "module";
 import { spawnSync } from "child_process";
 
 // ../agent-core/dist/index.js
 import { z as z4 } from "zod";
-import fs5 from "fs";
+import fs6 from "fs";
 import path5 from "path";
 import crypto22 from "crypto";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 import { WebSocket, WebSocketServer } from "ws";
 import fs23 from "fs";
 import os2 from "os";
-import path23 from "path";
+import path24 from "path";
 
 // ../orchestrator/dist/index.js
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 
 // ../protocol/dist/chunk-ROEX7TWK.js
@@ -287,17 +287,17 @@ var FlowDocumentSchema = z.object({
   revision: z.number().int().nonnegative().default(0)
 }).strict().superRefine((flow, ctx) => {
   const ids = /* @__PURE__ */ new Set();
-  flow.steps.forEach((s, i) => {
-    if (ids.has(s.id)) ctx.addIssue({ code: "custom", path: ["steps", i, "id"], message: "Step IDs must be unique" });
-    ids.add(s.id);
+  flow.steps.forEach((s2, i) => {
+    if (ids.has(s2.id)) ctx.addIssue({ code: "custom", path: ["steps", i, "id"], message: "Step IDs must be unique" });
+    ids.add(s2.id);
   });
 });
-var surfaceOf = (s) => JSON.stringify([s["pageId"] ?? "", s["frame"] ?? []]);
-var containerOf = (s) => JSON.stringify([targetOfStep(s), s["legacySelector"] ?? ""]);
-function targetOfStep(s) {
-  const t = { role: s["role"] ?? "", name: s["name"] ?? "", scope: s["scope"] ?? "" };
+var surfaceOf = (s2) => JSON.stringify([s2["pageId"] ?? "", s2["frame"] ?? []]);
+var containerOf = (s2) => JSON.stringify([targetOfStep(s2), s2["legacySelector"] ?? ""]);
+function targetOfStep(s2) {
+  const t = { role: s2["role"] ?? "", name: s2["name"] ?? "", scope: s2["scope"] ?? "" };
   for (const key of ["scopeRole", "frame", "pageId", "nameFrom", "locator", "nth"]) {
-    if (s[key] !== void 0) t[key] = s[key];
+    if (s2[key] !== void 0) t[key] = s2[key];
   }
   return t;
 }
@@ -305,12 +305,12 @@ function migrateScrollPrerequisites(doc) {
   const steps = Array.isArray(doc.steps) ? doc.steps : [];
   const out = [];
   const pending = [];
-  const isScroll = (s) => s["type"] === "scroll" && s["scroll"] !== void 0 && s["scroll"] !== null;
-  const hasChecks = (s) => Array.isArray(s["proposals"]) && s["proposals"].length > 0;
-  const carry = (s) => {
-    const pos = s["scroll"] ?? {};
-    const prerequisite = { x: Number(pos.x ?? 0), y: Number(pos.y ?? 0), container: targetOfStep(s) };
-    if (typeof s["legacySelector"] === "string" && s["legacySelector"]) prerequisite["legacySelector"] = s["legacySelector"];
+  const isScroll = (s2) => s2["type"] === "scroll" && s2["scroll"] !== void 0 && s2["scroll"] !== null;
+  const hasChecks = (s2) => Array.isArray(s2["proposals"]) && s2["proposals"].length > 0;
+  const carry = (s2) => {
+    const pos = s2["scroll"] ?? {};
+    const prerequisite = { x: Number(pos.x ?? 0), y: Number(pos.y ?? 0), container: targetOfStep(s2) };
+    if (typeof s2["legacySelector"] === "string" && s2["legacySelector"]) prerequisite["legacySelector"] = s2["legacySelector"];
     return prerequisite;
   };
   for (const step of steps) {
@@ -784,7 +784,7 @@ function describeAssertion(a, subject) {
 // ../orchestrator/dist/index.js
 import { execFileSync } from "child_process";
 import fs22 from "fs";
-import path22 from "path";
+import path23 from "path";
 
 // ../runner/dist/index.js
 import { chromium, firefox, webkit } from "playwright";
@@ -807,7 +807,7 @@ function installRecorder() {
   if (d.__flInstalled) return;
   d.__flInstalled = true;
   w.__flInstalled = true;
-  const clean = (s) => (s || "").replace(/\s+/g, " ").trim();
+  const clean = (s2) => (s2 || "").replace(/\s+/g, " ").trim();
   const FRAME_CHAIN = (() => {
     const chain = [];
     try {
@@ -887,7 +887,7 @@ function installRecorder() {
     return (first && first.tagName ? first : e.target) ?? null;
   }
   w.__flSignature = () => {
-    const texts = (sel) => Array.from(document.querySelectorAll(sel)).filter(readable).map((n) => clean(n.textContent)).filter(Boolean);
+    const texts = (sel) => Array.from(document.querySelectorAll(sel)).filter(readable).map((n2) => clean(n2.textContent)).filter(Boolean);
     return {
       url: location.href,
       title: document.title,
@@ -896,15 +896,15 @@ function installRecorder() {
       fields: Array.from(document.querySelectorAll("input, select, textarea")).filter(readable).map(accName).filter(Boolean),
       texts: (() => {
         const out = [];
-        for (const n of Array.from(document.querySelectorAll("body *"))) {
+        for (const n2 of Array.from(document.querySelectorAll("body *"))) {
           if (out.length >= 200) break;
           const t = clean(
-            Array.from(n.childNodes).filter((c) => c.nodeType === 3).map((c) => c.textContent).join(" ")
+            Array.from(n2.childNodes).filter((c) => c.nodeType === 3).map((c) => c.textContent).join(" ")
           );
           if (!t || t.length > 120) continue;
-          if (!readable(n)) continue;
-          const tag = (n.tagName || "").toLowerCase();
-          out.push({ key: `${tag}${n.id ? "#" + n.id : ""}|${t}`, text: t });
+          if (!readable(n2)) continue;
+          const tag = (n2.tagName || "").toLowerCase();
+          out.push({ key: `${tag}${n2.id ? "#" + n2.id : ""}|${t}`, text: t });
         }
         return out;
       })()
@@ -1894,7 +1894,7 @@ function installDebugPanel() {
     back: "Back",
     forward: "Forward"
   })[t] || t;
-  const esc = (s) => String(s).replace(
+  const esc = (s2) => String(s2).replace(
     /[&<>"]/g,
     (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]
   );
@@ -2320,7 +2320,7 @@ async function locateAll(page, step, opts = {}) {
   if (step.scope && !plan.overridden) {
     const roles = step.scopeRole ? [step.scopeRole] : [...SCOPE_ROLES];
     const containers = roles.map((role) => root.getByRole(role, { name: step.scope, exact: !step.scopeRole, includeHidden: opts.includeHidden }));
-    root = containers.reduce((a, b) => a.or(b));
+    root = containers.reduce((a, b2) => a.or(b2));
   }
   if (plan.viaAdjacentLabel) return root.getByText(plan.arg, { exact: true }).locator("xpath=..").getByRole(step.role || "textbox", { includeHidden: opts.includeHidden });
   let loc;
@@ -2719,7 +2719,7 @@ async function startRecordingSession(opts) {
     void ensureInstalled(p);
     p.on("domcontentloaded", () => void ensureInstalled(p));
     p.on("download", (download) => {
-      const step = [...steps].reverse().find((s) => (s.pageId ?? "main") === pageIds.get(p));
+      const step = [...steps].reverse().find((s2) => (s2.pageId ?? "main") === pageIds.get(p));
       if (step) {
         (step.downloads ??= []).push(download.suggestedFilename());
         onStep?.(step);
@@ -2727,7 +2727,7 @@ async function startRecordingSession(opts) {
       }
     });
     p.on("dialog", (dialog) => {
-      const step = [...steps].reverse().find((s) => (s.pageId ?? "main") === pageIds.get(p));
+      const step = [...steps].reverse().find((s2) => (s2.pageId ?? "main") === pageIds.get(p));
       if (!step) {
         void dialog.dismiss();
         record({ type: "unsupported", name: "Dialog before first action", warning: "Record an explicit navigation before a page-load dialog", pageId: pageIds.get(p) }, null);
@@ -2746,7 +2746,7 @@ async function startRecordingSession(opts) {
     pageIds.set(p, id);
     watchPage(p);
     void p.opener().then((opener) => {
-      const step = [...steps].reverse().find((s) => (s.pageId ?? "main") === pageIds.get(opener));
+      const step = [...steps].reverse().find((s2) => (s2.pageId ?? "main") === pageIds.get(opener));
       if (step) {
         step.opensPage = id;
         onStep?.(step);
@@ -3154,8 +3154,8 @@ async function checkAssertion(page, kind, value, timeoutMs = 3e3, assertion) {
       reading = { outcome: "value", value: kind === "url" ? page.url() : await page.title() };
     } else if (kind === "count") {
       try {
-        const n = await (await locateAll(page, asStep(assertion.target), { allowRoleOnly: true })).count();
-        reading = { outcome: "value", value: String(n) };
+        const n2 = await (await locateAll(page, asStep(assertion.target), { allowRoleOnly: true })).count();
+        reading = { outcome: "value", value: String(n2) };
       } catch (err) {
         reading = { outcome: "invalid", detail: firstLine2(err) };
       }
@@ -3225,7 +3225,7 @@ async function applyAction(loc, step, value, ctx = {}) {
     case "upload": {
       const name = String(value ?? "");
       const names = step.values ?? (name ? [name] : []);
-      const files = names.map((n) => ctx.resolveFile?.(n));
+      const files = names.map((n2) => ctx.resolveFile?.(n2));
       const file = files.every(Boolean);
       if (!file) {
         throw Object.assign(
@@ -3271,7 +3271,7 @@ async function replayFlow(opts) {
     opts.environment,
     headless,
     slowMo,
-    { policy: opts.artifacts, dir: evidenceDir, hasSecrets: steps.some((s) => s.secret) }
+    { policy: opts.artifacts, dir: evidenceDir, hasSecrets: steps.some((s2) => s2.secret) }
   );
   const page = await context.newPage();
   const pages = new ExecutionPages(context, page);
@@ -3639,7 +3639,7 @@ async function startDebugSession(opts) {
     onDisconnect,
     onEndRequested
   } = opts;
-  const steps = opts.steps.map((s) => ({ ...s }));
+  const steps = opts.steps.map((s2) => ({ ...s2 }));
   const breakpoints = new Set(opts.breakpoints ?? []);
   const results = {};
   let status2 = "idle";
@@ -3661,7 +3661,7 @@ async function startDebugSession(opts) {
     status: status2,
     cursor,
     breakpoints: [...breakpoints],
-    steps: steps.map((s) => ({ ...s })),
+    steps: steps.map((s2) => ({ ...s2 })),
     results: { ...results },
     failure,
     recording,
@@ -3669,15 +3669,15 @@ async function startDebugSession(opts) {
     mode: "debug"
   });
   const publish = () => {
-    const s = snapshot();
-    onState?.(s);
-    void paint(s);
-    return s;
+    const s2 = snapshot();
+    onState?.(s2);
+    void paint(s2);
+    return s2;
   };
-  async function paint(s) {
+  async function paint(s2) {
     const safe2 = {
-      ...s,
-      steps: s.steps.map((st) => ({
+      ...s2,
+      steps: s2.steps.map((st) => ({
         id: st.id,
         type: st.type,
         name: st.name,
@@ -3720,7 +3720,7 @@ async function startDebugSession(opts) {
       legacySelector: payload.legacySelector ?? "",
       proposals: []
     };
-    const at = cursor ? steps.findIndex((s) => s.id === cursor) : steps.length;
+    const at = cursor ? steps.findIndex((s2) => s2.id === cursor) : steps.length;
     const insertAt = at === -1 ? steps.length : at;
     if (["fill", "select", "setRange"].includes(step.type)) {
       const prev = steps[insertAt - 1];
@@ -3810,7 +3810,7 @@ async function startDebugSession(opts) {
         break;
     }
   }
-  const indexOf = (id) => id ? steps.findIndex((s) => s.id === id) : -1;
+  const indexOf = (id) => id ? steps.findIndex((s2) => s2.id === id) : -1;
   function advanceFrom(i) {
     let next = i + 1;
     while (next < steps.length && applied.has(steps[next].id)) next += 1;
@@ -3969,7 +3969,7 @@ async function startDebugSession(opts) {
       return publish();
     },
     deleteStep(stepId) {
-      const i = steps.findIndex((s) => s.id === stepId);
+      const i = steps.findIndex((s2) => s2.id === stepId);
       if (i === -1) return publish();
       if (cursor === stepId) cursor = steps[i + 1]?.id ?? null;
       if (failure?.stepId === stepId) failure = null;
@@ -3990,7 +3990,7 @@ async function startDebugSession(opts) {
       status2 = "finished";
       await browser.close().catch(() => {
       });
-      return steps.map((s) => ({ ...s }));
+      return steps.map((s2) => ({ ...s2 }));
     },
     async abort() {
       closed = true;
@@ -4003,6 +4003,9 @@ async function startDebugSession(opts) {
 }
 
 // ../rundb/dist/index.js
+import fs4 from "fs";
+import { createRequire as createRequire2 } from "module";
+import path22 from "path";
 import os from "os";
 import path3 from "path";
 var MIGRATIONS2 = [
@@ -4150,9 +4153,46 @@ var MIGRATIONS2 = [
   `
 ];
 var SCHEMA_VERSION = MIGRATIONS2.length;
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+var lastTime = -1;
+var lastRandom = [];
+function encodeTime(ms) {
+  let out = "";
+  for (let i = TIME_LEN - 1; i >= 0; i--) {
+    out = CROCKFORD[ms % 32] + out;
+    ms = Math.floor(ms / 32);
+  }
+  return out;
+}
+function bumpRandom() {
+  for (let i = RANDOM_LEN - 1; i >= 0; i--) {
+    if (lastRandom[i] < 31) {
+      lastRandom[i]++;
+      return;
+    }
+    lastRandom[i] = 0;
+  }
+}
+function ulid(now = Date.now()) {
+  if (now === lastTime) {
+    bumpRandom();
+  } else {
+    lastTime = now;
+    lastRandom = Array.from(crypto.getRandomValues(new Uint8Array(RANDOM_LEN)), (b2) => b2 % 32);
+  }
+  return encodeTime(now) + lastRandom.map((n2) => CROCKFORD[n2]).join("");
+}
+function rowId(prefix) {
+  return `${prefix}_${crypto.randomUUID().replace(/-/g, "").slice(0, 12)}`;
+}
 function flowrikiHome() {
   return process.env.FLOWRIKI_HOME || path3.join(os.homedir(), ".flowriki");
 }
+function defaultDbPath() {
+  return path3.join(flowrikiHome(), "flowriki.db");
+}
 function runArtifactsDir(runId, projectId = "default") {
   return path3.join(flowrikiHome(), "projects", safe(projectId), "runs", safe(runId));
 }
@@ -4167,6 +4207,469 @@ function isInside(root, candidate) {
   const target = path3.resolve(candidate);
   return target === base || target.startsWith(base + path3.sep);
 }
+var b = (v) => v ? 1 : 0;
+var s = (v) => v === void 0 || v === null ? null : String(v);
+var n = (v) => v === void 0 || v === null ? null : Number(v);
+var RUN_COLUMNS = `r.*,
+  (SELECT COALESCE(SUM(steps_run), 0)   FROM run_task t WHERE t.run_id = r.id) AS steps_run,
+  (SELECT COALESCE(SUM(steps_total), 0) FROM run_task t WHERE t.run_id = r.id) AS steps_total`;
+var SqliteStorage = class {
+  constructor(file = defaultDbPath()) {
+    this.file = file;
+  }
+  file;
+  db = null;
+  async init() {
+    if (this.db) return;
+    let DatabaseSync2;
+    try {
+      ({ DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)("node:sqlite"));
+    } catch (err) {
+      throw new Error(
+        `run history needs node:sqlite, which this Node (${process.version}) does not provide \u2014 Node 22.13 or newer is required (${err.message})`
+      );
+    }
+    if (this.file !== ":memory:") fs4.mkdirSync(path22.dirname(this.file), { recursive: true });
+    const db = new DatabaseSync2(this.file);
+    if (this.file !== ":memory:") db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA foreign_keys = ON");
+    const current = Number(db.prepare("PRAGMA user_version").get().user_version ?? 0);
+    if (current > SCHEMA_VERSION) {
+      throw new Error(
+        `${this.file} was written by a newer Flowriki (schema v${current}, this build understands v${SCHEMA_VERSION})`
+      );
+    }
+    for (let v = current; v < MIGRATIONS2.length; v++) {
+      db.exec("BEGIN");
+      try {
+        db.exec(MIGRATIONS2[v]);
+        db.exec(`PRAGMA user_version = ${v + 1}`);
+        db.exec("COMMIT");
+      } catch (err) {
+        db.exec("ROLLBACK");
+        throw err;
+      }
+    }
+    this.db = db;
+  }
+  async close() {
+    this.db?.close();
+    this.db = null;
+  }
+  get handle() {
+    if (!this.db) throw new Error("storage used before init()");
+    return this.db;
+  }
+  tx(fn) {
+    const db = this.handle;
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const out = fn();
+      db.exec("COMMIT");
+      return out;
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+  }
+  // ---- runs ----------------------------------------------------------------
+  async createRun(input) {
+    const id = ulid();
+    const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.handle.prepare(
+      `INSERT INTO run (id, project_id, kind, trigger, status, flow_id, flow_name,
+           git_sha, git_branch, git_dirty, env, base_url, concurrency, queued_at, flow_snapshot)
+         VALUES (?,?,?,?,'queued',?,?,?,?,?,?,?,?,?,?)`
+    ).run(
+      id,
+      input.projectId ?? "default",
+      input.kind,
+      input.trigger,
+      input.flowId,
+      input.flowName,
+      input.git?.sha ?? null,
+      input.git?.branch ?? null,
+      b(input.git?.dirty),
+      input.env ?? null,
+      input.baseUrl ?? null,
+      input.concurrency ?? null,
+      queuedAt,
+      input.flowSnapshot === void 0 ? null : JSON.stringify(input.flowSnapshot)
+    );
+    return await this.getRunSummary(id);
+  }
+  async startRun(runId) {
+    this.handle.prepare("UPDATE run SET status='running', started_at=? WHERE id=?").run((/* @__PURE__ */ new Date()).toISOString(), runId);
+  }
+  async finishRun(runId, input) {
+    const row = this.handle.prepare("SELECT started_at, queued_at FROM run WHERE id=?").get(runId);
+    if (!row) return;
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const from = Date.parse(String(row.started_at ?? row.queued_at));
+    this.handle.prepare(
+      `UPDATE run SET status=?, finished_at=?, duration_ms=?, error_message=?, artifacts_dir=?
+         WHERE id=?`
+    ).run(
+      input.status,
+      finishedAt,
+      Math.max(0, Date.parse(finishedAt) - from),
+      input.errorMessage ?? null,
+      input.artifactsDir ?? null,
+      runId
+    );
+  }
+  // ---- tasks and steps -----------------------------------------------------
+  async createTask(runId, input) {
+    const id = rowId("tsk");
+    return this.tx(() => {
+      const ordinal = input.ordinal ?? Number(
+        this.handle.prepare("SELECT COUNT(*) AS c FROM run_task WHERE run_id=?").get(runId).c
+      );
+      this.handle.prepare(
+        `INSERT INTO run_task (id, run_id, ordinal, case_name, row_id, capability_id,
+             capability, provider, attempt, max_attempts, status, worker_id, queued_at, started_at)
+           VALUES (?,?,?,?,?,?,?,?,?,?,'running',?,?,?)`
+      ).run(
+        id,
+        runId,
+        ordinal,
+        input.caseName,
+        input.rowId ?? null,
+        input.capability.id,
+        JSON.stringify(input.capability),
+        input.capability.provider ?? "local",
+        input.attempt ?? 1,
+        input.maxAttempts ?? 1,
+        input.workerId ?? null,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      this.handle.prepare("UPDATE run SET tasks_total = tasks_total + 1 WHERE id=?").run(runId);
+      return id;
+    });
+  }
+  async finishTask(taskId, input) {
+    this.tx(() => {
+      const row = this.handle.prepare("SELECT run_id, started_at, queued_at FROM run_task WHERE id=?").get(taskId);
+      if (!row) return;
+      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const from = Date.parse(String(row.started_at ?? row.queued_at ?? finishedAt));
+      this.handle.prepare(
+        `UPDATE run_task SET status=?, detail=?, session_id=?, session_url=?,
+             steps_run=COALESCE(?, steps_run), steps_total=COALESCE(?, steps_total),
+             finished_at=?, duration_ms=? WHERE id=?`
+      ).run(
+        input.status,
+        input.detail ?? null,
+        input.sessionId ?? null,
+        input.sessionUrl ?? null,
+        input.stepsRun ?? null,
+        input.stepsTotal ?? null,
+        finishedAt,
+        Math.max(0, Date.parse(finishedAt) - from),
+        taskId
+      );
+      const column = input.status === "passed" ? "tasks_passed" : input.status === "failed" || input.status === "errored" ? "tasks_failed" : null;
+      if (column) {
+        this.handle.prepare(`UPDATE run SET ${column} = ${column} + 1 WHERE id=?`).run(String(row.run_id));
+      }
+    });
+  }
+  async recordStep(taskId, input) {
+    const id = rowId("stp");
+    return this.tx(() => {
+      this.handle.prepare(
+        `INSERT INTO run_step (id, run_task_id, ordinal, step_id, action, target_role,
+             target_name, target_scope, status, failure_kind, detail, duration_ms,
+             page_url, page_title, value, secret)
+           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+      ).run(
+        id,
+        taskId,
+        input.ordinal,
+        input.stepId,
+        input.action,
+        input.targetRole ?? null,
+        input.targetName ?? null,
+        input.targetScope ?? null,
+        input.status,
+        input.failureKind ?? null,
+        input.detail ?? null,
+        input.durationMs ?? null,
+        input.pageUrl ?? null,
+        input.pageTitle ?? null,
+        // Never the plaintext. A secret arrives here already withheld.
+        input.secret ? null : input.value ?? null,
+        b(input.secret ?? false)
+      );
+      const stmt = this.handle.prepare(
+        `INSERT INTO run_check (id, run_step_id, assertion_id, kind, expected, actual, ok, soft, detail)
+         VALUES (?,?,?,?,?,?,?,?,?)`
+      );
+      for (const c of input.checks ?? []) {
+        stmt.run(
+          rowId("chk"),
+          id,
+          c.assertionId ?? null,
+          c.kind,
+          c.expected ?? null,
+          c.actual ?? null,
+          b(c.ok),
+          b(c.soft ?? false),
+          c.detail ?? null
+        );
+      }
+      return id;
+    });
+  }
+  async addArtifact(runId, input) {
+    const artifact = {
+      id: rowId("art"),
+      runId,
+      runStepId: input.runStepId ?? null,
+      kind: input.kind,
+      relPath: input.relPath,
+      bytes: input.bytes ?? null,
+      masked: input.masked ?? false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.handle.prepare(
+      `INSERT INTO artifact (id, run_id, run_step_id, kind, rel_path, bytes, masked, created_at)
+         VALUES (?,?,?,?,?,?,?,?)`
+    ).run(
+      artifact.id,
+      artifact.runId,
+      artifact.runStepId,
+      artifact.kind,
+      artifact.relPath,
+      artifact.bytes,
+      b(artifact.masked),
+      artifact.createdAt
+    );
+    return artifact;
+  }
+  // ---- events --------------------------------------------------------------
+  async appendEvent(runId, type, payload) {
+    return this.tx(() => {
+      const seq = Number(
+        this.handle.prepare("SELECT COALESCE(MAX(seq), 0) AS m FROM run_event WHERE run_id=?").get(runId).m
+      ) + 1;
+      this.handle.prepare("INSERT INTO run_event (run_id, seq, at, type, payload) VALUES (?,?,?,?,?)").run(runId, seq, (/* @__PURE__ */ new Date()).toISOString(), type, JSON.stringify(payload ?? null));
+      return seq;
+    });
+  }
+  async listEvents(runId, since = 0) {
+    return this.handle.prepare("SELECT seq, at, type, payload FROM run_event WHERE run_id=? AND seq>? ORDER BY seq").all(runId, since).map((r) => ({
+      seq: Number(r.seq),
+      at: String(r.at),
+      type: String(r.type),
+      payload: JSON.parse(String(r.payload))
+    }));
+  }
+  // ---- reads ---------------------------------------------------------------
+  async getRunSummary(runId) {
+    const row = this.handle.prepare(`SELECT ${RUN_COLUMNS} FROM run r WHERE r.id=?`).get(runId);
+    return row ? toSummary(row) : null;
+  }
+  async listRuns(query = {}) {
+    const limit = Math.min(Math.max(query.limit ?? 25, 1), 200);
+    const where = [];
+    const params = [];
+    const restrict = (clause, value) => {
+      where.push(clause);
+      params.push(value);
+    };
+    if (query.projectId) restrict("r.project_id=?", query.projectId);
+    if (query.flowId) restrict("r.flow_id=?", query.flowId);
+    if (query.status) restrict("r.status=?", query.status);
+    if (query.branch) restrict("r.git_branch=?", query.branch);
+    if (query.cursor) restrict("r.id<?", query.cursor);
+    const rows = this.handle.prepare(
+      `SELECT ${RUN_COLUMNS} FROM run r
+         ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+         ORDER BY r.id DESC LIMIT ?`
+    ).all(...params, limit + 1);
+    const page = rows.slice(0, limit);
+    return {
+      runs: page.map(toSummary),
+      nextCursor: rows.length > limit ? String(page[page.length - 1].id) : null
+    };
+  }
+  async getRun(runId) {
+    const run = this.handle.prepare(`SELECT ${RUN_COLUMNS} FROM run r WHERE r.id=?`).get(runId);
+    if (!run) return null;
+    const tasks = this.handle.prepare("SELECT * FROM run_task WHERE run_id=? ORDER BY ordinal").all(runId);
+    const steps = this.handle.prepare(
+      `SELECT s.* FROM run_step s JOIN run_task t ON t.id = s.run_task_id
+         WHERE t.run_id=? ORDER BY t.ordinal, s.ordinal`
+    ).all(runId);
+    const artifacts = this.handle.prepare("SELECT * FROM artifact WHERE run_id=? ORDER BY created_at").all(runId);
+    const checks = this.handle.prepare(
+      `SELECT c.* FROM run_check c
+         JOIN run_step s ON s.id = c.run_step_id
+         JOIN run_task t ON t.id = s.run_task_id
+         WHERE t.run_id=?`
+    ).all(runId);
+    const checksByStep = /* @__PURE__ */ new Map();
+    for (const c of checks) {
+      const list = checksByStep.get(String(c.run_step_id)) ?? [];
+      list.push({
+        id: String(c.id),
+        assertionId: s(c.assertion_id),
+        kind: String(c.kind),
+        expected: s(c.expected),
+        actual: s(c.actual),
+        ok: Number(c.ok) === 1,
+        soft: Number(c.soft) === 1,
+        detail: s(c.detail)
+      });
+      checksByStep.set(String(c.run_step_id), list);
+    }
+    const stepsByTask = /* @__PURE__ */ new Map();
+    for (const st of steps) {
+      const list = stepsByTask.get(String(st.run_task_id)) ?? [];
+      list.push({
+        id: String(st.id),
+        ordinal: Number(st.ordinal),
+        stepId: String(st.step_id),
+        action: String(st.action),
+        targetRole: s(st.target_role),
+        targetName: s(st.target_name),
+        targetScope: s(st.target_scope),
+        value: s(st.value),
+        secret: Number(st.secret) === 1,
+        status: String(st.status),
+        failureKind: s(st.failure_kind),
+        detail: s(st.detail),
+        durationMs: n(st.duration_ms),
+        pageUrl: s(st.page_url),
+        pageTitle: s(st.page_title),
+        checks: checksByStep.get(String(st.id)) ?? []
+      });
+      stepsByTask.set(String(st.run_task_id), list);
+    }
+    return {
+      ...toSummary(run),
+      errorMessage: s(run.error_message),
+      artifactsDir: s(run.artifacts_dir),
+      artifacts: artifacts.map(
+        (a) => ({
+          id: String(a.id),
+          runId: String(a.run_id),
+          runStepId: s(a.run_step_id),
+          kind: String(a.kind),
+          relPath: String(a.rel_path),
+          bytes: n(a.bytes),
+          masked: Number(a.masked) === 1,
+          createdAt: String(a.created_at)
+        })
+      ),
+      tasks: tasks.map(
+        (t) => ({
+          id: String(t.id),
+          ordinal: Number(t.ordinal),
+          caseName: String(t.case_name),
+          rowId: s(t.row_id),
+          capability: JSON.parse(String(t.capability)),
+          provider: String(t.provider),
+          attempt: Number(t.attempt),
+          maxAttempts: Number(t.max_attempts),
+          status: String(t.status),
+          workerId: s(t.worker_id),
+          sessionId: s(t.session_id),
+          sessionUrl: s(t.session_url),
+          detail: s(t.detail),
+          stepsRun: Number(t.steps_run),
+          stepsTotal: Number(t.steps_total),
+          durationMs: n(t.duration_ms),
+          steps: stepsByTask.get(String(t.id)) ?? []
+        })
+      )
+    };
+  }
+  async deleteRun(runId) {
+    this.handle.prepare("DELETE FROM run WHERE id=?").run(runId);
+  }
+  async pruneRuns(keep) {
+    if (keep < 0) throw new Error("keep must not be negative");
+    return this.tx(() => {
+      const doomed = this.handle.prepare(
+        `SELECT id FROM (
+             SELECT id, ROW_NUMBER() OVER (
+               PARTITION BY COALESCE(flow_id, '') ORDER BY id DESC
+             ) AS rn FROM run
+           ) WHERE rn > ?`
+      ).all(keep).map((r) => String(r.id));
+      const stmt = this.handle.prepare("DELETE FROM run WHERE id=?");
+      for (const id of doomed) stmt.run(id);
+      return doomed;
+    });
+  }
+  async runStats(days, projectId = "default") {
+    const since = new Date(Date.now() - days * 864e5).toISOString();
+    const row = this.handle.prepare(
+      `SELECT COUNT(*) AS total,
+                SUM(CASE WHEN status = 'passed' THEN 1 ELSE 0 END) AS passed,
+                SUM(CASE WHEN status IN ('failed', 'errored') THEN 1 ELSE 0 END) AS failed
+         FROM run
+         WHERE project_id = ? AND queued_at >= ? AND finished_at IS NOT NULL
+           -- A flakiness check repeats one flow on purpose and reports how
+           -- often it passed. Counting a deliberate 98/100 as a failing run
+           -- would make measuring reliability look like losing it.
+           AND kind <> 'flake'`
+    ).get(projectId, since);
+    return {
+      total: Number(row.total ?? 0),
+      passed: Number(row.passed ?? 0),
+      failed: Number(row.failed ?? 0)
+    };
+  }
+  async stepHistory(stepId, limit = 20) {
+    return this.handle.prepare(
+      `SELECT r.id AS run_id, COALESCE(r.started_at, r.queued_at) AS at, s.status,
+                s.failure_kind, s.detail, s.duration_ms, r.git_sha
+         FROM run_step s
+         JOIN run_task t ON t.id = s.run_task_id
+         JOIN run r      ON r.id = t.run_id
+         WHERE s.step_id = ?
+         ORDER BY r.id DESC LIMIT ?`
+    ).all(stepId, limit).map((r) => ({
+      runId: String(r.run_id),
+      at: String(r.at),
+      status: String(r.status),
+      failureKind: s(r.failure_kind),
+      detail: s(r.detail),
+      durationMs: n(r.duration_ms),
+      gitSha: s(r.git_sha)
+    })).reverse();
+  }
+};
+function toSummary(row) {
+  return {
+    id: String(row.id),
+    projectId: String(row.project_id),
+    kind: String(row.kind),
+    trigger: String(row.trigger),
+    status: String(row.status),
+    flowId: s(row.flow_id),
+    flowName: s(row.flow_name),
+    gitSha: s(row.git_sha),
+    gitBranch: s(row.git_branch),
+    gitDirty: Number(row.git_dirty) === 1,
+    env: s(row.env),
+    concurrency: n(row.concurrency),
+    tasksTotal: Number(row.tasks_total),
+    tasksPassed: Number(row.tasks_passed),
+    tasksFailed: Number(row.tasks_failed),
+    stepsRun: Number(row.steps_run ?? 0),
+    stepsTotal: Number(row.steps_total ?? 0),
+    queuedAt: String(row.queued_at),
+    startedAt: s(row.started_at),
+    finishedAt: s(row.finished_at),
+    durationMs: n(row.duration_ms)
+  };
+}
 
 // ../orchestrator/dist/index.js
 import crypto2 from "crypto";
@@ -4189,17 +4692,17 @@ var FlowConflict = class extends Error {
 };
 function writeFileAtomic(file, contents) {
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const handle = fs4.openSync(tmp, "w");
+  const handle = fs5.openSync(tmp, "w");
   try {
-    fs4.writeFileSync(handle, contents);
-    fs4.fsyncSync(handle);
+    fs5.writeFileSync(handle, contents);
+    fs5.fsyncSync(handle);
   } finally {
-    fs4.closeSync(handle);
+    fs5.closeSync(handle);
   }
   try {
-    fs4.renameSync(tmp, file);
+    fs5.renameSync(tmp, file);
   } catch (err) {
-    fs4.rmSync(tmp, { force: true });
+    fs5.rmSync(tmp, { force: true });
     throw err;
   }
 }
@@ -4213,9 +4716,9 @@ var FlowNotRunnable = class extends Error {
 var DEFAULT_FLAKINESS_REPEAT = 10;
 var MAX_FLAKINESS_REPEAT = 500;
 function clampRepeat(value) {
-  const n = Math.floor(Number(value));
-  if (!Number.isFinite(n) || n < 2) return DEFAULT_FLAKINESS_REPEAT;
-  return Math.min(n, MAX_FLAKINESS_REPEAT);
+  const n2 = Math.floor(Number(value));
+  if (!Number.isFinite(n2) || n2 < 2) return DEFAULT_FLAKINESS_REPEAT;
+  return Math.min(n2, MAX_FLAKINESS_REPEAT);
 }
 function uniqueRef(flowSlug, name, taken) {
   const base = `${flowSlug}_${slugify(name) || "secret"}`;
@@ -4223,8 +4726,8 @@ function uniqueRef(flowSlug, name, taken) {
     taken.add(base);
     return base;
   }
-  for (let n = 2; ; n++) {
-    const ref = `${base}_${n}`;
+  for (let n2 = 2; ; n2++) {
+    const ref = `${base}_${n2}`;
     if (!taken.has(ref)) {
       taken.add(ref);
       return ref;
@@ -4246,14 +4749,14 @@ var Store = class {
     return slug;
   }
   listFeatures() {
-    if (!fs4.existsSync(this.featuresDir)) return [];
+    if (!fs5.existsSync(this.featuresDir)) return [];
     const out = [];
-    for (const entry of fs4.readdirSync(this.featuresDir, { withFileTypes: true })) {
+    for (const entry of fs5.readdirSync(this.featuresDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       const file = path4.join(this.featuresDir, entry.name, "feature.json");
-      if (!fs4.existsSync(file)) continue;
+      if (!fs5.existsSync(file)) continue;
       try {
-        out.push(FeatureSchema.parse(JSON.parse(fs4.readFileSync(file, "utf8"))));
+        out.push(FeatureSchema.parse(JSON.parse(fs5.readFileSync(file, "utf8"))));
       } catch (err) {
         this.featureProblems.push({
           path: path4.relative(this.root, file),
@@ -4262,14 +4765,14 @@ var Store = class {
         });
       }
     }
-    return out.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return out.sort((a, b2) => a.createdAt.localeCompare(b2.createdAt));
   }
   featureProblems = [];
   createFeature(name, description = "") {
     const slug = this.assertSlug(slugify(name));
     const dir = path4.join(this.featuresDir, slug);
-    if (fs4.existsSync(dir)) throw new Error(`a feature named "${name}" already exists`);
-    fs4.mkdirSync(dir, { recursive: true });
+    if (fs5.existsSync(dir)) throw new Error(`a feature named "${name}" already exists`);
+    fs5.mkdirSync(dir, { recursive: true });
     const doc = {
       schemaVersion: 1,
       id: `f_${slug}`,
@@ -4278,11 +4781,11 @@ var Store = class {
       description: description.trim(),
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs4.writeFileSync(path4.join(dir, "feature.json"), JSON.stringify(doc, null, 2) + "\n");
+    fs5.writeFileSync(path4.join(dir, "feature.json"), JSON.stringify(doc, null, 2) + "\n");
     return doc;
   }
   deleteFeature(slug) {
-    fs4.rmSync(path4.join(this.featuresDir, this.assertSlug(slug)), { recursive: true, force: true });
+    fs5.rmSync(path4.join(this.featuresDir, this.assertSlug(slug)), { recursive: true, force: true });
   }
   /** Every flow that could be read.
    *
@@ -4297,22 +4800,22 @@ var Store = class {
     this.problemsFound = [];
     for (const slug of features) {
       const dir = path4.join(this.featuresDir, slug);
-      if (!fs4.existsSync(dir)) continue;
-      for (const file of fs4.readdirSync(dir)) {
+      if (!fs5.existsSync(dir)) continue;
+      for (const file of fs5.readdirSync(dir)) {
         if (!file.endsWith(".flow.json")) continue;
         const full = path4.join(dir, file);
         try {
-          out.push(parseFlowDocument(JSON.parse(fs4.readFileSync(full, "utf8"))));
+          out.push(parseFlowDocument(JSON.parse(fs5.readFileSync(full, "utf8"))));
         } catch (err) {
           this.problemsFound.push({
             path: path4.relative(this.root, full),
             error: String(err instanceof Error ? err.message : err).split("\n")[0].trim(),
-            recoverable: fs4.existsSync(this.recoveryPathFor(full))
+            recoverable: fs5.existsSync(this.recoveryPathFor(full))
           });
         }
       }
     }
-    return out.sort((a, b) => a.name.localeCompare(b.name));
+    return out.sort((a, b2) => a.name.localeCompare(b2.name));
   }
   problemsFound = [];
   /** Documents that could not be read on the last listing, and whether a
@@ -4337,8 +4840,8 @@ var Store = class {
   recoverFlowFile(relativePath) {
     const file = path4.join(this.root, relativePath);
     const backup = this.recoveryPathFor(file);
-    if (!fs4.existsSync(backup)) return false;
-    fs4.copyFileSync(backup, file);
+    if (!fs5.existsSync(backup)) return false;
+    fs5.copyFileSync(backup, file);
     return true;
   }
   /** Write a flow, atomically, keeping the previous contents recoverable.
@@ -4356,10 +4859,10 @@ var Store = class {
     const doc = parseFlowDocument(input);
     const featureSlug = this.assertSlug(doc.featureId.replace(/^f_/, ""));
     const dir = path4.join(this.featuresDir, featureSlug);
-    fs4.mkdirSync(dir, { recursive: true });
+    fs5.mkdirSync(dir, { recursive: true });
     const file = path4.join(dir, `${this.assertSlug(doc.slug)}.flow.json`);
     const destination = this.readFlowFile(file);
-    if (fs4.existsSync(file) && (!destination || destination.id !== doc.id)) {
+    if (fs5.existsSync(file) && (!destination || destination.id !== doc.id)) {
       throw new FlowConflict("the destination contains another flow or an unreadable document \u2014 choose another name or recover it first", destination?.revision ?? 0);
     }
     const current = this.getFlow(doc.id) ?? destination;
@@ -4377,20 +4880,20 @@ var Store = class {
     }
     doc.revision = (current?.revision ?? doc.revision ?? 0) + 1;
     const previousFile = current ? path4.join(this.root, this.relPath(current)) : file;
-    if (fs4.existsSync(previousFile)) {
+    if (fs5.existsSync(previousFile)) {
       const backup = this.recoveryPathFor(previousFile);
-      fs4.mkdirSync(path4.dirname(backup), { recursive: true });
-      fs4.copyFileSync(previousFile, backup);
+      fs5.mkdirSync(path4.dirname(backup), { recursive: true });
+      fs5.copyFileSync(previousFile, backup);
       this.ensureRecoveryIgnored();
     }
     writeFileAtomic(file, JSON.stringify(doc, null, 2) + "\n");
-    if (previousFile !== file) fs4.rmSync(previousFile);
+    if (previousFile !== file) fs5.rmSync(previousFile);
     return path4.relative(this.root, file);
   }
   /** Read one flow file, or null when it is missing or unreadable. */
   readFlowFile(file) {
     try {
-      return parseFlowDocument(JSON.parse(fs4.readFileSync(file, "utf8")));
+      return parseFlowDocument(JSON.parse(fs5.readFileSync(file, "utf8")));
     } catch {
       return null;
     }
@@ -4427,7 +4930,7 @@ var Store = class {
   deleteFlowDocument(doc) {
     const featureSlug = this.assertSlug(doc.featureId.replace(/^f_/, ""));
     this.assertSlug(doc.slug);
-    fs4.rmSync(path4.join(this.featuresDir, featureSlug, `${doc.slug}.flow.json`), { force: true });
+    fs5.rmSync(path4.join(this.featuresDir, featureSlug, `${doc.slug}.flow.json`), { force: true });
   }
   relPath(doc) {
     return path4.join(".flowriki", "features", doc.featureId.replace(/^f_/, ""), `${doc.slug}.flow.json`);
@@ -4460,7 +4963,7 @@ var Store = class {
   }
   readConfig() {
     try {
-      const raw = JSON.parse(fs4.readFileSync(this.configPath, "utf8"));
+      const raw = JSON.parse(fs5.readFileSync(this.configPath, "utf8"));
       return {
         // Normalised on write, so anything here is already a URL. Read back
         // leniently anyway: this file is git-tracked and routinely arrives
@@ -4489,8 +4992,8 @@ var Store = class {
       artifacts: ArtifactPolicySchema.parse(input.artifacts ?? existing.artifacts),
       flakinessRepeat: clampRepeat(input.flakinessRepeat ?? existing.flakinessRepeat)
     };
-    fs4.mkdirSync(path4.dirname(this.configPath), { recursive: true });
-    fs4.writeFileSync(this.configPath, JSON.stringify(config, null, 2) + "\n");
+    fs5.mkdirSync(path4.dirname(this.configPath), { recursive: true });
+    fs5.writeFileSync(this.configPath, JSON.stringify(config, null, 2) + "\n");
     return config;
   }
   /** Where a flow actually starts.
@@ -4518,7 +5021,7 @@ var Store = class {
   }
   readSecrets() {
     try {
-      return JSON.parse(fs4.readFileSync(this.secretsPath, "utf8"));
+      return JSON.parse(fs5.readFileSync(this.secretsPath, "utf8"));
     } catch {
       return {};
     }
@@ -4564,8 +5067,8 @@ var Store = class {
       changed = true;
     }
     if (changed) {
-      fs4.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
-      fs4.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
+      fs5.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
+      fs5.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
       this.ensureSecretsIgnored();
     }
     return steps;
@@ -4585,7 +5088,7 @@ var Store = class {
     const first = name;
     if (!first || first.includes("/") || first.includes("\\") || first.includes("..")) return void 0;
     const file = path4.join(this.filesDir, first);
-    return fs4.existsSync(file) ? file : void 0;
+    return fs5.existsSync(file) ? file : void 0;
   }
   /** The secret references a flow needs that this machine does not hold.
    *
@@ -4612,8 +5115,8 @@ var Store = class {
     if (!/^[a-z0-9][a-z0-9_-]*$/.test(ref)) throw new Error(`invalid secret name: ${ref}`);
     const secrets = this.readSecrets();
     secrets[ref] = value;
-    fs4.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
-    fs4.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
+    fs5.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
+    fs5.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
     this.ensureSecretsIgnored();
   }
   /** Move plaintext passwords out of flow documents recorded before secrets
@@ -4636,7 +5139,7 @@ var Store = class {
     const healed = [];
     for (const flow of this.listFlows()) {
       let changed = false;
-      const taken = new Set(flow.steps.flatMap((s) => s.secretRef ? [s.secretRef] : []));
+      const taken = new Set(flow.steps.flatMap((s2) => s2.secretRef ? [s2.secretRef] : []));
       for (const step of flow.steps) {
         if (!step.secret || step.secretRef || !step.value) continue;
         if (isSecretRefName(step.value)) continue;
@@ -4653,8 +5156,8 @@ var Store = class {
       }
     }
     if (healed.length) {
-      fs4.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
-      fs4.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
+      fs5.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
+      fs5.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
       this.ensureSecretsIgnored();
     }
     return healed;
@@ -4671,10 +5174,10 @@ var Store = class {
   /** Add one entry to .flowriki/.gitignore if it is not already there. */
   ensureIgnored(line, why) {
     const ignore = path4.join(this.root, ".flowriki", ".gitignore");
-    const existing = fs4.existsSync(ignore) ? fs4.readFileSync(ignore, "utf8") : "";
+    const existing = fs5.existsSync(ignore) ? fs5.readFileSync(ignore, "utf8") : "";
     if (existing.split("\n").includes(line)) return;
-    fs4.mkdirSync(path4.dirname(ignore), { recursive: true });
-    fs4.writeFileSync(
+    fs5.mkdirSync(path4.dirname(ignore), { recursive: true });
+    fs5.writeFileSync(
       ignore,
       `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}# ${why}
 ${line}
@@ -4752,12 +5255,12 @@ async function executeFlow(opts) {
     stepsTotal: flow.steps.length
   });
   const runDir = storage && run ? runArtifactsDir(run.id, run.projectId) : void 0;
-  const byId = new Map(flow.steps.map((s) => [s.id, s]));
+  const byId = new Map(flow.steps.map((s2) => [s2.id, s2]));
   const attempts = [];
   const perStep = /* @__PURE__ */ new Map();
   for (let attempt = 1; attempt <= repeat; attempt++) {
     if (opts.signal?.aborted) break;
-    const evidenceDir = runDir && repeat > 1 ? path22.join(runDir, `attempt-${String(attempt).padStart(3, "0")}`) : runDir;
+    const evidenceDir = runDir && repeat > 1 ? path23.join(runDir, `attempt-${String(attempt).padStart(3, "0")}`) : runDir;
     const relativeTo = (file) => repeat > 1 ? `attempt-${String(attempt).padStart(3, "0")}/${file}` : file;
     const taskId = storage && run ? await storage.createTask(run.id, {
       caseName: repeat > 1 ? `${flow.name} \xB7 attempt ${attempt}` : flow.name,
@@ -4914,15 +5417,15 @@ var percentile = (sorted, p) => sorted.length === 0 ? 0 : sorted[Math.min(sorted
 function report(attempts, perStep) {
   const passed = attempts.filter((a) => a.status === "passed").length;
   const failed = attempts.length - passed;
-  const steps = [...perStep].map(([stepId, s]) => {
-    const sorted = [...s.durations].sort((a, b) => a - b);
+  const steps = [...perStep].map(([stepId, s2]) => {
+    const sorted = [...s2.durations].sort((a, b2) => a - b2);
     return {
       stepId,
-      name: s.name,
-      type: s.type,
-      ran: s.ran,
-      failed: s.failed,
-      reasons: [...s.reasons],
+      name: s2.name,
+      type: s2.type,
+      ran: s2.ran,
+      failed: s2.failed,
+      reasons: [...s2.reasons],
       durationMs: { p50: percentile(sorted, 50), p99: percentile(sorted, 99), max: sorted[sorted.length - 1] ?? 0 }
     };
   });
@@ -4932,14 +5435,14 @@ function report(attempts, perStep) {
     failed,
     // How much a single green result is worth. 0 = every repetition agreed.
     flakeRate: attempts.length ? Math.min(passed, failed) / attempts.length * 2 : 0,
-    unstableSteps: steps.filter((s) => s.failed > 0).sort((a, b) => b.failed - a.failed),
+    unstableSteps: steps.filter((s2) => s2.failed > 0).sort((a, b2) => b2.failed - a.failed),
     steps
   };
 }
 function sizeOf(dir, file) {
   if (!dir) return null;
   try {
-    return fs22.statSync(path22.join(dir, file)).size;
+    return fs22.statSync(path23.join(dir, file)).size;
   } catch {
     return null;
   }
@@ -4992,7 +5495,7 @@ function redactPanel(state) {
   if (!state || typeof state !== "object") return state;
   const panel = state;
   if (!Array.isArray(panel.steps)) return state;
-  return { ...panel, steps: panel.steps.map((s) => redact(s)) };
+  return { ...panel, steps: panel.steps.map((s2) => redact(s2)) };
 }
 var START_GRACE_MS = 3e3;
 var RecordingCoordinator = class {
@@ -5123,7 +5626,7 @@ var RecordingCoordinator = class {
    *  resolves and attaches assertions — so this is an upsert, not an append. */
   upsert(step) {
     if (!this.draft) return;
-    const i = this.draft.steps.findIndex((s) => s.id === step.id);
+    const i = this.draft.steps.findIndex((s2) => s2.id === step.id);
     if (i === -1) this.draft.steps.push(step);
     else this.draft.steps[i] = step;
     this.deps.emit({ type: "recording.step", step: redact(step) });
@@ -5290,32 +5793,32 @@ var DebugCoordinator = class {
   async command(command, args = {}) {
     if (!this.current) throw new Error("no debug session is running");
     if (!COMMANDS.has(command)) throw new UnknownDebugCommand(`unknown command: ${command}`);
-    const s = this.current.session;
+    const s2 = this.current.session;
     switch (command) {
       case "play":
-        return s.play();
+        return s2.play();
       case "pause":
-        return s.pause();
+        return s2.pause();
       case "stepOver":
-        return s.stepOver();
+        return s2.stepOver();
       case "retry":
-        return s.retry();
+        return s2.retry();
       case "skip":
-        return s.skip();
+        return s2.skip();
       case "runTo":
-        return s.runTo(String(args.stepId));
+        return s2.runTo(String(args.stepId));
       case "toggleBreakpoint":
-        return s.toggleBreakpoint(String(args.stepId));
+        return s2.toggleBreakpoint(String(args.stepId));
       case "deleteStep":
-        return s.deleteStep(String(args.stepId));
+        return s2.deleteStep(String(args.stepId));
       case "updateStep":
-        return s.updateStep(String(args.stepId), args.patch ?? {});
+        return s2.updateStep(String(args.stepId), args.patch ?? {});
       case "record":
-        return s.setRecording(Boolean(args.on));
+        return s2.setRecording(Boolean(args.on));
       case "moveStep":
-        return s.moveStep(String(args.stepId), Number(args.toIndex));
+        return s2.moveStep(String(args.stepId), Number(args.toIndex));
       case "replay":
-        return s.replay();
+        return s2.replay();
     }
   }
   /** Shared by every door — the local route, the hosted command, and the
@@ -5335,11 +5838,25 @@ var DebugCoordinator = class {
       const steps = await session.finish();
       const flow = this.deps.store.getFlow(flowId);
       if (!flow) return { ok: false, error: "flow not found" };
-      this.deps.store.extractSecrets(flow.slug, steps);
+      if (this.deps.commit.to === "caller") {
+        const { scratch } = this.deps.commit;
+        const before = scratch.readSecrets();
+        scratch.extractSecrets(flow.slug, steps);
+        const after = scratch.readSecrets();
+        const captured = {};
+        for (const [ref, value] of Object.entries(after)) {
+          if (before[ref] !== value) captured[ref] = value;
+        }
+        const updated2 = { ...flow, steps, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        this.deps.emit({ type: "debug.ended", flowId, committed: true });
+        return { ok: true, committed: true, flow: updated2, secrets: captured };
+      }
+      const { store } = this.deps.commit;
+      store.extractSecrets(flow.slug, steps);
       const updated = { ...flow, steps, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      this.deps.store.saveFlow(updated);
+      store.saveFlow(updated);
       this.deps.emit({ type: "debug.ended", flowId, committed: true });
-      return { ok: true, committed: true, flow: { ...updated, path: this.deps.store.relPath(updated) } };
+      return { ok: true, committed: true, flow: { ...updated, path: store.relPath(updated) } };
     } finally {
       this.deps.lease?.release("debug");
     }
@@ -5356,7 +5873,7 @@ async function verifyFlowSteps(deps, opts) {
   const { store } = deps;
   const flow = store.getFlow(opts.flowId);
   if (!flow) throw new FlowNotFound("flow not found");
-  const steps = (opts.steps ?? flow.steps).map((s) => RecordedStepSchema.parse(s));
+  const steps = (opts.steps ?? flow.steps).map((s2) => RecordedStepSchema.parse(s2));
   if (!opts.verifyIds.length) return { results: [], error: null, failedAtStepId: null, ok: true };
   const baseUrl = store.baseUrlFor(flow);
   const claim = deps.lease?.acquire("run");
@@ -5717,16 +6234,16 @@ var EventJournal = class {
     return this.state ? this.state.size() : this.events.length;
   }
 };
-var { DatabaseSync } = createRequire2(import.meta.url)("node:sqlite");
+var { DatabaseSync } = createRequire3(import.meta.url)("node:sqlite");
 var AgentState = class {
   constructor(file, deviceId, commandLimit = 1e5) {
     this.commandLimit = commandLimit;
     if (!file || file === ":memory:") throw new Error("a persistent agent state file is required");
     if (!Number.isInteger(commandLimit) || commandLimit < 1) throw new Error("invalid command capacity");
-    fs5.mkdirSync(path5.dirname(file), { recursive: true, mode: 448 });
-    const fd = fs5.openSync(file, "a", 384);
-    fs5.closeSync(fd);
-    fs5.chmodSync(file, 384);
+    fs6.mkdirSync(path5.dirname(file), { recursive: true, mode: 448 });
+    const fd = fs6.openSync(file, "a", 384);
+    fs6.closeSync(fd);
+    fs6.chmodSync(file, 384);
     this.db = new DatabaseSync(file);
     try {
       this.db.exec("PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL;");
@@ -5770,7 +6287,7 @@ var AgentState = class {
   static fingerprint(command) {
     const canonical = (value) => {
       if (Array.isArray(value)) return value.map(canonical);
-      if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, v]) => [key, canonical(v)]));
+      if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b2]) => a.localeCompare(b2)).map(([key, v]) => [key, canonical(v)]));
       return value;
     };
     const { expiresAt: _expiry, issuedAt: _issued, ...work } = command;
@@ -5917,15 +6434,11 @@ var Agent = class {
       );
     }
     const delivered = command.args["flow"];
-    const produces = command.name.startsWith("record.") || command.name === "run.cancel";
-    const project = this.opts.projects.find((p) => p.id === command.projectId) ?? (delivered || produces ? { id: command.projectId, name: String(delivered?.name ?? command.projectId), root: "" } : void 0);
-    if (!project) {
-      return this.refuse(
-        command.id,
-        "unknown_project",
-        "this device has no project mapped under that name"
-      );
-    }
+    const project = this.opts.projects.find((p) => p.id === command.projectId) ?? {
+      id: command.projectId,
+      name: String(delivered?.name ?? command.projectId),
+      root: ""
+    };
     const allowed = this.opts.authorise?.(command) ?? { ok: true };
     if (!allowed.ok) return this.refuse(command.id, allowed.reason);
     if (this.closed) return this.refuse(command.id, "storage_unavailable", "the agent is closed");
@@ -6218,11 +6731,16 @@ var scratchRoots = /* @__PURE__ */ new Map();
 function scratchRoot(projectId) {
   let root = scratchRoots.get(projectId);
   if (!root) {
-    root = fs23.mkdtempSync(path23.join(os2.tmpdir(), `flowriki-record-${projectId.replace(/[^\w-]/g, "")}-`));
+    root = fs23.mkdtempSync(path24.join(os2.tmpdir(), `flowriki-record-${projectId.replace(/[^\w-]/g, "")}-`));
     scratchRoots.set(projectId, root);
   }
   return root;
 }
+var NO_CHECKOUT = {
+  ok: false,
+  reason: "failed",
+  detail: "this machine has no checkout of that project \u2014 clone it and start the agent with that folder"
+};
 function buildHandlers(deps) {
   const { storeFor, storage = null, onActivity, lease, recorder } = deps;
   const debugging = deps.debugger;
@@ -6230,6 +6748,7 @@ function buildHandlers(deps) {
   const cancels = /* @__PURE__ */ new Map();
   return {
     "project.list": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
       const full = command.args["documents"] === true;
       return {
@@ -6254,6 +6773,7 @@ function buildHandlers(deps) {
       };
     },
     "flow.get": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
       const flow = store.getFlow(String(command.args["flowId"] ?? ""));
       if (!flow) return { ok: false, reason: "failed", detail: "no such flow in this project" };
@@ -6265,7 +6785,7 @@ function buildHandlers(deps) {
           // has to be able to say "this flow cannot run until you set the
           // password" without the password ever leaving this machine.
           unresolvedSecrets: store.unresolvedSecrets(flow),
-          boundSecrets: flow.steps.filter((s) => s.secret && s.secretRef).map((s) => s.secretRef).filter((ref) => store.readSecrets()[ref] !== void 0)
+          boundSecrets: flow.steps.filter((s2) => s2.secret && s2.secretRef).map((s2) => s2.secretRef).filter((ref) => store.readSecrets()[ref] !== void 0)
         }
       };
     },
@@ -6288,6 +6808,7 @@ function buildHandlers(deps) {
       return { ok: true, result: { ...await storage.runStats(Number(command.args["days"] ?? 7)) } };
     },
     "flow.save": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       if (command.flowRevision === void 0) {
         return { ok: false, reason: "stale_revision", detail: "supply the revision being edited; new flows require create:true and revision 0" };
       }
@@ -6317,6 +6838,7 @@ function buildHandlers(deps) {
     // keyboard. The file stays in the machine's own git repository — the
     // service never gets a copy to diverge from.
     "flow.update": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       if (command.flowRevision === void 0) {
         return { ok: false, reason: "stale_revision", detail: "this edit needs the revision it was opened from \u2014 reload the flow" };
       }
@@ -6354,6 +6876,7 @@ function buildHandlers(deps) {
     // rather than the command, the service persists no command at all, and
     // neither the result below nor any event carries the value back.
     "secret.set": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
       const ref = String(command.args["ref"] ?? "");
       const value = command.args["value"];
@@ -6373,6 +6896,7 @@ function buildHandlers(deps) {
     // from the CLI or the local app — which, for anybody who had only ever
     // used the hosted service, was none.
     "feature.create": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
       const name = String(command.args["name"] ?? "").trim();
       if (!name) return { ok: false, reason: "failed", detail: "a feature name is required" };
@@ -6385,6 +6909,7 @@ function buildHandlers(deps) {
       }
     },
     "flow.delete": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
       const flowId = String(command.args["flowId"] ?? "");
       if (!store.getFlow(flowId)) return { ok: true, result: { deleted: false } };
@@ -6395,6 +6920,7 @@ function buildHandlers(deps) {
     // command because the whole point is to check an edit nobody has saved —
     // saving is gated on this passing.
     "flow.verify": async (command, project, emit) => {
+      if (!project.root) return NO_CHECKOUT;
       if (!deps.verify) {
         return { ok: false, reason: "failed", detail: "this agent cannot verify steps \u2014 no browser is configured" };
       }
@@ -6423,13 +6949,23 @@ function buildHandlers(deps) {
     // The browser opens on this machine and the panel lives inside that window,
     // so whoever is at the keyboard sees the same state the dashboard does.
     "debug.start": async (command, project) => {
+      const carried = command.args["flow"];
+      if (!carried && !project.root) return NO_CHECKOUT;
       if (!debugging) {
         return { ok: false, reason: "failed", detail: "this agent cannot debug \u2014 no browser is configured" };
       }
       try {
         const started = await debugging.start(String(command.args["flowId"] ?? ""), {
           ...command.args["breakpoints"] ? { breakpoints: command.args["breakpoints"] } : {},
-          ...command.args["watch"] === void 0 ? {} : { watch: Boolean(command.args["watch"]) }
+          ...command.args["watch"] === void 0 ? {} : { watch: Boolean(command.args["watch"]) },
+          ...carried ? {
+            delivered: {
+              flow: carried,
+              secrets: command.args["secrets"] ?? {},
+              config: command.args["config"] ?? {},
+              scratchRoot: scratchRoot(project.id)
+            }
+          } : {}
         });
         onActivity?.({ kind: "debugging", projectId: project.id, detail: started.flowId });
         return { ok: true, result: started };
@@ -6471,6 +7007,7 @@ function buildHandlers(deps) {
       }
     },
     "config.save": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
       try {
         store.writeConfig(command.args["config"]);
@@ -6483,6 +7020,7 @@ function buildHandlers(deps) {
     // committed, and the answer is what lets the service tell "not set up yet"
     // apart from "set up, but you are in the wrong clone".
     "project.status": async (_command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       if (!deps.binding) {
         return { ok: false, reason: "failed", detail: "this agent cannot inspect a repository" };
       }
@@ -6491,6 +7029,7 @@ function buildHandlers(deps) {
     // Write the marker, commit it, push it. Everything here happens with the
     // person's own git credentials, on their own machine.
     "project.claim": async (command, project) => {
+      if (!project.root) return NO_CHECKOUT;
       if (!deps.binding) {
         return { ok: false, reason: "failed", detail: "this agent cannot write to a repository" };
       }
@@ -6555,7 +7094,10 @@ function buildHandlers(deps) {
               runId = String(event.runId ?? "");
               if (runId) cancels.set(runId, cancels.get(command.id));
             }
-            emit(`run.${event.type}`, event);
+            emit(`run.${event.type}`, {
+              ...event,
+              projectId: project.id
+            });
           }
         });
         return {
@@ -6688,7 +7230,7 @@ function buildHandlers(deps) {
       const artifact = run.artifacts.find((a) => a.id === artifactId);
       if (!artifact) return { ok: false, reason: "failed", detail: "no such artifact on that run" };
       const dir = run.artifactsDir ?? runArtifactsDir(runId, run.projectId);
-      const file = path23.join(dir, artifact.relPath);
+      const file = path24.join(dir, artifact.relPath);
       if (!isInside(dir, file) || !fs23.existsSync(file) || !isInside(fs23.realpathSync(dir), fs23.realpathSync(file))) {
         return { ok: false, reason: "failed", detail: "the artifact file is not on this machine" };
       }
@@ -6734,8 +7276,10 @@ function createAgentRuntime(options) {
   const debuggerFor = (projectRoot) => {
     let existing = debuggers.get(projectRoot);
     if (!existing) {
+      const store = new Store(projectRoot);
       existing = new DebugCoordinator({
-        store: new Store(projectRoot),
+        store,
+        commit: { to: "disk", store },
         emit: (event) => {
           journal?.append({ name: `debug.${event.type.replace(/^debug\./, "")}`, data: event });
         }
@@ -6744,10 +7288,24 @@ function createAgentRuntime(options) {
     }
     return existing;
   };
+  const deliveredDebugger = (delivered) => new DebugCoordinator({
+    store: deliveredRun({
+      flow: delivered.flow,
+      secrets: delivered.secrets,
+      config: delivered.config
+    }),
+    // Handed back rather than written, and redacted on the way out through
+    // a scratch store — somewhere for extraction to put a password typed
+    // during the session, so it does not travel inside the document.
+    commit: { to: "caller", scratch: new Store(delivered.scratchRoot) },
+    emit: (event) => {
+      journal?.append({ name: `debug.${event.type.replace(/^debug\./, "")}`, data: event });
+    }
+  });
   const debugControl = {
     start: async (flowId, opts) => {
       if (debuggingIn?.active()) throw new Error("a debug session is already running on this machine");
-      const coordinator = debuggerFor(options.projects[0].root);
+      const coordinator = opts.delivered ? deliveredDebugger(opts.delivered) : debuggerFor(options.projects[0].root);
       const started = await coordinator.start(flowId, opts);
       debuggingIn = coordinator;
       return started;
@@ -6847,15 +7405,15 @@ function createAgentRuntime(options) {
 }
 
 // src/engine.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path7 from "path";
 
 // src/credentials.ts
 import crypto3 from "crypto";
-import fs7 from "fs";
+import fs8 from "fs";
 
 // src/paths.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import os3 from "os";
 import path6 from "path";
 function dataDir(env = process.env) {
@@ -6873,10 +7431,10 @@ function dataDir(env = process.env) {
 }
 function ensureDataDir(env = process.env) {
   const dir = dataDir(env);
-  fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
     try {
-      fs6.chmodSync(dir, 448);
+      fs7.chmodSync(dir, 448);
     } catch {
     }
   }
@@ -6889,7 +7447,7 @@ var ledgerPath = (deviceId, env = process.env) => path6.join(dataDir(env), `ledg
 // src/credentials.ts
 function readFile(env = process.env) {
   try {
-    const raw = JSON.parse(fs7.readFileSync(credentialsPath(env), "utf8"));
+    const raw = JSON.parse(fs8.readFileSync(credentialsPath(env), "utf8"));
     if (Array.isArray(raw.connections)) return { version: 3, connections: raw.connections };
     const older = Array.isArray(raw.devices) ? raw.devices : raw.deviceId ? [raw] : [];
     const connections = older.filter((d) => d.deviceId && d.secret).map((d) => ({
@@ -6919,8 +7477,8 @@ function saveConnection(connection, env = process.env) {
     connections: [...readFile(env).connections.filter((c) => c.service !== connection.service), connection]
   };
   const temporary = `${file}.${process.pid}.tmp`;
-  fs7.writeFileSync(temporary, JSON.stringify(next, null, 2) + "\n", { mode: 384 });
-  fs7.renameSync(temporary, file);
+  fs8.writeFileSync(temporary, JSON.stringify(next, null, 2) + "\n", { mode: 384 });
+  fs8.renameSync(temporary, file);
 }
 function forgetConnection(service, env = process.env) {
   const before = readFile(env).connections;
@@ -6929,8 +7487,8 @@ function forgetConnection(service, env = process.env) {
   ensureDataDir(env);
   const file = credentialsPath(env);
   const temporary = `${file}.${process.pid}.tmp`;
-  fs7.writeFileSync(temporary, JSON.stringify({ version: 3, connections: after }, null, 2) + "\n", { mode: 384 });
-  fs7.renameSync(temporary, file);
+  fs8.writeFileSync(temporary, JSON.stringify({ version: 3, connections: after }, null, 2) + "\n", { mode: 384 });
+  fs8.renameSync(temporary, file);
   return true;
 }
 var fingerprint = (secret) => crypto3.createHash("sha256").update(secret).digest("hex").slice(0, 12);
@@ -6957,7 +7515,7 @@ function resolveService(explicit, env = process.env) {
 }
 
 // src/lock.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import os4 from "os";
 function takeLock(env = process.env) {
   ensureDataDir(env);
@@ -6965,20 +7523,20 @@ function takeLock(env = process.env) {
   const mine = { pid: process.pid, since: (/* @__PURE__ */ new Date()).toISOString(), host: os4.hostname() };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      fs8.writeFileSync(file, JSON.stringify(mine), { flag: "wx", mode: 384 });
+      fs9.writeFileSync(file, JSON.stringify(mine), { flag: "wx", mode: 384 });
       return { ok: true, lock: { release: () => releaseLock(file, mine.pid) } };
     } catch {
       const held = readLock(file);
       if (!held) {
         try {
-          fs8.rmSync(file, { force: true });
+          fs9.rmSync(file, { force: true });
         } catch {
         }
         continue;
       }
       if (held.host === mine.host && !alive(held.pid)) {
         try {
-          fs8.rmSync(file, { force: true });
+          fs9.rmSync(file, { force: true });
         } catch {
         }
         continue;
@@ -6990,7 +7548,7 @@ function takeLock(env = process.env) {
 }
 function readLock(file) {
   try {
-    const held = JSON.parse(fs8.readFileSync(file, "utf8"));
+    const held = JSON.parse(fs9.readFileSync(file, "utf8"));
     return typeof held.pid === "number" ? { pid: held.pid, since: held.since ?? "", host: held.host ?? "" } : null;
   } catch {
     return null;
@@ -7009,7 +7567,7 @@ function releaseLock(file, pid) {
   const held = readLock(file);
   if (held?.pid === pid) {
     try {
-      fs8.rmSync(file, { force: true });
+      fs9.rmSync(file, { force: true });
     } catch {
     }
   }
@@ -7038,7 +7596,7 @@ function openBrowser(url, env = process.env) {
 }
 
 // src/engine.ts
-var AGENT_VERSION = "0.1.0-beta.6";
+var AGENT_VERSION = "0.1.0-beta.8";
 async function connect(options = {}) {
   let service;
   try {
@@ -7122,7 +7680,7 @@ function resolveCheckouts(dirs) {
   const skipped = [];
   for (const dir of dirs) {
     const root = path7.resolve(dir);
-    if (!fs9.existsSync(root)) {
+    if (!fs10.existsSync(root)) {
       skipped.push({ root, why: "no such folder" });
       continue;
     }
@@ -7186,11 +7744,21 @@ async function start(options = {}) {
   if (projects.length !== (connection.checkouts ?? []).length || options.projects?.length) {
     saveConnection({ ...connection, checkouts: projects.map((p) => p.root) });
   }
+  const storage = new SqliteStorage();
+  try {
+    await storage.init();
+  } catch (error) {
+    options.onProgress?.({
+      kind: "warning",
+      message: `run history is unavailable on this machine \u2014 ${error.message}`
+    });
+  }
   const agent = createAgentRuntime({
     deviceId: connection.deviceId,
     agentVersion: AGENT_VERSION,
     stateFile: ledgerPath(connection.deviceId),
     projects,
+    storage,
     onEvent: (event) => options.onProgress?.({ kind: event.name, message: "", detail: event.data })
   });
   const link = new AgentLink({
@@ -7221,7 +7789,7 @@ async function prepareBrowsers() {
   }
   let cli;
   try {
-    cli = createRequire3(import.meta.url).resolve("playwright/cli.js");
+    cli = createRequire4(import.meta.url).resolve("playwright/cli.js");
   } catch {
     return {
       ok: false,
@@ -7259,7 +7827,7 @@ function status(serviceArg) {
     ...connection ? { deviceId: connection.deviceId, machineName: connection.machineName, connectedAt: connection.connectedAt } : {},
     checkouts: [
       ...projects.map((p) => ({ root: p.root, project: p.name })),
-      ...skipped.map((s) => ({ root: s.root, project: null, why: s.why }))
+      ...skipped.map((s2) => ({ root: s2.root, project: null, why: s2.why }))
     ],
     running
   };
@@ -7307,7 +7875,7 @@ async function doctor(serviceArg) {
 function inspectPlaywright() {
   try {
     const browsersPath = process.env["PLAYWRIGHT_BROWSERS_PATH"] ?? (process.platform === "win32" ? path7.join(os5.homedir(), "AppData", "Local", "ms-playwright") : process.platform === "darwin" ? path7.join(os5.homedir(), "Library", "Caches", "ms-playwright") : path7.join(os5.homedir(), ".cache", "ms-playwright"));
-    const chromiumInstalled = fs9.existsSync(browsersPath) ? fs9.readdirSync(browsersPath).some((d) => d.startsWith("chromium")) : false;
+    const chromiumInstalled = fs10.existsSync(browsersPath) ? fs10.readdirSync(browsersPath).some((d) => d.startsWith("chromium")) : false;
     return { version: null, browsersPath, chromiumInstalled };
   } catch {
     return { version: null, browsersPath: null, chromiumInstalled: null };