@north-light/api 0.3.580 → 0.3.588

package/dist/clients/attach/input/clipboard-image.js

@@ -0,0 +1,237 @@
+// input/clipboard-image.ts — read the clipboard image for `crtr surface attach`.
+//
+// pi's `readClipboardImage` is NOT re-exported (it lives behind a native
+// clipboard binding + Photon worker the package gates off `.`-only exports), so
+// we reimplement the READ by shelling out to the platform clipboard tool. macOS:
+// `pngpaste` is a faster path IF present, but it is NOT a built-in (`brew install
+// pngpaste`), so the authoritative read is the dependency-free `osascript` path
+// (`the clipboard as «class PNGf»` → temp PNG), which works on a stock Mac.
+// Linux: `wl-paste` on Wayland, `xclip` on X11. The reader DISTINGUISHES three
+// outcomes — got bytes, clipboard genuinely empty, or no clipboard tool / read
+// failure — so the caller's notice is accurate ("No image in the clipboard" vs a
+// precise "install xclip" / "osascript failed") instead of collapsing every
+// miss to "no image".
+//
+// The bytes are then resized AGGRESSIVELY through pi's exported `resizeImage`
+// (which is reusable, unlike the reader) so the base64 stays well within the
+// broker's client-read line cap (`BROKER_READ_CAPS.maxLineBytes` = 24 MiB).
+// `resizeImage`'s `maxBytes` is the BASE64-PAYLOAD ceiling (it compares the
+// encoded size, not raw bytes — see image-resize-core), so MAX_BYTES (3 MiB)
+// bounds the base64 itself, far under 24 MiB. `resizeImage` already tries PNG and
+// JPEG and picks the smaller, so it doubles as format normalization;
+// `convertToPng` is the fallback when the Photon resizer is unavailable. The
+// fallbacks (convertToPng / raw bytes) are NOT size-bounded by `resizeImage`, so
+// each is gated on the SAME MAX_BYTES base64 ceiling: over it → the
+// image is DROPPED with a user-visible note rather than shipped as an over-cap
+// frame that would overflow BROKER_READ_CAPS.maxLineBytes (24 MiB) and destroy
+// the viewer socket. The result is an `ImageContent` (pi-ai) ready to drop
+// straight into a `prompt`/`steer`/`follow_up` frame's `images?` array (or, when
+// dropped, a `note`-only result and no image).
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { convertToPng, formatDimensionNote, resizeImage, } from '@earendil-works/pi-coding-agent';
+/** Longest edge (px) the pasted image is resized to — aggressive, matches the
+ *  ~1568px long-edge guidance vision models use. */
+const MAX_EDGE = 1568;
+/** Largest BASE64 payload per image — the ceiling for BOTH paths: passed as
+ *  `resizeImage`'s `maxBytes` (which bounds the encoded base64, not raw bytes)
+ *  on the primary path, and compared against the fallbacks' base64 length. 3 MiB
+ *  base64, far under BROKER_READ_CAPS.maxLineBytes (24 MiB). */
+const MAX_BYTES = 3 * 1024 * 1024;
+/** Bound the shell read so a giant/garbage clipboard can't blow up memory. */
+const SPAWN_MAX_BUFFER = 64 * 1024 * 1024;
+const SPAWN_TIMEOUT_MS = 3000;
+/** Persist a (already-resized) clipboard image to a stable temp file and return
+ *  its absolute path, so the attach editor can drop the PATH inline into the
+ *  prompt instead of inlining base64 the agent can't see. The broker runs on the
+ *  same host, so a tmpdir path is readable by the engine. */
+export function writeClipboardImageToFile(image) {
+    const dir = join(tmpdir(), 'crtr-clip-images');
+    mkdirSync(dir, { recursive: true });
+    const ext = image.mimeType === 'image/jpeg' ? 'jpg' : 'png';
+    const path = join(dir, `paste-${Date.now()}-${process.pid}.${ext}`);
+    writeFileSync(path, Buffer.from(image.data, 'base64'));
+    return path;
+}
+/** Read + resize the current clipboard image. Returns `null` ONLY when the
+ *  clipboard genuinely holds no image; a `note`-only result means there is a
+ *  precise reason to surface (no clipboard tool, read failure, or an over-cap
+ *  drop). All best-effort — the caller shows a brief notice and carries on. */
+export async function readClipboardImage() {
+    const outcome = readRawClipboardImage();
+    const raw = outcome.image;
+    if (!raw) {
+        // No bytes. A `note` means a precise reason worth surfacing (no clipboard
+        // tool, or a read failure) — return it so the caller shows it instead of the
+        // generic "No image in the clipboard". No note → the clipboard is genuinely
+        // empty → null (caller shows the generic notice).
+        return outcome.note ? { note: outcome.note } : null;
+    }
+    // Primary path: resize aggressively. Handles format (PNG/JPEG) + size bound.
+    const resized = await resizeImage(new Uint8Array(raw.bytes), raw.mimeType, {
+        maxWidth: MAX_EDGE,
+        maxHeight: MAX_EDGE,
+        maxBytes: MAX_BYTES,
+    });
+    if (resized) {
+        return {
+            image: { type: 'image', data: resized.data, mimeType: resized.mimeType },
+            note: resized.wasResized ? formatDimensionNote(resized) : undefined,
+        };
+    }
+    // Fallback: the Photon resizer is unavailable — at least normalize to PNG so
+    // the engine gets a format it accepts. Capped at MAX_BYTES (base64).
+    const png = await convertToPng(raw.bytes.toString('base64'), raw.mimeType);
+    if (png)
+        return capped({ type: 'image', data: png.data, mimeType: png.mimeType });
+    // Last resort: ship the raw bytes — also capped, never an over-cap frame.
+    return capped({ type: 'image', data: raw.bytes.toString('base64'), mimeType: raw.mimeType });
+}
+/** Gate a FALLBACK image on the per-image base64 ceiling (MAX_BYTES): under it →
+ *  attach; over → DROP with a user-visible note rather than ship a frame that
+ *  would overflow the broker's 24 MiB read cap and destroy the viewer socket.
+ *  base64 is ASCII, so its byte length equals the bytes the frame puts on the
+ *  wire. */
+function capped(image) {
+    const encodedBytes = Buffer.byteLength(image.data);
+    if (encodedBytes <= MAX_BYTES)
+        return { image };
+    const mib = (n) => Math.round(n / (1024 * 1024));
+    return {
+        note: `Image not attached: ${mib(encodedBytes)} MiB exceeds the ${mib(MAX_BYTES)} MiB attach limit (clipboard resizer unavailable)`,
+    };
+}
+/** Shell out to the platform clipboard tool for raw image bytes. */
+function readRawClipboardImage() {
+    if (process.platform === 'darwin') {
+        return selectMacOutcome(run, readMacClipboardViaOsascript);
+    }
+    return selectLinuxOutcome(run, isWayland());
+}
+/** Pure macOS dispatch (the regression-test seam): try `pngpaste` if present,
+ *  else fall through to the native osascript read — a missing `pngpaste` must
+ *  NOT collapse to "no image", which was the stock-Mac bug. */
+export function selectMacOutcome(runTool, readNative) {
+    const fast = runTool('pngpaste', ['-']);
+    if (fast.bytes)
+        return { image: { bytes: fast.bytes, mimeType: 'image/png' } };
+    // pngpaste missing OR clipboard empty → osascript is authoritative.
+    return readNative();
+}
+/** Pure Linux dispatch (the regression-test seam): Wayland (`wl-paste`) first,
+ *  then X11 (`xclip`), PNG then JPEG. If NO tool binary was found, surface a
+ *  precise "install …" note; if a tool ran but found no image, report empty. */
+export function selectLinuxOutcome(runTool, wayland) {
+    let anyToolPresent = false;
+    if (wayland) {
+        const out = runTool('wl-paste', ['--type', 'image/png', '--no-newline']);
+        if (out.bytes)
+            return { image: { bytes: out.bytes, mimeType: 'image/png' } };
+        if (!out.missing)
+            anyToolPresent = true;
+    }
+    for (const mimeType of ['image/png', 'image/jpeg']) {
+        const out = runTool('xclip', ['-selection', 'clipboard', '-t', mimeType, '-o']);
+        if (out.bytes)
+            return { image: { bytes: out.bytes, mimeType } };
+        if (!out.missing)
+            anyToolPresent = true;
+    }
+    if (!anyToolPresent) {
+        return {
+            note: wayland
+                ? 'No clipboard tool found — install wl-clipboard (wl-paste) to paste images'
+                : 'No clipboard tool found — install xclip to paste images',
+        };
+    }
+    return {}; // a tool ran but the clipboard holds no image
+}
+/** AppleScript that writes the clipboard's PNG representation to the temp path
+ *  in `argv`. `the clipboard as «class PNGf»` THROWS when the clipboard has no
+ *  PNG-convertible image — caught → "NO_IMAGE" (a clean empty signal, distinct
+ *  from a failure). A write failure (after `set eof` already truncated the file)
+ *  closes the handle and returns "WRITE_FAILED" rather than swallowing the error
+ *  and reporting a false "OK" over a 0-byte/partial file — so "OK" reliably means
+ *  the full bytes are in the temp file, preserving the empty-vs-failure split. */
+const MAC_PNG_SCRIPT = `on run argv
+  set outPath to item 1 of argv
+  try
+    set pngData to (the clipboard as «class PNGf»)
+  on error
+    return "NO_IMAGE"
+  end try
+  set fh to open for access (POSIX file outPath) with write permission
+  try
+    set eof fh to 0
+    write pngData to fh
+    close access fh
+  on error
+    try
+      close access fh
+    end try
+    return "WRITE_FAILED"
+  end try
+  return "OK"
+end run`;
+/** Native, dependency-free macOS read: osascript (always present) writes the
+ *  clipboard PNG to a temp file we then read. Distinguishes empty ("NO_IMAGE")
+ *  from a genuine read failure so the caller's notice is accurate. */
+function readMacClipboardViaOsascript() {
+    const tmpFile = join(tmpdir(), `crtr-clip-${process.pid}-${Date.now()}.png`);
+    try {
+        const result = spawnSync('osascript', ['-e', MAC_PNG_SCRIPT, tmpFile], {
+            timeout: SPAWN_TIMEOUT_MS,
+            maxBuffer: SPAWN_MAX_BUFFER,
+            encoding: 'utf-8',
+        });
+        if (result.error || result.status !== 0) {
+            return { note: 'Could not read the clipboard (osascript failed)' };
+        }
+        const signal = (result.stdout ?? '').trim();
+        if (signal === 'NO_IMAGE')
+            return {}; // clipboard genuinely holds no image
+        if (signal !== 'OK')
+            return { note: 'Could not read the clipboard image' };
+        let bytes;
+        try {
+            bytes = readFileSync(tmpFile);
+        }
+        catch {
+            return { note: 'Could not read the clipboard image' };
+        }
+        return bytes.length > 0 ? { image: { bytes, mimeType: 'image/png' } } : {};
+    }
+    finally {
+        try {
+            unlinkSync(tmpFile);
+        }
+        catch {
+            /* ignore temp-file cleanup errors (NO_IMAGE never created it) */
+        }
+    }
+}
+function isWayland() {
+    return Boolean(process.env.WAYLAND_DISPLAY) || process.env.XDG_SESSION_TYPE === 'wayland';
+}
+/** Run a clipboard tool; return its stdout bytes, or a `missing` flag when the
+ *  binary isn't on PATH (so the caller can distinguish "no tool" from "no
+ *  image"). Any other failure (non-zero exit, timeout, empty output) → an empty
+ *  result ({}), i.e. the tool ran but yielded no image. */
+function run(command, args) {
+    const result = spawnSync(command, args, {
+        timeout: SPAWN_TIMEOUT_MS,
+        maxBuffer: SPAWN_MAX_BUFFER,
+    });
+    if (result.error) {
+        const missing = result.error.code === 'ENOENT';
+        return { missing };
+    }
+    if (result.status !== 0)
+        return {};
+    const stdout = result.stdout;
+    if (!stdout || stdout.length === 0)
+        return {};
+    return { bytes: Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout) };
+}

