@teaflask/assistant 0.3.0 → 0.7.0

package/dist/contract/subscriptions.js

@@ -1,5 +1,35 @@
-// The subscription-connect surfaces. The shapes are generated
-// from serving-openapi.json; this file keeps the package's public names
-// stable over the generated ones.
-export {};
-//# sourceMappingURL=subscriptions.js.map
+const SUBSCRIPTION_CONNECT_MESSAGE_TYPE = "teaflask.subscription_connect";
+export function subscriptionConnectMessageOf(event, serverOrigin, provider) {
+    if (event.origin !== serverOrigin || event.source === null) {
+        return null;
+    }
+    const data = event.data;
+    if (typeof data !== "object" || data === null) {
+        return null;
+    }
+    const record = data;
+    if (record.type !== SUBSCRIPTION_CONNECT_MESSAGE_TYPE ||
+        record.provider !== provider) {
+        return null;
+    }
+    if (record.kind === "denied" || record.kind === "failed") {
+        return {
+            type: SUBSCRIPTION_CONNECT_MESSAGE_TYPE,
+            provider,
+            kind: record.kind,
+        };
+    }
+    if (record.kind === "code" &&
+        typeof record.code === "string" &&
+        typeof record.state === "string") {
+        return {
+            type: SUBSCRIPTION_CONNECT_MESSAGE_TYPE,
+            provider,
+            kind: "code",
+            code: record.code,
+            state: record.state,
+            client_id: typeof record.client_id === "string" ? record.client_id : null,
+        };
+    }
+    return null;
+}

package/dist/contract/telemetry.d.ts

@@ -1,48 +1,75 @@
-/** Why an attempted approval submit produced no request. */
+/**
+ * Why clicking approve or deny sent nothing. "no_active_thread" means no
+ * conversation was open; "card_missing" means the request was no longer shown;
+ * "already_submitting" is a repeat click while the first answer is sending;
+ * "not_actionable_answered" and "not_actionable_stale" mean the request had
+ * already been answered or was no longer open; "no_turn_id" means no turn could
+ * be found to answer.
+ */
 export type ApprovalSubmitDropReason = "no_active_thread" | "card_missing" | "already_submitting" | "not_actionable_answered" | "not_actionable_stale" | "no_turn_id";
-/** ApprovalCardStatus["kind"] (core/approval-inbox.ts) restated: the contract
- *  layer never imports core; the store's `card.status.kind` pass pins drift. */
 type ApprovalCardStatusKind = "actionable" | "submitting" | "answered" | "stale";
+/**
+ * Reported to onTelemetry as the user answers an approval, so you can spot
+ * answers that never reached the server.
+ */
 export interface ApprovalSubmitTelemetryEvent {
+    /**
+     * "approval_submit_attempted" when the user clicks approve or deny,
+     * "approval_submit_sent" when the answer is posted, and
+     * "approval_submit_dropped" when nothing was posted (see drop_reason).
+     */
     name: "approval_submit_attempted" | "approval_submit_sent" | "approval_submit_dropped";
+    /**
+     * The request's interrupt_id, the conversation's thread_id, whether it was
+     * approved and trusted, the request's on-screen status (actionable,
+     * submitting, answered or stale), whether its turn had parked, and the
+     * drop_reason for a dropped answer.
+     */
     properties: {
         interrupt_id: string;
         thread_id: string | null;
         approved: boolean;
         trusted: boolean;
-        /** The rendered card's status kind at handler entry. */
         card_status: ApprovalCardStatusKind;
         parked: boolean;
         drop_reason?: ApprovalSubmitDropReason;
     };
 }
-/** How a stream fetch failed: where in the request's life the wire died,
- *  since each class has a different owner (network, edge, origin, client). */
+/**
+ * Where a stream connection failed. "network_rejected" means no response
+ * arrived (offline, DNS, CORS); "http_error" is a non-2xx response; "no_body"
+ * is a 2xx with no readable body; "mid_stream" means the connection dropped
+ * after events had arrived; "parse_or_validation" means an event could not be
+ * read; "client_abort" is a cancellation by the widget and is not reported.
+ */
 export type StreamFailureClass = "network_rejected" | "http_error" | "no_body" | "mid_stream" | "parse_or_validation" | "client_abort";
