@north-light/crouter 0.3.311 → 0.3.313

package/dist/daemon/control.d.ts

@@ -1,3 +1,4 @@
+import type { DaemonAdmitDTO, StartupPhaseDTO } from '../api/dto/health.js';
 /** What crtrd exposes to handlers that act on the daemon process itself. */
 export interface DaemonControl {
     /** This daemon's epoch id. */
@@ -14,6 +15,23 @@ export interface DaemonControl {
     };
     /** Register daemon-owned post-response work for shutdown draining. */
     registerDetached(work: Promise<void>): void;
+    /** Null only after normal startup completed. */
+    startupBlock(): {
+        phase: Exclude<StartupPhaseDTO, 'ready'>;
+        message: string;
+        blockerPaths: readonly string[];
+    } | null;
+    /** Admit normal work after the daemon has prepared its storage. */
+    admitStartup(): Promise<DaemonAdmitDTO>;
+    /** Re-run daemon-owned corpus migration and resume normal startup when repaired. */
+    repairMigrations(req: {
+        dryRun: boolean;
+        dirs: readonly string[];
+    }): Promise<{
+        result: import('../migrations/runner.js').OnDiskMigrationRunResult;
+        resumed: boolean;
+        resumeError?: string;
+    }>;
 }
 /** Bind this process's control surface. Called once, by `runDaemon`. */
 export declare function bindDaemonControl(control: DaemonControl): void;

package/dist/daemon/cron/disposition.d.ts

@@ -1,4 +1,5 @@
 import { type Cron } from '../../core/canvas/crons.js';
+import { type CronSinkResolution } from './sinks.js';
 export interface RunSettleContext {
     runId: string;
     startedAtIso: string;
@@ -15,5 +16,6 @@ export interface Disposition {
     delivered: string;
     /** A paused row is retained so `cron resume` can re-arm it. */
     paused: boolean;
+    obligation?: CronSinkResolution;
 }
 export declare function disposeSettledRun(c: Cron, ctx: RunSettleContext, outOfBand: boolean, selfCanceled?: boolean): Promise<Disposition>;

package/dist/daemon/cron/disposition.js

@@ -1,6 +1,6 @@
 import { getCron, setCronLastOutputHash } from '../../core/canvas/crons.js';
 import { escalateFailure, failureSummary } from './escalation.js';
-import { deliverToSink } from './sinks.js';
+import { resolveCronSink } from './sinks.js';
 export async function disposeSettledRun(c, ctx, outOfBand, selfCanceled = false) {
     const prefix = outOfBand ? 'out-of-band: ' : '';
     // A self-cancel still delivers its already-produced output; an external cancellation does not.
@@ -31,17 +31,20 @@ export async function disposeSettledRun(c, ctx, outOfBand, selfCanceled = false)
         case 'on-change':
             if (!changed)
                 return { delivered: `${prefix}unchanged — not delivered (on-change)`, paused: false };
-            return deliverOrEscalate(effective, ctx, outOfBand, prefix);
+            return resolveOrEscalate(effective, ctx, outOfBand, prefix);
         case 'always':
-            return deliverOrEscalate(effective, ctx, outOfBand, prefix);
+            return resolveOrEscalate(effective, ctx, outOfBand, prefix);
     }
 }
