@north-light/crouter 0.3.170 → 0.3.172

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

@@ -0,0 +1,59 @@
+interface SessionEntryLike {
+    type: string;
+    customType?: string;
+    details?: {
+        reviewId?: string;
+    };
+}
+interface SessionStartCtxLike {
+    sessionManager: {
+        getEntries: () => SessionEntryLike[];
+        getBranch?: (fromId?: string) => SessionEntryLike[];
+    };
+}
+interface CustomMessageLike {
+    customType: string;
+    content: string;
+    display?: boolean;
+    details?: {
+        reviewId: string;
+        originNodeId: string;
+        targetFile: string;
+    };
+}
+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
+ * transcript. Ordinary nodes get nothing.
+ */
+export declare function registerCanvasReviewBoundary(pi: PiLike): void;
+export default registerCanvasReviewBoundary;

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

@@ -0,0 +1,81 @@
+// canvas-review-boundary.ts — durable visible-transcript boundary for review companions.
+//
+// On session_start, a review companion appends one custom_message after its
+// inherited fork context and before canvas-context-intro appends fork bearings.
+// The display projection starts at this marker while the model keeps the full
+// inherited context.
+import { getNode } from '../core/canvas/index.js';
+import { isReviewBoundary, REVIEW_BOUNDARY_CUSTOM_TYPE } from '../core/runtime/session-visibility.js';
+// ---------------------------------------------------------------------------
+// Collapsed-by-default rendering
+// ---------------------------------------------------------------------------
+/** Truncate plain text to at most `width` columns, appending an ellipsis when it
+ *  would overflow. Content here is ANSI-free plain text, so code-point count
+ *  stands in for visible width. The renderer MUST keep every emitted line within
+ *  the terminal width or pi's TUI aborts the whole render. */
+function truncateToWidth(text, width) {
+    if (width <= 0)
+        return '';
+    const chars = Array.from(text);
+    if (chars.length <= width)
+        return text;
+    if (width === 1)
+        return '…';
+    return chars.slice(0, width - 1).join('') + '…';
+}
+/** 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;
+    return {
+        render(width) {
+            const w = typeof width === 'number' && width > 0 ? width : 80;
+            return [paint('dim', truncateToWidth('[review boundary] earlier conversation is not shown', w))];
+        },
+        invalidate() {
+            /* stateless — nothing to clear */
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+/**
+ * Register the review boundary marker. Companion nodes receive one boundary
+ * marker on session_start that separates inherited context from the visible
+ * transcript. Ordinary nodes get nothing.
+ */
+export function registerCanvasReviewBoundary(pi) {
+    pi.registerMessageRenderer(REVIEW_BOUNDARY_CUSTOM_TYPE, renderReviewBoundary);
+    pi.on('session_start', (_event, ctx) => {
+        const nodeId = process.env['CRTR_NODE_ID'];
+        if (!nodeId || nodeId.trim() === '')
+            return;
+        const node = getNode(nodeId);
+        if (node?.review_binding == null)
+            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));
+        if (alreadyMarked)
+            return;
+        const { review_id: reviewId, origin_node_id: originNodeId, target_file: targetFile, } = node.review_binding;
+        const content = [
+            `Reviewed file: ${targetFile}`,
+            `Review ID: ${reviewId}`,
+            `Origin node: ${originNodeId}`,
+            '',
+            "The person's visible transcript starts here. Everything above this marker is inherited context they have not seen.",
+        ].join('\n');
+        pi.sendMessage({
+            customType: REVIEW_BOUNDARY_CUSTOM_TYPE,
+            content,
+            display: true,
+            details: { reviewId, originNodeId, targetFile },
+        });
+    });
+}
+export default registerCanvasReviewBoundary;

package/dist/pi-extensions/canvas-stophook.d.ts

