@vibefield/rosetta-room 0.0.0-stage → 0.1.1

package/dist/lib/transcript/use-transcript-tail.js

@@ -0,0 +1,158 @@
+import { useCallback, useLayoutEffect, useRef, useState } from "react";
+import { REDUCED_MOTION_QUERY, SETTLE_EASING } from "../motion.js";
+import { TailArrivals } from "./tail-state.js";
+import { TailScroll } from "./tail-scroll.js";
+const EMPTY = { away: false, unseen: 0 };
+export function useTranscriptTail(scrollerRef, sessionId, enabled, seeking, opening = false) {
+    const [state, setState] = useState(EMPTY);
+    const controller = useRef(null);
+    const layout = useRef(null);
+    const accept = useRef(null);
+    const openingRef = useRef(opening);
+    openingRef.current = opening;
+    // The document owns the displayed chronology (including shared team
+    // messages). Buffer its first child layout until the parent has mounted.
+    const onLayout = useCallback((next) => {
+        layout.current = next;
+        accept.current?.(next);
+    }, []);
+    useLayoutEffect(() => {
+        setState(EMPTY);
+        const element = scrollerRef.current;
+        if (!enabled || sessionId === null || element === null)
+            return;
+        const preference = window.matchMedia(REDUCED_MOTION_QUERY);
+        const scroll = new TailScroll(element, setState, () => preference.matches);
+        controller.current = scroll;
+        if (seeking)
+            scroll.pause();
+        const arrivals = new TailArrivals();
+        const animations = new Set();
+        const cancelEntrances = () => {
+            for (const animation of animations)
+                animation.cancel();
+            animations.clear();
+        };
+        const update = (next) => {
+            if (next.sessionId !== sessionId)
+                return;
+            if (!next.ready) {
+                arrivals.reset();
+                scroll.update(false, 0);
+                return;
+            }
+            const displayed = new Set(next.rows.map(row => row.timeline_id));
+            const fresh = arrivals.update(next.observedRows ?? next.rows).filter(row => displayed.has(row.timeline_id));
+            for (const id of next.readySessionIds)
+                arrivals.prime(id);
+            scroll.update(true, fresh.length, openingRef.current);
+            if (openingRef.current || fresh.length === 0 || preference.matches)
+                return;
+            const viewport = element.getBoundingClientRect();
+            const allowance = scroll.isFollowing ? element.clientHeight : 0;
+            // Animate actual new message elements, never an existing fold's
+            // representative, a patch, a historical page, or a whole transcript.
+            const entering = fresh.slice(-24).flatMap((row) => {
+                const target = next.elementForRow(row);
+                if (target === null || !element.contains(target))
+                    return [];
+                const box = target.getBoundingClientRect();
+                return box.height > 0 &&
+                    box.bottom >= viewport.top &&
+                    box.top <= viewport.bottom + allowance
+                    ? [target]
+                    : [];
+            });
+            for (const target of entering) {
+                const animation = target.animate([
+                    { opacity: 0, translate: "0 6px" },
+                    { opacity: 1, translate: "0 0" },
+                ], { duration: 280, easing: SETTLE_EASING });
+                animations.add(animation);
+                animation.onfinish = () => animations.delete(animation);
+            }
+        };
+        accept.current = update;
+        if (layout.current)
+            update(layout.current);
+        const wheel = (event) => {
+            if (Math.abs(event.deltaY) > Math.abs(event.deltaX))
+                scroll.pause();
+        };
+        const pointer = (event) => {
+            // Native scrollbar drags and clicks on the scroll surface also express
+            // reader intent, even on platforms that do not send wheel events.
+            if (event.target === element || scroll.isAnimating)
+                scroll.pause();
+        };
+        const focus = (event) => {
+            // Tabbing to a message action is reading/navigation intent. Keep that
+            // focused control in view instead of continuing a return past it.
+            if (event.target !== element)
+                scroll.pause();
+        };
+        let touchY = null;
+        const touchStart = (event) => {
+            touchY = event.touches[0]?.clientY ?? null;
+        };
+        const touchMove = (event) => {
+            if (touchY !== null && Math.abs((event.touches[0]?.clientY ?? touchY) - touchY) > 4) {
+                scroll.pause();
+            }
+        };
+        const key = (event) => {
+            if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.altKey)
+                return;
+            if (event.target instanceof Element &&
+                event.target.closest("input, textarea, select, button, a, [contenteditable='true']"))
+                return;
+            if (["ArrowUp", "ArrowDown", "PageUp", "PageDown", "Home", "End", " "].includes(event.key)) {
+                scroll.pause();
+            }
+        };
+        const preferenceChanged = () => {
+            if (preference.matches)
+                cancelEntrances();
+            scroll.resize();
+        };
+        // Observe the document as well as the viewport: images, disclosures,
+        // streamed text and window resizing can change the foot without a row.
+        const observer = new ResizeObserver(scroll.resize);
+        observer.observe(element);
+        const content = element.querySelector(".tr-col");
+        if (content)
+            observer.observe(content);
+        element.addEventListener("scroll", scroll.onScroll, { passive: true });
+        element.addEventListener("wheel", wheel, { passive: true });
+        element.addEventListener("pointerdown", pointer, { passive: true });
+        element.addEventListener("focusin", focus);
+        element.addEventListener("touchstart", touchStart, { passive: true });
+        element.addEventListener("touchmove", touchMove, { passive: true });
+        element.addEventListener("keydown", key);
+        preference.addEventListener("change", preferenceChanged);
+        return () => {
+            accept.current = null;
+            controller.current = null;
+            observer.disconnect();
+            cancelEntrances();
+            scroll.dispose();
+            element.removeEventListener("scroll", scroll.onScroll);
+            element.removeEventListener("wheel", wheel);
+            element.removeEventListener("pointerdown", pointer);
+            element.removeEventListener("focusin", focus);
+            element.removeEventListener("touchstart", touchStart);
+            element.removeEventListener("touchmove", touchMove);
+            element.removeEventListener("keydown", key);
+            preference.removeEventListener("change", preferenceChanged);
+        };
+        // Seeking changes pause the existing controller below; they must not
+        // recreate it or forget unread arrivals in this session.
+    }, [enabled, sessionId, scrollerRef]);
+    useLayoutEffect(() => {
+        if (seeking)
+            controller.current?.pause();
+    }, [seeking]);
+    const pause = useCallback(() => controller.current?.pause(), []);
+    const latest = useCallback(() => controller.current?.latest(), []);
+    return { ...state, onLayout, pause, latest };
+}