package/dist/clients/attach/input/completion-frecency.d.ts

@@ -0,0 +1,45 @@
+export interface FrecencyStore {
+    /** Bump an item's count and stamp it now. `id` is namespaced by the caller
+     *  (`command:<name>` / `ref:<canonicalName>`) so a command and a ref of the
+     *  same name never collide. */
+    record(id: string): void;
+    /** The non-negative bonus to SUBTRACT from an item's fuzzy score. */
+    bonus(id: string, now?: number): number;
+}
+/** Create the viewer's single frecency store. Loads once; writes are debounced
+ *  and unref'd so they never hold the process open. */
+export declare function createFrecencyStore(filePath?: string): FrecencyStore;
+/**
+ * Filter `items` to fuzzy matches of `query` and sort by combined
+ * `fuzzyScore − frecencyBonus` (ascending; lower = better, matching pi-tui's
+ * convention). An empty query matches everything at fuzzy score 0, so the
+ * result is ordered purely by frecency — the bare-`/` "most-used first" list.
+ *
+ * `fuzzyMatch` is pi-tui's own exported matcher, so for a single-token query
+ * this produces exactly pi-tui's per-item score; the frecency term is the only
+ * perturbation.
+ */
+export declare function rankByFuzzyFrecency<T>(items: readonly T[], query: string, opts: {
+    searchableOf: (item: T) => string;
+    idOf: (item: T) => string;
+    store: FrecencyStore;
+    now?: number;
+}): T[];
+/**
+ * The string a namespaced name is fuzzy-matched against. Users reach for the
+ * meaningful LEAF ("dev"), so the leaf is placed first (earning pi-tui's
+ * word-boundary bonus) and the full name follows. This is what lets a
+ * cross-segment query like `devacm` match `acme/dev` — `dev` from the
+ * leaf then `acm` from `acme` — which a subsequence over the raw name
+ * cannot do.
+ *
+ * One helper serves both inventories: memory refs are namespaced with `/`
+ * (canonical `acme/dev`) and slash commands with `:` (the same doc
+ * invoked as `/acme:dev`), so the leaf is whatever follows the last
+ * separator of either kind.
+ */
+export declare function leafFirstSearchable(name: string): string;
+/** Normalize a typed ref query for matching: drop the surface `:` separators so
+ *  a typed `acme:dev` matches the `/`-separated canonical searchable text,
+ *  and so cross-segment queries are not blocked by a separator mismatch. */
+export declare function normalizeRefQuery(surfacePrefixWithoutSlash: string): string;