@@ -26,9 +26,9 @@ interface PiLike {
  *  the single "keep going past this window" verb for every persona: it refreshes
  *  the node into a clean window, MODE-PRESERVING — a base node stays base,
  *  continuing fresh against its goal and its note. `--promote` is a separate,
- *  explicit opt-in (never steered here as auto-behavior) for when what remains
- *  has genuinely grown into phases to delegate across children — so no persona
- *  is ever steered at a bare `node promote` (which framed promotion as a heavy
+ *  explicit opt-in (never steered here as auto-behavior) for when worthwhile
+ *  independent work can run in parallel and coordination should become the
+ *  node's primary job — so no persona is ever steered at a bare `node promote` (which framed promotion as a heavy
  *  "become an orchestrator" step and bred yield-avoidance).
  *
  *  - orchestrator (terminal OR resident): checkpoint context/roadmap.md, then

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

@@ -21,17 +21,16 @@
 //     (c) Natural stop ('stop' | 'length') — run the stop-guard (the node is
 //         NEVER auto-pushed; it reports only via its own explicit `crtr push`):
 //           • 'reprompt' → pi.sendUserMessage so the node finishes or escalates.
-//           • 'allow' (awaiting) → idle-release: free the tmux window and shut
-//                          down; the daemon watches the inbox and revives it
-//                          (resume) when a subscribed worker delivers.
+//           • 'allow' (awaiting) → stay dormant when focused; otherwise release
+//                          and shut down. A subscribed node, controller, or
+//                          background bash job delivers the inbox wake.
 //           • 'allow' (attended root) → stay alive, dormant; the human wakes it.
 //
 // 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 { writeFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { publishFollowUpProgress } from '@crouton-kit/humanloop';
-import { getNode, jobDir, updateNode, recordPid, setPresence, dispatchFollowUpWork, dispatchVisualWork, getFollowUpWorkRow, getHumanWorkRow, reconcileFollowUpWork, reconcileVisualWork } from '../core/canvas/index.js';
+import { getNode, jobDir, updateNode, recordPid, setPresence } from '../core/canvas/index.js';
 import { transition } from '../core/runtime/lifecycle.js';
 import { markBusy, clearBusy, touchBusy, isBusy } from '../core/runtime/busy.js';
 import { clearFault, readFault } from '../core/runtime/fault.js';
@@ -44,7 +43,8 @@ import { clearStopSignals, consumeStopSignals } from '../core/runtime/stop-signa
 import { cliClient } from '../commands/api-client.js';
 import { focusOf, tearDownNode } from '../core/runtime/placement.js';
 import { readCursor, readInboxSince } from '../core/feed/inbox.js';
-import { CONTEXT_NUDGE_CUSTOM_TYPE, formatContextNudge } from '../shared/generated-context.js';
+import { CONTEXT_NUDGE_CUSTOM_TYPE, formatContextNudge, formatPersonaTransition } from '../shared/generated-context.js';
+import { isReviewBoundary } from '../core/runtime/session-visibility.js';
 /** Universal upper bound for an unfocused broker parked without runnable work. */
 export const UNATTENDED_PARK_MS = (() => {
     const testOverride = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
@@ -134,8 +134,8 @@ function lastAssistantMessage(messages) {
 //             told to checkpoint one. `crtr node yield` is still its continue
 //             verb — mode-preserving, continuing fresh against its goal and its
 //             note — offered against wrap-up, since a root chat can simply end.
-//             `--promote` is mentioned only once the chat has genuinely grown
-//             into phases to delegate. Gentle → firm → pushy.
+//             `--promote` is mentioned only when worthwhile independent work
+//             can run in parallel and coordination should become primary. Gentle → firm → pushy.
 //   terminal/base (a worker): steered to `crtr node yield` to continue in a
 //             fresh window, mode-preserving, when work remains, or `push final`
 //             when close. Gentle → firm → pushy.
@@ -145,7 +145,7 @@ function lastAssistantMessage(messages) {
 // bred yield-avoidance. A plain yield is always mode-preserving — a base node's
 // yield never auto-promotes, so the agent is never steered to decide about
 // promotion at all; `--promote` is a separate opt-in mentioned only for
-// became-multi-phase work. Only a terminal node is ever told `push final` (a
+// worthwhile parallel work. Only a terminal node is ever told `push final` (a
 // resident finishes by yielding or being closed); only an orchestrator already
 // HAS a roadmap to checkpoint before it yields.
 // ---------------------------------------------------------------------------
@@ -174,9 +174,9 @@ function steerBand(tokens) {
  *  the single "keep going past this window" verb for every persona: it refreshes
  *  the node into a clean window, MODE-PRESERVING — a base node stays base,
  *  continuing fresh against its goal and its note. `--promote` is a separate,
- *  explicit opt-in (never steered here as auto-behavior) for when what remains
- *  has genuinely grown into phases to delegate across children — so no persona
- *  is ever steered at a bare `node promote` (which framed promotion as a heavy
+ *  explicit opt-in (never steered here as auto-behavior) for when worthwhile
+ *  independent work can run in parallel and coordination should become the
+ *  node's primary job — so no persona is ever steered at a bare `node promote` (which framed promotion as a heavy
  *  "become an orchestrator" step and bred yield-avoidance).
  *
  *  - orchestrator (terminal OR resident): checkpoint context/roadmap.md, then
@@ -206,10 +206,10 @@ export function steerNote(at, lifecycle, mode) {
         // resident/base — a root conversation, mode-preserving `crtr node yield` is
         // the natural "carry this forward" verb: it refreshes into a clean window
         // and continues fresh against your goal and your note — no "become
-        // something" decision. Only mention --promote once the chat has genuinely
-        // grown into phases to delegate. Offer wrap-up as the alternative — a root
-        // chat can simply end.
-        const grow = `If this is turning into a multi-phase job, \`crtr node yield\` to continue fresh against your goal and your note — add --promote only once it has genuinely grown into phases you need to delegate across children.`;
+        // something" decision. Mention --promote only when worthwhile independent
+        // work can run in parallel and coordination should become primary. Offer
+        // wrap-up as the alternative — a root chat can simply end.
+        const grow = `If substantial work remains, \`crtr node yield\` to continue fresh against your goal and your note. Add --promote only when worthwhile independent work can run in parallel and coordinating it should become your primary job; \`crtr node yield -h\` has the boundary.`;
         if (at < 150_000) {
             return `Context ~${k}k and growing. ${grow} Otherwise no rush — wrap up when you reach a good stopping point.`;
         }
@@ -221,8 +221,7 @@ export function steerNote(at, lifecycle, mode) {
     // terminal/base — a worker. The natural "keep going past this window" verb is
     // `crtr node yield`: it refreshes into a clean window, mode-preserving, and
     // continues fresh against your goal and your note. --promote is a separate
-    // opt-in for when what remains needs delegating across children — mentioned
-    // only for became-multi-phase work, never steered as automatic. Steer it to
+    // opt-in for worthwhile parallel work, never steered as automatic. Steer it to
     // yield-or-finish, never a bare promote.
     if (at < 150_000) {
         return `Context ~${k}k and growing. If you're near done, finish with \`crtr push final\`. If real work remains, \`crtr node yield\` to continue in a fresh window against your goal and your note — no rush yet.`;
@@ -260,30 +259,13 @@ export function registerCanvasStophook(pi) {
     // a tool_execution_start flush (activity-only) preserves the latest token figure.
     let lastContext = null;
     let lastActivity = null;
-    // If this node IS a follow-up consult fork, its ticket binding never changes,
-    // so resolve it once and reuse it to narrate live activity back into the
-    // waiting ticket. `undefined` = not yet looked up, `null` = not a consult.
-    let consultTicket;
-    function narrateToTicket(line) {
-        if (line === null || line === '')
-            return;
-        if (consultTicket === undefined) {
-            const row = getFollowUpWorkRow(String(nodeId));
-            consultTicket = row === null ? null : { root: row.root, dir: row.dir, requestId: row.request_id };
-        }
-        if (consultTicket === null)
-            return;
-        // humanloop itself gates on the request still being the running one, so a
-        // superseded or already-answered ticket silently ignores this.
-        publishFollowUpProgress(consultTicket.root, consultTicket.dir, { requestId: consultTicket.requestId, line });
-    }
     // Context-size steering. As input context grows we nudge the node once per
     // band on an escalating, persona-specific schedule (see steerBand/steerNote).
     // The node's (lifecycle, mode) persona is read at fire time, since a terminal
     // worker can promote mid-session: an orchestrator is steered to checkpoint
     // its roadmap + yield; a resident base (root chat) to yield-or-wrap-up (or
-    // yield --promote only once it has grown into phases to delegate); a terminal
-    // worker to yield-or-push-final.
+    // yield --promote only when worthwhile independent work can run in parallel);
+    // a terminal worker to yield-or-push-final.
     const firedBands = new Set();
     // Every broker enters this bounded-release path at session_start, including a
     // boot-revived settled node that never produces another agent_settled event.
@@ -409,6 +391,30 @@ export function registerCanvasStophook(pi) {
             // whereas a bare id is resolved cwd-relative and forks across projects.
             const filed = ctx?.sessionManager?.getSessionFile?.();
             const sessionFile = typeof filed === 'string' && filed !== '' ? filed : null;
+            const existing = getNode(nodeId);
+            const reviewId = existing?.review_binding?.review_id;
+            if (reviewId !== undefined) {
+                let hasBoundary = false;
+                try {
+                    const manager = ctx?.sessionManager;
+                    const entries = typeof manager?.getBranch === 'function'
+                        ? manager.getBranch()
+                        : typeof manager?.getEntries === 'function'
+                            ? manager.getEntries()
+                            : [];
+                    hasBoundary = entries.some((entry) => isReviewBoundary(entry, reviewId));
+                }
+                catch {
+                    hasBoundary = false;
+                }
+                if (!hasBoundary) {
+                    try {
+                        ctx?.shutdown?.();
+                    }
+                    catch { /* best-effort */ }
+                    return;
+                }
+            }
             // `/new` — a brand-new conversation in the same process. The broker already
             // drove the engine-side new_session (the viewer's /new → broker
             // new_session frame); the runtime side then splits on root-ness: a ROOT
@@ -417,13 +423,12 @@ export function registerCanvasStophook(pi) {
             // its session id on the SAME node.
             if (event?.reason === 'new') {
                 try {
-                    const m = getNode(nodeId);
                     // A root relaunch LAUNCHES a broker, and launches are daemon-owned
                     // (fleet-bound) — so the broker never runs relaunchRoot in-process.
                     // It asks crtrd via POST /v1/nodes/:id/relaunch-root instead; the
                     // rejection is swallowed here (the enclosing sync catch can't catch
                     // an async one) to keep `/new` best-effort.
-                    if (m?.parent == null)
+                    if (existing?.parent == null)
                         void cliClient().relaunchRoot(nodeId).catch(() => { });
                     else
                         handleNewSession(nodeId, id, sessionFile);
@@ -446,36 +451,27 @@ export function registerCanvasStophook(pi) {
             // proof for reviveNode's cycling-attempt marker and the one-shot yield
             // note — both remain pending through any pre-session_start failure and are
             // safe to clear on any confirmed boot (cycling, resuming, or fresh).
-            const existing = getNode(nodeId);
-            // A pending private fork is not bound until Pi exposes BOTH the fresh child
-            // id and its writable session file. Persist those identities and the phase
-            // flip in one meta write: recovery sees either fork_pending with no child,
-            // or session_started with the complete child coordinate, never a mixed
-            // state that could fork provenance twice.
-            if (existing?.private_fork_phase === 'fork_pending' && sessionFile === null) {
+            // An ordinary fork is not bound until Pi exposes BOTH the fresh child id
+            // and its writable session file. Recovery sees either an unbound fork or
+            // complete child coordinates, never a mixed state that could fork
+            // provenance twice.
+            if (existing?.fork_from != null && existing?.pi_session_id == null && sessionFile === null) {
                 try {
                     ctx?.shutdown?.();
                 }
                 catch { /* best-effort */ }
                 return;
             }
-            // Identity (session id/file/phase) → meta; runtime (pid, intent) → atomic
-            // row setters. Any confirmed boot owns the one-shot yield note, if any;
+            // Identity (session id/file) → meta; runtime (pid, intent) → atomic row
+            // setters. Any confirmed boot owns the one-shot yield note, if any;
             // clear it once here so a pre-session_start retry preserves it, but a
             // successful revival can still only consume it once.
             clearYieldMessage(nodeId);
-            updateNode(nodeId, existing?.private_fork_phase === 'fork_pending'
-                ? {
-                    pi_session_id: id,
-                    pi_session_file: sessionFile,
-                    private_fork_phase: 'session_started',
-                    cycle_pending: false,
-                }
-                : {
-                    pi_session_id: id,
-                    pi_session_file: sessionFile,
-                    cycle_pending: false,
-                });
+            updateNode(nodeId, {
+                pi_session_id: id,
+                pi_session_file: sessionFile,
+                cycle_pending: false,
+            });
             recordPid(nodeId, process.pid);
             if (existing?.intent === 'refresh')
                 transition(nodeId, 'revive');
@@ -525,7 +521,6 @@ export function registerCanvasStophook(pi) {
         try {
             lastActivity = summarizeActivity(String(event?.toolName ?? ''), event?.args);
             flushTelemetry(jobDirPath, totalIn, totalOut, model, lastContext, lastActivity);
-            narrateToTicket(lastActivity); // a consult fork streams its activity to the waiting ticket
             touchBusy(nodeId); // wedge heartbeat: a fresh tool starting is a sign of life
             clearFault(nodeId, { link: 'daemon→node' }); // a tool actually starting clears any prior wedge notice
         }
@@ -720,7 +715,7 @@ export function registerCanvasStophook(pi) {
         try {
             const drift = personaDrift(nodeId);
             if (drift !== null) {
-                pi.sendUserMessage(drift.guidance, { deliverAs: 'steer' });
+                pi.sendUserMessage(formatPersonaTransition(drift.guidance), { deliverAs: 'steer' });
                 commitPersonaAck(nodeId, drift.to);
             }
         }
@@ -764,59 +759,19 @@ export function registerCanvasStophook(pi) {
             const stopReason = last?.stopReason ?? '';
             // Interrupted or errored runs stay alive for re-steering. The broker
             // publishes any settled provider fault from its subscriber event stream.
-            //
-            // EXCEPT a follow-up consultation fork (design-followup-consult-v2.md
-            // §B.2/§B.4; integrated-review Major-2): it is born `parent:null` with
-            // no subscriber and nothing left to re-steer it — there is no human or
-            // sibling that will ever send it another message. An exact-model turn
-            // failure (the broker's `modelExact` fail-closed gates deliberately
-            // refuse to substitute a different model/provider, so the turn just
-            // errors) would otherwise leave it parked here forever: `armed`/`pending`
-            // in the outbox with no future event guaranteed to reach it (the daemon
-            // only reconciles at its own startup, and `_consult`/`_deliver` only
-            // fire on a LATER human action on this SAME ticket). Identify it by the
-            // presence of its own outbox row (the delivery record) and settle it
-            // right here instead: crash the
-            // node (frees it from the daemon's supervised LIVE set) and reconcile
-            // its outbox immediately — `reconcileFollowUpWork`'s armed+dead branch
-            // turns this into the ticket's `error` result, event-driven, no polling.
             if (stopReason !== 'stop' && stopReason !== 'length') {
-                let isConsultFork = false;
-                let isVisualFork = false;
-                try {
-                    const work = getHumanWorkRow(nodeId);
-                    isConsultFork = work?.work_kind === 'follow_up';
-                    isVisualFork = work?.work_kind === 'visual';
-                }
-                catch {
-                    /* best-effort read — treat as ordinary work on storage failure */
-                }
-                if (isConsultFork || isVisualFork) {
-                    // Minor-6 (integrated review): shutdown must fire even when
-                    // transition/reconcile throws — sharing one try with the shutdown
-                    // call let a reconciliation exception skip it entirely, stranding
-                    // an already-crashed consult broker (settlement then waits on
-                    // NOTHING, since this fork has no subscriber to ever retry it).
-                    // `finally` guarantees the shutdown regardless of the outcome
-                    // above; the outbox row itself is unaffected either way —
-                    // `reconcileFollowUpWork` is retried at the next
-                    // daemon-crash/startup/_consult/_deliver touchpoint.
+                // A refresh-yield aborts its OWN turn (the tool_execution_end handler
+                // above calls ctx.abort() the instant `crtr node yield` returns), so a
+                // non-'stop' stopReason here is the deliberate refresh, never a failed
+                // run. Shut down and let the daemon relaunch the node fresh against
+                // its roadmap; classifying it below would crash the node instead and
+                // the daemon's exit policy would then forget an already-dead row,
+                // stranding the yield.
+                if (getNode(nodeId)?.intent === 'refresh') {
                     try {
-                        const cur = getNode(nodeId);
-                        if (cur !== null && (cur.status === 'active' || cur.status === 'idle'))
-                            transition(nodeId, 'crash');
-                        reconcileFollowUpWork();
-                        reconcileVisualWork();
-                    }
-                    catch {
-                        /* best-effort — reconcileFollowUpWork is retried at the next daemon-crash/startup/_consult/_deliver touchpoint */
-                    }
-                    finally {
-                        try {
-                            ctx?.shutdown?.();
-                        }
-                        catch { /* ignore */ }
+                        ctx?.shutdown?.();
                     }
+                    catch { /* ignore */ }
                 }
                 return;
             }
@@ -847,17 +802,6 @@ export function registerCanvasStophook(pi) {
                         setPresence(nodeId, { pane: null, tmux_session: null, window: null });
                     }
                     catch { /* best-effort */ }
-                    // Consult-outbox dispatch (design-followup-consult-v2.md §B.4): if this
-                    // node is a follow-up consultation fork, its outbox row was promoted
-                    // armed→pending inside the SAME transaction that just committed this
-                    // final (feed.ts commitCanonicalFinal). Deliver it now, in-process, on
-                    // this fork's own settlement — the happy-path dispatch, event-driven,
-                    // no polling. A no-op for every non-consult node (no outbox row).
-                    try {
-                        dispatchFollowUpWork(nodeId);
-                        dispatchVisualWork(nodeId);
-                    }
-                    catch { /* best-effort — durable reconcilers retry */ }
                 }
                 finally {
                     try {
@@ -935,6 +879,11 @@ export function registerCanvasStophook(pi) {
             }
             catch { /* best-effort */ }
             if (decision.reason === 'finished') {
+                // A canonical final can race the in-process watcher just like an
+                // awaiting stop: keep the broker alive until any non-deferred entry
+                // beyond the durable cursor has been delivered and committed.
+                if (readInboxSince(nodeId, readCursor(nodeId)).some((entry) => entry.tier !== 'deferred'))
+                    return;
                 try {
                     ctx?.shutdown?.();
                 }
@@ -942,11 +891,12 @@ export function registerCanvasStophook(pi) {
                 return;
             }
             //
-            // Idle-release: a node awaiting its workers (reason 'awaiting') is holding
-            // a tmux window for nothing. Free it — mark it idle-released and shut pi
-            // down; the daemon watches its inbox and revives it (resume) the moment a
-            // subscribed worker delivers. An 'attended' root never releases: the human
-            // is its wake source, so we keep its window live and dormant.
+            // Idle-release: an unfocused node awaiting a subscribed node, controller,
+            // or background bash job (reason 'awaiting') is holding a live broker for
+            // nothing. Mark it idle-released and shut pi down; the daemon watches its
+            // inbox and revives it (resume) when the awaited delivery arrives. A
+            // resident node never releases: the human is its wake source, so we keep
+            // its broker live and dormant.
             if (decision.reason === 'awaiting' || decision.reason === 'scheduled') {
                 // AWAITING ≠ done (no manager-takeover). What happens next splits on
                 // whether the user is WATCHING this node:

package/dist/pi-extensions/canvas-structured-output.js

@@ -27,6 +27,50 @@ function retireTool(pi) {
         /* best-effort; the execute handler is inert when no schema file exists */
     }
 }
+function strictToolSchema(schema) {
+    const transform = (value) => {
+        if (Array.isArray(value))
+            return value.map(transform);
+        if (value === null || typeof value !== 'object')
+            return value;
+        const source = value;
+        const transformed = {};
+        for (const [key, child] of Object.entries(source)) {
+            if (key === 'properties' && child !== null && typeof child === 'object' && !Array.isArray(child)) {
+                transformed[key] = Object.fromEntries(Object.entries(child).map(([name, property]) => [name, transform(property)]));
+            }
+            else {
+                transformed[key] = transform(child);
+            }
+        }
+        const properties = transformed['properties'];
+        if (properties === null || typeof properties !== 'object' || Array.isArray(properties))
+            return transformed;
+        const required = new Set(Array.isArray(source['required']) ? source['required'].filter((name) => typeof name === 'string') : []);
+        transformed['properties'] = Object.fromEntries(Object.entries(properties).map(([name, property]) => [
+            name,
+            required.has(name) ? property : { anyOf: [property, { type: 'null' }] },
+        ]));
+        transformed['required'] = Object.keys(properties);
+        return transformed;
+    };
+    return transform(schema);
+}
+function omitStrictNulls(value, schema) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value) || schema === null || typeof schema !== 'object' || Array.isArray(schema))
+        return value;
+    const source = schema;
+    const properties = source['properties'];
+    if (properties === null || typeof properties !== 'object' || Array.isArray(properties))
+        return value;
+    const requiredNames = source['required'];
+    const required = new Set(Array.isArray(requiredNames) ? requiredNames.filter((name) => typeof name === 'string') : []);
+    return Object.fromEntries(Object.entries(value).flatMap(([name, child]) => {
+        if (child === null && !required.has(name) && Object.hasOwn(properties, name))
+            return [];
+        return [[name, omitStrictNulls(child, properties[name])]];
+    }));
+}
 function toolDescription(request) {
     if (request.mode === 'terminal') {
         return 'Submit your final structured result. Calling this ends your run: the result is recorded and a final report is pushed automatically — do NOT call `crtr push final` yourself.';
@@ -66,11 +110,10 @@ export function registerCanvasStructuredOutput(pi) {
                         'Use submit to answer the pending one-off structured-output request before stopping or going dormant.',
                         'After one-off submit succeeds, continue with any remaining work normally.',
                     ],
-                parameters: request.schema,
-                // pi 0.82 can ask the provider to constrain sampling to the tool's JSON schema.
-                // `prefer` degrades silently on a model without strict tool support (`require`
-                // would fail the whole request); crouter's server-side validation and stop-guard
-                // stay authoritative either way — this only makes a malformed submission rarer.
+                // OpenAI strict tools require every property to be required. Optional fields
+                // become nullable in the provider-only schema and null is removed before the
+                // original result is persisted.
+                parameters: strictToolSchema(request.schema),
                 constrainedSampling: { type: 'json_schema', strict: 'prefer' },
                 async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
                     const current = readOutputRequest(nodeId);
@@ -88,8 +131,9 @@ export function registerCanvasStructuredOutput(pi) {
                             details: { submitted: false, reason: 'schema_replaced' },
                         };
                     }
+                    const result = omitStrictNulls(params, current.schema);
                     const resultPath = outputResultPath(nodeId);
-                    const json = JSON.stringify(params, null, 2);
+                    const json = JSON.stringify(result, null, 2);
                     mkdirSync(dirname(resultPath), { recursive: true });
                     writeFileSync(resultPath, `${json}\n`, 'utf8');
                     const body = reportBody(resultPath, json);
@@ -114,7 +158,7 @@ export function registerCanvasStructuredOutput(pi) {
                         catch { /* ignore */ }
                         return {
                             content: [{ type: 'text', text: `Structured output submitted and finalized: ${resultPath}` }],
-                            details: { submitted: true, mode: current.mode, resultPath, result: params },
+                            details: { submitted: true, mode: current.mode, resultPath, result },
                             terminate: true,
                         };
                     }
@@ -124,7 +168,7 @@ export function registerCanvasStructuredOutput(pi) {
                     retireTool(pi);
                     return {
                         content: [{ type: 'text', text: `Structured output submitted: ${resultPath}` }],
-                        details: { submitted: true, mode: current.mode, resultPath, result: params },
+                        details: { submitted: true, mode: current.mode, resultPath, result },
                     };
                 },
             });