@deepseek-harness-tui/dsh-tui 0.5.0

package/lib/types/presets.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Agent-presets roster integration (issue #8): compose each session's
+ * model-facing world (tools, prompt sections, projections) from one preset
+ * directory instead of the host composition.
+ *
+ * Mirrors the official host's integration (dsh-host-apiproxy's
+ * `composeAgent`): the preset id is resolved BEFORE create/resume because the
+ * session boundary snapshots `meta` (the durable header's `agentPreset`)
+ * before asynchronous setup begins; the mount itself runs inside the agent
+ * factory's `setup(agentCtx)` hook, where a composition failure rolls the
+ * whole creation back instead of publishing a half-configured agent.
+ *
+ * A deployment without the roster (bare `dsh --config cordis.yml` boots,
+ * older CLI without the shipped preset root) composes nothing: callers get
+ * no `setup` and every session shares the host composition — the behavior
+ * before presets existed.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentSetup } from '@deepseek-ai/dsh-agent';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+/** One roster entry, as returned by `agentPresets.list()`/`resolve()`. */
+export interface AgentPresetInfo {
+    readonly id: string;
+    readonly trust: 'system' | 'user';
+    readonly name?: string;
+    readonly description?: string;
+    /** Present when the preset cannot compose a session (human-readable). */
+    readonly broken?: string;
+}
+/** The `ctx.agentPresets` service surface dsh-tui consumes. */
+export interface AgentPresetsLike {
+    readonly defaultId: string;
+    list(): Promise<readonly AgentPresetInfo[]>;
+    resolve(id?: string): Promise<AgentPresetInfo>;
+    mount(agentCtx: Context, id?: string): Promise<AgentPresetInfo>;
+    recompose(agentCtx: Context, id: string): Promise<AgentPresetInfo>;
+    /** Read one service from the agent's own scope chain (preset realms). */
+    serviceFor?(agent: {
+        ctx: Context;
+    }, key: string): unknown;
+}
+/**
+ * The mounted preset roster, or undefined when the composition has no
+ * `agent-presets` row (bare boots) — optional-service access via `ctx.get`.
+ */
+export declare function rosterOf(ctx: Context): AgentPresetsLike | undefined;
+/** The composition inputs for `agents.create`/`agents.resume`. */
+export interface PresetComposition {
+    /** Value for the durable header's `meta.agentPreset`; absent without a roster. */
+    readonly agentPreset?: string;
+    /** Factory setup hook mounting the preset onto the unpublished agent. */
+    readonly setup?: AgentSetup;
+}
+/**
+ * Resolve the preset one new/resumed session will run under and the setup
+ * that installs it. `requested` undefined adopts the roster default.
+ *
+ * Resolution failures (unknown/broken preset id, an empty roster that cannot
+ * supply even the default) degrade to the rosterless composition with a loud
+ * log line: a session that cannot start at all is worse than one running on
+ * the host composition.
+ *
+ * @param ctx - The plugin context (roster lookup + logging).
+ * @param requested - The preset id the caller wants, or undefined for the default.
+ * @returns The header value + setup hook, or an empty composition.
+ */
+export declare function composePreset(ctx: Context, requested?: string): Promise<PresetComposition>;
+/**
+ * The preset a PERSISTED session actually runs, read from its log: the last
+ * `agent-preset/selected` event wins over the creation header (a blank
+ * session may have switched). undefined when the log records none (sessions
+ * from before presets existed → the roster default applies at mount).
+ *
+ * @param ctx - The plugin context (persistence lookup).
+ * @param sessionId - The persisted session to inspect.
+ * @returns The running preset id, or undefined when unrecorded/unreadable.
+ */
+export declare function resolvePersistedPreset(ctx: Context, sessionId: SessionId): Promise<string | undefined>;
+/**
+ * The preset a LIVE session runs, resolved from its own log (last
+ * `agent-preset/selected` wins over the header). Used for fork-style creates
+ * (rewind/model switch) and for reading an already-live agent's composition.
+ *
+ * @param session - The live session (`header` + `events`).
+ * @returns The running preset id, or undefined when the log records none.
+ */
+export declare function runningPresetOf(session: {
+    header: {
+        agentPreset?: string;
+    };
+    events: readonly {
+        type: string;
+        data: unknown;
+    }[];
+}): string | undefined;
+/**
+ * Read a service the way a joined agent sees it: through the preset scope
+ * chain when a roster is mounted (preset realms hide e.g. `compaction` from
+ * the root context), falling back to the host context otherwise. Mirrors the
+ * official host's `agentPresets.serviceFor(agent, key) ?? ctx.get(key)`.
+ *
+ * @param ctx - The plugin context (roster + host fallback).
+ * @param agent - The live agent whose scope chain resolves first.
+ * @param key - The cordis service key.
+ * @returns The service instance, or undefined when neither layer provides it.
+ */
+export declare function serviceForAgent<T>(ctx: Context, agent: {
+    ctx: Context;
+}, key: string): T | undefined;
+//# sourceMappingURL=presets.d.ts.map

