@genesislcap/ai-assistant 15.61.0 → 15.62.0

package/dist/dts/autopilot/autopilot-driver.d.ts

@@ -0,0 +1,278 @@
+import type { AIProviderRegistry, ChatAttachment, ChatDriverResult, ChatMessage } from '@genesislcap/foundation-ai';
+import type { AiDriver } from '../components/ai-driver/ai-driver';
+import { BaseDriverDecorator } from '../components/ai-driver/base-driver-decorator';
+import type { ContinueFromHistoryOptions } from '../components/chat-driver/chat-driver';
+import type { AgentConfig, AutopilotCopy } from '../config/config';
+import type { DiagnosticEntry } from '../state/persistence/diagnostics';
+import type { SendMessageOptions } from '../utils/delegated-message';
+/**
+ * The holder id the autopilot claims interactions as.
+ *
+ * @beta
+ */
+export declare const AUTOPILOT_CLAIMANT = "autopilot";
+/**
+ * The autopilot's mode for the current flow (GENC-1660 §4.10). `'unavailable'`: no autopilot for
+ * this flow, or not yet (e.g. no approved brief). `'paused'`: available but not answering.
+ * `'running'`: answering what its policy allows.
+ *
+ * @beta
+ */
+export type AutopilotMode = 'unavailable' | 'paused' | 'running';
+/**
+ * What the autopilot UI reads (GENC-1660 §4.10).
+ *
+ * @beta
+ */
+export interface AutopilotHostState {
+    readonly mode: AutopilotMode;
+    /**
+     * Set while paused. `'this-interaction'` is the autopilot's own hand-back: it resumes by itself
+     * once the person answers `interactionId`, and `reason` is the banner's text.
+     */
+    readonly pause?: {
+        readonly scope: 'until-resumed' | 'this-interaction';
+        readonly interactionId?: string;
+        readonly reason?: string;
+    };
+    /** The slim bar's one-line status. */
+    readonly status: string;
+    /** Whether something waits on the person: drives the "needs you" badge. */
+    readonly needsUser: boolean;
+    /**
+     * Whether something is happening: the working agent is busy, or the autopilot is deciding (a
+     * widget it holds, or a written question it is answering). The slim bar replaces the composer
+     * only while this is set; running but idle — stopped at a wall such as the budget, or at the end
+     * of a turn it had nothing to answer for — the host shows what the agent's own rules show. A host
+     * that hides the built-in composer keeps the slim bar regardless, as its only place for the pill.
+     */
+    readonly working: boolean;
+}
+/**
+ * The contract the autopilot UI is built against (GENC-1660 §4.10): the slim bar, its buttons, the
+ * banner's "Keep paused", and the badge. The host installs `AutopilotDriver` itself, so it reads it
+ * as this; nothing about it travels through `AiDriver`.
+ *
+ * @beta
+ */
+export interface AutopilotHost {
+    readonly state: AutopilotHostState;
+    subscribe(listener: () => void): () => void;
+    /** Pause until resumed. Hands a held interaction to the person on the spot. */
+    pause(): void;
+    /**
+     * Resume. Takes back an interaction that pausing handed over; during the autopilot's own
+     * hand-back it means "decide it yourself".
+     */
+    resume(): void;
+    /** The existing Stop, which also pauses, so what is shown stays honest. */
+    stop(): void;
+    /** The banner's "Keep paused": turn the autopilot's own hand-back into an ordinary pause. */
+    keepPaused(interactionId: string): void;
+    readonly copy: AutopilotCopy;
+}
+/**
+ * The autopilot's mode as saved with the session (GENC-1660 §4.8): which flow it was set for, and
+ * whether it was running. Cleared when that flow ends, so a saved mode never outlives its flow.
+ *
+ * @beta
+ */
+export interface PersistedAutopilotMode {
+    readonly onFor: string;
+    readonly mode: 'running' | 'paused';
+}
+/**
+ * What a working agent's tool handlers get as `context.capabilities.autopilot` (GENC-1660): the
+ * mode of their own flow, and a way to set it — e.g. after the user picks "Build it for me".
+ * Absent when the flow has no autopilot, so a handler feature-detects and does not offer the choice.
+ *
+ * @beta
+ */
+export interface AutopilotCapability {
+    readonly mode: AutopilotMode;
+    setMode(mode: 'paused' | 'running'): void;
+}
+declare module '@genesislcap/foundation-ai' {
+    interface ChatHandlerCapabilities {
+        autopilot: AutopilotCapability;
+    }
+}
+/**
+ * Options for {@link AutopilotDriver}.
+ *
+ * @beta
+ */
+export interface AutopilotDriverOptions {
+    /** The agents the host configured; an agent's `autopilot` key is what this driver runs. */
+    readonly agents: readonly AgentConfig[];
+    /** The registry the autopilot's own driver resolves its provider from. */
+    readonly providerRegistry: AIProviderRegistry;
+    /** The working session's debug-log key. */
+    readonly sessionKey?: string;
+}
+/**
+ * Autopilot (GENC-1660): a driver decorator that answers the questions a working agent asks the
+ * user, on their behalf, grounded in the agent's autopilot config (for bootstrap, the brief).
+ *
+ * Neither side calls the other. The working agent asks as it always does; this driver claims the
+ * interactions its policy allows, while it is running for that flow, and answers each in one short
+ * turn on the flow's `AutopilotSession`. It plugs in only through the generic extension points
+ * — an interaction interceptor, a handler capability and the flow lifecycle — so the core knows
+ * nothing about it, and it wraps any `AiDriver`.
+ *
+ * @beta
+ */
+export declare class AutopilotDriver extends BaseDriverDecorator implements AutopilotHost {
+    private readonly agents;
+    private readonly providerRegistry;
+    private readonly sessionKey;
+    private readonly listeners;
+    private readonly sessions;
+    /** The flow the mode applies to: set when it is first switched, cleared when that flow ends. */
+    private onFor;
+    private mode;
+    private pauseState?;
+    private held?;
+    /** Written answers given on the current step, for the refinement limit. */
+    private refinements?;
+    /** The watchdog's next check, while a claimed interaction is pending. */
+    private watchdog?;
+    /** What sessions that have ended did, kept for the debug log. */
+    private readonly endedDiagnostics;
+    /** Written answers sent in a row; see `MAX_CONSECUTIVE_REPLIES`. */
+    private consecutiveReplies;
+    /** Set while the turn-level hand-back waits on the person. */
+    private turnHandBack?;
+    /** A mode restored with the session, waiting for its flow to become the owner again. */
+    private restored?;
+    /**
+     * Bumped on every pause and resume, and when its sessions end. A written answer is sent only if
+     * none came between asking for it and its landing: one started before a pause is stale after it,
+     * even once resumed.
+     */
+    private generation;
+    /** Working turns this driver has started that have not ended yet; see `working`. */
+    private turnsInFlight;
+    /** Written questions being answered right now; see `working`. */
+    private answersInFlight;
+    constructor(inner: AiDriver, options: AutopilotDriverOptions);
+    get state(): AutopilotHostState;
+    get copy(): AutopilotCopy;
+    subscribe(listener: () => void): () => void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    /** The mode to save with the session, while it is set for the current flow. */
+    getPersistedMode(): PersistedAutopilotMode | undefined;
+    /**
+     * Bring back a saved mode. It applies once its flow is the owner again — at once if it already
+     * is, otherwise when the restored flow re-activates. Restoring starts nothing: the autopilot acts
+     * only on live events, such as the working agent's own resume asking a question (§4.10, S3).
+     */
+    restorePersistedMode(saved: PersistedAutopilotMode | undefined): void;
+    private adoptRestored;
+    keepPaused(interactionId: string): void;
+    sendMessage(input: string, attachments?: ChatAttachment[], options?: SendMessageOptions): Promise<ChatDriverResult>;
+    continueFromHistory(transientPrimer?: ChatMessage[], options?: ContinueFromHistoryOptions): Promise<ChatDriverResult>;
+    resumeRestoredFlow(resumeNote?: string, agent?: AgentConfig): Promise<ChatDriverResult | undefined>;
+    /**
+     * Run a working turn, counted for `working` from the moment it is asked for: the wrapped driver
+     * may not say it is busy until some way in. The caller notifies once it has acted on the end.
+     */
+    private whileWorking;
+    /**
+     * Act on how a working turn ended, without holding up whoever awaited it, then notify: idle
+     * unless that started something (an answer, a hand-back), which it does before this returns.
+     */
+    private afterTurn;
+    private onTurnEnded;
+    /** {@link AutopilotDriver.answer}, from a caller that does not wait for it. */
+    private answerInBackground;
+    /**
+     * Answer a written question the working agent ended its turn on, and send the answer on the
+     * user's behalf, with what writing it cost booked on that message (§4.2).
+     *
+     * Sent only if the question still stands when the answer lands: no pause or resume since it was
+     * asked (Pause stops it, and the question is the person's to answer by typing), the flow still
+     * running, the working agent idle, and the question still the last thing it said. Otherwise the
+     * answer goes nowhere — not sent, not counted, not recorded as acted — and its cost is recorded as
+     * dropped, as it is whenever no reply is sent to carry it.
+     */
+    private answer;
+    /**
+     * Spend on a written answer that no reply carries into the session total — it was handed back,
+     * stopped, or went stale — recorded so it is never lost silently.
+     */
+    private dropCost;
+    /** The working agent's last visible words, when its turn ended on them. */
+    private lastQuestion;
+    /**
+     * The turn-level hand-back (§4.10): a working turn ended needing the person and there is no
+     * widget to hand over, so the autopilot shows its own, `userOnly`, and acts on the choice.
+     */
+    private presentHandBack;
+    /**
+     * The inner driver's diagnostics, then everything the autopilot did (§4.8): diagnostics compose
+     * down the decorator stack, so they reach the downloaded and the persisted debug log through the
+     * host's existing external-diagnostics channel.
+     */
+    getExternalDiagnostics(): ReadonlyArray<DiagnosticEntry>;
+    /**
+     * Close every session, keeping what it did for the debug log. An answer one was still writing is
+     * stale from here: it is never sent, and its cost is recorded as dropped when it lands.
+     */
+    private endSessions;
+    dispose(): Promise<void>;
+    private onInteractionOpened;
+    /** Run one decision on the flow's session, and act on how it ended. */
+    private decide;
+    /** The step a decision belongs to, for the refinement limit (§4.4). */
+    private stepKey;
+    /** Whether a written answer is still allowed on this step. The count resets when the step changes. */
+    private mayRefine;
+    private countRefinement;
+    /** Written answers allowed per step: the config's when it is a whole number `>= 0`. */
+    private refinementLimit;
+    /**
+     * The watchdog (§4.2, critique S5): a claimed interaction whose work has gone quiet for longer
+     * than `watchdogMs` is handed back rather than left to hang silently. Quiet is either no surface
+     * ready to act on and no heartbeat, or the autopilot's own decision still running with no model
+     * call landing and no heartbeat — a stalled model call, which nothing else times out. It checks a
+     * few times per window, and stops when the interaction settles.
+     */
+    private armWatchdog;
+    private disarmWatchdog;
+    private onDecided;
+    /**
+     * The autopilot's self-pause, for one interaction (§4.10): the person gets it, with the reason as
+     * the banner, and the autopilot carries on by itself once they answer. Only while it is still
+     * the autopilot's to hand back — not settled, not already with the person — and its decision
+     * stops with it, so a decision still running spends nothing more on an interaction it no longer
+     * holds. Every caller (a decision's own hand-back, a failed decision, the watchdog) gets both.
+     */
+    private handBack;
+    /**
+     * On detach: hand a claimed interaction the autopilot still holds to the person, stopping its
+     * decision, so the driver it wrapped lives on with nothing held by an autopilot that is gone.
+     */
+    private releaseHeld;
+    /** A claimed interaction settled, whoever settled it. */
+    private onSettled;
+    private onFlowOwnerChanged;
+    private capabilityFor;
+    private flowOwner;
+    private bindingFor;
+    private isAvailable;
+    private copyFor;
+    private sessionFor;
+    private record;
+    private notify;
+}
+/**
+ * The autopilot a host installed, if `driver` is one (GENC-1660). The host installs it outermost,
+ * so this is the driver it holds; nothing about the autopilot travels through `AiDriver`.
+ *
+ * @internal
+ */
+export declare const autopilotOf: (driver: unknown) => AutopilotDriver | undefined;
+//# sourceMappingURL=autopilot-driver.d.ts.map

