@teaflask/assistant 0.3.0 → 0.7.0

package/dist/core/conversation-store.js

@@ -1,6 +1,7 @@
 import { IDLE_ACTIVITY, } from "./activity.js";
 import { noteDispatchSettledFromStore, refreshConversationFromStore, } from "./conversation-refresh.js";
 import { mintAttachmentDownloadUrlFromStore, uploadAttachmentFromStore, } from "./attachment-uploads.js";
+import { addComposerFilesFromStore } from "./composer-attachments.js";
 import { handleUserMessageInjectedFromStore, markComposerRefocusHandledFromStore, sendMessageFromStore, stopTurnFromStore, } from "./conversation-send.js";
 import { noteComposerFocusFromStore, setComposerAttachmentsFromStore, setComposerDraftFromStore, setModelPickFromStore, takeComposerCaretReturnFromStore, } from "./composer-input-state.js";
 import { submitApprovalDecisionFromStore } from "./approval-decision.js";
@@ -12,107 +13,44 @@ import { SettleRefreshScheduler } from "./settle-refresh.js";
 import { handleStreamClosedQuietlyFromStore, handleStreamErrorFromStore, handleWorkflowRestartedFromStore, retryStreamFromStore, } from "./stream-trouble.js";
 import { acquireTranscriptLeaseFromStore } from "./transcript-lease.js";
 import { clearIdleRecheck, syncIdleRecheck } from "./idle-recheck.js";
+import { armDispatchPoll, disarmDispatchPoll } from "./dispatch-poll.js";
 import { ConsumedInterruptFold } from "./consumed-interrupts.js";
 import { composerSnapshotOf, conversationSnapshotOf, publishStore, } from "./conversation-publish.js";
 import { retireEpoch } from "./epoch-sync.js";
 import { ObservableCell } from "./observable-cell.js";
