chainlesschain 0.163.4 → 0.163.6

package/src/commands/background-session.js

@@ -9,6 +9,7 @@ import {
 } from "../lib/collaboration-run-store.js";
 import { readSessionHostResumeState } from "../lib/session-host-snapshot.js";
 import executionBroker from "../lib/process-execution-broker/index.js";
+import { registerSchedulerDaemonCommands } from "./scheduler-daemon.js";
 
 export function buildBackgroundDispatchArgs(prompt) {
   return ["agent", "--bg", `--print=${prompt}`];
@@ -100,6 +101,21 @@ export function formatBackgroundAgentDetails(
     );
   }
   if (session.phase) lines.push(`  phase: ${session.phase}`);
+  if (session.pendingQuestion) {
+    const prompt = String(
+      session.pendingQuestion.prompt || session.pendingQuestion.question || "",
+    )
+      .replace(/\s+/gu, " ")
+      .trim()
+      .slice(0, 240);
+    lines.push(`  needsInput: ${prompt || "question pending"}`);
+  }
+  if (session.needsInputIncident) {
+    const incident = session.needsInputIncident;
+    lines.push(
+      `  needsInputIncident: ${incident.incidentId || "-"} status=${incident.status || "?"} notification=${incident.notification?.status || "?"}`,
+    );
+  }
   if (session.pr?.number) {
     lines.push(
       `  pr: #${session.pr.number}${session.pr.state ? ` ${session.pr.state}` : ""}${session.pr.url ? `  ${session.pr.url}` : ""}`,
@@ -120,6 +136,19 @@ export function formatBackgroundAgentDetails(
   lines.push("", "Commands:");
   lines.push(`  cc attach ${session.id}`);
   lines.push(`  cc logs ${session.id} -n 100`);
+  if (
+    ["failed", "unconfigured"].includes(
+      session.needsInputIncident?.notification?.status,
+    )
+  ) {
+    lines.push(`  cc daemon notify-needs-input ${session.id}`);
+  } else if (
+    ["delivering", "outcome_unknown", "partial"].includes(
+      session.needsInputIncident?.notification?.status,
+    )
+  ) {
+    lines.push(`  cc daemon notify-needs-input ${session.id} --force`);
+  }
   if (session.status === "running") {
     lines.push(`  cc daemon stop ${session.id}`);
   }
@@ -275,6 +304,49 @@ export async function replyBackgroundAgent(id, prompt, dependencies = {}) {
   }
 }
 
+export async function retryBackgroundNeedsInputNotification(
+  id,
+  options = {},
+  dependencies = {},
+) {
+  const sessionId = String(id || "").trim();
+  if (!sessionId) throw new Error("background agent id is required");
+  const supervisor = dependencies.supervisor || (await loadSupervisor());
+  const state = supervisor.readBackgroundAgentState(sessionId);
+  if (!state) throw new Error(`Background agent not found: ${sessionId}`);
+  if (!state.needsInputIncident) {
+    throw new Error(
+      `Background agent ${sessionId} has no needs-input incident`,
+    );
+  }
+  const result = await supervisor.deliverBackgroundNeedsInputNotification(
+    sessionId,
+    {
+      retry: true,
+      force: options.force === true,
+      ...(dependencies.notify ? { notify: dependencies.notify } : {}),
+    },
+  );
+  if (!result.applied) {
+    const error = new Error(
+      result.reason === "delivery_in_progress"
+        ? `Needs-input notification is already being delivered for ${sessionId}`
+        : result.reason === "delivery_not_retryable"
+          ? `Needs-input notification for ${sessionId} is not safely retryable; use --force only after accepting possible duplicate delivery`
+          : `Background agent ${sessionId} no longer has a pending needs-input incident`,
+    );
+    error.code = "BACKGROUND_NEEDS_INPUT_NOTIFICATION_NOT_RETRYABLE";
+    error.reason = result.reason;
+    throw error;
+  }
+  return {
+    id: sessionId,
+    incidentId: result.incident?.incidentId || null,
+    incidentStatus: result.incident?.status || null,
+    notification: result.incident?.notification || null,
+  };
+}
+
 export const LOG_TRUNCATION_NOTICE =
   "--- log truncated/rotated, resuming from tail ---";
 const TRUNCATION_RESUME_TAIL_BYTES = 4096;
@@ -825,7 +897,36 @@ export function registerBackgroundSessionCommands(program) {
 
   const daemon = program
     .command("daemon")
-    .description("Inspect and stop background agent supervisor sessions");
+    .description("Manage background agent and scheduler services");
+
+  registerSchedulerDaemonCommands(daemon);
+
+  daemon
+    .command("notify-needs-input <id>")
+    .description(
+      "Retry a durable needs-input notification for a background run",
+    )
+    .option(
+      "--force",
+      "Retry an ambiguous or already-delivered notification (may duplicate)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const result = await retryBackgroundNeedsInputNotification(id, options);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else {
+          logger.log(
+            chalk.green(
+              `Needs-input notification ${result.notification?.status || "settled"} for ${id}`,
+            ),
+          );
+        }
+      } catch (error) {
+        logger.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
+    });
 
   daemon
     .command("status")

package/src/commands/cowork.js

@@ -475,7 +475,7 @@ export function registerCoworkCommand(program) {
       for (const s of schedules) {
         const flag = s.enabled ? chalk.green("✓") : chalk.gray("✗");
         logger.log(
-          `  ${flag} ${chalk.cyan(s.id)}  ${chalk.yellow(s.cron)}  [${s.templateId || "free"}]`,
+          `  ${flag} ${chalk.cyan(s.id)}  ${chalk.yellow(s.cron)}${s.timeZone ? ` [${s.timeZone}]` : ""}  [${s.templateId || "free"}]`,
         );
         logger.log(chalk.gray(`    ${s.userMessage.slice(0, 80)}`));
         if (s.lastRunAt) {
@@ -495,6 +495,7 @@ export function registerCoworkCommand(program) {
       "5-field cron expression (e.g. '0 9 * * 1-5')",
     )
     .requiredOption("--message <text>", "Task prompt / user message")
+    .option("--timezone <iana>", "IANA time zone (for example Asia/Shanghai)")
     .option(
       "--template <id>",
       "Template id (e.g. doc-convert); omit for free mode",
@@ -505,6 +506,7 @@ export function registerCoworkCommand(program) {
       try {
         const entry = addSchedule(process.cwd(), {
           cron: options.cron,
+          timeZone: options.timezone || null,
           templateId: options.template || null,
           userMessage: options.message,
           files: options.files
@@ -516,6 +518,9 @@ export function registerCoworkCommand(program) {
         });
         logger.log(chalk.green(`✓ Added schedule ${entry.id}`));
         logger.log(chalk.gray(`  cron: ${entry.cron}`));
+        if (entry.timeZone) {
+          logger.log(chalk.gray(`  timezone: ${entry.timeZone}`));
+        }
         logger.log(chalk.gray(`  template: ${entry.templateId || "free"}`));
       } catch (err) {
         logger.error(err.message);
@@ -565,19 +570,30 @@ export function registerCoworkCommand(program) {
   cron
     .command("run")
     .description("Start the cron scheduler in the foreground (Ctrl-C to stop)")
-    .option("--interval <ms>", "Tick interval in ms (default 60000)", "60000")
+    .option(
+      "--interval <ms>",
+      "Tick interval in ms (auto: 1000 for six-field cron, otherwise 60000)",
+    )
     .action(async (options) => {
-      const [{ CoworkCronScheduler, _deps: cronDeps }, { runCoworkTask }] =
-        await Promise.all([
-          import("../lib/cowork-cron.js"),
-          import("../lib/cowork-task-runner.js"),
-        ]);
-      // Inject the runner so the scheduler doesn't require a circular import
-      cronDeps.runTask = runCoworkTask;
-
-      const scheduler = new CoworkCronScheduler({
+      const [
+        { CoworkCronKernelScheduler },
+        { openSchedulerStore },
+        { runCoworkTask },
+      ] = await Promise.all([
+        import("../lib/scheduler-kernel/cowork-cron-adapter.js"),
+        import("../lib/scheduler-kernel/store.js"),
+        import("../lib/cowork-task-runner.js"),
+      ]);
+      const schedulerStore = openSchedulerStore();
+      const intervalMs =
+        options.interval === undefined
+          ? undefined
+          : parseInt(options.interval, 10) || 60_000;
+      const scheduler = new CoworkCronKernelScheduler({
         cwd: process.cwd(),
-        intervalMs: parseInt(options.interval, 10) || 60_000,
+        schedulerStore,
+        runTask: runCoworkTask,
+        ...(intervalMs === undefined ? {} : { intervalMs }),
         onEvent: (e) => {
           const ts = new Date().toISOString();
           logger.log(chalk.gray(`[${ts}] ${JSON.stringify(e)}`));
@@ -587,8 +603,9 @@ export function registerCoworkCommand(program) {
       logger.log(
         chalk.green("Cowork cron scheduler running. Press Ctrl-C to stop."),
       );
-      process.on("SIGINT", () => {
+      process.once("SIGINT", () => {
         scheduler.stop();
+        schedulerStore.close();
         process.exit(0);
       });
     });

package/src/commands/loop.js

@@ -2,8 +2,9 @@
  * cc loop — repeatedly run a command or agent prompt on a fixed interval
  * (Claude-Code `/loop` parity, MVP). Lightweight by design: unlike `cc ccron`
  * (in-memory profile governance, runs nothing) or `cc automation` (DB-backed
- * flow/trigger engine), this just re-runs ONE thing on a timer until a stop
- * condition fires or you Ctrl-C.
+ * flow/trigger engine), this re-runs ONE thing until a stop condition fires or
+ * you Ctrl-C. Each iteration is claimed and settled by the durable scheduler
+ * kernel; the foreground command remains the lifecycle owner between rounds.
  *
  *   cc loop "check if CI passed, summarize failures"   # wraps `cc agent -p`
  *   cc loop --every 30s -- npm test                    # external command
@@ -20,9 +21,11 @@
  *   - with `--` → the operands after it are an EXTERNAL command (shell-resolved)
  *
  * The loop driver lives in src/lib/loop.js (pure, clock-injected). This layer
- * only builds the concrete iteration (spawn + tee output) and wires SIGINT.
+ * builds the concrete iteration (spawn + tee output), binds scheduler identity,
+ * persists resumable iteration plans, and wires SIGINT.
  */
 
+import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
@@ -34,16 +37,22 @@ import {
   makeSleep,
   parseLoopDirectives,
   summarizeLoopEvents,
+  findLoopIterationResult,
 } from "../lib/loop.js";
 import {
   startSession,
   appendEvent,
+  appendEventIfHead,
   readEvents,
   sessionExists,
 } from "../harness/jsonl-session-store.js";
+import { openSchedulerStore } from "../lib/scheduler-kernel/store.js";
+import { LoopSchedulerBridge } from "../lib/scheduler-kernel/loop-adapter.js";
 
 export const _deps = {
   spawn: executionBroker.spawn.bind(executionBroker),
+  openSchedulerStore,
+  createLoopSchedulerBridge: (options) => new LoopSchedulerBridge(options),
 };
 
 /**
@@ -68,10 +77,11 @@ const BIN_PATH = fileURLToPath(
  * the user sees live output) while capturing it, so `--until <regex>` can match
  * against what was printed. Resolves with { exitCode, output }.
  */
-function spawnIteration(cmd, args, { shell, onChild, capture }) {
+function spawnIteration(cmd, args, { shell, cwd, onChild, capture, signal }) {
   return new Promise((resolve) => {
     const child = _deps.spawn(cmd, args, {
       shell,
+      cwd,
       stdio: capture ? ["inherit", "pipe", "pipe"] : "inherit",
       env: process.env,
       origin: "loop:iteration",
@@ -80,6 +90,17 @@ function spawnIteration(cmd, args, { shell, onChild, capture }) {
     });
     if (onChild) onChild(child);
 
+    const onAbort = () => {
+      if (child.exitCode == null) {
+        try {
+          child.kill("SIGINT");
+        } catch {
+          // The child may have exited between the state check and kill.
+        }
+      }
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+
     const outChunks = [];
     if (capture) {
       child.stdout?.on("data", (d) => {
@@ -93,16 +114,22 @@ function spawnIteration(cmd, args, { shell, onChild, capture }) {
     }
 
     // `close` (not `exit`) so piped stdio is fully drained before we resolve.
-    child.on("close", (code, signal) => {
+    child.on("close", (code, childSignal) => {
+      signal?.removeEventListener?.("abort", onAbort);
       // Decode the captured bytes once, at the end. Accumulating with
       // `output += chunk` would decode each stdout chunk independently, so a
       // multi-byte UTF-8 character split across a chunk boundary corrupts the
       // captured string that `--until <regex>` / `--dynamic` directive parsing
       // reads. (The raw passthrough writes above are unaffected.)
       const output = Buffer.concat(outChunks).toString("utf-8");
-      resolve({ exitCode: code == null ? null : code, output, signal });
+      resolve({
+        exitCode: code == null ? null : code,
+        output,
+        signal: childSignal,
+      });
     });
     child.on("error", (err) => {
+      signal?.removeEventListener?.("abort", onAbort);
       resolve({
         exitCode: 127,
         output: String(err.message || err),
@@ -112,6 +139,73 @@ function spawnIteration(cmd, args, { shell, onChild, capture }) {
   });
 }
 
+function recoveredIterationResult(data) {
+  return {
+    exitCode: data?.exitCode ?? null,
+    signal: data?.signal ?? null,
+    durationMs: data?.durationMs ?? null,
+    done: data?.done === true,
+    nextDelayMs: data?.nextDelayMs ?? null,
+    matchedUntil: data?.matchedUntil === true,
+    outputBytes: data?.outputBytes ?? 0,
+    outputDigest: data?.outputDigest ?? null,
+    schedulerOccurrenceId: data?.schedulerOccurrenceId ?? null,
+    recovered: true,
+    output: "",
+  };
+}
+
+/**
+ * Publish one stable iteration schedule under the canonical session writer
+ * lock. A concurrent resumer either observes the same schedule or the already
+ * completed terminal record; it never invents a second scheduledFor identity.
+ */
+function claimPersistedIteration(sessionId, iteration, now = Date.now()) {
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    const events = readEvents(sessionId);
+    const completed = findLoopIterationResult(events, iteration);
+    if (completed) return { completed, scheduledFor: null };
+    const summary = summarizeLoopEvents(events);
+    if (summary.pendingIteration?.n === iteration) {
+      return {
+        completed: null,
+        scheduledFor: summary.pendingIteration.scheduledFor,
+      };
+    }
+    if (summary.pendingIteration) {
+      const error = new Error(
+        `loop session has unresolved iteration ${summary.pendingIteration.n}`,
+      );
+      error.code = "LOOP_PENDING_ITERATION_CONFLICT";
+      throw error;
+    }
+    const expectedHeadHash = events[events.length - 1]?.hash || null;
+    try {
+      appendEventIfHead(
+        sessionId,
+        "loop_iteration_scheduled",
+        { n: iteration, scheduledFor: now },
+        expectedHeadHash,
+      );
+      return { completed: null, scheduledFor: now };
+    } catch (error) {
+      if (error?.code === "SESSION_REVISION_STALE") continue;
+      // An append classified as outcome-unknown may still have committed.
+      const after = readEvents(sessionId);
+      const recovered = findLoopIterationResult(after, iteration);
+      if (recovered) return { completed: recovered, scheduledFor: null };
+      const pending = summarizeLoopEvents(after).pendingIteration;
+      if (pending?.n === iteration) {
+        return { completed: null, scheduledFor: pending.scheduledFor };
+      }
+      throw error;
+    }
+  }
+  const error = new Error("loop iteration schedule changed too many times");
+  error.code = "LOOP_ITERATION_SCHEDULE_CONTENTION";
+  throw error;
+}
+
 /**
  * Build the concrete child invocation from the resolved operands + mode.
  * Shared by fresh runs and `--resume` (which reconstructs it from saved config).
@@ -283,6 +377,7 @@ export function registerLoopCommand(program) {
           savedConfig && !fromCli("untilExitZero")
             ? Boolean(savedConfig.untilExitZero)
             : Boolean(options.untilExitZero);
+        const executionCwd = savedConfig?.cwd || process.cwd();
 
         // --- build the child invocation (shared with resume) ---
         const { cmd, args, shell, label } = buildInvocation({
@@ -308,6 +403,7 @@ export function registerLoopCommand(program) {
             maxIterations: maxIterations ?? null,
             untilExitZero,
             until: untilRaw || null,
+            cwd: executionCwd,
           });
         }
 
@@ -346,7 +442,54 @@ export function registerLoopCommand(program) {
 
         const startedAt = Date.now();
         let summary;
+        let schedulerStore;
         try {
+          const executionId = sessionId || `loop-${randomUUID()}`;
+          schedulerStore = _deps.openSchedulerStore();
+          const loopScheduler = _deps.createLoopSchedulerBridge({
+            schedulerStore,
+            definition: {
+              executionId,
+              cwd: executionCwd,
+              execMode,
+              operands,
+              dynamic,
+            },
+            runIteration: async (n, { signal } = {}) => {
+              logger.log(chalk.gray(`\n▸ iteration ${n} — ${label}`));
+              const t0 = Date.now();
+              const res = await spawnIteration(cmd, args, {
+                shell,
+                cwd: executionCwd,
+                capture,
+                signal,
+                onChild: (c) => {
+                  activeChild = c;
+                },
+              });
+              res.durationMs = Date.now() - t0;
+              res.matchedUntil = Boolean(
+                untilRegex && untilRegex.test(res.output || ""),
+              );
+              if (dynamic) {
+                const directive = parseLoopDirectives(res.output);
+                res.done = directive.done;
+                if (directive.nextDelayMs != null) {
+                  res.nextDelayMs = directive.nextDelayMs;
+                }
+                if (directive.done) {
+                  logger.log(chalk.gray("     directive: stop"));
+                } else if (directive.nextDelayMs != null) {
+                  logger.log(
+                    chalk.gray(
+                      `     directive: next in ${formatDuration(directive.nextDelayMs)}`,
+                    ),
+                  );
+                }
+              }
+              return res;
+            },
+          });
           summary = await runLoop({
             intervalMs,
             maxIterations,
@@ -370,46 +513,34 @@ export function registerLoopCommand(program) {
                   durationMs: res.durationMs ?? null,
                   done: Boolean(res.done),
                   nextDelayMs: res.nextDelayMs ?? null,
+                  matchedUntil: Boolean(res.matchedUntil),
+                  signal: res.signal ?? null,
+                  outputBytes: res.outputBytes ?? 0,
+                  outputDigest: res.outputDigest ?? null,
+                  schedulerOccurrenceId: res.schedulerOccurrenceId ?? null,
+                  recovered: Boolean(res.recovered),
                 });
               }
             },
             runIteration: async (n) => {
-              logger.log(chalk.gray(`\n▸ iteration ${n} — ${label}`));
-              const t0 = Date.now();
-              const res = await spawnIteration(cmd, args, {
-                shell,
-                capture,
-                onChild: (c) => {
-                  activeChild = c;
-                },
-              });
-              res.durationMs = Date.now() - t0;
-              // --dynamic: read the iteration's [[loop:next]] / [[loop:stop]]
-              // directive and surface it to runLoop as done / nextDelayMs.
-              // Use the RESOLVED `dynamic` (not raw options.dynamic): on
-              // `cc loop --resume`, dynamic is rehydrated from saved config while
-              // options.dynamic is false — gating on the raw flag would skip
-              // directive parsing and the model's [[loop:stop]] would be ignored,
-              // running the loop forever.
-              if (dynamic) {
-                const d = parseLoopDirectives(res.output);
-                res.done = d.done;
-                if (d.nextDelayMs != null) res.nextDelayMs = d.nextDelayMs;
-                if (d.done) {
-                  logger.log(chalk.gray(`     ↺ directive: stop`));
-                } else if (d.nextDelayMs != null) {
-                  logger.log(
-                    chalk.gray(
-                      `     ↺ directive: next in ${formatDuration(d.nextDelayMs)}`,
-                    ),
-                  );
+              let scheduledFor = Date.now();
+              if (persist) {
+                const claim = claimPersistedIteration(
+                  sessionId,
+                  n,
+                  scheduledFor,
+                );
+                if (claim.completed) {
+                  return recoveredIterationResult(claim.completed);
                 }
+                scheduledFor = claim.scheduledFor;
               }
-              return res;
+              return loopScheduler.runIteration(n, { scheduledFor });
             },
           });
         } finally {
           process.removeListener("SIGINT", onSigint);
+          schedulerStore?.close();
         }
 
         const elapsed = formatDuration(Date.now() - startedAt);

package/src/commands/routine.js

@@ -18,6 +18,11 @@ import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { executionBroker } from "../lib/process-execution-broker/index.js";
+import { openSchedulerStore } from "../lib/scheduler-kernel/store.js";
+import {
+  RoutineSchedulerBridge,
+  routineBridgeRunId,
+} from "../lib/scheduler-kernel/routine-adapter.js";
 
 export const _deps = {
   spawn: (...args) => executionBroker.spawn(...args),
@@ -107,6 +112,7 @@ export function defaultFetchEvents(repo) {
             (Array.isArray(rows) ? rows : []).map((r) => ({
               id: r.id,
               type: r.type,
+              created_at: r.created_at,
             })),
           );
         } catch {
@@ -281,14 +287,24 @@ export function registerRoutineCommand(program) {
     .description("Fire a routine NOW (the webhook/API entry point)")
     .option("--json", "Output as JSON")
     .action(async (id, options) => {
+      let schedulerStore;
       try {
         const store = await loadStore();
         const r = store.get(id);
         if (!r) throw new Error(`routine not found: ${id}`);
-        const { fireRoutine } = await import("../lib/routine-store.js");
-        const runId = await fireRoutine(store, r, defaultRunAgent, {
-          trigger: "manual",
+        schedulerStore = openSchedulerStore();
+        const bridge = new RoutineSchedulerBridge({
+          routineStore: store,
+          schedulerStore,
+          runAgent: defaultRunAgent,
         });
+        const fired = await bridge.trigger(r);
+        const runId = routineBridgeRunId(fired);
+        if (!runId) {
+          throw new Error(
+            `routine occurrence did not execute: ${fired.result?.status || "unknown"}`,
+          );
+        }
         const run = store.listRuns({ routineId: r.id, limit: 1 })[0];
         if (options.json) return console.log(JSON.stringify(run, null, 2));
         logger.success(`Fired ${r.id} → ${runId} (${run?.status})`);
@@ -296,6 +312,8 @@ export function registerRoutineCommand(program) {
       } catch (err) {
         logger.error(err.message);
         process.exitCode = 1;
+      } finally {
+        schedulerStore?.close();
       }
     });
 
@@ -304,25 +322,42 @@ export function registerRoutineCommand(program) {
     .description("Driver: fire due cron/once routines and poll github triggers")
     .option("--json", "Output as JSON")
     .action(async (options) => {
+      let schedulerStore;
       try {
         const store = await loadStore();
-        const { fireRoutine, pollGithubRoutine } =
-          await import("../lib/routine-store.js");
+        schedulerStore = openSchedulerStore();
+        const bridge = new RoutineSchedulerBridge({
+          routineStore: store,
+          schedulerStore,
+          runAgent: defaultRunAgent,
+        });
         const fired = [];
-        for (const r of store.due()) {
+        for (const scheduled of await bridge.runDue()) {
+          const runId = routineBridgeRunId(scheduled);
+          if (!runId) {
+            if (scheduled.result?.status === "busy") continue;
+            throw new Error(
+              `routine occurrence did not execute: ${scheduled.routine} (${scheduled.result?.status || "unknown"})`,
+            );
+          }
           fired.push({
-            routine: r.id,
-            runId: await fireRoutine(store, r, defaultRunAgent, {
-              trigger: r.trigger.kind,
-            }),
+            routine: scheduled.routine,
+            runId,
           });
         }
         for (const r of store.githubRoutines()) {
-          const runs = await pollGithubRoutine(store, r, {
+          const github = await bridge.pollGithub(r, {
             fetchEvents: defaultFetchEvents,
-            runAgent: defaultRunAgent,
           });
-          for (const runId of runs) fired.push({ routine: r.id, runId });
+          if (!github) continue;
+          const runId = routineBridgeRunId(github);
+          if (!runId) {
+            if (github.result?.status === "busy") continue;
+            throw new Error(
+              `routine GitHub occurrence did not execute: ${github.routine} (${github.result?.status || "unknown"})`,
+            );
+          }
+          fired.push({ routine: github.routine, runId });
         }
         if (options.json)
           return console.log(JSON.stringify({ fired }, null, 2));
@@ -334,6 +369,8 @@ export function registerRoutineCommand(program) {
       } catch (err) {
         logger.error(err.message);
         process.exitCode = 1;
+      } finally {
+        schedulerStore?.close();
       }
     });