-/** One stream failure, narrated for the host's analytics. Cursor fields
- *  locate it on the recorded log; NEVER message text, tool args or prompts. */
+/**
+ * Reported to onTelemetry when the conversation's live stream connection fails.
+ * Cancellations made by the widget itself are not reported.
+ */
 export interface StreamFailedTelemetryEvent {
+    /** Always "assistant_stream_failed". */
     name: "assistant_stream_failed";
+    /**
+     * Where the connection failed (failure_class), the HTTP status or null when
+     * no response arrived, the conversation's thread_id, and two stream
+     * positions, resume_cursor and last_committed_sse_id, that locate the
+     * failure in the conversation's event stream.
+     */
     properties: {
         failure_class: StreamFailureClass;
-        /** The HTTP status when a response arrived; null before one. */
         status: number | null;
         thread_id: string | null;
-        /** The resume snapshot's cursor a reconnect would replay past. */
         resume_cursor: string | null;
-        /** The last SSE `id:` the dying connection committed. */
         last_committed_sse_id: string | null;
     };
 }
+/**
+ * Any event passed to the provider's onTelemetry callback, for forwarding to
+ * your own analytics. None carry message text, tool arguments or prompts.
+ */
 export type AssistantTelemetryEvent = ApprovalSubmitTelemetryEvent | StreamFailedTelemetryEvent;
-/** Classify a stream failure off the transport's shapes: runHttpRequest
- *  stamps `.status` on a non-2xx, a missing body is its fixed sentence,
- *  protocol refusals are AGUIError, schema rejections are raw ZodErrors. A
- *  network death is a bare TypeError at BOTH ends of the request's life, so
- *  the caller says whether the body delivered any bytes (keepalives count):
- *  with bytes the wire died mid-stream; without, no response ever flowed. */
 export declare function streamFailureClassOf(error: Error, context: {
     sawBodyBytes: boolean;
 }): StreamFailureClass;
 export {};
-//# sourceMappingURL=telemetry.d.ts.map

package/dist/contract/telemetry.js

@@ -1,13 +1,4 @@
-// The package's product-telemetry seam: safety-critical human
-// controls must never fail silently, so the approval submit path narrates
-// itself as events the host forwards through onTelemetry (never an SDK here).
 import { AGUIError } from "@ag-ui/core";
