@hasna/loops 0.4.12 → 0.4.14

package/dist/lib/storage/pg-executor.d.ts

@@ -0,0 +1,27 @@
+import type { PoolQueryClient } from "../../generated/storage-kit/query.js";
+import type { PostgresQueryExecutor } from "./postgres.js";
+export interface PgExecutorOptions {
+    connectionString: string;
+    max?: number;
+    applicationName?: string;
+    connectionTimeoutMillis?: number;
+    idleTimeoutMillis?: number;
+}
+/**
+ * `PostgresQueryExecutor` backed by a live `pg.Pool` via the vendored kit.
+ *
+ * Transaction support is intentionally omitted: `PostgresStorage.migrate`
+ * treats DDL as idempotent (`CREATE ... IF NOT EXISTS` + a checksum ledger), so
+ * a pooled sequential apply is correct and avoids binding every inner
+ * `execute` to a single dedicated client.
+ */
+export declare class PgPoolExecutor implements PostgresQueryExecutor {
+    private readonly client;
+    constructor(client: PoolQueryClient);
+    static fromConnectionString(options: PgExecutorOptions): PgPoolExecutor;
+    /** The underlying typed query client, for callers that need `get`/`one`/`transaction`. */
+    get queryClient(): PoolQueryClient;
+    query<T extends Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<T[]>;
+    execute(sql: string, params?: readonly unknown[]): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/lib/storage/pg-runner-claim.d.ts

@@ -0,0 +1,40 @@
+import type { PoolQueryClient } from "../../generated/storage-kit/query.js";
+export interface ClaimedRunRow extends Record<string, unknown> {
+    id: string;
+    loop_id: string;
+    loop_name: string;
+    scheduled_for: string | Date;
+    attempt: number;
+    status: string;
+    claimed_by: string | null;
+    claim_token: string | null;
+    lease_expires_at: string | Date | null;
+}
+export interface ClaimNextRunOptions {
+    runnerId: string;
+    leaseMs: number;
+    claimToken: string;
+    /** Statuses a run may be in to be claimable. Defaults to queued + lease-expired running. */
+    now?: Date;
+}
+/**
+ * Atomically claim the next claimable run for `runnerId`.
+ *
+ * A run is claimable when it is `queued`, or `running` with an expired lease
+ * (crash recovery). Returns the claimed row, or `null` when nothing was
+ * available. Two concurrent callers are guaranteed to receive distinct rows
+ * (or one receives `null`) thanks to `FOR UPDATE SKIP LOCKED`.
+ */
+export declare function claimNextRun(client: PoolQueryClient, options: ClaimNextRunOptions): Promise<ClaimedRunRow | null>;
+/**
+ * Heartbeat a claimed run's lease. Returns true when the lease was extended
+ * (the caller still owns the run), false when ownership was lost (claim token
+ * mismatch, run finalized, or lease already stolen).
+ */
+export declare function heartbeatRunLease(client: PoolQueryClient, input: {
+    runId: string;
+    runnerId: string;
+    claimToken: string;
+    leaseMs: number;
+    now?: Date;
+}): Promise<boolean>;

package/dist/lib/storage/postgres-loop-storage.d.ts

@@ -0,0 +1,114 @@
+import type { RecoverExpiredRunLeasesResult } from "../store.js";
+import { Store } from "../store.js";
+import type { PoolQueryClient } from "../../generated/storage-kit/query.js";
+import type { LoopStorageContract, LoopStorageMethodName } from "./contract.js";
+/** Thrown by store methods that are not yet ported to the Postgres backend. */
+export declare class NotImplementedError extends Error {
+    readonly code = "not_implemented";
+    constructor(method: string);
+}
+type M<K extends LoopStorageMethodName> = Store[K] extends (...a: infer A) => infer R ? {
+    args: A;
+    result: R;
+} : never;
+export declare class PostgresLoopStorage implements LoopStorageContract {
+    private readonly client;
+    readonly backend = "postgres";
+    readonly supportsRemoteRunners = true;
+    constructor(client: PoolQueryClient);
+    close(): Promise<void>;
+    private assertDaemonLeaseFence;
+    private loadLoop;
+    private loadRun;
+    private loadRunBySlot;
+    private loadDaemonLease;
+    private setWorkItemsForLoop;
+    private setWorkItemsForWorkflowRun;
+    private cascadeWorkItemsForLoopRun;
+    createLoop(...args: M<"createLoop">["args"]): Promise<M<"createLoop">["result"]>;
+    getLoop(...args: M<"getLoop">["args"]): Promise<M<"getLoop">["result"]>;
+    findLoopByName(...args: M<"findLoopByName">["args"]): Promise<M<"findLoopByName">["result"]>;
+    requireLoop(...args: M<"requireLoop">["args"]): Promise<M<"requireLoop">["result"]>;
+    listLoops(...args: M<"listLoops">["args"]): Promise<M<"listLoops">["result"]>;
+    dueLoops(...args: M<"dueLoops">["args"]): Promise<M<"dueLoops">["result"]>;
+    updateLoop(...args: M<"updateLoop">["args"]): Promise<M<"updateLoop">["result"]>;
+    renameLoop(...args: M<"renameLoop">["args"]): Promise<M<"renameLoop">["result"]>;
+    archiveLoop(...args: M<"archiveLoop">["args"]): Promise<M<"archiveLoop">["result"]>;
+    unarchiveLoop(...args: M<"unarchiveLoop">["args"]): Promise<M<"unarchiveLoop">["result"]>;
+    deleteLoop(...args: M<"deleteLoop">["args"]): Promise<M<"deleteLoop">["result"]>;
+    private requireLoopIn;
+    countLoops(...args: M<"countLoops">["args"]): Promise<M<"countLoops">["result"]>;
+    createSkippedRun(...args: M<"createSkippedRun">["args"]): Promise<M<"createSkippedRun">["result"]>;
+    getRun(...args: M<"getRun">["args"]): Promise<M<"getRun">["result"]>;
+    getRunBySlot(...args: M<"getRunBySlot">["args"]): Promise<M<"getRunBySlot">["result"]>;
+    /**
+     * Claim a specific loop slot for a runner.
+     *
+     * Divergence from the sqlite Store (documented, not accidental): the sqlite
+     * path also consults LOCAL process liveness (`isRecordedProcessAlive`,
+     * `hasLiveWorkflowStepProcesses`) before stealing an expired-lease run,
+     * because the daemon and the run's child process share a host. On the
+     * Postgres/remote backend the claiming runner may be a different machine than
+     * the one that holds the (possibly still-live) process, so local pid checks
+     * are meaningless. Ownership here is governed purely by lease expiry: an
+     * expired lease is reclaimable, a live lease is not. The lease/heartbeat
+     * contract (plus `FOR UPDATE` row locks) is the remote correctness boundary.
+     */
+    claimRun(...args: M<"claimRun">["args"]): Promise<M<"claimRun">["result"]>;
+    finalizeRun(...args: M<"finalizeRun">["args"]): Promise<M<"finalizeRun">["result"]>;
+    heartbeatRunLease(...args: M<"heartbeatRunLease">["args"]): Promise<M<"heartbeatRunLease">["result"]>;
+    recordRunProcess(...args: M<"recordRunProcess">["args"]): Promise<M<"recordRunProcess">["result"]>;
+    listRuns(...args: M<"listRuns">["args"]): Promise<M<"listRuns">["result"]>;
+    countRuns(...args: M<"countRuns">["args"]): Promise<M<"countRuns">["result"]>;
+    recoverExpiredRunLeases(...args: M<"recoverExpiredRunLeases">["args"]): Promise<M<"recoverExpiredRunLeases">["result"]>;
+    /**
+     * Recover expired run leases. Divergence from sqlite (documented): the remote
+     * backend cannot inspect local process liveness, so an expired lease is always
+     * abandoned (never "deferred because the local process is still alive"). The
+     * `deferred` array is therefore always empty here. The generated-route
+     * workflow archival side effect is not ported (route automation is a TIER 2
+     * path); the core guarantee — no run stays `running` past its lease — holds.
+     */
+    recoverExpiredRunLeasesDetailed(...args: M<"recoverExpiredRunLeasesDetailed">["args"]): Promise<RecoverExpiredRunLeasesResult>;
+    pruneHistory(...args: M<"pruneHistory">["args"]): Promise<M<"pruneHistory">["result"]>;
+    acquireDaemonLease(...args: M<"acquireDaemonLease">["args"]): Promise<M<"acquireDaemonLease">["result"]>;
+    heartbeatDaemonLease(...args: M<"heartbeatDaemonLease">["args"]): Promise<M<"heartbeatDaemonLease">["result"]>;
+    releaseDaemonLease(...args: M<"releaseDaemonLease">["args"]): Promise<M<"releaseDaemonLease">["result"]>;
+    getDaemonLease(...args: M<"getDaemonLease">["args"]): Promise<M<"getDaemonLease">["result"]>;
+    private loadWorkflow;
+    getWorkflow(...args: M<"getWorkflow">["args"]): Promise<M<"getWorkflow">["result"]>;
+    listWorkflows(...args: M<"listWorkflows">["args"]): Promise<M<"listWorkflows">["result"]>;
+    countWorkflows(...args: M<"countWorkflows">["args"]): Promise<M<"countWorkflows">["result"]>;
+    getWorkflowInvocation(...args: M<"getWorkflowInvocation">["args"]): Promise<M<"getWorkflowInvocation">["result"]>;
+    listWorkflowInvocations(...args: M<"listWorkflowInvocations">["args"]): Promise<M<"listWorkflowInvocations">["result"]>;
+    getWorkflowWorkItem(...args: M<"getWorkflowWorkItem">["args"]): Promise<M<"getWorkflowWorkItem">["result"]>;
+    listWorkflowWorkItems(...args: M<"listWorkflowWorkItems">["args"]): Promise<M<"listWorkflowWorkItems">["result"]>;
+    countActiveWorkflowWorkItems(...args: M<"countActiveWorkflowWorkItems">["args"]): Promise<M<"countActiveWorkflowWorkItems">["result"]>;
+    getWorkflowRun(...args: M<"getWorkflowRun">["args"]): Promise<M<"getWorkflowRun">["result"]>;
+    listWorkflowRuns(...args: M<"listWorkflowRuns">["args"]): Promise<M<"listWorkflowRuns">["result"]>;
+    listWorkflowStepRuns(...args: M<"listWorkflowStepRuns">["args"]): Promise<M<"listWorkflowStepRuns">["result"]>;
+    getWorkflowStepRun(...args: M<"getWorkflowStepRun">["args"]): Promise<M<"getWorkflowStepRun">["result"]>;
+    listWorkflowEvents(...args: M<"listWorkflowEvents">["args"]): Promise<M<"listWorkflowEvents">["result"]>;
+    getGoal(...args: M<"getGoal">["args"]): Promise<M<"getGoal">["result"]>;
+    listGoals(...args: M<"listGoals">["args"]): Promise<M<"listGoals">["result"]>;
+    listGoalPlanNodes(...args: M<"listGoalPlanNodes">["args"]): Promise<M<"listGoalPlanNodes">["result"]>;
+    listGoalRuns(...args: M<"listGoalRuns">["args"]): Promise<M<"listGoalRuns">["result"]>;
+    createWorkflow(): never;
+    archiveWorkflow(): never;
+    createWorkflowInvocation(): never;
+    upsertWorkflowWorkItem(): never;
+    admitWorkflowWorkItem(): never;
+    createGoal(): never;
+    createGoalPlanNodes(): never;
+    updateGoalStatus(): never;
+    updateGoalPlanNode(): never;
+    recordGoalEvent(): never;
+    createWorkflowRun(): never;
+    startWorkflowStepRun(): never;
+    recoverWorkflowRun(): never;
+    finalizeWorkflowStepRun(): never;
+    finalizeWorkflowRun(): never;
+    appendWorkflowEvent(): never;
+}
+export declare function createPostgresLoopStorage(client: PoolQueryClient): PostgresLoopStorage;
+export {};

package/dist/lib/storage/sqlite.js

@@ -1,9 +1,9 @@
 // @bun
 // src/lib/store.ts
 import { Database } from "bun:sqlite";
-import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync2 } from "fs";
-import { tmpdir } from "os";
-import { basename as basename2, dirname as dirname2, join as join3 } from "path";
+import { chmodSync, existsSync, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname2, join as join4 } from "path";
 
 // src/lib/errors.ts
 class CodedError extends Error {
@@ -1202,6 +1202,196 @@ function discardWorkflowRunManifest(staged) {
   } catch {}
 }
 