package/dist/dts/autopilot/autopilot-driver.d.ts.map

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

package/dist/dts/autopilot/autopilot-session.d.ts

@@ -0,0 +1,163 @@
+import type { AIProviderRegistry } from '@genesislcap/foundation-ai';
+import type { AiDriver } from '../components/ai-driver/ai-driver';
+import type { AutopilotBinding, AutopilotCopy } from '../config/config';
+import type { DiagnosticEntry } from '../state/persistence/diagnostics';
+import type { InteractionOpened } from '../types/interaction-interceptor';
+/** What a decision may do, set by the driver from the mode and the refinement count. */
+export interface DecisionOptions {
+    /** `false` when the person said "decide it yourself". */
+    readonly allowHandBack: boolean;
+    /** `false` past the refinement limit for this step. */
+    readonly allowReply: boolean;
+    /**
+     * Called the moment a written answer is accepted — before the working agent can ask its next
+     * question — so the refinement count is current when that question is decided.
+     */
+    readonly onReply?: () => void;
+}
+/**
+ * A numeric guard from an autopilot's config: the value when it is a positive, finite number, the
+ * fallback otherwise — so `0`, a negative or `NaN` cannot turn a guard into a hair trigger.
+ */
+export declare const positiveOr: <T>(value: number | undefined, fallback: T) => number | T;
+/**
+ * The newest `lines` that fit in `maxChars`, after one line saying how many earlier ones were left
+ * out: a transcript cut to size from the old end, since what the autopilot decides next turns on the
+ * recent past.
+ */
+export declare function newestThatFit(lines: readonly string[], maxChars: number): string[];
+/**
+ * How a decision ended, from the autopilot's side. `costUsd` is set on the outcome of a written
+ * question: what answering it cost, which has no interaction to be booked to, so the driver books it
+ * on the reply it sends on the user's behalf, or records it as dropped when it sends none. A widget
+ * decision's cost is booked to its interaction, and is not on the outcome.
+ */
+export type DecisionOutcome = 
+/** It ran a widget action that settled the interaction. */
+{
+    kind: 'acted';
+    action: string;
+    costUsd?: number;
+}
+/** It answered a written question; the driver sends `text` on the user's behalf. */
+ | {
+    kind: 'replied';
+    text: string;
+    costUsd?: number;
+} | {
+    kind: 'handed-back';
+    reason: string;
+    trigger: 'model' | 'no-decision' | 'error' | 'budget';
+    costUsd?: number;
+} | {
+    kind: 'aborted';
+    costUsd?: number;
+};
+/** What a session needs from the `AutopilotDriver` that owns it. */
+export interface AutopilotSessionDeps {
+    /** The working agent this autopilot serves (its flow owner). */
+    readonly agentName: string;
+    readonly binding: AutopilotBinding;
+    readonly providerRegistry: AIProviderRegistry;
+    /** The working session's debug-log key: the autopilot's events go to the working timeline. */
+    readonly sessionKey: string;
+    /** The working driver, for its history (what the person saw) and cost booking. */
+    readonly working: AiDriver;
+    /** The claimant id the autopilot acts as. */
+    readonly claimant: string;
+    /** The autopilot's wording: the reasons it gives when it hands a decision back. */
+    readonly copy: AutopilotCopy;
+}
+/**
+ * One autopilot for one flow (GENC-1660): its own `ChatDriver`, its own history, and the last
+ * message of what the person has seen that it was told about. Each decision is one short turn on
+ * that driver, which ends when the autopilot acts or hands back.
+ *
+ * Its history holds only its own conversation — the decisions it was sent, its tool calls and
+ * their results — never the working agent's. What happened without it (answers the person gave,
+ * messages they typed, what the assistant showed) arrives at the top of the next decision as a
+ * `<since-last>` block, built from the working history by code. Its own messages in the working
+ * history (what it sent on the user's behalf) are left out of that block while its history holds
+ * them, and labelled as its own whenever it does not: on its first decision (after a reload, too),
+ * after a size rebuild, and when a compaction removed the last message it saw.
+ */
+export declare class AutopilotSession {
+    private readonly deps;
+    private readonly driver;
+    /** The last message of the working history the autopilot was told about; see `SeenThrough`. */
+    private seen?;
+    private current?;
+    /** The tail of the decision queue: decisions run one after another, never interleaved. */
+    private queue;
+    /** Its own messages a size-bounded rebuild dropped, kept for the debug log. */
+    private readonly archived;
+    /** This session's own debug-log key; see `ownSessionKey`. */
+    private readonly ownKey;
+    /**
+     * When the decision in progress last showed progress: when it started, and each time its history
+     * moved (a model call or a tool result landing). For the watchdog, which hands back a decision
+     * that has stalled.
+     */
+    private progressAt?;
+    constructor(deps: AutopilotSessionDeps);
+    /**
+     * Decide one interaction this autopilot holds. Resolves when the autopilot's turn ends, however it
+     * ended; the interaction itself is settled (or handed back) by then, unless the turn was aborted.
+     *
+     * Queued behind any decision still unwinding — an aborted one finishes its in-flight call before
+     * it can stop — so a Resume straight after a Pause is not lost. Checked again when its turn
+     * comes: if the autopilot no longer holds the interaction, nothing is sent.
+     */
+    decide(opened: InteractionOpened, options: DecisionOptions): Promise<DecisionOutcome>;
+    /**
+     * Answer a written question the working agent ended its turn on (GENC-1660 §4.2): `replied` with
+     * the text to send on the user's behalf, or `handed-back`. Either way the outcome carries what it
+     * cost (see `DecisionOutcome`).
+     *
+     * Queued like `decide`, and checked again when its turn comes: if `stillWanted` says no — the
+     * person paused since it was asked — nothing is sent and it ends `aborted`.
+     */
+    answerQuestion(question: string, options: {
+        allowHandBack: boolean;
+        stillWanted?: () => boolean;
+    }): Promise<DecisionOutcome>;
+    /**
+     * Everything the autopilot did, as debug-log entries (§4.8): its turns (prompt, tools, model,
+     * usage), its messages (the decisions it was sent, its calls and their results) and its own
+     * events, tagged `delegate` and breadcrumbed with the agent it serves, so a replay can follow one
+     * decision from what it was shown to what it did and what it cost.
+     */
+    diagnostics(): DiagnosticEntry[];
+    /**
+     * The autopilot's own debug-log key: under the working session's, named for the agent it serves,
+     * and unique to this session, so two agents' autopilots never relabel each other's events and a
+     * later flow's session never reads an ended one's again. Cleared when the session is disposed,
+     * after the driver has harvested it.
+     */
+    private get ownSessionKey();
+    /**
+     * When the decision on `interactionId` last showed progress (it started, or a model call or tool
+     * result landed); `undefined` when no decision on it is running. Read by the watchdog.
+     */
+    decisionProgressAt(interactionId: string): number | undefined;
+    /** Stop the decision in progress: the person took it back, or it ended another way. */
+    abort(): void;
+    /**
+     * Stop, and drop its debug-log bucket. The owner harvests `diagnostics()` first. Cleared again once
+     * the aborted turn has unwound, so nothing it records on the way out is left behind.
+     */
+    dispose(): void;
+    private enqueue;
+    /**
+     * One turn on the autopilot's driver: the `<since-last>` block, then the decision. Ends when the
+     * autopilot acts, replies or hands back, when it passes its spend cap, or when it runs out of
+     * calls. Books what it cost to `interactionId`; for a written question, which has none, returns
+     * it on the outcome for the driver to book on its reply.
+     */
+    private runTurn;
+    /** The autopilot as an agent: its config's resolvers bound to the working agent's state. */
+    private agentConfig;
+    /** `widget_read`, `widget_act` and `hand_back`, acting on the decision in progress. */
+    private fixedHandlers;
+}
+//# sourceMappingURL=autopilot-session.d.ts.map

