@north-light/crouter 0.3.192 → 0.3.194

package/dist/daemon/api/router.d.ts

@@ -18,10 +18,14 @@ export interface RequestContext {
     res: ServerResponse;
 }
 /** What a handler returns. `body` is JSON-serialized; omit it (or use 204) for
- *  an empty response. `headers` are merged over the default `content-type`. */
+ *  an empty response. `headers` are merged over the default `content-type`.
+ *  `rawBody` is the escape hatch for the routes that serve bytes rather than
+ *  JSON (the page runtime bundle): it is written verbatim and the handler owns
+ *  the `content-type`. Setting both is a handler bug — `rawBody` wins. */
 export interface HandlerResult {
     status: number;
     body?: unknown;
+    rawBody?: string | Buffer;
     headers?: Record<string, string>;
 }
 /** A route handler — sync or async. A throw is caught and mapped by the router

package/dist/daemon/api/router.js

@@ -164,6 +164,11 @@ function writeResult(res, result) {
     if (res.headersSent)
         return;
     const headers = { ...(result.headers ?? {}) };
+    if (result.rawBody !== undefined) {
+        res.writeHead(result.status, headers);
+        res.end(result.rawBody);
+        return;
+    }
     if (result.status === 204 || result.body === undefined) {
         res.writeHead(result.status, headers);
         res.end();

package/dist/daemon/api/server.js

@@ -19,6 +19,7 @@ import { emitEvent } from '../../core/events/emit.js';
 import { Router } from './router.js';
 import { handleAttachUpgrade } from './bridge.js';
 import { attachRoutes } from './handlers/attach.js';
+import { bashJobRoutes } from './handlers/bash-jobs.js';
 import { brokerOperationRoutes } from './handlers/broker-ops.js';
 import { canvasRoutes } from './handlers/canvas.js';
 import { daemonRoutes } from './handlers/daemon.js';
@@ -46,6 +47,7 @@ function buildRouter() {
         .registerAll(healthRoutes)
         .registerAll(daemonRoutes)
         .registerAll(nodeRoutes)
+        .registerAll(bashJobRoutes)
         .registerAll(brokerOperationRoutes)
         .registerAll(worktreeRoutes)
         .registerAll(messageRoutes)

package/dist/daemon/cron-run.js

@@ -32,9 +32,11 @@ import { spawn } from 'node:child_process';
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
-import { notifyDeck } from '../core/human/deck-factories.js';
+import { rmSync } from 'node:fs';
+import { synthesizedPageDocument, writeSynthesizedPage } from '../core/human/page-synth.js';
 import { ticketDir } from '../core/human/root.js';
-import { submitDeck } from '../core/human/tickets.js';
+import { preparePage, publishPage } from '../core/human/tickets.js';
+import { readConfig } from '../core/config.js';
 import { dueClockCrons, dueOverlapCrons, expiredIdleCrons, runningCrons, acquireCronRunLease, releaseCronRunLease, recordCronRun, listCronRuns, advanceCron, consumeCron, cancelCron, killLeasedCronRun, verifyLeasedCronRun, getCron, setCronState, setCronLastOutputHash, } from '../core/canvas/crons.js';
 import { getNode } from '../core/canvas/canvas.js';
 import { fullName } from '../core/canvas/labels.js';
@@ -211,19 +213,30 @@ async function deliverSpawnSink(c, kind, stdout) {
     });
     return res.node.node_id;
 }
-/** Deliver stdout through crouter as a durable notify deck (fire-and-forget
+/** Deliver stdout through crouter as a durable notify page (fire-and-forget
  *  inbox state — jobs whose output is a person's call). Mirrors `crtr human
- *  notify` minus the CLI-env source stamp: the deck names the cron instead. */
+ *  notify` minus the CLI-env source stamp: the page names the cron instead. */
 function deliverHumanSink(c, stdout) {
+    const synthesized = writeSynthesizedPage(synthesizedPageDocument(`⏰ cron ${c.name}`, `Scheduled cron "${c.name}" delivered output for your attention.`, stdout, false));
+    // Cron stdout rides into the page verbatim, so it can carry invalid page
+    // markup. Validate before minting the ticket, so a rejected page leaves no
+    // half-built `nfy-*` directory behind.
+    let prepared;
+    try {
+        prepared = preparePage({
+            sourceFile: synthesized.path,
+            dialect: 'md',
+            source: { sessionName: `cron ${c.name} (${c.cron_id})` },
+            productKinds: readConfig('user').page_components,
+        });
+    }
+    finally {
+        rmSync(synthesized.dir, { recursive: true, force: true });
+    }
     const id = `nfy-${randomBytes(4).toString('hex')}`;
     const rc = { mode: 'notify' };
     atomicWriteJson(join(ticketDir(id), 'run.json'), rc);
-    let deck = notifyDeck(`⏰ cron ${c.name}`, {
-        subtitle: `Scheduled cron "${c.name}" delivered output for your attention.`,
-        body: stdout,
-    });
-    deck = { ...deck, source: { sessionName: `cron ${c.name} (${c.cron_id})` } };
-    submitDeck({ dir: ticketDir(id), deck });
+    publishPage(ticketDir(id), prepared);
 }
 /** Route stdout to the cron's armed sink. Returns the delivered string on
  *  success; throws on an undeliverable sink (the caller's failure path). */

package/dist/daemon/human/finish.d.ts

@@ -1,6 +1,11 @@
-import type { InteractionResponse, TicketResult } from '../../core/human/types.js';
-/** Resolve a deck ticket under the store-owned claim-takeover lock boundary. */
-export declare function resolveDeckTicket(nodeId: string, responses: InteractionResponse[]): Promise<TicketResult>;
+import type { TicketResult } from '../../core/human/types.js';
+/**
+ * The one completion path for a page ticket: claim takeover, exclusive result
+ * publication, then the asking node's wake. Every addressing surface — the
+ * node-addressed resolve route and the ticket-id-addressed inbox respond route —
+ * finishes a page here, so an answer always reaches the node that asked.
+ */
+export declare function resolvePageTicket(nodeId: string, responses: unknown, productKinds?: string[]): Promise<TicketResult>;
 /** Cancel a ticket with the store's first-writer-wins publication. */
 export declare function cancelHumanTicket(nodeId: string, opts: {
     reason?: string;

package/dist/daemon/human/finish.js

@@ -2,19 +2,35 @@ import { join } from 'node:path';
 import { ApiError } from '../../api/index.js';
 import { getNode, subscribersOf } from '../../core/canvas/canvas.js';
 import { ticketDir } from '../../core/human/root.js';
-import { cancelTicket, projectReviewOutput, readTicketResult, takeoverAndCompleteDeck, } from '../../core/human/tickets.js';
+import { cancelTicket, projectReviewOutput, readTicketResult, takeoverAndCompletePage, } from '../../core/human/tickets.js';
 import { responsePath } from '../../core/human/convention.js';
 import { readJsonOrNull } from '../../core/fs-utils.js';
 import { appendInbox } from '../../core/feed/inbox.js';
 import { FinalDeliveryError, pushFinal } from '../../core/feed/feed.js';
 import { transition } from '../../core/runtime/lifecycle.js';
-function envelopeFromDeckResult(responses, summary, completedAt, resultPath) {
-    return { summary, responsePath: resultPath, schema: 'humanloop.response/v2', responses, completedAt };
-}
-function renderDeckAnswer(env) {
-    const summary = env.summary.trim();
-    const body = summary === '' ? '(the human submitted no answer text)' : summary;
-    return `${body}\n\nResponse metadata (question ids, selected options, timestamp): ${env.responsePath}`;
+/**
+ * The answer a page's asking node wakes with. Slot responses are small and
+ * typed, so they are inlined as compact JSON rather than left behind the path:
+ * the node reads its answers out of its own report. An acknowledgement carries
+ * no responses at all and reads as one line saying the human saw the page.
+ * Interim rendering — the designed answer view is phase 5.
+ */
+function renderPageAnswer(result, resultPath) {
+    const entries = Object.entries(result.responses);
+    const lines = [];
+    if (entries.length === 0) {
+        lines.push('The human read the page and dismissed it. No slot responses came back, so the acknowledgement is the whole answer.');
+    }
+    else {
+        lines.push(`The human answered ${entries.length} slot${entries.length === 1 ? '' : 's'}:`, '');
+        for (const [slotId, response] of entries)
+            lines.push(`${slotId}: ${JSON.stringify(response)}`);
+        const summary = result.summary.trim();
+        if (summary !== '')
+            lines.push('', summary);
+    }
+    lines.push('', `Response metadata (slot ids, typed responses, timestamp): ${resultPath}`);
+    return lines.join('\n');
 }
 function deliveryFailed(error) {
     // A canonical final is committed inside its own write boundary and can never
@@ -35,9 +51,14 @@ async function deliverOrConflict(nodeId) {
     }
     throw new ApiError(409, 'ticket_already_resolved', 'ticket already resolved');
 }
-/** Resolve a deck ticket under the store-owned claim-takeover lock boundary. */
-export async function resolveDeckTicket(nodeId, responses) {
-    const completed = takeoverAndCompleteDeck(ticketDir(nodeId), responses, { host: 'crtrd', pid: process.pid });
+/**
+ * The one completion path for a page ticket: claim takeover, exclusive result
+ * publication, then the asking node's wake. Every addressing surface — the
+ * node-addressed resolve route and the ticket-id-addressed inbox respond route —
+ * finishes a page here, so an answer always reaches the node that asked.
+ */
+export async function resolvePageTicket(nodeId, responses, productKinds = []) {
+    const completed = takeoverAndCompletePage(ticketDir(nodeId), responses, { host: 'crtrd', pid: process.pid }, { productKinds });
     if (!completed.won)
         return deliverOrConflict(nodeId);
     try {
@@ -108,9 +129,8 @@ export async function deliverTerminalResult(nodeId) {
         transition(nodeId, 'finish');
         return true;
     }
-    if (result.kind !== 'deck')
-        return true;
-    const envelope = envelopeFromDeckResult(result.responses, result.summary, result.completedAt, responsePath(dir));
-    await pushFinal(nodeId, renderDeckAnswer(envelope));
+    if (result.kind === 'page') {
+        await pushFinal(nodeId, renderPageAnswer(result, responsePath(dir)));
+    }
     return true;
 }

package/dist/daemon/reconcilers/broker-supervision.js

@@ -20,6 +20,7 @@ import { operationIdContext } from '../../core/events/operation-id.js';
 import { readCursor, readInboxSince } from '../../core/feed/inbox.js';
 import { activeBackgroundBashJobs } from '../../core/bash-jobs.js';
 import { focusOf } from '../../core/runtime/placement.js';
+import { hasLiveObligation } from './live-obligation.js';
 const execFileAsync = promisify(execFile);
 function configuredPositiveInteger(name, fallback) {
     const raw = process.env[name];
@@ -205,7 +206,12 @@ export class BrokerSupervisionReconciler {
         if (now - since < unattendedParkMsForDaemon())
             return;
         this.unattendedSince.delete(id);
-        transition(id, 'release');
+        const liveObligation = hasLiveObligation(id);
+        // A resident with nothing left to wake it has completed its conversation:
+        // terminalize it so history retention can eventually prune it. A resident
+        // still awaiting a child/controller/human/deadline/output stays wakeable, as does
+        // every terminal node (whose own stop guard owns semantic completion).
+        transition(id, row.lifecycle === 'resident' && !liveObligation ? 'finish' : 'release');
         headlessBrokerHost.teardown(id);
     }
     async warnOverCapInTmux(count, warning, max) {

package/dist/daemon/reconcilers/dormant-inbox.js

@@ -7,6 +7,7 @@ import { appendControllerDeathNotice, readCursor, readInboxSince, } from '../../
 import { fanDoctrineWake } from '../../core/runtime/close.js';
 import { transition } from '../../core/runtime/lifecycle.js';
 import { reviveNode } from '../../core/runtime/revive.js';
+import { hasLiveObligation } from './live-obligation.js';
 // Idle-release/inbox retry cap (2026-07-10 diagnosis, round 2): the SAME
 // livelock shape as the stranded-relaunch case, but on the separate pass that
 // resumes a dormant idle-released node when its inbox gains an unseen entry.
@@ -78,6 +79,13 @@ export class DormantInboxReconciler {
                     // set neither revives the node nor starts a stuck-relaunch episode.
                     if (!entries.some((entry) => entry.tier !== 'deferred')) {
                         this.relaunchState.delete(id);
+                        const meta = getNode(id);
+                        // An idle resident with no wake-worthy inbox entry still needs
+                        // lifecycle settlement. Once nothing live remains, this is completed
+                        // history rather than a permanently protected idle row.
+                        if (meta?.lifecycle === 'resident' && !hasLiveObligation(id)) {
+                            transition(id, 'finish');
+                        }
                         return;
                     }
                     const prior = this.relaunchState.get(id);

package/dist/daemon/reconcilers/live-obligation.d.ts

@@ -0,0 +1,2 @@
+/** Durable work that requires a resident to remain automatically wakeable. */
+export declare function hasLiveObligation(nodeId: string): boolean;

package/dist/daemon/reconcilers/live-obligation.js

@@ -0,0 +1,11 @@
+import { hasActiveLiveSubscription, hasLiveMessageWait, hasPendingCancelOnWakeCron, } from '../../core/canvas/index.js';
+import { countTickets } from '../../core/canvas/attention.js';
+import { readOutputRequest } from '../../core/runtime/structured-output.js';
+/** Durable work that requires a resident to remain automatically wakeable. */
+export function hasLiveObligation(nodeId) {
+    return hasActiveLiveSubscription(nodeId)
+        || hasLiveMessageWait(nodeId)
+        || hasPendingCancelOnWakeCron(nodeId)
+        || countTickets(nodeId) > 0
+        || readOutputRequest(nodeId).state !== 'absent';
+}

package/dist/pages/bundle.css

@@ -0,0 +1 @@
+:where(:root,:host){color-scheme:light dark;--crtr-color-background: #ffffff;--crtr-color-surface: #f7f7f8;--crtr-color-surface-hover: #eeeeef;--crtr-color-text: #1c1c1f;--crtr-color-text-muted: #68686f;--crtr-color-border: #d9d9de;--crtr-color-accent: #5753c9;--crtr-color-accent-contrast: #ffffff;--crtr-color-danger: #c73535;--crtr-color-focus: #706bea;--crtr-chart-1: #5753c9;--crtr-chart-2: #2c8c75;--crtr-chart-3: #cf7c2a;--crtr-chart-4: #b84c84;--crtr-chart-5: #477eb8;--crtr-font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;--crtr-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;--crtr-font-size: .875rem;--crtr-line-height: 1.5;--crtr-radius-small: .375rem;--crtr-radius-medium: .625rem;--crtr-space-1: .25rem;--crtr-space-2: .5rem;--crtr-space-3: .75rem;--crtr-space-4: 1rem;--crtr-shadow: 0 1px 2px rgb(0 0 0 / .08)}:where(crtr-options,crtr-text,crtr-table,crtr-cards,crtr-chart,crtr-pages,crtr-page,crtr-slot){color:var(--crtr-color-text);font-family:var(--crtr-font-family);font-size:var(--crtr-font-size);line-height:var(--crtr-line-height)}@media(prefers-color-scheme:dark){:where(:root,:host){--crtr-color-background: #161618;--crtr-color-surface: #222225;--crtr-color-surface-hover: #2d2d31;--crtr-color-text: #f2f2f3;--crtr-color-text-muted: #aaaab1;--crtr-color-border: #414147;--crtr-color-accent: #9692ff;--crtr-color-accent-contrast: #18181b;--crtr-color-danger: #f06a6a;--crtr-color-focus: #aaa7ff}}