@north-light/crouter 0.3.318 → 0.3.320

package/dist/daemon/cron/passes.js

@@ -1,58 +1 @@
-import { randomUUID } from 'node:crypto';
-import { cronDaemonInstanceId, liveRunFor } from './live-runs.js';
-import { advanceCron, cancelCron, dueOverlapCrons, expiredIdleCrons, listCronRuns, recordCronRun, } from '../../core/canvas/crons.js';
-import { emitEvent } from '../../core/events/emit.js';
-import { nextSlotAfter } from '../../core/wake.js';
-/** Lead of a `cron_runs.delivered` string written by the overlap=skip pass.
- *  Matched (not just written) — see `latestRunIsSkip`. */
-const SKIP_MARKER = 'skipped (overlap=skip)';
-export function expireDueCrons(nowIso) {
-    for (const c of expiredIdleCrons(nowIso)) {
-        cancelCron(c.cron_id);
-        emitEvent({
-            level: 'info',
-            event: 'cron.expired',
-            fields: { cron_id: c.cron_id, name: c.name, expires_at: c.expires_at },
-        });
-    }
-}
-function latestRunIsSkip(cronId) {
-    return listCronRuns(cronId)[0]?.delivered?.startsWith(SKIP_MARKER) === true;
-}
-export function applyOverlapPolicies(now, nowIso) {
-    for (const c of dueOverlapCrons(nowIso)) {
-        if (c.overlap === 'queue')
-            continue;
-        if (c.overlap === 'skip') {
-            let nextFire;
-            try {
-                nextFire = nextSlotAfter(c.recur, new Date(now));
-            }
-            catch {
-                continue; // paused + escalated by the run path when it next fires
-            }
-            advanceCron(c.cron_id, nextFire);
-            // One marker per streak preserves real runs in the 20-entry ring.
-            if (!latestRunIsSkip(c.cron_id)) {
-                recordCronRun({
-                    run_id: randomUUID(),
-                    cron_id: c.cron_id,
-                    started: nowIso,
-                    finished: nowIso,
-                    duration_ms: 0,
-                    exit_code: null,
-                    stdout_head: null,
-                    stderr_head: null,
-                    delivered: `${SKIP_MARKER}: fire landed while the previous run was in flight (consecutive skips are not re-recorded until a run settles)`,
-                });
-            }
-            continue;
-        }
-        // replace
-        const live = liveRunFor(c.cron_id);
-        if (c.run_lease_owner === cronDaemonInstanceId && live !== undefined && !live.replaced) {
-            live.replaced = true;
-            live.kill();
-        }
-    }
-}
+var c=Object.defineProperty;var o=(n,e)=>c(n,"name",{value:e,configurable:!0});import{randomUUID as l}from"node:crypto";import{cronDaemonInstanceId as s,liveRunFor as a}from"./live-runs.js";import{advanceCron as u,cancelCron as p,dueOverlapCrons as f,expiredIdleCrons as _,listCronRuns as m,recordCronRun as v}from"../../core/canvas/crons.js";import{emitEvent as x}from"../../core/events/emit.js";import{nextSlotAfter as h}from"../../core/wake.js";const d="skipped (overlap=skip)";function y(n){for(const e of _(n))p(e.cron_id),x({level:"info",event:"cron.expired",fields:{cron_id:e.cron_id,name:e.name,expires_at:e.expires_at}})}o(y,"expireDueCrons");function C(n){return m(n)[0]?.delivered?.startsWith(d)===!0}o(C,"latestRunIsSkip");function A(n,e){for(const r of f(e)){if(r.overlap==="queue")continue;if(r.overlap==="skip"){let t;try{t=h(r.recur,new Date(n))}catch{continue}u(r.cron_id,t),C(r.cron_id)||v({run_id:l(),cron_id:r.cron_id,started:e,finished:e,duration_ms:0,exit_code:null,stdout_head:null,stderr_head:null,delivered:`${d}: fire landed while the previous run was in flight (consecutive skips are not re-recorded until a run settles)`});continue}const i=a(r.cron_id);r.run_lease_owner===s&&i!==void 0&&!i.replaced&&(i.replaced=!0,i.kill())}}o(A,"applyOverlapPolicies");export{A as applyOverlapPolicies,y as expireDueCrons};

package/dist/daemon/cron/settle.js

