@xenosystem/blocks 0.6.0 → 0.8.0

package/dist/agent/index.d.ts

@@ -0,0 +1,568 @@
+import { PanelModule, PanelManifest } from '@xenosystem/block-sdk';
+import { a as XenoAgentEvent, b as XenoAgentTurnState, A as AgentViewState, X as XenoAgentSessionDelta, c as XenoAgentCatalog, d as XenoAgentConnection, e as AgentPanelState } from '../types-C5T3uVwd.js';
+export { f as XenoAgentAskEvent, g as XenoAgentAskWithdrawEvent, h as XenoAgentError, i as XenoAgentIntent, j as XenoAgentLane, k as XenoAgentMessageEvent, l as XenoAgentModel, m as XenoAgentPatchEvent, n as XenoAgentPatchFile, o as XenoAgentProvider, p as XenoAgentRole, q as XenoAgentSession, r as XenoAgentSessionClosedEvent, s as XenoAgentSessionEvent, t as XenoAgentStatus, u as XenoAgentTerminalEvent, v as XenoAgentToolEvent, w as XenoAgentTurnEvent, x as isBusy, y as isWaitingOnUser } from '../types-C5T3uVwd.js';
+import { ReactNode } from 'react';
+
+/**
+ * The translation: ONE agent session-event stream → the canonical panels that already render it.
+ *
+ * ## 🔴 This file is the reason the package exists
+ *
+ * `XENO AGENT PANEL - SPEC.md` §D3 is explicit: **no agent logic in the panel**, and the display
+ * work belongs to `runs`, `console`, `consent`, `diff` and `terminal`. What it does not say — and
+ * what building it made obvious — is that *something* has to turn one stream into five, and turn
+ * five answers back into one. That translation is the whole of the agent-specific work, it is
+ * framework-free, and it is the part every one of the four bespoke agent UIs wrote for itself.
+ *
+ * So this module is pure and testable in Node with no DOM, no React and no panel dependency: it
+ * takes events in and returns `{portId, value}` emissions out. Everything it emits is a shape one
+ * of the canonical panels already declares — see `WIRING.md` for the port-by-port map, and
+ * `test/wiring.test.ts` for the gate that checks the two agree against those panels' real
+ * manifests rather than against this comment.
+ *
+ * ## The correlation, and why dropping is the safe answer
+ *
+ * Every panel downstream answers in its own vocabulary and **none of them carries a session id**,
+ * because none of them knows sessions exist. This module holds the maps that put one back — and
+ * when a map misses, it **drops the answer and counts it** rather than attaching it to whatever
+ * session happens to be active. A consent decision routed to the wrong session applies a human's
+ * approval to work they never saw; there is no reading of "be helpful" that survives that.
+ *
+ * @module
+ */
+
+/**
+ * The output ports this module drives.
+ *
+ * ⚠️ These strings are also the manifest's output port ids and the `from` half of every wire in
+ * `WIRING.md`. They are declared once, here, and the manifest derives from them — a port id
+ * restated in three places is the three-place edit `xeno.core.runs` records as a real defect.
+ */
+declare const AGENT_FANOUT_PORTS: readonly ["runs", "records", "elicitations", "withdraw", "diffModel", "terminalData", "terminalSession"];
+/** One of the fan-out ports. */
+type AgentFanoutPort = (typeof AGENT_FANOUT_PORTS)[number];
+/** A value bound for one port. */
+interface AgentEmission {
+    portId: AgentFanoutPort;
+    value: unknown;
+}
+/** Map a turn or tool state onto the run panel's lifecycle vocabulary. */
+declare function turnStatusToRunStatus(state: XenoAgentTurnState): string;
+/** Construction options. */
+interface AgentProjectorOptions {
+    /** Injected so a test can assert timestamps instead of tolerating them. */
+    now?: () => number;
+}
+/**
+ * Turns agent events into panel deltas, and panel answers back into addressed intents.
+ *
+ * Stateful, and only as stateful as correlation requires: which turn belongs to which session,
+ * where a tool call sits in its run's step tree, which session asked a question, and which change
+ * set the diff panel is currently showing. **It holds no transcript, no run list and no log
+ * buffer** — those live in the panels that render them, which is the point of not reimplementing
+ * them here.
+ */
+declare class AgentProjector {
+    private readonly now;
+    /** turnId → sessionId. The address a run action comes back on. */
+    private readonly turnSession;
+    /** callId → the step path inside its run, so a nested call can be patched in place. */
+    private readonly callPath;
+    /** messageId → seen, so the second event for a message patches rather than re-appends. */
+    private readonly messages;
+    /** askId → sessionId. */
+    private readonly askSession;
+    /** terminalId → sessionId. */
+    private readonly terminalSession;
+    /**
+     * File path → the change set it belongs to.
+     *
+     * ⚠️ **Replaced wholesale on every `patch` event, because the diff panel's model is too.** The
+     * map and the thing it describes move together, so a decision can never address a change set the
+     * user is no longer looking at.
+     */
+    private patchPaths;
+    /**
+     * Answers that addressed nothing known, since the last clear.
+     *
+     * Surfaced rather than swallowed, for the reason `xeno.core.console` surfaces its dropped
+     * patches: a mis-wired return path and a dead one look identical from the outside, and this is
+     * the one number that tells them apart.
+     */
+    private dropped;
+    constructor(options?: AgentProjectorOptions);
+    /** How many answers were dropped for want of a correlation. */
+    get droppedAnswers(): number;
+    /** Forget everything. Used when the host replaces or clears the session index. */
+    reset(): void;
+    /** How many asks are still outstanding. */
+    get pendingAsks(): number;
+    /** Which session an ask belongs to, or `undefined`. */
+    sessionForAsk(askId: string): string | undefined;
+    /** Which session a turn belongs to, or `undefined`. */
+    sessionForTurn(turnId: string): string | undefined;
+    /** Which session a terminal belongs to, or `undefined`. */
+    sessionForTerminal(terminalId: string): string | undefined;
+    /** Which change set a reviewed file belongs to, or `undefined`. */
+    patchForPath(path: string): {
+        sessionId: string;
+        patchId: string;
+    } | undefined;
+    /** Record that an ask has been settled, so a second answer for it is dropped rather than resent. */
+    settleAsk(askId: string): void;
+    /** Count an answer that could not be correlated. */
+    dropAnswer(): void;
+    /**
+     * Project one event.
+     *
+     * @param event - The event.
+     * @returns Zero or more emissions, in the order they must be delivered. **Order matters**: a
+     *   console record must be appended before it is patched, and a step must be announced before it
+     *   is addressed — both panels drop an update for something they do not hold.
+     */
+    project(event: XenoAgentEvent): AgentEmission[];
+    /** One file of a change set → the diff panel's file shape. */
+    private projectFile;
+}
+
+/**
+ * The controller — framework-free. No React, no DOM.
+ *
+ * It owns three things and nothing else:
+ *
+ * 1. **The session index** — which conversations exist, which one is shown, what state its turn is
+ *    in. Small, and genuinely agent-specific.
+ * 2. **The composer** — the user's unsent text, and the single predicate that decides whether it
+ *    can be sent.
+ * 3. **The translation**, delegated to {@link AgentProjector}: events fan out to the canonical
+ *    panels, and their answers come back correlated to a session.
+ *
+ * 🔴 **It holds no transcript, no run list, no log buffer and no diff.** Those belong to
+ * `xeno.core.console`, `xeno.core.runs` and `xeno.core.diff`, which already ring-buffer, filter,
+ * virtualize and redact them. Keeping a second copy here would be the reimplementation the
+ * governing spec's §D3 forbids, and it would be the copy without the ring buffer.
+ *
+ * @module
+ */
+
+/** The host seam. Narrow on purpose: a test double is one function. */
+interface AgentHostBridge {
+    emit(portId: string, value: unknown): void;
+}
+/** Construction options. */
+interface AgentControllerOptions {
+    host: AgentHostBridge;
+    /** Injected so a test can assert timestamps rather than tolerate them. */
+    now?: () => number;
+}
+/** The panel controller. */
+declare class AgentController {
+    private readonly host;
+    private readonly projector;
+    private sessions;
+    private activeSessionId;
+    private connection;
+    private connectionMessage;
+    private catalog;
+    private draft;
+    /** Last delta revision applied. A delta whose rev has not advanced is dropped. */
+    private rev;
+    private readonly listeners;
+    /**
+     * Memoized view state.
+     *
+     * `useSyncExternalStore` compares by identity and loops forever if `getState` returns a fresh
+     * object each call. Every mutation clears this; nothing else may.
+     */
+    private snapshot;
+    constructor(options: AgentControllerOptions);
+    subscribe: (listener: () => void) => (() => void);
+    getState: () => AgentViewState;
+    private notify;
+    private fanOut;
+    /** Emit the one thing the host acts on. */
+    private intent;
+    /**
+     * Apply a session delta.
+     *
+     * The host is authoritative: sessions are upserted, never merged cleverly, and the panel keeps no
+     * "better" older value. A panel that second-guesses its host is a second source of truth.
+     *
+     * @param delta - The delta.
+     */
+    ingest(delta: XenoAgentSessionDelta): void;
+    private upsertSession;
+    private setTurnState;
+    /** Install the provider catalogue. The host decides what is selectable; the panel renders it. */
+    setCatalog(catalog: XenoAgentCatalog): void;
+    /**
+     * Report the connection out of band.
+     *
+     * Separate from the session delta so a host never has to express "not connected" as an empty
+     * session list — the distinction `xeno.core.runs` and `xeno.core.diff` both draw, and for the
+     * same reason: zero sessions means "there are none" only when someone looked.
+     */
+    setStatus(status: XenoAgentConnection, message?: string): void;
+    setDraft(text: string): void;
+    /**
+     * Would {@link submit} do anything?
+     *
+     * 🔴 The view's `disabled` derives from THIS, so an enabled button cannot be a button that
+     * refuses. The affordance and the guard are one predicate.
+     *
+     * ⚠️ `connection === 'idle'` does NOT block. Idle means *the host has never reported a
+     * connection state*, and inventing a blocker out of silence would make the panel unusable in
+     * every host that does not wire the optional `status` port. Silence is not a refusal; the host
+     * refuses if it must.
+     */
+    private canSubmit;
+    /**
+     * Ask the host to run the draft.
+     *
+     * 🔴 **The draft is NOT cleared here.** The panel does not know the turn started — the host may
+     * refuse, the provider may be unavailable, a permission check may reject it. Clearing on emit
+     * would show success before anything settled, which is a claim the panel cannot back; the draft
+     * clears when the host reports a `running` turn. (`panel-template`'s rule, applied to the one
+     * place in this catalog where a user would notice losing their text.)
+     *
+     * @returns Whether an intent was emitted.
+     */
+    submit(): boolean;
+    /**
+     * Ask the host to steer the running turn.
+     *
+     * ⚠️ **Steering lands at the agent's next decision point, not instantly.** That was measured
+     * against real Claude Code and recorded in the ADE spec, and it is why this is a separate verb
+     * from {@link submit} rather than "submit while busy": the two have different latencies and
+     * different failure modes, and a control that hid the difference would be lying about which one
+     * the user got.
+     *
+     * @returns Whether an intent was emitted.
+     */
+    steer(): boolean;
+    /** Ask the host to stop the running turn. */
+    cancel(): boolean;
+    /** Show another session. Panel-local AND an intent — the host may need to attach to it. */
+    selectSession(sessionId: string): boolean;
+    /** Ask the host to start a session. The panel does not create one — it has no way to. */
+    newSession(providerId?: string, modelId?: string): void;
+    /**
+     * Ask the host to switch the active session's agent.
+     *
+     * Refused for a provider the host declared unavailable: the panel must not offer what the host
+     * will not honour, which is the rule `xeno.core.consent` applies to durations.
+     *
+     * @returns Whether an intent was emitted.
+     */
+    selectProvider(providerId: string, modelId?: string): boolean;
+    /**
+     * A consent decision or an elicitation result, from `xeno.core.consent`.
+     *
+     * 🔴 **Dropped when the id correlates to nothing.** A decision routed to a guessed session
+     * applies a human's approval to work they never saw. Both of consent's output ports arrive here
+     * because both are answers to an ask this panel minted, and the panel forwards each verbatim —
+     * it does not read `decision`, and must not: interpreting an allow/deny would make this a second
+     * place where a grant is decided.
+     *
+     * @param answer - The decision or result, verbatim.
+     * @returns Whether an intent was emitted.
+     */
+    answer(answer: unknown): boolean;
+    /**
+     * A hunk decision, from `xeno.core.diff`.
+     *
+     * @param decision - `{path, hunkId, action, comment?}`, verbatim.
+     * @returns Whether an intent was emitted.
+     */
+    patchDecision(decision: unknown): boolean;
+    /**
+     * A run action, from `xeno.core.runs`.
+     *
+     * ⚠️ The targeted step is read from `stepPath`'s LAST element, falling back to `stepId`. Both are
+     * emitted together by that panel and mean the same thing at depth 1; only the path survives
+     * nesting, which is the case an agent's subagent calls produce.
+     *
+     * @param action - `{runId, action, stepId?, stepPath?}`, verbatim.
+     * @returns Whether an intent was emitted.
+     */
+    runAction(action: unknown): boolean;
+    /**
+     * A terminal intent, from `xeno.core.terminal`.
+     *
+     * @param intent - The terminal panel's intent, verbatim.
+     * @returns Whether an intent was emitted.
+     */
+    terminalIntent(intent: unknown): boolean;
+    /** Answers that could not be correlated, since the last reset. Surfaced, never swallowed. */
+    get droppedAnswers(): number;
+    /**
+     * Serialize.
+     *
+     * 🔴 **Preferences plus the unsent draft, and nothing else.** No transcript, no run list, no
+     * session content — that is host state which has moved on, and `.xapp` is a plain JSON file that
+     * may contain nothing sensitive.
+     */
+    serialize(): AgentPanelState;
+    /** Restore preferences. Sessions are NOT restored; the host re-pushes them. */
+    deserialize(state: unknown): void;
+    /** Release everything. */
+    dispose(): void;
+}
+
+/**
+ * The `PanelModule`.
+ *
+ * Every line marked 🔴 below exists because its absence was a shipped bug somewhere in this
+ * catalog: ten panels shipped unguarded input casts, sixteen read `host.config` once and never
+ * looked again, several leaked on dispose. `panel-template` carries the full account.
+ *
+ * @module
+ */
+
+/** Everything a renderer needs: the controller plus the resolved config. */
+interface AgentRenderContext {
+    controller: AgentController;
+    config: {
+        submitOnEnter: boolean;
+        showLane: boolean;
+        showSessions: boolean;
+        emptyHint: string;
+    };
+}
+/** Options for {@link createAgentPanel}. */
+interface CreateAgentPanelOptions {
+    /** Override the view. Rarely needed — mounting inside the package keeps React singular. */
+    render?: (root: HTMLElement, context: AgentRenderContext) => () => void;
+    /** Injected clock, so a host or a test can make timestamps deterministic. */
+    now?: () => number;
+}
+/**
+ * Build the panel module.
+ *
+ * @param options - Optional renderer override and clock.
+ * @returns The module.
+ */
+declare function createAgentPanel(options?: CreateAgentPanelOptions): PanelModule;
+/** The default module — view already wired. Register THIS, not the factory. */
+declare const agentPanel: PanelModule;
+
+/**
+ * The `xeno.core.agent` manifest.
+ *
+ * Capabilities: `storage.local` only. The panel runs nothing, spawns nothing, and grants nothing —
+ * it emits intents and the host executes them. That is the same boundary `xeno.core.terminal` draws
+ * for a PTY, and it is what lets this panel run unchanged in an `iframe-quickjs` sandbox: it was
+ * never anything but a host-brokered stream.
+ *
+ * ## The port set, and why it is this shape
+ *
+ * 🔴 **Seven of the outputs are the canonical panels' input shapes.** The panel does not render a
+ * tool timeline, a log, a permission queue, a diff or a terminal — five panels already do, better,
+ * with ring buffers and virtualization and redaction this one would have to reinvent. So the agent
+ * panel's job on that axis is to be a wire SOURCE, and `WIRING.md` is the map. A host that wires
+ * none of them still gets a working composer, session switcher and lane picker.
+ *
+ * @module
+ */
+
+/** The canonical manifest id. */
+declare const AGENT_PANEL_ID = "xeno.core.agent";
+/**
+ * The shape tag for the `session` input.
+ *
+ * Coined here, and it belongs in `WELL_KNOWN_PORT_SCHEMAS` alongside the rest — promoting it is a
+ * `@xenosystem/block-sdk` edit and therefore a coordinated cross-package change. ⚠️ The STRING must
+ * not change when it moves, or every wire built against it silently stops attaching.
+ */
+declare const AGENT_SESSION_SCHEMA = "xeno.agentsession@1";
+/** The shape tag for the `catalog` input. Same registration note as {@link AGENT_SESSION_SCHEMA}. */
+declare const AGENT_CATALOG_SCHEMA = "xeno.agentcatalog@1";
+/** The shape tag for the `intent` output. Same registration note. */
+declare const AGENT_INTENT_SCHEMA = "xeno.agentintent@1";
+/**
+ * `@xenosystem/panel-consent`'s elicitation tags, restated as literals.
+ *
+ * 🔴 **Not a copy of that panel's TYPES — a copy of its two tag STRINGS**, which is the one thing
+ * that must be byte-identical for a wire to attach at all. They are declared in that package (not
+ * in the SDK registry) and this package takes no dependency on it, so the literal is the only route
+ * available. `test/wiring.test.ts` reads consent's real manifest and asserts these still match, so
+ * a rename there fails here instead of silently detaching the wire.
+ */
+declare const CONSENT_ELICITATION_SCHEMA = "xeno.elicitation@1";
+/** See {@link CONSENT_ELICITATION_SCHEMA}. */
+declare const CONSENT_ELICITATION_RESULT_SCHEMA = "xeno.elicitationresult@1";
+/** The `xeno.core.agent` manifest. */
+declare const agentManifest: PanelManifest;
+
+/**
+ * The composition, **as data**.
+ *
+ * ## The decision this file records
+ *
+ * `panel-agent` is a THIN panel plus a declared wiring, not one panel that internally renders the
+ * other five. Four reasons, and the first is the one that settles it:
+ *
+ * 1. **The workbench docks panels; a panel that mounts panels takes that away.** A user must be
+ *    able to drag the log to the bottom, the diff to centre, and close the terminal. Nesting five
+ *    panes inside one pane makes the dock model — the entire reason `@xenosystem/workbench` exists
+ *    — unreachable for exactly the surface that needs it most.
+ * 2. **It would take five runtime dependencies**, which rule 8 forbids and which would impose the
+ *    xterm bundle on every host that mounts an agent panel and never opens a terminal.
+ * 3. **Every panel already owns its own config, `serialize`, state store and instance id.** A
+ *    nesting parent would have to re-implement the host's per-panel bookkeeping — badly, because
+ *    it cannot see the `.xapp`.
+ * 4. **The manifest would become the union of six panels' ports** and nobody could wire it.
+ *
+ * ⚠️ **The honest cost:** a host must place six panels and connect eleven wires rather than one
+ * panel and none. That cost is paid ONCE, in the ~40 lines of `INTEGRATION.md` §3, and it is why
+ * this file exists at all — the wiring is shipped as data so a host applies it rather than deriving
+ * it, and `test/wiring.test.ts` checks every wire against the target panels' REAL manifests. A
+ * wire this file gets wrong fails in CI here, not silently in a host.
+ *
+ * @module
+ */
+/** One end of a wire: a panel's manifest id and one of its port ids. */
+interface AgentWireEnd {
+    /** The panel's MANIFEST id. A host with several instances substitutes its own instance ids. */
+    panel: string;
+    port: string;
+}
+/** One connection a host should make. */
+interface AgentWire {
+    from: AgentWireEnd;
+    to: AgentWireEnd;
+    /** What breaks if this wire is missing. Rendered into `WIRING.md`; read it before skipping one. */
+    why: string;
+    /**
+     * The panel is optional and the agent surface still works without it.
+     *
+     * ⚠️ Only the two directions of ONE panel are ever optional together. Wiring an ask INTO consent
+     * without wiring its answer back leaves a user staring at a question whose Allow button does
+     * nothing — worse than never showing the question, because it looks like the agent ignored them.
+     */
+    optional: boolean;
+}
+/** The canonical manifest ids this wiring targets. */
+declare const AGENT_WIRING_TARGETS: {
+    readonly RUNS: "xeno.core.runs";
+    readonly CONSOLE: "xeno.core.console";
+    readonly CONSENT: "xeno.core.consent";
+    readonly DIFF: "xeno.core.diff";
+    readonly TERMINAL: "xeno.core.terminal";
+};
+/**
+ * Every wire between `xeno.core.agent` and the canonical panels.
+ *
+ * 🔴 **Both directions, always paired.** A one-way wiring is the failure mode this list is shaped
+ * to prevent: asks that cannot be answered, hunks that cannot be accepted, a terminal that renders
+ * output and swallows keystrokes.
+ */
+declare const AGENT_PANEL_WIRING: readonly AgentWire[];
+/**
+ * The wires a host must add to reach one panel, both directions.
+ *
+ * @param panelId - A manifest id from {@link AGENT_WIRING_TARGETS}.
+ * @returns Every wire touching it, in the order they should be created.
+ *
+ * @example
+ * ```ts
+ * for (const wire of wiringFor('xeno.core.consent')) connect(wire.from, wire.to)
+ * ```
+ */
+declare function wiringFor(panelId: string): AgentWire[];
+
+/**
+ * A unified-diff parser, because the adapter is where one belongs.
+ *
+ * ## Why this is here and not in `xeno.core.diff`
+ *
+ * The diff panel ships **no diff engine, by charter** — it renders `XenoDiffLine[]` that somebody
+ * else computed. The agent host on the other side emits raw unified-diff text. `XENO AGENT PANEL -
+ * SPEC.md` §D3 measured exactly that gap and gave the verdict: *"A parser must be written —
+ * adapter-side, not a panel edit."* This package is the adapter, so this is the adapter side.
+ *
+ * ## What it does NOT do
+ *
+ * It does not compute a diff. It reads one that already exists. There is no LCS here, no word-level
+ * segmentation, and no file access — a `+` line is an added line because the producer said so.
+ *
+ * ⚠️ **It also does not verify the diff against any file.** A hunk header claiming
+ * `@@ -41,3 +41,4 @@` is taken at its word; if the producer's arithmetic is wrong, the rendered
+ * line numbers are wrong in exactly the same way. Verifying would mean reading the user's files,
+ * which is a capability neither this package nor the diff panel has, and a syntactic check that
+ * happily passes a wrong-but-well-formed header would read like verification while proving nothing.
+ *
+ * @module
+ */
+/** What happened to a line. Mirrors `XenoDiffLineKind`. */
+type XenoDiffLineKind = 'context' | 'added' | 'removed';
+/** One rendered line. Mirrors `XenoDiffLine`. */
+interface XenoDiffLine {
+    kind: XenoDiffLineKind;
+    /** 1-based line number in the original. Absent on an added line. */
+    oldLineNumber?: number;
+    /** 1-based line number in the modified file. Absent on a removed line. */
+    newLineNumber?: number;
+    text: string;
+}
+/** A contiguous change region. Mirrors `XenoDiffHunk`. */
+interface XenoDiffHunk {
+    id: string;
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: XenoDiffLine[];
+    /** The raw `@@` header, kept verbatim — it is what the producer said, and it reads well. */
+    header?: string;
+}
+/**
+ * Parse one file's unified diff into hunks.
+ *
+ * @param path - The file's path. Part of every hunk id, so two files' hunks cannot collide.
+ * @param diff - Unified diff text for THIS file. File headers are tolerated and skipped.
+ * @returns The hunks, in order. **`[]` when the text contains no hunk header at all** — see the
+ *   caller's note: an empty result is reported as `omitted: 'unreadable'`, never as "no changes".
+ *
+ * @example
+ * ```ts
+ * parseUnifiedDiff('src/app.ts', '@@ -1,2 +1,2 @@\n-const a = 1\n+const a = 2\n context')
+ * // → [{ id: 'src/app.ts#…', oldStart: 1, oldLines: 2, newStart: 1, newLines: 2, lines: [...] }]
+ * ```
+ */
+declare function parseUnifiedDiff(path: string, diff: string): XenoDiffHunk[];
+/** How many lines a hunk adds and removes. Cheap, and the diff panel renders per-file counts. */
+declare function countChanges(hunks: readonly XenoDiffHunk[]): {
+    additions: number;
+    deletions: number;
+};
+
+/**
+ * The view — thin. Every decision lives in the controller.
+ *
+ * Composes `@xenosystem/workbench/primitives`, so it inherits `DESIGN_SYSTEM.md` for free. The host
+ * must load `@xenosystem/workbench/primitives.css`; without it this renders unstyled with no error.
+ *
+ * 🔴 **What is NOT here is the point.** No transcript, no tool timeline, no diff, no terminal — the
+ * canonical panels render those and this one wires to them (`WIRING.md`). What remains is the small
+ * amount of UI that is genuinely agent-specific: a composer, a lane and provider picker, and a
+ * session switcher.
+ *
+ * @module
+ */
+
+/** Props for {@link AgentPanelView}. */
+interface AgentPanelViewProps {
+    controller: AgentController;
+    /** Enter submits, Shift+Enter newlines. `false` swaps them. */
+    submitOnEnter?: boolean;
+    /** Render the lane badge. */
+    showLane?: boolean;
+    /** Render the session switcher. */
+    showSessions?: boolean;
+    emptyHint?: string;
+}
+/** The view. */
+declare function AgentPanelView({ controller, submitOnEnter, showLane, showSessions, emptyHint, }: AgentPanelViewProps): ReactNode;
+
+export { AGENT_CATALOG_SCHEMA, AGENT_FANOUT_PORTS, AGENT_INTENT_SCHEMA, AGENT_PANEL_ID, AGENT_PANEL_WIRING, AGENT_SESSION_SCHEMA, AGENT_WIRING_TARGETS, AgentController, type AgentControllerOptions, type AgentEmission, type AgentFanoutPort, type AgentHostBridge, AgentPanelState, AgentPanelView, type AgentPanelViewProps, AgentProjector, type AgentProjectorOptions, type AgentRenderContext, AgentViewState, type AgentWire, type AgentWireEnd, CONSENT_ELICITATION_RESULT_SCHEMA, CONSENT_ELICITATION_SCHEMA, type CreateAgentPanelOptions, XenoAgentCatalog, XenoAgentConnection, XenoAgentEvent, XenoAgentSessionDelta, XenoAgentTurnState, type XenoDiffHunk, type XenoDiffLine, type XenoDiffLineKind, agentManifest, agentPanel, countChanges, createAgentPanel, parseUnifiedDiff, turnStatusToRunStatus, wiringFor };