muonroi-cli 1.8.3 → 1.8.5

package/dist/packages/agent-harness-core/src/mcp-server.js

@@ -18,6 +18,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { createDriver } from "./driver.js";
+import { createEventTee } from "./event-tee.js";
 import { PROTOCOL_VERSION } from "./protocol.js";
 const ARG_ALLOW = /^(--agent-[a-z-]+(=.*)?|--mock-llm(=.+)?|--profile=[a-zA-Z0-9_-]+)$/;
 const ENV_KEY_RE = /^[A-Z_][A-Z0-9_]{0,63}$/;
@@ -133,7 +134,20 @@ export function validateMockLlmPath(value) {
     const sep = process.platform === "win32" ? "\\" : "/";
     return real === root || real.startsWith(root + sep);
 }
-const FEATURES = ["capabilities", "snapshot", "press", "type", "wait_for", "query", "expect", "render_text"];
+const FEATURES = [
+    "capabilities",
+    "snapshot",
+    "press",
+    "type",
+    "wait_for",
+    "query",
+    "expect",
+    "render_text",
+    "render_visual",
+    "snapshot_visual",
+    "cell",
+    "visual_quality",
+];
 export function buildCapabilitiesPayload() {
     return {
         protocol: PROTOCOL_VERSION,
@@ -203,6 +217,42 @@ export function registerReadTools(server, getDriver) {
             return noDriver();
         return { content: [{ type: "text", text: d.render_text() }] };
     });
+    server.registerTool("tui.render_visual", {
+        description: "Render the ACTUAL rendered cell grid as plain text — the characters a human reads on screen. Unlike tui.render_text (semantic tree), this reflects the real render. Requires agent-mode with the renderer attached.",
+        inputSchema: {},
+    }, async () => {
+        const d = getDriver();
+        if (!d)
+            return noDriver();
+        return { content: [{ type: "text", text: d.render_visual() }] };
+    });
+    server.registerTool("tui.snapshot_visual", {
+        description: "Return the latest VisualFrame — the real rendered cell grid with per-cell char + fg/bg hex + attribute bits. null until the renderer emits one.",
+        inputSchema: {},
+    }, async () => {
+        const d = getDriver();
+        if (!d)
+            return noDriver();
+        return { content: [{ type: "text", text: JSON.stringify(d.snapshot_visual()) }] };
+    });
+    server.registerTool("tui.cell", {
+        description: "Decode the rendered cell at (row, col): char + fg/bg hex + attribute bits, from the latest VisualFrame. Use to assert the colors/formatting a human actually sees.",
+        inputSchema: { row: z.number().int().min(0), col: z.number().int().min(0) },
+    }, async ({ row, col }) => {
+        const d = getDriver();
+        if (!d)
+            return noDriver();
+        return { content: [{ type: "text", text: JSON.stringify(d.visual_cell(row, col)) }] };
+    });
+    server.registerTool("tui.visual_quality", {
+        description: "Heuristic visual-quality report over the rendered grid: near-empty-row ratio, blank-row runs, whitespace density, mojibake, a 0-100 score and issues[]. Catches 'messy render' the semantic tree cannot see.",
+        inputSchema: {},
+    }, async () => {
+        const d = getDriver();
+        if (!d)
+            return noDriver();
+        return { content: [{ type: "text", text: JSON.stringify(d.visual_quality()) }] };
+    });
 }
 export function registerActionTools(server, getDriver) {
     const noDriver = () => ({
@@ -459,22 +509,13 @@ export function createMcpHarnessServer({ spawn }) {
             sendKey: (k) => sendLine(JSON.stringify({ op: "press", key: k })),
             sendType: (t) => sendLine(JSON.stringify({ op: "type", text: t })),
         });
+        // Optional JSONL event sink for external milestone watchers (null unless
+        // MUONROI_HARNESS_EVENT_LOG is set). Ephemeral kinds carry an at-emit
+        // visual snapshot so flash events aren't lost before an agent wakes.
+        const eventTee = createEventTee(() => driver.render_visual(), process.env["MUONROI_HARNESS_EVENT_LOG"]);
         // onLine already delivers complete newline-stripped lines — no extra
         // splitting required.
-        const unsub = onLine((line) => {
-            try {
-                const msg = JSON.parse(line);
-                if (msg.mode === "live")
-                    driver._ingest({ kind: "frame", frame: msg });
-                else if (msg.t === "idle")
-                    driver._ingest({ kind: "idle" });
-                else if (msg.t === "event")
-                    driver._ingest({ kind: "event", event: msg });
-            }
-            catch {
-                // ignore malformed lines
-            }
-        });
+        const unsub = onLine(makeLineHandler(driver, eventTee));
         spawnResult.exited.then(() => {
             unsub();
             if (currentPid === proc.pid) {
@@ -491,6 +532,37 @@ export function createMcpHarnessServer({ spawn }) {
     registerAsyncTools(server, () => currentDriver, { onStop });
     return server;
 }
+/**
+ * Build the onLine sidechannel handler: parse each JSON line, ingest frames /
+ * visuals / idle / events into the driver, and tee events to the optional JSONL
+ * sink. Extracted (and exported) so the frame/event/tee wiring is unit-testable
+ * without a live TUI or an MCP protocol handshake.
+ *
+ * @param driver   the driver to ingest into (only _ingest is used).
+ * @param eventTee optional sink from createEventTee (null → no tee).
+ */
+export function makeLineHandler(driver, eventTee) {
+    return (line) => {
+        try {
+            const msg = JSON.parse(line);
+            if (msg.mode === "live")
+                driver._ingest({ kind: "frame", frame: msg });
+            else if (msg.mode === "visual")
+                driver._ingest({ kind: "visual", frame: msg });
+            else if (msg.t === "idle")
+                driver._ingest({ kind: "idle" });
+            else if (msg.t === "event") {
+                const event = msg;
+                driver._ingest({ kind: "event", event });
+                // Tee AFTER ingest so render_visual reflects the frame at this event.
+                eventTee?.(event);
+            }
+        }
+        catch {
+            // ignore malformed lines
+        }
+    };
+}
 /**
  * Run the MCP harness driver over stdio with the OpenTUI spawn implementation
  * injected by the consumer.

package/dist/packages/agent-harness-core/src/protocol.d.ts

@@ -1,5 +1,17 @@
 export declare const PROTOCOL_VERSION: "0.4.0";
-export type Role = "dialog" | "textbox" | "listbox" | "listitem" | "button" | "checkbox" | "radio" | "radiogroup" | "tab" | "tablist" | "tree" | "treeitem" | "table" | "row" | "cell" | "progressbar" | "spinner" | "log" | "statusbar" | "menu" | "menuitem" | "toast" | "tooltip" | "region";
+/**
+ * Known accessibility-style roles for semantic blocks. Closed vocabulary —
+ * `Role` (below) additionally admits namespaced `x-*` custom roles so new UI
+ * surfaces can be introduced without a protocol version bump (additive-only).
+ */
+export type KnownRole = "dialog" | "textbox" | "listbox" | "listitem" | "button" | "checkbox" | "radio" | "radiogroup" | "tab" | "tablist" | "tree" | "treeitem" | "table" | "row" | "cell" | "progressbar" | "spinner" | "log" | "statusbar" | "menu" | "menuitem" | "toast" | "tooltip" | "region" | "editor" | "diff" | "gutter" | "panel";
+/**
+ * A semantic role. Either a well-known {@link KnownRole} or a namespaced
+ * `x-<custom>` role. The `x-` prefix keeps custom roles greppable and prevents
+ * silent collisions with future well-known roles — additive versioning via the
+ * `tui.capabilities` handshake rather than a breaking protocol bump.
+ */
+export type Role = KnownRole | `x-${string}`;
 export type UINode = {
     id: string;
     role: Role;
@@ -23,6 +35,58 @@ export type LiveFrame = {
     modals?: string[];
     nodes: UINode[];
 };
+/**
+ * Text-attribute bit flags in {@link VisualSpan.attrs}. Mirrors the low byte of
+ * OpenTUI's `TextAttributes` (`ATTRIBUTE_BASE_MASK = 255`), so a consumer can
+ * decode `attrs & VisualAttr.BOLD` etc. without importing the renderer.
+ */
+export declare const VisualAttr: {
+    readonly BOLD: 1;
+    readonly DIM: 2;
+    readonly ITALIC: 4;
+    readonly UNDERLINE: 8;
+    readonly BLINK: 16;
+    readonly INVERSE: 32;
+    readonly HIDDEN: 64;
+    readonly STRIKETHROUGH: 128;
+};
+/** One coalesced run of identically-styled cells on a visual line. */
+export type VisualSpan = {
+    /** The run's text (wide-char continuation cells omitted; `width` reflects columns). */
+    text: string;
+    /** Foreground color as "#rrggbb" (or "#rrggbbaa" when alpha < 255). */
+    fg: string;
+    /** Background color as "#rrggbb" (or "#rrggbbaa"). */
+    bg: string;
+    /** Text-attribute bitmask — decode with {@link VisualAttr}. */
+    attrs: number;
+    /** Display columns this run occupies (accounts for wide CJK/emoji). */
+    width: number;
+};
+/** One row of the rendered grid, as style-coalesced spans. */
+export type VisualLine = {
+    spans: VisualSpan[];
+};
+/**
+ * Ground-truth snapshot of the ACTUAL rendered terminal cell grid — the real
+ * characters, colors, and attributes OpenTUI painted, read directly from
+ * `CliRenderer.currentRenderBuffer.getSpanLines()`. Unlike {@link LiveFrame}
+ * (semantic structure), this is what a human SEES on screen. No OCR — the cell
+ * buffer is authoritative. Emitted on the same sidechannel as LiveFrame,
+ * deduped by content hash, and (to bound `getSpanLines` allocation) only
+ * captured when a semantic frame also changes.
+ */
+export type VisualFrame = {
+    mode: "visual";
+    version: typeof PROTOCOL_VERSION;
+    seq: number;
+    ts: number;
+    cols: number;
+    rows: number;
+    /** Cursor [col, row], or null when hidden/unknown. */
+    cursor: [number, number] | null;
+    lines: VisualLine[];
+};
 export type LiveEvent = {
     t: "event";
     kind: "stream.delta";
@@ -226,4 +290,4 @@ export type DesignSpec = {
         notes?: string;
     }>;
 };
-export type HarnessMessage = LiveFrame | LiveEvent;
+export type HarnessMessage = LiveFrame | VisualFrame | LiveEvent;

package/dist/packages/agent-harness-core/src/protocol.js

@@ -1,2 +1,17 @@
 export const PROTOCOL_VERSION = "0.4.0";
+/**
+ * Text-attribute bit flags in {@link VisualSpan.attrs}. Mirrors the low byte of
+ * OpenTUI's `TextAttributes` (`ATTRIBUTE_BASE_MASK = 255`), so a consumer can
+ * decode `attrs & VisualAttr.BOLD` etc. without importing the renderer.
+ */
+export const VisualAttr = {
+    BOLD: 1,
+    DIM: 2,
+    ITALIC: 4,
+    UNDERLINE: 8,
+    BLINK: 16,
+    INVERSE: 32,
+    HIDDEN: 64,
+    STRIKETHROUGH: 128,
+};
 //# sourceMappingURL=protocol.js.map

package/dist/packages/agent-harness-core/src/visual-quality.d.ts

@@ -0,0 +1,58 @@
+/**
+ * visual-quality.ts — programmatic visual-quality heuristics over a VisualFrame.
+ *
+ * P1 of Harness TUI v2. Given the ground-truth rendered cell grid, compute cheap
+ * ground-truth signals a human would call "messy" — WITHOUT a vision model:
+ *   - blank / near-blank row ratios (the council "↳" + "· Skip" garbage)
+ *   - long runs of consecutive blank rows (dead space)
+ *   - whitespace density
+ *   - mojibake (U+FFFD replacement chars + misdecoded-UTF8 clusters like `💡`)
+ *
+ * These are the exact defects the semantic tree (LiveFrame) is blind to — the
+ * 2217600e1f27 export had 12 near-empty rows + mojibake that no existing
+ * self-verify check could see. A composite `score` + `issues[]` lets self-QA
+ * fail a render regression automatically.
+ *
+ * Thresholds are conservative defaults; tune per surface. This is a heuristic,
+ * not a proof — a low score flags "look closer", it does not assert a bug.
+ */
+import type { VisualFrame } from "./protocol.js";
+export interface VisualQualityThresholds {
+    /** Rows with <= this many non-space chars count as "near-empty". */
+    nearEmptyMaxChars: number;
+    /** Flag when the near-empty-row ratio exceeds this. */
+    nearEmptyRowPct: number;
+    /** Flag when consecutive blank rows exceed this run length. */
+    maxConsecutiveBlankRows: number;
+    /** Flag when any mojibake is detected at/above this count. */
+    mojibakeCount: number;
+    /** Flag when whitespace density exceeds this fraction. */
+    whitespacePct: number;
+}
+export declare const DEFAULT_VISUAL_QUALITY_THRESHOLDS: VisualQualityThresholds;
+export interface VisualQualityReport {
+    rows: number;
+    cols: number;
+    /** Non-space characters across the whole grid. */
+    contentChars: number;
+    /** Rows that are entirely whitespace. */
+    blankRows: number;
+    /** Rows with 1..nearEmptyMaxChars non-space chars (skeleton noise). */
+    nearEmptyRows: number;
+    nearEmptyRowPct: number;
+    /** Longest run of consecutive fully-blank rows. */
+    maxConsecutiveBlankRows: number;
+    whitespacePct: number;
+    /** Count of mojibake signals (U+FFFD + misdecoded-UTF8 clusters). */
+    mojibakeCount: number;
+    /** Sample of offending text fragments (for diagnostics). */
+    mojibakeSamples: string[];
+    /** 0-100 composite; lower = messier. */
+    score: number;
+    /** Human-readable problems that tripped a threshold. */
+    issues: string[];
+}
+/**
+ * Compute visual-quality signals for a rendered frame. Pure + deterministic.
+ */
+export declare function computeVisualQuality(frame: VisualFrame, thresholds?: VisualQualityThresholds): VisualQualityReport;

package/dist/packages/agent-harness-core/src/visual-quality.js

@@ -0,0 +1,141 @@
+/**
+ * visual-quality.ts — programmatic visual-quality heuristics over a VisualFrame.
+ *
+ * P1 of Harness TUI v2. Given the ground-truth rendered cell grid, compute cheap
+ * ground-truth signals a human would call "messy" — WITHOUT a vision model:
+ *   - blank / near-blank row ratios (the council "↳" + "· Skip" garbage)
+ *   - long runs of consecutive blank rows (dead space)
+ *   - whitespace density
+ *   - mojibake (U+FFFD replacement chars + misdecoded-UTF8 clusters like `💡`)
+ *
+ * These are the exact defects the semantic tree (LiveFrame) is blind to — the
+ * 2217600e1f27 export had 12 near-empty rows + mojibake that no existing
+ * self-verify check could see. A composite `score` + `issues[]` lets self-QA
+ * fail a render regression automatically.
+ *
+ * Thresholds are conservative defaults; tune per surface. This is a heuristic,
+ * not a proof — a low score flags "look closer", it does not assert a bug.
+ */
+export const DEFAULT_VISUAL_QUALITY_THRESHOLDS = {
+    nearEmptyMaxChars: 2,
+    nearEmptyRowPct: 0.5,
+    maxConsecutiveBlankRows: 4,
+    mojibakeCount: 1,
+    whitespacePct: 0.92,
+};
+// Characters that legitimately never (or almost never) appear in this TUI but
+// are produced when UTF-8 bytes are re-decoded as CP437/latin1. Presence in a
+// 2+ cluster is a strong mojibake signal (e.g. 💡 → "≡ƒÆí", em-dash → "ΓÇô").
+const MOJIBAKE_SIGNAL = new Set([
+    ..."≡ƒÆÇÃÂ’ÿÖÜúÑŒ¬".split(""),
+    "�", // replacement char
+]);
+function rowText(line) {
+    return line.spans.map((s) => s.text).join("");
+}
+function countMojibake(text) {
+    let count = 0;
+    let sample;
+    // Definitive: U+FFFD replacement chars.
+    for (const ch of text) {
+        if (ch === "�")
+            count++;
+    }
+    // Clusters of 2+ consecutive signal chars — mojibake arrives in runs, which
+    // keeps ordinary accented text (single é, ü) from tripping the heuristic.
+    const chars = [...text];
+    let run = 0;
+    for (let i = 0; i <= chars.length; i++) {
+        const isSignal = i < chars.length && MOJIBAKE_SIGNAL.has(chars[i]) && chars[i] !== "�";
+        if (isSignal) {
+            run++;
+        }
+        else {
+            if (run >= 2) {
+                count += run;
+                if (!sample)
+                    sample = chars.slice(Math.max(0, i - run - 4), i + 2).join("");
+            }
+            run = 0;
+        }
+    }
+    return { count, sample };
+}
+/**
+ * Compute visual-quality signals for a rendered frame. Pure + deterministic.
+ */
+export function computeVisualQuality(frame, thresholds = DEFAULT_VISUAL_QUALITY_THRESHOLDS) {
+    const rows = frame.lines.length;
+    const cols = frame.cols;
+    let contentChars = 0;
+    let totalCells = 0;
+    let blankRows = 0;
+    let nearEmptyRows = 0;
+    let maxConsecutiveBlankRows = 0;
+    let curBlankRun = 0;
+    let mojibakeCount = 0;
+    const mojibakeSamples = [];
+    for (const line of frame.lines) {
+        const text = rowText(line);
+        const nonSpace = [...text].filter((c) => c.trim().length > 0).length;
+        contentChars += nonSpace;
+        totalCells += Math.max(text.length, cols);
+        if (nonSpace === 0) {
+            blankRows++;
+            curBlankRun++;
+            maxConsecutiveBlankRows = Math.max(maxConsecutiveBlankRows, curBlankRun);
+        }
+        else {
+            curBlankRun = 0;
+        }
+        // "Low-content" rows = blank OR only a glyph or two (skeleton noise like the
+        // council "↳" / "· Skip" rows, and the blank separators between them). Both
+        // are visual garbage, so they count together against the total row budget.
+        if (nonSpace <= thresholds.nearEmptyMaxChars)
+            nearEmptyRows++;
+        const mj = countMojibake(text);
+        if (mj.count > 0) {
+            mojibakeCount += mj.count;
+            if (mj.sample && mojibakeSamples.length < 5)
+                mojibakeSamples.push(mj.sample);
+        }
+    }
+    // Ratio of low-content (blank or near-empty) rows over the whole frame.
+    const nearEmptyRowPct = rows > 0 ? nearEmptyRows / rows : 0;
+    const whitespacePct = totalCells > 0 ? 1 - contentChars / totalCells : 1;
+    const issues = [];
+    if (nearEmptyRowPct > thresholds.nearEmptyRowPct) {
+        issues.push(`${nearEmptyRows}/${rows} rows are blank or near-empty (<=${thresholds.nearEmptyMaxChars} chars) — skeleton/garbage rows`);
+    }
+    if (maxConsecutiveBlankRows > thresholds.maxConsecutiveBlankRows) {
+        issues.push(`${maxConsecutiveBlankRows} consecutive blank rows — large dead gap`);
+    }
+    if (mojibakeCount >= thresholds.mojibakeCount) {
+        issues.push(`${mojibakeCount} mojibake signal(s) detected (misdecoded UTF-8 / U+FFFD)${mojibakeSamples.length ? ` e.g. ${JSON.stringify(mojibakeSamples[0])}` : ""}`);
+    }
+    if (whitespacePct > thresholds.whitespacePct && contentChars > 0) {
+        issues.push(`${(whitespacePct * 100).toFixed(0)}% of the grid is whitespace — very sparse render`);
+    }
+    // Composite score: start at 100, subtract weighted penalties.
+    let score = 100;
+    score -= Math.min(40, Math.round(nearEmptyRowPct * 60));
+    score -= Math.min(25, Math.max(0, maxConsecutiveBlankRows - thresholds.maxConsecutiveBlankRows) * 4);
+    score -= Math.min(30, mojibakeCount * 6);
+    score -= whitespacePct > thresholds.whitespacePct ? 10 : 0;
+    score = Math.max(0, Math.min(100, score));
+    return {
+        rows,
+        cols,
+        contentChars,
+        blankRows,
+        nearEmptyRows,
+        nearEmptyRowPct,
+        maxConsecutiveBlankRows,
+        whitespacePct,
+        mojibakeCount,
+        mojibakeSamples,
+        score,
+        issues,
+    };
+}
+//# sourceMappingURL=visual-quality.js.map

package/dist/packages/agent-harness-opentui/src/agent-mode.d.ts

@@ -17,6 +17,7 @@
  */
 import type { LiveEvent } from "@muonroi/agent-harness-core/protocol";
 import type { SemanticRegistry } from "./reconciler-hook.js";
+import { type RendererLike } from "./visual-capture.js";
 export type AgentModeOptions = {
     cols: number;
     rows: number;
@@ -40,6 +41,11 @@ export type AgentModeRuntime = {
     onCommand: (h: (cmd: unknown) => void) => void;
     /** Get the current timestamp (real or fake clock). */
     now: () => number;
+    /**
+     * Attach the OpenTUI renderer once it exists (constructed AFTER this runtime
+     * — see src/index.ts). Enables VisualFrame capture of the real cell grid.
+     */
+    attachRenderer: (renderer: RendererLike) => void;
     /** Tear down: close streams, dispose idle detector. */
     dispose: () => void;
 };

package/dist/packages/agent-harness-opentui/src/agent-mode.js

@@ -22,6 +22,7 @@ import { createIdleDetector } from "@muonroi/agent-harness-core/idle";
 import { createLineSplitter, createSidechannelWriter } from "@muonroi/agent-harness-core/transports/sidechannel";
 import { installOpenTUIHarness } from "./install.js";
 import { createSemanticRegistry } from "./reconciler-hook.js";
+import { createVisualCaptureHook } from "./visual-capture.js";
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
@@ -90,6 +91,11 @@ export async function startAgentMode(opts) {
     const now = () => (opts.fakeClock ? 0 : Date.now());
     // --- Semantic registry ---------------------------------------------------
     const registry = createSemanticRegistry();
+    // --- Visual capture (real rendered cell grid) ----------------------------
+    // The renderer does not exist yet — it is constructed after this runtime and
+    // handed back via attachRenderer(). The hook reads it late-bound.
+    let rendererRef;
+    const visualHook = createVisualCaptureHook(() => rendererRef);
     // --- Idle detector -------------------------------------------------------
     const idle = createIdleDetector({
         quiescenceMs: opts.idleMs,
@@ -116,6 +122,9 @@ export async function startAgentMode(opts) {
         // becomes deterministic (seq*16). Without this, ts = Date.now() and the
         // determinism spec sees timestamps differ between runs.
         fakeClock: opts.fakeClock,
+        // Emit a VisualFrame (real rendered cell grid) alongside each semantic
+        // change. No-op until attachRenderer() supplies the renderer.
+        captureVisual: (seq, ts) => visualHook.capture(seq, ts),
     });
     // --- Command channel (in stream → handlers) ------------------------------
     const commandHandlers = [];
@@ -165,6 +174,10 @@ export async function startAgentMode(opts) {
     const onCommand = (h) => {
         commandHandlers.push(h);
     };
+    const attachRenderer = (renderer) => {
+        rendererRef = renderer;
+        visualHook.resetDedup(); // force the first visual frame after attach
+    };
     const dispose = () => {
         harnessHandle.uninstall(); // stops poll interval; transport.close() ends outStream
         idle.dispose();
@@ -173,6 +186,6 @@ export async function startAgentMode(opts) {
             inStream.destroy();
         }
     };
-    return { registry, capture, emitEvent, onCommand, now, dispose };
+    return { registry, capture, emitEvent, onCommand, now, attachRenderer, dispose };
 }
 //# sourceMappingURL=agent-mode.js.map

package/dist/packages/agent-harness-opentui/src/input-bridge.d.ts

@@ -13,15 +13,7 @@
  * raw byte. We construct ParsedKey directly so we don't depend on terminal
  * escape sequence conventions.
  */
+import type { KeyEvent } from "@opentui/core";
 import type { AgentModeRuntime } from "./agent-mode.js";
-/**
- * Subscribe to agentRuntime.onCommand and inject synthetic key events into
- * OpenTUI's keyHandler. Safe no-op when agentRuntime is undefined (normal user
- * mode).
- *
- * Special key `__focus__:<id>` is intentionally NOT translated to OpenTUI input
- * here — it is a driver-level signal currently ignored at this layer. (Focus
- * routing in OpenTUI is owned by individual components; a global focus dispatch
- * is out of scope for this bridge.)
- */
+export declare function keyForNamed(key: string): KeyEvent | null;
 export declare function useAgentInputBridge(agentRuntime: AgentModeRuntime | undefined): void;