package/lib/types/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAGzD,0EAA0E;AAC1E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAA;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,IAAI,IAAI,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC,CAAA;IAC3C,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAC9C,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAC/D,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;IAClE,yEAAyE;IACzE,UAAU,CAAC,CAAC,KAAK,EAAE;QAAE,GAAG,EAAE,OAAO,CAAA;KAAE,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAC3D;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAEnE;AAED,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAA;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAmBhG;AAED;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAqB5G;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE;IACvC,MAAM,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAChC,MAAM,EAAE,SAAS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CACnD,GAAG,MAAM,GAAG,SAAS,CAErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAKpG"}

package/lib/types/presets.js

@@ -0,0 +1,114 @@
+/**
+ * Agent-presets roster integration (issue #8): compose each session's
+ * model-facing world (tools, prompt sections, projections) from one preset
+ * directory instead of the host composition.
+ *
+ * Mirrors the official host's integration (dsh-host-apiproxy's
+ * `composeAgent`): the preset id is resolved BEFORE create/resume because the
+ * session boundary snapshots `meta` (the durable header's `agentPreset`)
+ * before asynchronous setup begins; the mount itself runs inside the agent
+ * factory's `setup(agentCtx)` hook, where a composition failure rolls the
+ * whole creation back instead of publishing a half-configured agent.
+ *
+ * A deployment without the roster (bare `dsh --config cordis.yml` boots,
+ * older CLI without the shipped preset root) composes nothing: callers get
+ * no `setup` and every session shares the host composition — the behavior
+ * before presets existed.
+ */
+import { resolveSessionPreset } from '@deepseek-ai/dsh-agent-presets';
+/**
+ * The mounted preset roster, or undefined when the composition has no
+ * `agent-presets` row (bare boots) — optional-service access via `ctx.get`.
+ */
+export function rosterOf(ctx) {
+    return ctx.get('agentPresets');
+}
+/**
+ * Resolve the preset one new/resumed session will run under and the setup
+ * that installs it. `requested` undefined adopts the roster default.
+ *
+ * Resolution failures (unknown/broken preset id, an empty roster that cannot
+ * supply even the default) degrade to the rosterless composition with a loud
+ * log line: a session that cannot start at all is worse than one running on
+ * the host composition.
+ *
+ * @param ctx - The plugin context (roster lookup + logging).
+ * @param requested - The preset id the caller wants, or undefined for the default.
+ * @returns The header value + setup hook, or an empty composition.
+ */
+export async function composePreset(ctx, requested) {
+    const presets = rosterOf(ctx);
+    if (presets === undefined)
+        return {};
+    let resolvedId;
+    try {
+        resolvedId = (await presets.resolve(requested)).id;
+    }
+    catch (error) {
+        ctx.logger.warn(`dsh-tui: agent preset ${requested === undefined ? '(default)' : `"${requested}"`} unavailable ` +
+            `(${error instanceof Error ? error.message : String(error)}) — composing the session without a preset`);
+        return {};
+    }
+    return {
+        agentPreset: resolvedId,
+        setup: async (agentCtx) => {
+            await presets.mount(agentCtx, resolvedId);
+        },
+    };
+}
+/**
+ * The preset a PERSISTED session actually runs, read from its log: the last
+ * `agent-preset/selected` event wins over the creation header (a blank
+ * session may have switched). undefined when the log records none (sessions
+ * from before presets existed → the roster default applies at mount).
+ *
+ * @param ctx - The plugin context (persistence lookup).
+ * @param sessionId - The persisted session to inspect.
+ * @returns The running preset id, or undefined when unrecorded/unreadable.
+ */
+export async function resolvePersistedPreset(ctx, sessionId) {
+    const persistence = ctx.get('sessionPersistence');
+    if (persistence === undefined)
+        return undefined;
+    try {
+        const { meta, events } = await persistence.load(sessionId);
+        return resolveSessionPreset({
+            header: meta,
+            events,
+        });
+    }
+    catch {
+        // A missing/corrupt artifact leaves resume itself to report the failure;
+        // the preset lookup must not mask it with a second, misleading error.
+        return undefined;
+    }
+}
+/**
+ * The preset a LIVE session runs, resolved from its own log (last
+ * `agent-preset/selected` wins over the header). Used for fork-style creates
+ * (rewind/model switch) and for reading an already-live agent's composition.
+ *
+ * @param session - The live session (`header` + `events`).
+ * @returns The running preset id, or undefined when the log records none.
+ */
+export function runningPresetOf(session) {
+    return resolveSessionPreset(session);
+}
+/**
+ * Read a service the way a joined agent sees it: through the preset scope
+ * chain when a roster is mounted (preset realms hide e.g. `compaction` from
+ * the root context), falling back to the host context otherwise. Mirrors the
+ * official host's `agentPresets.serviceFor(agent, key) ?? ctx.get(key)`.
+ *
+ * @param ctx - The plugin context (roster + host fallback).
+ * @param agent - The live agent whose scope chain resolves first.
+ * @param key - The cordis service key.
+ * @returns The service instance, or undefined when neither layer provides it.
+ */
+export function serviceForAgent(ctx, agent, key) {
+    const presets = rosterOf(ctx);
+    const scoped = presets?.serviceFor?.(agent, key);
+    if (scoped !== undefined)
+        return scoped;
+    return ctx.get(key);
+}