-/** Classify a stream failure off the transport's shapes: runHttpRequest
- *  stamps `.status` on a non-2xx, a missing body is its fixed sentence,
- *  protocol refusals are AGUIError, schema rejections are raw ZodErrors. A
- *  network death is a bare TypeError at BOTH ends of the request's life, so
- *  the caller says whether the body delivered any bytes (keepalives count):
- *  with bytes the wire died mid-stream; without, no response ever flowed. */
 export function streamFailureClassOf(error, context) {
     if (error.name === "AbortError" || /\baborted?\b/i.test(error.message)) {
         return "client_abort";
@@ -26,4 +17,3 @@ export function streamFailureClassOf(error, context) {
     }
     return "mid_stream";
 }
-//# sourceMappingURL=telemetry.js.map

package/dist/contract/threads.d.ts

@@ -1,4 +1,7 @@
-export type { CreateServingAttachmentUploadResponse as AttachmentUploadIntent, HighlightResult, NavigateResult, PrefillFormResult, ReadPageResult, ResolveServingTurnApprovalRequest as ResolveTurnApprovalRequest, ResolveServingTurnApprovalResponse as ResolveTurnApprovalResponse, ResolveServingTurnToolResultsRequest as ResolveTurnToolResultsRequest, ResolveServingTurnToolResultsResponse as ResolveTurnToolResultsResponse, SendServingAssistantMessageRequest as SendAssistantMessageRequest, SendServingAssistantMessageResponse as SendAssistantMessageResponse, ServingApprovalDelivery as ApprovalDelivery, ServingAssistantThreadDetailResponse as AssistantThreadDetailResponse, ServingAssistantThreadResponse as ServingAssistantThread, ServingAssistantTurnResponse as ServingAssistantTurn, ServingAttachmentResponse as ServingAttachment, ServingTurnApprovalDecision as TurnApprovalDecision, ServingTurnAttachmentResponse as TurnAttachment, StopServingTurnResponse as StopTurnResponse, ThreadModelPickResponse as ThreadModelPick, AssistantTurnStatus as TurnStatus, } from "../generated/models/index.js";
+export type { CreateServingAttachmentUploadResponse as AttachmentUploadIntent, HighlightResult, NavigateResult, PrefillFormResult, ReadPageResult, ResolveServingTurnApprovalRequest as ResolveTurnApprovalRequest, ResolveServingTurnApprovalResponse as ResolveTurnApprovalResponse, ResolveServingTurnToolResultsRequest as ResolveTurnToolResultsRequest, ResolveServingTurnToolResultsResponse as ResolveTurnToolResultsResponse, SendServingAssistantMessageRequest as SendAssistantMessageRequest, SendServingAssistantMessageResponse as SendAssistantMessageResponse, ServingAssistantThreadDetailResponse as AssistantThreadDetailResponse, ServingAssistantThreadResponse as ServingAssistantThread, ServingAssistantTurnResponse as ServingAssistantTurn, ServingAttachmentResponse as ServingAttachment, ServingTurnAttachmentResponse as TurnAttachment, StopServingTurnResponse as StopTurnResponse, ThreadModelPickResponse as ThreadModelPick, AssistantTurnStatus as TurnStatus, } from "../generated/models/index.js";
+/**
+ * The longest message a user can send, in characters; the composer stops input
+ * at this length and the server rejects longer messages.
+ */
 export declare const ASSISTANT_MESSAGE_MAX_CHARS = 4000;
 export declare const ASSISTANT_MAX_ATTACHMENTS = 10;
-//# sourceMappingURL=threads.d.ts.map

package/dist/contract/threads.js

@@ -1,13 +1,2 @@
-// The conversation surfaces: send, list, detail, approval. The shapes are
-// generated from serving-openapi.json; this file keeps the package's
-// public names stable over the generated ones. The serving contract
-// stays normative for semantics (additive-only policy, tier rules).
-// Mirrors the send surface's message length bound, so the limit is felt
-// while typing rather than as a 422 after submitting. A runtime value the
-// schema carries only as a maxLength annotation — tests/contract-parity
-// pins it to serving-openapi.json.
 export const ASSISTANT_MESSAGE_MAX_CHARS = 4000;
-// Mirrors the send surface's attachment_ids bound the same way — the
-// composer refuses an eleventh chip instead of surfacing a 422.
 export const ASSISTANT_MAX_ATTACHMENTS = 10;
-//# sourceMappingURL=threads.js.map

package/dist/core/activity-title.js

@@ -1,8 +1,3 @@
-// Compact visible activity copy for a dispatch label: the first
-// MAX_TITLE_CHARS characters of the whitespace-collapsed label, with an
-// ellipsis when anything was cut. No sentence detection — a prefix is all
-// a one-line row needs, and callers keep the complete label in the title
-// attribute.
 const MAX_TITLE_CHARS = 64;
 export function activityTitleOf(label) {
     const compact = label.trim().replace(/\s+/g, " ");
@@ -11,4 +6,3 @@ export function activityTitleOf(label) {
     }
     return `${compact.slice(0, MAX_TITLE_CHARS - 1).trimEnd()}…`;
 }
-//# sourceMappingURL=activity-title.js.map

package/dist/core/activity.d.ts

@@ -1,17 +1,61 @@
 import type { ServingAssistantTurn, TurnStatus } from "../contract/threads.js";
 import type { ApprovalCardModel } from "./approval-inbox.js";
 import type { PendingDecisionGap } from "./pending-decision-gap.js";
+/** How the most recent finished turn of the conversation ended. */
 export interface AssistantActivityResult {
+    /**
+     * The id of that turn, which tells apart two identical outcomes in a row.
+     */
     turnId: string;
+    /**
+     * The final status. It is one of `succeeded`, `failed`, `stopped` (the user
+     * pressed Stop) or `superseded` (the user sent a new message instead of
+     * answering what the turn was waiting on).
+     */
     status: TurnStatus;
+    /**
+     * The error message recorded for a failed turn. Null when the turn did not
+     * fail or no message was recorded.
+     */
     failureSentence: string | null;
 }
+/**
+ * What the assistant is doing right now, for the open conversation. When no
+ * conversation is open, every field holds its idle value (false, 0 or null).
+ */
 export interface AssistantActivitySnapshot {
+    /**
+     * True while a message is being sent or the agent is working on a reply.
+     */
     busy: boolean;
+    /**
+     * The status of the latest turn (one message and the agent's work on it),
+     * or null when there is none. `queued` and `working` mean in progress.
+     * `awaiting_input` means it is waiting on the user. `parked` means an
+     * approval went unanswered long enough for the run to pause, and answering
+     * still resumes it. The other values mean it has finished.
+     */
     newestTurnStatus: TurnStatus | null;
+    /**
+     * The id of the latest turn, or null. Use it to dismiss a notification for
+     * one turn without hiding later ones.
+     */
     newestTurnId: string | null;
+    /**
+     * How many approvals are waiting for the user to approve or deny, including
+     * ones being submitted.
+     */
     pendingApprovalCount: number;
+    /**
+     * Set when the agent is waiting on the user for something this page has no
+     * prompt for, so nothing on screen lets them respond. Null otherwise. The
+     * built-in UI then shows an alert with a reload button.
+     */
     pendingDecisionGap: PendingDecisionGap | null;
+    /**
+     * How the most recent finished turn ended. It stays until another turn
+     * finishes, and is null until one has or when you switch conversations.
+     */
     lastResult: AssistantActivityResult | null;
 }
 export declare const IDLE_ACTIVITY: AssistantActivitySnapshot;
@@ -22,21 +66,6 @@ export declare function activitySnapshotOf(args: {
     pendingDecisionGap: PendingDecisionGap | null;
     lastResult: AssistantActivityResult | null;
 }): AssistantActivitySnapshot;
-/** A settled turn becomes the feed's last result; a live one (queued,
- *  working, awaiting_input, parked) leaves the previous result standing.
- *  Machine turns (kind non-null, the delivery push) report here too,
- *  DELIBERATELY: this feed's contract is "how did the last thing end",
- *  not "did your message fail" — the conversation-level failure banner
- *  (failureSentenceOf) is the surface that hides them. */
 export declare function settledResultOf(turn: ServingAssistantTurn): AssistantActivityResult | null;
 export declare function sameActivitySnapshot(a: AssistantActivitySnapshot, b: AssistantActivitySnapshot): boolean;
-/** Terminal turn statuses — the run reached an outcome and will not
- *  produce further work. The completed-episode fold (core/run-folds.ts)
- *  keys on this rather than on "running" (queued/working) so a
- *  HITL pause (awaiting_input, parked) never unifies a turn mid-flight
- *  and then pops its prose back out of the fold on resume. The one
- *  settled-turn predicate in the package: the approval inbox's terminal
- *  reconcile and the execution inbox's ledger's-word close both read it,
- *  so the four words are spelled once against the generated union. */
 export declare function isTerminalTurnStatus(status: TurnStatus): boolean;
-//# sourceMappingURL=activity.d.ts.map

package/dist/core/activity.js

@@ -16,12 +16,6 @@ export function activitySnapshotOf(args) {
         lastResult: args.lastResult,
     };
 }
