@teaflask/assistant 0.0.0 → 0.3.0

package/dist/core/run-folds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-folds.d.ts","sourceRoot":"","sources":["../../src/core/run-folds.ts"],"names":[],"mappings":"AAeA,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAE1E;;;sEAGsE;AACtE,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAElD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB;;;;+EAI2E;IAC3E,GAAG,EAAE,MAAM,CAAC;IACZ;yEACqE;IACrE,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAClC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9B;2EACuE;IACvE,QAAQ,EAAE,eAAe,CAAC;CAC3B;AAED;iCACiC;AACjC,MAAM,MAAM,mBAAmB,GAC7B,OAAO,CAAC,aAAa,EAAE,YAAY,CAAC,GAAG,UAAU,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B;;;;sEAIkE;IAClE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;mFAG+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;2BAG2B;AAC3B,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,aAAa,EAAE,EAC9B,OAAO,GAAE,eAAoB,GAC5B,mBAAmB,EAAE,CAWvB;AAED;;kEAEkE;AAClE,KAAK,eAAe,GAAG,aAAa,GAAG,mBAAmB,CAAC;AAkB3D;wEACwE;AACxE,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,eAAe,EAAE,CAAC;CAClC;AAoBD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,eAAe,EAAE,EAChC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,EACxC,YAAY,GAAE,WAAW,CAAC,MAAM,CAAqB,GACpD,MAAM,CAKR;AA8FD;;;;4EAI4E;AAC5E,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAKvE;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAkBxE;AA+BD,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,mBAAmB,EAAE,CAAC;CAC7B;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,eAAe,EAAE,EAIlC,OAAO,GAAE,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,GAAG;IAC5C,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;;6DAIyD;IACzD,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/B,GACL,WAAW,EAAE,CAiDf"}

package/dist/core/run-folds.js