package/dist/lib/transcript/vocabulary.d.ts

@@ -0,0 +1,119 @@
+import type { AttachmentRef, CanonicalText, CitationRef, Notice, ResourceRef, TimelineEntry, ToolAction } from "@vibefield/rosetta-protocol";
+/** One of the protocol's twenty-eight closed action families. */
+export type ToolFamily = ToolAction["type"];
+/**
+ * T-3's fold rule. `look` is high-volume and low-stakes, so consecutive looks
+ * of one family fold to a single line; `act` is the session's work product and
+ * always stands alone. `shell` is deliberately a LOOK (decided 2026-09-01) —
+ * running a command is looking at the world, and a *failed* command is an act,
+ * which is why a failure breaks the fold.
+ */
+export type LedgerClass = "look" | "act";
+export declare const FAMILY_CLASS: Readonly<Record<ToolFamily, LedgerClass>>;
+/**
+ * The run's closing sentence is nouns, never verbs — `17 commands · 3 edits ·
+ * 4 reads` (T-3). One entry per family, singular and plural.
+ */
+export declare const FAMILY_NOUN: Readonly<Record<ToolFamily, readonly [string, string]>>;
+/** `1 read` · `4 reads`. The count is always stated; the noun agrees with it. */
+export declare function familyNoun(family: ToolFamily, count: number): string;
+/**
+ * The nouns a *fold* uses for its own members — `4 files`, `2 commands`. A fold
+ * counts the things looked at, which is not always the family's run noun: four
+ * `file_read` rows are `4 files` on the line and `4 reads` in the sentence.
+ */
+export declare const FOLD_NOUN: Readonly<Record<ToolFamily, readonly [string, string]>>;
+/**
+ * Monoline glyph names on the 16-unit grid at stroke 1.5, `currentColor` — the
+ * record's own symbol ids minus the `g-` prefix, so a component draws
+ * `<use href={"#g-" + glyph}/>`. One glyph per FAMILY, never per operation: a
+ * file's type is not a state, and neither is a tool's, so `Created` and
+ * `Edited` share the delta glyph and the verb carries the operation.
+ *
+ * The glyph slot is substituted by STATE, not by this name (§04's last rows):
+ * a `failed` line draws `#g-fail`, a `running` line draws the breathing dot.
+ */
+export type LedgerGlyph = "read" | "list" | "search" | "web" | "shell" | "delta" | "delegate" | "task" | "question" | "doc" | "bell" | "box" | "plug" | "flag" | "bolt" | "sliders" | "clock" | "help";
+export declare const FAMILY_GLYPH: Readonly<Record<ToolFamily, LedgerGlyph>>;
+/**
+ * Ink and typeface for one span of the object column, named for the record's
+ * own classes so a component maps them without translating:
+ *
+ * - `plain` → a bare span: mono 11.5, primary ink. The object's default.
+ * - `dir`   → `.dir`: mono, tertiary. A path's directory, so the NAME is what
+ *             the eye lands on.
+ * - `query` → `.q`: mono, primary. A search term, quoted by weight not marks.
+ * - `aside` → `.in`: SANS 12, tertiary. Qualifiers and prose — `in files`,
+ *             a fold's name list, a delegate's objective, a question's prompt.
+ */
+export type ObjectTone = "plain" | "dir" | "query" | "aside";
+export interface ObjectPart {
+    readonly text: string;
+    readonly tone: ObjectTone;
+}
+/**
+ * Concatenate the parts with NO separator — each part's text already carries
+ * the spacing the record draws (a directory ends in `/`, an aside opens with
+ * ` · ` or ` `). Use it for a `title` attribute or an assertion, never as a
+ * substitute for drawing the parts, which is where the tones live.
+ */
+export declare function objectText(parts: readonly ObjectPart[]): string;
+export declare function part(text: string, tone?: ObjectTone): ObjectPart;
+/**
+ * Where the reading happens. A path is drawn relative to the session's own
+ * working directory when it lies beneath it, then home-relative, then whole —
+ * the record draws `packages/field-app/src/design-system/CardShell.tsx`, never
+ * the eleven leading characters that are the same on every line.
+ */
+export interface LedgerContext {
+    /** `SessionRow.cwd` — the adapter's one settled primary working directory. */
+    readonly cwd?: string | null;
+    /** The viewer's home directory, for the `~/…` form. */
+    readonly home?: string | null;
+}
+export declare function shortenPath(path: string, context?: LedgerContext): string;
+export declare function basename(path: string): string;
+/**
+ * Split a path or url into its dim leading run and its bright last segment.
+ * A url loses its scheme first: the record draws
+ * `developer.mozilla.org/en-US/docs/Web/API/` + `WebGPU_API`.
+ */
+export declare function splitPath(label: string): {
+    dir: string;
+    name: string;
+};
+/** Object parts for a path: directory dim, name bright (§04, `file_read`). */
+export declare function pathParts(label: string): ObjectPart[];
+/** The host of a url, for a source's caption and its icon's cache key. */
+export declare function urlHost(url: string): string;
+/** Inline text, or the preview a content-addressed member stands in for. */
+export declare function canonicalText(text: CanonicalText): string;
+/** The first line, clamped — every ledger line is one line by construction. */
+export declare function firstLine(text: string, max?: number): string;
+export declare function resourceLabel(resource: ResourceRef): string;
+/** A resource as the reader should see it: shortened when it is a local path. */
+export declare function resourceDisplay(resource: ResourceRef, context: LedgerContext): string;
+export declare function attachmentLabel(attachment: AttachmentRef): string;
+export declare function citationLabel(citation: CitationRef): string;
+/**
+ * Every `Notice` is a hairline marker, never a filled alarm (§03 G). This is
+ * its one line of text; a `runtime_error` earns red text and nothing more.
+ */
+export declare function noticeText(notice: Notice): string;
+/**
+ * A span at second precision — `21s`, `9m 36s`, `1h 04m`, `1d 11h`. The run's
+ * sentence and a line's own duration both use it. `lib/format.ts`'s `duration`
+ * is the canonical MINUTE-precision form and is what §07's pause pill uses;
+ * this is its finer sibling, because a two-command fold that took 21 seconds
+ * must not read `0m`.
+ */
+export declare function spanText(ms: number): string;
+/**
+ * Every stamp a row can honestly offer, in no particular order. Timing is
+ * evidence-backed and frequently absent — the Claude Code and Codex rows on
+ * today's daemon carry `completed_at` and nothing else — so a span is taken
+ * from what is there and is `null` when the row cannot prove one.
+ */
+export declare function rowStamps(row: TimelineEntry): number[];
+/** The span across a set of rows, or null when fewer than two stamps exist. */
+export declare function stampSpan(rows: readonly TimelineEntry[]): number | null;