-async function deliverOrEscalate(c, ctx, outOfBand, prefix) {
+async function resolveOrEscalate(c, ctx, outOfBand, prefix) {
     if (ctx.stdoutHead.trim() === '') {
         return { delivered: `${prefix}empty stdout — nothing delivered`, paused: false };
     }
     try {
-        return { delivered: `${prefix}${await deliverToSink(c, ctx.stdoutHead)}`, paused: false };
+        const obligation = resolveCronSink(c, ctx.runId, ctx.stdoutHead);
+        return obligation.kind === 'none'
+            ? { delivered: `${prefix}${obligation.delivered}`, paused: false }
+            : { delivered: '', paused: false, obligation };
     }
     catch (err) {
         const why = `delivery failed: ${err.message}`;

package/dist/daemon/cron/settle.js

@@ -1,4 +1,6 @@
-import { consumeCron, recordCronRun, releaseCronRunLease, } from '../../core/canvas/crons.js';
+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');
@@ -7,27 +9,49 @@ 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 = {
-        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,
-    };
-    recordCronRun(written);
+    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.

package/dist/daemon/cron/sinks.d.ts

@@ -1,2 +1,19 @@
 import { type Cron } from '../../core/canvas/crons.js';
-export declare function deliverToSink(c: Cron, stdout: string): Promise<string>;
+export type CronSinkResolution = {
+    kind: 'none';
+    delivered: string;
+} | {
+    kind: 'node';
+    destinationNodeId: string;
+    senderNodeId: string | null;
+    label: string;
+    stdout: string;
+    urgency: 'critical' | 'urgent' | 'normal' | 'deferred';
+} | {
+    kind: 'external';
+    destinationId: string;
+    adapter: Record<string, unknown>;
+    bodyJson: unknown;
+};
+/** Resolve a completed run into a durable obligation. No sink effect happens here. */
+export declare function resolveCronSink(c: Cron, runId: string, stdout: string): CronSinkResolution;

package/dist/daemon/cron/sinks.js

@@ -1,105 +1,59 @@
-import { randomBytes } from 'node:crypto';
-import { rmSync } from 'node:fs';
-import { synthesizedPageDocument, writeSynthesizedPage } from '../../core/human/page-synth.js';
-import { ticketDir } from '../../core/human/root.js';
-import { preparePage, publishPage } from '../../core/human/tickets.js';
-import { resolvePageComponents } from '../../core/config.js';
+import { newNodeId } from '../../core/runtime/nodes.js';
 import { getNode } from '../../core/canvas/canvas.js';
-import { cancelCronsOnWake } from '../../core/canvas/crons.js';
-import { appendInbox } from '../../core/feed/inbox.js';
+import { parseCronSink } from '../../core/canvas/crons.js';
 import { hasNoNaturalCycle } from '../../core/runtime/revive-all.js';
 import { isParked } from '../../core/runtime/lifecycle.js';
-import { reviveNode } from '../../core/runtime/revive.js';
-import { isBrokerLive } from '../../core/runtime/model-swap.js';
-import { spawnChild } from '../../core/runtime/spawn.js';
 import { cronWakeOrigin } from '../../core/runtime/bearings.js';
-import { parseCronSink } from '../../core/canvas/crons.js';
 import { resolveLiveProfile, resolveLiveProfileName } from './armed-context.js';
-async function deliverNodeSink(c, target, stdout) {
-    const meta = getNode(target);
-    if (meta === null)
-        throw new Error(`node sink ${target} is gone`);
-    // A cron is an explicit next cycle for a clock-parked node, not other done nodes.
-    if (hasNoNaturalCycle(meta) && !isParked(meta)) {
-        throw new Error(`node sink ${target} has no natural cycle ahead (done or finalized)`);
-    }
-    const from = c.created_by != null && getNode(c.created_by) !== null ? c.created_by : null;
-    const entry = appendInbox(target, {
-        from,
-        tier: c.tier,
-        kind: 'message',
-        label: `⏰ cron ${c.name}`,
-        data: { body: stdout },
-    });
-    if (entry.tier !== 'deferred' || meta.frozen_at !== null)
-        cancelCronsOnWake(target);
-    // The APPENDED tier decides the wake, not the cron's requested one: a deferred
-    // cron aimed at a terminal node was raised out of `deferred` by the append.
-    // The durable append succeeds even if its best-effort wake fails.
-    if (entry.tier !== 'deferred' && !isBrokerLive(meta)) {
-        try {
-            await reviveNode(target, { resume: true, capacity: 'freeze' });
-        }
-        catch {
-            /* best-effort wake — the entry is durably appended regardless */
-        }
-    }
-}
-async function deliverSpawnSink(c, kind, stdout) {
-    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');
-    const res = await spawnChild({
-        kind,
-        cwd: c.cwd,
-        prompt,
-        // Creatorless sinks are terminal roots so each run reaps without stealing focus.
-        ...(creatorAlive ? { parent: c.created_by } : { root: true, rootLifecycle: 'terminal' }),
-        readiness: 'launch',
-        profile: resolveLiveProfile(c),
-        wakeOrigin: cronWakeOrigin(c, 'node_birth'),
-    });
-    return res.node.node_id;
-}
-function deliverHumanSink(c, stdout) {
-    const synthesized = writeSynthesizedPage(synthesizedPageDocument(`⏰ cron ${c.name}`, `Scheduled cron "${c.name}" delivered output for your attention.`, stdout, false));
-    // Validate verbatim stdout before minting a ticket to avoid a half-built page.
-    let prepared;
-    try {
-        const profileName = resolveLiveProfileName(c);
-        prepared = preparePage({
-            sourceFile: synthesized.path,
-            source: {
-                sessionName: `cron ${c.name} (${c.cron_id})`,
-                ...(profileName === undefined ? {} : { profileName }),
-            },
-            productKinds: resolvePageComponents(),
-            delivery: { placement: 'inline', inbox: true, reply: false },
-        });
-    }
-    finally {
-        rmSync(synthesized.dir, { recursive: true, force: true });
-    }
-    const id = `page-${randomBytes(4).toString('hex')}`;
-    publishPage(ticketDir(id), prepared);
-}
-export async function deliverToSink(c, stdout) {
+/** 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 'no sink armed — nothing delivered';
+        return { kind: 'none', delivered: 'no sink armed — nothing delivered' };
     if (sink.kind === 'node') {
-        await deliverNodeSink(c, sink.node, stdout);
-        return `delivered: node ${sink.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 nodeId = await deliverSpawnSink(c, sink.spawn, stdout);
-        return `delivered: spawned ${nodeId}`;
+        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 },
+        };
     }
-    deliverHumanSink(c, stdout);
-    return 'delivered: human send --inbox';
+    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 },
+    };
 }

package/dist/daemon/crtrd-cli.js

@@ -3,8 +3,6 @@
 // raw fatal boundary; a winning daemon stays alive through its scheduled loop.
 import '../suppress-experimental-warnings.js';
 import { runDaemon } from './crtrd.js';
-import { DAEMON_EXIT_STARTUP_BLOCKED } from './startup-policy.js';
-import { blockedMigrationIn, recordDaemonStartupBlocked } from './startup-block-marker.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). */
@@ -18,21 +16,8 @@ function parseTcpArg(argv) {
     }
     return envCrtrdTcp();
 }
-// A blocked migration is the one startup failure guaranteed to recur, so it
-// exits on its own code rather than reaching Node's raw fatal boundary like
-// every other failure.
-try {
-    await runDaemon({ tcp: parseTcpArg(process.argv.slice(2)) });
-}
-catch (error) {
-    // Record it in the canvas home BEFORE exiting: the exit code alone only
-    // reaches the one process that spawned us, and the processes that would spawn
-    // the next daemon are all different processes with no memory of this. The
-    // marker is what makes the suppression outlive this pid.
-    const blocked = blockedMigrationIn(error);
-    if (blocked === null)
-        throw error;
-    recordDaemonStartupBlocked(blocked.message, blocked.blockerPaths);
-    process.stderr.write(`[crtrd] startup blocked\n${blocked.message}\n`);
-    process.exit(DAEMON_EXIT_STARTUP_BLOCKED);
+function parsePrepareArg(argv) {
+    return argv.includes('--prepare');
 }
+const argv = process.argv.slice(2);
+await runDaemon({ tcp: parseTcpArg(argv), prepare: parsePrepareArg(argv) });

package/dist/daemon/crtrd.d.ts

@@ -13,6 +13,8 @@ export interface DaemonOpts {
     /** Opt-in TCP listener for the API server as `host:port` (§4.1). Falls back
      *  to `CRTRD_TCP` when unset. Absent → unix socket only. */
     tcp?: string;
+    /** Hold after storage preparation until `POST /v1/daemon/admit`. */
+    prepare?: boolean;
 }
 /** Start the supervisor loop after winning the authoritative canvas claim.
  *