@@ -0,0 +1,287 @@
+// Run folds: the pure grouping pass between the
+// row projection and the rendered transcript. Open turn: consecutive
+// reasoning/tool rows are one fold, and any other row splits at its exact
+// position. Settled turn: each work span unifies around its LAST maximal
+// prose run, which stays outside — collapse the work, never the answer.
+// Structural only: position and row kinds decide, never content and never
+// which views a tool row resolves — a view is inspected at its
+// own row inside the fold. Each fold's duration reduces over ITS OWN
+// members' server timing. The premises in full:
+// docs/transcript-rows-and-folds.md, "Fold premises".
+import { REASONING_SETTLED_LABEL, REASONING_STREAMING_LABEL, } from "./reasoning-copy.js";
+import { durationLabelOf, settledFoldDurationOf, } from "./segment-timing.js";
+import { toolRowHeadlineOf } from "./tool-call-display.js";
+import { EMPTY_MARKER_BOUNDARIES, } from "./transcript-rows.js";
+/** Fold the projected rows. Rows before the tail turn (and the whole list
+ *  once the newest turn settles) fold as completed episodes; the open tail
+ *  turn — from the last user or subagent-delivery row on — keeps the live
+ *  per-cluster folding. */
+export function runFoldsOf(rows, options = {}) {
+    const folded = [];
+    const tailStart = options.tailStart !== undefined
+        ? Math.max(0, Math.min(options.tailStart, rows.length))
+        : options.openTailTurn
+            ? _tailTurnStartOf(rows)
+            : rows.length;
+    _pushEpisodeFolds(rows.slice(0, tailStart), folded);
+    _pushClusterFolds(rows.slice(tailStart), folded);
+    return folded;
+}
+/** The open tail turn starts at the last turn-boundary row — a user message
+ *  or a subagent delivery (the projection's severance scan's two kinds). A
+ *  list with neither (a bare fixture) is one turn, as is a child transcript,
+ *  whose only boundary is its opening brief at index 0. */
+function _tailTurnStartOf(rows) {
+    for (let index = rows.length - 1; index >= 0; index -= 1) {
+        const kind = rows[index].kind;
+        if (kind === "user" || kind === "subagent-delivery") {
+            return index;
+        }
+    }
+    return 0;
+}
+const NO_TURN_START_IDS = new Set();
+/** The newest DECLARED turn start, in flat coordinates over the blocks'
+ *  rows — a declared turn-start block marks the boundary at the position
+ *  its rows occupy (or would occupy, for a row-less block). */
+function _declaredTurnStartOf(blocks, turnStartIds) {
+    let declaredTurnStart = 0;
+    let flatIndex = 0;
+    for (const block of blocks) {
+        if (turnStartIds.has(block.messageId)) {
+            declaredTurnStart = flatIndex;
+        }
+        flatIndex += block.rows.length;
+    }
+    return declaredTurnStart;
+}
+/**
+ * Where the current turn starts, as a flat index into `rows`: the LAST
+ * boundary of either kind — the newest row the tail scan recognizes or the
+ * newest declared turn-start block — whichever is later. `null` blocks
+ * means only the row scan applies. The fold pass and the row list's
+ * placement hold both read this spelling, so the two windows never disagree.
+ */
+export function currentTurnStartOf(rows, blocks, turnStartIds = NO_TURN_START_IDS) {
+    return Math.max(_declaredTurnStartOf(blocks ?? [], turnStartIds), _tailTurnStartOf(rows));
+}
+/** Completed-episode folding. Within each span between hard
+ *  boundaries, the LAST maximal run of prose rows stays top-level — the
+ *  turn's last words. Everything before it is ONE episode fold, keyed on
+ *  its first work member (the live cluster it started as, so the settled
+ *  <details> is the same element); work rows after it (the cut-off tail)
+ *  are one trailing fold, so a stopped/failed turn never buries all its
+ *  prose. No work row → nothing folds; no prose → the span folds whole.
+ *  Position alone decides. */
+function _pushEpisodeFolds(rows, folded) {
+    let pending = [];
+    const flush = () => {
+        // The last maximal prose run: [proseStart, proseEnd] inclusive.
+        let proseEnd = -1;
+        for (let index = pending.length - 1; index >= 0; index -= 1) {
+            if (pending[index].kind === "assistant-text") {
+                proseEnd = index;
+                break;
+            }
+        }
+        let proseStart = proseEnd;
+        while (proseStart > 0 &&
+            pending[proseStart - 1].kind === "assistant-text") {
+            proseStart -= 1;
+        }
+        // Before the run: one episode fold. Maximality guarantees the prefix
+        // is empty or ends on a work row, so the fold has its anchor.
+        if (proseStart > 0) {
+            folded.push(_foldOf(pending.slice(0, proseStart)));
+        }
+        else if (proseEnd < 0 && pending.length > 0) {
+            // No prose anywhere: the whole span folds.
+            folded.push(_foldOf(pending));
+        }
+        // The run itself, top-level.
+        for (let index = Math.max(proseStart, 0); index <= proseEnd; index += 1) {
+            folded.push(pending[index]);
+        }
+        // After the run: work only (maximality again) — the cut-off tail.
+        if (proseEnd >= 0 && proseEnd + 1 < pending.length) {
+            folded.push(_foldOf(pending.slice(proseEnd + 1)));
+        }
+        pending = [];
+    };
+    for (const row of rows) {
+        if (row.kind === "reasoning" ||
+            row.kind === "assistant-text" ||
+            row.kind === "tool-call") {
+            pending.push(row);
+            continue;
+        }
+        flush();
+        folded.push(row);
+    }
+    flush();
+}
+/** Live per-cluster folding: consecutive reasoning/tool rows
+ *  are one fold; ANY other row — prose included — splits at its exact
+ *  transcript position, so the open turn reads in true chronology. */
+function _pushClusterFolds(rows, folded) {
+    let members = [];
+    const flush = () => {
+        if (members.length === 0) {
+            return;
+        }
+        folded.push(_foldOf(members));
+        members = [];
+    };
+    for (const row of rows) {
+        if (row.kind === "reasoning") {
+            members.push(row);
+            continue;
+        }
+        if (row.kind === "tool-call") {
+            members.push(row);
+            continue;
+        }
+        flush();
+        folded.push(row);
+    }
+    flush();
+}
+/** The settled fold headline. The duration is the member-relevant cost —
+ *  never a step count (TVC-011) — and the register is honest about its
+ *  evidence: a measured sub-second span reads "<1s", never "Worked for 0s";
+ *  an unknown span degrades to the neutral "Worked", never an invented
+ *  duration (docs/replay-metadata-contract.md, "Unknown vs sub-second"). */
+export function settledFoldHeadlineOf(duration) {
+    if (duration.kind === "unknown") {
+        return "Worked";
+    }
+    return `Worked for ${durationLabelOf(duration.durationMs)}`;
+}
+/**
+ * A COLLAPSED live fold's headline: the latest step's own label, so the
+ * member tracks the work without expanding (the expanded fold keeps the
+ * generic "Working…"). Each label is the one the step's own row wears: a
+ * tool call reads toolRowHeadlineOf on its OWN state, a reasoning step the
+ * ReasoningRow labels; narration is skipped (prose is not a work step); no
+ * usable step → "Working…". Returned RAW: the renderer (FoldHeadline)
+ * truncates for display and carries this text as its wrapper's title.
+ */
+export function liveFoldHeadlineOf(steps) {
+    for (let index = steps.length - 1; index >= 0; index -= 1) {
+        const step = steps[index];
+        if (step.kind === "tool-call") {
+            return toolRowHeadlineOf({
+                toolName: step.row.toolName,
+                state: step.row.state,
+                input: step.row.argsText,
+                display: step.row.display,
+            });
+        }
+        if (step.kind === "reasoning") {
+            return step.view.streaming
+                ? REASONING_STREAMING_LABEL
+                : REASONING_SETTLED_LABEL;
+        }
+    }
+    return "Working…";
+}
+function _foldOf(members) {
+    const timings = [];
+    for (const member of members) {
+        if (member.kind !== "assistant-text" && member.timing !== undefined) {
+            timings.push(member.timing);
+        }
+    }
+    // Both fold passes construct a fold only around at least one work row,
+    // so the anchor always exists; the fallback merely satisfies the type.
+    const anchor = members.find((member) => member.kind !== "assistant-text") ?? members[0];
+    return {
+        kind: "run-fold",
+        key: `activity:${anchor.key}`,
+        members,
+        steps: _stepsInTranscriptOrder(members),
+        duration: settledFoldDurationOf(timings),
+    };
+}
+export function foldedBlocksOf(blocks, 
+// tailStart is Omit-ed on purpose: it is the offset THIS function
+// computes and hands down per segment — accepting it here would
+// type-check and silently do nothing.
+options = {}) {
+    const boundaries = options.markerBoundaries ?? EMPTY_MARKER_BOUNDARIES;
+    const turnStartIds = options.turnStartIds ?? NO_TURN_START_IDS;
+    // Flatten, remembering each row's block by its key (keys are unique
+    // across the projection: message ids, `${messageId}:${toolCallId}`,
+    // marker keys, `subagents:` group keys).
+    const flat = [];
+    const blockIndexByKey = new Map();
+    // Segment cuts in flat coordinates: a before-boundary cuts ahead of its
+    // block's rows, an after-boundary behind them. 0 and length are cuts by
+    // construction.
+    const cuts = new Set([0]);
+    for (const [index, block] of blocks.entries()) {
+        if (boundaries.before.has(block.messageId)) {
+            cuts.add(flat.length);
+        }
+        for (const row of block.rows) {
+            blockIndexByKey.set(row.key, index);
+            flat.push(row);
+        }
+        if (boundaries.after.has(block.messageId)) {
+            cuts.add(flat.length);
+        }
+    }
+    cuts.add(flat.length);
+    // The open tail turn starts where the current turn starts (the row
+    // scan or the declared start, whichever is later in the flat order).
+    const tailStart = options.openTailTurn
+        ? currentTurnStartOf(flat, blocks, turnStartIds)
+        : flat.length;
+    const ordered = [...cuts].sort((a, b) => a - b);
+    const foldedBlocks = blocks.map((block) => ({
+        messageId: block.messageId,
+        rows: [],
+    }));
+    for (let cut = 0; cut + 1 < ordered.length; cut += 1) {
+        const [start, end] = [ordered[cut], ordered[cut + 1]];
+        const folded = runFoldsOf(flat.slice(start, end), {
+            tailStart: tailStart - start,
+        });
+        for (const row of folded) {
+            const firstKey = row.kind === "run-fold" ? row.members[0].key : row.key;
+            // The key map covers every input row; a fold's first member is one
+            // of them. The fallback merely satisfies the type.
+            const blockIndex = blockIndexByKey.get(firstKey) ?? 0;
+            foldedBlocks[blockIndex].rows.push(row);
+        }
+    }
+    return foldedBlocks;
+}
+function _stepsInTranscriptOrder(members) {
+    const steps = [];
+    for (const row of members) {
+        if (row.kind === "tool-call") {
+            steps.push({ kind: "tool-call", row });
+            continue;
+        }
+        if (row.kind === "assistant-text") {
+            steps.push({ kind: "narration", view: row });
+            continue;
+        }
+        const previous = steps.at(-1);
+        if (previous?.kind === "reasoning") {
+            previous.view = {
+                ...previous.view,
+                text: `${previous.view.text}\n\n${row.text}`,
+                streaming: previous.view.streaming || row.streaming,
+            };
+            continue;
+        }
+        steps.push({
+            kind: "reasoning",
+            view: { ...row, key: `reasoning:${row.key}` },
+        });
+    }
+    return steps;
+}
+//# sourceMappingURL=run-folds.js.map