+// src/lib/route/todos-cli.ts
+import { closeSync, mkdtempSync, openSync, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { join as join3 } from "path";
+import { homedir as homedir2, tmpdir } from "os";
+
+// src/lib/format.ts
+var TEXT_OUTPUT_LIMIT = 32 * 1024;
+var SENSITIVE_PAYLOAD_KEYS = new Set(["env", "error", "prompt", "reason", "stderr", "stdout"]);
+function redact(value, visible = 0) {
+  if (!value)
+    return value;
+  if (value.length <= visible)
+    return value;
+  if (visible <= 0)
+    return `[redacted ${value.length} chars]`;
+  return `${value.slice(0, visible)}... [redacted ${value.length - visible} chars]`;
+}
+function truncateTextOutput(value) {
+  if (value.length <= TEXT_OUTPUT_LIMIT)
+    return value;
+  return `${value.slice(0, TEXT_OUTPUT_LIMIT)}
+[truncated ${value.length - TEXT_OUTPUT_LIMIT} chars]`;
+}
+function redactSensitivePayload(value, key) {
+  if (key && SENSITIVE_PAYLOAD_KEYS.has(key)) {
+    if (typeof value === "string")
+      return redact(value);
+    if (value === undefined || value === null)
+      return value;
+    return "[redacted]";
+  }
+  if (Array.isArray(value))
+    return value.map((item) => redactSensitivePayload(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, redactSensitivePayload(entryValue, entryKey)]));
+  }
+  return value;
+}
+function textOutputBlocks(value, opts = {}) {
+  const indent = opts.indent ?? "";
+  const nested = `${indent}  `;
+  const blocks = [];
+  for (const [label, output] of [
+    ["stdout", value.stdout],
+    ["stderr", value.stderr]
+  ]) {
+    if (!output)
+      continue;
+    blocks.push(`${indent}${label}:`);
+    for (const line of truncateTextOutput(output).replace(/\s+$/, "").split(/\r?\n/)) {
+      blocks.push(`${nested}${line}`);
+    }
+  }
+  return blocks;
+}
+function publicLoop(loop) {
+  const target = loop.target.type === "command" ? { ...loop.target, env: loop.target.env ? "[redacted]" : undefined } : loop.target.type === "agent" ? { ...loop.target, prompt: redact(loop.target.prompt) } : loop.target;
+  return {
+    ...loop,
+    target
+  };
+}
+function publicRun(run, showOutput = false, opts = {}) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: opts.redactError ? redact(run.error) : run.error
+  };
+}
+function publicExecutorResult(result, showOutput = false) {
+  return {
+    ...result,
+    stdout: showOutput ? result.stdout : result.stdout ? `[redacted ${result.stdout.length} chars]` : undefined,
+    stderr: showOutput ? result.stderr : result.stderr ? `[redacted ${result.stderr.length} chars]` : undefined,
+    error: redact(result.error)
+  };
+}
+function publicWorkflow(workflow) {
+  return {
+    ...workflow,
+    steps: workflow.steps.map((step) => ({
+      ...step,
+      target: step.target.type === "agent" ? { ...step.target, prompt: redact(step.target.prompt) } : step.target.type === "command" && step.target.env ? { ...step.target, env: "[redacted]" } : step.target
+    }))
+  };
+}
+function publicWorkflowRun(run) {
+  return { ...run, error: redact(run.error) };
+}
+function publicWorkflowInvocation(invocation) {
+  return redactSensitivePayload(invocation);
+}
+function publicWorkflowWorkItem(item) {
+  return { ...item, lastReason: redact(item.lastReason, 240) };
+}
+function publicWorkflowStepRun(run, showOutput = false) {
+  return {
+    ...run,
+    stdout: showOutput ? run.stdout : run.stdout ? `[redacted ${run.stdout.length} chars]` : undefined,
+    stderr: showOutput ? run.stderr : run.stderr ? `[redacted ${run.stderr.length} chars]` : undefined,
+    error: redact(run.error)
+  };
+}
+function publicWorkflowEvent(event) {
+  return { ...event, payload: redactSensitivePayload(event.payload) };
+}
+function publicGoal(goal) {
+  return {
+    ...goal,
+    objective: redact(goal.objective, 120)
+  };
+}
+function publicGoalRun(run) {
+  return {
+    ...run,
+    evidence: redactSensitivePayload(run.evidence),
+    rawResponse: redactSensitivePayload(run.rawResponse)
+  };
+}
+
+// src/lib/route/todos-cli.ts
+function defaultLoopsProject() {
+  return process.env.LOOPS_TASK_PROJECT || process.env.LOOPS_DATA_DIR || `${process.env.HOME || homedir2()}/.hasna/loops`;
+}
+function runLocalCommand(command, args, opts = {}) {
+  const result = spawnSync2(command, args, {
+    input: opts.input,
+    encoding: "utf8",
+    timeout: opts.timeoutMs ?? 30000,
+    maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+    env: process.env
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error ? String(result.error.message || result.error) : ""
+  };
+}
+function runLocalCommandWithStdoutFile(command, args, opts = {}) {
+  const tempDir = mkdtempSync(join3(tmpdir(), "loops-command-output-"));
+  const stdoutPath = join3(tempDir, "stdout");
+  const stdoutFd = openSync(stdoutPath, "w");
+  let result;
+  try {
+    result = spawnSync2(command, args, {
+      input: opts.input,
+      encoding: "utf8",
+      timeout: opts.timeoutMs ?? 30000,
+      maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
+      env: process.env,
+      stdio: ["pipe", stdoutFd, "pipe"]
+    });
+  } finally {
+    closeSync(stdoutFd);
+  }
+  try {
+    return {
+      ok: result.status === 0,
+      status: result.status,
+      stdout: readFileSync3(stdoutPath, "utf8"),
+      stderr: typeof result.stderr === "string" ? result.stderr : result.stderr?.toString() || "",
+      error: result.error ? String(result.error.message || result.error) : ""
+    };
+  } finally {
+    rmSync2(tempDir, { recursive: true, force: true });
+  }
+}
+function ensureTodosTaskList(project, slug, name, description) {
+  runLocalCommand("todos", ["--project", project, "task-lists", "--add", name, "--slug", slug, "-d", description]);
+  const list = runLocalCommand("todos", ["--project", project, "--json", "task-lists"]);
+  if (!list.ok)
+    throw new Error(list.stderr || list.error || "failed to list todos task lists");
+  const values = JSON.parse(list.stdout || "[]");
+  const found = values.find((entry) => entry.slug === slug);
+  if (!found)
+    throw new Error(`todos task list not found after ensure: ${slug}`);
+  return found.id;
+}
+function todosMutationSummary(result) {
+  return {
+    ok: result.ok,
+    status: result.status,
+    error: result.ok ? undefined : redact(result.stderr || result.error || "todos mutation failed", 320)
+  };
+}
+
 // src/lib/store.ts
 var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
@@ -1211,6 +1401,7 @@ var TERMINAL_RUN_STATUSES = ["succeeded", "failed", "timed_out", "abandoned", "s
 var PRUNE_BATCH_SIZE = 400;
 var GENERATED_ROUTE_TEMPLATE_IDS = new Set(["todos-task-worker-verifier", "task-lifecycle", "event-worker-verifier"]);
 var GENERATED_ROUTE_KEYS = new Set(["todos-task", "generic-event"]);
+var TASK_LIFECYCLE_TEMPLATE_ID = "task-lifecycle";
 function rowToLoop(row) {
   return {
     id: row.id,
@@ -1261,6 +1452,9 @@ function rowToRun(row) {
     updatedAt: row.updated_at
   };
 }
+function latestRunTime(row) {
+  return row.finished_at ?? row.started_at ?? row.created_at;
+}
 function rowToWorkflow(row) {
   return {
     id: row.id,
@@ -1515,7 +1709,7 @@ class Store {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
-    this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    this.rootDir = file === ":memory:" ? mkdtempSync2(join4(tmpdir2(), "open-loops-store-")) : dirname2(file);
     if (file === ":memory:")
       this.memoryRootDir = this.rootDir;
     this.db = new Database(file);
@@ -2013,7 +2207,32 @@ class Store {
     } else {
       rows = this.db.query("SELECT * FROM loops WHERE archived_at IS NULL ORDER BY status ASC, next_run_at ASC LIMIT ?").all(limit);
     }
-    return rows.map(rowToLoop);
+    return this.withLatestRunSummaries(rows.map(rowToLoop));
+  }
+  withLatestRunSummaries(loops) {
+    if (loops.length === 0)
+      return loops;
+    const placeholders = loops.map(() => "?").join(",");
+    const rows = this.db.query(`SELECT loop_id, id, status, started_at, finished_at, created_at
+         FROM (
+           SELECT loop_id, id, status, started_at, finished_at, created_at,
+             ROW_NUMBER() OVER (PARTITION BY loop_id ORDER BY created_at DESC, id DESC) AS rn
+           FROM loop_runs
+           WHERE loop_id IN (${placeholders})
+         )
+         WHERE rn = 1`).all(...loops.map((loop) => loop.id));
+    const latestByLoopId = new Map(rows.map((row) => [row.loop_id, row]));
+    return loops.map((loop) => {
+      const latest = latestByLoopId.get(loop.id);
+      if (!latest)
+        return loop;
+      return {
+        ...loop,
+        latestRunId: latest.id,
+        latestRunStatus: latest.status,
+        lastRunAt: latestRunTime(latest)
+      };
+    });
   }
   dueLoops(now, limit = 500) {
     const rows = this.db.query(`SELECT * FROM loops
@@ -2132,6 +2351,45 @@ class Store {
       throw error;
     }
   }
+  updateAgentLoopTimeout(idOrName, timeoutMs, opts = {}) {
+    const updated = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.requireUniqueLoop(idOrName);
+      if (current.archivedAt)
+        throw new LoopArchivedError(current.name || current.id);
+      if (current.target.type !== "agent")
+        throw new Error(`loop is not an agent loop: ${idOrName}`);
+      if (this.hasRunningRun(current.id))
+        throw new Error(`refusing to update running loop: ${current.id}`);
+      const target = { ...current.target, timeoutMs };
+      if (timeoutMs === null && target.idleTimeoutMs !== undefined)
+        delete target.idleTimeoutMs;
+      const res = this.db.query(`UPDATE loops SET target_json=$target, updated_at=$updated
+           WHERE id=$id
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $id: current.id,
+        $target: JSON.stringify(target),
+        $updated: updated,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: updated
+      });
+      if (res.changes !== 1)
+        throw new Error("daemon lease lost");
+      this.db.exec("COMMIT");
+      const after = this.getLoop(current.id);
+      if (!after)
+        throw new Error(`loop not found after timeout update: ${current.id}`);
+      return after;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
   createAndRetargetWorkflowLoop(idOrName, workflowInput, opts = {}) {
     const normalized = normalizeCreateWorkflowInput(workflowInput);
     const updated = (opts.now ?? new Date).toISOString();
@@ -2462,6 +2720,59 @@ class Store {
       updated
     });
   }
+  taskLifecycleTodosPointerContext(workflowRunId) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run || run.status !== "succeeded" || !run.invocationId || !run.workItemId || !run.manifestPath)
+      return;
+    const workItem = this.getWorkflowWorkItem(run.workItemId);
+    if (!workItem || workItem.routeKey !== "todos-task")
+      return;
+    const invocation = this.getWorkflowInvocation(run.invocationId);
+    if (!invocation || invocation.templateId !== TASK_LIFECYCLE_TEMPLATE_ID)
+      return;
+    const projectPath = workItem.projectKey ?? invocation.scope?.projectPath;
+    const taskId = invocation.subjectRef.id ?? workItem.subjectRef;
+    if (!projectPath || !taskId)
+      return;
+    return {
+      projectPath,
+      taskId,
+      invocationId: invocation.id,
+      workflowRunId: run.id,
+      manifestPath: run.manifestPath
+    };
+  }
+  syncSuccessfulTaskLifecycleTodosPointers(workflowRunId) {
+    const context = this.taskLifecycleTodosPointerContext(workflowRunId);
+    if (!context)
+      return;
+    const result = runLocalCommand("todos", [
+      "--project",
+      context.projectPath,
+      "task",
+      "workflow-pointers",
+      context.taskId,
+      "--clear",
+      "--invocation",
+      context.invocationId,
+      "--run",
+      context.workflowRunId,
+      "--manifest",
+      context.manifestPath,
+      "--state",
+      "succeeded",
+      "--actor",
+      "openloops:task-lifecycle"
+    ]);
+    this.appendWorkflowEvent(workflowRunId, result.ok ? "todos_workflow_pointers_synced" : "todos_workflow_pointers_sync_failed", undefined, {
+      projectPath: context.projectPath,
+      taskId: context.taskId,
+      invocationId: context.invocationId,
+      workflowRunId: context.workflowRunId,
+      manifestPath: context.manifestPath,
+      mutation: todosMutationSummary(result)
+    });
+  }
   createWorkflowInvocation(input) {
     const now = nowIso();
     const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
@@ -3424,6 +3735,8 @@ class Store {
     const run = this.getWorkflowRun(workflowRunId);
     if (!run)
       throw new Error(`workflow run not found after finalize: ${workflowRunId}`);
+    if (changed && status === "succeeded")
+      this.syncSuccessfulTaskLifecycleTodosPointers(workflowRunId);
     return run;
   }
   cancelWorkflowRun(workflowRunId, reason = "cancelled by user") {
@@ -3485,6 +3798,17 @@ class Store {
     const row = this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE loop_id = ? AND scheduled_for = ? AND status = 'running'").get(loopId, scheduledFor);
     return (row?.count ?? 0) > 0;
   }
+  hasBlockingRunningRunForOtherSlot(loopId, scheduledFor, nowIso2) {
+    const rows = this.db.query(`SELECT * FROM loop_runs
+         WHERE loop_id = ? AND scheduled_for <> ? AND status = 'running'`).all(loopId, scheduledFor);
+    return rows.some((row) => {
+      if (!row.lease_expires_at || row.lease_expires_at > nowIso2)
+        return true;
+      if (isRecordedProcessAlive(row.pid, row.process_started_at))
+        return true;
+      return this.hasLiveWorkflowStepProcesses(row.id);
+    });
+  }
   markRunPid(id, pid, claimedBy, opts = {}) {
     const now = (opts.now ?? new Date).toISOString();
     const startedMs = processStartTimeMs(pid);
@@ -3617,6 +3941,10 @@ class Store {
       loop = currentLoop;
       const leaseExpiresAt = new Date(now.getTime() + loop.leaseMs).toISOString();
       const existing = this.getRunBySlot(loop.id, scheduledFor);
+      if (loop.overlap === "skip" && this.hasBlockingRunningRunForOtherSlot(loop.id, scheduledFor, startedAt)) {
+        this.db.exec("COMMIT");
+        return;
+      }
       if (existing) {
         if (existing.status === "running") {
           if (existing.leaseExpiresAt && existing.leaseExpiresAt <= startedAt && isRecordedProcessAlive(existing.pid, existing.processStartedAt)) {
@@ -4188,9 +4516,9 @@ class Store {
       const runDir = dirname2(manifestPath);
       try {
         if (/^[0-9a-f]{12,64}$/.test(basename2(runDir))) {
-          rmSync2(runDir, { recursive: true, force: true });
+          rmSync3(runDir, { recursive: true, force: true });
         } else {
-          rmSync2(manifestPath, { force: true });
+          rmSync3(manifestPath, { force: true });
         }
       } catch {}
     }
@@ -4257,7 +4585,7 @@ class Store {
     this.db.close();
     if (this.memoryRootDir) {
       try {
-        rmSync2(this.memoryRootDir, { recursive: true, force: true });
+        rmSync3(this.memoryRootDir, { recursive: true, force: true });
       } catch {}
       this.memoryRootDir = undefined;
     }