package/dist/dts/autopilot/autopilot-session.d.ts.map

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

package/dist/dts/autopilot/autopilot-tools.d.ts

@@ -0,0 +1,15 @@
+import type { ChatToolDefinition } from '@genesislcap/foundation-ai';
+/** Read the widget as it stands now. */
+export declare const WIDGET_READ = "widget_read";
+/** Run one of the widget's actions. */
+export declare const WIDGET_ACT = "widget_act";
+/** Hand this one decision to the person. */
+export declare const HAND_BACK = "hand_back";
+/**
+ * The autopilot's three fixed tools (GENC-1660 §4.2, §4.6). Fixed for every decision, so the cached
+ * prefix holds: what varies — the widget, its actions, their arguments — travels in the decision
+ * message, not here. Plain string and string-array fields only, which every provider accepts
+ * (critique round 2, N5: Gemini rejects a type-array union).
+ */
+export declare const AUTOPILOT_TOOL_DEFINITIONS: ChatToolDefinition[];
+//# sourceMappingURL=autopilot-tools.d.ts.map

package/dist/dts/autopilot/autopilot-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autopilot-tools.d.ts","sourceRoot":"","sources":["../../../src/autopilot/autopilot-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,wCAAwC;AACxC,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,uCAAuC;AACvC,eAAO,MAAM,UAAU,eAAe,CAAC;AACvC,4CAA4C;AAC5C,eAAO,MAAM,SAAS,cAAc,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,EA4D1D,CAAC"}