@@ -1,61 +1 @@
-import { consumeCron, recordCronRunLocked, releaseCronRunLease, } from '../../core/canvas/crons.js';
-import { withCanvasWrite } from '../../core/canvas/db.js';
-import { enqueueExternalAction, enqueueNodeMail } from '../../core/feed/messages.js';
-import { disposeSettledRun } from './disposition.js';
-function occurrenceStaysOwed(lease) {
-    return typeof lease === 'object' && (lease.kind === 'park' || lease.kind === 'redue');
-}
-export async function settleRun(c, input) {
-    const { outOfBand, outcome, record, lease } = input;
-    let delivered;
-    let paused;
-    let obligation;
-    if (outcome.kind === 'disposed') {
-        const disposition = await disposeSettledRun(c, outcome.ctx, outOfBand, outcome.selfCanceled ?? false);
-        delivered = disposition.delivered;
-        paused = disposition.paused;
-        obligation = disposition.obligation;
-    }
-    else {
-        delivered = outcome.delivered;
-        paused = outcome.paused ?? false;
-    }
-    const written = withCanvasWrite((db) => {
-        if (obligation !== undefined) {
-            if (obligation.kind === 'node') {
-                const enqueued = enqueueNodeMail(obligation.destinationNodeId, {
-                    kind: 'message', label: obligation.label, senderNodeId: obligation.senderNodeId,
-                    bodyJson: { body: obligation.stdout }, urgency: obligation.urgency, wake: 1,
-                    idempotencyKey: record.runId,
-                });
-                delivered = `delivered: ${enqueued.deliveryId}`;
-            }
-            else if (obligation.kind === 'external') {
-                const enqueued = enqueueExternalAction({
-                    destinationId: obligation.destinationId, adapter: obligation.adapter,
-                    bodyJson: obligation.bodyJson, idempotencyKey: record.runId,
-                });
-                delivered = `delivered: ${enqueued.deliveryId}`;
-            }
-        }
-        const entry = {
-            run_id: record.runId,
-            cron_id: c.cron_id,
-            started: record.startedAtIso,
-            finished: new Date(record.finishedAtMs).toISOString(),
-            duration_ms: record.durationMs,
-            exit_code: record.exitCode,
-            stdout_head: record.stdoutHead,
-            stderr_head: record.stderrHead,
-            delivered,
-        };
-        recordCronRunLocked(db, entry);
-        return entry;
-    });
-    if (lease !== 'none')
-        releaseCronRunLease(c.cron_id, lease === 'release' ? undefined : lease);
-    // Retain out-of-band, paused, and held rows; their occurrence is not spent.
-    if (!outOfBand && c.recur == null && !paused && !occurrenceStaysOwed(lease))
-        consumeCron(c.cron_id);
-    return written;
-}
+var y=Object.defineProperty;var a=(d,s)=>y(d,"name",{value:s,configurable:!0});import{consumeCron as m,recordCronRunLocked as I,releaseCronRunLease as b}from"../../core/canvas/crons.js";import{withCanvasWrite as k}from"../../core/canvas/db.js";import{enqueueExternalAction as _,enqueueNodeMail as v}from"../../core/feed/messages.js";import{disposeSettledRun as g}from"./disposition.js";function q(d){return typeof d=="object"&&(d.kind==="park"||d.kind==="redue")}a(q,"occurrenceStaysOwed");async function R(d,s){const{outOfBand:l,outcome:t,record:n,lease:i}=s;let o,u,e;if(t.kind==="disposed"){const r=await g(d,t.ctx,l,t.selfCanceled??!1);o=r.delivered,u=r.paused,e=r.obligation}else o=t.delivered,u=t.paused??!1;const f=k(r=>{e!==void 0&&(e.kind==="node"?o=`delivered: ${v(e.destinationNodeId,{kind:"message",label:e.label,senderNodeId:e.senderNodeId,bodyJson:{body:e.stdout},urgency:e.urgency,wake:1,idempotencyKey:n.runId}).deliveryId}`:e.kind==="external"&&(o=`delivered: ${_({destinationId:e.destinationId,adapter:e.adapter,bodyJson:e.bodyJson,idempotencyKey:n.runId}).deliveryId}`));const c={run_id:n.runId,cron_id:d.cron_id,started:n.startedAtIso,finished:new Date(n.finishedAtMs).toISOString(),duration_ms:n.durationMs,exit_code:n.exitCode,stdout_head:n.stdoutHead,stderr_head:n.stderrHead,delivered:o};return I(r,c),c});return i!=="none"&&b(d.cron_id,i==="release"?void 0:i),!l&&d.recur==null&&!u&&!q(i)&&m(d.cron_id),f}a(R,"settleRun");export{R as settleRun};

package/dist/daemon/cron/sinks.js

