@hasna/loops 0.4.14 → 0.4.23

package/dist/index.js

@@ -1202,6 +1202,175 @@ 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";
@@ -1273,6 +1442,9 @@ function publicRun(run, showOutput = false, opts = {}) {
     error: opts.redactError ? redact(run.error) : run.error
   };
 }
+function publicRunReceipt(receipt) {
+  return { ...receipt };
+}
 function publicExecutorResult(result, showOutput = false) {
   return {
     ...result,
@@ -1396,7 +1568,7 @@ function todosMutationSummary(result) {
 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"]);
@@ -1452,6 +1624,25 @@ 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;
 }
@@ -1515,6 +1706,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,
@@ -1672,6 +1864,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;
@@ -1686,6 +1879,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))
@@ -1803,6 +2032,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)");
+        }
       }
     ];
   }
@@ -1864,6 +2104,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,
@@ -1950,6 +2212,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,
@@ -1968,10 +2231,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.
@@ -2082,6 +2345,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))
@@ -2193,19 +2481,24 @@ 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);
+      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));
   }
@@ -2883,10 +3176,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,
@@ -2895,6 +3188,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
@@ -2937,6 +3234,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,
@@ -3446,7 +3744,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,
@@ -3777,7 +4075,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);
@@ -4100,18 +4398,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();
@@ -4270,6 +4643,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;
@@ -4594,7 +4970,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.14",
+  version: "0.4.23",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4704,7 +5080,6 @@ var package_default = {
     bun: ">=1.0.0"
   },
   dependencies: {
-    "@hasna/contracts": "^0.4.1",
     "@hasna/events": "^0.1.9",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@openrouter/ai-sdk-provider": "2.9.1",
@@ -4714,7 +5089,8 @@ var package_default = {
     zod: "4.4.3"
   },
   optionalDependencies: {
-    "@hasna/machines": "0.0.49"
+    "@hasna/machines": "0.0.49",
+    "@hasna/contracts": "^0.4.2"
   },
   devDependencies: {
     "@types/bun": "latest",
@@ -4927,12 +5303,12 @@ function deploymentStatusLine(status) {
 }
 
 // src/lib/storage/postgres-schema.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var POSTGRES_MIGRATION_LEDGER_TABLE = "open_loops_schema_migrations";
 function checksumStorageSql(sql) {
   const normalized = sql.trim().replace(/\r\n/g, `
 `);
-  return `sha256:${createHash2("sha256").update(normalized).digest("hex")}`;
+  return `sha256:${createHash3("sha256").update(normalized).digest("hex")}`;
 }
 function migration(id, sql) {
   return Object.freeze({ id, sql: sql.trim(), checksum: checksumStorageSql(sql) });
@@ -5250,6 +5626,35 @@ CREATE INDEX IF NOT EXISTS idx_audit_events_action ON audit_events(action, creat
   migration("0004_work_item_route_scope", `
 ALTER TABLE workflow_work_items ADD COLUMN IF NOT EXISTS route_scope TEXT;
 CREATE INDEX IF NOT EXISTS idx_workflow_work_items_scope ON workflow_work_items(route_scope, status);
+    `),
+  migration("0005_run_receipts", `
+CREATE TABLE IF NOT EXISTS run_receipts (
+  run_id TEXT PRIMARY KEY,
+  loop_id TEXT NOT NULL,
+  machine_json JSONB NOT NULL,
+  repo TEXT NOT NULL,
+  task_ids_json JSONB NOT NULL,
+  knowledge_ids_json JSONB NOT NULL,
+  digest_id TEXT NOT NULL,
+  started_at TIMESTAMPTZ,
+  finished_at TIMESTAMPTZ,
+  status TEXT NOT NULL,
+  exit_code INTEGER,
+  summary_json JSONB NOT NULL,
+  evidence_paths_json JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL,
+  updated_at TIMESTAMPTZ 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 INDEX IF NOT EXISTS idx_run_receipts_task_ids ON run_receipts USING GIN (task_ids_json);
+CREATE INDEX IF NOT EXISTS idx_run_receipts_knowledge_ids ON run_receipts USING GIN (knowledge_ids_json);
+    `),
+  migration("0006_work_item_machine_id", `
+ALTER TABLE workflow_work_items ADD COLUMN IF NOT EXISTS machine_id TEXT;
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_machine ON workflow_work_items(machine_id, status);
     `)
 ]);
 
@@ -5352,12 +5757,108 @@ function isMissingLedgerError(error) {
 // 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 readFileSync4, rmSync as rmSync4, writeFileSync as writeFileSync2 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
-import { hostname } from "os";
+import { hostname as hostname2 } from "os";
 import { dirname as dirname3, join as join5 } from "path";
 
 // src/daemon/loop.ts
@@ -5510,7 +6011,7 @@ function daemonStatus(store, path = pidFilePath()) {
   return {
     ...isDaemonRunning(path),
     lease: store.getDaemonLease(),
-    host: hostname(),
+    host: hostname2(),
     loops: {
       total: store.countLoops(),
       active: store.countLoops("active"),
@@ -5867,6 +6368,7 @@ var TRANSPORT_ENV_KEYS = new Set([
   "LOGNAME",
   "PATH",
   "SHELL",
+  "SHLVL",
   "SSH_AGENT_PID",
   "SSH_AUTH_SOCK",
   "TERM",
@@ -6088,6 +6590,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;
 }
@@ -6159,7 +6662,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; }',
@@ -6168,7 +6671,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; }',
@@ -6249,8 +6764,21 @@ 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)) {
@@ -6302,6 +6830,9 @@ async function preflightNativeAuthProfile(spec, env) {
   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 {
     return realpathSync(left) === realpathSync(right);
@@ -6351,8 +6882,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 };
   }
@@ -6368,7 +6936,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 };
@@ -6414,7 +6982,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) {
@@ -6674,7 +7242,7 @@ async function executeLoop(loop, run, opts = {}) {
 }
 
 // src/lib/health.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } 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;
@@ -6736,7 +7304,7 @@ function tagsFromValue(value) {
   return [];
 }
 function stableFingerprint(parts) {
-  return createHash3("sha256").update(parts.join(`
+  return createHash4("sha256").update(parts.join(`
 `)).digest("hex").slice(0, 16);
 }
 function stableScanFingerprint(parts) {
@@ -7715,55 +8283,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";
@@ -9003,21 +9522,933 @@ async function tick(deps) {
   return { claimed, completed, skipped, recovered, expired };
 }
 
-// src/mcp/index.ts
-var LOOP_STATUSES = ["active", "paused", "stopped", "expired"];
-var LOOP_STATUS_FILTERS = [...LOOP_STATUSES, "all"];
-var RUN_STATUSES = ["running", "succeeded", "failed", "timed_out", "abandoned", "skipped"];
-var WORKFLOW_STATUSES = ["active", "archived"];
-var WORKFLOW_STATUS_FILTERS = [...WORKFLOW_STATUSES, "all"];
-var CATCH_UP_POLICIES = ["none", "latest", "all"];
-var OVERLAP_POLICIES = ["skip", "allow"];
-var INTERVAL_ANCHORS = ["fixed_rate", "fixed_delay"];
-var MAX_LIMIT = 500;
+// 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;
+    }
+  }
+  async requeueWorkflowWorkItem(_id, _patch = {}) {
+    throw new CloudUnsupportedError("routes requeue");
+  }
+  async listWorkflowInvocations(opts = {}) {
+    const raw = await this.t.get("/invocations", { query: clean({ ...opts }) });
+    return pickArray(raw, "invocations");
+  }
+  async getWorkflowInvocation(id) {
+    try {
+      return pickObject(await this.t.get(`/invocations/${encodeURIComponent(id)}`), "invocation");
+    } catch {
+      return;
+    }
+  }
+  async getGoal(id) {
+    try {
+      return pickObject(await this.t.get(`/goals/${encodeURIComponent(id)}`), "goal");
+    } catch {
+      return;
+    }
+  }
+  async findGoalByLoop(idOrName) {
+    try {
+      return pickObject(await this.t.get("/goals", { query: clean({ loop: idOrName }) }), "goal");
+    } catch {
+      return;
+    }
+  }
+  async findGoalByRunId(id) {
+    try {
+      return pickObject(await this.t.get("/goals", { query: clean({ runId: id }) }), "goal");
+    } catch {
+      return;
+    }
+  }
+  async listGoals(opts = {}) {
+    const raw = await this.t.get("/goals", { query: clean({ ...opts }) });
+    return pickArray(raw, "goals");
+  }
+  async listGoalPlanNodes(goalIdOrPlanId) {
+    const raw = await this.t.get(`/goals/${encodeURIComponent(goalIdOrPlanId)}/plan-nodes`);
+    return pickArray(raw, "nodes");
+  }
+  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;
+    }
+  }
+  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;
+    }
+  }
+  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
+var LOOP_STATUSES = ["active", "paused", "stopped", "expired"];
+var LOOP_STATUS_FILTERS = [...LOOP_STATUSES, "all"];
+var RUN_STATUSES = ["running", "succeeded", "failed", "timed_out", "abandoned", "skipped"];
+var WORKFLOW_STATUSES = ["active", "archived"];
+var WORKFLOW_STATUS_FILTERS = [...WORKFLOW_STATUSES, "all"];
+var CATCH_UP_POLICIES = ["none", "latest", "all"];
+var OVERLAP_POLICIES = ["skip", "allow"];
+var INTERVAL_ANCHORS = ["fixed_rate", "fixed_delay"];
+var MAX_LIMIT = 500;
 var MUTATION_ENV = "LOOPS_MCP_ALLOW_MUTATIONS";
 var loopIdOrNameSchema = z2.string().min(1).describe("Loop id or exact loop name. Names resolve on exact match only; ambiguous names require the id.");
 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.");
@@ -9087,6 +10518,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);
@@ -9100,7 +10542,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`);
@@ -9118,7 +10560,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) {
@@ -9161,7 +10603,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,
@@ -9217,13 +10659,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)
     }))
   },
   {
@@ -9236,9 +10678,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
@@ -9246,34 +10688,78 @@ var TOOL_REGISTRATIONS = [
     })
   },
   {
-    name: "loops_runs",
-    aliases: ["loop_runs"],
-    description: "List loop runs with optional loop/status filtering.",
+    name: "loops_runs",
+    aliases: ["loop_runs"],
+    description: "List loop runs with optional loop/status filtering.",
+    readOnly: true,
+    annotations: READ_ONLY_ANNOTATIONS,
+    inputSchema: {
+      idOrName: loopIdOrNameSchema.optional(),
+      status: z2.enum(RUN_STATUSES).optional().describe("Filter by run status."),
+      limit: limitSchema,
+      showOutput: showOutputSchema
+    },
+    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));
+      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: {
-      idOrName: loopIdOrNameSchema.optional(),
-      status: z2.enum(RUN_STATUSES).optional().describe("Filter by run status."),
-      limit: limitSchema,
-      showOutput: showOutputSchema
+      run_id: z2.string().min(1).describe("Run id.")
     },
