@hasna/loops 0.4.13 → 0.4.22

package/dist/mcp/index.js

@@ -3,9 +3,9 @@
 
 // src/lib/store.ts
 import { Database } from "bun:sqlite";
-import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync2 } from "fs";
-import { tmpdir } from "os";
-import { basename as basename2, dirname as dirname2, join as join3 } from "path";
+import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname2, join as join4 } from "path";
 
 // src/lib/errors.ts
 class CodedError extends Error {
@@ -1204,15 +1204,378 @@ function discardWorkflowRunManifest(staged) {
   } catch {}
 }
 
+// src/lib/run-receipts.ts
+import { createHash as createHash2 } from "crypto";
+import { hostname } from "os";
+
+// src/lib/run-envelope.ts
+var ENVELOPE_EXCERPT_CHARS = 2048;
+var BLOCKED_STEP_ERROR_PREFIX = "blocked:";
+function boundedExcerpt(text, limit = ENVELOPE_EXCERPT_CHARS) {
+  if (!text)
+    return;
+  const scrubbed = scrubSecrets(text);
+  if (scrubbed.length <= limit * 2)
+    return scrubbed;
+  const omitted = scrubbed.length - limit * 2;
+  return `${scrubbed.slice(0, limit)}
+[... ${omitted} chars omitted ...]
+${scrubbed.slice(-limit)}`;
+}
+function summarizeOutput(stdout, stderr) {
+  return {
+    stdoutBytes: stdout ? Buffer.byteLength(stdout, "utf8") : 0,
+    stderrBytes: stderr ? Buffer.byteLength(stderr, "utf8") : 0,
+    stdoutExcerpt: boundedExcerpt(stdout),
+    stderrExcerpt: boundedExcerpt(stderr)
+  };
+}
+function summarizeExecutorResult(result) {
+  return {
+    ...summarizeOutput(result.stdout, result.stderr),
+    status: result.status,
+    exitCode: result.exitCode,
+    durationMs: result.durationMs,
+    error: boundedExcerpt(result.error)
+  };
+}
+function isBlockedStepRun(step) {
+  return step?.status === "skipped" && (step.error?.startsWith(BLOCKED_STEP_ERROR_PREFIX) ?? false);
+}
+function summarizeWorkflowStepRun(step) {
+  return {
+    ...summarizeOutput(step.stdout, step.stderr),
+    stepId: step.stepId,
+    status: step.status,
+    exitCode: step.exitCode,
+    durationMs: step.durationMs,
+    error: boundedExcerpt(step.error),
+    blocked: isBlockedStepRun(step)
+  };
+}
+function workflowRunEnvelope(run, steps) {
+  return JSON.stringify({ workflowRun: run, steps: steps.map(summarizeWorkflowStepRun) }, null, 2);
+}
+
+// src/lib/run-receipts.ts
+var RUN_RECEIPT_SUMMARY_TEXT_CHARS = 4096;
+var RUN_RECEIPT_MAX_IDS = 100;
+var RUN_RECEIPT_MAX_EVIDENCE_PATHS = 100;
+var RUN_RECEIPT_MAX_PATH_CHARS = 1024;
+function canonicalJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function digestReceipt(receipt) {
+  return `sha256:${createHash2("sha256").update(canonicalJson(receipt)).digest("hex")}`;
+}
+function isoOrNull(value, label) {
+  if (value === undefined || value === null || value === "")
+    return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()))
+    throw new Error(`${label} must be a valid ISO date/time`);
+  return date.toISOString();
+}
+function nonEmpty(value, label) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    throw new Error(`${label} must be non-empty`);
+  return trimmed;
+}
+function normalizedStringArray(values, opts) {
+  const out = [];
+  const seen = new Set;
+  for (const raw of values ?? []) {
+    const value = String(raw).trim();
+    if (!value || seen.has(value))
+      continue;
+    seen.add(value);
+    out.push(opts.itemMax ? value.slice(0, opts.itemMax) : value);
+    if (out.length >= opts.max)
+      break;
+  }
+  if ((values?.length ?? 0) > opts.max) {
+    out.push(`[truncated ${values.length - opts.max} ${opts.label}]`);
+  }
+  return out;
+}
+function receiptMachine(input, opts) {
+  if (typeof input.machine === "string")
+    return nonEmpty(input.machine, "machine");
+  if (input.machine && typeof input.machine === "object")
+    return input.machine;
+  if (opts.loop?.machine)
+    return { ...opts.loop.machine };
+  if (typeof opts.defaultMachine === "string")
+    return nonEmpty(opts.defaultMachine, "machine");
+  if (opts.defaultMachine && typeof opts.defaultMachine === "object")
+    return opts.defaultMachine;
+  return hostname();
+}
+function normalizeSummary(input, run) {
+  const stdout = input.stdout ?? run?.stdout;
+  const stderr = input.stderr ?? run?.stderr;
+  const output = summarizeOutput(stdout, stderr);
+  const summaryInput = input.summary;
+  const provided = typeof summaryInput === "object" && summaryInput !== null ? summaryInput : {};
+  const text = typeof summaryInput === "string" ? boundedExcerpt(summaryInput, Math.floor(RUN_RECEIPT_SUMMARY_TEXT_CHARS / 2)) : typeof provided.text === "string" ? boundedExcerpt(provided.text, Math.floor(RUN_RECEIPT_SUMMARY_TEXT_CHARS / 2)) : undefined;
+  return {
+    text,
+    stdout_bytes: Number.isFinite(provided.stdout_bytes) ? Number(provided.stdout_bytes) : output.stdoutBytes,
+    stderr_bytes: Number.isFinite(provided.stderr_bytes) ? Number(provided.stderr_bytes) : output.stderrBytes,
+    stdout_excerpt: typeof provided.stdout_excerpt === "string" ? boundedExcerpt(provided.stdout_excerpt) : output.stdoutExcerpt,
+    stderr_excerpt: typeof provided.stderr_excerpt === "string" ? boundedExcerpt(provided.stderr_excerpt) : output.stderrExcerpt,
+    error: typeof provided.error === "string" ? boundedExcerpt(provided.error) : boundedExcerpt(input.error ?? run?.error),
+    duration_ms: Number.isFinite(provided.duration_ms) ? Number(provided.duration_ms) : input.duration_ms ?? run?.durationMs
+  };
+}
+function normalizeRunReceipt(input, opts = {}) {
+  const now = (opts.now ?? new Date).toISOString();
+  const run = opts.run;
+  const loopId = input.loop_id ?? run?.loopId ?? opts.loop?.id;
+  const normalized = {
+    loop_id: nonEmpty(loopId, "loop_id"),
+    run_id: nonEmpty(input.run_id ?? run?.id, "run_id"),
+    machine: receiptMachine(input, opts),
+    repo: nonEmpty(input.repo ?? opts.defaultRepo ?? targetRepo(opts.loop) ?? process.cwd(), "repo"),
+    task_ids: normalizedStringArray(input.task_ids, { max: RUN_RECEIPT_MAX_IDS, label: "task_ids" }),
+    knowledge_ids: normalizedStringArray(input.knowledge_ids, { max: RUN_RECEIPT_MAX_IDS, label: "knowledge_ids" }),
+    started_at: isoOrNull(input.started_at ?? run?.startedAt, "started_at"),
+    finished_at: isoOrNull(input.finished_at ?? run?.finishedAt, "finished_at"),
+    status: nonEmpty(input.status ?? run?.status, "status"),
+    exit_code: input.exit_code === undefined ? run?.exitCode ?? null : input.exit_code,
+    summary: normalizeSummary(input, run),
+    evidence_paths: normalizedStringArray(input.evidence_paths, {
+      max: RUN_RECEIPT_MAX_EVIDENCE_PATHS,
+      label: "evidence_paths",
+      itemMax: RUN_RECEIPT_MAX_PATH_CHARS
+    })
+  };
+  return {
+    ...normalized,
+    digest_id: input.digest_id?.trim() || digestReceipt(normalized),
+    created_at: opts.existing?.created_at ?? now,
+    updated_at: now
+  };
+}
+function targetRepo(loop) {
+  if (!loop)
+    return;
+  if (loop.target.type === "command")
+    return loop.target.cwd;
+  if (loop.target.type === "agent")
+    return loop.target.cwd;
+  return;
+}
+
+// src/lib/route/todos-cli.ts
+import { closeSync, mkdtempSync, openSync, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { join as join3 } from "path";
+import { homedir as homedir2, tmpdir } from "os";
+
+// src/lib/format.ts
+var TEXT_OUTPUT_LIMIT = 32 * 1024;
+var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
+function redact(value, visible = 0) {
+  if (!value)
+    return value;
+  if (value.length <= visible)
+    return value;
+  if (visible <= 0)
+    return `[redacted ${value.length} chars]`;
+  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
+}
+function truncateTextOutput(value) {
+  if (value.length <= TEXT_OUTPUT_LIMIT)
+    return value;
+  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
+[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
+}
+function redactSensitivePayload(value, key) {
+  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
+    if (typeof value === "string")
+      return redact(value);
+    if (value === undefined || value === null)
+      return value;
+    return "[redacted]";
+  }
+  if (Array.isArray(value))
+    return value.map((item) => redactSensitivePayload(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
+  }
+  return value;
+}
+function textOutputBlocks(value, opts = {}) {
+  const indent = opts.indent ?? "";
+  const nested = `${indent}  `;
+  const blocks = [];
+  for (const [label, output] of [
+    ["stdout", value.stdout],
+    ["stderr", value.stderr]
+  ]) {
+    if (!output)
+      continue;
+    blocks.push(`${indent}${label}:`);
+    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
+      blocks.push(`${nested}${line}`);
+    }
+  }
+  return blocks;
+}
+function publicLoop(loop) {
+  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
+  return {
+    ...loop,
+    target
+  };
+}
+function publicRun(run, showOutput = false, opts = {}) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: opts.redactError ? redact(run.error) : run.error
+  };
+}
+function publicRunReceipt(receipt) {
+  return { ...receipt };
+}
+function publicExecutorResult(result, showOutput = false) {
+  return {
+    ...result,
+    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
+    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
+    error: redact(result.error)
+  };
+}
+function publicWorkflow(workflow) {
+  return {
+    ...workflow,
+    steps: workflow.steps.map((step) => ({
+      ...step,
+      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
+    }))
+  };
+}
+function publicWorkflowRun(run) {
+  return { ...run, error: redact(run.error) };
+}
+function publicWorkflowInvocation(invocation) {
+  return redactSensitivePayload(invocation);
+}
+function publicWorkflowWorkItem(item) {
+  return { ...item, lastReason: redact(item.lastReason, 240) };
+}
+function publicWorkflowStepRun(run, showOutput = false) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: redact(run.error)
+  };
+}
+function publicWorkflowEvent(event) {
+  return { ...event, payload: redactSensitivePayload(event.payload) };
+}
+function publicGoal(goal) {
+  return {
+    ...goal,
+    objective: redact(goal.objective, 120)
+  };
+}
+function publicGoalRun(run) {
+  return {
+    ...run,
+    evidence: redactSensitivePayload(run.evidence),
+    rawResponse: redactSensitivePayload(run.rawResponse)
+  };
+}
+
+// src/lib/route/todos-cli.ts
+function defaultLoopsProject() {
+  return process.env.LOOPS_TASK_PROJECT || process.env.LOOPS_DATA_DIR || `${process.env.HOME || homedir2()}/.hasna/loops`;
+}
+function runLocalCommand(command, args, opts = {}) {
+  const result = spawnSync2(command, args, {
+    input: opts.input,
+    encoding: "utf8",
+    timeout: opts.timeoutMs ?? 30000,
+    maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+    env: process.env
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error ? String(result.error.message || result.error) : ""
+  };
+}
+function runLocalCommandWithStdoutFile(command, args, opts = {}) {
+  const tempDir = mkdtempSync(join3(tmpdir(), "loops-command-output-"));
+  const stdoutPath = join3(tempDir, "stdout");
+  const stdoutFd = openSync(stdoutPath, "w");
+  let result;
+  try {
+    result = spawnSync2(command, args, {
+      input: opts.input,
+      encoding: "utf8",
+      timeout: opts.timeoutMs ?? 30000,
+      maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+      env: process.env,
+      stdio: ["pipe", stdoutFd, "pipe"]
+    });
+  } finally {
+    closeSync(stdoutFd);
+  }
+  try {
+    return {
+      ok: result.status === 0,
+      status: result.status,
+      stdout: readFileSync3(stdoutPath, "utf8"),
+      stderr: typeof result.stderr === "string" ? result.stderr : result.stderr?.toString() || "",
+      error: result.error ? String(result.error.message || result.error) : ""
+    };
+  } finally {
+    rmSync2(tempDir, { recursive: true, force: true });
+  }
+}
+function ensureTodosTaskList(project, slug, name, description) {
+  runLocalCommand("todos", ["--project", project, "task-lists", "--add", name, "--slug", slug, "-d", description]);
+  const list = runLocalCommand("todos", ["--project", project, "--json", "task-lists"]);
+  if (!list.ok)
+    throw new Error(list.stderr || list.error || "failed to list todos task lists");
+  const values = JSON.parse(list.stdout || "[]");
+  const found = values.find((entry) => entry.slug === slug);
+  if (!found)
+    throw new Error(`todos task list not found after ensure: ${slug}`);
+  return found.id;
+}
+function todosMutationSummary(result) {
+  return {
+    ok: result.ok,
+    status: result.status,
+    error: result.ok ? undefined : redact(result.stderr || result.error || "todos mutation failed", 320)
+  };
+}
+
 // src/lib/store.ts
 var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
 var LIVE_EXPIRED_RUN_GRACE_MS = 60000;
-var SCHEMA_USER_VERSION = 7;
+var SCHEMA_USER_VERSION = 8;
 var TERMINAL_RUN_STATUSES = ["succeeded", "failed", "timed_out", "abandoned", "skipped"];
 var PRUNE_BATCH_SIZE = 400;
 var GENERATED_ROUTE_TEMPLATE_IDS = new Set(["todos-task-worker-verifier", "task-lifecycle", "event-worker-verifier"]);
 var GENERATED_ROUTE_KEYS = new Set(["todos-task", "generic-event"]);
+var TASK_LIFECYCLE_TEMPLATE_ID = "task-lifecycle";
 function rowToLoop(row) {
   return {
     id: row.id,
@@ -1263,6 +1626,28 @@ function rowToRun(row) {
     updatedAt: row.updated_at
   };
 }
+function rowToRunReceipt(row) {
+  return {
+    loop_id: row.loop_id,
+    run_id: row.run_id,
+    machine: JSON.parse(row.machine_json),
+    repo: row.repo,
+    task_ids: JSON.parse(row.task_ids_json),
+    knowledge_ids: JSON.parse(row.knowledge_ids_json),
+    digest_id: row.digest_id,
+    started_at: row.started_at,
+    finished_at: row.finished_at,
+    status: row.status,
+    exit_code: row.exit_code,
+    summary: JSON.parse(row.summary_json),
+    evidence_paths: JSON.parse(row.evidence_paths_json),
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function latestRunTime(row) {
+  return row.finished_at ?? row.started_at ?? row.created_at;
+}
 function rowToWorkflow(row) {
   return {
     id: row.id,
@@ -1323,6 +1708,7 @@ function rowToWorkflowWorkItem(row) {
     subjectRef: row.subject_ref,
     projectKey: row.project_key ?? undefined,
     projectGroup: row.project_group ?? undefined,
+    machineId: row.machine_id ?? undefined,
     routeScope: row.route_scope ?? undefined,
     priority: row.priority,
     status: row.status,
@@ -1480,6 +1866,7 @@ function scrubbedOrNull(value) {
   return value == null ? null : scrubSecrets(value);
 }
 var MAX_PERSISTED_RUN_OUTPUT_CHARS = 64 * 1024;
+var MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS = 64 * 1024;
 function clampPersistedRunOutput(value) {
   if (value == null || value.length <= MAX_PERSISTED_RUN_OUTPUT_CHARS)
     return value;
@@ -1494,6 +1881,42 @@ ${tail}`;
 function persistedRunOutput(value) {
   return clampPersistedRunOutput(scrubbedOrNull(value));
 }
+function clampTextToChars(value, maxChars, reason) {
+  if (value.length <= maxChars)
+    return value;
+  const marker = `
+...[truncated by ${reason}]...
+`;
+  const budget = Math.max(0, maxChars - marker.length);
+  const headLength = Math.ceil(budget / 2);
+  const tailLength = Math.floor(budget / 2);
+  return `${value.slice(0, headLength)}${marker}${value.slice(value.length - tailLength)}`;
+}
+function boundedWorkflowEventPayloadJson(scrubbedJson) {
+  if (scrubbedJson.length <= MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS)
+    return scrubbedJson;
+  const base = {
+    truncated: true,
+    originalChars: scrubbedJson.length,
+    maxChars: MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS,
+    preview: ""
+  };
+  const baseChars = JSON.stringify(base).length;
+  let previewBudget = Math.max(0, MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS - baseChars - 64);
+  while (true) {
+    const preview = clampTextToChars(scrubbedJson, previewBudget, "loops workflow-event payload retention");
+    const bounded = JSON.stringify({ ...base, preview });
+    if (bounded.length <= MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS || previewBudget === 0)
+      return bounded;
+    previewBudget = Math.max(0, previewBudget - (bounded.length - MAX_PERSISTED_WORKFLOW_EVENT_PAYLOAD_CHARS) - 64);
+  }
+}
+function persistedWorkflowEventPayload(payload) {
+  if (payload == null)
+    return null;
+  const scrubbed = scrubSecretsDeep(payload);
+  return boundedWorkflowEventPayloadJson(scrubSecrets(JSON.stringify(scrubbed)));
+}
 function chmodIfExists(path, mode) {
   try {
     if (existsSync(path))
@@ -1517,7 +1940,7 @@ class Store {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
-    this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    this.rootDir = file === ":memory:" ? mkdtempSync2(join4(tmpdir2(), "open-loops-store-")) : dirname2(file);
     if (file === ":memory:")
       this.memoryRootDir = this.rootDir;
     this.db = new Database(file);
@@ -1611,6 +2034,17 @@ class Store {
           this.addColumnIfMissing("workflow_work_items", "route_scope", "TEXT");
           this.db.exec("CREATE INDEX IF NOT EXISTS idx_workflow_work_items_scope ON workflow_work_items(route_scope, status)");
         }
+      },
+      {
+        id: "0009_run_receipts",
+        apply: () => this.createRunReceiptsSchema()
+      },
+      {
+        id: "0010_work_item_machine_id",
+        apply: () => {
+          this.addColumnIfMissing("workflow_work_items", "machine_id", "TEXT");
+          this.db.exec("CREATE INDEX IF NOT EXISTS idx_workflow_work_items_machine ON workflow_work_items(machine_id, status)");
+        }
       }
     ];
   }
@@ -1672,6 +2106,28 @@ class Store {
       CREATE INDEX IF NOT EXISTS idx_runs_status_lease ON loop_runs(status, lease_expires_at);
       CREATE INDEX IF NOT EXISTS idx_runs_scheduled ON loop_runs(scheduled_for);
 
+      CREATE TABLE IF NOT EXISTS run_receipts (
+        run_id TEXT PRIMARY KEY,
+        loop_id TEXT NOT NULL,
+        machine_json TEXT NOT NULL,
+        repo TEXT NOT NULL,
+        task_ids_json TEXT NOT NULL,
+        knowledge_ids_json TEXT NOT NULL,
+        digest_id TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        status TEXT NOT NULL,
+        exit_code INTEGER,
+        summary_json TEXT NOT NULL,
+        evidence_paths_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_loop ON run_receipts(loop_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_repo ON run_receipts(repo, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_digest ON run_receipts(digest_id);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_status ON run_receipts(status, created_at DESC);
+
       CREATE TABLE IF NOT EXISTS daemon_lease (
         id TEXT PRIMARY KEY,
         pid INTEGER NOT NULL,
@@ -1758,6 +2214,7 @@ class Store {
         subject_ref TEXT NOT NULL,
         project_key TEXT,
         project_group TEXT,
+        machine_id TEXT,
         route_scope TEXT,
         priority INTEGER NOT NULL,
         status TEXT NOT NULL,
@@ -1776,10 +2233,10 @@ class Store {
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_project ON workflow_work_items(project_key, status);
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_group ON workflow_work_items(project_group, status);
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_invocation ON workflow_work_items(invocation_id);
-      -- idx_workflow_work_items_scope (route_scope, status) is created ONLY by
-      -- migration 0008_work_item_route_scope, never here: this baseline DDL
+      -- New-column indexes (route_scope, machine_id, etc.) are created ONLY by
+      -- their additive migrations, never here: this baseline DDL
       -- re-runs on EVERY open (0001 is not skip-guarded), and on a pre-0008
-      -- database the CREATE TABLE above is a no-op, so an index on route_scope
+      -- database the CREATE TABLE above is a no-op, so an index on a new column
       -- here would execute before the column exists and crash the open
       -- ("no such column: route_scope"). New columns may be folded into the
       -- CREATE TABLE (fresh-db only); their indexes must live in the migration.
@@ -1890,6 +2347,31 @@ class Store {
       CREATE INDEX IF NOT EXISTS idx_goal_runs_workflow_run ON goal_runs(workflow_run_id);
     `);
   }
+  createRunReceiptsSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS run_receipts (
+        run_id TEXT PRIMARY KEY,
+        loop_id TEXT NOT NULL,
+        machine_json TEXT NOT NULL,
+        repo TEXT NOT NULL,
+        task_ids_json TEXT NOT NULL,
+        knowledge_ids_json TEXT NOT NULL,
+        digest_id TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        status TEXT NOT NULL,
+        exit_code INTEGER,
+        summary_json TEXT NOT NULL,
+        evidence_paths_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_loop ON run_receipts(loop_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_repo ON run_receipts(repo, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_digest ON run_receipts(digest_id);
+      CREATE INDEX IF NOT EXISTS idx_run_receipts_status ON run_receipts(status, created_at DESC);
+    `);
+  }
   addColumnIfMissing(table, column, definition) {
     const columns = this.db.query(`PRAGMA table_info(${table})`).all();
     if (columns.some((c) => c.name === column))
@@ -2001,21 +2483,51 @@ class Store {
   }
   listLoops(opts = {}) {
     const limit = opts.limit ?? 200;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
+    if (opts.name != null) {
+      const rows2 = this.db.query("SELECT * FROM loops WHERE name = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.name, limit, offset);
+      return this.withLatestRunSummaries(rows2.map(rowToLoop));
+    }
     let rows;
     if (opts.status && opts.archived) {
-      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else if (opts.status && opts.includeArchived) {
-      rows = this.db.query("SELECT * FROM loops WHERE status = ? ORDER BY next_run_at ASC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loops WHERE status = ? ORDER BY next_run_at ASC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else if (opts.status) {
-      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loops WHERE status = ? AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else if (opts.archived) {
-      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT ?").all(limit);
+      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT ? OFFSET ?").all(limit, offset);
     } else if (opts.includeArchived) {
-      rows = this.db.query("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
+      rows = this.db.query("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT ? OFFSET ?").all(limit, offset);
     } else {
-      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
-    }
-    return rows.map(rowToLoop);
+      rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ? OFFSET ?").all(limit, offset);
+    }
+    return this.withLatestRunSummaries(rows.map(rowToLoop));
+  }
+  withLatestRunSummaries(loops) {
+    if (loops.length === 0)
+      return loops;
+    const placeholders = loops.map(() => "?").join(",");
+    const rows = this.db.query(`SELECT loop_id, id, status, started_at, finished_at, created_at
+         FROM (
+           SELECT loop_id, id, status, started_at, finished_at, created_at,
+             ROW_NUMBER() OVER (PARTITION BY loop_id ORDER BY created_at DESC, id DESC) AS rn
+           FROM loop_runs
+           WHERE loop_id IN (${placeholders})
+         )
+         WHERE rn = 1`).all(...loops.map((loop) => loop.id));
+    const latestByLoopId = new Map(rows.map((row) => [row.loop_id, row]));
+    return loops.map((loop) => {
+      const latest = latestByLoopId.get(loop.id);
+      if (!latest)
+        return loop;
+      return {
+        ...loop,
+        latestRunId: latest.id,
+        latestRunStatus: latest.status,
+        lastRunAt: latestRunTime(latest)
+      };
+    });
   }
   dueLoops(now, limit = 500) {
     const rows = this.db.query(`SELECT * FROM loops
@@ -2134,6 +2646,45 @@ class Store {
       throw error;
     }
   }
+  updateAgentLoopTimeout(idOrName, timeoutMs, opts = {}) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireUniqueLoop(idOrName);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || current.id);
+      if (current.target.type !== "agent")
+        throw new Error(`loop is not an agent loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to update running loop: ${current.id}`);
+      const target = { ...current.target, timeoutMs };
+      if (timeoutMs === null && target.idleTimeoutMs !== undefined)
+        delete target.idleTimeoutMs;
+      const res = this.db.query(`UPDATE loops SET target_json=$target, updated_at=$updated
+           WHERE id=$id
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $id: current.id,
+        $target: JSON.stringify(target),
+        $updated: updated,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: updated
+      });
+      if (res.changes !== 1)
+        throw new Error("daemon lease lost");
+      this.db.exec("COMMIT");
+      const after = this.getLoop(current.id);
+      if (!after)
+        throw new Error(`loop not found after timeout update: ${current.id}`);
+      return after;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
   createAndRetargetWorkflowLoop(idOrName, workflowInput, opts = {}) {
     const normalized = normalizeCreateWorkflowInput(workflowInput);
     const updated = (opts.now ?? new Date).toISOString();
@@ -2464,6 +3015,59 @@ class Store {
       updated
     });
   }
+  taskLifecycleTodosPointerContext(workflowRunId) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run || run.status !== "succeeded" || !run.invocationId || !run.workItemId || !run.manifestPath)
+      return;
+    const workItem = this.getWorkflowWorkItem(run.workItemId);
+    if (!workItem || workItem.routeKey !== "todos-task")
+      return;
+    const invocation = this.getWorkflowInvocation(run.invocationId);
+    if (!invocation || invocation.templateId !== TASK_LIFECYCLE_TEMPLATE_ID)
+      return;
+    const projectPath = workItem.projectKey ?? invocation.scope?.projectPath;
+    const taskId = invocation.subjectRef.id ?? workItem.subjectRef;
+    if (!projectPath || !taskId)
+      return;
+    return {
+      projectPath,
+      taskId,
+      invocationId: invocation.id,
+      workflowRunId: run.id,
+      manifestPath: run.manifestPath
+    };
+  }
+  syncSuccessfulTaskLifecycleTodosPointers(workflowRunId) {
+    const context = this.taskLifecycleTodosPointerContext(workflowRunId);
+    if (!context)
+      return;
+    const result = runLocalCommand("todos", [
+      "--project",
+      context.projectPath,
+      "task",
+      "workflow-pointers",
+      context.taskId,
+      "--clear",
+      "--invocation",
+      context.invocationId,
+      "--run",
+      context.workflowRunId,
+      "--manifest",
+      context.manifestPath,
+      "--state",
+      "succeeded",
+      "--actor",
+      "openloops:task-lifecycle"
+    ]);
+    this.appendWorkflowEvent(workflowRunId, result.ok ? "todos_workflow_pointers_synced" : "todos_workflow_pointers_sync_failed", undefined, {
+      projectPath: context.projectPath,
+      taskId: context.taskId,
+      invocationId: context.invocationId,
+      workflowRunId: context.workflowRunId,
+      manifestPath: context.manifestPath,
+      mutation: todosMutationSummary(result)
+    });
+  }
   createWorkflowInvocation(input) {
     const now = nowIso();
     const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
@@ -2574,10 +3178,10 @@ class Store {
     const id = genId();
     const status = input.status ?? "queued";
     this.db.query(`INSERT INTO workflow_work_items (id, route_key, idempotency_key, invocation_id, source_type, source_ref,
-          subject_ref, project_key, project_group, route_scope, priority, status, attempts, next_attempt_at, lease_expires_at,
+          subject_ref, project_key, project_group, machine_id, route_scope, priority, status, attempts, next_attempt_at, lease_expires_at,
           workflow_id, loop_id, workflow_run_id, last_reason, created_at, updated_at)
          VALUES ($id, $routeKey, $idempotencyKey, $invocationId, $sourceType, $sourceRef, $subjectRef,
-          $projectKey, $projectGroup, $routeScope, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
+          $projectKey, $projectGroup, $machineId, $routeScope, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
           $lastReason, $created, $updated)
          ON CONFLICT(route_key, idempotency_key) DO UPDATE SET
           invocation_id=excluded.invocation_id,
@@ -2586,6 +3190,10 @@ class Store {
           subject_ref=excluded.subject_ref,
           project_key=excluded.project_key,
           project_group=excluded.project_group,
+          machine_id=CASE
+            WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled') THEN workflow_work_items.machine_id
+            ELSE excluded.machine_id
+          END,
           route_scope=excluded.route_scope,
           priority=excluded.priority,
           status=CASE
@@ -2628,6 +3236,7 @@ class Store {
       $subjectRef: input.subjectRef,
       $projectKey: input.projectKey ?? null,
       $projectGroup: input.projectGroup ?? null,
+      $machineId: input.machineId ?? null,
       $routeScope: input.routeScope ?? null,
       $priority: input.priority ?? 0,
       $status: status,
@@ -3137,7 +3746,7 @@ class Store {
            VALUES ($id, $workflowRunId, 1, 'created', NULL, $payload, $created)`).run({
         $id: genId(),
         $workflowRunId: runId,
-        $payload: JSON.stringify({
+        $payload: persistedWorkflowEventPayload({
           workflowId: input.workflow.id,
           workflowName: input.workflow.name,
           stepCount: input.workflow.steps.length,
@@ -3426,6 +4035,8 @@ class Store {
     const run = this.getWorkflowRun(workflowRunId);
     if (!run)
       throw new Error(`workflow run not found after finalize: ${workflowRunId}`);
+    if (changed && status === "succeeded")
+      this.syncSuccessfulTaskLifecycleTodosPointers(workflowRunId);
     return run;
   }
   cancelWorkflowRun(workflowRunId, reason = "cancelled by user") {
@@ -3466,7 +4077,7 @@ class Store {
         $sequence: sequence,
         $eventType: eventType,
         $stepId: stepId ?? null,
-        $payload: payload ? JSON.stringify(payload) : null,
+        $payload: persistedWorkflowEventPayload(payload),
         $created: now
       });
       const event = this.db.query("SELECT * FROM workflow_events WHERE id = ?").get(id);
@@ -3487,6 +4098,17 @@ class Store {
     const row = this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE loop_id = ? AND scheduled_for = ? AND status = 'running'").get(loopId, scheduledFor);
     return (row?.count ?? 0) > 0;
   }
+  hasBlockingRunningRunForOtherSlot(loopId, scheduledFor, nowIso2) {
+    const rows = this.db.query(`SELECT * FROM loop_runs
+         WHERE loop_id = ? AND scheduled_for <> ? AND status = 'running'`).all(loopId, scheduledFor);
+    return rows.some((row) => {
+      if (!row.lease_expires_at || row.lease_expires_at > nowIso2)
+        return true;
+      if (isRecordedProcessAlive(row.pid, row.process_started_at))
+        return true;
+      return this.hasLiveWorkflowStepProcesses(row.id);
+    });
+  }
   markRunPid(id, pid, claimedBy, opts = {}) {
     const now = (opts.now ?? new Date).toISOString();
     const startedMs = processStartTimeMs(pid);
@@ -3619,6 +4241,10 @@ class Store {
       loop = currentLoop;
       const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
       const existing = this.getRunBySlot(loop.id, scheduledFor);
+      if (loop.overlap === "skip" && this.hasBlockingRunningRunForOtherSlot(loop.id, scheduledFor, startedAt)) {
+        this.db.exec("COMMIT");
+        return;
+      }
       if (existing) {
         if (existing.status === "running") {
           if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && isRecordedProcessAlive(existing.pid, existing.processStartedAt)) {
@@ -3774,18 +4400,93 @@ class Store {
   }
   listRuns(opts = {}) {
     const limit = opts.limit ?? 100;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
     let rows;
     if (opts.loopId && opts.status) {
-      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? AND status = ? ORDER BY created_at DESC LIMIT ?").all(opts.loopId, opts.status, limit);
+      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? AND status = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.loopId, opts.status, limit, offset);
     } else if (opts.loopId) {
-      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? ORDER BY created_at DESC LIMIT ?").all(opts.loopId, limit);
+      rows = this.db.query("SELECT * FROM loop_runs WHERE loop_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.loopId, limit, offset);
     } else if (opts.status) {
-      rows = this.db.query("SELECT * FROM loop_runs WHERE status = ? ORDER BY created_at DESC LIMIT ?").all(opts.status, limit);
+      rows = this.db.query("SELECT * FROM loop_runs WHERE status = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.status, limit, offset);
     } else {
-      rows = this.db.query("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT ?").all(limit);
+      rows = this.db.query("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
     }
     return rows.map(rowToRun);
   }
+  writeRunReceipt(input, opts = {}) {
+    const inputRunId = typeof input.run_id === "string" && input.run_id.trim() ? input.run_id : undefined;
+    const existing = inputRunId ? this.getRunReceipt(inputRunId) : undefined;
+    const run = inputRunId ? this.getRun(inputRunId) : undefined;
+    const loop = input.loop_id ? this.getLoop(input.loop_id) : run ? this.getLoop(run.loopId) : undefined;
+    const receipt = normalizeRunReceipt(input, { now: opts.now, run, loop, existing });
+    this.db.query(`INSERT INTO run_receipts (run_id, loop_id, machine_json, repo, task_ids_json, knowledge_ids_json, digest_id,
+          started_at, finished_at, status, exit_code, summary_json, evidence_paths_json, created_at, updated_at)
+         VALUES ($runId, $loopId, $machineJson, $repo, $taskIdsJson, $knowledgeIdsJson, $digestId,
+          $startedAt, $finishedAt, $status, $exitCode, $summaryJson, $evidencePathsJson, $createdAt, $updatedAt)
+         ON CONFLICT(run_id) DO UPDATE SET
+          loop_id=excluded.loop_id,
+          machine_json=excluded.machine_json,
+          repo=excluded.repo,
+          task_ids_json=excluded.task_ids_json,
+          knowledge_ids_json=excluded.knowledge_ids_json,
+          digest_id=excluded.digest_id,
+          started_at=excluded.started_at,
+          finished_at=excluded.finished_at,
+          status=excluded.status,
+          exit_code=excluded.exit_code,
+          summary_json=excluded.summary_json,
+          evidence_paths_json=excluded.evidence_paths_json,
+          updated_at=excluded.updated_at`).run({
+      $runId: receipt.run_id,
+      $loopId: receipt.loop_id,
+      $machineJson: JSON.stringify(receipt.machine),
+      $repo: receipt.repo,
+      $taskIdsJson: JSON.stringify(receipt.task_ids),
+      $knowledgeIdsJson: JSON.stringify(receipt.knowledge_ids),
+      $digestId: receipt.digest_id,
+      $startedAt: receipt.started_at,
+      $finishedAt: receipt.finished_at,
+      $status: receipt.status,
+      $exitCode: receipt.exit_code,
+      $summaryJson: JSON.stringify(receipt.summary),
+      $evidencePathsJson: JSON.stringify(receipt.evidence_paths),
+      $createdAt: receipt.created_at,
+      $updatedAt: receipt.updated_at
+    });
+    return this.getRunReceipt(receipt.run_id) ?? receipt;
+  }
+  getRunReceipt(runId) {
+    const row = this.db.query("SELECT * FROM run_receipts WHERE run_id = ?").get(runId);
+    return row ? rowToRunReceipt(row) : undefined;
+  }
+  listRunReceipts(opts = {}) {
+    const limit = opts.limit ?? 100;
+    const filters = [];
+    const params = [];
+    if (opts.loopId) {
+      filters.push("loop_id = ?");
+      params.push(opts.loopId);
+    }
+    if (opts.repo) {
+      filters.push("repo = ?");
+      params.push(opts.repo);
+    }
+    if (opts.status) {
+      filters.push("status = ?");
+      params.push(opts.status);
+    }
+    if (opts.taskId) {
+      filters.push("EXISTS (SELECT 1 FROM json_each(run_receipts.task_ids_json) WHERE value = ?)");
+      params.push(opts.taskId);
+    }
+    if (opts.knowledgeId) {
+      filters.push("EXISTS (SELECT 1 FROM json_each(run_receipts.knowledge_ids_json) WHERE value = ?)");
+      params.push(opts.knowledgeId);
+    }
+    const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+    const rows = this.db.query(`SELECT * FROM run_receipts ${where} ORDER BY created_at DESC LIMIT ?`).all(...params, limit);
+    return rows.map(rowToRunReceipt);
+  }
   deferLiveExpiredRun(id, now, opts = {}) {
     const updated = now.toISOString();
     const deferredUntil = new Date(now.getTime() + LIVE_EXPIRED_RUN_GRACE_MS).toISOString();
@@ -3944,6 +4645,9 @@ class Store {
     const runs = includeRuns ? this.db.query("SELECT * FROM loop_runs ORDER BY created_at ASC, id ASC").all().map(rowToRun) : [];
     return { schemaVersion: SCHEMA_USER_VERSION, workflows, loops, runs, checks: this.migrationChecks() };
   }
+  exportMigrationRunPage(opts) {
+    return this.db.query("SELECT * FROM loop_runs ORDER BY created_at ASC, id ASC LIMIT ? OFFSET ?").all(opts.limit, opts.offset).map(rowToRun);
+  }
   countTable(table) {
     const row = this.db.query(`SELECT COUNT(*) AS count FROM ${table}`).get();
     return row?.count ?? 0;
@@ -4190,9 +4894,9 @@ class Store {
       const runDir = dirname2(manifestPath);
       try {
         if (/^[0-9a-f]{12,64}$/.test(basename2(runDir))) {
-          rmSync2(runDir, { recursive: true, force: true });
+          rmSync3(runDir, { recursive: true, force: true });
         } else {
-          rmSync2(manifestPath, { force: true });
+          rmSync3(manifestPath, { force: true });
         }
       } catch {}
     }
@@ -4259,7 +4963,7 @@ class Store {
     this.db.close();
     if (this.memoryRootDir) {
       try {
-        rmSync2(this.memoryRootDir, { recursive: true, force: true });
+        rmSync3(this.memoryRootDir, { recursive: true, force: true });
       } catch {}
       this.memoryRootDir = undefined;
     }
@@ -4268,7 +4972,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.13",
+  version: "0.4.22",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4277,6 +4981,7 @@ var package_default = {
     loops: "dist/cli/index.js",
     "loops-daemon": "dist/daemon/index.js",
     "loops-api": "dist/api/index.js",
+    "loops-serve": "dist/serve/index.js",
     "loops-runner": "dist/runner/index.js",
     "loops-mcp": "dist/mcp/index.js"
   },
@@ -4289,6 +4994,14 @@ var package_default = {
       types: "./dist/sdk/index.d.ts",
       import: "./dist/sdk/index.js"
     },
+    "./sdk/http": {
+      types: "./dist/sdk/http.d.ts",
+      import: "./dist/sdk/http.js"
+    },
+    "./serve": {
+      types: "./dist/serve/index.d.ts",
+      import: "./dist/serve/index.js"
+    },
     "./mcp": {
       types: "./dist/mcp/index.d.ts",
       import: "./dist/mcp/index.js"
@@ -4334,7 +5047,7 @@ var package_default = {
     "LICENSE"
   ],
   scripts: {
-    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/api/index.ts src/runner/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/lib/store.ts src/lib/mode.ts src/lib/storage/index.ts src/lib/storage/contract.ts src/lib/storage/sqlite.ts src/lib/storage/postgres.ts src/lib/storage/postgres-schema.ts --root src --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js dist/api/index.js dist/runner/index.js dist/mcp/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
+    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/api/index.ts src/serve/index.ts src/runner/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/sdk/http.ts src/lib/store.ts src/lib/mode.ts src/lib/storage/index.ts src/lib/storage/contract.ts src/lib/storage/sqlite.ts src/lib/storage/postgres.ts src/lib/storage/postgres-schema.ts --root src --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js dist/api/index.js dist/serve/index.js dist/runner/index.js dist/mcp/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
     "build:bin": "bun build src/cli/index.ts --compile --outfile dist/loops",
     typecheck: "tsc --noEmit",
     test: "bun test",
@@ -4374,13 +5087,16 @@ var package_default = {
     "@openrouter/ai-sdk-provider": "2.9.1",
     ai: "6.0.204",
     commander: "^13.1.0",
+    pg: "^8.13.1",
     zod: "4.4.3"
   },
   optionalDependencies: {
-    "@hasna/machines": "0.0.49"
+    "@hasna/machines": "0.0.49",
+    "@hasna/contracts": "^0.4.2"
   },
   devDependencies: {
     "@types/bun": "latest",
+    "@types/pg": "^8.11.10",
     typescript: "^5.7.3"
   },
   publishConfig: {
@@ -4591,13 +5307,109 @@ function deploymentStatusLine(status) {
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/http.ts
+import { createServer } from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var MCP_HTTP_SERVICE_NAME = "loops";
+var DEFAULT_MCP_HTTP_PORT = 8890;
+function isStdioMode(argv = process.argv, env = process.env) {
+  return argv.includes("--stdio") || env.MCP_STDIO === "1";
+}
+function resolveMcpHttpPort(argv = process.argv, env = process.env) {
+  const portIdx = argv.indexOf("--port");
+  if (portIdx !== -1 && argv[portIdx + 1]) {
+    return parsePort(argv[portIdx + 1], "--port");
+  }
+  if (env.MCP_HTTP_PORT) {
+    return parsePort(env.MCP_HTTP_PORT, "MCP_HTTP_PORT");
+  }
+  return DEFAULT_MCP_HTTP_PORT;
+}
+function parsePort(raw, source) {
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    throw new Error(`Invalid ${source} value "${raw}". Expected 0-65535.`);
+  }
+  return parsed;
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text)
+    return;
+  return JSON.parse(text);
+}
+async function startMcpHttpServer(buildServer, options) {
+  const host = options?.host ?? "127.0.0.1";
+  const requestedPort = options?.port ?? resolveMcpHttpPort();
+  const serviceName = options?.serviceName ?? MCP_HTTP_SERVICE_NAME;
+  const httpServer = createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+      if (req.method === "GET" && url.pathname === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", name: serviceName }));
+        return;
+      }
+      if (url.pathname !== "/mcp") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+        return;
+      }
+      const server = buildServer();
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined
+      });
+      await server.connect(transport);
+      let parsedBody;
+      if (req.method === "POST") {
+        parsedBody = await readJsonBody(req);
+      }
+      await transport.handleRequest(req, res, parsedBody);
+      res.on("close", () => {
+        transport.close();
+        server.close();
+      });
+    } catch (error) {
+      console.error(`[${serviceName}-mcp] HTTP error:`, error);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null
+        }));
+      }
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(requestedPort, host, () => resolve2());
+  });
+  const addr = httpServer.address();
+  const port = typeof addr === "object" && addr ? addr.port : requestedPort;
+  console.error(`[${serviceName}-mcp] Streamable HTTP listening on http://${host}:${port}/mcp`);
+  return {
+    port,
+    host,
+    close: () => new Promise((resolve2, reject) => {
+      httpServer.close((err) => err ? reject(err) : resolve2());
+    })
+  };
+}
+
+// src/mcp/index.ts
 import { z as z2 } from "zod/v3";
 
 // src/daemon/control.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
-import { spawnSync as spawnSync2 } from "child_process";
-import { hostname } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync as rmSync4, writeFileSync as writeFileSync2 } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { hostname as hostname2 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
 
 // src/daemon/loop.ts
 function realSleep(ms) {
@@ -4627,7 +5439,7 @@ function readPidRecord(path = pidFilePath()) {
     return;
   let raw;
   try {
-    raw = readFileSync3(path, "utf8").trim();
+    raw = readFileSync4(path, "utf8").trim();
   } catch {
     return;
   }
@@ -4653,7 +5465,7 @@ function writePid(pid = process.pid, path = pidFilePath()) {
   writeFileSync2(path, JSON.stringify({ pid, startedAt: processStartTimeMs(pid) }));
 }
 function removePid(path = pidFilePath()) {
-  rmSync3(path, { force: true });
+  rmSync4(path, { force: true });
 }
 function isAlive(pid, startedAt) {
   try {
@@ -4683,7 +5495,7 @@ function ownProcessGroupId() {
       return pgrp;
   }
   try {
-    const run = spawnSync2("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8" });
+    const run = spawnSync3("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8" });
     const pgid = Number(run.stdout.trim());
     if (run.status === 0 && Number.isInteger(pgid) && pgid > 0)
       return pgid;
@@ -4749,7 +5561,7 @@ function daemonStatus(store, path = pidFilePath()) {
   return {
     ...isDaemonRunning(path),
     lease: store.getDaemonLease(),
-    host: hostname(),
+    host: hostname2(),
     loops: {
       total: store.countLoops(),
       active: store.countLoops("active"),
@@ -4779,7 +5591,7 @@ async function stopDaemon(opts = {}) {
   if (!state.running || !state.pid)
     return { wasRunning: false, stopped: false, forced: false };
   const sleep = opts.sleep ?? realSleep;
-  const store = new Store(join4(dirname3(path), "loops.db"));
+  const store = new Store(join5(dirname3(path), "loops.db"));
   try {
     const lease = store.getDaemonLease();
     const leaseVerified = Boolean(lease && lease.pid === state.pid && new Date(lease.expiresAt).getTime() > Date.now());
@@ -4817,18 +5629,18 @@ async function stopDaemon(opts = {}) {
 }
 
 // src/lib/doctor.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 import { accessSync as accessSync2, constants as constants2 } from "fs";
 
 // src/lib/executor.ts
-import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 import { once } from "events";
 import { lstatSync, mkdirSync as mkdirSync5, realpathSync } from "fs";
 import { dirname as dirname4, resolve as resolve2 } from "path";
 
 // src/lib/accounts.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 var EXPORT_RE = /^export\s+([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
 var ACCOUNTS_ENV_TIMEOUT_MS = 30000;
@@ -4933,7 +5745,7 @@ function resolveAccountEnvSync(account, toolHint, env) {
   if (!account)
     return {};
   const tool = requiredAccountTool(account, toolHint);
-  const result = spawnSync3("accounts", ["env", account.profile, "--tool", tool], {
+  const result = spawnSync4("accounts", ["env", account.profile, "--tool", tool], {
     encoding: "utf8",
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -4949,8 +5761,8 @@ function resolveAccountEnvSync(account, toolHint, env) {
 
 // src/lib/env.ts
 import { accessSync, constants } from "fs";
-import { homedir as homedir2 } from "os";
-import { delimiter, join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { delimiter, join as join6 } from "path";
 function compactPathParts(parts) {
   const seen = new Set;
   const result = [];
@@ -4964,16 +5776,16 @@ function compactPathParts(parts) {
   return result;
 }
 function commonExecutableDirs(env = process.env) {
-  const home = env.HOME || homedir2();
+  const home = env.HOME || homedir3();
   return compactPathParts([
-    join5(home, ".local", "bin"),
-    join5(home, ".bun", "bin"),
-    join5(home, ".cargo", "bin"),
-    join5(home, ".npm-global", "bin"),
-    join5(home, "bin"),
-    env.BUN_INSTALL ? join5(env.BUN_INSTALL, "bin") : undefined,
+    join6(home, ".local", "bin"),
+    join6(home, ".bun", "bin"),
+    join6(home, ".cargo", "bin"),
+    join6(home, ".npm-global", "bin"),
+    join6(home, "bin"),
+    env.BUN_INSTALL ? join6(env.BUN_INSTALL, "bin") : undefined,
     env.PNPM_HOME,
-    env.NPM_CONFIG_PREFIX ? join5(env.NPM_CONFIG_PREFIX, "bin") : undefined,
+    env.NPM_CONFIG_PREFIX ? join6(env.NPM_CONFIG_PREFIX, "bin") : undefined,
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -4997,7 +5809,7 @@ function executableExists(command, env = process.env) {
   if (command.includes("/"))
     return isExecutable(command);
   for (const dir of (env.PATH ?? "").split(delimiter)) {
-    if (dir && isExecutable(join5(dir, command)))
+    if (dir && isExecutable(join6(dir, command)))
       return true;
   }
   return false;
@@ -5106,6 +5918,7 @@ var TRANSPORT_ENV_KEYS = new Set([
   "LOGNAME",
   "PATH",
   "SHELL",
+  "SHLVL",
   "SSH_AGENT_PID",
   "SSH_AUTH_SOCK",
   "TERM",
@@ -5138,6 +5951,32 @@ function timeoutResult(startedAt, error, fields = {}) {
 function successResult(startedAt, fields = {}) {
   return buildResult("succeeded", startedAt, fields);
 }
+function codewithJsonlHasTerminalSuccess(stdout) {
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.startsWith("{"))
+      continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!event || typeof event !== "object")
+      continue;
+    const record = event;
+    if (record.type === "task_complete")
+      return true;
+    const payload = record.payload;
+    if (payload && typeof payload === "object" && payload.type === "task_complete") {
+      return true;
+    }
+  }
+  return false;
+}
+function codewithJsonlReconciledSuccess(spec, fields) {
+  return spec.agentProvider === "codewith" && codewithJsonlHasTerminalSuccess(fields.stdout ?? "");
+}
 function notifySpawn(pid, opts) {
   if (!pid)
     return;
@@ -5153,10 +5992,48 @@ function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function codewithProfileCandidateFromLine(line) {
-  const cols = line.trim().split(/\s+/);
-  if (cols[0] === "*")
-    return cols[1];
-  return cols[0];
+  const trimmed = line.trim();
+  if (!trimmed || trimmed === "No auth profiles saved.")
+    return;
+  const cols = trimmed.split(/\s+/);
+  const candidate = cols[0] === "*" ? cols[1] : cols[0];
+  if (candidate === "NAME" && (cols[1] === "ACCOUNT" || cols[2] === "ACCOUNT"))
+    return;
+  if (candidate === '"name":') {
+    const jsonName = trimmed.match(/"name"\s*:\s*"([^"]+)"/)?.[1];
+    if (jsonName)
+      return jsonName;
+  }
+  return candidate;
+}
+function codewithProfileCandidatesFromJson(value) {
+  const candidates = [];
+  const root = value && typeof value === "object" ? value : undefined;
+  const addProfile = (entry) => {
+    if (!entry || typeof entry !== "object")
+      return;
+    const name = entry.name;
+    if (typeof name === "string" && name)
+      candidates.push(name);
+  };
+  const data = root?.data;
+  if (Array.isArray(data))
+    data.forEach(addProfile);
+  const profiles = root?.profiles;
+  if (Array.isArray(profiles))
+    profiles.forEach(addProfile);
+  return candidates;
+}
+function codewithProfileCandidatesFromOutput(output) {
+  const trimmed = output.trim();
+  const jsonStart = trimmed.indexOf("{");
+  const jsonEnd = trimmed.lastIndexOf("}");
+  if (jsonStart >= 0 && jsonEnd >= jsonStart) {
+    try {
+      return codewithProfileCandidatesFromJson(JSON.parse(trimmed.slice(jsonStart, jsonEnd + 1)));
+    } catch {}
+  }
+  return output.split(/\r?\n/).map(codewithProfileCandidateFromLine).filter(Boolean);
 }
 function codewithProfileForError(profile) {
   return /[\u0000-\u001F\u007F]/.test(profile) ? JSON.stringify(profile) ?? profile : profile;
@@ -5249,6 +6126,7 @@ function commandSpec(target, opts) {
     preflightAnyOf: invocation.preflightAnyOf,
     stdin: invocation.stdin,
     allowlist: agentTarget.allowlist,
+    agentProvider: agentTarget.provider,
     worktree: agentTarget.worktree
   };
 }
@@ -5262,6 +6140,7 @@ function composeExecutionEnv(spec, metadata, opts, accountEnv) {
   Object.assign(env, spec.env ?? {});
   Object.assign(env, allowlistEnv(spec.allowlist));
   env.PATH = normalizeExecutionPath(env);
+  env.SHLVL ||= "1";
   Object.assign(env, metadataEnv(metadata));
   return env;
 }
@@ -5333,7 +6212,7 @@ function remoteWorktreePrepareLines(worktree) {
   return [
     "__openloops_prepare_worktree() {",
     `  local repo=${shellQuote(repoRoot)} path=${shellQuote(path)} branch=${shellQuote(branch)}`,
-    "  local top expected_common actual_common current",
+    "  local top expected_common actual_common current status recovered",
     '  if [ -L "$path" ]; then echo "refusing symlinked worktree path $path" >&2; return 1; fi',
     '  if [ -e "$path" ]; then',
     '    top="$(git -C "$path" rev-parse --show-toplevel 2>/dev/null)" || { echo "refusing to reuse non-worktree path: $path" >&2; return 1; }',
@@ -5342,7 +6221,19 @@ function remoteWorktreePrepareLines(worktree) {
     '    actual_common="$(cd "$path" 2>/dev/null && cd "$(git rev-parse --git-common-dir 2>/dev/null)" 2>/dev/null && pwd -P)"',
     '    if [ -z "$expected_common" ] || [ "$expected_common" != "$actual_common" ]; then echo "existing worktree $path belongs to a different git common dir" >&2; return 1; fi',
     '    current="$(git -C "$path" branch --show-current 2>/dev/null)"',
-    '    if [ "$current" != "$branch" ]; then echo "existing worktree $path is on branch ${current:-unknown}, expected $branch" >&2; return 1; fi',
+    '    if [ "$current" != "$branch" ]; then',
+    '      status="$(git -C "$path" status --porcelain=v1 --untracked-files=all 2>/dev/null)" || { echo "existing worktree $path is on branch ${current:-unknown}, expected $branch, and cleanliness could not be checked; inspect or remove the stale worktree" >&2; return 1; }',
+    '      if [ -n "$status" ]; then echo "existing worktree $path is on branch ${current:-unknown}, expected $branch, and has local changes; commit/stash them or remove the stale worktree before retrying" >&2; return 1; fi',
+    '      if git -C "$repo" show-ref --verify --quiet "refs/heads/$branch"; then',
+    '        git -C "$path" checkout "$branch" 1>&2 || { echo "existing worktree $path is clean but could not switch from branch ${current:-unknown} to expected $branch; remove/prune the stale worktree or free the branch before retrying" >&2; return 1; }',
+    '      elif [ -z "$current" ]; then',
+    '        git -C "$path" checkout -b "$branch" 1>&2 || { echo "existing worktree $path is clean but could not recreate expected branch $branch at the current detached HEAD; remove/prune the stale worktree before retrying" >&2; return 1; }',
+    "      else",
+    '        echo "existing worktree $path is on branch $current, expected $branch, but expected branch does not exist; remove/prune the stale worktree or recreate the expected branch before retrying" >&2; return 1',
+    "      fi",
+    '      recovered="$(git -C "$path" branch --show-current 2>/dev/null)"',
+    '      if [ "$recovered" != "$branch" ]; then echo "existing worktree $path branch recovery ended on ${recovered:-unknown}, expected $branch; remove/prune the stale worktree before retrying" >&2; return 1; fi',
+    "    fi",
     "    return 0",
     "  fi",
     '  git -C "$repo" rev-parse --is-inside-work-tree >/dev/null 2>&1 || { echo "worktree repoRoot is not a git repository: $repo" >&2; return 1; }',
@@ -5408,7 +6299,7 @@ function remotePreflightScript(spec, metadata) {
   }
   if (spec.nativeAuthProfile?.provider === "codewith") {
     const profileForError = codewithProfileForError(spec.nativeAuthProfile.profile);
-    lines.push(`__OPENLOOPS_CODEWITH_PROFILE=${shellQuote(spec.nativeAuthProfile.profile)}`, "export __OPENLOOPS_CODEWITH_PROFILE", `__OPENLOOPS_CODEWITH_PROFILES="$(${shellQuote(spec.command)} profile list)" || {`, `  printf '%s\\n' ${shellQuote("codewith auth profile preflight failed")} >&2`, "  exit 1", "}", `if ! printf '%s\\n' "$__OPENLOOPS_CODEWITH_PROFILES" | awk 'NR > 1 { candidate = ($1 == "*" ? $2 : $1); if (candidate == ENVIRON["__OPENLOOPS_CODEWITH_PROFILE"]) found = 1 } END { exit(found ? 0 : 1) }'; then`, `  printf '%s\\n' ${shellQuote(`codewith auth profile not found: ${profileForError}`)} >&2`, "  exit 1", "fi");
+    lines.push(`__OPENLOOPS_CODEWITH_PROFILE=${shellQuote(spec.nativeAuthProfile.profile)}`, "export __OPENLOOPS_CODEWITH_PROFILE", "__openloops_codewith_profile_list_contains() {", `  printf '%s\\n' "$__OPENLOOPS_CODEWITH_PROFILES" | awk '{ line = $0; gsub(/^[[:space:]]+|[[:space:]]+$/, "", line); if (line == "" || line == "No auth profiles saved.") next; if (line ~ /"(data|profiles)"[[:space:]]*:[[:space:]]*\\[/) { in_profiles = 1; next } if (in_profiles && line ~ /^\\]/) { in_profiles = 0; next } json = line; if (in_profiles && json ~ /"name"[[:space:]]*:[[:space:]]*"/) { sub(/^.*"name"[[:space:]]*:[[:space:]]*"/, "", json); sub(/".*$/, "", json); if (json == ENVIRON["__OPENLOOPS_CODEWITH_PROFILE"]) found = 1; next } split(line, cols, /[[:space:]]+/); candidate = (cols[1] == "*" ? cols[2] : cols[1]); if (candidate == "NAME" && (cols[2] == "ACCOUNT" || cols[3] == "ACCOUNT")) next; if (candidate == ENVIRON["__OPENLOOPS_CODEWITH_PROFILE"]) found = 1 } END { exit(found ? 0 : 1) }'`, "}", `if __OPENLOOPS_CODEWITH_PROFILES="$(${shellQuote(spec.command)} profile list --json 2>/dev/null)" && __openloops_codewith_profile_list_contains; then`, "  :", "else", `  __OPENLOOPS_CODEWITH_PROFILES="$(${shellQuote(spec.command)} profile list)" || {`, `    printf '%s\\n' ${shellQuote("codewith auth profile preflight failed")} >&2`, "    exit 1", "  }", "  if ! __openloops_codewith_profile_list_contains; then", `    printf '%s\\n' ${shellQuote(`codewith auth profile not found: ${profileForError}`)} >&2`, "    exit 1", "  fi", "fi");
   }
   return lines.join(`
 `);
@@ -5423,9 +6314,28 @@ function transportEnv(opts) {
       env[key] = value;
   }
   env.PATH = normalizeExecutionPath(env);
+  env.SHLVL ||= "1";
   return env;
 }
+function remotePreflightFailureMessage(machineId, detail) {
+  const normalized = detail.trim();
+  if (/Host key verification failed|REMOTE HOST IDENTIFICATION HAS CHANGED|Offending .*key in .*known_hosts/i.test(normalized)) {
+    return [
+      `remote preflight failed on ${machineId}: SSH host key verification failed.`,
+      `Verify ${machineId}'s host identity and repair SSH known_hosts/trust material outside OpenLoops;`,
+      "OpenLoops will not disable host-key checking or modify known_hosts automatically.",
+      normalized ? `Transport detail: ${normalized}` : ""
+    ].filter(Boolean).join(" ");
+  }
+  return `remote preflight failed on ${machineId}${normalized ? `: ${normalized}` : ""}`;
+}
 function assertCodewithProfileListed(profile, result) {
+  const profiles = codewithProfileSetFromResult(result);
+  if (!profiles.has(profile)) {
+    throw new Error(`codewith auth profile not found: ${codewithProfileForError(profile)}`);
+  }
+}
+function codewithProfileSetFromResult(result) {
   if (result.error) {
     throw new Error(`codewith auth profile preflight failed: ${result.error}`);
   }
@@ -5433,32 +6343,45 @@ function assertCodewithProfileListed(profile, result) {
     const detail = (result.stderr || result.stdout || `exit ${result.status ?? "unknown"}`).trim();
     throw new Error(`codewith auth profile preflight failed${detail ? `: ${detail}` : ""}`);
   }
-  const profiles = new Set((result.stdout || "").split(/\r?\n/).slice(1).map(codewithProfileCandidateFromLine).filter(Boolean));
-  if (!profiles.has(profile)) {
-    throw new Error(`codewith auth profile not found: ${codewithProfileForError(profile)}`);
-  }
+  return new Set(codewithProfileCandidatesFromOutput(result.stdout || ""));
 }
 function preflightNativeAuthProfileSync(spec, env) {
   if (spec.nativeAuthProfile?.provider !== "codewith")
     return;
-  const result = spawnSync4(spec.command, ["profile", "list"], {
-    encoding: "utf8",
-    env,
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 15000
-  });
-  assertCodewithProfileListed(spec.nativeAuthProfile.profile, {
-    status: result.status,
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-    error: result.error?.message
-  });
+  const runProfileList = (args) => {
+    const result = spawnSync5(spec.command, args, {
+      encoding: "utf8",
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15000
+    });
+    return {
+      status: result.status,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      error: result.error?.message
+    };
+  };
+  const jsonResult = runProfileList(["profile", "list", "--json"]);
+  try {
+    if (codewithProfileSetFromResult(jsonResult).has(spec.nativeAuthProfile.profile))
+      return;
+  } catch {}
+  assertCodewithProfileListed(spec.nativeAuthProfile.profile, runProfileList(["profile", "list"]));
 }
 async function preflightNativeAuthProfile(spec, env) {
   if (spec.nativeAuthProfile?.provider !== "codewith")
     return;
-  const result = await spawnCapture(spec.command, ["profile", "list"], { env, timeoutMs: 15000 });
-  assertCodewithProfileListed(spec.nativeAuthProfile.profile, result);
+  const jsonResult = await spawnCapture(spec.command, ["profile", "list", "--json"], { env, timeoutMs: 15000 });
+  try {
+    if (codewithProfileSetFromResult(jsonResult).has(spec.nativeAuthProfile.profile))
+      return;
+  } catch {}
+  const tableResult = await spawnCapture(spec.command, ["profile", "list"], { env, timeoutMs: 15000 });
+  assertCodewithProfileListed(spec.nativeAuthProfile.profile, tableResult);
+}
+function spawnDetail(result) {
+  return (result.stderr || result.stdout || result.error || "").toString().trim();
 }
 function resolvedDirEquals(left, right) {
   try {
@@ -5509,8 +6432,45 @@ async function ensureLocalWorktree(worktree, env) {
     }
     const current = await git(["-C", path, "branch", "--show-current"]);
     const actualBranch = current.stdout.trim();
-    if (current.error || (current.status ?? 1) !== 0 || actualBranch !== branch) {
-      return { error: `existing worktree ${path} is on branch ${actualBranch || "unknown"}, expected ${branch}` };
+    if (current.error || (current.status ?? 1) !== 0) {
+      return { error: `existing worktree ${path} branch could not be inspected${spawnDetail(current) ? `: ${spawnDetail(current)}` : ""}` };
+    }
+    if (actualBranch !== branch) {
+      const actualLabel = actualBranch || "unknown";
+      const status = await git(["-C", path, "status", "--porcelain=v1", "--untracked-files=all"]);
+      if (status.error || (status.status ?? 1) !== 0) {
+        const detail = spawnDetail(status);
+        return {
+          error: `existing worktree ${path} is on branch ${actualLabel}, expected ${branch}, and cleanliness could not be checked; inspect or remove the stale worktree${detail ? `: ${detail}` : ""}`
+        };
+      }
+      if (status.stdout.trim()) {
+        return {
+          error: `existing worktree ${path} is on branch ${actualLabel}, expected ${branch}, and has local changes; commit/stash them or remove the stale worktree before retrying`
+        };
+      }
+      const hasBranch2 = await git(["-C", repoRoot, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+      const checkout = hasBranch2.status === 0 ? await git(["-C", path, "checkout", branch]) : actualBranch ? {
+        status: 1,
+        stdout: "",
+        stderr: `existing worktree ${path} is on branch ${actualLabel}, expected ${branch}, but expected branch does not exist; remove/prune the stale worktree or recreate the expected branch before retrying`,
+        signal: null,
+        timedOut: false
+      } : await git(["-C", path, "checkout", "-b", branch]);
+      if (checkout.error || (checkout.status ?? 1) !== 0) {
+        const detail = spawnDetail(checkout);
+        return {
+          error: `existing worktree ${path} is clean but could not recover branch ${branch} from ${actualLabel}; remove/prune the stale worktree before retrying${detail ? `: ${detail}` : ""}`
+        };
+      }
+      const recovered = await git(["-C", path, "branch", "--show-current"]);
+      if (recovered.error || (recovered.status ?? 1) !== 0 || recovered.stdout.trim() !== branch) {
+        const recoveredBranch = recovered.stdout.trim() || "unknown";
+        const detail = spawnDetail(recovered);
+        return {
+          error: `existing worktree ${path} branch recovery ended on ${recoveredBranch}, expected ${branch}; remove/prune the stale worktree before retrying${detail ? `: ${detail}` : ""}`
+        };
+      }
     }
     return { cwd: worktree.cwd };
   }
@@ -5526,7 +6486,7 @@ async function ensureLocalWorktree(worktree, env) {
   const hasBranch = await git(["-C", repoRoot, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
   const add = hasBranch.status === 0 ? await git(["-C", repoRoot, "worktree", "add", path, branch]) : await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
   if (add.error || (add.status ?? 1) !== 0) {
-    const detail = (add.stderr || add.stdout || add.error || "").toString().trim();
+    const detail = spawnDetail(add);
     return { error: `git worktree add failed for ${path}${detail ? `: ${detail}` : ""}` };
   }
   return { cwd: worktree.cwd };
@@ -5561,7 +6521,7 @@ function worktreeFallbackSpec(target, opts, fallbackCwd) {
 }
 function preflightRemoteSpec(spec, machine, metadata, opts) {
   const plan = (opts.machineCommandResolver ?? resolveMachineCommand)(machine.id, "bash -s");
-  const result = spawnSync4(plan.command, plan.args, {
+  const result = spawnSync5(plan.command, plan.args, {
     encoding: "utf8",
     env: transportEnv(opts),
     input: remotePreflightScript(spec, metadata),
@@ -5572,7 +6532,7 @@ function preflightRemoteSpec(spec, machine, metadata, opts) {
     throw new Error(`remote preflight failed on ${machine.id}: ${result.error.message}`);
   if ((result.status ?? 1) !== 0) {
     const detail = (result.stderr || result.stdout || `exit ${result.status ?? "unknown"}`).trim();
-    throw new Error(`remote preflight failed on ${machine.id}${detail ? `: ${detail}` : ""}`);
+    throw new Error(remotePreflightFailureMessage(machine.id, detail));
   }
 }
 async function executeRemoteSpec(spec, machine, metadata, opts, fallbackSpec) {
@@ -5660,6 +6620,9 @@ async function executeRemoteSpec(spec, machine, metadata, opts, fallbackSpec) {
   if (timedOut || idleTimedOut) {
     return timeoutResult(startedAt, idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`, fields);
   }
+  if (!error && exitCode !== 0 && codewithJsonlReconciledSuccess(spec, fields)) {
+    return successResult(startedAt, fields);
+  }
   if (error || exitCode !== 0) {
     return failureResult(startedAt, error ?? `remote process on ${machine.id} exited with code ${exitCode ?? "unknown"}`, fields);
   }
@@ -5795,6 +6758,9 @@ async function executeTarget(target, metadata = {}, opts = {}) {
   if (timedOut || idleTimedOut) {
     return timeoutResult(startedAt, idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`, fields);
   }
+  if (!error && exitCode !== 0 && codewithJsonlReconciledSuccess(spec, fields)) {
+    return successResult(startedAt, fields);
+  }
   if (error || exitCode !== 0) {
     return failureResult(startedAt, error ?? `process exited with code ${exitCode ?? "unknown"}`, fields);
   }
@@ -5825,320 +6791,392 @@ async function executeLoop(loop, run, opts = {}) {
   }, { ...opts, machine: opts.machine ?? loop.machine });
 }
 
-// src/lib/doctor.ts
-var PROVIDER_COMMANDS = [
-  "claude",
-  "agent",
-  "codewith",
-  "aicopilot",
-  "opencode",
-  "codex"
+// src/lib/health.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+var EVIDENCE_CHARS = 2000;
+var FINGERPRINT_EVIDENCE_CHARS = 120;
+var DEFAULT_SCAN_LIMIT = 200;
+var DEFAULT_SCAN_STATUSES = ["active", "paused"];
+var DEFAULT_MAX_FINDINGS = 100;
+var MIN_STALE_RUNNING_MS = 10 * 60000;
+var CLASSIFICATIONS = [
+  "rate_limit",
+  "auth",
+  "provider_unavailable",
+  "model_not_found",
+  "context_length",
+  "schema_response_format",
+  "node_init",
+  "preflight",
+  "route_functional",
+  "timeout",
+  "sigsegv",
+  "restart_interrupted",
+  "skipped_previous_active",
+  "circuit_breaker",
+  "unknown"
 ];
-function hasCommand(command) {
-  const result = spawnSync5("sh", ["-c", 'command -v "$1" >/dev/null', "sh", command], { stdio: "ignore" });
-  return (result.status ?? 1) === 0;
+var RESTART_INTERRUPTED_RUN_PREFIX = "daemon restart interrupted active run";
+function bounded(value, limit = EVIDENCE_CHARS) {
+  if (!value)
+    return;
+  if (value.length <= limit)
+    return value;
+  return `${value.slice(0, limit)}
+[truncated ${value.length - limit} chars]`;
 }
-function commandVersion(command) {
-  const result = spawnSync5(command, ["--version"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if ((result.status ?? 1) !== 0)
+function redactedEvidence(value) {
+  return redact(bounded(value));
+}
+function searchableText(run) {
+  return [run.error, run.stderr, run.stdout].filter(Boolean).join(`
+`);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function objectField(value, key) {
+  if (!value)
     return;
-  return (result.stdout || result.stderr).trim().split(/\r?\n/)[0];
+  const field = value[key];
+  return isRecord(field) ? field : undefined;
 }
-function runDoctor(store) {
-  const checks = [];
-  try {
-    const dir = ensureDataDir();
-    accessSync2(dir, constants2.R_OK | constants2.W_OK);
-    checks.push({ id: "data-dir", status: "ok", message: "data directory is writable", detail: dir });
-  } catch (error) {
-    checks.push({
-      id: "data-dir",
-      status: "fail",
-      message: "data directory is not writable",
-      detail: error instanceof Error ? error.message : String(error)
-    });
-  }
-  const bunVersion = commandVersion("bun");
-  checks.push(bunVersion ? { id: "bun", status: "ok", message: "bun is available", detail: bunVersion } : { id: "bun", status: "fail", message: "bun is not available on PATH" });
-  const accountsVersion = commandVersion("accounts");
-  checks.push(accountsVersion ? { id: "accounts", status: "ok", message: "accounts is available", detail: accountsVersion } : { id: "accounts", status: "warn", message: "accounts CLI is not available; account-routed steps will fail" });
-  try {
-    const machines = listOpenMachines();
-    const local = machines.find((machine) => machine.local);
-    checks.push({
-      id: "machines",
-      status: "ok",
-      message: `OpenMachines topology available (${machines.length} machine(s))`,
-      detail: local ? `local=${local.id}` : undefined
-    });
-  } catch (error) {
-    checks.push({
-      id: "machines",
-      status: "warn",
-      message: "OpenMachines topology is not available; machine-assigned loops will fail",
-      detail: error instanceof Error ? error.message : String(error)
-    });
-  }
-  for (const command of PROVIDER_COMMANDS) {
-    checks.push(hasCommand(command) ? { id: `provider:${command}`, status: "ok", message: `${command} is available` } : { id: `provider:${command}`, status: "warn", message: `${command} is not on PATH` });
-  }
-  const status = daemonStatus(store);
-  checks.push(status.running ? { id: "daemon", status: "ok", message: `daemon is running pid=${status.pid}` } : { id: "daemon", status: status.stale ? "warn" : "ok", message: status.stale ? "daemon pid file is stale" : "daemon is not running" });
-  const failedRuns = store.countRuns("failed");
-  checks.push(failedRuns === 0 ? { id: "loop-runs", status: "ok", message: "no failed loop runs recorded" } : { id: "loop-runs", status: "warn", message: `${failedRuns} failed loop run(s) recorded` });
-  const deployment = buildDeploymentStatus();
-  const schedulerState = deployment.schedulerState;
-  checks.push({
-    id: "scheduler-state",
-    status: deployment.deploymentMode === "local" || deployment.controlPlane.configured ? "ok" : "warn",
-    message: `scheduler state authority=${schedulerState.authority} local=${schedulerState.localStore.role} remote=${schedulerState.remoteStore.backend}`,
-    detail: [
-      `route_state=${schedulerState.routeAdmission.stateStore}`,
-      `active_statuses=${schedulerState.routeAdmission.activeStatuses.join(",")}`,
-      `gates=${schedulerState.routeAdmission.gates.join(",")}`,
-      `artifacts=${schedulerState.localStore.runArtifacts}`,
-      `remote_artifacts=${schedulerState.remoteStore.objectArtifacts}`,
-      `remote_apply=${String(schedulerState.remoteStore.applySupported)}`
-    ].join(" ")
-  });
-  for (const loop of store.listLoops({ status: "active" })) {
-    try {
-      if (loop.target.type === "workflow") {
-        const workflow = store.requireWorkflow(loop.target.workflowId);
-        for (const step of workflowExecutionOrder(workflow)) {
-          preflightTarget({
-            ...step.target,
-            account: step.account ?? step.target.account,
-            timeoutMs: step.timeoutMs !== undefined ? step.timeoutMs : step.target.timeoutMs
-          }, { loopId: loop.id, loopName: loop.name, workflowId: workflow.id, workflowName: workflow.name, workflowStepId: step.id }, { machine: loop.machine });
-        }
-      } else {
-        preflightTarget(loop.target, { loopId: loop.id, loopName: loop.name }, { machine: loop.machine });
-      }
-      checks.push({ id: `loop:${loop.id}:preflight`, status: "ok", message: `active loop target is ready: ${loop.name}` });
-    } catch (error) {
-      checks.push({
-        id: `loop:${loop.id}:preflight`,
-        status: "fail",
-        message: `active loop target preflight failed: ${loop.name}`,
-        detail: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return {
-    ok: checks.every((check) => check.status !== "fail"),
-    checks
-  };
+function tagsFromValue(value) {
+  if (Array.isArray(value))
+    return value.map((entry) => String(entry).trim()).filter(Boolean);
+  if (typeof value === "string")
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return [];
 }
-
-// src/lib/format.ts
-var TEXT_OUTPUT_LIMIT = 32 * 1024;
-var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
-function redact(value, visible = 0) {
+function stableFingerprint(parts) {
+  return createHash3("sha256").update(parts.join(`
+`)).digest("hex").slice(0, 16);
+}
+function stableScanFingerprint(parts) {
+  return `openloops:health-scan:${stableFingerprint(parts)}`;
+}
+function safeHost(value) {
   if (!value)
-    return value;
-  if (value.length <= visible)
-    return value;
-  if (visible <= 0)
-    return `[redacted ${value.length} chars]`;
-  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
+    return;
+  let host = value.trim().replace(/^[a-z]+:\/\//i, "").split(/[/:?#\s)"'\\]+/)[0] ?? "";
+  host = host.replace(/^\[|\]$/g, "");
+  return /^[a-z0-9.-]+$/i.test(host) ? host.toLowerCase() : undefined;
 }
-function truncateTextOutput(value) {
-  if (value.length <= TEXT_OUTPUT_LIMIT)
-    return value;
-  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
-[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
+function isCursorHost(host) {
+  return host === "cursor.sh" || Boolean(host?.endsWith(".cursor.sh"));
 }
-function redactSensitivePayload(value, key) {
-  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
-    if (typeof value === "string")
-      return redact(value);
-    if (value === undefined || value === null)
-      return value;
-    return "[redacted]";
-  }
-  if (Array.isArray(value))
-    return value.map((item) => redactSensitivePayload(item));
-  if (value && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
+function providerUnavailableSummary(rawText) {
+  const dns = /\bgetaddrinfo\s+(EAI_AGAIN|ENOTFOUND)\s+([a-z0-9.-]+)/i.exec(rawText);
+  if (dns) {
+    const host = safeHost(dns[2]);
+    if (isCursorHost(host))
+      return `provider DNS lookup failed: ${dns[1]} ${host}`;
   }
-  return value;
+  return;
 }
-function textOutputBlocks(value, opts = {}) {
-  const indent = opts.indent ?? "";
-  const nested = `${indent}  `;
-  const blocks = [];
-  for (const [label, output] of [
-    ["stdout", value.stdout],
-    ["stderr", value.stderr]
-  ]) {
-    if (!output)
-      continue;
-    blocks.push(`${indent}${label}:`);
-    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
-      blocks.push(`${nested}${line}`);
-    }
-  }
-  return blocks;
+function stableFailureFingerprint(run, classification, summary) {
+  const evidence = summary ?? (classification === "provider_unavailable" ? providerUnavailableSummary(searchableText(run)) : undefined) ?? run.error ?? run.stderr ?? run.stdout ?? "";
+  return stableFingerprint([
+    run.loopId,
+    classification,
+    String(run.status),
+    String(run.exitCode ?? ""),
+    evidence.replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
+  ]);
 }
-function publicLoop(loop) {
-  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
-  return {
-    ...loop,
-    target
-  };
+function stableRouteFunctionalFingerprint(loop, reason) {
+  return stableFingerprint([
+    loop.id,
+    "route_functional",
+    reason.replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
+  ]);
 }
-function publicRun(run, showOutput = false, opts = {}) {
+function healthRun(run) {
   return {
     ...run,
-    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
-    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
-    error: opts.redactError ? redact(run.error) : run.error
+    error: redactedEvidence(run.error),
+    stdout: redactedEvidence(run.stdout),
+    stderr: redactedEvidence(run.stderr)
   };
 }
-function publicExecutorResult(result, showOutput = false) {
+function compactText(value, limit = 500) {
+  const text = redact(bounded(value, limit));
+  return text?.replace(/\s+/g, " ").trim();
+}
+function publicDoctorCheck(check) {
   return {
-    ...result,
-    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
-    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
-    error: redact(result.error)
+    id: check.id,
+    status: check.status,
+    message: redact(bounded(check.message, 500)) ?? "",
+    detail: redact(bounded(check.detail, 800))
   };
 }
-function publicWorkflow(workflow) {
+function publicDoctorReport(report) {
   return {
-    ...workflow,
-    steps: workflow.steps.map((step) => ({
-      ...step,
-      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
-    }))
+    ok: report.ok,
+    checks: report.checks.map(publicDoctorCheck)
   };
 }
-function publicWorkflowRun(run) {
-  return { ...run, error: redact(run.error) };
+function includedStatusSet(statuses) {
+  const values = statuses?.length ? statuses : DEFAULT_SCAN_STATUSES;
+  return new Set(values);
 }
-function publicWorkflowInvocation(invocation) {
-  return redactSensitivePayload(invocation);
+function statusCounts(loops) {
+  return {
+    loops: loops.length,
+    active: loops.filter((loop) => loop.status === "active").length,
+    paused: loops.filter((loop) => loop.status === "paused").length,
+    stopped: loops.filter((loop) => loop.status === "stopped").length,
+    expired: loops.filter((loop) => loop.status === "expired").length
+  };
 }
-function publicWorkflowWorkItem(item) {
-  return { ...item, lastReason: redact(item.lastReason, 240) };
+function compareLoopsForScan(left, right) {
+  const statusOrder = left.status.localeCompare(right.status);
+  if (statusOrder !== 0)
+    return statusOrder;
+  return (left.nextRunAt ?? "").localeCompare(right.nextRunAt ?? "");
 }
-function publicWorkflowStepRun(run, showOutput = false) {
+function scanLoops(store, statuses, opts) {
+  const limit = opts.limit ?? DEFAULT_SCAN_LIMIT;
+  return statuses.flatMap((status) => store.listLoops({ includeArchived: opts.includeArchived, status, limit })).sort(compareLoopsForScan).slice(0, limit);
+}
+function healthReportForLoops(store, loops, generatedAt) {
+  const expectations = loops.map((loop) => expectationForLoop(store, loop));
+  const classifications = Object.fromEntries(CLASSIFICATIONS.map((key) => [key, 0]));
+  for (const expectation of expectations) {
+    if (expectation.failure)
+      classifications[expectation.failure.classification] += 1;
+  }
+  const unhealthy = expectations.filter((expectation) => !expectation.ok).length;
+  const warnings = expectations.filter((expectation) => expectation.check.status === "warn").length;
   return {
-    ...run,
-    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
-    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
-    error: redact(run.error)
+    ok: unhealthy === 0,
+    generatedAt,
+    summary: {
+      loops: expectations.length,
+      healthy: expectations.length - unhealthy,
+      unhealthy,
+      warnings
+    },
+    classifications,
+    expectations
   };
 }
-function publicWorkflowEvent(event) {
-  return { ...event, payload: redactSensitivePayload(event.payload) };
+function ageMs(run, now) {
+  const stamp = run.startedAt ?? run.createdAt ?? run.scheduledFor;
+  const time = Date.parse(stamp);
+  return Number.isFinite(time) ? Math.max(0, now.getTime() - time) : 0;
 }
-function publicGoal(goal) {
+function shortLoop(loop) {
   return {
-    ...goal,
-    objective: redact(goal.objective, 120)
+    id: loop.id,
+    name: loop.name,
+    status: loop.status,
+    nextRunAt: loop.nextRunAt,
+    leaseMs: loop.leaseMs
   };
 }
-function publicGoalRun(run) {
+function priorityForSeverity(severity) {
+  if (severity === "critical")
+    return "critical";
+  if (severity === "high")
+    return "high";
+  if (severity === "low")
+    return "low";
+  return "medium";
+}
+function recommendedFindingTask(finding, route) {
+  const tags = ["bug", "openloops", "loops", "loop-health", finding.kind];
+  if (finding.classification)
+    tags.push(finding.classification);
+  const description = [
+    `OpenLoops health scan found a ${finding.kind} issue.`,
+    finding.loop ? `Loop: ${finding.loop.name} (${finding.loop.id})` : undefined,
+    finding.run ? `Run: ${finding.run.id}` : undefined,
+    finding.classification ? `Classification: ${finding.classification}` : undefined,
+    finding.ageMs !== undefined ? `AgeMs: ${finding.ageMs}` : undefined,
+    finding.staleThresholdMs !== undefined ? `StaleThresholdMs: ${finding.staleThresholdMs}` : undefined,
+    `Fingerprint: ${finding.fingerprint}`,
+    `Severity: ${finding.severity}`,
+    `No-tmux routing: Do not dispatch or paste prompts into tmux panes; use task-triggered headless worker/verifier workflows only.`,
+    route?.cwd ? `Route cwd: ${route.cwd}` : undefined,
+    route?.provider ? `Provider: ${route.provider}` : undefined,
+    "",
+    finding.message,
+    finding.run?.error ? `Error:
+${finding.run.error}` : undefined,
+    finding.run?.stderr ? `Stderr:
+${finding.run.stderr}` : undefined
+  ].filter(Boolean).join(`
+
+`);
   return {
-    ...run,
-    evidence: redactSensitivePayload(run.evidence),
-    rawResponse: redactSensitivePayload(run.rawResponse)
+    title: finding.title,
+    description,
+    priority: priorityForSeverity(finding.severity),
+    tags,
+    dedupeKey: finding.fingerprint,
+    search: { query: finding.fingerprint },
+    compatibilityFallback: {
+      search: ["todos", "search", finding.fingerprint, "--json"],
+      add: ["todos", "add", finding.title, "--description", description, "--tag", tags.join(","), "--priority", priorityForSeverity(finding.severity)],
+      comment: ["todos", "comment", "<task-id>", description]
+    },
+    futureNativeUpsert: {
+      command: "todos task upsert",
+      fields: {
+        title: finding.title,
+        description,
+        priority: priorityForSeverity(finding.severity),
+        tags,
+        dedupeKey: finding.fingerprint,
+        routeSource: route?.source ?? "openloops",
+        routeKind: route?.kind ?? "health_scan",
+        routeLoopId: finding.loop?.id ?? "",
+        routeLoopName: finding.loop?.name ?? ""
+      }
+    }
   };
 }
-
-// src/lib/health.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-var EVIDENCE_CHARS = 2000;
-var FINGERPRINT_EVIDENCE_CHARS = 120;
-var CLASSIFICATIONS = [
-  "rate_limit",
-  "auth",
-  "model_not_found",
-  "context_length",
-  "schema_response_format",
-  "node_init",
-  "preflight",
-  "route_functional",
-  "timeout",
-  "sigsegv",
-  "skipped_previous_active",
-  "circuit_breaker",
-  "unknown"
-];
-function bounded(value, limit = EVIDENCE_CHARS) {
-  if (!value)
+function daemonFinding(daemon) {
+  if (daemon.running && !daemon.stale)
     return;
-  if (value.length <= limit)
-    return value;
-  return `${value.slice(0, limit)}
-[truncated ${value.length - limit} chars]`;
+  const reason = daemon.stale ? "daemon pid file is stale" : "daemon is not running";
+  const severity = "critical";
+  const finding = {
+    kind: "daemon",
+    severity,
+    fingerprint: `openloops:health-scan:daemon:${daemon.stale ? "stale" : "not-running"}`,
+    title: "OpenLoops daemon health issue",
+    message: reason
+  };
+  return {
+    ...finding,
+    recommendedTask: recommendedFindingTask(finding, undefined)
+  };
 }
-function redactedEvidence(value) {
-  return redact(bounded(value));
+function doctorSeverity(check) {
+  if (check.status === "fail" && check.id === "data-dir")
+    return "critical";
+  if (check.status === "fail")
+    return "high";
+  return "medium";
 }
-function searchableText(run) {
-  return [run.error, run.stderr, run.stdout].filter(Boolean).join(`
-`).toLowerCase();
+function doctorFinding(check, loop, route) {
+  if (check.status === "ok" || check.id === "loop-runs")
+    return;
+  const kind = check.id.startsWith("loop:") && check.id.endsWith(":preflight") ? "preflight" : "doctor";
+  const severity = kind === "preflight" && check.status === "fail" ? "high" : doctorSeverity(check);
+  const fingerprint = stableScanFingerprint(["doctor", check.id, check.status, check.message, check.detail ?? ""]);
+  const finding = {
+    kind,
+    severity,
+    fingerprint,
+    title: kind === "preflight" && loop ? `OpenLoops preflight issue - ${loop.name}` : `OpenLoops doctor issue - ${check.id}`,
+    message: [check.status, check.message, check.detail].filter(Boolean).join(" "),
+    loop: loop ? shortLoop(loop) : undefined,
+    route,
+    doctorCheck: publicDoctorCheck(check)
+  };
+  return {
+    ...finding,
+    recommendedTask: recommendedFindingTask(finding, route)
+  };
 }
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function stringValue(value) {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-function objectField(value, key) {
-  if (!value)
+function latestRunFinding(expectation) {
+  if (expectation.ok || !expectation.latestRun || expectation.latestRun.status === "running")
     return;
-  const field = value[key];
-  return isRecord(field) ? field : undefined;
-}
-function tagsFromValue(value) {
-  if (Array.isArray(value))
-    return value.map((entry) => String(entry).trim()).filter(Boolean);
-  if (typeof value === "string")
-    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
-  return [];
+  const failure = expectation.failure;
+  if (!failure)
+    return;
+  const severity = expectation.loop.status === "active" ? "high" : "medium";
+  return {
+    kind: "latest-run",
+    severity,
+    fingerprint: expectation.recommendedTask?.dedupeKey ?? `openloops:${expectation.loop.id}:${failure.fingerprint}`,
+    title: expectation.recommendedTask?.title ?? `OpenLoops latest run failed - ${expectation.loop.name}`,
+    message: expectation.check.message,
+    loop: expectation.loop,
+    run: expectation.latestRun,
+    route: expectation.route,
+    classification: failure.classification,
+    doctorCheck: undefined,
+    recommendedTask: expectation.recommendedTask
+  };
 }
-function stableFingerprint(parts) {
-  return createHash2("sha256").update(parts.join(`
-`)).digest("hex").slice(0, 16);
+function staleRunningFinding(loop, expectation, now, staleRunningMs) {
+  const run = expectation.latestRun;
+  if (loop.status !== "active" || run?.status !== "running")
+    return;
+  const threshold = Math.max(loop.leaseMs, staleRunningMs, MIN_STALE_RUNNING_MS);
+  const age = ageMs(run, now);
+  if (age <= threshold)
+    return;
+  const fingerprint = `openloops:health-scan:stale-running:${loop.id}:${run.id}`;
+  const message = `active loop latest run is still running after ${age}ms (threshold ${threshold}ms)`;
+  const finding = {
+    kind: "stale-running",
+    severity: "critical",
+    fingerprint,
+    title: `OpenLoops stale running run - ${loop.name}`,
+    message,
+    loop: shortLoop(loop),
+    run,
+    route: expectation.route,
+    ageMs: age,
+    staleThresholdMs: threshold
+  };
+  return {
+    ...finding,
+    recommendedTask: recommendedFindingTask(finding, expectation.route)
+  };
 }
-function stableFailureFingerprint(run, classification) {
-  return stableFingerprint([
-    run.loopId,
-    classification,
-    String(run.status),
-    String(run.exitCode ?? ""),
-    (run.error ?? run.stderr ?? run.stdout ?? "").replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
-  ]);
+function scanStatus(findings) {
+  if (findings.some((finding) => finding.severity === "critical"))
+    return "critical";
+  if (findings.length > 0)
+    return "degraded";
+  return "ok";
 }
-function stableRouteFunctionalFingerprint(loop, reason) {
-  return stableFingerprint([
-    loop.id,
-    "route_functional",
-    reason.replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
-  ]);
+function timestampDir(root, generatedAt) {
+  const stamp = generatedAt.replace(/[-:]/g, "").replace(/\./g, "");
+  return join7(root, stamp);
 }
-function healthRun(run) {
-  return {
-    ...run,
-    error: redactedEvidence(run.error),
-    stdout: redactedEvidence(run.stdout),
-    stderr: redactedEvidence(run.stderr)
-  };
+function healthScanMarkdown(scan) {
+  return [
+    "# OpenLoops Health Scan",
+    "",
+    `- status: ${scan.status}`,
+    `- generated_at: ${scan.generatedAt}`,
+    `- included_statuses: ${scan.includedStatuses.join(",")}`,
+    `- loops: total=${scan.counts.loops} active=${scan.counts.active} paused=${scan.counts.paused} stopped=${scan.counts.stopped} expired=${scan.counts.expired}`,
+    `- findings: total=${scan.counts.findings} reported=${scan.counts.reportedFindings} truncated=${scan.counts.truncatedFindings} latest_run=${scan.counts.latestRunFindings} stale_running=${scan.counts.staleRunning} daemon=${scan.counts.daemonFindings} doctor=${scan.counts.doctorFindings} preflight=${scan.counts.preflightFindings}`,
+    scan.daemon ? `- daemon: running=${scan.daemon.running} stale=${scan.daemon.stale} pid=${scan.daemon.pid ?? "none"}` : "- daemon: not checked",
+    scan.doctor ? `- doctor_ok: ${scan.doctor.ok}` : "- doctor: not checked",
+    scan.selfHeals.length ? `- self_heals: ${scan.selfHeals.map((action) => `${action.kind}:${action.attempted ? action.ok ? "ok" : "failed" : "skipped"}`).join(",")}` : "- self_heals: none",
+    "",
+    "## Findings",
+    scan.findings.length ? scan.findings.map((finding) => `- ${finding.severity} ${finding.kind} ${finding.fingerprint} ${finding.loop ? `${finding.loop.name}: ` : ""}${compactText(finding.message, 240) ?? ""}`).join(`
+`) : "None."
+  ].join(`
+`);
 }
 function classifyRunFailure(run) {
   if (run.status === "succeeded" || run.status === "running")
     return;
-  const text = searchableText(run);
+  const rawText = searchableText(run);
+  const text = rawText.toLowerCase();
   let classification = "unknown";
+  let summary;
   if (run.status === "timed_out")
     classification = "timeout";
+  else if (run.status === "skipped" && run.error?.startsWith(RESTART_INTERRUPTED_RUN_PREFIX))
+    classification = "restart_interrupted";
   else if (run.status === "skipped" && /circuit breaker open/.test(text))
     classification = "circuit_breaker";
   else if (run.status === "skipped" && /previous run still active/.test(text))
@@ -6147,8 +7185,10 @@ function classifyRunFailure(run) {
     classification = "preflight";
   else if (/rate limit|too many requests|429\b|quota exceeded/.test(text))
     classification = "rate_limit";
-  else if (/unauthorized|authentication|auth\b|api key|invalid token|permission denied|401\b|403\b/.test(text))
+  else if (/unauthorized|authentication|auth\b|api key|invalid token|permission denied|401\b|403\b|not logged in|please run \/login|login required|not authenticated|failed to authenticate/.test(text))
     classification = "auth";
+  else if (summary = providerUnavailableSummary(rawText))
+    classification = "provider_unavailable";
   else if (/model .*not found|model_not_found|unknown model|invalid model|404.*model/.test(text))
     classification = "model_not_found";
   else if (/context length|context_length|context window|maximum context|token limit|too many tokens/.test(text))
@@ -6161,8 +7201,9 @@ function classifyRunFailure(run) {
     classification = "sigsegv";
   return {
     classification,
-    fingerprint: stableFailureFingerprint(run, classification),
+    fingerprint: stableFailureFingerprint(run, classification, summary),
     evidence: {
+      summary,
       error: redactedEvidence(run.error),
       stdout: redactedEvidence(run.stdout),
       stderr: redactedEvidence(run.stderr),
@@ -6207,7 +7248,7 @@ function routeEvidenceReport(run) {
   const evidencePath = stringValue(stdoutReport?.evidencePath);
   if (evidencePath && existsSync4(evidencePath)) {
     try {
-      return parseJsonObject(readFileSync4(evidencePath, "utf8")) ?? stdoutReport;
+      return parseJsonObject(readFileSync5(evidencePath, "utf8")) ?? stdoutReport;
     } catch {
       return stdoutReport;
     }
@@ -6339,6 +7380,12 @@ function targetRoute(loop) {
     loopName: loop.name
   };
 }
+function expectationLoop(loop) {
+  return { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt, retryScheduledFor: loop.retryScheduledFor };
+}
+function hasPendingRetry(loop, run) {
+  return loop.status === "active" && loop.retryScheduledFor === run.scheduledFor && run.attempt < loop.maxAttempts;
+}
 function recommendedTask(loop, run, failure, route) {
   const title = `BUG: open-loops loop failure - ${loop.name}`;
   const description = [
@@ -6350,6 +7397,7 @@ function recommendedTask(loop, run, failure, route) {
     `No-tmux routing: Do not dispatch or paste prompts into tmux panes; use task-triggered headless worker/verifier workflows only.`,
     route.cwd ? `Route cwd: ${route.cwd}` : undefined,
     route.provider ? `Provider: ${route.provider}` : undefined,
+    failure.evidence.summary ? `Summary: ${failure.evidence.summary}` : undefined,
     failure.evidence.error ? `Error:
 ${failure.evidence.error}` : undefined,
     failure.evidence.stderr ? `Stderr:
@@ -6359,7 +7407,7 @@ ${failure.evidence.stderr}` : undefined
 `);
   const dedupeKey = `openloops:${loop.id}:${failure.fingerprint}`;
   const tags = ["bug", "openloops", "loops", "loop-health", failure.classification];
-  const priority = failure.classification === "auth" || failure.classification === "rate_limit" ? "high" : "medium";
+  const priority = failure.classification === "auth" || failure.classification === "rate_limit" || failure.classification === "provider_unavailable" ? "high" : "medium";
   return {
     title,
     description,
@@ -6393,7 +7441,7 @@ function expectationForLoop(store, loop) {
   const route = targetRoute(loop);
   if (!latestRun) {
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: true,
       check: { id: "latest-run-succeeded", status: "warn", message: "loop has no recorded runs yet" },
       route
@@ -6402,7 +7450,7 @@ function expectationForLoop(store, loop) {
   const routeFailure = detectRouteFunctionalFailure(store, loop, latestRun);
   if (routeFailure) {
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: false,
       check: { id: "route-functional-health", status: "fail", message: routeFailure.evidence.error ?? "route functional blocker detected" },
       latestRun: healthRun(latestRun),
@@ -6413,7 +7461,7 @@ function expectationForLoop(store, loop) {
   }
   if (latestRun.status === "succeeded") {
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: true,
       check: { id: "latest-run-succeeded", status: "pass", message: "latest run succeeded" },
       latestRun: healthRun(latestRun),
@@ -6424,7 +7472,7 @@ function expectationForLoop(store, loop) {
   if (failure?.classification === "circuit_breaker") {
     if (loop.status !== "paused") {
       return {
-        loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+        loop: expectationLoop(loop),
         ok: true,
         check: { id: "latest-run-succeeded", status: "warn", message: "circuit breaker cleared by resume; awaiting next run" },
         latestRun: healthRun(latestRun),
@@ -6432,7 +7480,7 @@ function expectationForLoop(store, loop) {
       };
     }
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: false,
       check: { id: "latest-run-succeeded", status: "fail", message: latestRun.error ?? "circuit breaker open; loop auto-paused" },
       latestRun: healthRun(latestRun),
@@ -6441,8 +7489,33 @@ function expectationForLoop(store, loop) {
       recommendedTask: recommendedTask(loop, latestRun, failure, route)
     };
   }
+  if (failure?.classification === "restart_interrupted") {
+    return {
+      loop: expectationLoop(loop),
+      ok: true,
+      check: { id: "latest-run-succeeded", status: "warn", message: latestRun.error ?? "daemon restart interrupted latest run" },
+      latestRun: healthRun(latestRun),
+      failure,
+      route
+    };
+  }
+  if (failure?.classification === "provider_unavailable" && hasPendingRetry(loop, latestRun)) {
+    const message = [
+      "provider unavailable/network failure; retry is scheduled",
+      loop.nextRunAt ? `next attempt at ${loop.nextRunAt}` : undefined,
+      failure.evidence.summary
+    ].filter(Boolean).join("; ");
+    return {
+      loop: expectationLoop(loop),
+      ok: true,
+      check: { id: "latest-run-succeeded", status: "warn", message },
+      latestRun: healthRun(latestRun),
+      failure,
+      route
+    };
+  }
   return {
-    loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+    loop: expectationLoop(loop),
     ok: false,
     check: { id: "latest-run-succeeded", status: "fail", message: `latest run is ${latestRun.status}` },
     latestRun: healthRun(latestRun),
@@ -6474,6 +7547,206 @@ function buildHealthReport(store, opts = {}) {
     expectations
   };
 }
+function buildHealthScan(store, opts = {}) {
+  const generatedAt = (opts.now ?? new Date).toISOString();
+  const now = opts.now ?? new Date(generatedAt);
+  const includeStatuses = [...includedStatusSet(opts.includeStatuses)];
+  const loops = scanLoops(store, includeStatuses, opts);
+  const health = healthReportForLoops(store, loops, generatedAt);
+  const expectationsByLoopId = new Map(health.expectations.map((expectation) => [expectation.loop.id, expectation]));
+  const loopsById = new Map(loops.map((loop) => [loop.id, loop]));
+  const maxFindings = Math.max(0, opts.maxFindings ?? DEFAULT_MAX_FINDINGS);
+  const allFindings = [];
+  const pushFinding = (finding) => {
+    if (!finding)
+      return;
+    allFindings.push(finding);
+  };
+  if (opts.daemon)
+    pushFinding(daemonFinding(opts.daemon));
+  if (opts.latestRun !== false) {
+    for (const loop of loops) {
+      const expectation = expectationsByLoopId.get(loop.id);
+      if (!expectation)
+        continue;
+      pushFinding(staleRunningFinding(loop, expectation, now, opts.staleRunningMs ?? MIN_STALE_RUNNING_MS));
+      pushFinding(latestRunFinding(expectation));
+    }
+  }
+  const doctor = opts.doctor ? publicDoctorReport(opts.doctor) : undefined;
+  if (doctor) {
+    for (const check of doctor.checks) {
+      const preflightLoopId = check.id.startsWith("loop:") && check.id.endsWith(":preflight") ? check.id.slice("loop:".length, -":preflight".length) : undefined;
+      const loop = preflightLoopId ? loopsById.get(preflightLoopId) : undefined;
+      const route = preflightLoopId ? expectationsByLoopId.get(preflightLoopId)?.route : undefined;
+      pushFinding(doctorFinding(check, loop, route));
+    }
+  }
+  const findings = allFindings.slice(0, maxFindings);
+  const status = scanStatus(allFindings);
+  const baseCounts = statusCounts(loops);
+  return {
+    ok: status === "ok",
+    status,
+    generatedAt,
+    includedStatuses: includeStatuses,
+    counts: {
+      ...baseCounts,
+      latestRunFindings: allFindings.filter((finding) => finding.kind === "latest-run").length,
+      staleRunning: allFindings.filter((finding) => finding.kind === "stale-running").length,
+      daemonFindings: allFindings.filter((finding) => finding.kind === "daemon").length,
+      doctorFindings: allFindings.filter((finding) => finding.kind === "doctor").length,
+      preflightFindings: allFindings.filter((finding) => finding.kind === "preflight").length,
+      findings: allFindings.length,
+      reportedFindings: findings.length,
+      truncatedFindings: Math.max(0, allFindings.length - findings.length)
+    },
+    daemon: opts.daemon ? {
+      running: opts.daemon.running,
+      stale: opts.daemon.stale,
+      pid: opts.daemon.pid,
+      host: opts.daemon.host,
+      loops: opts.daemon.loops,
+      runs: opts.daemon.runs,
+      logPath: opts.daemon.logPath
+    } : undefined,
+    doctor,
+    health,
+    selfHeals: opts.selfHeals ?? [],
+    findings
+  };
+}
+function writeHealthScanReports(scan, opts = {}) {
+  const root = opts.reportDir ?? join7(dataDir(), "reports", "health-scan");
+  const dir = timestampDir(root, scan.generatedAt);
+  mkdirSync6(dir, { recursive: true, mode: 448 });
+  const json = join7(dir, "summary.json");
+  const markdown = join7(dir, "report.md");
+  const withReports = {
+    ...scan,
+    reports: { dir, json, markdown }
+  };
+  writeFileSync3(json, JSON.stringify(withReports, null, 2), { mode: 384 });
+  writeFileSync3(markdown, healthScanMarkdown(withReports), { mode: 384 });
+  return withReports;
+}
+
+// src/lib/doctor.ts
+var PROVIDER_COMMANDS = [
+  "claude",
+  "agent",
+  "codewith",
+  "aicopilot",
+  "opencode",
+  "codex"
+];
+function hasCommand(command) {
+  const result = spawnSync6("sh", ["-c", 'command -v "$1" >/dev/null', "sh", command], { stdio: "ignore" });
+  return (result.status ?? 1) === 0;
+}
+function commandVersion(command) {
+  const result = spawnSync6(command, ["--version"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if ((result.status ?? 1) !== 0)
+    return;
+  return (result.stdout || result.stderr).trim().split(/\r?\n/)[0];
+}
+function runDoctor(store) {
+  const checks = [];
+  try {
+    const dir = ensureDataDir();
+    accessSync2(dir, constants2.R_OK | constants2.W_OK);
+    checks.push({ id: "data-dir", status: "ok", message: "data directory is writable", detail: dir });
+  } catch (error) {
+    checks.push({
+      id: "data-dir",
+      status: "fail",
+      message: "data directory is not writable",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const bunVersion = commandVersion("bun");
+  checks.push(bunVersion ? { id: "bun", status: "ok", message: "bun is available", detail: bunVersion } : { id: "bun", status: "fail", message: "bun is not available on PATH" });
+  const accountsVersion = commandVersion("accounts");
+  checks.push(accountsVersion ? { id: "accounts", status: "ok", message: "accounts is available", detail: accountsVersion } : { id: "accounts", status: "warn", message: "accounts CLI is not available; account-routed steps will fail" });
+  try {
+    const machines = listOpenMachines();
+    const local = machines.find((machine) => machine.local);
+    checks.push({
+      id: "machines",
+      status: "ok",
+      message: `OpenMachines topology available (${machines.length} machine(s))`,
+      detail: local ? `local=${local.id}` : undefined
+    });
+  } catch (error) {
+    checks.push({
+      id: "machines",
+      status: "warn",
+      message: "OpenMachines topology is not available; machine-assigned loops will fail",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  for (const command of PROVIDER_COMMANDS) {
+    checks.push(hasCommand(command) ? { id: `provider:${command}`, status: "ok", message: `${command} is available` } : { id: `provider:${command}`, status: "warn", message: `${command} is not on PATH` });
+  }
+  const status = daemonStatus(store);
+  checks.push(status.running ? { id: "daemon", status: "ok", message: `daemon is running pid=${status.pid}` } : { id: "daemon", status: status.stale ? "warn" : "ok", message: status.stale ? "daemon pid file is stale" : "daemon is not running" });
+  const failedRuns = store.countRuns("failed");
+  const restartInterruptedRuns = store.listRuns({ status: "skipped", limit: 1000 }).filter((run) => run.error?.startsWith(RESTART_INTERRUPTED_RUN_PREFIX)).length;
+  checks.push(failedRuns === 0 ? { id: "loop-runs", status: "ok", message: "no failed loop runs recorded" } : { id: "loop-runs", status: "warn", message: `${failedRuns} failed loop run(s) recorded` });
+  if (restartInterruptedRuns > 0) {
+    checks.push({
+      id: "loop-runs:restart-interrupted",
+      status: "warn",
+      message: `${restartInterruptedRuns} daemon restart-interrupted loop run(s) recorded`
+    });
+  }
+  const deployment = buildDeploymentStatus();
+  const schedulerState = deployment.schedulerState;
+  checks.push({
+    id: "scheduler-state",
+    status: deployment.deploymentMode === "local" || deployment.controlPlane.configured ? "ok" : "warn",
+    message: `scheduler state authority=${schedulerState.authority} local=${schedulerState.localStore.role} remote=${schedulerState.remoteStore.backend}`,
+    detail: [
+      `route_state=${schedulerState.routeAdmission.stateStore}`,
+      `active_statuses=${schedulerState.routeAdmission.activeStatuses.join(",")}`,
+      `gates=${schedulerState.routeAdmission.gates.join(",")}`,
+      `artifacts=${schedulerState.localStore.runArtifacts}`,
+      `remote_artifacts=${schedulerState.remoteStore.objectArtifacts}`,
+      `remote_apply=${String(schedulerState.remoteStore.applySupported)}`
+    ].join(" ")
+  });
+  for (const loop of store.listLoops({ status: "active" })) {
+    try {
+      if (loop.target.type === "workflow") {
+        const workflow = store.requireWorkflow(loop.target.workflowId);
+        for (const step of workflowExecutionOrder(workflow)) {
+          preflightTarget({
+            ...step.target,
+            account: step.account ?? step.target.account,
+            timeoutMs: step.timeoutMs !== undefined ? step.timeoutMs : step.target.timeoutMs
+          }, { loopId: loop.id, loopName: loop.name, workflowId: workflow.id, workflowName: workflow.name, workflowStepId: step.id }, { machine: loop.machine });
+        }
+      } else {
+        preflightTarget(loop.target, { loopId: loop.id, loopName: loop.name }, { machine: loop.machine });
+      }
+      checks.push({ id: `loop:${loop.id}:preflight`, status: "ok", message: `active loop target is ready: ${loop.name}` });
+    } catch (error) {
+      checks.push({
+        id: `loop:${loop.id}:preflight`,
+        status: "fail",
+        message: `active loop target preflight failed: ${loop.name}`,
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return {
+    ok: checks.every((check) => check.status !== "fail"),
+    checks
+  };
+}
 
 // src/lib/goal/metadata.ts
 function goalExecutionContext(parts) {
@@ -6560,55 +7833,6 @@ ${evidence.join(`
 import { generateObject } from "ai";
 import { z } from "zod";
 
-// src/lib/run-envelope.ts
-var ENVELOPE_EXCERPT_CHARS = 2048;
-var BLOCKED_STEP_ERROR_PREFIX = "blocked:";
-function boundedExcerpt(text, limit = ENVELOPE_EXCERPT_CHARS) {
-  if (!text)
-    return;
-  const scrubbed = scrubSecrets(text);
-  if (scrubbed.length <= limit * 2)
-    return scrubbed;
-  const omitted = scrubbed.length - limit * 2;
-  return `${scrubbed.slice(0, limit)}
-[... ${omitted} chars omitted ...]
-${scrubbed.slice(-limit)}`;
-}
-function summarizeOutput(stdout, stderr) {
-  return {
-    stdoutBytes: stdout ? Buffer.byteLength(stdout, "utf8") : 0,
-    stderrBytes: stderr ? Buffer.byteLength(stderr, "utf8") : 0,
-    stdoutExcerpt: boundedExcerpt(stdout),
-    stderrExcerpt: boundedExcerpt(stderr)
-  };
-}
-function summarizeExecutorResult(result) {
-  return {
-    ...summarizeOutput(result.stdout, result.stderr),
-    status: result.status,
-    exitCode: result.exitCode,
-    durationMs: result.durationMs,
-    error: boundedExcerpt(result.error)
-  };
-}
-function isBlockedStepRun(step) {
-  return step?.status === "skipped" && (step.error?.startsWith(BLOCKED_STEP_ERROR_PREFIX) ?? false);
-}
-function summarizeWorkflowStepRun(step) {
-  return {
-    ...summarizeOutput(step.stdout, step.stderr),
-    stepId: step.stepId,
-    status: step.status,
-    exitCode: step.exitCode,
-    durationMs: step.durationMs,
-    error: boundedExcerpt(step.error),
-    blocked: isBlockedStepRun(step)
-  };
-}
-function workflowRunEnvelope(run, steps) {
-  return JSON.stringify({ workflowRun: run, steps: steps.map(summarizeWorkflowStepRun) }, null, 2);
-}
-
 // src/lib/goal/model-factory.ts
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 var DEFAULT_GOAL_MODEL = "openai/gpt-4o-mini";
@@ -7473,7 +8697,7 @@ var MAX_RETRY_EXPONENT = 20;
 function retryBackoffDelayMs(loop, run, random = Math.random) {
   const attempt = Math.max(1, run.attempt);
   const failure = classifyRunFailure(run);
-  const throttled = failure?.classification === "rate_limit" || failure?.classification === "auth";
+  const throttled = failure?.classification === "rate_limit" || failure?.classification === "auth" || failure?.classification === "provider_unavailable";
   const growth = 2 ** Math.min(attempt - 1, MAX_RETRY_EXPONENT);
   const base = loop.retryDelayMs * growth * (throttled ? THROTTLED_RETRY_MULTIPLIER : 1);
   const jitter = 0.5 + random();
@@ -7600,20 +8824,21 @@ async function executeClaimedRun(deps) {
       daemonLeaseId: deps.daemonLeaseId,
       onSpawn: (pid) => deps.store.markRunPid(run.id, pid, deps.runnerId, { daemonLeaseId: deps.daemonLeaseId })
     })))(deps.loop, deps.run);
+    const finalResult = deps.finalizeResult?.(result, deps.loop, deps.run) ?? result;
     deps.beforeFinalize?.(deps.loop, deps.run);
     return deps.store.finalizeRun(deps.run.id, {
-      status: result.status,
-      finishedAt: result.finishedAt,
-      durationMs: result.durationMs,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exitCode: result.exitCode,
-      error: result.error,
-      pid: result.pid
+      status: finalResult.status,
+      finishedAt: finalResult.finishedAt,
+      durationMs: finalResult.durationMs,
+      stdout: finalResult.stdout,
+      stderr: finalResult.stderr,
+      exitCode: finalResult.exitCode,
+      error: finalResult.error,
+      pid: finalResult.pid
     }, {
       claimedBy: deps.runnerId,
       daemonLeaseId: deps.daemonLeaseId,
-      now: deps.now?.() ?? new Date(result.finishedAt)
+      now: deps.now?.() ?? new Date(finalResult.finishedAt)
     });
   } catch (err) {
     deps.onError?.(deps.loop, err);
@@ -7673,178 +8898,1062 @@ async function runSlot(deps, loop, scheduledFor) {
   if (loop.overlap === "skip" && deps.store.hasRunningRun(loop.id)) {
     let skipped;
     try {
-      skipped = deps.store.createSkippedRun(loop, scheduledFor, "previous run still active", {
-        daemonLeaseId: deps.daemonLeaseId
-      });
-    } catch (error) {
-      if (deps.daemonLeaseId && isDaemonLeaseLost(error))
-        return;
-      throw error;
+      skipped = deps.store.createSkippedRun(loop, scheduledFor, "previous run still active", {
+        daemonLeaseId: deps.daemonLeaseId
+      });
+    } catch (error) {
+      if (deps.daemonLeaseId && isDaemonLeaseLost(error))
+        return;
+      throw error;
+    }
+    advanceLoop(deps.store, loop, skipped, now, true, advanceOptions(deps));
+    deps.onRun?.(skipped);
+    return skipped;
+  }
+  let claim;
+  try {
+    claim = deps.store.claimRun(loop, scheduledFor, deps.runnerId, now, { daemonLeaseId: deps.daemonLeaseId });
+  } catch (error) {
+    if (deps.daemonLeaseId && isDaemonLeaseLost(error))
+      return;
+    throw error;
+  }
+  if (!claim) {
+    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
+    return;
+  }
+  deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
+  deps.onRun?.(claim.run);
+  const finalRun = await executeClaimedRun({
+    store: deps.store,
+    runnerId: deps.runnerId,
+    loop: claim.loop,
+    run: claim.run,
+    now: deps.now,
+    execute: deps.execute,
+    beforeFinalize: deps.beforeFinalize,
+    daemonLeaseId: deps.daemonLeaseId,
+    onError: deps.onError
+  });
+  advanceLoop(deps.store, claim.loop, finalRun, new Date(finalRun.finishedAt ?? new Date), finalRun.status === "succeeded", advanceOptions(deps));
+  deps.onRun?.(finalRun);
+  return finalRun;
+}
+function claimSlot(deps, loop, scheduledFor) {
+  const now = deps.now?.() ?? new Date;
+  deps.beforeRun?.(loop, scheduledFor);
+  if (loop.overlap === "skip" && deps.store.hasRunningRun(loop.id)) {
+    if (deps.store.hasRunningRunForSlot(loop.id, scheduledFor))
+      return;
+    let skipped;
+    try {
+      skipped = deps.store.createSkippedRun(loop, scheduledFor, "previous run still active", {
+        daemonLeaseId: deps.daemonLeaseId
+      });
+    } catch (error) {
+      if (deps.daemonLeaseId && isDaemonLeaseLost(error))
+        return;
+      throw error;
+    }
+    advanceLoop(deps.store, loop, skipped, now, true, advanceOptions(deps));
+    deps.onRun?.(skipped);
+    return skipped;
+  }
+  let claim;
+  try {
+    claim = deps.store.claimRun(loop, scheduledFor, deps.runnerId, now, { daemonLeaseId: deps.daemonLeaseId });
+  } catch (error) {
+    if (deps.daemonLeaseId && isDaemonLeaseLost(error))
+      return;
+    throw error;
+  }
+  if (!claim) {
+    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
+    return;
+  }
+  deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
+  deps.onRun?.(claim.run);
+  return claim;
+}
+function recoverAndExpire(deps, now) {
+  const recovered = deps.store.recoverExpiredRunLeases(now, { daemonLeaseId: deps.daemonLeaseId });
+  const recoveredByLoop = new Map;
+  for (const run of recovered) {
+    recoveredByLoop.set(run.loopId, [...recoveredByLoop.get(run.loopId) ?? [], run]);
+  }
+  for (const runs of recoveredByLoop.values()) {
+    const loop = deps.store.getLoop(runs[0].loopId);
+    if (!loop)
+      continue;
+    const retryable = runs.filter((run) => run.attempt < loop.maxAttempts).sort((a, b) => new Date(a.scheduledFor).getTime() - new Date(b.scheduledFor).getTime())[0];
+    if (retryable) {
+      advanceLoop(deps.store, loop, retryable, new Date(retryable.finishedAt ?? now), false, advanceOptions(deps));
+      continue;
+    }
+    for (const run of runs) {
+      const current = deps.store.getLoop(run.loopId);
+      if (current) {
+        advanceLoop(deps.store, current, run, new Date(run.finishedAt ?? now), false, advanceOptions(deps));
+      }
+    }
+  }
+  const expired = deps.store.expireLoops(now, { daemonLeaseId: deps.daemonLeaseId });
+  return { recovered, expired };
+}
+function claimDueRuns(deps) {
+  const now = deps.now?.() ?? new Date;
+  const { recovered, expired } = recoverAndExpire(deps, now);
+  const claims = [];
+  const claimed = [];
+  const skipped = [];
+  const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
+  if (maxClaims === 0)
+    return { claims, claimed, completed: [], skipped, recovered, expired };
+  const laneLimits = deps.laneLimits;
+  const laneClaims = { command: 0, agent: 0 };
+  const laneCap = (lane) => laneLimits === undefined ? Number.POSITIVE_INFINITY : Math.max(0, laneLimits[lane] ?? Number.POSITIVE_INFINITY);
+  const laneFull = (lane) => laneClaims[lane] >= laneCap(lane);
+  for (const loop of deps.store.dueLoops(now)) {
+    if (claims.length >= maxClaims)
+      break;
+    const lane = loopLane(loop);
+    if (laneFull(lane))
+      continue;
+    const plan = dueSlots(loop, now);
+    let loopSkips = 0;
+    for (const slot of plan.slots) {
+      if (claims.length >= maxClaims)
+        break;
+      if (laneFull(lane))
+        break;
+      if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
+        break;
+      const run = claimSlot(deps, loop, slot);
+      if (!run)
+        continue;
+      if ("loop" in run) {
+        claims.push(run);
+        claimed.push(run.run);
+        laneClaims[lane] += 1;
+      } else if (run.status === "skipped") {
+        skipped.push(run);
+        loopSkips += 1;
+      }
+    }
+  }
+  return { claims, claimed, completed: [], skipped, recovered, expired };
+}
+async function tick(deps) {
+  const now = deps.now?.() ?? new Date;
+  const { recovered, expired } = recoverAndExpire(deps, now);
+  const claimed = [];
+  const completed = [];
+  const skipped = [];
+  for (const loop of deps.store.dueLoops(now)) {
+    const plan = dueSlots(loop, now);
+    let loopSkips = 0;
+    for (const slot of plan.slots) {
+      if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
+        break;
+      const run = await runSlot(deps, loop, slot);
+      if (!run)
+        continue;
+      if (run.status === "running")
+        claimed.push(run);
+      else if (run.status === "skipped") {
+        skipped.push(run);
+        loopSkips += 1;
+      } else
+        completed.push(run);
+      if (["failed", "timed_out", "abandoned"].includes(run.status) && run.attempt < loop.maxAttempts)
+        break;
+    }
+  }
+  return { claimed, completed, skipped, recovered, expired };
+}
+
+// src/lib/cloud/mode.ts
+var DEPRECATED_STORAGE_MODE_ALIASES = ["remote", "hybrid", "self_hosted"];
+function normalizeStorageMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "local")
+    return { mode: "local", deprecatedAlias: null };
+  if (normalized === "cloud")
+    return { mode: "cloud", deprecatedAlias: null };
+  if (DEPRECATED_STORAGE_MODE_ALIASES.includes(normalized)) {
+    return { mode: "cloud", deprecatedAlias: normalized };
+  }
+  throw new Error(`Unknown storage mode: ${value}. Use local or cloud.`);
+}
+function envToken(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+
+// src/lib/cloud/transport.ts
+function defaultCloudBaseUrl(name) {
+  return `https://${name}.hasna.xyz`;
+}
+function clientTransportEnvKeys(name) {
+  const token = envToken(name);
+  return {
+    modeKeys: [
+      `HASNA_${token}_STORAGE_MODE`,
+      `HASNA_${token}_MODE`,
+      `${token}_STORAGE_MODE`,
+      `${token}_MODE`
+    ],
+    apiUrlKeys: [`HASNA_${token}_API_URL`, `${token}_API_URL`],
+    apiKeyKeys: [
+      `HASNA_${token}_API_KEY`,
+      `${token}_API_KEY`,
+      `HASNA_${token}_API_TOKEN`,
+      `${token}_API_TOKEN`
+    ]
+  };
+}
+function firstEnv(env, keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value)
+      return { key, value };
+  }
+  return null;
+}
+function toV1BaseUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("API URL must use http or https.");
+  }
+  let path = url.pathname.replace(/\/+$/, "");
+  if (path.endsWith("/v1"))
+    path = path.slice(0, -"/v1".length);
+  url.pathname = `${path}/v1`;
+  url.search = "";
+  url.hash = "";
+  return url.toString().replace(/\/+$/, "");
+}
+function resolveClientTransport(name, env = process.env) {
+  const keys = clientTransportEnvKeys(name);
+  const modeHit = firstEnv(env, keys.modeKeys);
+  const urlHit = firstEnv(env, keys.apiUrlKeys);
+  const keyHit = firstEnv(env, keys.apiKeyKeys);
+  let mode = "local";
+  let deprecatedAlias = null;
+  let modeSource = "default";
+  const warnings = [];
+  if (modeHit) {
+    const normalized = normalizeStorageMode(modeHit.value);
+    mode = normalized.mode;
+    deprecatedAlias = normalized.deprecatedAlias;
+    modeSource = modeHit.key;
+    if (deprecatedAlias) {
+      warnings.push(`Deprecated mode '${deprecatedAlias}' from ${modeHit.key} is treated as 'cloud'. Prefer ${keys.modeKeys[0]}=cloud.`);
+    }
+  }
+  if (mode === "local") {
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: Boolean(keyHit),
+      apiKeySource: keyHit ? keyHit.key : null,
+      misconfigured: false,
+      warning: warnings.length > 0 ? warnings.join(" ") : null
+    };
+  }
+  if (!keyHit) {
+    warnings.push(`${modeSource}=cloud but no API key is set (${keys.apiKeyKeys[0]}). Refusing to route to cloud; using local store. Set ${keys.apiKeyKeys[0]} to enable the cloud client.`);
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: false,
+      apiKeySource: null,
+      misconfigured: true,
+      warning: warnings.join(" ")
+    };
+  }
+  const rawUrl = urlHit?.value ?? defaultCloudBaseUrl(name);
+  const apiUrlSource = urlHit ? urlHit.key : "default";
+  let baseUrl;
+  try {
+    baseUrl = toV1BaseUrl(rawUrl);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warnings.push(`Invalid API URL from ${apiUrlSource}: ${message}. Using local store.`);
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: true,
+      apiKeySource: keyHit.key,
+      misconfigured: true,
+      warning: warnings.join(" ")
+    };
+  }
+  return {
+    transport: "cloud-http",
+    mode,
+    deprecatedAlias,
+    modeSource,
+    baseUrl,
+    apiUrlSource,
+    apiKeyPresent: true,
+    apiKeySource: keyHit.key,
+    misconfigured: false,
+    warning: warnings.length > 0 ? warnings.join(" ") : null
+  };
+}
+
+class HasnaHttpError extends Error {
+  status;
+  method;
+  path;
+  body;
+  constructor(method, path, status, body) {
+    super(`Hasna cloud request failed: ${method} ${path} -> ${status}`);
+    this.name = "HasnaHttpError";
+    this.status = status;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+  }
+}
+var DEFAULT_RETRY_STATUSES = [408, 425, 429, 500, 502, 503, 504];
+var IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+function appendQuery(path, query) {
+  if (!query)
+    return path;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams;
+  if (!(query instanceof URLSearchParams)) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === null || value === undefined)
+        continue;
+      if (Array.isArray(value)) {
+        for (const v of value)
+          params.append(key, String(v));
+      } else {
+        params.append(key, String(value));
+      }
+    }
+  }
+  const qs = params.toString();
+  if (!qs)
+    return path;
+  return `${path}${path.includes("?") ? "&" : "?"}${qs}`;
+}
+var defaultSleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
+function createHasnaHttpTransport(options) {
+  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+  const base = options.baseUrl.replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const sleep = options.sleepImpl ?? defaultSleep;
+  const defaultRetry = options.retry;
+  function resolveRetry(callRetry) {
+    const chosen = callRetry !== undefined ? callRetry : defaultRetry;
+    if (chosen === false)
+      return null;
+    const r = chosen ?? {};
+    return {
+      retries: r.retries ?? 2,
+      baseDelayMs: r.baseDelayMs ?? 200,
+      maxDelayMs: r.maxDelayMs ?? 2000,
+      retryStatuses: r.retryStatuses ?? [...DEFAULT_RETRY_STATUSES]
+    };
+  }
+  async function once2(method, rel, url, body, opts) {
+    const headers = {
+      "x-api-key": options.apiKey,
+      Authorization: `Bearer ${options.apiKey}`,
+      Accept: "application/json",
+      ...options.headers ?? {},
+      ...opts.headers ?? {}
+    };
+    if (opts.idempotencyKey)
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    const init = { method, headers };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    if (opts.signal) {
+      if (opts.signal.aborted)
+        controller.abort();
+      else
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? timeoutMs);
+    init.signal = controller.signal;
+    let response;
+    try {
+      response = await fetchImpl(url, init);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (opts.signal?.aborted)
+        return { ok: false, retryable: false, error: err };
+      return { ok: false, retryable: true, error: err };
+    } finally {
+      clearTimeout(timer);
+      if (opts.signal)
+        opts.signal.removeEventListener("abort", onAbort);
+    }
+    const text = await response.text();
+    let parsed = undefined;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!response.ok) {
+      const retry = resolveRetry(opts.retry);
+      const retryable = retry ? retry.retryStatuses.includes(response.status) : false;
+      return { ok: false, retryable, error: new HasnaHttpError(method, rel, response.status, parsed) };
+    }
+    return { ok: true, value: parsed };
+  }
+  async function request(method, path, body, opts = {}) {
+    const upper = method.toUpperCase();
+    const rel = appendQuery(path.startsWith("/") ? path : `/${path}`, opts.query);
+    const url = `${base}${rel}`;
+    const retry = resolveRetry(opts.retry);
+    const methodRetryable = IDEMPOTENT_METHODS.has(upper) || Boolean(opts.idempotencyKey);
+    const maxAttempts = retry && methodRetryable ? retry.retries + 1 : 1;
+    let last = null;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      const result = await once2(upper, rel, url, body, opts);
+      if (result.ok)
+        return result.value;
+      last = result;
+      const canRetry = retry !== null && methodRetryable && result.retryable && attempt < maxAttempts;
+      if (!canRetry)
+        break;
+      const backoff = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** (attempt - 1));
+      const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+      await sleep(backoff + jitter);
+    }
+    throw last.error;
+  }
+  return {
+    baseUrl: base,
+    request,
+    get: (path, opts) => request("GET", path, undefined, opts),
+    post: (path, body, opts) => request("POST", path, body, opts),
+    put: (path, body, opts) => request("PUT", path, body, opts),
+    patch: (path, body, opts) => request("PATCH", path, body, opts),
+    del: (path, body, opts) => request("DELETE", path, body, opts)
+  };
+}
+function createClientTransport(name, env = process.env, overrides) {
+  const resolution = resolveClientTransport(name, env);
+  if (resolution.misconfigured) {
+    throw new Error(resolution.warning ?? `Client for '${name}' is misconfigured for cloud mode.`);
+  }
+  if (resolution.transport === "local" || !resolution.baseUrl) {
+    return { transport: "local", client: null, resolution };
+  }
+  const keys = clientTransportEnvKeys(name);
+  const apiKey = firstEnv(env, keys.apiKeyKeys)?.value;
+  if (!apiKey) {
+    throw new Error(`Client for '${name}' resolved to cloud-http without an API key.`);
+  }
+  return {
+    transport: "cloud-http",
+    client: createHasnaHttpTransport({
+      name,
+      baseUrl: resolution.baseUrl,
+      apiKey,
+      ...overrides?.fetchImpl ? { fetchImpl: overrides.fetchImpl } : {},
+      ...overrides?.headers ? { headers: overrides.headers } : {},
+      ...overrides?.timeoutMs ? { timeoutMs: overrides.timeoutMs } : {},
+      ...overrides?.retry !== undefined ? { retry: overrides.retry } : {},
+      ...overrides?.sleepImpl ? { sleepImpl: overrides.sleepImpl } : {}
+    }),
+    resolution
+  };
+}
+
+// src/lib/cloud/storage.ts
+function resourcePath(resource) {
+  const trimmed = resource.replace(/^\/+|\/+$/g, "");
+  if (!trimmed)
+    throw new Error("resource must be a non-empty path segment");
+  return `/${trimmed}`;
+}
+function entityPath(resource, id) {
+  if (id === undefined || id === null || `${id}`.length === 0) {
+    throw new Error("id must be a non-empty string");
+  }
+  return `${resourcePath(resource)}/${encodeURIComponent(String(id))}`;
+}
+function newIdempotencyKey() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID)
+    return g.crypto.randomUUID();
+  return `idmp_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function extractItems(raw) {
+  if (Array.isArray(raw))
+    return raw;
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["items", "data", "results", "rows", "records"]) {
+      if (Array.isArray(obj[key]))
+        return obj[key];
+    }
+  }
+  return [];
+}
+function extractTotal(raw) {
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["total", "count", "totalCount", "total_count"]) {
+      if (typeof obj[key] === "number")
+        return obj[key];
+    }
+  }
+  return null;
+}
+function extractCursor(raw) {
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["cursor", "nextCursor", "next_cursor", "next"]) {
+      if (typeof obj[key] === "string")
+        return obj[key];
+    }
+  }
+  return null;
+}
+function createHasnaStorageClient(name, transport) {
+  return {
+    name,
+    baseUrl: transport.baseUrl,
+    transport,
+    async list(resource, options = {}) {
+      const raw = await transport.get(resourcePath(resource), options);
+      return {
+        items: extractItems(raw),
+        total: extractTotal(raw),
+        cursor: extractCursor(raw),
+        raw
+      };
+    },
+    async get(resource, id, options = {}) {
+      try {
+        return await transport.get(entityPath(resource, id), options);
+      } catch (error) {
+        if (error instanceof HasnaHttpError && error.status === 404)
+          return null;
+        throw error;
+      }
+    },
+    async create(resource, body, options = {}) {
+      const { idempotencyKey, ...rest } = options;
+      return transport.post(resourcePath(resource), body, {
+        ...rest,
+        idempotencyKey: idempotencyKey ?? newIdempotencyKey()
+      });
+    },
+    async update(resource, id, patch, options = {}) {
+      const { method = "PATCH", idempotencyKey, ...rest } = options;
+      const call = method === "PUT" ? transport.put : transport.patch;
+      return call(entityPath(resource, id), patch, { ...rest, ...idempotencyKey ? { idempotencyKey } : {} });
+    },
+    async delete(resource, id, options = {}) {
+      try {
+        await transport.del(entityPath(resource, id), undefined, options);
+      } catch (error) {
+        if (error instanceof HasnaHttpError && error.status === 404)
+          return;
+        throw error;
+      }
+    }
+  };
+}
+
+// src/lib/cloud/resolve.ts
+function firstValue(env, keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value)
+      return value;
+  }
+  return;
+}
+function resolveCloudStorage(name, env = process.env) {
+  const token = envToken(name);
+  const modeKeys = [`HASNA_${token}_STORAGE_MODE`, `HASNA_${token}_MODE`, `${token}_STORAGE_MODE`, `${token}_MODE`];
+  const apiUrlKeys = [`HASNA_${token}_API_URL`, `${token}_API_URL`];
+  const apiKeyKeys = [
+    `HASNA_${token}_API_KEY`,
+    `${token}_API_KEY`,
+    `HASNA_${token}_API_TOKEN`,
+    `${token}_API_TOKEN`
+  ];
+  const explicitMode = firstValue(env, modeKeys);
+  if (explicitMode && normalizeStorageMode(explicitMode).mode === "local") {
+    return { transport: "local", client: null };
+  }
+  const apiUrl = firstValue(env, apiUrlKeys);
+  const apiKey = firstValue(env, apiKeyKeys);
+  if (!apiUrl || !apiKey) {
+    return { transport: "local", client: null };
+  }
+  const cloudEnv = { ...env, [`HASNA_${token}_STORAGE_MODE`]: "self_hosted" };
+  const wired = createClientTransport(name, cloudEnv);
+  if (wired.transport !== "cloud-http") {
+    return { transport: "local", client: null };
+  }
+  return {
+    transport: "cloud-http",
+    client: createHasnaStorageClient(name, wired.client),
+    baseUrl: wired.client.baseUrl
+  };
+}
+
+// src/lib/store/index.ts
+class CloudUnsupportedError extends Error {
+  constructor(operation) {
+    super(`operation not supported over the hosted OpenLoops API: ${operation}. ` + `Run it on a machine using local storage, or unset HASNA_LOOPS_API_URL/HASNA_LOOPS_API_KEY.`);
+    this.name = "CloudUnsupportedError";
+  }
+}
+
+class LocalStore {
+  transport = "local";
+  store;
+  constructor(store = new Store) {
+    this.store = store;
+  }
+  get raw() {
+    return this.store;
+  }
+  async close() {
+    this.store.close();
+  }
+  async createLoop(input, from) {
+    return from ? this.store.createLoop(input, from) : this.store.createLoop(input);
+  }
+  async getLoop(id) {
+    return this.store.getLoop(id);
+  }
+  async findLoopByName(name) {
+    return this.store.findLoopByName(name);
+  }
+  async requireLoop(idOrName) {
+    return this.store.requireLoop(idOrName);
+  }
+  async requireUniqueLoop(idOrName) {
+    return this.store.requireUniqueLoop(idOrName);
+  }
+  async listLoops(opts = {}) {
+    return this.store.listLoops(opts);
+  }
+  async countLoops(status, opts = {}) {
+    return this.store.countLoops(status, opts);
+  }
+  async updateLoop(id, patch) {
+    return this.store.updateLoop(id, patch);
+  }
+  async renameLoop(id, name) {
+    return this.store.renameLoop(id, name);
+  }
+  async archiveLoop(idOrName) {
+    return this.store.archiveLoop(idOrName);
+  }
+  async unarchiveLoop(idOrName) {
+    return this.store.unarchiveLoop(idOrName);
+  }
+  async deleteLoop(idOrName) {
+    return this.store.deleteLoop(idOrName);
+  }
+  async createWorkflow(input) {
+    return this.store.createWorkflow(input);
+  }
+  async getWorkflow(id) {
+    return this.store.getWorkflow(id);
+  }
+  async findWorkflowByName(name) {
+    return this.store.findWorkflowByName(name);
+  }
+  async requireWorkflow(idOrName) {
+    return this.store.requireWorkflow(idOrName);
+  }
+  async listWorkflows(opts = {}) {
+    return this.store.listWorkflows(opts);
+  }
+  async countWorkflows(opts = {}) {
+    return this.store.countWorkflows(opts);
+  }
+  async archiveWorkflow(idOrName) {
+    return this.store.archiveWorkflow(idOrName);
+  }
+  async getWorkflowRun(id) {
+    return this.store.getWorkflowRun(id);
+  }
+  async requireWorkflowRun(id) {
+    return this.store.requireWorkflowRun(id);
+  }
+  async listWorkflowRuns(opts = {}) {
+    return this.store.listWorkflowRuns(opts);
+  }
+  async listWorkflowStepRuns(workflowRunId) {
+    return this.store.listWorkflowStepRuns(workflowRunId);
+  }
+  async listWorkflowEvents(workflowRunId, limit) {
+    return limit === undefined ? this.store.listWorkflowEvents(workflowRunId) : this.store.listWorkflowEvents(workflowRunId, limit);
+  }
+  async recoverWorkflowRun(workflowRunId, reason) {
+    return reason === undefined ? this.store.recoverWorkflowRun(workflowRunId) : this.store.recoverWorkflowRun(workflowRunId, reason);
+  }
+  async cancelWorkflowRun(workflowRunId, reason) {
+    return reason === undefined ? this.store.cancelWorkflowRun(workflowRunId) : this.store.cancelWorkflowRun(workflowRunId, reason);
+  }
+  async listWorkflowWorkItems(opts = {}) {
+    return this.store.listWorkflowWorkItems(opts);
+  }
+  async getWorkflowWorkItem(id) {
+    return this.store.getWorkflowWorkItem(id);
+  }
+  async requeueWorkflowWorkItem(id, patch = {}) {
+    return this.store.requeueWorkflowWorkItem(id, patch);
+  }
+  async listWorkflowInvocations(opts = {}) {
+    return this.store.listWorkflowInvocations(opts);
+  }
+  async getWorkflowInvocation(id) {
+    return this.store.getWorkflowInvocation(id);
+  }
+  async getGoal(id) {
+    return this.store.getGoal(id);
+  }
+  async findGoalByLoop(idOrName) {
+    return this.store.findGoalByLoop(idOrName);
+  }
+  async findGoalByRunId(id) {
+    return this.store.findGoalByRunId(id);
+  }
+  async listGoals(opts = {}) {
+    return this.store.listGoals(opts);
+  }
+  async listGoalPlanNodes(goalIdOrPlanId) {
+    return this.store.listGoalPlanNodes(goalIdOrPlanId);
+  }
+  async listGoalRuns(opts = {}) {
+    return this.store.listGoalRuns(opts);
+  }
+  async listRuns(opts = {}) {
+    return this.store.listRuns(opts);
+  }
+  async getRun(id) {
+    return this.store.getRun(id);
+  }
+  async writeRunReceipt(input) {
+    return this.store.writeRunReceipt(input);
+  }
+  async getRunReceipt(runId) {
+    return this.store.getRunReceipt(runId);
+  }
+  async listRunReceipts(opts = {}) {
+    return this.store.listRunReceipts(opts);
+  }
+  async pruneHistory(opts) {
+    return this.store.pruneHistory(opts);
+  }
+}
+function clean(query) {
+  const out = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined && value !== null && value !== "")
+      out[key] = value;
+  }
+  return out;
+}
+function pickArray(raw, key, fallback = []) {
+  if (raw && typeof raw === "object" && Array.isArray(raw[key])) {
+    return raw[key];
+  }
+  return fallback;
+}
+function pickObject(raw, key) {
+  if (raw && typeof raw === "object") {
+    const value = raw[key];
+    return value == null ? undefined : value;
+  }
+  return raw == null ? undefined : raw;
+}
+
+class ApiStore {
+  client;
+  baseUrl;
+  transport = "cloud-http";
+  constructor(client, baseUrl) {
+    this.client = client;
+    this.baseUrl = baseUrl;
+  }
+  get t() {
+    return this.client.transport;
+  }
+  async close() {}
+  async createLoop(input) {
+    return pickObject(await this.t.post("/loops", input), "loop");
+  }
+  async getLoop(id) {
+    try {
+      return pickObject(await this.t.get(`/loops/${encodeURIComponent(id)}`), "loop");
+    } catch {
+      return;
+    }
+  }
+  async findLoopByName(name) {
+    const matches = (await this.listLoops({ name, limit: 1000 })).filter((loop) => loop.name === name);
+    return matches[0];
+  }
+  async requireLoop(idOrName) {
+    const loop = await this.resolveLoop(idOrName);
+    if (!loop)
+      throw new LoopNotFoundError(idOrName);
+    return loop;
+  }
+  async requireUniqueLoop(idOrName) {
+    const byId = await this.getLoop(idOrName);
+    if (byId)
+      return byId;
+    const matches = (await this.listLoops({ name: idOrName, limit: 1000 })).filter((loop) => loop.name === idOrName);
+    if (matches.length === 0)
+      throw new LoopNotFoundError(idOrName);
+    if (matches.length === 1)
+      return matches[0];
+    const active = matches.filter((loop) => !loop.archivedAt);
+    if (active.length !== 1)
+      throw new AmbiguousNameError(idOrName);
+    return active[0];
+  }
+  async resolveLoop(idOrName) {
+    const byId = await this.getLoop(idOrName);
+    if (byId)
+      return byId;
+    const matches = (await this.listLoops({ name: idOrName, limit: 1000 })).filter((loop) => loop.name === idOrName);
+    if (matches.length === 0)
+      return;
+    if (matches.length === 1)
+      return matches[0];
+    const active = matches.filter((loop) => !loop.archivedAt);
+    if (active.length === 1)
+      return active[0];
+    throw new AmbiguousNameError(idOrName);
+  }
+  async listLoops(opts = {}) {
+    const raw = await this.t.get("/loops", { query: clean({ ...opts }) });
+    return pickArray(raw, "loops");
+  }
+  async countLoops(status, opts = {}) {
+    const raw = await this.t.get("/loops/count", { query: clean({ status, ...opts }) });
+    return Number(pickObject(raw, "count") ?? 0);
+  }
+  async updateLoop(id, patch) {
+    return pickObject(await this.t.patch(`/loops/${encodeURIComponent(id)}`, patch), "loop");
+  }
+  async renameLoop(id, name) {
+    return pickObject(await this.t.post(`/loops/${encodeURIComponent(id)}/rename`, { name }), "loop");
+  }
+  async archiveLoop(idOrName) {
+    const loop = await this.requireLoop(idOrName);
+    return pickObject(await this.t.post(`/loops/${encodeURIComponent(loop.id)}/archive`), "loop");
+  }
+  async unarchiveLoop(idOrName) {
+    const loop = await this.requireLoop(idOrName);
+    return pickObject(await this.t.post(`/loops/${encodeURIComponent(loop.id)}/unarchive`), "loop");
+  }
+  async deleteLoop(idOrName) {
+    const loop = await this.resolveLoop(idOrName);
+    if (!loop)
+      return false;
+    const raw = await this.t.request("DELETE", `/loops/${encodeURIComponent(loop.id)}`);
+    return Boolean(pickObject(raw, "deleted") ?? true);
+  }
+  async createWorkflow(input) {
+    return pickObject(await this.t.post("/workflows", input), "workflow");
+  }
+  async getWorkflow(id) {
+    try {
+      return pickObject(await this.t.get(`/workflows/${encodeURIComponent(id)}`), "workflow");
+    } catch {
+      return;
+    }
+  }
+  async findWorkflowByName(name) {
+    const matches = (await this.listWorkflows({ limit: 1000 })).filter((wf) => wf.name === name);
+    return matches[0];
+  }
+  async requireWorkflow(idOrName) {
+    const byId = await this.getWorkflow(idOrName);
+    if (byId)
+      return byId;
+    const byName = await this.findWorkflowByName(idOrName);
+    if (byName)
+      return byName;
+    throw new Error(`workflow not found: ${idOrName}`);
+  }
+  async listWorkflows(opts = {}) {
+    const raw = await this.t.get("/workflows", { query: clean({ ...opts }) });
+    return pickArray(raw, "workflows");
+  }
+  async countWorkflows(opts = {}) {
+    const raw = await this.t.get("/workflows/count", { query: clean({ ...opts }) });
+    return Number(pickObject(raw, "count") ?? 0);
+  }
+  async archiveWorkflow(idOrName) {
+    const wf = await this.requireWorkflow(idOrName);
+    return pickObject(await this.t.post(`/workflows/${encodeURIComponent(wf.id)}/archive`), "workflow");
+  }
+  async getWorkflowRun(id) {
+    try {
+      return pickObject(await this.t.get(`/workflow-runs/${encodeURIComponent(id)}`), "workflowRun");
+    } catch {
+      return;
+    }
+  }
+  async requireWorkflowRun(id) {
+    const run = await this.getWorkflowRun(id);
+    if (!run)
+      throw new Error(`workflow run not found: ${id}`);
+    return run;
+  }
+  async listWorkflowRuns(opts = {}) {
+    const raw = await this.t.get("/workflow-runs", { query: clean({ ...opts }) });
+    return pickArray(raw, "workflowRuns");
+  }
+  async listWorkflowStepRuns(workflowRunId) {
+    const raw = await this.t.get(`/workflow-runs/${encodeURIComponent(workflowRunId)}/steps`);
+    return pickArray(raw, "steps");
+  }
+  async listWorkflowEvents(workflowRunId, limit) {
+    const raw = await this.t.get(`/workflow-runs/${encodeURIComponent(workflowRunId)}/events`, { query: clean({ limit }) });
+    return pickArray(raw, "events");
+  }
+  async recoverWorkflowRun(workflowRunId, reason) {
+    const raw = await this.t.post(`/workflow-runs/${encodeURIComponent(workflowRunId)}/recover`, { reason });
+    return {
+      run: pickObject(raw, "workflowRun"),
+      recoveredSteps: pickArray(raw, "recoveredSteps")
+    };
+  }
+  async cancelWorkflowRun(_workflowRunId, _reason) {
+    throw new CloudUnsupportedError("workflows cancel");
+  }
+  async listWorkflowWorkItems(opts = {}) {
+    const raw = await this.t.get("/work-items", { query: clean({ ...opts }) });
+    return pickArray(raw, "workItems");
+  }
+  async getWorkflowWorkItem(id) {
+    try {
+      return pickObject(await this.t.get(`/work-items/${encodeURIComponent(id)}`), "workItem");
+    } catch {
+      return;
     }
-    advanceLoop(deps.store, loop, skipped, now, true, advanceOptions(deps));
-    deps.onRun?.(skipped);
-    return skipped;
   }
-  let claim;
-  try {
-    claim = deps.store.claimRun(loop, scheduledFor, deps.runnerId, now, { daemonLeaseId: deps.daemonLeaseId });
-  } catch (error) {
-    if (deps.daemonLeaseId && isDaemonLeaseLost(error))
-      return;
-    throw error;
+  async requeueWorkflowWorkItem(_id, _patch = {}) {
+    throw new CloudUnsupportedError("routes requeue");
   }
-  if (!claim) {
-    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
-    return;
+  async listWorkflowInvocations(opts = {}) {
+    const raw = await this.t.get("/invocations", { query: clean({ ...opts }) });
+    return pickArray(raw, "invocations");
   }
-  deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
-  deps.onRun?.(claim.run);
-  const finalRun = await executeClaimedRun({
-    store: deps.store,
-    runnerId: deps.runnerId,
-    loop: claim.loop,
-    run: claim.run,
-    now: deps.now,
-    execute: deps.execute,
-    beforeFinalize: deps.beforeFinalize,
-    daemonLeaseId: deps.daemonLeaseId,
-    onError: deps.onError
-  });
-  advanceLoop(deps.store, claim.loop, finalRun, new Date(finalRun.finishedAt ?? new Date), finalRun.status === "succeeded", advanceOptions(deps));
-  deps.onRun?.(finalRun);
-  return finalRun;
-}
-function claimSlot(deps, loop, scheduledFor) {
-  const now = deps.now?.() ?? new Date;
-  deps.beforeRun?.(loop, scheduledFor);
-  if (loop.overlap === "skip" && deps.store.hasRunningRun(loop.id)) {
-    if (deps.store.hasRunningRunForSlot(loop.id, scheduledFor))
+  async getWorkflowInvocation(id) {
+    try {
+      return pickObject(await this.t.get(`/invocations/${encodeURIComponent(id)}`), "invocation");
+    } catch {
       return;
-    let skipped;
+    }
+  }
+  async getGoal(id) {
     try {
-      skipped = deps.store.createSkippedRun(loop, scheduledFor, "previous run still active", {
-        daemonLeaseId: deps.daemonLeaseId
-      });
-    } catch (error) {
-      if (deps.daemonLeaseId && isDaemonLeaseLost(error))
-        return;
-      throw error;
+      return pickObject(await this.t.get(`/goals/${encodeURIComponent(id)}`), "goal");
+    } catch {
+      return;
     }
-    advanceLoop(deps.store, loop, skipped, now, true, advanceOptions(deps));
-    deps.onRun?.(skipped);
-    return skipped;
   }
-  let claim;
-  try {
-    claim = deps.store.claimRun(loop, scheduledFor, deps.runnerId, now, { daemonLeaseId: deps.daemonLeaseId });
-  } catch (error) {
-    if (deps.daemonLeaseId && isDaemonLeaseLost(error))
+  async findGoalByLoop(idOrName) {
+    try {
+      return pickObject(await this.t.get("/goals", { query: clean({ loop: idOrName }) }), "goal");
+    } catch {
       return;
-    throw error;
+    }
   }
-  if (!claim) {
-    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
-    return;
+  async findGoalByRunId(id) {
+    try {
+      return pickObject(await this.t.get("/goals", { query: clean({ runId: id }) }), "goal");
+    } catch {
+      return;
+    }
   }
-  deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
-  deps.onRun?.(claim.run);
-  return claim;
-}
-function recoverAndExpire(deps, now) {
-  const recovered = deps.store.recoverExpiredRunLeases(now, { daemonLeaseId: deps.daemonLeaseId });
-  const recoveredByLoop = new Map;
-  for (const run of recovered) {
-    recoveredByLoop.set(run.loopId, [...recoveredByLoop.get(run.loopId) ?? [], run]);
+  async listGoals(opts = {}) {
+    const raw = await this.t.get("/goals", { query: clean({ ...opts }) });
+    return pickArray(raw, "goals");
   }
-  for (const runs of recoveredByLoop.values()) {
-    const loop = deps.store.getLoop(runs[0].loopId);
-    if (!loop)
-      continue;
-    const retryable = runs.filter((run) => run.attempt < loop.maxAttempts).sort((a, b) => new Date(a.scheduledFor).getTime() - new Date(b.scheduledFor).getTime())[0];
-    if (retryable) {
-      advanceLoop(deps.store, loop, retryable, new Date(retryable.finishedAt ?? now), false, advanceOptions(deps));
-      continue;
-    }
-    for (const run of runs) {
-      const current = deps.store.getLoop(run.loopId);
-      if (current) {
-        advanceLoop(deps.store, current, run, new Date(run.finishedAt ?? now), false, advanceOptions(deps));
-      }
-    }
+  async listGoalPlanNodes(goalIdOrPlanId) {
+    const raw = await this.t.get(`/goals/${encodeURIComponent(goalIdOrPlanId)}/plan-nodes`);
+    return pickArray(raw, "nodes");
   }
-  const expired = deps.store.expireLoops(now, { daemonLeaseId: deps.daemonLeaseId });
-  return { recovered, expired };
-}
-function claimDueRuns(deps) {
-  const now = deps.now?.() ?? new Date;
-  const { recovered, expired } = recoverAndExpire(deps, now);
-  const claims = [];
-  const claimed = [];
-  const skipped = [];
-  const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
-  if (maxClaims === 0)
-    return { claims, claimed, completed: [], skipped, recovered, expired };
-  const laneLimits = deps.laneLimits;
-  const laneClaims = { command: 0, agent: 0 };
-  const laneCap = (lane) => laneLimits === undefined ? Number.POSITIVE_INFINITY : Math.max(0, laneLimits[lane] ?? Number.POSITIVE_INFINITY);
-  const laneFull = (lane) => laneClaims[lane] >= laneCap(lane);
-  for (const loop of deps.store.dueLoops(now)) {
-    if (claims.length >= maxClaims)
-      break;
-    const lane = loopLane(loop);
-    if (laneFull(lane))
-      continue;
-    const plan = dueSlots(loop, now);
-    let loopSkips = 0;
-    for (const slot of plan.slots) {
-      if (claims.length >= maxClaims)
-        break;
-      if (laneFull(lane))
-        break;
-      if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
-        break;
-      const run = claimSlot(deps, loop, slot);
-      if (!run)
-        continue;
-      if ("loop" in run) {
-        claims.push(run);
-        claimed.push(run.run);
-        laneClaims[lane] += 1;
-      } else if (run.status === "skipped") {
-        skipped.push(run);
-        loopSkips += 1;
-      }
+  async listGoalRuns(opts = {}) {
+    const raw = await this.t.get("/goal-runs", { query: clean({ ...opts }) });
+    return pickArray(raw, "goalRuns");
+  }
+  async listRuns(opts = {}) {
+    const raw = await this.t.get("/runs", { query: clean({ ...opts, showOutput: true }) });
+    return pickArray(raw, "runs");
+  }
+  async getRun(id) {
+    try {
+      return pickObject(await this.t.get(`/runs/${encodeURIComponent(id)}`, { query: { showOutput: true } }), "run");
+    } catch {
+      return;
     }
   }
-  return { claims, claimed, completed: [], skipped, recovered, expired };
-}
-async function tick(deps) {
-  const now = deps.now?.() ?? new Date;
-  const { recovered, expired } = recoverAndExpire(deps, now);
-  const claimed = [];
-  const completed = [];
-  const skipped = [];
-  for (const loop of deps.store.dueLoops(now)) {
-    const plan = dueSlots(loop, now);
-    let loopSkips = 0;
-    for (const slot of plan.slots) {
-      if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
-        break;
-      const run = await runSlot(deps, loop, slot);
-      if (!run)
-        continue;
-      if (run.status === "running")
-        claimed.push(run);
-      else if (run.status === "skipped") {
-        skipped.push(run);
-        loopSkips += 1;
-      } else
-        completed.push(run);
-      if (["failed", "timed_out", "abandoned"].includes(run.status) && run.attempt < loop.maxAttempts)
-        break;
+  async writeRunReceipt(input) {
+    return pickObject(await this.t.post("/receipts", input), "receipt");
+  }
+  async getRunReceipt(runId) {
+    try {
+      return pickObject(await this.t.get(`/receipts/${encodeURIComponent(runId)}`), "receipt");
+    } catch {
+      return;
     }
   }
-  return { claimed, completed, skipped, recovered, expired };
+  async listRunReceipts(opts = {}) {
+    const raw = await this.t.get("/receipts", { query: clean({ ...opts }) });
+    return pickArray(raw, "receipts");
+  }
+  async pruneHistory(opts) {
+    const raw = await this.t.post("/history/prune", {
+      maxAgeDays: opts.maxAgeDays,
+      keepPerLoop: opts.keepPerLoop,
+      dryRun: opts.dryRun
+    });
+    return pickObject(raw, "history");
+  }
+}
+function getStore(env = process.env) {
+  const resolution = resolveCloudStorage("loops", env);
+  if (resolution.transport === "cloud-http")
+    return new ApiStore(resolution.client, resolution.baseUrl);
+  return new LocalStore;
+}
+function isCloudStore(env = process.env) {
+  return resolveCloudStorage("loops", env).transport === "cloud-http";
 }
 
 // src/mcp/index.ts
@@ -7862,6 +9971,34 @@ var loopIdOrNameSchema = z2.string().min(1).describe("Loop id or exact loop name
 var workflowIdOrNameSchema = z2.string().min(1).describe("Workflow id or exact workflow name.");
 var showOutputSchema = z2.boolean().optional().describe("Include raw stdout/stderr (default false: only redacted lengths are returned).");
 var limitSchema = z2.number().int().min(1).max(MAX_LIMIT).optional().describe(`Maximum entries to return (1-${MAX_LIMIT}).`);
+var runReceiptSummarySchema = z2.object({
+  text: z2.string().optional().describe("Short human summary. It is scrubbed and bounded before storage."),
+  stdout_bytes: z2.number().int().min(0).optional().describe("Original stdout byte count."),
+  stderr_bytes: z2.number().int().min(0).optional().describe("Original stderr byte count."),
+  stdout_excerpt: z2.string().optional().describe("Bounded stdout excerpt. Raw unbounded stdout is never required."),
+  stderr_excerpt: z2.string().optional().describe("Bounded stderr excerpt. Raw unbounded stderr is never required."),
+  error: z2.string().optional().describe("Bounded error excerpt."),
+  duration_ms: z2.number().int().min(0).optional().describe("Run duration in milliseconds.")
+});
+var runReceiptInputSchema = {
+  loop_id: z2.string().min(1).optional().describe("OpenLoops loop id. Optional when run_id references an existing loop run."),
+  run_id: z2.string().min(1).describe("Scheduler-neutral run id. Existing values are updated idempotently."),
+  machine: z2.union([z2.string().min(1), z2.record(z2.string(), z2.unknown())]).optional().describe("Machine id/name or machine metadata object."),
+  repo: z2.string().min(1).optional().describe("Repository path or owner/repo string. Defaults from the loop target cwd when possible."),
+  task_ids: z2.array(z2.string().min(1)).optional().describe("Task ids associated with this run."),
+  knowledge_ids: z2.array(z2.string().min(1)).optional().describe("Knowledge record ids associated with this run."),
+  digest_id: z2.string().min(1).optional().describe("Stable digest id. Computed from normalized receipt content when omitted."),
+  started_at: z2.string().nullable().optional().describe("Run start timestamp."),
+  finished_at: z2.string().nullable().optional().describe("Run finish timestamp."),
+  status: z2.string().min(1).optional().describe("Run status."),
+  exit_code: z2.number().int().nullable().optional().describe("Process exit code."),
+  summary: z2.union([z2.string(), runReceiptSummarySchema]).nullable().optional().describe("Bounded structured summary; may be a string shorthand."),
+  evidence_paths: z2.array(z2.string().min(1)).optional().describe("Bounded paths to durable evidence artifacts."),
+  stdout: z2.string().optional().describe("Optional raw stdout to summarize and bound before storage."),
+  stderr: z2.string().optional().describe("Optional raw stderr to summarize and bound before storage."),
+  error: z2.string().optional().describe("Optional raw error text to summarize and bound before storage."),
+  duration_ms: z2.number().int().min(0).optional().describe("Run duration in milliseconds.")
+};
 var optionalTimeoutSchema = z2.number().int().positive().nullable().optional().describe("Per-run timeout in milliseconds; null disables the timeout.");
 var catchUpSchema = z2.enum(CATCH_UP_POLICIES).optional().describe("Missed-slot policy after downtime: none skips them, latest replays the newest slot, all replays every slot.");
 var overlapSchema = z2.enum(OVERLAP_POLICIES).optional().describe("Behavior when a slot comes due while a previous run is active: skip records a skipped run, allow runs concurrently.");
@@ -7931,6 +10068,17 @@ function errorResult(error) {
   };
 }
 async function withStore(fn) {
+  const store = getStore();
+  try {
+    return await fn(store);
+  } finally {
+    await store.close();
+  }
+}
+async function withLocalStore(operation, fn) {
+  if (isCloudStore()) {
+    throw new Error(`'${operation}' inspects this machine's local OpenLoops runtime and is not available while flipped to the hosted OpenLoops API. ` + `Unset HASNA_LOOPS_API_URL/HASNA_LOOPS_API_KEY (or set HASNA_LOOPS_STORAGE_MODE=local) to run it here.`);
+  }
   const store = new Store;
   try {
     return await fn(store);
@@ -7944,7 +10092,7 @@ function requireMutationsEnabled() {
     throw new Error(`MCP mutation tools require ${MUTATION_ENV}=true`);
   }
 }
-function nonEmpty(value, label) {
+function nonEmpty2(value, label) {
   const trimmed = value.trim();
   if (!trimmed)
     throw new Error(`${label} must be non-empty`);
@@ -7962,7 +10110,7 @@ function normalizeSchedule(input) {
   if (input.type === "interval")
     return { type: "interval", everyMs: input.everyMs, anchor: input.anchor ?? "fixed_rate" };
   if (input.type === "cron")
-    return { type: "cron", expression: nonEmpty(input.expression, "schedule.expression") };
+    return { type: "cron", expression: nonEmpty2(input.expression, "schedule.expression") };
   return { type: "dynamic", minIntervalMs: input.minIntervalMs };
 }
 function durationLabel(ms) {
@@ -8005,7 +10153,7 @@ function defaultLoopDescription(name, schedule, target) {
   ].join(" ");
 }
 function commonCreateInput(input) {
-  const name = nonEmpty(input.name, "name");
+  const name = nonEmpty2(input.name, "name");
   const schedule = normalizeSchedule(input.schedule);
   return {
     name,
@@ -8061,13 +10209,13 @@ var TOOL_REGISTRATIONS = [
       includeArchived: z2.boolean().optional().describe("Include archived loops alongside live ones (default false)."),
       archivedOnly: z2.boolean().optional().describe("Return only archived loops (default false).")
     },
-    handler: ({ status, limit, includeArchived, archivedOnly }) => withStore((store) => ({
-      loops: store.listLoops({
+    handler: ({ status, limit, includeArchived, archivedOnly }) => withStore(async (store) => ({
+      loops: (await store.listLoops({
         status: filteredLoopStatus(status),
         limit,
         includeArchived: includeArchived ?? false,
         archived: archivedOnly ?? false
-      }).map(publicLoop)
+      })).map(publicLoop)
     }))
   },
   {
@@ -8080,9 +10228,9 @@ var TOOL_REGISTRATIONS = [
       includeLatestRun: z2.boolean().optional().describe("Include the most recent run record (default false)."),
       showOutput: showOutputSchema
     },
-    handler: ({ idOrName, includeLatestRun, showOutput }) => withStore((store) => {
-      const loop = store.requireLoop(idOrName);
-      const latestRun = includeLatestRun ? store.listRuns({ loopId: loop.id, limit: 1 })[0] : undefined;
+    handler: ({ idOrName, includeLatestRun, showOutput }) => withStore(async (store) => {
+      const loop = await store.requireLoop(idOrName);
+      const latestRun = includeLatestRun ? (await store.listRuns({ loopId: loop.id, limit: 1 }))[0] : undefined;
       return {
         loop: publicLoop(loop),
         latestRun: latestRun ? publicRun(latestRun, showOutput ?? false) : undefined
@@ -8101,23 +10249,67 @@ var TOOL_REGISTRATIONS = [
       limit: limitSchema,
       showOutput: showOutputSchema
     },
-    handler: ({ idOrName, status, limit, showOutput }) => withStore((store) => {
-      const loop = idOrName ? store.requireLoop(idOrName) : undefined;
-      const runs = store.listRuns({
+    handler: ({ idOrName, status, limit, showOutput }) => withStore(async (store) => {
+      const loop = idOrName ? await store.requireLoop(idOrName) : undefined;
+      const runs = (await store.listRuns({
         loopId: loop?.id,
         status,
         limit
-      }).map((run) => publicRun(run, showOutput ?? false));
+      })).map((run) => publicRun(run, showOutput ?? false));
       return { loop: loop ? publicLoop(loop) : undefined, runs };
     })
   },
+  {
+    name: "loops_receipts_list",
+    description: "List scheduler-neutral run receipts with bounded summaries and evidence paths.",
+    readOnly: true,
+    annotations: READ_ONLY_ANNOTATIONS,
+    inputSchema: {
+      loop_id: z2.string().min(1).optional().describe("Filter by loop_id."),
+      repo: z2.string().min(1).optional().describe("Filter by repo."),
+      task_id: z2.string().min(1).optional().describe("Filter by task id."),
+      knowledge_id: z2.string().min(1).optional().describe("Filter by knowledge id."),
+      status: z2.string().min(1).optional().describe("Filter by receipt status."),
+      limit: limitSchema
+    },
+    handler: ({ loop_id, repo, task_id, knowledge_id, status, limit }) => withStore(async (store) => ({
+      receipts: (await store.listRunReceipts({ loopId: loop_id, repo, taskId: task_id, knowledgeId: knowledge_id, status, limit })).map(publicRunReceipt)
+    }))
+  },
+  {
+    name: "loops_receipt_read",
+    description: "Read one scheduler-neutral run receipt by run id.",
+    readOnly: true,
+    annotations: READ_ONLY_ANNOTATIONS,
+    inputSchema: {
+      run_id: z2.string().min(1).describe("Run id.")
+    },
+    handler: ({ run_id }) => withStore(async (store) => {
+      const receipt = await store.getRunReceipt(run_id);
+      if (!receipt)
+        throw new Error(`run receipt not found: ${run_id}`);
+      return { receipt: publicRunReceipt(receipt) };
+    })
+  },
+  {
+    name: "loops_receipt_write",
+    description: `Write a scheduler-neutral run receipt. Requires ${MUTATION_ENV}=true on the MCP server process.`,
+    readOnly: false,
+    guarded: true,
+    annotations: mutationAnnotations({ idempotent: true }),
+    inputSchema: runReceiptInputSchema,
+    handler: (input) => {
+      requireMutationsEnabled();
+      return withStore(async (store) => ({ receipt: publicRunReceipt(await store.writeRunReceipt(input)) }));
+    }
+  },
   {
     name: "loops_doctor",
     description: "Run OpenLoops runtime diagnostics.",
     readOnly: true,
     annotations: READ_ONLY_ANNOTATIONS,
     inputSchema: {},
-    handler: () => withStore((store) => runDoctor(store))
+    handler: () => withLocalStore("loops_doctor", (store) => runDoctor(store))
   },
   {
     name: "loops_health",
@@ -8129,7 +10321,33 @@ var TOOL_REGISTRATIONS = [
       includeInactive: z2.boolean().optional().describe("Include stopped/expired loops (default false: active and paused only)."),
       limit: limitSchema
     },
-    handler: ({ includeArchived, includeInactive, limit }) => withStore((store) => buildHealthReport(store, { includeArchived, includeInactive, limit }))
+    handler: ({ includeArchived, includeInactive, limit }) => withLocalStore("loops_health", (store) => buildHealthReport(store, { includeArchived, includeInactive, limit }))
+  },
+  {
+    name: "loops_health_scan",
+    description: "Build a read-only OpenLoops health scan with bounded daemon, doctor/preflight, latest-run, and stale-running findings.",
+    readOnly: true,
+    annotations: READ_ONLY_ANNOTATIONS,
+    inputSchema: {
+      includeStatuses: z2.array(z2.enum(LOOP_STATUSES)).optional().describe("Loop statuses to inventory (default active and paused)."),
+      includeArchived: z2.boolean().optional().describe("Include archived loops in the scan (default false)."),
+      latestRun: z2.boolean().optional().describe("Include latest-run and stale-running checks (default true)."),
+      doctor: z2.boolean().optional().describe("Include doctor/preflight checks (default false)."),
+      daemon: z2.boolean().optional().describe("Include daemon status checks (default false)."),
+      staleRunningMs: z2.number().int().positive().optional().describe("Minimum age before a running latest run is stale; loop lease and 10m still apply."),
+      maxFindings: z2.number().int().min(0).max(MAX_LIMIT).optional().describe(`Maximum findings to return (0-${MAX_LIMIT}, default 100).`),
+      limit: limitSchema
+    },
+    handler: ({ includeStatuses, includeArchived, latestRun, doctor, daemon, staleRunningMs, maxFindings, limit }) => withLocalStore("loops_health_scan", (store) => buildHealthScan(store, {
+      includeStatuses,
+      includeArchived,
+      latestRun,
+      doctor: doctor ? runDoctor(store) : undefined,
+      daemon: daemon ? daemonStatus(store) : undefined,
+      staleRunningMs,
+      maxFindings,
+      limit
+    }))
   },
   {
     name: "loops_diagnose",
@@ -8142,7 +10360,7 @@ var TOOL_REGISTRATIONS = [
       runLimit: z2.number().int().min(1).max(50).optional().describe("How many recent runs to classify (1-50, default 5)."),
       showOutput: showOutputSchema
     },
-    handler: ({ idOrName, runLimit, showOutput }) => withStore((store) => {
+    handler: ({ idOrName, runLimit, showOutput }) => withLocalStore("loops_diagnose", (store) => {
       const loop = store.requireLoop(idOrName);
       const runs = store.listRuns({ loopId: loop.id, limit: runLimit ?? 5 });
       return {
@@ -8162,7 +10380,7 @@ var TOOL_REGISTRATIONS = [
     readOnly: true,
     annotations: READ_ONLY_ANNOTATIONS,
     inputSchema: {},
-    handler: () => withStore((store) => daemonStatus(store))
+    handler: () => withLocalStore("loops_daemon_status", (store) => daemonStatus(store))
   },
   {
     name: "loops_workflows_list",
@@ -8175,12 +10393,12 @@ var TOOL_REGISTRATIONS = [
       limit: limitSchema,
       offset: z2.number().int().min(0).optional().describe("Entries to skip before returning results (pagination).")
     },
-    handler: ({ status, limit, offset }) => withStore((store) => ({
-      workflows: store.listWorkflows({
+    handler: ({ status, limit, offset }) => withStore(async (store) => ({
+      workflows: (await store.listWorkflows({
         status: filteredWorkflowStatus(status),
         limit,
         offset
-      }).map(publicWorkflow)
+      })).map(publicWorkflow)
     }))
   },
   {
@@ -8196,16 +10414,16 @@ var TOOL_REGISTRATIONS = [
       runLimit: limitSchema,
       showOutput: showOutputSchema
     },
-    handler: ({ idOrName, includeRuns, includeEvents, runLimit, showOutput }) => withStore((store) => {
-      const workflow = store.requireWorkflow(idOrName);
-      const runs = includeRuns ? store.listWorkflowRuns({ workflowId: workflow.id, limit: runLimit ?? 20 }) : [];
+    handler: ({ idOrName, includeRuns, includeEvents, runLimit, showOutput }) => withStore(async (store) => {
+      const workflow = await store.requireWorkflow(idOrName);
+      const runs = includeRuns ? await store.listWorkflowRuns({ workflowId: workflow.id, limit: runLimit ?? 20 }) : [];
       return {
         workflow: publicWorkflow(workflow),
-        runs: runs.map((run) => ({
+        runs: await Promise.all(runs.map(async (run) => ({
           ...publicWorkflowRun(run),
-          steps: store.listWorkflowStepRuns(run.id).map((step) => publicWorkflowStepRun(step, showOutput ?? false)),
-          events: includeEvents ? store.listWorkflowEvents(run.id).map(publicWorkflowEvent) : undefined
-        }))
+          steps: (await store.listWorkflowStepRuns(run.id)).map((step) => publicWorkflowStepRun(step, showOutput ?? false)),
+          events: includeEvents ? (await store.listWorkflowEvents(run.id)).map(publicWorkflowEvent) : undefined
+        })))
       };
     })
   },
@@ -8247,14 +10465,14 @@ var TOOL_REGISTRATIONS = [
       includeEvents: z2.boolean().optional().describe("Include the workflow event log (default true)."),
       showOutput: showOutputSchema
     },
-    handler: ({ runId, includeEvents, showOutput }) => withStore((store) => {
-      const run = store.getWorkflowRun(runId);
+    handler: ({ runId, includeEvents, showOutput }) => withStore(async (store) => {
+      const run = await store.getWorkflowRun(runId);
       if (!run)
         throw new Error(`workflow run not found: ${runId}`);
       return {
         run: publicWorkflowRun(run),
-        steps: store.listWorkflowStepRuns(run.id).map((step) => publicWorkflowStepRun(step, showOutput ?? false)),
-        events: includeEvents ?? true ? store.listWorkflowEvents(run.id).map(publicWorkflowEvent) : undefined
+        steps: (await store.listWorkflowStepRuns(run.id)).map((step) => publicWorkflowStepRun(step, showOutput ?? false)),
+        events: includeEvents ?? true ? (await store.listWorkflowEvents(run.id)).map(publicWorkflowEvent) : undefined
       };
     })
   },
@@ -8266,7 +10484,12 @@ var TOOL_REGISTRATIONS = [
     guarded: true,
     annotations: mutationAnnotations({ idempotent: true }),
     inputSchema: { idOrName: loopIdOrNameSchema },
-    handler: ({ idOrName }) => withStore((store) => ({ loop: publicLoop(store.updateLoop(store.requireUniqueLoop(idOrName).id, { status: "paused" })) }))
+    handler: ({ idOrName }) => withStore(async (store) => {
+      const loop = await store.requireUniqueLoop(idOrName);
+      if (loop.archivedAt)
+        throw new LoopArchivedError(idOrName);
+      return { loop: publicLoop(await store.updateLoop(loop.id, { status: "paused" })) };
+    })
   },
   {
     name: "loops_resume",
@@ -8276,14 +10499,16 @@ var TOOL_REGISTRATIONS = [
     guarded: true,
     annotations: mutationAnnotations({ idempotent: true }),
     inputSchema: { idOrName: loopIdOrNameSchema },
-    handler: ({ idOrName }) => withStore((store) => {
-      const loop = store.requireUniqueLoop(idOrName);
+    handler: ({ idOrName }) => withStore(async (store) => {
+      const loop = await store.requireUniqueLoop(idOrName);
+      if (loop.archivedAt)
+        throw new LoopArchivedError(idOrName);
       let nextRunAt = loop.nextRunAt;
       if (!nextRunAt) {
         const now = new Date;
         nextRunAt = computeNextAfter(loop.schedule, now, now);
       }
-      return { loop: publicLoop(store.updateLoop(loop.id, { status: "active", nextRunAt })) };
+      return { loop: publicLoop(await store.updateLoop(loop.id, { status: "active", nextRunAt })) };
     })
   },
   {
@@ -8294,9 +10519,12 @@ var TOOL_REGISTRATIONS = [
     guarded: true,
     annotations: mutationAnnotations({ idempotent: true }),
     inputSchema: { idOrName: loopIdOrNameSchema },
-    handler: ({ idOrName }) => withStore((store) => ({
-      loop: publicLoop(store.updateLoop(store.requireUniqueLoop(idOrName).id, { status: "stopped", nextRunAt: undefined }))
-    }))
+    handler: ({ idOrName }) => withStore(async (store) => {
+      const loop = await store.requireUniqueLoop(idOrName);
+      if (loop.archivedAt)
+        throw new LoopArchivedError(idOrName);
+      return { loop: publicLoop(await store.updateLoop(loop.id, { status: "stopped", nextRunAt: undefined })) };
+    })
   },
   {
     name: "loops_run_now",
@@ -8307,8 +10535,22 @@ var TOOL_REGISTRATIONS = [
     annotations: mutationAnnotations(),
     inputSchema: { idOrName: loopIdOrNameSchema },
     handler: ({ idOrName }) => withStore(async (store) => {
-      const daemon = daemonStatus(store);
-      const result = await runLoopNow({ store, idOrName: store.requireUniqueLoop(idOrName).id, runnerId: `mcp:${process.pid}`, mode: "schedule" });
+      if (store.transport === "cloud-http") {
+        const loop = await store.requireUniqueLoop(idOrName);
+        if (loop.archivedAt)
+          throw new LoopArchivedError(idOrName);
+        const now = new Date().toISOString();
+        const updated = await store.updateLoop(loop.id, { status: "active", nextRunAt: now });
+        return {
+          scheduledFor: now,
+          loop: publicLoop(updated),
+          daemon: undefined,
+          warning: "loops is flipped to self_hosted: the loop is marked due on the hosted control plane; a self-hosted runner must execute it."
+        };
+      }
+      const raw = store.raw;
+      const daemon = daemonStatus(raw);
+      const result = await runLoopNow({ store: raw, idOrName: raw.requireUniqueLoop(idOrName).id, runnerId: `mcp:${process.pid}`, mode: "schedule" });
       return {
         scheduledFor: result.scheduledFor,
         loop: publicLoop(result.loop),
@@ -8324,7 +10566,7 @@ var TOOL_REGISTRATIONS = [
     guarded: true,
     annotations: mutationAnnotations({ idempotent: true }),
     inputSchema: { idOrName: loopIdOrNameSchema },
-    handler: ({ idOrName }) => withStore((store) => ({ loop: publicLoop(store.archiveLoop(idOrName)) }))
+    handler: ({ idOrName }) => withStore(async (store) => ({ loop: publicLoop(await store.archiveLoop(idOrName)) }))
   },
   {
     name: "loops_unarchive",
@@ -8333,7 +10575,7 @@ var TOOL_REGISTRATIONS = [
     guarded: true,
     annotations: mutationAnnotations({ idempotent: true }),
     inputSchema: { idOrName: loopIdOrNameSchema },
-    handler: ({ idOrName }) => withStore((store) => ({ loop: publicLoop(store.unarchiveLoop(idOrName)) }))
+    handler: ({ idOrName }) => withStore(async (store) => ({ loop: publicLoop(await store.unarchiveLoop(idOrName)) }))
   },
   {
     name: "loops_create_command",
@@ -8349,21 +10591,21 @@ var TOOL_REGISTRATIONS = [
       cwd: z2.string().optional().describe("Working directory for the command."),
       shell: z2.never().optional().describe("Not supported over MCP: shell execution is rejected. Use 'command' plus 'args' instead.")
     },
-    handler: (input) => withStore((store) => {
+    handler: (input) => {
       const timeoutMs = input.timeoutMs;
-      const loop = store.createLoop(commonCreateInput({
+      const createInput = commonCreateInput({
         ...input,
         target: {
           type: "command",
-          command: nonEmpty(input.command, "command"),
+          command: nonEmpty2(input.command, "command"),
           args: input.args,
           cwd: input.cwd,
           shell: false,
           timeoutMs
         }
-      }));
-      return { loop: publicLoop(loop) };
-    })
+      });
+      return withStore(async (store) => ({ loop: publicLoop(await store.createLoop(createInput)) }));
+    }
   },
   {
     name: "loops_create_workflow",
@@ -8377,20 +10619,17 @@ var TOOL_REGISTRATIONS = [
       workflow: workflowIdOrNameSchema,
       workflowInput: z2.record(z2.string(), z2.string()).optional().describe("String key/value input passed to the workflow on each run.")
     },
-    handler: (input) => withStore((store) => {
-      const workflow = store.requireWorkflow(input.workflow);
+    handler: (input) => {
       const timeoutMs = input.timeoutMs;
-      const loop = store.createLoop(commonCreateInput({
-        ...input,
-        target: {
-          type: "workflow",
-          workflowId: workflow.id,
-          input: input.workflowInput,
-          timeoutMs
-        }
-      }));
-      return { workflow: publicWorkflow(workflow), loop: publicLoop(loop) };
-    })
+      return withStore(async (store) => {
+        const wf = await store.requireWorkflow(input.workflow);
+        const createInput = commonCreateInput({
+          ...input,
+          target: { type: "workflow", workflowId: wf.id, input: input.workflowInput, timeoutMs }
+        });
+        return { workflow: publicWorkflow(wf), loop: publicLoop(await store.createLoop(createInput)) };
+      });
+    }
   }
 ];
 function toolDescription(tool) {
@@ -8467,8 +10706,20 @@ async function main() {
     console.log(JSON.stringify(listToolsForCli(), null, 2));
     return;
   }
-  const server = createLoopsMcpServer();
-  await server.connect(new StdioServerTransport);
+  if (isStdioMode()) {
+    const server = createLoopsMcpServer();
+    await server.connect(new StdioServerTransport);
+    return;
+  }
+  const handle = await startMcpHttpServer(() => createLoopsMcpServer(), {
+    port: resolveMcpHttpPort()
+  });
+  process.on("SIGINT", () => {
+    handle.close().finally(() => process.exit(0));
+  });
+  process.on("SIGTERM", () => {
+    handle.close().finally(() => process.exit(0));
+  });
 }
 if (import.meta.main) {
   main().catch((error) => {