@hasna/loops 0.1.0 → 0.2.0

package/dist/cli/index.js

@@ -236,6 +236,100 @@ function parseDuration(input) {
   return Math.round(value * multiplier);
 }
 
+// src/lib/workflow-spec.ts
+function assertObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+}
+function assertString(value, label) {
+  if (typeof value !== "string" || value.trim() === "")
+    throw new Error(`${label} must be a non-empty string`);
+}
+function validateTarget(value, label) {
+  assertObject(value, label);
+  if (value.type === "command") {
+    assertString(value.command, `${label}.command`);
+    return value;
+  }
+  if (value.type === "agent") {
+    assertString(value.provider, `${label}.provider`);
+    assertString(value.prompt, `${label}.prompt`);
+    const providers = ["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"];
+    if (!providers.includes(value.provider))
+      throw new Error(`${label}.provider must be one of ${providers.join(", ")}`);
+    return value;
+  }
+  throw new Error(`${label}.type must be command or agent`);
+}
+function normalizeCreateWorkflowInput(input) {
+  assertString(input.name, "workflow.name");
+  if (!Array.isArray(input.steps) || input.steps.length === 0)
+    throw new Error("workflow.steps must contain at least one step");
+  const seen = new Set;
+  const steps = input.steps.map((step, index) => {
+    assertObject(step, `workflow.steps[${index}]`);
+    assertString(step.id, `workflow.steps[${index}].id`);
+    if (seen.has(step.id))
+      throw new Error(`duplicate workflow step id: ${step.id}`);
+    seen.add(step.id);
+    return {
+      ...step,
+      id: step.id,
+      target: validateTarget(step.target, `workflow.steps[${index}].target`),
+      dependsOn: step.dependsOn ?? [],
+      continueOnFailure: step.continueOnFailure ?? false
+    };
+  });
+  for (const step of steps) {
+    for (const dependency of step.dependsOn ?? []) {
+      if (!seen.has(dependency))
+        throw new Error(`step ${step.id} depends on missing step ${dependency}`);
+      if (dependency === step.id)
+        throw new Error(`step ${step.id} cannot depend on itself`);
+    }
+  }
+  workflowExecutionOrder({ steps });
+  return { ...input, name: input.name.trim(), version: input.version ?? 1, steps };
+}
+function workflowExecutionOrder(workflow) {
+  const byId = new Map(workflow.steps.map((step) => [step.id, step]));
+  const visiting = new Set;
+  const visited = new Set;
+  const order = [];
+  function visit(step) {
+    if (visited.has(step.id))
+      return;
+    if (visiting.has(step.id))
+      throw new Error(`workflow dependency cycle includes step ${step.id}`);
+    visiting.add(step.id);
+    for (const dependencyId of step.dependsOn ?? []) {
+      const dependency = byId.get(dependencyId);
+      if (!dependency)
+        throw new Error(`step ${step.id} depends on missing step ${dependencyId}`);
+      visit(dependency);
+    }
+    visiting.delete(step.id);
+    visited.add(step.id);
+    order.push(step);
+  }
+  for (const step of workflow.steps)
+    visit(step);
+  return order;
+}
+function workflowBodyFromJson(value, fallbackName) {
+  assertObject(value, "workflow file");
+  const rawName = fallbackName ?? value.name;
+  assertString(rawName, "workflow.name");
+  if (!Array.isArray(value.steps))
+    throw new Error("workflow.steps must be an array");
+  return normalizeCreateWorkflowInput({
+    name: rawName,
+    description: typeof value.description === "string" ? value.description : undefined,
+    version: typeof value.version === "number" ? value.version : undefined,
+    steps: value.steps
+  });
+}
+
 // src/lib/store.ts
 function rowToLoop(row) {
   return {
@@ -280,6 +374,67 @@ function rowToRun(row) {
     updatedAt: row.updated_at
   };
 }
+function rowToWorkflow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description ?? undefined,
+    version: row.version,
+    status: row.status,
+    steps: JSON.parse(row.steps_json),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowRun(row) {
+  return {
+    id: row.id,
+    workflowId: row.workflow_id,
+    workflowName: row.workflow_name,
+    loopId: row.loop_id ?? undefined,
+    loopRunId: row.loop_run_id ?? undefined,
+    scheduledFor: row.scheduled_for ?? undefined,
+    idempotencyKey: row.idempotency_key ?? undefined,
+    status: row.status,
+    startedAt: row.started_at ?? undefined,
+    finishedAt: row.finished_at ?? undefined,
+    durationMs: row.duration_ms ?? undefined,
+    error: row.error ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowStepRun(row) {
+  return {
+    id: row.id,
+    workflowRunId: row.workflow_run_id,
+    stepId: row.step_id,
+    sequence: row.sequence,
+    status: row.status,
+    startedAt: row.started_at ?? undefined,
+    finishedAt: row.finished_at ?? undefined,
+    exitCode: row.exit_code ?? undefined,
+    durationMs: row.duration_ms ?? undefined,
+    stdout: row.stdout ?? undefined,
+    stderr: row.stderr ?? undefined,
+    error: row.error ?? undefined,
+    accountProfile: row.account_profile ?? undefined,
+    accountTool: row.account_tool ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function rowToWorkflowEvent(row) {
+  return {
+    id: row.id,
+    workflowRunId: row.workflow_run_id,
+    sequence: row.sequence,
+    eventType: row.event_type,
+    stepId: row.step_id ?? undefined,
+    payload: row.payload_json ? JSON.parse(row.payload_json) : undefined,
+    createdAt: row.created_at
+  };
+}
 function rowToLease(row) {
   return {
     id: row.id,
@@ -305,6 +460,11 @@ class Store {
   }
   migrate() {
     this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        id TEXT PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      );
+
       CREATE TABLE IF NOT EXISTS loops (
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
@@ -361,7 +521,78 @@ class Store {
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL
       );
+
+      CREATE TABLE IF NOT EXISTS workflow_specs (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        version INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        steps_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflows_status_name ON workflow_specs(status, name);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_workflows_name_active ON workflow_specs(name) WHERE status = 'active';
+
+      CREATE TABLE IF NOT EXISTS workflow_runs (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL REFERENCES workflow_specs(id) ON DELETE CASCADE,
+        workflow_name TEXT NOT NULL,
+        loop_id TEXT REFERENCES loops(id) ON DELETE SET NULL,
+        loop_run_id TEXT REFERENCES loop_runs(id) ON DELETE SET NULL,
+        scheduled_for TEXT,
+        idempotency_key TEXT,
+        status TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        duration_ms INTEGER,
+        error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_workflow_runs_idempotency
+        ON workflow_runs(workflow_id, idempotency_key)
+        WHERE idempotency_key IS NOT NULL;
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow_created ON workflow_runs(workflow_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_loop_run ON workflow_runs(loop_run_id);
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+
+      CREATE TABLE IF NOT EXISTS workflow_step_runs (
+        id TEXT PRIMARY KEY,
+        workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+        step_id TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        exit_code INTEGER,
+        duration_ms INTEGER,
+        stdout TEXT,
+        stderr TEXT,
+        error TEXT,
+        account_profile TEXT,
+        account_tool TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(workflow_run_id, step_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_run_sequence ON workflow_step_runs(workflow_run_id, sequence);
+      CREATE INDEX IF NOT EXISTS idx_workflow_step_runs_status ON workflow_step_runs(status);
+
+      CREATE TABLE IF NOT EXISTS workflow_events (
+        id TEXT PRIMARY KEY,
+        workflow_run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+        sequence INTEGER NOT NULL,
+        event_type TEXT NOT NULL,
+        step_id TEXT,
+        payload_json TEXT,
+        created_at TEXT NOT NULL,
+        UNIQUE(workflow_run_id, sequence)
+      );
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_run_sequence ON workflow_events(workflow_run_id, sequence);
     `);
+    this.db.query("INSERT OR IGNORE INTO schema_migrations (id, applied_at) VALUES (?, ?)").run("0001_initial_and_workflows", nowIso());
   }
   createLoop(input, from = new Date) {
     const now = nowIso();
@@ -453,6 +684,244 @@ class Store {
     const res = this.db.query("DELETE FROM loops WHERE id = ?").run(loop.id);
     return res.changes > 0;
   }
+  createWorkflow(input) {
+    const normalized = normalizeCreateWorkflowInput(input);
+    const now = nowIso();
+    const workflow = {
+      id: genId(),
+      name: normalized.name,
+      description: normalized.description,
+      version: normalized.version ?? 1,
+      status: "active",
+      steps: normalized.steps,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.query(`INSERT INTO workflow_specs (id, name, description, version, status, steps_json, created_at, updated_at)
+         VALUES ($id, $name, $description, $version, $status, $steps, $created, $updated)`).run({
+      $id: workflow.id,
+      $name: workflow.name,
+      $description: workflow.description ?? null,
+      $version: workflow.version,
+      $status: workflow.status,
+      $steps: JSON.stringify(workflow.steps),
+      $created: workflow.createdAt,
+      $updated: workflow.updatedAt
+    });
+    return workflow;
+  }
+  getWorkflow(id) {
+    const row = this.db.query("SELECT * FROM workflow_specs WHERE id = ?").get(id);
+    return row ? rowToWorkflow(row) : undefined;
+  }
+  findWorkflowByName(name) {
+    const row = this.db.query("SELECT * FROM workflow_specs WHERE name = ? AND status = 'active' ORDER BY updated_at DESC LIMIT 1").get(name);
+    return row ? rowToWorkflow(row) : undefined;
+  }
+  requireWorkflow(idOrName) {
+    return this.getWorkflow(idOrName) ?? this.findWorkflowByName(idOrName) ?? (() => {
+      throw new Error(`workflow not found: ${idOrName}`);
+    })();
+  }
+  listWorkflows(opts = {}) {
+    const limit = opts.limit ?? 200;
+    const rows = opts.status ? this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT ?").all(opts.status, limit) : this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT ?").all(limit);
+    return rows.map(rowToWorkflow);
+  }
+  archiveWorkflow(idOrName) {
+    const workflow = this.requireWorkflow(idOrName);
+    const updated = nowIso();
+    this.db.query("UPDATE workflow_specs SET status='archived', updated_at=? WHERE id=?").run(updated, workflow.id);
+    const archived = this.getWorkflow(workflow.id);
+    if (!archived)
+      throw new Error(`workflow not found after archive: ${workflow.id}`);
+    return archived;
+  }
+  createWorkflowRun(input) {
+    const now = nowIso();
+    if (input.idempotencyKey) {
+      const existing = this.db.query("SELECT * FROM workflow_runs WHERE workflow_id = ? AND idempotency_key = ? LIMIT 1").get(input.workflow.id, input.idempotencyKey);
+      if (existing)
+        return rowToWorkflowRun(existing);
+    }
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      if (input.idempotencyKey) {
+        const existing = this.db.query("SELECT * FROM workflow_runs WHERE workflow_id = ? AND idempotency_key = ? LIMIT 1").get(input.workflow.id, input.idempotencyKey);
+        if (existing) {
+          this.db.exec("COMMIT");
+          return rowToWorkflowRun(existing);
+        }
+      }
+      const runId = genId();
+      this.db.query(`INSERT INTO workflow_runs (id, workflow_id, workflow_name, loop_id, loop_run_id, scheduled_for, idempotency_key,
+            status, started_at, finished_at, duration_ms, error, created_at, updated_at)
+           VALUES ($id, $workflowId, $workflowName, $loopId, $loopRunId, $scheduledFor, $idempotencyKey,
+            'running', $started, NULL, NULL, NULL, $created, $updated)`).run({
+        $id: runId,
+        $workflowId: input.workflow.id,
+        $workflowName: input.workflow.name,
+        $loopId: input.loop?.id ?? null,
+        $loopRunId: input.loopRun?.id ?? null,
+        $scheduledFor: input.scheduledFor ?? input.loopRun?.scheduledFor ?? null,
+        $idempotencyKey: input.idempotencyKey ?? null,
+        $started: now,
+        $created: now,
+        $updated: now
+      });
+      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,
+              $accountProfile, $accountTool, $created, $updated)`).run({
+          $id: genId(),
+          $workflowRunId: runId,
+          $stepId: step.id,
+          $sequence: sequence,
+          $accountProfile: account?.profile ?? null,
+          $accountTool: account?.tool ?? null,
+          $created: now,
+          $updated: now
+        });
+      });
+      this.db.query(`INSERT INTO workflow_events (id, workflow_run_id, sequence, event_type, step_id, payload_json, created_at)
+           VALUES ($id, $workflowRunId, 1, 'created', NULL, $payload, $created)`).run({
+        $id: genId(),
+        $workflowRunId: runId,
+        $payload: JSON.stringify({
+          workflowId: input.workflow.id,
+          workflowName: input.workflow.name,
+          stepCount: input.workflow.steps.length,
+          loopId: input.loop?.id,
+          loopRunId: input.loopRun?.id
+        }),
+        $created: now
+      });
+      this.db.exec("COMMIT");
+      const run = this.getWorkflowRun(runId);
+      if (!run)
+        throw new Error(`workflow run not found after create: ${runId}`);
+      return run;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  getWorkflowRun(id) {
+    const row = this.db.query("SELECT * FROM workflow_runs WHERE id = ?").get(id);
+    return row ? rowToWorkflowRun(row) : undefined;
+  }
+  listWorkflowRuns(opts = {}) {
+    const limit = opts.limit ?? 100;
+    let rows;
+    if (opts.workflowId) {
+      rows = this.db.query("SELECT * FROM workflow_runs WHERE workflow_id = ? ORDER BY created_at DESC LIMIT ?").all(opts.workflowId, limit);
+    } else if (opts.loopRunId) {
+      rows = this.db.query("SELECT * FROM workflow_runs WHERE loop_run_id = ? ORDER BY created_at DESC LIMIT ?").all(opts.loopRunId, limit);
+    } else {
+      rows = this.db.query("SELECT * FROM workflow_runs ORDER BY created_at DESC LIMIT ?").all(limit);
+    }
+    return rows.map(rowToWorkflowRun);
+  }
+  listWorkflowStepRuns(workflowRunId) {
+    const rows = this.db.query("SELECT * FROM workflow_step_runs WHERE workflow_run_id = ? ORDER BY sequence ASC").all(workflowRunId);
+    return rows.map(rowToWorkflowStepRun);
+  }
+  getWorkflowStepRun(workflowRunId, stepId) {
+    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;
+  }
+  startWorkflowStepRun(workflowRunId, stepId) {
+    const now = nowIso();
+    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);
+    const run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found: ${workflowRunId}/${stepId}`);
+    return run;
+  }
+  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({
+      $workflowRunId: workflowRunId,
+      $stepId: stepId,
+      $status: patch.status,
+      $finished: finishedAt,
+      $exitCode: patch.exitCode ?? null,
+      $durationMs: patch.durationMs ?? null,
+      $stdout: patch.stdout ?? null,
+      $stderr: patch.stderr ?? null,
+      $error: patch.error ?? null,
+      $updated: finishedAt
+    });
+    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}`);
+    return run;
+  }
+  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 run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found after skip: ${workflowRunId}/${stepId}`);
+    return run;
+  }
+  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({
+      $id: workflowRunId,
+      $status: status,
+      $finished: finishedAt,
+      $durationMs: patch.durationMs ?? null,
+      $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}`);
+    return run;
+  }
+  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);
+    const sequence = (current?.sequence ?? 0) + 1;
+    const id = genId();
+    this.db.query(`INSERT INTO workflow_events (id, workflow_run_id, sequence, event_type, step_id, payload_json, created_at)
+         VALUES ($id, $workflowRunId, $sequence, $eventType, $stepId, $payload, $created)`).run({
+      $id: id,
+      $workflowRunId: workflowRunId,
+      $sequence: sequence,
+      $eventType: eventType,
+      $stepId: stepId ?? null,
+      $payload: payload ? JSON.stringify(payload) : null,
+      $created: now
+    });
+    const event = this.db.query("SELECT * FROM workflow_events WHERE id = ?").get(id);
+    if (!event)
+      throw new Error(`workflow event not found after append: ${id}`);
+    return rowToWorkflowEvent(event);
+  }
+  listWorkflowEvents(workflowRunId, limit = 200) {
+    const rows = this.db.query("SELECT * FROM workflow_events WHERE workflow_run_id = ? ORDER BY sequence ASC LIMIT ?").all(workflowRunId, limit);
+    return rows.map(rowToWorkflowEvent);
+  }
   hasRunningRun(loopId) {
     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;
@@ -573,10 +1042,9 @@ class Store {
       throw error;
     }
   }
-  finalizeRun(id, patch) {
+  finalizeRun(id, patch, opts = {}) {
     const finishedAt = patch.finishedAt ?? nowIso();
-    this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
-         duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated WHERE id=$id`).run({
+    const params = {
       $id: id,
       $status: patch.status,
       $finished: finishedAt,
@@ -586,13 +1054,29 @@ class Store {
       $stdout: patch.stdout ?? null,
       $stderr: patch.stderr ?? null,
       $error: patch.error ?? null,
-      $updated: finishedAt
-    });
+      $updated: finishedAt,
+      $claimedBy: opts.claimedBy ?? null,
+      $now: (opts.now ?? new Date).toISOString()
+    };
+    const res = opts.claimedBy ? this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
+             duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
+             WHERE id=$id AND status='running' AND claimed_by=$claimedBy AND lease_expires_at > $now`).run(params) : this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, lease_expires_at=NULL, pid=$pid, exit_code=$exitCode,
+             duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated WHERE id=$id`).run(params);
     const run = this.getRun(id);
     if (!run)
       throw new Error(`run not found after finalize: ${id}`);
+    if (opts.claimedBy && res.changes !== 1)
+      return run;
     return run;
   }
+  heartbeatRunLease(id, claimedBy, leaseMs, now = new Date) {
+    const expiresAt = new Date(now.getTime() + leaseMs).toISOString();
+    const res = this.db.query(`UPDATE loop_runs SET lease_expires_at=$expires, updated_at=$updated
+         WHERE id=$id AND status='running' AND claimed_by=$claimedBy`).run({ $id: id, $claimedBy: claimedBy, $expires: expiresAt, $updated: now.toISOString() });
+    if (res.changes !== 1)
+      return;
+    return this.getRun(id);
+  }
   listRuns(opts = {}) {
     const limit = opts.limit ?? 100;
     let rows;
@@ -684,7 +1168,7 @@ class Store {
 }
 
 // src/cli/index.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { Command } from "commander";
 
 // src/lib/format.ts
@@ -696,7 +1180,7 @@ function redact(value, visible = 80) {
   return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
 }
 function publicLoop(loop) {
-  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : { ...loop.target, prompt: redact(loop.target.prompt) };
+  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
@@ -709,12 +1193,129 @@ function publicRun(run, showOutput = false) {
     stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined
   };
 }
+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 };
+}
+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
+  };
+}
+function publicWorkflowEvent(event) {
+  return { ...event };
+}
 
 // src/lib/executor.ts
 import { spawn } from "child_process";
 import { once } from "events";
+
+// src/lib/accounts.ts
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+var EXPORT_RE = /^export\s+([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+function accountToolForProvider(provider) {
+  switch (provider) {
+    case "claude":
+      return "claude";
+    case "cursor":
+      return "cursor";
+    case "codewith":
+      return "codewith";
+    case "aicopilot":
+      return "aicopilot";
+    case "opencode":
+      return "opencode";
+    case "codex":
+      return "codex";
+  }
+}
+function parseExportValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw.replace(/^['"]|['"]$/g, "");
+  }
+}
+function parseAccountExportLines(output) {
+  const env = {};
+  for (const line of output.split(/\r?\n/)) {
+    const match = EXPORT_RE.exec(line.trim());
+    if (!match)
+      continue;
+    env[match[1]] = parseExportValue(match[2]);
+  }
+  return env;
+}
+function primaryAccountDir(output) {
+  for (const line of output.split(/\r?\n/)) {
+    const match = EXPORT_RE.exec(line.trim());
+    if (!match)
+      continue;
+    return parseExportValue(match[2]);
+  }
+  return;
+}
+function resolveAccountEnv(account, toolHint, env) {
+  if (!account)
+    return {};
+  const tool = account.tool ?? toolHint;
+  if (!tool)
+    throw new Error("account.tool is required when no provider tool can be inferred");
+  const result = spawnSync("accounts", ["env", account.profile, "--tool", tool], {
+    encoding: "utf8",
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error) {
+    throw new Error(`failed to run accounts env for ${account.profile}/${tool}: ${result.error.message}`);
+  }
+  if ((result.status ?? 0) !== 0) {
+    const stderr = result.stderr.trim();
+    throw new Error(`accounts env failed for ${account.profile}/${tool}${stderr ? `: ${stderr}` : ""}`);
+  }
+  const profileDir = 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),
+    LOOPS_ACCOUNT_PROFILE: account.profile,
+    LOOPS_ACCOUNT_TOOL: tool
+  };
+}
+
+// src/lib/executor.ts
 var DEFAULT_TIMEOUT_MS = 30 * 60000;
 var DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
+var AUTH_ENV_KEYS = [
+  "CLAUDE_CONFIG_DIR",
+  "CODEWITH_HOME",
+  "CODEX_HOME",
+  "CURSOR_CONFIG_DIR",
+  "OPENCODE_CONFIG_DIR",
+  "AICOPILOT_CONFIG_DIR",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "GITHUB_TOKEN",
+  "GH_TOKEN",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "XDG_CACHE_HOME"
+];
 function appendBounded(current, chunk, maxBytes) {
   const next = current + chunk.toString("utf8");
   if (Buffer.byteLength(next, "utf8") <= maxBytes)
@@ -753,6 +1354,8 @@ function providerCommand(provider) {
       return "aicopilot";
     case "opencode":
       return "opencode";
+    case "codex":
+      return "codex";
   }
 }
 function agentArgs(target) {
@@ -789,6 +1392,16 @@ function agentArgs(target) {
         args.push("--agent", target.agent);
       args.push(...target.extraArgs ?? [], target.prompt);
       return args;
+    case "codex":
+      args.push("exec", "--json", "--ephemeral", "--ask-for-approval", "never", "--sandbox", "workspace-write");
+      if (isolation === "safe")
+        args.push("--ignore-rules");
+      if (target.cwd)
+        args.push("--cd", target.cwd);
+      if (target.model)
+        args.push("--model", target.model);
+      args.push(...target.extraArgs ?? [], target.prompt);
+      return args;
     case "aicopilot":
       args.push("run", "--format", "json");
       if (isolation === "safe")
@@ -815,8 +1428,7 @@ function agentArgs(target) {
       return args;
   }
 }
-function commandSpec(loop) {
-  const target = loop.target;
+function commandSpec(target) {
   if (target.type === "command") {
     const commandTarget = target;
     return {
@@ -825,7 +1437,9 @@ function commandSpec(loop) {
       cwd: commandTarget.cwd,
       shell: commandTarget.shell,
       env: commandTarget.env,
-      timeoutMs: commandTarget.timeoutMs ?? DEFAULT_TIMEOUT_MS
+      timeoutMs: commandTarget.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      account: commandTarget.account,
+      accountTool: commandTarget.account?.tool
     };
   }
   const agentTarget = target;
@@ -833,11 +1447,40 @@ function commandSpec(loop) {
     command: providerCommand(agentTarget.provider),
     args: agentArgs(agentTarget),
     cwd: agentTarget.cwd,
-    timeoutMs: agentTarget.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    timeoutMs: agentTarget.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    account: agentTarget.account,
+    accountTool: agentTarget.account?.tool ?? accountToolForProvider(agentTarget.provider)
   };
 }
-async function executeLoop(loop, run, opts = {}) {
-  const spec = commandSpec(loop);
+function executionEnv(spec, metadata, opts) {
+  const env = { ...opts.env ?? process.env };
+  if (spec.account) {
+    const accountEnv = resolveAccountEnv(spec.account, spec.accountTool, env);
+    for (const key of AUTH_ENV_KEYS)
+      delete env[key];
+    Object.assign(env, accountEnv);
+  }
+  Object.assign(env, spec.env ?? {});
+  if (metadata.loopId)
+    env.LOOPS_LOOP_ID = metadata.loopId;
+  if (metadata.loopName)
+    env.LOOPS_LOOP_NAME = metadata.loopName;
+  if (metadata.runId)
+    env.LOOPS_RUN_ID = metadata.runId;
+  if (metadata.scheduledFor)
+    env.LOOPS_SCHEDULED_FOR = metadata.scheduledFor;
+  if (metadata.workflowId)
+    env.LOOPS_WORKFLOW_ID = metadata.workflowId;
+  if (metadata.workflowName)
+    env.LOOPS_WORKFLOW_NAME = metadata.workflowName;
+  if (metadata.workflowRunId)
+    env.LOOPS_WORKFLOW_RUN_ID = metadata.workflowRunId;
+  if (metadata.workflowStepId)
+    env.LOOPS_WORKFLOW_STEP_ID = metadata.workflowStepId;
+  return env;
+}
+async function executeTarget(target, metadata = {}, opts = {}) {
+  const spec = commandSpec(target);
   const maxOutputBytes = opts.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   const startedAt = nowIso();
   let stdout = "";
@@ -845,14 +1488,7 @@ async function executeLoop(loop, run, opts = {}) {
   let timedOut = false;
   let exitCode;
   let error;
-  const env = {
-    ...opts.env ?? process.env,
-    ...spec.env ?? {},
-    LOOPS_LOOP_ID: loop.id,
-    LOOPS_LOOP_NAME: loop.name,
-    LOOPS_RUN_ID: run.id,
-    LOOPS_SCHEDULED_FOR: run.scheduledFor
-  };
+  const env = executionEnv(spec, metadata, opts);
   const child = spawn(spec.command, spec.args, {
     cwd: spec.cwd,
     env,
@@ -922,12 +1558,137 @@ async function executeLoop(loop, run, opts = {}) {
     durationMs
   };
 }
+async function executeLoop(loop, run, opts = {}) {
+  if (loop.target.type === "workflow") {
+    throw new Error("workflow loop targets must be executed with executeLoopTarget");
+  }
+  return executeTarget(loop.target, {
+    loopId: loop.id,
+    loopName: loop.name,
+    runId: run.id,
+    scheduledFor: run.scheduledFor
+  }, opts);
+}
+
+// src/lib/workflow-runner.ts
+function targetWithStepAccount(step) {
+  const account = step.account ?? step.target.account;
+  if (!account)
+    return step.target;
+  return { ...step.target, account };
+}
+function workflowResult(workflowRun, status, startedAt, finishedAt, stdout, error) {
+  return {
+    status,
+    exitCode: status === "succeeded" ? 0 : 1,
+    stdout,
+    stderr: "",
+    error,
+    startedAt,
+    finishedAt,
+    durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime()
+  };
+}
+async function executeWorkflow(store, workflow, opts = {}) {
+  const run = store.createWorkflowRun({
+    workflow,
+    loop: opts.loop,
+    loopRun: opts.loopRun,
+    scheduledFor: opts.scheduledFor,
+    idempotencyKey: opts.idempotencyKey
+  });
+  const startedAt = run.startedAt ?? nowIso();
+  if (run.status === "succeeded" || run.status === "failed" || run.status === "timed_out") {
+    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);
+  }
+  const ordered = workflowExecutionOrder(workflow);
+  const byId = new Map(workflow.steps.map((step) => [step.id, step]));
+  let blockingError;
+  let terminalStatus = "succeeded";
+  for (const step of ordered) {
+    const existing = store.getWorkflowStepRun(run.id, step.id);
+    if (existing?.status === "succeeded" || existing?.status === "skipped")
+      continue;
+    const blockedBy = (step.dependsOn ?? []).find((dependencyId) => {
+      const dependencyRun = store.getWorkflowStepRun(run.id, dependencyId);
+      const dependencyStep = byId.get(dependencyId);
+      if (dependencyRun?.status === "succeeded")
+        return false;
+      return !dependencyStep?.continueOnFailure;
+    });
+    if (blockedBy) {
+      store.skipWorkflowStepRun(run.id, step.id, `dependency did not succeed: ${blockedBy}`);
+      blockingError ??= `step ${step.id} blocked by dependency ${blockedBy}`;
+      terminalStatus = "failed";
+      continue;
+    }
+    store.startWorkflowStepRun(run.id, step.id);
+    const result = await executeTarget(targetWithStepAccount(step), {
+      loopId: opts.loop?.id,
+      loopName: opts.loop?.name,
+      runId: opts.loopRun?.id,
+      scheduledFor: opts.loopRun?.scheduledFor ?? opts.scheduledFor,
+      workflowId: workflow.id,
+      workflowName: workflow.name,
+      workflowRunId: run.id,
+      workflowStepId: step.id
+    }, opts);
+    store.finalizeWorkflowStepRun(run.id, step.id, {
+      status: result.status,
+      finishedAt: result.finishedAt,
+      durationMs: result.durationMs,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode,
+      error: result.error
+    });
+    if (result.status !== "succeeded" && !step.continueOnFailure) {
+      terminalStatus = result.status;
+      blockingError = `step ${step.id} ${result.status}${result.error ? `: ${result.error}` : ""}`;
+      break;
+    }
+  }
+  if (terminalStatus !== "succeeded") {
+    for (const step of ordered) {
+      const existing = store.getWorkflowStepRun(run.id, step.id);
+      if (existing?.status === "pending" || existing?.status === "running") {
+        store.skipWorkflowStepRun(run.id, step.id, blockingError ?? "workflow stopped before step could run");
+      }
+    }
+  }
+  const finishedAt = nowIso();
+  const finalRun = store.finalizeWorkflowRun(run.id, terminalStatus, {
+    finishedAt,
+    durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
+    error: blockingError
+  });
+  const steps = store.listWorkflowStepRuns(run.id);
+  return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, JSON.stringify({ workflowRun: finalRun, steps }, null, 2), blockingError);
+}
+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}`
+  });
+}
 
 // src/lib/scheduler.ts
 function nextAfterRetry(loop, now) {
   return new Date(now.getTime() + loop.retryDelayMs).toISOString();
 }
 function advanceLoop(store, loop, run, finishedAt, succeeded) {
+  if (run.status === "running")
+    return;
+  const current = store.getLoop(loop.id);
+  if (!current || current.status !== "active")
+    return;
   const shouldRetry = !succeeded && run.attempt < loop.maxAttempts;
   if (shouldRetry) {
     store.updateLoop(loop.id, {
@@ -956,8 +1717,14 @@ async function runSlot(deps, loop, scheduledFor) {
   if (!claim)
     return;
   deps.onRun?.(claim.run);
+  let heartbeat;
+  const heartbeatEveryMs = Math.max(1000, Math.min(60000, Math.floor(claim.loop.leaseMs / 3)));
+  heartbeat = setInterval(() => {
+    deps.store.heartbeatRunLease(claim.run.id, deps.runnerId, claim.loop.leaseMs);
+  }, heartbeatEveryMs);
+  heartbeat.unref();
   try {
-    const result = await (deps.execute ?? executeLoop)(claim.loop, claim.run);
+    const result = await (deps.execute ?? ((loop2, run) => executeLoopTarget(deps.store, loop2, run)))(claim.loop, claim.run);
     const finalRun = deps.store.finalizeRun(claim.run.id, {
       status: result.status,
       finishedAt: result.finishedAt,
@@ -967,8 +1734,11 @@ async function runSlot(deps, loop, scheduledFor) {
       exitCode: result.exitCode,
       error: result.error,
       pid: result.pid
+    }, {
+      claimedBy: deps.runnerId,
+      now: deps.now?.() ?? new Date(result.finishedAt)
     });
-    advanceLoop(deps.store, claim.loop, finalRun, new Date(result.finishedAt), result.status === "succeeded");
+    advanceLoop(deps.store, claim.loop, finalRun, new Date(result.finishedAt), finalRun.status === "succeeded");
     deps.onRun?.(finalRun);
     return finalRun;
   } catch (err) {
@@ -981,10 +1751,16 @@ async function runSlot(deps, loop, scheduledFor) {
       stdout: "",
       stderr: "",
       error: err instanceof Error ? err.message : String(err)
+    }, {
+      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 tick(deps) {
@@ -1011,13 +1787,15 @@ async function tick(deps) {
         skipped.push(run);
       else
         completed.push(run);
+      if (["failed", "timed_out", "abandoned"].includes(run.status) && run.attempt < loop.maxAttempts)
+        break;
     }
   }
   return { claimed, completed, skipped, recovered, expired };
 }
 
 // src/daemon/control.ts
-import { existsSync, mkdirSync as mkdirSync3, readFileSync, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync, rmSync, writeFileSync } from "fs";
 import { hostname } from "os";
 import { dirname as dirname2 } from "path";
 
@@ -1045,7 +1823,7 @@ async function runLoop(opts) {
 
 // src/daemon/control.ts
 function readPid(path = pidFilePath()) {
-  if (!existsSync(path))
+  if (!existsSync2(path))
     return;
   try {
     const pid = Number(readFileSync(path, "utf8").trim());
@@ -1330,7 +2108,7 @@ ${args.map((arg) => `    <string>${arg}</string>`).join(`
 
 // src/cli/index.ts
 var program = new Command;
-program.name("loops").description("Persistent local loops for commands and headless coding agents").version("0.1.0");
+program.name("loops").description("Persistent local loops for commands and headless coding agents").version("0.2.0");
 program.option("-j, --json", "print JSON");
 function isJson() {
   return Boolean(program.opts().json);
@@ -1412,8 +2190,16 @@ function baseCreateInput(name, opts, target) {
 function addScheduleOptions(command) {
   return command.option("--at <time>", "run once at an absolute time").option("--every <duration>", "run at a fixed interval, e.g. 15m, 1h, 30s").option("--cron <expr>", "run on a 5-field cron expression").option("--dynamic", "run on the default dynamic one-minute cadence").option("--catch-up <policy>", "none, latest, or all", "latest").option("--catch-up-limit <n>", "maximum missed slots to run when --catch-up all").option("--overlap <policy>", "skip or allow", "skip").option("--attempts <n>", "max attempts per scheduled slot").option("--retry-delay <duration>", "delay between retries", "1m").option("--lease <duration>", "running lease timeout", "30m").option("--expires-at <time>", "stop scheduling after this time").option("-d, --description <text>", "description");
 }
+function addAccountOptions(command) {
+  return command.option("--account <profile>", "OpenAccounts profile name for this target").option("--account-tool <tool>", "OpenAccounts tool id; defaults from provider for agents");
+}
+function accountFromOpts(opts) {
+  if (!opts.account && opts.accountTool)
+    throw new Error("--account-tool requires --account");
+  return opts.account ? { profile: opts.account, tool: opts.accountTool } : undefined;
+}
 var create = program.command("create").description("create loops");
-addScheduleOptions(create.command("command <name>").description("create a deterministic shell command loop").requiredOption("--cmd <command>", "command string to execute").option("--cwd <dir>", "working directory").option("--timeout <duration>", "run timeout").option("--no-shell", "execute without a shell")).action((name, opts) => {
+addAccountOptions(addScheduleOptions(create.command("command <name>").description("create a deterministic shell command loop").requiredOption("--cmd <command>", "command string to execute").option("--cwd <dir>", "working directory").option("--timeout <duration>", "run timeout").option("--no-shell", "execute without a shell"))).action((name, opts) => {
   const store = new Store;
   try {
     const target = {
@@ -1421,7 +2207,8 @@ addScheduleOptions(create.command("command <name>").description("create a determ
       command: opts.cmd,
       cwd: opts.cwd,
       shell: opts.shell,
-      timeoutMs: opts.timeout ? parseDuration(opts.timeout) : undefined
+      timeoutMs: opts.timeout ? parseDuration(opts.timeout) : undefined,
+      account: accountFromOpts(opts)
     };
     const loop = store.createLoop(baseCreateInput(name, opts, target));
     print(publicLoop(loop), `created loop ${loop.id} (${loop.name}) next=${loop.nextRunAt}`);
@@ -1429,9 +2216,9 @@ addScheduleOptions(create.command("command <name>").description("create a determ
     store.close();
   }
 });
-addScheduleOptions(create.command("agent <name>").description("create a headless coding-agent loop").requiredOption("--provider <provider>", "claude, cursor, codewith, aicopilot, or opencode").requiredOption("--prompt <prompt>", "agent prompt").option("--cwd <dir>", "working directory").option("--model <model>", "model").option("--agent <agent>", "provider-specific agent").option("--timeout <duration>", "run timeout").option("--config-isolation <mode>", "safe or none", "safe")).action((name, opts) => {
+addAccountOptions(addScheduleOptions(create.command("agent <name>").description("create a headless coding-agent loop").requiredOption("--provider <provider>", "claude, cursor, codewith, aicopilot, opencode, or codex").requiredOption("--prompt <prompt>", "agent prompt").option("--cwd <dir>", "working directory").option("--model <model>", "model").option("--agent <agent>", "provider-specific agent").option("--timeout <duration>", "run timeout").option("--config-isolation <mode>", "safe or none", "safe"))).action((name, opts) => {
   const provider = opts.provider;
-  if (!["claude", "cursor", "codewith", "aicopilot", "opencode"].includes(provider)) {
+  if (!["claude", "cursor", "codewith", "aicopilot", "opencode", "codex"].includes(provider)) {
     throw new Error("unsupported provider");
   }
   if (!["safe", "none"].includes(opts.configIsolation)) {
@@ -1447,7 +2234,8 @@ addScheduleOptions(create.command("agent <name>").description("create a headless
       model: opts.model,
       agent: opts.agent,
       timeoutMs: opts.timeout ? parseDuration(opts.timeout) : undefined,
-      configIsolation: opts.configIsolation
+      configIsolation: opts.configIsolation,
+      account: accountFromOpts(opts)
     };
     const loop = store.createLoop(baseCreateInput(name, opts, target));
     print(publicLoop(loop), `created loop ${loop.id} (${loop.name}) next=${loop.nextRunAt}`);
@@ -1455,6 +2243,111 @@ addScheduleOptions(create.command("agent <name>").description("create a headless
     store.close();
   }
 });
+addScheduleOptions(create.command("workflow <name>").description("schedule a stored workflow").requiredOption("--workflow <idOrName>", "workflow id or name")).action((name, opts) => {
+  const store = new Store;
+  try {
+    const workflow = store.requireWorkflow(opts.workflow);
+    const target = {
+      type: "workflow",
+      workflowId: workflow.id
+    };
+    const loop = store.createLoop(baseCreateInput(name, opts, target));
+    print(publicLoop(loop), `created workflow loop ${loop.id} (${loop.name}) workflow=${workflow.name} next=${loop.nextRunAt}`);
+  } finally {
+    store.close();
+  }
+});
+var workflows = program.command("workflows").alias("workflow").description("manage workflow specs and runs");
+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 {
+    const body = workflowBodyFromJson(JSON.parse(readFileSync2(file, "utf8")), opts.name);
+    const workflow = store.createWorkflow(body);
+    print(publicWorkflow(workflow), `created workflow ${workflow.id} (${workflow.name}) steps=${workflow.steps.length}`);
+  } finally {
+    store.close();
+  }
+});
+workflows.command("list").alias("ls").option("--status <status>", "active or archived", "active").action((opts) => {
+  const store = new Store;
+  try {
+    const workflowsList = store.listWorkflows({ status: opts.status });
+    if (isJson())
+      print(workflowsList.map(publicWorkflow));
+    else {
+      for (const workflow of workflowsList) {
+        console.log(`${workflow.id}  ${workflow.status.padEnd(8)}  steps=${workflow.steps.length}  ${workflow.name}`);
+      }
+    }
+  } finally {
+    store.close();
+  }
+});
+workflows.command("show <idOrName>").action((idOrName) => {
+  const store = new Store;
+  try {
+    print(publicWorkflow(store.requireWorkflow(idOrName)));
+  } finally {
+    store.close();
+  }
+});
+workflows.command("run <idOrName>").option("--show-output", "show step stdout/stderr").action(async (idOrName, opts) => {
+  const store = new Store;
+  try {
+    const workflow = store.requireWorkflow(idOrName);
+    const result = await executeWorkflow(store, workflow);
+    const run = store.listWorkflowRuns({ workflowId: workflow.id, limit: 1 })[0];
+    const steps = run ? store.listWorkflowStepRuns(run.id) : [];
+    const value = {
+      result,
+      workflowRun: run ? publicWorkflowRun(run) : undefined,
+      steps: steps.map((step) => publicWorkflowStepRun(step, opts.showOutput))
+    };
+    print(value, `${run?.id ?? workflow.id} ${result.status}`);
+  } finally {
+    store.close();
+  }
+});
+workflows.command("runs [idOrName]").option("--limit <n>", "limit", "50").action((idOrName, opts) => {
+  const store = new Store;
+  try {
+    const workflow = idOrName ? store.requireWorkflow(idOrName) : undefined;
+    const runs = store.listWorkflowRuns({ workflowId: workflow?.id, limit: Number(opts.limit) });
+    if (isJson())
+      print(runs.map(publicWorkflowRun));
+    else {
+      for (const run of runs) {
+        console.log(`${run.id}  ${run.status.padEnd(10)}  ${run.workflowName}  started=${run.startedAt ?? "-"}`);
+      }
+    }
+  } finally {
+    store.close();
+  }
+});
+workflows.command("events <runId>").option("--limit <n>", "limit", "200").action((runId, opts) => {
+  const store = new Store;
+  try {
+    const events = store.listWorkflowEvents(runId, Number(opts.limit));
+    if (isJson())
+      print(events.map(publicWorkflowEvent));
+    else {
+      for (const event of events) {
+        console.log(`${String(event.sequence).padStart(3, "0")}  ${event.eventType.padEnd(14)}  ${event.stepId ?? "-"}  ${event.createdAt}`);
+      }
+    }
+  } finally {
+    store.close();
+  }
+});
+workflows.command("archive <idOrName>").action((idOrName) => {
+  const store = new Store;
+  try {
+    const workflow = store.archiveWorkflow(idOrName);
+    print(publicWorkflow(workflow), `${workflow.id} ${workflow.status}`);
+  } finally {
+    store.close();
+  }
+});
 program.command("list").alias("ls").option("--status <status>", "filter by status").action((opts) => {
   const store = new Store;
   try {
@@ -1523,7 +2416,7 @@ program.command("run-now <idOrName>").option("--show-output", "show stdout/stder
     const claim = store.claimRun(loop, new Date().toISOString(), `manual:${process.pid}`);
     if (!claim)
       throw new Error("could not claim manual run");
-    const result = await executeLoop(loop, claim.run);
+    const result = await executeLoopTarget(store, loop, claim.run);
     const run = store.finalizeRun(claim.run.id, {
       status: result.status,
       finishedAt: result.finishedAt,
@@ -1533,6 +2426,8 @@ program.command("run-now <idOrName>").option("--show-output", "show stdout/stder
       exitCode: result.exitCode,
       error: result.error,
       pid: result.pid
+    }, {
+      claimedBy: claim.run.claimedBy
     });
     print(publicRun(run, opts.showOutput), `${run.id} ${run.status}`);
   } finally {
@@ -1574,7 +2469,7 @@ ${result.instructions.join(`
 });
 daemon.command("logs").option("-n, --lines <n>", "lines", "80").action((opts) => {
   const path = daemonLogPath();
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     console.log("");
     return;
   }