@@ -1,59 +1,2 @@
-import { newNodeId } from '../../core/runtime/nodes.js';
-import { getNode } from '../../core/canvas/canvas.js';
-import { parseCronSink } from '../../core/canvas/crons.js';
-import { hasNoNaturalCycle } from '../../core/runtime/revive-all.js';
-import { isParked } from '../../core/runtime/lifecycle.js';
-import { cronWakeOrigin } from '../../core/runtime/bearings.js';
-import { resolveLiveProfile, resolveLiveProfileName } from './armed-context.js';
-/** Resolve a completed run into a durable obligation. No sink effect happens here. */
-export function resolveCronSink(c, runId, stdout) {
-    const sink = parseCronSink(c.sink);
-    if (sink === null)
-        return { kind: 'none', delivered: 'no sink armed — nothing delivered' };
-    if (sink.kind === 'node') {
-        const meta = getNode(sink.node);
-        if (meta === null)
-            throw new Error(`node sink ${sink.node} is gone`);
-        if (hasNoNaturalCycle(meta) && !isParked(meta)) {
-            throw new Error(`node sink ${sink.node} has no natural cycle ahead (done or finalized)`);
-        }
-        return {
-            kind: 'node',
-            destinationNodeId: sink.node,
-            senderNodeId: c.created_by !== null && getNode(c.created_by) !== null ? c.created_by : null,
-            label: `⏰ cron ${c.name}`,
-            stdout,
-            urgency: c.tier,
-        };
-    }
-    if (sink.kind === 'spawn') {
-        const creatorAlive = c.created_by !== null && getNode(c.created_by) !== null;
-        const prompt = [
-            `Scheduled cron "${c.name}" (${c.cron_id}) fired and delivered its output to you as your kickoff.`,
-            '',
-            '## Command output',
-            '',
-            stdout,
-        ].join('\n');
-        return {
-            kind: 'external',
-            destinationId: 'cron_spawn',
-            adapter: {
-                adapter: 'cron_spawn', cronId: c.cron_id, nodeId: newNodeId(), kind: sink.spawn, cwd: c.cwd,
-                ...(creatorAlive ? { parent: c.created_by, root: false } : { parent: null, root: true, rootLifecycle: 'terminal' }),
-                profile: resolveLiveProfile(c), wakeOrigin: cronWakeOrigin(c, 'node_birth'), prompt,
-            },
-            bodyJson: { runId, stdout },
-        };
-    }
-    return {
-        kind: 'external',
-        destinationId: 'cron_human',
-        adapter: {
-            adapter: 'cron_human', cronId: c.cron_id, requestId: newNodeId(), title: `⏰ cron ${c.name}`,
-            summary: `Scheduled cron "${c.name}" delivered output for your attention.`, sessionName: `cron ${c.name} (${c.cron_id})`,
-            profileName: resolveLiveProfileName(c) ?? null,
-        },
-        bodyJson: { runId, stdout },
-    };
-}
+var m=Object.defineProperty;var t=(e,o)=>m(e,"name",{value:o,configurable:!0});import{newNodeId as a}from"../../core/runtime/nodes.js";import{getNode as i}from"../../core/canvas/canvas.js";import{parseCronSink as s}from"../../core/canvas/crons.js";import{hasNoNaturalCycle as u}from"../../core/runtime/revive-all.js";import{isParked as p}from"../../core/runtime/lifecycle.js";import{cronWakeOrigin as f}from"../../core/runtime/bearings.js";import{resolveLiveProfile as c,resolveLiveProfileName as k}from"./armed-context.js";function I(e,o,d){const n=s(e.sink);if(n===null)return{kind:"none",delivered:"no sink armed \u2014 nothing delivered"};if(n.kind==="node"){const r=i(n.node);if(r===null)throw new Error(`node sink ${n.node} is gone`);if(u(r)&&!p(r))throw new Error(`node sink ${n.node} has no natural cycle ahead (done or finalized)`);return{kind:"node",destinationNodeId:n.node,senderNodeId:e.created_by!==null&&i(e.created_by)!==null?e.created_by:null,label:`\u23F0 cron ${e.name}`,stdout:d,urgency:e.tier}}if(n.kind==="spawn"){const r=e.created_by!==null&&i(e.created_by)!==null,l=[`Scheduled cron "${e.name}" (${e.cron_id}) fired and delivered its output to you as your kickoff.`,"","## Command output","",d].join(`
+`);return{kind:"external",destinationId:"cron_spawn",adapter:{adapter:"cron_spawn",cronId:e.cron_id,nodeId:a(),kind:n.spawn,cwd:e.cwd,...r?{parent:e.created_by,root:!1}:{parent:null,root:!0,rootLifecycle:"terminal"},profile:c(e),wakeOrigin:f(e,"node_birth"),prompt:l},bodyJson:{runId:o,stdout:d}}}return{kind:"external",destinationId:"cron_human",adapter:{adapter:"cron_human",cronId:e.cron_id,requestId:a(),title:`\u23F0 cron ${e.name}`,summary:`Scheduled cron "${e.name}" delivered output for your attention.`,sessionName:`cron ${e.name} (${e.cron_id})`,profileName:k(e)??null},bodyJson:{runId:o,stdout:d}}}t(I,"resolveCronSink");export{I as resolveCronSink};

package/dist/daemon/cron-run.js