-    handler: ({ idOrName, status, limit, showOutput }) => withStore((store) => {
-      const loop = idOrName ? store.requireLoop(idOrName) : undefined;
-      const runs = store.listRuns({
-        loopId: loop?.id,
-        status,
-        limit
-      }).map((run) => publicRun(run, showOutput ?? false));
-      return { loop: loop ? publicLoop(loop) : undefined, runs };
+    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",
@@ -9285,7 +10771,7 @@ 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",
@@ -9302,7 +10788,7 @@ var TOOL_REGISTRATIONS = [
       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 }) => withStore((store) => buildHealthScan(store, {
+    handler: ({ includeStatuses, includeArchived, latestRun, doctor, daemon, staleRunningMs, maxFindings, limit }) => withLocalStore("loops_health_scan", (store) => buildHealthScan(store, {
       includeStatuses,
       includeArchived,
       latestRun,
@@ -9324,7 +10810,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 {
@@ -9344,7 +10830,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",
@@ -9357,12 +10843,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)
     }))
   },
   {
@@ -9378,16 +10864,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
+        })))
       };
     })
   },
@@ -9429,14 +10915,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
       };
     })
   },
@@ -9448,7 +10934,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",
@@ -9458,14 +10949,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 })) };
     })
   },
   {
@@ -9476,9 +10969,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",
@@ -9489,8 +10985,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),
@@ -9506,7 +11016,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",
@@ -9515,7 +11025,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",
@@ -9531,21 +11041,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",
@@ -9559,20 +11069,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) {
@@ -9649,8 +11156,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) => {
@@ -9660,8 +11179,8 @@ if (import.meta.main) {
 }
 
 // src/lib/migration.ts
-import { createHash as createHash4 } from "crypto";
-import { hostname as hostname2 } from "os";
+import { createHash as createHash5 } from "crypto";
+import { hostname as hostname3 } from "os";
 var LOOPS_MIGRATION_SCHEMA = "open-loops.migration/v1";
 function canonicalize(value) {
   if (Array.isArray(value))
@@ -9672,7 +11191,7 @@ function canonicalize(value) {
   return value;
 }
 function migrationHash(value) {
-  return createHash4("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
 }
 function pushBlocker(rows, resource, id, reason, name) {
   rows.push({ resource, id, name, action: "blocked", reason });
@@ -9748,7 +11267,7 @@ function exportLoopsMigrationBundle(store, opts = {}) {
     source: {
       backend: "sqlite",
       schemaVersion: rows.schemaVersion,
-      hostname: hostname2()
+      hostname: hostname3()
     },
     checks: rows.checks,
     importable: sanitized.blockers.length === 0,
@@ -10129,6 +11648,85 @@ async function buildSelfHostedMigrationPlan(store, opts) {
   });
   return { ...plan, importable: false };
 }
+async function postImportBatch(fetchImpl, config, payload) {
+  const body = await requestJson(fetchImpl, config, "/v1/import", { method: "POST", body: JSON.stringify(payload) });
+  const imported = body.imported ?? {};
+  return {
+    imported: { workflows: imported.workflows ?? 0, loops: imported.loops ?? 0, runs: imported.runs ?? 0 },
+    skippedRunning: typeof body.skippedRunning === "number" ? body.skippedRunning : 0
+  };
+}
+async function applySelfHostedPush(store, opts) {
+  const resolved = resolveApiConfig(opts);
+  if (!resolved.apiUrl)
+    throw new ValidationError("LOOPS_API_URL or --api-url is required for self-hosted push");
+  if (!isLocalApiUrl(resolved.apiUrl) && !resolved.token) {
+    throw new ValidationError("non-local self-hosted APIs require LOOPS_API_TOKEN or HASNA_LOOPS_API_TOKEN");
+  }
+  const config = { apiUrl: resolved.apiUrl, token: resolved.token };
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const includeRuns = opts.includeRuns ?? true;
+  const replace = opts.replace ?? false;
+  const batchRows = Math.max(1, opts.batchRows ?? 200);
+  const runBatchBytes = Math.max(64 * 1024, opts.runBatchBytes ?? 4 * 1024 * 1024);
+  const applied = { workflows: 0, loops: 0, runs: 0 };
+  const skipped = { runningRuns: 0, orphanRuns: 0 };
+  let requests = 0;
+  const base = store.exportMigrationRows({ includeRuns: false });
+  const loopIds = new Set(base.loops.map((loop) => loop.id));
+  for (let i = 0;i < base.workflows.length; i += batchRows) {
+    const batch = base.workflows.slice(i, i + batchRows);
+    const result = await postImportBatch(fetchImpl, config, { workflows: batch, replace });
+    applied.workflows += result.imported.workflows;
+    requests += 1;
+    opts.onProgress?.({ phase: "workflows", sent: applied.workflows, requests });
+  }
+  for (let i = 0;i < base.loops.length; i += batchRows) {
+    const batch = base.loops.slice(i, i + batchRows);
+    const result = await postImportBatch(fetchImpl, config, { loops: batch, replace });
+    applied.loops += result.imported.loops;
+    requests += 1;
+    opts.onProgress?.({ phase: "loops", sent: applied.loops, requests });
+  }
+  if (includeRuns) {
+    const pageSize = 500;
+    let pending = [];
+    let pendingBytes = 0;
+    const flush = async () => {
+      if (pending.length === 0)
+        return;
+      const result = await postImportBatch(fetchImpl, config, { runs: pending, replace });
+      applied.runs += result.imported.runs;
+      skipped.runningRuns += result.skippedRunning;
+      requests += 1;
+      opts.onProgress?.({ phase: "runs", sent: applied.runs, requests });
+      pending = [];
+      pendingBytes = 0;
+    };
+    for (let offset = 0;; offset += pageSize) {
+      const page = store.exportMigrationRunPage({ limit: pageSize, offset });
+      if (page.length === 0)
+        break;
+      for (const run of page) {
+        if (!loopIds.has(run.loopId)) {
+          skipped.orphanRuns += 1;
+          continue;
+        }
+        const encoded = JSON.stringify(run).length;
+        if (pending.length > 0 && pendingBytes + encoded > runBatchBytes)
+          await flush();
+        pending.push(run);
+        pendingBytes += encoded;
+        if (pending.length >= batchRows * 4)
+          await flush();
+      }
+      if (page.length < pageSize)
+        break;
+    }
+    await flush();
+  }
+  return { ok: true, apiUrl: config.apiUrl, applied, skipped, requests };
+}
 async function registerSelfHostedRunner(opts) {
   const config = resolveApiConfig(opts);
   if (!config.apiUrl)
@@ -10174,10 +11772,16 @@ class LoopsClient {
   ownStore;
   runnerId;
   constructor(opts = {}) {
-    this.store = opts.store ?? new Store;
+    this.store = opts.store ? new LocalStore(opts.store) : getStore();
     this.ownStore = !opts.store;
     this.runnerId = opts.runnerId ?? `sdk:${process.pid}`;
   }
+  localRuntime(operation) {
+    if (this.store.transport !== "local") {
+      throw new Error(`loops SDK ${operation} operates on this machine's local 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.`);
+    }
+    return this.store.raw;
+  }
   create(input) {
     return this.store.createLoop(input);
   }
@@ -10192,11 +11796,12 @@ class LoopsClient {
   get(idOrName) {
     return this.store.requireLoop(idOrName);
   }
-  pause(idOrName) {
-    return this.store.updateLoop(this.store.requireUniqueLoop(idOrName).id, { status: "paused" });
+  async pause(idOrName) {
+    const loop = await this.store.requireUniqueLoop(idOrName);
+    return this.store.updateLoop(loop.id, { status: "paused" });
   }
-  resume(idOrName) {
-    const loop = this.store.requireUniqueLoop(idOrName);
+  async resume(idOrName) {
+    const loop = await this.store.requireUniqueLoop(idOrName);
     let nextRunAt = loop.nextRunAt;
     if (!nextRunAt) {
       const now = new Date;
@@ -10204,8 +11809,9 @@ class LoopsClient {
     }
     return this.store.updateLoop(loop.id, { status: "active", nextRunAt });
   }
-  stop(idOrName) {
-    return this.store.updateLoop(this.store.requireUniqueLoop(idOrName).id, { status: "stopped", nextRunAt: undefined });
+  async stop(idOrName) {
+    const loop = await this.store.requireUniqueLoop(idOrName);
+    return this.store.updateLoop(loop.id, { status: "stopped", nextRunAt: undefined });
   }
   archive(idOrName) {
     return this.store.archiveLoop(idOrName);
@@ -10213,14 +11819,15 @@ class LoopsClient {
   unarchive(idOrName) {
     return this.store.unarchiveLoop(idOrName);
   }
-  delete(idOrName) {
-    return this.store.deleteLoop(this.store.requireUniqueLoop(idOrName).id);
+  async delete(idOrName) {
+    const loop = await this.store.requireUniqueLoop(idOrName);
+    return this.store.deleteLoop(loop.id);
   }
-  runs(idOrName, filters = {}) {
+  async runs(idOrName, filters = {}) {
     let loopId;
     if (idOrName) {
       try {
-        loopId = this.get(idOrName).id;
+        loopId = (await this.get(idOrName)).id;
       } catch (error) {
         if (error instanceof LoopNotFoundError)
           return [];
@@ -10229,48 +11836,59 @@ class LoopsClient {
     }
     return this.store.listRuns({ loopId, status: filters.status, limit: filters.limit });
   }
+  writeReceipt(input) {
+    return this.store.writeRunReceipt(input);
+  }
+  receipt(runId) {
+    return this.store.getRunReceipt(runId);
+  }
+  receipts(filters = {}) {
+    return this.store.listRunReceipts(filters);
+  }
+  async goal(idOrName) {
+    const goal = await this.store.getGoal(idOrName) ?? await this.store.findGoalByLoop(idOrName) ?? await this.store.findGoalByRunId(idOrName);
+    return {
+      goal,
+      runs: goal ? await this.store.listGoalRuns({ goalId: goal.goalId }) : []
+    };
+  }
   doctor() {
-    return runDoctor(this.store);
+    return runDoctor(this.localRuntime("doctor()"));
   }
   health(opts = {}) {
-    return buildHealthReport(this.store, opts);
+    return buildHealthReport(this.localRuntime("health()"), opts);
   }
   healthScan(opts = {}) {
-    return buildHealthScan(this.store, {
+    const store = this.localRuntime("healthScan()");
+    return buildHealthScan(store, {
       ...opts,
-      doctor: opts.doctor ? runDoctor(this.store) : undefined,
-      daemon: opts.daemon ? daemonStatus(this.store) : undefined
+      doctor: opts.doctor ? runDoctor(store) : undefined,
+      daemon: opts.daemon ? daemonStatus(store) : undefined
     });
   }
-  goal(idOrName) {
-    const goal = this.store.getGoal(idOrName) ?? this.store.findGoalByLoop(idOrName) ?? this.store.findGoalByRunId(idOrName);
-    return {
-      goal,
-      runs: goal ? this.store.listGoalRuns({ goalId: goal.goalId }) : []
-    };
-  }
   async tick() {
-    return tick({ store: this.store, runnerId: this.runnerId });
+    return tick({ store: this.localRuntime("tick()"), runnerId: this.runnerId });
   }
   async runNow(idOrName) {
-    const result = await runLoopNow({ store: this.store, idOrName: this.store.requireUniqueLoop(idOrName).id, runnerId: this.runnerId });
+    const store = this.localRuntime("runNow()");
+    const result = await runLoopNow({ store, idOrName: store.requireUniqueLoop(idOrName).id, runnerId: this.runnerId });
     return result.run;
   }
   exportBundle(opts = {}) {
-    return exportLoopsMigrationBundle(this.store, opts);
+    return exportLoopsMigrationBundle(this.localRuntime("exportBundle()"), opts);
   }
   planImport(bundle, opts = {}) {
-    return buildImportMigrationPlan(this.store, bundle, opts);
+    return buildImportMigrationPlan(this.localRuntime("planImport()"), bundle, opts);
   }
   importBundle(bundle, opts = {}) {
-    return applyImportMigrationBundle(this.store, bundle, opts);
+    return applyImportMigrationBundle(this.localRuntime("importBundle()"), bundle, opts);
   }
   planSelfHostedMigration(opts = {}) {
-    return buildSelfHostedMigrationPlan(this.store, { ...opts, operation: opts.operation ?? "self-hosted-migrate" });
+    return buildSelfHostedMigrationPlan(this.localRuntime("planSelfHostedMigration()"), { ...opts, operation: opts.operation ?? "self-hosted-migrate" });
   }
-  close() {
+  async close() {
     if (this.ownStore)
-      this.store.close();
+      await this.store.close();
   }
 }
 function loops(opts = {}) {
@@ -10363,6 +11981,15 @@ class SqliteLoopStorage {
   deleteLoop(...args) {
     return this.call("deleteLoop", ...args);
   }
+  upsertMigrationLoop(...args) {
+    return this.call("upsertMigrationLoop", ...args);
+  }
+  upsertMigrationRun(...args) {
+    return this.call("upsertMigrationRun", ...args);
+  }
+  upsertMigrationWorkflow(...args) {
+    return this.call("upsertMigrationWorkflow", ...args);
+  }
   createWorkflow(...args) {
     return this.call("createWorkflow", ...args);
   }
@@ -10486,6 +12113,15 @@ class SqliteLoopStorage {
   listRuns(...args) {
     return this.call("listRuns", ...args);
   }
+  writeRunReceipt(...args) {
+    return this.call("writeRunReceipt", ...args);
+  }
+  getRunReceipt(...args) {
+    return this.call("getRunReceipt", ...args);
+  }
+  listRunReceipts(...args) {
+    return this.call("listRunReceipts", ...args);
+  }
   recoverExpiredRunLeases(...args) {
     return this.call("recoverExpiredRunLeases", ...args);
   }
@@ -10535,6 +12171,9 @@ class NotImplementedError extends Error {
 }
 var TERMINAL_RUN_STATUSES3 = ["succeeded", "failed", "timed_out", "abandoned", "skipped"];
 var PRUNE_BATCH_SIZE2 = 400;
+function isUniqueViolation(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "23505";
+}
 var DEFAULT_RECOVERY_BATCH_LIMIT2 = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER2 = 5;
 
@@ -10666,19 +12305,22 @@ class PostgresLoopStorage {
   async listLoops(...args) {
     const opts = args[0] ?? {};
     const limit = opts.limit ?? 200;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
     let rows;
-    if (opts.status && opts.archived) {
-      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+    if (opts.name != null) {
+      rows = await this.client.many("SELECT * FROM loops WHERE name = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3", [opts.name, limit, offset]);
+    } else if (opts.status && opts.archived) {
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NOT NULL ORDER BY next_run_at ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else if (opts.status && opts.includeArchived) {
-      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 ORDER BY next_run_at ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else if (opts.status) {
-      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT $2", [opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE status = $1 AND archived_at IS NULL ORDER BY next_run_at ASC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else if (opts.archived) {
-      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NOT NULL ORDER BY archived_at DESC LIMIT $1 OFFSET $2", [limit, offset]);
     } else if (opts.includeArchived) {
-      rows = await this.client.many("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loops ORDER BY status ASC, next_run_at ASC LIMIT $1 OFFSET $2", [limit, offset]);
     } else {
-      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT $1 OFFSET $2", [limit, offset]);
     }
     return rows.map(rowToLoop);
   }
@@ -10809,6 +12451,172 @@ class PostgresLoopStorage {
     const row = await this.client.get(sql, params);
     return row?.count ?? 0;
   }
+  async upsertMigrationWorkflow(...args) {
+    const [workflow, opts = {}] = args;
+    const existing = await this.getWorkflow(workflow.id);
+    if (existing && !opts.replace)
+      return existing;
+    try {
+      await this.client.execute(`INSERT INTO workflow_specs (id, name, description, version, status, goal_json, steps_json, created_at, updated_at)
+         VALUES ($1,$2,$3,$4,$5,$6::jsonb,$7::jsonb,$8,$9)
+         ON CONFLICT(id) DO UPDATE SET
+           name=EXCLUDED.name,
+           description=EXCLUDED.description,
+           version=EXCLUDED.version,
+           status=EXCLUDED.status,
+           goal_json=EXCLUDED.goal_json,
+           steps_json=EXCLUDED.steps_json,
+           created_at=EXCLUDED.created_at,
+           updated_at=EXCLUDED.updated_at`, [
+        workflow.id,
+        workflow.name,
+        workflow.description ?? null,
+        workflow.version,
+        workflow.status,
+        workflow.goal ? JSON.stringify(workflow.goal) : null,
+        JSON.stringify(workflow.steps),
+        workflow.createdAt,
+        workflow.updatedAt
+      ]);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        const owner = await this.client.get("SELECT * FROM workflow_specs WHERE name = $1 AND status = 'active' LIMIT 1", [workflow.name]);
+        if (owner)
+          return rowToWorkflow(owner);
+      }
+      throw error;
+    }
+    const imported = await this.getWorkflow(workflow.id);
+    if (!imported)
+      throw new Error(`workflow not found after migration import: ${workflow.id}`);
+    return imported;
+  }
+  async upsertMigrationLoop(...args) {
+    const [loop, opts = {}] = args;
+    const existing = await this.loadLoop(this.client, loop.id);
+    if (existing && !opts.replace)
+      return existing;
+    await this.client.execute(`INSERT INTO loops (id, name, description, status, archived_at, archived_from_status, schedule_json, target_json,
+        goal_json, machine_json, next_run_at, retry_scheduled_for, catch_up, catch_up_limit, overlap, max_attempts,
+        retry_delay_ms, lease_ms, expires_at, created_at, updated_at)
+       VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8::jsonb,$9::jsonb,$10::jsonb,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)
+       ON CONFLICT(id) DO UPDATE SET
+         name=EXCLUDED.name,
+         description=EXCLUDED.description,
+         status=EXCLUDED.status,
+         archived_at=EXCLUDED.archived_at,
+         archived_from_status=EXCLUDED.archived_from_status,
+         schedule_json=EXCLUDED.schedule_json,
+         target_json=EXCLUDED.target_json,
+         goal_json=EXCLUDED.goal_json,
+         machine_json=EXCLUDED.machine_json,
+         next_run_at=EXCLUDED.next_run_at,
+         retry_scheduled_for=EXCLUDED.retry_scheduled_for,
+         catch_up=EXCLUDED.catch_up,
+         catch_up_limit=EXCLUDED.catch_up_limit,
+         overlap=EXCLUDED.overlap,
+         max_attempts=EXCLUDED.max_attempts,
+         retry_delay_ms=EXCLUDED.retry_delay_ms,
+         lease_ms=EXCLUDED.lease_ms,
+         expires_at=EXCLUDED.expires_at,
+         created_at=EXCLUDED.created_at,
+         updated_at=EXCLUDED.updated_at`, [
+      loop.id,
+      loop.name,
+      loop.description ?? null,
+      loop.status,
+      loop.archivedAt ?? null,
+      loop.archivedFromStatus ?? null,
+      JSON.stringify(loop.schedule),
+      JSON.stringify(loop.target),
+      loop.goal ? JSON.stringify(loop.goal) : null,
+      loop.machine ? JSON.stringify(loop.machine) : null,
+      loop.nextRunAt ?? null,
+      loop.retryScheduledFor ?? null,
+      loop.catchUp,
+      loop.catchUpLimit,
+      loop.overlap,
+      loop.maxAttempts,
+      loop.retryDelayMs,
+      loop.leaseMs,
+      loop.expiresAt ?? null,
+      loop.createdAt,
+      loop.updatedAt
+    ]);
+    const imported = await this.loadLoop(this.client, loop.id);
+    if (!imported)
+      throw new Error(`loop not found after migration import: ${loop.id}`);
+    return imported;
+  }
+  async upsertMigrationRun(...args) {
+    const [run, opts = {}] = args;
+    if (run.status === "running")
+      throw new ValidationError(`cannot import running run ${run.id}`);
+    const existing = await this.loadRun(this.client, run.id);
+    if (existing && !opts.replace)
+      return existing;
+    try {
+      await this.client.execute(`INSERT INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+        claimed_by, claim_token, lease_expires_at, pid, pgid, process_started_at, exit_code, duration_ms,
+        stdout, stderr, error, goal_run_id, created_at, updated_at)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,NULL,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)
+       ON CONFLICT(id) DO UPDATE SET
+         loop_id=EXCLUDED.loop_id,
+         loop_name=EXCLUDED.loop_name,
+         scheduled_for=EXCLUDED.scheduled_for,
+         attempt=EXCLUDED.attempt,
+         status=EXCLUDED.status,
+         started_at=EXCLUDED.started_at,
+         finished_at=EXCLUDED.finished_at,
+         claimed_by=EXCLUDED.claimed_by,
+         claim_token=NULL,
+         lease_expires_at=EXCLUDED.lease_expires_at,
+         pid=EXCLUDED.pid,
+         pgid=EXCLUDED.pgid,
+         process_started_at=EXCLUDED.process_started_at,
+         exit_code=EXCLUDED.exit_code,
+         duration_ms=EXCLUDED.duration_ms,
+         stdout=EXCLUDED.stdout,
+         stderr=EXCLUDED.stderr,
+         error=EXCLUDED.error,
+         goal_run_id=EXCLUDED.goal_run_id,
+         created_at=EXCLUDED.created_at,
+         updated_at=EXCLUDED.updated_at`, [
+        run.id,
+        run.loopId,
+        run.loopName,
+        run.scheduledFor,
+        run.attempt,
+        run.status,
+        run.startedAt ?? null,
+        run.finishedAt ?? null,
+        run.claimedBy ?? null,
+        run.leaseExpiresAt ?? null,
+        run.pid ?? null,
+        run.pgid ?? null,
+        run.processStartedAt ?? null,
+        run.exitCode ?? null,
+        run.durationMs ?? null,
+        persistedRunOutput(run.stdout),
+        persistedRunOutput(run.stderr),
+        scrubbedOrNull(run.error),
+        run.goalRunId ?? null,
+        run.createdAt,
+        run.updatedAt
+      ]);
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        const slot = await this.loadRunBySlot(this.client, run.loopId, run.scheduledFor);
+        if (slot)
+          return slot;
+      }
+      throw error;
+    }
+    const imported = await this.loadRun(this.client, run.id);
+    if (!imported)
+      throw new Error(`run not found after migration import: ${run.id}`);
+    return imported;
+  }
   async createSkippedRun(...args) {
     const [loop, scheduledFor, reason, opts = {}] = args;
     const now = nowIso();
@@ -10976,18 +12784,102 @@ class PostgresLoopStorage {
   async listRuns(...args) {
     const opts = args[0] ?? {};
     const limit = opts.limit ?? 100;
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
     let rows;
     if (opts.loopId && opts.status) {
-      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 AND status = $2 ORDER BY created_at DESC LIMIT $3", [opts.loopId, opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 AND status = $2 ORDER BY created_at DESC LIMIT $3 OFFSET $4", [opts.loopId, opts.status, limit, offset]);
     } else if (opts.loopId) {
-      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 ORDER BY created_at DESC LIMIT $2", [opts.loopId, limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE loop_id = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3", [opts.loopId, limit, offset]);
     } else if (opts.status) {
-      rows = await this.client.many("SELECT * FROM loop_runs WHERE status = $1 ORDER BY created_at DESC LIMIT $2", [opts.status, limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3", [opts.status, limit, offset]);
     } else {
-      rows = await this.client.many("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT $1", [limit]);
+      rows = await this.client.many("SELECT * FROM loop_runs ORDER BY created_at DESC LIMIT $1 OFFSET $2", [limit, offset]);
     }
     return rows.map(rowToRun);
   }
+  async writeRunReceipt(...args) {
+    const [input, opts = {}] = args;
+    const inputRunId = typeof input.run_id === "string" && input.run_id.trim() ? input.run_id : undefined;
+    const existing = inputRunId ? await this.getRunReceipt(inputRunId) : undefined;
+    const run = inputRunId ? await this.getRun(inputRunId) : undefined;
+    const loop = input.loop_id ? await this.getLoop(input.loop_id) : run ? await this.getLoop(run.loopId) : undefined;
+    const receipt = normalizeRunReceipt(input, { now: opts.now, run, loop, existing });
+    await this.client.execute(`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 ($1,$2,$3::jsonb,$4,$5::jsonb,$6::jsonb,$7,$8,$9,$10,$11,$12::jsonb,$13::jsonb,$14,$15)
+       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`, [
+      receipt.run_id,
+      receipt.loop_id,
+      JSON.stringify(receipt.machine),
+      receipt.repo,
+      JSON.stringify(receipt.task_ids),
+      JSON.stringify(receipt.knowledge_ids),
+      receipt.digest_id,
+      receipt.started_at,
+      receipt.finished_at,
+      receipt.status,
+      receipt.exit_code,
+      JSON.stringify(receipt.summary),
+      JSON.stringify(receipt.evidence_paths),
+      receipt.created_at,
+      receipt.updated_at
+    ]);
+    return await this.getRunReceipt(receipt.run_id) ?? receipt;
+  }
+  async getRunReceipt(...args) {
+    const row = await this.client.get("SELECT * FROM run_receipts WHERE run_id = $1", [args[0]]);
+    return row ? rowToRunReceipt(row) : undefined;
+  }
+  async listRunReceipts(...args) {
+    const opts = args[0] ?? {};
+    const limit = opts.limit ?? 100;
+    const filters = [];
+    const params = [];
+    const next = () => `$${params.length + 1}`;
+    if (opts.loopId) {
+      const slot = next();
+      filters.push(`loop_id = ${slot}`);
+      params.push(opts.loopId);
+    }
+    if (opts.repo) {
+      const slot = next();
+      filters.push(`repo = ${slot}`);
+      params.push(opts.repo);
+    }
+    if (opts.status) {
+      const slot = next();
+      filters.push(`status = ${slot}`);
+      params.push(opts.status);
+    }
+    if (opts.taskId) {
+      const slot = next();
+      filters.push(`task_ids_json ? ${slot}`);
+      params.push(opts.taskId);
+    }
+    if (opts.knowledgeId) {
+      const slot = next();
+      filters.push(`knowledge_ids_json ? ${slot}`);
+      params.push(opts.knowledgeId);
+    }
+    const limitSlot = next();
+    params.push(limit);
+    const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+    const rows = await this.client.many(`SELECT * FROM run_receipts ${where} ORDER BY created_at DESC LIMIT ${limitSlot}`, params);
+    return rows.map(rowToRunReceipt);
+  }
   async countRuns(...args) {
     const status = args[0];
     const row = status ? await this.client.get("SELECT COUNT(*)::int AS count FROM loop_runs WHERE status = $1", [status]) : await this.client.get("SELECT COUNT(*)::int AS count FROM loop_runs", []);
@@ -11321,6 +13213,7 @@ var KNOWLEDGE_REFRESH_TEMPLATE_ID = "knowledge-refresh";
 var REPORT_ONLY_TEMPLATE_ID = "report-only";
 var INCIDENT_RESPONSE_TEMPLATE_ID = "incident-response";
 var DETERMINISTIC_CHECK_CREATE_TASK_TEMPLATE_ID = "deterministic-check-create-task";
+var ROUTING_REMEDIATION_TEMPLATE_ID = "routing-remediation";
 function projectPathVariable(description = "Repository or project working directory.") {
   return { name: "projectPath", required: true, description };
 }
@@ -11514,6 +13407,28 @@ var BUILTIN_TEMPLATE_SUMMARIES = [
       { name: "name", description: "Workflow name." },
       { name: "timeoutMs", default: "300000", description: "Check timeout in milliseconds." }
     ]
+  },
+  {
+    id: ROUTING_REMEDIATION_TEMPLATE_ID,
+    name: "Routing Remediation",
+    description: "Run a bounded routing-doctor remediation workflow: deterministic preflight, safe Todos CLI repair, blocker task filing, and adversarial verification.",
+    kind: "workflow",
+    variables: [
+      projectPathVariable("Repository/project path used for workflow evidence artifacts."),
+      { name: "todosProjectPath", description: "Todos storage project path to inspect and repair; defaults to projectPath." },
+      { name: "doctorJsonPath", description: "Optional existing todos doctor routing --json output to consume instead of running a fresh dry-run." },
+      { name: "doctorProject", description: "Optional todos doctor routing --project scope (id, slug, or path)." },
+      { name: "tag", description: "Optional todos doctor routing --tag scope." },
+      { name: "status", default: "pending,in_progress", description: "Comma-separated task statuses for the doctor." },
+      { name: "shard", description: "Optional deterministic shard such as 0/6." },
+      { name: "limit", description: "Optional maximum tasks inspected by the doctor." },
+      { name: "maxRepairs", default: "25", description: "Capacity gate: maximum safe_auto findings allowed in one apply run." },
+      { name: "dryRun", default: "true", description: "When true, perform preflight/reporting only and do not apply repairs." },
+      { name: "idempotencyKey", description: "Stable key used for evidence paths, undo records, and dedupe fingerprints." },
+      { name: "evidenceDir", description: "Directory for doctor, preflight, apply, and recheck JSON artifacts." },
+      { name: "undoDir", description: "Directory for todos doctor routing --undo-record output." },
+      ...lifecycleSharedVariables({ worktreeModeDefault: "required" })
+    ]
   }
 ];
 var NO_TMUX_DISPATCH_FRAGMENT = "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.";
@@ -11619,6 +13534,152 @@ function worktreeContextFragment(plan) {
 function shellQuote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function routingRemediationDoctorScopeArgs(opts) {
+  return [
+    opts.doctorProject ? ["--project", opts.doctorProject] : [],
+    opts.tag ? ["--tag", opts.tag] : [],
+    opts.status ? ["--status", opts.status] : [],
+    opts.shard ? ["--shard", opts.shard] : [],
+    opts.limit ? ["--limit", opts.limit] : []
+  ].flat();
+}
+function displayCommand(command, args) {
+  const shellSafe = /^[A-Za-z0-9_./:@%+=,-]+$/;
+  return [command, ...args.map((arg) => shellSafe.test(arg) ? arg : shellQuote2(arg))].join(" ");
+}
+function routingRemediationDoctorCommand(opts) {
+  const args = [
+    "--project",
+    opts.todosProjectPath,
+    "doctor",
+    "routing",
+    "--json",
+    ...opts.apply ? ["--apply"] : [],
+    ...opts.apply && opts.undoRecordPath ? ["--undo-record", opts.undoRecordPath] : [],
+    ...routingRemediationDoctorScopeArgs(opts)
+  ];
+  return displayCommand("todos", args);
+}
+var ROUTING_REMEDIATION_PREFLIGHT_SCRIPT = [
+  "const { mkdirSync, readFileSync, writeFileSync } = await import('node:fs');",
+  "const { dirname } = await import('node:path');",
+  "const { spawnSync } = await import('node:child_process');",
+  "const env = process.env;",
+  "const required = (name) => {",
+  "  const value = env[name];",
+  "  if (!value || !value.trim()) throw new Error(`${name} is required`);",
+  "  return value.trim();",
+  "};",
+  "const optional = (name) => {",
+  "  const value = env[name];",
+  "  return value && value.trim() ? value.trim() : undefined;",
+  "};",
+  "const parseJson = (text, label) => {",
+  "  try { return JSON.parse(text || '{}'); } catch (error) { throw new Error(`${label} is not valid JSON: ${error?.message || error}`); }",
+  "};",
+  "const writeJson = (path, value) => {",
+  "  mkdirSync(dirname(path), { recursive: true });",
+  "  writeFileSync(path, `${JSON.stringify(value, null, 2)}\\n`);",
+  "};",
+  "const todosProject = required('OPENLOOPS_ROUTING_REMEDIATION_TODOS_PROJECT');",
+  "const doctorJsonPath = optional('OPENLOOPS_ROUTING_REMEDIATION_DOCTOR_JSON');",
+  "const doctorOutputPath = required('OPENLOOPS_ROUTING_REMEDIATION_DOCTOR_OUTPUT');",
+  "const preflightOutputPath = required('OPENLOOPS_ROUTING_REMEDIATION_PREFLIGHT_OUTPUT');",
+  "const idempotencyKey = required('OPENLOOPS_ROUTING_REMEDIATION_IDEMPOTENCY_KEY');",
+  "const applyCommand = required('OPENLOOPS_ROUTING_REMEDIATION_APPLY_COMMAND');",
+  "const scopeArgs = parseJson(env.OPENLOOPS_ROUTING_REMEDIATION_SCOPE_ARGS || '[]', 'scope args');",
+  "if (!Array.isArray(scopeArgs) || !scopeArgs.every((entry) => typeof entry === 'string')) throw new Error('scope args must be a string array');",
+  "const maxRepairs = Number(env.OPENLOOPS_ROUTING_REMEDIATION_MAX_REPAIRS || '25');",
+  "if (!Number.isInteger(maxRepairs) || maxRepairs < 0) throw new Error('maxRepairs must be a non-negative integer');",
+  "const dryRun = !['0', 'false', 'no', 'off'].includes(String(env.OPENLOOPS_ROUTING_REMEDIATION_DRY_RUN || 'true').toLowerCase());",
+  "let doctor;",
+  "let sourceDoctorRun;",
+  "if (doctorJsonPath) {",
+  "  doctor = parseJson(readFileSync(doctorJsonPath, 'utf8'), doctorJsonPath);",
+  "  sourceDoctorRun = { type: 'file', path: doctorJsonPath };",
+  "} else {",
+  "  const args = ['--project', todosProject, 'doctor', 'routing', '--json', ...scopeArgs];",
+  "  const result = spawnSync('todos', args, { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });",
+  "  if (![0, 1].includes(result.status ?? -1)) {",
+  "    throw new Error(`todos doctor routing preflight failed status=${result.status ?? 'null'} ${String(result.stderr || result.error || result.stdout).slice(0, 500)}`);",
+  "  }",
+  "  doctor = parseJson(result.stdout, 'todos doctor routing output');",
+  "  sourceDoctorRun = { type: 'command', command: ['todos', ...args].join(' ') };",
+  "}",
+  "if (doctor.schema_version !== 'todos.routing_doctor.v1') throw new Error(`unsupported routing doctor schema: ${doctor.schema_version || 'missing'}`);",
+  "const findings = Array.isArray(doctor.findings) ? doctor.findings : [];",
+  "const safeFindings = findings.filter((finding) => finding?.repair_class === 'safe_auto');",
+  "const allowedSafeFields = new Set(['working_dir', 'task_list_id']);",
+  "const safeFields = safeFindings.map((finding) => String(finding?.suggested_repair?.field || finding?.field || '__missing_safe_field__'));",
+  "const unsupportedSafeFields = [...new Set(safeFields.filter((field) => !allowedSafeFields.has(field)))];",
+  "const blockerClasses = new Set(['blocker_human', 'blocker_cross_repo', 'blocker_invalid_path', 'unsupported']);",
+  "const blockerFindings = findings.filter((finding) => blockerClasses.has(String(finding?.repair_class || '')));",
+  "const byCategory = findings.reduce((acc, finding) => {",
+  "  const category = String(finding?.category || 'unknown');",
+  "  acc[category] = (acc[category] || 0) + 1;",
+  "  return acc;",
+  "}, {});",
+  "const preflight = {",
+  "  schema_version: 'openloops.routing_remediation_preflight.v1',",
+  "  generated_at: new Date().toISOString(),",
+  "  ok: unsupportedSafeFields.length === 0 && safeFindings.length <= maxRepairs,",
+  "  dry_run: dryRun,",
+  "  idempotency_key: idempotencyKey,",
+  "  source_doctor_run: sourceDoctorRun,",
+  "  doctor_json_path: doctorOutputPath,",
+  "  safe_auto: safeFindings.length,",
+  "  blocker_findings: blockerFindings.length,",
+  "  unsupported_findings: findings.filter((finding) => finding?.repair_class === 'unsupported').length,",
+  "  by_category: byCategory,",
+  "  allowed_safe_fields: [...allowedSafeFields],",
+  "  unsupported_safe_fields: unsupportedSafeFields,",
+  "  capacity: { max_repairs: maxRepairs, requested_repairs: safeFindings.length, allowed: safeFindings.length <= maxRepairs },",
+  "  apply_allowed: !dryRun && unsupportedSafeFields.length === 0 && safeFindings.length <= maxRepairs,",
+  "  apply_command: applyCommand,",
+  "  blocker_task_tags: ['from-kai', 'routing-health'],",
+  "  blocker_repair_classes: [...blockerClasses],",
+  "};",
+  "writeJson(doctorOutputPath, doctor);",
+  "writeJson(preflightOutputPath, preflight);",
+  "console.log(JSON.stringify({",
+  "  ok: preflight.ok,",
+  "  dry_run: preflight.dry_run,",
+  "  idempotency_key: preflight.idempotency_key,",
+  "  doctor_json_path: preflight.doctor_json_path,",
+  "  preflight_output_path: preflightOutputPath,",
+  "  safe_auto: preflight.safe_auto,",
+  "  blocker_findings: preflight.blocker_findings,",
+  "  unsupported_safe_fields: preflight.unsupported_safe_fields,",
+  "  capacity: preflight.capacity,",
+  "}));",
+  "if (unsupportedSafeFields.length) {",
+  "  console.error(`routing remediation preflight blocked unsupported safe_auto fields: ${unsupportedSafeFields.join(', ')}`);",
+  "  process.exit(12);",
+  "}",
+  "if (safeFindings.length > maxRepairs) {",
+  "  console.error(`routing remediation preflight blocked capacity: safe_auto=${safeFindings.length} maxRepairs=${maxRepairs}`);",
+  "  process.exit(12);",
+  "}"
+].join(`
+`);
+function routingRemediationPreflightCommand(opts) {
+  return [
+    "set -euo pipefail",
+    `export OPENLOOPS_ROUTING_REMEDIATION_TODOS_PROJECT=${shellQuote2(opts.todosProjectPath)}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_DOCTOR_JSON=${shellQuote2(opts.doctorJsonPath ?? "")}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_DOCTOR_OUTPUT=${shellQuote2(opts.doctorOutputPath)}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_PREFLIGHT_OUTPUT=${shellQuote2(opts.preflightOutputPath)}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_IDEMPOTENCY_KEY=${shellQuote2(opts.idempotencyKey)}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_MAX_REPAIRS=${shellQuote2(String(opts.maxRepairs))}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_DRY_RUN=${shellQuote2(opts.dryRun ? "true" : "false")}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_SCOPE_ARGS=${shellQuote2(JSON.stringify(routingRemediationDoctorScopeArgs(opts)))}`,
+    `export OPENLOOPS_ROUTING_REMEDIATION_APPLY_COMMAND=${shellQuote2(opts.applyCommand)}`,
+    "bun - <<'BUN'",
+    ROUTING_REMEDIATION_PREFLIGHT_SCRIPT,
+    "BUN"
+  ].join(`
+`);
+}
 function sourceTaskGateCommand(todosProjectPath, taskId) {
   return [
     "set -euo pipefail",
@@ -11716,6 +13777,7 @@ var PR_HANDOFF_SCRIPT = [
   "  }",
   "  return undefined;",
   "};",
+  "const scrubUrlCredentials = (value) => String(value || '').replace(/(https?:\\/\\/)[^\\s/@]+:[^\\s/@]+@/gi, '$1').replace(/(https?:\\/\\/)[^\\s/@]+@/gi, '$1');",
   "const run = (command, args, options = {}) => spawnSync(command, args, { encoding: 'utf8', ...options });",
   "const todosArgs = (...args) => todosProject ? ['--project', todosProject, ...args] : args;",
   "const todos = (...args) => run(todosBin, todosArgs(...args));",
@@ -11730,6 +13792,8 @@ var PR_HANDOFF_SCRIPT = [
   "const remote = stringField('remote') || 'origin';",
   "let commit = stringField('commit', 'commitSha', 'sha');",
   "const repo = stringField('githubRepo', 'repoSlug', 'repository');",
+  "const repoDisplay = scrubUrlCredentials(repo || stringField('repo', 'remoteUrl') || '');",
+  "const artifactError = scrubUrlCredentials(artifact.error);",
   "const prUrl = stringField('prUrl', 'pullRequestUrl');",
   "const title = stringField('title', 'prTitle') || `PR handoff for ${taskId}`;",
   "const body = stringField('body', 'prBody') || [",
@@ -11737,16 +13801,16 @@ var PR_HANDOFF_SCRIPT = [
   "  `Commit: ${commit || 'unknown'}`,",
   "  `Branch: ${branch || 'unknown'}`,",
   "  artifact.validation ? `Validation: ${artifact.validation}` : undefined,",
-  "  artifact.error ? `Worker network error: ${artifact.error}` : undefined,",
+  "  artifactError ? `Worker network error: ${artifactError}` : undefined,",
   "].filter(Boolean).join('\\n\\n');",
   "const fingerprint = stringField('fingerprint') || `openloops:pr-handoff:${taskId}:${branch || 'missing-branch'}:${commit || 'missing-commit'}`;",
-  "const repoTagSource = (repo || stringField('repo', 'remoteUrl') || repoPath).split(/[/:]/).filter(Boolean).at(-1) || 'unknown';",
+  "const repoTagSource = (repoDisplay || repoPath).split(/[/:]/).filter(Boolean).at(-1) || 'unknown';",
   "const repoTag = `repo:${repoTagSource.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'unknown'}`;",
   "const metadata = {",
   "  route_enabled: true,",
   "  source: 'openloops.pr-handoff',",
   "  original_task_id: taskId,",
-  "  repo: repo || stringField('repo', 'remoteUrl') || '',",
+  "  repo: repoDisplay,",
   "  branch: branch || '',",
   "  base,",
   "  commit: commit || '',",
@@ -11756,18 +13820,19 @@ var PR_HANDOFF_SCRIPT = [
   "  no_tmux_dispatch: true,",
   "};",
   "const upsertTask = (why) => {",
+  "  const safeWhy = scrubUrlCredentials(why);",
   "  const description = [",
   "    `OpenLoops could not complete network PR handoff for original task ${taskId}.`,",
-  "    `Reason: ${why}`,",
+  "    `Reason: ${safeWhy}`,",
   "    `Fingerprint: ${fingerprint}`,",
-  "    `Repository: ${repo || stringField('repo', 'remoteUrl') || 'unknown'}`,",
+  "    `Repository: ${repoDisplay || 'unknown'}`,",
   "    `Worktree: ${repoPath}`,",
   "    `Branch: ${branch || 'unknown'}`,",
   "    `Base: ${base}`,",
   "    `Commit: ${commit || 'unknown'}`,",
   "    `Artifact: ${artifactPath}`,",
   "    artifact.validation ? `Validation: ${artifact.validation}` : undefined,",
-  "    artifact.error ? `Worker error: ${artifact.error}` : undefined,",
+  "    artifactError ? `Worker error: ${artifactError}` : undefined,",
   "    'Do not rerun implementation work. Push the recorded commit/branch, open or update the PR, then comment the original task with the PR URL and validation evidence.',",
   "  ].filter(Boolean).join('\\n\\n');",
   "  const result = todos(",
@@ -11781,8 +13846,8 @@ var PR_HANDOFF_SCRIPT = [
   "    '--metadata-json', JSON.stringify(metadata),",
   "    '--working-dir', repoPath,",
   "  );",
-  "  if (result.status !== 0) throw new Error(`todos task upsert failed: ${result.stderr || result.stdout || result.status}`);",
-  "  comment(`openloops:pr-handoff=pending task=${taskId} artifact=${artifactPath} fingerprint=${fingerprint} reason=${why}`);",
+  "  if (result.status !== 0) throw new Error(`todos task upsert failed: ${scrubUrlCredentials(result.stderr || result.stdout || result.status)}`);",
+  "  comment(`openloops:pr-handoff=pending task=${taskId} artifact=${artifactPath} fingerprint=${fingerprint} reason=${safeWhy}`);",
   "  console.log(`queued PR handoff task fingerprint=${fingerprint}`);",
   "};",
   "const queueNetworkHandoff = (why) => { upsertTask(why); process.exit(0); };",
@@ -11791,6 +13856,10 @@ var PR_HANDOFF_SCRIPT = [
   "  console.error(`invalid PR handoff artifact: ${why}`);",
   "  process.exit(0);",
   "};",
+  "const preflightGitHub = () => {",
+  "  const probe = run(gitBin, ['-C', repoPath, 'ls-remote', '--heads', remote, base]);",
+  "  if (probe.status !== 0) queueNetworkHandoff(`github preflight failed before push/PR: ${String(probe.stderr || probe.stdout || probe.status).slice(0, 300)}`);",
+  "};",
   "const canonicalPath = (path) => {",
   "  try { return realpathSync(path); } catch { return path; }",
   "};",
@@ -11811,6 +13880,7 @@ var PR_HANDOFF_SCRIPT = [
   "commit = String(resolvedCommit.stdout || commit).trim();",
   "const reachable = run(gitBin, ['-C', repoPath, 'merge-base', '--is-ancestor', commit, 'HEAD']);",
   "if (reachable.status !== 0) invalidArtifact(`artifact commit ${commit} is not reachable from HEAD`);",
+  "preflightGitHub();",
   "if (prUrl) {",
   `  const viewed = run(ghBin, ['pr', 'view', prUrl, '--json', 'url,headRefName', '--jq', '.url + "\\\\n" + .headRefName']);`,
   "  if (viewed.status !== 0) queueNetworkHandoff(`could not verify existing PR URL: ${String(viewed.stderr || viewed.stdout || viewed.status).slice(0, 300)}`);",
@@ -11861,6 +13931,34 @@ var PR_HANDOFF_NO_ARTIFACT_SCRIPT = [
   "  const result = run(todosBin, todosArgs('comment', taskId, text));",
   "  if (result.status !== 0) console.error(`failed to comment original task: ${result.stderr || result.stdout || result.status}`);",
   "};",
+  "const scrubUrlCredentials = (value) => String(value || '').replace(/(https?:\\/\\/)[^\\s/@]+@/gi, '$1').replace(/(https?:\\/\\/)[^\\s/@]+:[^\\s/@]+@/gi, '$1');",
+  "const upsertTask = (why, branch, commit, remoteUrl) => {",
+  "  const safeWhy = scrubUrlCredentials(why);",
+  "  const displayRemoteUrl = scrubUrlCredentials(remoteUrl);",
+  "  const fingerprint = `openloops:pr-handoff:${taskId}:${branch || 'missing-branch'}:${commit || 'missing-commit'}`;",
+  "  const repoTagSource = String(displayRemoteUrl || worktree).split(/[/:]/).filter(Boolean).at(-1) || 'unknown';",
+  "  const repoTag = `repo:${repoTagSource.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'unknown'}`;",
+  "  const metadata = { route_enabled: true, source: 'openloops.pr-handoff', original_task_id: taskId, repo: displayRemoteUrl || '', branch: branch || '', commit: commit || '', fingerprint, automation: { allowed: true, mode: 'auto' }, no_tmux_dispatch: true };",
+  "  const description = [",
+  "    `OpenLoops could not complete no-artifact PR handoff for original task ${taskId}.`,",
+  "    `Reason: ${safeWhy}`,",
+  "    `Fingerprint: ${fingerprint}`,",
+  "    `Repository: ${displayRemoteUrl || 'unknown'}`,",
+  "    `Worktree: ${worktree}`,",
+  "    `Branch: ${branch || 'unknown'}`,",
+  "    `Commit: ${commit || 'unknown'}`,",
+  "    'Do not rerun implementation work. Use the recorded worktree/branch/commit to verify or create the PR, then comment the original task with the PR URL and validation evidence.',",
+  "  ].filter(Boolean).join('\\n\\n');",
+  "  const result = run(todosBin, todosArgs('task', 'upsert', '--fingerprint', fingerprint, '--title', `PR handoff for ${taskId}`, '-d', description, '-p', 'high', '-t', ['auto:route', 'pr-handoff', 'github', 'network', repoTag].join(','), '--metadata-json', JSON.stringify(metadata), '--working-dir', worktree));",
+  "  if (result.status !== 0) {",
+  "    const upsertError = scrubUrlCredentials(result.stderr || result.stdout || result.status);",
+  "    console.error(`todos task upsert failed: ${upsertError}`);",
+  "    comment(`openloops:pr-handoff=failed task=${taskId} fingerprint=${fingerprint} reason=todos-upsert-failed detail=${String(upsertError).slice(0, 300)}`);",
+  "    return;",
+  "  }",
+  "  comment(`openloops:pr-handoff=pending task=${taskId} fingerprint=${fingerprint} reason=${safeWhy}`);",
+  "  console.log(`queued PR handoff task fingerprint=${fingerprint}`);",
+  "};",
   "const main = () => {",
   "  let branch = expectedBranch;",
   "  if (!branch) {",
@@ -11868,17 +13966,27 @@ var PR_HANDOFF_NO_ARTIFACT_SCRIPT = [
   "    branch = String((shown.status === 0 ? shown.stdout : '') || '').trim();",
   "  }",
   "  if (!branch) { console.log('pr-handoff: no artifact and no resolvable branch; nothing to hand off'); return; }",
+  "  const head = run(gitBin, ['-C', worktree, 'rev-parse', 'HEAD']);",
+  "  const commitFromHead = String((head.status === 0 ? head.stdout : '') || '').trim();",
+  "  const remoteUrlResult = run(gitBin, ['-C', worktree, 'remote', 'get-url', 'origin']);",
+  "  const remoteUrl = String((remoteUrlResult.status === 0 ? remoteUrlResult.stdout : '') || '').trim();",
+  "  if (remoteUrl) {",
+  "    const probe = run(gitBin, ['-C', worktree, 'ls-remote', '--heads', 'origin', branch]);",
+  "    if (probe.status !== 0) { upsertTask(`github preflight failed before PR lookup: ${String(probe.stderr || probe.stdout || probe.status).slice(0, 300)}`, branch, commitFromHead, remoteUrl); return; }",
+  "  }",
   "  const listed = run(ghBin, ['pr', 'list', '--head', branch, '--state', 'open', '--json', 'url,number,headRefName,headRefOid'], { cwd: worktree });",
-  "  if (listed.status !== 0) { console.log(`pr-handoff: no artifact; PR lookup failed for branch ${branch}: ${String(listed.stderr || listed.stdout || listed.status).slice(0, 300)}`); return; }",
+  "  if (listed.status !== 0) {",
+  "    const reason = `gh PR lookup failed for branch ${branch}: ${String(listed.stderr || listed.stdout || listed.status).slice(0, 300)}`;",
+  "    if (remoteUrl) upsertTask(reason, branch, commitFromHead, remoteUrl);",
+  "    else console.log(`pr-handoff: no artifact; PR lookup failed for branch ${branch}: ${String(listed.stderr || listed.stdout || listed.status).slice(0, 300)}`);",
+  "    return;",
+  "  }",
   "  let prs = [];",
   "  try { prs = JSON.parse(String(listed.stdout || '[]')); } catch { prs = []; }",
   "  const pr = Array.isArray(prs) ? prs.find((entry) => entry && entry.headRefName === branch && typeof entry.url === 'string' && entry.url) : undefined;",
   "  if (!pr) { console.log(`pr-handoff: no artifact and no open PR for branch ${branch}; worker completed without opening a PR`); return; }",
   "  let commit = String(pr.headRefOid || '').trim();",
-  "  if (!commit) {",
-  "    const head = run(gitBin, ['-C', worktree, 'rev-parse', 'HEAD']);",
-  "    commit = String((head.status === 0 ? head.stdout : '') || '').trim();",
-  "  }",
+  "  if (!commit) commit = commitFromHead;",
   "  comment(`openloops:pr-handoff=done task=${taskId} pr=${pr.url} commit=${commit || 'unknown'} branch=${branch}`);",
   "  console.log(`PR handoff complete (worker-opened PR): ${pr.url}`);",
   "};",
@@ -12374,6 +14482,14 @@ function parseDeterministicTimeoutMs(raw, fallbackMs, label = "timeoutMs") {
     throw new Error(`${label} must be a positive integer number of milliseconds`);
   return value;
 }
+function parseNonNegativeIntegerVar(raw, fallback, label) {
+  if (raw === undefined || raw.trim() === "")
+    return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0)
+    throw new Error(`${label} must be a non-negative integer`);
+  return value;
+}
 function rolePoolValue(pool, seed, role) {
   if (!pool?.length)
     return;
@@ -12920,6 +15036,163 @@ function renderTaskLifecycleWorkflow(input) {
     steps
   };
 }
+function renderRoutingRemediationWorkflow(input) {
+  if (!input.projectPath?.trim())
+    throw new Error("projectPath is required");
+  const todosProjectPath = input.todosProjectPath ?? input.routeProjectPath ?? input.projectPath;
+  const status = input.status ?? "pending,in_progress";
+  const scope = {
+    doctorProject: input.doctorProject,
+    tag: input.tag,
+    status,
+    shard: input.shard,
+    limit: input.limit
+  };
+  const idempotencyKey = input.idempotencyKey?.trim() || [
+    "routing-remediation",
+    todosProjectPath,
+    input.doctorJsonPath ?? "doctor-live",
+    input.doctorProject ?? "all-projects",
+    input.tag ?? "all-tags",
+    status,
+    input.shard ?? "all-shards",
+    input.limit ?? "unlimited"
+  ].join(":");
+  const runId = `${slugSegment(idempotencyKey, "routing-remediation").slice(0, 48)}-${stableHex(idempotencyKey)}`;
+  const maxRepairs = input.maxRepairs ?? 25;
+  if (!Number.isInteger(maxRepairs) || maxRepairs < 0)
+    throw new Error("maxRepairs must be a non-negative integer");
+  const dryRun = input.dryRun ?? true;
+  const plan = worktreePlan(input, idempotencyKey);
+  const evidenceDir = input.evidenceDir ?? join9(input.projectPath, ".openloops", "routing-remediation");
+  const undoDir = input.undoDir ?? evidenceDir;
+  const doctorOutputPath = join9(evidenceDir, `routing-doctor-${runId}.json`);
+  const preflightOutputPath = join9(evidenceDir, `routing-remediation-preflight-${runId}.json`);
+  const applyOutputPath = join9(evidenceDir, `routing-remediation-apply-${runId}.json`);
+  const recheckOutputPath = join9(evidenceDir, `routing-remediation-recheck-${runId}.json`);
+  const undoRecordPath = join9(undoDir, `routing-remediation-${runId}.undo.json`);
+  const applyCommand = routingRemediationDoctorCommand({
+    todosProjectPath,
+    apply: true,
+    undoRecordPath,
+    ...scope
+  });
+  const recheckCommand = routingRemediationDoctorCommand({
+    todosProjectPath,
+    ...scope
+  });
+  const preflightCommand = routingRemediationPreflightCommand({
+    todosProjectPath,
+    doctorJsonPath: input.doctorJsonPath,
+    doctorOutputPath,
+    preflightOutputPath,
+    maxRepairs,
+    dryRun,
+    idempotencyKey,
+    applyCommand,
+    ...scope
+  });
+  const context = {
+    idempotencyKey,
+    projectPath: input.projectPath,
+    routeProjectPath: input.routeProjectPath,
+    projectGroup: input.projectGroup,
+    todosProjectPath,
+    doctorJsonPath: input.doctorJsonPath,
+    doctorProject: input.doctorProject,
+    tag: input.tag,
+    status,
+    shard: input.shard,
+    limit: input.limit,
+    maxRepairs,
+    dryRun,
+    evidence: {
+      doctorOutputPath,
+      preflightOutputPath,
+      applyOutputPath,
+      recheckOutputPath,
+      undoRecordPath
+    },
+    worktree: worktreeContextFragment(plan)
+  };
+  const shared = [
+    worktreePrompt(plan),
+    "Routing remediation contract:",
+    `- Todos project path: ${todosProjectPath}`,
+    `- Idempotency key: ${idempotencyKey}`,
+    `- Dry-run/preflight mode: ${dryRun ? "true" : "false"}`,
+    `- Max safe_auto repairs for this run: ${maxRepairs}`,
+    `- Source doctor JSON: ${input.doctorJsonPath ?? "generated by routing-doctor-preflight"}`,
+    `- Normalized doctor JSON: ${doctorOutputPath}`,
+    `- Preflight JSON: ${preflightOutputPath}`,
+    `- Apply JSON target: ${applyOutputPath}`,
+    `- Recheck JSON target: ${recheckOutputPath}`,
+    `- Undo record target: ${undoRecordPath}`,
+    "Never edit the Todos SQLite database, raw DB files, or task JSON storage directly. Do not use sqlite3, ad hoc SQL, or filesystem mutations as a repair mechanism.",
+    "Only supported Todos CLI/API commands may mutate tasks. Safe repairs are limited to doctor findings classified safe_auto whose suggested_repair.field is working_dir or task_list_id.",
+    "Refuse blocker_human, blocker_cross_repo, blocker_invalid_path, unsupported, legal, and other human-judgement findings as mutations. File or update blocker tasks instead.",
+    NO_TMUX_DISPATCH_FRAGMENT,
+    "",
+    `Routing remediation context JSON: ${compactJson(context)}`
+  ].join(`
+`);
+  const workerPrompt = [
+    ...boundedStepHeaderFragment("Apply bounded routing-doctor remediation from preflight evidence.", "worker", "bounded"),
+    shared,
+    "Read the preflight JSON before making any mutation. If preflight apply_allowed is false, do not run the apply command.",
+    dryRun ? "This workflow was rendered with dryRun=true. Do not run the apply command; produce only a dry-run summary and blocker-task preview/update evidence." : `If preflight permits apply, run the supported repair command and capture stdout JSON to ${applyOutputPath}: ${applyCommand}`,
+    `After any apply run, recheck route state and capture stdout JSON to ${recheckOutputPath}: ${recheckCommand}`,
+    "For every modified task, ensure a task comment records old value, new value, repair command, source doctor run, undo record, and route-state recheck result. If the Todos CLI already wrote a complete per-task repair comment, verify it; otherwise add the missing evidence with todos comment.",
+    "Create or update deduped blocker tasks for every blocker_human, blocker_cross_repo, blocker_invalid_path, unsupported, legal, or otherwise unsupported finding.",
+    [
+      "Blocker task command shape:",
+      `todos --project ${todosProjectPath} task upsert --fingerprint "routing-health:blocker:<source-task-id>:<finding-category>" --title "Routing remediation blocker: <finding-category> for <source-task-id>" -d "<source task id, finding category, repair_class, old value, new value, source doctor run, and why automation refused mutation>" -p high -t from-kai,routing-health`
+    ].join(`
+`),
+    "Do not change cross-repo task intent. A cross-repo finding can only be changed when the doctor itself classifies the exact field repair as safe_auto and the supported Todos repair command applies it.",
+    "Record compact workflow evidence: changed tasks, blocker fingerprints, apply/recheck artifact paths, undo record path, validation results, and residual risks."
+  ].join(`
+`);
+  const verifierPrompt = [
+    ...boundedStepHeaderFragment("Verify bounded routing-doctor remediation evidence.", "verifier", "bounded"),
+    shared,
+    adversarialReviewFragment("the preflight artifact, apply output, undo record, blocker tasks, per-task comments, and route-state recheck", TASK_REVIEW_FOCUS),
+    verifierRuntimeGuidance(input),
+    `Re-run or inspect the route-state recheck command as needed: ${recheckCommand}`,
+    "Confirm safe_auto repairs were limited to working_dir and task_list_id, raw DB edits were not used, cross-repo/human/legal/unsupported findings became from-kai,routing-health blocker tasks, and every changed task has old/new/command/source/recheck evidence.",
+    "If dry-run mode was rendered, verify that no apply/repair mutation occurred and that the output is clearly preflight-only.",
+    "If invalid, record precise blocker evidence and create follow-up tasks rather than broad fixes.",
+    VERIFIER_TINY_FIXES_FRAGMENT
+  ].join(`
+`);
+  return {
+    name: `routing-remediation-${runId}`,
+    description: `Routing doctor remediation workflow; dryRun=${dryRun}; maxRepairs=${maxRepairs}; idempotency=${idempotencyKey}`,
+    version: 1,
+    steps: [
+      commandStep({
+        id: "routing-doctor-preflight",
+        name: "Routing Doctor Preflight",
+        description: "Run or consume routing doctor JSON, enforce safe-field and repair-capacity gates, and write bounded evidence.",
+        command: preflightCommand,
+        cwd: input.projectPath,
+        timeoutMs: 5 * 60000,
+        idleTimeoutMs: 60000,
+        blockedExitCodes: GATE_BLOCKED_EXIT_CODES
+      }),
+      ...workerVerifierSteps({
+        input,
+        seed: idempotencyKey,
+        plan,
+        workerPrompt,
+        verifierPrompt,
+        workerDescription: "Apply only supported Todos CLI safe_auto repairs and file blocker tasks.",
+        verifierDescription: "Adversarially verify routing remediation evidence and safety boundaries.",
+        workerDependsOn: ["routing-doctor-preflight"]
+      })
+    ]
+  };
+}
 function renderEventWorkerVerifierWorkflow(input) {
   if (!input.eventId?.trim())
     throw new Error("eventId is required");
@@ -13178,10 +15451,32 @@ function renderDeterministicCheckCreateTaskWorkflow(values) {
     ]
   };
 }
+function renderRoutingRemediationTemplate(values) {
+  const base = agentTemplateInput(values);
+  return renderRoutingRemediationWorkflow({
+    ...base,
+    todosProjectPath: values.todosProjectPath ?? values.todosProject,
+    doctorJsonPath: values.doctorJsonPath,
+    doctorProject: values.doctorProject,
+    tag: values.tag,
+    status: values.status,
+    shard: values.shard,
+    limit: values.limit,
+    maxRepairs: parseNonNegativeIntegerVar(values.maxRepairs, 25, "maxRepairs"),
+    dryRun: booleanVar(values.dryRun) ?? true,
+    idempotencyKey: values.idempotencyKey,
+    evidenceDir: values.evidenceDir,
+    undoDir: values.undoDir,
+    worktreeMode: base.worktreeMode ?? "required"
+  });
+}
 function renderBuiltinLoopTemplate(id, values) {
   if (id === DETERMINISTIC_CHECK_CREATE_TASK_TEMPLATE_ID) {
     return renderDeterministicCheckCreateTaskWorkflow(values);
   }
+  if (id === ROUTING_REMEDIATION_TEMPLATE_ID) {
+    return renderRoutingRemediationTemplate(values);
+  }
   const lifecycle = renderLifecycleBoundedTemplate(id, values);
   if (lifecycle)
     return lifecycle;