package/dist/dts/autopilot/decision-message.d.ts

@@ -0,0 +1,62 @@
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+import type { InteractionSurface, SurfaceAction } from '../types/interaction-surface';
+/**
+ * A widget as text: what the person saw (GENC-1660 §4.7). From its registration's `asText` when it
+ * has one; otherwise its name and a size-limited dump of its data — ugly, never wrong, and a nudge
+ * to register one.
+ */
+export declare function widgetAsText(componentName: string, data: unknown, result?: unknown): string;
+/** The numbered list of a surface's actions, and which name each number stands for. */
+export interface RenderedActions {
+    readonly text: string;
+    /** `numbering[n - 1]` is the action named by number `n`. */
+    readonly numbering: readonly string[];
+}
+/**
+ * List a surface's actions for the model (GENC-1660 §4.2). Options are numbered from 1, so they are
+ * chosen by number rather than by retyping a label; platform-owned actions keep their names. An
+ * unavailable action is listed, and marked, so the model knows it exists but cannot take it.
+ */
+export declare function renderActions(actions: readonly SurfaceAction[], options?: {
+    withholdReply?: boolean;
+}): RenderedActions;
+/** The current decision as one message for the autopilot (GENC-1660 §4.2). */
+export declare function renderDecision(opts: {
+    interactionId: string;
+    componentName: string;
+    data: unknown;
+    surface: InteractionSurface;
+    /** Set when the person clicked Resume to say "decide it yourself": no hand-back this time. */
+    decideYourself?: boolean;
+    /** Set past the refinement limit: `reply` is withdrawn. */
+    withholdReply?: boolean;
+}): RenderedActions;
+/**
+ * A written question the working agent ended its turn on, as one message for the autopilot
+ * (GENC-1660 §4.2): answer it in the user's place, or hand it back.
+ */
+export declare function renderQuestion(question: string, opts?: {
+    decideYourself?: boolean;
+}): string;
+/**
+ * What the person could see in `messages`, as lines, for the autopilot's `<since-last>` block
+ * (GENC-1660 §4.7). Built with the renderer's own visibility function at the default settings, so
+ * what the autopilot is told and what the person sees cannot drift: verbatim user messages and
+ * visible assistant output (driver notices included — hidden from the model is not hidden from the
+ * person); interactions by their text form and who answered. Never the working agent's hidden prose,
+ * tool calls or results: the autopilot checks proposals against its grounding, not against the
+ * argument that produced them.
+ *
+ * `claimant` is this autopilot's id. Its own messages — what it said to the person, and what it
+ * sent on the user's behalf — are left out while its own history holds them; `includeOwn` puts them
+ * in, labelled as its own, for when it does not (a first decision, a reload, a rebuild, or a
+ * compaction that removed what it last saw). `short` keeps the last entries verbatim and reduces
+ * older answered widgets to their first line — the form a catch-up after a long flow uses.
+ */
+export declare function visibleTranscript(messages: readonly ChatMessage[], opts: {
+    claimant: string;
+    skipInteractionId?: string;
+    short?: boolean;
+    includeOwn?: boolean;
+}): string[];
+//# sourceMappingURL=decision-message.d.ts.map

