@north-light/crouter 0.3.164 → 0.3.166

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

@@ -26,21 +26,17 @@ import { attachMarkdownTheme } from '../config.js';
 import { ContextMessageComponent } from './context-message.js';
 import { CRTR_OUTPUT_CUSTOM_TYPE, CrtrOutputMessageComponent, createCrtrBashToolDefinition, } from './crtr-output.js';
 import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../../core/runtime/session-cycles.js';
-import { SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../../../core/runtime/situational-context.js';
+import { generatedContextPresentation } from '../../../shared/generated-context.js';
 import { transformMessageDiagrams } from './diagram.js';
 import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-headings.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
 import { FoldedToolCallController, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
 import { ringCompletionBell } from '../chrome/completion-bell.js';
 import { extractFilePaths } from '../visible-paths.js';
-import { FrozenHistoryComponent, keepWhenCondensed, liveRegionStart } from './frozen-history.js';
+import { keepWhenCondensed, liveRegionStart } from './condensed-history.js';
 import { ViewerAssistantMessageComponent } from './assistant-message.js';
 import { readConfig, updateRawConfigAtomically } from '../../../core/config.js';
 import { DEFAULT_CONDENSED_HISTORY, DEFAULT_LIVE_CYCLES } from '../../../types.js';
-/** customType stamped on the injected `<crtr-context>` bearings block (mirrors
- *  CONTEXT_INTRO_CUSTOM_TYPE in canvas-context-intro.ts — kept as a local literal
- *  so the viewer never imports the in-process extension). */
-const CONTEXT_INTRO_CUSTOM_TYPE = 'crtr-context';
 /** Theme-derived chrome colors (spinner / dim / error) are supplied by the
  *  attach command via `ChatViewOptions.palette` (built from the live theme in
  *  config.ts). pi does not re-export the raw `theme` instance, so when no
@@ -257,8 +253,8 @@ export class ChatView {
     /** Activity/status area below history. Holds working/compaction/retry loaders. */
     statusContainer = new Container();
     /** Where `append()` puts a component. Normally `historyContainer`; retargeted to
-     *  a scratch container while a frozen block is being built, so the very same
-     *  message-rendering path serves both. */
+     *  a nested container while condensed history is being built, so the same
+     *  message-rendering path serves both regions. */
     appendTarget = this.historyContainer;
     /** Trailing cycles kept at full fidelity (config `live_cycles`). */
     liveCycles;
@@ -372,18 +368,18 @@ export class ChatView {
         const renderedPendingTools = new Map();
         const messages = snapshot.messages;
         const lastIndex = messages.length - 1;
-        // Cycles older than the trailing `live_cycles` are condensed to prose and
-        // frozen into one flat line block BEFORE the live region is built, so the loop
-        // below only ever constructs components for the cycles you are actually
-        // working in. `liveStart` is 0 — condense nothing — until the node has yielded
-        // past the configured window, so a fresh node renders exactly as it always did.
+        // Cycles older than the trailing `live_cycles` are condensed into one nested
+        // container before the live region is built. It retains only configured prose
+        // and cycle seams, avoiding old tool components while still reflowing on pane
+        // resize. `liveStart` is 0 until the node has yielded past the configured
+        // window, so a fresh node renders at full fidelity.
         const liveStart = liveRegionStart(messages, this.liveCycles);
         if (liveStart > 0) {
-            const frozen = await this.buildFrozenBlock(messages.slice(0, liveStart), generation);
+            const condensed = await this.buildCondensedBlock(messages.slice(0, liveStart), generation);
             if (generation !== this.snapshotGeneration)
                 return;
-            if (frozen)
-                this.append(frozen);
+            if (condensed)
+                this.append(condensed);
         }
         for (let i = liveStart; i < messages.length; i++) {
             // Yield to the event loop every SNAPSHOT_YIELD_EVERY messages so queued
@@ -483,20 +479,20 @@ export class ChatView {
         this.replayDeferredFrames();
     }
     /**
-     * Render the condensed form of the already-finished cycles ONCE and hand back a
-     * frozen line block (or undefined when nothing survived condensation).
+     * Build the condensed form of the already-finished cycles as a nested component
+     * container, or return undefined when nothing survives condensation.
      *
-     * Reuses `addMessageToChat` verbatim by retargeting `append()` at a scratch
-     * container, so condensed history is styled exactly like live history — the same
-     * renderer, with the tool traffic filtered out and the result flattened to text.
-     * Yields on the same cadence as the live build so a very long history still lets
-     * queued keystrokes through, and abandons itself when a newer welcome supersedes
-     * this generation.
+     * Reuses `addMessageToChat` by retargeting `append()` at the nested container, so
+     * condensed history uses the same renderer as live history with tool traffic
+     * filtered out. The outer history cache keeps stable-width frames cheap, while
+     * preserving the components lets pane-width changes reflow their content. The
+     * build yields on the live cadence and abandons itself when a newer welcome
+     * supersedes this generation.
      */
-    async buildFrozenBlock(messages, generation) {
-        const scratch = new Container();
+    async buildCondensedBlock(messages, generation) {
+        const condensed = new Container();
         const previousTarget = this.appendTarget;
-        this.appendTarget = scratch;
+        this.appendTarget = condensed;
         try {
             let built = 0;
             for (const message of messages) {
@@ -518,10 +514,7 @@ export class ChatView {
         finally {
             this.appendTarget = previousTarget;
         }
-        const width = this.renderWidth();
-        const lines = scratch.render(width);
-        scratch.clear();
-        return lines.length > 0 ? new FrozenHistoryComponent(lines, width) : undefined;
+        return condensed.children.length > 0 ? condensed : undefined;
     }
     /** Defer a live broker frame when a snapshot build is in flight. Returns true
      *  (and enqueues the replay closure) while building so the caller returns
@@ -564,8 +557,8 @@ export class ChatView {
     // -------------------------------------------------------------------------
     /** Ctrl+O / app.tools.expand — flip global tool-output expansion and apply it to
      *  every rendered component that supports it. Returns the new expanded state so
-     *  the caller can surface a notice. Condensed cycles hold no tool components and
-     *  are frozen as text, so they are unaffected by design. */
+     *  the caller can surface a notice. Condensed cycles hold no tool components, so
+     *  they are unaffected by design. */
     toggleToolsExpanded() {
         this.toolOutputExpanded = !this.toolOutputExpanded;
         this.applyToolDisplay();
@@ -870,6 +863,18 @@ export class ChatView {
     // Rebuild path (ports addMessageToChat, interactive-mode.js:2483).
     // -------------------------------------------------------------------------
     addMessageToChat(message) {
+        // Crouter-generated context retains its runtime role (user vs custom) so
+        // delivery to the model is unchanged, but every attached view presents it
+        // through one compact disclosure contract. The shared classifier uses the
+        // producers' exact custom types/sentinels, so ordinary user prompts cannot
+        // accidentally acquire this treatment and saved transcripts gain it too.
+        const generated = generatedContextPresentation(message);
+        if (generated !== null &&
+            (message.role !== 'custom' || message.display === true)) {
+            this.pushTranscriptText(generated.body);
+            this.append(new ContextMessageComponent(generated.body, this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), generated.label, ` ${generated.summary} — ctrl+o to expand`));
+            return;
+        }
         switch (message.role) {
             case 'bashExecution': {
                 this.pushTranscriptText(message.output ?? '');
@@ -888,25 +893,6 @@ export class ChatView {
             case 'custom': {
                 if (message.display) {
                     this.pushTranscriptText(this.userMessageText(message));
-                    // The <crtr-context> bearings block folds to a one-liner under Ctrl+O
-                    // (the broker runs its renderer extension, so reimplement it natively).
-                    if (message.customType === CONTEXT_INTRO_CUSTOM_TYPE) {
-                        this.append(new ContextMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.dimStyle, 
-                        // Bold + active accent, so the [crtr context] label reads as a
-                        // distinct color against the dim rest of the line.
-                        (s) => this.spinnerStyle(this.labelStyle(s))));
-                        break;
-                    }
-                    // The hidden ambient `<situational-context>` update (canvas-inbox-watcher's
-                    // ~non-birth wake path). Rendered collapsed exactly like `crtr-context`
-                    // (same component, distinct label) so an existing-node ambient update is
-                    // never more prominent in the transcript than the bearings block it rides
-                    // alongside on fresh birth — the LLM sees the full content either way; only
-                    // the viewer's display treatment differs.
-                    if (message.customType === SITUATIONAL_CONTEXT_CUSTOM_TYPE) {
-                        this.append(new ContextMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)), 'situational context', ' ambient context update — ctrl+o to expand'));
-                        break;
-                    }
                     if (message.customType === CRTR_OUTPUT_CUSTOM_TYPE) {
                         this.append(new CrtrOutputMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.crtrOutputTheme()));
                         break;
@@ -1047,7 +1033,7 @@ export class ChatView {
         return component;
     }
     /** Append conversation content above the independent live status area — or into
-     *  the scratch container while a frozen block is under construction. */
+     *  the nested container while condensed history is under construction. */
     append(child) {
         this.appendTarget.addChild(child);
     }
@@ -1058,7 +1044,7 @@ export class ChatView {
         return Math.max(40, process.stdout.columns ?? 80);
     }
     /** Number of rendered conversation components in the container currently being
-     *  appended to (history, or the frozen block's scratch container). */
+     *  appended to (live history or the nested condensed region). */
     chatChildCount() {
         return this.appendTarget.children.length;
     }

package/dist/clients/attach/render/{frozen-history.d.ts → condensed-history.d.ts}

@@ -1,4 +1,3 @@
-import { type Component } from '@earendil-works/pi-tui';
 import type { CondensedHistoryMode } from '../../../types.js';
 /** A message from the broker snapshot, structurally. */
 type Message = {
@@ -6,7 +5,7 @@ type Message = {
     customType?: string;
 };
 export declare function isCycleDivider(message: Message): boolean;
-/** Does this message survive condensation into the frozen block? */
+/** Does this message survive into the condensed region? */
 export declare function keepWhenCondensed(message: Message, mode: CondensedHistoryMode): boolean;
 /**
  * Index into `messages` at which the LIVE (fully rendered) region begins.
@@ -19,20 +18,4 @@ export declare function keepWhenCondensed(message: Message, mode: CondensedHisto
  * single-yield node renders exactly as it always did.
  */
 export declare function liveRegionStart(messages: readonly Message[], liveCycles: number): number;
-/**
- * A settled block of pre-rendered transcript lines. Renders in O(1) at the width
- * it was frozen at, and clips (never reflows) when the pane is narrower. Ctrl+O /
- * Ctrl+T do not reach it: it holds no components to expand, only text.
- */
-export declare class FrozenHistoryComponent implements Component {
-    private readonly lines;
-    private readonly frozenWidth;
-    /** Last clip result, so a stable narrow pane clips once rather than per frame. */
-    private clipped;
-    constructor(lines: readonly string[], frozenWidth: number);
-    get lineCount(): number;
-    /** Nothing to recompute — the block is text, already laid out. */
-    invalidate(): void;
-    render(width: number): string[];
-}
 export {};

package/dist/clients/attach/render/condensed-history.js

@@ -0,0 +1,60 @@
+// condensed-history.ts — lightweight rendering of a node's OLD cycles.
+//
+// A node that has yielded several times carries every prior cycle in its welcome
+// snapshot (cycleAwareMessages, session-cycles.ts). Cycles older than the trailing
+// `live_cycles` (config, default 2) are condensed to cycle dividers plus whichever
+// messages `condensed_history` (config, default `none`) admits. Tool calls and
+// results are excluded; across six measured sessions they accounted for 62.9% of
+// rendered lines and 69% of transcript build time.
+//
+// Retained messages stay as components inside one nested container. Settled lines
+// are cached at a stable pane width, while a width change rerenders the nested
+// content so old prose wraps with the rest of the transcript.
+//
+// The full detail of a condensed cycle remains in the node's session file, and
+// `/tree` navigates the real branches.
+import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../../core/runtime/session-cycles.js';
+/** Roles admitted by each `condensed_history` mode. `toolResult`,
+ *  `bashExecution`, and every non-divider `custom` message (crtr output,
+ *  injected context blocks) are never kept, nor are the tool-call components an
+ *  assistant message would otherwise spawn — only its prose. The cycle dividers
+ *  survive every mode, so `none` leaves the seams and nothing else. */
+const ROLES_BY_MODE = {
+    none: new Set(),
+    user: new Set(['user']),
+    agent: new Set(['assistant', 'compactionSummary', 'branchSummary']),
+    both: new Set(['user', 'assistant', 'compactionSummary', 'branchSummary']),
+};
+export function isCycleDivider(message) {
+    return message.role === 'custom' && message.customType === CRTR_CYCLE_DIVIDER_CUSTOM_TYPE;
+}
+/** Does this message survive into the condensed region? */
+export function keepWhenCondensed(message, mode) {
+    if (isCycleDivider(message))
+        return true;
+    return (ROLES_BY_MODE[mode] ?? ROLES_BY_MODE.none).has(message.role ?? '');
+}
+/**
+ * Index into `messages` at which the LIVE (fully rendered) region begins.
+ *
+ * The snapshot is `[cycle 0][divider][cycle 1][divider]…[current cycle]`, so a
+ * transcript with D dividers holds D+1 cycles. Keeping the trailing
+ * `liveCycles` of them means everything up to and including divider
+ * `D - liveCycles` is condensed. Returns 0 — condense nothing — when the node
+ * has not yielded often enough to have older cycles, so a fresh or
+ * single-yield node renders exactly as it always did.
+ */
+export function liveRegionStart(messages, liveCycles) {
+    const keep = Math.max(1, Math.floor(liveCycles));
+    const dividers = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (isCycleDivider(messages[i]))
+            dividers.push(i);
+    }
+    const cycles = dividers.length + 1;
+    if (cycles <= keep)
+        return 0;
+    // The last divider that closes a condensed cycle; the live region opens just
+    // after it (the divider itself stays in the condensed region as the seam).
+    return dividers[cycles - keep - 1] + 1;
+}

package/dist/clients/attach/render/context-message.d.ts

@@ -1,11 +1,11 @@
 import { type Component } from '@earendil-works/pi-tui';
 export declare class ContextMessageComponent implements Component {
-    private readonly body;
     private readonly dim;
     private readonly label;
     private readonly labelText;
     private readonly collapsedHint;
     private expanded;
+    private readonly expandedBody;
     constructor(body: string, expanded: boolean, dim: (s: string) => string, label: (s: string) => string, labelText?: string, collapsedHint?: string);
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded: boolean): void;

package/dist/clients/attach/render/context-message.js

@@ -1,54 +1,33 @@
-// render/context-message.ts — the viewer's foldable renderer for hidden-context custom
-// messages: the `<crtr-context>` bearings block (customType `crtr-context`) and
-// the ambient `<situational-context>` update (customType
-// `crtr-situational-context`). Both are broker-injected (canvas-context-intro,
-// canvas-inbox-watcher), so the VIEWER has no message renderer for either and
-// would otherwise show the full block always. This reimplements the bearings
-// renderer natively (src/pi-extensions/canvas-context-intro.ts:
-// `renderContextMessage`) and reuses the same collapsed/expand shape for
-// situational context so both render consistently: collapsed → one dim line;
-// expanded (Ctrl+O) → label + full wrapped body. It implements `setExpanded`,
-// so the Ctrl+O tool-display cycle (ChatView.cycleToolDisplay →
-// isExpandable) folds it alongside tool output.
+// render/context-message.ts — the terminal viewer's foldable renderer for
+// crouter-generated context. Session bearings, situational updates, fresh-revive
+// kickoffs, context-size nudges, and node inbox digests retain their full model-visible body and
+// runtime role, while this display-only component presents them consistently:
+// collapsed → one dim line; expanded (Ctrl+O) → the ordinary user-message
+// surface, regardless of the message's runtime role. It implements
+// `setExpanded`, so the global tool-display cycle folds these blocks alongside
+// tool output. Classification lives in shared/generated-context.ts; this
+// component only renders the presentation it is handed.
+import { UserMessageComponent } from '@earendil-works/pi-coding-agent';
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
-/** Default label/hint for the `crtr-context` bearings block. Mirrors the
- *  extension's customType stamp. */
+import { attachMarkdownTheme } from '../config.js';
+import { styleAttachMarkdownHeadings } from './markdown-headings.js';
+/** Default label/hint for the `crtr-context` bearings block. */
 const LABEL = 'crtr context';
 const COLLAPSED_HINT = ' orienting bearings — ctrl+o to expand';
-/** Char-based wrap that never emits an over-width line (pi-tui hard-crashes on
- *  one). Visible-width aware so wide glyphs in the bearings tree count right. */
-function wrapLine(line, width) {
-    if (line === '')
-        return [''];
-    const out = [];
-    let cur = '';
-    for (const ch of line) {
-        if (cur !== '' && visibleWidth(cur + ch) > width) {
-            out.push(cur);
-            cur = ch;
-        }
-        else {
-            cur += ch;
-        }
-    }
-    if (cur !== '')
-        out.push(cur);
-    return out;
-}
 export class ContextMessageComponent {
-    body;
     dim;
     label;
     labelText;
     collapsedHint;
     expanded;
+    expandedBody;
     constructor(body, expanded, dim, label, labelText = LABEL, collapsedHint = COLLAPSED_HINT) {
-        this.body = body;
         this.dim = dim;
         this.label = label;
         this.labelText = labelText;
         this.collapsedHint = collapsedHint;
         this.expanded = expanded;
+        this.expandedBody = new UserMessageComponent(styleAttachMarkdownHeadings(body), attachMarkdownTheme());
     }
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded) {
@@ -68,11 +47,9 @@ export class ContextMessageComponent {
                 return [this.label(truncateToWidth(labelTag, w, '…'))];
             return [this.label(labelTag) + this.dim(truncateToWidth(rest, w - labelW, '…'))];
         }
-        const lines = [this.label(truncateToWidth(`[${this.labelText}]`, w, '…')), ''];
-        for (const raw of this.body.split('\n')) {
-            for (const seg of wrapLine(raw, w))
-                lines.push(seg);
-        }
+        const lines = this.expandedBody.render(w);
+        if (lines.at(-1) !== '')
+            lines.push('');
         return lines;
     }
     invalidate() {

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

@@ -1,9 +1,11 @@
-import { type BindingId, type BindingResolution } from '../../../core/keybindings/index.js';
-export type AttachBindingId = Extract<BindingId, `crtr.attach.${string}` | 'crtr.mode.cycle'>;
+import { type AttachBindingId, type BindingId, type BindingResolution } from '../../../core/keybindings/index.js';
+export type { AttachBindingId } from '../../../core/keybindings/index.js';
 export type AttachBindings = BindingResolution<BindingId>;
+export type AttachActions = Record<AttachBindingId, () => void>;
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
 export declare function matchesAttachBinding(bindings: AttachBindings, id: AttachBindingId, data: string): boolean;
-export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: Record<AttachBindingId, () => void>): boolean;
+export declare function dispatchAttachAction(id: AttachBindingId, actions: AttachActions): void;
+export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: AttachActions): boolean;
 export declare function detachHint(bindings: AttachBindings): string | undefined;
 /** Re-resolve the user's binding catalog and republish it to every consumer:
  *  the graph overlay's own snapshot and (in tmux) the crouter-owned tmux

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

@@ -5,24 +5,18 @@
 // tmux installer binds from (`core/keybindings`), never from ad-hoc key
 // literals, so a user's rebind is honored by the viewer and tmux alike.
 import { matchesKey } from '@earendil-works/pi-tui';
-import { formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
+import { ATTACH_CONTROL_BINDINGS, formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
 export function matchesAttachBinding(bindings, id, data) {
     return matchesPiTuiInput(bindings, id, data, (input, gesture) => matchesKey(input, gesture));
 }
+export function dispatchAttachAction(id, actions) {
+    actions[id]();
+}
 export function dispatchAttachBinding(bindings, data, actions) {
-    for (const id of [
-        'crtr.attach.detach',
-        'crtr.attach.clear-or-detach',
-        'crtr.mode.cycle',
-        'crtr.attach.graph.toggle',
-        'crtr.attach.model-ladder.next',
-        'crtr.attach.model-ladder.previous',
-        'crtr.attach.command.inspect',
-        'crtr.attach.file-review',
-    ]) {
-        if (matchesAttachBinding(bindings, id, data)) {
-            actions[id]();
+    for (const { actionId } of ATTACH_CONTROL_BINDINGS) {
+        if (matchesAttachBinding(bindings, actionId, data)) {
+            dispatchAttachAction(actionId, actions);
             return true;
         }
     }

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

@@ -17,6 +17,8 @@ export interface KeyHooks {
     inspectLoadedCommand: () => void;
     /** The file-review chord — open the transcript-file picker + review surface. */
     openFileReview: () => void;
+    /** Search the current node's local profile project files. */
+    openProfileFiles: () => void;
 }
 /** Install the listener; returns the remover, which teardown MUST call. */
 export declare function installGlobalKeys(ctx: Pick<AttachSession, 'tui' | 'editor'>, hooks: KeyHooks): () => void;

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

@@ -3,10 +3,11 @@
 // A TUI input listener fires BEFORE the focused component and before any dialog
 // overlay, so the configured attach actions work regardless of what has focus.
 // That privilege is also the hazard: anything consumed here never reaches the
-// editor. Only three things may claim a chunk — terminal focus reports, the
-// roster while it holds the cursor, and a configured crtr binding — and each
-// returns to the editor untouched when it does not apply.
-import { dispatchAttachBinding } from './bindings.js';
+// editor. Only terminal focus reports, a private crouter control input, the
+// roster while it holds the cursor, and a configured crtr binding may claim a
+// chunk; each returns ordinary editor input untouched when it does not apply.
+import { extractAttachControlInput } from '../../../core/keybindings/index.js';
+import { dispatchAttachAction, dispatchAttachBinding } from './bindings.js';
 import { FOCUS_IN, FOCUS_OUT } from './focus-events.js';
 /** Press the clear-or-detach binding twice inside this window to detach. */
 const CLEAR_OR_DETACH_MS = 1000;
@@ -14,47 +15,45 @@ const CLEAR_OR_DETACH_MS = 1000;
 export function installGlobalKeys(ctx, hooks) {
     const { tui, editor } = ctx;
     let lastClearOrDetachAt = 0;
+    const actions = {
+        'crtr.attach.detach': hooks.detach,
+        'crtr.attach.clear-or-detach': () => {
+            const now = Date.now();
+            if (now - lastClearOrDetachAt < CLEAR_OR_DETACH_MS) {
+                lastClearOrDetachAt = 0;
+                hooks.detach();
+                return;
+            }
+            lastClearOrDetachAt = now;
+            editor.setText('');
+            hooks.setNotice(`Editor cleared — press ${hooks.detachHint()} again to detach`);
+            tui.requestRender();
+        },
+        'crtr.mode.cycle': hooks.cycleMode,
+        'crtr.attach.graph.toggle': hooks.toggleGraph,
+        // A plain broker frame, so this works locally and remotely alike; the broker gates observers on controller role.
+        'crtr.attach.model-ladder.next': () => hooks.cycleModelLadder('forward'),
+        'crtr.attach.model-ladder.previous': () => hooks.cycleModelLadder('backward'),
+        'crtr.attach.command.inspect': hooks.inspectLoadedCommand,
+        'crtr.attach.file-review': hooks.openFileReview,
+        'crtr.attach.profile-files': hooks.openProfileFiles,
+    };
     return tui.addInputListener((data) => {
-        // Terminal focus reporting (DECSET 1004, enabled after tui.start; tmux
-        // forwards it per-pane with `focus-events on`). Pane focus drives the
-        // editor's fake cursor — solid block focused, hollow outline blurred — so a
-        // wall of attach panes shows exactly which one keys go to. The events are
-        // stripped rather than blanket-consumed in case the chunk coalesced them
-        // with real keystrokes.
+        // Terminal focus reporting (DECSET 1004, enabled after tui.start; tmux forwards it per-pane with `focus-events on`). Pane focus drives the editor's fake cursor — solid block focused, hollow outline blurred — so a wall of attach panes shows exactly which one keys go to. The events are stripped rather than blanket-consumed in case the chunk coalesced them with real keystrokes.
         if (data.includes(FOCUS_IN) || data.includes(FOCUS_OUT)) {
             hooks.setPaneFocused(data.lastIndexOf(FOCUS_IN) > data.lastIndexOf(FOCUS_OUT));
             tui.requestRender();
             const rest = data.replaceAll(FOCUS_IN, '').replaceAll(FOCUS_OUT, '');
             return rest.length > 0 ? { data: rest } : { consume: true };
         }
-        // Inline subagent scroll+swap: once the editor hands off at its ↓ boundary,
-        // ↑/↓ move over the manager/report roster and Enter dives into a node. An
-        // inactive roster never intercepts editor input.
+        const control = extractAttachControlInput(data);
+        if (control !== undefined) {
+            dispatchAttachAction(control.actionId, actions);
+            return control.remaining.length > 0 ? { data: control.remaining } : { consume: true };
+        }
+        // Inline subagent scroll+swap: once the editor hands off at its ↓ boundary, ↑/↓ move over the manager/report roster and Enter dives into a node. An inactive roster never intercepts editor input.
         if (hooks.rosterHandleKey(data))
             return { consume: true };
-        const dispatched = dispatchAttachBinding(hooks.bindings(), data, {
-            'crtr.attach.detach': hooks.detach,
-            'crtr.attach.clear-or-detach': () => {
-                const now = Date.now();
-                if (now - lastClearOrDetachAt < CLEAR_OR_DETACH_MS) {
-                    lastClearOrDetachAt = 0;
-                    hooks.detach();
-                    return;
-                }
-                lastClearOrDetachAt = now;
-                editor.setText('');
-                hooks.setNotice(`Editor cleared — press ${hooks.detachHint()} again to detach`);
-                tui.requestRender();
-            },
-            'crtr.mode.cycle': hooks.cycleMode,
-            'crtr.attach.graph.toggle': hooks.toggleGraph,
-            // A plain broker frame, so this works locally and remotely alike; the
-            // broker gates observers on controller role.
-            'crtr.attach.model-ladder.next': () => hooks.cycleModelLadder('forward'),
-            'crtr.attach.model-ladder.previous': () => hooks.cycleModelLadder('backward'),
-            'crtr.attach.command.inspect': hooks.inspectLoadedCommand,
-            'crtr.attach.file-review': hooks.openFileReview,
-        });
-        return dispatched ? { consume: true } : undefined;
+        return dispatchAttachBinding(hooks.bindings(), data, actions) ? { consume: true } : undefined;
     });
 }

package/dist/clients/attach/session/profile-files.d.ts

@@ -0,0 +1,8 @@
+interface ProfileFileSearchOptions {
+    cwd: string;
+    profileId: string | null;
+    fdPath: string | null;
+    onNotice: (message: string) => void;
+}
+export declare function launchProfileFileSearch(opts: ProfileFileSearchOptions): void;
+export {};