@teaflask/assistant 0.3.0 → 0.6.0

package/dist/core/run-status.js

@@ -1,21 +1,3 @@
-// The status announcer's ladder, pure of
-// React and of the wire. Chrome does not narrate run state visibly —
-// the actionable thing is its own signal — so this ladder serves only
-// the sr-only live region. Honesty rule: the wire's awaiting_input and
-// parked statuses record lifecycle, not who the run waits on (a subagent
-// park ships the same "parked" as a HITL pause), so "waiting" is claimed
-// only while an actionable decision actually exists; a pause with no
-// pending decision is the machine's time (delegated children are
-// running, or the execution driver is answering) and reads "working".
-// Terminal states map to null: transient status disappears at settle,
-// and the durable "Worked for …" story belongs to the settled fold
-// headline (core/run-folds.ts).
-/**
- * Map the newest turn's wire status, plus the one fact the status enum
- * cannot carry — whether a member-actionable decision is live — onto the
- * announcer's register. `decisionsPending` comes from the decision
- * surfaces themselves (the cards), never inferred from what rendered.
- */
 export function announcedStatusOf(status, decisionsPending) {
     if (status === "queued" || status === "working") {
         return "working";
@@ -25,17 +7,6 @@ export function announcedStatusOf(status, decisionsPending) {
     }
     return null;
 }
-/**
- * The VISIBLE liveness register: whether the run reads as the
- * machine's time — the fold headline's "Working…", the tool rows'
- * running-vs-pending projection, the jump affordance's live treatment.
- * One function with the announcer, on purpose: the fold used to derive
- * liveness from the REST-only queued/working status (never advanced by
- * a stream event), so an approved live pause read "Worked for <1s" above
- * a running tool row while the sr-only region honestly said "working".
- * Parity is now by construction — the two registers cannot disagree.
- */
 export function runReadsAsWorking(status, decisionsPending) {
     return announcedStatusOf(status, decisionsPending) === "working";
 }
-//# sourceMappingURL=run-status.js.map

package/dist/core/segment-timing.d.ts

@@ -1,33 +1,13 @@
-/** One transcript block's observed server timing: the earliest and latest
- *  emit-side timestamp seen for its id. Either half may be null — old
- *  histories carry no timestamps, and an open block has no settle yet. */
 export interface BlockTiming {
     startedAtMs: number | null;
     settledAtMs: number | null;
 }
-/** The typed unknown-vs-measured distinction: `measured` under 1000 ms is
- *  the sub-second case (render "<1s", never "0s"); `unknown` means the
- *  evidence does not exist and the UI hides the duration entirely. */
 export type SegmentDuration = {
     kind: "unknown";
 } | {
     kind: "measured";
     durationMs: number;
 };
-/** The settled fold reduction: earliest observed start to latest observed
- *  settle across the members. Members without evidence contribute nothing;
- *  a fold with no timestamped member is unknown. A settle counts as a start
- *  bound too — a block observed only at its settle is still inside. */
 export declare function settledFoldDurationOf(members: readonly BlockTiming[]): SegmentDuration;
-/** The house duration vocabulary for every duration surface: "12s",
- *  "3m 04s", "1h 07m", with the sub-second floor "<1s" — "0s" is not in the
- *  register. The subagent roster's settledDurationLabelOf delegates here. */
 export declare function durationLabelOf(durationMs: number): string;
-/** The active fold's elapsed time: the persisted server start to the
- *  caller's "now"; with no persisted start there is none — unknown, never a
- *  mount-relative stopwatch. CAUTION: a client `Date.now()` as `nowMs` is a
- *  cross-clock-domain subtraction carrying the device's full offset from the
- *  server. No widget chrome consumes this; reach for it only with
- *  a server-derived `nowMs`, or where the surface accepts the skew. */
 export declare function activeFoldElapsedOf(members: readonly BlockTiming[], nowMs: number): SegmentDuration;
-//# sourceMappingURL=segment-timing.d.ts.map

package/dist/core/segment-timing.js

@@ -1,13 +1,4 @@
-// The duration contract, pure of React and of the wire. Two laws:
-// a fold's duration reduces over its MEMBER blocks' emit-side server
-// timestamps — earliest start, latest settle — never turn-level evidence;
-// and "unknown" and "sub-second" are DIFFERENT states held apart by type, so
-// no consumer renders "Worked for 0s" (docs/transcript-rows-and-folds.md).
 const UNKNOWN = { kind: "unknown" };
-/** The settled fold reduction: earliest observed start to latest observed
- *  settle across the members. Members without evidence contribute nothing;
- *  a fold with no timestamped member is unknown. A settle counts as a start
- *  bound too — a block observed only at its settle is still inside. */
 export function settledFoldDurationOf(members) {
     let earliest = null;
     let latest = null;
@@ -23,13 +14,8 @@ export function settledFoldDurationOf(members) {
     if (earliest === null || latest === null) {
         return UNKNOWN;
     }
-    // A single flush can stamp a whole coalesced batch with one instant:
-    // that is a MEASURED zero — a real sub-second span — never unknown.
     return { kind: "measured", durationMs: Math.max(0, latest - earliest) };
 }
-/** The house duration vocabulary for every duration surface: "12s",
- *  "3m 04s", "1h 07m", with the sub-second floor "<1s" — "0s" is not in the
- *  register. The subagent roster's settledDurationLabelOf delegates here. */
 export function durationLabelOf(durationMs) {
     if (durationMs < 1_000) {
         return "<1s";
@@ -45,12 +31,6 @@ export function durationLabelOf(durationMs) {
     const hours = Math.floor(totalMinutes / 60);
     return `${String(hours)}h ${String(totalMinutes % 60).padStart(2, "0")}m`;
 }
-/** The active fold's elapsed time: the persisted server start to the
- *  caller's "now"; with no persisted start there is none — unknown, never a
- *  mount-relative stopwatch. CAUTION: a client `Date.now()` as `nowMs` is a
- *  cross-clock-domain subtraction carrying the device's full offset from the
- *  server. No widget chrome consumes this; reach for it only with
- *  a server-derived `nowMs`, or where the surface accepts the skew. */
 export function activeFoldElapsedOf(members, nowMs) {
     let earliest = null;
     for (const member of members) {
@@ -65,4 +45,3 @@ export function activeFoldElapsedOf(members, nowMs) {
     }
     return { kind: "measured", durationMs: Math.max(0, nowMs - earliest) };
 }
-//# sourceMappingURL=segment-timing.js.map

package/dist/core/settle-refresh.d.ts

@@ -1,12 +1,4 @@
 export declare const SETTLE_REFRESH_DELAY_MS = 400;
-/**
- * The settle re-read's debounce: every settled run re-arms one timer, and
- * the re-read fires once the burst has been quiet for
- * SETTLE_REFRESH_DELAY_MS. What a settle refreshes is the owner's
- * (`onSettle`): the widget store re-reads the thread, the history list and
- * the funding gate; the playground hook re-reads the thread and
- * invalidates its thread-list query. The timing policy lives here, once.
- */
 export declare class SettleRefreshScheduler {
     private readonly onSettle;
     private timer;
@@ -15,4 +7,3 @@ export declare class SettleRefreshScheduler {
     dispose(): void;
     private clearTimer;
 }
-//# sourceMappingURL=settle-refresh.d.ts.map

package/dist/core/settle-refresh.js

@@ -1,15 +1,4 @@
-// A settled run means the thread's REST truth moved (busy flag, turn
-// statuses, maybe the title). Full replays settle every historical run in
-// a burst, so the re-read waits out the burst.
 export const SETTLE_REFRESH_DELAY_MS = 400;
-/**
- * The settle re-read's debounce: every settled run re-arms one timer, and
- * the re-read fires once the burst has been quiet for
- * SETTLE_REFRESH_DELAY_MS. What a settle refreshes is the owner's
- * (`onSettle`): the widget store re-reads the thread, the history list and
- * the funding gate; the playground hook re-reads the thread and
- * invalidates its thread-list query. The timing policy lives here, once.
- */
 export class SettleRefreshScheduler {
     onSettle;
     timer = null;
@@ -33,4 +22,3 @@ export class SettleRefreshScheduler {
         }
     }
 }
-//# sourceMappingURL=settle-refresh.js.map

package/dist/core/step-caption.d.ts

@@ -1,5 +1,2 @@
 export declare const STEP_CAPTION_ARG_KEY = "caption";
-/** `args` without the reserved key: the same object when the key is
- *  absent, else a copy — the source is never mutated. */
 export declare function withoutStepCaption(args: Record<string, unknown>): Record<string, unknown>;
-//# sourceMappingURL=step-caption.d.ts.map

package/dist/core/step-caption.js

@@ -1,14 +1,7 @@
-// The protocol-reserved argument key: every tool's schema
-// carries the model's `caption`, and it is the row's label, not an
-// argument — stripped before a tool view or an approval card reads the
-// arguments. A dependency-free leaf, so the approval narrowing stays one.
 export const STEP_CAPTION_ARG_KEY = "caption";
-/** `args` without the reserved key: the same object when the key is
- *  absent, else a copy — the source is never mutated. */
 export function withoutStepCaption(args) {
     if (!(STEP_CAPTION_ARG_KEY in args)) {
         return args;
     }
     return Object.fromEntries(Object.entries(args).filter(([key]) => key !== STEP_CAPTION_ARG_KEY));
 }
-//# sourceMappingURL=step-caption.js.map

package/dist/core/stop-copy.d.ts

@@ -1,2 +1 @@
 export declare const STOP_NOT_DELIVERED_SENTENCE = "The stop couldn't be delivered right now. Please try again in a moment.";
-//# sourceMappingURL=stop-copy.d.ts.map

package/dist/core/stop-copy.js

@@ -1,8 +1 @@
-// The stop door's failure vocabulary, as a dependency-free leaf:
-// a failed stop must never read as a failed send — the door's
-// own sentences pass through on every surface, and this one line covers
-// only transport deaths that never reached the door. Lives apart from
-// error-copy.ts, which imports the transport, so the ./transcript entry
-// can export it to the dashboard playground without paying that closure.
 export const STOP_NOT_DELIVERED_SENTENCE = "The stop couldn't be delivered right now. Please try again in a moment.";
-//# sourceMappingURL=stop-copy.js.map

package/dist/core/stop-settle.d.ts

@@ -1,17 +1,5 @@
 export declare const STOP_SETTLE_PROBES = 10;
-/**
- * The stop's bounded fallback probe: the workflow's stop exit lands
- * turn_stopped plus a quiet RUN_FINISHED on the stream (~2s), which the
- * ordinary settle machinery adopts — this loop is the dead-stream corner's
- * fallback, one re-read per beat until the settle shows up or the budget
- * runs out. `stillAwaitsSettle` is read fresh behind every await (thread
- * switches and the settle machinery move the owner's fields while the
- * probe sleeps). Returns true when the budget is exhausted with the stop
- * still unsettled — the caller releases its "Stopping…" lock; false when
- * the settle landed (or the stop lost its thread) mid-probe.
- */
 export declare function probeStopSettle(deps: {
     refresh: () => Promise<void>;
     stillAwaitsSettle: () => boolean;
 }): Promise<boolean>;
-//# sourceMappingURL=stop-settle.d.ts.map

package/dist/core/stop-settle.js

@@ -1,21 +1,5 @@
 import { SETTLE_REFRESH_DELAY_MS } from "./settle-refresh.js";
-// How many SETTLE_REFRESH_DELAY_MS beats a stop's fallback re-read keeps
-// probing for the ~2s stop exit before releasing the "Stopping…" lock.
-// Its own constant on purpose: the sibling probe budgets (restart
-// reclaim, delivery claim) answer different questions and may be retuned
-// without silently changing how long a stop narrates.
 export const STOP_SETTLE_PROBES = 10;
-/**
- * The stop's bounded fallback probe: the workflow's stop exit lands
- * turn_stopped plus a quiet RUN_FINISHED on the stream (~2s), which the
- * ordinary settle machinery adopts — this loop is the dead-stream corner's
- * fallback, one re-read per beat until the settle shows up or the budget
- * runs out. `stillAwaitsSettle` is read fresh behind every await (thread
- * switches and the settle machinery move the owner's fields while the
- * probe sleeps). Returns true when the budget is exhausted with the stop
- * still unsettled — the caller releases its "Stopping…" lock; false when
- * the settle landed (or the stop lost its thread) mid-probe.
- */
 export async function probeStopSettle(deps) {
     if (!deps.stillAwaitsSettle()) {
         return false;
@@ -29,4 +13,3 @@ export async function probeStopSettle(deps) {
     }
     return deps.stillAwaitsSettle();
 }
-//# sourceMappingURL=stop-settle.js.map

package/dist/core/stream-trouble.d.ts

@@ -3,4 +3,3 @@ export declare function handleStreamErrorFromStore(store: AssistantConversationS
 export declare function handleStreamClosedQuietlyFromStore(store: AssistantConversationStore, stillStreaming: () => boolean): void;
 export declare function retryStreamFromStore(store: AssistantConversationStore): void;
 export declare function handleWorkflowRestartedFromStore(store: AssistantConversationStore): void;
-//# sourceMappingURL=stream-trouble.d.ts.map

package/dist/core/stream-trouble.js

@@ -1,27 +1,13 @@
-// Stream trouble: what the store does when the live stream misbehaves —
-// a wire error, a terminal-free quiet close, the member's retry, and the
-// post-restart reconnect that waits for a restarted workflow to reclaim
-// its parked turn.
 import { streamFailureClassOf } from "../contract/telemetry.js";
 import { getAssistantThread } from "../transport/serving-api.js";
 import { adoptRefreshedDetail, refreshThreads, } from "./conversation-adoption.js";
 import { settlesFor } from "./conversation-refresh.js";
 import { publishStore } from "./conversation-publish.js";
 import { SETTLE_REFRESH_DELAY_MS } from "./settle-refresh.js";
-// How many SETTLE_REFRESH_DELAY_MS beats the post-restart reconnect will
-// wait for the restarted workflow to reclaim its parked turn before
-// reconnecting regardless.
 const RESTART_RECLAIM_PROBES = 10;
 export function handleStreamErrorFromStore(store, error) {
     store._streamInterrupted = true;
     publishStore(store);
-    // The failure, classified for the host's analytics: where the
-    // wire died and the cursors that locate it. Deliberately no run content.
-    // sawBodyBytes' premise: the scanner sets it on the first SSE body chunk
-    // of a connection — keepalive comments included, so a live-but-idle
-    // resumed stream still reads as mid-stream when the edge cuts it — and
-    // headers alone never set it. The store connects ONCE per epoch (a fresh
-    // scanner per connection), so the flag is a fact about THIS connection.
     store.deps.onTelemetry({
         name: "assistant_stream_failed",
         properties: {
@@ -34,20 +20,9 @@ export function handleStreamErrorFromStore(store, error) {
             last_committed_sse_id: store._epoch?.agent.resumeCursor ?? null,
         },
     });
-    // Re-read the truth: a RUN_ERROR that settled the turn failed shows
-    // up as busy=false + the turn's failure sentence, which suppresses
-    // the interruption banner in favor of the honest failure notice.
     store._scheduleSettleRefresh();
     store.deps.reportError(error);
 }
-// A stream that ends without a terminal event is either a parked turn
-// (the designed quiet close) or a dropped connection wearing the
-// same wire shape — REST is the authority. The re-read alone is most of
-// the answer: it unlocks the composer after a live park (busy rides
-// thread.busy, and parking released the thread pointer) and renders any
-// settled outcome honestly (turnFailure for failed; superseded stays
-// banner-free — its receipt row is the honest rendering). Only a turn
-// the workflow still owns means the connection died under us.
 export function handleStreamClosedQuietlyFromStore(store, stillStreaming) {
     const active = store._active;
     if (active === null) {
@@ -56,12 +31,6 @@ export function handleStreamClosedQuietlyFromStore(store, stillStreaming) {
     getAssistantThread(store.deps.session, active.thread.id)
         .then((detail) => {
         adoptRefreshedDetail(store, detail);
-        // The detail is stale once the visitor moves to another thread
-        // mid-flight — its verdict must not raise a banner over the new
-        // one. stillStreaming is read after the round-trip on purpose: a
-        // detach-and-reconnect (StrictMode's double connect) ends the
-        // first run terminal-free, but by now the replacement is
-        // running and no banner belongs.
         if (store._active?.thread.id === detail.thread.id &&
             _workflowStillOwnsTurn(detail.turns.at(-1)?.status) &&
             !stillStreaming()) {
@@ -71,8 +40,6 @@ export function handleStreamClosedQuietlyFromStore(store, stillStreaming) {
         void refreshThreads(store);
     })
         .catch(() => {
-        // A blip here self-heals like every other refresh: the
-        // visitor's next action re-reads the thread.
     });
 }
 export function retryStreamFromStore(store) {
@@ -81,13 +48,6 @@ export function retryStreamFromStore(store) {
     store._reconnectNonce += 1;
     publishStore(store);
 }
-// Answering a parked card restarts its workflow, and only a fresh
-// connection can tail the restarted run — but the reconnect must not race
-// the workflow's reclaim (parked → working is a worker pickup after the
-// endpoint returns): a stream connected while the turn still reads parked
-// closes quietly again and freezes on the stale pause. So wait for REST to
-// show the turn moving, bounded — the restart is durably started, and on
-// exhaustion the reconnect happens anyway (full replay is always correct).
 export function handleWorkflowRestartedFromStore(store) {
     const active = store._active;
     if (active === null) {
@@ -107,7 +67,6 @@ export function handleWorkflowRestartedFromStore(store) {
                 }
             }
             catch {
-                // Keep probing; the reconnect below is the recovery either way.
             }
         }
         if (!store._disposed && store._active?.thread.id === threadId) {
@@ -115,15 +74,10 @@ export function handleWorkflowRestartedFromStore(store) {
         }
     })();
 }
-// The statuses a live workflow still owns; parked is deliberately not one
-// of them (the workflow exited, the turn waits for its late answer).
 function _workflowStillOwnsTurn(status) {
     return (status === "queued" || status === "working" || status === "awaiting_input");
 }
-// runHttpRequest stamps the response status on a non-2xx error; a
-// pre-response failure carries none.
 function _httpStatusOf(error) {
     const status = error.status;
     return typeof status === "number" ? status : null;
 }
-//# sourceMappingURL=stream-trouble.js.map

package/dist/core/subagent-brief.d.ts

@@ -1,7 +1,3 @@
 import type { Message } from "@ag-ui/core";
-/** The task the parent dispatched to this child, or null while the
- *  parent's call or its receipt has not landed. */
 export declare function openingBriefOf(parentMessages: readonly Message[], childSessionId: string): string | null;
-/** The child's messages led by its brief, when there is one. */
 export declare function withOpeningBrief(childMessages: readonly Message[], brief: string | null, childSessionId: string): readonly Message[];
-//# sourceMappingURL=subagent-brief.d.ts.map

package/dist/core/subagent-brief.js

@@ -1,10 +1,4 @@
-// A child's opening brief as its transcript's first user row. The child's
-// log carries only the assistant's side (the parent's user side comes
-// from turn rows); the brief's full text lives on the parent's
-// dispatch_subagent call, joined to the child by its receipt.
 import { DISPATCH_SUBAGENT_TOOL_NAME, dispatchedTaskOf, dispatchReceiptOf, } from "./subagent-rows.js";
-/** The task the parent dispatched to this child, or null while the
- *  parent's call or its receipt has not landed. */
 export function openingBriefOf(parentMessages, childSessionId) {
     const results = _toolResultsByCallIdOf(parentMessages);
     for (const message of parentMessages) {
@@ -20,7 +14,6 @@ export function openingBriefOf(parentMessages, childSessionId) {
     }
     return null;
 }
-/** The child's messages led by its brief, when there is one. */
 export function withOpeningBrief(childMessages, brief, childSessionId) {
     if (brief === null) {
         return childMessages;
@@ -43,4 +36,3 @@ function _isDispatchOfChild(call, result, childSessionId) {
     return (call.function.name === DISPATCH_SUBAGENT_TOOL_NAME &&
         dispatchReceiptOf(result)?.childSessionId === childSessionId);
 }
-//# sourceMappingURL=subagent-brief.js.map

package/dist/core/subagent-delivery-anchors.d.ts

@@ -5,37 +5,7 @@ export interface DeliveredResult {
     succeeded: boolean;
 }
 export declare const EMPTY_SUBAGENT_DELIVERY_ANCHORS: ReadonlyMap<string, DeliveredResult[]>;
-/**
- * Narrow a subagent_results_delivered CUSTOM event's wire value (any by
- * contract). Entries without a numeric ordinal are dropped; a missing
- * label degrades to "" and a missing succeeded to true (the wire's own
- * default). Null when nothing valid survives — the contract's "clients
- * MUST ignore events and fields they do not recognize".
- */
 export declare function deliveredResultsOf(value: unknown): DeliveredResult[] | null;
-/**
- * First anchor wins, ever: the marker is emitted at most once per
- * delivery run, so a second anchoring under the same message id is a
- * replay's re-delivery, never new information.
- */
 export declare function withSubagentDeliveryAnchored(previous: ReadonlyMap<string, DeliveredResult[]>, messageId: string, results: DeliveredResult[]): ReadonlyMap<string, DeliveredResult[]>;
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * entries that do not hold well-formed results are dropped rather than
- * rendered (or crashed on). The store is in-memory today, so every entry
- * it holds passed the payload narrower — this seam is where any future
- * persisted form of the store must degrade gracefully instead of wedging
- * the resume path: a dropped receipt reappears on the next full replay.
- */
 export declare function wellFormedDeliveryAnchorsOf(stored: ReadonlyMap<string, DeliveredResult[]>): ReadonlyMap<string, DeliveredResult[]>;
-/**
- * Anchors each subagent_results_delivered marker to the first message
- * that appears after it — the delivery run's first assistant message,
- * since the marker is the run's first stored row and a delivery turn
- * has no user bubble. Run-bounded: a pending marker never leaks onto a
- * later run's first message, and the run id rides to the caller so the
- * store can anchor once per delivery run no matter where each
- * connection's message list has drifted to at flush time.
- */
 export declare function subagentDeliveryMarkerRecorder(onDeliveryAnchored: (deliveryRunId: string, messageId: string, results: DeliveredResult[]) => void): AgentSubscriber;
-//# sourceMappingURL=subagent-delivery-anchors.d.ts.map

package/dist/core/subagent-delivery-anchors.js

@@ -1,24 +1,6 @@
-// The delivery-receipt anchor model, pure of React: a
-// machine-started delivery turn opens its run with a
-// subagent_results_delivered marker naming the settled dispatches it
-// pushes. The recorder anchors each marker to the run's first message,
-// the transcript renders a quiet divider before it, and the resume
-// store holds the anchors across remounts (a snapshot-seeded reconnect
-// replays only past the cursor, so historical receipts never re-arrive
-// on the wire).
 import { SUBAGENT_RESULTS_DELIVERED_EVENT_NAME, } from "../contract/events.js";
-// The label is the dispatch's bounded excerpt today, but the narrower
-// distrusts the wire by contract; a runaway string is retained capped,
-// never unbounded.
 const LABEL_MAX_CHARS = 200;
 export const EMPTY_SUBAGENT_DELIVERY_ANCHORS = new Map();
-/**
- * Narrow a subagent_results_delivered CUSTOM event's wire value (any by
- * contract). Entries without a numeric ordinal are dropped; a missing
- * label degrades to "" and a missing succeeded to true (the wire's own
- * default). Null when nothing valid survives — the contract's "clients
- * MUST ignore events and fields they do not recognize".
- */
 export function deliveredResultsOf(value) {
     if (typeof value !== "object" || value === null) {
         return null;
@@ -46,11 +28,6 @@ export function deliveredResultsOf(value) {
     }
     return results.length > 0 ? results : null;
 }
-/**
- * First anchor wins, ever: the marker is emitted at most once per
- * delivery run, so a second anchoring under the same message id is a
- * replay's re-delivery, never new information.
- */
 export function withSubagentDeliveryAnchored(previous, messageId, results) {
     if (previous.has(messageId)) {
         return previous;
@@ -59,18 +36,8 @@ export function withSubagentDeliveryAnchored(previous, messageId, results) {
     next.set(messageId, results);
     return next;
 }
-/**
- * A defensive copy for seeding transcript state from the resume store:
- * entries that do not hold well-formed results are dropped rather than
- * rendered (or crashed on). The store is in-memory today, so every entry
- * it holds passed the payload narrower — this seam is where any future
- * persisted form of the store must degrade gracefully instead of wedging
- * the resume path: a dropped receipt reappears on the next full replay.
- */
 export function wellFormedDeliveryAnchorsOf(stored) {
     const seeded = new Map();
-    // The narrowing deliberately distrusts the map's own types: this seam
-    // is what turns a stale shape into missing rows instead of a crash.
     const entries = stored;
     for (const [messageId, anchored] of entries) {
         if (!Array.isArray(anchored)) {
@@ -87,23 +54,10 @@ export function wellFormedDeliveryAnchorsOf(stored) {
     }
     return seeded;
 }
-/**
- * Anchors each subagent_results_delivered marker to the first message
- * that appears after it — the delivery run's first assistant message,
- * since the marker is the run's first stored row and a delivery turn
- * has no user bubble. Run-bounded: a pending marker never leaks onto a
- * later run's first message, and the run id rides to the caller so the
- * store can anchor once per delivery run no matter where each
- * connection's message list has drifted to at flush time.
- */
 export function subagentDeliveryMarkerRecorder(onDeliveryAnchored) {
     let pending = null;
     let currentRunId = null;
     return {
-        // One agent can be connected more than once (StrictMode detaches
-        // the first run terminal-free and starts over): a marker a dead
-        // connection collected but never flushed must not ride into the
-        // replacement's flush.
         onRunInitialized() {
             pending = null;
             currentRunId = null;
@@ -129,11 +83,8 @@ export function subagentDeliveryMarkerRecorder(onDeliveryAnchored) {
             pending = null;
             onDeliveryAnchored(marker.runId, newestMessage.id, marker.results);
         },
-        // A pathological message-less delivery run must not carry its
-        // divider into the next run's first message.
         onRunFinishedEvent() {
             pending = null;
         },
     };
 }
-//# sourceMappingURL=subagent-delivery-anchors.js.map

package/dist/core/subagent-presence.d.ts

@@ -1,38 +1,10 @@
 import type { ToolCallViewModel } from "./tool-call-display.js";
 import type { TranscriptRow } from "./transcript-rows.js";
-/** The deterministic per-coworker palette index (law 10): distinct children
- *  wear distinct colors, and the SAME child keeps the SAME color across the
- *  inline group, the roster, the child transcript, a reconnect and a full
- *  replay. Replay-stable by construction: coworkers rank by their FIRST
- *  ask's ordinal — a durable wire fact — so arrival and settle order can
- *  never permute it, and a resume chain keeps one index. 1-based. */
 export declare function coworkerIndicesOf(dispatches: Iterable<{
     ordinal: number;
     child_session_id: string;
 }>): ReadonlyMap<string, number>;
-/** A child transcript's newest LIVE tool call, as the presenter's view shape
- *  — the evidence behind the inline current-work line (TVC-072). Rows sit in
- *  TOOL_CALL_START order while results land in COMPLETION order, and every
- *  result-less call is input-available while the run streams (bar the
- *  retry-severed), so several live calls at once are normal: the
- *  scan walks past settled rows to the newest LIVE one, null when none is.
- *  Only `input-available` counts — `input-streaming` is never live here. */
 export declare function newestToolCallViewOf(rows: readonly TranscriptRow[]): ToolCallViewModel | null;
-/** Whether two published live views carry the same current-work EVIDENCE —
- *  the fields the running-arm headline reads: the model's `caption`, else
- *  the authored `progressText` when the wire annotated the call, else the
- *  tool name. The publish path
- *  may treat equal-evidence views as one fact; a consumer reading payload
- *  fields off the map must extend this comparison first. */
 export declare function sameCurrentWorkView(a: ToolCallViewModel, b: ToolCallViewModel): boolean;
-/** A settled dispatch's span in milliseconds — the ONE timestamp read behind
- *  both duration registers: null while the child runs and on unparseable
- *  timestamps (hidden, never invented); clock skew clamps to a measured
- *  zero, which the ladder renders "<1s" (TVC-073). */
 export declare function settledSpanMsOf(startedAt: string, settledAt: string | null): number | null;
-/** A settled dispatch's duration in the settled-fold register (law 2):
- *  "Worked for 12s" / "Worked for <1s" — sentence AND ladder come from
- *  settledFoldHeadlineOf, so "Worked for 0s" is unrenderable (TVC-073).
- *  Null while the child runs and on unparseable timestamps — never invents. */
 export declare function settledWorkedLabelOf(startedAt: string, settledAt: string | null): string | null;
-//# sourceMappingURL=subagent-presence.d.ts.map

package/dist/core/subagent-presence.js

@@ -1,14 +1,4 @@
-// Subagent presence derivations: the pure reads behind the
-// agent-identity variants, the inline current-work line and the roster's
-// settled-duration copy. Kept OUTSIDE subagent-roster.ts — these pull in
-// run-folds and tool-call-display; the roster imports from here, never back.
 import { settledFoldHeadlineOf } from "./run-folds.js";
-/** The deterministic per-coworker palette index (law 10): distinct children
- *  wear distinct colors, and the SAME child keeps the SAME color across the
- *  inline group, the roster, the child transcript, a reconnect and a full
- *  replay. Replay-stable by construction: coworkers rank by their FIRST
- *  ask's ordinal — a durable wire fact — so arrival and settle order can
- *  never permute it, and a resume chain keeps one index. 1-based. */
 export function coworkerIndicesOf(dispatches) {
     const firstOrdinalBySession = new Map();
     for (const dispatch of dispatches) {
@@ -24,13 +14,6 @@ export function coworkerIndicesOf(dispatches) {
     });
     return indices;
 }
-/** A child transcript's newest LIVE tool call, as the presenter's view shape
- *  — the evidence behind the inline current-work line (TVC-072). Rows sit in
- *  TOOL_CALL_START order while results land in COMPLETION order, and every
- *  result-less call is input-available while the run streams (bar the
- *  retry-severed), so several live calls at once are normal: the
- *  scan walks past settled rows to the newest LIVE one, null when none is.
- *  Only `input-available` counts — `input-streaming` is never live here. */
 export function newestToolCallViewOf(rows) {
     for (let rowIndex = rows.length - 1; rowIndex >= 0; rowIndex -= 1) {
         const row = rows[rowIndex];
@@ -43,12 +26,6 @@ export function newestToolCallViewOf(rows) {
     }
     return null;
 }
-/** Whether two published live views carry the same current-work EVIDENCE —
- *  the fields the running-arm headline reads: the model's `caption`, else
- *  the authored `progressText` when the wire annotated the call, else the
- *  tool name. The publish path
- *  may treat equal-evidence views as one fact; a consumer reading payload
- *  fields off the map must extend this comparison first. */
 export function sameCurrentWorkView(a, b) {
     return (a.toolName === b.toolName &&
         a.state === b.state &&
@@ -59,9 +36,6 @@ function _liveViewOf(row) {
     if (row.state !== "input-available") {
         return null;
     }
-    // The label-bearing fields only: currentWorkLabel derives from the
-    // headline ladder (display text → humanized tool name), never from the
-    // payload panes, so output stays off this narrow view.
     return {
         toolName: row.toolName,
         state: row.state,
@@ -70,10 +44,6 @@ function _liveViewOf(row) {
         display: row.display,
     };
 }
-/** A settled dispatch's span in milliseconds — the ONE timestamp read behind
- *  both duration registers: null while the child runs and on unparseable
- *  timestamps (hidden, never invented); clock skew clamps to a measured
- *  zero, which the ladder renders "<1s" (TVC-073). */
 export function settledSpanMsOf(startedAt, settledAt) {
     if (settledAt === null) {
         return null;
@@ -85,10 +55,6 @@ export function settledSpanMsOf(startedAt, settledAt) {
     }
     return Math.max(0, ended - started);
 }
-/** A settled dispatch's duration in the settled-fold register (law 2):
- *  "Worked for 12s" / "Worked for <1s" — sentence AND ladder come from
- *  settledFoldHeadlineOf, so "Worked for 0s" is unrenderable (TVC-073).
- *  Null while the child runs and on unparseable timestamps — never invents. */
 export function settledWorkedLabelOf(startedAt, settledAt) {
     const durationMs = settledSpanMsOf(startedAt, settledAt);
     if (durationMs === null) {
@@ -96,4 +62,3 @@ export function settledWorkedLabelOf(startedAt, settledAt) {
     }
     return settledFoldHeadlineOf({ kind: "measured", durationMs });
 }
-//# sourceMappingURL=subagent-presence.js.map