@north-light/crouter 0.3.249 → 0.3.251

package/dist/daemon/manage.js

@@ -16,6 +16,7 @@ import { hostExecPath } from '../core/runtime/branded-host.js';
 import { isDaemonRunning, readPidfile, isPidAlive } from './pidfile.js';
 import { DAEMON_STARTUP_WINDOW_MS } from './startup-policy.js';
 import { envNoDaemonAutostart } from '../shared/env.js';
+import { CrtrClient } from '../api/index.js';
 // Daemon env sanitization
 /** Env keys that must NEVER reach the daemon process. Restarting crtrd is
  *  overwhelmingly done from inside an agent node's own bash tool (`crtr sys
@@ -201,6 +202,24 @@ export async function execDaemon() {
 // Shutdown stays short even though startup may include corpus migration.
 const DAEMON_SHUTDOWN_WINDOW_MS = 20_000;
 const DAEMON_VERIFY_POLL_MS = 10;
+/** A status/start readiness probe must not hang behind a daemon that accepts a
+ * Unix connection but never answers it. */
+const DAEMON_HEALTH_PROBE_TIMEOUT_MS = 1_000;
+/** True only when the mandatory Unix API socket answers `/healthz`. This is
+ * deliberately separate from `isDaemonRunning()`: a pidfile remains useful for
+ * identifying the process an operator must stop, but it is not readiness. */
+export async function isDaemonServing() {
+    try {
+        const health = await CrtrClient.forLocalSocket({
+            autostart: false,
+            timeoutMs: DAEMON_HEALTH_PROBE_TIMEOUT_MS,
+        }).healthz();
+        return health.ok;
+    }
+    catch {
+        return false;
+    }
+}
 function sleepMs(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
@@ -223,12 +242,13 @@ export async function verifyDaemonStartup(pid, timeoutMs = DAEMON_STARTUP_WINDOW
     const read = deps.readPidfile ?? readPidfile;
     const alive = deps.isPidAlive ?? isPidAlive;
     const exited = deps.childExited;
+    const serving = deps.isDaemonServing ?? isDaemonServing;
     const sleep = deps.sleepMs ?? sleepMs;
     const now = deps.now ?? Date.now;
     const deadline = now() + timeoutMs;
     while (now() <= deadline) {
         const owner = read();
-        if (owner !== null && alive(owner))
+        if (owner !== null && alive(owner) && await serving())
             return owner === pid ? null : owner;
         const exitState = exited?.();
         if (exitState !== null && exitState !== undefined) {
@@ -314,8 +334,17 @@ export async function stopDaemonProcess(pid, timeoutMs = DAEMON_SHUTDOWN_WINDOW_
  *  If the daemon is already running, returns {started:false, existing_pid}.
  *  If spawning fails (e.g. missing dist — run `npm run build` first), throws. */
 export async function spawnDaemon() {
-    if (isDaemonRunning()) {
-        return { started: false, existing_pid: readPidfile() ?? undefined };
+    const recordedPid = readPidfile();
+    if (recordedPid !== null && isPidAlive(recordedPid)) {
+        if (await isDaemonServing())
+            return { started: false, existing_pid: recordedPid };
+        return {
+            started: false,
+            existing_pid: recordedPid,
+            running: true,
+            serving: false,
+            next: 'Run `crtr sys daemon stop` to release the non-serving daemon before starting it again.',
+        };
     }
     // Ensure the canvas home directory exists so the daemon can write its pidfile.
     mkdirSync(crtrHome(), { recursive: true });

package/dist/daemon/messaging/node-message.js

@@ -1,4 +1,5 @@
 import { getNode } from '../../core/canvas/canvas.js';
+import { cancelCronsOnWake } from '../../core/canvas/crons.js';
 import { withFreshTerminalGuard } from '../../core/canvas/canvas.js';
 import { appendInbox } from '../../core/feed/inbox.js';
 import { BrokerUnreachableError } from '../../core/runtime/broker-request.js';
@@ -43,6 +44,7 @@ export async function deliverNodeMessage(args) {
             // before reporting an engine receipt so a final that committed during the
             // request is not represented as a routable delivery.
             guardRoutable(args.node_id, () => undefined);
+            cancelCronsOnWake(args.node_id);
             return { entry_id: null, via: 'engine', revived: false };
         }
         catch (error) {
@@ -57,9 +59,13 @@ export async function deliverNodeMessage(args) {
         label: args.label,
         data: { ...args.data, body: args.body },
     }));
+    if (args.mode !== 'quiet' || target.frozen_at !== null)
+        cancelCronsOnWake(args.node_id);
+    // The APPENDED entry's tier decides the wake: a quiet send to a terminal
+    // target was raised out of `deferred` by the append, and must be delivered.
     let revived = false;
     let reason;
-    if (args.mode !== 'quiet') {
+    if (entry.tier !== 'deferred') {
         target = getNode(args.node_id);
         if (target === null)
             deliveryUnroutable(args.node_id, 'origin_missing');

package/dist/daemon/reconcilers/bash-deadline.js

@@ -1,6 +1,7 @@
 import { bashJobPaths, expiredAutoBackgroundBashJobs, formatBashElapsed, stopBackgroundBashJob, } from '../../core/bash-jobs.js';
 import { isSafeNodeId } from '../../core/canvas/paths.js';
 import { contextDir } from '../../core/canvas/paths.js';
+import { cancelCronsOnWake } from '../../core/canvas/crons.js';
 import { appendInbox } from '../../core/feed/inbox.js';
 import { emitEvent } from '../../core/events/emit.js';
 import { operationIdContext } from '../../core/events/operation-id.js';
@@ -64,6 +65,7 @@ export class BashDeadlineReconciler {
                             `Log: ${paths.jobLog}  Command: ${paths.cmdSh}`,
                     },
                 });
+                cancelCronsOnWake(nodeId);
             }
             catch (err) {
                 emitEvent({ level: 'error', event: 'bash_deadline.notice_failed', ...(isSafeNodeId(nodeId) ? { node_id: nodeId } : {}), error: err, fields: { job_id: jobId } });

package/dist/daemon/reconcilers/broker-supervision.d.ts

@@ -36,6 +36,7 @@ export declare function wedgeVerdict(input: {
     busy: boolean;
     quietForMs: number | null;
     cpuPercent: number | null;
+    hasDescendants: boolean | null;
 }): WedgeVerdict;
 export declare function sumTreeCpu(psOutput: string, rootPid: number): number | null;
 export declare function treeHasDescendants(psOutput: string, rootPid: number): boolean | null;

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

@@ -61,7 +61,9 @@ export function wedgeVerdict(input) {
         return 'leave';
     if (input.quietForMs === null || input.quietForMs < WEDGE_QUIET_MS)
         return 'leave';
-    if (input.cpuPercent === null || input.cpuPercent > WEDGE_CPU_MAX_PERCENT)
+    if (input.cpuPercent === null)
+        return 'pending';
+    if (input.hasDescendants !== false && input.cpuPercent > WEDGE_CPU_MAX_PERCENT)
         return 'pending';
     return 'wedged';
 }
@@ -471,18 +473,20 @@ export class BrokerSupervisionReconciler {
         const quietForMs = since === null ? null : now - since;
         const sample = quietForMs !== null && quietForMs >= WEDGE_QUIET_MS ? await this.readTreeSample(pid) : null;
         const cpuPercent = sample?.cpuPercent ?? null;
-        if (wedgeVerdict({ busy: true, quietForMs, cpuPercent }) !== 'wedged')
+        const sampleHasDescendants = sample?.hasDescendants ?? null;
+        if (wedgeVerdict({ busy: true, quietForMs, cpuPercent, hasDescendants: sampleHasDescendants }) !== 'wedged')
             return;
         if (since !== null && this.wedgeNotifiedAt.get(id) === since)
             return;
-        if (sample?.hasDescendants === false && (expectedIdentity == null || recordedPidLiveness(pid, expectedIdentity) !== 'alive'))
-            return;
         if (since !== null)
             this.wedgeNotifiedAt.set(id, since);
         const meta = getNode(id);
         const name = meta !== null ? fullName(meta) : id;
         const minutes = Math.round((quietForMs ?? WEDGE_QUIET_MS) / 60_000);
-        const hasDescendants = sample?.hasDescendants ?? true;
+        const hasDescendants = sampleHasDescendants ?? true;
+        const kickSuppressionReason = !hasDescendants && (expectedIdentity == null || recordedPidLiveness(pid, expectedIdentity) !== 'alive')
+            ? 'pid_identity_unproven'
+            : null;
         let label;
         if (hasDescendants) {
             label =
@@ -491,11 +495,18 @@ export class BrokerSupervisionReconciler {
                     `\`crtr memory read wedged-child-on-runaway-bash\` and kill the runaway SUBPROCESS (not this ` +
                     `node) so its turn can resume with no lost context.`;
         }
+        else if (kickSuppressionReason !== null) {
+            label =
+                `Child wedged — ${name} (${id}) is alive and mid-turn but has shown NO engine progress for ` +
+                    `${minutes}+ minutes and it has no subprocess to kill (the engine itself stalled). The daemon did ` +
+                    `not SIGTERM the broker because its PID identity cannot be ` +
+                    `confirmed alive.`;
+        }
         else {
             label =
                 `Child wedged — ${name} (${id}) is alive and mid-turn but has shown NO engine progress for ` +
-                    `${minutes}+ minutes, its process is near-idle, AND it has no subprocess to kill (the engine ` +
-                    `itself stalled). Kicking it now: SIGTERM to the broker — the daemon will resume a cleanly ` +
+                    `${minutes}+ minutes and it has no subprocess to kill (the engine itself stalled). Kicking it ` +
+                    `now: SIGTERM to the broker — the daemon will resume a cleanly ` +
                     `aborted session with a continuation, or start a recovery cycle if the abort cannot settle.`;
             try {
                 process.kill(pid, 'SIGTERM');
@@ -514,7 +525,8 @@ export class BrokerSupervisionReconciler {
                 quiet_ms: quietForMs,
                 cpu_percent: cpuPercent,
                 has_descendants: hasDescendants,
-                kicked: !hasDescendants,
+                kicked: !hasDescendants && kickSuppressionReason === null,
+                ...(kickSuppressionReason === null ? {} : { kick_suppression_reason: kickSuppressionReason }),
             },
         });
         try {
@@ -539,7 +551,8 @@ export class BrokerSupervisionReconciler {
             child: id,
             quiet_ms: quietForMs,
             cpu_percent: cpuPercent,
-            kicked: !hasDescendants,
+            kicked: !hasDescendants && kickSuppressionReason === null,
+            ...(kickSuppressionReason === null ? {} : { kick_suppression_reason: kickSuppressionReason }),
         });
     }
     handleFatalFault(id) {

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

@@ -25,16 +25,26 @@ export declare function hasPendingWake(nodeId: string): boolean;
  *              report is an outstanding deliverable, so such a node keeps its
  *              wakeable idle row instead of being written off.
  *
- *  Undelivered mail of ANY tier also holds the row. A deferred-only unseen set
- *  never wakes a node on its own — it rides the next natural cycle — but a
- *  terminalized row no longer takes that cycle, so writing one off would drop
- *  content the sender already handed over.
+ *  Undelivered mail holds the row, with one carve-out: a deferred-only unseen
+ *  set does not hold a RESIDENT. Deferred mail never wakes a node on its own,
+ *  and parking a resident is reversible — a message sent to it revives it and
+ *  flushes the held mail on that cycle. A terminalized row takes no such
+ *  cycle, so unread mail of any tier keeps it from being written off: the
+ *  invariant is that content a sender already handed over is never dropped.
  */
 export type ParkEvent = Extract<LifecycleEvent, 'release' | 'park' | 'cancel'>;
 export declare function parkEvent(nodeId: string, lifecycle: Lifecycle): ParkEvent;
 /** 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 declare function applyParkEvent(nodeId: string, event: ParkEvent): void;

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;