@north-light/crouter 0.3.282 → 0.3.284

package/dist/api/client.d.ts

@@ -1,15 +1,16 @@
 import type { DaemonRestartDTO, HealthDTO, StatusDTO } from './dto/health.js';
 import type { BashJobStatusDTO, BashJobStopResultDTO } from './dto/bash-jobs.js';
 import type { ArtifactListDTO, ArtifactsQuery, ContextListDTO, CreateNodeRequest, ListNodesQuery, NodeDetailDTO, NodeMessagesPageDTO, NodeMessagesQuery, NodeSessionDTO, NodeSnapshotDTO, NodeSubjectDTO, NodeSummaryDTO, TranscriptDTO, TranscriptQuery } from './dto/nodes.js';
+import type { NodeOutcomeResponseDTO, OutcomeDeliveryDTO, RegisterOutcomeDeliveryRequest } from './dto/node-outcomes.js';
 import type { InterruptResultDTO, MessageResultDTO, SendMessageRequest } from './dto/messages.js';
-import type { PushReportRequest, PushReportResultDTO, ReportDTO, ReportsQuery } from './dto/reports.js';
+import type { PushReportRequest, PushReportResultDTO, ReportDTO, ReportsQuery, SubmitResultDTO, SubmitResultRequest } from './dto/reports.js';
 import type { CloseRequest, CloseResultDTO, PromoteRequest, RelaunchRootResultDTO, ReviveRequest, ReviveResultDTO, WaitRequest, YieldRequest } from './dto/lifecycle.js';
 import type { SubscribeRequest, SubscriptionDTO } from './dto/subscriptions.js';
 import type { FocusDTO, RegisterFocusRequest, SetFocusPaneRequest } from './dto/focus.js';
 import { type ArmCronRequest, type CancelCronQuery, type CronDTO, type CronRunDTO, type CronScopeQuery, type CronShowDTO, type ListCronsQuery, type PokeCronsResult } from './dto/crons.js';
 import type { NodeConfigPatch } from './dto/config.js';
 import type { AttachEnsureRequest, AttachEnsureResultDTO } from './dto/attach.js';
-import type { DeleteProfileRequest, DeleteProfileResultDTO, EnsureProfileRequest, ProfileDTO, UpdateProfileMetadataRequest } from './dto/profiles.js';
+import type { DeleteProfileRequest, DeleteProfileResultDTO, EnsureProfileRequest, ProfileDTO, ProfilePauseResultDTO, UpdateProfileMetadataRequest } from './dto/profiles.js';
 import type { FilePeekDTO } from './dto/files.js';
 import type { MemoryDocRefDTO } from './dto/memory.js';
 import type { ChatInventoryDTO, ProspectiveChatInventoryDTO, ProspectiveChatInventoryQuery } from './dto/chat-inventory.js';