package/lib/types/questions.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Ask-user-question store — the UI-side half of the DSH user-interaction
+ * seam (`ctx.userQuestions`). The harness's model-facing
+ * `ask_user_question` tool calls `UserQuestionService.ask()`, which
+ * forwards to the provider registered here; this store parks the request,
+ * surfaces one question at a time to the TUI (Claude Code style
+ * questionnaire), and settles the harness promise when the user answers,
+ * cancels, or the owning tool's abort signal fires.
+ *
+ * Queue semantics mirror the official dsh-tui chat/questions machine: asks
+ * arrive one at a time in practice (the tool blocks until answered), but
+ * concurrent asks from subagents are drained FIFO.
+ */
+import { type AskUserQuestionAnswer, type AskUserQuestionItem, type AskUserQuestionRequest } from '@deepseek-ai/dsh-user-questions';
+/** One answered question as the panel submits it: selected option labels
+ *  plus optional free-text (the dsh protocol's "Other" answer). */
+export interface QuestionSelection {
+    readonly selected: string[];
+    readonly custom?: string;
+}
+/** What the TUI renders while a question is pending. */
+export interface QuestionSnapshot {
+    /** Stable key so the panel remounts (fresh selection state) per question. */
+    readonly key: string;
+    readonly question: AskUserQuestionItem;
+    /** 1-based position within the batch. */
+    readonly position: number;
+    /** Total questions in the batch. */
+    readonly total: number;
+    /** Questions answered before the current one. */
+    readonly answered: number;
+}
+/** Completed batch summary, pushed into the transcript by the caller. */
+export interface QuestionSummary {
+    readonly title: string;
+    readonly lines: readonly string[];
+}
+/**
+ * Ask-user-question store: parks asks from the harness's user-interaction
+ * seam, surfaces one question at a time to the TUI, and settles each ask
+ * when the user answers or the batch is interrupted. The TUI subscribes for
+ * re-renders and answers via {@link QuestionStore.answerCurrent}.
+ */
+export declare class QuestionStore {
+    private readonly queue;
+    private active;
+    private readonly listeners;
+    private batchSeq;
+    /** Completed batch summaries, drained by the TUI into the transcript. */
+    private summaries;
+    /**
+     * Cached snapshot: useSyncExternalStore requires a stable reference while
+     * nothing changed (a fresh object per call would loop re-renders).
+     */
+    private snapshotCache;
+    /**
+     * Subscribe to store changes (useSyncExternalStore contract).
+     * @param listener - Called after every mutation that changes the snapshot.
+     * @returns An unsubscribe function removing the listener.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * The question the TUI should render now, or null when idle.
+     * @returns The cached snapshot; the reference is stable between mutations.
+     */
+    getSnapshot(): QuestionSnapshot | null;
+    /**
+     * Take (and clear) every completed batch summary for the transcript.
+     * @returns The summaries collected since the last take.
+     */
+    takeSummaries(): QuestionSummary[];
+    private emit;
+    /** Rebuild the cached snapshot after any mutation of active/index. */
+    private rebuildSnapshot;
+    /**
+     * Provider entry point — called by `ctx.userQuestions.ask()` when the
+     * model runs the `ask_user_question` tool.
+     * @param request - The ask request: questions plus optional abort signal.
+     * @returns A promise settling with the collected answers when the user
+     *   submits the batch, or rejecting when the ask is interrupted.
+     */
+    ask(request: AskUserQuestionRequest): Promise<AskUserQuestionAnswer>;
+    /** Advance to the next queued ask, if any. */
+    private startNext;
+    /**
+     * The user submitted an answer for the current question; advances the
+     * batch and settles it once every question is answered.
+     * @param selection - Selected option labels plus optional custom text.
+     */
+    answerCurrent(selection: QuestionSelection): void;
+    /** The user interrupted the questionnaire (Esc / Ctrl+C). */
+    cancelCurrent(): void;
+    /** Reject the active and all queued asks (plugin teardown). */
+    rejectAll(): void;
+    private fail;
+}
+//# sourceMappingURL=questions.d.ts.map

