@hasna/loops 0.2.0 → 0.3.1

package/dist/cli/index.js

@@ -249,6 +249,9 @@ function validateTarget(value, label) {
   assertObject(value, label);
   if (value.type === "command") {
     assertString(value.command, `${label}.command`);
+    if (value.shell !== true && /\s/.test(value.command.trim())) {
+      throw new Error(`${label}.command must be an executable without spaces when shell is false; put flags in args or set shell true`);
+    }
     return value;
   }
   if (value.type === "agent") {
@@ -414,6 +417,7 @@ function rowToWorkflowStepRun(row) {
     startedAt: row.started_at ?? undefined,
     finishedAt: row.finished_at ?? undefined,
     exitCode: row.exit_code ?? undefined,
+    pid: row.pid ?? undefined,
     durationMs: row.duration_ms ?? undefined,
     stdout: row.stdout ?? undefined,
     stderr: row.stderr ?? undefined,
@@ -435,6 +439,14 @@ function rowToWorkflowEvent(row) {
     createdAt: row.created_at
   };
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function rowToLease(row) {
   return {
     id: row.id,
@@ -567,6 +579,7 @@ class Store {
         started_at TEXT,
         finished_at TEXT,
         exit_code INTEGER,
+        pid INTEGER,
         duration_ms INTEGER,
         stdout TEXT,
         stderr TEXT,
@@ -592,6 +605,9 @@ class Store {
       );
       CREATE INDEX IF NOT EXISTS idx_workflow_events_run_sequence ON workflow_events(workflow_run_id, sequence);
     `);
+    try {
+      this.db.query("ALTER TABLE workflow_step_runs ADD COLUMN pid INTEGER").run();
+    } catch {}
     this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0001_initial_and_workflows", nowIso());
   }
   createLoop(input, from = new Date) {
@@ -772,8 +788,8 @@ class Store {
       input.workflow.steps.forEach((step, sequence) => {
         const account = step.account ?? step.target.account;
         this.db.query(`INSERT INTO workflow_step_runs (id, workflow_run_id, step_id, sequence, status, started_at, finished_at,
-              exit_code, duration_ms, stdout, stderr, error, account_profile, account_tool, created_at, updated_at)
-             VALUES ($id, $workflowRunId, $stepId, $sequence, 'pending', NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+              exit_code, pid, duration_ms, stdout, stderr, error, account_profile, account_tool, created_at, updated_at)
+             VALUES ($id, $workflowRunId, $stepId, $sequence, 'pending', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
               $accountProfile, $accountTool, $created, $updated)`).run({
           $id: genId(),
           $workflowRunId: runId,
@@ -814,6 +830,12 @@ class Store {
     const row = this.db.query("SELECT * FROM workflow_runs WHERE id = ?").get(id);
     return row ? rowToWorkflowRun(row) : undefined;
   }
+  requireWorkflowRun(id) {
+    const run = this.getWorkflowRun(id);
+    if (!run)
+      throw new Error(`workflow run not found: ${id}`);
+    return run;
+  }
   listWorkflowRuns(opts = {}) {
     const limit = opts.limit ?? 100;
     let rows;
@@ -834,23 +856,67 @@ class Store {
     const row = this.db.query("SELECT * FROM workflow_step_runs WHERE workflow_run_id = ? AND step_id = ?").get(workflowRunId, stepId);
     return row ? rowToWorkflowStepRun(row) : undefined;
   }
+  isWorkflowRunTerminal(workflowRunId) {
+    const run = this.getWorkflowRun(workflowRunId);
+    return Boolean(run && ["succeeded", "failed", "timed_out", "cancelled"].includes(run.status));
+  }
   startWorkflowStepRun(workflowRunId, stepId) {
     const now = nowIso();
-    this.db.query(`UPDATE workflow_step_runs
+    const res = this.db.query(`UPDATE workflow_step_runs
          SET status='running', started_at=$started, finished_at=NULL, exit_code=NULL, duration_ms=NULL,
-          stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
-         WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status IN ('pending', 'running', 'failed', 'timed_out')`).run({ $workflowRunId: workflowRunId, $stepId: stepId, $started: now, $updated: now });
-    this.appendWorkflowEvent(workflowRunId, "step_started", stepId);
+          pid=NULL, stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
+         WHERE workflow_run_id=$workflowRunId
+           AND step_id=$stepId
+           AND status IN ('pending', 'failed', 'timed_out')
+           AND EXISTS (
+             SELECT 1 FROM workflow_runs
+             WHERE id=$workflowRunId AND status='running'
+           )`).run({ $workflowRunId: workflowRunId, $stepId: stepId, $started: now, $updated: now });
     const run = this.getWorkflowStepRun(workflowRunId, stepId);
     if (!run)
       throw new Error(`workflow step run not found: ${workflowRunId}/${stepId}`);
+    if (res.changes !== 1) {
+      throw new Error(`workflow step is not claimable: ${workflowRunId}/${stepId} status=${run.status}`);
+    }
+    this.appendWorkflowEvent(workflowRunId, "step_started", stepId);
     return run;
   }
+  markWorkflowStepPid(workflowRunId, stepId, pid) {
+    const now = nowIso();
+    this.db.query(`UPDATE workflow_step_runs SET pid=$pid, updated_at=$updated
+         WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status='running'`).run({ $workflowRunId: workflowRunId, $stepId: stepId, $pid: pid, $updated: now });
+    const run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found after pid update: ${workflowRunId}/${stepId}`);
+    return run;
+  }
+  recoverWorkflowRun(workflowRunId, reason = "workflow run recovered for retry") {
+    const now = nowIso();
+    const before = this.listWorkflowStepRuns(workflowRunId).filter((step) => step.status === "running");
+    const live = before.filter((step) => step.pid !== undefined && isProcessAlive(step.pid));
+    if (live.length > 0) {
+      throw new Error(`cannot recover workflow run while step processes are still alive: ${live.map((step) => `${step.stepId} pid=${step.pid}`).join(", ")}`);
+    }
+    this.db.query(`UPDATE workflow_step_runs
+         SET status='pending', started_at=NULL, finished_at=NULL, exit_code=NULL, pid=NULL, duration_ms=NULL,
+          stdout=NULL, stderr=NULL, error=$reason, updated_at=$updated
+         WHERE workflow_run_id=$workflowRunId AND status='running'`).run({ $workflowRunId: workflowRunId, $reason: reason, $updated: now });
+    if (before.length > 0) {
+      this.appendWorkflowEvent(workflowRunId, "recovered", undefined, {
+        reason,
+        recoveredSteps: before.map((step) => step.stepId)
+      });
+    }
+    return {
+      run: this.requireWorkflowRun(workflowRunId),
+      recoveredSteps: before.map((step) => this.getWorkflowStepRun(workflowRunId, step.stepId)).filter(Boolean)
+    };
+  }
   finalizeWorkflowStepRun(workflowRunId, stepId, patch) {
     const finishedAt = patch.finishedAt ?? nowIso();
-    this.db.query(`UPDATE workflow_step_runs SET status=$status, finished_at=$finished, exit_code=$exitCode, duration_ms=$durationMs,
-         stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
-         WHERE workflow_run_id=$workflowRunId AND step_id=$stepId`).run({
+    const res = this.db.query(`UPDATE workflow_step_runs SET status=$status, finished_at=$finished, exit_code=$exitCode, duration_ms=$durationMs,
+         pid=NULL, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
+         WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status='running'`).run({
       $workflowRunId: workflowRunId,
       $stepId: stepId,
       $status: patch.status,
@@ -862,10 +928,12 @@ class Store {
       $error: patch.error ?? null,
       $updated: finishedAt
     });
-    this.appendWorkflowEvent(workflowRunId, `step_${patch.status}`, stepId, {
-      exitCode: patch.exitCode,
-      error: patch.error
-    });
+    if (res.changes === 1) {
+      this.appendWorkflowEvent(workflowRunId, `step_${patch.status}`, stepId, {
+        exitCode: patch.exitCode,
+        error: patch.error
+      });
+    }
     const run = this.getWorkflowStepRun(workflowRunId, stepId);
     if (!run)
       throw new Error(`workflow step run not found after finalize: ${workflowRunId}/${stepId}`);
@@ -873,9 +941,10 @@ class Store {
   }
   skipWorkflowStepRun(workflowRunId, stepId, reason) {
     const now = nowIso();
-    this.db.query(`UPDATE workflow_step_runs SET status='skipped', finished_at=$finished, error=$error, updated_at=$updated
-         WHERE workflow_run_id=$workflowRunId AND step_id=$stepId`).run({ $workflowRunId: workflowRunId, $stepId: stepId, $finished: now, $error: reason, $updated: now });
-    this.appendWorkflowEvent(workflowRunId, "step_skipped", stepId, { reason });
+    const res = this.db.query(`UPDATE workflow_step_runs SET status='skipped', finished_at=$finished, pid=NULL, error=$error, updated_at=$updated
+         WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status IN ('pending', 'running')`).run({ $workflowRunId: workflowRunId, $stepId: stepId, $finished: now, $error: reason, $updated: now });
+    if (res.changes === 1)
+      this.appendWorkflowEvent(workflowRunId, "step_skipped", stepId, { reason });
     const run = this.getWorkflowStepRun(workflowRunId, stepId);
     if (!run)
       throw new Error(`workflow step run not found after skip: ${workflowRunId}/${stepId}`);
@@ -883,8 +952,8 @@ class Store {
   }
   finalizeWorkflowRun(workflowRunId, status, patch = {}) {
     const finishedAt = patch.finishedAt ?? nowIso();
-    this.db.query(`UPDATE workflow_runs SET status=$status, finished_at=$finished, duration_ms=$durationMs, error=$error, updated_at=$updated
-         WHERE id=$id`).run({
+    const res = this.db.query(`UPDATE workflow_runs SET status=$status, finished_at=$finished, duration_ms=$durationMs, error=$error, updated_at=$updated
+         WHERE id=$id AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')`).run({
       $id: workflowRunId,
       $status: status,
       $finished: finishedAt,
@@ -892,12 +961,36 @@ class Store {
       $error: patch.error ?? null,
       $updated: finishedAt
     });
-    this.appendWorkflowEvent(workflowRunId, status, undefined, { error: patch.error });
     const run = this.getWorkflowRun(workflowRunId);
     if (!run)
       throw new Error(`workflow run not found after finalize: ${workflowRunId}`);
+    if (res.changes === 1)
+      this.appendWorkflowEvent(workflowRunId, status, undefined, { error: patch.error });
     return run;
   }
+  cancelWorkflowRun(workflowRunId, reason = "cancelled by user") {
+    const now = nowIso();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const run = this.requireWorkflowRun(workflowRunId);
+      if (!["succeeded", "failed", "timed_out", "cancelled"].includes(run.status)) {
+        this.db.query(`UPDATE workflow_runs
+             SET status='cancelled', finished_at=$finished, error=$reason, updated_at=$updated
+             WHERE id=$id AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')`).run({ $id: workflowRunId, $finished: now, $reason: reason, $updated: now });
+        this.db.query(`UPDATE workflow_step_runs
+             SET status='cancelled', finished_at=$finished, pid=NULL, error=$reason, updated_at=$updated
+             WHERE workflow_run_id=$workflowRunId AND status IN ('pending', 'running')`).run({ $workflowRunId: workflowRunId, $finished: now, $reason: reason, $updated: now });
+        this.appendWorkflowEvent(workflowRunId, "cancelled", undefined, { reason });
+      }
+      this.db.exec("COMMIT");
+      return this.requireWorkflowRun(workflowRunId);
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
   appendWorkflowEvent(workflowRunId, eventType, stepId, payload) {
     const now = nowIso();
     const current = this.db.query("SELECT MAX(sequence) AS sequence FROM workflow_events WHERE workflow_run_id = ?").get(workflowRunId);
@@ -926,6 +1019,24 @@ class Store {
     const row = this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE loop_id = ? AND status = 'running'").get(loopId);
     return (row?.count ?? 0) > 0;
   }
+  markRunPid(id, pid, claimedBy) {
+    const now = nowIso();
+    const res = claimedBy ? this.db.query(`UPDATE loop_runs SET pid=$pid, updated_at=$updated
+             WHERE id=$id AND status='running' AND claimed_by=$claimedBy`).run({ $id: id, $pid: pid, $updated: now, $claimedBy: claimedBy }) : this.db.query("UPDATE loop_runs SET pid=$pid, updated_at=$updated WHERE id=$id AND status='running'").run({ $id: id, $pid: pid, $updated: now });
+    if (res.changes !== 1)
+      return;
+    return this.getRun(id);
+  }
+  hasLiveWorkflowStepProcesses(loopRunId) {
+    const liveWorkflowSteps = this.db.query(`SELECT wr.id AS workflow_run_id, wsr.step_id AS step_id, wsr.pid AS pid
+         FROM workflow_runs wr
+         JOIN workflow_step_runs wsr ON wsr.workflow_run_id = wr.id
+         WHERE wr.loop_run_id = ?
+           AND wr.status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')
+           AND wsr.status = 'running'
+           AND wsr.pid IS NOT NULL`).all(loopRunId);
+    return liveWorkflowSteps.some((step) => isProcessAlive(step.pid));
+  }
   createSkippedRun(loop, scheduledFor, reason) {
     const now = nowIso();
     const run = {
@@ -973,6 +1084,14 @@ class Store {
       const existing = this.getRunBySlot(loop.id, scheduledFor);
       if (existing) {
         if (existing.status === "running") {
+          if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && existing.pid && isProcessAlive(existing.pid)) {
+            this.db.exec("COMMIT");
+            return;
+          }
+          if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && this.hasLiveWorkflowStepProcesses(existing.id)) {
+            this.db.exec("COMMIT");
+            return;
+          }
           const res3 = this.db.query(`UPDATE loop_runs SET status='running', started_at=$started, finished_at=NULL,
                claimed_by=$claimedBy, lease_expires_at=$lease, pid=NULL, exit_code=NULL,
                duration_ms=NULL, stdout=NULL, stderr=NULL, error=NULL, updated_at=$updated
@@ -1095,8 +1214,26 @@ class Store {
     const rows = this.db.query("SELECT * FROM loop_runs WHERE status = 'running' AND lease_expires_at <= ?").all(now.toISOString());
     const recovered = [];
     for (const row of rows) {
+      if (row.pid && isProcessAlive(row.pid))
+        continue;
+      if (this.hasLiveWorkflowStepProcesses(row.id))
+        continue;
+      const finished = now.toISOString();
       this.db.query(`UPDATE loop_runs SET status='abandoned', finished_at=$finished, lease_expires_at=NULL,
-           error='run lease expired before completion', updated_at=$updated WHERE id=$id`).run({ $id: row.id, $finished: now.toISOString(), $updated: now.toISOString() });
+           error='run lease expired before completion', updated_at=$updated WHERE id=$id`).run({ $id: row.id, $finished: finished, $updated: finished });
+      const workflowRows = this.db.query("SELECT * FROM workflow_runs WHERE loop_run_id = ? AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')").all(row.id);
+      for (const workflowRow of workflowRows) {
+        this.db.query(`UPDATE workflow_runs
+             SET status='failed', finished_at=$finished, error='parent loop run lease expired before completion', updated_at=$updated
+             WHERE id=$id AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')`).run({ $id: workflowRow.id, $finished: finished, $updated: finished });
+        this.db.query(`UPDATE workflow_step_runs
+             SET status='skipped', finished_at=$finished, pid=NULL, error='parent loop run lease expired before completion', updated_at=$updated
+             WHERE workflow_run_id=$workflowRunId AND status IN ('pending', 'running')`).run({ $workflowRunId: workflowRow.id, $finished: finished, $updated: finished });
+        this.appendWorkflowEvent(workflowRow.id, "failed", undefined, {
+          error: "parent loop run lease expired before completion",
+          loopRunId: row.id
+        });
+      }
       const run = this.getRun(row.id);
       if (run)
         recovered.push(run);
@@ -1172,6 +1309,7 @@ import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { Command } from "commander";
 
 // src/lib/format.ts
+var TEXT_OUTPUT_LIMIT = 32 * 1024;
 function redact(value, visible = 80) {
   if (!value)
     return value;
@@ -1179,6 +1317,29 @@ function redact(value, visible = 80) {
     return value;
   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 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 {
@@ -1266,6 +1427,25 @@ function primaryAccountDir(output) {
   }
   return;
 }
+function accountDirEnvVar(tool) {
+  switch (tool) {
+    case "claude":
+      return "CLAUDE_CONFIG_DIR";
+    case "codex":
+    case "codex-app":
+      return "CODEX_HOME";
+    case "cursor":
+      return "CURSOR_CONFIG_DIR";
+    case "opencode":
+      return "OPENCODE_CONFIG_DIR";
+    case "codewith":
+      return "CODEWITH_HOME";
+    case "aicopilot":
+      return "AICOPILOT_CONFIG_DIR";
+    default:
+      return;
+  }
+}
 function resolveAccountEnv(account, toolHint, env) {
   if (!account)
     return {};
@@ -1284,18 +1464,78 @@ function resolveAccountEnv(account, toolHint, env) {
     const stderr = result.stderr.trim();
     throw new Error(`accounts env failed for ${account.profile}/${tool}${stderr ? `: ${stderr}` : ""}`);
   }
-  const profileDir = primaryAccountDir(result.stdout);
+  const accountEnv = parseAccountExportLines(result.stdout);
+  const profileDir = (accountDirEnvVar(tool) ? accountEnv[accountDirEnvVar(tool)] : undefined) ?? primaryAccountDir(result.stdout);
   if (!profileDir)
     throw new Error(`accounts env returned no profile directory for ${account.profile}/${tool}`);
   if (!existsSync(profileDir))
     throw new Error(`account profile directory does not exist for ${account.profile}/${tool}: ${profileDir}`);
   return {
-    ...parseAccountExportLines(result.stdout),
+    ...accountEnv,
     LOOPS_ACCOUNT_PROFILE: account.profile,
     LOOPS_ACCOUNT_TOOL: tool
   };
 }
 
+// src/lib/env.ts
+import { accessSync, constants } from "fs";
+import { homedir as homedir2 } from "os";
+import { delimiter, join as join2 } from "path";
+function compactPathParts(parts) {
+  const seen = new Set;
+  const result = [];
+  for (const part of parts) {
+    const value = part?.trim();
+    if (!value || seen.has(value))
+      continue;
+    seen.add(value);
+    result.push(value);
+  }
+  return result;
+}
+function commonExecutableDirs(env = process.env) {
+  const home = env.HOME || homedir2();
+  return compactPathParts([
+    join2(home, ".local", "bin"),
+    join2(home, ".bun", "bin"),
+    join2(home, ".cargo", "bin"),
+    join2(home, ".npm-global", "bin"),
+    join2(home, "bin"),
+    env.BUN_INSTALL ? join2(env.BUN_INSTALL, "bin") : undefined,
+    env.PNPM_HOME,
+    env.NPM_CONFIG_PREFIX ? join2(env.NPM_CONFIG_PREFIX, "bin") : undefined,
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ]);
+}
+function normalizeExecutionPath(env = process.env) {
+  return compactPathParts([...(env.PATH ?? "").split(delimiter), ...commonExecutableDirs(env)]).join(delimiter);
+}
+function isExecutable(path) {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function executableExists(command, env = process.env) {
+  if (command.includes("/"))
+    return isExecutable(command);
+  for (const dir of (env.PATH ?? "").split(delimiter)) {
+    if (dir && isExecutable(join2(dir, command)))
+      return true;
+  }
+  return false;
+}
+function commandNotFoundMessage(command, env = process.env) {
+  return `Executable not found in PATH: ${command}. Effective PATH=${env.PATH || "(empty)"}`;
+}
+
 // src/lib/executor.ts
 var DEFAULT_TIMEOUT_MS = 30 * 60000;
 var DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
@@ -1381,7 +1621,7 @@ function agentArgs(target) {
       args.push(...target.extraArgs ?? [], target.prompt);
       return args;
     case "codewith":
-      args.push("exec", "--json", "--ephemeral", "--ask-for-approval", "never", "--sandbox", "workspace-write");
+      args.push("--ask-for-approval", "never", "exec", "--json", "--ephemeral", "--sandbox", "workspace-write", "--skip-git-repo-check");
       if (isolation === "safe")
         args.push("--ignore-rules");
       if (target.cwd)
@@ -1461,6 +1701,7 @@ function executionEnv(spec, metadata, opts) {
     Object.assign(env, accountEnv);
   }
   Object.assign(env, spec.env ?? {});
+  env.PATH = normalizeExecutionPath(env);
   if (metadata.loopId)
     env.LOOPS_LOOP_ID = metadata.loopId;
   if (metadata.loopName)
@@ -1479,6 +1720,18 @@ function executionEnv(spec, metadata, opts) {
     env.LOOPS_WORKFLOW_STEP_ID = metadata.workflowStepId;
   return env;
 }
+function preflightTarget(target, metadata = {}, opts = {}) {
+  const spec = commandSpec(target);
+  const env = executionEnv(spec, metadata, opts);
+  if (!spec.shell && !executableExists(spec.command, env)) {
+    throw new Error(commandNotFoundMessage(spec.command, env));
+  }
+  return {
+    command: spec.command,
+    accountProfile: spec.account?.profile,
+    accountTool: spec.accountTool
+  };
+}
 async function executeTarget(target, metadata = {}, opts = {}) {
   const spec = commandSpec(target);
   const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
@@ -1489,6 +1742,17 @@ async function executeTarget(target, metadata = {}, opts = {}) {
   let exitCode;
   let error;
   const env = executionEnv(spec, metadata, opts);
+  if (!spec.shell && !executableExists(spec.command, env)) {
+    return {
+      status: "failed",
+      stdout: "",
+      stderr: "",
+      error: commandNotFoundMessage(spec.command, env),
+      startedAt,
+      finishedAt: nowIso(),
+      durationMs: 0
+    };
+  }
   const child = spawn(spec.command, spec.args, {
     cwd: spec.cwd,
     env,
@@ -1496,6 +1760,16 @@ async function executeTarget(target, metadata = {}, opts = {}) {
     detached: true,
     stdio: ["ignore", "pipe", "pipe"]
   });
+  if (child.pid)
+    opts.onSpawn?.(child.pid);
+  const abortHandler = () => {
+    error = "cancelled";
+    if (child.pid)
+      killProcessGroup(child.pid);
+  };
+  if (opts.signal?.aborted)
+    abortHandler();
+  opts.signal?.addEventListener("abort", abortHandler, { once: true });
   child.stdout.on("data", (chunk) => {
     stdout = appendBounded(stdout, chunk, maxOutputBytes);
   });
@@ -1518,6 +1792,7 @@ async function executeTarget(target, metadata = {}, opts = {}) {
     error = err instanceof Error ? err.message : String(err);
   } finally {
     clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", abortHandler);
   }
   const finishedAt = nowIso();
   const durationMs = new Date(finishedAt).getTime() - new Date(startedAt).getTime();
@@ -1573,14 +1848,16 @@ async function executeLoop(loop, run, opts = {}) {
 // src/lib/workflow-runner.ts
 function targetWithStepAccount(step) {
   const account = step.account ?? step.target.account;
-  if (!account)
+  const timeoutMs = step.timeoutMs ?? step.target.timeoutMs;
+  if (!account && timeoutMs === step.target.timeoutMs)
     return step.target;
-  return { ...step.target, account };
+  return { ...step.target, account, timeoutMs };
 }
 function workflowResult(workflowRun, status, startedAt, finishedAt, stdout, error) {
+  const executorStatus = status === "succeeded" ? "succeeded" : status === "timed_out" ? "timed_out" : "failed";
   return {
-    status,
-    exitCode: status === "succeeded" ? 0 : 1,
+    status: executorStatus,
+    exitCode: executorStatus === "succeeded" ? 0 : 1,
     stdout,
     stderr: "",
     error,
@@ -1598,7 +1875,7 @@ async function executeWorkflow(store, workflow, opts = {}) {
     idempotencyKey: opts.idempotencyKey
   });
   const startedAt = run.startedAt ?? nowIso();
-  if (run.status === "succeeded" || run.status === "failed" || run.status === "timed_out") {
+  if (run.status === "succeeded" || run.status === "failed" || run.status === "timed_out" || run.status === "cancelled") {
     const steps2 = store.listWorkflowStepRuns(run.id);
     return workflowResult(run, run.status, startedAt, run.finishedAt ?? nowIso(), JSON.stringify({ workflowRun: run, steps: steps2 }, null, 2), run.error);
   }
@@ -1607,8 +1884,19 @@ async function executeWorkflow(store, workflow, opts = {}) {
   let blockingError;
   let terminalStatus = "succeeded";
   for (const step of ordered) {
+    if (store.isWorkflowRunTerminal(run.id)) {
+      terminalStatus = store.requireWorkflowRun(run.id).status;
+      blockingError = "workflow run was cancelled";
+      break;
+    }
+    const pendingTimeout = opts.signal?.aborted ? opts.signalTimeoutMessage?.() : undefined;
+    if (pendingTimeout) {
+      terminalStatus = "timed_out";
+      blockingError = pendingTimeout;
+      break;
+    }
     const existing = store.getWorkflowStepRun(run.id, step.id);
-    if (existing?.status === "succeeded" || existing?.status === "skipped")
+    if (existing?.status === "succeeded" || existing?.status === "skipped" || existing?.status === "cancelled")
       continue;
     const blockedBy = (step.dependsOn ?? []).find((dependencyId) => {
       const dependencyRun = store.getWorkflowStepRun(run.id, dependencyId);
@@ -1623,8 +1911,13 @@ async function executeWorkflow(store, workflow, opts = {}) {
       terminalStatus = "failed";
       continue;
     }
-    store.startWorkflowStepRun(run.id, step.id);
-    const result = await executeTarget(targetWithStepAccount(step), {
+    const startedStep = store.startWorkflowStepRun(run.id, step.id);
+    if (startedStep.status !== "running") {
+      terminalStatus = "failed";
+      blockingError = `step ${step.id} could not start because workflow is no longer running`;
+      break;
+    }
+    const metadata = {
       loopId: opts.loop?.id,
       loopName: opts.loop?.name,
       runId: opts.loopRun?.id,
@@ -1633,7 +1926,51 @@ async function executeWorkflow(store, workflow, opts = {}) {
       workflowName: workflow.name,
       workflowRunId: run.id,
       workflowStepId: step.id
-    }, opts);
+    };
+    let result;
+    const controller = new AbortController;
+    const externalAbort = () => controller.abort();
+    if (opts.signal?.aborted)
+      controller.abort();
+    opts.signal?.addEventListener("abort", externalAbort, { once: true });
+    const cancelTimer = setInterval(() => {
+      if (store.getWorkflowRun(run.id)?.status === "cancelled")
+        controller.abort();
+    }, opts.cancelPollMs ?? 500);
+    cancelTimer.unref();
+    try {
+      result = await executeTarget(targetWithStepAccount(step), metadata, {
+        ...opts,
+        signal: controller.signal,
+        onSpawn: (pid) => {
+          store.markWorkflowStepPid(run.id, step.id, pid);
+          opts.onSpawn?.(pid);
+        }
+      });
+    } catch (error) {
+      const finishedAt2 = nowIso();
+      result = {
+        status: "failed",
+        stdout: "",
+        stderr: "",
+        error: error instanceof Error ? error.message : String(error),
+        startedAt: startedStep.startedAt ?? finishedAt2,
+        finishedAt: finishedAt2,
+        durationMs: new Date(finishedAt2).getTime() - new Date(startedStep.startedAt ?? finishedAt2).getTime()
+      };
+    } finally {
+      clearInterval(cancelTimer);
+      opts.signal?.removeEventListener("abort", externalAbort);
+    }
+    const timeoutMessage = opts.signal?.aborted ? opts.signalTimeoutMessage?.() : undefined;
+    if (timeoutMessage && result.status === "failed") {
+      result = { ...result, status: "timed_out", error: timeoutMessage };
+    }
+    if (store.isWorkflowRunTerminal(run.id)) {
+      terminalStatus = store.requireWorkflowRun(run.id).status;
+      blockingError = "workflow run was cancelled";
+      break;
+    }
     store.finalizeWorkflowStepRun(run.id, step.id, {
       status: result.status,
       finishedAt: result.finishedAt,
@@ -1658,6 +1995,11 @@ async function executeWorkflow(store, workflow, opts = {}) {
     }
   }
   const finishedAt = nowIso();
+  if (store.isWorkflowRunTerminal(run.id)) {
+    const terminalRun = store.requireWorkflowRun(run.id);
+    const steps2 = store.listWorkflowStepRuns(run.id);
+    return workflowResult(terminalRun, terminalRun.status, startedAt, terminalRun.finishedAt ?? finishedAt, JSON.stringify({ workflowRun: terminalRun, steps: steps2 }, null, 2), terminalRun.error ?? blockingError);
+  }
   const finalRun = store.finalizeWorkflowRun(run.id, terminalStatus, {
     finishedAt,
     durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
@@ -1666,20 +2008,59 @@ async function executeWorkflow(store, workflow, opts = {}) {
   const steps = store.listWorkflowStepRuns(run.id);
   return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, JSON.stringify({ workflowRun: finalRun, steps }, null, 2), blockingError);
 }
+function preflightWorkflow(workflow, opts = {}) {
+  return workflowExecutionOrder(workflow).map((step) => preflightTarget(targetWithStepAccount(step), {
+    workflowId: workflow.id,
+    workflowName: workflow.name,
+    workflowStepId: step.id
+  }, opts));
+}
 async function executeLoopTarget(store, loop, run, opts = {}) {
   if (loop.target.type !== "workflow")
     return executeLoop(loop, run, opts);
   const workflow = store.requireWorkflow(loop.target.workflowId);
-  return executeWorkflow(store, workflow, {
-    ...opts,
-    loop,
-    loopRun: run,
-    scheduledFor: run.scheduledFor,
-    idempotencyKey: `${loop.id}:${run.scheduledFor}`
-  });
+  const controller = loop.target.timeoutMs ? new AbortController : undefined;
+  let workflowTimedOut = false;
+  const externalAbort = () => controller?.abort();
+  if (controller && opts.signal?.aborted)
+    controller.abort();
+  if (controller)
+    opts.signal?.addEventListener("abort", externalAbort, { once: true });
+  const timer = controller ? setTimeout(() => {
+    workflowTimedOut = true;
+    controller.abort();
+  }, loop.target.timeoutMs) : undefined;
+  timer?.unref();
+  try {
+    return await executeWorkflow(store, workflow, {
+      ...opts,
+      signal: controller?.signal ?? opts.signal,
+      signalTimeoutMessage: () => workflowTimedOut && loop.target.type === "workflow" ? `workflow timed out after ${loop.target.timeoutMs}ms` : undefined,
+      loop,
+      loopRun: run,
+      scheduledFor: run.scheduledFor,
+      idempotencyKey: `${loop.id}:${run.scheduledFor}:attempt:${run.attempt}`
+    });
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    if (controller)
+      opts.signal?.removeEventListener("abort", externalAbort);
+  }
 }
 
 // src/lib/scheduler.ts
+function manualRunScheduledFor(loop, now = new Date) {
+  if (loop.nextRunAt && new Date(loop.nextRunAt).getTime() <= now.getTime()) {
+    return loop.retryScheduledFor ?? loop.nextRunAt;
+  }
+  return now.toISOString();
+}
+function shouldAdvanceManualRun(loop, scheduledFor, now = new Date) {
+  if (!loop.nextRunAt || new Date(loop.nextRunAt).getTime() > now.getTime())
+    return false;
+  return scheduledFor === (loop.retryScheduledFor ?? loop.nextRunAt);
+}
 function nextAfterRetry(loop, now) {
   return new Date(now.getTime() + loop.retryDelayMs).toISOString();
 }
@@ -1705,27 +2086,18 @@ function advanceLoop(store, loop, run, finishedAt, succeeded) {
     retryScheduledFor: undefined
   });
 }
-async function runSlot(deps, loop, scheduledFor) {
-  const now = deps.now?.() ?? new Date;
-  if (loop.overlap === "skip" && deps.store.hasRunningRun(loop.id)) {
-    const skipped = deps.store.createSkippedRun(loop, scheduledFor, "previous run still active");
-    advanceLoop(deps.store, loop, skipped, now, true);
-    deps.onRun?.(skipped);
-    return skipped;
-  }
-  const claim = deps.store.claimRun(loop, scheduledFor, deps.runnerId, now);
-  if (!claim)
-    return;
-  deps.onRun?.(claim.run);
+async function executeClaimedRun(deps) {
   let heartbeat;
-  const heartbeatEveryMs = Math.max(1000, Math.min(60000, Math.floor(claim.loop.leaseMs / 3)));
+  const heartbeatEveryMs = Math.max(10, Math.min(60000, Math.floor(deps.loop.leaseMs / 3)));
   heartbeat = setInterval(() => {
-    deps.store.heartbeatRunLease(claim.run.id, deps.runnerId, claim.loop.leaseMs);
+    deps.store.heartbeatRunLease(deps.run.id, deps.runnerId, deps.loop.leaseMs);
   }, heartbeatEveryMs);
   heartbeat.unref();
   try {
-    const result = await (deps.execute ?? ((loop2, run) => executeLoopTarget(deps.store, loop2, run)))(claim.loop, claim.run);
-    const finalRun = deps.store.finalizeRun(claim.run.id, {
+    const result = await (deps.execute ?? ((loop, run) => executeLoopTarget(deps.store, loop, run, {
+      onSpawn: (pid) => deps.store.markRunPid(run.id, pid, deps.runnerId)
+    })))(deps.loop, deps.run);
+    return deps.store.finalizeRun(deps.run.id, {
       status: result.status,
       finishedAt: result.finishedAt,
       durationMs: result.durationMs,
@@ -1738,16 +2110,13 @@ async function runSlot(deps, loop, scheduledFor) {
       claimedBy: deps.runnerId,
       now: deps.now?.() ?? new Date(result.finishedAt)
     });
-    advanceLoop(deps.store, claim.loop, finalRun, new Date(result.finishedAt), finalRun.status === "succeeded");
-    deps.onRun?.(finalRun);
-    return finalRun;
   } catch (err) {
-    deps.onError?.(claim.loop, err);
+    deps.onError?.(deps.loop, err);
     const finishedAt = new Date;
-    const finalRun = deps.store.finalizeRun(claim.run.id, {
+    return deps.store.finalizeRun(deps.run.id, {
       status: "failed",
       finishedAt: finishedAt.toISOString(),
-      durationMs: finishedAt.getTime() - new Date(claim.run.startedAt ?? claim.run.createdAt).getTime(),
+      durationMs: finishedAt.getTime() - new Date(deps.run.startedAt ?? deps.run.createdAt).getTime(),
       stdout: "",
       stderr: "",
       error: err instanceof Error ? err.message : String(err)
@@ -1755,14 +2124,36 @@ async function runSlot(deps, loop, scheduledFor) {
       claimedBy: deps.runnerId,
       now: deps.now?.() ?? finishedAt
     });
-    advanceLoop(deps.store, claim.loop, finalRun, finishedAt, false);
-    deps.onRun?.(finalRun);
-    return finalRun;
   } finally {
     if (heartbeat)
       clearInterval(heartbeat);
   }
 }
+async function runSlot(deps, loop, scheduledFor) {
+  const now = deps.now?.() ?? new Date;
+  if (loop.overlap === "skip" && deps.store.hasRunningRun(loop.id)) {
+    const skipped = deps.store.createSkippedRun(loop, scheduledFor, "previous run still active");
+    advanceLoop(deps.store, loop, skipped, now, true);
+    deps.onRun?.(skipped);
+    return skipped;
+  }
+  const claim = deps.store.claimRun(loop, scheduledFor, deps.runnerId, now);
+  if (!claim)
+    return;
+  deps.onRun?.(claim.run);
+  const finalRun = await executeClaimedRun({
+    store: deps.store,
+    runnerId: deps.runnerId,
+    loop: claim.loop,
+    run: claim.run,
+    now: deps.now,
+    execute: deps.execute,
+    onError: deps.onError
+  });
+  advanceLoop(deps.store, claim.loop, finalRun, new Date(finalRun.finishedAt ?? new Date), finalRun.status === "succeeded");
+  deps.onRun?.(finalRun);
+  return finalRun;
+}
 async function tick(deps) {
   const now = deps.now?.() ?? new Date;
   const recovered = deps.store.recoverExpiredRunLeases(now);
@@ -1941,6 +2332,7 @@ async function runDaemon(opts = {}) {
   const ownStore = !opts.store;
   const store = opts.store ?? new Store;
   const leaseId = genId();
+  const runnerId = `${hostname2()}:${process.pid}:${leaseId}`;
   const intervalMs = opts.intervalMs ?? intervalFromEnv() ?? 1000;
   const leaseTtlMs = opts.leaseTtlMs ?? Math.max(60000, intervalMs * 10);
   const log = opts.log ?? ((message) => console.error(`[loops-daemon] ${message}`));
@@ -1956,18 +2348,28 @@ async function runDaemon(opts = {}) {
   log(`started pid=${process.pid} interval=${intervalMs}ms lease=${leaseId}`);
   let stopFlag = false;
   let leaseLost = false;
+  const runAbort = new AbortController;
+  const requestStop = (message) => {
+    stopFlag = true;
+    if (!runAbort.signal.aborted)
+      runAbort.abort();
+    if (message)
+      log(message);
+  };
   const ensureLease = () => {
     const current = store.heartbeatDaemonLease(leaseId, leaseTtlMs);
     if (!current || current.id !== leaseId) {
       leaseLost = true;
-      stopFlag = true;
+      requestStop("daemon lease lost");
       throw new Error("daemon lease lost");
     }
   };
   const onSignal = () => {
-    stopFlag = true;
-    log("stop signal received");
+    requestStop("stop signal received");
   };
+  if (opts.signal?.aborted)
+    onSignal();
+  opts.signal?.addEventListener("abort", onSignal, { once: true });
   process.on("SIGINT", onSignal);
   process.on("SIGTERM", onSignal);
   try {
@@ -1980,7 +2382,7 @@ async function runDaemon(opts = {}) {
         ensureLease();
         const result = await tick({
           store,
-          runnerId: `${hostname2()}:${process.pid}:${leaseId}`,
+          runnerId,
           execute: async (loop, run) => {
             const heartbeatMs = Math.max(1000, Math.floor(leaseTtlMs / 3));
             const timer = setInterval(() => {
@@ -1992,7 +2394,10 @@ async function runDaemon(opts = {}) {
             }, heartbeatMs);
             timer.unref();
             try {
-              const result2 = await executeLoop(loop, run);
+              const result2 = await executeLoopTarget(store, loop, run, {
+                signal: runAbort.signal,
+                onSpawn: (pid) => store.markRunPid(run.id, pid, runnerId)
+              });
               if (leaseLost)
                 throw new Error("daemon lease lost during run");
               return result2;
@@ -2009,6 +2414,7 @@ async function runDaemon(opts = {}) {
       }
     });
   } finally {
+    opts.signal?.removeEventListener("abort", onSignal);
     process.off("SIGINT", onSignal);
     process.off("SIGTERM", onSignal);
     store.releaseDaemonLease(leaseId);
@@ -2044,9 +2450,11 @@ async function startDaemon(opts) {
 
 // src/daemon/install.ts
 import { chmodSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
 import { dirname as dirname3 } from "path";
 function installStartup(cliEntry, execPath = process.execPath, args = ["daemon", "run"]) {
   const command = [execPath, cliEntry, ...args].join(" ");
+  const pathEnv = normalizeExecutionPath(process.env);
   if (process.platform === "linux") {
     const path = systemdServicePath();
     mkdirSync4(dirname3(path), { recursive: true, mode: 448 });
@@ -2059,7 +2467,7 @@ Type=simple
 ExecStart=${command}
 Restart=always
 RestartSec=5
-Environment=PATH=${process.env.PATH ?? ""}
+Environment=PATH=${pathEnv}
 
 [Install]
 WantedBy=default.target
@@ -2091,6 +2499,10 @@ ${args.map((arg) => `    <string>${arg}</string>`).join(`
   </array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>${pathEnv}</string>
+  </dict>
   <key>StandardOutPath</key><string>${daemonLogPath()}</string>
   <key>StandardErrorPath</key><string>${daemonLogPath()}</string>
 </dict>
@@ -2105,10 +2517,100 @@ ${args.map((arg) => `    <string>${arg}</string>`).join(`
   }
   throw new Error(`startup install is not implemented for ${process.platform}`);
 }
+function enableStartup(result) {
+  const commands = result.platform === "linux" ? ["systemctl --user daemon-reload", "systemctl --user enable --now loops-daemon.service"] : result.platform === "darwin" ? [`launchctl load -w ${result.path}`] : [];
+  return commands.map((command) => {
+    const run = spawnSync2("sh", ["-c", command], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return {
+      command,
+      status: run.status,
+      stdout: run.stdout.trim(),
+      stderr: run.stderr.trim()
+    };
+  });
+}
+
+// src/lib/doctor.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { accessSync as accessSync2, constants as constants2 } from "fs";
+var PROVIDER_COMMANDS = [
+  "claude",
+  "cursor-agent",
+  "codewith",
+  "aicopilot",
+  "opencode",
+  "codex"
+];
+function hasCommand(command) {
+  const result = spawnSync3("sh", ["-c", 'command -v "$1" >/dev/null', "sh", command], { stdio: "ignore" });
+  return (result.status ?? 1) === 0;
+}
+function commandVersion(command) {
+  const result = spawnSync3(command, ["--version"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if ((result.status ?? 1) !== 0)
+    return;
+  return (result.stdout || result.stderr).trim().split(/\r?\n/)[0];
+}
+function runDoctor(store) {
+  const checks = [];
+  try {
+    const dir = ensureDataDir();
+    accessSync2(dir, constants2.R_OK | constants2.W_OK);
+    checks.push({ id: "data-dir", status: "ok", message: "data directory is writable", detail: dir });
+  } catch (error) {
+    checks.push({
+      id: "data-dir",
+      status: "fail",
+      message: "data directory is not writable",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const bunVersion = commandVersion("bun");
+  checks.push(bunVersion ? { id: "bun", status: "ok", message: "bun is available", detail: bunVersion } : { id: "bun", status: "fail", message: "bun is not available on PATH" });
+  const accountsVersion = commandVersion("accounts");
+  checks.push(accountsVersion ? { id: "accounts", status: "ok", message: "accounts is available", detail: accountsVersion } : { id: "accounts", status: "warn", message: "accounts CLI is not available; account-routed steps will fail" });
+  for (const command of PROVIDER_COMMANDS) {
+    checks.push(hasCommand(command) ? { id: `provider:${command}`, status: "ok", message: `${command} is available` } : { id: `provider:${command}`, status: "warn", message: `${command} is not on PATH` });
+  }
+  const status = daemonStatus(store);
+  checks.push(status.running ? { id: "daemon", status: "ok", message: `daemon is running pid=${status.pid}` } : { id: "daemon", status: status.stale ? "warn" : "ok", message: status.stale ? "daemon pid file is stale" : "daemon is not running" });
+  const failedRuns = store.countRuns("failed");
+  checks.push(failedRuns === 0 ? { id: "loop-runs", status: "ok", message: "no failed loop runs recorded" } : { id: "loop-runs", status: "warn", message: `${failedRuns} failed loop run(s) recorded` });
+  for (const loop of store.listLoops({ status: "active" })) {
+    try {
+      if (loop.target.type === "workflow") {
+        const workflow = store.requireWorkflow(loop.target.workflowId);
+        for (const step of workflowExecutionOrder(workflow)) {
+          preflightTarget({ ...step.target, account: step.account ?? step.target.account, timeoutMs: step.timeoutMs ?? step.target.timeoutMs }, { loopId: loop.id, loopName: loop.name, workflowId: workflow.id, workflowName: workflow.name, workflowStepId: step.id });
+        }
+      } else {
+        preflightTarget(loop.target, { loopId: loop.id, loopName: loop.name });
+      }
+      checks.push({ id: `loop:${loop.id}:preflight`, status: "ok", message: `active loop target is ready: ${loop.name}` });
+    } catch (error) {
+      checks.push({
+        id: `loop:${loop.id}:preflight`,
+        status: "warn",
+        message: `active loop target preflight failed: ${loop.name}`,
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return {
+    ok: checks.every((check) => check.status !== "fail"),
+    checks
+  };
+}
 
 // src/cli/index.ts
 var program = new Command;
-program.name("loops").description("Persistent local loops for commands and headless coding agents").version("0.2.0");
+program.name("loops").description("Persistent local loops for commands and headless coding agents").version("0.3.1");
 program.option("-j, --json", "print JSON");
 function isJson() {
   return Boolean(program.opts().json);
@@ -2119,6 +2621,10 @@ function print(value, human) {
   else
     console.log(human);
 }
+function printTextOutput(value) {
+  for (const line of textOutputBlocks(value, { indent: "  " }))
+    console.log(line);
+}
 function parseSchedule(opts) {
   const count = [opts.at, opts.every, opts.cron, opts.dynamic ? "dynamic" : undefined].filter(Boolean).length;
   if (count !== 1)
@@ -2258,6 +2764,22 @@ addScheduleOptions(create.command("workflow <name>").description("schedule a sto
   }
 });
 var workflows = program.command("workflows").alias("workflow").description("manage workflow specs and runs");
+workflows.command("validate <file>").description("validate a workflow JSON file without storing or running it").option("--name <name>", "override workflow name from the file").option("--preflight", "also check account env and target executables").action((file, opts) => {
+  const body = workflowBodyFromJson(JSON.parse(readFileSync2(file, "utf8")), opts.name);
+  const now = new Date().toISOString();
+  const workflow = {
+    id: "validation",
+    name: body.name,
+    description: body.description,
+    version: body.version ?? 1,
+    status: "active",
+    steps: body.steps,
+    createdAt: now,
+    updatedAt: now
+  };
+  const preflight = opts.preflight ? preflightWorkflow(workflow) : undefined;
+  print({ valid: true, workflow: publicWorkflow(workflow), preflight }, `valid workflow ${workflow.name} steps=${workflow.steps.length}`);
+});
 workflows.command("create <file>").description("validate and store a workflow JSON file").option("--name <name>", "override workflow name from the file").action((file, opts) => {
   const store = new Store;
   try {
@@ -2291,6 +2813,30 @@ workflows.command("show <idOrName>").action((idOrName) => {
     store.close();
   }
 });
+workflows.command("inspect <runId>").description("show a workflow run with steps and events").action((runId) => {
+  const store = new Store;
+  try {
+    const run = store.requireWorkflowRun(runId);
+    const steps = store.listWorkflowStepRuns(run.id);
+    const events = store.listWorkflowEvents(run.id);
+    const value = {
+      workflowRun: publicWorkflowRun(run),
+      steps: steps.map((step) => publicWorkflowStepRun(step, isJson())),
+      events: events.map(publicWorkflowEvent)
+    };
+    if (isJson())
+      print(value);
+    else {
+      console.log(`${run.id}  ${run.status}  ${run.workflowName}`);
+      for (const step of steps) {
+        console.log(`  ${String(step.sequence).padStart(2, "0")}  ${step.status.padEnd(10)}  ${step.stepId}  ${step.error ?? ""}`);
+      }
+      console.log(`  events=${events.length}`);
+    }
+  } finally {
+    store.close();
+  }
+});
 workflows.command("run <idOrName>").option("--show-output", "show step stdout/stderr").action(async (idOrName, opts) => {
   const store = new Store;
   try {
@@ -2303,7 +2849,16 @@ workflows.command("run <idOrName>").option("--show-output", "show step stdout/st
       workflowRun: run ? publicWorkflowRun(run) : undefined,
       steps: steps.map((step) => publicWorkflowStepRun(step, opts.showOutput))
     };
-    print(value, `${run?.id ?? workflow.id} ${result.status}`);
+    if (isJson())
+      print(value);
+    else {
+      console.log(`${run?.id ?? workflow.id} ${result.status}`);
+      for (const step of steps) {
+        console.log(`  ${String(step.sequence).padStart(2, "0")}  ${step.status.padEnd(10)}  ${step.stepId}  ${step.error ?? ""}`);
+        if (opts.showOutput)
+          printTextOutput(step);
+      }
+    }
   } finally {
     store.close();
   }
@@ -2339,6 +2894,27 @@ workflows.command("events <runId>").option("--limit <n>", "limit", "200").action
     store.close();
   }
 });
+workflows.command("cancel <runId>").description("mark a workflow run cancelled and cancel pending/running steps").option("--reason <reason>", "cancellation reason", "cancelled by user").action((runId, opts) => {
+  const store = new Store;
+  try {
+    const run = store.cancelWorkflowRun(runId, opts.reason);
+    print(publicWorkflowRun(run), `${run.id} ${run.status}`);
+  } finally {
+    store.close();
+  }
+});
+workflows.command("recover <runId>").description("reset interrupted running workflow steps to pending").option("--reason <reason>", "recovery reason", "manual recovery").action((runId, opts) => {
+  const store = new Store;
+  try {
+    const result = store.recoverWorkflowRun(runId, opts.reason);
+    print({
+      workflowRun: publicWorkflowRun(result.run),
+      recoveredSteps: result.recoveredSteps.map((step) => publicWorkflowStepRun(step))
+    }, `${result.run.id} recovered=${result.recoveredSteps.length}`);
+  } finally {
+    store.close();
+  }
+});
 workflows.command("archive <idOrName>").action((idOrName) => {
   const store = new Store;
   try {
@@ -2381,6 +2957,8 @@ program.command("runs [idOrName]").option("--limit <n>", "limit", "50").option("
     else {
       for (const run of runs) {
         console.log(`${run.id}  ${run.status.padEnd(10)}  attempt=${run.attempt}  slot=${run.scheduledFor}  ${run.loopName}`);
+        if (opts.showOutput)
+          printTextOutput(run);
       }
     }
   } finally {
@@ -2413,23 +2991,20 @@ program.command("run-now <idOrName>").option("--show-output", "show stdout/stder
   const store = new Store;
   try {
     const loop = store.requireLoop(idOrName);
-    const claim = store.claimRun(loop, new Date().toISOString(), `manual:${process.pid}`);
+    const runnerId = `manual:${process.pid}`;
+    const now = new Date;
+    const scheduledFor = manualRunScheduledFor(loop, now);
+    const shouldAdvance = shouldAdvanceManualRun(loop, scheduledFor, now);
+    const claim = store.claimRun(loop, scheduledFor, runnerId, now);
     if (!claim)
       throw new Error("could not claim manual run");
-    const result = await executeLoopTarget(store, loop, claim.run);
-    const run = store.finalizeRun(claim.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
-    }, {
-      claimedBy: claim.run.claimedBy
-    });
+    const run = await executeClaimedRun({ store, runnerId, loop: claim.loop, run: claim.run });
+    if (shouldAdvance) {
+      advanceLoop(store, claim.loop, run, new Date(run.finishedAt ?? new Date), run.status === "succeeded");
+    }
     print(publicRun(run, opts.showOutput), `${run.id} ${run.status}`);
+    if (!isJson() && opts.showOutput)
+      printTextOutput(run);
   } finally {
     store.close();
   }
@@ -2443,6 +3018,24 @@ program.command("tick").description("run one scheduler tick").action(async () =>
     store.close();
   }
 });
+program.command("doctor").description("check local OpenLoops runtime dependencies and state").action(() => {
+  const store = new Store;
+  try {
+    const report = runDoctor(store);
+    if (isJson())
+      print(report);
+    else {
+      for (const check of report.checks) {
+        const marker = check.status === "ok" ? "ok" : check.status === "warn" ? "warn" : "fail";
+        console.log(`${marker.padEnd(4)} ${check.id.padEnd(22)} ${check.message}${check.detail ? ` (${check.detail})` : ""}`);
+      }
+      if (!report.ok)
+        process.exitCode = 1;
+    }
+  } finally {
+    store.close();
+  }
+});
 var daemon = program.command("daemon").description("manage the local daemon");
 daemon.command("run").option("--interval-ms <ms>", "tick interval", (value) => Number(value)).action(async (opts) => runDaemon({ intervalMs: opts.intervalMs }));
 daemon.command("start").action(async () => {
@@ -2461,11 +3054,16 @@ daemon.command("status").action(() => {
     store.close();
   }
 });
-daemon.command("install").description("write a systemd user service or launchd plist").action(() => {
+daemon.command("install").description("write a systemd user service or launchd plist").option("--enable", "also enable/start the user service when supported").action((opts) => {
   const result = installStartup(process.argv[1] ?? "loops");
+  if (opts.enable)
+    result.enableResults = enableStartup(result);
+  const enableText = result.enableResults ? `
+${result.enableResults.map((item) => `${item.command} -> ${item.status === 0 ? "ok" : `exit ${item.status}`}`).join(`
+`)}` : "";
   print(result, `wrote ${result.path}
 ${result.instructions.join(`
-`)}`);
+`)}${enableText}`);
 });
 daemon.command("logs").option("-n, --lines <n>", "lines", "80").action((opts) => {
   const path = daemonLogPath();