@north-light/crouter 0.3.278 → 0.3.280

package/dist/api/dto/model-config.d.ts

@@ -0,0 +1,25 @@
+export type ModelStrengthDTO = 'ultra' | 'strong' | 'medium' | 'light';
+export interface ModelRouteConfigDTO {
+    family: string;
+    credentialSource: string;
+    providerId: string;
+    models: Record<ModelStrengthDTO, string>;
+}
+export interface ModelRoutingDTO {
+    credentialSourceOrder?: string[];
+    familyOrder?: string[];
+    strengthFallback?: ModelStrengthDTO[];
+}
+export interface PutModelConfigRequest {
+    config_version: string;
+    modelRoutes: Record<string, ModelRouteConfigDTO>;
+    modelRouting: ModelRoutingDTO;
+    kinds: Record<string, {
+        model: string;
+        orchestratorModel?: string;
+    }>;
+}
+export interface PutModelConfigResponse {
+    config_version: string;
+    delivered: true;
+}

package/dist/api/dto/model-config.js

@@ -0,0 +1 @@
+export {};

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

@@ -4,8 +4,9 @@ import { anthropicMessagesApi, openAICodexResponsesApi } from '@earendil-works/p
 import { ANTHROPIC_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID, INVALID_REFRESH_TOKEN_BACKOFF_MS, formatStatusLine, getProviderLabel, isManagedProvider, isInvalidRefreshTokenError, addSubscription, enrichManagedLoginIdentity, markSubscriptionAuthenticationFailed, markSubscriptionRateLimited, markSubscriptionSuccess, parseRetryAfterHeader, promoteSubscription, readRotationConfig, readSubscriptionPool, refreshSubscriptionCredential, removeManagedAccount, resolveProviderCandidates, upsertSubscriptionWithUniqueAccount, } from '../../../core/subscription-state.js';
 import { readMergedLaunchConfig } from '../../../core/config.js';
 import { expandModelCandidates, modelRequestFromConfig, probeRouteAvailability } from '../../../core/model-routes.js';
-import { envModelExact } from '../../../shared/env.js';
+import { envModelExact, envNodeId } from '../../../shared/env.js';
 import { ManagedProviderCoolingError } from '../../../core/runtime/managed-provider-cooling.js';
+import { recordTransportPoisonVerdict } from '../../../core/runtime/busy.js';
 import { recognizeProviderError } from '../../../core/provider-error-recognition.js';
 // A response without Retry-After proves only that THIS attempt was throttled; it
 // does not authorize crouter to invent a five-minute provider-wide outage. Keep