package/dist/dts/autopilot/decision-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-message.d.ts","sourceRoot":"","sources":["../../../src/autopilot/decision-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAMtF;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAa3F;AAED,uFAAuF;AACvF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,aAAa,EAAE,EACjC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,eAAe,CA2BjB;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,kBAAkB,CAAC;IAC5B,8FAA8F;IAC9F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,GAAG,eAAe,CAmClB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,MAAM,CAWhG;AAiCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAC5F,MAAM,EAAE,CA2CV"}

package/dist/dts/autopilot/hand-back/hand-back.controller.d.ts

@@ -0,0 +1,69 @@
+import type { InteractionContext } from '../../types/interaction-context';
+import type { DecisionAnswer } from '../../types/interaction-surface';
+/**
+ * The tag of the turn-level hand-back widget (GENC-1660 §4.10): what the autopilot shows when a
+ * working turn ends needing the person, and there is no widget to hand over.
+ *
+ * @beta
+ */
+export declare const AUTOPILOT_HAND_BACK = "ai-autopilot-hand-back";
+/**
+ * One choice the hand-back offers.
+ *
+ * @beta
+ */
+export interface HandBackOption {
+    readonly id: HandBackChoice;
+    readonly label: string;
+}
+/**
+ * What the person can choose. `reply` carries their written answer to the working agent's
+ * question; the rest tell the autopilot what to do next.
+ *
+ * @beta
+ */
+export type HandBackChoice = 'carry-on' | 'try-again' | 'compact' | 'pause' | 'reply';
+/**
+ * The hand-back's inputs. Every word it shows comes from here, so it follows the autopilot's
+ * `AutopilotCopy`.
+ *
+ * @beta
+ */
+export interface HandBackData {
+    /** Why the person is needed, in the assistant's voice. */
+    readonly message: string;
+    /** The working agent's question, when the turn ended on one. */
+    readonly question?: string;
+    readonly options: readonly HandBackOption[];
+    /** Whether a written answer is offered (a turn that ended on a question). */
+    readonly freeText?: boolean;
+    /** The label of the button that sends the written answer, with `freeText`. */
+    readonly sendLabel?: string;
+}
+/**
+ * What the hand-back resolves with.
+ *
+ * @beta
+ */
+export interface HandBackResult {
+    readonly status: 'approved';
+    readonly payload: {
+        choice: HandBackChoice;
+        text?: string;
+    };
+}
+/**
+ * The hand-back's controller. DOM-free: it exposes the choices as a decision (so the visible
+ * transcript and the debug log describe it like any widget) and resolves through `ctx.resolve`. The
+ * hand-back is always `userOnly`, so nothing but the person ever answers it.
+ */
+export declare class HandBackController {
+    readonly data: HandBackData;
+    private readonly ctx;
+    constructor(data: HandBackData, ctx: InteractionContext);
+    /** The person's choice, from the view's buttons or its text box. */
+    choose(answer: DecisionAnswer): void;
+}
+/** The hand-back as text: what the person saw, and what they chose. */
+export declare function handBackAsText(data: unknown, result?: unknown): string;
+//# sourceMappingURL=hand-back.controller.d.ts.map