-/** A settled turn becomes the feed's last result; a live one (queued,
- *  working, awaiting_input, parked) leaves the previous result standing.
- *  Machine turns (kind non-null, the delivery push) report here too,
- *  DELIBERATELY: this feed's contract is "how did the last thing end",
- *  not "did your message fail" — the conversation-level failure banner
- *  (failureSentenceOf) is the surface that hides them. */
 export function settledResultOf(turn) {
     if (!isTerminalTurnStatus(turn.status)) {
         return null;
@@ -37,8 +31,6 @@ export function sameActivitySnapshot(a, b) {
         a.newestTurnStatus === b.newestTurnStatus &&
         a.newestTurnId === b.newestTurnId &&
         a.pendingApprovalCount === b.pendingApprovalCount &&
-        // Reference identity is sound: the store keeps the published gap
-        // reference-stable while its signature holds.
         a.pendingDecisionGap === b.pendingDecisionGap &&
         _sameResult(a.lastResult, b.lastResult));
 }
@@ -53,18 +45,9 @@ function _sameResult(a, b) {
 function _cardAwaitsTheHuman(card) {
     return card.status.kind === "actionable" || card.status.kind === "submitting";
 }
-/** Terminal turn statuses — the run reached an outcome and will not
- *  produce further work. The completed-episode fold (core/run-folds.ts)
- *  keys on this rather than on "running" (queued/working) so a
- *  HITL pause (awaiting_input, parked) never unifies a turn mid-flight
- *  and then pops its prose back out of the fold on resume. The one
- *  settled-turn predicate in the package: the approval inbox's terminal
- *  reconcile and the execution inbox's ledger's-word close both read it,
- *  so the four words are spelled once against the generated union. */
 export function isTerminalTurnStatus(status) {
     return (status === "succeeded" ||
         status === "failed" ||
         status === "superseded" ||
         status === "stopped");
 }
-//# sourceMappingURL=activity.js.map

package/dist/core/agent-identity.js

@@ -1,21 +1,4 @@
-// TeaFlask agent identity tokens (contract law 10). The DOM hooks
-// [data-tf-agent-identity] / [data-tf-subagent-identity] carry these as
-// their VALUES — a valueless hook is not an identity (TVC-090/091 read
-// the tokens, not the attributes' presence).
-//
-// Ownership note: this module mints the identity tokens alone; the
-// marks and their visible treatment are the renderer's. Every mark must
-// derive its token from this module — a second token spelling would
-// break TVC-091's cross-surface stability law.
-/** The primary assistant's identity token — one agent, one constant. */
 export const PRIMARY_AGENT_IDENTITY_TOKEN = "teaflask";
-/**
- * A subagent's identity token: the child SESSION is the coworker's
- * identity (a resume chain deliberately shares it — several asks
- * of ONE coworker wear one mark), and the prefix makes a collision with
- * the primary token structurally impossible.
- */
 export function subagentIdentityTokenOf(childSessionId) {
     return `subagent:${childSessionId}`;
 }
-//# sourceMappingURL=agent-identity.js.map

package/dist/core/approval-decision.js

@@ -1,8 +1,3 @@
-// Answering approvals: the one POST per decision, under the
-// self-narration law (attempted, sent, and every drop with its
-// reason), with the durable-turn-first target resolution the execution
-// driver also follows. turnIdAnsweredBy is exported for the elicitation
-// submit, its documented twin.
 import { resolveTurnApproval } from "../transport/serving-api.js";
 import { ServingApiError } from "../transport/serving-error.js";
 import { ANSWER_NOT_SENT_SENTENCE, } from "./approval-inbox.js";
@@ -10,17 +5,10 @@ import { publishApprovalCards } from "./epoch-sync.js";
 import { userSentenceFor } from "./error-copy.js";
 export async function submitApprovalDecisionFromStore(store, card, decision) {
     const active = store._active;
-    // Only a card that advertised the affordance may speak trust — the
-    // door degrades a stray token to a plain approval anyway; this keeps
-    // the wire honest from here.
     const trusting = decision.trust === true && !card.gated && card.trustAvailable;
     const telemetry = _approvalTelemetryOf(store, card, decision, trusting, active);
     telemetry("approval_submit_attempted");
-    // No epoch gate here on purpose: the POST needs only session + thread
-    // + inbox, and a parked turn legitimately holds no socket.
     if (active === null) {
-        // Should be impossible while a card renders (cards come from the
-        // active thread's inbox) — say so loudly instead of swallowing it.
         telemetry("approval_submit_dropped", "no_active_thread");
         store.deps.reportError(new Error(`Approval decision dropped: no active conversation to answer into (interrupt ${card.interruptId}).`));
         return;
@@ -30,13 +18,6 @@ export async function submitApprovalDecisionFromStore(store, card, decision) {
         _explainBeginSubmitRefusal(store, inbox, card, telemetry);
         return;
     }
-    // Confine every shared-cell write to this submit's own inbox: a
-    // thread switch during the POST replaces the active conversation, and
-    // publishing the resolved OLD inbox's cards would stamp a foreign
-    // approval onto the now-active thread until its stream next publishes.
-    // Deliberately the INBOX's identity, not the epoch's or _active's: a
-    // reconnect (or any refresh) on the same thread keeps this inbox, and
-    // the submit's progress must keep rendering straight through it.
     const publishIfCurrent = () => {
         if (store._active?.approvalInbox === inbox) {
             publishApprovalCards(store, inbox.cards());
@@ -48,11 +29,6 @@ export async function submitApprovalDecisionFromStore(store, card, decision) {
     }
     catch (error) {
         if (_turnNoLongerAwaiting(error)) {
-            // Timed out, or answered in another tab: the whole pause is over.
-            // Re-read the thread for its settled truth (busy flag, and the
-            // timeout sentence rides the failure banner). A coworker's 409
-            // speaks for its card alone — the turn's own pause,
-            // if any, is untouched.
             if (card.asker.kind === "coworker") {
                 inbox.markCoworkerCardStale(card.interruptId);
             }
@@ -85,20 +61,12 @@ function _approvalTelemetryOf(store, card, decision, trusting, active) {
         });
     };
 }
-// beginSubmit refused: the rendered card lagged the live one, or the
-// first submit is already in flight — narrate the drop and, when the live
-// truth moved, re-read it so reconciliation visibly settles what the user
-// is seeing.
 function _explainBeginSubmitRefusal(store, inbox, card, telemetry) {
     const liveKind = inbox.statusOf(card.interruptId);
     if (liveKind === "submitting") {
-        // A benign double-click: the first submit is in flight and the
-        // live card already renders its spinner.
         telemetry("approval_submit_dropped", "already_submitting");
         return;
     }
-    // The rendered card lagged the live one — re-read the durable
-    // truth so reconciliation visibly settles what the user is seeing.
     telemetry("approval_submit_dropped", liveKind === "answered"
         ? "not_actionable_answered"
         : liveKind === "stale"
@@ -108,11 +76,7 @@ function _explainBeginSubmitRefusal(store, inbox, card, telemetry) {
         void store.refreshConversation();
     }
 }
-// The POST itself and its delivery arms — target resolution, the one
-// answer per POST, and what each delivery verdict means for the pause.
 async function _postApprovalDecision(store, active, inbox, card, decision, trusting, telemetry) {
-    // A coworker's card has exactly one door — its dispatching turn,
-    // whatever that turn's status (the execution driver's rule).
     const turnId = card.asker.kind === "coworker"
         ? card.turnId
         : await _turnIdAwaitingInterrupt(store, card, active);
@@ -122,8 +86,6 @@ async function _postApprovalDecision(store, active, inbox, card, decision, trust
         return;
     }
     telemetry("approval_submit_sent");
-    // One answer per POST — sibling cards stay individually actionable,
-    // and the workflow resumes once every pending ask is answered.
     const resolution = await resolveTurnApproval(store.deps.session, active.thread.id, turnId, {
         approvals: [
             {
@@ -136,56 +98,16 @@ async function _postApprovalDecision(store, active, inbox, card, decision, trust
             },
         ],
     });
-    // Delivery is asynchronous (the response's turn still says
-    // awaiting_input); on a live pause the stream's own resume closes
-    // the card. An answer that restarted a parked turn's workflow has
-    // no live stream to do that — reconnecting is what picks up the
-    // restarted run (and its approval_resolved receipt keeps the
-    // replayed card answered).
     inbox.settleSubmitAnswered(card.interruptId, decision.approved, trusting);
-    if (
-    // Confined like every post-await read: the reclaim probes exist
-    // to un-freeze the conversation being VIEWED, and after a
-    // mid-POST thread switch there is nothing here to un-freeze —
-    // reopening the thread reconnects on adoption, while the probes
-    // would bounce the other thread's epoch for nothing.
-    store._active?.approvalInbox === inbox) {
+    if (store._active?.approvalInbox === inbox) {
         if (resolution.delivery === "workflow_restarted") {
             store.handleWorkflowRestarted();
         }
         else if (resolution.delivery === "already_consumed") {
-            // The receipt: the answer is already past the door —
-            // the turn's own once a resume consumed it and then died parked, or
-            // a coworker's once its row left paused with the decision
-            // recorded, or paused again at a newer round — nothing
-            // was restarted, so no reconnect will ever arrive to move the
-            // conversation past this pause.
-            // Re-read the turn for its
-            // current truth (the contract's instruction): the refreshed
-            // projection subtracts consumed ids, so the pause
-            // retires instead of rendering a wait nothing will resume.
             void store.refreshConversation();
         }
     }
 }
-// The turn to answer, resolved durable-turn-first (the execution
-// driver's stance): the newest turn that still awaits this interrupt
-// names the POST's target — which stays correct after a park-restart,
-// when the card's stamped run id names a run the ledger never saw. One
-// refresh covers a stale read; a queued message can sit
-// NEWER than the pause, so the refreshed check also consults the
-// newest ANSWERABLE turn, not just the newest row. The CAPTURED
-// conversation's ledger remains as the fallback (absent
-// pending_interrupt_ids must never read as empty, and the door's own
-// 409 backstops a wrong guess).
-//
-// Confinement (the publishIfCurrent law): the first _newestTurn read
-// runs before any await in the submit, so it still belongs to the
-// captured conversation; every read AFTER the refresh trusts the
-// store-global turn only while the submit's inbox is still the active
-// one — a thread switch mid-refresh would otherwise resolve thread B's
-// turn id and POST it to thread A's approval URL. The captured ledger
-// is switch-proof by construction.
 async function _turnIdAwaitingInterrupt(store, card, active) {
     if (_turnAwaitsInterrupt(store._newestTurn, card.interruptId)) {
         return store._newestTurn?.id ?? null;
@@ -202,14 +124,6 @@ async function _turnIdAwaitingInterrupt(store, card, active) {
     const ledger = active.ledger;
     return (ledger.turnForRun(card.runId) ?? ledger.newestTurn())?.turnId ?? null;
 }
-// The elicitation submit's twin of _turnIdAwaitingInterrupt: the
-// ledger names the pausing run when it can; a lost capture (or
-// another tab's send) refreshes and then consults the ANSWERABLE turn
-// — a queued message can sit newer than the pause, so
-// the ledger's newest record may be a QUEUED turn whose POST would
-// 409. Same confinement as the sibling: store-global turns are
-// trusted only while this submit's inbox is still the active one.
-// ledger.newestTurn() stays the last resort, 409-backstopped.
 export async function turnIdAnsweredBy(store, active, card) {
     const ledger = active.ledger;
     const known = ledger.turnForRun(card.runId);
@@ -231,16 +145,6 @@ export async function turnIdAnsweredBy(store, active, card) {
     }
     return ledger.newestTurn()?.turnId ?? null;
 }
-// The sibling of the execution driver's durable-turn guard: a
-// turn is answerable iff it still pauses (awaiting_input or parked — a
-// late answer restarts a parked turn) and still holds the interrupt. Two
-// tolerances mirror the driver's: a null run_id is a lost capture, where
-// the server hides the cards (the set reads empty though the pause is
-// real), so the status gate alone holds; and a server predating
-// pending_interrupt_ids sends no array at all, which degrades to the
-// status gate too — an actual empty list under a captured run means the
-// pause moved on, so absent must never read as empty. A wrong yes is
-// backstopped by the door's own 409.
 function _turnAwaitsInterrupt(turn, interruptId) {
     if (turn === null) {
         return false;
@@ -256,4 +160,3 @@ function _turnNoLongerAwaiting(error) {
     return (error instanceof ServingApiError &&
         error.code === "ASSISTANT_TURN_NOT_AWAITING_APPROVAL");
 }
-//# sourceMappingURL=approval-decision.js.map