@north-light/crouter 0.3.282 → 0.3.284

package/dist/commands/api-client.js

@@ -137,18 +137,8 @@ export function cliClient(opts) {
 // NodeSummaryDTO now carries every NodeRow field and NodeDetailDTO extends it,
 // so the viewer adapter returns the daemon's typed projections directly. It
 // performs no lossy legacy reconstruction or invented local-presence values.
-// The attach viewer's recurring subtree walk (chrome/canvas-panels.ts + overlays/graph.ts
-// computeActivity/visitActivity) calls subscriptionsOf/subscribersOf once per
-// visited node on every poll tick, and a `GET /v1/nodes/:id` per call just to
-// read the edge list off the detail DTO costs one round trip per visited node.
-// This short-TTL cache backs those two methods with the lean roster
-// (`GET /v1/canvas/roster`) instead — one shared fetch per TTL window covers
-// every topology walk in that window, comfortably under the attach viewer's 5s
-// poll cadence. Scoped to subscriptionsOf/subscribersOf only: listNodes/getRow
-// stay on the full per-id/list HTTP path because the roster does not carry the
-// runtime fields (intent/waiting_for/pi_pid/etc) those two already populate for
-// real from the full DTO — backing them with the roster would silently null out
-// live display fields, not just the already-lossy tmux-presence ones.
+// Index the short-lived lean roster once so repeated topology lookups stay O(1).
+// listNodes/getRow still use full DTO endpoints for fields the roster omits.
 const ROSTER_CACHE_TTL_MS = 2000;
 export class ApiCanvasSource {
     client;
@@ -160,15 +150,30 @@ export class ApiCanvasSource {
     async roster() {
         const now = Date.now();
         if (this.rosterCache !== null && now - this.rosterCache.at < ROSTER_CACHE_TTL_MS) {
-            return this.rosterCache.roster;
+            return this.rosterCache.index;
         }
         if (this.rosterInFlight !== null)
             return this.rosterInFlight;
         this.rosterInFlight = this.client
             .canvasRoster()
             .then((roster) => {
-            this.rosterCache = { at: Date.now(), roster };
-            return roster;
+            const index = { subscriptions: new Map(), subscribers: new Map() };
+            for (const edge of roster.edges) {
+                const subscription = { node_id: edge.to_id, active: edge.active, created: edge.created };
+                const subscriber = { node_id: edge.from_id, active: edge.active, created: edge.created };
+                const subscriptions = index.subscriptions.get(edge.from_id);
+                if (subscriptions === undefined)
+                    index.subscriptions.set(edge.from_id, [subscription]);
+                else
+                    subscriptions.push(subscription);
+                const subscribers = index.subscribers.get(edge.to_id);
+                if (subscribers === undefined)
+                    index.subscribers.set(edge.to_id, [subscriber]);
+                else
+                    subscribers.push(subscriber);
+            }
+            this.rosterCache = { at: Date.now(), index };
+            return index;
         })
             .finally(() => {
             this.rosterInFlight = null;
@@ -212,16 +217,10 @@ export class ApiCanvasSource {
         return rows;
     }
     async subscriptionsOf(subscriber) {
-        const roster = await this.roster();
-        return roster.edges
-            .filter((e) => e.from_id === subscriber)
-            .map((e) => ({ node_id: e.to_id, active: e.active, created: e.created }));
+        return this.roster().then((index) => index.subscriptions.get(subscriber) ?? []);
     }
     async subscribersOf(publisher) {
-        const roster = await this.roster();
-        return roster.edges
-            .filter((e) => e.to_id === publisher)
-            .map((e) => ({ node_id: e.from_id, active: e.active, created: e.created }));
+        return this.roster().then((index) => index.subscribers.get(publisher) ?? []);
     }
     /** BFS over the active `subscribes_to` edges from `root` (its transitive view),
      *  excluding `root` itself — the same traversal shape as

package/dist/commands/node/create.js

@@ -6,6 +6,7 @@ import { mark } from '../../core/timing.js';
 import { OUTPUT_SCHEMA_CONSTRAINTS, OUTPUT_SCHEMA_TRANSPORT, parseOutputSchemaValue } from '../../core/runtime/structured-output.js';
 import { MODEL_SPEC_FORMS, MODEL_SPEC_NEXT } from '../../core/runtime/model-selection.js';
 import { readMergedLaunchConfig } from '../../core/config.js';
+import { parseDurationMs } from '../../core/wake.js';
 import { profilesStateBlock } from '../../core/profiles/state-block.js';
 import { resolveProfileOperand } from '../../core/profiles/manifest.js';
 import { stateBlock } from '../../core/help.js';
@@ -14,7 +15,7 @@ import { inTmux } from '../../core/runtime/placement-tmux.js';
 import { openSpawnViewer } from '../surface/node/placement.js';
 import { resolve } from 'node:path';
 const YIELD_NUDGE_THRESHOLD = 100_000;
-const NODE_NEW_OUTPUT_SCHEMA_EFFECT = '--output-schema writes the accepted result to the node’s context/result.json and pushes it as the node’s final report.';
+const NODE_NEW_OUTPUT_SCHEMA_EFFECT = '--output-schema writes the accepted result to the node’s context/result.json and pushes it as the node’s final report; a node that cannot honestly satisfy the schema declines with `crtr push result --decline "<reason>" --code <token>`, which finishes it with a failure outcome (reason `declined`) whose `declined` field carries { reason, code, retryable } and no result. Name the code tokens you accept in the prompt; crouter carries the code verbatim and you validate it.';
 const STD_CHILD_FOLLOW_UP = "Do not wait, poll, or duplicate this child's assignment in your own context — there is no result to await, stopping will not strand you, and duplicated work wastes the delegated context. You're auto-subscribed, so its finish wakes you on its own. Two moves only: do other independent work right now, or stop and end your turn — the wake brings you back.";
 /** Decision road sign for a managed (non-root) child. Normally STD_CHILD_FOLLOW_UP,
  *  but when the SPAWNER is an orchestrator whose context has already grown past
@@ -121,6 +122,9 @@ function nodeNewParams() {
         // this flag at exactly the moment it is needed. Advertising it would tax
         // every spawn with a capability almost no caller wants.
         { kind: 'flag', name: 'no-kickoff', type: 'bool', required: false, hidden: true, constraint: 'With --root, start the broker and session idle without a first message or model turn. Mutually exclusive with a prompt and --mode orchestrator.' },
+        { kind: 'flag', name: 'deadline', type: 'string', required: false, constraint: 'Positive, representable wall-clock duration from spawn. Grammar: one or more positive integer-unit parts; units: s, m, h, d; adjacent parts are summed. Omit for no deadline.' },
+        { kind: 'flag', name: 'outcome-action', type: 'string', required: false, constraint: 'Declared human-action name that receives the node outcome. Grammar: 1–128 ASCII letters, digits, dots, underscores, or hyphens; starts with a letter or digit. Omit when no external delivery target is needed.' },
+        { kind: 'flag', name: 'outcome-payload', type: 'string', required: false, constraint: 'JSON value, serialized at most 64 KiB, frozen and echoed to --outcome-action. Requires --outcome-action.' },
         {
             kind: 'flag',
             name: 'output-schema',
@@ -131,10 +135,10 @@ function nodeNewParams() {
                 whenToUse: 'Use only when the node’s consumer needs a machine-checkable final object with fixed fields. Omit it for ordinary delegation or when a prose report is enough; structured output replaces the completion protocol, and an over-constrained schema can force retries.',
                 value: `Pass the JSON Schema the result must satisfy. ${OUTPUT_SCHEMA_TRANSPORT} ${OUTPUT_SCHEMA_CONSTRAINTS}`,
                 effects: [
-                    'The node receives a terminal submit tool and cannot finish until submit accepts a result; it must not call `crtr push final` itself.',
+                    'The node must answer with `crtr push result` and cannot finish until the result is accepted; a plain `crtr push final` is blocked while the request is pending.',
                     NODE_NEW_OUTPUT_SCHEMA_EFFECT,
                     'The managed parent wakes through its existing subscription when the final report arrives; an independent root has no subscriber to wake.',
-                    'Successful submit removes the request and terminates the node.',
+                    'An accepted result, or a decline, removes the request and terminates the node.',
                 ],
             },
         },
@@ -164,6 +168,8 @@ function nodeNewEffects() {
         'A managed child creates an active parent subscription; its pushes wake the parent. --root creates an independent node with spawned_by provenance and no parent subscription.',
         '--worktree creates a managed worktree at ~/.crouter/canvas/worktrees/<node-id>/ on a new crtr/<node-id> branch.',
         NODE_NEW_OUTPUT_SCHEMA_EFFECT,
+        '--deadline persists a wall-clock deadline from spawn; expiry cancels the node and records a failure outcome with reason deadline_exceeded.',
+        '--outcome-action registers one resolved local human-action target. When the node settles, crouter retries delivery of its outcome document until the target accepts it or permanently rejects it; --outcome-payload is frozen and echoed in that document.',
         ...(inTmux() ? ['--root opens a viewer for the new node in the current tmux session.'] : []),
     ];
 }
@@ -203,6 +209,28 @@ async function runNodeCreation(input) {
     const situationalContext = situationalContextRaw !== undefined && situationalContextRaw !== '' ? situationalContextRaw : undefined;
     const outputSchemaParsed = parseOutputSchemaValue(input['outputSchema']);
     const outputSchema = outputSchemaParsed !== null ? JSON.stringify(outputSchemaParsed) : null;
+    const deadline = input['deadline'];
+    if (deadline !== undefined) {
+        const durationMs = parseDurationMs(deadline);
+        const deadlineAt = durationMs === null ? Number.NaN : new Date(Date.now() + durationMs).getTime();
+        if (durationMs === null || !Number.isFinite(durationMs) || durationMs <= 0 || !Number.isFinite(deadlineAt)) {
+            throw new InputError({ error: 'invalid_deadline', message: '--deadline must be a positive representable duration', field: 'deadline', next: 'Pass positive integer-unit parts using s, m, h, or d.' });
+        }
+    }
+    const outcomeAction = input['outcomeAction'];
+    const outcomePayloadRaw = input['outcomePayload'];
+    if (outcomePayloadRaw !== undefined && outcomeAction === undefined) {
+        throw new InputError({ error: 'outcome_payload_requires_action', message: '--outcome-payload requires --outcome-action', field: 'outcome-payload', next: 'Pass the declared delivery action with --outcome-action.' });
+    }
+    let outcomePayload;
+    if (outcomePayloadRaw !== undefined) {
+        try {
+            outcomePayload = JSON.parse(outcomePayloadRaw);
+        }
+        catch {
+            throw new InputError({ error: 'invalid_outcome_payload', message: '--outcome-payload must be valid JSON', field: 'outcome-payload', next: 'Pass one valid JSON value.' });
+        }
+    }
     const nodeId = input['nodeId']?.trim();
     if (root && worktreeBase !== undefined) {
         throw new InputError({ error: 'worktree_root_conflict', message: '--worktree is mutually exclusive with --root', field: 'worktree', next: 'Drop either --root or --worktree.' });
@@ -236,6 +264,13 @@ async function runNodeCreation(input) {
         ...(situationalContext !== undefined ? { situational_context: situationalContext } : {}),
         ...(noKickoff ? { no_kickoff: true } : {}),
         ...(outputSchema !== null ? { output_schema: outputSchema } : {}),
+        ...(deadline !== undefined ? { deadline } : {}),
+        ...(outcomeAction !== undefined ? {
+            outcome_delivery: {
+                action: outcomeAction,
+                ...(outcomePayload === undefined ? {} : { payload: outcomePayload }),
+            },
+        } : {}),
         ...(nodeId !== undefined && nodeId !== '' ? { node_id: nodeId } : {}),
         // A bare `--root --no-kickoff` create is exactly what the warm pool holds
         // ready; every other shape is rejected server-side and cold-spawns.

package/dist/commands/node/inspect.js

@@ -82,13 +82,9 @@ const nodeList = defineLeaf({
                 return false;
             return true;
         });
-        const nodes = [];
-        for (const row of rows) {
-            const detail = await canvasSource.getNode(row.node_id).catch(rethrowAsCliError);
-            const named = { ...row, name: fullName(detail ?? row) };
-            if (name === undefined || name === '' || fuzzyMatch(name, named.name))
-                nodes.push(named);
-        }
+        const nodes = rows
+            .map((row) => ({ ...row, name: fullName(row) }))
+            .filter((row) => name === undefined || name === '' || fuzzyMatch(name, row.name));
         return { nodes };
     },
 });

package/dist/commands/node/message.js

@@ -57,7 +57,7 @@ function messageRequestParams() {
         { kind: 'flag', name: 'to', type: 'string', required: false, constraint: 'Target an existing node by id. Exactly one of --to or --self is required.' },
         { kind: 'flag', name: 'self', type: 'bool', required: false, constraint: 'Target the calling node. Exactly one of --to or --self is required.' },
         { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal'], required: false, default: 'normal', constraint: 'Delivery urgency. Every accepted tier may revive a dormant target, because the request must be answered; deferred is rejected for that reason.' },
-        { kind: 'flag', name: 'output-schema', type: 'string', required: true, constraint: `JSON Schema the result must satisfy. ${OUTPUT_SCHEMA_TRANSPORT} The target answers through a constrained submit tool, then keeps working. ${OUTPUT_SCHEMA_CONSTRAINTS}` },
+        { kind: 'flag', name: 'output-schema', type: 'string', required: true, constraint: `JSON Schema the result must satisfy. ${OUTPUT_SCHEMA_TRANSPORT} The target answers with \`crtr push result\` (or declines with \`crtr push result --decline "<reason>" --code <token>\`), then keeps working. ${OUTPUT_SCHEMA_CONSTRAINTS}` },
         { kind: 'flag', name: 'situational-context', type: 'string', required: false, constraint: 'Non-empty hidden ambient context delivered beside the message, or alone.' },
         { kind: 'flag', name: 'reopen', type: 'bool', required: false, hidden: true, constraint: 'Clear a finalized target latch before delivery or fresh revive.' },
     ];
@@ -129,7 +129,7 @@ const nodeMessageRequest = defineLeaf({
         params: messageRequestParams(),
         output: messageOutput(),
         outputKind: 'object',
-        effects: ['Installs the one-off submit schema before appending the request.'],
+        effects: ['Installs the one-off output schema before appending the request.'],
     },
     run: (input) => {
         requireNonBlankDiscriminant(input, 'outputSchema');
@@ -144,7 +144,7 @@ export const nodeMessage = defineBranch({
     help: {
         name: 'node message',
         summary: 'deliver one immediate inbox entry to an existing node',
-        model: 'Both children append one inbox entry to a node that already exists, targeted by id or --self, and may revive it if it is dormant. They differ in what the delivery obligates. An ordinary message obligates nothing: the target reads it and acts however it judges best. A request installs a one-off submit schema and holds the target awake and owing until it answers; the answer is validated against the schema, written to the target’s result file, and pushed as an update report to the TARGET’S subscribers, so subscribe to it first if the answer has to reach you. Neither child creates that standing relationship — a durable delivery edge is `node subscription`, and work that needs a fresh agent is `node new`.',
+        model: 'Both children append one inbox entry to a node that already exists, targeted by id or --self, and may revive it if it is dormant. They differ in what the delivery obligates. An ordinary message obligates nothing: the target reads it and acts however it judges best. A request installs a one-off output schema and holds the target awake and owing until it answers; the answer is validated against the schema, written to the target’s result file, and pushed as an update report to the TARGET’S subscribers, so subscribe to it first if the answer has to reach you. Neither child creates that standing relationship — a durable delivery edge is `node subscription`, and work that needs a fresh agent is `node new`.',
     },
     children: [nodeMessageSend, nodeMessageRequest],
 });

package/dist/commands/node/outcome.d.ts

@@ -0,0 +1,2 @@
+export declare const nodeOutcomeDelivery: import("../../core/command.js").LeafDef;
+export declare const nodeOutcome: import("../../core/command.js").BranchDef;

package/dist/commands/node/outcome.js

@@ -0,0 +1,134 @@
+// `crtr node outcome` — read a durable terminal outcome through crtrd only.
+import { isSafeNodeId } from '../../api/index.js';
+import { defineBranch, defineLeaf } from '../../core/command.js';
+import { InputError } from '../../core/io.js';
+import { cliClient, rethrowAsCliError } from '../api-client.js';
+function nodeId(input) {
+    const id = typeof input['node'] === 'string' ? input['node'].trim() : '';
+    if (!isSafeNodeId(id)) {
+        throw new InputError({
+            error: 'invalid_node',
+            message: `invalid node id: ${id === '' ? '(empty)' : id}`,
+            field: 'node',
+            next: 'Pass the exact node id returned when the node was created.',
+        });
+    }
+    return id;
+}
+function renderedJson(value) {
+    return value === null || value === undefined ? 'none' : JSON.stringify(value);
+}
+const nodeOutcomeRead = defineLeaf({
+    name: 'read',
+    description: 'read or briefly await a node’s durable terminal outcome',
+    whenToUse: 'an external caller needs the durable result or failure reason for one node, optionally blocking for its terminal outcome without consuming or claiming it',
+    help: {
+        name: 'node outcome read',
+        summary: 'read a node’s durable outcome, optionally awaiting it for up to 25 seconds',
+        params: [
+            { kind: 'positional', name: 'node', required: true, constraint: 'Node id whose durable outcome to read.' },
+            { kind: 'flag', name: 'wait', type: 'int', required: false, default: 0, constraint: 'Whole seconds to await settlement: 0–25. Omit or use 0 to return the current pending/settled state immediately.' },
+        ],
+        output: [
+            { name: 'node_id', type: 'string', required: true, constraint: 'The requested node id.' },
+            { name: 'state', type: 'string', required: true, constraint: '`pending` while the node has no terminal outcome, otherwise `settled`.' },
+            { name: 'outcome', type: 'object', required: true, constraint: 'The durable result/failure record when settled — kind/reason, revision, settled time, report basename/path, structured result, failure detail, and `declined` ({ reason, code, retryable } for a failure with reason `declined`, else null) — otherwise null.' },
+            { name: 'node_status', type: 'string', required: true, constraint: 'The node status observed with the outcome.' },
+            { name: 'deadline_at', type: 'string', required: true, constraint: 'The absolute spawn deadline, or null when unbounded.' },
+        ],
+        outputKind: 'object',
+        effects: ['Read-only: calls the daemon’s replay-safe GET outcome route. With --wait, the daemon polls the durable row for no more than 25 seconds.'],
+    },
+    run: async (input) => {
+        const id = nodeId(input);
+        const wait = input['wait'];
+        if (typeof wait !== 'number' || !Number.isInteger(wait) || wait < 0 || wait > 25) {
+            throw new InputError({
+                error: 'invalid_wait',
+                message: '--wait must be an integer between 0 and 25 seconds',
+                field: 'wait',
+                received: wait,
+                next: 'Pass a whole number from 0 through 25, or omit --wait to poll immediately.',
+            });
+        }
+        return { ...await cliClient().getNodeOutcome(id, { waitSeconds: wait }).catch(rethrowAsCliError) };
+    },
+    render: (result) => {
+        const outcome = result['outcome'];
+        if (outcome === null) {
+            return [
+                `<outcome state="pending" node_id="${result['node_id']}">`,
+                `- node status: ${result['node_status']}`,
+                `- deadline: ${result['deadline_at'] ?? 'none'}`,
+                '</outcome>',
+            ].join('\n');
+        }
+        return [
+            `<outcome kind="${outcome['kind']}" reason="${outcome['reason']}" state="settled" node_id="${result['node_id']}" revision="${outcome['revision']}">`,
+            `- final report: ${outcome['final_report'] ?? 'none'}`,
+            `- report path: ${outcome['final_report_path'] ?? 'none'}`,
+            `- structured result: ${renderedJson(outcome['structured_result'])}`,
+            `- declined: ${renderedJson(outcome['declined'])}`,
+            `- failure detail: ${renderedJson(outcome['detail'])}`,
+            `- settled at: ${outcome['settled_at']}`,
+            `- node status: ${result['node_status']}`,
+            `- deadline: ${result['deadline_at'] ?? 'none'}`,
+            '</outcome>',
+        ].join('\n');
+    },
+});
+export const nodeOutcomeDelivery = defineLeaf({
+    name: 'delivery',
+    description: 'inspect a node outcome-delivery registration',
+    whenToUse: 'you need the durable state of the local action target registered to receive a node’s outcome',
+    help: {
+        name: 'node outcome delivery',
+        summary: 'inspect the registered outcome-delivery target for one node',
+        params: [
+            { kind: 'positional', name: 'node', required: true, constraint: 'Node id whose outcome-delivery registration to inspect.' },
+        ],
+        output: [
+            { name: 'node_id', type: 'string', required: true, constraint: 'The node whose outcome is delivered.' },
+            { name: 'state', type: 'string', required: true, constraint: '`armed`, `pending`, `running`, `accepted`, or `permanent_failed`.' },
+            { name: 'action', type: 'string', required: true, constraint: 'The resolved configured action name.' },
+            { name: 'attempt', type: 'number', required: true, constraint: 'How many delivery attempts have been claimed.' },
+            { name: 'next_attempt_at', type: 'string', required: true, constraint: 'ISO-8601 time of the next retry, or null before a retry is scheduled (including while armed).' },
+            { name: 'accepted_at', type: 'string', required: true, constraint: 'When the target accepted the document, or null.' },
+            { name: 'permanent_failed_at', type: 'string', required: true, constraint: 'When the target permanently rejected the document, or null.' },
+            { name: 'last_failure', type: 'object', required: true, constraint: 'The most recent retryable or permanent delivery failure, or null.' },
+            { name: 'created_at', type: 'string', required: true, constraint: 'When this delivery registration was created.' },
+            { name: 'updated_at', type: 'string', required: true, constraint: 'When this delivery registration was last updated.' },
+        ],
+        outputKind: 'object',
+        effects: ['Read-only: calls the daemon outcome-delivery inspection route.'],
+    },
+    run: async (input) => {
+        const id = nodeId(input);
+        return { ...await cliClient().getOutcomeDelivery(id).catch(rethrowAsCliError) };
+    },
+    render: (result) => {
+        return [
+            `<outcome-delivery state="${result['state']}" node_id="${result['node_id']}">`,
+            `- attempt: ${result['attempt']}`,
+            `- next retry: ${result['next_attempt_at'] ?? 'none'}`,
+            `- last failure: ${renderedJson(result['last_failure'])}`,
+            `- action: ${result['action']}`,
+            `- accepted at: ${result['accepted_at'] ?? 'none'}`,
+            `- permanently failed at: ${result['permanent_failed_at'] ?? 'none'}`,
+            `- registered at: ${result['created_at']}`,
+            `- updated at: ${result['updated_at']}`,
+            '</outcome-delivery>',
+        ].join('\n');
+    },
+});
+export const nodeOutcome = defineBranch({
+    name: 'outcome',
+    description: 'read a node’s terminal outcome or its delivery state',
+    whenToUse: 'you need the durable terminal result/failure of one node, or the state of its registered outcome-delivery target',
+    help: {
+        name: 'node outcome',
+        summary: 'read one node’s durable terminal outcome or its delivery registration',
+        model: 'Outcome reads never consume the terminal record. Read returns the durable result or failure and can wait briefly for settlement; delivery inspects the separate action-registration attempt state.',
+    },
+    children: [nodeOutcomeRead, nodeOutcomeDelivery],
+});

package/dist/commands/node.js

@@ -9,6 +9,7 @@ import { nodeSubscription } from './node/subscription.js';
 import { nodeBash } from './node/bash.js';
 import { pyramidSlash } from './node/pyramid.js';
 import { nodeWorktreeBranch } from './node-worktree.js';
+import { nodeOutcome } from './node/outcome.js';
 export function registerNode() {
     return defineBranch({
         name: 'node',
@@ -23,6 +24,6 @@ export function registerNode() {
             summary: 'create, inspect, message, and change canvas nodes',
             model: 'A node is one agent on the canvas. Immediate actions, durable waits, subscriptions, lifecycle changes, and scheduled crons are separate intent families; choose the family by when the effect happens and what persistent state it changes.',
         },
-        children: [nodeNew, nodeFork, nodeMessage, nodeWaitBranch, nodeSubscription, nodeInspect, nodeLifecycle, nodeWorktreeBranch, nodeConfig, nodePromote, nodeYield, nodeBash],
+        children: [nodeNew, nodeFork, nodeMessage, nodeWaitBranch, nodeSubscription, nodeOutcome, nodeInspect, nodeLifecycle, nodeWorktreeBranch, nodeConfig, nodePromote, nodeYield, nodeBash],
     });
 }

package/dist/commands/profile/pause.js

@@ -1,5 +1,6 @@
 import { defineLeaf } from '../../core/command.js';
-import { resolveProfileOperand, pauseProfile, resumeProfile } from '../../core/profiles/manifest.js';
+import { resolveProfileOperand } from '../../core/profiles/manifest.js';
+import { cliClient, rethrowAsCliError } from '../api-client.js';
 const profileParam = {
     kind: 'positional',
     name: 'profile',
@@ -9,7 +10,7 @@ const profileParam = {
 export const pauseLeaf = defineLeaf({
     name: 'pause',
     description: 'make a profile inert',
-    whenToUse: 'new nodes and revives under a profile must stop while its running broker is allowed to finish its current turn.',
+    whenToUse: 'all work under a profile must stop now while in-flight bash commands continue under their detached supervisors.',
     help: {
         name: 'profile pause',
         summary: 'pause a profile so it creates and revives no nodes',
@@ -19,15 +20,16 @@ export const pauseLeaf = defineLeaf({
             { name: 'paused_at', type: 'string', required: true, constraint: 'ISO 8601 timestamp when the profile became inert.' },
         ],
         outputKind: 'object',
-        effects: ['Writes `paused_at` to the profile manifest. Existing brokers continue their current turn; queued inbox messages do not revive nodes until resume.'],
+        effects: ['Writes `paused_at`, SIGTERMs every live broker under the profile so its foreground bash hands off to its detached supervisor, and holds cron, deadline, revive, and inbox delivery until resume.'],
     },
     run: async (input) => {
         const { profileId } = resolveProfileOperand(input['profile']);
-        const { manifest } = pauseProfile(profileId);
-        return {
-            profile_id: profileId,
-            paused_at: manifest.paused_at,
-        };
+        try {
+            return { ...await cliClient().pauseProfile(profileId) };
+        }
+        catch (error) {
+            rethrowAsCliError(error);
+        }
     },
 });
 export const resumeLeaf = defineLeaf({
@@ -43,14 +45,15 @@ export const resumeLeaf = defineLeaf({
             { name: 'paused_at', type: 'null', required: true, constraint: 'Always null after resume; null means active.' },
         ],
         outputKind: 'object',
-        effects: ['Clears `paused_at` in the profile manifest. Future creates and revives are allowed.'],
+        effects: ['Clears `paused_at`, credits active node deadlines for the paused interval, and lets retained inbox mail, due crons, and interrupted turns resume.'],
     },
     run: async (input) => {
         const { profileId } = resolveProfileOperand(input['profile']);
-        const { manifest } = resumeProfile(profileId);
-        return {
-            profile_id: profileId,
-            paused_at: manifest.paused_at,
-        };
+        try {
+            return { ...await cliClient().resumeProfile(profileId) };
+        }
+        catch (error) {
+            rethrowAsCliError(error);
+        }
     },
 });

package/dist/commands/push.js

@@ -2,6 +2,7 @@
 //
 //   crtr push update [body]   — report progress to subscribers
 //   crtr push final  [body]   — finish: write result, mark node done, close window
+//   crtr push result [json]   — answer a pending structured-output request
 //
 // "push" is THE verb a node uses to talk to its managers. `update` reports
 // progress; its --tier sets delivery urgency. The caller's node is resolved from
@@ -39,6 +40,106 @@ const PUSH_WHEN_TO_USE = {
     update: 'you have progress worth surfacing to your managers while work remains in flight. Use normal delivery unless it can wait for their next real wake (--tier deferred) or needs immediate attention (--tier urgent); use push final only when the work is actually done.',
     final: 'the work this node was spawned to do is complete and you are ready to hand back the canonical result — this writes that result, marks the node done, and closes its window, so it is the LAST thing you do here, not a progress note. Use push update while work is still in flight, and do not reach for final on a node working directly with the user: it has no manager to report up to and would close mid-conversation (the guard blocks it unless you pass --force after the user confirms).',
 };
+/** `crtr push result` — submit the JSON answer to a pending structured-output
+ *  request. A pure API client like its siblings: JSON is parsed client-side
+ *  only to fail fast with a clean error; validation against the schema, the
+ *  result write, the report push, and the schema clear all happen server-side
+ *  in `POST /nodes/{id}/result`. */
+function makeResultLeaf() {
+    return defineLeaf({
+        name: 'result',
+        description: 'answer a pending structured-output request with the required JSON result, or decline it',
+        whenToUse: 'your system prompt names a pending structured-output request you must answer. The value is validated against the required schema server-side; a mismatch rejects with field errors and records nothing, so fix and rerun. When the schema cannot be honestly satisfied (blocked, unavailable, bad input), pass `--decline "<reason>" --code <token>` (plus `--retryable` when the same request could succeed later) instead of inventing a value; your requester names the code tokens it accepts. For a terminal request either path IS how the node finishes — never call `crtr push final` alongside it.',
+        help: {
+            name: 'push result',
+            summary: 'answer a pending structured-output request',
+            params: [
+                { kind: 'stdin', name: 'value', required: false, constraint: "The JSON result. Pipe it from a single-quoted heredoc (`<<'EOF'`) to preserve literal bytes. Required unless `--decline` is passed." },
+                { kind: 'flag', name: 'decline', type: 'string', required: false, constraint: 'Decline instead of answering: one plain sentence on why the schema cannot be honestly satisfied (blocked, unavailable, bad input). Requires `--code`. Records a failure outcome with reason `declined` carrying the reason, code, and retryable flag, and clears the request; for a terminal request this finishes the node.' },
+                { kind: 'flag', name: 'code', type: 'string', required: false, constraint: 'With `--decline`: one whitespace-free token (≤ 64 chars) naming the decline class. crouter carries it verbatim; the requester validates it against the tokens it documented for you.' },
+                { kind: 'flag', name: 'retryable', type: 'bool', required: false, default: false, constraint: 'With `--decline`: the same request could succeed if issued again later (a transient block). Omit when the decline is final for this input.' },
+            ],
+            output: [
+                { name: 'mode', type: 'string', required: true, constraint: 'Which request this answered: `terminal` finished the node; `oneoff` left it working.' },
+                { name: 'result_path', type: 'string', required: true, constraint: 'Absolute path of the recorded artifact: the result JSON, or the declined marker when `--decline` was passed.' },
+                { name: 'declined', type: 'object', required: false, constraint: 'Present only when the request was declined: { reason, code, retryable } as recorded.' },
+                { name: 'report_path', type: 'string', required: true, constraint: 'Absolute path of the report pushed alongside the result.' },
+                { name: 'notified', type: 'string[]', required: true, constraint: 'Subscriber node ids that received an inbox pointer.' },
+                { name: 'transitioned', type: 'object', required: false, constraint: 'Present only for a terminal request that flipped the node — { from, to } lifecycle-status transition applied server-side.' },
+            ],
+            outputKind: 'object',
+            effects: [
+                'Validates the value against the pending schema server-side; a mismatch records nothing and the request stays pending.',
+                'Writes the accepted result to nodes/<nodeId>/context/result.json (or the decline to context/declined.json) and clears the pending request.',
+                'A terminal decline records a `failure` outcome with reason `declined` whose `declined` field carries { reason, code, retryable }; the requester sees no value.',
+                'Pushes the mode-matched report: final for a terminal request (the node finishes — same effects as `push final`), update for a one-off request (the node keeps working).',
+            ],
+        },
+        run: async (input) => {
+            const nodeId = requireCallerNode();
+            const decline = typeof input['decline'] === 'string' ? input['decline'].trim() : '';
+            const code = typeof input['code'] === 'string' ? input['code'].trim() : '';
+            let request;
+            if (decline !== '') {
+                if (code === '') {
+                    throw new InputError({ error: 'missing_decline_code', message: 'a decline needs a code', field: 'code', next: 'Pass `--code <token>` — the whitespace-free token your requester documented for this decline class.' });
+                }
+                request = { decline, code, retryable: input['retryable'] === true };
+            }
+            else {
+                if (code !== '' || input['retryable'] === true) {
+                    throw new InputError({ error: 'decline_flags_without_decline', message: '--code and --retryable only apply with --decline', next: 'Pass `--decline "<reason>"` alongside them, or drop them and submit the JSON result.' });
+                }
+                let raw = typeof input['value'] === 'string' ? input['value'].trim() : '';
+                if (raw === '')
+                    raw = (await readStdinRaw()).trim();
+                if (raw === '') {
+                    throw new InputError({ error: 'missing_value', message: 'no result value', field: 'value', next: 'Pass the JSON result as an argument or on stdin, or `--decline "<reason>" --code <token>` when the schema cannot be honestly satisfied.' });
+                }
+                let value;
+                try {
+                    value = JSON.parse(raw);
+                }
+                catch (err) {
+                    throw new InputError({
+                        error: 'bad_result_json',
+                        message: `the result is not valid JSON: ${err.message}`,
+                        field: 'value',
+                        next: 'Pass one valid JSON value matching the requested schema.',
+                    });
+                }
+                request = { value };
+            }
+            try {
+                const result = await cliClient().submitResult(nodeId, request);
+                if (result.mode === 'terminal')
+                    markStopSignal(nodeId, 'pushedFinal');
+                return {
+                    mode: result.mode,
+                    result_path: result.result_path,
+                    report_path: result.report_path,
+                    notified: result.notified,
+                    ...(result.declined === undefined ? {} : { declined: result.declined }),
+                    ...(result.transitioned !== undefined ? { transitioned: result.transitioned } : {}),
+                    ...(result.worktree_auto_dropped === true
+                        ? { worktree_auto_dropped: true, worktree_auto_dropped_path: result.worktree_auto_dropped_path }
+                        : {}),
+                };
+            }
+            catch (err) {
+                rethrowAsCliError(err);
+            }
+        },
+        render: (r) => {
+            const declined = r['declined'];
+            const line = r['mode'] === 'terminal'
+                ? `${declined ? 'Decline recorded' : 'Result recorded'} — node finished; its engine shuts down on next stop. Nothing more to do here: STOP your turn immediately. Reply with just "Done." and nothing else.`
+                : `${declined ? 'One-off request declined' : 'One-off result recorded'} and pushed — the structured-output gate is cleared; continue working normally.`;
+            const declinedLine = declined === undefined ? '' : `\n- code: ${declined.code} (${declined.retryable ? 'retryable' : 'not retryable'})`;
+            return `${line}\n\n- ${declined ? 'declined' : 'result'}: ${r['result_path']}${declinedLine}\n- report: ${r['report_path']}`;
+        },
+    });
+}
 function makePushLeaf(kind) {
     return defineLeaf({
         name: kind,
@@ -159,6 +260,6 @@ export function registerPush() {
             summary: 'push a report to your subscribers',
             model: "A push writes a markdown report to the node's reports/ history and fans a lightweight pointer to every subscriber's inbox. Delivery inlines reports under 1,000 characters with their absolute path; larger reports remain pointers to dereference. Nothing is pushed automatically — the feed contains only what a node pushes explicitly, so push whenever you want a manager to see something. Pipe markdown via a single-quoted heredoc so it reaches the report literally. `push final` is how ANY node finishes: write the canonical result, mark done, close the window.",
         },
-        children: [makePushLeaf('update'), makePushLeaf('final')],
+        children: [makePushLeaf('update'), makePushLeaf('final'), makeResultLeaf()],
     });
 }

package/dist/commands/sys/__tests__/setup-core.test.js

@@ -14,7 +14,10 @@ test('resolveBundledPiCliPath uses crouter bundled pi instead of a standalone pi
     try {
         const cliPath = resolveBundledPiCliPath();
         assert.equal(existsSync(cliPath), true);
-        assert.match(cliPath, /@earendil-works[\/]pi-coding-agent[\/]dist[\/]cli\.js$/);
+        // The path INSIDE the package is pi's own layout (0.84.4 moved it to
+        // dist/bundle/cli.js) and is read from its package.json `bin.pi` — assert
+        // only that we resolved into the bundled package.
+        assert.match(cliPath, /@earendil-works[\/]pi-coding-agent[\/].*cli\.js$/);
     }
     finally {
         if (prevPath === undefined)

package/dist/commands/sys/panels/broker-limits-panel.js

@@ -69,8 +69,14 @@ export class BrokerLimitsPanel {
             this.move(1);
         else if (matches("crtr.setup.list-up", data))
             this.move(-1);
+        // DEL (\x7f) is what terminals send for backspace and its code point sits
+        // above the control range, so it has to be excluded here or editing an
+        // existing value is refused as a non-digit keystroke.
         else if (data.length > 0 &&
-            [...data].every((char) => char.codePointAt(0) >= 32))
+            [...data].every((char) => {
+                const code = char.codePointAt(0);
+                return code >= 32 && code !== 127;
+            }))
             this.notice = "Broker limits accept digits only.";
         else {
             this.selected().handleInput(data);

package/dist/commands/sys/panels/models-panel.js

@@ -1,5 +1,5 @@
 import { envProfileId } from '../../../shared/env.js';
-import { ModelSelectorComponent, SettingsManager, ThinkingSelectorComponent, } from '@earendil-works/pi-coding-agent';
+import { ModelSelectorComponent, ThinkingSelectorComponent, } from '@earendil-works/pi-coding-agent';
 import { Input, truncateToWidth } from '@earendil-works/pi-tui';
 import { basename, dirname, join } from 'node:path';
 import { ANTHROPIC_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID, isManagedProvider, readSubscriptionPool, } from '../../../core/subscription-state.js';
@@ -744,7 +744,7 @@ export class ModelsPanel {
         this.notify();
     }
     showModelSelector(scoped, current, onPick) {
-        this.modelSelector = new ModelSelectorComponent(this.tui, current, SettingsManager.inMemory(), this.runtime, scoped.map((model) => ({ model })), onPick, () => this.closePicker());
+        this.modelSelector = new ModelSelectorComponent(this.tui, current, this.runtime, scoped.map((model) => ({ model })), onPick, () => this.closePicker());
         this.modelSelector.focused = true;
         this.mode = "model-picker";
         this.notify();

package/dist/commands/sys/settings-shell.d.ts

@@ -1,7 +1,7 @@
 import { ModelRegistry, ModelRuntime } from '@earendil-works/pi-coding-agent';
 import { TUI, type Component, type Focusable } from '@earendil-works/pi-tui';
 import { type BindingId, type BindingResolution } from '../../core/keybindings/index.js';
-export type DestinationId = "providers" | "models" | "keybindings" | "display" | "profiles" | "panes" | "broker-limits" | "updates";
+export type DestinationId = "providers" | "models" | "provider-options" | "keybindings" | "display" | "profiles" | "panes" | "broker-limits" | "updates";
 export declare class SettingsShell implements Component, Focusable {
     private readonly tui;
     private readonly bindings;