@adaptic/maestro 1.7.3 → 1.8.0

package/lib/cadence-bus.test.mjs

@@ -0,0 +1,354 @@
+/**
+ * cadence-bus.test.mjs — node:test coverage for the cadence bus primitive.
+ *
+ * Every test creates its own AGENT_ROOT under tmpdir() and cleans up.
+ * No real network, no real Claude. Time is injectable via `now` arguments
+ * where the API supports it; otherwise tests use real wall-clock with
+ * generous epsilons.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { promises as fsp } from "fs";
+import { readFileSync, writeFileSync, existsSync, readdirSync } from "node:fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import {
+  enqueueTick,
+  claimNextTick,
+  completeTick,
+  failTick,
+  recoverStaleClaims,
+  writeHealth,
+  readHealth,
+  busDepth,
+  ensureBusDirs,
+  bootstrapBus,
+  getBusPaths,
+  nextEventId,
+  listInbox,
+  listClaimed,
+  BUS_VERSION,
+} from "./cadence-bus.mjs";
+
+async function makeAgentRoot() {
+  const path = join(
+    tmpdir(),
+    `cadence-bus-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  await fsp.mkdir(path, { recursive: true });
+  return path;
+}
+
+async function rmRoot(path) {
+  try { await fsp.rm(path, { recursive: true, force: true }); } catch { /* */ }
+}
+
+// ---------------------------------------------------------------------------
+// Path resolution + bootstrap
+// ---------------------------------------------------------------------------
+
+test("getBusPaths derives every path under state/cadence-bus/", async () => {
+  const root = await makeAgentRoot();
+  try {
+    const p = getBusPaths(root);
+    assert.equal(p.agentRoot, root);
+    assert.equal(p.base, join(root, "state/cadence-bus"));
+    assert.equal(p.inbox, join(root, "state/cadence-bus/inbox"));
+    assert.equal(p.claimed, join(root, "state/cadence-bus/claimed"));
+    assert.equal(p.processed, join(root, "state/cadence-bus/processed"));
+    assert.equal(p.dlq, join(root, "state/cadence-bus/dlq"));
+    assert.equal(p.queueJsonl, join(root, "state/cadence-bus/queue.jsonl"));
+    assert.equal(p.health, join(root, "state/cadence-bus/health.json"));
+    assert.equal(p.logsDir, join(root, "logs/cadence-bus"));
+  } finally { await rmRoot(root); }
+});
+
+test("ensureBusDirs is idempotent and writes VERSION marker", async () => {
+  const root = await makeAgentRoot();
+  try {
+    const p = ensureBusDirs(root);
+    assert.ok(existsSync(p.inbox));
+    assert.ok(existsSync(p.claimed));
+    assert.ok(existsSync(p.processed));
+    assert.ok(existsSync(p.failed));
+    assert.ok(existsSync(p.dlq));
+    assert.ok(existsSync(p.logsDir));
+    assert.equal(readFileSync(p.version, "utf-8").trim(), BUS_VERSION);
+    // Calling again must not throw and must not duplicate the VERSION file.
+    ensureBusDirs(root);
+    ensureBusDirs(root);
+    assert.equal(readFileSync(p.version, "utf-8").trim(), BUS_VERSION);
+  } finally { await rmRoot(root); }
+});
+
+test("bootstrapBus writes .gitkeep stubs in every bus dir", async () => {
+  const root = await makeAgentRoot();
+  try {
+    const p = bootstrapBus(root);
+    for (const d of [p.inbox, p.claimed, p.processed, p.failed, p.dlq, p.logsDir]) {
+      assert.ok(existsSync(join(d, ".gitkeep")), `.gitkeep missing in ${d}`);
+    }
+  } finally { await rmRoot(root); }
+});
+
+// ---------------------------------------------------------------------------
+// Event ids
+// ---------------------------------------------------------------------------
+
+test("nextEventId yields unique sortable ids", () => {
+  const ids = new Set();
+  for (let i = 0; i < 200; i++) ids.add(nextEventId());
+  assert.equal(ids.size, 200);
+  // Sortability: with a fixed clock, the ISO prefix is identical so the
+  // hex suffix breaks ties — pass an explicit clock to check.
+  const a = nextEventId(new Date(0));
+  const b = nextEventId(new Date(0));
+  assert.notEqual(a, b);
+  assert.match(a, /^evt-1970-01-01T00:00:00\.000Z-[0-9a-f]{8}$/);
+});
+
+// ---------------------------------------------------------------------------
+// Enqueue
+// ---------------------------------------------------------------------------
+
+test("enqueueTick rejects missing cadence", async () => {
+  const root = await makeAgentRoot();
+  try {
+    assert.throws(() => enqueueTick({ agentRoot: root }), /cadence is required/);
+  } finally { await rmRoot(root); }
+});
+
+test("enqueueTick writes inbox JSON + queue.jsonl audit row", async () => {
+  const root = await makeAgentRoot();
+  try {
+    const out = enqueueTick({
+      cadence: "inbox-processor",
+      source: "launchd",
+      metadata: { note: "smoke" },
+      agentRoot: root,
+    });
+    assert.equal(out.fallbackOnly, false);
+    assert.ok(out.path);
+    const event = JSON.parse(readFileSync(out.path, "utf-8"));
+    assert.equal(event.cadence, "inbox-processor");
+    assert.equal(event.source, "launchd");
+    assert.equal(event.metadata.note, "smoke");
+    assert.equal(event.priority, "normal");
+    assert.equal(event.attempts, 0);
+    // queue.jsonl mirror
+    const paths = getBusPaths(root);
+    const audit = readFileSync(paths.queueJsonl, "utf-8").trim();
+    const rec = JSON.parse(audit);
+    assert.equal(rec.id, out.id);
+  } finally { await rmRoot(root); }
+});
+
+test("enqueueTick suppresses when .emergency-stop exists but still audits", async () => {
+  const root = await makeAgentRoot();
+  try {
+    writeFileSync(join(root, ".emergency-stop"), new Date().toISOString());
+    const out = enqueueTick({
+      cadence: "weekly-strategic-memo",
+      source: "launchd",
+      agentRoot: root,
+    });
+    assert.equal(out.skipped, "emergency-stop");
+    assert.equal(out.fallbackOnly, true);
+    assert.equal(listInbox(root).length, 0);
+    const paths = getBusPaths(root);
+    const audit = readFileSync(paths.queueJsonl, "utf-8").trim();
+    const rec = JSON.parse(audit);
+    assert.equal(rec._suppressed, "emergency-stop");
+  } finally { await rmRoot(root); }
+});
+
+test("enqueueTick coerces unknown priority to 'normal'", async () => {
+  const root = await makeAgentRoot();
+  try {
+    const out = enqueueTick({ cadence: "x", priority: "BOGUS", agentRoot: root });
+    const event = JSON.parse(readFileSync(out.path, "utf-8"));
+    assert.equal(event.priority, "normal");
+  } finally { await rmRoot(root); }
+});
+
+// ---------------------------------------------------------------------------
+// Claim / complete / fail / DLQ
+// ---------------------------------------------------------------------------
+
+test("claimNextTick is atomic — only one claimer wins per event", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    enqueueTick({ cadence: "x", agentRoot: root });
+    enqueueTick({ cadence: "x", agentRoot: root });
+    assert.equal(listInbox(root).length, 3);
+
+    const seen = new Set();
+    let c;
+    while ((c = claimNextTick(root)) !== null) {
+      assert.ok(!seen.has(c.event.id), "duplicate claim");
+      seen.add(c.event.id);
+    }
+    assert.equal(seen.size, 3);
+    assert.equal(listInbox(root).length, 0);
+    assert.equal(listClaimed(root).length, 3);
+  } finally { await rmRoot(root); }
+});
+
+test("claimNextTick bumps attempts and persists to claimed/", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    const { event, claimedPath } = claimNextTick(root);
+    assert.equal(event.attempts, 1);
+    const reloaded = JSON.parse(readFileSync(claimedPath, "utf-8"));
+    assert.equal(reloaded.attempts, 1);
+  } finally { await rmRoot(root); }
+});
+
+test("claimNextTick returns null on empty inbox", async () => {
+  const root = await makeAgentRoot();
+  try {
+    assert.equal(claimNextTick(root), null);
+  } finally { await rmRoot(root); }
+});
+
+test("completeTick archives the claim under processed/<utc-date>/", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    const { event } = claimNextTick(root);
+    const dst = completeTick(root, event.id, { decision: "inline", duration_ms: 42 });
+    assert.ok(dst);
+    const archived = JSON.parse(readFileSync(dst, "utf-8"));
+    assert.equal(archived.result.decision, "inline");
+    assert.equal(archived.result.duration_ms, 42);
+    assert.ok(archived.completed_at);
+    assert.equal(listClaimed(root).length, 0);
+  } finally { await rmRoot(root); }
+});
+
+test("failTick re-queues to inbox while under retry budget", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    const { event } = claimNextTick(root);
+    const out = failTick(root, event.id, "transient");
+    assert.equal(out.destination, "inbox");
+    assert.equal(listInbox(root).length, 1);
+    assert.equal(listClaimed(root).length, 0);
+    // Reload and confirm last_error set.
+    const requeued = JSON.parse(readFileSync(join(getBusPaths(root).inbox, `${event.id}.json`), "utf-8"));
+    assert.equal(requeued.last_error, "transient");
+  } finally { await rmRoot(root); }
+});
+
+test("failTick routes to dlq once attempts hit the budget", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    // Cycle claim/fail until the event lands in dlq.
+    let last;
+    for (let i = 0; i < 10; i++) {
+      const c = claimNextTick(root);
+      if (!c) break;
+      last = failTick(root, c.event.id, `attempt-${i}`);
+      if (last?.destination === "dlq") break;
+    }
+    assert.equal(last.destination, "dlq");
+    assert.equal(listInbox(root).length, 0);
+    assert.equal(listClaimed(root).length, 0);
+    const dlqDir = getBusPaths(root).dlq;
+    assert.ok(readdirSync(dlqDir).length >= 1);
+  } finally { await rmRoot(root); }
+});
+
+test("failTick { terminal: true } sends straight to dlq", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    const { event } = claimNextTick(root);
+    const out = failTick(root, event.id, "no-prompt", { terminal: true });
+    assert.equal(out.destination, "dlq");
+  } finally { await rmRoot(root); }
+});
+
+// ---------------------------------------------------------------------------
+// Stale claim recovery
+// ---------------------------------------------------------------------------
+
+test("recoverStaleClaims returns aging claims to inbox", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    const { event, claimedPath } = claimNextTick(root);
+    // Backdate the claim's mtime by 2 hours.
+    const oldMs = Date.now() - 2 * 60 * 60 * 1000;
+    await fsp.utimes(claimedPath, new Date(oldMs), new Date(oldMs));
+
+    const stats = recoverStaleClaims(root, 60 * 60 * 1000); // 1 hour threshold
+    assert.equal(stats.scanned, 1);
+    assert.equal(stats.recovered, 1);
+    assert.equal(listInbox(root).length, 1);
+    assert.equal(listClaimed(root).length, 0);
+    // The recovered event retains its bumped attempts.
+    const requeued = JSON.parse(readFileSync(join(getBusPaths(root).inbox, `${event.id}.json`), "utf-8"));
+    assert.ok(requeued.attempts >= 1);
+  } finally { await rmRoot(root); }
+});
+
+test("recoverStaleClaims leaves fresh claims alone", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    claimNextTick(root);
+    const stats = recoverStaleClaims(root, 60 * 60 * 1000);
+    assert.equal(stats.scanned, 1);
+    assert.equal(stats.recovered, 0);
+  } finally { await rmRoot(root); }
+});
+
+// ---------------------------------------------------------------------------
+// Health
+// ---------------------------------------------------------------------------
+
+test("writeHealth + readHealth round-trip", async () => {
+  const root = await makeAgentRoot();
+  try {
+    writeHealth(root, { stats: { foo: 1 } });
+    const h = readHealth(root);
+    assert.ok(h);
+    assert.equal(h.version, BUS_VERSION);
+    assert.equal(h.stats.foo, 1);
+    assert.ok(h.ts);
+  } finally { await rmRoot(root); }
+});
+
+test("readHealth returns null when missing or corrupt", async () => {
+  const root = await makeAgentRoot();
+  try {
+    assert.equal(readHealth(root), null);
+    ensureBusDirs(root);
+    writeFileSync(join(root, "state/cadence-bus/health.json"), "{not json");
+    assert.equal(readHealth(root), null);
+  } finally { await rmRoot(root); }
+});
+
+// ---------------------------------------------------------------------------
+// Depth
+// ---------------------------------------------------------------------------
+
+test("busDepth reports counts per stage", async () => {
+  const root = await makeAgentRoot();
+  try {
+    enqueueTick({ cadence: "x", agentRoot: root });
+    enqueueTick({ cadence: "x", agentRoot: root });
+    claimNextTick(root);
+    const d = busDepth(root);
+    assert.equal(d.inbox, 1);
+    assert.equal(d.claimed, 1);
+    assert.equal(d.dlq, 0);
+  } finally { await rmRoot(root); }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptic/maestro",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "description": "Maestro — Autonomous AI agent operating system. Deploy AI employees on dedicated Mac minis.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "./tools": "./lib/tool-definitions.js",
     "./executor": "./lib/action-executor.js",
     "./singleton": "./lib/singleton.js",
+    "./cadence-bus": "./lib/cadence-bus.mjs",
     "./tts": "./lib/tts.mjs",
     "./package.json": "./package.json"
   },
@@ -42,6 +43,10 @@
   },
   "always-build-npm": true,
   "scripts": {
+    "test": "node --test lib/cadence-bus.test.mjs scripts/cadence/enqueue-cadence-tick.test.mjs scripts/daemon/cadence-consumer.test.mjs scripts/daemon/lib/session-router.test.mjs scripts/local-triggers/generate-plists.test.mjs bin/maestro.test.mjs",
+    "test:cadence": "node --test lib/cadence-bus.test.mjs scripts/cadence/enqueue-cadence-tick.test.mjs scripts/daemon/cadence-consumer.test.mjs",
+    "test:cli": "node --test bin/maestro.test.mjs",
+    "test:plists": "node --test scripts/local-triggers/generate-plists.test.mjs",
     "prepublishOnly": "echo 'Publishing @adaptic/maestro...'"
   },
   "engines": {

package/scaffold/CLAUDE.md

@@ -261,15 +261,19 @@ This agent is powered by the `@adaptic/maestro` framework. Update framework: `np
 - Daemon detects inbound Slack/Gmail/Calendar events every 60 seconds
 - Priority events trigger immediate processing
 
-### Mode 2: Scheduled — Run Cadence Workflows
-- Morning brief, midday sweep, evening wrap (daily)
-- Domain-specific reviews (weekly)
-- Self-assessment (quarterly)
+### Mode 2: Scheduled — Run Cadence Workflows via the Cadence Bus
+- Launchd plists drop tiny JSON events onto `state/cadence-bus/inbox/` every 5 / 10 / 15 / 30 minutes, daily, weekly, monthly, and quarterly.
+- The persistent daemon (a single, long-running Node process) consumes the bus and decides per cadence:
+  - **inline**: handled in-process (heartbeats, housekeeping, queue sweeps where the queues are empty)
+  - **guarded**: a cheap pre-check escalates only if there's substantive work
+  - **escalate**: spawns a managed sub-session running `schedules/triggers/<cadence>.md` (substantive drafting, multi-step outreach, large audits)
+- Launchd never spawns Claude Code directly for routine cadence ticks. The daemon is the sole orchestrator of cadence housekeeping.
+- Emergency-stop is honoured at both producer (enqueue) and consumer (drain).
+- Full lifecycle is recorded under `logs/cadence-bus/<date>.jsonl`.
 
 ### Mode 3: Proactive — Execute the Backlog
-- Backlog executor runs every 10 minutes
-- Reads all queues, selects top actionable items
-- Spawns parallel background agents to execute each item
+- Backlog executor runs every 10 minutes via the cadence bus.
+- The bus consumer guards the tick — if all queues are empty, the tick completes inline. Otherwise it escalates to a managed sub-session that reads queues, selects top items by priority, and spawns parallel sub-agents to execute them.
 
 ## Parallel Execution & Agent Teams
 

package/scripts/cadence/cadence-status.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * cadence-status.mjs — Print the current cadence-bus depth + heartbeat.
+ *
+ * Used by `npm run cadence:status` and by `maestro doctor` for a quick
+ * snapshot. Reads files only; never mutates state.
+ *
+ * Output (JSON):
+ *   {
+ *     "depth":  { "inbox": N, "claimed": N, "dlq": N, "failed": N },
+ *     "health": { ... } | null,
+ *     "heartbeat_age_ms": N | null
+ *   }
+ *
+ * Exit code is always 0 — health interpretation is the caller's job.
+ */
+
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const { busDepth, readHealth, getBusPaths } = await import(
+  resolve(__dirname, "..", "..", "lib", "cadence-bus.mjs")
+);
+
+const paths = getBusPaths();
+const depth = busDepth();
+const health = readHealth();
+const heartbeatAgeMs = health?.ts ? Date.now() - new Date(health.ts).getTime() : null;
+
+process.stdout.write(JSON.stringify({
+  agent_root: paths.agentRoot,
+  depth,
+  health,
+  heartbeat_age_ms: heartbeatAgeMs,
+}, null, 2) + "\n");

package/scripts/cadence/enqueue-cadence-tick.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Maestro — enqueue-cadence-tick.mjs
+ *
+ * Lightweight cadence-bus enqueue CLI. Designed to be invoked from launchd
+ * plists (or manual scripting) in place of `claude --print` per tick. The
+ * heavy lifting — running the cadence, deciding whether to spawn a sub-
+ * session, etc. — is owned by the persistent Maestro daemon, which consumes
+ * events from the bus.
+ *
+ * Design constraints:
+ *   • Must finish in well under a second so launchd never piles up.
+ *   • Must never spawn Claude Code itself.
+ *   • Must be safe to call when the daemon is down (event still lands on
+ *     disk and is processed on next consumer startup).
+ *   • Must honour .emergency-stop (no event lands in inbox/; suppressed
+ *     event is still recorded in queue.jsonl for audit).
+ *
+ * Usage:
+ *   node scripts/cadence/enqueue-cadence-tick.mjs <cadence-name> [options]
+ *
+ * Options:
+ *   --source=<label>          launchd | manual | daemon | init-maestro | upgrade  (default: manual)
+ *   --workflow=<path>         e.g. continuous/inbox-processor
+ *   --priority=<high|normal|low>
+ *   --correlation-id=<id>
+ *   --metadata=<key=value>    May be repeated. Comma-separated pairs also accepted.
+ *   --quiet                   Suppress stdout JSON line.
+ *   --help                    Show this help.
+ *
+ * Exit codes:
+ *   0  — enqueued (or suppressed by emergency-stop, which is still success)
+ *   2  — invalid usage / missing required arg
+ *   3  — internal failure (disk full, permissions, etc.) — caller should retry
+ *
+ * Examples:
+ *   # Launchd plist invokes this every 10 minutes:
+ *   node scripts/cadence/enqueue-cadence-tick.mjs backlog-executor --source=launchd
+ *
+ *   # Manual smoke-test:
+ *   node scripts/cadence/enqueue-cadence-tick.mjs inbox-processor --source=manual --metadata=note=smoke
+ */
+
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Resolve cadence-bus relative to this script so the same enqueue works
+// whether invoked from the framework repo (~/maestro/scripts/cadence/...)
+// or from a generated agent repo (~/<agent>/scripts/cadence/...).
+const { enqueueTick, BUS_VERSION } = await import(
+  resolve(__dirname, "..", "..", "lib", "cadence-bus.mjs")
+);
+
+function printHelp() {
+  process.stdout.write(`enqueue-cadence-tick — Maestro cadence bus producer
+
+Usage:
+  node scripts/cadence/enqueue-cadence-tick.mjs <cadence-name> [options]
+
+Options:
+  --source=<label>             launchd | manual | daemon | init-maestro | upgrade
+  --workflow=<path>            e.g. continuous/inbox-processor
+  --priority=<high|normal|low>
+  --correlation-id=<id>
+  --metadata=<key=value>       repeatable, or comma-separated pairs
+  --quiet                      suppress JSON output to stdout
+  --version                    print bus version and exit
+  --help, -h                   show this help
+
+Exits 0 on success (including emergency-stop suppression).
+`);
+}
+
+function parseMetadata(raw) {
+  // Accept --metadata=key=value, repeated, or --metadata=k1=v1,k2=v2.
+  const out = {};
+  for (const item of raw) {
+    if (!item) continue;
+    for (const pair of String(item).split(",")) {
+      const idx = pair.indexOf("=");
+      if (idx === -1) continue;
+      const k = pair.slice(0, idx).trim();
+      const v = pair.slice(idx + 1).trim();
+      if (k) out[k] = v;
+    }
+  }
+  return out;
+}
+
+function parseArgs(argv) {
+  const args = { cadence: null, source: "manual", metadata: [], quiet: false };
+  for (const arg of argv) {
+    if (arg === "--help" || arg === "-h") return { help: true };
+    if (arg === "--version") return { version: true };
+    if (arg === "--quiet") { args.quiet = true; continue; }
+    if (arg.startsWith("--source=")) { args.source = arg.slice("--source=".length); continue; }
+    if (arg.startsWith("--workflow=")) { args.workflow = arg.slice("--workflow=".length); continue; }
+    if (arg.startsWith("--priority=")) { args.priority = arg.slice("--priority=".length); continue; }
+    if (arg.startsWith("--correlation-id=")) { args.correlation_id = arg.slice("--correlation-id=".length); continue; }
+    if (arg.startsWith("--metadata=")) { args.metadata.push(arg.slice("--metadata=".length)); continue; }
+    if (arg.startsWith("--")) {
+      process.stderr.write(`enqueue-cadence-tick: unknown flag: ${arg}\n`);
+      return { invalid: true };
+    }
+    if (!args.cadence) { args.cadence = arg; continue; }
+    process.stderr.write(`enqueue-cadence-tick: unexpected positional arg: ${arg}\n`);
+    return { invalid: true };
+  }
+  return args;
+}
+
+const argv = process.argv.slice(2);
+const parsed = parseArgs(argv);
+
+if (parsed.help) {
+  printHelp();
+  process.exit(0);
+}
+if (parsed.version) {
+  process.stdout.write(`${BUS_VERSION}\n`);
+  process.exit(0);
+}
+if (parsed.invalid) {
+  printHelp();
+  process.exit(2);
+}
+if (!parsed.cadence) {
+  process.stderr.write("enqueue-cadence-tick: <cadence-name> required\n");
+  printHelp();
+  process.exit(2);
+}
+
+try {
+  const result = enqueueTick({
+    cadence: parsed.cadence,
+    source: parsed.source,
+    workflow: parsed.workflow,
+    priority: parsed.priority,
+    correlation_id: parsed.correlation_id,
+    metadata: parseMetadata(parsed.metadata),
+  });
+  if (!parsed.quiet) {
+    process.stdout.write(JSON.stringify({
+      ok: true,
+      id: result.id,
+      cadence: parsed.cadence,
+      path: result.path,
+      fallback_only: result.fallbackOnly,
+      skipped: result.skipped || null,
+    }) + "\n");
+  }
+  process.exit(0);
+} catch (err) {
+  process.stderr.write(`enqueue-cadence-tick: ${err.message}\n`);
+  process.exit(3);
+}