@north-light/crouter 0.3.249 → 0.3.250

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

@@ -1,4 +1,4 @@
-import { hasActiveLiveSubscription, hasLiveMessageWait, hasLiveSubscriber, hasPendingCancelOnWakeCron, subscribersOf, } from '../../core/canvas/index.js';
+import { newestReportRef, hasActiveLiveSubscription, hasLiveMessageWait, hasLiveSubscriber, hasPendingCancelOnWakeCron, subscribersOf, } from '../../core/canvas/index.js';
 import { fullName } from '../../core/canvas/labels.js';
 import { countTickets } from '../../core/canvas/attention.js';
 import { hasUnseenWakeMail, readCursor, readInboxSince } from '../../core/feed/inbox.js';
@@ -33,22 +33,34 @@ export function hasPendingWake(nodeId) {
 export function parkEvent(nodeId, lifecycle) {
     if (hasLiveObligation(nodeId))
         return 'release';
+    if (lifecycle === 'resident')
+        return hasUnseenWakeMail(nodeId) ? 'release' : 'park';
     if (readInboxSince(nodeId, readCursor(nodeId)).length > 0)
         return 'release';
-    if (lifecycle === 'resident')
-        return 'park';
     return hasLiveSubscriber(nodeId) ? 'release' : 'cancel';
 }
 /** Apply an unattended decision and notify subscribers of automatic completion.
  *  This is the DEGRADED enactment: no summary turn ran, so subscribers get the
- *  doctrine wake instead of the node's own report. The live clock's good path
+ *  doctrine notice instead of the node's own report. The live clock's good path
  *  (broker settlement after a parking turn) enacts `park` directly and fans
- *  nothing — the node's report is the notice. */
+ *  nothing — the node's report is the notice.
+ *
+ *  The notice is DEFERRED: a node settling quietly at the end of its unattended
+ *  grace is not an event worth starting a manager's cycle for, so it rides the
+ *  manager's next natural cycle and arrives alongside whatever does.
+ *
+ *  Only `park` fans, and only a resident parks, so the notice speaks about a
+ *  resident throughout: its conversation ended without a final report, its state
+ *  lives in whatever report it did leave, and a message reopens it. */
 export function applyParkEvent(nodeId, event) {
     const node = event === 'cancel'
         ? transition(nodeId, event, { reason: 'stranded' })
         : transition(nodeId, event);
     if (event !== 'park')
         return;
-    fanDoctrineWake(nodeId, subscribersOf(nodeId), `Child done — ${fullName(node)} (${nodeId}) was automatically marked done after its unattended grace with nothing left to wake it. It sent no final report.`, { reason: 'child-auto-done', child: nodeId });
+    const ref = newestReportRef(nodeId);
+    const pointer = ref === null
+        ? `It left no report behind; \`crtr node inspect show ${nodeId}\` shows where it stands.`
+        : `Its latest report is where it left things: \`crtr canvas history read ${ref}\`.`;
+    fanDoctrineWake(nodeId, subscribersOf(nodeId), `Resident concluded — ${fullName(node)} (${nodeId}) had nothing left to wake it through its unattended grace, so its conversation was concluded. It submitted no final report. ${pointer} A message to it reopens it on a fresh cycle.`, { reason: 'child-auto-done', child: nodeId }, 'deferred');
 }

package/dist/daemon/reconcilers/node-lifecycle/respawn-policy.d.ts

@@ -1,5 +1,16 @@
-import type { NodeRow } from '../../../core/canvas/index.js';
-/** Whether a durable backoff still holds this row back from a relaunch. A row
- *  in backoff holds no slot and is excluded from the saturation figure — it is
- *  waiting on a clock, not on capacity. */
+import { type NodeRow } from '../../../core/canvas/index.js';
+export declare const MAX_RESPAWN_ATTEMPTS = 6;
+export declare function respawnBackoffMs(consecutiveFailures: number): number;
+export interface RespawnAttempt {
+    failures: number;
+    notBefore: string | null;
+    exhausted: boolean;
+}
+/** Whether a durable backoff still holds this row back from a relaunch. */
 export declare function isInBackoff(row: NodeRow, now: number): boolean;
+/** The only respawn-failure policy: progress since launch clears the sequence;
+ * every other missing-engine observation advances it and records its backoff. */
+export declare function decideRespawnAttempt(row: Pick<NodeRow, 'last_settled_at' | 'launched_at' | 'respawn_failures'>, now: number): RespawnAttempt;
+/** Persist the policy decision through the daemon-only canvas writer. */
+export declare function recordRespawnPolicy(row: NodeRow, now: number): RespawnAttempt;
+export declare function clearRespawnPolicy(nodeId: string): void;

package/dist/daemon/reconcilers/node-lifecycle/respawn-policy.js

@@ -1,6 +1,13 @@
-/** Whether a durable backoff still holds this row back from a relaunch. A row
- *  in backoff holds no slot and is excluded from the saturation figure — it is
- *  waiting on a clock, not on capacity. */
+import { recordRespawnAttempt } from '../../../core/canvas/index.js';
+export const MAX_RESPAWN_ATTEMPTS = 6;
+const RESPAWN_BACKOFF_BASE_MS = 5_000;
+const RESPAWN_BACKOFF_MAX_MS = 10 * 60_000;
+export function respawnBackoffMs(consecutiveFailures) {
+    if (consecutiveFailures <= 0)
+        return 0;
+    return Math.min(RESPAWN_BACKOFF_BASE_MS * 2 ** (consecutiveFailures - 1), RESPAWN_BACKOFF_MAX_MS);
+}
+/** Whether a durable backoff still holds this row back from a relaunch. */
 export function isInBackoff(row, now) {
     const notBefore = row.respawn_not_before;
     if (notBefore == null)
@@ -8,3 +15,27 @@ export function isInBackoff(row, now) {
     const at = Date.parse(notBefore);
     return Number.isFinite(at) && now < at;
 }
+/** The only respawn-failure policy: progress since launch clears the sequence;
+ * every other missing-engine observation advances it and records its backoff. */
+export function decideRespawnAttempt(row, now) {
+    const settledAt = row.last_settled_at == null ? Number.NaN : Date.parse(row.last_settled_at);
+    const launchedAt = row.launched_at == null ? Number.NaN : Date.parse(row.launched_at);
+    if (Number.isFinite(settledAt) && Number.isFinite(launchedAt) && settledAt > launchedAt) {
+        return { failures: 0, notBefore: null, exhausted: false };
+    }
+    const failures = (row.respawn_failures ?? 0) + 1;
+    return {
+        failures,
+        notBefore: new Date(now + respawnBackoffMs(failures)).toISOString(),
+        exhausted: failures >= MAX_RESPAWN_ATTEMPTS,
+    };
+}
+/** Persist the policy decision through the daemon-only canvas writer. */
+export function recordRespawnPolicy(row, now) {
+    const attempt = decideRespawnAttempt(row, now);
+    recordRespawnAttempt(row.node_id, { failures: attempt.failures, notBefore: attempt.notBefore });
+    return attempt;
+}
+export function clearRespawnPolicy(nodeId) {
+    recordRespawnAttempt(nodeId, { failures: 0, notBefore: null });
+}

package/dist/daemon/reconcilers/node-lifecycle/terminating.d.ts

@@ -1,2 +1,5 @@
 import type { NodeRow } from '../../../core/canvas/index.js';
-export declare function handleTerminatingRow(row: NodeRow): void;
+/** Request teardown only while a terminal row still has a daemon handle or a
+ * provably live recorded process. An indeterminate pid is left for the next
+ * tick: uncertainty never authorizes a signal. */
+export declare function handleTerminatingRow(row: NodeRow, hasFleetHandle: boolean): boolean;

package/dist/daemon/reconcilers/node-lifecycle/terminating.js

@@ -1,3 +1,12 @@
-export function handleTerminatingRow(row) {
-    void row;
+import { recordedPidLiveness } from '../../../core/canvas/pid.js';
+import { requestBrokerTeardown } from '../../../core/runtime/host.js';
+/** Request teardown only while a terminal row still has a daemon handle or a
+ * provably live recorded process. An indeterminate pid is left for the next
+ * tick: uncertainty never authorizes a signal. */
+export function handleTerminatingRow(row, hasFleetHandle) {
+    if (!hasFleetHandle && (row.pi_pid == null || recordedPidLiveness(row.pi_pid, row.pi_pid_identity) !== 'alive')) {
+        return false;
+    }
+    requestBrokerTeardown(row.node_id);
+    return true;
 }

package/dist/daemon/reconcilers/node-lifecycle/tick.js

@@ -59,18 +59,21 @@ export class NodeLifecycleReconciler {
     }
     async classifyRow(now, row, ctx, candidates) {
         const id = row.node_id;
+        if (isTerminal(row)) {
+            if (handleTerminatingRow(row, ctx.fleet.has(id)))
+                return;
+            if (row.pi_pid != null && recordedPidLiveness(row.pi_pid, row.pi_pid_identity) === 'dead') {
+                clearRecordedPid(id);
+            }
+            if (row.frozen_at != null)
+                candidates.push({ row, enact: 'thaw' });
+            return;
+        }
         // 1. A fleet handle IS execution. Whatever froze this row is over.
         if (ctx.fleet.has(id)) {
             this.thawMark(row);
             return;
         }
-        if (isTerminal(row)) {
-            if (row.pi_pid != null)
-                handleTerminatingRow(row);
-            else if (row.frozen_at != null)
-                candidates.push({ row, enact: 'thaw' });
-            return;
-        }
         // A paused profile launches nothing, and its stuck-delivery episode is over
         // rather than merely stalled — the pause is not a delivery failure.
         if (isProfilePaused(row.profile_id)) {
@@ -101,6 +104,10 @@ export class NodeLifecycleReconciler {
         //    its way to the launch seam, which owns its own launch and must be left
         //    alone rather than raced or written off as a boot failure.
         if (row.pi_pid == null) {
+            if (row.respawn_not_before != null) {
+                candidates.push({ row, enact: 'policy' });
+                return;
+            }
             if (row.frozen_at != null)
                 candidates.push({ row, enact: 'thaw' });
             return;

package/dist/daemon/reconcilers/storage-maintenance.d.ts

@@ -13,8 +13,8 @@ export declare class StorageMaintenanceReconciler {
     /** Milliseconds since meta/telemetry was last written. Inbox activity is
      * deliberately excluded: children can keep writing a dead manager's inbox. */
     private msSinceDiskActivity;
-    /** Reap only the physical placement residue of long-dead nodes. The durable
-     * row, graph, and on-disk state remain available for a later manual revive. */
+    /** Reap only physical placement residue of terminal nodes. The durable row,
+     * graph, and on-disk state remain available for a later manual revive. */
     private reapDeadResidue;
     /** Delete focus rows whose recorded tmux pane no longer exists. A failed tmux
      * probe is "can't tell" and never authorizes deleting every viewport. */

package/dist/daemon/reconcilers/storage-maintenance.js

@@ -66,12 +66,12 @@ export class StorageMaintenanceReconciler {
         }
         return latest === 0 ? Number.POSITIVE_INFINITY : now - latest;
     }
-    /** Reap only the physical placement residue of long-dead nodes. The durable
-     * row, graph, and on-disk state remain available for a later manual revive. */
+    /** Reap only physical placement residue of terminal nodes. The durable row,
+     * graph, and on-disk state remain available for a later manual revive. */
     reapDeadResidue(now) {
         let rows;
         try {
-            rows = listNodes({ status: ['dead'] });
+            rows = listNodes({ status: ['done', 'canceled', 'dead'] });
         }
         catch (err) {
             operationIdContext.fresh(() => {

package/dist/pi-extensions/__tests__/canvas-stophook-agentend.test.js

@@ -186,7 +186,7 @@ test('gh-451: finished does NOT shut down while a non-deferred inbox entry sits
     assert.equal(getNode('mgr')?.intent ?? null, null, 'no idle-release intent while a non-deferred entry is unseen');
     assert.equal(shutdown, false, 'pi stays alive so the in-process watcher can still deliver/commit');
 });
-test('gh-451: a DEFERRED-only unseen entry does not block idle-release (matches the daemon\'s own wake gate)', { timeout: 1_000 }, async () => {
+test('a deferred send to a TERMINAL node was raised on append, so it holds the settle instead of riding a later cycle', { timeout: 1_000 }, async () => {
     createNode(node('root', { parent: null, lifecycle: 'resident' }));
     createNode(node('mgr', { parent: 'root', lifecycle: 'terminal', mode: 'orchestrator' }));
     createNode(node('worker', { parent: 'mgr', lifecycle: 'terminal', status: 'active' }));
@@ -199,9 +199,9 @@ test('gh-451: a DEFERRED-only unseen entry does not block idle-release (matches
     let shutdown = false;
     const ctx = { shutdown: () => { shutdown = true; } };
     await settle(pi, stopEvent('still waiting on the worker'), ctx);
-    assert.equal(getNode('mgr')?.intent, 'idle-release', 'a deferred-only unseen entry does not block release (#341 parity)');
-    assert.equal(getNode('mgr')?.status, 'idle');
-    assert.equal(shutdown, true, 'pi shuts down — deferred entries ride the next natural cycle, not this settle');
+    assert.equal(getNode('mgr')?.intent ?? null, null, 'a terminal node takes no reliable later cycle, so its raised entry blocks the release');
+    assert.equal(getNode('mgr')?.status, 'active', 'mgr stays active for the entry the watcher still owes it');
+    assert.equal(shutdown, false, 'pi stays alive so the in-process watcher can deliver it');
 });
 test('queued continuation finishes before natural-stop routing commits', { timeout: 1_000 }, async () => {
     createNode(node('leaf', { parent: null, lifecycle: 'terminal' }));

package/dist/pi-extensions/canvas-context-intro.d.ts

@@ -23,8 +23,9 @@ interface SessionEntryLike {
 }
 interface SessionStartCtxLike {
     sessionManager: {
-        getEntries: () => SessionEntryLike[];
-        getBranch?: (fromId?: string) => SessionEntryLike[];
+        /** Required by pi's `ReadonlySessionManager`: the active branch, which is
+         *  the context the next turn actually sees. */
+        getBranch: (fromId?: string) => SessionEntryLike[];
     };
 }
 interface CustomMessageLike {
@@ -37,35 +38,12 @@ interface CustomMessageLike {
         nodeId: string;
     };
 }
-/** The message handed to a message renderer. `content` is normally the string we
- *  sent, but pi types it as string-or-blocks, so we handle both. */
-interface RenderedMessageLike {
-    customType: string;
-    content: string | Array<{
-        type: string;
-        text?: string;
-    }>;
-}
-/** Minimal structural match for pi-tui's `Component` (render + invalidate). A
- *  plain object of this shape is a valid child for pi's Container. */
-interface ComponentLike {
-    render: (width: number) => string[];
-    invalidate: () => void;
-}
-/** Subset of pi's `Theme` we touch — `fg(color, text)` wraps text in ANSI. Used
- *  defensively (falls back to plain text if absent). */
-interface ThemeLike {
-    fg?: (color: string, text: string) => string;
-}
 interface PiLike {
     on: (event: 'session_start', handler: (event: unknown, ctx: SessionStartCtxLike) => void | Promise<void>) => void;
     sendMessage: (message: CustomMessageLike, options?: {
         deliverAs?: string;
         triggerTurn?: boolean;
     }) => void;
-    registerMessageRenderer: (customType: string, renderer: (message: RenderedMessageLike, options: {
-        expanded?: boolean;
-    }, theme: ThemeLike) => ComponentLike | undefined) => void;
 }
 /** Build the full bearings baseline for a conversation without inherited
  *  crouter context. Exported for testing. */
@@ -73,15 +51,6 @@ export declare function buildContextIntro(nodeId: string, target?: ExposureTarge
 /** Build the compact node-scoped update for a fork whose copied branch already
  *  carries a full crouter baseline. Exported for testing. */
 export declare function buildForkContextIntro(nodeId: string): Promise<string>;
-/**
- * Renderer for `crtr-context` messages. Collapsed (default) shows a one-line
- * stub; expanded (Ctrl+O) shows the label + full body. Returns a plain object
- * matching pi's structural `Component` interface — no pi-tui import. Exported for
- * testing.
- */
-export declare function renderContextMessage(message: RenderedMessageLike, options: {
-    expanded?: boolean;
-}, theme: ThemeLike): ComponentLike;
 /** Register new-context baseline assembly; a strict resume changes nothing. */
 export declare function registerCanvasContextIntro(pi: PiLike): void;
 export default registerCanvasContextIntro;

package/dist/pi-extensions/canvas-context-intro.js

@@ -11,26 +11,16 @@
 // stamp and receives a new baseline. The preference snapshot and persona
 // acknowledgment persist only after Pi materializes that baseline.
 //
-// COLLAPSED BY DEFAULT: a `registerMessageRenderer` keyed to our customType
-// renders the block as a single one-line stub; the full body only appears when
-// the user expands tool output (Ctrl+O / `app.tools.expand`). pi drives this via
-// `CustomMessageComponent.setExpanded(toolOutputExpanded)`, so the same toggle
-// that expands tool results expands the bearings. The renderer returns a plain
-// object satisfying pi's structural `Component` interface ({ render, invalidate })
-// — no pi-tui class needed. The LLM always sees the full `content` regardless of
-// how it renders; the renderer is display-only.
-//
 // Plain TS-with-types — no imports from @earendil-works/* so this compiles inside
 // crouter's own tsc build without a dep on the pi packages.
 import { envNodeId } from '../shared/env.js';
-import { CONTEXT_INTRO_CUSTOM_TYPE, formatCard, parseCard } from '../shared/generated-context.js';
+import { CONTEXT_INTRO_CUSTOM_TYPE, formatCard } from '../shared/generated-context.js';
 import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { buildContextBearingsFromState, buildForkBearingsFromState, buildProjectContextBlockForBroker, renderPreferencesFromState, } from '../core/runtime/broker-extension-render.js';
 import { acknowledgePersonaBaseline } from '../core/runtime/broker-persona-guidance.js';
 import { situationalContextEnvelope } from '../core/runtime/situational-context.js';
 import { clearContextExposureState, cloneTranscriptExposureState, emptyContextExposureState, exposureTarget, freezePreferenceSnapshot, hasTranscriptExposure, loadContextExposureState, replaceContextExposureState, saveContextExposureState, sharedContextExposureState, } from '../core/substrate/injected-store.js';
 import { clearSessionCache } from '../core/substrate/session-cache.js';
-import { truncateToWidth } from './truncate.js';
 /** The `customType` stamped on the injected session message. Used both to write
  *  the entry and to detect it on resume (the idempotency guard). Defined beside
  *  the block builder in `core/runtime/bearings.ts` because the warm-pool claim's
@@ -49,16 +39,7 @@ export async function buildForkContextIntro(nodeId) {
     const state = await brokerExtensionState(nodeId);
     return buildForkBearingsFromState(state, situationalContextEnvelope(nodeId) ?? '');
 }
-// Collapsed-by-default rendering
-/** Pull the plain text out of a custom message's content (string or blocks). */
-function messageText(message) {
-    if (typeof message.content === 'string')
-        return message.content;
-    return message.content
-        .filter((c) => c.type === 'text' && typeof c.text === 'string')
-        .map((c) => c.text)
-        .join('\n');
-}
+// Message extraction
 /** Plain text of a session entry's content (string or text blocks), '' when
  *  absent. Used by the idempotency guard to tell OUR own injected bearings
  *  (which name our node id) from a SOURCE's bearings copied in by `--fork-from`. */
@@ -74,62 +55,9 @@ function entryText(e) {
     }
     return '';
 }
-function activeBranch(ctx) {
-    return typeof ctx.sessionManager.getBranch === 'function'
-        ? ctx.sessionManager.getBranch()
-        : ctx.sessionManager.getEntries();
-}
-/** Hard-wrap a single logical line to `width` columns (content carries no ANSI).
- *  Code-point aware so wide-string slicing never splits a surrogate pair; the
- *  bearings prose is plain text, so code-point count == visible columns. */
-function wrapLine(line, width) {
-    if (width <= 0)
-        return [''];
-    const chars = Array.from(line);
-    if (chars.length <= width)
-        return [line];
-    const out = [];
-    for (let i = 0; i < chars.length; i += width)
-        out.push(chars.slice(i, i + width).join(''));
-    return out;
-}
-/**
- * Renderer for `crtr-context` messages. Collapsed (default) shows a one-line
- * stub; expanded (Ctrl+O) shows the label + full body. Returns a plain object
- * matching pi's structural `Component` interface — no pi-tui import. Exported for
- * testing.
- */
-export function renderContextMessage(message, options, theme) {
-    const expanded = options?.expanded === true;
-    const paint = (color, text) => typeof theme?.fg === 'function' ? theme.fg(color, text) : text;
-    return {
-        render(width) {
-            const w = typeof width === 'number' && width > 0 ? width : 80;
-            if (!expanded) {
-                // Truncate BEFORE painting so the ANSI wrapper never inflates the
-                // measured width; an over-wide line aborts pi's entire TUI render.
-                const stub = `[${CONTEXT_INTRO_CUSTOM_TYPE}] orienting bearings — ctrl+o to expand`;
-                return [paint('dim', truncateToWidth(stub, w))];
-            }
-            const lines = [paint('customMessageLabel', truncateToWidth(`[${CONTEXT_INTRO_CUSTOM_TYPE}]`, w)), ''];
-            const body = parseCard({ role: 'custom', customType: message.customType, content: messageText(message) })?.body ?? messageText(message);
-            for (const raw of body.split('\n')) {
-                for (const wrapped of wrapLine(raw, w))
-                    lines.push(paint('customMessageText', wrapped));
-            }
-            return lines;
-        },
-        invalidate() {
-            /* stateless — nothing to clear */
-        },
-    };
-}
 // Extension
 /** Register new-context baseline assembly; a strict resume changes nothing. */
 export function registerCanvasContextIntro(pi) {
-    // Collapse the block to a one-liner until the user expands tool output (Ctrl+O).
-    // Harmless to register outside TUI mode (it's only consulted while rendering).
-    pi.registerMessageRenderer(CONTEXT_INTRO_CUSTOM_TYPE, renderContextMessage);
     pi.on('session_start', async (event, ctx) => {
         const nodeId = envNodeId();
         if (nodeId === undefined || nodeId.trim() === '')
@@ -150,7 +78,7 @@ export function registerCanvasContextIntro(pi) {
         }
         // The active branch, rather than the whole session file, is the context the
         // next turn sees. A new cycle therefore receives its own current baseline.
-        const contextEntries = activeBranch(ctx).filter((e) => e.type === 'custom_message' && e.customType === CONTEXT_INTRO_CUSTOM_TYPE);
+        const contextEntries = ctx.sessionManager.getBranch().filter((e) => e.type === 'custom_message' && e.customType === CONTEXT_INTRO_CUSTOM_TYPE);
         const ours = contextEntries.some((e) => e.details?.nodeId === nodeId || entryText(e).includes(nodeId));
         if (ours)
             return;
@@ -170,7 +98,7 @@ export function registerCanvasContextIntro(pi) {
             display: true,
             details: { nodeId },
         });
-        const delivered = activeBranch(ctx).some((entry) => entry.type === 'custom_message'
+        const delivered = ctx.sessionManager.getBranch().some((entry) => entry.type === 'custom_message'
             && entry.customType === CONTEXT_INTRO_CUSTOM_TYPE
             && entry.details?.nodeId === nodeId
             && entryText(entry) === messageContent);

package/dist/pi-extensions/canvas-review-boundary.d.ts

@@ -7,8 +7,9 @@ interface SessionEntryLike {
 }
 interface SessionStartCtxLike {
     sessionManager: {
-        getEntries: () => SessionEntryLike[];
-        getBranch?: (fromId?: string) => SessionEntryLike[];
+        /** Required by pi's `ReadonlySessionManager`: the active branch, which is
+         * the context the next turn actually sees. */
+        getBranch: (fromId?: string) => SessionEntryLike[];
     };
 }
 interface CustomMessageLike {
@@ -25,35 +26,13 @@ interface CustomMessageLike {
         kind: 'review' | 'page_feedback';
     };
 }
-interface RenderedMessageLike {
-    customType: string;
-    content: string | Array<{
-        type: string;
-        text?: string;
-    }>;
-}
-interface ComponentLike {
-    render: (width: number) => string[];
-    invalidate: () => void;
-}
-interface ThemeLike {
-    fg?: (color: string, text: string) => string;
-}
 interface PiLike {
     on: (event: 'session_start', handler: (event: unknown, ctx: SessionStartCtxLike) => void | Promise<void>) => void;
     sendMessage: (message: CustomMessageLike, options?: {
         deliverAs?: string;
         triggerTurn?: boolean;
     }) => void;
-    registerMessageRenderer: (customType: string, renderer: (message: RenderedMessageLike, options: {
-        expanded?: boolean;
-    }, theme: ThemeLike) => ComponentLike | undefined) => void;
 }
-/** Render the marker as a single compact divider; its full content remains in
- * the message list for the model and generated-context presenters. */
-export declare function renderReviewBoundary(message: RenderedMessageLike, options: {
-    expanded?: boolean;
-}, theme: ThemeLike): ComponentLike;
 /**
  * Register the review boundary marker. Companion nodes receive one boundary
  * marker on session_start that separates inherited context from the visible

package/dist/pi-extensions/canvas-review-boundary.js

@@ -7,30 +7,7 @@
 import { envNodeId } from '../shared/env.js';
 import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { isReviewBoundary, REVIEW_BOUNDARY_CUSTOM_TYPE } from '../core/runtime/session-visibility.js';
-import { formatCard, parseCard } from '../shared/generated-context.js';
-import { truncateToWidth } from './truncate.js';
-// Collapsed-by-default rendering
-/** Render the marker as a single compact divider; its full content remains in
- * the message list for the model and generated-context presenters. */
-export function renderReviewBoundary(message, options, theme) {
-    const paint = (color, text) => typeof theme?.fg === 'function' ? theme.fg(color, text) : text;
-    const text = typeof message.content === 'string'
-        ? message.content
-        : message.content.filter((block) => block.type === 'text' && typeof block.text === 'string').map((block) => block.text).join('\n');
-    const body = parseCard({ role: 'custom', customType: message.customType, content: text })?.body ?? text;
-    return {
-        render(width) {
-            const w = typeof width === 'number' && width > 0 ? width : 80;
-            const divider = paint('dim', truncateToWidth('[review boundary] earlier conversation is not shown', w));
-            if (options?.expanded !== true)
-                return [divider];
-            return [divider, '', ...body.split('\n').map((line) => paint('customMessageText', truncateToWidth(line, w)))];
-        },
-        invalidate() {
-            /* stateless — nothing to clear */
-        },
-    };
-}
+import { formatCard } from '../shared/generated-context.js';
 // Extension
 /**
  * Register the review boundary marker. Companion nodes receive one boundary
@@ -38,7 +15,6 @@ export function renderReviewBoundary(message, options, theme) {
  * transcript. Ordinary nodes get nothing.
  */
 export function registerCanvasReviewBoundary(pi) {
-    pi.registerMessageRenderer(REVIEW_BOUNDARY_CUSTOM_TYPE, renderReviewBoundary);
     pi.on('session_start', async (_event, ctx) => {
         const nodeId = envNodeId();
         if (!nodeId || nodeId.trim() === '')
@@ -54,10 +30,9 @@ export function registerCanvasReviewBoundary(pi) {
             return;
         // The active branch, not the whole session file, is the context the next
         // turn sees. Check for an existing boundary marker on this branch.
-        const scan = typeof ctx.sessionManager.getBranch === 'function'
-            ? ctx.sessionManager.getBranch()
-            : ctx.sessionManager.getEntries();
-        const alreadyMarked = scan.some((entry) => isReviewBoundary(entry, node.review_binding?.review_id));
+        const alreadyMarked = ctx.sessionManager
+            .getBranch()
+            .some((entry) => isReviewBoundary(entry, node.review_binding?.review_id));
         if (alreadyMarked)
             return;
         const binding = node.review_binding;

package/dist/pi-extensions/canvas-stophook.js

@@ -94,12 +94,7 @@ function lastAssistantMessage(messages) {
  * Pi-owned fact; crtrd compares it with the node's daemon-owned review binding. */
 function currentReviewBoundaryIds(ctx) {
     try {
-        const manager = ctx?.sessionManager;
-        const entries = typeof manager?.getBranch === 'function'
-            ? manager.getBranch()
-            : typeof manager?.getEntries === 'function'
-                ? manager.getEntries()
-                : [];
+        const entries = ctx?.sessionManager?.getBranch();
         if (!Array.isArray(entries))
             return [];
         const ids = new Set();

package/dist/shared/birth-announcement.d.ts

@@ -0,0 +1,12 @@
+/** The entry marker keeps delivery-time rendering exclusive to birth notices. */
+export declare const BIRTH_ANNOUNCEMENT_MARKER = "crtr.birth-announcement.v1";
+export declare const BIRTH_ANNOUNCEMENT_AGE_TOKEN = "[[CRTR_BIRTH_ANNOUNCEMENT_AGE]]";
+export declare function birthAnnouncementBody(child: {
+    name: string;
+    nodeId: string;
+    kind: string;
+    creator: string;
+}): string;
+export declare function birthAnnouncementAge(createdAt: string, now?: number): string;
+/** Return a birth notice's body rendered at delivery, or null for every other entry. */
+export declare function renderBirthAnnouncementBody(data: Record<string, unknown> | undefined, createdAt: string, now?: number): string | null;

package/dist/shared/birth-announcement.js

@@ -0,0 +1,25 @@
+/** The entry marker keeps delivery-time rendering exclusive to birth notices. */
+export const BIRTH_ANNOUNCEMENT_MARKER = 'crtr.birth-announcement.v1';
+export const BIRTH_ANNOUNCEMENT_AGE_TOKEN = '[[CRTR_BIRTH_ANNOUNCEMENT_AGE]]';
+export function birthAnnouncementBody(child) {
+    return `${child.name} (${child.nodeId}, ${child.kind}) was created under you by ${child.creator} ${BIRTH_ANNOUNCEMENT_AGE_TOKEN} ago. For your awareness only — no response or action is needed, and no need to mention it unless asked. Treat its future reports as background you already know about; investigate only if something genuinely needs you.`;
+}
+export function birthAnnouncementAge(createdAt, now = Date.now()) {
+    const elapsed = Math.max(0, now - Date.parse(createdAt));
+    if (elapsed < 60_000)
+        return 'moments';
+    const minutes = Math.floor(elapsed / 60_000);
+    if (minutes < 60)
+        return `${minutes} minute${minutes === 1 ? '' : 's'}`;
+    const hours = Math.floor(elapsed / 3_600_000);
+    if (hours < 48)
+        return `${hours} hour${hours === 1 ? '' : 's'}`;
+    const days = Math.floor(elapsed / 86_400_000);
+    return `${days} day${days === 1 ? '' : 's'}`;
+}
+/** Return a birth notice's body rendered at delivery, or null for every other entry. */
+export function renderBirthAnnouncementBody(data, createdAt, now = Date.now()) {
+    if (data?.['birth_announcement'] !== BIRTH_ANNOUNCEMENT_MARKER || typeof data['body'] !== 'string')
+        return null;
+    return data['body'].replace(BIRTH_ANNOUNCEMENT_AGE_TOKEN, birthAnnouncementAge(createdAt, now));
+}

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

@@ -10,10 +10,14 @@ export declare const REVIEW_BOUNDARY_CUSTOM_TYPE = "crtr-review-boundary";
 export declare const STALL_REPROMPT: string;
 /** The daemon's parking mandate: the last turn of a conversation the unattended
  *  clock is concluding. Delivered live, wrapped in a `park` runtime card. It
- *  shares a CONTRACT with `node yield`'s pre-invocation guide (roadmap current,
- *  short and shrinking; context dir for in-progress material; memory only for
- *  gated permanent lessons) but not a string: yield is read by an agent choosing
- *  to refresh, this by an agent being told to conclude. */
+ *  governs both the node's durable inheritance and reader-facing output:
+ *  one update for subscribers and history, then a goodbye that does not narrate
+ *  the parking.
+ *
+ *  The durable inheritance shares a CONTRACT with `node yield`'s pre-invocation
+ *  guide (roadmap current, short and shrinking; context dir for in-progress
+ *  material; memory only for gated permanent lessons) but not a string: yield is
+ *  read by an agent choosing to refresh, this by an agent being told to conclude. */
 export declare const PARK_SUMMARY_PROMPT: string;
 /** Static recovery prompts shared by the broker producer and display classifier. */
 export declare const AUTH_FAULT_RECOVERY_BODY = "Provider credentials were just updated (a new login landed). Your previous turn stopped on a provider authentication failure. Continue from where you left off and retry the work that failed.";