@north-light/crouter 0.3.176 → 0.3.178

package/dist/clients/attach/render/group-recap.js

@@ -6,6 +6,8 @@ import { pathToFileURL } from 'node:url';
 import { ICON } from '../../../core/inspector/model.js';
 import { TOOL_ICON } from '../../../core/preview-registry.js';
 const MEMORY_ICON = String.fromCodePoint(0xf02d);
+// trash — deletion has no tool of its own, so it borrows no TOOL_ICON entry.
+const DELETE_ICON = String.fromCodePoint(0xf1f8);
 function count(value, singular, plural) {
     return `${value} ${value === 1 ? singular : plural}`;
 }
@@ -74,6 +76,11 @@ export class GroupRecapComponent extends Container {
             if (changedFiles >= 1) {
                 stats.push(`${palette.warning(TOOL_ICON.edit)} ${palette.muted(count(changedFiles, 'file changed', 'files changed'))}`);
             }
+            // Deletions never enter activity.files (only edit/write calls do), so the
+            // model's count covers a disjoint set and cannot double-count a change.
+            if (summary.filesDeleted >= 1) {
+                stats.push(`${palette.diffRemoved(DELETE_ICON)} ${palette.muted(count(summary.filesDeleted, 'file deleted', 'files deleted'))}`);
+            }
             const memoriesRead = countMemories(activity.memories, 'read');
             if (memoriesRead >= 1) {
                 stats.push(`${palette.info(MEMORY_ICON)} ${palette.muted(count(memoriesRead, 'memory read', 'memory reads'))}`);

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

@@ -1,8 +1,8 @@
 // session/context.ts — the named home for an attach session's STABLE facts.
 //
-// `runAttach` used to hold every one of these as a closure local, which is why
-// pulling any block out of it meant inventing a bespoke parameter list for that
-// block alone. `AttachSession` gives the state one declaration; each
+// Held as closure locals inside `runAttach`, pulling any block out of it would
+// mean inventing a bespoke parameter list for that block alone.
+// `AttachSession` gives the state one declaration; each
 // collaborator then names the slice it needs as a `Pick<AttachSession, …>`
 // view, so the module's dependencies are a *projection* of one truth rather
 // than a hand-maintained bag that can drift from it.

package/dist/clients/attach/session/editor-inventory.js

@@ -62,8 +62,8 @@ export function createEditorInventory(ctx, capabilities, hooks) {
     let brokerCommands;
     let memoryRefs = [];
     // The broker's `engineLeadingCommandNames` from the latest `list_memory_refs`
-    // reply (design: inline memory references, review Major 6) — leading tokens
-    // the ENGINE independently consumes, kept separate from the viewer-local
+    // reply — leading tokens the ENGINE independently consumes, kept separate
+    // from the viewer-local
     // `locallyConsumedCommandNames()` set and fed to the editor's untrimmed
     // engine-suppression rule via `setEngineCommandNames`.
     let engineLeadingCommandNames = [];
@@ -82,9 +82,9 @@ export function createEditorInventory(ctx, capabilities, hooks) {
     // Atomically rebuild the editor's provider/highlight state from whatever
     // command + ref inventory is CURRENTLY known — the one seam `setCommands` and
     // `setMemoryRefs` both call, so a command-only or ref-only response can never
-    // rebuild the provider having silently dropped the other inventory (T3
-    // ownership note: this module combines command metadata, ref metadata,
-    // provider rebuild, and editor highlight sets in one place). Command-only
+    // rebuild the provider having silently dropped the other inventory. This
+    // module owns command metadata, ref metadata, provider rebuild, and editor
+    // highlight sets in one place. Command-only
     // autocomplete is unchanged: `RefAwareAutocompleteProvider` fully delegates
     // leading-slash and every non-ref context to the wrapped command provider, so
     // refs never enter command completion or the loaded-command preview (which
@@ -93,7 +93,7 @@ export function createEditorInventory(ctx, capabilities, hooks) {
         const commandProvider = buildAttachAutocompleteProvider(meta.cwd, hooks.fdPath, brokerCommands, capabilities);
         editor.setAutocompleteProvider(new RefAwareAutocompleteProvider(memoryRefs, commandProvider));
         editor.setResolvedRefNames(memoryRefs.map((ref) => ref.name));
-        // Two independent suppression inventories (review Major 6): the viewer-local
+        // Two independent suppression inventories: the viewer-local
         // set (everything `dispatchSlashCommand` handles entirely locally, trimmed
         // rule) and the broker's own `engineLeadingCommandNames` (untrimmed rule) —
         // never the merged display/completion list `slashCommandList` returns.

package/dist/clients/attach/session/file-links.js

@@ -5,9 +5,8 @@
 // and OSC-8 boundaries have all already been composed there.
 import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import stringWidth from 'string-width';
+import { walkRow } from '../ansi-cells.js';
 import { respawnPaneInBackground, shellQuote, viewerSplitEnv } from '../../../core/runtime/placement-tmux.js';
-const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 /** URI of the OSC-8 hyperlink occupying the given 1-indexed terminal cell. */
 export function osc8UriAt(frame, row, column) {
     if (!Number.isInteger(row) || !Number.isInteger(column) || row < 1 || column < 1)
@@ -24,56 +23,22 @@ export function osc8UriAt(frame, row, column) {
 }
 function scanOsc8Row(line, initialUri, hitColumn) {
     let activeUri = initialUri;
-    let cell = 1;
-    let index = 0;
-    while (index < line.length) {
-        if (line[index] === '\x1b') {
-            const escape = readEscape(line, index);
-            if (escape === undefined)
-                break;
-            const osc8 = parseOsc8(escape.text);
+    let uri;
+    walkRow(line, {
+        onEscape: (escape) => {
+            const osc8 = parseOsc8(escape);
             if (osc8 !== null)
                 activeUri = osc8 === '' ? undefined : osc8;
-            index = escape.end;
-            continue;
-        }
-        const nextEscape = line.indexOf('\x1b', index);
-        const text = line.slice(index, nextEscape === -1 ? undefined : nextEscape);
-        for (const segment of GRAPHEMES.segment(text)) {
-            const width = stringWidth(segment.segment);
-            if (hitColumn !== undefined && width > 0 && hitColumn >= cell && hitColumn < cell + width && activeUri !== undefined) {
-                return { activeUri, uri: activeUri };
-            }
-            cell += width;
-        }
-        index = nextEscape === -1 ? line.length : nextEscape;
-    }
-    return { activeUri, uri: undefined };
-}
-/** Read one terminal control sequence so non-printing ANSI never takes a cell. */
-function readEscape(line, start) {
-    const kind = line[start + 1];
-    if (kind === undefined)
-        return undefined;
-    // OSC, APC, DCS, and PM are string controls terminated by BEL or ST. pi-tui's
-    // cursor marker uses APC, so it must consume no display cells here.
-    if (kind === ']' || kind === '_' || kind === 'P' || kind === '^') {
-        const bel = line.indexOf('\x07', start + 2);
-        const st = line.indexOf('\x1b\\', start + 2);
-        const end = bel === -1 ? st : st === -1 ? bel : Math.min(bel, st);
-        if (end === -1)
-            return undefined;
-        return { text: line.slice(start, end + (end === bel ? 1 : 2)), end: end + (end === bel ? 1 : 2) };
-    }
-    if (kind === '[') {
-        let end = start + 2;
-        while (end < line.length && (line.charCodeAt(end) < 0x40 || line.charCodeAt(end) > 0x7e))
-            end++;
-        if (end >= line.length)
-            return undefined;
-        return { text: line.slice(start, end + 1), end: end + 1 };
-    }
-    return { text: line.slice(start, start + 2), end: start + 2 };
+        },
+        onGlyph: (glyph) => {
+            if (uri !== undefined || hitColumn === undefined || activeUri === undefined || glyph.width === 0)
+                return;
+            const cell = hitColumn - 1;
+            if (cell >= glyph.cell && cell < glyph.cell + glyph.width)
+                uri = activeUri;
+        },
+    });
+    return { activeUri, uri };
 }
 /** `null` means another escape sequence; an empty URI closes the active link. */
 function parseOsc8(sequence) {

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

@@ -25,9 +25,13 @@ export declare class ViewerFrame implements Component {
     private readonly parts;
     private viewportRows;
     private lastFrame;
+    private overlay;
     constructor(terminal: Terminal, parts: ViewerFrameParts);
     render(width: number): string[];
-    /** The physical rows returned by the most recent render. */
+    /** Paint attributes over the composed frame — mouse selection highlight. The
+     *  overlay may restyle rows but must return the same number of them. */
+    setOverlay(overlay: (frame: readonly string[]) => string[]): void;
+    /** The physical rows returned by the most recent render, before any overlay. */
     lastRenderedFrame(): readonly string[];
     invalidate(): void;
     /** Rows the transcript viewport got in the last frame — the page size. */

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

@@ -56,6 +56,7 @@ export class ViewerFrame {
     parts;
     viewportRows = 0;
     lastFrame = [];
+    overlay;
     constructor(terminal, parts) {
         this.terminal = terminal;
         this.parts = parts;
@@ -117,12 +118,26 @@ export class ViewerFrame {
         if (frame.length !== rows)
             reportInvariant(`frame correction rendered ${frame.length} rows; expected ${rows}`);
         const finalFrame = this.ensureCursorMarker(frame, editorLines, editorSlice, editorBottomOffset, bottomLines.length, rows);
-        // This is the exact physical screen content used for OSC-8 mouse hit tests.
-        // Keep a copy because terminal rendering is allowed to retain the returned array.
+        // This is the exact physical screen content used for OSC-8 mouse hit tests
+        // and for the text a mouse selection copies, so it is kept BEFORE the
+        // overlay paints attributes over it. Keep a copy because terminal rendering
+        // is allowed to retain the returned array.
         this.lastFrame = finalFrame.slice();
-        return finalFrame;
+        if (this.overlay === undefined)
+            return finalFrame;
+        const painted = this.overlay(finalFrame);
+        if (painted.length !== finalFrame.length) {
+            reportInvariant(`frame overlay returned ${painted.length} rows; expected ${finalFrame.length}`);
+            return finalFrame;
+        }
+        return painted;
+    }
+    /** Paint attributes over the composed frame — mouse selection highlight. The
+     *  overlay may restyle rows but must return the same number of them. */
+    setOverlay(overlay) {
+        this.overlay = overlay;
     }
-    /** The physical rows returned by the most recent render. */
+    /** The physical rows returned by the most recent render, before any overlay. */
     lastRenderedFrame() {
         return this.lastFrame;
     }

package/dist/clients/attach/session/input-wiring.js

@@ -36,7 +36,7 @@ export function createInputController(ctx, km, capabilities, hooks) {
     //
     // A read-only viewer wires NEITHER. A REMOTE attach (`--canvas`) disables both
     // because they target the LOCAL `auth.json` via `defaultAgentDir()`, the wrong
-    // host for a remote node (Phase 3 review Major 1, 1d); an OBSERVER because
+    // host for a remote node; an OBSERVER because
     // switching credentials and telling the broker to reload them mutates the
     // engine's auth, which a read-only viewer must not do. Unwired here means the
     // slash context carries no picker at all, so `/login` and `/logout` report
@@ -70,7 +70,7 @@ export function createInputController(ctx, km, capabilities, hooks) {
         onCopyTarget: hooks.copyTarget,
         onToggleMouse: () => {
             const on = hooks.toggleMouse();
-            setNotice(on ? 'Mouse: wheel scrolling on' : 'Mouse: off — tmux drag-select and copy-mode restored');
+            setNotice(on ? 'Mouse: wheel scrolling on, drag to select and copy' : 'Mouse: off — tmux drag-select and copy-mode restored');
         },
         onColor: hooks.setChipColor,
         onPromptSent: hooks.onPromptSent,

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

@@ -18,6 +18,10 @@ export interface MouseHandlers {
     onWheel(direction: 'up' | 'down', lines: number, column: number): void;
     /** A primary-button press with no Shift, Alt, or Control modifier. */
     onPrimaryPress(column: number, row: number): void;
+    /** Pointer motion with the primary button held. */
+    onPrimaryDrag(column: number, row: number): void;
+    /** The primary button came back up, wherever the pointer ended. */
+    onPrimaryRelease(column: number, row: number): void;
 }
 /** Create per-viewer mouse reporting from the user's saved starting mode. */
 export declare function createMouseReporting(write: (data: string) => void, defaultMode: MouseModeDefault): MouseReporting;

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

@@ -3,7 +3,12 @@
 // Mouse reporting starts from the user's configured default. Follow-tmux mode
 // leaves native terminal selection alone when tmux mouse is off; inside a
 // reporting viewer, every mouse sequence is consumed so clicks and drags can
-// never become editor input.
+// never become editor input — which is why the viewer, not the terminal, owns
+// drag-select while reporting is on (session/selection.ts).
+//
+// Mode 1002 is button-event tracking: press, motion while a button is held, and
+// release. Those three are exactly the gesture parts a selection needs, so the
+// drag is reconstructed here and reported as press · drag · release.
 import { spawnSync } from 'node:child_process';
 import { inTmux } from '../../../core/runtime/placement-tmux.js';
 const MOUSE_REPORTING_ON = '\x1b[?1002h\x1b[?1006h';
@@ -46,12 +51,18 @@ export function createMouseReporting(write, defaultMode) {
             const withoutSgr = data.replace(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g, (_match, buttons, column, row, action) => {
                 consumed = true;
                 const code = Number(buttons);
+                // Bits 4/8/16 are Shift/Meta/Control; bit 32 is the motion flag, which
+                // must survive the mask so a drag is distinguishable from a press.
                 const button = code & ~(4 | 8 | 16);
                 if (button === 64)
                     handlers.onWheel('up', WHEEL_LINES, Number(column));
-                if (button === 65)
+                else if (button === 65)
                     handlers.onWheel('down', WHEEL_LINES, Number(column));
-                if (code === 0 && action === 'M')
+                else if (button === 32 && action === 'M')
+                    handlers.onPrimaryDrag(Number(column), Number(row));
+                else if (button === 0 && action === 'm')
+                    handlers.onPrimaryRelease(Number(column), Number(row));
+                else if (code === 0 && action === 'M')
                     handlers.onPrimaryPress(Number(column), Number(row));
                 return '';
             });

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

@@ -0,0 +1,28 @@
+export type SelectionRelease = {
+    kind: 'click';
+    column: number;
+    row: number;
+} | {
+    kind: 'selection';
+    notice: string;
+};
+export interface FrameSelection {
+    /** Primary button pressed: anchor here and drop any previous highlight. */
+    begin(column: number, row: number): void;
+    /** Drag to a new cell. Returns true when the highlight changed. */
+    extend(column: number, row: number): boolean;
+    /** Primary button released. `click` means the press never moved, so the
+     *  caller's click handling (file links) still owns the gesture. */
+    release(): SelectionRelease | undefined;
+    /** Drop the highlight. Returns true when something was showing. */
+    clear(): boolean;
+    /** A highlight is on screen. */
+    active(): boolean;
+    /** Paint the highlight onto a composed frame; identity when nothing is selected. */
+    apply(frame: readonly string[]): string[];
+}
+export declare function createFrameSelection(deps: {
+    /** The physical rows of the last render, unhighlighted. */
+    frame: () => readonly string[];
+    width: () => number;
+}): FrameSelection;

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

@@ -0,0 +1,108 @@
+// session/selection.ts — mouse drag-select and copy over the rendered frame.
+//
+// While the viewer reports mouse events, the terminal hands presses and drags to
+// this process, so the terminal's own drag-select is unavailable: the viewer has
+// to do the selecting. It selects the way a terminal does — over the physical
+// rows last handed to the screen, not over transcript records — so wrapping,
+// folds, the pinned header, and the cockpit all select exactly as they look.
+// Releasing the button copies the selection to the clipboard (and, in tmux, the
+// paste buffer); the highlight stays up as confirmation until the next keypress,
+// wheel notch, or press.
+import { highlightCells, sliceCells } from '../ansi-cells.js';
+import { writeClipboardTextEverywhere } from '../../../core/clipboard-text.js';
+function before(a, b) {
+    return a.row < b.row || (a.row === b.row && a.column <= b.column);
+}
+/** The per-row cell ranges covered by a drag, in terminal selection geometry:
+ *  the first row runs to the pane edge, whole rows in between, the last row up
+ *  to and including the cell under the pointer. */
+function spans(anchor, head, width) {
+    const [start, end] = before(anchor, head) ? [anchor, head] : [head, anchor];
+    const rows = [];
+    for (let row = start.row; row <= end.row; row++) {
+        const from = row === start.row ? start.column - 1 : 0;
+        const to = row === end.row ? end.column : width;
+        if (to > from)
+            rows.push({ row, from, to });
+    }
+    return rows;
+}
+export function createFrameSelection(deps) {
+    let anchor;
+    let head;
+    const selected = () => anchor !== undefined && head !== undefined ? { anchor, head } : undefined;
+    const selectionText = () => {
+        const current = selected();
+        if (!current)
+            return '';
+        const frame = deps.frame();
+        const rows = spans(current.anchor, current.head, deps.width())
+            .map((span) => sliceCells(frame[span.row - 1] ?? '', span.from, span.to).trimEnd());
+        // A trailing blank row is an artifact of where the button came up; leading
+        // blanks inside the span are real content the user dragged across.
+        while (rows.length > 0 && rows[rows.length - 1] === '')
+            rows.pop();
+        return rows.join('\n');
+    };
+    return {
+        begin(column, row) {
+            anchor = { row, column };
+            head = undefined;
+        },
+        extend(column, row) {
+            if (anchor === undefined)
+                return false;
+            if (head !== undefined && head.row === row && head.column === column)
+                return false;
+            head = { row, column };
+            return true;
+        },
+        release() {
+            const press = anchor;
+            if (press === undefined)
+                return undefined;
+            if (head === undefined) {
+                anchor = undefined;
+                return { kind: 'click', column: press.column, row: press.row };
+            }
+            const text = selectionText();
+            if (text === '') {
+                anchor = undefined;
+                head = undefined;
+                return { kind: 'selection', notice: 'Nothing to copy — selection is empty' };
+            }
+            const { system, tmux } = writeClipboardTextEverywhere(text);
+            const destination = system && tmux ? 'clipboard + tmux buffer' : system ? 'clipboard' : tmux ? 'tmux buffer' : undefined;
+            const lines = text.split('\n').length;
+            return {
+                kind: 'selection',
+                notice: destination === undefined
+                    ? 'Copy failed — no clipboard tool found'
+                    : `Copied selection (${lines} ${lines === 1 ? 'line' : 'lines'}) — ${destination}`,
+            };
+        },
+        clear() {
+            const showing = head !== undefined;
+            anchor = undefined;
+            head = undefined;
+            return showing;
+        },
+        active() {
+            return head !== undefined;
+        },
+        apply(frame) {
+            const current = selected();
+            if (!current)
+                return frame.slice();
+            const width = deps.width();
+            const painted = frame.slice();
+            for (const span of spans(current.anchor, current.head, width)) {
+                const index = span.row - 1;
+                if (index < 0 || index >= painted.length)
+                    continue;
+                painted[index] = highlightCells(painted[index], span.from, span.to, width);
+            }
+            return painted;
+        },
+    };
+}

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

@@ -57,18 +57,16 @@ export function createTeardown(s, hooks) {
         socket.close();
         restore();
         // A clean detach leaves the broker running (the engine runs on) — the
-        // documented "detach leaves the broker running" contract (B2). Per-action
-        // reaping of an empty husk used to run here (reapIfEmpty →
-        // teardown/deleteNode, which reaps EVEN a live broker since the user
-        // explicitly detached), but it required a direct canvas.db mutation the
-        // API-only client cannot reach and no per-node reap route exposes, so it is
-        // dropped (B-10). Disposition of an abandoned empty broker: `crtr canvas
+        // documented "detach leaves the broker running" contract. Teardown reaps
+        // nothing per-action: reaping an empty husk here would need a direct
+        // canvas.db mutation the API-only client cannot reach, and no per-node reap
+        // route exposes one. Disposition of an abandoned empty broker: `crtr canvas
         // prune --empty` (reapEmptyNodes) sweeps it, but only ONCE its pid is dead
         // — it deliberately spares a LIVE broker as the daemon's domain. So an empty
         // broker lingers until it idle-releases (or is closed) to a dormant husk,
-        // then prune reaps it. Net vs OLD: a narrow, transient live-empty window
-        // replaces immediate reap — the only faithful option under the API boundary;
-        // a per-node reap route would restore immediate cleanup (future work).
+        // then prune reaps it, leaving a narrow, transient live-empty window — the
+        // only faithful option under the API boundary. A per-node reap route would
+        // buy immediate cleanup (future work).
         if (reason === 'broker-gone') {
             const msg = hooks.lastSocketError() ??
                 `broker gone — node ${nodeId} is no longer running its engine. Re-focus to reattach.`;

package/dist/clients/attach/slash/dispatch.d.ts

@@ -87,8 +87,7 @@ export declare const CANVAS_SLASH_COMMANDS: ReadonlyArray<{
  *  `true` from `dispatchSlashCommand` — swallowed with a notice, never
  *  forwarded as prose — so it counts as consumed here too, independent of
  *  `remote`). Exactly BUILTIN_NAMES ∪ CANVAS_NAMES ∪ SCOPED_OUT — every name
- *  `dispatchSlashCommand` returns `true` for (design: inline memory
- *  references, review Major 6/terminal). Used ONLY for terminal
+ *  `dispatchSlashCommand` returns `true` for. Used ONLY for terminal
  *  ref-decoration suppression (`input/titled-editor.ts`); never merged into
  *  command completion, which is `slashCommandList` — a different,
  *  remote-filtered, broker-augmented list. */

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

@@ -19,12 +19,13 @@
 // against pi 0.79.1 — `ScopedModelsSelectorComponent` is the one selector pi does
 // not re-export, so /scoped-models renders read-only via a SelectList.)
 //
-// SCOPED OUT (review m2 — no engine method): `/login`, `/logout`, `/share`,
+// SCOPED OUT (no engine method): `/login`, `/logout`, `/share`,
 // `/trust` — a brief "not supported in attach" notice, never a frame.
 import { execFile } from 'node:child_process';
 import { BUILTIN_SLASH_COMMANDS } from '../../../core/runtime/pi-vendored.js';
 import { surfaceTmuxStyleArgs } from '../../../core/runtime/surface-bg.js';
 import { viewerOperationForSlash } from '../input/capabilities.js';
+import { shellQuote } from '../../../shared/shell-quote.js';
 /** Canvas slash-commands — implemented NATIVE in the viewer, the ONLY live host:
  *  the broker binds mode:'rpc', so broker pi-extensions never run their
  *  interactive (mode==='tui') paths. `/promote` triggers a turn after shelling
@@ -43,7 +44,7 @@ export const CANVAS_SLASH_COMMANDS = [
     { name: 'mcp', description: 'MCP servers — status from the adapter’s config/cache; Enter (or /mcp <server>) connects, reconnects, or re-auths' },
     { name: 'rename', description: 'Rename this node everywhere — node row, viewer window, session chip, tmux pane: /rename <name>' },
     { name: 'color', description: 'Color this node — tmux pane outline + name chip: /color <color> (red, blue, #rrggbb, …) or /color none' },
-    { name: 'mouse', description: 'Toggle mouse wheel scrolling — off restores tmux drag-select and copy-mode mouse' },
+    { name: 'mouse', description: 'Toggle mouse wheel scrolling and drag-select — off restores tmux drag-select and copy-mode mouse' },
     { name: 'copy-message', description: 'Copy the newest message visible in the transcript viewport' },
     { name: 'copy-tool', description: 'Copy the newest tool call output' },
     { name: 'copy-transcript', description: 'Copy every copyable transcript block' },
@@ -58,7 +59,7 @@ const TMUX_NAMED_COLORS = new Set([
     'brightred', 'brightgreen', 'brightyellow', 'brightblue', 'brightmagenta', 'brightcyan',
     'orange', 'grey', 'gray', 'default',
 ]);
-/** Builtins with no Phase-4 engine method — scoped out (review m2). */
+/** Builtins with no engine method — scoped out. */
 const SCOPED_OUT = new Set(['trust']);
 /** Valid `/settings thinking` levels — the `SetThinkingLevelFrame['level']`
  *  union (= AgentSession['thinkingLevel'], pi-agent-core ThinkingLevel),
@@ -92,8 +93,7 @@ function readOnlyRefusal(name, ctx) {
  *  `true` from `dispatchSlashCommand` — swallowed with a notice, never
  *  forwarded as prose — so it counts as consumed here too, independent of
  *  `remote`). Exactly BUILTIN_NAMES ∪ CANVAS_NAMES ∪ SCOPED_OUT — every name
- *  `dispatchSlashCommand` returns `true` for (design: inline memory
- *  references, review Major 6/terminal). Used ONLY for terminal
+ *  `dispatchSlashCommand` returns `true` for. Used ONLY for terminal
  *  ref-decoration suppression (`input/titled-editor.ts`); never merged into
  *  command completion, which is `slashCommandList` — a different,
  *  remote-filtered, broker-augmented list. */
@@ -605,10 +605,6 @@ function popup(cmd) {
         /* best-effort */
     }
 }
-/** Single-quote a string for safe interpolation into a `sh -c` command line. */
-function shellQuote(s) {
-    return `'${s.replace(/'/g, `'\\''`)}'`;
-}
 // ---------------------------------------------------------------------------
 function usage(ctx, form) {
     ctx.notify(`Usage: ${form}`);