@@ -102,8 +103,10 @@ export function __setSleepForTest(fn) {
 // heal (the dispatcher cannot be safely re-instantiated), so the recovery is a
 // fresh process: self-terminate via SIGTERM and let the daemon's exit policy
 // respawn this broker against the same session. A genuine full network outage
-// also trips this — harmlessly: the respawned broker fails the same way and the
-// daemon's respawn backoff paces the loop.
+// trips this too, and a fresh process cannot heal that one — so the daemon's
+// respawn path probes network reachability before it counts a relaunch, and an
+// offline box parks the node until the network returns instead of spending its
+// respawn budget (daemon/fleet.ts, `deferRespawnWhileOffline`).
 export const POISONED_TRANSPORT_PASS_LIMIT = 2;
 function defaultTerminatePoisonedProcess(tried) {
     // Only the broker process itself may self-terminate: runBroker stamps
@@ -111,6 +114,11 @@ function defaultTerminatePoisonedProcess(tried) {
     // keeps the ordinary terminal-error path.
     if (process.env["CRTR_BROKER_PID"] !== String(process.pid))
         return false;
+    const routes = tried.split(', ').filter((route) => route !== '');
+    const nodeId = envNodeId();
+    if (nodeId !== undefined && routes.length > 0) {
+        recordTransportPoisonVerdict(nodeId, { consecutivePasses: POISONED_TRANSPORT_PASS_LIMIT, routes });
+    }
     logRotation(`process transport poisoned: ${POISONED_TRANSPORT_PASS_LIMIT} consecutive route-queue passes failed with no HTTP response (tried ${tried}); exiting so the daemon respawns this broker fresh`);
     process.kill(process.pid, "SIGTERM");
     return true;

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

@@ -39,8 +39,9 @@ import {
 } from '../../../core/subscription-state.js';
 import { readMergedLaunchConfig } from '../../../core/config.js';
 import { expandModelCandidates, modelRequestFromConfig, probeRouteAvailability } from '../../../core/model-routes.js';
-import { envModelExact } from '../../../shared/env.js';
+import { envModelExact, envNodeId } from '../../../shared/env.js';
 import { ManagedProviderCoolingError } from '../../../core/runtime/managed-provider-cooling.js';
+import { recordTransportPoisonVerdict } from '../../../core/runtime/busy.js';
 import { recognizeProviderError, type ProviderErrorSignal } from '../../../core/provider-error-recognition.js';
 
 // A response without Retry-After proves only that THIS attempt was throttled; it
@@ -197,8 +198,10 @@ export function __setSleepForTest(fn: typeof defaultSleep | undefined): void {
 // heal (the dispatcher cannot be safely re-instantiated), so the recovery is a
 // fresh process: self-terminate via SIGTERM and let the daemon's exit policy
 // respawn this broker against the same session. A genuine full network outage
-// also trips this — harmlessly: the respawned broker fails the same way and the
-// daemon's respawn backoff paces the loop.
+// trips this too, and a fresh process cannot heal that one — so the daemon's
+// respawn path probes network reachability before it counts a relaunch, and an
+// offline box parks the node until the network returns instead of spending its
+// respawn budget (daemon/fleet.ts, `deferRespawnWhileOffline`).
 export const POISONED_TRANSPORT_PASS_LIMIT = 2;
 
 function defaultTerminatePoisonedProcess(tried: string): boolean {
@@ -206,6 +209,11 @@ function defaultTerminatePoisonedProcess(tried: string): boolean {
   // CRTR_BROKER_PID with its own pid at boot. Any other host (tests, tooling)
   // keeps the ordinary terminal-error path.
   if (process.env["CRTR_BROKER_PID"] !== String(process.pid)) return false;
+  const routes = tried.split(', ').filter((route) => route !== '');
+  const nodeId = envNodeId();
+  if (nodeId !== undefined && routes.length > 0) {
+    recordTransportPoisonVerdict(nodeId, { consecutivePasses: POISONED_TRANSPORT_PASS_LIMIT, routes });
+  }
   logRotation(
     `process transport poisoned: ${POISONED_TRANSPORT_PASS_LIMIT} consecutive route-queue passes failed with no HTTP response (tried ${tried}); exiting so the daemon respawns this broker fresh`,
   );

package/dist/clients/attach/chrome/status-line.js

@@ -18,15 +18,10 @@
 // explicitly replaced (the reconnect indicator, cleared by hand on redial).
 // That timer is why this module has a `dispose`.
 import { Text, truncateToWidth } from '@earendil-works/pi-tui';
-import { oldestRunningBashJobStartedAtMs } from '../../../core/bash-jobs.js';
-import { contextDir } from '../../../core/canvas/paths.js';
 import { visibleWidth } from '../../../core/canvas/nav-render.js';
 import { inTmux } from '../../../core/runtime/placement-tmux.js';
-import { backgroundBashHint, formatBinding, inboxOpenHint } from '../../../core/keybindings/index.js';
+import { formatBinding, inboxOpenHint } from '../../../core/keybindings/index.js';
 const NOTICE_CLEAR_MS = 3_000;
-/** R4 (Alt+C -> b hint): how long a foreground bash command must have been
- *  running before backgrounding it is worth suggesting. */
-const BASH_HINT_THRESHOLD_MS = 5_000;
 const formatTokens = (n) => n >= 1000 ? `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}k` : `${n}`;
 export function createStatusLine(s, hooks) {
     const { pal, tui, nodeId, remote } = s;
@@ -81,22 +76,6 @@ export function createStatusLine(s, hooks) {
         if (!hooks.mouseEnabled()) {
             segs.push(pal.muted('mouse off'));
         }
-        // Lowest-priority segment (R4): the Alt+C -> b hint, shown only once the
-        // oldest still-foreground bash job has crossed the threshold. Read straight
-        // off this node's job files rather than tracked from relayed tool-execution
-        // events — that on-disk state is the valve's own authoritative record of
-        // what is really running, so a fresh or reconnected attach (which never
-        // replays past events) reads it correctly with no viewer-local map that
-        // could go stale across a broker/session replacement. Evaluated per paint
-        // and on the viewer's existing 5s chrome poll — no new timer.
-        if (!remote && inTmux()) {
-            const oldestStart = oldestRunningBashJobStartedAtMs(contextDir(nodeId));
-            if (oldestStart !== undefined && Date.now() - oldestStart >= BASH_HINT_THRESHOLD_MS) {
-                const hint = backgroundBashHint(bindings);
-                if (hint !== null)
-                    segs.push(pal.muted(`⧗ ${hint}`));
-            }
-        }
         // The file-review affordance, tmux-only like the surface it opens.
         if (inTmux() && bindings.gestures('crtr.attach.file-review').length > 0) {
             segs.push(pal.muted(`${formatBinding(bindings, 'crtr.attach.file-review')} review file`));

package/dist/clients/attach/render/chat-view.d.ts

@@ -58,6 +58,10 @@ export interface ChatViewOptions {
     /** How the person opens their inbox on this surface, resolved lazily because
      *  bindings are resolved after ChatView is constructed. */
     pageOpenHint?: () => string;
+    /** How the person hands a still-running bash command to the background on this
+     *  surface, resolved lazily for the same reason. Null when this viewer cannot
+     *  invoke the handoff at all, which suppresses the row. */
+    backgroundBashHint?: () => string | null;
     /** Pre-colored banner lines pinned as the FIRST child of the chat container,
      *  above history (the crouton wordmark). Sits at the very top of the transcript
      *  and scrolls up into scrollback as the chat grows. Absent → no banner. */
@@ -85,6 +89,7 @@ export declare class ChatView {
     private readonly pageBlocks;
     private readonly inlinePageBlocks;
     private readonly pageOpenHint;
+    private readonly backgroundBashHint;
     /** Trailing cycles kept at full fidelity (config `live_cycles`). */
     private readonly liveCycles;
     /** Messages kept from a condensed cycle (config `condensed_history`). */
@@ -293,6 +298,12 @@ export declare class ChatView {
      *  way assistant prose stays. Condensed history is skipped deliberately — old
      *  cycles keep only prose and cycle seams. */
     private maybeAppendPageBlock;
+    /** Re-measure the tool calls still in flight. A silent long-running command
+     *  emits no tool-execution update, so nothing else would evict its cached
+     *  lines and its backgrounding hint would never appear. Driven by the
+     *  viewer's existing low-rate chrome poll, and cheap because it touches only
+     *  in-flight tools — usually one, never the transcript. */
+    refreshInFlightTools(): void;
     /** Re-read every placed page from disk. Driven by the viewer's ticket-activity
      *  watcher, so an answer, a cancellation, or a `--replace` revision lands on
      *  the block already anchored in the transcript. */

package/dist/clients/attach/render/chat-view.js

@@ -35,7 +35,7 @@ import { styleAttachAgentMarkdown, styleAttachMarkdownSource, styleAttachMessage
 import { createCrtrEditToolDefinition } from './edit-diff.js';
 import { GroupActivityRecorder } from './group-activity.js';
 import { GroupRecapComponent } from './group-recap.js';
-import { FoldedToolCallController, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
+import { FoldedToolCallController, bashCallBackgroundHintLines, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
 import { ringCompletionBell } from '../chrome/completion-bell.js';
 import { extractFilePaths } from '#core/human/visible-paths';
 import { keepWhenCondensed, liveRegionStart } from './condensed-history.js';
@@ -225,8 +225,13 @@ class MinimizableToolComponent extends ToolExecutionComponent {
         super.setExpanded(this.expandedState);
     }
     render(width) {
-        if (!this.minimized)
-            return super.render(width);
+        // The backgrounding row is appended HERE, by the component that owns the
+        // whole tool block, so it renders after the block's highlighted band ends
+        // instead of inside it. It is empty unless this is a bash call still running
+        // past the threshold.
+        if (!this.minimized) {
+            return [...super.render(width), ...bashCallBackgroundHintLines(this.foldController?.callComponent(), width)];
+        }
         const call = this.foldController?.callComponent();
         if (!call)
             return super.render(width);
@@ -276,6 +281,7 @@ export class ChatView {
     pageBlocks = new Map();
     inlinePageBlocks;
     pageOpenHint;
+    backgroundBashHint;
     /** Trailing cycles kept at full fidelity (config `live_cycles`). */
     liveCycles;
     /** Messages kept from a condensed cycle (config `condensed_history`). */
@@ -391,6 +397,7 @@ export class ChatView {
         this.onActivityChange = opts.onActivityChange;
         this.inlinePageBlocks = opts.inlinePageBlocks ?? false;
         this.pageOpenHint = opts.pageOpenHint ?? (() => 'crtr human list');
+        this.backgroundBashHint = opts.backgroundBashHint ?? (() => null);
         this.recapPalette = opts.palette ?? defaultAttachPalette;
         this.spinnerStyle = this.recapPalette.active;
         this.dimStyle = this.recapPalette.muted;
@@ -1380,7 +1387,7 @@ export class ChatView {
         let resultObserver;
         let toolDefinition;
         if (name === 'bash') {
-            toolDefinition = createCrtrBashToolDefinition(args, fold) ?? createCrtrPlainBashToolDefinition(this.cwd, fold);
+            toolDefinition = createCrtrBashToolDefinition(args, fold) ?? createCrtrPlainBashToolDefinition(this.cwd, fold, this.backgroundBashHint);
         }
         else if (name === 'edit') {
             const edit = createCrtrEditToolDefinition(this.cwd, fold);
@@ -1444,6 +1451,18 @@ export class ChatView {
         this.pageBlocks.set(page.pageId, block);
         this.append(block);
     }
+    /** Re-measure the tool calls still in flight. A silent long-running command
+     *  emits no tool-execution update, so nothing else would evict its cached
+     *  lines and its backgrounding hint would never appear. Driven by the
+     *  viewer's existing low-rate chrome poll, and cheap because it touches only
+     *  in-flight tools — usually one, never the transcript. */
+    refreshInFlightTools() {
+        if (this.pendingTools.size === 0)
+            return;
+        for (const component of this.pendingTools.values())
+            this.historyContainer.markDirty(component);
+        this.tui.requestRender();
+    }
     /** Re-read every placed page from disk. Driven by the viewer's ticket-activity
      *  watcher, so an answer, a cancellation, or a `--replace` revision lands on
      *  the block already anchored in the transcript. */

package/dist/clients/attach/render/tool-calls.d.ts

@@ -28,6 +28,11 @@ export declare function createCrtrReadToolDefinition(cwd: string, fold?: FoldedT
  *  syntax-highlighted content preview and its expand hint) with the icon
  *  prefixed onto its header line. Folded, only that header survives. */
 export declare function createCrtrWriteToolDefinition(cwd: string, fold?: FoldedToolCallController): unknown;
+/** The backgrounding row for a tool component's captured call — nothing unless
+ *  that call is a bash command still running past the threshold. The owning tool
+ *  component renders it after its whole block, which is what keeps the row
+ *  outside the highlighted band. */
+export declare function bashCallBackgroundHintLines(call: Component | undefined, width: number): string[];
 /** Attach-viewer `bash` for anything that is not a `crtr` invocation. */
-export declare function createCrtrPlainBashToolDefinition(cwd: string, fold?: FoldedToolCallController): unknown;
+export declare function createCrtrPlainBashToolDefinition(cwd: string, fold?: FoldedToolCallController, backgroundHint?: () => string | null): unknown;
 export {};

package/dist/clients/attach/render/tool-calls.js

@@ -20,6 +20,22 @@ import { TOOL_ICON } from '../../../core/preview-registry.js';
 function str(value) {
     return typeof value === 'string' ? value : '';
 }
+/** How long a bash command must have been running before the transcript offers
+ *  the backgrounding gesture under it. */
+const BACKGROUND_HINT_AFTER_MS = 5_000;
+/** The backgrounding affordance, under the running call it applies to, once the
+ *  command has been running long enough that waiting it out is a real choice.
+ *  Empty for a finished command, one short of the threshold, or a viewer that
+ *  cannot invoke the handoff — the transcript is the user/assistant exchange,
+ *  so this row exists only while it is actionable. */
+function backgroundHintLines(theme, startedAt, hint, width) {
+    if (startedAt === undefined || Date.now() - startedAt < BACKGROUND_HINT_AFTER_MS)
+        return [];
+    const text = hint?.() ?? null;
+    if (text === null)
+        return [];
+    return [truncateToWidth(`  ${theme.fg('muted', `⧗ ${text}`)}`, width, '…')];
+}
 /** Per-tool fold state owned by the attach viewer. Tool definitions capture the
  *  call component they render while folded, so the viewer never reaches into
  *  `ToolExecutionComponent`'s private renderer fields to recover it. */
@@ -236,16 +252,33 @@ class BashCallComponent {
     folded = false;
     timeout;
     theme;
+    startedAt;
+    hint;
     /** Nothing is cached across paints (render recomputes from the fields), so
      *  pi's cache-drop hook has nothing to do here. */
     invalidate() { }
-    update(theme, command, purpose, expanded, folded, timeout) {
+    update(theme, command, purpose, expanded, folded, timeout, startedAt, hint) {
         this.theme = theme;
         this.command = command;
         this.purpose = purpose;
         this.expanded = expanded;
         this.folded = folded;
         this.timeout = timeout;
+        this.startedAt = startedAt;
+        this.hint = hint;
+    }
+    /** The backgrounding affordance, under the call it applies to, once this
+     *  command has been running long enough that waiting it out is a real choice.
+     *  Empty for a command that has finished, one that has not reached the
+     *  threshold, or a viewer that cannot invoke the handoff — the transcript is
+     *  the user/assistant exchange, so this row exists only while it is
+     *  actionable. */
+    /** The backgrounding row for this call. Rendered by the tool component that
+     *  OWNS this call, after the whole block, so it lands outside the highlighted
+     *  band the block paints rather than inside it. */
+    backgroundHintLines(width) {
+        const theme = this.theme;
+        return theme === undefined ? [] : backgroundHintLines(theme, this.startedAt, this.hint, width);
     }
     render(width) {
         const theme = this.theme;
@@ -286,8 +319,15 @@ class BashCallComponent {
         return [truncateToWidth(`${icon} ${styleCommandLine(shown, theme)}${more}${suffix}`, width)];
     }
 }
+/** The backgrounding row for a tool component's captured call — nothing unless
+ *  that call is a bash command still running past the threshold. The owning tool
+ *  component renders it after its whole block, which is what keeps the row
+ *  outside the highlighted band. */
+export function bashCallBackgroundHintLines(call, width) {
+    return call instanceof BashCallComponent ? call.backgroundHintLines(width) : [];
+}
 /** Attach-viewer `bash` for anything that is not a `crtr` invocation. */
-export function createCrtrPlainBashToolDefinition(cwd, fold = new FoldedToolCallController()) {
+export function createCrtrPlainBashToolDefinition(cwd, fold = new FoldedToolCallController(), backgroundHint) {
     const builtin = createBashToolDefinition(cwd);
     return {
         name: 'bash',
@@ -305,12 +345,16 @@ export function createCrtrPlainBashToolDefinition(cwd, fold = new FoldedToolCall
                 state.endedAt = undefined;
             }
             const component = context.lastComponent instanceof BashCallComponent ? context.lastComponent : new BashCallComponent();
+            // Running = execution started and no result has stamped `endedAt`. The
+            // hint row lives on that fact, so it disappears the moment the command
+            // returns without anything having to clear it.
+            const running = state?.startedAt !== undefined && state.endedAt === undefined;
             component.update(theme, str(a?.command), 
             // The purpose stands in for the command only while folded; it is normalized
             // here because it is model-supplied text painted straight into the frame.
             fold.folded ? normalizeBashJobPurpose(a?.purpose) ?? undefined : undefined, 
             // Folded wins over ctrl+o expansion: a folded bash is always its one-line form.
-            Boolean(context.expanded) && !fold.folded, fold.folded, typeof a?.timeout === 'number' ? a.timeout : undefined);
+            Boolean(context.expanded) && !fold.folded, fold.folded, typeof a?.timeout === 'number' ? a.timeout : undefined, running ? state?.startedAt : undefined, backgroundHint);
             return fold.capture(component);
         },
         renderResult(result, options, theme, context) {

package/dist/clients/attach/session/bindings.d.ts

@@ -5,7 +5,7 @@ export type AttachActions = Record<AttachBindingId, () => void>;
 export declare const ATTACH_VIEWPORT_BINDINGS: readonly ["crtr.attach.scroll.up", "crtr.attach.scroll.down", "crtr.attach.scroll.page-up", "crtr.attach.scroll.page-down", "crtr.attach.scroll.live", "crtr.attach.mouse.toggle", "crtr.attach.copy.message"];
 export type AttachViewportBindingId = typeof ATTACH_VIEWPORT_BINDINGS[number];
 export type AttachViewportActions = Record<AttachViewportBindingId, () => void>;
-export { inboxOpenHint } from '../../../core/keybindings/index.js';
+export { backgroundBashHint, inboxOpenHint } from '../../../core/keybindings/index.js';
 export declare function matchesAttachBinding(bindings: AttachBindings, id: BindingId, data: string): boolean;
 export declare function dispatchAttachAction(id: AttachBindingId, actions: AttachActions): void;
 export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: AttachActions): boolean;

package/dist/clients/attach/session/bindings.js

@@ -13,7 +13,7 @@ export const ATTACH_VIEWPORT_BINDINGS = [
     'crtr.attach.mouse.toggle',
     'crtr.attach.copy.message',
 ];
-export { inboxOpenHint } from '../../../core/keybindings/index.js';
+export { backgroundBashHint, inboxOpenHint } from '../../../core/keybindings/index.js';
 export function matchesAttachBinding(bindings, id, data) {
     // Match the normalized chunk, never the raw one: a terminal that sends Option
     // as a meta prefix spells Alt+Shift+M in a form pi-tui rejects. Only matching

package/dist/clients/attach/session/chrome-refresh.d.ts

@@ -13,6 +13,9 @@ export interface ChromeRefreshHooks {
     refreshIdentity: () => void;
     renderFooter: () => void;
     renderExtensionWidgets: () => void;
+    /** Re-measure the tool calls still in flight, so a silent long-running bash
+     *  call still reaches its backgrounding hint with no per-call timer. */
+    refreshInFlightTools: () => void;
     /** Re-poll this pane's own git context (owned by the editor chrome). */
     pollGit: () => void;
 }

package/dist/clients/attach/session/chrome-refresh.js

@@ -62,9 +62,9 @@ export function createChromeRefresh(ctx, hooks) {
         hooks.refreshIdentity();
         hooks.renderExtensionWidgets();
         hooks.pollGit();
-        // R4: re-evaluate the bash-hint threshold on the existing 5s cadence, so a
-        // long-running SILENT bash call (no tool-execution update in between) still
-        // surfaces the hint without a new per-call timer.
+        // A long-running SILENT bash call emits no tool-execution update, so this
+        // cadence is what brings its backgrounding hint on screen.
+        hooks.refreshInFlightTools();
         hooks.renderFooter();
         void (async () => {
             const root = await climbRootFromSource(nodeId);