package/dist/dts/autopilot/hand-back/hand-back.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hand-back.controller.d.ts","sourceRoot":"","sources":["../../../../src/autopilot/hand-back/hand-back.controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,cAAc,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAEtF;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7D;AAED;;;;GAIG;AACH,qBAAa,kBAAkB;IAE3B,QAAQ,CAAC,IAAI,EAAE,YAAY;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG;gBADX,IAAI,EAAE,YAAY,EACV,GAAG,EAAE,kBAAkB;IAS1C,oEAAoE;IACpE,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;CAWrC;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAUtE"}

package/dist/dts/autopilot/hand-back/hand-back.d.ts

@@ -0,0 +1,22 @@
+import { GenesisElement } from '@genesislcap/web-core';
+import type { AiChatInteraction } from '../../types/ai-chat-widget';
+import { type HandBackData, type HandBackResult } from './hand-back.controller';
+/**
+ * The turn-level hand-back's view (GENC-1660 §4.10): the message, the working agent's question if
+ * there was one, and the choices. It only renders: choosing calls the controller, which resolves.
+ * Always the person's to answer (`userOnly`), so it never hides itself.
+ *
+ * @beta
+ */
+export declare class AutopilotHandBack extends GenesisElement {
+    interactionId: string;
+    interaction?: AiChatInteraction<HandBackData, HandBackResult['payload']>;
+    draft: string;
+    get data(): HandBackData | undefined;
+    /** What was chosen, once resolved. */
+    get answer(): string | undefined;
+    private get controller();
+    choose(option: string): void;
+    reply(): void;
+}
+//# sourceMappingURL=hand-back.d.ts.map