package/lib/types/questions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"questions.d.ts","sourceRoot":"","sources":["../../src/questions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAEL,KAAK,qBAAqB,EAE1B,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC5B,MAAM,iCAAiC,CAAA;AAExC;mEACmE;AACnE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACzB;AAgBD,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;IACtC,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,oCAAoC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC;AA0BD;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;IAC9C,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,QAAQ,CAAI;IACpB,yEAAyE;IACzE,OAAO,CAAC,SAAS,CAAwB;IACzC;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAgC;IAErD;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAO3C;;;OAGG;IACH,WAAW,IAAI,gBAAgB,GAAG,IAAI;IAItC;;;OAGG;IACH,aAAa,IAAI,eAAe,EAAE;IAMlC,OAAO,CAAC,IAAI;IAIZ,sEAAsE;IACtE,OAAO,CAAC,eAAe;IAgBvB;;;;;;OAMG;IACH,GAAG,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA6BpE,8CAA8C;IAC9C,OAAO,CAAC,SAAS;IAOjB;;;;OAIG;IACH,aAAa,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI;IAwBjD,6DAA6D;IAC7D,aAAa,IAAI,IAAI;IAUrB,+DAA+D;IAC/D,SAAS,IAAI,IAAI;IASjB,OAAO,CAAC,IAAI;CAMb"}

package/lib/types/questions.js

