@north-light/crouter 0.3.164 → 0.3.165

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,20 @@ 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);
+            if (message.role === 'user' && this.chatChildCount() > 0)
+                this.append(new Spacer(1));
+            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 +895,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 +1035,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 +1046,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.js

@@ -1,18 +1,13 @@
-// 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) → label + full wrapped body. 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 { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
-/** Default label/hint for the `crtr-context` bearings block. Mirrors the
- *  extension's customType stamp. */
+/** 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

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 {};

package/dist/clients/attach/session/profile-files.js

@@ -0,0 +1,157 @@
+// session/profile-files.ts — fuzzy file search across a node's local profile.
+//
+// The popup searches the current workspace plus every project named by the
+// node's profile manifest. Ancestor `.crouter/memory/` stores are added with
+// ignore rules disabled, so project memory remains findable even when a parent
+// ignore file hides `.crouter/`. fzf owns selection and nvim owns viewing; the
+// attach viewer only resolves the relevant roots and wires the two popups.
+import { constants, accessSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, dirname, join, resolve, sep } from 'node:path';
+import { execFile, spawnSync } from 'node:child_process';
+import { loadProfileManifest } from '../../../core/profiles/manifest.js';
+import { shellQuote } from '../../../core/runtime/placement-tmux.js';
+import { surfaceTmuxStyleArgs } from '../../../core/runtime/surface-bg.js';
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function executableCandidates(name, preferred) {
+    const candidates = [
+        ...(preferred === undefined || preferred === null ? [] : [preferred]),
+        ...(process.env['PATH'] ?? '').split(delimiter).filter(Boolean).map((dir) => join(dir, name)),
+    ];
+    return [...new Set(candidates)];
+}
+/** Return the first PATH candidate that can actually execute. Checking only
+ *  X_OK is insufficient when a managed tool cache contains a binary for a
+ *  different host platform. This runs only when the user opens the search. */
+function workingExecutable(name, preferred) {
+    for (const candidate of executableCandidates(name, preferred)) {
+        try {
+            accessSync(candidate, constants.X_OK);
+        }
+        catch {
+            continue;
+        }
+        const probe = spawnSync(candidate, ['--version'], { stdio: 'ignore' });
+        if (probe.status === 0)
+            return candidate;
+    }
+    return null;
+}
+function profileProjectDirs(profileId) {
+    if (profileId === null || profileId === '')
+        return [];
+    try {
+        return loadProfileManifest(profileId).manifest.projects;
+    }
+    catch {
+        return [];
+    }
+}
+function dedupeExistingDirs(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const path of paths) {
+        const absolute = resolve(path);
+        if (seen.has(absolute) || !isDirectory(absolute))
+            continue;
+        seen.add(absolute);
+        out.push(absolute);
+    }
+    return out;
+}
+/** Keep only the outermost search roots. An outer profile project already
+ *  covers a cwd or another project nested beneath it, and avoiding the second
+ *  fd walk keeps every candidate unique without a separate dedupe process. */
+function outermostDirs(paths) {
+    return paths.filter((path) => !paths.some((other) => other !== path && path.startsWith(other + sep)));
+}
+/** Every existing `<ancestor>/.crouter/memory/` from each pointer through the
+ *  filesystem root. A dedicated no-ignore fd pass guarantees these files are
+ *  present even when the wider project scan respects an ignore rule. */
+function ancestorMemoryDirs(pointers) {
+    const found = [];
+    for (const pointer of pointers) {
+        let cursor = resolve(pointer);
+        for (;;) {
+            const memory = join(cursor, '.crouter', 'memory');
+            if (isDirectory(memory))
+                found.push(memory);
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                break;
+            cursor = parent;
+        }
+    }
+    return dedupeExistingDirs(found);
+}
+function selectionPath(path) {
+    try {
+        const bytes = readFileSync(path);
+        if (bytes.length === 0)
+            return null;
+        const end = bytes[bytes.length - 1] === 0 ? bytes.length - 1 : bytes.length;
+        return bytes.subarray(0, end).toString('utf8') || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function launchProfileFileSearch(opts) {
+    const fd = workingExecutable('fd', opts.fdPath);
+    if (fd === null) {
+        opts.onNotice('fd is required for profile file search');
+        return;
+    }
+    const fzf = workingExecutable('fzf');
+    if (fzf === null) {
+        opts.onNotice('fzf is required for profile file search');
+        return;
+    }
+    const nvim = workingExecutable('nvim');
+    if (nvim === null) {
+        opts.onNotice('Neovim is required for profile file search');
+        return;
+    }
+    const pointers = dedupeExistingDirs([opts.cwd, ...profileProjectDirs(opts.profileId)]);
+    if (pointers.length === 0) {
+        opts.onNotice('No profile file-search directories exist');
+        return;
+    }
+    const roots = outermostDirs(pointers);
+    const memoryDirs = ancestorMemoryDirs(pointers);
+    const tempDir = mkdtempSync(join(tmpdir(), 'crtr-profile-files-'));
+    const selected = join(tempDir, 'selection');
+    const scans = [
+        ...roots.map((root) => `${shellQuote(fd)} --type f --hidden --exclude .git --exclude ${shellQuote('**/.crouter/memory/**')} --print0 . ${shellQuote(root)}`),
+        ...memoryDirs.map((memory) => `${shellQuote(fd)} --type f --hidden --exclude .git --no-ignore --print0 . ${shellQuote(memory)}`),
+    ];
+    const command = `{ ${scans.map((scan) => `${scan} &`).join(' ')} wait; } | ${shellQuote(fzf)} --read0 --print0 --preview ${shellQuote('head -100 -- {}')} > ${shellQuote(selected)}`;
+    try {
+        execFile('tmux', ['display-popup', '-E', '-T', ' profile files ', '-w', '80%', '-h', '60%', ...surfaceTmuxStyleArgs(), command], () => {
+            const file = selectionPath(selected);
+            if (file === null || !existsSync(file)) {
+                rmSync(tempDir, { recursive: true, force: true });
+                return;
+            }
+            const open = `exec ${shellQuote(nvim)} -- ${shellQuote(file)}`;
+            try {
+                execFile('tmux', ['display-popup', '-E', '-T', ' profile file ', '-w', '90%', '-h', '90%', ...surfaceTmuxStyleArgs(), open], () => rmSync(tempDir, { recursive: true, force: true }));
+            }
+            catch (err) {
+                rmSync(tempDir, { recursive: true, force: true });
+                opts.onNotice(`Could not open profile file: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
+    }
+    catch (err) {
+        rmSync(tempDir, { recursive: true, force: true });
+        opts.onNotice(`Could not open profile file search: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}