@xenosystem/agent-interface-host 0.1.3

package/dist/session/AgentSessionService.js

@@ -0,0 +1,444 @@
+/**
+ * The session substrate — ADE spec §2.8, build-order step 0.
+ *
+ * > "The terminal belongs to us, not to the agent. We do not attach to an
+ * >  agent's terminal; we *give* every session a terminal and own both ends of
+ * >  it. That part is unconditional — every session has a PTY, and input
+ * >  routing, attach and takeover work identically regardless of what is running
+ * >  inside."
+ *
+ * §9 calls this "not a step so much as the floor the others stand on", and it is
+ * the floor §5.5's attach and takeover were found to be waiting on: §4.6's two
+ * process worlds — an agent spawned as a stdio JSON-RPC child with no terminal,
+ * and a PTY belonging to the user — meet here or nowhere.
+ *
+ * ## One session, TWO channels — measured, not assumed
+ *
+ * A PTY is **not** a byte-transparent pipe. Measured 2026-08-13 against real
+ * `node-pty` on Windows/ConPTY (`scripts/probe-pty-framing.mjs`): a
+ * `Content-Length` header survives, and the `\r\n\r\n` that separates it from
+ * the body is **re-rendered as a cursor-position escape**. A framed reader never
+ * finds the separator, so it never begins counting. `\n` is rewritten to `\r\n`
+ * as well.
+ *
+ * That is not a bug to harden around — a terminal's job is to render a screen,
+ * so it is free to express the same visual result as different bytes, which is
+ * exactly what breaks a byte-counted protocol.
+ *
+ * So a session owns a PTY **and**, when the agent speaks a protocol, a separate
+ * channel for framed messages. The two are distinct types here with no
+ * conversion between them, so "just send the JSON-RPC through the terminal"
+ * cannot be written by accident.
+ *
+ * ## What renders is a MODE, and the modes are exclusive
+ *
+ * §2.8: *"The two modes are not simultaneous for one process: a CLI in
+ * interactive TUI mode is not also serving ACP."* That is enforced at open time
+ * rather than documented: a `native-tui` session with a protocol channel is a
+ * contradiction, and an `acp` session without one has nothing to render.
+ */
+import { agentMayWrite, deliveryFor, humanReleasesWriteLease, humanTakesWriteLease, openWriteLease, routeHumanInput, selectSessionRenderMode, } from '@xenosystem/agent-interface-core';
+/**
+ * How much terminal output a session retains.
+ *
+ * Bounded because a session can run for hours and a build can print megabytes,
+ * and an unbounded buffer per session turns a long-lived host into a memory
+ * leak that only shows up on the busiest run. 256 KiB is roughly a few thousand
+ * lines — enough to see what an agent just did, which is what attach is for.
+ */
+const MAX_SESSION_OUTPUT = 256 * 1024;
+/**
+ * The neutral rendering: one compact line per message.
+ *
+ * Deliberately dull. A substrate that formatted an agent's stream prettily would
+ * be making product decisions on behalf of every surface, and a surface that
+ * wants better passes `renderProtocolMessage`. What it must NOT do is show
+ * nothing, which is what it did before.
+ */
+function defaultProtocolRender(message) {
+    if (typeof message === 'string')
+        return `${message}\r\n`;
+    try {
+        return `${JSON.stringify(message)}\r\n`;
+    }
+    catch {
+        // Circular or otherwise unserialisable. Saying so beats saying nothing.
+        return '[unrenderable protocol message]\r\n';
+    }
+}
+/** Keeps the TAIL: the newest output is the output a viewer wants. */
+function capOutput(value) {
+    return value.length <= MAX_SESSION_OUTPUT ? value : value.slice(value.length - MAX_SESSION_OUTPUT);
+}
+export class AgentSessionService {
+    #sessions = new Map();
+    #now;
+    /** Takeovers refused because another human held the lease. Kept so a surface
+     *  can explain why a keystroke did nothing, rather than dropping it silently. */
+    #refusals = [];
+    #emit;
+    #record;
+    constructor(options = {}) {
+        this.#now = options.now ?? Date.now;
+        this.#emit = options.emit ?? (() => { });
+        this.#record = options.record ?? (() => { });
+    }
+    /** Where interventions become a durable transcript entry. */
+    setInterventionSink(record) {
+        this.#record = record;
+    }
+    /** Takeovers refused because someone else was typing. */
+    refusals() {
+        return [...this.#refusals];
+    }
+    /** Mirrors the coordination and observation services — see either for why a
+     *  sink fixed at construction cannot be the host that owns the service. */
+    setEventSink(emit) {
+        this.#emit = emit;
+    }
+    /**
+     * Gives a run a session: a terminal always, a protocol channel when the mode
+     * needs one.
+     *
+     * Every refusal is NAMED. An unopenable session that reports success would
+     * hand a caller a terminal that renders nothing, which is the failure §7.1
+     * exists to prevent.
+     */
+    open(request) {
+        if (this.#sessions.has(request.sessionId)) {
+            return {
+                ok: false,
+                code: 'session_exists',
+                reason: 'a session with that id is already open',
+            };
+        }
+        const selection = selectSessionRenderMode(request.support, request.preference);
+        if (!selection.ok) {
+            return { ok: false, code: 'mode_unavailable', reason: selection.reason };
+        }
+        // §2.8's exclusivity, enforced rather than documented.
+        if (selection.mode === 'acp' && !request.protocol) {
+            return {
+                ok: false,
+                code: 'protocol_channel_required',
+                reason: 'an acp session renders the structured stream and has none to render',
+            };
+        }
+        if (selection.mode === 'native-tui' && request.protocol) {
+            return {
+                ok: false,
+                code: 'protocol_channel_forbidden',
+                reason: 'a CLI in interactive TUI mode is not also serving ACP; the two modes are not simultaneous for one process',
+            };
+        }
+        const record = {
+            sessionId: request.sessionId,
+            runId: request.runId,
+            mode: selection.mode,
+            switchable: selection.switchable,
+            hasProtocolChannel: Boolean(request.protocol),
+            openedAt: this.#now(),
+            viewers: [],
+            lease: openWriteLease(this.#now()),
+        };
+        const live = {
+            record,
+            pty: request.pty,
+            protocol: request.protocol,
+            support: request.support,
+            viewers: new Map(),
+            lease: record.lease,
+            output: '',
+            /**
+             * 🔴 Subscribed HERE, at open, not on first attach.
+             *
+             * A session outlives its viewers (see `detach`), and the whole point of a
+             * detached host is that a run keeps working with no window. If retention
+             * began at the first attach, the output produced while nobody was
+             * watching — which is precisely the output someone attaches in order to
+             * read — would be gone. Attaching would show an empty terminal for a
+             * session that had been busy for an hour.
+             */
+            unsubscribe: request.pty.onData((chunk) => {
+                live.output = capOutput(live.output + chunk);
+            }),
+        };
+        /**
+         * 🔴 The structured stream is RENDERED into the PTY.
+         *
+         * Without this the channel was stored and never read: `open` REQUIRED one
+         * for an `acp` session on the grounds that such a session "renders the
+         * structured stream", then subscribed to nothing. Every message the agent
+         * sent was dropped and the terminal stayed empty for the entire run — a
+         * pane indistinguishable, to the person looking at it, from a broken one.
+         *
+         * The channel was read only by `sendProtocol` and `close`, both OUTBOUND.
+         * `onMessage` — the half that carries what there is to show — had no
+         * subscriber anywhere in the repo.
+         */
+        if (request.protocol) {
+            const render = request.renderProtocolMessage ?? defaultProtocolRender;
+            const stopRendering = request.protocol.onMessage((message) => {
+                // Rendering must never take the session down. A message this renderer
+                // cannot handle is one line lost, not a dead terminal.
+                try {
+                    const text = render(message);
+                    /**
+                     * 🔴 Appended to the session's own output, NOT written to the PTY.
+                     *
+                     * `SessionPty.write` is the INPUT direction — bytes toward the process
+                     * — and this is the agent SPEAKING. The port has no "inject output"
+                     * method because a real terminal's output arrives through `onData`
+                     * from the process itself; there is no process here, so the rendered
+                     * text IS the session's output and belongs on the same path
+                     * retention already feeds.
+                     *
+                     * The first version called `pty.write(text)` and the rendered line
+                     * never reached a snapshot, so a viewer attaching mid-run saw an
+                     * empty terminal — the exact symptom this whole fix exists to remove.
+                     */
+                    if (text)
+                        live.output = capOutput(live.output + text);
+                }
+                catch {
+                    // Deliberately silent HERE and reported nowhere else, because there is
+                    // nowhere honest to report it to: the caller is the agent's own
+                    // stream, not a person. A malformed frame is the agent's problem.
+                }
+            });
+            const stopRetention = live.unsubscribe;
+            live.unsubscribe = () => {
+                stopRendering();
+                stopRetention();
+            };
+        }
+        this.#sessions.set(request.sessionId, live);
+        this.#emit({
+            type: 'session.opened',
+            sessionId: record.sessionId,
+            runId: record.runId,
+            mode: record.mode,
+        });
+        return { ok: true, session: { ...record, viewers: [], lease: { ...record.lease } } };
+    }
+    /**
+     * Adds a live view. §5.5: *"two surfaces can hold the same running session at
+     * once and both see it move"* — so this is plural by construction rather than
+     * a handoff, and it is NOT resume: joining a live session and replaying a
+     * stored one are different operations.
+     */
+    attach(sessionId, viewerId, onData) {
+        const session = this.#sessions.get(sessionId);
+        if (!session || session.viewers.has(viewerId))
+            return false;
+        session.viewers.set(viewerId, session.pty.onData(onData));
+        session.record.viewers = [...session.viewers.keys()];
+        this.#emit({
+            type: 'session.attached',
+            sessionId,
+            viewerId,
+            viewers: session.viewers.size,
+        });
+        return true;
+    }
+    detach(sessionId, viewerId) {
+        const session = this.#sessions.get(sessionId);
+        const unsubscribe = session?.viewers.get(viewerId);
+        if (!session || !unsubscribe)
+            return false;
+        unsubscribe();
+        session.viewers.delete(viewerId);
+        session.record.viewers = [...session.viewers.keys()];
+        this.#emit({
+            type: 'session.detached',
+            sessionId,
+            viewerId,
+            viewers: session.viewers.size,
+        });
+        // The session outlives its viewers. §3 of the coordination spec makes the
+        // same point about runs: a session no window is attached to is still live,
+        // because it lives in the host and not in a window.
+        return true;
+    }
+    /**
+     * Routes human input into a session.
+     *
+     * The disposition comes from `routeHumanInput` (§2.8), which has no `drop`
+     * case — typing never falls into a void. **Both dispositions write to the
+     * PTY**: steering is delivered by writing to the terminal we own, which the
+     * agent cannot distinguish from the user typing, and a queued instruction is
+     * still recorded as a human intervention.
+     */
+    /**
+     * Puts the human's keystrokes where the agent will actually see them.
+     *
+     * 🔴 ONE callee for both doors. `routeInput` and `takeOver` each wrote to
+     * the PTY unconditionally, and for an `acp` session that PTY has no process
+     * behind it — it is a render target for the structured stream. So the
+     * keystrokes went nowhere, which is precisely the void `InputRouting` has no
+     * value for. The type made dropping inexpressible and the delivery did it
+     * anyway.
+     *
+     * What this does NOT do is deliver an `acp` steer itself. That travels
+     * `turn.steer`, where acknowledgement, idempotency and the named refusal
+     * already live; a second path from inside the substrate would be the
+     * unacknowledged one §5.5 measured to be wrong. It reports the sink instead,
+     * so the caller knows whether delivery is still owed.
+     */
+    #deliver(session, data, routing) {
+        const delivery = deliveryFor(session.record.mode, routing);
+        // Nothing typed is nothing to deliver — and reporting `delivered: true` for
+        // an empty string would tell a caller the agent received something it never
+        // did. Takeover reaches here with no data at all: §5.5's first keystroke IS
+        // the takeover, so taking the lease without typing is an ordinary case.
+        if (!data)
+            return { ...delivery, delivered: false };
+        if (delivery.sink === 'pty')
+            session.pty.write(data);
+        return delivery;
+    }
+    routeInput(sessionId, viewerId, data, context) {
+        const session = this.#sessions.get(sessionId);
+        if (!session)
+            return { ok: false, code: 'no_such_session' };
+        /**
+         * 🔴 The lease governs THIS door too.
+         *
+         * `takeOver` already refuses a second human, on the grounds that
+         * interleaving two of them produces a command neither typed. This method
+         * writes to the same PTY, so leaving it ungated meant the rule held at one
+         * entrance and not the other — and the ungated one is the ordinary
+         * typing path, so it is the one a second surface would actually use.
+         *
+         * A free lease permits anyone: that is the normal case, one human at a
+         * terminal, and requiring a takeover to type would make every session
+         * start with a ceremony.
+         */
+        const holder = session.lease.holder;
+        if (holder.kind === 'human' && holder.viewerId !== viewerId) {
+            this.#refusals.push({ sessionId, viewerId, code: 'lease_held' });
+            return { ok: false, code: 'lease_held', holder: holder.viewerId };
+        }
+        const routing = routeHumanInput(context);
+        const delivery = this.#deliver(session, data, routing);
+        this.#emit({ type: 'session.input', sessionId, disposition: routing.disposition });
+        return { ok: true, routing, delivery };
+    }
+    /**
+     * Recent terminal output for a session — the READ half of attach.
+     *
+     * A SNAPSHOT, deliberately, not a stream. The host protocol is
+     * request/response and its event feed is a broadcast to every connected
+     * client; PTY bytes must not go on it, because output is per-viewer and can
+     * be large. So a surface polls this, exactly as `workspace.pty.snapshot`
+     * already works in this repo — the mechanism is not new here, only its
+     * application to sessions.
+     *
+     * ⚠️ Returns what is RETAINED, which is bounded. `truncated` says when older
+     * output has already been dropped, so a surface can say "earlier output is
+     * gone" rather than presenting a terminal that appears to start mid-sentence
+     * for no reason.
+     */
+    snapshot(sessionId) {
+        const session = this.#sessions.get(sessionId);
+        if (!session)
+            return undefined;
+        return { output: session.output, truncated: session.output.length >= MAX_SESSION_OUTPUT };
+    }
+    /**
+     * A human types into the agent's terminal. **This is the takeover** — §5.5
+     * has no request-and-wait step, because the case it exists for is an agent
+     * going wrong now.
+     *
+     * The input is written to the PTY whether or not this call TOOK the lease,
+     * because a human who already holds it is simply still typing. What changes
+     * on the first keystroke is the arbitration state and the record.
+     */
+    takeOver(sessionId, viewerId, data) {
+        const session = this.#sessions.get(sessionId);
+        if (!session)
+            return undefined;
+        const transition = humanTakesWriteLease(session.lease, viewerId, this.#now());
+        if (!transition.ok) {
+            // Refused: another human is typing. Their keystrokes are NOT written —
+            // interleaving two humans produces a command neither of them typed, which
+            // is the corruption this whole model exists to prevent.
+            this.#refusals.push({ sessionId, viewerId, code: transition.code });
+            return undefined;
+        }
+        session.lease = transition.state;
+        session.record.lease = transition.state;
+        // 🔴 The SAME callee as `routeInput`. This used to write to the PTY
+        // directly, which meant the mode rule held at one entrance and not the
+        // other — and takeover is the entrance used when an agent is going wrong
+        // NOW, so it is the worse one to get silently wrong.
+        const delivery = this.#deliver(session, data, { disposition: 'steer', recordedAs: 'human-intervention' });
+        if (transition.agentYielded) {
+            this.#emit({
+                type: 'session.takeover',
+                sessionId,
+                viewerId,
+                interventions: transition.state.interventions,
+            });
+            // The durable half. §5.5's gate is "see the human intervention in the
+            // timeline", and the live feed carries counts rather than the typed text
+            // — the same split coordination makes between its feed and its record.
+            this.#record({ sessionId, viewerId, kind: 'takeover', at: transition.state.since, data });
+        }
+        return { lease: transition.state, delivery };
+    }
+    /** The human hands the session back. Only the holder may. */
+    releaseTakeOver(sessionId, viewerId) {
+        const session = this.#sessions.get(sessionId);
+        if (!session)
+            return false;
+        const transition = humanReleasesWriteLease(session.lease, viewerId, this.#now());
+        if (!transition.ok)
+            return false;
+        session.lease = transition.state;
+        session.record.lease = transition.state;
+        this.#emit({ type: 'session.released', sessionId, viewerId });
+        this.#record({ sessionId, viewerId, kind: 'released', at: transition.state.since });
+        return true;
+    }
+    /**
+     * Whether the host may inject agent-side input right now.
+     *
+     * ⚠️ INPUT only. Agent OUTPUT is never gated: the agent is a running process
+     * we cannot silence, and its output during a takeover is exactly the evidence
+     * a reviewer needs to see what the human interrupted.
+     */
+    agentMayWrite(sessionId) {
+        const session = this.#sessions.get(sessionId);
+        return session ? agentMayWrite(session.lease) : false;
+    }
+    session(sessionId) {
+        const record = this.#sessions.get(sessionId)?.record;
+        return record ? { ...record, viewers: [...record.viewers], lease: { ...record.lease } } : undefined;
+    }
+    sessions() {
+        return [...this.#sessions.values()]
+            .map((session) => ({
+            ...session.record,
+            viewers: [...session.record.viewers],
+            lease: { ...session.record.lease },
+        }))
+            .sort((left, right) => left.sessionId.localeCompare(right.sessionId));
+    }
+    close(sessionId) {
+        const session = this.#sessions.get(sessionId);
+        if (!session)
+            return false;
+        for (const unsubscribe of session.viewers.values())
+            unsubscribe();
+        // The retention listener too, or a closed session keeps a subscription on a
+        // PTY nobody owns and its buffer is never collected.
+        session.unsubscribe();
+        session.protocol?.close();
+        session.pty.close();
+        this.#sessions.delete(sessionId);
+        this.#emit({ type: 'session.closed', sessionId });
+        return true;
+    }
+}
+//# sourceMappingURL=AgentSessionService.js.map

package/dist/session/AgentSessionService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentSessionService.js","sourceRoot":"","sources":["../../src/session/AgentSessionService.ts"],"names":[],"mappings":"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"}

package/dist/session/bufferedSessionPty.d.ts

@@ -0,0 +1,27 @@
+import type { SessionPty } from './AgentSessionService.js';
+/**
+ * A terminal with no process behind it.
+ *
+ * An `acp` session's PTY is a RENDER TARGET, not a terminal: what appears in it
+ * is our rendering of the agent's structured stream, and the agent itself is
+ * driven over the protocol. So there is nothing to spawn, nothing to attach,
+ * and no native module involved — which is why this lives in the host rather
+ * than in the Electron composition, and why a session can be opened for a run
+ * without a tty existing anywhere.
+ *
+ * 🔴 `write` THROWS, and that is deliberate.
+ *
+ * The obvious implementation is a silent no-op, and it would recreate the exact
+ * defect this file exists downstream of: keystrokes disappearing into a PTY
+ * nobody reads. `AgentSessionService` already guarantees this is unreachable —
+ * its `#deliver` writes to a PTY only in `native-tui` mode, and a `native-tui`
+ * session is never given one of these. So being called means a mode rule has
+ * broken, and the useful behaviour then is to fail loudly at the surface rather
+ * than lose what someone typed.
+ *
+ * `resize` is accepted and ignored, which is not the same thing: a render
+ * target genuinely has no dimensions to change, and refusing a resize would
+ * make an ordinary window drag throw.
+ */
+export declare function createBufferedSessionPty(): SessionPty;
+//# sourceMappingURL=bufferedSessionPty.d.ts.map

package/dist/session/bufferedSessionPty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferedSessionPty.d.ts","sourceRoot":"","sources":["../../src/session/bufferedSessionPty.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,IAAI,UAAU,CAyBrD"}

package/dist/session/bufferedSessionPty.js

@@ -0,0 +1,49 @@
+/**
+ * A terminal with no process behind it.
+ *
+ * An `acp` session's PTY is a RENDER TARGET, not a terminal: what appears in it
+ * is our rendering of the agent's structured stream, and the agent itself is
+ * driven over the protocol. So there is nothing to spawn, nothing to attach,
+ * and no native module involved — which is why this lives in the host rather
+ * than in the Electron composition, and why a session can be opened for a run
+ * without a tty existing anywhere.
+ *
+ * 🔴 `write` THROWS, and that is deliberate.
+ *
+ * The obvious implementation is a silent no-op, and it would recreate the exact
+ * defect this file exists downstream of: keystrokes disappearing into a PTY
+ * nobody reads. `AgentSessionService` already guarantees this is unreachable —
+ * its `#deliver` writes to a PTY only in `native-tui` mode, and a `native-tui`
+ * session is never given one of these. So being called means a mode rule has
+ * broken, and the useful behaviour then is to fail loudly at the surface rather
+ * than lose what someone typed.
+ *
+ * `resize` is accepted and ignored, which is not the same thing: a render
+ * target genuinely has no dimensions to change, and refusing a resize would
+ * make an ordinary window drag throw.
+ */
+export function createBufferedSessionPty() {
+    const listeners = new Set();
+    let closed = false;
+    return {
+        write() {
+            throw new Error('This session renders a structured stream and has no process to write to. '
+                + 'Input for an acp session travels turn.steer; reaching here means a render-mode rule broke.');
+        },
+        resize() {
+            // No dimensions to change. Ignored rather than refused — a window drag
+            // must not throw.
+        },
+        onData(listener) {
+            if (closed)
+                return () => { };
+            listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+        close() {
+            closed = true;
+            listeners.clear();
+        },
+    };
+}
+//# sourceMappingURL=bufferedSessionPty.js.map

package/dist/session/bufferedSessionPty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferedSessionPty.js","sourceRoot":"","sources":["../../src/session/bufferedSessionPty.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,wBAAwB;IACtC,MAAM,SAAS,GAAG,IAAI,GAAG,EAA2B,CAAA;IACpD,IAAI,MAAM,GAAG,KAAK,CAAA;IAElB,OAAO;QACL,KAAK;YACH,MAAM,IAAI,KAAK,CACb,2EAA2E;kBACvE,4FAA4F,CACjG,CAAA;QACH,CAAC;QACD,MAAM;YACJ,uEAAuE;YACvE,kBAAkB;QACpB,CAAC;QACD,MAAM,CAAC,QAAQ;YACb,IAAI,MAAM;gBAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAA;YAC3B,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YACvB,OAAO,GAAG,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA,CAAC,CAAC,CAAA;QAC7C,CAAC;QACD,KAAK;YACH,MAAM,GAAG,IAAI,CAAA;YACb,SAAS,CAAC,KAAK,EAAE,CAAA;QACnB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/session/renderSupport.d.ts

@@ -0,0 +1,53 @@
+import type { AgentRuntimeProviderDescriptor } from '@xenosystem/agent-interface-contract';
+import type { AgentRenderSupport } from '@xenosystem/agent-interface-core';
+/**
+ * Whether the host can attach an agent's OWN interactive TUI to a PTY.
+ *
+ * 🔴 Always false, and that is a measurement rather than a placeholder.
+ *
+ * §2.8's `native-tui` mode runs the vendor's real interface — Claude Code's
+ * actual TUI, not a reproduction — and nothing in this repo spawns a vendor
+ * binary in interactive mode attached to a terminal. Every lane that exists
+ * today drives its agent headless: ACP over stdio, the SDK loop in-process,
+ * Cloud over HTTP. So there is no TUI to render, for any provider.
+ *
+ * Declaring it here rather than writing `false` inline is the point. When the
+ * PTY lane is built it replaces this function, and `renderSupportFor`'s tests
+ * already prove a `true` answer flows through — so the day it lands, the mode
+ * becomes available by construction instead of by someone remembering.
+ */
+export declare function noNativeTuiLane(): boolean;
+export interface RenderSupportOptions {
+    /**
+     * The registered turn adapters. Asked, not listed.
+     *
+     * 🔴 The alternative was a kind→support table, and it would have been wrong
+     * within a release. `cli-app-server` and `cli-remote` are declared provider
+     * kinds with NO adapter — a run on either cannot execute, so it emits no
+     * runtime events and there is nothing for a session to render. A table would
+     * have had to restate that, and would have kept saying it after someone built
+     * the adapter. Asking the adapters means the answer is derived from the same
+     * fact that decides whether the run happens at all.
+     */
+    adapters: readonly {
+        supports(provider: AgentRuntimeProviderDescriptor): boolean;
+    }[];
+    /** Injected so the PTY lane can turn the mode on without editing this file. */
+    nativeTuiLane?: (provider: AgentRuntimeProviderDescriptor) => boolean;
+}
+/**
+ * What a run on this provider can render into a terminal.
+ *
+ * The `acp` half is not "the provider speaks ACP" — it is "we can render this
+ * agent's structured stream", which is what §2.8's mode of that name means. The
+ * stream is the run's runtime events (see `createRuntimeEventSessionChannel`),
+ * and every lane that can execute produces them. So the question reduces to
+ * whether ANY adapter can run this provider, which is checkable rather than
+ * asserted.
+ *
+ * A provider no adapter supports gets `{ nativeTui: false, acp: false }`, and
+ * `selectSessionRenderMode` REFUSES it by name. That is the honest outcome: the
+ * alternative is a session that opens, renders nothing, and reports no error.
+ */
+export declare function renderSupportFor(provider: AgentRuntimeProviderDescriptor, options: RenderSupportOptions): AgentRenderSupport;
+//# sourceMappingURL=renderSupport.d.ts.map

package/dist/session/renderSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderSupport.d.ts","sourceRoot":"","sources":["../../src/session/renderSupport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,sCAAsC,CAAA;AAC1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAE1E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,8BAA8B,GAAG,OAAO,CAAA;KAAE,EAAE,CAAA;IACpF,+EAA+E;IAC/E,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,8BAA8B,KAAK,OAAO,CAAA;CACtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,8BAA8B,EACxC,OAAO,EAAE,oBAAoB,GAC5B,kBAAkB,CAMpB"}

package/dist/session/renderSupport.js

@@ -0,0 +1,41 @@
+/**
+ * Whether the host can attach an agent's OWN interactive TUI to a PTY.
+ *
+ * 🔴 Always false, and that is a measurement rather than a placeholder.
+ *
+ * §2.8's `native-tui` mode runs the vendor's real interface — Claude Code's
+ * actual TUI, not a reproduction — and nothing in this repo spawns a vendor
+ * binary in interactive mode attached to a terminal. Every lane that exists
+ * today drives its agent headless: ACP over stdio, the SDK loop in-process,
+ * Cloud over HTTP. So there is no TUI to render, for any provider.
+ *
+ * Declaring it here rather than writing `false` inline is the point. When the
+ * PTY lane is built it replaces this function, and `renderSupportFor`'s tests
+ * already prove a `true` answer flows through — so the day it lands, the mode
+ * becomes available by construction instead of by someone remembering.
+ */
+export function noNativeTuiLane() {
+    return false;
+}
+/**
+ * What a run on this provider can render into a terminal.
+ *
+ * The `acp` half is not "the provider speaks ACP" — it is "we can render this
+ * agent's structured stream", which is what §2.8's mode of that name means. The
+ * stream is the run's runtime events (see `createRuntimeEventSessionChannel`),
+ * and every lane that can execute produces them. So the question reduces to
+ * whether ANY adapter can run this provider, which is checkable rather than
+ * asserted.
+ *
+ * A provider no adapter supports gets `{ nativeTui: false, acp: false }`, and
+ * `selectSessionRenderMode` REFUSES it by name. That is the honest outcome: the
+ * alternative is a session that opens, renders nothing, and reports no error.
+ */
+export function renderSupportFor(provider, options) {
+    const nativeTuiLane = options.nativeTuiLane ?? noNativeTuiLane;
+    return {
+        nativeTui: nativeTuiLane(provider),
+        acp: options.adapters.some((adapter) => adapter.supports(provider)),
+    };
+}
+//# sourceMappingURL=renderSupport.js.map

package/dist/session/renderSupport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderSupport.js","sourceRoot":"","sources":["../../src/session/renderSupport.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO,KAAK,CAAA;AACd,CAAC;AAmBD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAC9B,QAAwC,EACxC,OAA6B;IAE7B,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,eAAe,CAAA;IAC9D,OAAO;QACL,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAC;QAClC,GAAG,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;KACpE,CAAA;AACH,CAAC"}