@north-light/crouter 0.3.277 → 0.3.279

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/input/capabilities.js

@@ -74,7 +74,7 @@ export function viewerOperationForFrame(frame) {
 export function viewerOperationForSlash(name, builtin, canvas) {
     if (canvas) {
         switch (name) {
-            case 'resume-node': return 'canvas-resume';
+            case 'resume': return 'canvas-resume';
             case 'context':
             case 'node-metadata': return 'local-canvas-inspect';
             // `/plugins` configures the local machine, not this node; observers and
@@ -84,6 +84,7 @@ export function viewerOperationForSlash(name, builtin, canvas) {
             case 'clear':
             case 'promote':
             case 'rename':
+            case 'resume-session':
             case 'mcp': return 'engine-drive';
             default: return undefined;
         }

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);

package/dist/clients/attach/slash/dispatch.js

@@ -38,7 +38,8 @@ export const CANVAS_SLASH_COMMANDS = [
     { name: 'graph', description: 'Toggle the canvas GRAPH view (your local subscription tree)' },
     { name: 'inbox', description: 'Toggle the human inbox — pending asks and reviews for you' },
     { name: 'promote', description: 'Promote this node to an orchestrator — /promote, or /promote <kind> to specialize' },
-    { name: 'resume-node', description: 'Open the canvas navigator and focus the chosen node; parked residents wake only on submitted input' },
+    { name: 'resume', description: 'Open the canvas navigator and swap THIS pane onto the chosen node; parked residents wake only on submitted input' },
+    { name: 'resume-session', description: 'Switch this node onto one of its saved pi sessions — picker, or /resume-session <session-path>' },
     { name: 'context', description: 'Browse this node + its subscriptions’ context dirs in a read-only nvim popup' },
     { name: 'plugins', description: 'Open the interactive plugin browser for this machine' },
     { name: 'node-metadata', description: 'Inspect this node — identity, lifecycle, runtime, graph, artifacts, paths, and agent surfaces' },
@@ -51,7 +52,11 @@ export const CANVAS_SLASH_COMMANDS = [
     { name: 'copy-transcript', description: 'Copy every copyable transcript block' },
     { name: 'fold-tools', description: 'View setting — fold every FINISHED tool call to its single call line (Alt+C → z → f)' },
 ];
-const CANVAS_NAMES = new Set(CANVAS_SLASH_COMMANDS.map((c) => c.name));
+/** Prior names still dispatched natively but kept OUT of autocomplete, so
+ *  muscle memory keeps working while the palette shows one canonical entry.
+ *  Normalized to the canonical name before any gate or dispatch runs. */
+const CANVAS_ALIASES = new Map([['resume-node', 'resume']]);
+const CANVAS_NAMES = new Set([...CANVAS_SLASH_COMMANDS.map((c) => c.name), ...CANVAS_ALIASES.keys()]);
 /** tmux named colours accepted by `/color` (plus `colourN`/`#rrggbb`, validated
  *  by pattern). Mirrors tmux's colour-name table so a typo is rejected with the
  *  options rather than silently ignored by tmux. */
@@ -119,7 +124,8 @@ export function dispatchSlashCommand(text, ctx) {
     const command = parseSlashCommand(text);
     if (command === undefined)
         return false;
-    const { name, arg } = command;
+    const { arg } = command;
+    const name = CANVAS_ALIASES.get(command.name) ?? command.name;
     if (SCOPED_OUT.has(name)) {
         ctx.notify(`/${name} is not supported in attach (Phase 4)`);
         return true;
@@ -189,11 +195,6 @@ export function dispatchSlashCommand(text, ctx) {
                 return openOrHint(ctx.openModelPicker, ctx, 'model', '/model <provider/id>');
             ctx.send({ type: 'set_model', model: arg });
             return true;
-        case 'resume':
-            if (!arg)
-                return openOrHint(ctx.openSessionPicker, ctx, 'session', '/resume <session-path>');
-            ctx.send({ type: 'switch_session', path: arg });
-            return true;
         case 'fork':
             if (!arg)
                 return openOrHint(ctx.openForkPicker, ctx, 'fork point', '/fork <entryId>');
@@ -277,12 +278,24 @@ export function dispatchSlashCommand(text, ctx) {
  *  omitted rather than offered-then-blocked, so autocomplete never advertises a
  *  command `dispatchCanvasCommand` would refuse to run. */
 function withCanvasCommands(commands, capabilities) {
-    const seen = new Set(commands.map((c) => c.name));
-    const offerable = CANVAS_SLASH_COMMANDS.filter((command) => {
-        const operation = viewerOperationForSlash(command.name, false, true);
+    const permitted = (name) => {
+        const operation = viewerOperationForSlash(name, false, true);
         return operation === undefined || capabilities.permits(operation);
+    };
+    const offerable = CANVAS_SLASH_COMMANDS.filter((command) => permitted(command.name));
+    // A canvas command that REPURPOSES a builtin name (`/resume`) keeps that name's
+    // slot in the incoming list but carries the canvas description and the canvas
+    // capability gate — so autocomplete never advertises pi's meaning for a command
+    // this viewer redefines, and never offers one it would refuse to run.
+    const canvasByName = new Map(CANVAS_SLASH_COMMANDS.map((command) => [command.name, command]));
+    const merged = commands.flatMap((command) => {
+        const canvas = canvasByName.get(command.name);
+        if (canvas === undefined)
+            return [command];
+        return permitted(command.name) ? [canvas] : [];
     });
-    return [...commands, ...offerable.filter((command) => !seen.has(command.name))];
+    const seen = new Set(commands.map((c) => c.name));
+    return [...merged, ...offerable.filter((command) => !seen.has(command.name))];
 }
 /** Build slash-command autocomplete entries from the merged command list (the
  *  broker's `get_commands` result, which T7 may inject) — defaults to the
@@ -326,10 +339,19 @@ function dispatchCanvasCommand(name, arg, ctx) {
         case 'promote':
             promoteNode(arg, ctx);
             return true;
-        case 'resume-node':
-            // Open the full-screen canvas navigator as a popup; on Enter it focuses the
-            // chosen node back into THIS pane via `crtr surface node focus`.
+        case 'resume':
+            // Open the full-screen canvas navigator as a popup; on Enter it swaps THIS
+            // pane onto the chosen node via `crtr surface node focus --in-place`.
+            if (arg)
+                return usage(ctx, '/resume — no argument; use /resume-session <path> to switch pi sessions');
             return resumeNode(ctx);
+        case 'resume-session':
+            // The pi session picker: rebind THIS node onto a different saved session
+            // file (recovering a conversation the node cycled away from).
+            if (!arg)
+                return openOrHint(ctx.openSessionPicker, ctx, 'session', '/resume-session <session-path>');
+            ctx.send({ type: 'switch_session', path: arg });
+            return true;
         case 'mcp':
             // MCP server status panel — viewer-local reads of the adapter's on-disk
             // config sources/cache (see overlays/mcp.ts); the actions (connect /
@@ -556,13 +578,14 @@ function colorNode(arg, ctx) {
     ctx.notify(clear ? 'Node color cleared' : `Node colored ${value}${inTmux ? '' : ' (chip only — no tmux pane)'}`);
     return true;
 }
-/** `/resume-node`. Opens `crtr canvas browse` as a tmux popup, initially scoped
- *  to this node's profile (with all dirs visible); on Enter it focuses the chosen
- *  node back into this pane via `crtr surface node focus --pane`. */
+/** `/resume`. Opens `crtr canvas browse` as a tmux popup, initially scoped to
+ *  this node's profile (with all dirs visible); on Enter the navigator respawns
+ *  THIS pane onto the chosen node (`crtr surface node focus --pane --in-place`),
+ *  so resuming replaces the viewer you invoked it from. */
 function resumeNode(ctx) {
     const origPane = process.env['TMUX_PANE'];
     if (process.env['TMUX'] === undefined || origPane === undefined || origPane === '') {
-        ctx.notify('/resume-node needs tmux');
+        ctx.notify('/resume needs tmux');
         return true;
     }
     const cwd = shellQuote(ctx.cwd ?? process.cwd());