@hasna/loops 0.4.4 → 0.4.6

package/dist/cli/index.js

@@ -1493,11 +1493,14 @@ function ensurePrivateStorePath(file) {
 class Store {
   db;
   rootDir;
+  memoryRootDir;
   constructor(path) {
     const file = path ?? dbPath();
     if (file !== ":memory:")
       ensurePrivateStorePath(file);
     this.rootDir = file === ":memory:" ? mkdtempSync(join3(tmpdir(), "open-loops-store-")) : dirname2(file);
+    if (file === ":memory:")
+      this.memoryRootDir = this.rootDir;
     this.db = new Database(file);
     this.db.exec("PRAGMA foreign_keys = ON;");
     this.db.exec("PRAGMA busy_timeout = 5000;");
@@ -1642,7 +1645,6 @@ class Store {
       CREATE INDEX IF NOT EXISTS idx_runs_status ON loop_runs(status);
       CREATE INDEX IF NOT EXISTS idx_runs_status_lease ON loop_runs(status, lease_expires_at);
       CREATE INDEX IF NOT EXISTS idx_runs_scheduled ON loop_runs(scheduled_for);
-      CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL;
 
       CREATE TABLE IF NOT EXISTS daemon_lease (
         id TEXT PRIMARY KEY,
@@ -1951,9 +1953,12 @@ class Store {
     const rows = this.db.query("SELECT * FROM loops WHERE name = ? ORDER BY created_at DESC LIMIT 2").all(idOrName);
     if (rows.length === 0)
       throw new LoopNotFoundError(idOrName);
-    if (rows.length > 1)
+    if (rows.length === 1)
+      return rowToLoop(rows[0]);
+    const active = this.db.query("SELECT * FROM loops WHERE name = ? AND archived_at IS NULL ORDER BY created_at DESC LIMIT 2").all(idOrName);
+    if (active.length !== 1)
       throw new AmbiguousNameError(idOrName);
-    return rowToLoop(rows[0]);
+    return rowToLoop(active[0]);
   }
   requireLoop(idOrName) {
     return this.getLoop(idOrName) ?? this.findLoopByName(idOrName) ?? (() => {
@@ -2294,6 +2299,7 @@ class Store {
     return this.transact(() => {
       const loop = this.requireLoop(idOrName);
       this.setWorkflowWorkItemsForLoop(loop.id, "cancelled", "loop deleted", nowIso());
+      this.db.query("DELETE FROM loop_runs WHERE loop_id = ?").run(loop.id);
       const res = this.db.query("DELETE FROM loops WHERE id = ?").run(loop.id);
       return res.changes > 0;
     });
@@ -2778,7 +2784,10 @@ class Store {
         return rowToGoal(row);
     }
     if (context.sourceType && context.sourceId) {
-      const row = this.db.query("SELECT * FROM goals WHERE source_type = ? AND source_id = ? ORDER BY created_at DESC LIMIT 1").get(context.sourceType, context.sourceId);
+      const terminalPlaceholders = GOAL_TERMINAL.map(() => "?").join(", ");
+      const row = this.db.query(`SELECT * FROM goals
+           WHERE source_type = ? AND source_id = ? AND status NOT IN (${terminalPlaceholders})
+           ORDER BY created_at DESC LIMIT 1`).get(context.sourceType, context.sourceId, ...GOAL_TERMINAL);
       if (row)
         return rowToGoal(row);
     }
@@ -3198,6 +3207,41 @@ class Store {
       throw new Error(`workflow step run not found after pid update: ${workflowRunId}/${stepId}`);
     return run;
   }
+  recordWorkflowStepProgress(workflowRunId, stepId, progress, opts = {}) {
+    const now = (opts.now ?? new Date).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const res = this.db.query(`UPDATE workflow_step_runs
+           SET stdout=COALESCE($stdout, stdout),
+               stderr=COALESCE($stderr, stderr),
+               updated_at=$updated
+           WHERE workflow_run_id=$workflowRunId AND step_id=$stepId AND status='running'
+             AND ($daemonLeaseId IS NULL OR EXISTS (
+               SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
+             ))`).run({
+        $workflowRunId: workflowRunId,
+        $stepId: stepId,
+        $stdout: progress.stdout === undefined ? null : scrubbedOrNull(progress.stdout),
+        $stderr: progress.stderr === undefined ? null : scrubbedOrNull(progress.stderr),
+        $updated: now,
+        $daemonLeaseId: opts.daemonLeaseId ?? null,
+        $now: now
+      });
+      if (res.changes === 1) {
+        this.appendWorkflowEvent(workflowRunId, "step_progress", stepId, progress.payload);
+      }
+      this.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+    const run = this.getWorkflowStepRun(workflowRunId, stepId);
+    if (!run)
+      throw new Error(`workflow step run not found after progress update: ${workflowRunId}/${stepId}`);
+    return run;
+  }
   recoverWorkflowRun(workflowRunId, reason = "workflow run recovered for retry") {
     return this.transact(() => {
       const now = nowIso();
@@ -3635,7 +3679,8 @@ class Store {
                  AND ($daemonLeaseId IS NULL OR EXISTS (
                    SELECT 1 FROM daemon_lease WHERE id=$daemonLeaseId AND expires_at > $now
                  ))`).run(params) : this.db.query(`UPDATE loop_runs SET status=$status, finished_at=$finished, claim_token=NULL, 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);
+               duration_ms=$durationMs, stdout=$stdout, stderr=$stderr, error=$error, updated_at=$updated
+               WHERE id=$id AND status='running'`).run(params);
       const run = this.getRun(id);
       if (!run)
         throw new Error(`run not found after finalize: ${id}`);
@@ -4163,12 +4208,18 @@ class Store {
   }
   close() {
     this.db.close();
+    if (this.memoryRootDir) {
+      try {
+        rmSync2(this.memoryRootDir, { recursive: true, force: true });
+      } catch {}
+      this.memoryRootDir = undefined;
+    }
   }
 }
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.4",
+  version: "0.4.6",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4883,7 +4934,12 @@ function notifySpawn(pid, opts) {
   if (!pid)
     return;
   opts.onSpawn?.(pid);
-  opts.onSpawnProcess?.({ pid, pgid: pid, processStartedAt: nowIso() });
+  const startedMs = processStartTimeMs(pid);
+  opts.onSpawnProcess?.({
+    pid,
+    pgid: pid,
+    processStartedAt: startedMs !== undefined ? new Date(startedMs).toISOString() : nowIso()
+  });
 }
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -5238,6 +5294,13 @@ function numberField(value, key) {
 function codewithAgentStatus(readJson) {
   return stringField(recordField(readJson, "agent"), "status") ?? stringField(recordField(readJson, "statusSnapshot"), "status");
 }
+function codewithAgentLastEventSeq(readJson) {
+  const agentSeq = numberField(recordField(readJson, "agent"), "lastEventSeq");
+  const snapshotSeq = numberField(recordField(readJson, "statusSnapshot"), "lastEventSeq");
+  if (agentSeq !== undefined && snapshotSeq !== undefined)
+    return Math.max(agentSeq, snapshotSeq);
+  return agentSeq ?? snapshotSeq;
+}
 function codewithAgentEvidence(startJson, readJson, logsJson) {
   const agent = recordField(readJson, "agent") ?? recordField(startJson, "agent");
   const statusSnapshot = recordField(readJson, "statusSnapshot");
@@ -5268,6 +5331,21 @@ function codewithAgentEvidence(startJson, readJson, logsJson) {
     events
   }, null, 2);
 }
+function codewithAgentProgress(readJson) {
+  const agent = recordField(readJson, "agent");
+  const statusSnapshot = recordField(readJson, "statusSnapshot");
+  return {
+    provider: "codewith",
+    agentId: stringField(agent, "agentId"),
+    status: stringField(agent, "status") ?? stringField(statusSnapshot, "status"),
+    summary: stringField(statusSnapshot, "summary"),
+    statusReason: stringField(agent, "statusReason"),
+    threadId: stringField(agent, "threadId"),
+    rolloutPath: stringField(agent, "rolloutPath"),
+    pid: numberField(agent, "pid"),
+    lastEventSeq: codewithAgentLastEventSeq(readJson)
+  };
+}
 function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
@@ -5302,6 +5380,7 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
   if (!agentId) {
     return failureResult(startedAt, "codewith agent start did not return agent.agentId", { stdout: start.stdout, stderr: stderr.value() });
   }
+  opts.onAgentProgress?.(codewithAgentProgress(startJson));
   const stopAgent = async () => {
     await spawnCapture(spec.command, codewithAgentControlArgs(target, "stop", agentId), {
       cwd: spec.cwd,
@@ -5344,10 +5423,15 @@ async function executeCodewithDurableAgent(spec, metadata, opts, env, startedAt)
       });
     }
     const status = codewithAgentStatus(lastReadJson);
-    const fingerprint = JSON.stringify({ status, snapshot: recordField(lastReadJson, "statusSnapshot") ?? null });
+    const fingerprint = JSON.stringify({
+      status,
+      agentLastEventSeq: numberField(recordField(lastReadJson, "agent"), "lastEventSeq"),
+      snapshot: recordField(lastReadJson, "statusSnapshot") ?? null
+    });
     if (fingerprint !== lastFingerprint) {
       lastFingerprint = fingerprint;
       lastProgressAt = Date.now();
+      opts.onAgentProgress?.(codewithAgentProgress(lastReadJson));
     }
     if (status === "completed" || status === "failed" || status === "cancelled") {
       const logs = await spawnCapture(spec.command, codewithAgentControlArgs(target, "logs", agentId), {
@@ -6348,173 +6432,213 @@ async function executeWorkflow(store, workflow, opts = {}) {
   if (run.status === "succeeded" || run.status === "failed" || run.status === "timed_out" || run.status === "cancelled") {
     return workflowResult(run, run.status, startedAt, run.finishedAt ?? nowIso(), store.listWorkflowStepRuns(run.id), run.error);
   }
+  const resumedRunningSteps = store.listWorkflowStepRuns(run.id).filter((step) => step.status === "running");
+  if (resumedRunningSteps.length > 0 && resumedRunningSteps.every((step) => step.pid !== undefined)) {
+    try {
+      store.recoverWorkflowRun(run.id, "workflow run resumed after lease takeover");
+    } catch {}
+  }
   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) {
-    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" || existing?.status === "cancelled")
-      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) {
-      opts.beforePersist?.();
-      if (isBlockedStepRun(store.getWorkflowStepRun(run.id, blockedBy))) {
-        store.skipWorkflowStepRun(run.id, step.id, `${BLOCKED_STEP_ERROR_PREFIX} upstream step ${blockedBy} was blocked`, {
-          daemonLeaseId: opts.daemonLeaseId
-        });
+  try {
+    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" || existing?.status === "cancelled")
+        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) {
+        opts.beforePersist?.();
+        if (isBlockedStepRun(store.getWorkflowStepRun(run.id, blockedBy))) {
+          store.skipWorkflowStepRun(run.id, step.id, `${BLOCKED_STEP_ERROR_PREFIX} upstream step ${blockedBy} was blocked`, {
+            daemonLeaseId: opts.daemonLeaseId
+          });
+          continue;
+        }
+        store.skipWorkflowStepRun(run.id, step.id, `dependency did not succeed: ${blockedBy}`, { daemonLeaseId: opts.daemonLeaseId });
+        blockingError ??= `step ${step.id} blocked by dependency ${blockedBy}`;
+        terminalStatus = "failed";
         continue;
       }
-      store.skipWorkflowStepRun(run.id, step.id, `dependency did not succeed: ${blockedBy}`, { daemonLeaseId: opts.daemonLeaseId });
-      blockingError ??= `step ${step.id} blocked by dependency ${blockedBy}`;
-      terminalStatus = "failed";
-      continue;
-    }
-    opts.beforePersist?.();
-    const startedStep = store.startWorkflowStepRun(run.id, step.id, { daemonLeaseId: opts.daemonLeaseId });
-    if (startedStep.status !== "running") {
-      terminalStatus = "failed";
-      blockingError = `step ${step.id} could not start because workflow is no longer running`;
-      break;
-    }
-    const stepContext = goalExecutionContext({
-      loop: opts.loop,
-      loopRun: opts.loopRun,
-      scheduledFor: opts.scheduledFor,
-      workflow,
-      workflowRunId: run.id,
-      workflowStepId: step.id
-    });
-    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")
+      opts.beforePersist?.();
+      const startedStep = store.startWorkflowStepRun(run.id, step.id, { daemonLeaseId: opts.daemonLeaseId });
+      if (startedStep.status !== "running") {
+        terminalStatus = "failed";
+        blockingError = `step ${step.id} could not start because workflow is no longer running`;
+        break;
+      }
+      const stepContext = goalExecutionContext({
+        loop: opts.loop,
+        loopRun: opts.loopRun,
+        scheduledFor: opts.scheduledFor,
+        workflow,
+        workflowRunId: run.id,
+        workflowStepId: step.id
+      });
+      let result;
+      const controller = new AbortController;
+      const externalAbort = () => controller.abort();
+      if (opts.signal?.aborted)
         controller.abort();
-    }, opts.cancelPollMs ?? 500);
-    cancelTimer.unref();
-    try {
-      if (step.goal) {
-        result = await runGoal(store, step.goal, {
-          ...opts,
-          model: opts.goalModel,
-          target: targetWithStepAccount(step),
-          signal: controller.signal,
-          context: stepContext
-        });
-      } else {
-        result = await executeTarget(targetWithStepAccount(step, opts.goalNodePrompt), executionMetadata(stepContext), {
-          ...opts,
-          machine: opts.machine ?? opts.loop?.machine,
-          signal: controller.signal,
-          onSpawn: (pid) => {
-            opts.beforePersist?.();
-            store.markWorkflowStepPid(run.id, step.id, pid, { daemonLeaseId: opts.daemonLeaseId });
-            opts.onSpawn?.(pid);
-          }
+      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 {
+        if (step.goal) {
+          result = await runGoal(store, step.goal, {
+            ...opts,
+            model: opts.goalModel,
+            target: targetWithStepAccount(step),
+            signal: controller.signal,
+            context: stepContext
+          });
+        } else {
+          result = await executeTarget(targetWithStepAccount(step, opts.goalNodePrompt), executionMetadata(stepContext), {
+            ...opts,
+            machine: opts.machine ?? opts.loop?.machine,
+            signal: controller.signal,
+            onAgentProgress: (progress) => {
+              const stdout = JSON.stringify({ agentProgress: progress }, null, 2);
+              opts.beforePersist?.();
+              store.recordWorkflowStepProgress(run.id, step.id, {
+                stdout,
+                payload: progress
+              }, {
+                daemonLeaseId: opts.daemonLeaseId
+              });
+              opts.onAgentProgress?.(progress);
+            },
+            onSpawn: (pid) => {
+              opts.beforePersist?.();
+              store.markWorkflowStepPid(run.id, step.id, pid, { daemonLeaseId: opts.daemonLeaseId });
+              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;
+      }
+      opts.beforePersist?.();
+      const blockedExit = result.status === "failed" && result.exitCode !== undefined && blockedExitCodesForStep(step).includes(result.exitCode);
+      if (blockedExit) {
+        store.finalizeWorkflowStepRun(run.id, step.id, {
+          status: "skipped",
+          finishedAt: result.finishedAt,
+          durationMs: result.durationMs,
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode,
+          error: `${BLOCKED_STEP_ERROR_PREFIX} step ${step.id} exited with blocked exit code ${result.exitCode}`
+        }, {
+          daemonLeaseId: opts.daemonLeaseId
         });
+        continue;
       }
-    } 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;
-    }
-    opts.beforePersist?.();
-    const blockedExit = result.status === "failed" && result.exitCode !== undefined && blockedExitCodesForStep(step).includes(result.exitCode);
-    if (blockedExit) {
       store.finalizeWorkflowStepRun(run.id, step.id, {
-        status: "skipped",
+        status: result.status,
         finishedAt: result.finishedAt,
         durationMs: result.durationMs,
         stdout: result.stdout,
         stderr: result.stderr,
         exitCode: result.exitCode,
-        error: `${BLOCKED_STEP_ERROR_PREFIX} step ${step.id} exited with blocked exit code ${result.exitCode}`
+        error: result.error
       }, {
         daemonLeaseId: opts.daemonLeaseId
       });
-      continue;
+      if (result.status !== "succeeded" && !step.continueOnFailure) {
+        terminalStatus = result.status;
+        blockingError = `step ${step.id} ${result.status}${result.error ? `: ${result.error}` : ""}`;
+        break;
+      }
     }
-    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 (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", {
+            daemonLeaseId: opts.daemonLeaseId
+          });
+        }
+      }
+    }
+    const finishedAt = nowIso();
+    if (store.isWorkflowRunTerminal(run.id)) {
+      const terminalRun = store.requireWorkflowRun(run.id);
+      return workflowResult(terminalRun, terminalRun.status, startedAt, terminalRun.finishedAt ?? finishedAt, store.listWorkflowStepRuns(run.id), terminalRun.error ?? blockingError);
+    }
+    opts.beforePersist?.();
+    const finalRun = store.finalizeWorkflowRun(run.id, terminalStatus, {
+      finishedAt,
+      durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
+      error: blockingError
     }, {
       daemonLeaseId: opts.daemonLeaseId
     });
-    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", {
+    return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, store.listWorkflowStepRuns(run.id), blockingError);
+  } catch (error) {
+    if (opts.daemonLeaseId && error instanceof Error && error.message === "daemon lease lost")
+      throw error;
+    if (error instanceof Error && error.message.includes("workflow step is not claimable"))
+      throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    const finishedAt = nowIso();
+    try {
+      if (!store.isWorkflowRunTerminal(run.id)) {
+        store.finalizeWorkflowRun(run.id, "failed", {
+          finishedAt,
+          durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
+          error: message
+        }, {
           daemonLeaseId: opts.daemonLeaseId
         });
       }
-    }
-  }
-  const finishedAt = nowIso();
-  if (store.isWorkflowRunTerminal(run.id)) {
-    const terminalRun = store.requireWorkflowRun(run.id);
-    return workflowResult(terminalRun, terminalRun.status, startedAt, terminalRun.finishedAt ?? finishedAt, store.listWorkflowStepRuns(run.id), terminalRun.error ?? blockingError);
+    } catch {}
+    const current = store.getWorkflowRun(run.id) ?? run;
+    const resultStatus = current.status === "running" ? "failed" : current.status;
+    return workflowResult(current, resultStatus, startedAt, finishedAt, store.listWorkflowStepRuns(run.id), current.error ?? message);
   }
-  opts.beforePersist?.();
-  const finalRun = store.finalizeWorkflowRun(run.id, terminalStatus, {
-    finishedAt,
-    durationMs: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
-    error: blockingError
-  }, {
-    daemonLeaseId: opts.daemonLeaseId
-  });
-  return workflowResult(finalRun, terminalStatus, startedAt, finishedAt, store.listWorkflowStepRuns(run.id), blockingError);
 }
 function preflightWorkflow(workflow, opts = {}) {
   return workflowExecutionOrder(workflow).map((step) => {
@@ -6936,7 +7060,7 @@ ${failure.evidence.stderr}` : undefined
 
 `);
   const dedupeKey = `openloops:${loop.id}:${failure.fingerprint}`;
-  const tags = ["bug", "openloops", "loop-health", failure.classification];
+  const tags = ["bug", "openloops", "loops", "loop-health", failure.classification];
   const priority = failure.classification === "auth" || failure.classification === "rate_limit" ? "high" : "medium";
   return {
     title,
@@ -6951,7 +7075,7 @@ ${failure.evidence.stderr}` : undefined
       comment: ["todos", "comment", "<task-id>", description]
     },
     futureNativeUpsert: {
-      command: "todos upsert",
+      command: "todos task upsert",
       fields: {
         title,
         description,
@@ -7310,6 +7434,25 @@ function advanceOptions(deps) {
     onRun: deps.onRun
   };
 }
+var TERMINAL_RUN_STATUSES2 = new Set([
+  "succeeded",
+  "failed",
+  "timed_out",
+  "abandoned",
+  "skipped"
+]);
+function repairWedgedTerminalSlot(deps, loop, scheduledFor, now) {
+  const existing = deps.store.getRunBySlot(loop.id, scheduledFor);
+  if (!existing || !TERMINAL_RUN_STATUSES2.has(existing.status))
+    return;
+  try {
+    advanceLoop(deps.store, loop, existing, new Date(existing.finishedAt ?? now), existing.status === "succeeded", advanceOptions(deps));
+  } catch (error) {
+    if (deps.daemonLeaseId && isDaemonLeaseLost(error))
+      return;
+    throw error;
+  }
+}
 async function runSlot(deps, loop, scheduledFor) {
   const now = deps.now?.() ?? new Date;
   deps.beforeRun?.(loop, scheduledFor);
@@ -7336,8 +7479,10 @@ async function runSlot(deps, loop, scheduledFor) {
       return;
     throw error;
   }
-  if (!claim)
+  if (!claim) {
+    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
     return;
+  }
   deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
   deps.onRun?.(claim.run);
   const finalRun = await executeClaimedRun({
@@ -7383,8 +7528,10 @@ function claimSlot(deps, loop, scheduledFor) {
       return;
     throw error;
   }
-  if (!claim)
+  if (!claim) {
+    repairWedgedTerminalSlot(deps, loop, scheduledFor, now);
     return;
+  }
   deps.beforeRun?.(claim.loop, claim.run.scheduledFor);
   deps.onRun?.(claim.run);
   return claim;
@@ -7665,10 +7812,7 @@ async function stopDaemon(opts = {}) {
   const store = new Store(join5(dirname4(path), "loops.db"));
   try {
     const lease = store.getDaemonLease();
-    if (!lease || lease.pid !== state.pid || new Date(lease.expiresAt).getTime() <= Date.now()) {
-      removePid(path);
-      return { wasRunning: false, stopped: false, forced: false, pid: state.pid };
-    }
+    const leaseVerified = Boolean(lease && lease.pid === state.pid && new Date(lease.expiresAt).getTime() > Date.now());
     try {
       process.kill(state.pid, "SIGTERM");
     } catch {
@@ -7688,11 +7832,14 @@ async function stopDaemon(opts = {}) {
     } catch {}
     await sleep2(150);
     removePid(path);
-    const ownedRuns = store.listRuns({ status: "running", limit: 1000 }).filter((run) => run.claimedBy !== undefined && run.claimedBy.endsWith(`:${lease.id}`));
-    const reapedPgids = await reapProcessGroups(ownedRuns.map(toReapableProcess), {
-      sleep: sleep2,
-      graceMs: opts.reapGraceMs
-    });
+    let reapedPgids = [];
+    if (leaseVerified && lease) {
+      const ownedRuns = store.listRuns({ status: "running", limit: 1000 }).filter((run) => run.claimedBy !== undefined && run.claimedBy.endsWith(`:${lease.id}`));
+      reapedPgids = await reapProcessGroups(ownedRuns.map(toReapableProcess), {
+        sleep: sleep2,
+        graceMs: opts.reapGraceMs
+      });
+    }
     return { wasRunning: true, stopped: !isAlive(state.pid, record?.startedAt), forced: true, pid: state.pid, reapedPgids };
   } finally {
     store.close();
@@ -7880,7 +8027,14 @@ async function runDaemon(opts = {}) {
       try {
         const liveInlineOwner = (run) => {
           const ownerPid = inlineRunnerOwnerPid(run.claimedBy);
-          return ownerPid !== undefined && isAlive(ownerPid);
+          if (ownerPid === undefined || !isAlive(ownerPid))
+            return false;
+          const ownerStartMs = processStartTimeMs(ownerPid);
+          const runStartMs = run.startedAt ? Date.parse(run.startedAt) : Number.NaN;
+          if (ownerStartMs !== undefined && Number.isFinite(runStartMs) && ownerStartMs > runStartMs + START_TIME_TOLERANCE_MS) {
+            return false;
+          }
+          return true;
         };
         const staleCandidates = store.listRuns({ status: "running", limit: 1000 }).filter((run) => run.leaseExpiresAt !== undefined && new Date(run.leaseExpiresAt).getTime() <= Date.now());
         const startup = claimDueRuns({ store, runnerId, daemonLeaseId: leaseId, maxClaims: 0 });
@@ -9165,6 +9319,9 @@ function roleFragment(role, flow) {
 function goalHeaderFragment(goal, role, flow) {
   return [`/goal ${goal}`, "", roleFragment(role, flow)];
 }
+function boundedStepHeaderFragment(objective, role, flow) {
+  return [`Objective: ${objective}`, "", roleFragment(role, flow)];
+}
 function adversarialReviewFragment(inspect, focus) {
   return `Use fresh context. Inspect ${inspect}. Act as an adversarial reviewer focused on ${focus}.`;
 }
@@ -10297,7 +10454,7 @@ function renderTaskLifecycleWorkflow(input) {
   const blockTaskCommand = `todos --project ${todosProjectPath} update ${input.taskId} --status blocked`;
   const gateStopFragment = (stage, stops) => `The deterministic ${stage} gate will stop ${stops} unless the latest ${stage} marker is the exact go marker and the task has no blocked/completed/done/cancelled/failed/archived/no-auto/manual/approval-required state.`;
   const triagePrompt = [
-    ...goalHeaderFragment(`Triage todos task ${input.taskId} for safe automated execution.`, "triage", "lifecycle"),
+    ...boundedStepHeaderFragment(`Triage todos task ${input.taskId} for safe automated execution.`, "triage", "lifecycle"),
     shared,
     "Decide whether the task is eligible for loop execution. Check status, dependencies, duplicate tasks, no-auto/manual/approval metadata, project path, acceptance criteria, and whether the requested work should be split before implementation.",
     "Do not implement repo changes in this step.",
@@ -10309,7 +10466,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].join(`
 `);
   const plannerPrompt = [
-    ...goalHeaderFragment(`Plan todos task ${input.taskId} before implementation.`, "planner", "lifecycle"),
+    ...boundedStepHeaderFragment(`Plan todos task ${input.taskId} before implementation.`, "planner", "lifecycle"),
     shared,
     "Read the triage comment and current task details.",
     `If the task is ready for implementation, add a task comment whose first line is exactly: ${gateMarker("planner", "go")}`,
@@ -10320,7 +10477,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].join(`
 `);
   const workerPrompt = [
-    ...goalHeaderFragment(`Complete todos task ${input.taskId} according to the planner evidence.`, "worker", "lifecycle"),
+    ...boundedStepHeaderFragment(`Complete todos task ${input.taskId} according to the planner evidence.`, "worker", "lifecycle"),
     shared,
     todosStartLine(todosProjectPath, input.taskId),
     "Read the triage and planner comments first. Implement only the scoped task, run focused validation, and record changed files, commits, evidence, blockers, and residual risks.",
@@ -10329,7 +10486,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].filter(Boolean).join(`
 `);
   const verifierPrompt = [
-    ...goalHeaderFragment(`Verify todos task ${input.taskId} after the full lifecycle worker step.`, "verifier", "lifecycle"),
+    ...boundedStepHeaderFragment(`Verify todos task ${input.taskId} after the full lifecycle worker step.`, "verifier", "lifecycle"),
     shared,
     todosVerificationLine(todosProjectPath, input.taskId),
     todosDoneLine(todosProjectPath, input.taskId),
@@ -11035,7 +11192,7 @@ function taskRouteEligibility(data, metadata) {
   const records = taskEventRecords(data, metadata);
   const automation = automationRecords(data, metadata);
   const tags = taskEventTags(records);
-  const hasRouteOptIn = tags.includes("auto:route") || hasTruthyField(records, ["route_enabled", "routeEnabled", "automation_allowed", "automationAllowed"]) || hasTruthyField(automation, ["allowed"]);
+  const hasRouteOptIn = tags.includes("auto:route") || tags.includes("route:enabled") || hasTruthyField(records, ["route_enabled", "routeEnabled", "automation_allowed", "automationAllowed"]) || hasTruthyField(automation, ["allowed"]);
   if (!hasRouteOptIn)
     return { eligible: false, reason: "missing explicit route opt-in", tags };
   const status = taskEventField(data, ["status", "task_status", "taskStatus"])?.toLowerCase();
@@ -12336,7 +12493,8 @@ function compactDrainResult(result) {
     workflowName: stringField2(workflow?.name),
     providerRouting,
     requeue,
-    queuedAtSource: value.queuedAtSource
+    queuedAtSource: value.queuedAtSource,
+    fatal: value.fatal === true ? true : undefined
   };
 }
 function loadReadyTodosTasks(opts, scanLimit) {
@@ -12456,10 +12614,12 @@ function drainTodosTaskRoutes(opts) {
       result = routeTodosTaskEvent(event, opts);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (!isSkippableDrainRouteError(message))
-        throw error;
-      const sourceTaskUpdate = opts.dryRun ? { attempted: false, reason: "dry-run" } : markInvalidDrainTaskNonRouteable(todosProject, task, message);
-      result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { sourceTaskUpdate });
+      if (isSkippableDrainRouteError(message)) {
+        const sourceTaskUpdate = opts.dryRun ? { attempted: false, reason: "dry-run" } : markInvalidDrainTaskNonRouteable(todosProject, task, message);
+        result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { sourceTaskUpdate });
+      } else {
+        result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { fatal: true });
+      }
     }
     results.push(result);
     if (result.kind === "created")
@@ -12486,6 +12646,7 @@ function drainTodosTaskRoutes(opts) {
     deduped: results.filter((result) => result.kind === "deduped").length,
     throttled: results.filter((result) => result.kind === "throttled").length,
     skipped: results.filter((result) => result.kind === "skipped").length,
+    fatal: results.filter((result) => result.value.fatal === true).length,
     maxDispatch,
     source: "todos ready",
     dryRun: Boolean(opts.dryRun),
@@ -12513,6 +12674,7 @@ function drainTodosTaskRoutes(opts) {
     deduped: report.deduped,
     throttled: report.throttled,
     skipped: report.skipped,
+    fatal: report.fatal,
     maxDispatch: report.maxDispatch,
     source: report.source,
     dryRun: report.dryRun,
@@ -12521,7 +12683,7 @@ function drainTodosTaskRoutes(opts) {
   } : { ...report, evidencePath };
   return {
     value,
-    human: `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped}`
+    human: `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped} fatal=${report.fatal}`
   };
 }
 // src/lib/route/route-tasks.ts
@@ -13722,6 +13884,11 @@ function handleRouteDrain(kind, opts) {
     throw new ValidationError("route drain currently supports kind todos-task");
   const result = drainTodosTaskRoutes(opts);
   print(result.value, result.human);
+  const fatal = Number(result.value.fatal ?? 0);
+  if (fatal > 0) {
+    console.error(`route drain hit ${fatal} non-skippable task error(s); see evidence file`);
+    process.exitCode = 1;
+  }
 }
 addRouteEventOptions(routes.command("preview <kind>").description("(deprecated: use 'routes create <kind> --dry-run') preview a route-created workflow invocation without storing it")).action(runAction(async (kind, opts) => handleRouteEvent(kind, { ...opts, dryRun: true })));
 addRouteEventOptions(routes.command("create <kind>").description("create a route workflow invocation and admit it when capacity allows"), { dryRunDescription: "preview the generated workflow invocation and loop without storing anything" }).action(runAction(async (kind, opts) => handleRouteEvent(kind, opts)));
@@ -13923,7 +14090,7 @@ workflows.command("runs [idOrName]").description("list workflow runs, optionally
   const store = new Store;
   try {
     const workflow = idOrName ? store.requireWorkflow(idOrName) : undefined;
-    const runs = store.listWorkflowRuns({ workflowId: workflow?.id, limit: Number(opts.limit) });
+    const runs = store.listWorkflowRuns({ workflowId: workflow?.id, limit: positiveInteger(opts.limit, "--limit") ?? 50 });
     if (isJson())
       print(runs.map(publicWorkflowRun));
     else {
@@ -13938,7 +14105,7 @@ workflows.command("runs [idOrName]").description("list workflow runs, optionally
 workflows.command("events <runId>").description("list step/lifecycle events for a workflow run").option("--limit <n>", "limit", "200").action(runAction((runId, opts) => {
   const store = new Store;
   try {
-    const runEvents = store.listWorkflowEvents(runId, Number(opts.limit));
+    const runEvents = store.listWorkflowEvents(runId, positiveInteger(opts.limit, "--limit") ?? 200);
     if (isJson())
       print(runEvents.map(publicWorkflowEvent));
     else {
@@ -14179,7 +14346,7 @@ program.command("runs [idOrName]").description("list recent runs, optionally for
   const store = new Store;
   try {
     const loop = idOrName ? store.requireLoop(idOrName) : undefined;
-    const runs = store.listRuns({ loopId: loop?.id, limit: Number(opts.limit) });
+    const runs = store.listRuns({ loopId: loop?.id, limit: positiveInteger(opts.limit, "--limit") ?? 50 });
     if (isJson())
       print(runs.map((run) => publicRun(run, opts.showOutput)));
     else {
@@ -14196,7 +14363,7 @@ program.command("runs [idOrName]").description("list recent runs, optionally for
 program.command("expectations [idOrName]").description("evaluate deterministic loop expectations without mutating external task systems").option("--limit <n>", "maximum loops to inspect when no loop is specified", "200").action(runAction((idOrName, opts) => {
   const store = new Store;
   try {
-    const loops = idOrName ? [store.requireLoop(idOrName)] : store.listLoops({ limit: Number(opts.limit) });
+    const loops = idOrName ? [store.requireLoop(idOrName)] : store.listLoops({ limit: positiveInteger(opts.limit, "--limit") ?? 200 });
     const values = loops.map((loop) => expectationForLoop(store, loop));
     if (isJson())
       console.log(JSON.stringify(idOrName ? values[0] : values, null, 2));
@@ -14234,7 +14401,7 @@ var health = program.command("health").description("summarize loop health and la
 health.command("route-tasks").description("upsert deduped todos tasks for failed loop health expectations").option("--project <path>", "todos project path", defaultLoopsProject()).option("--task-list <slug>", "todos task-list slug", "loop-error-self-heal").option("--limit <n>", "maximum loops to inspect", "200").option("--max-actions <n>", "maximum todos tasks to upsert", "5").option("--include-inactive", "also route stopped or expired loops").option("--auto-route", "opt routed tasks into task-created headless worker/verifier automation").option("--route-project-path <path>", "fallback project path for --auto-route when the failed loop has no cwd").option("--evidence-dir <path>", "write the route result JSON to this directory").option("--dry-run", "print intended task upserts without mutating todos").action(runAction((opts) => {
   const store = new Store;
   try {
-    const report = buildHealthReport(store, { limit: Number(opts.limit), includeInactive: Boolean(opts.includeInactive) });
+    const report = buildHealthReport(store, { limit: positiveInteger(opts.limit, "--limit") ?? 200, includeInactive: Boolean(opts.includeInactive) });
     const failures = report.expectations.filter((entry) => !entry.ok && entry.recommendedTask);
     const result = upsertRouteTasks({
       project: opts.project,
@@ -14247,7 +14414,7 @@ health.command("route-tasks").description("upsert deduped todos tasks for failed
         autoRoute: Boolean(opts.autoRoute),
         routeProjectPath: opts.routeProjectPath
       }),
-      maxActions: Number(opts.maxActions),
+      maxActions: positiveInteger(opts.maxActions, "--max-actions") ?? 5,
       dryRun: Boolean(opts.dryRun),
       autoRoute: Boolean(opts.autoRoute),
       routeProjectPath: opts.routeProjectPath,
@@ -14301,7 +14468,7 @@ hygiene.command("names").description("check or apply canonical machine-/repo-pre
       apply: false,
       includeStopped: Boolean(opts.includeStopped),
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit)
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000
     });
     let outputReport = report;
     const backupPath = opts.apply && report.changed > 0 ? backupLoopsDatabase("name-hygiene") : undefined;
@@ -14310,7 +14477,7 @@ hygiene.command("names").description("check or apply canonical machine-/repo-pre
         apply: true,
         includeStopped: Boolean(opts.includeStopped),
         includeInactive: Boolean(opts.includeInactive),
-        limit: Number(opts.limit)
+        limit: positiveInteger(opts.limit, "--limit") ?? 1000
       });
     } else if (opts.apply) {
       outputReport = { ...report, applied: true };
@@ -14337,7 +14504,7 @@ hygiene.command("duplicates").description("detect duplicate/overlapping loops wi
   try {
     const report = buildDuplicateOverlapReport(store, {
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit)
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000
     });
     if (isJson())
       console.log(JSON.stringify(report, null, 2));
@@ -14359,7 +14526,7 @@ hygiene.command("scripts").description("inventory loops still backed by local ~/
     const report = buildScriptInventoryReport(store, {
       scriptsDir: opts.scriptsDir,
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit)
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000
     });
     if (isJson())
       console.log(JSON.stringify(report, null, 2));
@@ -14381,7 +14548,7 @@ hygiene.command("route-tasks").description("upsert deduped todos tasks for hygie
     const route = buildHygieneRouteTasks(store, {
       checks,
       includeInactive: Boolean(opts.includeInactive),
-      limit: Number(opts.limit),
+      limit: positiveInteger(opts.limit, "--limit") ?? 1000,
       scriptsDir: opts.scriptsDir
     });
     const result = upsertRouteTasks({
@@ -14395,7 +14562,7 @@ hygiene.command("route-tasks").description("upsert deduped todos tasks for hygie
         autoRoute: Boolean(opts.autoRoute),
         routeProjectPath: opts.routeProjectPath
       }),
-      maxActions: Number(opts.maxActions),
+      maxActions: positiveInteger(opts.maxActions, "--max-actions") ?? 10,
       dryRun: Boolean(opts.dryRun),
       autoRoute: Boolean(opts.autoRoute),
       routeProjectPath: opts.routeProjectPath,
@@ -14435,7 +14602,7 @@ program.command("stop <idOrName>").description("stop a loop and clear its next s
 program.command("rename <idOrName> <newName>").description("rename a loop without changing its id, schedule, runs, or history").action(runAction((idOrName, newName) => {
   const store = new Store;
   try {
-    const loop = store.requireLoop(idOrName);
+    const loop = store.requireUniqueLoop(idOrName);
     const oldName = loop.name;
     const trimmed = String(newName).trim();
     if (!trimmed)
@@ -14472,10 +14639,17 @@ backup=${backupPath ?? "skipped (recent rename backup exists)"}`);
 function updateStatus(idOrName, status) {
   const store = new Store;
   try {
-    const loop = store.requireLoop(idOrName);
+    const loop = store.requireUniqueLoop(idOrName);
     if (loop.archivedAt)
       throw new Error(`loop is archived; run 'loops unarchive ${idOrName}' first`);
-    const updated = store.updateLoop(loop.id, { status, nextRunAt: status === "stopped" ? undefined : loop.nextRunAt });
+    let nextRunAt = loop.nextRunAt;
+    if (status === "stopped") {
+      nextRunAt = undefined;
+    } else if (status === "active" && !loop.nextRunAt) {
+      const now = new Date;
+      nextRunAt = computeNextAfter(loop.schedule, now, now);
+    }
+    const updated = store.updateLoop(loop.id, { status, nextRunAt });
     print(publicLoop(updated), `${updated.id} ${updated.status}`);
   } finally {
     store.close();
@@ -14484,7 +14658,7 @@ function updateStatus(idOrName, status) {
 program.command("remove <idOrName>").alias("rm").description("delete a loop and its run history").action(runAction((idOrName) => {
   const store = new Store;
   try {
-    const removed = store.deleteLoop(idOrName);
+    const removed = store.deleteLoop(store.requireUniqueLoop(idOrName).id);
     print({ removed }, removed ? "removed" : "not removed");
   } finally {
     store.close();
@@ -14511,7 +14685,7 @@ program.command("unarchive <idOrName>").alias("restore").description("restore an
 program.command("run-now <idOrName>").description("claim and execute one loop run immediately").option("--show-output", "show stdout/stderr").action(runAction(async (idOrName, opts) => {
   const store = new Store;
   try {
-    const loop = store.requireLoop(idOrName);
+    const loop = store.requireUniqueLoop(idOrName);
     if (loop.archivedAt)
       throw new Error(`loop is archived; run 'loops unarchive ${idOrName}' before running it`);
     const runnerId = `manual:${process.pid}`;
@@ -14691,15 +14865,16 @@ ${result.enableResults.map((item) => `${item.command} -> ${item.status === 0 ? "
 ${result.instructions.join(`
 `)}${enableText}`);
 }));
-daemon.command("logs").description("print the tail of the daemon log").option("-n, --lines <n>", "lines", "80").action(runAction((opts) => {
+daemon.command("logs").description("print the tail of the daemon log").option("-n, --lines <n>", "lines", "80").option("--tail <n>", "alias for --lines").action(runAction((opts) => {
   const path = daemonLogPath();
   if (!existsSync10(path)) {
     console.log("");
     return;
   }
+  const count = positiveInteger(opts.tail ?? opts.lines, opts.tail !== undefined ? "--tail" : "--lines") ?? 80;
   const lines = readFileSync10(path, "utf8").trimEnd().split(`
 `);
-  console.log(lines.slice(-Number(opts.lines)).join(`
+  console.log(lines.slice(-count).join(`
 `));
 }));
 await program.parseAsync(process.argv);