@flowriki/agent 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/{chunk-RNHUFS2Q.js → chunk-QGSEWMJE.js}

@@ -1,33 +1,449 @@
 #!/usr/bin/env node
 
-// src/engine.ts
-import os5 from "os";
-import { createRequire as createRequire4 } from "module";
+// src/engine/machine.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { createRequire } from "module";
 import { spawnSync } from "child_process";
+var AGENT_VERSION = "0.1.0-beta.9";
+async function prepareBrowsers() {
+  if (browsersReady()) {
+    return { ok: true, already: true, message: "chromium is already installed" };
+  }
+  let cli;
+  try {
+    cli = createRequire(import.meta.url).resolve("playwright/cli.js");
+  } catch {
+    return {
+      ok: false,
+      already: false,
+      message: "playwright is not installed beside this agent \u2014 reinstall it"
+    };
+  }
+  const run = spawnSync(process.execPath, [cli, "install", "chromium"], { stdio: "inherit" });
+  if (run.status !== 0) {
+    return {
+      ok: false,
+      already: false,
+      message: `could not install chromium (exit ${run.status ?? "unknown"}) \u2014 try \`npx playwright@${playwrightVersion() ?? "latest"} install chromium\` yourself`
+    };
+  }
+  return { ok: browsersReady(), already: false, message: "chromium installed" };
+}
+function browsersReady() {
+  return inspectPlaywright().chromiumInstalled === true;
+}
+function playwrightVersion() {
+  return inspectPlaywright().version;
+}
+function inspectPlaywright() {
+  try {
+    const browsersPath = process.env["PLAYWRIGHT_BROWSERS_PATH"] ?? (process.platform === "win32" ? path.join(os.homedir(), "AppData", "Local", "ms-playwright") : process.platform === "darwin" ? path.join(os.homedir(), "Library", "Caches", "ms-playwright") : path.join(os.homedir(), ".cache", "ms-playwright"));
+    const chromiumInstalled = fs.existsSync(browsersPath) ? fs.readdirSync(browsersPath).some((d) => d.startsWith("chromium")) : false;
+    return { version: null, browsersPath, chromiumInstalled };
+  } catch {
+    return { version: null, browsersPath: null, chromiumInstalled: null };
+  }
+}
 
-// ../agent-core/dist/index.js
-import { z as z4 } from "zod";
-import fs6 from "fs";
-import path5 from "path";
-import crypto22 from "crypto";
-import { createRequire as createRequire3 } from "module";
-import { WebSocket, WebSocketServer } from "ws";
-import fs23 from "fs";
+// src/engine/connection.ts
+import os3 from "os";
+
+// src/credentials.ts
+import crypto2 from "crypto";
+import fs3 from "fs";
+
+// src/paths.ts
+import fs2 from "fs";
 import os2 from "os";
-import path24 from "path";
+import path2 from "path";
+function dataDir(env = process.env) {
+  const override = env["FLOWRIKI_HOME"]?.trim();
+  if (override) return path2.resolve(override);
+  if (process.platform === "win32") {
+    const appData = env["APPDATA"]?.trim();
+    return appData ? path2.join(appData, "Flowriki") : path2.join(os2.homedir(), "AppData", "Roaming", "Flowriki");
+  }
+  if (process.platform === "darwin") {
+    return path2.join(os2.homedir(), "Library", "Application Support", "Flowriki");
+  }
+  const state = env["XDG_STATE_HOME"]?.trim();
+  return state ? path2.join(state, "flowriki") : path2.join(os2.homedir(), ".local", "state", "flowriki");
+}
+function ensureDataDir(env = process.env) {
+  const dir = dataDir(env);
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") {
+    try {
+      fs2.chmodSync(dir, 448);
+    } catch {
+    }
+  }
+  return dir;
+}
+var credentialsPath = (env = process.env) => path2.join(dataDir(env), "credentials.json");
+var lockPath = (env = process.env) => path2.join(dataDir(env), "agent.lock");
+var ledgerPath = (deviceId, env = process.env) => path2.join(dataDir(env), `ledger-${deviceId}.sqlite`);
+
+// src/credentials.ts
+function readFile(env = process.env) {
+  try {
+    const raw = JSON.parse(fs3.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) => ({
+      service: (d.url ?? "").replace(/^ws/, "http").replace(/\/agent$/, ""),
+      deviceId: d.deviceId,
+      secret: d.secret,
+      machineName: "this machine",
+      connectedAt: d.pairedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      ...d.checkouts ? { checkouts: d.checkouts } : {}
+    })).filter((c) => c.service);
+    return { version: 3, connections };
+  } catch {
+    return { version: 3, connections: [] };
+  }
+}
+function connectionFor(service, env = process.env) {
+  return readFile(env).connections.find((c) => c.service === service) ?? null;
+}
+function allConnections(env = process.env) {
+  return readFile(env).connections;
+}
+function saveConnection(connection, env = process.env) {
+  ensureDataDir(env);
+  const file = credentialsPath(env);
+  const next = {
+    version: 3,
+    connections: [...readFile(env).connections.filter((c) => c.service !== connection.service), connection]
+  };
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs3.writeFileSync(temporary, JSON.stringify(next, null, 2) + "\n", { mode: 384 });
+  fs3.renameSync(temporary, file);
+}
+function forgetConnection(service, env = process.env) {
+  const before = readFile(env).connections;
+  const after = before.filter((c) => c.service !== service);
+  if (after.length === before.length) return false;
+  ensureDataDir(env);
+  const file = credentialsPath(env);
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs3.writeFileSync(temporary, JSON.stringify({ version: 3, connections: after }, null, 2) + "\n", { mode: 384 });
+  fs3.renameSync(temporary, file);
+  return true;
+}
+var fingerprint = (secret) => crypto2.createHash("sha256").update(secret).digest("hex").slice(0, 12);
+
+// ../contracts/dist/chunk-PMU57KFW.js
+import { z } from "zod";
+var PROTOCOL_VERSION = 1;
+var PAIRING_CODE_TTL_MS = 5 * 60 * 1e3;
+var JOURNAL_LIMIT = 1e3;
+var CommandNameSchema = z.enum([
+  "record.start",
+  "record.stop",
+  "record.discard",
+  "record.status",
+  "record.dialog",
+  "flow.run",
+  "flow.save",
+  "flow.update",
+  "flow.delete",
+  "flow.verify",
+  "flow.get",
+  "debug.start",
+  "debug.status",
+  "debug.command",
+  "debug.end",
+  "config.save",
+  "run.cancel",
+  "feature.create",
+  "secret.set",
+  "project.list",
+  "project.status",
+  "project.claim",
+  "runs.list",
+  "runs.stats",
+  "run.get",
+  "artifact.fetch"
+]);
+var EFFECTFUL = /* @__PURE__ */ new Set([
+  "record.start",
+  "record.stop",
+  "record.discard",
+  // Answering a dialog is a click on the page under test. Re-delivering it
+  // after a dropped socket would answer the NEXT dialog with the previous
+  // reply — `record.status` stays out of this set because reading is safe to
+  // repeat, and that is the whole distinction.
+  "record.dialog",
+  "flow.run",
+  "flow.save",
+  "flow.update",
+  "flow.delete",
+  // Verification and a debug session both open a browser on somebody's machine
+  // and both can be told to record steps into a draft. Neither is a read.
+  "flow.verify",
+  "debug.start",
+  "debug.command",
+  "debug.end",
+  "config.save",
+  // Setting a secret writes a file. Idempotent — the same value written twice
+  // is the same value — but it is a write, and the deduplication path is the
+  // right default for one.
+  "secret.set",
+  // Creating a feature makes a directory and a file. A blind retry after a
+  // dropped socket would find it already there and report a failure for
+  // something that had in fact succeeded.
+  "feature.create",
+  // Claiming writes a file, makes a commit and pushes. Blind retry after a
+  // dropped socket would commit twice.
+  "project.claim",
+  "run.cancel"
+]);
+var CommandSchema = z.object({
+  /** Unique per command. The agent stores it, so a redelivery after a
+   *  reconnect is recognised rather than performed twice. */
+  id: z.string().min(1).max(128),
+  v: z.number().int().positive(),
+  name: CommandNameSchema,
+  /** Which project on the agent's machine. Never a path — a name the user has
+   *  explicitly mapped, so the service cannot reach arbitrary files. */
+  projectId: z.string().min(1),
+  /** The revision the caller believes it is acting on, where that matters. A
+   *  save built on a stale copy is refused rather than applied. */
+  flowRevision: z.number().int().nonnegative().optional(),
+  /** Wall-clock expiry. A command that surfaced from a queue an hour late must
+   *  not start a browser on somebody's machine. */
+  expiresAt: z.number().int().positive(),
+  /** When the service stamped this, by the service's clock.
+   *
+   * Present so the agent never has to compare a timestamp minted on another
+   * machine against its own clock. `expiresAt` alone made the deadline
+   * meaningless the moment two clocks disagreed: a machine running five
+   * minutes fast rejected every command the instant it arrived, saying it had
+   * expired before it got there — which is true only if you believe both
+   * clocks. Optional, so an older service that does not send it still works;
+   * the agent falls back to the absolute deadline it has always used. */
+  issuedAt: z.number().int().positive().optional(),
+  args: z.record(z.unknown()).default({})
+  // UNKNOWN FIELDS ARE IGNORED, not refused.
+  //
+  // Strictness here looked like caution and was a compatibility trap: the day
+  // the service added `issuedAt`, every agent older than that release began
+  // refusing every command as unrecognised — over a field it had no need to
+  // read. The allowlist on command NAMES is the security boundary and is
+  // unchanged; which extra keys ride along is not, because nothing acts on a
+  // field it does not know about.
+});
+var AckSchema = z.object({
+  type: z.literal("ack"),
+  commandId: z.string().min(1),
+  /** `accepted` means the agent has taken the work on, not that it finished.
+   *  `duplicate` means it has done this exact command before and is returning
+   *  the first outcome. */
+  status: z.enum(["accepted", "duplicate", "refused"]),
+  reason: z.string().optional(),
+  result: z.record(z.unknown()).optional()
+}).strict();
+var AgentEventSchema = z.object({
+  type: z.literal("event"),
+  /** Monotonic per agent connection-independent stream. A client that
+   *  reconnects says which sequence it last saw and is sent the rest. */
+  seq: z.number().int().nonnegative(),
+  at: z.number().int().nonnegative(),
+  name: z.string().min(1),
+  commandId: z.string().optional(),
+  sessionId: z.string().optional(),
+  runId: z.string().optional(),
+  data: z.record(z.unknown()).default({})
+}).strict();
+var GapSchema = z.object({
+  type: z.literal("gap"),
+  from: z.number().int().nonnegative(),
+  to: z.number().int().nonnegative()
+}).strict();
+var HelloSchema = z.object({
+  type: z.literal("hello"),
+  protocolVersion: z.number().int().positive(),
+  agentVersion: z.string(),
+  deviceId: z.string().min(1),
+  projects: z.array(z.object({ id: z.string(), name: z.string() })).default([])
+}).strict();
+var AgentMessageSchema = z.discriminatedUnion("type", [
+  AckSchema,
+  AgentEventSchema,
+  GapSchema,
+  HelloSchema
+]);
+
+// ../contracts/dist/index.js
+import { z as z2 } from "zod";
+var MARKER_PATH = ".flowriki/project.json";
+var ProjectMarkerSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  projectId: z2.string().min(1),
+  /** Shown to people, and NOT covered by the signature.
+   *
+   * Deliberate: projects get renamed, and signing the name would invalidate the
+   * marker in every existing clone the moment somebody did. Anything reading
+   * this must present it as what the file says rather than as something
+   * checked - the id is the verified identity. */
+  name: z2.string(),
+  boundAt: z2.string(),
+  /** The repository's first commit at the moment of binding.
+   *
+   * This is what ties the marker to THIS history rather than to any folder
+   * somebody pastes it into. Null only where the repository had no commits at
+   * all when it was claimed. */
+  rootCommit: z2.string().nullable(),
+  /** `v1:ed25519:<base64url>` */
+  signature: z2.string()
+});
+var PRODUCTION_SERVICE = "https://flowriki-cloud.onrender.com";
+
+// src/service.ts
+var BadServiceUrl = class extends Error {
+};
+function resolveService(explicit, env = process.env) {
+  const raw = explicit?.trim() || env["FLOWRIKI_SERVICE_URL"]?.trim() || PRODUCTION_SERVICE;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new BadServiceUrl(`"${raw}" is not a URL \u2014 expected something like https://flowriki.example`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new BadServiceUrl(`"${raw}" is not http or https`);
+  }
+  const loopback = ["localhost", "127.0.0.1", "[::1]", "::1"].includes(url.hostname);
+  if (url.protocol === "http:" && !loopback) {
+    throw new BadServiceUrl(`refusing to use plain http for ${url.hostname} \u2014 a device credential would cross the network in the clear`);
+  }
+  return url.origin + (url.pathname === "/" ? "" : url.pathname.replace(/\/+$/, ""));
+}
+
+// src/open-browser.ts
+import { spawn } from "child_process";
+function canOpenBrowser(env = process.env) {
+  if (process.platform === "win32" || process.platform === "darwin") return true;
+  return Boolean(env["DISPLAY"] || env["WAYLAND_DISPLAY"]);
+}
+function openBrowser(url, env = process.env) {
+  if (!canOpenBrowser(env)) return "no-display";
+  try {
+    if (process.platform === "win32") {
+      spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true, windowsHide: true }).unref();
+    } else if (process.platform === "darwin") {
+      spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+    } else {
+      spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+    }
+    return "opened";
+  } catch {
+    return "failed";
+  }
+}
+
+// src/engine/connection.ts
+async function connect(options = {}) {
+  let service;
+  try {
+    service = resolveService(options.service);
+  } catch (error) {
+    return { ok: false, reason: "refused", message: error.message };
+  }
+  const existing = connectionFor(service);
+  if (existing) {
+    const still = await verifyConnection(existing).catch(() => false);
+    if (still) return { ok: true, connection: existing, reused: true };
+    options.onProgress?.({
+      kind: "stale",
+      message: "the stored connection is no longer accepted \u2014 asking for a new one"
+    });
+  }
+  const machineName = options.machineName?.trim() || `${os3.userInfo().username}@${os3.hostname()}`;
+  let asked;
+  try {
+    const res = await fetch(`${service}/api/pairing-requests`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ machineName, agentVersion: AGENT_VERSION }),
+      signal: options.signal ?? null
+    });
+    if (!res.ok) {
+      return { ok: false, reason: "refused", message: `${service} refused the request (${res.status})` };
+    }
+    asked = await res.json();
+  } catch (error) {
+    return { ok: false, reason: "unreachable", message: `could not reach ${service} \u2014 ${error.message}` };
+  }
+  const approve = `${service}${asked.approveUrl}`;
+  options.onProgress?.({
+    kind: "approve",
+    message: "waiting for approval in your browser",
+    detail: { url: approve, machineName, canOpen: options.open !== false && canOpenBrowser() }
+  });
+  if (options.open !== false) openBrowser(approve);
+  const pollMs = options.pollMs ?? 1500;
+  const deadline = Date.now() + (options.timeoutMs ?? 10 * 60 * 1e3);
+  while (Date.now() < deadline) {
+    if (options.signal?.aborted) return { ok: false, reason: "aborted", message: "cancelled" };
+    const res = await fetch(`${service}/api/pairing-requests/${encodeURIComponent(asked.requestId)}/claim`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ claim: asked.claim })
+    }).catch(() => null);
+    if (res?.status === 200) {
+      const granted = await res.json();
+      const connection = {
+        service,
+        deviceId: granted.deviceId,
+        secret: granted.secret,
+        machineName,
+        connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...existing?.checkouts ? { checkouts: existing.checkouts } : {}
+      };
+      saveConnection(connection);
+      return { ok: true, connection, reused: false };
+    }
+    if (res && res.status !== 202) {
+      const body = await res.json().catch(() => ({}));
+      return { ok: false, reason: "refused", message: body.error ?? `refused (${res.status})` };
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return { ok: false, reason: "expired", message: "nobody approved this in time" };
+}
+async function verifyConnection(connection) {
+  const res = await fetch(`${connection.service}/api/agent-check`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ deviceId: connection.deviceId, secret: connection.secret })
+  });
+  if (res.status === 404) return true;
+  return res.ok;
+}
+
+// src/engine/checkouts.ts
+import fs8 from "fs";
+import path8 from "path";
+
+// ../execution/dist/index.js
+import fs7 from "fs";
+import path7 from "path";
 
-// ../orchestrator/dist/index.js
-import fs5 from "fs";
-import path4 from "path";
+// ../engine-playwright/dist/index.js
+import { chromium, firefox, webkit } from "playwright";
 