-/**
- * The conversation core shared by every surface: one thread's state, the
- * send/reconnect/echo machinery, and the honest error taxonomy — a plain
- * observable store so surfaces are pure chrome subscribing to its cells
- * (via useSyncExternalStore in React; `.get()`/`.subscribe()` anywhere
- * else). Surfaces differ only in chrome — <AssistantPage/> adds the
- * thread list, <AssistantPalette/> an overlay shell — never in transport,
- * persistence, or transcript semantics.
- *
- * Every send reconnects the stream with a fresh agent: the serving stream
- * closes once a turn settles, and the contract's frozen semantic makes a
- * fresh full replay the one always-correct way to pick up the next turn.
- *
- * Construction is side-effect-free (StrictMode-inert); `bootstrap()` is
- * the boot, `dispose()` the teardown.
- */
 export class AssistantConversationStore {
     deps;
     conversation;
     composer;
     connection;
     approvals;
-    // The pending asks (question sets): cards
-    // derived from the epoch's execution entries — the member's half of
-    // the execution inbox, beside the approvals' human half.
     elicitations;
-    // What the member owes each coworker, by ordinal:
-    // an action their browser performs or a decision on an approval — the
-    // delegation group row's read.
     coworkerWork;
     markerAnchors;
     activity;
-    // The live message list, mirrored from the epoch agent's own state by
-    // messagesRecorder. Any number of surfaces may render it concurrently —
-    // with the store as the only connection driver there is nothing left
-    // to collide (the old newest-holder-only lease gate was chassis
-    // crash-avoidance, not UX).
     messages;
-    // Each injected user message's turn-side display facts — attachments
-    // and the turn's created_at stamp — keyed by its stable id:
-    // the transcript derivation's side table (neither fact rides the
-    // AG-UI Message itself, which the client library owns).
     turnMeta;
-    // Underscore members are store-internal state, deliberately not TS
-    // `private`: the store's section modules (conversation-adoption,
-    // conversation-send, connection-driver, …) are the class's friends and
-    // read them through the store argument each entry function takes. Nothing
-    // outside src/core names one; headless.ts records the never-export rule.
     _conversationCell;
     _composerCell;
     _connectionCell;
     _approvalsCell;
     _elicitationsCell;
-    // What the member owes each coworker, by ordinal,
-    // folded from the live epoch's coworker execution entries and the
-    // carried approval inbox's coworker cards on either publish; the
-    // delegation group row reads it to name the asker.
     _coworkerWorkCell;
-    // Submit-failure sentences by interrupt id, stamped by the question
-    // set's submit and cancel and cleared by their next attempt; the card
-    // model carries them so the panel can say why nothing moved.
     _elicitationErrors = new Map();
-    // What each successful submit or cancel posted, by interrupt
-    // id, for the settled receipt. Every write on the question-set path and
-    // its live reader are enumerated in docs/decision-anchors.md.
     _questionAnswers = new Map();
-    /** The question-set drafts: store-owned so the panel's
-     *  remounts (paging, reconnect, workflow restart) never lose a
-     *  member's staged answers. Lifetime is ruled in question-drafts.ts;
-     *  this store clears a set on present-and-settled evidence and clears
-     *  all on a thread switch or abandon — never on an epoch reset. */
     questionDrafts = new QuestionDraftStore();
     _markerAnchorsCell;
     _activityCell;
     _messagesCell;
     _turnMetaCell;
-    // The dirty check behind the derived meta map: republish only when
-    // the ledger instance or its version moved.
     _publishedMetaLedger = null;
     _publishedMetaVersion = -1;
-    // Minted download URLs, reused while comfortably inside their TTL so a
-    // list re-render never stampedes the mint endpoint.
     _downloadUrls = new Map();
     _active = null;
     _threads = [];
     _sendError = null;
-    // The newest turn's failure sentence, straight from the turn row.
     _turnFailure = null;
-    // The published pending-decision gap. Reference-stable while
-    // its signature holds, so the snapshot comparer can be an identity
-    // check.
     _pendingDecisionGap = null;
-    // The quiet→loud grace lives in the shared PendingDecisionGapGate; the
-    // timer alone bounds the alert, never anything network-shaped. publish
-    // writes _pendingDecisionGap; probe is one best-effort re-read per
-    // signature; evidenceSettled is GAP-PROBE PREMISE #3: _epochConnectedOnce
-    // records a real stream ATTEMPT (docs/connection-lifecycle.md).
     _gapGate = new PendingDecisionGapGate({
         publish: (gap) => {
             this._pendingDecisionGap = gap;
@@ -131,117 +69,49 @@ export class AssistantConversationStore {
     });
     _inPublish = false;
     _streamInterrupted = false;
-    // A stop POST is in flight, or its ~2s settle window is still open.
-    // Cleared wherever the settled truth arrives (an adopted detail with
-    // busy false) and on every new-intent moment (send, open, abandon).
     _stopping = false;
     _threadOpening = false;
     _reconnectNonce = 0;
-    // The background-attach nonce: remints the connection epoch
-    // WITHOUT remounting the keyed transcript — it feeds the epoch
-    // signature but never the ConversationSnapshot, so the Transcript key
-    // (thread.id#reconnectNonce) holds still while the store attaches to a
-    // background-initiated turn. The premise lives at the remint branch in
-    // syncConnection.
     _backgroundAttachNonce = 0;
     _pendingSend = false;
     _pendingEcho = null;
     _composerRefocusPending = false;
-    // The conversation's model pick. Seeded from the thread's
-    // wire truth on every adoption; a chip selection sets it locally
-    // (dirty) until the next send carries it, so a settle refresh never
-    // clobbers an unsent choice. The server may clear a pick between
-    // turns — the thread read is authoritative once nothing is dirty.
     _modelPick = null;
     _modelPickDirty = false;
-    // The composer's unsaved input. See ComposerInput and the
-    // ComposerContract fields for the placement ruling and the death arm
-    // in _connectionEnded for the lifetime ruling. A dedicated cell on
-    // purpose: its writes never ride publishStore, so a keystroke notifies the
-    // composer's subscription alone — no conversation-plane state moves
-    // when the visitor types.
     _composerInput = new ObservableCell({
         scope: "u:0",
         draft: "",
         attachments: [],
     });
-    // The next conversation-less scope token; 0 is the constructed state.
     _nextUnboundScope = 1;
-    // WHICH SURFACE's composer textarea owns the keyboard (null: none) — a
-    // surface token, not a boolean, so the owed caret return names its owner
-    // and no bystander surface's fresh composer consumes it. Kept true to the
-    // DOM by blur, the owner's unmount cleanup (DOM-checked for StrictMode),
-    // and the death arm's read-before-publish. Event-plane, never published.
+    _composerInputResets = 0;
     _composerFocusOwned = null;
-    // One owed caret return, stamped with the owning surface (the death
-    // arm's remount tore down that surface's focused textarea). Take-
-    // consumed at mount by the fresh composer instance WHOSE SURFACE
-    // MATCHES — bystander surfaces' takes return false and leave it
-    // armed.
     _composerCaretReturnPending = null;
     _tier = null;
-    // The activity feed's raw material: the newest turn as REST last told
-    // us, and the newest turn that reached a terminal status.
     _newestTurn = null;
-    // The newest ANSWERABLE turn off the last full refresh (with
-    // queuing, the pause can sit behind QUEUED rows, so the newest row and
-    // the answerable row diverge). Only trusted right after a refresh —
-    // the partial adopters (send, resume) don't maintain it.
     _awaitingTurn = null;
     _lastResult = null;
-    // The consumed-interrupt fold — the how and why live on the
-    // ConsumedInterruptFold class in consumed-interrupts.ts.
     _consumedInterrupts = new ConsumedInterruptFold();
-    // A resume that resolves after some other path adopted a conversation
-    // (a send, a thread switch, a newer resume) must be discarded — its
-    // detail predates the adoption. The counter is that staleness guard.
     _resumeRequest = 0;
-    // A monotonic token per adoption ask: a backfill that outlives its
-    // adoption (the user opened another thread mid-drain) finds the token
-    // moved on and adopts nothing.
     _adoptionAsk = 0;
-    // Refresh adoption is monotonic in issue order: with no
-    // AbortSignal or timeout in this transport, a stalled thread GET can land
-    // MINUTES late and would regress _newestTurn. A response adopts only if no
-    // later-issued refresh adopted first — landed truth is arbitrated by issue
-    // order, never discarded outright. Scope: the refreshConversation family.
     _refreshTicket = 0;
     _refreshAdoptedThrough = 0;
     _historyLoadRequested = false;
-    // The settle re-read's debounce policy lives in the shared scheduler;
-    // what a settle refreshes is this store's: the thread, the history
-    // list, and (via onTurnSettled) the funding facts — a taster crossing
-    // or a drained window moves the gate projection.
     _settleScheduler = new SettleRefreshScheduler(() => {
         void this.refreshConversation();
         void refreshThreads(this);
         this.deps.onTurnSettled();
     });
-    // The delivery-claim probe's coalescing flags: one burst at a
-    // time, and a settle landing mid-burst restarts the probe budget instead
-    // of stacking a second burst. No timer handle on purpose — the probe is
-    // settlesFor beats with _disposed re-checked behind every await, and its
-    // only awaits are its own beat timers, never a network promise.
     _deliveryProbeRunning = false;
     _deliveryProbeRearm = false;
-    // The leased idle re-read's interval. Cleared in dispose()
-    // and re-armed by any later publish (the gap gate's lifecycle: a
-    // timer dies with the life that armed it, and a StrictMode
-    // dispose→bootstrap revival re-arms through the ordinary sync). The
-    // in-flight flag is the tick's single-flight guard — see
-    // the comment inside syncIdleRecheck.
     _idleRecheckTimer = null;
     _idleRecheckInFlight = false;
+    _disarmDispatchPoll = null;
     _disposed = false;
     _epoch = null;
     _epochResume = null;
     _epochSignature = null;
     _nextEpochId = 1;
-    // Surface presence (the old transcript lease, kept as a registry): the
-    // store is the ONLY connection driver now, and presence upgrades the
-    // socket policy per the truth table in syncConnection — a mounted
-    // surface means "ensure this epoch has connected once" (history paints
-    // by full replay); no surfaces means the bounded headless table.
     _leaseHolders = [];
     _connectionRunning = false;
     _connectionSyncQueued = false;
@@ -286,29 +156,13 @@ export class AssistantConversationStore {
         this.messages = this._messagesCell;
         this.turnMeta = this._turnMetaCell;
     }
-    /** Boot: resume where the visitor left off, and prime the identified
-     *  history eagerly — the list call itself is what primes the first
-     *  mint, so a fresh browser (no stored thread — exactly the
-     *  cross-device case) shows its history without waiting for a first
-     *  send. Anonymous embeds stay lazy — no traffic until the visitor
-     *  interacts. Idempotent: the resume staleness counter and the history
-     *  flag absorb StrictMode's double boot. */
     bootstrap() {
-        // Revival, not just boot: StrictMode runs the provider's teardown
-        // between two boots of the SAME memoized store, so a dispose followed
-        // by a bootstrap must leave a working store, exactly like the
-        // TokenSession it lives beside.
         this._disposed = false;
         this.resumeStoredThread();
         loadHistoryOnceExpected(this);
-        // Revival belt-and-braces: a StrictMode dispose cleared the
-        // idle re-read while the lease holders (and possibly the active
-        // conversation) survived — re-judge now rather than waiting for the
-        // next publish.
         syncIdleRecheck(this);
+        armDispatchPoll(this);
     }
-    /** The provider pushes each mint's tier verdict in; identification can
-     *  arrive mid-session and flips the history expectation. */
     setTier(tier) {
         if (this._tier === tier) {
             return;
@@ -321,25 +175,14 @@ export class AssistantConversationStore {
         this._disposed = true;
         invalidateInFlightResume(this);
         this._settleScheduler.dispose();
-        // The gap gate's window dies with the life that armed it: a timer
-        // left in place would survive a StrictMode dispose→bootstrap revival
-        // with stale state — and a re-derived gap with the SAME signature
-        // would then skip the confirming re-read and the timer forever,
-        // never publishing. That is the silent-pending-decision state the
-        // gate exists to remove.
         this._gapGate.dispose();
-        // The idle re-read dies with the same life: a leaked
-        // interval would keep re-reading a disposed store's thread for the
-        // rest of the page. Revival re-arms it through the ordinary publish
-        // sync, exactly like the connection itself.
         clearIdleRecheck(this);
+        disarmDispatchPoll(this);
         retireEpoch(this);
     }
-    // --- resuming the stored conversation (conversation-adoption.ts) -----------
     resumeStoredThread = () => {
         resumeStoredThreadFromStore(this);
     };
-    // --- sending and stopping (conversation-send.ts) ---------------------------
     sendMessage = async (message, attachmentIds, optimisticAttachments) => sendMessageFromStore(this, message, attachmentIds, optimisticAttachments);
     markComposerRefocusHandled = () => {
         markComposerRefocusHandledFromStore(this);
@@ -358,41 +201,32 @@ export class AssistantConversationStore {
         noteComposerFocusFromStore(this, owner);
     };
     takeComposerCaretReturn = (surface) => takeComposerCaretReturnFromStore(this, surface);
-    // --- attachments -----------------------------------------------------------
     uploadAttachment = async (file) => uploadAttachmentFromStore(this, file);
+    addComposerFiles = async (files) => addComposerFilesFromStore(this, files);
     mintAttachmentDownloadUrl = async (attachmentId) => mintAttachmentDownloadUrlFromStore(this, attachmentId);
-    // --- surface presence (the transcript lease) -------------------------------
     acquireTranscriptLease = (surface) => acquireTranscriptLeaseFromStore(this, surface);
-    // --- answering approvals (approval-decision.ts) ----------------------------
     submitApprovalDecision = async (card, decision) => submitApprovalDecisionFromStore(this, card, decision);
-    // --- answering question sets (elicitation-answers.ts) ----------------------
     submitQuestionAnswers = async (card, answers) => submitQuestionAnswersFromStore(this, card, answers);
     cancelQuestionSet = async (card) => cancelQuestionSetFromStore(this, card);
     handleUserMessageInjected = (messageId) => {
         handleUserMessageInjectedFromStore(this, messageId);
     };
-    // --- navigation (conversation-adoption.ts) ---------------------------------
     openThread = (thread) => {
         openThreadFromStore(this, thread);
     };
     startNewConversation = () => {
         startNewConversationFromStore(this);
     };
-    // --- keeping the REST truth fresh (conversation-refresh.ts) ----------------
     refreshConversation = async () => refreshConversationFromStore(this);
     noteDispatchSettled = () => {
         noteDispatchSettledFromStore(this);
     };
-    // A coworker read paused: its request is on the dispatching
-    // turn's snapshot, so re-read the conversation and let the adoption
-    // hand it to the execution inbox.
     noteDispatchPaused = () => {
         void refreshConversationFromStore(this);
     };
     handleRunSettled = () => {
         this._scheduleSettleRefresh();
     };
-    // --- stream trouble (stream-trouble.ts) ------------------------------------
     handleStreamError = (error) => {
         handleStreamErrorFromStore(this, error);
     };
@@ -405,7 +239,6 @@ export class AssistantConversationStore {
     handleWorkflowRestarted = () => {
         handleWorkflowRestartedFromStore(this);
     };
-    // --- the settle re-read ----------------------------------------------------
     _scheduleSettleRefresh() {
         if (this._disposed) {
             return;
@@ -413,4 +246,3 @@ export class AssistantConversationStore {
         this._settleScheduler.noteRunSettled();
     }
 }
-//# sourceMappingURL=conversation-store.js.map

package/dist/core/coworker-execution-work.d.ts

@@ -1,21 +1,10 @@
 import type { ApprovalCardModel } from "./approval-inbox.js";
 import type { ExecutionEntryModel } from "./execution-inbox.js";
 export interface CoworkerExecutionWork {
-    /** Null when the approval stopped no tool call — the card's tool fields
-     *  are best-effort on the contract; an execution always names its tool. */
     toolName: string | null;
     status: "pending" | "executing" | "reported" | "stale";
-    /** The reported outcome (a decision's approved); null until reported. */
     ok: boolean | null;
-    /** browser: the member's browser performs it; approval: the member
-     *  decides it. */
     via: "browser" | "approval";
 }
-/** ordinal → the entry or card most worth showing (RANK's order; an open
- *  approval outranks an open execution of the same rank — the member is
- *  the one who must act). */
 export declare function coworkerExecutionWorkOf(entries: readonly ExecutionEntryModel[], cards?: readonly ApprovalCardModel[]): ReadonlyMap<number, CoworkerExecutionWork>;
-/** Equality by content — both maps fold entries in publish order, so the
- *  serialized pairs compare directly. */
 export declare function sameCoworkerExecutionWork(a: ReadonlyMap<number, CoworkerExecutionWork>, b: ReadonlyMap<number, CoworkerExecutionWork>): boolean;
-//# sourceMappingURL=coworker-execution-work.d.ts.map

package/dist/core/coworker-execution-work.js

@@ -1,20 +1,9 @@
-// What the member's browser is doing for each coworker, and
-// what the member owes it: the execution inbox's coworker
-// entries and the approval inbox's coworker cards folded to one line per
-// ordinal, for the delegation group row — the coworker's own line names
-// the asker, so a request the browser performs or a decision the member
-// owes on a coworker's behalf never reads as the assistant's. Pure over
-// the published entries and cards.
-// Live work first, then the open ask, then what was reported, then stale.
 const RANK = [
     "executing",
     "pending",
     "reported",
     "stale",
 ];
-/** ordinal → the entry or card most worth showing (RANK's order; an open
- *  approval outranks an open execution of the same rank — the member is
- *  the one who must act). */
 export function coworkerExecutionWorkOf(entries, cards = []) {
     const byOrdinal = new Map();
     const consider = (ordinal, work) => {
@@ -59,9 +48,6 @@ function _approvalWorkStatusOf(card) {
             return "stale";
     }
 }
-/** Equality by content — both maps fold entries in publish order, so the
- *  serialized pairs compare directly. */
 export function sameCoworkerExecutionWork(a, b) {
     return JSON.stringify([...a]) === JSON.stringify([...b]);
 }
-//# sourceMappingURL=coworker-execution-work.js.map

package/dist/core/dispatch-poll.js

@@ -0,0 +1,81 @@
+import { demandInputOfMessages, dispatchDemandOf, dispatchJoinKeyOf, RESUME_SUBAGENT_TOOL_NAME, staleDeliveredOrdinalsKeyOf, } from "./subagent-ledger-join.js";
+import { DISPATCH_SUBAGENT_TOOL_NAME } from "./subagent-rows.js";
+import { EMPTY_THREAD_DISPATCHES, threadDispatchLedgerFor, } from "./thread-dispatch-ledger.js";
+export function armDispatchPoll(store) {
+    if (store._disarmDispatchPoll !== null) {
+        return;
+    }
+    const ledger = threadDispatchLedgerFor(store.deps.session);
+    ledger.setSettleListener(store, store.noteDispatchSettled);
+    ledger.setPauseListener(store, store.noteDispatchPaused);
+    let queued = false;
+    let lastTapKey = "";
+    const judge = () => {
+        queued = false;
+        if (store._disposed || store._disarmDispatchPoll === null) {
+            return;
+        }
+        lastTapKey = _judgeDemand(store, ledger, lastTapKey);
+    };
+    const schedule = () => {
+        if (queued) {
+            return;
+        }
+        queued = true;
+        queueMicrotask(judge);
+    };
+    const unsubscribes = [
+        store.messages.subscribe(schedule),
+        store.markerAnchors.subscribe(schedule),
+        store.connection.subscribe(schedule),
+        ledger.cell.subscribe(schedule),
+    ];
+    store._disarmDispatchPoll = () => {
+        for (const unsubscribe of unsubscribes) {
+            unsubscribe();
+        }
+        ledger.setDemand(store, null);
+        ledger.setSettleListener(store, null);
+        ledger.setPauseListener(store, null);
+    };
+    schedule();
+}
+export function disarmDispatchPoll(store) {
+    const disarm = store._disarmDispatchPoll;
+    if (disarm === null) {
+        return;
+    }
+    store._disarmDispatchPoll = null;
+    disarm();
+}
+export function noteThreadRead(store, threadId) {
+    threadDispatchLedgerFor(store.deps.session).noteThreadAnswered(threadId);
+}
+function _judgeDemand(store, ledger, lastTapKey) {
+    const threadId = store.connection.get()?.threadId ?? null;
+    const messages = store.messages.get();
+    if (threadId === null || !_delegates(messages)) {
+        ledger.setDemand(store, null);
+        return "";
+    }
+    const input = demandInputOfMessages(messages, store.markerAnchors.get());
+    const read = ledger.cell.get();
+    const map = read !== null && read.threadId === threadId
+        ? read.map
+        : EMPTY_THREAD_DISPATCHES;
+    ledger.setDemand(store, {
+        threadId,
+        ...dispatchDemandOf(input, map),
+        joinKey: dispatchJoinKeyOf(input),
+    });
+    const tapKey = staleDeliveredOrdinalsKeyOf(input, map);
+    if (tapKey !== "" && tapKey !== lastTapKey) {
+        void ledger.refresh(threadId);
+    }
+    return tapKey;
+}
+function _delegates(messages) {
+    return messages.some((message) => message.role === "assistant" &&
+        (message.toolCalls ?? []).some((call) => call.function.name === DISPATCH_SUBAGENT_TOOL_NAME ||
+            call.function.name === RESUME_SUBAGENT_TOOL_NAME));
+}

package/dist/core/dock-reflow.js

@@ -1,27 +1,6 @@
-// The sidebar's host reflow: the docked panel is a top-layer popover that
-// can never join the host's flow, so the page is pushed out from under it
-// — a margin-right on documentElement equal to the panel's width, with an
-// inline transition on the panel's own clock so push and slide-in read as
-// one motion. The host's inline values are saved on the first push of a
-// cycle and restored on release, asymmetrically: the margin goes back at
-// once (that IS the un-push) while our transition outlives the slide back,
-// paced by a timer, not transitionend (the host may transition nothing).
-// Known Intercom-class limitations, documented rather than fixed: 100vw
-// host elements overflow by the pushed width; right-anchored fixed UI stays.
-// The floating panel's motion clock (styles.css), restated here because
-// an inline style can't read the stylesheet's literal.
 const DOCK_REFLOW_TRANSITION = "margin-right 220ms cubic-bezier(0.22, 1, 0.36, 1)";
-// Matches the stylesheet's reduced-motion collapse: 1ms, never 0 — a
-// zero-duration transition fires no events and some engines skip it.
 const DOCK_REFLOW_REDUCED_TRANSITION = "margin-right 1ms";
-// Outlasts the 220ms slide-back before the host's transition is
-// restored, with room for a busy main thread to start the slide late.
 const REFLOW_SETTLE_FALLBACK_MS = 400;
-// One controller per root, for the root's lifetime. The panel that
-// drives it unmounts instantly on minimize, so the controller must
-// outlive it to animate the un-push — and a remount inside the settle
-// window must find the SAME bookkeeping, or the new instance would save
-// our own still-inline transition as host state.
 const _controllers = new WeakMap();
 export function dockReflowFor(root) {
     const existing = _controllers.get(root);
@@ -33,11 +12,6 @@ export function dockReflowFor(root) {
     return controller;
 }
 function _createDockReflow(root) {
-    // `saved` lives from the first push until a release's settle finishes —
-    // NOT until release: a re-push inside the settle window (the park→
-    // re-show path) would otherwise find it empty and save our own
-    // still-inline transition as host state. `pushed` alone says whether a
-    // release has work to do.
     let saved = null;
     let pushed = false;
     let settleTimer = null;
@@ -92,4 +66,3 @@ function _createDockReflow(root) {
         },
     };
 }
-//# sourceMappingURL=dock-reflow.js.map

package/dist/core/elicitation-answers.js

@@ -1,30 +1,12 @@
-// Answering question sets: the ONE POST for a whole pending
-// set — answers or a distinct cancellation — with the same lock, turn
-// lookup, delivery and failure arms as the approval submit. The
-// `{ kind: "answers" }` / `{ kind: "cancelled" }` literals below are this
-// package's one allowed tool-call state site outside the driver — the
-// ledger in tests/tool-call-state-sites.test.ts names this file.
 import { resolveTurnToolResults } from "../transport/serving-api.js";
 import { ServingApiError } from "../transport/serving-error.js";
 import { ANSWER_NOT_SENT_SENTENCE } from "./approval-inbox.js";
 import { turnIdAnsweredBy } from "./approval-decision.js";
 import { publishExecutionEntries } from "./epoch-sync.js";
 import { userSentenceFor } from "./error-copy.js";
-/**
- * Submit the member's answers to one pending question set — the ONE
- * POST for the whole set, after the panel's local navigation. Same
- * lock, turn lookup, delivery and failure arms as the approval submit;
- * the draft is released on success and KEPT on any failure, so a retry
- * never starts from an empty panel.
- */
 export async function submitQuestionAnswersFromStore(store, card, answers) {
     await _deliverQuestionSetReport(store, card, { answers: answers.map((answer) => ({ ...answer })) }, { kind: "answers", answers });
 }
-/**
- * Dismiss one pending question set whole: no partial answers, and the
- * model hears a distinct cancellation — never the kind-unsupported
- * failure that would tell it to ask the same questions in chat.
- */
 export async function cancelQuestionSetFromStore(store, card) {
     await _deliverQuestionSetReport(store, card, { cancelled: true }, { kind: "cancelled" });
 }
@@ -32,6 +14,7 @@ async function _deliverQuestionSetReport(store, card, result, answered) {
     const epoch = store._epoch;
     const active = store._active;
     if (epoch === null || active === null) {
+        _stampAnswerNotSent(store, card);
         return;
     }
     const inbox = epoch.executionInbox;
@@ -55,21 +38,13 @@ async function _deliverQuestionSetReport(store, card, result, answered) {
         const resolution = await resolveTurnToolResults(store.deps.session, active.thread.id, turnId, { results: [{ interrupt_id: card.interruptId, ok: true, result }] });
         store._questionAnswers.set(card.interruptId, answered);
         inbox.settleReported(card.interruptId, true);
-        // Released on success only — a failed POST keeps the member's
-        // staged answers for the retry.
         store.questionDrafts.clear(card.interruptId);
-        // The delivery field alone decides the reconnect (the approval
-        // submit's law): a notice can accompany a DELIVERED restart too (the
-        // oversize drop), and skipping the reconnect there would freeze the
-        // transcript on the dead run.
         if (resolution.delivery === "workflow_restarted") {
             store.handleWorkflowRestarted();
         }
     }
     catch (error) {
         if (_turnNoLongerAwaitingToolResults(error)) {
-            // Voided, settled, or answered in another tab: the set is over,
-            // and so is its draft.
             inbox.markRunStale(card.runId);
             store.questionDrafts.clear(card.interruptId);
             void store.refreshConversation();
@@ -83,36 +58,21 @@ async function _deliverQuestionSetReport(store, card, result, answered) {
         publishIfCurrent();
     }
 }
+function _stampAnswerNotSent(store, card) {
+    store._elicitationErrors.set(card.interruptId, ANSWER_NOT_SENT_SENTENCE);
+    const cards = store._elicitationsCell.get();
+    const next = cards.map((item) => item.interruptId === card.interruptId &&
+        item.errorSentence !== ANSWER_NOT_SENT_SENTENCE
+        ? { ...item, errorSentence: ANSWER_NOT_SENT_SENTENCE }
+        : item);
+    if (next.some((item, index) => item !== cards[index])) {
+        store._elicitationsCell.set(next);
+    }
+}
 function _turnNoLongerAwaitingToolResults(error) {
     return (error instanceof ServingApiError &&
         error.code === "ASSISTANT_TURN_NOT_AWAITING_TOOL_RESULTS");
 }
-// THE RULES THE DOOR CAN REFUSE A QUESTION SET ON, AND WHAT THE MEMBER
-// SEES — the client prevents each one it can:
-//   - per-answer length ≤ 1,900 (prevented: overLimitOf gates Submit and
-//     names the question; if reached anyway, the door's sentence: "One
-//     answer is longer than 1,900 characters. Shorten it and submit
-//     again.")
-//   - C0 control characters other than tab/newline/CR (prevented:
-//     normalizeCustomText at the draft write; if reached anyway — a
-//     non-panel client — the door's sentence names the rule)
-//   - every question answered exactly once (prevented: answersOf gates
-//     Submit and builds the body from the set itself; if reached anyway,
-//     the door names the unanswered / repeated / unasked ids)
-//   - the answers-or-cancelled shape (prevented by construction; the door
-//     would say the answers could not be read)
-//   - the whole-report size cap (cannot be reached from a set the client
-//     admits: 5 × 2 × 1,900 plus the envelope sits under it — a degrade
-//     to the too-large failure, never a 422, if a foreign client did)
-//   - 409 not awaiting (stale: the panel leaves and the settled line says
-//     the set was already answered or expired)
-//   - anything else (the generic sentence: "That answer couldn't be sent.
-//     Please try again.")
-// The playground's question-submit.ts passes the door's sentence through
-// (describeError), the same words. The composer's own VALIDATION_ERROR
-// copy ("Shorten it and try again") is about the message field and is
-// deliberately NOT reused here — a member who pasted a control character
-// cannot act on "shorten".
 function _questionSetFailureSentenceOf(error) {
     if (error instanceof ServingApiError &&
         error.code === "VALIDATION_ERROR" &&
@@ -121,4 +81,3 @@ function _questionSetFailureSentenceOf(error) {
     }
     return userSentenceFor(error);
 }
-//# sourceMappingURL=elicitation-answers.js.map