package/dist/clients/attach/input/completion-frecency.js

@@ -0,0 +1,141 @@
+// input/completion-frecency.ts — per-user frequency/recency ("frecency") bias
+// for `/` completion, shared by the leading slash-command path and the inline
+// memory-ref path. The store persists a small usage map to the user scope root
+// (`~/.crouter/completion-frecency.json`) — user-wide state with no cwd
+// dimension, which per the storage tiers belongs there and NOT in canvas.db.
+// The viewer is a client and owns this plain JSON file directly; it never
+// touches canvas state.
+//
+// The design intent is a SLIGHT bias: `bonus` is capped well below the spread
+// of fuzzy scores, so it only breaks near-ties and fully orders the bare-`/`
+// list (where every fuzzy score is 0) by most-recent/most-used. A clearly
+// better fuzzy match always wins.
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fuzzyMatch } from '@earendil-works/pi-tui';
+import { userScopeRoot } from '../../../core/scope.js';
+const FILE_NAME = 'completion-frecency.json';
+/** Recency half-life: a use's recency weight halves every two weeks. */
+const HALF_LIFE_MS = 14 * 24 * 60 * 60 * 1000;
+/** Maximum bonus subtracted from a fuzzy score. Chosen well below typical
+ *  good-match scores (−10…−30) so the bias never overrides a clearly better
+ *  fuzzy match — it only breaks near-ties and orders the all-zero empty list. */
+const BONUS_CAP = 8;
+/** Coalesce bursts of records into one disk write. */
+const WRITE_DEBOUNCE_MS = 1000;
+/** Pure frecency curve. Every entry reaching it is well-formed — `loadMap` is
+ *  the only untrusted source and validates there — so an unknown id is the only
+ *  case to handle here. */
+function frecencyBonus(entry, now) {
+    if (!entry)
+        return 0;
+    const ageMs = Math.max(0, now - entry.t);
+    const recency = Math.pow(0.5, ageMs / HALF_LIFE_MS); // (0, 1], 1 at age 0
+    const saturate = 1 - Math.exp(-entry.n / 3); // climbs fast, then flattens < 1
+    return BONUS_CAP * recency * saturate;
+}
+/** Load the usage map, keeping only well-formed entries. Anything else —
+ *  a non-object container, an array, a non-finite or non-positive `n`, a
+ *  non-finite `t` — is dropped, so a parseable-but-malformed file can never
+ *  poison a sort or silently swallow later writes. */
+function loadMap(filePath) {
+    const map = {};
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return map;
+        for (const [id, value] of Object.entries(parsed)) {
+            if (!value || typeof value !== 'object')
+                continue;
+            const { n, t } = value;
+            if (typeof n !== 'number' || !Number.isFinite(n) || n <= 0)
+                continue;
+            if (typeof t !== 'number' || !Number.isFinite(t))
+                continue;
+            map[id] = { n, t };
+        }
+    }
+    catch {
+        // Missing or corrupt → start empty. No fallback theater; a fresh map is the
+        // honest state and self-heals on the next successful write.
+    }
+    return map;
+}
+function saveMap(filePath, map) {
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, JSON.stringify(map), 'utf8');
+    }
+    catch {
+        // Best-effort persistence — a failed write loses only this session's counts,
+        // never breaks completion. The in-memory map stays authoritative for now.
+    }
+}
+/** Create the viewer's single frecency store. Loads once; writes are debounced
+ *  and unref'd so they never hold the process open. */
+export function createFrecencyStore(filePath = join(userScopeRoot(), FILE_NAME)) {
+    const map = loadMap(filePath);
+    let timer;
+    const scheduleWrite = () => {
+        if (timer)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            saveMap(filePath, map);
+        }, WRITE_DEBOUNCE_MS);
+        timer.unref?.();
+    };
+    return {
+        record: (id) => {
+            const prev = map[id];
+            map[id] = { n: (prev?.n ?? 0) + 1, t: Date.now() };
+            scheduleWrite();
+        },
+        bonus: (id, now = Date.now()) => frecencyBonus(map[id], now),
+    };
+}
+/**
+ * Filter `items` to fuzzy matches of `query` and sort by combined
+ * `fuzzyScore − frecencyBonus` (ascending; lower = better, matching pi-tui's
+ * convention). An empty query matches everything at fuzzy score 0, so the
+ * result is ordered purely by frecency — the bare-`/` "most-used first" list.
+ *
+ * `fuzzyMatch` is pi-tui's own exported matcher, so for a single-token query
+ * this produces exactly pi-tui's per-item score; the frecency term is the only
+ * perturbation.
+ */
+export function rankByFuzzyFrecency(items, query, opts) {
+    const now = opts.now ?? Date.now();
+    const scored = [];
+    for (const item of items) {
+        const match = fuzzyMatch(query, opts.searchableOf(item));
+        if (!match.matches)
+            continue;
+        scored.push({ item, score: match.score - opts.store.bonus(opts.idOf(item), now) });
+    }
+    scored.sort((a, b) => a.score - b.score);
+    return scored.map((s) => s.item);
+}
+/**
+ * The string a namespaced name is fuzzy-matched against. Users reach for the
+ * meaningful LEAF ("dev"), so the leaf is placed first (earning pi-tui's
+ * word-boundary bonus) and the full name follows. This is what lets a
+ * cross-segment query like `devacm` match `acme/dev` — `dev` from the
+ * leaf then `acm` from `acme` — which a subsequence over the raw name
+ * cannot do.
+ *
+ * One helper serves both inventories: memory refs are namespaced with `/`
+ * (canonical `acme/dev`) and slash commands with `:` (the same doc
+ * invoked as `/acme:dev`), so the leaf is whatever follows the last
+ * separator of either kind.
+ */
+export function leafFirstSearchable(name) {
+    const cut = Math.max(name.lastIndexOf('/'), name.lastIndexOf(':'));
+    return cut < 0 ? name : `${name.slice(cut + 1)} ${name}`;
+}
+/** Normalize a typed ref query for matching: drop the surface `:` separators so
+ *  a typed `acme:dev` matches the `/`-separated canonical searchable text,
+ *  and so cross-segment queries are not blocked by a separator mismatch. */
+export function normalizeRefQuery(surfacePrefixWithoutSlash) {
+    return surfacePrefixWithoutSlash.replace(/:/g, '');
+}