@@ -1,405 +1 @@
-// src/daemon/cron-run.ts — the daemon-owned cron run executor and the entry
-// surface of the cron lane: subprocess spawn/capture/timeout/lease mechanics
-// for due `crons` rows (the cron-spec scheduler), and the tick pass that fires
-// them. The collaborators it composes live in `cron/`: arm-time context,
-// output capture, the live-run registry, the pre-run passes, stale-lease
-// recovery, the owed-gate decision, delivery sinks,
-// escalation, output disposition, and the one settle tail.
-//
-// A cron RUN is the enactment — there is no separate action to fire —
-// so a recurrence advances `fire_at` BEFORE the run (crash-safe: a crash
-// mid-run never re-fires a settled slot) while a one-shot row is deleted only
-// AFTER its run settles, so the run can still be observed while in flight.
-//
-// SETTLE RULES (the cron spec's output disposition + failure sections):
-//   silent      — record only, never deliver, never escalate.
-//   on-failure  — (default) no success delivery; a failure pauses the cron and
-//                 spawns a terminal escalation node to deal with it.
-//   always      — stdout becomes a delivery every run, at the cron's tier.
-//   on-change   — deliver only when stdout's hash differs from the previous
-//                 run's (including the very first run); the hash is updated
-//                 after EVERY settled run, delivered or not.
-// A FAILURE is: timeout kill, process error, nonzero exit, or an undeliverable
-// sink (target node gone/terminal, spawn threw, human submit threw). Every
-// disposition except `silent` escalates: pause + spawn — pausing is the
-// natural dedup (a paused row never refires). An out-of-band run (`cron run`)
-// never escalates or pauses: the invoker sees the result directly.
-// Those rules are enforced in `cron/disposition.ts` and `cron/settle.ts`; this
-// file only decides WHICH outcome a closed child settled into.
-//
-// Fire-and-forget contract: runDueCrons
-// NEVER awaits a subprocess in the tick — it kicks each child off
-// synchronously and returns one settlement promise per admitted run, each
-// resolving only after its subprocess has closed and its durable
-// record/lease/consume transition is written. The daemon tick registers those
-// promises for graceful-teardown drain but never blocks on a slow run.
-import { spawn } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { CRON_DEATH_POLL_MS, CRON_KILL_GRACE_MS, CRON_OUTPUT_HEAD_BYTES, EMPTY_STDOUT_SHA256, newHeadCapture, } from './cron/capture.js';
-import { clearLiveRun, cronDaemonInstanceId, liveRunFor, registerLiveRun } from './cron/live-runs.js';
-import { buildArmedRunContext } from './cron/armed-context.js';
-import { decideHeldSettle, EXIT_HELD, HELD_DELIVERED } from './cron/held.js';
-import { settleRun } from './cron/settle.js';
-import { applyOverlapPolicies, expireDueCrons, } from './cron/passes.js';
-import { dueClockCrons, acquireCronRunLease, advanceCron, setCronState, } from '../core/canvas/crons.js';
-import { captureTeardownSnapshot, isAnyPidAlive, killProcessTreePids } from '../core/canvas/pid.js';
-import { emitEvent } from '../core/events/emit.js';
-import { nextSlotAfter } from '../core/wake.js';
-import { resolveAdmittedHostCommand } from '../core/runtime/spawn-env.js';
-// The entry surface the daemon tick, the API handlers, and the cron tests
-// import: the executor and tick pass below, plus the collaborators they were
-// decomposed into.
-export { CRON_OUTPUT_HEAD_BYTES } from './cron/capture.js';
-export { cronDaemonInstanceId, markSelfCanceledCronRun } from './cron/live-runs.js';
-export { recoverStaleCronLeases } from './cron/lease-recovery.js';
-/** Settle one closed child: choose the outcome (replaced short-circuit, owed
- *  gate, or the full disposition), then hand it to the one settle tail. */
-async function settleClosedRun(c, run) {
-    const { runId, outOfBand, startedAtIso, finishedAtMs, code, timedOut, processError } = run;
-    // The owed-gate branch (exit 75): a peer of the wasReplaced short-circuit —
-    // skip disposition entirely (no delivery, no escalation, no pause, no
-    // on-change hash, no one-shot consumption) and settle the row's held state
-    // with the lease release instead. The exclusions are deliberate: a manual
-    // `cron run` must not change scheduling state; a timeout-killed or
-    // launch-failed run is a real failure even if a stray 75 surfaces; a replaced
-    // or self-canceled run's existing short-circuits win.
-    const heldDeferred = !outOfBand &&
-        !timedOut &&
-        processError == null &&
-        code === EXIT_HELD &&
-        !run.wasReplaced &&
-        !run.wasSelfCanceled;
-    let outcome;
-    let lease;
-    if (run.wasReplaced) {
-        // Record it, no disposition, no escalation, and leave `held` untouched
-        // (the gate is still unresolved).
-        outcome = { kind: 'stated', delivered: 'replaced (overlap=replace)' };
-        lease = 'release';
-    }
-    else if (heldDeferred) {
-        // The occurrence is NOT spent — even a one-shot is retained (like a paused
-        // escalated one-shot is). Park/re-due and the lease release are one write.
-        // A row canceled mid-run has nothing to settle.
-        outcome = { kind: 'stated', delivered: HELD_DELIVERED };
-        lease = decideHeldSettle(c, startedAtIso, finishedAtMs) ?? 'release';
-    }
-    else {
-        outcome = {
-            kind: 'disposed',
-            ctx: {
-                runId,
-                startedAtIso,
-                exitCode: timedOut ? -1 : code,
-                timedOut,
-                runTimeoutS: c.run_timeout_s,
-                processErrorMessage: processError != null ? processError.message : null,
-                stdoutHead: run.stdoutHead,
-                stdoutSha256: run.stdoutSha256,
-                stderrHead: run.stderrHead,
-            },
-            selfCanceled: run.wasSelfCanceled,
-        };
-        // An ordinary scheduled disposition settlement resolves the gate, so it
-        // unparks a held row; an out-of-band run leaves `held` untouched.
-        lease = outOfBand ? 'release' : { kind: 'clear' };
-    }
-    return settleRun(c, {
-        outOfBand,
-        outcome,
-        record: {
-            runId,
-            startedAtIso,
-            finishedAtMs,
-            durationMs: finishedAtMs - run.startedAtMs,
-            exitCode: timedOut ? -1 : code,
-            stdoutHead: run.stdoutHead === '' ? null : run.stdoutHead,
-            stderrHead: processError != null
-                ? `run process error: ${processError.message}`.slice(0, CRON_OUTPUT_HEAD_BYTES)
-                : run.stderrHead === ''
-                    ? null
-                    : run.stderrHead,
-        },
-        lease,
-    });
-}
-/** Settle a run whose child never existed — the arm-time context was corrupt,
- *  or `spawn` threw synchronously — so no lease was ever taken. Settled through
- *  the failure path so a broken cron pauses + escalates (and keeps its one-shot)
- *  instead of refiring every tick. `lead` names which of the two happened. */
-function settleUnspawnedRun(c, run, lead, err) {
-    const finishedAtMs = Date.now();
-    const stderrHead = `${lead}: ${err.message}`.slice(0, CRON_OUTPUT_HEAD_BYTES);
-    return settleRun(c, {
-        outOfBand: run.outOfBand,
-        outcome: {
-            kind: 'disposed',
-            ctx: {
-                runId: run.runId,
-                startedAtIso: run.startedAtIso,
-                exitCode: null,
-                timedOut: false,
-                runTimeoutS: c.run_timeout_s,
-                processErrorMessage: err.message,
-                stdoutHead: '',
-                stdoutSha256: EMPTY_STDOUT_SHA256,
-                stderrHead,
-            },
-        },
-        record: {
-            runId: run.runId,
-            startedAtIso: run.startedAtIso,
-            finishedAtMs,
-            durationMs: finishedAtMs - run.startedAtMs,
-            exitCode: null,
-            stdoutHead: null,
-            stderrHead,
-        },
-        lease: 'none',
-    });
-}
-/** Settle the schedule BEFORE the run: a recurrence advances to its next slot
- *  now, so a crash mid-run never re-fires this slot (the lease guards the
- *  intra-life overlap; the advanced fire_at guards the crash window).
- *
- *  Returns the process error to hand `close` when the recurrence cannot be
- *  parsed, else null. That row can never be scheduled again as written — but
- *  DELETING it would destroy the user's config AND its whole run history with
- *  no record and no escalation, the one outcome the spec has no vocabulary for.
- *  It takes the failure path instead, so the row PAUSES and an escalation node
- *  arrives holding the parse error. `fire_at` is deliberately left past-due: a
- *  paused row is not due, and once someone fixes the recurrence a `cron resume`
- *  fires immediately. */
-function advanceRecurrence(c, startedAtMs) {
-    let nextFire;
-    try {
-        nextFire = nextSlotAfter(c.recur, new Date(startedAtMs));
-    }
-    catch (err) {
-        emitEvent({
-            level: 'error',
-            event: 'cron.recur.unparseable',
-            error: err,
-            fields: { cron_id: c.cron_id, name: c.name, recur: c.recur },
-        });
-        // Pause HERE, not only via the escalation: `fire_at` was never advanced, so
-        // an on_output='silent' row (whose failure path never escalates and never
-        // pauses) would otherwise re-fire this unschedulable command on every
-        // single tick, forever.
-        setCronState(c.cron_id, 'paused');
-        return new Error(`unparseable recurrence ${JSON.stringify(c.recur)}: ${err.message} — this cron cannot be rescheduled until its recurrence is fixed (\`crtr cron cancel\` and re-arm it), so it has been paused.`);
-    }
-    advanceCron(c.cron_id, nextFire);
-    return null;
-}
-/** Kick off ONE cron run and return its settlement promise, resolving with
- *  the settled run record (null = the idle→running lease was lost, or the row
- *  was quarantined — nothing was recorded by THIS call). The subprocess
- *  starts synchronously (spawn + lease + recurrence advance happen before
- *  this returns); the promise resolves only after the child has CLOSED and
- *  every durable transition — disposition/delivery, run record, lease
- *  release, one-shot consumption — is written.
- *
- *  `outOfBand` (the `cron run` verb) takes the same lease but does NOT
- *  advance a recurrence, does NOT consume a one-shot, and never
- *  escalates/pauses — it delivers per disposition and hands the record back
- *  to the invoker. */
-export function executeCron(c, opts) {
-    const { outOfBand } = opts;
-    return new Promise((resolve, reject) => {
-        const runId = randomUUID();
-        const startedAtMs = Date.now();
-        const startedAtIso = new Date(startedAtMs).toISOString();
-        const unspawned = { runId, outOfBand, startedAtIso, startedAtMs };
-        // The context the run was ARMED under, built before anything is spawned: a
-        // corrupt snapshot must not execute the command under an environment or
-        // profile nobody armed. It settles through the same no-lease failure path a
-        // synchronous spawn failure takes.
-        let env;
-        try {
-            ({ env } = buildArmedRunContext(c, runId));
-        }
-        catch (err) {
-            settleUnspawnedRun(c, unspawned, 'run could not be armed', err).then(resolve, reject);
-            return;
-        }
-        let child;
-        try {
-            child = spawn(resolveAdmittedHostCommand('bash', env, c.cwd), ['-c', c.command], {
-                cwd: c.cwd,
-                env,
-                detached: true, // own process group — killProcessGroup(-pid) reaps the whole tree
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-        }
-        catch (err) {
-            settleUnspawnedRun(c, unspawned, 'run failed to spawn', err).then(resolve, reject);
-            return;
-        }
-        let settled = false;
-        let timer;
-        let killTimer;
-        let deathTimer;
-        let closeCode;
-        let killed = false;
-        let timedOut = false;
-        let leaseLost = false;
-        let processError = null;
-        // Output capture. The head is accumulated as raw BYTES and decoded ONCE at
-        // close: decoding per chunk and slicing by `String.length` capped in UTF-16
-        // code units despite the `_BYTES` name, and split any multi-byte sequence
-        // straddling a chunk boundary into replacement characters. The change-
-        // detection hash runs over the FULL stdout stream rather than the head, so
-        // output differing only past the cap is still seen to have changed (it used
-        // to report "unchanged" forever).
-        const stdout = newHeadCapture();
-        const stderr = newHeadCapture();
-        const stdoutHash = createHash('sha256');
-        child.stdout?.on('data', (chunk) => {
-            stdoutHash.update(chunk);
-            stdout.take(chunk);
-        });
-        child.stderr?.on('data', (chunk) => {
-            stderr.take(chunk);
-        });
-        let teardown;
-        const settleClosedChild = (code) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timer !== undefined)
-                clearTimeout(timer);
-            if (killTimer !== undefined)
-                clearTimeout(killTimer);
-            if (deathTimer !== undefined)
-                clearTimeout(deathTimer);
-            const stdoutHead = stdout.decode();
-            const stderrHead = stderr.decode();
-            const live = liveRunFor(c.cron_id);
-            const wasReplaced = live !== undefined && live.runId === runId && live.replaced;
-            const wasSelfCanceled = live !== undefined && live.runId === runId && live.selfCanceled;
-            clearLiveRun(c.cron_id, runId);
-            if (leaseLost) {
-                // Lost the idle→running race (explicit cancel or another daemon's
-                // lease) — whoever won owns the row's disposition; abandon silently.
-                resolve(null);
-                return;
-            }
-            settleClosedRun(c, {
-                runId,
-                outOfBand,
-                startedAtIso,
-                startedAtMs,
-                finishedAtMs: Date.now(),
-                code,
-                timedOut,
-                processError,
-                stdoutHead,
-                stderrHead,
-                stdoutSha256: stdoutHash.digest('hex'),
-                wasReplaced,
-                wasSelfCanceled,
-            }).then(resolve, reject);
-        };
-        const awaitTeardownDeath = () => {
-            if (teardown === undefined || !isAnyPidAlive(teardown.tree)) {
-                if (closeCode !== undefined)
-                    settleClosedChild(closeCode);
-                return;
-            }
-            deathTimer = setTimeout(awaitTeardownDeath, CRON_DEATH_POLL_MS);
-        };
-        const killWithEscalation = (pid) => {
-            teardown ??= captureTeardownSnapshot(pid, null);
-            killProcessTreePids(teardown.tree, 'SIGTERM', teardown.identities);
-            if (killTimer === undefined) {
-                killTimer = setTimeout(() => {
-                    if (isAnyPidAlive(teardown.tree))
-                        killProcessTreePids(teardown.tree, 'SIGKILL', teardown.identities);
-                    killed = true;
-                    if (closeCode !== undefined)
-                        awaitTeardownDeath();
-                }, CRON_KILL_GRACE_MS);
-                killTimer.unref?.();
-            }
-        };
-        // A signal, not settlement: 'close' always follows 'error'.
-        child.on('error', (err) => {
-            if (processError == null)
-                processError = err;
-        });
-        child.on('close', (code) => {
-            if (settled)
-                return;
-            closeCode = code;
-            if (timer !== undefined)
-                clearTimeout(timer);
-            if (teardown !== undefined && isAnyPidAlive(teardown.tree)) {
-                if (killed)
-                    awaitTeardownDeath();
-                return;
-            }
-            settleClosedChild(code);
-        });
-        if (child.pid == null ||
-            !acquireCronRunLease(c.cron_id, cronDaemonInstanceId, child.pid, startedAtIso, outOfBand)) {
-            if (child.pid != null)
-                killWithEscalation(child.pid);
-            leaseLost = true;
-            return; // 'close' above performs the actual settlement.
-        }
-        registerLiveRun(c.cron_id, {
-            runId,
-            replaced: false,
-            selfCanceled: false,
-            kill: () => {
-                if (child.pid != null)
-                    killWithEscalation(child.pid);
-            },
-        });
-        // An out-of-band run never touches the schedule.
-        if (!outOfBand && c.recur != null) {
-            const recurError = advanceRecurrence(c, startedAtMs);
-            if (recurError !== null) {
-                // Kill the just-started run and hand `close` a process error, so it
-                // settles through the ordinary failure path.
-                processError = recurError;
-                killWithEscalation(child.pid);
-                return;
-            }
-        }
-        timer = setTimeout(() => {
-            if (settled)
-                return;
-            timedOut = true;
-            killWithEscalation(child.pid);
-            // Signal only — 'close' above performs the actual settlement.
-        }, c.run_timeout_s * 1000);
-        timer.unref?.();
-    });
-}
-/** The daemon's cron pass: expire clock-bounded rows, apply overlap policies,
- *  then kick off every due active idle cron. Each child starts synchronously
- *  but is NEVER awaited in the tick; returns one settlement promise per
- *  admitted run.
- *
- *  A run that launches or revives a node is admitted unconditionally: the
- *  broker slot ledger is the one admission gate, so such a run's node is born
- *  or revived frozen at the cap and the node-lifecycle tick starts it when a
- *  slot frees. The cron itself always fires and settles. */
-export function runDueCrons(now, options = {}) {
-    const nowIso = new Date(now).toISOString();
-    expireDueCrons(nowIso);
-    applyOverlapPolicies(now, nowIso);
-    const settlements = [];
-    for (const c of dueClockCrons(nowIso)) {
-        const settlement = executeCron(c, { outOfBand: false }).then(() => undefined);
-        settlements.push(settlement);
-        options.register?.(settlement);
-    }
-    // Backstop: even an unregistered settlement's rejection must never surface
-    // as a process-level unhandled rejection.
-    for (const s of settlements)
-        void s.catch(() => { });
-    return settlements;
-}
+var $=Object.defineProperty;var l=(e,t)=>$(e,"name",{value:t,configurable:!0});import{spawn as G}from"node:child_process";import{createHash as Y,randomUUID as F}from"node:crypto";import{CRON_DEATH_POLL_MS as K,CRON_KILL_GRACE_MS as q,CRON_OUTPUT_HEAD_BYTES as L,EMPTY_STDOUT_SHA256 as J,newHeadCapture as M}from"./cron/capture.js";import{clearLiveRun as V,cronDaemonInstanceId as W,liveRunFor as X,registerLiveRun as z}from"./cron/live-runs.js";import{buildArmedRunContext as Q}from"./cron/armed-context.js";import{decideHeldSettle as Z,EXIT_HELD as j,HELD_DELIVERED as ee}from"./cron/held.js";import{settleRun as k}from"./cron/settle.js";import{applyOverlapPolicies as te,expireDueCrons as re}from"./cron/passes.js";import{dueClockCrons as ne,acquireCronRunLease as de,advanceCron as oe,setCronState as se}from"../core/canvas/crons.js";import{captureTeardownSnapshot as ie,isAnyPidAlive as A,killProcessTreePids as P}from"../core/canvas/pid.js";import{emitEvent as ae}from"../core/events/emit.js";import{nextSlotAfter as le}from"../core/wake.js";import{resolveAdmittedHostCommand as ue}from"../core/runtime/spawn-env.js";import{CRON_OUTPUT_HEAD_BYTES as Le}from"./cron/capture.js";import{cronDaemonInstanceId as ke,markSelfCanceledCronRun as Pe}from"./cron/live-runs.js";import{recoverStaleCronLeases as be}from"./cron/lease-recovery.js";async function ce(e,t){const{runId:s,outOfBand:n,startedAtIso:i,finishedAtMs:o,code:c,timedOut:f,processError:m}=t,h=!n&&!f&&m==null&&c===j&&!t.wasReplaced&&!t.wasSelfCanceled;let d,u;return t.wasReplaced?(d={kind:"stated",delivered:"replaced (overlap=replace)"},u="release"):h?(d={kind:"stated",delivered:ee},u=Z(e,i,o)??"release"):(d={kind:"disposed",ctx:{runId:s,startedAtIso:i,exitCode:f?-1:c,timedOut:f,runTimeoutS:e.run_timeout_s,processErrorMessage:m!=null?m.message:null,stdoutHead:t.stdoutHead,stdoutSha256:t.stdoutSha256,stderrHead:t.stderrHead},selfCanceled:t.wasSelfCanceled},u=n?"release":{kind:"clear"}),k(e,{outOfBand:n,outcome:d,record:{runId:s,startedAtIso:i,finishedAtMs:o,durationMs:o-t.startedAtMs,exitCode:f?-1:c,stdoutHead:t.stdoutHead===""?null:t.stdoutHead,stderrHead:m!=null?`run process error: ${m.message}`.slice(0,L):t.stderrHead===""?null:t.stderrHead},lease:u})}l(ce,"settleClosedRun");function U(e,t,s,n){const i=Date.now(),o=`${s}: ${n.message}`.slice(0,L);return k(e,{outOfBand:t.outOfBand,outcome:{kind:"disposed",ctx:{runId:t.runId,startedAtIso:t.startedAtIso,exitCode:null,timedOut:!1,runTimeoutS:e.run_timeout_s,processErrorMessage:n.message,stdoutHead:"",stdoutSha256:J,stderrHead:o}},record:{runId:t.runId,startedAtIso:t.startedAtIso,finishedAtMs:i,durationMs:i-t.startedAtMs,exitCode:null,stdoutHead:null,stderrHead:o},lease:"none"})}l(U,"settleUnspawnedRun");function fe(e,t){let s;try{s=le(e.recur,new Date(t))}catch(n){return ae({level:"error",event:"cron.recur.unparseable",error:n,fields:{cron_id:e.cron_id,name:e.name,recur:e.recur}}),se(e.cron_id,"paused"),new Error(`unparseable recurrence ${JSON.stringify(e.recur)}: ${n.message} \u2014 this cron cannot be rescheduled until its recurrence is fixed (\`crtr cron cancel\` and re-arm it), so it has been paused.`)}return oe(e.cron_id,s),null}l(fe,"advanceRecurrence");function me(e,t){const{outOfBand:s}=t;return new Promise((n,i)=>{const o=F(),c=Date.now(),f=new Date(c).toISOString(),m={runId:o,outOfBand:s,startedAtIso:f,startedAtMs:c};let h;try{({env:h}=Q(e,o))}catch(r){U(e,m,"run could not be armed",r).then(n,i);return}let d;try{d=G(ue("bash",h,e.cwd),["-c",e.command],{cwd:e.cwd,env:h,detached:!0,stdio:["ignore","pipe","pipe"]})}catch(r){U(e,m,"run failed to spawn",r).then(n,i);return}let u=!1,p,_,H,I,E=!1,D=!1,O=!1,S=null;const R=M(),x=M(),v=Y("sha256");d.stdout?.on("data",r=>{v.update(r),R.take(r)}),d.stderr?.on("data",r=>{x.take(r)});let a;const g=l(r=>{if(u)return;u=!0,p!==void 0&&clearTimeout(p),_!==void 0&&clearTimeout(_),H!==void 0&&clearTimeout(H);const b=R.decode(),y=x.decode(),C=X(e.cron_id),B=C!==void 0&&C.runId===o&&C.replaced,N=C!==void 0&&C.runId===o&&C.selfCanceled;if(V(e.cron_id,o),O){n(null);return}ce(e,{runId:o,outOfBand:s,startedAtIso:f,startedAtMs:c,finishedAtMs:Date.now(),code:r,timedOut:D,processError:S,stdoutHead:b,stderrHead:y,stdoutSha256:v.digest("hex"),wasReplaced:B,wasSelfCanceled:N}).then(n,i)},"settleClosedChild"),T=l(()=>{if(a===void 0||!A(a.tree)){I!==void 0&&g(I);return}H=setTimeout(T,K)},"awaitTeardownDeath"),w=l(r=>{a??=ie(r,null),P(a.tree,"SIGTERM",a.identities),_===void 0&&(_=setTimeout(()=>{A(a.tree)&&P(a.tree,"SIGKILL",a.identities),E=!0,I!==void 0&&T()},q),_.unref?.())},"killWithEscalation");if(d.on("error",r=>{S==null&&(S=r)}),d.on("close",r=>{if(!u){if(I=r,p!==void 0&&clearTimeout(p),a!==void 0&&A(a.tree)){E&&T();return}g(r)}}),d.pid==null||!de(e.cron_id,W,d.pid,f,s)){d.pid!=null&&w(d.pid),O=!0;return}if(z(e.cron_id,{runId:o,replaced:!1,selfCanceled:!1,kill:l(()=>{d.pid!=null&&w(d.pid)},"kill")}),!s&&e.recur!=null){const r=fe(e,c);if(r!==null){S=r,w(d.pid);return}}p=setTimeout(()=>{u||(D=!0,w(d.pid))},e.run_timeout_s*1e3),p.unref?.()})}l(me,"executeCron");function xe(e,t={}){const s=new Date(e).toISOString();re(s),te(e,s);const n=[];for(const i of ne(s)){const o=me(i,{outOfBand:!1}).then(()=>{});n.push(o),t.register?.(o)}for(const i of n)i.catch(()=>{});return n}l(xe,"runDueCrons");export{Le as CRON_OUTPUT_HEAD_BYTES,ke as cronDaemonInstanceId,me as executeCron,Pe as markSelfCanceledCronRun,be as recoverStaleCronLeases,xe as runDueCrons};