package/dist/core/run-folds.js.map

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

package/dist/core/run-status.d.ts

@@ -0,0 +1,22 @@
+import type { TurnStatus } from "../contract/threads.js";
+/** The two states the announcer can honestly claim. */
+export type AnnouncedStatus = "working" | "waiting";
+/**
+ * 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 declare function announcedStatusOf(status: TurnStatus | null, decisionsPending: boolean): AnnouncedStatus | 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 declare function runReadsAsWorking(status: TurnStatus | null, decisionsPending: boolean): boolean;
+//# sourceMappingURL=run-status.d.ts.map

package/dist/core/run-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-status.d.ts","sourceRoot":"","sources":["../../src/core/run-status.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,uDAAuD;AACvD,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,SAAS,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,GAAG,IAAI,EACzB,gBAAgB,EAAE,OAAO,GACxB,eAAe,GAAG,IAAI,CAQxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,GAAG,IAAI,EACzB,gBAAgB,EAAE,OAAO,GACxB,OAAO,CAET"}

package/dist/core/run-status.js

@@ -0,0 +1,41 @@
+// 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";
+    }
+    if (status === "awaiting_input" || status === "parked") {
+        return decisionsPending ? "waiting" : "working";
+    }
+    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/run-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-status.js","sourceRoot":"","sources":["../../src/core/run-status.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,qEAAqE;AACrE,sEAAsE;AACtE,uEAAuE;AACvE,yEAAyE;AACzE,yEAAyE;AACzE,qEAAqE;AACrE,iEAAiE;AACjE,sEAAsE;AACtE,sEAAsE;AACtE,mEAAmE;AACnE,gCAAgC;AAOhC;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAyB,EACzB,gBAAyB;IAEzB,IAAI,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAChD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,MAAM,KAAK,gBAAgB,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QACvD,OAAO,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IAClD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAyB,EACzB,gBAAyB;IAEzB,OAAO,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,CAAC,KAAK,SAAS,CAAC;AACnE,CAAC"}

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

@@ -0,0 +1,33 @@
+/** 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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-timing.d.ts","sourceRoot":"","sources":["../../src/core/segment-timing.ts"],"names":[],"mappings":"AAMA;;0EAE0E;AAC1E,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;sEAEsE;AACtE,MAAM,MAAM,eAAe,GACzB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAIjE;;;uEAGuE;AACvE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,WAAW,EAAE,GAC9B,eAAe,CAkBjB;AAED;;6EAE6E;AAC7E,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAc1D;AAED;;;;;uEAKuE;AACvE,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,WAAW,EAAE,EAC/B,KAAK,EAAE,MAAM,GACZ,eAAe,CAajB"}

package/dist/core/segment-timing.js

@@ -0,0 +1,68 @@
+// 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;
+    for (const member of members) {
+        for (const observed of [member.startedAtMs, member.settledAtMs]) {
+            if (observed === null) {
+                continue;
+            }
+            earliest = earliest === null ? observed : Math.min(earliest, observed);
+            latest = latest === null ? observed : Math.max(latest, observed);
+        }
+    }
+    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";
+    }
+    const totalSeconds = Math.floor(durationMs / 1_000);
+    if (totalSeconds < 60) {
+        return `${String(totalSeconds)}s`;
+    }
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `${String(totalMinutes)}m ${String(totalSeconds % 60).padStart(2, "0")}s`;
+    }
+    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) {
+        for (const observed of [member.startedAtMs, member.settledAtMs]) {
+            if (observed !== null) {
+                earliest = earliest === null ? observed : Math.min(earliest, observed);
+            }
+        }
+    }
+    if (earliest === null) {
+        return UNKNOWN;
+    }
+    return { kind: "measured", durationMs: Math.max(0, nowMs - earliest) };
+}
+//# sourceMappingURL=segment-timing.js.map

package/dist/core/segment-timing.js.map

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

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

@@ -0,0 +1,18 @@
+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;
+    constructor(onSettle: () => void);
+    noteRunSettled(): void;
+    dispose(): void;
+    private clearTimer;
+}
+//# sourceMappingURL=settle-refresh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"settle-refresh.d.ts","sourceRoot":"","sources":["../../src/core/settle-refresh.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IAGrB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,OAAO,CAAC,KAAK,CAA8C;gBAE9B,QAAQ,EAAE,MAAM,IAAI;IAEjD,cAAc,IAAI,IAAI;IAQtB,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,UAAU;CAMnB"}

package/dist/core/settle-refresh.js

@@ -0,0 +1,36 @@
+// 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;
+    constructor(onSettle) {
+        this.onSettle = onSettle;
+    }
+    noteRunSettled() {
+        this.clearTimer();
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.onSettle();
+        }, SETTLE_REFRESH_DELAY_MS);
+    }
+    dispose() {
+        this.clearTimer();
+    }
+    clearTimer() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+//# sourceMappingURL=settle-refresh.js.map

package/dist/core/settle-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle-refresh.js","sourceRoot":"","sources":["../../src/core/settle-refresh.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,0EAA0E;AAC1E,+CAA+C;AAC/C,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,OAAO,sBAAsB;IAGJ;IAFrB,KAAK,GAAyC,IAAI,CAAC;IAE3D,YAA6B,QAAoB;QAApB,aAAQ,GAAR,QAAQ,CAAY;IAAG,CAAC;IAErD,cAAc;QACZ,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAClB,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC,EAAE,uBAAuB,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAEO,UAAU;QAChB,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACxB,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QACpB,CAAC;IACH,CAAC;CACF"}

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

@@ -0,0 +1,5 @@
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-caption.d.ts","sourceRoot":"","sources":["../../src/core/step-caption.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,oBAAoB,YAAY,CAAC;AAE9C;yDACyD;AACzD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB"}

package/dist/core/step-caption.js

@@ -0,0 +1,14 @@
+// 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/step-caption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-caption.js","sourceRoot":"","sources":["../../src/core/step-caption.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,mEAAmE;AACnE,uEAAuE;AACvE,0EAA0E;AAE1E,MAAM,CAAC,MAAM,oBAAoB,GAAG,SAAS,CAAC;AAE9C;yDACyD;AACzD,MAAM,UAAU,kBAAkB,CAChC,IAA6B;IAE7B,IAAI,CAAC,CAAC,oBAAoB,IAAI,IAAI,CAAC,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,oBAAoB,CAAC,CACrE,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,2 @@
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-copy.d.ts","sourceRoot":"","sources":["../../src/core/stop-copy.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,2BAA2B,4EACmC,CAAC"}

package/dist/core/stop-copy.js

@@ -0,0 +1,8 @@
+// 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-copy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-copy.js","sourceRoot":"","sources":["../../src/core/stop-copy.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,8DAA8D;AAC9D,wEAAwE;AACxE,sEAAsE;AACtE,wEAAwE;AACxE,yEAAyE;AACzE,MAAM,CAAC,MAAM,2BAA2B,GACtC,yEAAyE,CAAC"}

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

@@ -0,0 +1,17 @@
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-settle.d.ts","sourceRoot":"","sources":["../../src/core/stop-settle.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,iBAAiB,EAAE,MAAM,OAAO,CAAC;CAClC,GAAG,OAAO,CAAC,OAAO,CAAC,CAcnB"}