@@ -21,13 +22,15 @@ import type { CancelInboxTicketRequest, CanceledTicketResultDTO, InboxListDTO, I
 import type { CreateHumanRequestDTO, CreateHumanRequestRequest, HumanRequestDTO, HumanRequestIdDTO, ReplaceHumanRequestRequest, RespondHumanRequestRequest, SettleHumanRequestRequest } from './dto/human-requests.js';
 import type { AttentionCountsDTO, AttentionDTO, DashboardDTO, DashboardQuery, HistoryGrepQuery, HistoryGrepResultDTO, HistoryReadQuery, HistoryStatsQuery, HistoryStatsResultDTO, HistoryReadResultDTO, HistorySearchQuery, HistorySearchResultDTO, PruneRequest, PruneResultDTO, RebuildIndexResultDTO, RosterDTO, SnapshotDTO } from './dto/canvas.js';
 import type { AbandonWorktreeRequest, AbandonWorktreeResultDTO, CloseWorktreeResultDTO, QuarantinedWorktreeDTO } from './dto/worktree.js';
-import type { BrokerExtensionStateDTO, BrokerGeneratedNameRequest, BrokerGeneratedNameResultDTO, BrokerInboxCursorDirective, BrokerInboxCursorRequest, BrokerModelCommitRequest, BrokerModelCommitResultDTO, BrokerPersonaAckRequest, BrokerPersonaAckResultDTO, BrokerSessionBoundRequest, BrokerSessionBoundResultDTO, BrokerSettleDirective, BrokerSettleRequest } from './dto/broker-ops.js';
+import type { BrokerExtensionStateDTO, BrokerGeneratedNameRequest, BrokerGeneratedNameResultDTO, BrokerInboxCursorDirective, BrokerInboxCursorRequest, BrokerModelCommitRequest, BrokerModelCommitResultDTO, BrokerParkActivityResultDTO, BrokerParkCompleteRequest, BrokerPersonaAckRequest, BrokerPersonaAckResultDTO, BrokerSessionBoundRequest, BrokerSessionBoundResultDTO, BrokerSettleDirective, BrokerSettleRequest } from './dto/broker-ops.js';
 export interface CrtrClientOptions {
     /** Unix socket path (default local transport). Exactly one of socketPath|baseUrl. */
     socketPath?: string;
     /** `http(s)://host:port` for TCP/remote transport. */
     baseUrl?: string;
-    /** Extra headers (e.g. an edge auth token on TCP; crtrd ignores it). */
+    /** Extra headers, e.g. `{ authorization: 'Bearer <token>' }` when the target
+     *  crtrd's TCP listener has `CRTRD_TOKEN` set (unix-socket transport is
+     *  never checked, and a TCP daemon with no token set ignores this too). */
     headers?: Record<string, string>;
     /** Autostart on a cold socket (default true for socketPath, false for baseUrl). */
     autostart?: boolean;
@@ -95,6 +98,16 @@ export declare class CrtrClient {
      * latest/canonical reports and pending-human counts in the same response. */
     listNodes(q?: ListNodesQuery): Promise<NodeSummaryDTO[]>;
     getNode(id: string): Promise<NodeDetailDTO>;
+    /** Read a node outcome, optionally awaiting it for at most 25 seconds. This
+     * is a GET so the client can safely replay it across daemon handover. */
+    getNodeOutcome(id: string, { waitSeconds }?: {
+        waitSeconds?: number;
+    }): Promise<NodeOutcomeResponseDTO>;
+    /** Register or replace an armed target for terminal-outcome delivery. */
+    registerOutcomeDelivery(id: string, req: RegisterOutcomeDeliveryRequest): Promise<OutcomeDeliveryDTO>;
+    getOutcomeDelivery(id: string): Promise<OutcomeDeliveryDTO>;
+    /** Disarm an unsettled outcome-delivery registration. */
+    disarmOutcomeDelivery(id: string): Promise<void>;
     listBashJobs(id: string): Promise<BashJobStatusDTO[]>;
     stopBashJob(id: string, jobId: string): Promise<BashJobStopResultDTO>;
     sendMessage(id: string, req: SendMessageRequest): Promise<MessageResultDTO>;
@@ -103,11 +116,14 @@ export declare class CrtrClient {
      *  revives a dormant target. */
     interruptNode(id: string): Promise<InterruptResultDTO>;
     pushReport(id: string, req: PushReportRequest): Promise<PushReportResultDTO>;
+    submitResult(id: string, req: SubmitResultRequest): Promise<SubmitResultDTO>;
     forkNode(id: string): Promise<NodeDetailDTO>;
     reviveNode(id: string, req?: ReviveRequest): Promise<ReviveResultDTO>;
     relaunchRoot(id: string): Promise<RelaunchRootResultDTO>;
     bindBrokerSession(id: string, req: BrokerSessionBoundRequest): Promise<BrokerSessionBoundResultDTO>;
     settleBroker(id: string, req: BrokerSettleRequest): Promise<BrokerSettleDirective>;
+    completeBrokerPark(id: string, req: BrokerParkCompleteRequest): Promise<BrokerSettleDirective>;
+    recordBrokerParkActivity(id: string): Promise<BrokerParkActivityResultDTO>;
     advanceBrokerInboxCursor(id: string, req: BrokerInboxCursorRequest): Promise<BrokerInboxCursorDirective>;
     commitBrokerModel(id: string, req: BrokerModelCommitRequest): Promise<BrokerModelCommitResultDTO>;
     brokerExtensionState(id: string): Promise<BrokerExtensionStateDTO>;
@@ -187,6 +203,8 @@ export declare class CrtrClient {
     ensureProfile(name: string, req?: EnsureProfileRequest): Promise<ProfileDTO>;
     listProfiles(): Promise<ProfileDTO[]>;
     getProfile(name: string): Promise<ProfileDTO>;
+    pauseProfile(name: string): Promise<ProfilePauseResultDTO>;
+    resumeProfile(name: string): Promise<ProfilePauseResultDTO>;
     /** Merge and remove entries in a profile's metadata map. */
     updateProfileMetadata(name: string, req: UpdateProfileMetadataRequest): Promise<ProfileDTO>;
     /** Force-delete or detach one profile by exact id or unique name. */

package/dist/api/client.js

@@ -104,6 +104,25 @@ export class CrtrClient {
     getNode(id) {
         return this.request('GET', routes.node(this.nodePath(id)));
     }
+    /** Read a node outcome, optionally awaiting it for at most 25 seconds. This
+     * is a GET so the client can safely replay it across daemon handover. */
+    getNodeOutcome(id, { waitSeconds } = {}) {
+        if (waitSeconds !== undefined && (!Number.isInteger(waitSeconds) || waitSeconds < 0 || waitSeconds > 25)) {
+            throw new RangeError('waitSeconds must be an integer between 0 and 25');
+        }
+        return this.request('GET', withQuery(routes.nodeOutcome(this.nodePath(id)), { wait: waitSeconds }));
+    }
+    /** Register or replace an armed target for terminal-outcome delivery. */
+    registerOutcomeDelivery(id, req) {
+        return this.request('PUT', routes.nodeOutcomeDelivery(this.nodePath(id)), req);
+    }
+    getOutcomeDelivery(id) {
+        return this.request('GET', routes.nodeOutcomeDelivery(this.nodePath(id)));
+    }
+    /** Disarm an unsettled outcome-delivery registration. */
+    async disarmOutcomeDelivery(id) {
+        await this.request('DELETE', routes.nodeOutcomeDelivery(this.nodePath(id)));
+    }
     listBashJobs(id) {
         return this.request('GET', routes.nodeJobs(this.nodePath(id)));
     }
@@ -122,6 +141,9 @@ export class CrtrClient {
     pushReport(id, req) {
         return this.request('POST', routes.nodeReports(this.nodePath(id)), req);
     }
+    submitResult(id, req) {
+        return this.request('POST', routes.nodeResult(this.nodePath(id)), req);
+    }
     forkNode(id) {
         return this.request('POST', routes.nodeFork(this.nodePath(id)), {});
     }
@@ -137,6 +159,12 @@ export class CrtrClient {
     settleBroker(id, req) {
         return this.request('POST', routes.nodeBrokerSettle(this.nodePath(id)), req);
     }
+    completeBrokerPark(id, req) {
+        return this.request('POST', routes.nodeBrokerParkComplete(this.nodePath(id)), req);
+    }
+    recordBrokerParkActivity(id) {
+        return this.request('POST', routes.nodeBrokerParkActivity(this.nodePath(id)), {});
+    }
     advanceBrokerInboxCursor(id, req) {
         return this.request('POST', routes.nodeBrokerInboxCursor(this.nodePath(id)), req);
     }
@@ -319,6 +347,12 @@ export class CrtrClient {
     getProfile(name) {
         return this.request('GET', routes.profile(name));
     }
+    pauseProfile(name) {
+        return this.request('POST', routes.profilePause(name), {});
+    }
+    resumeProfile(name) {
+        return this.request('POST', routes.profileResume(name), {});
+    }
     /** Merge and remove entries in a profile's metadata map. */
     updateProfileMetadata(name, req) {
         return this.request('PATCH', routes.profileMetadata(name), req);

package/dist/api/dto/broker-ops.d.ts

@@ -36,6 +36,17 @@ export type BrokerSettleDirective = {
 } | {
     action: 'shutdown';
 };
+/** A main-engine input has won broker admission while a parking summary may be
+ * in flight. crtrd records it against the process-local pending marker before
+ * Pi begins the input, making parking completion and input admission atomic. */
+export interface BrokerParkActivityResultDTO {
+    activity: 'recorded' | 'none';
+}
+/** `POST /v1/nodes/{id}/broker/park-complete` body. The isolated parking turn
+ * has ended; crtrd alone decides whether its pending park still applies. */
+export interface BrokerParkCompleteRequest {
+    outcome: 'completed' | 'failed';
+}
 /** `POST /v1/nodes/{id}/broker/inbox-cursor` body. The watcher advances this
  * only after Pi has settled every handoff through the supplied physical entry.
  * `brokerPid` binds the commit to the broker generation crtrd currently owns. */

package/dist/api/dto/broker.d.ts

@@ -46,11 +46,6 @@ export interface BrokerWelcomeFrame<M = unknown> {
     type: 'welcome';
     snapshot?: BrokerWelcomeSnapshot<M>;
 }
-/** The presentation classification of the run whose native events follow. */
-export interface BrokerTurnVisibilityFrame {
-    type: 'turn_visibility';
-    visibility: 'visible' | 'internal';
-}
 /**
  * The crtrd broker `node_named` control frame — the node's generated name at the
  * instant crtrd committed it.
@@ -76,12 +71,12 @@ export interface BrokerNodeNamedFrame {
     editorLabel: string;
 }
 /**
- * The broker-control frames a relay consumer reads: `welcome` (catch-up snapshot),
- * `turn_visibility`, `error`, and `node_named`. The broker interleaves others (display_*, ack, …)
+ * The broker-control frames a relay consumer reads: `welcome`, `error`, and
+ * `node_named`. The broker interleaves others (display_*, ack, …)
  * under non-colliding `type` discriminants; a relay mapper drops those through its
  * `default` arm untyped, so they are not enumerated here.
  */
-export type BrokerControlFrame<M = unknown> = BrokerWelcomeFrame<M> | BrokerTurnVisibilityFrame | BrokerErrorFrame | BrokerNodeNamedFrame;
+export type BrokerControlFrame<M = unknown> = BrokerWelcomeFrame<M> | BrokerErrorFrame | BrokerNodeNamedFrame;
 /**
  * What the crtrd broker attach delivers to a relay consumer: the live engine
  * event stream (`E` — pi's `AgentSessionEvent`, relayed verbatim) unioned with the

package/dist/api/dto/common.d.ts

@@ -20,7 +20,7 @@ export type ModeDTO = 'base' | 'orchestrator';
 /** Why a node last stopped (mirrors the runtime `ExitIntent` union). */
 export type ExitIntentDTO = 'done' | 'refresh' | 'idle-release' | 'parked' | null;
 /** Why a terminal node ended (mirrors the runtime `TerminalReason` union). */
-export type TerminalReasonDTO = 'finalized' | 'finished' | 'parked' | 'closed' | 'retired' | 'crashed' | 'stranded';
+export type TerminalReasonDTO = 'finalized' | 'finished' | 'parked' | 'closed' | 'retired' | 'crashed' | 'stranded' | 'boot_failed' | 'crash_looped' | 'launch_failed' | 'context_overflow' | 'deadline_exceeded' | 'provider_fatal' | 'declined';
 /** Inbox urgency tier for a delivered message (mirrors feed/inbox `InboxTier`). */
 export type InboxTierDTO = 'critical' | 'urgent' | 'normal' | 'deferred';
 /** Whether a node id is a safe single filesystem path segment. Re-declared here

package/dist/api/dto/messages.d.ts

@@ -36,8 +36,8 @@ export interface SendMessageRequest {
     /** One-shot runtime cards for this turn only — never persisted. Delivered in
      *  array order, after `situational_card` and ahead of the body. */
     context_cards?: RuntimeCardRequest[];
-    /** Raw JSON-schema string granting a one-off `submit` tool before delivery
-     *  (`--output-schema`). Immediate only. */
+    /** Raw JSON-schema string installing a one-off output schema before delivery
+     *  (`--output-schema`); the target answers with `crtr push result`. Immediate only. */
     output_schema?: string;
     /** `'interactive'`: deliver via the target's LIVE broker engine (prompt/steer
      *  on its one serialized frame loop — the same ordering a tmux viewer gets)

package/dist/api/dto/node-outcomes.d.ts

@@ -0,0 +1,80 @@
+import type { IsoTime, NodeIdDTO, NodeStatusDTO, TerminalReasonDTO } from './common.js';
+import type { DeclinedResultDTO } from './reports.js';
+export type OutcomeKindDTO = 'result' | 'failure';
+/** Bounded diagnostics recorded for a failed node outcome. */
+export interface NodeOutcomeDetailV1 {
+    schema: 'crtr.node-outcome-detail/v1';
+    message?: string;
+    fault_kind?: 'rate-limit' | 'overloaded' | 'connection' | 'auth' | 'protocol' | 'context-overflow' | 'other' | 'wedged' | 'model-not-found';
+    error_class?: 'rate_limit' | 'overloaded' | 'connection' | 'auth' | 'protocol' | 'context_overflow' | 'wedged' | 'model_not_found' | 'unknown';
+    respawn_failures?: number;
+    deadline?: {
+        deadline_at: string;
+        elapsed_ms: number;
+    };
+    /** Present only for reason `declined`: what the node gave `crtr push result --decline`. */
+    declined?: DeclinedResultDTO;
+    truncated?: true;
+}
+interface NodeOutcomeBaseDTO {
+    node_id: NodeIdDTO;
+    revision: number;
+    settled_at: IsoTime;
+    /** Canonical final report basename; set for kind='result' and for a declined structured result (kind='failure', reason='declined'); else null. */
+    final_report: string | null;
+    /** Absolute path of the canonical final report; null whenever `final_report` is. */
+    final_report_path: string | null;
+    /** Parsed context/result.json when the node ran under --output-schema; else null. */
+    structured_result: unknown | null;
+    /** Bounded diagnostics; null for kind='result'. */
+    detail: NodeOutcomeDetailV1 | null;
+}
+/** A settled outcome. Narrowing on `kind` then `reason` makes a declined
+ *  structured result (`failure`/`declined`) a case a consumer must handle:
+ *  only that case carries `declined`; every other outcome has it null. */
+export type NodeOutcomeDTO = (NodeOutcomeBaseDTO & {
+    kind: 'result';
+    reason: TerminalReasonDTO;
+    declined: null;
+}) | (NodeOutcomeBaseDTO & {
+    kind: 'failure';
+    reason: 'declined';
+    declined: DeclinedResultDTO;
+}) | (NodeOutcomeBaseDTO & {
+    kind: 'failure';
+    reason: Exclude<TerminalReasonDTO, 'declined'>;
+    declined: null;
+});
+export interface NodeOutcomeResponseDTO {
+    node_id: NodeIdDTO;
+    state: 'pending' | 'settled';
+    outcome: NodeOutcomeDTO | null;
+    node_status: NodeStatusDTO;
+    deadline_at: IsoTime | null;
+}
+export interface RegisterOutcomeDeliveryRequest {
+    /** A name declared in the humanActions map of scope config. */
+    action: string;
+    /** Opaque, frozen at registration, echoed verbatim in the document. */
+    payload?: unknown;
+}
+export type OutcomeDeliveryStateDTO = 'armed' | 'pending' | 'running' | 'accepted' | 'permanent_failed';
+export interface OutcomeDeliveryDTO {
+    node_id: NodeIdDTO;
+    state: OutcomeDeliveryStateDTO;
+    action: string;
+    attempt: number;
+    /** ISO-8601 time of the next retry, or null before the row is scheduled. */
+    next_attempt_at: IsoTime | null;
+    accepted_at: IsoTime | null;
+    permanent_failed_at: IsoTime | null;
+    last_failure: {
+        kind: string;
+        exit_code?: number;
+        signal?: string;
+        message?: string;
+    } | null;
+    created_at: IsoTime;
+    updated_at: IsoTime;
+}
+export {};

package/dist/api/dto/node-outcomes.js

@@ -0,0 +1,2 @@
+// Node terminal-outcome and outcome-delivery DTOs.
+export {};

package/dist/api/dto/nodes.d.ts

@@ -1,5 +1,6 @@
 import type { Cursor, ExitIntentDTO, IsoTime, LifecycleDTO, ModeDTO, NodeIdDTO, NodeStatusDTO, TerminalReasonDTO } from './common.js';
 import type { ReportDTO } from './reports.js';
+import type { NodeOutcomeDTO, RegisterOutcomeDeliveryRequest } from './node-outcomes.js';
 /** `GET /v1/nodes/{id}/subject` — the node-config subject substrate gate
  *  predicates evaluate against. Mirrors `NodeConfigSubject`; this narrow
  *  endpoint exists so a CLI process (the `memory read` leaf) can gate-check
@@ -51,6 +52,10 @@ export interface CreateNodeRequest {
     situational_context?: string;
     no_kickoff?: boolean;
     output_schema?: string;
+    /** Wall-clock bound from spawn, e.g. "45m", "2h", "1h30m". Expiry cancels the node and synthesizes a failure outcome with reason 'deadline_exceeded'. */
+    deadline?: string;
+    /** Arm outcome delivery atomically with node birth. */
+    outcome_delivery?: RegisterOutcomeDeliveryRequest;
     /** Spawn AT this exact node id instead of a runtime-minted one — format-
      *  validated and duplicate-rejected server-side (`NodeIdConflictError` →
      *  HTTP 409 `node_id_exists`). See `crtr node new --node-id`. */
@@ -80,6 +85,8 @@ export interface NodeSummaryDTO {
     cwd: string;
     host_kind: 'tmux' | 'broker' | null;
     profile_id: string | null;
+    /** Whether the node's profile is currently paused. */
+    profile_paused: boolean;
     parent: NodeIdDTO | null;
     created: IsoTime;
     intent: ExitIntentDTO;
@@ -96,6 +103,8 @@ export interface NodeSummaryDTO {
     /** Basename of the canonical final report, or null when this node has not finalized. */
     final_report: string | null;
     finalized_at: IsoTime | null;
+    deadline_at: IsoTime | null;
+    outcome: NodeOutcomeDTO | null;
     /** Present only when requested with `include=activity`. */
     activity?: NodeActivityDTO;
 }

package/dist/api/dto/profiles.d.ts

@@ -28,6 +28,11 @@ export interface UpdateProfileMetadataRequest {
     set?: Record<string, string>;
     unset?: string[];
 }
+/** The daemon-owned result of pausing or resuming one profile. */
+export interface ProfilePauseResultDTO {
+    profile_id: string;
+    paused_at: string | null;
+}
 /** `DELETE /v1/profiles/{name}` body. Destructive deletion is never implicit. */
 export interface DeleteProfileRequest {
     force: boolean;

package/dist/api/dto/reports.d.ts

@@ -31,6 +31,51 @@ export interface PushReportResultDTO {
     /** Present only alongside `worktree_auto_dropped`: the checkout path dropped. */
     worktree_auto_dropped_path?: string;
 }
+/** Why a node declined a structured result. `reason` is one plain sentence
+ *  for a reader; `code` is an opaque token the requester classifies on and
+ *  validates itself — crouter only carries it; `retryable` is the node's
+ *  claim that the same request could succeed later. */
+export interface DeclinedResultDTO {
+    reason: string;
+    code: string;
+    retryable: boolean;
+}
+/** `POST /v1/nodes/{id}/result` body ({id} = the submitting node). Either the
+ *  structured result to validate against the node's pending output schema —
+ *  `value` must be present; any JSON value (including null) is legal input to
+ *  validation — or a decline: `decline` is the reason sentence, `code` the
+ *  requester-classified token, `retryable` the node's retry claim. A decline
+ *  records a `failure` outcome with reason `declined` carrying all three and
+ *  clears the request without validating anything. */
+export type SubmitResultRequest = {
+    value: unknown;
+} | {
+    decline: string;
+    code: string;
+    retryable: boolean;
+};
+/** Result of a structured-result submission (`crtr push result`). Terminal
+ *  mode reuses the final-push machinery, so `transitioned` and the worktree
+ *  auto-drop fields carry the same meaning as on PushReportResultDTO. */
+export interface SubmitResultDTO {
+    /** Which request this answered: `terminal` finished the node; `oneoff` left it working. */
+    mode: 'terminal' | 'oneoff';
+    /** Absolute path of the recorded artifact: context/result.json for an
+     *  answered request, context/declined.json for a declined one. */
+    result_path: string;
+    /** Present only when the request was declined. */
+    declined?: DeclinedResultDTO;
+    /** Absolute path of the report pushed alongside the result. */
+    report_path: string;
+    /** Subscriber node ids that received an inbox entry. */
+    notified: NodeIdDTO[];
+    transitioned?: {
+        from: string;
+        to: string;
+    };
+    worktree_auto_dropped?: boolean;
+    worktree_auto_dropped_path?: string;
+}
 /** `GET /v1/nodes/{id}/reports` query filters. */
 export interface ReportsQuery {
     tier?: ReportTierDTO;

package/dist/api/index.d.ts

@@ -7,6 +7,7 @@ export * from '../shared/generated-context.js';
 export * from './dto/common.js';
 export * from './dto/health.js';
 export * from './dto/nodes.js';
+export * from './dto/node-outcomes.js';
 export * from './dto/bash-jobs.js';
 export * from './dto/messages.js';
 export * from './dto/reports.js';

package/dist/api/index.js

@@ -8,6 +8,7 @@ export * from '../shared/generated-context.js';
 export * from './dto/common.js';
 export * from './dto/health.js';
 export * from './dto/nodes.js';
+export * from './dto/node-outcomes.js';
 export * from './dto/bash-jobs.js';
 export * from './dto/messages.js';
 export * from './dto/reports.js';

package/dist/api/routes.d.ts

@@ -8,6 +8,8 @@ export declare const routes: {
     readonly nodes: () => string;
     readonly reviveAll: () => string;
     readonly node: (id: string) => string;
+    readonly nodeOutcome: (id: string) => string;
+    readonly nodeOutcomeDelivery: (id: string) => string;
     readonly nodeSnapshot: (id: string) => string;
     readonly nodeSubject: (id: string) => string;
     readonly nodeSession: (id: string) => string;
@@ -17,6 +19,7 @@ export declare const routes: {
     readonly nodeContext: (id: string) => string;
     readonly nodeArtifacts: (id: string) => string;
     readonly nodeReports: (id: string) => string;
+    readonly nodeResult: (id: string) => string;
     readonly nodeJobs: (id: string) => string;
     readonly nodeJob: (id: string, jobId: string) => string;
     readonly nodeMessages: (id: string) => string;
@@ -26,6 +29,8 @@ export declare const routes: {
     readonly nodeRelaunchRoot: (id: string) => string;
     readonly nodeBrokerSessionBound: (id: string) => string;
     readonly nodeBrokerSettle: (id: string) => string;
+    readonly nodeBrokerParkComplete: (id: string) => string;
+    readonly nodeBrokerParkActivity: (id: string) => string;
     readonly nodeBrokerInboxCursor: (id: string) => string;
     readonly nodeBrokerModel: (id: string) => string;
     readonly nodeBrokerExtensionState: (id: string) => string;
@@ -96,6 +101,8 @@ export declare const routes: {
     readonly humanRequestCancel: (requestId: string) => string;
     readonly profiles: () => string;
     readonly profile: (name: string) => string;
+    readonly profilePause: (name: string) => string;
+    readonly profileResume: (name: string) => string;
     readonly profileMetadata: (name: string) => string;
     readonly modelAuths: () => string;
     readonly modelAuth: (provider: string) => string;

package/dist/api/routes.js

@@ -23,6 +23,8 @@ export const routes = {
     nodes: () => `${V}/nodes`,
     reviveAll: () => `${V}/nodes/revive-all`,
     node: (id) => `${V}/nodes/${id}`,
+    nodeOutcome: (id) => `${V}/nodes/${id}/outcome`,
+    nodeOutcomeDelivery: (id) => `${V}/nodes/${id}/outcome-delivery`,
     // Node reads
     nodeSnapshot: (id) => `${V}/nodes/${id}/snapshot`,
     nodeSubject: (id) => `${V}/nodes/${id}/subject`,
@@ -33,6 +35,7 @@ export const routes = {
     nodeContext: (id) => `${V}/nodes/${id}/context`,
     nodeArtifacts: (id) => `${V}/nodes/${id}/artifacts`,
     nodeReports: (id) => `${V}/nodes/${id}/reports`,
+    nodeResult: (id) => `${V}/nodes/${id}/result`,
     nodeJobs: (id) => `${V}/nodes/${id}/jobs`,
     nodeJob: (id, jobId) => `${V}/nodes/${id}/jobs/${jobId}`,
     // Node messages / feed
@@ -44,6 +47,8 @@ export const routes = {
     nodeRelaunchRoot: (id) => `${V}/nodes/${id}/relaunch-root`,
     nodeBrokerSessionBound: (id) => `${V}/nodes/${id}/broker/session-bound`,
     nodeBrokerSettle: (id) => `${V}/nodes/${id}/broker/settle`,
+    nodeBrokerParkComplete: (id) => `${V}/nodes/${id}/broker/park-complete`,
+    nodeBrokerParkActivity: (id) => `${V}/nodes/${id}/broker/park-activity`,
     nodeBrokerInboxCursor: (id) => `${V}/nodes/${id}/broker/inbox-cursor`,
     nodeBrokerModel: (id) => `${V}/nodes/${id}/broker/model`,
     nodeBrokerExtensionState: (id) => `${V}/nodes/${id}/broker/extension-state`,
@@ -127,6 +132,8 @@ export const routes = {
     // Profiles (deletion is daemon-owned because it crosses canvas state)
     profiles: () => `${V}/profiles`,
     profile: (name) => `${V}/profiles/${name}`,
+    profilePause: (name) => `${V}/profiles/${name}/pause`,
+    profileResume: (name) => `${V}/profiles/${name}/resume`,
     profileMetadata: (name) => `${V}/profiles/${name}/metadata`,
     // Model auth
     modelAuths: () => `${V}/model-auth`,

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/provider-rotation.js

@@ -405,6 +405,18 @@ async function streamProviderAttempt(state, providerId, model, context, options,
                     fetch: withAnthropicFallbackBeta(options?.fetch ?? globalThis.fetch),
                 }
                 : {}),
+            // Codex fast mode: the ChatGPT backend serves the turn at its priority
+            // tier. The wire value is `priority` (`fast` is rejected 400), and the
+            // response always echoes `service_tier: "default"` regardless — only
+            // generation timing shows whether it took effect.
+            ...(providerId === OPENAI_CODEX_PROVIDER_ID && state.providerOptions?.[OPENAI_CODEX_PROVIDER_ID]?.fastMode === true
+                ? {
+                    onPayload: async (payload, payloadModel) => {
+                        const callerPayload = await options?.onPayload?.(payload, payloadModel);
+                        return { ...(callerPayload === undefined ? payload : callerPayload), service_tier: "priority" };
+                    },
+                }
+                : {}),
             onResponse: async (response, responseModel) => {
                 observedStatus = response.status;
                 if (response.status === 429 || response.status === 503) {
@@ -773,8 +785,12 @@ function parseCommand(args) {
 function parseProvider(value) {
     return isManagedProvider(value) ? value : undefined;
 }
-function installDeclaredRouteProviders(state, pi, ctx) {
-    const config = readMergedLaunchConfig(ctx.cwd, configuredValue(state, 'profileId', 'CRTR_PROFILE_ID') || null);
+/** Merged config for the NODE's scope (its own cwd/profile), not this
+ *  process's ambient one. */
+function readTargetLaunchConfig(state, ctx) {
+    return readMergedLaunchConfig(ctx.cwd, configuredValue(state, 'profileId', 'CRTR_PROFILE_ID') || null);
+}
+function installDeclaredRouteProviders(state, pi, ctx, config) {
     const providerIds = new Set(Object.values({ ...(config.modelRoutes ?? {}), ...(config.legacyModelRoutes ?? {}) }).map((route) => route.providerId));
     for (const providerId of providerIds) {
         if (isManagedProvider(providerId) || state.delegatedProviderStreams.has(providerId))
@@ -931,11 +947,16 @@ export function createProviderRotationExtension(options) {
         });
         pi.on("session_start", async (_event, ctx) => {
             state.runtimeContext = ctx;
-            installDeclaredRouteProviders(state, pi, ctx);
+            const config = readTargetLaunchConfig(state, ctx);
+            state.providerOptions = config.providerOptions;
+            installDeclaredRouteProviders(state, pi, ctx, config);
             updateRotationStatus(state, ctx);
         });
         pi.on("before_agent_start", async (_event, ctx) => {
             state.runtimeContext = ctx;
+            // Re-read per turn: this is what makes a provider-options toggle apply to
+            // a broker that is already running, on its next turn.
+            state.providerOptions = readTargetLaunchConfig(state, ctx).providerOptions;
             const restored = await restoreHigherRankIfAvailable(state, pi, ctx);
             if (restored && ctx.model && isManagedProvider(ctx.model.provider)) {
                 logRotation(`restored higher-ranked route ${ctx.model.provider}/${ctx.model.id}`);

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/provider-rotation.ts

@@ -37,7 +37,8 @@ import {
   type ManagedProviderId,
   type SubscriptionCredential,
 } from '../../../core/subscription-state.js';
-import { readMergedLaunchConfig } from '../../../core/config.js';
+import { readMergedLaunchConfig, type MergedLaunchConfig } from '../../../core/config.js';
+import type { ProviderOptionsConfig } from '../../../types.js';
 import { expandModelCandidates, modelRequestFromConfig, probeRouteAvailability } from '../../../core/model-routes.js';
 import { envModelExact, envNodeId } from '../../../shared/env.js';
 import { ManagedProviderCoolingError } from '../../../core/runtime/managed-provider-cooling.js';
@@ -83,6 +84,10 @@ type ProviderRotationState = {
   extensionAPI?: ExtensionAPI;
   delegatedProviderStreams: Map<string, ProviderStream>;
   options?: Readonly<ProviderRotationOptions>;
+  /** Per-provider behavior options from merged config, refreshed at session
+   *  start and before every agent turn so a settings toggle reaches a broker
+   *  that is already live. */
+  providerOptions?: Record<string, ProviderOptionsConfig>;
   /** Consecutive route-queue passes that exhausted every route without a single
    * HTTP response — the poisoned-process signature counted across turns. */
   transportOnlyExhaustedPasses: number;
@@ -563,6 +568,18 @@ async function streamProviderAttempt(
             fetch: withAnthropicFallbackBeta(options?.fetch ?? globalThis.fetch),
           }
         : {}),
+      // Codex fast mode: the ChatGPT backend serves the turn at its priority
+      // tier. The wire value is `priority` (`fast` is rejected 400), and the
+      // response always echoes `service_tier: "default"` regardless — only
+      // generation timing shows whether it took effect.
+      ...(providerId === OPENAI_CODEX_PROVIDER_ID && state.providerOptions?.[OPENAI_CODEX_PROVIDER_ID]?.fastMode === true
+        ? {
+            onPayload: async (payload: unknown, payloadModel: Model<any>) => {
+              const callerPayload = await options?.onPayload?.(payload, payloadModel);
+              return { ...((callerPayload === undefined ? payload : callerPayload) as Record<string, unknown>), service_tier: "priority" };
+            },
+          }
+        : {}),
       onResponse: async (response: { status: number; headers: Record<string, string> }, responseModel: Model<any>) => {
         observedStatus = response.status;
         if (response.status === 429 || response.status === 503) {
@@ -957,8 +974,13 @@ function parseProvider(value: string | undefined): ManagedProviderId | undefined
   return isManagedProvider(value) ? value : undefined;
 }
 
-function installDeclaredRouteProviders(state: ProviderRotationState, pi: ExtensionAPI, ctx: ExtensionContext): void {
-  const config = readMergedLaunchConfig(ctx.cwd, configuredValue(state, 'profileId', 'CRTR_PROFILE_ID') || null);
+/** Merged config for the NODE's scope (its own cwd/profile), not this
+ *  process's ambient one. */
+function readTargetLaunchConfig(state: ProviderRotationState, ctx: ExtensionContext): MergedLaunchConfig {
+  return readMergedLaunchConfig(ctx.cwd, configuredValue(state, 'profileId', 'CRTR_PROFILE_ID') || null);
+}
+
+function installDeclaredRouteProviders(state: ProviderRotationState, pi: ExtensionAPI, ctx: ExtensionContext, config: MergedLaunchConfig): void {
   const providerIds = new Set(Object.values({ ...(config.modelRoutes ?? {}), ...(config.legacyModelRoutes ?? {}) }).map((route) => route.providerId));
   for (const providerId of providerIds) {
     if (isManagedProvider(providerId) || state.delegatedProviderStreams.has(providerId)) continue;
@@ -1129,12 +1151,17 @@ export function createProviderRotationExtension(options?: ProviderRotationOption
 
     pi.on("session_start", async (_event, ctx) => {
       state.runtimeContext = ctx;
-      installDeclaredRouteProviders(state, pi, ctx);
+      const config = readTargetLaunchConfig(state, ctx);
+      state.providerOptions = config.providerOptions;
+      installDeclaredRouteProviders(state, pi, ctx, config);
       updateRotationStatus(state, ctx);
     });
 
     pi.on("before_agent_start", async (_event, ctx) => {
       state.runtimeContext = ctx;
+      // Re-read per turn: this is what makes a provider-options toggle apply to
+      // a broker that is already running, on its next turn.
+      state.providerOptions = readTargetLaunchConfig(state, ctx).providerOptions;
       const restored = await restoreHigherRankIfAvailable(state, pi, ctx);
       if (restored && ctx.model && isManagedProvider(ctx.model.provider)) {
         logRotation(`restored higher-ranked route ${ctx.model.provider}/${ctx.model.id}`);

package/dist/clients/attach/overlays/graph.d.ts

@@ -54,6 +54,11 @@ export declare class GraphOverlay implements Component {
     refresh(): void;
     invalidate(): void;
     private buildSnapshot;
+    /** Fold state is presentation-only. Reproject the visible DFS from the fully
+     * fetched topology so h/l never cross the daemon boundary. The explicit stack
+     * also keeps a deep graph from consuming the JavaScript call stack. */
+    private projectRows;
+    private repaintFolds;
     private renderSnapshotRow;
     render(width: number): string[];
     /** A top/bottom border row: `<lc>─ <label> ────<rc>`, frame in the theme border