@hasna/loops 0.4.13 → 0.4.14

package/dist/daemon/index.js

@@ -3,9 +3,9 @@
 
 // src/lib/store.ts
 import { Database } from "bun:sqlite";
-import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync2 } from "fs";
-import { tmpdir } from "os";
-import { basename as basename2, dirname as dirname2, join as join3 } from "path";
+import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname2, join as join4 } from "path";
 
 // src/lib/errors.ts
 class CodedError extends Error {
@@ -1204,6 +1204,196 @@ function discardWorkflowRunManifest(staged) {
   } catch {}
 }
 
+// src/lib/route/todos-cli.ts
+import { closeSync, mkdtempSync, openSync, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { join as join3 } from "path";
+import { homedir as homedir2, tmpdir } from "os";
+
+// src/lib/format.ts
+var TEXT_OUTPUT_LIMIT = 32 * 1024;
+var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
+function redact(value, visible = 0) {
+  if (!value)
+    return value;
+  if (value.length <= visible)
+    return value;
+  if (visible <= 0)
+    return `[redacted ${value.length} chars]`;
+  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
+}
+function truncateTextOutput(value) {
+  if (value.length <= TEXT_OUTPUT_LIMIT)
+    return value;
+  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
+[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
+}
+function redactSensitivePayload(value, key) {
+  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
+    if (typeof value === "string")
+      return redact(value);
+    if (value === undefined || value === null)
+      return value;
+    return "[redacted]";
+  }
+  if (Array.isArray(value))
+    return value.map((item) => redactSensitivePayload(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
+  }
+  return value;
+}
+function textOutputBlocks(value, opts = {}) {
+  const indent = opts.indent ?? "";
+  const nested = `${indent}  `;
+  const blocks = [];
+  for (const [label, output] of [
+    ["stdout", value.stdout],
+    ["stderr", value.stderr]
+  ]) {
+    if (!output)
+      continue;
+    blocks.push(`${indent}${label}:`);
+    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
+      blocks.push(`${nested}${line}`);
+    }
+  }
+  return blocks;
+}
+function publicLoop(loop) {
+  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
+  return {
+    ...loop,
+    target
+  };
+}
+function publicRun(run, showOutput = false, opts = {}) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: opts.redactError ? redact(run.error) : run.error
+  };
+}
+function publicExecutorResult(result, showOutput = false) {
+  return {
+    ...result,
+    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
+    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
+    error: redact(result.error)
+  };
+}
+function publicWorkflow(workflow) {
+  return {
+    ...workflow,
+    steps: workflow.steps.map((step) => ({
+      ...step,
+      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
+    }))
+  };
+}
+function publicWorkflowRun(run) {
+  return { ...run, error: redact(run.error) };
+}
+function publicWorkflowInvocation(invocation) {
+  return redactSensitivePayload(invocation);
+}
+function publicWorkflowWorkItem(item) {
+  return { ...item, lastReason: redact(item.lastReason, 240) };
+}
+function publicWorkflowStepRun(run, showOutput = false) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: redact(run.error)
+  };
+}
+function publicWorkflowEvent(event) {
+  return { ...event, payload: redactSensitivePayload(event.payload) };
+}
+function publicGoal(goal) {
+  return {
+    ...goal,
+    objective: redact(goal.objective, 120)
+  };
+}
+function publicGoalRun(run) {
+  return {
+    ...run,
+    evidence: redactSensitivePayload(run.evidence),
+    rawResponse: redactSensitivePayload(run.rawResponse)
+  };
+}
+
+// src/lib/route/todos-cli.ts
+function defaultLoopsProject() {
+  return process.env.LOOPS_TASK_PROJECT || process.env.LOOPS_DATA_DIR || `${process.env.HOME || homedir2()}/.hasna/loops`;
+}
+function runLocalCommand(command, args, opts = {}) {
+  const result = spawnSync2(command, args, {
+    input: opts.input,
+    encoding: "utf8",
+    timeout: opts.timeoutMs ?? 30000,
+    maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+    env: process.env
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error ? String(result.error.message || result.error) : ""
+  };
+}
+function runLocalCommandWithStdoutFile(command, args, opts = {}) {
+  const tempDir = mkdtempSync(join3(tmpdir(), "loops-command-output-"));
+  const stdoutPath = join3(tempDir, "stdout");
+  const stdoutFd = openSync(stdoutPath, "w");
+  let result;
+  try {
+    result = spawnSync2(command, args, {
+      input: opts.input,
+      encoding: "utf8",
+      timeout: opts.timeoutMs ?? 30000,
+      maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+      env: process.env,
+      stdio: ["pipe", stdoutFd, "pipe"]
+    });
+  } finally {
+    closeSync(stdoutFd);
+  }
+  try {
+    return {
+      ok: result.status === 0,
+      status: result.status,
+      stdout: readFileSync3(stdoutPath, "utf8"),
+      stderr: typeof result.stderr === "string" ? result.stderr : result.stderr?.toString() || "",
+      error: result.error ? String(result.error.message || result.error) : ""
+    };
+  } finally {
+    rmSync2(tempDir, { recursive: true, force: true });
+  }
+}
+function ensureTodosTaskList(project, slug, name, description) {
+  runLocalCommand("todos", ["--project", project, "task-lists", "--add", name, "--slug", slug, "-d", description]);
+  const list = runLocalCommand("todos", ["--project", project, "--json", "task-lists"]);
+  if (!list.ok)
+    throw new Error(list.stderr || list.error || "failed to list todos task lists");
+  const values = JSON.parse(list.stdout || "[]");
+  const found = values.find((entry) => entry.slug === slug);
+  if (!found)
+    throw new Error(`todos task list not found after ensure: ${slug}`);
+  return found.id;
+}
+function todosMutationSummary(result) {
+  return {
+    ok: result.ok,
+    status: result.status,
+    error: result.ok ? undefined : redact(result.stderr || result.error || "todos mutation failed", 320)
+  };
+}
+
 // src/lib/store.ts
 var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
@@ -1213,6 +1403,7 @@ var TERMINAL_RUN_STATUSES = ["succeeded", "failed", "timed_out", "abandoned", "s
 var PRUNE_BATCH_SIZE = 400;
 var GENERATED_ROUTE_TEMPLATE_IDS = new Set(["todos-task-worker-verifier", "task-lifecycle", "event-worker-verifier"]);
 var GENERATED_ROUTE_KEYS = new Set(["todos-task", "generic-event"]);
+var TASK_LIFECYCLE_TEMPLATE_ID = "task-lifecycle";
 function rowToLoop(row) {
   return {
     id: row.id,
@@ -1263,6 +1454,9 @@ function rowToRun(row) {
     updatedAt: row.updated_at
   };
 }
+function latestRunTime(row) {
+  return row.finished_at ?? row.started_at ?? row.created_at;
+}
 function rowToWorkflow(row) {
   return {
     id: row.id,
@@ -1517,7 +1711,7 @@ class Store {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
-    this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    this.rootDir = file === ":memory:" ? mkdtempSync2(join4(tmpdir2(), "open-loops-store-")) : dirname2(file);
     if (file === ":memory:")
       this.memoryRootDir = this.rootDir;
     this.db = new Database(file);
@@ -2015,7 +2209,32 @@ class Store {
     } else {
       rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
     }
-    return rows.map(rowToLoop);
+    return this.withLatestRunSummaries(rows.map(rowToLoop));
+  }
+  withLatestRunSummaries(loops) {
+    if (loops.length === 0)
+      return loops;
+    const placeholders = loops.map(() => "?").join(",");
+    const rows = this.db.query(`SELECT loop_id, id, status, started_at, finished_at, created_at
+         FROM (
+           SELECT loop_id, id, status, started_at, finished_at, created_at,
+             ROW_NUMBER() OVER (PARTITION BY loop_id ORDER BY created_at DESC, id DESC) AS rn
+           FROM loop_runs
+           WHERE loop_id IN (${placeholders})
+         )
+         WHERE rn = 1`).all(...loops.map((loop) => loop.id));
+    const latestByLoopId = new Map(rows.map((row) => [row.loop_id, row]));
+    return loops.map((loop) => {
+      const latest = latestByLoopId.get(loop.id);
+      if (!latest)
+        return loop;
+      return {
+        ...loop,
+        latestRunId: latest.id,
+        latestRunStatus: latest.status,
+        lastRunAt: latestRunTime(latest)
+      };
+    });
   }
   dueLoops(now, limit = 500) {
     const rows = this.db.query(`SELECT * FROM loops
@@ -2134,6 +2353,45 @@ class Store {
       throw error;
     }
   }
+  updateAgentLoopTimeout(idOrName, timeoutMs, opts = {}) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireUniqueLoop(idOrName);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || current.id);
+      if (current.target.type !== "agent")
+        throw new Error(`loop is not an agent loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to update running loop: ${current.id}`);
+      const target = { ...current.target, timeoutMs };
+      if (timeoutMs === null && target.idleTimeoutMs !== undefined)
+        delete target.idleTimeoutMs;
+      const res = this.db.query(`UPDATE loops SET target_json=$target, updated_at=$updated
+           WHERE id=$id
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $id: current.id,
+        $target: JSON.stringify(target),
+        $updated: updated,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: updated
+      });
+      if (res.changes !== 1)
+        throw new Error("daemon lease lost");
+      this.db.exec("COMMIT");
+      const after = this.getLoop(current.id);
+      if (!after)
+        throw new Error(`loop not found after timeout update: ${current.id}`);
+      return after;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
   createAndRetargetWorkflowLoop(idOrName, workflowInput, opts = {}) {
     const normalized = normalizeCreateWorkflowInput(workflowInput);
     const updated = (opts.now ?? new Date).toISOString();
@@ -2464,6 +2722,59 @@ class Store {
       updated
     });
   }
+  taskLifecycleTodosPointerContext(workflowRunId) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run || run.status !== "succeeded" || !run.invocationId || !run.workItemId || !run.manifestPath)
+      return;
+    const workItem = this.getWorkflowWorkItem(run.workItemId);
+    if (!workItem || workItem.routeKey !== "todos-task")
+      return;
+    const invocation = this.getWorkflowInvocation(run.invocationId);
+    if (!invocation || invocation.templateId !== TASK_LIFECYCLE_TEMPLATE_ID)
+      return;
+    const projectPath = workItem.projectKey ?? invocation.scope?.projectPath;
+    const taskId = invocation.subjectRef.id ?? workItem.subjectRef;
+    if (!projectPath || !taskId)
+      return;
+    return {
+      projectPath,
+      taskId,
+      invocationId: invocation.id,
+      workflowRunId: run.id,
+      manifestPath: run.manifestPath
+    };
+  }
+  syncSuccessfulTaskLifecycleTodosPointers(workflowRunId) {
+    const context = this.taskLifecycleTodosPointerContext(workflowRunId);
+    if (!context)
+      return;
+    const result = runLocalCommand("todos", [
+      "--project",
+      context.projectPath,
+      "task",
+      "workflow-pointers",
+      context.taskId,
+      "--clear",
+      "--invocation",
+      context.invocationId,
+      "--run",
+      context.workflowRunId,
+      "--manifest",
+      context.manifestPath,
+      "--state",
+      "succeeded",
+      "--actor",
+      "openloops:task-lifecycle"
+    ]);
+    this.appendWorkflowEvent(workflowRunId, result.ok ? "todos_workflow_pointers_synced" : "todos_workflow_pointers_sync_failed", undefined, {
+      projectPath: context.projectPath,
+      taskId: context.taskId,
+      invocationId: context.invocationId,
+      workflowRunId: context.workflowRunId,
+      manifestPath: context.manifestPath,
+      mutation: todosMutationSummary(result)
+    });
+  }
   createWorkflowInvocation(input) {
     const now = nowIso();
     const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
@@ -3426,6 +3737,8 @@ class Store {
     const run = this.getWorkflowRun(workflowRunId);
     if (!run)
       throw new Error(`workflow run not found after finalize: ${workflowRunId}`);
+    if (changed && status === "succeeded")
+      this.syncSuccessfulTaskLifecycleTodosPointers(workflowRunId);
     return run;
   }
   cancelWorkflowRun(workflowRunId, reason = "cancelled by user") {
@@ -3487,6 +3800,17 @@ class Store {
     const row = this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE loop_id = ? AND scheduled_for = ? AND status = 'running'").get(loopId, scheduledFor);
     return (row?.count ?? 0) > 0;
   }
+  hasBlockingRunningRunForOtherSlot(loopId, scheduledFor, nowIso2) {
+    const rows = this.db.query(`SELECT * FROM loop_runs
+         WHERE loop_id = ? AND scheduled_for <> ? AND status = 'running'`).all(loopId, scheduledFor);
+    return rows.some((row) => {
+      if (!row.lease_expires_at || row.lease_expires_at > nowIso2)
+        return true;
+      if (isRecordedProcessAlive(row.pid, row.process_started_at))
+        return true;
+      return this.hasLiveWorkflowStepProcesses(row.id);
+    });
+  }
   markRunPid(id, pid, claimedBy, opts = {}) {
     const now = (opts.now ?? new Date).toISOString();
     const startedMs = processStartTimeMs(pid);
@@ -3619,6 +3943,10 @@ class Store {
       loop = currentLoop;
       const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
       const existing = this.getRunBySlot(loop.id, scheduledFor);
+      if (loop.overlap === "skip" && this.hasBlockingRunningRunForOtherSlot(loop.id, scheduledFor, startedAt)) {
+        this.db.exec("COMMIT");
+        return;
+      }
       if (existing) {
         if (existing.status === "running") {
           if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && isRecordedProcessAlive(existing.pid, existing.processStartedAt)) {
@@ -4190,9 +4518,9 @@ class Store {
       const runDir = dirname2(manifestPath);
       try {
         if (/^[0-9a-f]{12,64}$/.test(basename2(runDir))) {
-          rmSync2(runDir, { recursive: true, force: true });
+          rmSync3(runDir, { recursive: true, force: true });
         } else {
-          rmSync2(manifestPath, { force: true });
+          rmSync3(manifestPath, { force: true });
         }
       } catch {}
     }
@@ -4259,7 +4587,7 @@ class Store {
     this.db.close();
     if (this.memoryRootDir) {
       try {
-        rmSync2(this.memoryRootDir, { recursive: true, force: true });
+        rmSync3(this.memoryRootDir, { recursive: true, force: true });
       } catch {}
       this.memoryRootDir = undefined;
     }
@@ -4270,136 +4598,24 @@ class Store {
 import { Command } from "commander";
 
 // src/daemon/daemon.ts
-import { copyFileSync, existsSync as existsSync5, openSync, renameSync as renameSync2, rmSync as rmSync4, statSync, truncateSync } from "fs";
+import { copyFileSync, existsSync as existsSync5, openSync as openSync2, renameSync as renameSync2, rmSync as rmSync5, statSync, truncateSync } from "fs";
 import { hostname as hostname2 } from "os";
 import { spawn as spawn3 } from "child_process";
 
 // src/lib/health.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-
-// src/lib/format.ts
-var TEXT_OUTPUT_LIMIT = 32 * 1024;
-var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
-function redact(value, visible = 0) {
-  if (!value)
-    return value;
-  if (value.length <= visible)
-    return value;
-  if (visible <= 0)
-    return `[redacted ${value.length} chars]`;
-  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
-}
-function truncateTextOutput(value) {
-  if (value.length <= TEXT_OUTPUT_LIMIT)
-    return value;
-  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
-[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
-}
-function redactSensitivePayload(value, key) {
-  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
-    if (typeof value === "string")
-      return redact(value);
-    if (value === undefined || value === null)
-      return value;
-    return "[redacted]";
-  }
-  if (Array.isArray(value))
-    return value.map((item) => redactSensitivePayload(item));
-  if (value && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
-  }
-  return value;
-}
-function textOutputBlocks(value, opts = {}) {
-  const indent = opts.indent ?? "";
-  const nested = `${indent}  `;
-  const blocks = [];
-  for (const [label, output] of [
-    ["stdout", value.stdout],
-    ["stderr", value.stderr]
-  ]) {
-    if (!output)
-      continue;
-    blocks.push(`${indent}${label}:`);
-    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
-      blocks.push(`${nested}${line}`);
-    }
-  }
-  return blocks;
-}
-function publicLoop(loop) {
-  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
-  return {
-    ...loop,
-    target
-  };
-}
-function publicRun(run, showOutput = false, opts = {}) {
-  return {
-    ...run,
-    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
-    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
-    error: opts.redactError ? redact(run.error) : run.error
-  };
-}
-function publicExecutorResult(result, showOutput = false) {
-  return {
-    ...result,
-    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
-    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
-    error: redact(result.error)
-  };
-}
-function publicWorkflow(workflow) {
-  return {
-    ...workflow,
-    steps: workflow.steps.map((step) => ({
-      ...step,
-      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
-    }))
-  };
-}
-function publicWorkflowRun(run) {
-  return { ...run, error: redact(run.error) };
-}
-function publicWorkflowInvocation(invocation) {
-  return redactSensitivePayload(invocation);
-}
-function publicWorkflowWorkItem(item) {
-  return { ...item, lastReason: redact(item.lastReason, 240) };
-}
-function publicWorkflowStepRun(run, showOutput = false) {
-  return {
-    ...run,
-    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
-    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
-    error: redact(run.error)
-  };
-}
-function publicWorkflowEvent(event) {
-  return { ...event, payload: redactSensitivePayload(event.payload) };
-}
-function publicGoal(goal) {
-  return {
-    ...goal,
-    objective: redact(goal.objective, 120)
-  };
-}
-function publicGoalRun(run) {
-  return {
-    ...run,
-    evidence: redactSensitivePayload(run.evidence),
-    rawResponse: redactSensitivePayload(run.rawResponse)
-  };
-}
-
-// src/lib/health.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 var EVIDENCE_CHARS = 2000;
 var FINGERPRINT_EVIDENCE_CHARS = 120;
+var DEFAULT_SCAN_LIMIT = 200;
+var DEFAULT_SCAN_STATUSES = ["active", "paused"];
+var DEFAULT_MAX_FINDINGS = 100;
+var MIN_STALE_RUNNING_MS = 10 * 60000;
 var CLASSIFICATIONS = [
   "rate_limit",
   "auth",
+  "provider_unavailable",
   "model_not_found",
   "context_length",
   "schema_response_format",
@@ -4408,10 +4624,12 @@ var CLASSIFICATIONS = [
   "route_functional",
   "timeout",
   "sigsegv",
+  "restart_interrupted",
   "skipped_previous_active",
   "circuit_breaker",
   "unknown"
 ];
+var RESTART_INTERRUPTED_RUN_PREFIX = "daemon restart interrupted active run";
 function bounded(value, limit = EVIDENCE_CHARS) {
   if (!value)
     return;
@@ -4425,7 +4643,7 @@ function redactedEvidence(value) {
 }
 function searchableText(run) {
   return [run.error, run.stderr, run.stdout].filter(Boolean).join(`
-`).toLowerCase();
+`);
 }
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -4450,13 +4668,36 @@ function stableFingerprint(parts) {
   return createHash2("sha256").update(parts.join(`
 `)).digest("hex").slice(0, 16);
 }
-function stableFailureFingerprint(run, classification) {
+function stableScanFingerprint(parts) {
+  return `openloops:health-scan:${stableFingerprint(parts)}`;
+}
+function safeHost(value) {
+  if (!value)
+    return;
+  let host = value.trim().replace(/^[a-z]+:\/\//i, "").split(/[/:?#\s)"'\\]+/)[0] ?? "";
+  host = host.replace(/^\[|\]$/g, "");
+  return /^[a-z0-9.-]+$/i.test(host) ? host.toLowerCase() : undefined;
+}
+function isCursorHost(host) {
+  return host === "cursor.sh" || Boolean(host?.endsWith(".cursor.sh"));
+}
+function providerUnavailableSummary(rawText) {
+  const dns = /\bgetaddrinfo\s+(EAI_AGAIN|ENOTFOUND)\s+([a-z0-9.-]+)/i.exec(rawText);
+  if (dns) {
+    const host = safeHost(dns[2]);
+    if (isCursorHost(host))
+      return `provider DNS lookup failed: ${dns[1]} ${host}`;
+  }
+  return;
+}
+function stableFailureFingerprint(run, classification, summary) {
+  const evidence = summary ?? (classification === "provider_unavailable" ? providerUnavailableSummary(searchableText(run)) : undefined) ?? run.error ?? run.stderr ?? run.stdout ?? "";
   return stableFingerprint([
     run.loopId,
     classification,
     String(run.status),
     String(run.exitCode ?? ""),
-    (run.error ?? run.stderr ?? run.stdout ?? "").replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
+    evidence.replace(/\d{4}-\d{2}-\d{2}T\S+/g, "<timestamp>").slice(0, FINGERPRINT_EVIDENCE_CHARS)
   ]);
 }
 function stableRouteFunctionalFingerprint(loop, reason) {
@@ -4474,13 +4715,279 @@ function healthRun(run) {
     stderr: redactedEvidence(run.stderr)
   };
 }
+function compactText(value, limit = 500) {
+  const text = redact(bounded(value, limit));
+  return text?.replace(/\s+/g, " ").trim();
+}
+function publicDoctorCheck(check) {
+  return {
+    id: check.id,
+    status: check.status,
+    message: redact(bounded(check.message, 500)) ?? "",
+    detail: redact(bounded(check.detail, 800))
+  };
+}
+function publicDoctorReport(report) {
+  return {
+    ok: report.ok,
+    checks: report.checks.map(publicDoctorCheck)
+  };
+}
+function includedStatusSet(statuses) {
+  const values = statuses?.length ? statuses : DEFAULT_SCAN_STATUSES;
+  return new Set(values);
+}
+function statusCounts(loops) {
+  return {
+    loops: loops.length,
+    active: loops.filter((loop) => loop.status === "active").length,
+    paused: loops.filter((loop) => loop.status === "paused").length,
+    stopped: loops.filter((loop) => loop.status === "stopped").length,
+    expired: loops.filter((loop) => loop.status === "expired").length
+  };
+}
+function compareLoopsForScan(left, right) {
+  const statusOrder = left.status.localeCompare(right.status);
+  if (statusOrder !== 0)
+    return statusOrder;
+  return (left.nextRunAt ?? "").localeCompare(right.nextRunAt ?? "");
+}
+function scanLoops(store, statuses, opts) {
+  const limit = opts.limit ?? DEFAULT_SCAN_LIMIT;
+  return statuses.flatMap((status) => store.listLoops({ includeArchived: opts.includeArchived, status, limit })).sort(compareLoopsForScan).slice(0, limit);
+}
+function healthReportForLoops(store, loops, generatedAt) {
+  const expectations = loops.map((loop) => expectationForLoop(store, loop));
+  const classifications = Object.fromEntries(CLASSIFICATIONS.map((key) => [key, 0]));
+  for (const expectation of expectations) {
+    if (expectation.failure)
+      classifications[expectation.failure.classification] += 1;
+  }
+  const unhealthy = expectations.filter((expectation) => !expectation.ok).length;
+  const warnings = expectations.filter((expectation) => expectation.check.status === "warn").length;
+  return {
+    ok: unhealthy === 0,
+    generatedAt,
+    summary: {
+      loops: expectations.length,
+      healthy: expectations.length - unhealthy,
+      unhealthy,
+      warnings
+    },
+    classifications,
+    expectations
+  };
+}
+function ageMs(run, now) {
+  const stamp = run.startedAt ?? run.createdAt ?? run.scheduledFor;
+  const time = Date.parse(stamp);
+  return Number.isFinite(time) ? Math.max(0, now.getTime() - time) : 0;
+}
+function shortLoop(loop) {
+  return {
+    id: loop.id,
+    name: loop.name,
+    status: loop.status,
+    nextRunAt: loop.nextRunAt,
+    leaseMs: loop.leaseMs
+  };
+}
+function priorityForSeverity(severity) {
+  if (severity === "critical")
+    return "critical";
+  if (severity === "high")
+    return "high";
+  if (severity === "low")
+    return "low";
+  return "medium";
+}
+function recommendedFindingTask(finding, route) {
+  const tags = ["bug", "openloops", "loops", "loop-health", finding.kind];
+  if (finding.classification)
+    tags.push(finding.classification);
+  const description = [
+    `OpenLoops health scan found a ${finding.kind} issue.`,
+    finding.loop ? `Loop: ${finding.loop.name} (${finding.loop.id})` : undefined,
+    finding.run ? `Run: ${finding.run.id}` : undefined,
+    finding.classification ? `Classification: ${finding.classification}` : undefined,
+    finding.ageMs !== undefined ? `AgeMs: ${finding.ageMs}` : undefined,
+    finding.staleThresholdMs !== undefined ? `StaleThresholdMs: ${finding.staleThresholdMs}` : undefined,
+    `Fingerprint: ${finding.fingerprint}`,
+    `Severity: ${finding.severity}`,
+    `No-tmux routing: Do not dispatch or paste prompts into tmux panes; use task-triggered headless worker/verifier workflows only.`,
+    route?.cwd ? `Route cwd: ${route.cwd}` : undefined,
+    route?.provider ? `Provider: ${route.provider}` : undefined,
+    "",
+    finding.message,
+    finding.run?.error ? `Error:
+${finding.run.error}` : undefined,
+    finding.run?.stderr ? `Stderr:
+${finding.run.stderr}` : undefined
+  ].filter(Boolean).join(`
+
+`);
+  return {
+    title: finding.title,
+    description,
+    priority: priorityForSeverity(finding.severity),
+    tags,
+    dedupeKey: finding.fingerprint,
+    search: { query: finding.fingerprint },
+    compatibilityFallback: {
+      search: ["todos", "search", finding.fingerprint, "--json"],
+      add: ["todos", "add", finding.title, "--description", description, "--tag", tags.join(","), "--priority", priorityForSeverity(finding.severity)],
+      comment: ["todos", "comment", "<task-id>", description]
+    },
+    futureNativeUpsert: {
+      command: "todos task upsert",
+      fields: {
+        title: finding.title,
+        description,
+        priority: priorityForSeverity(finding.severity),
+        tags,
+        dedupeKey: finding.fingerprint,
+        routeSource: route?.source ?? "openloops",
+        routeKind: route?.kind ?? "health_scan",
+        routeLoopId: finding.loop?.id ?? "",
+        routeLoopName: finding.loop?.name ?? ""
+      }
+    }
+  };
+}
+function daemonFinding(daemon) {
+  if (daemon.running && !daemon.stale)
+    return;
+  const reason = daemon.stale ? "daemon pid file is stale" : "daemon is not running";
+  const severity = "critical";
+  const finding = {
+    kind: "daemon",
+    severity,
+    fingerprint: `openloops:health-scan:daemon:${daemon.stale ? "stale" : "not-running"}`,
+    title: "OpenLoops daemon health issue",
+    message: reason
+  };
+  return {
+    ...finding,
+    recommendedTask: recommendedFindingTask(finding, undefined)
+  };
+}
+function doctorSeverity(check) {
+  if (check.status === "fail" && check.id === "data-dir")
+    return "critical";
+  if (check.status === "fail")
+    return "high";
+  return "medium";
+}
+function doctorFinding(check, loop, route) {
+  if (check.status === "ok" || check.id === "loop-runs")
+    return;
+  const kind = check.id.startsWith("loop:") && check.id.endsWith(":preflight") ? "preflight" : "doctor";
+  const severity = kind === "preflight" && check.status === "fail" ? "high" : doctorSeverity(check);
+  const fingerprint = stableScanFingerprint(["doctor", check.id, check.status, check.message, check.detail ?? ""]);
+  const finding = {
+    kind,
+    severity,
+    fingerprint,
+    title: kind === "preflight" && loop ? `OpenLoops preflight issue - ${loop.name}` : `OpenLoops doctor issue - ${check.id}`,
+    message: [check.status, check.message, check.detail].filter(Boolean).join(" "),
+    loop: loop ? shortLoop(loop) : undefined,
+    route,
+    doctorCheck: publicDoctorCheck(check)
+  };
+  return {
+    ...finding,
+    recommendedTask: recommendedFindingTask(finding, route)
+  };
+}
+function latestRunFinding(expectation) {
+  if (expectation.ok || !expectation.latestRun || expectation.latestRun.status === "running")
+    return;
+  const failure = expectation.failure;
+  if (!failure)
+    return;
+  const severity = expectation.loop.status === "active" ? "high" : "medium";
+  return {
+    kind: "latest-run",
+    severity,
+    fingerprint: expectation.recommendedTask?.dedupeKey ?? `openloops:${expectation.loop.id}:${failure.fingerprint}`,
+    title: expectation.recommendedTask?.title ?? `OpenLoops latest run failed - ${expectation.loop.name}`,
+    message: expectation.check.message,
+    loop: expectation.loop,
+    run: expectation.latestRun,
+    route: expectation.route,
+    classification: failure.classification,
+    doctorCheck: undefined,
+    recommendedTask: expectation.recommendedTask
+  };
+}
+function staleRunningFinding(loop, expectation, now, staleRunningMs) {
+  const run = expectation.latestRun;
+  if (loop.status !== "active" || run?.status !== "running")
+    return;
+  const threshold = Math.max(loop.leaseMs, staleRunningMs, MIN_STALE_RUNNING_MS);
+  const age = ageMs(run, now);
+  if (age <= threshold)
+    return;
+  const fingerprint = `openloops:health-scan:stale-running:${loop.id}:${run.id}`;
+  const message = `active loop latest run is still running after ${age}ms (threshold ${threshold}ms)`;
+  const finding = {
+    kind: "stale-running",
+    severity: "critical",
+    fingerprint,
+    title: `OpenLoops stale running run - ${loop.name}`,
+    message,
+    loop: shortLoop(loop),
+    run,
+    route: expectation.route,
+    ageMs: age,
+    staleThresholdMs: threshold
+  };
+  return {
+    ...finding,
+    recommendedTask: recommendedFindingTask(finding, expectation.route)
+  };
+}
+function scanStatus(findings) {
+  if (findings.some((finding) => finding.severity === "critical"))
+    return "critical";
+  if (findings.length > 0)
+    return "degraded";
+  return "ok";
+}
+function timestampDir(root, generatedAt) {
+  const stamp = generatedAt.replace(/[-:]/g, "").replace(/\./g, "");
+  return join5(root, stamp);
+}
+function healthScanMarkdown(scan) {
+  return [
+    "# OpenLoops Health Scan",
+    "",
+    `- status: ${scan.status}`,
+    `- generated_at: ${scan.generatedAt}`,
+    `- included_statuses: ${scan.includedStatuses.join(",")}`,
+    `- loops: total=${scan.counts.loops} active=${scan.counts.active} paused=${scan.counts.paused} stopped=${scan.counts.stopped} expired=${scan.counts.expired}`,
+    `- findings: total=${scan.counts.findings} reported=${scan.counts.reportedFindings} truncated=${scan.counts.truncatedFindings} latest_run=${scan.counts.latestRunFindings} stale_running=${scan.counts.staleRunning} daemon=${scan.counts.daemonFindings} doctor=${scan.counts.doctorFindings} preflight=${scan.counts.preflightFindings}`,
+    scan.daemon ? `- daemon: running=${scan.daemon.running} stale=${scan.daemon.stale} pid=${scan.daemon.pid ?? "none"}` : "- daemon: not checked",
+    scan.doctor ? `- doctor_ok: ${scan.doctor.ok}` : "- doctor: not checked",
+    scan.selfHeals.length ? `- self_heals: ${scan.selfHeals.map((action) => `${action.kind}:${action.attempted ? action.ok ? "ok" : "failed" : "skipped"}`).join(",")}` : "- self_heals: none",
+    "",
+    "## Findings",
+    scan.findings.length ? scan.findings.map((finding) => `- ${finding.severity} ${finding.kind} ${finding.fingerprint} ${finding.loop ? `${finding.loop.name}: ` : ""}${compactText(finding.message, 240) ?? ""}`).join(`
+`) : "None."
+  ].join(`
+`);
+}
 function classifyRunFailure(run) {
   if (run.status === "succeeded" || run.status === "running")
     return;
-  const text = searchableText(run);
+  const rawText = searchableText(run);
+  const text = rawText.toLowerCase();
   let classification = "unknown";
+  let summary;
   if (run.status === "timed_out")
     classification = "timeout";
+  else if (run.status === "skipped" && run.error?.startsWith(RESTART_INTERRUPTED_RUN_PREFIX))
+    classification = "restart_interrupted";
   else if (run.status === "skipped" && /circuit breaker open/.test(text))
     classification = "circuit_breaker";
   else if (run.status === "skipped" && /previous run still active/.test(text))
@@ -4489,8 +4996,10 @@ function classifyRunFailure(run) {
     classification = "preflight";
   else if (/rate limit|too many requests|429\b|quota exceeded/.test(text))
     classification = "rate_limit";
-  else if (/unauthorized|authentication|auth\b|api key|invalid token|permission denied|401\b|403\b/.test(text))
+  else if (/unauthorized|authentication|auth\b|api key|invalid token|permission denied|401\b|403\b|not logged in|please run \/login|login required|not authenticated|failed to authenticate/.test(text))
     classification = "auth";
+  else if (summary = providerUnavailableSummary(rawText))
+    classification = "provider_unavailable";
   else if (/model .*not found|model_not_found|unknown model|invalid model|404.*model/.test(text))
     classification = "model_not_found";
   else if (/context length|context_length|context window|maximum context|token limit|too many tokens/.test(text))
@@ -4503,8 +5012,9 @@ function classifyRunFailure(run) {
     classification = "sigsegv";
   return {
     classification,
-    fingerprint: stableFailureFingerprint(run, classification),
+    fingerprint: stableFailureFingerprint(run, classification, summary),
     evidence: {
+      summary,
       error: redactedEvidence(run.error),
       stdout: redactedEvidence(run.stdout),
       stderr: redactedEvidence(run.stderr),
@@ -4549,7 +5059,7 @@ function routeEvidenceReport(run) {
   const evidencePath = stringValue(stdoutReport?.evidencePath);
   if (evidencePath && existsSync2(evidencePath)) {
     try {
-      return parseJsonObject(readFileSync3(evidencePath, "utf8")) ?? stdoutReport;
+      return parseJsonObject(readFileSync4(evidencePath, "utf8")) ?? stdoutReport;
     } catch {
       return stdoutReport;
     }
@@ -4681,6 +5191,12 @@ function targetRoute(loop) {
     loopName: loop.name
   };
 }
+function expectationLoop(loop) {
+  return { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt, retryScheduledFor: loop.retryScheduledFor };
+}
+function hasPendingRetry(loop, run) {
+  return loop.status === "active" && loop.retryScheduledFor === run.scheduledFor && run.attempt < loop.maxAttempts;
+}
 function recommendedTask(loop, run, failure, route) {
   const title = `BUG: open-loops loop failure - ${loop.name}`;
   const description = [
@@ -4692,6 +5208,7 @@ function recommendedTask(loop, run, failure, route) {
     `No-tmux routing: Do not dispatch or paste prompts into tmux panes; use task-triggered headless worker/verifier workflows only.`,
     route.cwd ? `Route cwd: ${route.cwd}` : undefined,
     route.provider ? `Provider: ${route.provider}` : undefined,
+    failure.evidence.summary ? `Summary: ${failure.evidence.summary}` : undefined,
     failure.evidence.error ? `Error:
 ${failure.evidence.error}` : undefined,
     failure.evidence.stderr ? `Stderr:
@@ -4701,7 +5218,7 @@ ${failure.evidence.stderr}` : undefined
 `);
   const dedupeKey = `openloops:${loop.id}:${failure.fingerprint}`;
   const tags = ["bug", "openloops", "loops", "loop-health", failure.classification];
-  const priority = failure.classification === "auth" || failure.classification === "rate_limit" ? "high" : "medium";
+  const priority = failure.classification === "auth" || failure.classification === "rate_limit" || failure.classification === "provider_unavailable" ? "high" : "medium";
   return {
     title,
     description,
@@ -4735,7 +5252,7 @@ function expectationForLoop(store, loop) {
   const route = targetRoute(loop);
   if (!latestRun) {
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: true,
       check: { id: "latest-run-succeeded", status: "warn", message: "loop has no recorded runs yet" },
       route
@@ -4744,7 +5261,7 @@ function expectationForLoop(store, loop) {
   const routeFailure = detectRouteFunctionalFailure(store, loop, latestRun);
   if (routeFailure) {
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: false,
       check: { id: "route-functional-health", status: "fail", message: routeFailure.evidence.error ?? "route functional blocker detected" },
       latestRun: healthRun(latestRun),
@@ -4755,7 +5272,7 @@ function expectationForLoop(store, loop) {
   }
   if (latestRun.status === "succeeded") {
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: true,
       check: { id: "latest-run-succeeded", status: "pass", message: "latest run succeeded" },
       latestRun: healthRun(latestRun),
@@ -4766,7 +5283,7 @@ function expectationForLoop(store, loop) {
   if (failure?.classification === "circuit_breaker") {
     if (loop.status !== "paused") {
       return {
-        loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+        loop: expectationLoop(loop),
         ok: true,
         check: { id: "latest-run-succeeded", status: "warn", message: "circuit breaker cleared by resume; awaiting next run" },
         latestRun: healthRun(latestRun),
@@ -4774,7 +5291,7 @@ function expectationForLoop(store, loop) {
       };
     }
     return {
-      loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+      loop: expectationLoop(loop),
       ok: false,
       check: { id: "latest-run-succeeded", status: "fail", message: latestRun.error ?? "circuit breaker open; loop auto-paused" },
       latestRun: healthRun(latestRun),
@@ -4783,8 +5300,33 @@ function expectationForLoop(store, loop) {
       recommendedTask: recommendedTask(loop, latestRun, failure, route)
     };
   }
+  if (failure?.classification === "restart_interrupted") {
+    return {
+      loop: expectationLoop(loop),
+      ok: true,
+      check: { id: "latest-run-succeeded", status: "warn", message: latestRun.error ?? "daemon restart interrupted latest run" },
+      latestRun: healthRun(latestRun),
+      failure,
+      route
+    };
+  }
+  if (failure?.classification === "provider_unavailable" && hasPendingRetry(loop, latestRun)) {
+    const message = [
+      "provider unavailable/network failure; retry is scheduled",
+      loop.nextRunAt ? `next attempt at ${loop.nextRunAt}` : undefined,
+      failure.evidence.summary
+    ].filter(Boolean).join("; ");
+    return {
+      loop: expectationLoop(loop),
+      ok: true,
+      check: { id: "latest-run-succeeded", status: "warn", message },
+      latestRun: healthRun(latestRun),
+      failure,
+      route
+    };
+  }
   return {
-    loop: { id: loop.id, name: loop.name, status: loop.status, nextRunAt: loop.nextRunAt },
+    loop: expectationLoop(loop),
     ok: false,
     check: { id: "latest-run-succeeded", status: "fail", message: `latest run is ${latestRun.status}` },
     latestRun: healthRun(latestRun),
@@ -4816,16 +5358,99 @@ function buildHealthReport(store, opts = {}) {
     expectations
   };
 }
+function buildHealthScan(store, opts = {}) {
+  const generatedAt = (opts.now ?? new Date).toISOString();
+  const now = opts.now ?? new Date(generatedAt);
+  const includeStatuses = [...includedStatusSet(opts.includeStatuses)];
+  const loops = scanLoops(store, includeStatuses, opts);
+  const health = healthReportForLoops(store, loops, generatedAt);
+  const expectationsByLoopId = new Map(health.expectations.map((expectation) => [expectation.loop.id, expectation]));
+  const loopsById = new Map(loops.map((loop) => [loop.id, loop]));
+  const maxFindings = Math.max(0, opts.maxFindings ?? DEFAULT_MAX_FINDINGS);
+  const allFindings = [];
+  const pushFinding = (finding) => {
+    if (!finding)
+      return;
+    allFindings.push(finding);
+  };
+  if (opts.daemon)
+    pushFinding(daemonFinding(opts.daemon));
+  if (opts.latestRun !== false) {
+    for (const loop of loops) {
+      const expectation = expectationsByLoopId.get(loop.id);
+      if (!expectation)
+        continue;
+      pushFinding(staleRunningFinding(loop, expectation, now, opts.staleRunningMs ?? MIN_STALE_RUNNING_MS));
+      pushFinding(latestRunFinding(expectation));
+    }
+  }
+  const doctor = opts.doctor ? publicDoctorReport(opts.doctor) : undefined;
+  if (doctor) {
+    for (const check of doctor.checks) {
+      const preflightLoopId = check.id.startsWith("loop:") && check.id.endsWith(":preflight") ? check.id.slice("loop:".length, -":preflight".length) : undefined;
+      const loop = preflightLoopId ? loopsById.get(preflightLoopId) : undefined;
+      const route = preflightLoopId ? expectationsByLoopId.get(preflightLoopId)?.route : undefined;
+      pushFinding(doctorFinding(check, loop, route));
+    }
+  }
+  const findings = allFindings.slice(0, maxFindings);
+  const status = scanStatus(allFindings);
+  const baseCounts = statusCounts(loops);
+  return {
+    ok: status === "ok",
+    status,
+    generatedAt,
+    includedStatuses: includeStatuses,
+    counts: {
+      ...baseCounts,
+      latestRunFindings: allFindings.filter((finding) => finding.kind === "latest-run").length,
+      staleRunning: allFindings.filter((finding) => finding.kind === "stale-running").length,
+      daemonFindings: allFindings.filter((finding) => finding.kind === "daemon").length,
+      doctorFindings: allFindings.filter((finding) => finding.kind === "doctor").length,
+      preflightFindings: allFindings.filter((finding) => finding.kind === "preflight").length,
+      findings: allFindings.length,
+      reportedFindings: findings.length,
+      truncatedFindings: Math.max(0, allFindings.length - findings.length)
+    },
+    daemon: opts.daemon ? {
+      running: opts.daemon.running,
+      stale: opts.daemon.stale,
+      pid: opts.daemon.pid,
+      host: opts.daemon.host,
+      loops: opts.daemon.loops,
+      runs: opts.daemon.runs,
+      logPath: opts.daemon.logPath
+    } : undefined,
+    doctor,
+    health,
+    selfHeals: opts.selfHeals ?? [],
+    findings
+  };
+}
+function writeHealthScanReports(scan, opts = {}) {
+  const root = opts.reportDir ?? join5(dataDir(), "reports", "health-scan");
+  const dir = timestampDir(root, scan.generatedAt);
+  mkdirSync4(dir, { recursive: true, mode: 448 });
+  const json = join5(dir, "summary.json");
+  const markdown = join5(dir, "report.md");
+  const withReports = {
+    ...scan,
+    reports: { dir, json, markdown }
+  };
+  writeFileSync2(json, JSON.stringify(withReports, null, 2), { mode: 384 });
+  writeFileSync2(markdown, healthScanMarkdown(withReports), { mode: 384 });
+  return withReports;
+}
 
 // src/lib/executor.ts
-import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
 import { randomBytes as randomBytes2 } from "crypto";
 import { once } from "events";
-import { lstatSync, mkdirSync as mkdirSync4, realpathSync } from "fs";
+import { lstatSync, mkdirSync as mkdirSync5, realpathSync } from "fs";
 import { dirname as dirname3, resolve as resolve2 } from "path";
 
 // src/lib/accounts.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 var EXPORT_RE = /^export\s+([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
 var ACCOUNTS_ENV_TIMEOUT_MS = 30000;
@@ -4930,7 +5555,7 @@ function resolveAccountEnvSync(account, toolHint, env) {
   if (!account)
     return {};
   const tool = requiredAccountTool(account, toolHint);
-  const result = spawnSync2("accounts", ["env", account.profile, "--tool", tool], {
+  const result = spawnSync3("accounts", ["env", account.profile, "--tool", tool], {
     encoding: "utf8",
     env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -4946,8 +5571,8 @@ function resolveAccountEnvSync(account, toolHint, env) {
 
 // src/lib/env.ts
 import { accessSync, constants } from "fs";
-import { homedir as homedir2 } from "os";
-import { delimiter, join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { delimiter, join as join6 } from "path";
 function compactPathParts(parts) {
   const seen = new Set;
   const result = [];
@@ -4961,16 +5586,16 @@ function compactPathParts(parts) {
   return result;
 }
 function commonExecutableDirs(env = process.env) {
-  const home = env.HOME || homedir2();
+  const home = env.HOME || homedir3();
   return compactPathParts([
-    join4(home, ".local", "bin"),
-    join4(home, ".bun", "bin"),
-    join4(home, ".cargo", "bin"),
-    join4(home, ".npm-global", "bin"),
-    join4(home, "bin"),
-    env.BUN_INSTALL ? join4(env.BUN_INSTALL, "bin") : undefined,
+    join6(home, ".local", "bin"),
+    join6(home, ".bun", "bin"),
+    join6(home, ".cargo", "bin"),
+    join6(home, ".npm-global", "bin"),
+    join6(home, "bin"),
+    env.BUN_INSTALL ? join6(env.BUN_INSTALL, "bin") : undefined,
     env.PNPM_HOME,
-    env.NPM_CONFIG_PREFIX ? join4(env.NPM_CONFIG_PREFIX, "bin") : undefined,
+    env.NPM_CONFIG_PREFIX ? join6(env.NPM_CONFIG_PREFIX, "bin") : undefined,
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -4994,7 +5619,7 @@ function executableExists(command, env = process.env) {
   if (command.includes("/"))
     return isExecutable(command);
   for (const dir of (env.PATH ?? "").split(delimiter)) {
-    if (dir && isExecutable(join4(dir, command)))
+    if (dir && isExecutable(join6(dir, command)))
       return true;
   }
   return false;
@@ -5135,6 +5760,32 @@ function timeoutResult(startedAt, error, fields = {}) {
 function successResult(startedAt, fields = {}) {
   return buildResult("succeeded", startedAt, fields);
 }
+function codewithJsonlHasTerminalSuccess(stdout) {
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.startsWith("{"))
+      continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!event || typeof event !== "object")
+      continue;
+    const record = event;
+    if (record.type === "task_complete")
+      return true;
+    const payload = record.payload;
+    if (payload && typeof payload === "object" && payload.type === "task_complete") {
+      return true;
+    }
+  }
+  return false;
+}
+function codewithJsonlReconciledSuccess(spec, fields) {
+  return spec.agentProvider === "codewith" && codewithJsonlHasTerminalSuccess(fields.stdout ?? "");
+}
 function notifySpawn(pid, opts) {
   if (!pid)
     return;
@@ -5150,10 +5801,48 @@ function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function codewithProfileCandidateFromLine(line) {
-  const cols = line.trim().split(/\s+/);
-  if (cols[0] === "*")
-    return cols[1];
-  return cols[0];
+  const trimmed = line.trim();
+  if (!trimmed || trimmed === "No auth profiles saved.")
+    return;
+  const cols = trimmed.split(/\s+/);
+  const candidate = cols[0] === "*" ? cols[1] : cols[0];
+  if (candidate === "NAME" && (cols[1] === "ACCOUNT" || cols[2] === "ACCOUNT"))
+    return;
+  if (candidate === '"name":') {
+    const jsonName = trimmed.match(/"name"\s*:\s*"([^"]+)"/)?.[1];
+    if (jsonName)
+      return jsonName;
+  }
+  return candidate;
+}
+function codewithProfileCandidatesFromJson(value) {
+  const candidates = [];
+  const root = value && typeof value === "object" ? value : undefined;
+  const addProfile = (entry) => {
+    if (!entry || typeof entry !== "object")
+      return;
+    const name = entry.name;
+    if (typeof name === "string" && name)
+      candidates.push(name);
+  };
+  const data = root?.data;
+  if (Array.isArray(data))
+    data.forEach(addProfile);
+  const profiles = root?.profiles;
+  if (Array.isArray(profiles))
+    profiles.forEach(addProfile);
+  return candidates;
+}
+function codewithProfileCandidatesFromOutput(output) {
+  const trimmed = output.trim();
+  const jsonStart = trimmed.indexOf("{");
+  const jsonEnd = trimmed.lastIndexOf("}");
+  if (jsonStart >= 0 && jsonEnd >= jsonStart) {
+    try {
+      return codewithProfileCandidatesFromJson(JSON.parse(trimmed.slice(jsonStart, jsonEnd + 1)));
+    } catch {}
+  }
+  return output.split(/\r?\n/).map(codewithProfileCandidateFromLine).filter(Boolean);
 }
 function codewithProfileForError(profile) {
   return /[\u0000-\u001F\u007F]/.test(profile) ? JSON.stringify(profile) ?? profile : profile;
@@ -5246,6 +5935,7 @@ function commandSpec(target, opts) {
     preflightAnyOf: invocation.preflightAnyOf,
     stdin: invocation.stdin,
     allowlist: agentTarget.allowlist,
+    agentProvider: agentTarget.provider,
     worktree: agentTarget.worktree
   };
 }
@@ -5405,7 +6095,7 @@ function remotePreflightScript(spec, metadata) {
   }
   if (spec.nativeAuthProfile?.provider === "codewith") {
     const profileForError = codewithProfileForError(spec.nativeAuthProfile.profile);
-    lines.push(`__OPENLOOPS_CODEWITH_PROFILE=${shellQuote(spec.nativeAuthProfile.profile)}`, "export __OPENLOOPS_CODEWITH_PROFILE", `__OPENLOOPS_CODEWITH_PROFILES="$(${shellQuote(spec.command)} profile list)" || {`, `  printf '%s\\n' ${shellQuote("codewith auth profile preflight failed")} >&2`, "  exit 1", "}", `if ! printf '%s\\n' "$__OPENLOOPS_CODEWITH_PROFILES" | awk 'NR > 1 { candidate = ($1 == "*" ? $2 : $1); if (candidate == ENVIRON["__OPENLOOPS_CODEWITH_PROFILE"]) found = 1 } END { exit(found ? 0 : 1) }'; then`, `  printf '%s\\n' ${shellQuote(`codewith auth profile not found: ${profileForError}`)} >&2`, "  exit 1", "fi");
+    lines.push(`__OPENLOOPS_CODEWITH_PROFILE=${shellQuote(spec.nativeAuthProfile.profile)}`, "export __OPENLOOPS_CODEWITH_PROFILE", "__openloops_codewith_profile_list_contains() {", `  printf '%s\\n' "$__OPENLOOPS_CODEWITH_PROFILES" | awk '{ line = $0; gsub(/^[[:space:]]+|[[:space:]]+$/, "", line); if (line == "" || line == "No auth profiles saved.") next; if (line ~ /"(data|profiles)"[[:space:]]*:[[:space:]]*\\[/) { in_profiles = 1; next } if (in_profiles && line ~ /^\\]/) { in_profiles = 0; next } json = line; if (in_profiles && json ~ /"name"[[:space:]]*:[[:space:]]*"/) { sub(/^.*"name"[[:space:]]*:[[:space:]]*"/, "", json); sub(/".*$/, "", json); if (json == ENVIRON["__OPENLOOPS_CODEWITH_PROFILE"]) found = 1; next } split(line, cols, /[[:space:]]+/); candidate = (cols[1] == "*" ? cols[2] : cols[1]); if (candidate == "NAME" && (cols[2] == "ACCOUNT" || cols[3] == "ACCOUNT")) next; if (candidate == ENVIRON["__OPENLOOPS_CODEWITH_PROFILE"]) found = 1 } END { exit(found ? 0 : 1) }'`, "}", `if __OPENLOOPS_CODEWITH_PROFILES="$(${shellQuote(spec.command)} profile list --json 2>/dev/null)" && __openloops_codewith_profile_list_contains; then`, "  :", "else", `  __OPENLOOPS_CODEWITH_PROFILES="$(${shellQuote(spec.command)} profile list)" || {`, `    printf '%s\\n' ${shellQuote("codewith auth profile preflight failed")} >&2`, "    exit 1", "  }", "  if ! __openloops_codewith_profile_list_contains; then", `    printf '%s\\n' ${shellQuote(`codewith auth profile not found: ${profileForError}`)} >&2`, "    exit 1", "  fi", "fi");
   }
   return lines.join(`
 `);
@@ -5423,6 +6113,12 @@ function transportEnv(opts) {
   return env;
 }
 function assertCodewithProfileListed(profile, result) {
+  const profiles = codewithProfileSetFromResult(result);
+  if (!profiles.has(profile)) {
+    throw new Error(`codewith auth profile not found: ${codewithProfileForError(profile)}`);
+  }
+}
+function codewithProfileSetFromResult(result) {
   if (result.error) {
     throw new Error(`codewith auth profile preflight failed: ${result.error}`);
   }
@@ -5430,32 +6126,42 @@ function assertCodewithProfileListed(profile, result) {
     const detail = (result.stderr || result.stdout || `exit ${result.status ?? "unknown"}`).trim();
     throw new Error(`codewith auth profile preflight failed${detail ? `: ${detail}` : ""}`);
   }
-  const profiles = new Set((result.stdout || "").split(/\r?\n/).slice(1).map(codewithProfileCandidateFromLine).filter(Boolean));
-  if (!profiles.has(profile)) {
-    throw new Error(`codewith auth profile not found: ${codewithProfileForError(profile)}`);
-  }
+  return new Set(codewithProfileCandidatesFromOutput(result.stdout || ""));
 }
 function preflightNativeAuthProfileSync(spec, env) {
   if (spec.nativeAuthProfile?.provider !== "codewith")
     return;
-  const result = spawnSync3(spec.command, ["profile", "list"], {
-    encoding: "utf8",
-    env,
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 15000
-  });
-  assertCodewithProfileListed(spec.nativeAuthProfile.profile, {
-    status: result.status,
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-    error: result.error?.message
-  });
+  const runProfileList = (args) => {
+    const result = spawnSync4(spec.command, args, {
+      encoding: "utf8",
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15000
+    });
+    return {
+      status: result.status,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      error: result.error?.message
+    };
+  };
+  const jsonResult = runProfileList(["profile", "list", "--json"]);
+  try {
+    if (codewithProfileSetFromResult(jsonResult).has(spec.nativeAuthProfile.profile))
+      return;
+  } catch {}
+  assertCodewithProfileListed(spec.nativeAuthProfile.profile, runProfileList(["profile", "list"]));
 }
 async function preflightNativeAuthProfile(spec, env) {
   if (spec.nativeAuthProfile?.provider !== "codewith")
     return;
-  const result = await spawnCapture(spec.command, ["profile", "list"], { env, timeoutMs: 15000 });
-  assertCodewithProfileListed(spec.nativeAuthProfile.profile, result);
+  const jsonResult = await spawnCapture(spec.command, ["profile", "list", "--json"], { env, timeoutMs: 15000 });
+  try {
+    if (codewithProfileSetFromResult(jsonResult).has(spec.nativeAuthProfile.profile))
+      return;
+  } catch {}
+  const tableResult = await spawnCapture(spec.command, ["profile", "list"], { env, timeoutMs: 15000 });
+  assertCodewithProfileListed(spec.nativeAuthProfile.profile, tableResult);
 }
 function resolvedDirEquals(left, right) {
   try {
@@ -5516,7 +6222,7 @@ async function ensureLocalWorktree(worktree, env) {
     return { error: `worktree repoRoot is not a git repository: ${repoRoot}` };
   }
   try {
-    mkdirSync4(dirname3(path), { recursive: true });
+    mkdirSync5(dirname3(path), { recursive: true });
   } catch (error) {
     return { error: `could not create worktree parent directory: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -5558,7 +6264,7 @@ function worktreeFallbackSpec(target, opts, fallbackCwd) {
 }
 function preflightRemoteSpec(spec, machine, metadata, opts) {
   const plan = (opts.machineCommandResolver ?? resolveMachineCommand)(machine.id, "bash -s");
-  const result = spawnSync3(plan.command, plan.args, {
+  const result = spawnSync4(plan.command, plan.args, {
     encoding: "utf8",
     env: transportEnv(opts),
     input: remotePreflightScript(spec, metadata),
@@ -5657,6 +6363,9 @@ async function executeRemoteSpec(spec, machine, metadata, opts, fallbackSpec) {
   if (timedOut || idleTimedOut) {
     return timeoutResult(startedAt, idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`, fields);
   }
+  if (!error && exitCode !== 0 && codewithJsonlReconciledSuccess(spec, fields)) {
+    return successResult(startedAt, fields);
+  }
   if (error || exitCode !== 0) {
     return failureResult(startedAt, error ?? `remote process on ${machine.id} exited with code ${exitCode ?? "unknown"}`, fields);
   }
@@ -5792,6 +6501,9 @@ async function executeTarget(target, metadata = {}, opts = {}) {
   if (timedOut || idleTimedOut) {
     return timeoutResult(startedAt, idleTimedOut ? `idle timed out after ${spec.idleTimeoutMs}ms without stdout/stderr` : `timed out after ${spec.timeoutMs}ms`, fields);
   }
+  if (!error && exitCode !== 0 && codewithJsonlReconciledSuccess(spec, fields)) {
+    return successResult(startedAt, fields);
+  }
   if (error || exitCode !== 0) {
     return failureResult(startedAt, error ?? `process exited with code ${exitCode ?? "unknown"}`, fields);
   }
@@ -6820,7 +7532,7 @@ var MAX_RETRY_EXPONENT = 20;
 function retryBackoffDelayMs(loop, run, random = Math.random) {
   const attempt = Math.max(1, run.attempt);
   const failure = classifyRunFailure(run);
-  const throttled = failure?.classification === "rate_limit" || failure?.classification === "auth";
+  const throttled = failure?.classification === "rate_limit" || failure?.classification === "auth" || failure?.classification === "provider_unavailable";
   const growth = 2 ** Math.min(attempt - 1, MAX_RETRY_EXPONENT);
   const base = loop.retryDelayMs * growth * (throttled ? THROTTLED_RETRY_MULTIPLIER : 1);
   const jitter = 0.5 + random();
@@ -6947,20 +7659,21 @@ async function executeClaimedRun(deps) {
       daemonLeaseId: deps.daemonLeaseId,
       onSpawn: (pid) => deps.store.markRunPid(run.id, pid, deps.runnerId, { daemonLeaseId: deps.daemonLeaseId })
     })))(deps.loop, deps.run);
+    const finalResult = deps.finalizeResult?.(result, deps.loop, deps.run) ?? result;
     deps.beforeFinalize?.(deps.loop, deps.run);
     return deps.store.finalizeRun(deps.run.id, {
-      status: result.status,
-      finishedAt: result.finishedAt,
-      durationMs: result.durationMs,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exitCode: result.exitCode,
-      error: result.error,
-      pid: result.pid
+      status: finalResult.status,
+      finishedAt: finalResult.finishedAt,
+      durationMs: finalResult.durationMs,
+      stdout: finalResult.stdout,
+      stderr: finalResult.stderr,
+      exitCode: finalResult.exitCode,
+      error: finalResult.error,
+      pid: finalResult.pid
     }, {
       claimedBy: deps.runnerId,
       daemonLeaseId: deps.daemonLeaseId,
-      now: deps.now?.() ?? new Date(result.finishedAt)
+      now: deps.now?.() ?? new Date(finalResult.finishedAt)
     });
   } catch (err) {
     deps.onError?.(deps.loop, err);
@@ -7195,10 +7908,10 @@ async function tick(deps) {
 }
 
 // src/daemon/control.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync4, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
-import { spawnSync as spawnSync4 } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync5, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "fs";
+import { spawnSync as spawnSync5 } from "child_process";
 import { hostname } from "os";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 
 // src/daemon/loop.ts
 function realSleep(ms) {
@@ -7228,7 +7941,7 @@ function readPidRecord(path = pidFilePath()) {
     return;
   let raw;
   try {
-    raw = readFileSync4(path, "utf8").trim();
+    raw = readFileSync5(path, "utf8").trim();
   } catch {
     return;
   }
@@ -7250,11 +7963,11 @@ function readPidRecord(path = pidFilePath()) {
   return Number.isInteger(pid) && pid > 0 ? { pid } : undefined;
 }
 function writePid(pid = process.pid, path = pidFilePath()) {
-  mkdirSync5(dirname4(path), { recursive: true, mode: 448 });
-  writeFileSync2(path, JSON.stringify({ pid, startedAt: processStartTimeMs(pid) }));
+  mkdirSync6(dirname4(path), { recursive: true, mode: 448 });
+  writeFileSync3(path, JSON.stringify({ pid, startedAt: processStartTimeMs(pid) }));
 }
 function removePid(path = pidFilePath()) {
-  rmSync3(path, { force: true });
+  rmSync4(path, { force: true });
 }
 function isAlive(pid, startedAt) {
   try {
@@ -7284,7 +7997,7 @@ function ownProcessGroupId() {
       return pgrp;
   }
   try {
-    const run = spawnSync4("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8" });
+    const run = spawnSync5("ps", ["-o", "pgid=", "-p", String(process.pid)], { encoding: "utf8" });
     const pgid = Number(run.stdout.trim());
     if (run.status === 0 && Number.isInteger(pgid) && pgid > 0)
       return pgid;
@@ -7380,7 +8093,7 @@ async function stopDaemon(opts = {}) {
   if (!state.running || !state.pid)
     return { wasRunning: false, stopped: false, forced: false };
   const sleep = opts.sleep ?? realSleep;
-  const store = new Store(join5(dirname4(path), "loops.db"));
+  const store = new Store(join7(dirname4(path), "loops.db"));
   try {
     const lease = store.getDaemonLease();
     const leaseVerified = Boolean(lease && lease.pid === state.pid && new Date(lease.expiresAt).getTime() > Date.now());
@@ -7457,7 +8170,7 @@ function rotateDaemonLog(path = daemonLogPath(), maxBytes = DAEMON_LOG_MAX_BYTES
   if (size < maxBytes)
     return false;
   try {
-    rmSync4(`${path}.${keep}`, { force: true });
+    rmSync5(`${path}.${keep}`, { force: true });
     for (let i = keep - 1;i >= 1; i--) {
       if (existsSync5(`${path}.${i}`))
         renameSync2(`${path}.${i}`, `${path}.${i + 1}`);
@@ -7506,6 +8219,7 @@ async function runDaemon(opts = {}) {
   let runAbort = new AbortController;
   const activeRuns = new Map;
   const activeByLane = { command: 0, agent: 0 };
+  const isControlledStopInterruption = (result) => stopFlag && !leaseLost && result.status === "failed" && result.error?.includes("terminated by SIGTERM") === true;
   const requestStop = (message) => {
     stopFlag = true;
     if (!runAbort.signal.aborted)
@@ -7589,6 +8303,16 @@ async function runDaemon(opts = {}) {
           store.recordRunProcess(run.id, info, { daemonLeaseId: leaseId });
         }
       })),
+      finalizeResult: (result) => {
+        if (!isControlledStopInterruption(result))
+          return result;
+        return {
+          ...result,
+          status: "skipped",
+          exitCode: undefined,
+          error: `${RESTART_INTERRUPTED_RUN_PREFIX}: child process terminated by SIGTERM during daemon stop/restart`
+        };
+      },
       onError: (loop, err) => log(`loop ${loop.id} failed: ${err instanceof Error ? err.message : String(err)}`)
     });
     ensureLease();
@@ -7682,7 +8406,7 @@ async function startDaemon(opts) {
     return { started: false, alreadyRunning: true, pid: state.pid };
   if (state.stale)
     removePid();
-  const out = openSync(daemonLogPath(), "a");
+  const out = openSync2(daemonLogPath(), "a");
   const child = spawn3(opts.execPath ?? process.execPath, [opts.cliEntry, ...opts.args ?? ["daemon", "run"]], {
     detached: true,
     stdio: ["ignore", out, out]
@@ -7700,8 +8424,8 @@ async function startDaemon(opts) {
 }
 
 // src/daemon/install.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync6, writeFileSync as writeFileSync3 } from "fs";
-import { spawnSync as spawnSync5 } from "child_process";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "fs";
+import { spawnSync as spawnSync6 } from "child_process";
 import { dirname as dirname5 } from "path";
 function systemdEscapeExecPart(part) {
   const escaped = part.replaceAll("%", "%%");
@@ -7733,9 +8457,9 @@ function installStartup(cliEntry, execPath = process.execPath, args = ["daemon",
   const dataDirPath = ensureDataDir();
   if (platform === "linux") {
     const path = systemdServicePath();
-    mkdirSync6(dirname5(path), { recursive: true, mode: 448 });
+    mkdirSync7(dirname5(path), { recursive: true, mode: 448 });
     const execStart = [execPath, cliEntry, ...args].map(systemdEscapeExecPart).join(" ");
-    writeFileSync3(path, `[Unit]
+    writeFileSync4(path, `[Unit]
 Description=Hasna OpenLoops daemon
 After=basic.target
 
@@ -7763,8 +8487,8 @@ WantedBy=default.target
   }
   if (platform === "darwin") {
     const path = launchdPlistPath();
-    mkdirSync6(dirname5(path), { recursive: true, mode: 448 });
-    writeFileSync3(path, `<?xml version="1.0" encoding="UTF-8"?>
+    mkdirSync7(dirname5(path), { recursive: true, mode: 448 });
+    writeFileSync4(path, `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
@@ -7801,7 +8525,7 @@ ${args.map((arg) => `    <string>${xmlEscape(arg)}</string>`).join(`
 function enableStartup(result) {
   const commands = result.platform === "linux" ? ["systemctl --user daemon-reload", "systemctl --user enable --now loops-daemon.service"] : result.platform === "darwin" ? launchctlCommands(result.path) : [];
   return commands.map((command) => {
-    const run = spawnSync5("sh", ["-c", command], {
+    const run = spawnSync6("sh", ["-c", command], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -7816,7 +8540,7 @@ function enableStartup(result) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.13",
+  version: "0.4.14",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -7825,6 +8549,7 @@ var package_default = {
     loops: "dist/cli/index.js",
     "loops-daemon": "dist/daemon/index.js",
     "loops-api": "dist/api/index.js",
+    "loops-serve": "dist/serve/index.js",
     "loops-runner": "dist/runner/index.js",
     "loops-mcp": "dist/mcp/index.js"
   },
@@ -7837,6 +8562,14 @@ var package_default = {
       types: "./dist/sdk/index.d.ts",
       import: "./dist/sdk/index.js"
     },
+    "./sdk/http": {
+      types: "./dist/sdk/http.d.ts",
+      import: "./dist/sdk/http.js"
+    },
+    "./serve": {
+      types: "./dist/serve/index.d.ts",
+      import: "./dist/serve/index.js"
+    },
     "./mcp": {
       types: "./dist/mcp/index.d.ts",
       import: "./dist/mcp/index.js"
@@ -7882,7 +8615,7 @@ var package_default = {
     "LICENSE"
   ],
   scripts: {
-    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/api/index.ts src/runner/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/lib/store.ts src/lib/mode.ts src/lib/storage/index.ts src/lib/storage/contract.ts src/lib/storage/sqlite.ts src/lib/storage/postgres.ts src/lib/storage/postgres-schema.ts --root src --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js dist/api/index.js dist/runner/index.js dist/mcp/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
+    build: "rm -rf dist && bun build src/cli/index.ts src/daemon/index.ts src/api/index.ts src/serve/index.ts src/runner/index.ts src/mcp/index.ts src/index.ts src/sdk/index.ts src/sdk/http.ts src/lib/store.ts src/lib/mode.ts src/lib/storage/index.ts src/lib/storage/contract.ts src/lib/storage/sqlite.ts src/lib/storage/postgres.ts src/lib/storage/postgres-schema.ts --root src --outdir dist --target bun --packages external && chmod +x dist/cli/index.js dist/daemon/index.js dist/api/index.js dist/serve/index.js dist/runner/index.js dist/mcp/index.js && tsc -p tsconfig.build.json --emitDeclarationOnly --outDir dist",
     "build:bin": "bun build src/cli/index.ts --compile --outfile dist/loops",
     typecheck: "tsc --noEmit",
     test: "bun test",
@@ -7917,11 +8650,13 @@ 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",
     ai: "6.0.204",
     commander: "^13.1.0",
+    pg: "^8.13.1",
     zod: "4.4.3"
   },
   optionalDependencies: {
@@ -7929,6 +8664,7 @@ var package_default = {
   },
   devDependencies: {
     "@types/bun": "latest",
+    "@types/pg": "^8.11.10",
     typescript: "^5.7.3"
   },
   publishConfig: {