package/dist/clients/attach/input/controller.d.ts

@@ -0,0 +1,92 @@
+import type { CustomEditor } from '@earendil-works/pi-coding-agent';
+import type { Component, KeybindingsManager, TUI } from '@earendil-works/pi-tui';
+import { type BrokerDataFrame, type BrokerSnapshot, type ClientToBroker, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from '../../../core/runtime/broker-protocol.js';
+import type { ReadOpRequest } from '../../../core/broker-client/index.js';
+import type { FrecencyStore } from './completion-frecency.js';
+import type { CopyTarget } from '../render/transcript-copy.js';
+import { type ViewerCapabilities } from './capabilities.js';
+import { InputOverlayOwner } from './overlay-owner.js';
+export interface InputControllerHooks {
+    onCommand: (frame: ClientToBroker) => void;
+    onDialogResponse: (response: RpcExtensionUIResponse) => void;
+    onNotice?: (message: string) => void;
+    onGraph?: () => void;
+    onInbox?: () => void;
+    onHelp?: () => void;
+    onQuit?: () => void;
+    onCopy?: () => void;
+    onCopyTarget?: (target: CopyTarget) => void;
+    onToggleMouse?: () => void;
+    onColor?: (color: string | null) => void;
+    onNodeMetadata?: () => void;
+    onToggleToolsExpand?: () => void;
+    onFoldTools?: () => void;
+    onShowWorking?: () => void;
+    onToggleThinking?: () => void;
+    onRequest?: (frame: ReadOpRequest) => Promise<BrokerDataFrame>;
+    onMountPicker?: (component: Component) => void;
+    onUnmountPicker?: () => void;
+    /** Viewer-local auth entry points. Their presence is an affordance, not
+     * permission; input-wiring supplies them only when capabilities permit auth. */
+    openLoginPicker?: () => void;
+    openLogoutPicker?: () => void;
+    isDormant?: () => boolean;
+    onDormantSubmit?: (text: string) => void;
+    onPromptSent?: () => void;
+    /** Per-user completion frecency store — usage recorded here biases the sort
+     *  order the next time `/` completion opens. */
+    frecency?: FrecencyStore;
+    /** Canonical names of currently-resolvable memory refs, so a submitted
+     *  message records ONLY real refs, not arbitrary slash tokens. */
+    knownRefNames?: () => ReadonlySet<string>;
+}
+export declare class InputController {
+    private readonly tui;
+    private readonly editor;
+    private readonly keybindings;
+    private readonly hooks;
+    private readonly capabilities;
+    private readonly overlays;
+    private state;
+    private lastEscapeAt;
+    private pastedImages;
+    private pasteSeq;
+    constructor(tui: TUI, editor: CustomEditor, keybindings: KeybindingsManager, hooks: InputControllerHooks, capabilities: ViewerCapabilities);
+    cycleLadder(direction: 'forward' | 'backward'): void;
+    sendInterrupting(text: string): boolean;
+    /** Cancel the running turn without sending a message — the ctrl+c "stop the
+     *  agent" chord. Mirrors Esc's abort semantics. Returns false when nothing is
+     *  streaming to cancel, so the caller can hint at detach instead. */
+    abortTurn(): boolean;
+    attachDialog(request: RpcExtensionUIRequest): void;
+    dismissDialog(id: string): void;
+    setState(state: BrokerSnapshot['state']): void;
+    openFileReviewPicker(candidates: string[], cwd: string, onChoose: (file: string) => void): void;
+    /** Retained as a narrow delegate for auth affordances wired by the session. */
+    openAuthPicker(prepare: Parameters<InputOverlayOwner['openAuthPicker']>[0]): Promise<void>;
+    private readonly send;
+    private emitCommand;
+    private openBrokerPicker;
+    private wire;
+    private slashContext;
+    /** Record a leading slash command as used. Called only once the command has
+     *  actually run — after a successful local dispatch or a successful send — so
+     *  refused, unsupported, and rejected submissions never bias completion. */
+    private recordCommandUse;
+    /** Record usage so `/` completion can bias toward frequently/recently used
+     *  items next time. A leading slash token is a command; every resolvable
+     *  memory ref found in submitted prose is a ref use. Called only on the
+     *  success paths of `handleSubmit` — never for bash, a refused drive, or a
+     *  submission that classified out. */
+    private recordCompletionUse;
+    private handleSubmit;
+    private handleFollowUp;
+    private handleDequeue;
+    private emitDrive;
+    private handlePaste;
+    private attachImage;
+    private expandImagePlaceholders;
+    private clearPastedImages;
+    private openExternalEditor;
+    private notify;
+}