package/dist/dts/autopilot/hand-back/hand-back.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hand-back.d.ts","sourceRoot":"","sources":["../../../../src/autopilot/hand-back/hand-back.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,cAAc,EAKf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAGL,KAAK,YAAY,EAEjB,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAC;AAyFhC;;;;;;GAMG;AACH,qBACa,iBAAkB,SAAQ,cAAc;IACnD,aAAa,SAAM;IACP,WAAW,CAAC,EAAE,iBAAiB,CAAC,YAAY,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;IACzE,KAAK,SAAM;IAEvB,IAAI,IAAI,IAAI,YAAY,GAAG,SAAS,CAEnC;IAED,sCAAsC;IACtC,IAAI,MAAM,IAAI,MAAM,GAAG,SAAS,CAM/B;IAED,OAAO,KAAK,UAAU,GAIrB;IAED,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI5B,KAAK,IAAI,IAAI;CAId"}

package/dist/dts/autopilot/index.d.ts

@@ -0,0 +1,4 @@
+export { AUTOPILOT_CLAIMANT, AutopilotDriver, type AutopilotCapability, type AutopilotDriverOptions, type AutopilotHost, type AutopilotHostState, type AutopilotMode, type PersistedAutopilotMode, } from './autopilot-driver';
+export { AUTOPILOT_HAND_BACK, type HandBackChoice, type HandBackData, type HandBackOption, type HandBackResult, } from './hand-back/hand-back.controller';
+export { AutopilotHandBack } from './hand-back/hand-back';
+//# sourceMappingURL=index.d.ts.map