@teaflask/assistant 0.3.0 → 0.7.0

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.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.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.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.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

@@ -1,41 +1,18 @@
 import type { AgentSubscriber } from "@ag-ui/client";
+/** One finished sub-agent whose result a turn reports. */
 export interface DeliveredResult {
+    /**
+     * The sub-agent's number within the conversation, matching
+     * DispatchReceipt.ordinal of its dispatch.
+     */
     ordinal: number;
+    /** A short excerpt of the task the sub-agent was given. */
     label: string;
+    /** True when the sub-agent succeeded, false when it failed. */
     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-ledger-join.js

@@ -0,0 +1,176 @@
+import { dispatchFailed, dispatchIsPaused, dispatchIsRunning, } from "../contract/dispatches.js";
+import { subagentIdentityTokenOf } from "./agent-identity.js";
+import { DISPATCH_SUBAGENT_TOOL_NAME, dispatchReceiptOf, withSubagentGroups, } from "./subagent-rows.js";
+export function resolvedSubagentEntryOf(entry, byOrdinal) {
+    const ledger = entry.receipt != null ? byOrdinal.get(entry.receipt.ordinal) : undefined;
+    const ledgerLabel = ledger !== undefined && ledger.label !== "" ? ledger.label : null;
+    const childSessionId = ledger !== undefined && entry.receipt?.childSessionId != null
+        ? entry.receipt.childSessionId
+        : null;
+    const running = ledger !== undefined ? dispatchIsRunning(ledger) : entry.running;
+    const failed = ledger !== undefined ? dispatchFailed(ledger) : entry.failed;
+    return {
+        toolCallId: entry.toolCallId,
+        label: ledgerLabel ?? entry.label,
+        running,
+        failed,
+        cancelled: entry.cancelled,
+        note: (ledger !== undefined && dispatchFailed(ledger) ? ledger.error : null) ??
+            entry.note,
+        childSessionId,
+        identityToken: childSessionId !== null ? subagentIdentityTokenOf(childSessionId) : null,
+        ordinal: entry.receipt?.ordinal ?? null,
+        paused: ledger !== undefined && dispatchIsPaused(ledger),
+        startedAt: ledger !== undefined ? ledger.created_at : null,
+        settledAt: ledger !== undefined && !running ? ledger.updated_at : null,
+    };
+}
+export const RESUME_SUBAGENT_TOOL_NAME = "resume_subagent";
+export function demandInputOfRows(rows) {
+    const entries = [];
+    const resumeResults = [];
+    const deliveredOrdinals = [];
+    for (const row of rows) {
+        if (row.kind === "subagent-group") {
+            entries.push(...row.entries);
+        }
+        else if (row.kind === "tool-call" &&
+            row.toolName === RESUME_SUBAGENT_TOOL_NAME) {
+            resumeResults.push(row.result);
+        }
+        else if (row.kind === "subagent-delivery") {
+            deliveredOrdinals.push(...row.results.map((result) => result.ordinal));
+        }
+    }
+    return { entries, resumeResults, deliveredOrdinals };
+}
+export function demandInputOfMessages(messages, anchors) {
+    const results = new Map();
+    for (const message of messages) {
+        if (message.role === "tool" && typeof message.content === "string") {
+            results.set(message.toolCallId, message.content);
+        }
+    }
+    const calls = [];
+    const resumeResults = [];
+    for (const message of messages) {
+        if (message.role !== "assistant") {
+            continue;
+        }
+        for (const toolCall of message.toolCalls ?? []) {
+            const id = toolCall.id;
+            if (toolCall.function.name === RESUME_SUBAGENT_TOOL_NAME) {
+                resumeResults.push(results.get(id));
+                continue;
+            }
+            if (toolCall.function.name !== DISPATCH_SUBAGENT_TOOL_NAME) {
+                continue;
+            }
+            const failed = anchors.toolErrorAnchors.has(id);
+            const denied = !failed && (anchors.toolDenialAnchors?.has(id) ?? false);
+            const cancelled = !failed && !denied && anchors.toolCancelAnchors.has(id);
+            const refused = !failed && !denied && !cancelled && anchors.toolRefusalAnchors.has(id);
+            if (denied || refused) {
+                continue;
+            }
+            const result = results.get(id);
+            calls.push({
+                toolCallId: id,
+                settled: failed || cancelled || result !== undefined,
+                failed,
+                cancelled,
+                result,
+                errorText: undefined,
+                argsText: toolCall.function.arguments,
+            });
+        }
+    }
+    const entries = withSubagentGroups(calls, (call) => call, (call) => call.toolCallId).flatMap((row) => ("entries" in row ? row.entries : []));
+    const deliveredOrdinals = [];
+    for (const delivered of anchors.subagentDeliveryAnchors.values()) {
+        deliveredOrdinals.push(...delivered.map((result) => result.ordinal));
+    }
+    return { entries, resumeResults, deliveredOrdinals };
+}
+function aResumeAwaitsLedgerTruth(resumeResults, ledger) {
+    return resumeResults.some((result) => {
+        const receipt = dispatchReceiptOf(result);
+        if (receipt === null || receipt.outcome === "already_settled") {
+            return false;
+        }
+        const dispatched = ledger.get(receipt.ordinal);
+        return dispatched === undefined || dispatchIsRunning(dispatched);
+    });
+}
+function anySubagentStillRunning(entries, ledger) {
+    return entries.some((entry) => entry.receipt != null && resolvedSubagentEntryOf(entry, ledger).running);
+}
+export function dispatchDemandOf(input, byOrdinal) {
+    return {
+        delegated: input.entries.length > 0 ||
+            aResumeAwaitsLedgerTruth(input.resumeResults, EMPTY_BY_ORDINAL),
+        stillMoving: anySubagentStillRunning(input.entries, byOrdinal) ||
+            aResumeAwaitsLedgerTruth(input.resumeResults, byOrdinal),
+    };
+}
+const EMPTY_BY_ORDINAL = new Map();
+export function dispatchJoinKeyOf(input) {
+    const ordinals = new Set();
+    for (const entry of input.entries) {
+        if (entry.receipt !== null) {
+            ordinals.add(entry.receipt.ordinal);
+        }
+    }
+    for (const result of input.resumeResults) {
+        const receipt = dispatchReceiptOf(result);
+        if (receipt !== null) {
+            ordinals.add(receipt.ordinal);
+        }
+    }
+    return [...ordinals].sort((a, b) => a - b).join(",");
+}
+export function staleDeliveredOrdinalsKeyOf(input, byOrdinal) {
+    return [...new Set(input.deliveredOrdinals)]
+        .filter((ordinal) => {
+        const ledgerRow = byOrdinal.get(ordinal);
+        return ledgerRow !== undefined && dispatchIsRunning(ledgerRow);
+    })
+        .sort((a, b) => a - b)
+        .join(",");
+}
+export function withDispatchLedger(rows, byOrdinal) {
+    if (byOrdinal.size === 0) {
+        return rows;
+    }
+    let out = null;
+    for (const [index, row] of rows.entries()) {
+        if (row.kind !== "subagent-group") {
+            continue;
+        }
+        const joined = _joinedGroupRowOf(row, byOrdinal);
+        if (joined !== row) {
+            out ??= [...rows];
+            out[index] = joined;
+        }
+    }
+    return out ?? rows;
+}
+function _joinedGroupRowOf(row, byOrdinal) {
+    let entries = null;
+    for (const [index, entry] of row.entries.entries()) {
+        const resolved = resolvedSubagentEntryOf(entry, byOrdinal);
+        if (resolved.running === entry.running &&
+            resolved.failed === entry.failed &&
+            resolved.note === entry.note) {
+            continue;
+        }
+        entries ??= [...row.entries];
+        entries[index] = {
+            ...entry,
+            running: resolved.running,
+            failed: resolved.failed,
+            note: resolved.note,
+        };
+    }
+    return entries === null ? row : { ...row, entries };
+}

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

package/dist/core/subagent-roster.js

@@ -1,7 +1,3 @@
-// The conversation-wide subagent roster: the dispatch ledger's
-// rows bucketed for the count pill and its hover roster; the dashboard's
-// conversations pill imports it through agent-run/roster.ts. Status never
-// enters as a string: callers inject their own tree's predicates.
 import { durationLabelOf } from "./segment-timing.js";
 import { settledSpanMsOf } from "./subagent-presence.js";
 export function rosterEntriesOf(dispatches, predicates) {
@@ -16,9 +12,6 @@ export function rosterEntriesOf(dispatches, predicates) {
             label: dispatch.label === "" ? "Delegated task" : dispatch.label,
             running,
             failed,
-            // A failed row must carry a reason: error is nullable and the roster
-            // has no wire receipt to fall through to — the constant sentence is the
-            // guard every neighbouring surface keeps (dispatchRunOutcomeOf).
             note: failed
                 ? (dispatch.error ?? "The subagent failed before it could report back.")
                 : null,
@@ -26,18 +19,11 @@ export function rosterEntriesOf(dispatches, predicates) {
             settledAt: running ? null : dispatch.updated_at,
         });
     }
-    // Dispatch order, not settle order: the roster reads as the fan-outs the
-    // parent authored. One thread has ONE parent run, so ordinal is unique
-    // across the roster — the invariant the group rows' byOrdinal join depends
-    // on; startedAt leads the sort, ordinal is the deterministic tiebreak.
     entries.sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt) ||
         a.ordinal - b.ordinal);
     return entries;
 }
 export function subagentRosterOf(entries) {
-    // One coworker = one chain: its NEWEST ask (highest ordinal — chains
-    // never span parent runs) is its current state, the same
-    // newest-supersedes posture every other surface keeps.
     const newestBySession = new Map();
     for (const entry of entries) {
         const held = newestBySession.get(entry.childSessionId);
@@ -72,35 +58,19 @@ export function subagentRosterOf(entries) {
     }
     return roster;
 }
-/** The pill's copy: null when the conversation has no subagents, the live
- *  count while any child runs, the total once everything settled — with the
- *  losses named (the group headline's suffix vocabulary): the pill is the
- *  roster's collapsed form, and the one loud fact must survive the collapse. */
 export function subagentPillLabelOf(roster) {
     if (roster.total === 0) {
         return null;
     }
-    // The loss suffix rides BOTH arms (the group headline's rule): a live
-    // fan-out that already lost a coworker must not read clean while someone
-    // watches the pill. It counts COWORKERS like every other number here — a
-    // coworker is lost when its NEWEST ask failed, recovered by a later resume.
     const failedSuffix = roster.failedSessions > 0
         ? ` · ${String(roster.failedSessions)} failed`
         : "";
     if (roster.running.length > 0) {
-        // Per-ask is per-coworker here: one chain holds at most one live
-        // row (the one-live-run law), so running.length counts coworkers.
         return `${String(roster.running.length)} running${failedSuffix}`;
     }
-    // The noun counts COWORKERS, never asks: a resumed
-    // child is one subagent asked again, and the pill's word must mean
-    // what it says even while the roster honestly lists every ask.
     const noun = roster.distinctSessions === 1 ? "subagent" : "subagents";
     return `${String(roster.distinctSessions)} ${noun}${failedSuffix}`;
 }
-/** A settled row's duration in the house ladder (segment-timing's
- *  durationLabelOf: "<1s" floor, "0s" unrenderable) — null while running (a
- *  live clock is the dashboard's ElapsedTime concern) and on bad timestamps. */
 export function settledDurationLabelOf(startedAt, settledAt) {
     const durationMs = settledSpanMsOf(startedAt, settledAt);
     if (durationMs === null) {
@@ -108,4 +78,3 @@ export function settledDurationLabelOf(startedAt, settledAt) {
     }
     return durationLabelOf(durationMs);
 }
-//# sourceMappingURL=subagent-roster.js.map