-// ../protocol/dist/chunk-ROEX7TWK.js
-import { z } from "zod";
-var LocatorOverrideSchema = z.object({
-  strategy: z.enum(["css", "xpath", "id", "testId", "text", "label", "placeholder", "altText", "title"]),
-  value: z.string()
+// ../test-model/dist/chunk-ROEX7TWK.js
+import { z as z3 } from "zod";
+var LocatorOverrideSchema = z3.object({
+  strategy: z3.enum(["css", "xpath", "id", "testId", "text", "label", "placeholder", "altText", "title"]),
+  value: z3.string()
 }).strict();
-var CaptureModeSchema = z.enum(["off", "on-failure", "always"]);
-var ArtifactPolicySchema = z.object({
+var CaptureModeSchema = z3.enum(["off", "on-failure", "always"]);
+var ArtifactPolicySchema = z3.object({
   /** Masked before the shutter opens — password fields are covered. */
   screenshot: CaptureModeSchema.optional(),
   /** NOT maskable. A video shows every character typed, so a flow holding a
@@ -38,33 +454,33 @@ var ArtifactPolicySchema = z.object({
   trace: CaptureModeSchema.optional(),
   /** Cheap, small, and the first thing anyone asks for when a step fails for
    * no visible reason. */
-  console: z.boolean().optional(),
+  console: z3.boolean().optional(),
   /** How many runs keep their artifacts. Video is megabytes per run, so an
    * unbounded history fills a disk quietly. */
-  retainRuns: z.number().int().positive().max(1e4).optional(),
+  retainRuns: z3.number().int().positive().max(1e4).optional(),
   /** Deliberate opt-out of the secret guard, for a project with nothing to
    * protect. Off by default: leaking a password into a video that nobody
    * thinks of as sensitive is not a mistake worth making by accident. */
-  allowUnmaskedArtifacts: z.boolean().optional()
+  allowUnmaskedArtifacts: z3.boolean().optional()
 }).strict();
-var ExecutionEnvironmentSchema = z.object({
-  browser: z.enum(["chromium", "firefox", "webkit"]).optional(),
-  viewport: z.object({ width: z.number().int().positive(), height: z.number().int().positive() }).optional(),
-  locale: z.string().optional(),
-  timezoneId: z.string().optional(),
-  colorScheme: z.enum(["light", "dark", "no-preference"]).optional(),
+var ExecutionEnvironmentSchema = z3.object({
+  browser: z3.enum(["chromium", "firefox", "webkit"]).optional(),
+  viewport: z3.object({ width: z3.number().int().positive(), height: z3.number().int().positive() }).optional(),
+  locale: z3.string().optional(),
+  timezoneId: z3.string().optional(),
+  colorScheme: z3.enum(["light", "dark", "no-preference"]).optional(),
   /** How long a single step may take to find its target and act. */
-  timeoutMs: z.number().int().positive().max(3e5).optional(),
+  timeoutMs: z3.number().int().positive().max(3e5).optional(),
   /** How long a page load or history traversal may take. Separate from the
    * step timeout on purpose: "this page is slow to load" and "this element
    * does not exist" are different problems, and one number for both made
    * every real site fail during load rather than during the assertion. */
-  navigationTimeoutMs: z.number().int().positive().max(3e5).optional(),
+  navigationTimeoutMs: z3.number().int().positive().max(3e5).optional(),
   /** How long an assertion may wait for the state it expects. Usually shorter
    * than a step — an outcome that has not appeared quickly usually is not
    * coming — but slow back ends need it raised. */
-  assertionTimeoutMs: z.number().int().positive().max(3e5).optional(),
-  openClosedShadowRoots: z.boolean().optional(),
+  assertionTimeoutMs: z3.number().int().positive().max(3e5).optional(),
+  openClosedShadowRoots: z3.boolean().optional(),
   /** Let the browser window take the whole screen, and the page take the whole
    *  window.
    *
@@ -76,20 +492,20 @@ var ExecutionEnvironmentSchema = z.object({
    *
    * Recorded ON the flow, like the rest of the environment, so a run always
    * says which of the two it was. */
-  fullWindow: z.boolean().optional()
+  fullWindow: z3.boolean().optional()
 }).strict();
-var RecordedTargetSchema = z.object({
-  role: z.string(),
-  name: z.string(),
-  scope: z.string().optional(),
-  scopeRole: z.string().optional(),
-  frame: z.array(z.string()).optional(),
-  pageId: z.string().optional(),
-  nameFrom: z.enum(["adjacent-label", "text"]).optional(),
+var RecordedTargetSchema = z3.object({
+  role: z3.string(),
+  name: z3.string(),
+  scope: z3.string().optional(),
+  scopeRole: z3.string().optional(),
+  frame: z3.array(z3.string()).optional(),
+  pageId: z3.string().optional(),
+  nameFrom: z3.enum(["adjacent-label", "text"]).optional(),
   locator: LocatorOverrideSchema.optional(),
-  nth: z.number().int().nonnegative().optional()
+  nth: z3.number().int().nonnegative().optional()
 });
-var RecordedAssertionKindSchema = z.enum([
+var RecordedAssertionKindSchema = z3.enum([
   // Proposed automatically from a page-signature diff. Heuristic shapes, not
   // things a person picks by name.
   "screen",
@@ -115,679 +531,299 @@ var RecordedAssertionKindSchema = z.enum([
   "title",
   "heading"
 ]);
-var AssertionOpSchema = z.enum(["equals", "contains", "matches", "gt", "gte", "lt", "lte"]);
-var RecordedAssertionSchema = z.object({
+var AssertionOpSchema = z3.enum(["equals", "contains", "matches", "gt", "gte", "lt", "lte"]);
+var RecordedAssertionSchema = z3.object({
   kind: RecordedAssertionKindSchema,
-  value: z.union([z.string(), z.array(z.string())]),
+  value: z3.union([z3.string(), z3.array(z3.string())]),
   /** Defaults to "equals" when absent, so older flows keep their meaning. */
   op: AssertionOpSchema.optional(),
   /** Negates the whole assertion, which is what gives every reading a mirror
    *  without doubling the catalogue. `visible` + `not` IS `hidden`. */
-  not: z.boolean().optional(),
+  not: z3.boolean().optional(),
   /** Which attribute, for kind "attribute". Ignored otherwise. */
-  attr: z.string().optional(),
+  attr: z3.string().optional(),
   /** A failure records the check and lets the run carry on, instead of
    *  stopping the flow. Chosen by whoever authored the assertion: some checks
    *  are the point of the test and some are worth knowing about. */
-  soft: z.boolean().optional(),
-  why: z.string().optional(),
-  enabled: z.boolean().optional(),
-  confidence: z.enum(["low", "high"]).optional(),
+  soft: z3.boolean().optional(),
+  why: z3.string().optional(),
+  enabled: z3.boolean().optional(),
+  confidence: z3.enum(["low", "high"]).optional(),
   target: RecordedTargetSchema.optional()
-}).strict();
-var PageSignatureSchema = z.object({
-  url: z.string(),
-  title: z.string(),
-  heading: z.string(),
-  alerts: z.array(z.string()),
-  fields: z.array(z.string()),
-  /** Every short piece of visible text on the page, each tagged with enough
-   * identity to tell two elements apart.
-   *
-   * The generic net beneath `alerts`, which only sees a message when the page
-   * announced itself with role=alert or a class we happened to guess — so a
-   * bare <div id="error">Your username is invalid!</div> was invisible to it.
-   *
-   * `key` exists because comparing bare strings is not enough: a page that
-   * quotes its own error message in body copy (a docs page, help text, an
-   * empty state) already contains that string before anything happens, so the
-   * real message appearing looked like nothing had changed. The key is used
-   * ONLY to diff two snapshots of the same page a moment apart — never to
-   * find an element, which stays role + accessible name. */
-  texts: z.array(z.object({ key: z.string(), text: z.string() })).default([])
-});
-var AssertionKindSchema = z.enum(["screen", "message", "heading", "fields_visible"]);
-var AssertionSchema = z.object({
-  id: z.string(),
-  kind: AssertionKindSchema,
-  value: z.union([z.string(), z.array(z.string())]),
-  /** Human-readable reason it was proposed — shown next to the tick box. */
-  why: z.string().optional(),
-  /** Present only on INFERRED proposals — ones derived from a text diff rather
-   * than from something the page stated about itself. They arrive unticked,
-   * because a guess that silently becomes a passing assertion is worse than no
-   * assertion: it makes the suite look green for a reason nobody chose. */
-  confidence: z.literal("low").optional(),
-  /** Unticked assertions stay in the file as a record of what was offered. */
-  enabled: z.boolean().default(true),
-  source: z.enum(["proposed", "manual"]).default("proposed")
-});
-var AssertionProposalSchema = AssertionSchema.omit({ id: true, enabled: true, source: true });
-var FeatureSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: z.string(),
-  /** Directory name. Stable even when the display name is edited. */
-  slug: z.string(),
-  name: z.string(),
-  description: z.string().default(""),
-  /** Manual ordering in the UI; ties break by name. */
-  order: z.number().int().default(0),
-  createdAt: z.string(),
-  createdBy: z.string().default("")
-});
-var SECRET_REF_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
-var isSecretRefName = (value) => SECRET_REF_PATTERN.test(value);
-var ScrollPrerequisiteSchema = z.object({
-  x: z.number(),
-  y: z.number(),
-  container: RecordedTargetSchema.optional(),
-  legacySelector: z.string().optional()
-}).strict();
-var DialogAnswerSchema = z.object({
-  type: z.enum(["alert", "confirm", "prompt", "beforeunload"]),
-  message: z.string(),
-  accept: z.boolean(),
-  promptText: z.string().optional()
-}).strict();
-var RecordedStepSchema = RecordedTargetSchema.extend({
-  id: z.string().min(1),
-  type: z.enum(["fill", "select", "click", "dblclick", "rightclick", "drag", "check", "press", "hover", "upload", "scroll", "back", "forward", "navigate", "closePage", "unsupported", "setRange", "assert"]),
-  scope: z.string(),
-  value: z.string(),
-  secret: z.boolean(),
-  legacySelector: z.string(),
-  proposals: z.array(RecordedAssertionSchema),
-  values: z.array(z.string()).optional(),
-  to: RecordedTargetSchema.optional(),
-  manual: z.boolean().optional(),
-  verified: z.boolean().optional(),
-  /** Skip this step without deleting it.
-   *
-   * There is a real gap between "this step is wrong" and "this field is broken
-   * today". Deleting is the only way to express the second without this, which
-   * loses the step's identity, its assertions and its place in the order — and
-   * the person then has to re-record it once the field is fixed.
-   *
-   * Absent means enabled, so every flow recorded before this stays enabled
-   * without a migration. */
-  disabled: z.boolean().optional(),
-  /** How long a single step may take to find its target and act. */
-  timeoutMs: z.number().int().positive().max(3e5).optional(),
-  /** How long a page load or history traversal may take. Separate from the
-   * step timeout on purpose: "this page is slow to load" and "this element
-   * does not exist" are different problems, and one number for both made
-   * every real site fail during load rather than during the assertion. */
-  navigationTimeoutMs: z.number().int().positive().max(3e5).optional(),
-  /** How long an assertion may wait for the state it expects. Usually shorter
-   * than a step — an outcome that has not appeared quickly usually is not
-   * coming — but slow back ends need it raised. */
-  assertionTimeoutMs: z.number().int().positive().max(3e5).optional(),
-  // Popups are bound to the action that created them; subsequent steps use pageId.
-  opensPage: z.string().optional(),
-  dialogs: z.array(DialogAnswerSchema).optional(),
-  downloads: z.array(z.string()).optional(),
-  warning: z.string().optional(),
-  scroll: ScrollPrerequisiteSchema.optional(),
-  /** The NAME of a secret held outside this document.
-   *
-   * Explicit, because `secret: true` with the reference living in `value` made
-   * a reference and a password the same shape. Nothing could then tell an
-   * unresolvable reference from a leaked literal, and the code that tried
-   * guessed from whether the local secret store happened to contain the key —
-   * so on a machine that had never held the secret, a perfectly good reference
-   * was "healed" into a password whose value was its own name.
-   *
-   * When this is set, `value` is empty and carries nothing: the secret is
-   * looked up by this name at run time, and a name that is not on this machine
-   * stays unresolved and is reported, never invented. */
-  secretRef: z.string().regex(SECRET_REF_PATTERN).optional()
-}).strict();
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-var CURRENT_SCHEMA_VERSION = 5;
-var FlowDocumentSchema = z.object({
-  schemaVersion: z.literal(CURRENT_SCHEMA_VERSION),
-  id: z.string().min(1),
-  featureId: z.string().min(1),
-  name: z.string().min(1),
-  slug: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  /** Where this flow starts, when it is pinned to somewhere of its own.
-   *
-   * OPTIONAL, and normally absent. The origin belongs to the project, not to
-   * each flow: a flow that carries its own hard-codes an environment into a
-   * git-tracked file, and the POC proved how that ends — an ephemeral port,
-   * `http://127.0.0.1:65226/`, committed and unrunnable on any other machine.
-   * Absent means "the project's base URL", which is what a flow recorded today
-   * stores. Present is honoured, so every flow recorded before this keeps
-   * working exactly as it did. */
-  baseUrl: z.string().url().optional(),
-  /** The route, resolved against whichever base URL applies. */
-  startPath: z.string(),
-  recordedAt: z.string(),
-  recordedBy: z.string(),
-  updatedAt: z.string(),
-  steps: z.array(RecordedStepSchema),
-  environment: ExecutionEnvironmentSchema.optional(),
-  path: z.string().optional(),
-  /** Bumped on every save. An edit carries the revision it was made against,
-   *  so a save built on a stale copy is refused instead of overwriting work
-   *  somebody else — or a debug session on the same machine — has since done.
-   *  Documents written before this default to 0. */
-  revision: z.number().int().nonnegative().default(0)
-}).strict().superRefine((flow, ctx) => {
-  const ids = /* @__PURE__ */ new Set();
-  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 = (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 (s2[key] !== void 0) t[key] = s2[key];
-  }
-  return t;
-}
-function migrateScrollPrerequisites(doc) {
-  const steps = Array.isArray(doc.steps) ? doc.steps : [];
-  const out = [];
-  const pending = [];
-  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) {
-    if (isScroll(step)) {
-      const previous = pending.at(-1);
-      const same = previous && !hasChecks(previous) && !hasChecks(step) && surfaceOf(previous) === surfaceOf(step) && containerOf(previous) === containerOf(step) && Boolean(previous["disabled"]) === Boolean(step["disabled"]);
-      if (same) pending[pending.length - 1] = step;
-      else pending.push(step);
-      continue;
-    }
-    const last = pending.at(-1);
-    if (last && !hasChecks(last) && !step["scroll"] && surfaceOf(last) === surfaceOf(step) && Boolean(last["disabled"]) === Boolean(step["disabled"])) {
-      step["scroll"] = carry(pending.pop());
-    }
-    for (const p of pending.splice(0)) out.push(p);
-    out.push(step);
-  }
-  for (const p of pending.splice(0)) out.push(p);
-  doc.steps = out;
-}
-function migrateRadioCheckedState(doc) {
-  for (const step of Array.isArray(doc.steps) ? doc.steps : []) {
-    if (step["type"] === "check" && step["role"] === "radio" && step["value"] === "") step["value"] = "true";
-  }
-}
-function migrateExplicitSecretRefs(doc) {
-  for (const step of Array.isArray(doc.steps) ? doc.steps : []) {
-    if (step["secret"] !== true) continue;
-    if (typeof step["secretRef"] === "string" && step["secretRef"]) continue;
-    const value = typeof step["value"] === "string" ? step["value"] : "";
-    if (value && isSecretRefName(value)) {
-      step["secretRef"] = value;
-      step["value"] = "";
-    }
-  }
-}
-function migrateBareModifierPresses(doc) {
-  const MODIFIERS = ["Meta", "Control", "Alt", "Shift"];
-  const invented = (step) => step["type"] === "press" && typeof step["value"] === "string" && MODIFIERS.some((m) => step["value"] === `${m}+${m}` || step["value"] === m);
-  doc.steps = (Array.isArray(doc.steps) ? doc.steps : []).filter((step) => !invented(step));
-}
-var MIGRATIONS = {
-  2: (doc) => {
-    migrateScrollPrerequisites(doc);
-    migrateRadioCheckedState(doc);
-  },
-  3: migrateExplicitSecretRefs,
-  4: migrateBareModifierPresses
-};
-function parseFlowDocument(input) {
-  const raw = structuredClone(input);
-  let version = typeof raw?.schemaVersion === "number" ? raw.schemaVersion : 2;
-  if (version > CURRENT_SCHEMA_VERSION) {
-    throw new Error(
-      `this flow was written by a newer version of Flowriki (schema ${version}, this build understands ${CURRENT_SCHEMA_VERSION}) \u2014 upgrade to open it`
-    );
-  }
-  while (version < CURRENT_SCHEMA_VERSION) {
-    const migrate = MIGRATIONS[version];
-    if (!migrate) throw new Error(`no migration path from schema version ${version}`);
-    migrate(raw);
-    version += 1;
-    raw.schemaVersion = version;
-  }
-  return FlowDocumentSchema.parse(raw);
-}
-
-// ../protocol/dist/chunk-S4QJBHEH.js
-import { z as z2 } from "zod";
-var EngineSchema = z2.enum(["chromium", "firefox", "webkit"]);
-var CapabilitySchema = z2.object({
-  id: z2.string(),
-  provider: z2.string().default("local"),
-  engine: EngineSchema,
-  /** Branded local builds: "chrome", "msedge". */
-  channel: z2.string().optional(),
-  browserVersion: z2.string().optional(),
-  os: z2.string().optional(),
-  osVersion: z2.string().optional(),
-  device: z2.string().optional(),
-  viewport: z2.object({ width: z2.number().int(), height: z2.number().int() }).optional()
-});
-var ExecutionConfigSchema = z2.object({
-  concurrency: z2.number().int().positive().default(4),
-  defaultBrowser: z2.string().default("chromium"),
-  retries: z2.number().int().nonnegative().default(0),
-  browsers: z2.record(z2.string(), CapabilitySchema.omit({ id: true }).partial({ provider: true })),
-  suites: z2.record(
-    z2.string(),
-    z2.object({
-      flows: z2.array(z2.string()).default([]),
-      browser: z2.string().optional(),
-      /** Opt-in cross-browser fan-out for this suite only. */
-      matrix: z2.array(z2.string()).optional()
-    })
-  ).default({})
-});
-var RunStatusSchema = z2.enum([
-  "queued",
-  "running",
-  "passed",
-  "failed",
-  "cancelled",
-  "errored"
-]);
-var TaskStatusSchema = z2.enum([
-  "queued",
-  "running",
-  "passed",
-  "failed",
-  "skipped",
-  "cancelled",
-  "errored"
-]);
-var FailureKindSchema = z2.enum([
-  "not_found",
-  "ambiguous",
-  "timeout",
-  "assertion",
-  "navigation",
-  "crash",
-  "unknown"
-]);
-var RunCheckSchema = z2.object({
-  id: z2.string(),
-  assertionId: z2.string().nullable(),
-  kind: z2.string(),
-  expected: z2.string().nullable(),
-  actual: z2.string().nullable(),
-  ok: z2.boolean(),
-  /** A failed soft check is reported but does not fail its step, so a run can
-   *  be green and still carry findings. Stored per check rather than derived,
-   *  because the flow it came from can be edited afterwards and history has to
-   *  keep saying what actually happened. */
-  soft: z2.boolean().default(false),
-  detail: z2.string().nullable()
-});
-var RunStepSchema = z2.object({
-  id: z2.string(),
-  ordinal: z2.number().int().nonnegative(),
-  /** The STABLE document step id — this is what joins runs across time and
-   * makes flake-rate a view over existing columns rather than a migration. */
-  stepId: z2.string(),
-  action: z2.string(),
-  targetRole: z2.string().nullable(),
-  targetName: z2.string().nullable(),
-  targetScope: z2.string().nullable(),
-  /** What the step typed, chose or pressed.
-   *
-   * A report that says `fill "Password"` and nothing else cannot tell you
-   * whether the run used the right credentials, which is most of what anyone
-   * reads a report to find out.
-   *
-   * NEVER set for a secret — see `secret` below. A run report is the thing
-   * people paste into a ticket. */
-  value: z2.string().nullable().default(null),
-  /** The step typed a secret, so `value` is deliberately absent rather than
-   *  merely unknown. Stored, because "no value" and "a value withheld" render
-   *  differently and history has to keep saying which it was. */
-  secret: z2.boolean().default(false),
-  status: z2.enum(["passed", "failed", "skipped"]),
-  failureKind: FailureKindSchema.nullable(),
-  detail: z2.string().nullable(),
-  durationMs: z2.number().int().nonnegative().nullable(),
-  /** Where the browser was when this step ran. Recorded on failure, and
-   * frequently the whole answer — the element is missing because a step
-   * before it navigated somewhere unexpected, not because it was renamed. */
-  pageUrl: z2.string().nullable().default(null),
-  pageTitle: z2.string().nullable().default(null),
-  checks: z2.array(RunCheckSchema).default([])
-});
-var RunTaskSchema = z2.object({
-  id: z2.string(),
-  ordinal: z2.number().int().nonnegative(),
-  caseName: z2.string(),
-  rowId: z2.string().nullable(),
-  capability: CapabilitySchema,
-  provider: z2.string(),
-  attempt: z2.number().int().positive().default(1),
-  maxAttempts: z2.number().int().positive().default(1),
-  status: TaskStatusSchema,
-  workerId: z2.string().nullable(),
-  /** Cloud provider's own session, so a failure is one click from their video. */
-  sessionId: z2.string().nullable(),
-  sessionUrl: z2.string().nullable(),
-  detail: z2.string().nullable(),
-  stepsRun: z2.number().int().nonnegative().default(0),
-  stepsTotal: z2.number().int().nonnegative().default(0),
-  durationMs: z2.number().int().nonnegative().nullable(),
-  steps: z2.array(RunStepSchema).default([])
-});
-var ArtifactKindSchema = z2.enum(["screenshot", "video", "trace", "console", "har"]);
-var ArtifactSchema = z2.object({
-  id: z2.string(),
-  runId: z2.string(),
-  runStepId: z2.string().nullable(),
-  kind: ArtifactKindSchema,
-  relPath: z2.string(),
-  bytes: z2.number().int().nonnegative().nullable(),
-  masked: z2.boolean().default(false),
-  createdAt: z2.string()
-});
-var RunSummarySchema = z2.object({
-  id: z2.string(),
-  projectId: z2.string(),
-  /** What the run was FOR.
-   *
-   * `flake` is a deliberate repetition of one flow to measure how often it
-   * passes. It is kept out of pass-rate statistics: a 98/100 flakiness check is
-   * a useful finding, not a failing suite, and counting it as one would make
-   * measuring reliability look like losing it. */
-  kind: z2.enum(["smoke", "test", "adhoc", "flake"]),
-  trigger: z2.enum(["ui", "cli", "ci"]),
-  status: RunStatusSchema,
-  flowId: z2.string().nullable(),
-  flowName: z2.string().nullable(),
-  gitSha: z2.string().nullable(),
-  gitBranch: z2.string().nullable(),
-  gitDirty: z2.boolean().default(false),
-  env: z2.string().nullable(),
-  concurrency: z2.number().int().positive().nullable(),
-  tasksTotal: z2.number().int().nonnegative().default(0),
-  tasksPassed: z2.number().int().nonnegative().default(0),
-  tasksFailed: z2.number().int().nonnegative().default(0),
-  /** Rolled up from the run's tasks rather than stored on the run, so they
-   * cannot drift from the step rows they describe. "9 of 12" in a list is
-   * what tells a reader where a run died; "1 of 1 tasks" tells them nothing
-   * until there is more than one browser in play. */
-  stepsRun: z2.number().int().nonnegative().default(0),
-  stepsTotal: z2.number().int().nonnegative().default(0),
-  queuedAt: z2.string(),
-  startedAt: z2.string().nullable(),
-  finishedAt: z2.string().nullable(),
-  durationMs: z2.number().int().nonnegative().nullable()
+}).strict();
+var PageSignatureSchema = z3.object({
+  url: z3.string(),
+  title: z3.string(),
+  heading: z3.string(),
+  alerts: z3.array(z3.string()),
+  fields: z3.array(z3.string()),
+  /** Every short piece of visible text on the page, each tagged with enough
+   * identity to tell two elements apart.
+   *
+   * The generic net beneath `alerts`, which only sees a message when the page
+   * announced itself with role=alert or a class we happened to guess — so a
+   * bare <div id="error">Your username is invalid!</div> was invisible to it.
+   *
+   * `key` exists because comparing bare strings is not enough: a page that
+   * quotes its own error message in body copy (a docs page, help text, an
+   * empty state) already contains that string before anything happens, so the
+   * real message appearing looked like nothing had changed. The key is used
+   * ONLY to diff two snapshots of the same page a moment apart — never to
+   * find an element, which stays role + accessible name. */
+  texts: z3.array(z3.object({ key: z3.string(), text: z3.string() })).default([])
 });
-var RunDetailSchema = RunSummarySchema.extend({
-  errorMessage: z2.string().nullable(),
-  artifactsDir: z2.string().nullable(),
-  tasks: z2.array(RunTaskSchema).default([]),
-  /** Screenshots and the like, addressed by `runStepId`. Kept flat rather than
-   * nested inside each step: an artifact can belong to the run as a whole. */
-  artifacts: z2.array(ArtifactSchema).default([])
+var AssertionKindSchema = z3.enum(["screen", "message", "heading", "fields_visible"]);
+var AssertionSchema = z3.object({
+  id: z3.string(),
+  kind: AssertionKindSchema,
+  value: z3.union([z3.string(), z3.array(z3.string())]),
+  /** Human-readable reason it was proposed — shown next to the tick box. */
+  why: z3.string().optional(),
+  /** Present only on INFERRED proposals — ones derived from a text diff rather
+   * than from something the page stated about itself. They arrive unticked,
+   * because a guess that silently becomes a passing assertion is worse than no
+   * assertion: it makes the suite look green for a reason nobody chose. */
+  confidence: z3.literal("low").optional(),
+  /** Unticked assertions stay in the file as a record of what was offered. */
+  enabled: z3.boolean().default(true),
+  source: z3.enum(["proposed", "manual"]).default("proposed")
 });
-
-// ../protocol/dist/index.js
-import { z as z3 } from "zod";
-var MARKER_PATH = ".flowriki/project.json";
-var ProjectMarkerSchema = z3.object({
+var AssertionProposalSchema = AssertionSchema.omit({ id: true, enabled: true, source: true });
+var FeatureSchema = z3.object({
   schemaVersion: z3.literal(1),
-  projectId: z3.string().min(1),
-  /** Shown to people, and NOT covered by the signature.
-   *
-   * Deliberate: projects get renamed, and signing the name would invalidate the
-   * marker in every existing clone the moment somebody did. Anything reading
-   * this must present it as what the file says rather than as something
-   * checked - the id is the verified identity. */
+  id: z3.string(),
+  /** Directory name. Stable even when the display name is edited. */
+  slug: z3.string(),
   name: z3.string(),
-  boundAt: z3.string(),
-  /** The repository's first commit at the moment of binding.
-   *
-   * This is what ties the marker to THIS history rather than to any folder
-   * somebody pastes it into. Null only where the repository had no commits at
-   * all when it was claimed. */
-  rootCommit: z3.string().nullable(),
-  /** `v1:ed25519:<base64url>` */
-  signature: z3.string()
+  description: z3.string().default(""),
+  /** Manual ordering in the UI; ties break by name. */
+  order: z3.number().int().default(0),
+  createdAt: z3.string(),
+  createdBy: z3.string().default("")
 });
-var PRODUCTION_SERVICE = "https://flowriki-cloud.onrender.com";
-
-// ../core/dist/index.js
-function proposeAssertions(before, after) {
-  const out = [];
-  if (!before || !after) return out;
-  if (before.url !== after.url)
-    out.push({
-      kind: "screen",
-      value: after.heading || after.title,
-      why: "navigated to a new screen"
-    });
-  for (const a of after.alerts.filter((x) => !before.alerts.includes(x)))
-    out.push({ kind: "message", value: a, why: "a message appeared that was not there before" });
-  if (before.url === after.url && before.heading !== after.heading && after.heading)
-    out.push({ kind: "heading", value: after.heading, why: "the heading changed in place" });
-  const newFields = after.fields.filter((f) => !before.fields.includes(f));
-  if (newFields.length)
-    out.push({ kind: "fields_visible", value: newFields, why: "new fields became visible" });
-  if (before.url === after.url) {
-    const seenKeys = new Set(before.texts.map((t) => t.key));
-    const covered = /* @__PURE__ */ new Set([after.heading, ...after.alerts]);
-    const appeared = after.texts.filter((t) => !seenKeys.has(t.key) && !covered.has(t.text));
-    for (const t of appeared.slice(0, 2))
-      out.push({
-        kind: "message",
-        value: t.text,
-        why: "this text appeared after the action",
-        confidence: "low"
-      });
-  }
-  return out;
-}
-function hasObservableChange(before, after) {
-  return proposeAssertions(before, after).some((p) => p.confidence !== "low");
-}
-function isLocalHost(host) {
-  const h = host.toLowerCase();
-  return h === "localhost" || h.endsWith(".localhost") || h === "127.0.0.1" || h === "[::1]" || h === "0.0.0.0";
-}
-function hasScheme(raw) {
-  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(raw)) return true;
-  return /^[a-zA-Z][a-zA-Z0-9+.-]*:(?!\d)/.test(raw);
+var SECRET_REF_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+var isSecretRefName = (value) => SECRET_REF_PATTERN.test(value);
+var ScrollPrerequisiteSchema = z3.object({
+  x: z3.number(),
+  y: z3.number(),
+  container: RecordedTargetSchema.optional(),
+  legacySelector: z3.string().optional()
+}).strict();
+var DialogAnswerSchema = z3.object({
+  type: z3.enum(["alert", "confirm", "prompt", "beforeunload"]),
+  message: z3.string(),
+  accept: z3.boolean(),
+  promptText: z3.string().optional()
+}).strict();
+var RecordedStepSchema = RecordedTargetSchema.extend({
+  id: z3.string().min(1),
+  type: z3.enum(["fill", "select", "click", "dblclick", "rightclick", "drag", "check", "press", "hover", "upload", "scroll", "back", "forward", "navigate", "closePage", "unsupported", "setRange", "assert"]),
+  scope: z3.string(),
+  value: z3.string(),
+  secret: z3.boolean(),
+  legacySelector: z3.string(),
+  proposals: z3.array(RecordedAssertionSchema),
+  values: z3.array(z3.string()).optional(),
+  to: RecordedTargetSchema.optional(),
+  manual: z3.boolean().optional(),
+  verified: z3.boolean().optional(),
+  /** Skip this step without deleting it.
+   *
+   * There is a real gap between "this step is wrong" and "this field is broken
+   * today". Deleting is the only way to express the second without this, which
+   * loses the step's identity, its assertions and its place in the order — and
+   * the person then has to re-record it once the field is fixed.
+   *
+   * Absent means enabled, so every flow recorded before this stays enabled
+   * without a migration. */
+  disabled: z3.boolean().optional(),
+  /** How long a single step may take to find its target and act. */
+  timeoutMs: z3.number().int().positive().max(3e5).optional(),
+  /** How long a page load or history traversal may take. Separate from the
+   * step timeout on purpose: "this page is slow to load" and "this element
+   * does not exist" are different problems, and one number for both made
+   * every real site fail during load rather than during the assertion. */
+  navigationTimeoutMs: z3.number().int().positive().max(3e5).optional(),
+  /** How long an assertion may wait for the state it expects. Usually shorter
+   * than a step — an outcome that has not appeared quickly usually is not
+   * coming — but slow back ends need it raised. */
+  assertionTimeoutMs: z3.number().int().positive().max(3e5).optional(),
+  // Popups are bound to the action that created them; subsequent steps use pageId.
+  opensPage: z3.string().optional(),
+  dialogs: z3.array(DialogAnswerSchema).optional(),
+  downloads: z3.array(z3.string()).optional(),
+  warning: z3.string().optional(),
+  scroll: ScrollPrerequisiteSchema.optional(),
+  /** The NAME of a secret held outside this document.
+   *
+   * Explicit, because `secret: true` with the reference living in `value` made
+   * a reference and a password the same shape. Nothing could then tell an
+   * unresolvable reference from a leaked literal, and the code that tried
+   * guessed from whether the local secret store happened to contain the key —
+   * so on a machine that had never held the secret, a perfectly good reference
+   * was "healed" into a password whose value was its own name.
+   *
+   * When this is set, `value` is empty and carries nothing: the secret is
+   * looked up by this name at run time, and a name that is not on this machine
+   * stays unresolved and is reported, never invented. */
+  secretRef: z3.string().regex(SECRET_REF_PATTERN).optional()
+}).strict();
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function normalizeStartUrl(input) {
-  const raw = (input ?? "").trim();
-  if (!raw) throw new Error("enter a URL to record against");
-  let candidate;
-  if (hasScheme(raw)) {
-    candidate = raw;
-  } else {
-    const bare = raw.replace(/^\/+/, "");
-    const host = bare.split(/[/?#]/)[0] ?? "";
-    candidate = `${isLocalHost(host.split(":")[0] ?? "") ? "http" : "https"}://${bare}`;
-  }
-  let parsed;
-  try {
-    parsed = new URL(candidate);
-  } catch {
-    throw new Error(`"${raw}" is not a valid URL`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(`only http:// and https:// URLs can be recorded (got ${parsed.protocol}//)`);
+var CURRENT_SCHEMA_VERSION = 5;
+var FlowDocumentSchema = z3.object({
+  schemaVersion: z3.literal(CURRENT_SCHEMA_VERSION),
+  id: z3.string().min(1),
+  featureId: z3.string().min(1),
+  name: z3.string().min(1),
+  slug: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  /** Where this flow starts, when it is pinned to somewhere of its own.
+   *
+   * OPTIONAL, and normally absent. The origin belongs to the project, not to
+   * each flow: a flow that carries its own hard-codes an environment into a
+   * git-tracked file, and the POC proved how that ends — an ephemeral port,
+   * `http://127.0.0.1:65226/`, committed and unrunnable on any other machine.
+   * Absent means "the project's base URL", which is what a flow recorded today
+   * stores. Present is honoured, so every flow recorded before this keeps
+   * working exactly as it did. */
+  baseUrl: z3.string().url().optional(),
+  /** The route, resolved against whichever base URL applies. */
+  startPath: z3.string(),
+  recordedAt: z3.string(),
+  recordedBy: z3.string(),
+  updatedAt: z3.string(),
+  steps: z3.array(RecordedStepSchema),
+  environment: ExecutionEnvironmentSchema.optional(),
+  path: z3.string().optional(),
+  /** Bumped on every save. An edit carries the revision it was made against,
+   *  so a save built on a stale copy is refused instead of overwriting work
+   *  somebody else — or a debug session on the same machine — has since done.
+   *  Documents written before this default to 0. */
+  revision: z3.number().int().nonnegative().default(0)
+}).strict().superRefine((flow, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  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 = (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 (s2[key] !== void 0) t[key] = s2[key];
   }
-  if (!parsed.hostname) throw new Error(`"${raw}" has no host`);
-  return parsed.toString();
-}
-function resolveStartUrl(baseUrl, startPath) {
-  const base = normalizeStartUrl(baseUrl);
-  return new URL(startPath || "/", base).toString();
+  return t;
 }
-var INPUT_ROLES = /* @__PURE__ */ new Set(["textbox", "combobox", "checkbox", "radio", "spinbutton", "searchbox"]);
-var NAVIGATIONS = /* @__PURE__ */ new Set(["back", "forward"]);
-function locatorPlan(step) {
-  const o = step.locator;
-  if (o && o.value.trim()) {
-    const value = o.value.trim();
-    switch (o.strategy) {
-      // Playwright reads a leading `xpath=` prefix, and also bare paths that
-      // start with `/` or `//`. Normalising here means the QA can paste either.
-      case "xpath":
-        return { method: "locator", arg: value.startsWith("xpath=") ? value : `xpath=${value}`, overridden: true };
-      // Typed as a bare id, so nobody has to remember the `#`.
-      case "id":
-        return { method: "locator", arg: /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(value.replace(/^#/, "")) ? `#${value.replace(/^#/, "")}` : `[id=${JSON.stringify(value.replace(/^#/, ""))}]`, overridden: true };
-      case "css":
-        return { method: "locator", arg: value, overridden: true };
-      case "testId":
-        return { method: "getByTestId", arg: value, overridden: true };
-      case "text":
-        return { method: "getByText", arg: value, exact: true, overridden: true };
-      case "label":
-        return { method: "getByLabel", arg: value, exact: true, overridden: true };
-      case "placeholder":
-        return { method: "getByPlaceholder", arg: value, exact: true, overridden: true };
-      case "altText":
-        return { method: "getByAltText", arg: value, exact: true, overridden: true };
-      case "title":
-        return { method: "getByTitle", arg: value, exact: true, overridden: true };
+function migrateScrollPrerequisites(doc) {
+  const steps = Array.isArray(doc.steps) ? doc.steps : [];
+  const out = [];
+  const pending = [];
+  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) {
+    if (isScroll(step)) {
+      const previous = pending.at(-1);
+      const same = previous && !hasChecks(previous) && !hasChecks(step) && surfaceOf(previous) === surfaceOf(step) && containerOf(previous) === containerOf(step) && Boolean(previous["disabled"]) === Boolean(step["disabled"]);
+      if (same) pending[pending.length - 1] = step;
+      else pending.push(step);
+      continue;
     }
+    const last = pending.at(-1);
+    if (last && !hasChecks(last) && !step["scroll"] && surfaceOf(last) === surfaceOf(step) && Boolean(last["disabled"]) === Boolean(step["disabled"])) {
+      step["scroll"] = carry(pending.pop());
+    }
+    for (const p of pending.splice(0)) out.push(p);
+    out.push(step);
   }
-  if (NAVIGATIONS.has(step.type)) {
-    return { method: step.type === "back" ? "goBack" : "goForward", arg: "", overridden: false };
-  }
-  if (!step.name.trim()) return { method: "none", arg: "", overridden: false };
-  if (step.nameFrom === "adjacent-label") {
-    return {
-      method: "getByText",
-      arg: step.name,
-      exact: true,
-      overridden: false,
-      viaAdjacentLabel: true
-    };
-  }
-  if (step.nameFrom === "text") {
-    return {
-      method: "getByText",
-      arg: step.name,
-      exact: step.type !== "hover",
-      overridden: false,
-      visible: true
-    };
-  }
-  return INPUT_ROLES.has(step.role) ? { method: "getByLabel", arg: step.name, exact: true, overridden: false, inputRole: step.role } : step.role ? { method: "getByRole", arg: step.role, name: step.name, exact: true, overridden: false } : { method: "getByText", arg: step.name, exact: step.type !== "hover", overridden: false, visible: true };
+  for (const p of pending.splice(0)) out.push(p);
+  doc.steps = out;
 }
-function frameSelector(name) {
-  const positional = /^nth:(\d+)$/.exec(name);
-  if (positional) return `iframe, frame >> nth=${positional[1]}`;
-  const v = JSON.stringify(name);
-  return `iframe[title=${v}], iframe[name=${v}], iframe[id=${v}], frame[title=${v}], frame[name=${v}], frame[id=${v}]`;
+function migrateRadioCheckedState(doc) {
+  for (const step of Array.isArray(doc.steps) ? doc.steps : []) {
+    if (step["type"] === "check" && step["role"] === "radio" && step["value"] === "") step["value"] = "true";
+  }
 }
-function inputSelector(role) {
-  return role === "textbox" ? 'input, textarea, [contenteditable="true"], [role="textbox"]' : `input, select, [role="${role}"]`;
+function migrateExplicitSecretRefs(doc) {
+  for (const step of Array.isArray(doc.steps) ? doc.steps : []) {
+    if (step["secret"] !== true) continue;
+    if (typeof step["secretRef"] === "string" && step["secretRef"]) continue;
+    const value = typeof step["value"] === "string" ? step["value"] : "";
+    if (value && isSecretRefName(value)) {
+      step["secretRef"] = value;
+      step["value"] = "";
+    }
+  }
 }
-var SCOPE_ROLES = ["form", "group", "region", "dialog", "alertdialog"];
-var CHECKS = [
-  { id: "visible", label: "is visible", kind: "visible", group: "state" },
-  { id: "not-visible", label: "is not visible", kind: "visible", not: true, group: "state" },
-  { id: "attached", label: "exists on the page", kind: "attached", group: "state" },
-  { id: "not-attached", label: "does not exist", kind: "attached", not: true, group: "state" },
-  { id: "enabled", label: "is enabled", kind: "enabled", group: "state" },
-  { id: "disabled", label: "is disabled", kind: "enabled", not: true, group: "state" },
-  { id: "editable", label: "is editable", kind: "editable", group: "state" },
-  { id: "readonly", label: "is read-only", kind: "editable", not: true, group: "state" },
-  { id: "focused", label: "is focused", kind: "focused", group: "state" },
-  { id: "checked", label: "is checked", kind: "checked", value: "true", group: "state" },
-  { id: "unchecked", label: "is not checked", kind: "checked", value: "false", group: "state" },
-  { id: "text", label: "text is exactly", kind: "text", input: true, group: "text" },
-  { id: "text-contains", label: "text contains", kind: "text", op: "contains", input: true, group: "text" },
-  { id: "text-matches", label: "text matches pattern", kind: "text", op: "matches", input: true, group: "text" },
-  { id: "text-not", label: "text is not", kind: "text", not: true, input: true, group: "text" },
-  { id: "text-not-contains", label: "text does not contain", kind: "text", op: "contains", not: true, input: true, group: "text" },
-  { id: "value", label: "value is exactly", kind: "value", input: true, group: "value" },
-  { id: "value-contains", label: "value contains", kind: "value", op: "contains", input: true, group: "value" },
-  { id: "value-not", label: "value is not", kind: "value", not: true, input: true, group: "value" },
-  { id: "attr", label: "attribute is", kind: "attribute", input: true, attr: true, group: "attributes" },
-  { id: "attr-contains", label: "attribute contains", kind: "attribute", op: "contains", input: true, attr: true, group: "attributes" },
-  { id: "attr-not", label: "attribute is not", kind: "attribute", not: true, input: true, attr: true, group: "attributes" },
-  { id: "class", label: "has class", kind: "class", input: true, group: "attributes" },
-  { id: "not-class", label: "does not have class", kind: "class", not: true, input: true, group: "attributes" },
-  { id: "count", label: "how many \xB7 is exactly", kind: "count", input: true, roleOnly: true, group: "count" },
-  { id: "count-gte", label: "how many \xB7 is at least", kind: "count", op: "gte", input: true, roleOnly: true, group: "count" },
-  { id: "count-lte", label: "how many \xB7 is at most", kind: "count", op: "lte", input: true, roleOnly: true, group: "count" },
-  { id: "url", label: "page URL is", kind: "url", input: true, page: true, group: "page" },
-  { id: "url-contains", label: "page URL contains", kind: "url", op: "contains", input: true, page: true, group: "page" },
-  { id: "title", label: "page title is", kind: "title", input: true, page: true, group: "page" },
-  { id: "title-contains", label: "page title contains", kind: "title", op: "contains", input: true, page: true, group: "page" }
-];
-function matchCheck(a) {
-  const op = a.op ?? "equals";
-  const value = Array.isArray(a.value) ? a.value.join(", ") : a.value;
-  return CHECKS.find(
-    (c) => c.kind === a.kind && (c.op ?? "equals") === op && Boolean(c.not) === Boolean(a.not) && // A fixed-value entry (is checked / is not checked) only matches its own
-    // value, or the two would be indistinguishable.
-    (c.value === void 0 || c.value === value)
-  );
+function migrateBareModifierPresses(doc) {
+  const MODIFIERS = ["Meta", "Control", "Alt", "Shift"];
+  const invented = (step) => step["type"] === "press" && typeof step["value"] === "string" && MODIFIERS.some((m) => step["value"] === `${m}+${m}` || step["value"] === m);
+  doc.steps = (Array.isArray(doc.steps) ? doc.steps : []).filter((step) => !invented(step));
 }
-var PROPOSED_LABELS = {
-  screen: (v) => `screen is \u201C${v}\u201D`,
-  heading: (v) => `heading is \u201C${v}\u201D`,
-  message: (v) => `message \u201C${v}\u201D is shown`,
-  fields_visible: (v) => `fields visible: ${v}`
+var MIGRATIONS = {
+  2: (doc) => {
+    migrateScrollPrerequisites(doc);
+    migrateRadioCheckedState(doc);
+  },
+  3: migrateExplicitSecretRefs,
+  4: migrateBareModifierPresses
 };
-function describeAssertion(a, subject) {
-  const value = Array.isArray(a.value) ? a.value.join(", ") : a.value;
-  const proposed = PROPOSED_LABELS[a.kind];
-  if (proposed && !a.target) return proposed(value);
-  const check = matchCheck(a);
-  const who = a.target?.name || subject || "";
-  if (!check) {
-    return `${a.kind}${a.op && a.op !== "equals" ? ` ${a.op}` : ""}${a.not ? " not" : ""}${value ? ` \u201C${value}\u201D` : ""}`;
+function parseFlowDocument(input) {
+  const raw = structuredClone(input);
+  let version = typeof raw?.schemaVersion === "number" ? raw.schemaVersion : 2;
+  if (version > CURRENT_SCHEMA_VERSION) {
+    throw new Error(
+      `this flow was written by a newer version of Flowriki (schema ${version}, this build understands ${CURRENT_SCHEMA_VERSION}) \u2014 upgrade to open it`
+    );
   }
-  const attr = check.attr && a.attr ? ` ${a.attr}` : "";
-  const expects = check.input ? ` \u201C${value}\u201D` : "";
-  if (check.page) return `${check.label}${expects}`;
-  if (check.roleOnly) {
-    const role = a.target?.role || "element";
-    return `${role}s \xB7 ${check.label.replace("how many \xB7 ", "")}${expects}`;
+  while (version < CURRENT_SCHEMA_VERSION) {
+    const migrate = MIGRATIONS[version];
+    if (!migrate) throw new Error(`no migration path from schema version ${version}`);
+    migrate(raw);
+    version += 1;
+    raw.schemaVersion = version;
   }
-  const label = check.label.replace("attribute", `attribute${attr}`);
-  return who ? `\u201C${who}\u201D ${label}${expects}` : `${label}${expects}`;
+  return FlowDocumentSchema.parse(raw);
 }
 
-// ../orchestrator/dist/index.js
-import { execFileSync } from "child_process";
-import fs22 from "fs";
-import path23 from "path";
-
-// ../runner/dist/index.js
-import { chromium, firefox, webkit } from "playwright";
+// ../test-model/dist/index.js
+import { z as z4 } from "zod";
+var EngineSchema = z4.enum(["chromium", "firefox", "webkit"]);
+var CapabilitySchema = z4.object({
+  id: z4.string(),
+  provider: z4.string().default("local"),
+  engine: EngineSchema,
+  /** Branded local builds: "chrome", "msedge". */
+  channel: z4.string().optional(),
+  browserVersion: z4.string().optional(),
+  os: z4.string().optional(),
+  osVersion: z4.string().optional(),
+  device: z4.string().optional(),
+  viewport: z4.object({ width: z4.number().int(), height: z4.number().int() }).optional()
+});
+var ExecutionConfigSchema = z4.object({
+  concurrency: z4.number().int().positive().default(4),
+  defaultBrowser: z4.string().default("chromium"),
+  retries: z4.number().int().nonnegative().default(0),
+  browsers: z4.record(z4.string(), CapabilitySchema.omit({ id: true }).partial({ provider: true })),
+  suites: z4.record(
+    z4.string(),
+    z4.object({
+      flows: z4.array(z4.string()).default([]),
+      browser: z4.string().optional(),
+      /** Opt-in cross-browser fan-out for this suite only. */
+      matrix: z4.array(z4.string()).optional()
+    })
+  ).default({})
+});
 
 // ../recorder/dist/index.js
 function openShadowRoots() {
@@ -882,8 +918,8 @@ function installRecorder() {
     return Boolean(el?.closest?.("[data-flowriki],[data-flowriki-debug]"));
   }
   function actualTarget(e) {
-    const path8 = typeof e.composedPath === "function" ? e.composedPath() : [];
-    const first = path8[0];
+    const path11 = typeof e.composedPath === "function" ? e.composedPath() : [];
+    const first = path11[0];
     return (first && first.tagName ? first : e.target) ?? null;
   }
   w.__flSignature = () => {
@@ -1048,6 +1084,15 @@ function installRecorder() {
     }
     return false;
   }
+  function identityRank(el) {
+    try {
+      const identity = identify(el);
+      if (identity.name || identity.locator) return 2;
+      return roleOf(el) ? 1 : 0;
+    } catch {
+      return 0;
+    }
+  }
   let pendingHover = null;
   let pendingReveal = null;
   let lastClosedWarning = { el: null };
@@ -1080,11 +1125,13 @@ function installRecorder() {
       const hit = actualTarget(e);
       const trigger = (hit && hit.closest ? hit.closest(HOVER_TRIGGERS) : null) ?? hit;
       if (!trigger || !visible(trigger) || !couldReveal(trigger)) return;
-      if (pendingHover && Date.now() - pendingHover.at < HOVER_WINDOW_MS) {
+      const rank = identityRank(trigger);
+      if (pendingHover && Date.now() - pendingHover.at < HOVER_WINDOW_MS && pendingHover.rank > 0) {
         if (pendingHover.el === trigger) return;
         if (!pendingHover.seen.has(trigger)) return;
+        if (rank < pendingHover.rank) return;
       }
-      pendingHover = { el: trigger, seen: visibleClickables(), at: Date.now() };
+      pendingHover = { el: trigger, seen: visibleClickables(), at: Date.now(), rank };
     },
     true
   );
@@ -1299,12 +1346,12 @@ function installRecorder() {
           });
           return;
         }
-        if (hit && visible(hit)) pendingReveal = { el: hit, seen: visibleClickables(), at: Date.now() };
+        if (hit && visible(hit)) pendingReveal = { el: hit, seen: visibleClickables(), at: Date.now(), rank: identityRank(hit) };
         return;
       }
       const hoverMattered = pendingHover && Date.now() - pendingHover.at <= HOVER_WINDOW_MS && (revealed(pendingHover, el) || insideFlyoutOf(pendingHover.el, el));
       if (revealed(pendingReveal, el)) emitTrigger("click", pendingReveal.el);
-      else if (hoverMattered) emitTrigger("hover", pendingHover.el);
+      else if (hoverMattered && pendingHover.rank > 0) emitTrigger("hover", pendingHover.el);
       pendingReveal = null;
       pendingHover = null;
       const role = roleOf(el);
@@ -2110,43 +2157,246 @@ function installDebugPanel() {
         c.style.transform = shift ? vertical ? `translateY(${shift}px)` : `translateX(${shift}px)` : "";
       });
     };
-    const up = () => {
-      card.releasePointerCapture(down.pointerId);
-      window.removeEventListener("pointermove", move);
-      window.removeEventListener("pointerup", up);
-      window.removeEventListener("pointercancel", up);
-      dragging = null;
-      cards.forEach((c) => {
-        c.style.transform = "";
-        c.classList.remove("drag");
-      });
-      if (to !== from) cmd("moveStep", { stepId: card.dataset.id, toIndex: to });
-      else if (pendingRender) render();
+    const up = () => {
+      card.releasePointerCapture(down.pointerId);
+      window.removeEventListener("pointermove", move);
+      window.removeEventListener("pointerup", up);
+      window.removeEventListener("pointercancel", up);
+      dragging = null;
+      cards.forEach((c) => {
+        c.style.transform = "";
+        c.classList.remove("drag");
+      });
+      if (to !== from) cmd("moveStep", { stepId: card.dataset.id, toIndex: to });
+      else if (pendingRender) render();
+    };
+    window.addEventListener("pointermove", move);
+    window.addEventListener("pointerup", up);
+    window.addEventListener("pointercancel", up);
+  };
+  w.__flDebugRender = (next) => {
+    state = next;
+    render();
+  };
+  if (document.body) mount();
+  else document.addEventListener("DOMContentLoaded", mount);
+}
+
+// ../engine-playwright/dist/index.js
+import fs4 from "fs";
+import { createRequire as createRequire2 } from "module";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import "playwright";
+
+// ../core/dist/index.js
+function proposeAssertions(before, after) {
+  const out = [];
+  if (!before || !after) return out;
+  if (before.url !== after.url)
+    out.push({
+      kind: "screen",
+      value: after.heading || after.title,
+      why: "navigated to a new screen"
+    });
+  for (const a of after.alerts.filter((x) => !before.alerts.includes(x)))
+    out.push({ kind: "message", value: a, why: "a message appeared that was not there before" });
+  if (before.url === after.url && before.heading !== after.heading && after.heading)
+    out.push({ kind: "heading", value: after.heading, why: "the heading changed in place" });
+  const newFields = after.fields.filter((f) => !before.fields.includes(f));
+  if (newFields.length)
+    out.push({ kind: "fields_visible", value: newFields, why: "new fields became visible" });
+  if (before.url === after.url) {
+    const seenKeys = new Set(before.texts.map((t) => t.key));
+    const covered = /* @__PURE__ */ new Set([after.heading, ...after.alerts]);
+    const appeared = after.texts.filter((t) => !seenKeys.has(t.key) && !covered.has(t.text));
+    for (const t of appeared.slice(0, 2))
+      out.push({
+        kind: "message",
+        value: t.text,
+        why: "this text appeared after the action",
+        confidence: "low"
+      });
+  }
+  return out;
+}
+function hasObservableChange(before, after) {
+  return proposeAssertions(before, after).some((p) => p.confidence !== "low");
+}
+function isLocalHost(host) {
+  const h = host.toLowerCase();
+  return h === "localhost" || h.endsWith(".localhost") || h === "127.0.0.1" || h === "[::1]" || h === "0.0.0.0";
+}
+function hasScheme(raw) {
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(raw)) return true;
+  return /^[a-zA-Z][a-zA-Z0-9+.-]*:(?!\d)/.test(raw);
+}
+function normalizeStartUrl(input) {
+  const raw = (input ?? "").trim();
+  if (!raw) throw new Error("enter a URL to record against");
+  let candidate;
+  if (hasScheme(raw)) {
+    candidate = raw;
+  } else {
+    const bare = raw.replace(/^\/+/, "");
+    const host = bare.split(/[/?#]/)[0] ?? "";
+    candidate = `${isLocalHost(host.split(":")[0] ?? "") ? "http" : "https"}://${bare}`;
+  }
+  let parsed;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    throw new Error(`"${raw}" is not a valid URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`only http:// and https:// URLs can be recorded (got ${parsed.protocol}//)`);
+  }
+  if (!parsed.hostname) throw new Error(`"${raw}" has no host`);
+  return parsed.toString();
+}
+function resolveStartUrl(baseUrl, startPath) {
+  const base = normalizeStartUrl(baseUrl);
+  return new URL(startPath || "/", base).toString();
+}
+var INPUT_ROLES = /* @__PURE__ */ new Set(["textbox", "combobox", "checkbox", "radio", "spinbutton", "searchbox"]);
+var NAVIGATIONS = /* @__PURE__ */ new Set(["back", "forward"]);
+function locatorPlan(step) {
+  const o = step.locator;
+  if (o && o.value.trim()) {
+    const value = o.value.trim();
+    switch (o.strategy) {
+      // Playwright reads a leading `xpath=` prefix, and also bare paths that
+      // start with `/` or `//`. Normalising here means the QA can paste either.
+      case "xpath":
+        return { method: "locator", arg: value.startsWith("xpath=") ? value : `xpath=${value}`, overridden: true };
+      // Typed as a bare id, so nobody has to remember the `#`.
+      case "id":
+        return { method: "locator", arg: /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(value.replace(/^#/, "")) ? `#${value.replace(/^#/, "")}` : `[id=${JSON.stringify(value.replace(/^#/, ""))}]`, overridden: true };
+      case "css":
+        return { method: "locator", arg: value, overridden: true };
+      case "testId":
+        return { method: "getByTestId", arg: value, overridden: true };
+      case "text":
+        return { method: "getByText", arg: value, exact: true, overridden: true };
+      case "label":
+        return { method: "getByLabel", arg: value, exact: true, overridden: true };
+      case "placeholder":
+        return { method: "getByPlaceholder", arg: value, exact: true, overridden: true };
+      case "altText":
+        return { method: "getByAltText", arg: value, exact: true, overridden: true };
+      case "title":
+        return { method: "getByTitle", arg: value, exact: true, overridden: true };
+    }
+  }
+  if (NAVIGATIONS.has(step.type)) {
+    return { method: step.type === "back" ? "goBack" : "goForward", arg: "", overridden: false };
+  }
+  if (!step.name.trim()) return { method: "none", arg: "", overridden: false };
+  if (step.nameFrom === "adjacent-label") {
+    return {
+      method: "getByText",
+      arg: step.name,
+      exact: true,
+      overridden: false,
+      viaAdjacentLabel: true
+    };
+  }
+  if (step.nameFrom === "text") {
+    return {
+      method: "getByText",
+      arg: step.name,
+      exact: step.type !== "hover",
+      overridden: false,
+      visible: true
     };
-    window.addEventListener("pointermove", move);
-    window.addEventListener("pointerup", up);
-    window.addEventListener("pointercancel", up);
-  };
-  w.__flDebugRender = (next) => {
-    state = next;
-    render();
-  };
-  if (document.body) mount();
-  else document.addEventListener("DOMContentLoaded", mount);
+  }
+  return INPUT_ROLES.has(step.role) ? { method: "getByLabel", arg: step.name, exact: true, overridden: false, inputRole: step.role } : step.role ? { method: "getByRole", arg: step.role, name: step.name, exact: true, overridden: false } : { method: "getByText", arg: step.name, exact: step.type !== "hover", overridden: false, visible: true };
+}
+function frameSelector(name) {
+  const positional = /^nth:(\d+)$/.exec(name);
+  if (positional) return `iframe, frame >> nth=${positional[1]}`;
+  const v = JSON.stringify(name);
+  return `iframe[title=${v}], iframe[name=${v}], iframe[id=${v}], frame[title=${v}], frame[name=${v}], frame[id=${v}]`;
+}
+function inputSelector(role) {
+  return role === "textbox" ? 'input, textarea, [contenteditable="true"], [role="textbox"]' : `input, select, [role="${role}"]`;
+}
+var SCOPE_ROLES = ["form", "group", "region", "dialog", "alertdialog"];
+var CHECKS = [
+  { id: "visible", label: "is visible", kind: "visible", group: "state" },
+  { id: "not-visible", label: "is not visible", kind: "visible", not: true, group: "state" },
+  { id: "attached", label: "exists on the page", kind: "attached", group: "state" },
+  { id: "not-attached", label: "does not exist", kind: "attached", not: true, group: "state" },
+  { id: "enabled", label: "is enabled", kind: "enabled", group: "state" },
+  { id: "disabled", label: "is disabled", kind: "enabled", not: true, group: "state" },
+  { id: "editable", label: "is editable", kind: "editable", group: "state" },
+  { id: "readonly", label: "is read-only", kind: "editable", not: true, group: "state" },
+  { id: "focused", label: "is focused", kind: "focused", group: "state" },
+  { id: "checked", label: "is checked", kind: "checked", value: "true", group: "state" },
+  { id: "unchecked", label: "is not checked", kind: "checked", value: "false", group: "state" },
+  { id: "text", label: "text is exactly", kind: "text", input: true, group: "text" },
+  { id: "text-contains", label: "text contains", kind: "text", op: "contains", input: true, group: "text" },
+  { id: "text-matches", label: "text matches pattern", kind: "text", op: "matches", input: true, group: "text" },
+  { id: "text-not", label: "text is not", kind: "text", not: true, input: true, group: "text" },
+  { id: "text-not-contains", label: "text does not contain", kind: "text", op: "contains", not: true, input: true, group: "text" },
+  { id: "value", label: "value is exactly", kind: "value", input: true, group: "value" },
+  { id: "value-contains", label: "value contains", kind: "value", op: "contains", input: true, group: "value" },
+  { id: "value-not", label: "value is not", kind: "value", not: true, input: true, group: "value" },
+  { id: "attr", label: "attribute is", kind: "attribute", input: true, attr: true, group: "attributes" },
+  { id: "attr-contains", label: "attribute contains", kind: "attribute", op: "contains", input: true, attr: true, group: "attributes" },
+  { id: "attr-not", label: "attribute is not", kind: "attribute", not: true, input: true, attr: true, group: "attributes" },
+  { id: "class", label: "has class", kind: "class", input: true, group: "attributes" },
+  { id: "not-class", label: "does not have class", kind: "class", not: true, input: true, group: "attributes" },
+  { id: "count", label: "how many \xB7 is exactly", kind: "count", input: true, roleOnly: true, group: "count" },
+  { id: "count-gte", label: "how many \xB7 is at least", kind: "count", op: "gte", input: true, roleOnly: true, group: "count" },
+  { id: "count-lte", label: "how many \xB7 is at most", kind: "count", op: "lte", input: true, roleOnly: true, group: "count" },
+  { id: "url", label: "page URL is", kind: "url", input: true, page: true, group: "page" },
+  { id: "url-contains", label: "page URL contains", kind: "url", op: "contains", input: true, page: true, group: "page" },
+  { id: "title", label: "page title is", kind: "title", input: true, page: true, group: "page" },
+  { id: "title-contains", label: "page title contains", kind: "title", op: "contains", input: true, page: true, group: "page" }
+];
+function matchCheck(a) {
+  const op = a.op ?? "equals";
+  const value = Array.isArray(a.value) ? a.value.join(", ") : a.value;
+  return CHECKS.find(
+    (c) => c.kind === a.kind && (c.op ?? "equals") === op && Boolean(c.not) === Boolean(a.not) && // A fixed-value entry (is checked / is not checked) only matches its own
+    // value, or the two would be indistinguishable.
+    (c.value === void 0 || c.value === value)
+  );
+}
+var PROPOSED_LABELS = {
+  screen: (v) => `screen is \u201C${v}\u201D`,
+  heading: (v) => `heading is \u201C${v}\u201D`,
+  message: (v) => `message \u201C${v}\u201D is shown`,
+  fields_visible: (v) => `fields visible: ${v}`
+};
+function describeAssertion(a, subject) {
+  const value = Array.isArray(a.value) ? a.value.join(", ") : a.value;
+  const proposed = PROPOSED_LABELS[a.kind];
+  if (proposed && !a.target) return proposed(value);
+  const check = matchCheck(a);
+  const who = a.target?.name || subject || "";
+  if (!check) {
+    return `${a.kind}${a.op && a.op !== "equals" ? ` ${a.op}` : ""}${a.not ? " not" : ""}${value ? ` \u201C${value}\u201D` : ""}`;
+  }
+  const attr = check.attr && a.attr ? ` ${a.attr}` : "";
+  const expects = check.input ? ` \u201C${value}\u201D` : "";
+  if (check.page) return `${check.label}${expects}`;
+  if (check.roleOnly) {
+    const role = a.target?.role || "element";
+    return `${role}s \xB7 ${check.label.replace("how many \xB7 ", "")}${expects}`;
+  }
+  const label = check.label.replace("attribute", `attribute${attr}`);
+  return who ? `\u201C${who}\u201D ${label}${expects}` : `${label}${expects}`;
 }
 
-// ../runner/dist/index.js
-import fs from "fs";
-import { createRequire } from "module";
-import path from "path";
-import { fileURLToPath } from "url";
-import "playwright";
+// ../engine-playwright/dist/index.js
 import "playwright";
 import { errors } from "playwright";
-import fs2 from "fs";
-import path2 from "path";
+import fs22 from "fs";
+import path22 from "path";
 import "playwright";
-import fs3 from "fs";
+import fs32 from "fs";
 import "playwright";
 var DEFAULT_ENVIRONMENT = {
   browser: "chromium",
@@ -2198,7 +2448,9 @@ function resolveCapture(options = {}) {
     blockedBySecrets: blocked && (policy.video !== "off" || policy.trace !== "off")
   };
 }
-async function launchSession(environment = {}, headless = true, slowMo = 0, capture = {}) {
+var forcedHeadless = () => process.env["FLOWRIKI_FORCE_HEADLESS"] === "1";
+async function launchSession(environment = {}, headlessRequested = true, slowMo = 0, capture = {}) {
+  const headless = headlessRequested || forcedHeadless();
   const config = { ...DEFAULT_ENVIRONMENT, ...ExecutionEnvironmentSchema.parse(environment) };
   const fullWindow = config.fullWindow === true && !headless;
   const engine = { chromium, firefox, webkit }[config.browser];
@@ -2413,16 +2665,16 @@ var cachedAccNameScript = null;
 var ACCNAME_ASSET = "accname.global.js";
 function accNameScript() {
   if (cachedAccNameScript === null) {
-    cachedAccNameScript = fs.readFileSync(accNameScriptPath(), "utf8");
+    cachedAccNameScript = fs4.readFileSync(accNameScriptPath(), "utf8");
   }
   return cachedAccNameScript;
 }
 function accNameScriptPath() {
   try {
-    return createRequire(import.meta.url).resolve("@flowriki/recorder/accname.global.js");
+    return createRequire2(import.meta.url).resolve("@flowriki/recorder/accname.global.js");
   } catch {
-    const beside = path.join(path.dirname(fileURLToPath(import.meta.url)), ACCNAME_ASSET);
-    if (fs.existsSync(beside)) return beside;
+    const beside = path3.join(path3.dirname(fileURLToPath(import.meta.url)), ACCNAME_ASSET);
+    if (fs4.existsSync(beside)) return beside;
     throw new Error(
       `this build is missing ${ACCNAME_ASSET}, which recording injects into the page \u2014 reinstall the agent`
     );
@@ -2882,9 +3134,9 @@ async function captureFailure(opts) {
   let screenshot = null;
   try {
     const file = `step-${String(ordinal).padStart(2, "0")}.png`;
-    fs2.mkdirSync(dir, { recursive: true });
+    fs22.mkdirSync(dir, { recursive: true });
     await page.screenshot({
-      path: path2.join(dir, file),
+      path: path22.join(dir, file),
       // The viewport, not the full page: a failure is about what was on screen,
       // and a full-page capture of an infinite-scroll app is a 20MB image.
       fullPage: false,
@@ -2935,7 +3187,7 @@ async function finaliseArtifacts(opts) {
   const out = [];
   const size = (file) => {
     try {
-      return fs2.statSync(path2.join(dir, file)).size;
+      return fs22.statSync(path22.join(dir, file)).size;
     } catch {
       return null;
     }
@@ -2944,8 +3196,8 @@ async function finaliseArtifacts(opts) {
     const file = "trace.zip";
     try {
       if (keep(artifacts.trace)) {
-        fs2.mkdirSync(dir, { recursive: true });
-        await context.tracing.stop({ path: path2.join(dir, file) });
+        fs22.mkdirSync(dir, { recursive: true });
+        await context.tracing.stop({ path: path22.join(dir, file) });
         out.push({ kind: "trace", relPath: file, bytes: size(file) });
       } else {
         await context.tracing.stop();
@@ -2956,8 +3208,8 @@ async function finaliseArtifacts(opts) {
   if (artifacts.console && consoleLines.length) {
     const file = "console.log";
     try {
-      fs2.mkdirSync(dir, { recursive: true });
-      fs2.writeFileSync(path2.join(dir, file), consoleLines.join("\n") + "\n");
+      fs22.mkdirSync(dir, { recursive: true });
+      fs22.writeFileSync(path22.join(dir, file), consoleLines.join("\n") + "\n");
       out.push({ kind: "console", relPath: file, bytes: size(file) });
     } catch {
     }
@@ -2967,18 +3219,18 @@ async function finaliseArtifacts(opts) {
 function collectVideos(dir, keep) {
   let files;
   try {
-    files = fs2.readdirSync(dir).filter((f) => f.endsWith(".webm"));
+    files = fs22.readdirSync(dir).filter((f) => f.endsWith(".webm"));
   } catch {
     return [];
   }
   if (!keep) {
-    for (const f of files) fs2.rmSync(path2.join(dir, f), { force: true });
+    for (const f of files) fs22.rmSync(path22.join(dir, f), { force: true });
     return [];
   }
   return files.map((f) => {
     let bytes = null;
     try {
-      bytes = fs2.statSync(path2.join(dir, f)).size;
+      bytes = fs22.statSync(path22.join(dir, f)).size;
     } catch {
       bytes = null;
     }
@@ -3622,7 +3874,7 @@ var cachedAccName = null;
 function accNameScript2() {
   if (cachedAccName === null) {
     const path33 = accNameScriptPath();
-    cachedAccName = fs3.readFileSync(path33, "utf8");
+    cachedAccName = fs32.readFileSync(path33, "utf8");
   }
   return cachedAccName;
 }
@@ -4002,12 +4254,183 @@ async function startDebugSession(opts) {
   return session;
 }
 
-// ../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";
+// ../results/dist/chunk-ZYUMNEFU.js
+import { z as z5 } from "zod";
+var RunStatusSchema = z5.enum([
+  "queued",
+  "running",
+  "passed",
+  "failed",
+  "cancelled",
+  "errored"
+]);
+var TaskStatusSchema = z5.enum([
+  "queued",
+  "running",
+  "passed",
+  "failed",
+  "skipped",
+  "cancelled",
+  "errored"
+]);
+var FailureKindSchema = z5.enum([
+  "not_found",
+  "ambiguous",
+  "timeout",
+  "assertion",
+  "navigation",
+  "crash",
+  "unknown"
+]);
+var RunCheckSchema = z5.object({
+  id: z5.string(),
+  assertionId: z5.string().nullable(),
+  kind: z5.string(),
+  expected: z5.string().nullable(),
+  actual: z5.string().nullable(),
+  ok: z5.boolean(),
+  /** A failed soft check is reported but does not fail its step, so a run can
+   *  be green and still carry findings. Stored per check rather than derived,
+   *  because the flow it came from can be edited afterwards and history has to
+   *  keep saying what actually happened. */
+  soft: z5.boolean().default(false),
+  detail: z5.string().nullable()
+});
+var RunStepSchema = z5.object({
+  id: z5.string(),
+  ordinal: z5.number().int().nonnegative(),
+  /** The STABLE document step id — this is what joins runs across time and
+   * makes flake-rate a view over existing columns rather than a migration. */
+  stepId: z5.string(),
+  action: z5.string(),
+  targetRole: z5.string().nullable(),
+  targetName: z5.string().nullable(),
+  targetScope: z5.string().nullable(),
+  /** What the step typed, chose or pressed.
+   *
+   * A report that says `fill "Password"` and nothing else cannot tell you
+   * whether the run used the right credentials, which is most of what anyone
+   * reads a report to find out.
+   *
+   * NEVER set for a secret — see `secret` below. A run report is the thing
+   * people paste into a ticket. */
+  value: z5.string().nullable().default(null),
+  /** The step typed a secret, so `value` is deliberately absent rather than
+   *  merely unknown. Stored, because "no value" and "a value withheld" render
+   *  differently and history has to keep saying which it was. */
+  secret: z5.boolean().default(false),
+  status: z5.enum(["passed", "failed", "skipped"]),
+  failureKind: FailureKindSchema.nullable(),
+  detail: z5.string().nullable(),
+  durationMs: z5.number().int().nonnegative().nullable(),
+  /** Where the browser was when this step ran. Recorded on failure, and
+   * frequently the whole answer — the element is missing because a step
+   * before it navigated somewhere unexpected, not because it was renamed. */
+  pageUrl: z5.string().nullable().default(null),
+  pageTitle: z5.string().nullable().default(null),
+  checks: z5.array(RunCheckSchema).default([])
+});
+var RunTaskSchema = z5.object({
+  id: z5.string(),
+  ordinal: z5.number().int().nonnegative(),
+  caseName: z5.string(),
+  rowId: z5.string().nullable(),
+  capability: CapabilitySchema,
+  provider: z5.string(),
+  attempt: z5.number().int().positive().default(1),
+  maxAttempts: z5.number().int().positive().default(1),
+  status: TaskStatusSchema,
+  workerId: z5.string().nullable(),
+  /** Cloud provider's own session, so a failure is one click from their video. */
+  sessionId: z5.string().nullable(),
+  sessionUrl: z5.string().nullable(),
+  detail: z5.string().nullable(),
+  stepsRun: z5.number().int().nonnegative().default(0),
+  stepsTotal: z5.number().int().nonnegative().default(0),
+  durationMs: z5.number().int().nonnegative().nullable(),
+  steps: z5.array(RunStepSchema).default([])
+});
+var ArtifactKindSchema = z5.enum(["screenshot", "video", "trace", "console", "har"]);
+var ArtifactSchema = z5.object({
+  id: z5.string(),
+  runId: z5.string(),
+  runStepId: z5.string().nullable(),
+  kind: ArtifactKindSchema,
+  relPath: z5.string(),
+  bytes: z5.number().int().nonnegative().nullable(),
+  masked: z5.boolean().default(false),
+  createdAt: z5.string()
+});
+var RunSummarySchema = z5.object({
+  id: z5.string(),
+  projectId: z5.string(),
+  /** What the run was FOR.
+   *
+   * `flake` is a deliberate repetition of one flow to measure how often it
+   * passes. It is kept out of pass-rate statistics: a 98/100 flakiness check is
+   * a useful finding, not a failing suite, and counting it as one would make
+   * measuring reliability look like losing it. */
+  kind: z5.enum(["smoke", "test", "adhoc", "flake"]),
+  trigger: z5.enum(["ui", "cli", "ci"]),
+  status: RunStatusSchema,
+  flowId: z5.string().nullable(),
+  flowName: z5.string().nullable(),
+  gitSha: z5.string().nullable(),
+  gitBranch: z5.string().nullable(),
+  gitDirty: z5.boolean().default(false),
+  env: z5.string().nullable(),
+  concurrency: z5.number().int().positive().nullable(),
+  tasksTotal: z5.number().int().nonnegative().default(0),
+  tasksPassed: z5.number().int().nonnegative().default(0),
+  tasksFailed: z5.number().int().nonnegative().default(0),
+  /** Rolled up from the run's tasks rather than stored on the run, so they
+   * cannot drift from the step rows they describe. "9 of 12" in a list is
+   * what tells a reader where a run died; "1 of 1 tasks" tells them nothing
+   * until there is more than one browser in play. */
+  stepsRun: z5.number().int().nonnegative().default(0),
+  stepsTotal: z5.number().int().nonnegative().default(0),
+  queuedAt: z5.string(),
+  startedAt: z5.string().nullable(),
+  finishedAt: z5.string().nullable(),
+  durationMs: z5.number().int().nonnegative().nullable()
+});
+var RunDetailSchema = RunSummarySchema.extend({
+  errorMessage: z5.string().nullable(),
+  artifactsDir: z5.string().nullable(),
+  tasks: z5.array(RunTaskSchema).default([]),
+  /** Screenshots and the like, addressed by `runStepId`. Kept flat rather than
+   * nested inside each step: an artifact can belong to the run as a whole. */
+  artifacts: z5.array(ArtifactSchema).default([])
+});
+
+// ../results/dist/chunk-IW3PJWP6.js
+import os4 from "os";
+import path4 from "path";
+function flowrikiHome() {
+  return process.env.FLOWRIKI_HOME || path4.join(os4.homedir(), ".flowriki");
+}
+function defaultDbPath() {
+  return path4.join(flowrikiHome(), "flowriki.db");
+}
+function runArtifactsDir(runId, projectId = "default") {
+  return path4.join(flowrikiHome(), "projects", safe(projectId), "runs", safe(runId));
+}
+function safe(segment) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(segment) || segment.includes("..")) {
+    throw new Error(`unsafe path segment: ${segment}`);
+  }
+  return segment;
+}
+function isInside(root, candidate) {
+  const base = path4.resolve(root);
+  const target = path4.resolve(candidate);
+  return target === base || target.startsWith(base + path4.sep);
+}
+
+// ../results/dist/node.js
+import fs5 from "fs";
+import { createRequire as createRequire3 } from "module";
+import path5 from "path";
 var MIGRATIONS2 = [
   // 1 — initial
   `
@@ -4187,26 +4610,6 @@ function ulid(now = Date.now()) {
 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));
-}
-function safe(segment) {
-  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(segment) || segment.includes("..")) {
-    throw new Error(`unsafe path segment: ${segment}`);
-  }
-  return segment;
-}
-function isInside(root, candidate) {
-  const base = path3.resolve(root);
-  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);
@@ -4223,13 +4626,13 @@ var SqliteStorage = class {
     if (this.db) return;
     let DatabaseSync2;
     try {
-      ({ DatabaseSync: DatabaseSync2 } = createRequire2(import.meta.url)("node:sqlite"));
+      ({ DatabaseSync: DatabaseSync2 } = createRequire3(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 });
+    if (this.file !== ":memory:") fs5.mkdirSync(path5.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");
@@ -4671,11 +5074,48 @@ function toSummary(row) {
   };
 }
 
-// ../orchestrator/dist/index.js
-import crypto2 from "crypto";
-import { execFileSync as execFileSync2 } from "child_process";
-import fs32 from "fs";
-import path32 from "path";
+// ../repository-store/dist/chunk-W6R7EC2D.js
+var FLOWRIKI_DIR = ".flowriki";
+var FEATURES_DIR = `${FLOWRIKI_DIR}/features`;
+var CONFIG_PATH = `${FLOWRIKI_DIR}/config.json`;
+var PROJECT_MARKER_PATH = `${FLOWRIKI_DIR}/project.json`;
+var FEATURE_FILE = "feature.json";
+var FLOW_SUFFIX = ".flow.json";
+function assertSlug(slug) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(slug)) throw new Error(`invalid slug: ${slug}`);
+  return slug;
+}
+var featureIdFor = (slug) => `f_${assertSlug(slug)}`;
+var featureSlugOf = (featureId) => assertSlug(featureId.replace(/^f_/, ""));
+var featureDir = (slug) => `${FEATURES_DIR}/${assertSlug(slug)}`;
+function flowPath(doc) {
+  return `${featureDir(featureSlugOf(doc.featureId))}/${assertSlug(doc.slug)}${FLOW_SUFFIX}`;
+}
+var isFlowFile = (name) => name.endsWith(FLOW_SUFFIX);
+var DEFAULT_FLAKINESS_REPEAT = 10;
+var MAX_FLAKINESS_REPEAT = 500;
+function clampRepeat(value) {
+  const n2 = Math.floor(Number(value));
+  if (!Number.isFinite(n2) || n2 < 2) return DEFAULT_FLAKINESS_REPEAT;
+  return Math.min(n2, MAX_FLAKINESS_REPEAT);
+}
+var defaultConfig = () => ({
+  baseUrl: "",
+  headless: false,
+  environment: {},
+  artifacts: {},
+  flakinessRepeat: DEFAULT_FLAKINESS_REPEAT
+});
+function parseConfig(raw) {
+  const source = raw && typeof raw === "object" ? raw : {};
+  return {
+    baseUrl: typeof source["baseUrl"] === "string" ? source["baseUrl"] : "",
+    headless: source["headless"] === true,
+    environment: ExecutionEnvironmentSchema.parse(source["environment"] ?? {}),
+    artifacts: ArtifactPolicySchema.parse(source["artifacts"] ?? {}),
+    flakinessRepeat: clampRepeat(source["flakinessRepeat"])
+  };
+}
 var FlowNotFound = class extends Error {
   constructor(message) {
     super(message);
@@ -4690,36 +5130,24 @@ var FlowConflict = class extends Error {
   }
   currentRevision;
 };
-function writeFileAtomic(file, contents) {
-  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const handle = fs5.openSync(tmp, "w");
-  try {
-    fs5.writeFileSync(handle, contents);
-    fs5.fsyncSync(handle);
-  } finally {
-    fs5.closeSync(handle);
-  }
-  try {
-    fs5.renameSync(tmp, file);
-  } catch (err) {
-    fs5.rmSync(tmp, { force: true });
-    throw err;
-  }
-}
 var FlowNotRunnable = class extends Error {
   constructor(message, reason) {
     super(message);
     this.reason = reason;
+    this.name = "FlowNotRunnable";
   }
   reason;
 };
-var DEFAULT_FLAKINESS_REPEAT = 10;
-var MAX_FLAKINESS_REPEAT = 500;
-function clampRepeat(value) {
-  const n2 = Math.floor(Number(value));
-  if (!Number.isFinite(n2) || n2 < 2) return DEFAULT_FLAKINESS_REPEAT;
-  return Math.min(n2, MAX_FLAKINESS_REPEAT);
-}
+
+// ../repository-store/dist/local.js
+import fs23 from "fs";
+import path23 from "path";
+import fs6 from "fs";
+import path6 from "path";
+import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
+import fs33 from "fs";
+import path32 from "path";
 function uniqueRef(flowSlug, name, taken) {
   const base = `${flowSlug}_${slugify(name) || "secret"}`;
   if (!taken.has(base)) {
@@ -4734,32 +5162,207 @@ function uniqueRef(flowSlug, name, taken) {
     }
   }
 }
+var LocalSecrets = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  get secretsPath() {
+    return path6.join(this.root, ".flowriki", "secrets.local.json");
+  }
+  readSecrets() {
+    try {
+      return JSON.parse(fs6.readFileSync(this.secretsPath, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  /** Move every captured secret VALUE out of the flow and into the local
+   *  store, leaving a reference behind.
+   *
+   * The recorder can only capture what was typed, so the raw password does
+   * reach this process — but it must never reach the flow file, which is
+   * meant to be committed. This is the one place that separation happens, so
+   * it happens before the flow is ever written to disk.
+   *
+   * Returns the steps with values replaced by references. */
+  extractSecrets(flowSlug, steps) {
+    const secrets = this.readSecrets();
+    const taken = /* @__PURE__ */ new Set();
+    const byValue = /* @__PURE__ */ new Map();
+    let changed = false;
+    for (const step of steps) {
+      if (step.secretRef) taken.add(step.secretRef);
+      else if (step.secret && step.value && secrets[step.value] !== void 0) taken.add(step.value);
+    }
+    for (const step of steps) {
+      if (!step.secret) continue;
+      if (step.secretRef) continue;
+      if (!step.value) continue;
+      if (secrets[step.value] !== void 0) {
+        step.secretRef = step.value;
+        step.value = "";
+        changed = true;
+        continue;
+      }
+      const key = `${slugify(step.name)} ${step.value}`;
+      let ref = byValue.get(key);
+      if (!ref) {
+        ref = uniqueRef(flowSlug, step.name, taken);
+        byValue.set(key, ref);
+        taken.add(ref);
+        secrets[ref] = step.value;
+      }
+      step.secretRef = ref;
+      step.value = "";
+      changed = true;
+    }
+    if (changed) {
+      fs6.mkdirSync(path6.dirname(this.secretsPath), { recursive: true });
+      fs6.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
+      this.ensureSecretsIgnored();
+    }
+    return steps;
+  }
+  /** The secret references a flow needs that this machine does not hold.
+   *
+   * Reported rather than resolved: a reference with no value is a setup step
+   * the person has not done yet, and inventing one — which is what reading the
+   * reference name as the password amounted to — turns a clear prompt into a
+   * mysterious authentication failure. */
+  unresolvedSecrets(flow) {
+    const secrets = this.readSecrets();
+    const missing = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const step of flow.steps) {
+      if (!step.secret || step.disabled) continue;
+      const ref = step.secretRef ?? "";
+      if (ref && secrets[ref] !== void 0) continue;
+      const key = ref || `step:${step.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      missing.push({ ref, field: step.name });
+    }
+    return missing;
+  }
+  writeSecret(ref, value) {
+    if (!/^[a-z0-9][a-z0-9_-]*$/.test(ref)) throw new Error(`invalid secret name: ${ref}`);
+    const secrets = this.readSecrets();
+    secrets[ref] = value;
+    fs6.mkdirSync(path6.dirname(this.secretsPath), { recursive: true });
+    fs6.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
+    this.ensureSecretsIgnored();
+  }
+  /** Move plaintext passwords out of flow documents recorded before secrets
+   *  were extracted at save time.
+   *
+   * Only ever touches a value that is PROVABLY a literal — one that does not
+   * match the reference grammar, and so could never have been written by
+   * `writeSecret`. A reference is by then an explicit `secretRef`, put there by
+   * the schema migration without needing to consult this store.
+   *
+   * This is the whole of the fix for the failure this used to cause: it decided
+   * "reference or password?" by asking whether the local store held the key,
+   * which answers "no" on a fresh clone, a colleague's machine or CI — so a
+   * working reference was rewritten into a password equal to its own name, and
+   * the real credential was lost. It no longer asks that question.
+   *
+   * Returns the flows it changed. */
+  migrateLeakedSecrets(flows, save) {
+    const secrets = this.readSecrets();
+    const healed = [];
+    for (const flow of flows) {
+      let changed = false;
+      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;
+        const ref = uniqueRef(flow.slug, step.name, taken);
+        taken.add(ref);
+        secrets[ref] = step.value;
+        step.secretRef = ref;
+        step.value = "";
+        changed = true;
+      }
+      if (changed) {
+        save(flow);
+        healed.push(flow.name);
+      }
+    }
+    if (healed.length) {
+      fs6.mkdirSync(path6.dirname(this.secretsPath), { recursive: true });
+      fs6.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
+      this.ensureSecretsIgnored();
+    }
+    return healed;
+  }
+  /** Recovery copies are machine-local and must not be committed. */
+  ensureRecoveryIgnored() {
+    this.ensureIgnored(".recovery/", "Recovery copies are local scratch, not part of the project.");
+  }
+  /** The secret store sits inside .flowriki/, which IS committed — so the one
+   *  file that must not be has to say so itself. */
+  ensureSecretsIgnored() {
+    this.ensureIgnored("secrets.local.json", "Secret values never belong in version control.");
+  }
+  /** Add one entry to .flowriki/.gitignore if it is not already there. */
+  ensureIgnored(line, why) {
+    const ignore = path6.join(this.root, ".flowriki", ".gitignore");
+    const existing = fs6.existsSync(ignore) ? fs6.readFileSync(ignore, "utf8") : "";
+    if (existing.split("\n").includes(line)) return;
+    fs6.mkdirSync(path6.dirname(ignore), { recursive: true });
+    fs6.writeFileSync(
+      ignore,
+      `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}# ${why}
+${line}
+`
+    );
+  }
+};
+function writeFileAtomic(file, contents) {
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  const handle = fs23.openSync(tmp, "w");
+  try {
+    fs23.writeFileSync(handle, contents);
+    fs23.fsyncSync(handle);
+  } finally {
+    fs23.closeSync(handle);
+  }
+  try {
+    fs23.renameSync(tmp, file);
+  } catch (err) {
+    fs23.rmSync(tmp, { force: true });
+    throw err;
+  }
+}
 var Store = class {
   constructor(root) {
     this.root = root;
+    this.secrets = new LocalSecrets(root);
   }
   root;
+  secrets;
+  /** The repository layout, rooted at this checkout. The segments come from
+   *  the shared layout rules, so a flow written here lands in the same file the
+   *  hosted API would have written it to. */
   get featuresDir() {
-    return path4.join(this.root, ".flowriki", "features");
+    return path23.join(this.root, ...FEATURES_DIR.split("/"));
   }
-  /** Every path that comes from a request goes through this. A slug is a
-   *  single path segment and nothing else — no traversal, no absolute paths. */
   assertSlug(slug) {
-    if (!/^[a-z0-9][a-z0-9-]*$/.test(slug)) throw new Error(`invalid slug: ${slug}`);
-    return slug;
+    return assertSlug(slug);
   }
   listFeatures() {
-    if (!fs5.existsSync(this.featuresDir)) return [];
+    if (!fs23.existsSync(this.featuresDir)) return [];
     const out = [];
-    for (const entry of fs5.readdirSync(this.featuresDir, { withFileTypes: true })) {
+    for (const entry of fs23.readdirSync(this.featuresDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const file = path4.join(this.featuresDir, entry.name, "feature.json");
-      if (!fs5.existsSync(file)) continue;
+      const file = path23.join(this.featuresDir, entry.name, FEATURE_FILE);
+      if (!fs23.existsSync(file)) continue;
       try {
-        out.push(FeatureSchema.parse(JSON.parse(fs5.readFileSync(file, "utf8"))));
+        out.push(FeatureSchema.parse(JSON.parse(fs23.readFileSync(file, "utf8"))));
       } catch (err) {
         this.featureProblems.push({
-          path: path4.relative(this.root, file),
+          path: path23.relative(this.root, file),
           error: String(err instanceof Error ? err.message : err).split("\n")[0].trim(),
           recoverable: false
         });
@@ -4770,22 +5373,22 @@ var Store = class {
   featureProblems = [];
   createFeature(name, description = "") {
     const slug = this.assertSlug(slugify(name));
-    const dir = path4.join(this.featuresDir, slug);
-    if (fs5.existsSync(dir)) throw new Error(`a feature named "${name}" already exists`);
-    fs5.mkdirSync(dir, { recursive: true });
+    const dir = path23.join(this.featuresDir, slug);
+    if (fs23.existsSync(dir)) throw new Error(`a feature named "${name}" already exists`);
+    fs23.mkdirSync(dir, { recursive: true });
     const doc = {
       schemaVersion: 1,
-      id: `f_${slug}`,
+      id: featureIdFor(slug),
       slug,
       name: name.trim(),
       description: description.trim(),
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs5.writeFileSync(path4.join(dir, "feature.json"), JSON.stringify(doc, null, 2) + "\n");
+    fs23.writeFileSync(path23.join(dir, FEATURE_FILE), JSON.stringify(doc, null, 2) + "\n");
     return doc;
   }
   deleteFeature(slug) {
-    fs5.rmSync(path4.join(this.featuresDir, this.assertSlug(slug)), { recursive: true, force: true });
+    fs23.rmSync(path23.join(this.featuresDir, this.assertSlug(slug)), { recursive: true, force: true });
   }
   /** Every flow that could be read.
    *
@@ -4799,18 +5402,18 @@ var Store = class {
     const out = [];
     this.problemsFound = [];
     for (const slug of features) {
-      const dir = path4.join(this.featuresDir, slug);
-      if (!fs5.existsSync(dir)) continue;
-      for (const file of fs5.readdirSync(dir)) {
-        if (!file.endsWith(".flow.json")) continue;
-        const full = path4.join(dir, file);
+      const dir = path23.join(this.featuresDir, slug);
+      if (!fs23.existsSync(dir)) continue;
+      for (const file of fs23.readdirSync(dir)) {
+        if (!isFlowFile(file)) continue;
+        const full = path23.join(dir, file);
         try {
-          out.push(parseFlowDocument(JSON.parse(fs5.readFileSync(full, "utf8"))));
+          out.push(parseFlowDocument(JSON.parse(fs23.readFileSync(full, "utf8"))));
         } catch (err) {
           this.problemsFound.push({
-            path: path4.relative(this.root, full),
+            path: path23.relative(this.root, full),
             error: String(err instanceof Error ? err.message : err).split("\n")[0].trim(),
-            recoverable: fs5.existsSync(this.recoveryPathFor(full))
+            recoverable: fs23.existsSync(this.recoveryPathFor(full))
           });
         }
       }
@@ -4833,15 +5436,15 @@ var Store = class {
    * Outside `features/`, because that directory is the product and is
    * committed; a recovery copy is machine-local noise. */
   recoveryPathFor(file) {
-    return path4.join(this.root, ".flowriki", ".recovery", path4.basename(file) + ".bak");
+    return path23.join(this.root, ".flowriki", ".recovery", path23.basename(file) + ".bak");
   }
   /** Restore a flow file from its recovery copy. Returns false when there is
    *  none, which is the honest answer rather than an invented document. */
   recoverFlowFile(relativePath) {
-    const file = path4.join(this.root, relativePath);
+    const file = path23.join(this.root, relativePath);
     const backup = this.recoveryPathFor(file);
-    if (!fs5.existsSync(backup)) return false;
-    fs5.copyFileSync(backup, file);
+    if (!fs23.existsSync(backup)) return false;
+    fs23.copyFileSync(backup, file);
     return true;
   }
   /** Write a flow, atomically, keeping the previous contents recoverable.
@@ -4858,11 +5461,11 @@ var Store = class {
   saveFlow(input, opts = {}) {
     const doc = parseFlowDocument(input);
     const featureSlug = this.assertSlug(doc.featureId.replace(/^f_/, ""));
-    const dir = path4.join(this.featuresDir, featureSlug);
-    fs5.mkdirSync(dir, { recursive: true });
-    const file = path4.join(dir, `${this.assertSlug(doc.slug)}.flow.json`);
+    const dir = path23.join(this.featuresDir, featureSlug);
+    fs23.mkdirSync(dir, { recursive: true });
+    const file = path23.join(dir, `${this.assertSlug(doc.slug)}${FLOW_SUFFIX}`);
     const destination = this.readFlowFile(file);
-    if (fs5.existsSync(file) && (!destination || destination.id !== doc.id)) {
+    if (fs23.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;
@@ -4879,21 +5482,21 @@ var Store = class {
       }
     }
     doc.revision = (current?.revision ?? doc.revision ?? 0) + 1;
-    const previousFile = current ? path4.join(this.root, this.relPath(current)) : file;
-    if (fs5.existsSync(previousFile)) {
+    const previousFile = current ? path23.join(this.root, this.relPath(current)) : file;
+    if (fs23.existsSync(previousFile)) {
       const backup = this.recoveryPathFor(previousFile);
-      fs5.mkdirSync(path4.dirname(backup), { recursive: true });
-      fs5.copyFileSync(previousFile, backup);
+      fs23.mkdirSync(path23.dirname(backup), { recursive: true });
+      fs23.copyFileSync(previousFile, backup);
       this.ensureRecoveryIgnored();
     }
     writeFileAtomic(file, JSON.stringify(doc, null, 2) + "\n");
-    if (previousFile !== file) fs5.rmSync(previousFile);
-    return path4.relative(this.root, file);
+    if (previousFile !== file) fs23.rmSync(previousFile);
+    return path23.relative(this.root, file);
   }
   /** Read one flow file, or null when it is missing or unreadable. */
   readFlowFile(file) {
     try {
-      return parseFlowDocument(JSON.parse(fs5.readFileSync(file, "utf8")));
+      return parseFlowDocument(JSON.parse(fs23.readFileSync(file, "utf8")));
     } catch {
       return null;
     }
@@ -4930,10 +5533,10 @@ var Store = class {
   deleteFlowDocument(doc) {
     const featureSlug = this.assertSlug(doc.featureId.replace(/^f_/, ""));
     this.assertSlug(doc.slug);
-    fs5.rmSync(path4.join(this.featuresDir, featureSlug, `${doc.slug}.flow.json`), { force: true });
+    fs23.rmSync(path23.join(this.featuresDir, featureSlug, `${doc.slug}${FLOW_SUFFIX}`), { force: true });
   }
   relPath(doc) {
-    return path4.join(".flowriki", "features", doc.featureId.replace(/^f_/, ""), `${doc.slug}.flow.json`);
+    return path23.join(...flowPath(doc).split("/"));
   }
   /** The environment a flow actually executes in.
    *
@@ -4959,23 +5562,13 @@ var Store = class {
    * per flow, and it travels with the repo like everything else in
    * `.flowriki/`. */
   get configPath() {
-    return path4.join(this.root, ".flowriki", "config.json");
+    return path23.join(this.root, ...CONFIG_PATH.split("/"));
   }
   readConfig() {
     try {
-      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
-        // from a merge or somebody's editor.
-        baseUrl: typeof raw.baseUrl === "string" ? raw.baseUrl : "",
-        headless: raw.headless === true,
-        environment: ExecutionEnvironmentSchema.parse(raw.environment ?? {}),
-        artifacts: ArtifactPolicySchema.parse(raw.artifacts ?? {}),
-        flakinessRepeat: clampRepeat(raw.flakinessRepeat)
-      };
+      return parseConfig(JSON.parse(fs23.readFileSync(this.configPath, "utf8")));
     } catch {
-      return { baseUrl: "", headless: false, environment: {}, artifacts: {}, flakinessRepeat: DEFAULT_FLAKINESS_REPEAT };
+      return defaultConfig();
     }
   }
   writeConfig(input) {
@@ -4992,8 +5585,8 @@ var Store = class {
       artifacts: ArtifactPolicySchema.parse(input.artifacts ?? existing.artifacts),
       flakinessRepeat: clampRepeat(input.flakinessRepeat ?? existing.flakinessRepeat)
     };
-    fs5.mkdirSync(path4.dirname(this.configPath), { recursive: true });
-    fs5.writeFileSync(this.configPath, JSON.stringify(config, null, 2) + "\n");
+    fs23.mkdirSync(path23.dirname(this.configPath), { recursive: true });
+    fs23.writeFileSync(this.configPath, JSON.stringify(config, null, 2) + "\n");
     return config;
   }
   /** Where a flow actually starts.
@@ -5016,63 +5609,6 @@ var Store = class {
   startUrlFor(flow) {
     return resolveStartUrl(this.baseUrlFor(flow), flow.startPath);
   }
-  get secretsPath() {
-    return path4.join(this.root, ".flowriki", "secrets.local.json");
-  }
-  readSecrets() {
-    try {
-      return JSON.parse(fs5.readFileSync(this.secretsPath, "utf8"));
-    } catch {
-      return {};
-    }
-  }
-  /** Move every captured secret VALUE out of the flow and into the local
-   *  store, leaving a reference behind.
-   *
-   * The recorder can only capture what was typed, so the raw password does
-   * reach this process — but it must never reach the flow file, which is
-   * meant to be committed. This is the one place that separation happens, so
-   * it happens before the flow is ever written to disk.
-   *
-   * Returns the steps with values replaced by references. */
-  extractSecrets(flowSlug, steps) {
-    const secrets = this.readSecrets();
-    const taken = /* @__PURE__ */ new Set();
-    const byValue = /* @__PURE__ */ new Map();
-    let changed = false;
-    for (const step of steps) {
-      if (step.secretRef) taken.add(step.secretRef);
-      else if (step.secret && step.value && secrets[step.value] !== void 0) taken.add(step.value);
-    }
-    for (const step of steps) {
-      if (!step.secret) continue;
-      if (step.secretRef) continue;
-      if (!step.value) continue;
-      if (secrets[step.value] !== void 0) {
-        step.secretRef = step.value;
-        step.value = "";
-        changed = true;
-        continue;
-      }
-      const key = `${slugify(step.name)} ${step.value}`;
-      let ref = byValue.get(key);
-      if (!ref) {
-        ref = uniqueRef(flowSlug, step.name, taken);
-        byValue.set(key, ref);
-        taken.add(ref);
-        secrets[ref] = step.value;
-      }
-      step.secretRef = ref;
-      step.value = "";
-      changed = true;
-    }
-    if (changed) {
-      fs5.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
-      fs5.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
-      this.ensureSecretsIgnored();
-    }
-    return steps;
-  }
   /** Where a file an upload step needs is looked for.
    *
    * The browser never gives a page the file's PATH, only its name — so a
@@ -5080,109 +5616,41 @@ var Store = class {
    * file. Committed alongside the flows, because a test that needs a 2KB
    * sample CSV should not need a side-channel to share it. */
   get filesDir() {
-    return path4.join(this.root, ".flowriki", "files");
+    return path23.join(this.root, ".flowriki", "files");
   }
   /** Resolve an upload step's file name to a path, or undefined when it is
    *  not on this machine. */
   resolveFile(name) {
     const first = name;
     if (!first || first.includes("/") || first.includes("\\") || first.includes("..")) return void 0;
-    const file = path4.join(this.filesDir, first);
-    return fs5.existsSync(file) ? file : void 0;
+    const file = path23.join(this.filesDir, first);
+    return fs23.existsSync(file) ? file : void 0;
   }
-  /** The secret references a flow needs that this machine does not hold.
-   *
-   * Reported rather than resolved: a reference with no value is a setup step
-   * the person has not done yet, and inventing one — which is what reading the
-   * reference name as the password amounted to — turns a clear prompt into a
-   * mysterious authentication failure. */
-  unresolvedSecrets(flow) {
-    const secrets = this.readSecrets();
-    const missing = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const step of flow.steps) {
-      if (!step.secret || step.disabled) continue;
-      const ref = step.secretRef ?? "";
-      if (ref && secrets[ref] !== void 0) continue;
-      const key = ref || `step:${step.id}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      missing.push({ ref, field: step.name });
-    }
-    return missing;
+  // ── secret values, held by `LocalSecrets` ───────────────────────────────
+  //
+  // Delegated rather than re-implemented, and delegated rather than exposed:
+  // every existing caller of `store.readSecrets()` keeps working, and the file
+  // handling lives in one place that a reader can take in whole.
+  readSecrets() {
+    return this.secrets.readSecrets();
+  }
+  extractSecrets(flowSlug, steps) {
+    return this.secrets.extractSecrets(flowSlug, steps);
+  }
+  unresolvedSecrets(flow) {
+    return this.secrets.unresolvedSecrets(flow);
   }
   writeSecret(ref, value) {
-    if (!/^[a-z0-9][a-z0-9_-]*$/.test(ref)) throw new Error(`invalid secret name: ${ref}`);
-    const secrets = this.readSecrets();
-    secrets[ref] = value;
-    fs5.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
-    fs5.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
-    this.ensureSecretsIgnored();
+    this.secrets.writeSecret(ref, value);
   }
-  /** Move plaintext passwords out of flow documents recorded before secrets
-   *  were extracted at save time.
-   *
-   * Only ever touches a value that is PROVABLY a literal — one that does not
-   * match the reference grammar, and so could never have been written by
-   * `writeSecret`. A reference is by then an explicit `secretRef`, put there by
-   * the schema migration without needing to consult this store.
-   *
-   * This is the whole of the fix for the failure this used to cause: it decided
-   * "reference or password?" by asking whether the local store held the key,
-   * which answers "no" on a fresh clone, a colleague's machine or CI — so a
-   * working reference was rewritten into a password equal to its own name, and
-   * the real credential was lost. It no longer asks that question.
-   *
-   * Returns the flows it changed. */
   migrateLeakedSecrets() {
-    const secrets = this.readSecrets();
-    const healed = [];
-    for (const flow of this.listFlows()) {
-      let changed = false;
-      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;
-        const ref = uniqueRef(flow.slug, step.name, taken);
-        taken.add(ref);
-        secrets[ref] = step.value;
-        step.secretRef = ref;
-        step.value = "";
-        changed = true;
-      }
-      if (changed) {
-        this.saveFlow(flow);
-        healed.push(flow.name);
-      }
-    }
-    if (healed.length) {
-      fs5.mkdirSync(path4.dirname(this.secretsPath), { recursive: true });
-      fs5.writeFileSync(this.secretsPath, JSON.stringify(secrets, null, 2) + "\n", { mode: 384 });
-      this.ensureSecretsIgnored();
-    }
-    return healed;
+    return this.secrets.migrateLeakedSecrets(this.listFlows(), (doc) => {
+      this.saveFlow(doc);
+    });
   }
   /** Recovery copies are machine-local and must not be committed. */
   ensureRecoveryIgnored() {
-    this.ensureIgnored(".recovery/", "Recovery copies are local scratch, not part of the project.");
-  }
-  /** The secret store sits inside .flowriki/, which IS committed — so the one
-   *  file that must not be has to say so itself. */
-  ensureSecretsIgnored() {
-    this.ensureIgnored("secrets.local.json", "Secret values never belong in version control.");
-  }
-  /** 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 = fs5.existsSync(ignore) ? fs5.readFileSync(ignore, "utf8") : "";
-    if (existing.split("\n").includes(line)) return;
-    fs5.mkdirSync(path4.dirname(ignore), { recursive: true });
-    fs5.writeFileSync(
-      ignore,
-      `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}# ${why}
-${line}
-`
-    );
+    this.secrets.ensureIgnored(".recovery/", "Recovery copies are local scratch, not part of the project.");
   }
 };
 function git(cwd, args) {
@@ -5212,6 +5680,100 @@ function readGitInfo(cwd) {
   cache.set(cwd, info);
   return info;
 }
+function git2(root, args) {
+  return execFileSync2("git", args, {
+    cwd: root,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function tryGit(root, args) {
+  try {
+    return git2(root, args);
+  } catch {
+    return null;
+  }
+}
+function readRepo(root) {
+  const isRepo = tryGit(root, ["rev-parse", "--is-inside-work-tree"]) === "true";
+  const markerFile = path32.join(root, MARKER_PATH);
+  let marker = null;
+  let markerUnreadable = false;
+  if (fs33.existsSync(markerFile)) {
+    try {
+      marker = ProjectMarkerSchema.parse(JSON.parse(fs33.readFileSync(markerFile, "utf8")));
+    } catch {
+      markerUnreadable = true;
+    }
+  }
+  if (!isRepo) {
+    return {
+      isRepo: false,
+      rootCommit: null,
+      branch: null,
+      hasRemote: false,
+      clean: true,
+      marker,
+      markerUnreadable,
+      markerIgnored: false
+    };
+  }
+  const roots = tryGit(root, ["rev-list", "--max-parents=0", "HEAD"]);
+  const rootCommit = roots ? roots.split("\n").pop() || null : null;
+  return {
+    isRepo: true,
+    rootCommit,
+    // An empty repository has no branch until the first commit creates one, so
+    // this being null is a state to handle rather than a failure.
+    branch: tryGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    hasRemote: Boolean(tryGit(root, ["remote"])),
+    clean: (tryGit(root, ["status", "--porcelain"]) ?? "") === "",
+    marker,
+    markerUnreadable,
+    // `check-ignore` exits non-zero when the path is NOT ignored, so a null
+    // here is the good answer.
+    markerIgnored: tryGit(root, ["check-ignore", MARKER_PATH]) !== null
+  };
+}
+var ClaimRefused = class extends Error {
+};
+function writeMarker(root, marker, opts = {}) {
+  const facts = readRepo(root);
+  if (!facts.isRepo) throw new ClaimRefused("that folder is not a git repository");
+  if (facts.markerIgnored) {
+    throw new ClaimRefused(
+      `${MARKER_PATH} is covered by a .gitignore rule, so committing it would do nothing \u2014 remove the rule first`
+    );
+  }
+  if (facts.marker) {
+    throw new ClaimRefused(`this folder already carries a marker for ${facts.marker.projectId}`);
+  }
+  if (!facts.clean) {
+    throw new ClaimRefused("this repository has uncommitted changes \u2014 commit or stash them first");
+  }
+  const file = path32.join(root, MARKER_PATH);
+  fs33.mkdirSync(path32.dirname(file), { recursive: true });
+  fs33.writeFileSync(file, JSON.stringify(marker, null, 2) + "\n");
+  git2(root, ["add", "--", MARKER_PATH]);
+  git2(root, ["commit", "-m", `Bind this repository to Flowriki project ${marker.projectId}`]);
+  const commit = git2(root, ["rev-parse", "HEAD"]);
+  const branch = tryGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  let pushed = false;
+  if (opts.push !== false && facts.hasRemote && branch) {
+    pushed = tryGit(root, ["push", "-u", "origin", branch]) !== null;
+  }
+  return { commit, pushed, branch };
+}
+function ensureRootCommit(root) {
+  const facts = readRepo(root);
+  if (!facts.isRepo) throw new ClaimRefused("that folder is not a git repository");
+  if (facts.rootCommit) return facts.rootCommit;
+  git2(root, ["commit", "--allow-empty", "-m", "Initialise repository"]);
+  return git2(root, ["rev-list", "--max-parents=0", "HEAD"]).split("\n").pop();
+}
+
+// ../execution/dist/index.js
+import crypto3 from "crypto";
 var LOCAL_CHROMIUM = { id: "chromium", provider: "local", engine: "chromium" };
 async function executeFlow(opts) {
   const { store, storage = null, flowId, trigger, watch = false, onEvent } = opts;
@@ -5260,7 +5822,7 @@ async function executeFlow(opts) {
   const perStep = /* @__PURE__ */ new Map();
   for (let attempt = 1; attempt <= repeat; attempt++) {
     if (opts.signal?.aborted) break;
-    const evidenceDir = runDir && repeat > 1 ? path23.join(runDir, `attempt-${String(attempt).padStart(3, "0")}`) : runDir;
+    const evidenceDir = runDir && repeat > 1 ? path7.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,
@@ -5403,7 +5965,7 @@ async function executeFlow(opts) {
       errorMessage: last.error,
       // Recorded only when something was actually written, so a passing run
       // does not claim a directory that does not exist.
-      artifactsDir: runDir && fs22.existsSync(runDir) ? runDir : null
+      artifactsDir: runDir && fs7.existsSync(runDir) ? runDir : null
     });
   }
   await emit({ type: "run.finished", runId: run?.id ?? "", flowId: flow.id, outcome: last });
@@ -5442,7 +6004,7 @@ function report(attempts, perStep) {
 function sizeOf(dir, file) {
   if (!dir) return null;
   try {
-    return fs22.statSync(path23.join(dir, file)).size;
+    return fs7.statSync(path7.join(dir, file)).size;
   } catch {
     return null;
   }
@@ -5667,7 +6229,7 @@ var RecordingCoordinator = class {
     this.deps.store.extractSecrets(slugify(draft.name), steps);
     const doc = {
       schemaVersion: CURRENT_SCHEMA_VERSION,
-      id: `flw_${crypto2.randomUUID().slice(0, 8)}`,
+      id: `flw_${crypto3.randomUUID().slice(0, 8)}`,
       featureId: feature.id,
       name: draft.name,
       slug: slugify(draft.name),
@@ -5717,6 +6279,10 @@ var RecordingCoordinator = class {
   }
 };
 var BrowserBusy = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserBusy";
+  }
 };
 var COMMANDS = /* @__PURE__ */ new Set([
   "play",
@@ -5838,11 +6404,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");
     }
@@ -5867,8 +6447,8 @@ async function verifyFlowSteps(deps, opts) {
     throw new BrowserBusy(`the browser on this machine is in use (${claim.heldBy}, ${claim.phase})`);
   }
   deps.lease?.activate("run");
-  const secrets = store.readSecrets();
   try {
+    const secrets = store.readSecrets();
     return await verifySteps({
       environment: store.environmentFor(flow),
       resolveFile: (name) => store.resolveFile(name),
@@ -5890,252 +6470,194 @@ async function verifyFlowSteps(deps, opts) {
     deps.lease?.release("run");
   }
 }
-function git2(root, args) {
-  return execFileSync2("git", args, {
-    cwd: root,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  }).trim();
-}
-function tryGit(root, args) {
-  try {
-    return git2(root, args);
-  } catch {
-    return null;
-  }
-}
-function readRepo(root) {
-  const isRepo = tryGit(root, ["rev-parse", "--is-inside-work-tree"]) === "true";
-  const markerFile = path32.join(root, MARKER_PATH);
-  let marker = null;
-  let markerUnreadable = false;
-  if (fs32.existsSync(markerFile)) {
-    try {
-      marker = ProjectMarkerSchema.parse(JSON.parse(fs32.readFileSync(markerFile, "utf8")));
-    } catch {
-      markerUnreadable = true;
-    }
-  }
-  if (!isRepo) {
-    return {
-      isRepo: false,
-      rootCommit: null,
-      branch: null,
-      hasRemote: false,
-      clean: true,
-      marker,
-      markerUnreadable,
-      markerIgnored: false
-    };
-  }
-  const roots = tryGit(root, ["rev-list", "--max-parents=0", "HEAD"]);
-  const rootCommit = roots ? roots.split("\n").pop() || null : null;
+function deliveredRun(delivered) {
+  const { flow, secrets, config } = delivered;
   return {
-    isRepo: true,
-    rootCommit,
-    // An empty repository has no branch until the first commit creates one, so
-    // this being null is a state to handle rather than a failure.
-    branch: tryGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]),
-    hasRemote: Boolean(tryGit(root, ["remote"])),
-    clean: (tryGit(root, ["status", "--porcelain"]) ?? "") === "",
-    marker,
-    markerUnreadable,
-    // `check-ignore` exits non-zero when the path is NOT ignored, so a null
-    // here is the good answer.
-    markerIgnored: tryGit(root, ["check-ignore", MARKER_PATH]) !== null
+    readConfig: () => config,
+    // By id, and only the one that was sent. A machine serving no checkout has
+    // no other flow to confuse it with.
+    getFlow: (id) => id === flow.id ? flow : null,
+    readSecrets: () => secrets,
+    baseUrlFor: (f) => f.baseUrl ?? config.baseUrl ?? "",
+    environmentFor: (f) => ({ ...config.environment, ...f.environment ?? {} }),
+    // See RunSource.resolveFile: there is no project directory here.
+    resolveFile: () => void 0
   };
 }
-var ClaimRefused = class extends Error {
-};
-function writeMarker(root, marker, opts = {}) {
-  const facts = readRepo(root);
-  if (!facts.isRepo) throw new ClaimRefused("that folder is not a git repository");
-  if (facts.markerIgnored) {
-    throw new ClaimRefused(
-      `${MARKER_PATH} is covered by a .gitignore rule, so committing it would do nothing \u2014 remove the rule first`
-    );
+var BrowserLease = class {
+  owner = null;
+  phase = "idle";
+  since = null;
+  /** Take the lease, or report who has it. Never awaits — that is the point. */
+  acquire(owner) {
+    if (this.owner !== null) {
+      return { ok: false, heldBy: this.owner, phase: this.phase };
+    }
+    this.owner = owner;
+    this.phase = "starting";
+    this.since = Date.now();
+    return { ok: true };
   }
-  if (facts.marker) {
-    throw new ClaimRefused(`this folder already carries a marker for ${facts.marker.projectId}`);
+  /** The holder finished starting and is now doing the thing. */
+  activate(owner) {
+    if (this.owner === owner) this.phase = "active";
   }
-  if (!facts.clean) {
-    throw new ClaimRefused("this repository has uncommitted changes \u2014 commit or stash them first");
+  /** The holder has begun shutting down. Still not idle: a second stop must
+   *  join the first rather than starting its own. */
+  beginRelease(owner) {
+    if (this.owner !== owner || this.phase === "stopping") return false;
+    this.phase = "stopping";
+    return true;
   }
-  const file = path32.join(root, MARKER_PATH);
-  fs32.mkdirSync(path32.dirname(file), { recursive: true });
-  fs32.writeFileSync(file, JSON.stringify(marker, null, 2) + "\n");
-  git2(root, ["add", "--", MARKER_PATH]);
-  git2(root, ["commit", "-m", `Bind this repository to Flowriki project ${marker.projectId}`]);
-  const commit = git2(root, ["rev-parse", "HEAD"]);
-  const branch = tryGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
-  let pushed = false;
-  if (opts.push !== false && facts.hasRemote && branch) {
-    pushed = tryGit(root, ["push", "-u", "origin", branch]) !== null;
+  release(owner) {
+    if (this.owner !== owner) return;
+    this.owner = null;
+    this.phase = "idle";
+    this.since = null;
+  }
+  /** Drop the lease whoever holds it — shutdown, and nothing else. */
+  forceRelease() {
+    this.owner = null;
+    this.phase = "idle";
+    this.since = null;
+  }
+  state() {
+    return { owner: this.owner, phase: this.phase, since: this.since };
+  }
+  /** The sentence a refused caller is shown. Names what is happening, because
+   *  "busy" leaves someone hunting for a window they cannot find. */
+  static refusal(heldBy, phase) {
+    const what = heldBy === "recording" ? "a recording" : heldBy === "debug" ? "a debug session" : "a run";
+    if (phase === "starting") return `${what} is starting \u2014 wait for it to open, or stop it first`;
+    if (phase === "stopping") return `${what} is still closing \u2014 try again in a moment`;
+    return `${what} is already using the browser \u2014 stop it before starting another`;
+  }
+};
+
+// src/engine/checkouts.ts
+function resolveCheckouts(dirs) {
+  const projects = [];
+  const skipped = [];
+  for (const dir of dirs) {
+    const root = path8.resolve(dir);
+    if (!fs8.existsSync(root)) {
+      skipped.push({ root, why: "no such folder" });
+      continue;
+    }
+    const facts = readRepo(root);
+    if (!facts.isRepo) {
+      skipped.push({ root, why: "not a git repository" });
+      continue;
+    }
+    if (facts.markerUnreadable) {
+      skipped.push({ root, why: `${MARKER_PATH} is there but cannot be read` });
+      continue;
+    }
+    if (!facts.marker) {
+      skipped.push({ root, why: "not connected to a Flowriki project \u2014 connect its repository from the dashboard" });
+      continue;
+    }
+    if (projects.some((p) => p.id === facts.marker.projectId)) {
+      skipped.push({ root, why: "another folder here is already that project" });
+      continue;
+    }
+    projects.push({ id: facts.marker.projectId, name: facts.marker.name, root });
   }
-  return { commit, pushed, branch };
-}
-function ensureRootCommit(root) {
-  const facts = readRepo(root);
-  if (!facts.isRepo) throw new ClaimRefused("that folder is not a git repository");
-  if (facts.rootCommit) return facts.rootCommit;
-  git2(root, ["commit", "--allow-empty", "-m", "Initialise repository"]);
-  return git2(root, ["rev-list", "--max-parents=0", "HEAD"]).split("\n").pop();
+  return { projects, skipped };
 }
-function deliveredRun(delivered) {
-  const { flow, secrets, config } = delivered;
+
+// ../agent-core/dist/chunk-PLNYCQPO.js
+import { WebSocket, WebSocketServer } from "ws";
+var HEARTBEAT_MS = 3e4;
+function adapt(socket) {
+  let closed = false;
+  const closeHandlers = [];
+  const fire = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(heartbeat);
+    for (const handler of closeHandlers) handler();
+  };
+  socket.on("close", fire);
+  socket.on("error", fire);
+  let answered = true;
+  socket.on("pong", () => {
+    answered = true;
+  });
+  const heartbeat = setInterval(() => {
+    if (!answered) {
+      try {
+        socket.terminate();
+      } catch {
+      }
+      fire();
+      return;
+    }
+    answered = false;
+    try {
+      socket.ping();
+    } catch {
+      fire();
+    }
+  }, HEARTBEAT_MS);
+  heartbeat.unref?.();
   return {
-    readConfig: () => config,
-    // By id, and only the one that was sent. A machine serving no checkout has
-    // no other flow to confuse it with.
-    getFlow: (id) => id === flow.id ? flow : null,
-    readSecrets: () => secrets,
-    baseUrlFor: (f) => f.baseUrl ?? config.baseUrl ?? "",
-    environmentFor: (f) => ({ ...config.environment, ...f.environment ?? {} }),
-    // See RunSource.resolveFile: there is no project directory here.
-    resolveFile: () => void 0
+    send: (data) => {
+      if (socket.readyState !== WebSocket.OPEN) return;
+      try {
+        socket.send(data);
+      } catch {
+        fire();
+      }
+    },
+    close: () => {
+      try {
+        socket.close();
+      } catch {
+      }
+      fire();
+    },
+    onMessage: (handler) => {
+      socket.on("message", (raw, isBinary) => {
+        if (isBinary) return;
+        handler(raw.toString());
+      });
+    },
+    onClose: (handler) => {
+      if (closed) {
+        handler();
+        return;
+      }
+      closeHandlers.push(handler);
+    }
   };
 }
+function dialWebSocket(opts) {
+  return () => new Promise((resolve, reject) => {
+    const socket = new WebSocket(opts.url, {
+      handshakeTimeout: opts.handshakeTimeoutMs ?? 1e4,
+      ...opts.headers ? { headers: opts.headers } : {}
+    });
+    const failed = (err) => {
+      try {
+        socket.terminate();
+      } catch {
+      }
+      reject(err instanceof Error ? err : new Error(String(err)));
+    };
+    socket.once("open", () => {
+      socket.off("error", failed);
+      resolve(adapt(socket));
+    });
+    socket.once("error", failed);
+  });
+}
 
 // ../agent-core/dist/index.js
-var PROTOCOL_VERSION = 1;
-var PAIRING_CODE_TTL_MS = 5 * 60 * 1e3;
-var JOURNAL_LIMIT = 1e3;
-var CommandNameSchema = z4.enum([
-  "record.start",
-  "record.stop",
-  "record.discard",
-  "record.status",
-  "record.dialog",
-  "flow.run",
-  "flow.save",
-  "flow.update",
-  "flow.delete",
-  "flow.verify",
-  "flow.get",
-  "debug.start",
-  "debug.status",
-  "debug.command",
-  "debug.end",
-  "config.save",
-  "run.cancel",
-  "feature.create",
-  "secret.set",
-  "project.list",
-  "project.status",
-  "project.claim",
-  "runs.list",
-  "runs.stats",
-  "run.get",
-  "artifact.fetch"
-]);
-var EFFECTFUL = /* @__PURE__ */ new Set([
-  "record.start",
-  "record.stop",
-  "record.discard",
-  // Answering a dialog is a click on the page under test. Re-delivering it
-  // after a dropped socket would answer the NEXT dialog with the previous
-  // reply — `record.status` stays out of this set because reading is safe to
-  // repeat, and that is the whole distinction.
-  "record.dialog",
-  "flow.run",
-  "flow.save",
-  "flow.update",
-  "flow.delete",
-  // Verification and a debug session both open a browser on somebody's machine
-  // and both can be told to record steps into a draft. Neither is a read.
-  "flow.verify",
-  "debug.start",
-  "debug.command",
-  "debug.end",
-  "config.save",
-  // Setting a secret writes a file. Idempotent — the same value written twice
-  // is the same value — but it is a write, and the deduplication path is the
-  // right default for one.
-  "secret.set",
-  // Creating a feature makes a directory and a file. A blind retry after a
-  // dropped socket would find it already there and report a failure for
-  // something that had in fact succeeded.
-  "feature.create",
-  // Claiming writes a file, makes a commit and pushes. Blind retry after a
-  // dropped socket would commit twice.
-  "project.claim",
-  "run.cancel"
-]);
-var CommandSchema = z4.object({
-  /** Unique per command. The agent stores it, so a redelivery after a
-   *  reconnect is recognised rather than performed twice. */
-  id: z4.string().min(1).max(128),
-  v: z4.number().int().positive(),
-  name: CommandNameSchema,
-  /** Which project on the agent's machine. Never a path — a name the user has
-   *  explicitly mapped, so the service cannot reach arbitrary files. */
-  projectId: z4.string().min(1),
-  /** The revision the caller believes it is acting on, where that matters. A
-   *  save built on a stale copy is refused rather than applied. */
-  flowRevision: z4.number().int().nonnegative().optional(),
-  /** Wall-clock expiry. A command that surfaced from a queue an hour late must
-   *  not start a browser on somebody's machine. */
-  expiresAt: z4.number().int().positive(),
-  /** When the service stamped this, by the service's clock.
-   *
-   * Present so the agent never has to compare a timestamp minted on another
-   * machine against its own clock. `expiresAt` alone made the deadline
-   * meaningless the moment two clocks disagreed: a machine running five
-   * minutes fast rejected every command the instant it arrived, saying it had
-   * expired before it got there — which is true only if you believe both
-   * clocks. Optional, so an older service that does not send it still works;
-   * the agent falls back to the absolute deadline it has always used. */
-  issuedAt: z4.number().int().positive().optional(),
-  args: z4.record(z4.unknown()).default({})
-  // UNKNOWN FIELDS ARE IGNORED, not refused.
-  //
-  // Strictness here looked like caution and was a compatibility trap: the day
-  // the service added `issuedAt`, every agent older than that release began
-  // refusing every command as unrecognised — over a field it had no need to
-  // read. The allowlist on command NAMES is the security boundary and is
-  // unchanged; which extra keys ride along is not, because nothing acts on a
-  // field it does not know about.
-});
-var AckSchema = z4.object({
-  type: z4.literal("ack"),
-  commandId: z4.string().min(1),
-  /** `accepted` means the agent has taken the work on, not that it finished.
-   *  `duplicate` means it has done this exact command before and is returning
-   *  the first outcome. */
-  status: z4.enum(["accepted", "duplicate", "refused"]),
-  reason: z4.string().optional(),
-  result: z4.record(z4.unknown()).optional()
-}).strict();
-var AgentEventSchema = z4.object({
-  type: z4.literal("event"),
-  /** Monotonic per agent connection-independent stream. A client that
-   *  reconnects says which sequence it last saw and is sent the rest. */
-  seq: z4.number().int().nonnegative(),
-  at: z4.number().int().nonnegative(),
-  name: z4.string().min(1),
-  commandId: z4.string().optional(),
-  sessionId: z4.string().optional(),
-  runId: z4.string().optional(),
-  data: z4.record(z4.unknown()).default({})
-}).strict();
-var GapSchema = z4.object({
-  type: z4.literal("gap"),
-  from: z4.number().int().nonnegative(),
-  to: z4.number().int().nonnegative()
-}).strict();
-var HelloSchema = z4.object({
-  type: z4.literal("hello"),
-  protocolVersion: z4.number().int().positive(),
-  agentVersion: z4.string(),
-  deviceId: z4.string().min(1),
-  projects: z4.array(z4.object({ id: z4.string(), name: z4.string() })).default([])
-}).strict();
-var AgentMessageSchema = z4.discriminatedUnion("type", [
-  AckSchema,
-  AgentEventSchema,
-  GapSchema,
-  HelloSchema
-]);
+import fs9 from "fs";
+import path9 from "path";
+import crypto4 from "crypto";
+import { createRequire as createRequire4 } from "module";
 var EventJournal = class {
   constructor(limit = JOURNAL_LIMIT, state) {
     this.limit = limit;
@@ -6220,16 +6742,16 @@ var EventJournal = class {
     return this.state ? this.state.size() : this.events.length;
   }
 };
-var { DatabaseSync } = createRequire3(import.meta.url)("node:sqlite");
+var { DatabaseSync } = createRequire4(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");
-    fs6.mkdirSync(path5.dirname(file), { recursive: true, mode: 448 });
-    const fd = fs6.openSync(file, "a", 384);
-    fs6.closeSync(fd);
-    fs6.chmodSync(file, 384);
+    fs9.mkdirSync(path9.dirname(file), { recursive: true, mode: 448 });
+    const fd = fs9.openSync(file, "a", 384);
+    fs9.closeSync(fd);
+    fs9.chmodSync(file, 384);
     this.db = new DatabaseSync(file);
     try {
       this.db.exec("PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL;");
@@ -6279,7 +6801,7 @@ var AgentState = class {
     const { expiresAt: _expiry, issuedAt: _issued, ...work } = command;
     const text = JSON.stringify(canonical(work));
     if (Buffer.byteLength(text) > 256 * 1024) throw new Error("command exceeds local size limit");
-    return crypto22.createHash("sha256").update(text).digest("hex");
+    return crypto4.createHash("sha256").update(text).digest("hex");
   }
   get(id) {
     const row = this.db.prepare("SELECT fingerprint, state, ack FROM commands WHERE id=?").get(id);
@@ -6618,120 +7140,39 @@ var AgentLink = class {
     if (message["type"] === "command") {
       const ack = await this.opts.agent.handle(message["command"]);
       this.send(ack);
-      this.flush();
-      return;
-    }
-    if (message["type"] === "acked") {
-      const seq = Number(message["seq"] ?? -1);
-      if (!Number.isInteger(seq)) return;
-      this.ackedSeq = Math.max(this.ackedSeq, seq);
-      this.flush();
-    }
-  }
-};
-var HEARTBEAT_MS = 3e4;
-function adapt(socket) {
-  let closed = false;
-  const closeHandlers = [];
-  const fire = () => {
-    if (closed) return;
-    closed = true;
-    clearInterval(heartbeat);
-    for (const handler of closeHandlers) handler();
-  };
-  socket.on("close", fire);
-  socket.on("error", fire);
-  let answered = true;
-  socket.on("pong", () => {
-    answered = true;
-  });
-  const heartbeat = setInterval(() => {
-    if (!answered) {
-      try {
-        socket.terminate();
-      } catch {
-      }
-      fire();
+      this.flush();
       return;
     }
-    answered = false;
-    try {
-      socket.ping();
-    } catch {
-      fire();
-    }
-  }, HEARTBEAT_MS);
-  heartbeat.unref?.();
-  return {
-    send: (data) => {
-      if (socket.readyState !== WebSocket.OPEN) return;
-      try {
-        socket.send(data);
-      } catch {
-        fire();
-      }
-    },
-    close: () => {
-      try {
-        socket.close();
-      } catch {
-      }
-      fire();
-    },
-    onMessage: (handler) => {
-      socket.on("message", (raw, isBinary) => {
-        if (isBinary) return;
-        handler(raw.toString());
-      });
-    },
-    onClose: (handler) => {
-      if (closed) {
-        handler();
-        return;
-      }
-      closeHandlers.push(handler);
+    if (message["type"] === "acked") {
+      const seq = Number(message["seq"] ?? -1);
+      if (!Number.isInteger(seq)) return;
+      this.ackedSeq = Math.max(this.ackedSeq, seq);
+      this.flush();
     }
-  };
-}
-function dialWebSocket(opts) {
-  return () => new Promise((resolve, reject) => {
-    const socket = new WebSocket(opts.url, {
-      handshakeTimeout: opts.handshakeTimeoutMs ?? 1e4,
-      ...opts.headers ? { headers: opts.headers } : {}
-    });
-    const failed = (err) => {
-      try {
-        socket.terminate();
-      } catch {
-      }
-      reject(err instanceof Error ? err : new Error(String(err)));
-    };
-    socket.once("open", () => {
-      socket.off("error", failed);
-      resolve(adapt(socket));
-    });
-    socket.once("error", failed);
-  });
-}
+  }
+};
+
+// ../provider-local/dist/index.js
+import fs10 from "fs";
+import os5 from "os";
+import path10 from "path";
+import fs24 from "fs";
+import path24 from "path";
+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"
+};
 var scratchRoots = /* @__PURE__ */ new Map();
 function scratchRoot(projectId) {
   let root = scratchRoots.get(projectId);
   if (!root) {
-    root = fs23.mkdtempSync(path24.join(os2.tmpdir(), `flowriki-record-${projectId.replace(/[^\w-]/g, "")}-`));
+    root = fs10.mkdtempSync(path10.join(os5.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;
-  const artifactLimit = deps.artifactLimitBytes ?? 25 * 1024 * 1024;
-  const cancels = /* @__PURE__ */ new Map();
+function repositoryHandlers({ storeFor }) {
   return {
     "project.list": async (command, project) => {
       if (!project.root) return NO_CHECKOUT;
@@ -6775,24 +7216,6 @@ function buildHandlers(deps) {
         }
       };
     },
-    "runs.list": async (command) => {
-      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
-      const page = await storage.listRuns({
-        limit: Math.min(100, Number(command.args["limit"] ?? 20)),
-        ...command.args["flowId"] ? { flowId: String(command.args["flowId"]) } : {}
-      });
-      return { ok: true, result: { runs: page.runs, nextCursor: page.nextCursor ?? null } };
-    },
-    "run.get": async (command) => {
-      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
-      const run = await storage.getRun(String(command.args["runId"] ?? ""));
-      if (!run) return { ok: false, reason: "failed", detail: "run not found" };
-      return { ok: true, result: { run } };
-    },
-    "runs.stats": async (command) => {
-      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
-      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) {
@@ -6861,26 +7284,17 @@ function buildHandlers(deps) {
     // nowhere on the way: the command ledger stores a SHA-256 of the command
     // 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) => {
+    "flow.delete": 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"];
-      if (typeof value !== "string") {
-        return { ok: false, reason: "failed", detail: "a secret needs a value" };
-      }
-      try {
-        store.writeSecret(ref, value);
-      } catch (err) {
-        return { ok: false, reason: "failed", detail: String(err.message) };
-      }
-      return { ok: true, result: { ref, set: true } };
+      const flowId = String(command.args["flowId"] ?? "");
+      if (!store.getFlow(flowId)) return { ok: true, result: { deleted: false } };
+      store.deleteFlow(flowId);
+      return { ok: true, result: { deleted: true } };
     },
-    // A new feature: one directory and one feature.json, in the tester's own
-    // repository. The hosted dashboard had no way to make one at all, so a
-    // hosted project could only ever record into features somebody had created
-    // from the CLI or the local app — which, for anybody who had only ever
-    // used the hosted service, was none.
+    // Checking unsaved steps against a real page. The steps travel in the
+    // command because the whole point is to check an edit nobody has saved —
+    // saving is gated on this passing.
     "feature.create": async (command, project) => {
       if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
@@ -6894,95 +7308,26 @@ function buildHandlers(deps) {
         return { ok: false, reason: /already exists/.test(detail) ? "name_taken" : "failed", detail };
       }
     },
-    "flow.delete": async (command, project) => {
+    "secret.set": 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 } };
-      store.deleteFlow(flowId);
-      return { ok: true, result: { deleted: true } };
-    },
-    // Checking unsaved steps against a real page. The steps travel in the
-    // 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" };
-      }
-      const flowId = String(command.args["flowId"] ?? "");
-      try {
-        const outcome = await deps.verify({
-          root: project.root,
-          flowId,
-          ...command.args["steps"] ? { steps: command.args["steps"] } : {},
-          verifyIds: command.args["verifyIds"] ?? [],
-          ...command.args["watch"] === void 0 ? {} : { watch: Boolean(command.args["watch"]) },
-          // Streamed, so a hosted editor fills in as the pass proceeds instead
-          // of sitting blank for the twenty-odd seconds a replay takes.
-          onStepResult: (result) => emit("verify.step", { flowId, result })
-        });
-        emit("verify.finished", { flowId, outcome });
-        return { ok: true, result: outcome };
-      } catch (err) {
-        const name = err.name;
-        if (name === "BrowserBusy") return { ok: false, reason: "busy", detail: String(err.message) };
-        if (name === "FlowNotFound") return { ok: false, reason: "failed", detail: "flow not found" };
-        return { ok: false, reason: "failed", detail: String(err.message) };
-      }
-    },
-    // ── stepping through a flow ─────────────────────────────────────────
-    // 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) => {
-      if (!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"]) }
-        });
-        onActivity?.({ kind: "debugging", projectId: project.id, detail: started.flowId });
-        return { ok: true, result: started };
-      } catch (err) {
-        const name = err.name;
-        if (name === "BrowserBusy") return { ok: false, reason: "busy", detail: String(err.message) };
-        if (name === "FlowNotFound") return { ok: false, reason: "failed", detail: "flow not found" };
-        return { ok: false, reason: "failed", detail: String(err.message) };
+      const ref = String(command.args["ref"] ?? "");
+      const value = command.args["value"];
+      if (typeof value !== "string") {
+        return { ok: false, reason: "failed", detail: "a secret needs a value" };
       }
-    },
-    // A read, so it stays out of EFFECTFUL: it is how a dashboard opened
-    // mid-session catches up rather than showing a stale half-run.
-    "debug.status": async () => ({
-      ok: true,
-      result: debugging?.status() ?? { flowId: null, state: null }
-    }),
-    "debug.command": async (command) => {
-      if (!debugging) return { ok: false, reason: "failed", detail: "no debug session is running" };
       try {
-        const state = await debugging.command(String(command.args["command"] ?? ""), {
-          ...command.args["stepId"] === void 0 ? {} : { stepId: command.args["stepId"] },
-          ...command.args["patch"] === void 0 ? {} : { patch: command.args["patch"] },
-          ...command.args["toIndex"] === void 0 ? {} : { toIndex: command.args["toIndex"] },
-          ...command.args["on"] === void 0 ? {} : { on: command.args["on"] }
-        });
-        return { ok: true, result: { state } };
+        store.writeSecret(ref, value);
       } catch (err) {
         return { ok: false, reason: "failed", detail: String(err.message) };
       }
+      return { ok: true, result: { ref, set: true } };
     },
-    "debug.end": async (command) => {
-      if (!debugging) return { ok: false, reason: "failed", detail: "no debug session is running" };
-      try {
-        const res = await debugging.end(command.args["commit"] !== false);
-        if (!res.ok) return { ok: false, reason: "failed", detail: res.error ?? "no debug session is running" };
-        return { ok: true, result: res };
-      } finally {
-        onActivity?.(null);
-      }
-    },
+    // A new feature: one directory and one feature.json, in the tester's own
+    // repository. The hosted dashboard had no way to make one at all, so a
+    // hosted project could only ever record into features somebody had created
+    // from the CLI or the local app — which, for anybody who had only ever
+    // used the hosted service, was none.
     "config.save": async (command, project) => {
       if (!project.root) return NO_CHECKOUT;
       const store = storeFor(project.root);
@@ -6992,10 +7337,15 @@ function buildHandlers(deps) {
       } catch (err) {
         return { ok: false, reason: "failed", detail: String(err.message) };
       }
-    },
+    }
     // What this folder actually is. A read: nothing is written, nothing is
     // 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".
+  };
+}
+function bindingHandlers(ctx) {
+  const { deps } = ctx;
+  return {
     "project.status": async (_command, project) => {
       if (!project.root) return NO_CHECKOUT;
       if (!deps.binding) {
@@ -7019,7 +7369,62 @@ function buildHandlers(deps) {
       } catch (err) {
         return { ok: false, reason: "failed", detail: String(err.message) };
       }
-    },
+    }
+  };
+}
+function historyHandlers({ storage, artifactLimit }) {
+  return {
+    "runs.list": async (command) => {
+      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
+      const page = await storage.listRuns({
+        limit: Math.min(100, Number(command.args["limit"] ?? 20)),
+        ...command.args["flowId"] ? { flowId: String(command.args["flowId"]) } : {}
+      });
+      return { ok: true, result: { runs: page.runs, nextCursor: page.nextCursor ?? null } };
+    },
+    "run.get": async (command) => {
+      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
+      const run = await storage.getRun(String(command.args["runId"] ?? ""));
+      if (!run) return { ok: false, reason: "failed", detail: "run not found" };
+      return { ok: true, result: { run } };
+    },
+    "runs.stats": async (command) => {
+      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
+      return { ok: true, result: { ...await storage.runStats(Number(command.args["days"] ?? 7)) } };
+    },
+    "artifact.fetch": async (command, project) => {
+      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
+      const runId = String(command.args["runId"] ?? "");
+      const artifactId = String(command.args["artifactId"] ?? "");
+      const run = await storage.getRun(runId);
+      if (!run) return { ok: false, reason: "failed", detail: `no run ${runId} on this machine` };
+      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 = path24.join(dir, artifact.relPath);
+      if (!isInside(dir, file) || !fs24.existsSync(file) || !isInside(fs24.realpathSync(dir), fs24.realpathSync(file))) {
+        return { ok: false, reason: "failed", detail: "the artifact file is not on this machine" };
+      }
+      const { size } = fs24.statSync(file);
+      if (size > artifactLimit) {
+        return { ok: false, reason: "failed", detail: `this artifact is ${size} bytes, over the ${artifactLimit}-byte transfer limit` };
+      }
+      return {
+        ok: true,
+        result: {
+          projectId: project.id,
+          kind: artifact.kind,
+          masked: artifact.masked,
+          bytes: size,
+          base64: fs24.readFileSync(file).toString("base64")
+        }
+      };
+    }
+  };
+}
+function executionHandlers(ctx) {
+  const { storeFor, storage, onActivity, lease, cancels } = ctx;
+  return {
     "flow.run": async (command, project, emit) => {
       if (command.flowRevision === void 0) {
         return { ok: false, reason: "stale_revision", detail: "reload the flow and supply its revision before running" };
@@ -7105,15 +7510,17 @@ function buildHandlers(deps) {
       if (!cancelled || cancelled.projectId !== project.id) return { ok: false, reason: "failed", detail: `no run ${runId} is in progress on this machine` };
       cancelled.cancel();
       return { ok: true, result: { runId, projectId: project.id, stopping: true } };
-    },
+    }
+  };
+}
+function recordingHandlers({ recorder, onActivity }) {
+  return {
     "record.start": async (command, project) => {
       if (!recorder) return { ok: false, reason: "failed", detail: "this agent cannot record \u2014 no browser is configured" };
       if (recorder.active()) return { ok: false, reason: "busy", detail: "a recording is already in progress on this machine" };
       const featureId = String(command.args["featureId"] ?? "");
       const name = String(command.args["name"] ?? "").trim();
       if (!featureId || !name) return { ok: false, reason: "failed", detail: "featureId and name are both required" };
-      const claim = lease?.acquire("run");
-      if (claim && !claim.ok) return { ok: false, reason: "busy", detail: `the browser on this machine is in use (${claim.heldBy})` };
       const optional = (key) => command.args[key] === void 0 ? void 0 : String(command.args[key]);
       try {
         const url = optional("url");
@@ -7142,11 +7549,9 @@ function buildHandlers(deps) {
           ...command.args["environment"] ? { environment: command.args["environment"] } : {},
           ...headless === void 0 ? {} : { headless }
         });
-        lease?.activate("run");
         onActivity?.({ kind: "recording", projectId: project.id, detail: name });
         return { ok: true, result: { url: started.url, projectId: project.id } };
       } catch (err) {
-        lease?.release("run");
         const detail = String(err.message);
         const busy = err.name === "BrowserBusy";
         return { ok: false, reason: busy ? "busy" : "failed", detail };
@@ -7160,7 +7565,6 @@ function buildHandlers(deps) {
         return { ok: true, result: { flow: saved.flow, projectId: project.id } };
       } finally {
         onActivity?.(null);
-        lease?.release("run");
       }
     },
     "record.discard": async () => {
@@ -7171,7 +7575,6 @@ function buildHandlers(deps) {
         return { ok: true, result: { discarded: true } };
       } finally {
         onActivity?.(null);
-        lease?.release("run");
       }
     },
     // Reading, so it is not in EFFECTFUL and is safe to redeliver. It is how a
@@ -7197,38 +7600,133 @@ function buildHandlers(deps) {
       } catch (err) {
         return { ok: false, reason: "failed", detail: String(err.message) };
       }
+    }
+  };
+}
+function debuggingHandlers(ctx) {
+  const { debugging, onActivity, deps } = ctx;
+  return {
+    "flow.verify": async (command, project, emit) => {
+      const carried = command.args["flow"];
+      if (!carried && !project.root) return NO_CHECKOUT;
+      if (!deps.verify) {
+        return { ok: false, reason: "failed", detail: "this agent cannot verify steps \u2014 no browser is configured" };
+      }
+      const flowId = String(command.args["flowId"] ?? "");
+      try {
+        const outcome = await deps.verify({
+          root: project.root,
+          ...carried ? { delivered: {
+            flow: carried,
+            secrets: command.args["secrets"] ?? {},
+            config: command.args["config"] ?? {}
+          } } : {},
+          flowId,
+          ...command.args["steps"] ? { steps: command.args["steps"] } : {},
+          verifyIds: command.args["verifyIds"] ?? [],
+          ...command.args["watch"] === void 0 ? {} : { watch: Boolean(command.args["watch"]) },
+          // Streamed, so a hosted editor fills in as the pass proceeds instead
+          // of sitting blank for the twenty-odd seconds a replay takes.
+          onStepResult: (result) => emit("verify.step", { flowId, result })
+        });
+        emit("verify.finished", { flowId, outcome });
+        return { ok: true, result: outcome };
+      } catch (err) {
+        const name = err.name;
+        if (name === "BrowserBusy") return { ok: false, reason: "busy", detail: String(err.message) };
+        if (name === "FlowNotFound") return { ok: false, reason: "failed", detail: "flow not found" };
+        return { ok: false, reason: "failed", detail: String(err.message) };
+      }
     },
-    "artifact.fetch": async (command, project) => {
-      if (!storage) return { ok: false, reason: "failed", detail: "run history is not available on this machine" };
-      const runId = String(command.args["runId"] ?? "");
-      const artifactId = String(command.args["artifactId"] ?? "");
-      const run = await storage.getRun(runId);
-      if (!run) return { ok: false, reason: "failed", detail: `no run ${runId} on this machine` };
-      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 = 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" };
+    // ── stepping through a flow ─────────────────────────────────────────
+    // 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" };
       }
-      const { size } = fs23.statSync(file);
-      if (size > artifactLimit) {
-        return { ok: false, reason: "failed", detail: `this artifact is ${size} bytes, over the ${artifactLimit}-byte transfer limit` };
+      try {
+        const started = await debugging.start(String(command.args["flowId"] ?? ""), {
+          root: project.root,
+          ...command.args["breakpoints"] ? { breakpoints: command.args["breakpoints"] } : {},
+          ...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 };
+      } catch (err) {
+        const name = err.name;
+        if (name === "BrowserBusy") return { ok: false, reason: "busy", detail: String(err.message) };
+        if (name === "FlowNotFound") return { ok: false, reason: "failed", detail: "flow not found" };
+        return { ok: false, reason: "failed", detail: String(err.message) };
+      }
+    },
+    // A read, so it stays out of EFFECTFUL: it is how a dashboard opened
+    // mid-session catches up rather than showing a stale half-run.
+    "debug.status": async () => ({
+      ok: true,
+      result: debugging?.status() ?? { flowId: null, state: null }
+    }),
+    "debug.command": async (command) => {
+      if (!debugging) return { ok: false, reason: "failed", detail: "no debug session is running" };
+      try {
+        const state = await debugging.command(String(command.args["command"] ?? ""), {
+          ...command.args["stepId"] === void 0 ? {} : { stepId: command.args["stepId"] },
+          ...command.args["patch"] === void 0 ? {} : { patch: command.args["patch"] },
+          ...command.args["toIndex"] === void 0 ? {} : { toIndex: command.args["toIndex"] },
+          ...command.args["on"] === void 0 ? {} : { on: command.args["on"] }
+        });
+        return { ok: true, result: { state } };
+      } catch (err) {
+        return { ok: false, reason: "failed", detail: String(err.message) };
+      }
+    },
+    "debug.end": async (command) => {
+      if (!debugging) return { ok: false, reason: "failed", detail: "no debug session is running" };
+      try {
+        const res = await debugging.end(command.args["commit"] !== false);
+        if (!res.ok) return { ok: false, reason: "failed", detail: res.error ?? "no debug session is running" };
+        return { ok: true, result: res };
+      } finally {
+        onActivity?.(null);
       }
-      return {
-        ok: true,
-        result: {
-          projectId: project.id,
-          kind: artifact.kind,
-          masked: artifact.masked,
-          bytes: size,
-          base64: fs23.readFileSync(file).toString("base64")
-        }
-      };
     }
   };
 }
+function buildHandlers(deps) {
+  const context = {
+    deps,
+    storeFor: deps.storeFor,
+    storage: deps.storage ?? null,
+    onActivity: deps.onActivity,
+    lease: deps.lease,
+    recorder: deps.recorder,
+    debugging: deps.debugger,
+    // A video is easily hundreds of megabytes, and nobody wants one pushed down
+    // a control channel by accident.
+    artifactLimit: deps.artifactLimitBytes ?? 25 * 1024 * 1024,
+    cancels: /* @__PURE__ */ new Map()
+  };
+  return {
+    ...repositoryHandlers(context),
+    ...bindingHandlers(context),
+    ...historyHandlers(context),
+    ...executionHandlers(context),
+    ...recordingHandlers(context),
+    ...debuggingHandlers(context)
+  };
+}
 function createAgentRuntime(options) {
+  const lease = new BrowserLease();
   let journal = null;
   const coordinators = /* @__PURE__ */ new Map();
   let recordingIn = null;
@@ -7238,6 +7736,7 @@ function createAgentRuntime(options) {
     let existing = coordinators.get(projectRoot);
     if (!existing) {
       existing = new RecordingCoordinator({
+        lease,
         store: new Store(projectRoot),
         emit: (event) => {
           if (event.type === "recording.stopped") lastRecording = { ok: true, flow: event.flow };
@@ -7253,8 +7752,11 @@ 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),
+        lease,
+        store,
+        commit: { to: "disk", store },
         emit: (event) => {
           journal?.append({ name: `debug.${event.type.replace(/^debug\./, "")}`, data: event });
         }
@@ -7263,10 +7765,25 @@ function createAgentRuntime(options) {
     }
     return existing;
   };
+  const deliveredDebugger = (delivered) => new DebugCoordinator({
+    lease,
+    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(opts.root);
       const started = await coordinator.start(flowId, opts);
       debuggingIn = coordinator;
       return started;
@@ -7285,7 +7802,11 @@ function createAgentRuntime(options) {
     active: () => Boolean(debuggingIn?.active())
   };
   const verify = (opts) => verifyFlowSteps(
-    { store: new Store(opts.root), onStepResult: opts.onStepResult },
+    {
+      store: opts.delivered ? deliveredRun(opts.delivered) : new Store(opts.root),
+      lease,
+      onStepResult: opts.onStepResult
+    },
     {
       flowId: opts.flowId,
       ...opts.steps ? { steps: opts.steps } : {},
@@ -7307,197 +7828,88 @@ function createAgentRuntime(options) {
     stop: async (projectId) => {
       if (projectId && recordingProject && projectId !== recordingProject) return { ok: false, error: "This recording belongs to another project" };
       if (lastRecording?.ok) return lastRecording;
-      if (!recordingIn) return lastRecording ?? { ok: false, error: "no recording is in progress on this machine" };
-      const result = await recordingIn.stop();
-      lastRecording = result;
-      return result;
-    },
-    discard: async () => {
-      if (!recordingIn) return { ok: false, error: "no recording is in progress on this machine" };
-      const result = await recordingIn.discard();
-      recordingIn = null;
-      return result;
-    },
-    status: () => recordingIn?.status() ?? { active: false, featureId: null, name: null, steps: [], dialog: null },
-    answerDialog: async (accept, promptText) => {
-      if (!recordingIn) throw new Error("No recording is active");
-      await recordingIn.answerDialog(accept, promptText);
-    },
-    active: () => recordingIn?.active() ?? null
-  };
-  function buildAgent() {
-    return new Agent({
-      stateFile: options.stateFile,
-      deviceId: options.deviceId,
-      agentVersion: options.agentVersion,
-      // EVERY checkout, each named by its own marker. One agent run serves
-      // all of them; the service routes each command to the folder that is
-      // the project it names.
-      projects: options.projects,
-      handlers: buildHandlers({
-        storeFor: (r) => new Store(r),
-        ...options.storage ? { storage: options.storage } : {},
-        recorder,
-        // Reading and writing the repository marker. All of it runs here, with
-        // this person's git credentials; the service only ever asks.
-        binding: {
-          read: (r) => readRepo(r),
-          claim: (r, marker) => writeMarker(r, marker),
-          ensureRoot: (r) => ensureRootCommit(r)
-        },
-        debugger: debugControl,
-        verify,
-        // Somebody at a keyboard should be able to see that a remote page just
-        // opened a browser on their machine, and what for.
-        // Somebody at a keyboard should be able to see that a remote page just
-        // opened a browser on their machine, and what for — but a library does
-        // not decide how that is shown. It is reported; the caller presents it.
-        onActivity: (activity) => {
-          options.onEvent?.(
-            activity ? { name: "activity", data: { kind: activity.kind, detail: activity.detail } } : { name: "activity", data: {} }
-          );
-        }
-      })
-    });
-  }
-  const agent = buildAgent();
-  journal = agent.journal;
-  return agent;
-}
-
-// src/engine.ts
-import fs10 from "fs";
-import path7 from "path";
-
-// src/credentials.ts
-import crypto3 from "crypto";
-import fs8 from "fs";
-
-// src/paths.ts
-import fs7 from "fs";
-import os3 from "os";
-import path6 from "path";
-function dataDir(env = process.env) {
-  const override = env["FLOWRIKI_HOME"]?.trim();
-  if (override) return path6.resolve(override);
-  if (process.platform === "win32") {
-    const appData = env["APPDATA"]?.trim();
-    return appData ? path6.join(appData, "Flowriki") : path6.join(os3.homedir(), "AppData", "Roaming", "Flowriki");
-  }
-  if (process.platform === "darwin") {
-    return path6.join(os3.homedir(), "Library", "Application Support", "Flowriki");
-  }
-  const state = env["XDG_STATE_HOME"]?.trim();
-  return state ? path6.join(state, "flowriki") : path6.join(os3.homedir(), ".local", "state", "flowriki");
-}
-function ensureDataDir(env = process.env) {
-  const dir = dataDir(env);
-  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
-  if (process.platform !== "win32") {
-    try {
-      fs7.chmodSync(dir, 448);
-    } catch {
-    }
-  }
-  return dir;
-}
-var credentialsPath = (env = process.env) => path6.join(dataDir(env), "credentials.json");
-var lockPath = (env = process.env) => path6.join(dataDir(env), "agent.lock");
-var ledgerPath = (deviceId, env = process.env) => path6.join(dataDir(env), `ledger-${deviceId}.sqlite`);
-
-// src/credentials.ts
-function readFile(env = process.env) {
-  try {
-    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) => ({
-      service: (d.url ?? "").replace(/^ws/, "http").replace(/\/agent$/, ""),
-      deviceId: d.deviceId,
-      secret: d.secret,
-      machineName: "this machine",
-      connectedAt: d.pairedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-      ...d.checkouts ? { checkouts: d.checkouts } : {}
-    })).filter((c) => c.service);
-    return { version: 3, connections };
-  } catch {
-    return { version: 3, connections: [] };
-  }
-}
-function connectionFor(service, env = process.env) {
-  return readFile(env).connections.find((c) => c.service === service) ?? null;
-}
-function allConnections(env = process.env) {
-  return readFile(env).connections;
-}
-function saveConnection(connection, env = process.env) {
-  ensureDataDir(env);
-  const file = credentialsPath(env);
-  const next = {
-    version: 3,
-    connections: [...readFile(env).connections.filter((c) => c.service !== connection.service), connection]
+      if (!recordingIn) return lastRecording ?? { ok: false, error: "no recording is in progress on this machine" };
+      const result = await recordingIn.stop();
+      lastRecording = result;
+      return result;
+    },
+    discard: async () => {
+      if (!recordingIn) return { ok: false, error: "no recording is in progress on this machine" };
+      const result = await recordingIn.discard();
+      recordingIn = null;
+      return result;
+    },
+    status: () => recordingIn?.status() ?? { active: false, featureId: null, name: null, steps: [], dialog: null },
+    answerDialog: async (accept, promptText) => {
+      if (!recordingIn) throw new Error("No recording is active");
+      await recordingIn.answerDialog(accept, promptText);
+    },
+    active: () => recordingIn?.active() ?? null
   };
-  const temporary = `${file}.${process.pid}.tmp`;
-  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;
-  const after = before.filter((c) => c.service !== service);
-  if (after.length === before.length) return false;
-  ensureDataDir(env);
-  const file = credentialsPath(env);
-  const temporary = `${file}.${process.pid}.tmp`;
-  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);
-
-// src/service.ts
-var BadServiceUrl = class extends Error {
-};
-function resolveService(explicit, env = process.env) {
-  const raw = explicit?.trim() || env["FLOWRIKI_SERVICE_URL"]?.trim() || PRODUCTION_SERVICE;
-  let url;
-  try {
-    url = new URL(raw);
-  } catch {
-    throw new BadServiceUrl(`"${raw}" is not a URL \u2014 expected something like https://flowriki.example`);
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new BadServiceUrl(`"${raw}" is not http or https`);
-  }
-  const loopback = ["localhost", "127.0.0.1", "[::1]", "::1"].includes(url.hostname);
-  if (url.protocol === "http:" && !loopback) {
-    throw new BadServiceUrl(`refusing to use plain http for ${url.hostname} \u2014 a device credential would cross the network in the clear`);
+  function buildAgent() {
+    return new Agent({
+      stateFile: options.stateFile,
+      deviceId: options.deviceId,
+      agentVersion: options.agentVersion,
+      // EVERY checkout, each named by its own marker. One agent run serves
+      // all of them; the service routes each command to the folder that is
+      // the project it names.
+      projects: options.projects,
+      handlers: buildHandlers({
+        lease,
+        storeFor: (r) => new Store(r),
+        ...options.storage ? { storage: options.storage } : {},
+        recorder,
+        // Reading and writing the repository marker. All of it runs here, with
+        // this person's git credentials; the service only ever asks.
+        binding: {
+          read: (r) => readRepo(r),
+          claim: (r, marker) => writeMarker(r, marker),
+          ensureRoot: (r) => ensureRootCommit(r)
+        },
+        debugger: debugControl,
+        verify,
+        // Somebody at a keyboard should be able to see that a remote page just
+        // opened a browser on their machine, and what for.
+        // Somebody at a keyboard should be able to see that a remote page just
+        // opened a browser on their machine, and what for — but a library does
+        // not decide how that is shown. It is reported; the caller presents it.
+        onActivity: (activity) => {
+          options.onEvent?.(
+            activity ? { name: "activity", data: { kind: activity.kind, detail: activity.detail } } : { name: "activity", data: {} }
+          );
+        }
+      })
+    });
   }
-  return url.origin + (url.pathname === "/" ? "" : url.pathname.replace(/\/+$/, ""));
+  const agent = buildAgent();
+  journal = agent.journal;
+  return agent;
 }
 
 // src/lock.ts
-import fs9 from "fs";
-import os4 from "os";
+import fs11 from "fs";
+import os6 from "os";
 function takeLock(env = process.env) {
   ensureDataDir(env);
   const file = lockPath(env);
-  const mine = { pid: process.pid, since: (/* @__PURE__ */ new Date()).toISOString(), host: os4.hostname() };
+  const mine = { pid: process.pid, since: (/* @__PURE__ */ new Date()).toISOString(), host: os6.hostname() };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      fs9.writeFileSync(file, JSON.stringify(mine), { flag: "wx", mode: 384 });
+      fs11.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 {
-          fs9.rmSync(file, { force: true });
+          fs11.rmSync(file, { force: true });
         } catch {
         }
         continue;
       }
       if (held.host === mine.host && !alive(held.pid)) {
         try {
-          fs9.rmSync(file, { force: true });
+          fs11.rmSync(file, { force: true });
         } catch {
         }
         continue;
@@ -7509,7 +7921,7 @@ function takeLock(env = process.env) {
 }
 function readLock(file) {
   try {
-    const held = JSON.parse(fs9.readFileSync(file, "utf8"));
+    const held = JSON.parse(fs11.readFileSync(file, "utf8"));
     return typeof held.pid === "number" ? { pid: held.pid, since: held.since ?? "", host: held.host ?? "" } : null;
   } catch {
     return null;
@@ -7528,144 +7940,13 @@ function releaseLock(file, pid) {
   const held = readLock(file);
   if (held?.pid === pid) {
     try {
-      fs9.rmSync(file, { force: true });
+      fs11.rmSync(file, { force: true });
     } catch {
     }
   }
 }
 
-// src/open-browser.ts
-import { spawn } from "child_process";
-function canOpenBrowser(env = process.env) {
-  if (process.platform === "win32" || process.platform === "darwin") return true;
-  return Boolean(env["DISPLAY"] || env["WAYLAND_DISPLAY"]);
-}
-function openBrowser(url, env = process.env) {
-  if (!canOpenBrowser(env)) return "no-display";
-  try {
-    if (process.platform === "win32") {
-      spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true, windowsHide: true }).unref();
-    } else if (process.platform === "darwin") {
-      spawn("open", [url], { stdio: "ignore", detached: true }).unref();
-    } else {
-      spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
-    }
-    return "opened";
-  } catch {
-    return "failed";
-  }
-}
-
-// src/engine.ts
-var AGENT_VERSION = "0.1.0-beta.7";
-async function connect(options = {}) {
-  let service;
-  try {
-    service = resolveService(options.service);
-  } catch (error) {
-    return { ok: false, reason: "refused", message: error.message };
-  }
-  const existing = connectionFor(service);
-  if (existing) {
-    const still = await verifyConnection(existing).catch(() => false);
-    if (still) return { ok: true, connection: existing, reused: true };
-    options.onProgress?.({
-      kind: "stale",
-      message: "the stored connection is no longer accepted \u2014 asking for a new one"
-    });
-  }
-  const machineName = options.machineName?.trim() || `${os5.userInfo().username}@${os5.hostname()}`;
-  let asked;
-  try {
-    const res = await fetch(`${service}/api/pairing-requests`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ machineName, agentVersion: AGENT_VERSION }),
-      signal: options.signal ?? null
-    });
-    if (!res.ok) {
-      return { ok: false, reason: "refused", message: `${service} refused the request (${res.status})` };
-    }
-    asked = await res.json();
-  } catch (error) {
-    return { ok: false, reason: "unreachable", message: `could not reach ${service} \u2014 ${error.message}` };
-  }
-  const approve = `${service}${asked.approveUrl}`;
-  options.onProgress?.({
-    kind: "approve",
-    message: "waiting for approval in your browser",
-    detail: { url: approve, machineName, canOpen: canOpenBrowser() }
-  });
-  openBrowser(approve);
-  const pollMs = options.pollMs ?? 1500;
-  const deadline = Date.now() + (options.timeoutMs ?? 10 * 60 * 1e3);
-  while (Date.now() < deadline) {
-    if (options.signal?.aborted) return { ok: false, reason: "aborted", message: "cancelled" };
-    const res = await fetch(`${service}/api/pairing-requests/${encodeURIComponent(asked.requestId)}/claim`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ claim: asked.claim })
-    }).catch(() => null);
-    if (res?.status === 200) {
-      const granted = await res.json();
-      const connection = {
-        service,
-        deviceId: granted.deviceId,
-        secret: granted.secret,
-        machineName,
-        connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        ...existing?.checkouts ? { checkouts: existing.checkouts } : {}
-      };
-      saveConnection(connection);
-      return { ok: true, connection, reused: false };
-    }
-    if (res && res.status !== 202) {
-      const body = await res.json().catch(() => ({}));
-      return { ok: false, reason: "refused", message: body.error ?? `refused (${res.status})` };
-    }
-    await new Promise((r) => setTimeout(r, pollMs));
-  }
-  return { ok: false, reason: "expired", message: "nobody approved this in time" };
-}
-async function verifyConnection(connection) {
-  const res = await fetch(`${connection.service}/api/agent-check`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ deviceId: connection.deviceId, secret: connection.secret })
-  });
-  if (res.status === 404) return true;
-  return res.ok;
-}
-function resolveCheckouts(dirs) {
-  const projects = [];
-  const skipped = [];
-  for (const dir of dirs) {
-    const root = path7.resolve(dir);
-    if (!fs10.existsSync(root)) {
-      skipped.push({ root, why: "no such folder" });
-      continue;
-    }
-    const facts = readRepo(root);
-    if (!facts.isRepo) {
-      skipped.push({ root, why: "not a git repository" });
-      continue;
-    }
-    if (facts.markerUnreadable) {
-      skipped.push({ root, why: `${MARKER_PATH} is there but cannot be read` });
-      continue;
-    }
-    if (!facts.marker) {
-      skipped.push({ root, why: "not connected to a Flowriki project \u2014 connect its repository from the dashboard" });
-      continue;
-    }
-    if (projects.some((p) => p.id === facts.marker.projectId)) {
-      skipped.push({ root, why: "another folder here is already that project" });
-      continue;
-    }
-    projects.push({ id: facts.marker.projectId, name: facts.marker.name, root });
-  }
-  return { projects, skipped };
-}
+// src/engine/session.ts
 async function start(options = {}) {
   let service;
   try {
@@ -7744,36 +8025,8 @@ async function start(options = {}) {
     }
   };
 }
-async function prepareBrowsers() {
-  if (browsersReady()) {
-    return { ok: true, already: true, message: "chromium is already installed" };
-  }
-  let cli;
-  try {
-    cli = createRequire4(import.meta.url).resolve("playwright/cli.js");
-  } catch {
-    return {
-      ok: false,
-      already: false,
-      message: "playwright is not installed beside this agent \u2014 reinstall it"
-    };
-  }
-  const run = spawnSync(process.execPath, [cli, "install", "chromium"], { stdio: "inherit" });
-  if (run.status !== 0) {
-    return {
-      ok: false,
-      already: false,
-      message: `could not install chromium (exit ${run.status ?? "unknown"}) \u2014 try \`npx playwright@${playwrightVersion() ?? "latest"} install chromium\` yourself`
-    };
-  }
-  return { ok: browsersReady(), already: false, message: "chromium installed" };
-}
-function browsersReady() {
-  return inspectPlaywright().chromiumInstalled === true;
-}
-function playwrightVersion() {
-  return inspectPlaywright().version;
-}
+
+// src/engine/state.ts
 function status(serviceArg) {
   const service = resolveService(serviceArg);
   const connection = connectionFor(service);
@@ -7808,10 +8061,18 @@ async function doctor(serviceArg) {
   const connection = connectionFor(service);
   let reachable = null;
   let serviceError;
+  let environment = null;
   try {
     const res = await fetch(`${service}/healthz`, { signal: AbortSignal.timeout(1e4) });
     reachable = res.ok;
     if (!res.ok) serviceError = `healthz returned ${res.status}`;
+    else {
+      try {
+        const body = await res.json();
+        environment = typeof body.environment === "string" ? body.environment : null;
+      } catch {
+      }
+    }
   } catch (error) {
     reachable = false;
     serviceError = error.message;
@@ -7826,6 +8087,7 @@ async function doctor(serviceArg) {
     arch: process.arch,
     dataDir: dataDir(),
     service,
+    environment,
     credentialFingerprint: connection ? fingerprint(connection.secret) : null,
     reachable,
     ...serviceError ? { serviceError } : {},
@@ -7833,15 +8095,6 @@ async function doctor(serviceArg) {
     problems
   };
 }
-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 = 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 };
-  }
-}
 function disconnect(serviceArg) {
   const service = resolveService(serviceArg);
   const removed = forgetConnection(service);
@@ -7850,11 +8103,11 @@ function disconnect(serviceArg) {
 
 export {
   AGENT_VERSION,
+  prepareBrowsers,
+  browsersReady,
   connect,
   resolveCheckouts,
   start,
-  prepareBrowsers,
-  browsersReady,
   status,
   doctor,
   disconnect