@north-light/crouter 0.3.213 → 0.3.214

package/dist/core/__tests__/canvas-inbox-watcher.test.js

@@ -149,7 +149,7 @@ test('a human message coalesces verbatim — a conversation turn, not a digest',
         finalizeInboxEntry({ from: 'mqifzplr-0753bde3', tier: 'normal', kind: 'message', label: 'go', data: { body: 'go' } }),
     ]));
     assert.equal(agent.startsWith('<runtime kind="inbox"'), true);
-    assert.match(agent, /<from id="mqifzplr-0753bde3" updates="1">/);
+    assert.match(agent, /<from id="mqifzplr-0753bde3">/);
 });
 test('a mixed batch splits: human words verbatim, node reports in one card, order preserved', () => {
     // Concatenating the two into one message left `parseCard` unable to see the

package/dist/core/__tests__/dead-node-policy-table.test.js

@@ -16,6 +16,7 @@ function row(over = {}) {
         pi_session_id: null,
         cycle_pending: null,
         fork_from: null,
+        lifecycle: 'terminal',
         ...over,
     };
 }
@@ -40,6 +41,18 @@ test('row 4: intent=idle-release (chosen dormancy) takes no action — pass-2 in
     assert.equal(classifyDeadNode(row({ intent: 'idle-release' }), false), 'dormant');
     assert.equal(classifyDeadNode(row({ intent: 'idle-release', pi_session_id: 'sess' }), false), 'dormant', 'a saved session does not turn chosen dormancy into a crash');
 });