package/dist/daemon/crtrd-cli.js

@@ -1,23 +1 @@
-// crtrd entry point — spawned detached by `crtr sys daemon start` and by bin/crtrd.
-// Startup is awaited so a rejected startup/cleanup aggregate reaches Node's
-// raw fatal boundary; a winning daemon stays alive through its scheduled loop.
-import '../suppress-experimental-warnings.js';
-import { runDaemon } from './crtrd.js';
-import { envCrtrdTcp } from '../shared/env.js';
-/** Extract `--tcp <host:port>` (or `--tcp=<host:port>`) from argv; falls back to
- *  `CRTRD_TCP`. Absent → unix socket only (§4.1). */
-function parseTcpArg(argv) {
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        if (arg === '--tcp')
-            return argv[i + 1];
-        if (arg !== undefined && arg.startsWith('--tcp='))
-            return arg.slice('--tcp='.length);
-    }
-    return envCrtrdTcp();
-}
-function parsePrepareArg(argv) {
-    return argv.includes('--prepare');
-}
-const argv = process.argv.slice(2);
-await runDaemon({ tcp: parseTcpArg(argv), prepare: parsePrepareArg(argv) });
+var c=Object.defineProperty;var n=(r,e)=>c(r,"name",{value:e,configurable:!0});import"../suppress-experimental-warnings.js";import{runDaemon as i}from"./crtrd.js";import{envCrtrdTcp as o}from"../shared/env.js";function s(r){for(let e=0;e<r.length;e++){const t=r[e];if(t==="--tcp")return r[e+1];if(t!==void 0&&t.startsWith("--tcp="))return t.slice(6)}return o()}n(s,"parseTcpArg");function a(r){return r.includes("--prepare")}n(a,"parsePrepareArg");const p=process.argv.slice(2);await i({tcp:s(p),prepare:a(p)});