@@ -0,0 +1,201 @@
+/**
+ * Ask-user-question store — the UI-side half of the DSH user-interaction
+ * seam (`ctx.userQuestions`). The harness's model-facing
+ * `ask_user_question` tool calls `UserQuestionService.ask()`, which
+ * forwards to the provider registered here; this store parks the request,
+ * surfaces one question at a time to the TUI (Claude Code style
+ * questionnaire), and settles the harness promise when the user answers,
+ * cancels, or the owning tool's abort signal fires.
+ *
+ * Queue semantics mirror the official dsh-tui chat/questions machine: asks
+ * arrive one at a time in practice (the tool blocks until answered), but
+ * concurrent asks from subagents are drained FIFO.
+ */
+import { t } from './i18n.js';
+import { UserQuestionError, } from '@deepseek-ai/dsh-user-questions';
+const ASK_ABORTED = 'ASK_ABORTED';
+/** Truncate a long answer line for the transcript summary. */
+function clip(text, max = 140) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}…`;
+}
+function buildSummary(pending) {
+    const lines = pending.answers.map(answer => {
+        const question = pending.request.questions.find(q => q.id === answer.id);
+        const labels = answer.selected.join('、');
+        const text = answer.custom !== undefined && answer.custom !== ''
+            ? labels === '' ? answer.custom : `${labels}：${answer.custom}`
+            : labels;
+        return `· ${question?.question ?? answer.id} → ${clip(text)}`;
+    });
+    const total = pending.request.questions.length;
+    return {
+        title: t('questionnaire-answered', { total }),
+        lines,
+    };
+}
+/**
+ * Ask-user-question store: parks asks from the harness's user-interaction
+ * seam, surfaces one question at a time to the TUI, and settles each ask
+ * when the user answers or the batch is interrupted. The TUI subscribes for
+ * re-renders and answers via {@link QuestionStore.answerCurrent}.
+ */
+export class QuestionStore {
+    queue = [];
+    active;
+    listeners = new Set();
+    batchSeq = 0;
+    /** Completed batch summaries, drained by the TUI into the transcript. */
+    summaries = [];
+    /**
+     * Cached snapshot: useSyncExternalStore requires a stable reference while
+     * nothing changed (a fresh object per call would loop re-renders).
+     */
+    snapshotCache = null;
+    /**
+     * Subscribe to store changes (useSyncExternalStore contract).
+     * @param listener - Called after every mutation that changes the snapshot.
+     * @returns An unsubscribe function removing the listener.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * The question the TUI should render now, or null when idle.
+     * @returns The cached snapshot; the reference is stable between mutations.
+     */
+    getSnapshot() {
+        return this.snapshotCache;
+    }
+    /**
+     * Take (and clear) every completed batch summary for the transcript.
+     * @returns The summaries collected since the last take.
+     */
+    takeSummaries() {
+        const summaries = this.summaries;
+        this.summaries = [];
+        return summaries;
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener();
+    }
+    /** Rebuild the cached snapshot after any mutation of active/index. */
+    rebuildSnapshot() {
+        const pending = this.active;
+        if (pending === undefined) {
+            this.snapshotCache = null;
+            return;
+        }
+        const question = pending.request.questions[pending.index];
+        this.snapshotCache = question === undefined ? null : {
+            key: `${pending.batchId}-${pending.index}`,
+            question,
+            position: pending.index + 1,
+            total: pending.request.questions.length,
+            answered: pending.answers.length,
+        };
+    }
+    /**
+     * Provider entry point — called by `ctx.userQuestions.ask()` when the
+     * model runs the `ask_user_question` tool.
+     * @param request - The ask request: questions plus optional abort signal.
+     * @returns A promise settling with the collected answers when the user
+     *   submits the batch, or rejecting when the ask is interrupted.
+     */
+    ask(request) {
+        return new Promise((resolve, reject) => {
+            const pending = {
+                request,
+                batchId: ++this.batchSeq,
+                index: 0,
+                answers: [],
+                resolve,
+                reject,
+                onAbort: () => {
+                    if (this.active === pending) {
+                        this.active = undefined;
+                        this.rebuildSnapshot();
+                        this.fail(pending);
+                        this.startNext();
+                        this.emit();
+                        return;
+                    }
+                    const at = this.queue.indexOf(pending);
+                    if (at >= 0)
+                        this.queue.splice(at, 1);
+                    this.fail(pending);
+                },
+            };
+            request.signal?.addEventListener('abort', pending.onAbort, { once: true });
+            this.queue.push(pending);
+            this.startNext();
+        });
+    }
+    /** Advance to the next queued ask, if any. */
+    startNext() {
+        if (this.active !== undefined || this.queue.length === 0)
+            return;
+        this.active = this.queue.shift();
+        this.rebuildSnapshot();
+        this.emit();
+    }
+    /**
+     * The user submitted an answer for the current question; advances the
+     * batch and settles it once every question is answered.
+     * @param selection - Selected option labels plus optional custom text.
+     */
+    answerCurrent(selection) {
+        const pending = this.active;
+        const question = pending?.request.questions[pending.index];
+        if (pending === undefined || question === undefined)
+            return;
+        pending.answers.push({
+            id: question.id,
+            selected: [...selection.selected],
+            ...(selection.custom !== undefined && selection.custom !== ''
+                ? { custom: selection.custom }
+                : {}),
+        });
+        pending.index += 1;
+        if (pending.index >= pending.request.questions.length) {
+            // Batch complete: settle the harness promise, remember a transcript
+            // summary, and drain the next queued ask if any.
+            this.active = undefined;
+            pending.resolve({ answers: [...pending.answers] });
+            this.summaries.push(buildSummary(pending));
+            this.startNext();
+        }
+        this.rebuildSnapshot();
+        this.emit();
+    }
+    /** The user interrupted the questionnaire (Esc / Ctrl+C). */
+    cancelCurrent() {
+        const pending = this.active;
+        if (pending === undefined)
+            return;
+        this.active = undefined;
+        this.rebuildSnapshot();
+        this.fail(pending);
+        this.startNext();
+        this.emit();
+    }
+    /** Reject the active and all queued asks (plugin teardown). */
+    rejectAll() {
+        const active = this.active;
+        this.active = undefined;
+        this.rebuildSnapshot();
+        if (active !== undefined)
+            this.fail(active);
+        for (const pending of this.queue.splice(0))
+            this.fail(pending);
+        this.emit();
+    }
+    fail(pending) {
+        pending.reject(new UserQuestionError('ask_user_question was interrupted before the user answered', ASK_ABORTED));
+    }
+}

package/lib/types/screens/Chat.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { Channel } from '../channel.js';
+import type { QuestionStore } from '../questions.js';
+/**
+ * Main chat screen in the Claude Code layout: a scrollable transcript
+ * (with the current turn's prompt pinned above the viewport while scrolled
+ * up), transient notifications, the working spinner, the bordered prompt
+ * input (with slash-command overlay) and the status line pinned at the
+ * bottom.
+ *
+ * Ctrl+O toggles expanded detail globally; Shift+↑ enters message-selection
+ * mode (↑/↓ move, Enter expands the selected row, Esc exits); Ctrl+C
+ * interrupts the running turn, or (when idle) asks for a second Ctrl+C to
+ * exit; Enter while scrolled up jumps back to the bottom.
+ */
+export declare function Chat({ channel, questionStore, onExit, onUpdate, }: {
+    channel: Channel;
+    questionStore: QuestionStore;
+    onExit: () => void;
+    /** Update the installed package and restart the current TUI process. */
+    onUpdate?: () => void;
+}): React.JSX.Element;
+//# sourceMappingURL=Chat.d.ts.map

package/lib/types/screens/Chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../../src/screens/Chat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAMzB,OAAO,KAAK,EAAE,OAAO,EAAyB,MAAM,eAAe,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAqFpD;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,EACnB,OAAO,EACP,aAAa,EACb,MAAM,EACN,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,aAAa,EAAE,aAAa,CAAA;IAC5B,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,qBA0wCA"}