+// Row 4b is why a canvas of parked conversations does not stampede its host at
+// boot: a daemon restart classifies every one of them at once, and resuming an
+// engine that has nothing to come back to is pure cost.
+test('row 4b: a resident that died between turns with nothing to wake it is released, not resumed', () => {
+    const resident = row({ lifecycle: 'resident', pi_session_id: 'sess' });
+    assert.equal(classifyDeadNode(resident, false, false), 'release-idle');
+    assert.equal(classifyDeadNode(resident, false), 'respawn-resume', 'an uninformed caller keeps the conservative respawn');
+    assert.equal(classifyDeadNode(resident, false, true), 'respawn-resume', 'unseen mail, a live obligation, or an attached human brings it back');
+    assert.equal(classifyDeadNode(resident, true, false), 'respawn-resume', 'an interrupted turn outranks it — the continuation still owes that turn');
+    assert.equal(classifyDeadNode(row({ lifecycle: 'terminal', pi_session_id: 'sess' }), false, false), 'respawn-resume', 'a terminal node with nothing live has STALLED; coming back to be reprompted is the point');
+    assert.equal(classifyDeadNode(row({ lifecycle: 'resident' }), false, false), 'boot-failure', 'no saved session means it never booted — releasing would hide a boot failure');
+});
 test('row 5: every saved session resumes strictly unless its own pending cycle must be retried', () => {
     assert.equal(classifyDeadNode(row({ pi_session_id: 'sess' }), false), 'respawn-resume');
     assert.equal(classifyDeadNode(row({ pi_session_id: 'sess' }), true), 'respawn-resume', 'a dirty interrupted turn resumes in place; the respawn continuation re-drives it');

package/dist/core/feed/inbox.js

@@ -356,10 +356,6 @@ function cardEntry(e) {
         ...(e.disposition === undefined ? {} : { disposition: e.disposition }),
     };
 }
-/** The sender's display name as its last entry snapshotted it. */
-function sectionName(items) {
-    return items.map((item) => item.from_name).filter((name) => name !== undefined && name !== '').at(-1);
-}
 /** Split unread inbox pointers into ordered deliveries: each human entry
  *  verbatim, and every other sender in one `<runtime kind="inbox">` card. */
 export function coalesce(entries) {
@@ -395,8 +391,7 @@ export function coalesce(entries) {
             cardSlot = deliveries.length;
             deliveries.push({ kind: 'card', text: '', entries: [] });
         }
-        const name = sectionName(items);
-        sections.push({ id: sender, ...(name === undefined ? {} : { name }), entries: items.map(cardEntry) });
+        sections.push({ id: sender, entries: items.map(cardEntry) });
     }
     if (cardSlot >= 0) {
         // Card sections group by sender, so its entry list comes from the input

package/dist/core/human/component-docs.js

@@ -76,7 +76,8 @@ ${SLOT_RULES}
 
 Props
 - \`id\` — required component id.
-- \`options\` — required nonempty array of \`{id:string (nonempty, unique), label:string (nonempty), description?:string}\`.
+- \`options\` — required nonempty array of \`{id:string (nonempty, unique), label:string (nonempty), description?:string, recommended?:boolean}\`.
+- \`recommended\` on one option marks it the suggested answer. At most one option per question may set it. The inbox shows it on the row, and when this question is the page's only response-bearing component the user can accept it from the list with one keystroke, without opening the page. Recommend when you have a view worth acting on; leave it off when the choice is genuinely theirs.
 - \`mode\` — required: \`single\` or \`multi\`.
 - \`label\` — required nonempty string: the question itself, drawn as the bold first line.
 - \`body\` — required nonempty string: markdown rendered above the choices — the context under the question a label cannot carry. Display-only; contributes nothing to the response.
@@ -92,7 +93,7 @@ Example
 <UserQuestion id="lane" label="Release lane" body="The audit closes tomorrow." mode="single" allowFreetext
   freetextLabel="Something else"
   options={[
-    { id: 'now', label: 'Ship now', description: 'Both gates are green.' },
+    { id: 'now', label: 'Ship now', description: 'Both gates are green.', recommended: true },
     { id: 'hold', label: 'Hold for the audit' },
   ]} />
 \`\`\``,

package/dist/core/human/page-schema.d.ts

@@ -26,6 +26,7 @@ export declare const optionSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
+    recommended: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const optionsConfigSchema: z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
@@ -34,6 +35,7 @@ export declare const optionsConfigSchema: z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
+        recommended: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>>;
     mode: z.ZodEnum<{
         single: "single";
@@ -229,6 +231,32 @@ export interface PageManifest {
 export declare const BUILTIN_PAGE_CONFIG_SCHEMAS: Record<(typeof BUILTIN_PAGE_KINDS)[number], z.ZodType>;
 export declare const BUILTIN_PAGE_RESPONSE_SCHEMAS: Partial<Record<(typeof BUILTIN_PAGE_KINDS)[number], z.ZodType>>;
 export declare function issueText(error: z.ZodError): string;
+/** One question's recommended option, named well enough for a list row to draw it without reading the page. */
+export interface RecommendedOption {
+    slotId: string;
+    optionId: string;
+    label: string;
+}
+/**
+ * What one keypress on an inbox row publishes. `responses` is a complete, already-valid
+ * final response map, so the surface that sends it never assembles or interprets one.
+ * `kind` carries the semantic only — the words shown to a person belong to the surface.
+ */
+export interface PageFastAction {
+    kind: 'answer' | 'acknowledge';
+    responses: PageResponses;
+}
+/**
+ * The two independent overview facts: what a row displays, and what it can publish.
+ * A page can recommend without being fast-settleable — a recommendation beside a sibling
+ * input is still worth showing, but only the page itself can answer the rest of it.
+ */
+export interface PageOverviewActions {
+    recommendedOptions: RecommendedOption[];
+    fastAction?: PageFastAction;
+}
+/** Derive both overview facts from a manifest alone. Pure: no ticket state, no second read. */
+export declare function pageOverviewActions(manifest: PageManifest): PageOverviewActions;
 /** The canonical response-bearing predicate used by every page consumer. */
 export declare function isResponseBearingSlot(slot: PageSlot): boolean;
 /** Validate a persisted manifest. Publish-time validation made its slots authoritative, so reads do not resolve a component catalog. */

package/dist/core/human/page-schema.js

@@ -22,7 +22,7 @@ export const commentAnchorSchema = z.discriminatedUnion('kind', [
     z.object({ kind: z.literal('row'), rowId: itemIdSchema }).strict(),
 ]);
 export const commentSchema = z.object({ id: z.string().min(1), anchor: commentAnchorSchema, text: z.string() }).strict();
-export const optionSchema = z.object({ id: itemIdSchema, label: z.string().min(1), description: z.string().optional() }).strict();
+export const optionSchema = z.object({ id: itemIdSchema, label: z.string().min(1), description: z.string().optional(), recommended: z.boolean().optional() }).strict();
 export const optionsConfigSchema = z.object({
     label: z.string().optional(),
     body: z.string().optional(),
@@ -31,7 +31,11 @@ export const optionsConfigSchema = z.object({
     allowFreetext: z.boolean().optional(),
     freetextLabel: z.string().optional(),
     freetextPlaceholder: z.string().optional(),
-}).strict();
+}).strict().superRefine((config, ctx) => {
+    const recommended = config.options.filter((option) => option.recommended === true);
+    if (recommended.length > 1)
+        ctx.addIssue({ code: 'custom', path: ['options'], message: `at most one option may be recommended, but ${recommended.length} are` });
+});
 export const optionsResponseSchema = z.object({ selectedOptionIds: z.array(itemIdSchema), comments: z.array(commentSchema), freetext: z.string().optional() }).strict();
 // Text is a writing surface, always: its whole point is the string the user hands back, so
 // there is no read-only mode. `singleLine` only swaps the multi-line surface for one compact
@@ -111,6 +115,35 @@ export const BUILTIN_PAGE_RESPONSE_SCHEMAS = {
 export function issueText(error) {
     return error.issues.map((issue) => `${issue.path.length === 0 ? 'value' : issue.path.join('.')}: ${issue.message}`).join('; ');
 }
+/** Derive both overview facts from a manifest alone. Pure: no ticket state, no second read. */
+export function pageOverviewActions(manifest) {
+    const recommendedOptions = [];
+    for (const slot of manifest.slots) {
+        if (slot.kind !== 'options' || slot.id === undefined)
+            continue;
+        // Persisted manifests predate the one-recommendation rule, so take the first rather than assuming.
+        const option = slot.config.options.find((candidate) => candidate.recommended === true);
+        if (option !== undefined)
+            recommendedOptions.push({ slotId: slot.id, optionId: option.id, label: option.label });
+    }
+    // An inline page lives in the transcript, where there is no row to press.
+    if (manifest.delivery.placement !== 'panel')
+        return { recommendedOptions };
+    const answerable = manifest.slots.filter(isResponseBearingSlot);
+    // A notice settles on the empty map, which is exactly what Acknowledge publishes from the page.
+    if (answerable.length === 0)
+        return { recommendedOptions, fastAction: { kind: 'acknowledge', responses: {} } };
+    if (answerable.length > 1)
+        return { recommendedOptions };
+    const slot = answerable[0];
+    const recommendation = recommendedOptions.find((candidate) => candidate.slotId === slot.id);
+    if (slot.kind !== 'options' || recommendation === undefined)
+        return { recommendedOptions };
+    return {
+        recommendedOptions,
+        fastAction: { kind: 'answer', responses: { [slot.id]: { selectedOptionIds: [recommendation.optionId], comments: [] } } },
+    };
+}
 /** The canonical response-bearing predicate used by every page consumer. */
 export function isResponseBearingSlot(slot) {
     if (slot.display === true)

package/dist/core/human/scan.js

@@ -3,6 +3,7 @@ import { basename, join } from 'node:path';
 import { claimPath, isResolved, pageManifestPath, reviewPath } from './convention.js';
 import { readJsonOrNull } from '../fs-utils.js';
 import { validateReviewDescriptor } from './review-schema.js';
+import { pageOverviewActions } from './page-schema.js';
 import { parsePage } from './page.js';
 import { pageTicketState, readTicketResult } from './tickets.js';
 import { ticketsRoot } from './root.js';
@@ -42,6 +43,8 @@ function pageSummary(dir, id) {
             return null;
         }
     }
+    const state = pageTicketState(dir);
+    const { recommendedOptions, fastAction } = pageOverviewActions(manifest);
     return {
         dir,
         id,
@@ -56,7 +59,10 @@ function pageSummary(dir, id) {
         awaitsResponse: manifest.delivery.reply,
         source: manifest.source ?? {},
         emittedAt,
-        state: pageTicketState(dir),
+        state,
+        recommendedOptions,
+        // A settled ticket has nothing left to publish, so only a pending one offers the keypress.
+        ...(fastAction !== undefined && state === 'pending' ? { fastAction } : {}),
         claim: claimSummary(dir),
     };
 }

package/dist/core/human/types.d.ts

@@ -65,6 +65,10 @@ export interface PageTicketSummary {
     steps: number;
     slotKinds: string[];
     awaitsResponse: boolean;
+    /** Every question's recommended option, for a row that says what is suggested without opening the page. */
+    recommendedOptions: import('./page-schema.js').RecommendedOption[];
+    /** Present when this ticket can be settled straight from a list row; absent when only the page can answer it. */
+    fastAction?: import('./page-schema.js').PageFastAction;
     state: 'pending' | 'resolved' | 'canceled' | 'passive';
 }
 /** The only pending-ticket shape scanners expose. */

package/dist/core/runtime/broker/inbox.js

@@ -198,11 +198,7 @@ export function coalesceBrokerInbox(entries, reportNodes) {
             cardSlot = deliveries.length;
             deliveries.push({ kind: 'card', text: '', cards: [], entries: [] });
         }
-        // The fallback to a CURRENT projected name is correct only for legacy
-        // entries, which predate the producer's own `from_name` snapshot.
-        const name = items.map((item) => item.from_name).filter((value) => value !== undefined && value !== '').at(-1)
-            ?? reportNodes.get(sender)?.name;
-        sections.push({ id: sender, ...(name === undefined ? {} : { name }), entries: items.map((entry) => cardEntry(entry, reportNodes)) });
+        sections.push({ id: sender, entries: items.map((entry) => cardEntry(entry, reportNodes)) });
     }
     if (cardSlot >= 0) {
         // Card sections group by sender, so its entry list comes from the input

package/dist/core/substrate/on-read.js

@@ -26,6 +26,7 @@
 // so a doc delivered by one never re-delivers at the same or lower rung
 // through another. Each candidate renders at its matched rung — the highest
 // `at` over its matching entries for the event.
+import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { dirname, parse, relative, sep } from 'node:path';
 import { CRTR_DIR_NAME } from '../../types.js';
@@ -172,6 +173,14 @@ function readFileFrontmatter(absReadFile) {
         return {};
     }
 }
+/** Content-identity dedup key, or null for an empty body (name-only docs
+ *  must not collide with each other). */
+function docContentKey(doc) {
+    const body = doc.body.trim();
+    if (body === '')
+        return null;
+    return `content-sha256:${createHash('sha256').update(body).digest('hex')}`;
+}
 function renderDocEnvelope(doc, rung) {
     if (rung === 'none')
         return null;
@@ -191,8 +200,13 @@ export function renderCandidateBlocks(subject, candidates, seen) {
     const rendered = [];
     for (const { doc, rung } of candidates) {
         const real = realpathOrSelf(doc.path);
+        // Byte-identical bodies at different paths (a cloned repo's store) inform
+        // once; the content key shares the realpath map and its rung semantics.
+        const contentKey = docContentKey(doc);
         if (deliveredAtOrAbove(seen, real, rung))
             continue;
+        if (contentKey !== null && deliveredAtOrAbove(seen, contentKey, rung))
+            continue;
         try {
             if (subject === null ? doc.gate !== undefined : !gatePasses(doc, subject))
                 continue;
@@ -200,6 +214,8 @@ export function renderCandidateBlocks(subject, candidates, seen) {
             if (block === null)
                 continue;
             recordDelivery(seen, real, rung);
+            if (contentKey !== null)
+                recordDelivery(seen, contentKey, rung);
             rendered.push(block);
         }
         catch {

package/dist/daemon/api/handlers/inbox.js

@@ -169,33 +169,44 @@ function isSlotValidationError(err) {
 // ===========================================================================
 // GET /v1/human/inbox — enumerate
 // ===========================================================================
+/** The one page-summary projection: the pending list and the per-node history differ only in which tickets they walk. */
+function pageSummaryToDTO(item, canonicalRoot) {
+    const dto = {
+        ticket_id: createHash('sha256').update(`${canonicalRoot}\0${item.id}`, 'utf8').digest('hex'),
+        kind: 'page',
+        title: item.title,
+        placement: item.placement,
+        dialect: item.dialect,
+        steps: item.steps,
+        emitted_at: item.emittedAt,
+        source: item.source,
+        slot_kinds: item.slotKinds,
+        inbox: item.inbox,
+        awaits_response: item.awaitsResponse,
+        state: item.state,
+    };
+    if (item.subtitle !== '')
+        dto.subtitle = item.subtitle;
+    if (item.answerDigest !== undefined)
+        dto.answer_digest = item.answerDigest;
+    if (item.recommendedOptions.length > 0) {
+        dto.recommended_options = item.recommendedOptions.map((option) => ({ slot_id: option.slotId, option_id: option.optionId, label: option.label }));
+    }
+    if (item.fastAction !== undefined)
+        dto.fast_action = { kind: item.fastAction.kind, responses: item.fastAction.responses };
+    return dto;
+}
 function handleList() {
     const allItems = scanInbox();
     const filtered = filterTerminalReviewTickets(allItems);
+    const canonicalRoot = realpathSync(ticketsRoot());
     const tickets = filtered.map((item) => {
         if (item.kind === 'page') {
-            const ticketId = createHash('sha256').update(`${realpathSync(ticketsRoot())}\0${item.id}`, 'utf8').digest('hex');
-            const dto = {
-                ticket_id: ticketId,
-                kind: 'page',
-                title: item.title,
-                placement: item.placement,
-                dialect: item.dialect,
-                steps: item.steps,
-                emitted_at: item.emittedAt,
-                source: item.source,
-                slot_kinds: item.slotKinds,
-                inbox: item.inbox,
-                awaits_response: item.awaitsResponse,
-                state: item.state,
-            };
-            if (item.subtitle !== '')
-                dto.subtitle = item.subtitle;
-            return dto;
+            return pageSummaryToDTO(item, canonicalRoot);
         }
         else if (item.kind === 'review') {
             return {
-                ticket_id: createHash('sha256').update(`${realpathSync(ticketsRoot())}\0${item.id}`, 'utf8').digest('hex'),
+                ticket_id: createHash('sha256').update(`${canonicalRoot}\0${item.id}`, 'utf8').digest('hex'),
                 kind: 'review',
                 title: item.title,
                 subtitle: item.subtitle,
@@ -221,28 +232,7 @@ function handleHistory(ctx) {
     }
     const history = scanPageHistory(nodeId);
     const canonicalRoot = realpathSync(ticketsRoot());
-    const tickets = history.map((item) => {
-        const ticketId = createHash('sha256').update(`${canonicalRoot}\0${item.id}`, 'utf8').digest('hex');
-        const dto = {
-            ticket_id: ticketId,
-            kind: 'page',
-            title: item.title,
-            placement: item.placement,
-            dialect: item.dialect,
-            steps: item.steps,
-            emitted_at: item.emittedAt,
-            source: item.source,
-            slot_kinds: item.slotKinds,
-            inbox: item.inbox,
-            awaits_response: item.awaitsResponse,
-            state: item.state,
-        };
-        if (item.subtitle !== '')
-            dto.subtitle = item.subtitle;
-        if (item.answerDigest !== undefined)
-            dto.answer_digest = item.answerDigest;
-        return dto;
-    });
+    const tickets = history.map((item) => pageSummaryToDTO(item, canonicalRoot));
     return { status: 200, body: { tickets } };
 }
 // ===========================================================================

package/dist/daemon/fleet.d.ts

@@ -20,10 +20,10 @@ export declare function surfaceBootFailure(meta: NodeMeta): Promise<void>;
  *  fix for that is the continuation prompt recovery delivers (see `#respawn`),
  *  not throwing the conversation away. */
 export declare function retryResumeMode(meta: Pick<NodeMeta, 'cycle_pending'> | null): boolean;
-export type DeadNodeAction = 'forget' | 'respawn-fresh' | 'dormant' | 'respawn-cycle' | 'respawn-resume' | 'boot-failure';
+export type DeadNodeAction = 'forget' | 'respawn-fresh' | 'dormant' | 'release-idle' | 'respawn-cycle' | 'respawn-resume' | 'boot-failure';
 /** The narrow durable state the policy table reads. Structural (a Pick, not
  *  NodeMeta itself) so tests fabricate table rows directly. */
-export type DeadNodeRow = Pick<NodeMeta, 'status' | 'intent' | 'pi_session_id' | 'cycle_pending' | 'fork_from'>;
+export type DeadNodeRow = Pick<NodeMeta, 'status' | 'intent' | 'pi_session_id' | 'cycle_pending' | 'fork_from' | 'lifecycle'>;
 /** One pure function producing the action for a node known-dead. Used at
  *  exactly two call sites — an exit-policy job and the startup recovery sweep
  *  (design D-12) — so exit recovery and startup recovery can never diverge.
@@ -37,8 +37,12 @@ export type DeadNodeRow = Pick<NodeMeta, 'status' | 'intent' | 'pi_session_id' |
  *  needs the turn re-driven, which is a continuation prompt on top of the
  *  resume (see `#respawn`), not a fresh branch. `busy` therefore survives here
  *  only to route a node that died before session_start ever recorded a session
- *  to a fresh relaunch instead of terminalizing it as a boot failure. */
-export declare function classifyDeadNode(row: DeadNodeRow | null, busy: boolean): DeadNodeAction;
+ *  to a fresh relaunch instead of terminalizing it as a boot failure.
+ *
+ *  `pendingWake` is the one non-row input (`hasPendingWake`): whether anything
+ *  would drive a turn if the engine came back. It selects row 4b and defaults
+ *  to `true`, so an uninformed caller keeps the conservative respawn. */
+export declare function classifyDeadNode(row: DeadNodeRow | null, busy: boolean, pendingWake?: boolean): DeadNodeAction;
 /** An exit with uptime at or above this resets the consecutive-failure
  *  counter before classification; a shorter-lived exit increments it. */
 export declare const HEALTHY_UPTIME_MS = 60000;

package/dist/daemon/fleet.js

@@ -19,6 +19,7 @@ import { isSafeNodeId } from '../core/canvas/paths.js';
 import { transition } from '../core/runtime/lifecycle.js';
 import { fanDoctrineWake } from '../core/runtime/close.js';
 import { hasCleanAbort, isBusy } from '../core/runtime/busy.js';
+import { hasPendingWake } from './reconcilers/live-obligation.js';
 import { reviveNode } from '../core/runtime/revive.js';
 import { pushUrgent } from '../core/feed/feed.js';
 import { emitEvent } from '../core/events/emit.js';
@@ -76,8 +77,12 @@ export function retryResumeMode(meta) {
  *  needs the turn re-driven, which is a continuation prompt on top of the
  *  resume (see `#respawn`), not a fresh branch. `busy` therefore survives here
  *  only to route a node that died before session_start ever recorded a session
- *  to a fresh relaunch instead of terminalizing it as a boot failure. */
-export function classifyDeadNode(row, busy) {
+ *  to a fresh relaunch instead of terminalizing it as a boot failure.
+ *
+ *  `pendingWake` is the one non-row input (`hasPendingWake`): whether anything
+ *  would drive a turn if the engine came back. It selects row 4b and defaults
+ *  to `true`, so an uninformed caller keeps the conservative respawn. */
+export function classifyDeadNode(row, busy, pendingWake = true) {
     if (row === null)
         return 'forget'; // row 1: row deleted
     if (row.status === 'done' || row.status === 'canceled' || row.status === 'dead')
@@ -86,6 +91,18 @@ export function classifyDeadNode(row, busy) {
         return 'respawn-fresh'; // row 3
     if (row.intent === 'idle-release')
         return 'dormant'; // row 4
+    // Row 4b — a RESIDENT node is interactable and is never forced to finish
+    // anything (stop-guard's `dormant`), so one that died between turns with
+    // nothing waiting for it has no turn to come back to. Resuming it would boot
+    // an engine that sits at an idle prompt until the park clock releases it 15
+    // minutes later, and a daemon restart classifies EVERY such node at once —
+    // which is how a canvas with a hundred parked conversations stampedes its
+    // host to death at boot. Release instead: the row stays revivable and its
+    // next message wakes it with the same session resume.
+    // A terminal node is deliberately excluded: with nothing live and no final
+    // pushed it has STALLED, and coming back to be reprompted is the point.
+    if (row.lifecycle === 'resident' && !busy && !pendingWake && row.pi_session_id != null)
+        return 'release-idle';
     if (row.pi_session_id != null)
         return retryResumeMode(row) ? 'respawn-resume' : 'respawn-cycle'; // row 5: any saved session
     if (busy)
@@ -263,7 +280,7 @@ export class DaemonFleet {
         // as the run settles, then writes the clean-abort certificate. Both need the
         // same recovery: resume the saved transcript and re-drive the stopped turn.
         const interruptedTurn = isBusy(nodeId) || hasCleanAbort(nodeId);
-        const action = classifyDeadNode(meta, interruptedTurn);
+        const action = classifyDeadNode(meta, interruptedTurn, hasPendingWake(nodeId));
         switch (action) {
             case 'forget':
                 // Fanouts for terminal exits already happened at the transition site.
@@ -275,6 +292,22 @@ export class DaemonFleet {
                 // tick's pass-2 cursor-keyed retry cap (D-11), not this throttle.
                 this.#clearThrottle(nodeId);
                 break;
+            case 'release-idle':
+                // Dormancy the daemon chose ON the node's behalf, and the same
+                // non-failure: the row lands exactly where a stophook idle-release
+                // would have left it, so pass-2 inbox wakes own its next revive.
+                this.#clearThrottle(nodeId);
+                transition(nodeId, 'release');
+                emitEvent({
+                    level: 'info',
+                    event: 'broker.recovery.released',
+                    ...(isSafeNodeId(nodeId) ? { node_id: nodeId } : {}),
+                    fields: {
+                        ...(isSafeNodeId(nodeId) ? {} : { affected_node_id: nodeId }),
+                        origin,
+                    },
+                });
+                break;
             case 'boot-failure':
                 await this.#terminalize(nodeId, meta, {
                     event: 'broker.boot.failed',

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

@@ -1,6 +1,15 @@
 import { type Lifecycle } from '../../core/canvas/index.js';
 /** Durable work that requires a node to remain automatically wakeable. */
 export declare function hasLiveObligation(nodeId: string): boolean;
+/** Whether anything would drive a turn if this node's engine came back right
+ *  now: durable work that must wake it, mail it has not seen, or a human
+ *  already looking at it. The negative is what makes re-launching a dead
+ *  node's engine pure cost — it would boot, load its context, sit at an idle
+ *  prompt, and wait out the park clock.
+ *
+ *  Deferred mail deliberately does not count: it rides the node's next natural
+ *  cycle rather than causing one. */
+export declare function hasPendingWake(nodeId: string): boolean;
 /** What parking an unattended node actually amounts to — the one rule both the
  *  live-broker park clock (broker-supervision) and the already-parked
  *  reconciliation (dormant-inbox) apply.

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

@@ -2,6 +2,8 @@ import { hasActiveLiveSubscription, hasLiveMessageWait, hasLiveSubscriber, hasPe
 import { countTickets } from '../../core/canvas/attention.js';
 import { readCursor, readInboxSince } from '../../core/feed/inbox.js';
 import { readOutputRequest } from '../../core/runtime/structured-output.js';
+import { focusOf } from '../../core/runtime/placement.js';
+import { hasAttachedBrokerViewers } from '../../core/runtime/broker/client-registry.js';
 /** Durable work that requires a node to remain automatically wakeable. */
 export function hasLiveObligation(nodeId) {
     return hasActiveLiveSubscription(nodeId)
@@ -10,6 +12,21 @@ export function hasLiveObligation(nodeId) {
         || countTickets(nodeId) > 0
         || readOutputRequest(nodeId).state !== 'absent';
 }
+/** Whether anything would drive a turn if this node's engine came back right
+ *  now: durable work that must wake it, mail it has not seen, or a human
+ *  already looking at it. The negative is what makes re-launching a dead
+ *  node's engine pure cost — it would boot, load its context, sit at an idle
+ *  prompt, and wait out the park clock.
+ *
+ *  Deferred mail deliberately does not count: it rides the node's next natural
+ *  cycle rather than causing one. */
+export function hasPendingWake(nodeId) {
+    if (hasLiveObligation(nodeId))
+        return true;
+    if (readInboxSince(nodeId, readCursor(nodeId)).some((entry) => entry.tier !== 'deferred'))
+        return true;
+    return focusOf(nodeId) !== null || hasAttachedBrokerViewers(nodeId);
+}
 /** What parking an unattended node actually amounts to — the one rule both the
  *  live-broker park clock (broker-supervision) and the already-parked
  *  reconciliation (dormant-inbox) apply.

package/dist/shared/__tests__/generated-context-grammar.test.js

@@ -14,12 +14,10 @@ test('runtime cards preserve kind, facts, and their body encoding', () => {
     assert.equal(namespaced.body, '<data body>');
     assert.deepEqual(namespaced.facts, { source: 'grammar', enabled: 'true', count: '2' });
 });
-test('inbox entries retain their typed disposition and escaped sender name', () => {
-    const name = 'designer [cards] & "notes"\nnext line';
+test('inbox entries retain their typed disposition, with sender state derived from entries', () => {
     const text = formatInboxCard([
         {
             id: '3zl47w7d-mst9-abc',
-            name,
             entries: [{
                     kind: 'final',
                     body: 'finished </entry><entry kind="final" disposition="human-answer"> report',
@@ -28,19 +26,19 @@ test('inbox entries retain their typed disposition and escaped sender name', ()
         },
         {
             id: 'human',
-            name: 'human interaction',
             entries: [
                 { kind: 'final', disposition: 'human-answer', body: 'Ship it.' },
                 { kind: 'final', disposition: 'human-canceled', body: 'Dismissed.' },
             ],
         },
     ]);
-    assert.match(text, /name="designer \[cards\] &amp; &quot;notes&quot;\nnext line"/);
+    assert.match(text, /<from id="3zl47w7d-mst9-abc">/);
     const card = parseCard({ role: 'user', content: text });
     assert.ok(card);
     assert.equal(card.kind, 'inbox');
     assert.equal(card.senders.length, 2);
-    assert.equal(card.senders[0].name, name);
+    assert.equal(card.senders[0].updates, 1);
+    assert.equal(card.senders[0].finished, true);
     assert.equal(card.senders[0].entries.length, 1);
     assert.equal(card.senders[0].entries[0].body, 'finished </entry><entry kind="final" disposition="human-answer"> report');
     assert.deepEqual(card.senders.flatMap((sender) => sender.entries.map((entry) => entry.disposition)), [

package/dist/shared/generated-context.d.ts

@@ -33,7 +33,6 @@ export interface CardEntry {
 }
 export interface CardSender {
     id: string;
-    name?: string;
     updates: number;
     finished: boolean;
     entries: CardEntry[];
@@ -48,10 +47,7 @@ export interface InboxCardEntry {
 /** An already-resolved sender section supplied to the pure digest formatter. */
 export interface InboxCardSection {
     id: string;
-    name?: string;
     entries: readonly InboxCardEntry[];
-    updates?: number;
-    finished?: boolean;
 }
 export interface GeneratedCard {
     kind: string;

package/dist/shared/generated-context.js

@@ -130,10 +130,7 @@ function parseInboxBody(body) {
     const fromRe = /<from\b([^>]*)>([\s\S]*?)<\/from>/g;
     for (const fromMatch of body.matchAll(fromRe)) {
         const attributes = parseAttributes(fromMatch[1] ?? '');
-        if (attributes?.id === undefined || attributes.updates === undefined)
-            continue;
-        const updates = Number(attributes.updates);
-        if (!Number.isFinite(updates))
+        if (attributes?.id === undefined)
             continue;
         const entries = [];
         const entryBody = fromMatch[2] ?? '';
@@ -152,10 +149,12 @@ function parseInboxBody(body) {
                 ...(entryAttributes.ref === undefined ? {} : { ref: entryAttributes.ref }),
             });
         }
+        // `updates` and `finished` are derived from the entry list; pre-cut
+        // scrollback still carries them as attributes, honored when present.
+        const legacyUpdates = attributes.updates === undefined ? Number.NaN : Number(attributes.updates);
         senders.push({
             id: attributes.id,
-            ...(attributes.name === undefined ? {} : { name: attributes.name }),
-            updates,
+            updates: Number.isFinite(legacyUpdates) ? legacyUpdates : entries.length,
             finished: attributes.finished === 'true' || entries.some((entry) => entry.kind === 'final'),
             entries,
         });
@@ -203,15 +202,13 @@ export function parseCard(message) {
 /** Format a complete inbox card from report bodies resolved by the caller. */
 export function formatInboxCard(sections) {
     const body = sections.map((section) => {
-        const updates = section.updates ?? section.entries.length;
-        const finished = section.finished ?? section.entries.some((entry) => entry.kind === 'final');
         const entries = section.entries.map((entry) => {
             const disposition = entry.disposition === 'human-answer' || entry.disposition === 'human-canceled'
                 ? entry.disposition
                 : undefined;
             return `<entry${formatAttributes({ kind: entry.kind, ref: entry.ref, disposition })}>${escapeXmlText(entry.body)}</entry>`;
         }).join('\n');
-        return `<from${formatAttributes({ id: section.id, name: section.name, updates, finished: finished || undefined })}>${entries}</from>`;
+        return `<from${formatAttributes({ id: section.id })}>${entries}</from>`;
     }).join('\n');
     return formatCard('inbox', {}, body);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.213",
+  "version": "0.3.214",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",