package/dist/lib/transcript/vocabulary.js

@@ -0,0 +1,293 @@
+export const FAMILY_CLASS = {
+    file_read: "look",
+    file_list: "look",
+    file_search: "look",
+    code_lookup: "look",
+    web_search: "look",
+    web_fetch: "look",
+    web_navigate: "look",
+    tool_discovery: "look",
+    shell: "look",
+    file_change: "act",
+    code_execute: "act",
+    process: "act",
+    orchestration: "act",
+    delegate: "act",
+    collaborate: "act",
+    question: "act",
+    skill: "act",
+    workflow: "act",
+    schedule: "act",
+    artifact: "act",
+    notification: "act",
+    mode: "act",
+    task: "act",
+    plan: "act",
+    finding: "act",
+    structured_output: "act",
+    external: "act",
+    unknown: "act",
+};
+/**
+ * The run's closing sentence is nouns, never verbs — `17 commands · 3 edits ·
+ * 4 reads` (T-3). One entry per family, singular and plural.
+ */
+export const FAMILY_NOUN = {
+    file_read: ["read", "reads"],
+    file_list: ["listing", "listings"],
+    file_search: ["search", "searches"],
+    code_lookup: ["lookup", "lookups"],
+    web_search: ["web search", "web searches"],
+    web_fetch: ["fetch", "fetches"],
+    web_navigate: ["page", "pages"],
+    tool_discovery: ["tool search", "tool searches"],
+    shell: ["command", "commands"],
+    code_execute: ["run", "runs"],
+    file_change: ["edit", "edits"],
+    process: ["process", "processes"],
+    orchestration: ["tool batch", "tool batches"],
+    delegate: ["delegation", "delegations"],
+    collaborate: ["message", "messages"],
+    question: ["question", "questions"],
+    skill: ["skill", "skills"],
+    workflow: ["workflow", "workflows"],
+    schedule: ["schedule", "schedules"],
+    artifact: ["artifact", "artifacts"],
+    notification: ["notification", "notifications"],
+    mode: ["mode change", "mode changes"],
+    task: ["task", "tasks"],
+    plan: ["plan", "plans"],
+    finding: ["report", "reports"],
+    structured_output: ["document", "documents"],
+    external: ["call", "calls"],
+    unknown: ["call", "calls"],
+};
+/** `1 read` · `4 reads`. The count is always stated; the noun agrees with it. */
+export function familyNoun(family, count) {
+    const [one, many] = FAMILY_NOUN[family];
+    return `${count} ${count === 1 ? one : many}`;
+}
+/**
+ * The nouns a *fold* uses for its own members — `4 files`, `2 commands`. A fold
+ * counts the things looked at, which is not always the family's run noun: four
+ * `file_read` rows are `4 files` on the line and `4 reads` in the sentence.
+ */
+export const FOLD_NOUN = {
+    ...FAMILY_NOUN,
+    file_read: ["file", "files"],
+    file_list: ["directory", "directories"],
+    shell: ["command", "commands"],
+    web_fetch: ["page", "pages"],
+};
+export const FAMILY_GLYPH = {
+    file_read: "read",
+    file_list: "list",
+    file_search: "search",
+    code_lookup: "search",
+    web_search: "web",
+    web_fetch: "web",
+    web_navigate: "web",
+    tool_discovery: "plug",
+    file_change: "delta",
+    shell: "shell",
+    code_execute: "shell",
+    process: "clock",
+    orchestration: "bolt",
+    delegate: "delegate",
+    collaborate: "bell",
+    question: "question",
+    skill: "bolt",
+    workflow: "bolt",
+    schedule: "clock",
+    artifact: "box",
+    notification: "bell",
+    mode: "sliders",
+    task: "task",
+    plan: "task",
+    finding: "flag",
+    structured_output: "doc",
+    external: "plug",
+    unknown: "help",
+};
+/**
+ * Concatenate the parts with NO separator — each part's text already carries
+ * the spacing the record draws (a directory ends in `/`, an aside opens with
+ * ` · ` or ` `). Use it for a `title` attribute or an assertion, never as a
+ * substitute for drawing the parts, which is where the tones live.
+ */
+export function objectText(parts) {
+    return parts.map((part) => part.text).join("");
+}
+export function part(text, tone = "plain") {
+    return { text, tone };
+}
+export function shortenPath(path, context = {}) {
+    const cwd = context.cwd?.replace(/\/+$/, "") ?? null;
+    if (cwd !== null && cwd.length > 0) {
+        if (path === cwd)
+            return basename(path);
+        if (path.startsWith(`${cwd}/`))
+            return path.slice(cwd.length + 1);
+    }
+    const home = context.home?.replace(/\/+$/, "") ?? null;
+    if (home !== null && home.length > 0 && path.startsWith(`${home}/`)) {
+        return `~/${path.slice(home.length + 1)}`;
+    }
+    return path;
+}
+export function basename(path) {
+    const trimmed = path.replace(/\/+$/, "");
+    const cut = trimmed.lastIndexOf("/");
+    return cut === -1 ? trimmed : trimmed.slice(cut + 1);
+}
+/**
+ * Split a path or url into its dim leading run and its bright last segment.
+ * A url loses its scheme first: the record draws
+ * `developer.mozilla.org/en-US/docs/Web/API/` + `WebGPU_API`.
+ */
+export function splitPath(label) {
+    const stripped = label.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/\/+$/, "");
+    const cut = stripped.lastIndexOf("/");
+    if (cut === -1)
+        return { dir: "", name: stripped };
+    return { dir: stripped.slice(0, cut + 1), name: stripped.slice(cut + 1) };
+}
+/** Object parts for a path: directory dim, name bright (§04, `file_read`). */
+export function pathParts(label) {
+    const { dir, name } = splitPath(label);
+    const parts = [];
+    if (dir)
+        parts.push(part(dir, "dir"));
+    parts.push(part(name || label));
+    return parts;
+}
+/** The host of a url, for a source's caption and its icon's cache key. */
+export function urlHost(url) {
+    const match = /^(?:[a-z][a-z0-9+.-]*:\/\/)?([^/?#]+)/i.exec(url);
+    return match ? match[1].replace(/^www\./i, "") : url;
+}
+/** Inline text, or the preview a content-addressed member stands in for. */
+export function canonicalText(text) {
+    return text.type === "inline" ? text.text : text.preview;
+}
+/** The first line, clamped — every ledger line is one line by construction. */
+export function firstLine(text, max = 120) {
+    const line = text.split("\n", 1)[0].trim();
+    return line.length > max ? `${line.slice(0, max - 1)}…` : line;
+}
+export function resourceLabel(resource) {
+    switch (resource.type) {
+        case "file":
+        case "directory":
+            return resource.path;
+        case "url":
+            return resource.url;
+        case "session":
+        case "task":
+        case "process":
+            return resource.id;
+        case "asset":
+            return resource.asset.url;
+    }
+}
+/** A resource as the reader should see it: shortened when it is a local path. */
+export function resourceDisplay(resource, context) {
+    const label = resourceLabel(resource);
+    return resource.type === "file" || resource.type === "directory"
+        ? shortenPath(label, context)
+        : label;
+}
+export function attachmentLabel(attachment) {
+    return attachment.name?.trim() || attachment.label?.trim() || (attachment.kind === "image" ? "Image" : "Attachment");
+}
+export function citationLabel(citation) {
+    const source = citation.source ? resourceLabel(citation.source) : null;
+    return citation.title?.trim() || source || citation.provider?.trim() || "Source";
+}
+/**
+ * Every `Notice` is a hairline marker, never a filled alarm (§03 G). This is
+ * its one line of text; a `runtime_error` earns red text and nothing more.
+ */
+export function noticeText(notice) {
+    switch (notice.type) {
+        case "compaction":
+            return notice.reason ? `context compacted · ${notice.reason}` : "context compacted";
+        case "truncation": {
+            const count = notice.omitted_count === null ? "" : ` · ${notice.omitted_count} omitted`;
+            return `${notice.scope.replaceAll("_", " ")} truncated${count}`;
+        }
+        case "model_changed":
+            return notice.from ? `model ${notice.from} → ${notice.to}` : `model → ${notice.to}`;
+        case "mode_changed":
+            return notice.from ? `mode ${notice.from} → ${notice.to}` : `mode → ${notice.to}`;
+        case "permission_requested":
+            return notice.scope ? `permission requested · ${notice.scope}` : "permission requested";
+        case "permission_decision":
+            return notice.scope
+                ? `permission ${notice.decision} · ${notice.scope}`
+                : `permission ${notice.decision}`;
+        case "handoff":
+            return `handed off to ${notice.to_agent ?? notice.to_session_id ?? "another agent"}`;
+        case "command_output":
+            return canonicalText(notice.output);
+        case "async_task": {
+            const identity = notice.task_id ?? notice.tool_use_id;
+            const status = notice.status === "succeeded" ? "completed" : notice.status.replaceAll("_", " ");
+            return ["background task", identity, status, notice.summary]
+                .filter((value) => value !== null)
+                .join(" · ");
+        }
+        case "runtime_error":
+            return `runtime error · ${notice.kind.replaceAll("_", " ")} · ${notice.summary}`;
+    }
+}
+/* ── spans ───────────────────────────────────────────────────────────────── */
+/**
+ * A span at second precision — `21s`, `9m 36s`, `1h 04m`, `1d 11h`. The run's
+ * sentence and a line's own duration both use it. `lib/format.ts`'s `duration`
+ * is the canonical MINUTE-precision form and is what §07's pause pill uses;
+ * this is its finer sibling, because a two-command fold that took 21 seconds
+ * must not read `0m`.
+ */
+export function spanText(ms) {
+    const seconds = Math.max(0, Math.round(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
+    return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+}
+/* ── stamps ──────────────────────────────────────────────────────────────── */
+/**
+ * Every stamp a row can honestly offer, in no particular order. Timing is
+ * evidence-backed and frequently absent — the Claude Code and Codex rows on
+ * today's daemon carry `completed_at` and nothing else — so a span is taken
+ * from what is there and is `null` when the row cannot prove one.
+ */
+export function rowStamps(row) {
+    const stamps = [];
+    if (row.at !== null)
+        stamps.push(row.at);
+    if (row.body.type === "tool_use") {
+        const timing = row.body.tool.timing;
+        if (timing) {
+            if (timing.started_at !== null)
+                stamps.push(timing.started_at);
+            if (timing.completed_at !== null)
+                stamps.push(timing.completed_at);
+        }
+    }
+    return stamps;
+}
+/** The span across a set of rows, or null when fewer than two stamps exist. */
+export function stampSpan(rows) {
+    const stamps = rows.flatMap(rowStamps);
+    if (stamps.length < 2)
+        return null;
+    const span = Math.max(...stamps) - Math.min(...stamps);
+    return span > 0 ? span : null;
+}

package/dist/lib/transcript/web-address.d.ts

@@ -0,0 +1,6 @@
+/** Recorded web addresses are data, never relative navigation or executable
+ * schemes. Keep the exact URL for opening; only normalize the icon cache key. */
+export declare function webAddress(value: string | null): {
+    href: string;
+    host: string;
+} | null;

package/dist/lib/transcript/web-address.js

@@ -0,0 +1,18 @@
+/** Recorded web addresses are data, never relative navigation or executable
+ * schemes. Keep the exact URL for opening; only normalize the icon cache key. */
+export function webAddress(value) {
+    if (!value)
+        return null;
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            return null;
+        if (url.username || url.password)
+            return null;
+        const host = url.hostname.toLowerCase().replace(/\.$/, "");
+        return host ? { href: url.href, host } : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/transcript/workflow.d.ts

@@ -0,0 +1,31 @@
+import type { TimelineEntry, ToolStatus, WorkflowRunStatus, WorkflowWorker } from "@vibefield/rosetta-protocol";
+export interface WorkflowAttemptFact {
+    readonly timelineId: string;
+    readonly attempt: number;
+    readonly taskId: string | null;
+    readonly runId: string | null;
+    readonly resumed: boolean;
+    readonly status: ToolStatus;
+    readonly at: number | null;
+    readonly completedAt: number | null;
+    readonly durationMs: number | null;
+    readonly summary: string | null;
+}
+export interface WorkflowAttemptIndex {
+    readonly byRunId: ReadonlyMap<string, readonly WorkflowAttemptFact[]>;
+    readonly byTimelineId: ReadonlyMap<string, WorkflowAttemptFact>;
+}
+export declare function workflowAttemptIndex(rows: readonly TimelineEntry[]): WorkflowAttemptIndex;
+export declare function workflowAttemptsFor(index: WorkflowAttemptIndex, row: TimelineEntry): readonly WorkflowAttemptFact[];
+export interface WorkflowRuntimeFact {
+    readonly basis: "observed" | "varies" | "configured" | "unknown";
+    readonly model: string;
+    readonly effort: string;
+}
+/** Observed child-response metadata wins. A sidecar configuration is a
+ * labelled fallback, never presented as observation. */
+export declare function workflowRuntime(worker: WorkflowWorker, defaultModel: string | null): WorkflowRuntimeFact;
+/** Terminal run state refines unfinished worker rows without falsifying the
+ * native worker outcome. Cached completion is called reused and claims no
+ * fresh accounting. */
+export declare function workflowWorkerState(worker: WorkflowWorker, runStatus: WorkflowRunStatus): string;