@vibefield/rosetta-room 0.0.0-stage → 0.1.1

package/dist/lib/sections.js

@@ -0,0 +1,36 @@
+/**
+ * The rows each section draws. A row two sections name is drawn in the
+ * first; a row no section names goes to the first section without `ids`, or
+ * nowhere when every section names its own — so a host filter hides rows by
+ * naming fewer. Ids the room does not hold are skipped.
+ */
+export function arrangeSections(sections, rowsInRoomOrder, idOf) {
+    const byId = new Map(rowsInRoomOrder.map((row) => [idOf(row), row]));
+    const rank = new Map(rowsInRoomOrder.map((row, at) => [idOf(row), at]));
+    const named = new Set(sections.flatMap((section) => section.ids ?? []));
+    const drawn = new Set();
+    let restTaken = false;
+    return sections.map((section, index) => {
+        let rows;
+        let order;
+        if (section.ids === undefined) {
+            order = "room";
+            rows = restTaken ? [] : rowsInRoomOrder.filter((row) => !named.has(idOf(row)));
+            restTaken = true;
+        }
+        else {
+            order = section.order ?? "host";
+            const ids = [...new Set(section.ids)].filter((id) => byId.has(id) && !drawn.has(id));
+            if (order === "room")
+                ids.sort((left, right) => rank.get(left) - rank.get(right));
+            rows = ids.map((id) => byId.get(id));
+        }
+        for (const row of rows)
+            drawn.add(idOf(row));
+        return { section, index, rows, order };
+    });
+}
+/** How many rows a folded section says it holds: the host's figure, or its rows. */
+export function foldCount(arranged) {
+    return arranged.section.fold?.count ?? arranged.rows.length;
+}

package/dist/lib/session-activity.d.ts

@@ -0,0 +1,5 @@
+import type { SessionRow } from "@vibefield/rosetta-protocol";
+/** Recorded conversation time; metadata/file timestamps are never a fallback. */
+export declare function sessionLastActive(session: SessionRow): number | null;
+/** Newest known conversation first, then a stable id; unknowns go last. */
+export declare function compareSessionActivity(left: SessionRow, right: SessionRow): number;

package/dist/lib/session-activity.js

@@ -0,0 +1,15 @@
+/** Recorded conversation time; metadata/file timestamps are never a fallback. */
+export function sessionLastActive(session) {
+    const at = session.activity?.last_at;
+    return typeof at === "number" && Number.isFinite(at) ? at : null;
+}
+/** Newest known conversation first, then a stable id; unknowns go last. */
+export function compareSessionActivity(left, right) {
+    const a = sessionLastActive(left);
+    const b = sessionLastActive(right);
+    if (a === null && b !== null)
+        return 1;
+    if (b === null && a !== null)
+        return -1;
+    return (a !== null && b !== null ? b - a : 0) || left.id.localeCompare(right.id);
+}

package/dist/lib/session-leases.d.ts

@@ -0,0 +1,15 @@
+import type { SessionClient, SessionPort } from "../ports.js";
+export interface SessionLease {
+    /** The client, once the port has answered; null while it opens. */
+    readonly client: SessionClient | null;
+    /** Settles with the client, or rejects with the port's refusal. */
+    readonly ready: Promise<SessionClient>;
+    /** Give the session back. Idempotent; the last holder's release closes it. */
+    release(): void;
+}
+export interface SessionLeases {
+    acquire(sessionId: string): SessionLease;
+    /** One read through a session's client, held only for the read. */
+    run<T>(sessionId: string, read: (client: SessionClient) => Promise<T>): Promise<T>;
+}
+export declare function createSessionLeases(port: SessionPort): SessionLeases;

package/dist/lib/session-leases.js

@@ -0,0 +1,61 @@
+function isPromiseLike(value) {
+    return typeof value?.then === "function";
+}
+export function createSessionLeases(port) {
+    const open = new Map();
+    function openSession(sessionId) {
+        let answered;
+        try {
+            answered = port.open(sessionId);
+        }
+        catch (error) {
+            answered = Promise.reject(error);
+        }
+        if (!isPromiseLike(answered)) {
+            return { holders: 0, client: answered, ready: Promise.resolve(answered) };
+        }
+        const session = { holders: 0, client: null, ready: Promise.resolve(answered) };
+        session.ready.then((client) => {
+            session.client = client;
+        }, 
+        // A refusal is the reader's to see through `ready`; nothing to keep here.
+        () => { });
+        return session;
+    }
+    function acquire(sessionId) {
+        let session = open.get(sessionId);
+        if (session === undefined) {
+            session = openSession(sessionId);
+            open.set(sessionId, session);
+        }
+        session.holders += 1;
+        const held = session;
+        let released = false;
+        return {
+            get client() {
+                return held.client;
+            },
+            ready: held.ready,
+            release() {
+                if (released)
+                    return;
+                released = true;
+                held.holders -= 1;
+                if (held.holders === 0 && open.get(sessionId) === held) {
+                    open.delete(sessionId);
+                    port.close(sessionId);
+                }
+            },
+        };
+    }
+    async function run(sessionId, read) {
+        const lease = acquire(sessionId);
+        try {
+            return await read(lease.client ?? (await lease.ready));
+        }
+        finally {
+            lease.release();
+        }
+    }
+    return { acquire, run };
+}

package/dist/lib/spend.d.ts

@@ -0,0 +1,42 @@
+import type { CompactNumberParts } from "./format.js";
+/** The wire's spend columns, flattened beside every aggregate `tokens`. */
+export interface SpendFields {
+    readonly cost_micro_usd: number | null;
+    readonly billed_micro_usd: number | null;
+    readonly unpriced_tokens: number;
+    readonly unrecorded_output: number;
+    readonly reported_cost_adjustment_micro_usd?: number;
+}
+export interface Spend {
+    /** Estimated micro-USD, including reported adjustments; null when unpriced. */
+    readonly costMicroUsd: number | null;
+    /** Provider-billed micro-USD where the agent records one; null otherwise. */
+    readonly billedMicroUsd: number | null;
+    /** Tokens the price catalog could not price. */
+    readonly unpricedTokens: number;
+    /** Usage records whose prompt was recorded but whose output never was
+     * (a streamed reply that never got its final usage record): the priced
+     * figure is a lower bound. */
+    readonly unrecordedOutput: number;
+    /** Additional estimate recovered from cumulative agent totals. */
+    readonly reportedCostAdjustmentMicroUsd: number;
+}
+export declare const NO_SPEND: Spend;
+export declare function spendOf(fields: SpendFields): Spend;
+export declare function addSpend(left: Spend, right: Spend): Spend;
+export declare function sumSpend(rows: Iterable<SpendFields>): Spend;
+/** `complete`: every token priced and every output recorded. `partial`: some
+ * usage unpriced or some output unrecorded, so the figure is a lower bound.
+ * `unavailable`: tokens, none priced. `none`: no usage. */
+export type Coverage = "complete" | "partial" | "unavailable" | "none";
+export declare function coverage(spend: Spend): Coverage;
+/** Shared compact scale, with currency-specific cents for smaller amounts. */
+export declare function fmtUsd(microUsd: number): CompactNumberParts;
+export declare function usdText(microUsd: number): string;
+/** A long form for titles and accessible labels: `$1,234.56`. */
+export declare function usdExact(microUsd: number): string;
+/** The compact figure with its coverage marker: `$53.5K`, `$53.5K+` when some
+ * usage is unpriced (a lower bound), `unpriced` when none was priced. */
+export declare function spendText(spend: Spend): string | null;
+/** One sentence for a title or accessible label. */
+export declare function spendDescription(spend: Spend, tokenText: (tokens: number) => string): string;

package/dist/lib/spend.js

@@ -0,0 +1,112 @@
+// Estimated spend (docs/ARCHITECTURE.md §4.1.3): recorded requests at the
+// model creator's API list price, supplemented by higher reported session
+// totals. A provider-billed amount is a separate, secondary figure; usage the
+// price catalog cannot price is counted and shown, never read as $0.
+import { fmtCompactNumber } from "./format.js";
+export const NO_SPEND = {
+    costMicroUsd: null,
+    billedMicroUsd: null,
+    unpricedTokens: 0,
+    unrecordedOutput: 0,
+    reportedCostAdjustmentMicroUsd: 0,
+};
+export function spendOf(fields) {
+    return {
+        costMicroUsd: fields.cost_micro_usd,
+        billedMicroUsd: fields.billed_micro_usd,
+        unpricedTokens: fields.unpriced_tokens,
+        unrecordedOutput: fields.unrecorded_output,
+        reportedCostAdjustmentMicroUsd: fields.reported_cost_adjustment_micro_usd ?? 0,
+    };
+}
+function addNullable(left, right) {
+    if (left === null)
+        return right;
+    if (right === null)
+        return left;
+    return left + right;
+}
+export function addSpend(left, right) {
+    return {
+        costMicroUsd: addNullable(left.costMicroUsd, right.costMicroUsd),
+        billedMicroUsd: addNullable(left.billedMicroUsd, right.billedMicroUsd),
+        unpricedTokens: left.unpricedTokens + right.unpricedTokens,
+        unrecordedOutput: left.unrecordedOutput + right.unrecordedOutput,
+        reportedCostAdjustmentMicroUsd: left.reportedCostAdjustmentMicroUsd + right.reportedCostAdjustmentMicroUsd,
+    };
+}
+export function sumSpend(rows) {
+    let total = NO_SPEND;
+    for (const row of rows)
+        total = addSpend(total, spendOf(row));
+    return total;
+}
+export function coverage(spend) {
+    if (spend.costMicroUsd === null)
+        return spend.unpricedTokens > 0 ? "unavailable" : "none";
+    return spend.unpricedTokens > 0 || spend.unrecordedOutput > 0 ? "partial" : "complete";
+}
+/** Shared compact scale, with currency-specific cents for smaller amounts. */
+export function fmtUsd(microUsd) {
+    const usd = microUsd / 1e6;
+    if (usd >= 999.5) {
+        const figure = fmtCompactNumber(usd);
+        return { n: `$${figure.n}`, u: figure.u };
+    }
+    if (usd >= 100)
+        return { n: `$${usd.toFixed(0)}`, u: "" };
+    if (usd >= 0.01 || usd === 0)
+        return { n: `$${usd.toFixed(2)}`, u: "" };
+    return { n: "<$0.01", u: "" };
+}
+export function usdText(microUsd) {
+    const figure = fmtUsd(microUsd);
+    return figure.n + figure.u;
+}
+/** A long form for titles and accessible labels: `$1,234.56`. */
+export function usdExact(microUsd) {
+    return (microUsd / 1e6).toLocaleString(undefined, {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: 2,
+        maximumFractionDigits: microUsd < 10_000 ? 4 : 2,
+    });
+}
+/** The compact figure with its coverage marker: `$53.5K`, `$53.5K+` when some
+ * usage is unpriced (a lower bound), `unpriced` when none was priced. */
+export function spendText(spend) {
+    switch (coverage(spend)) {
+        case "none":
+            return null;
+        case "unavailable":
+            return "unpriced";
+        case "partial":
+            return `${usdText(spend.costMicroUsd ?? 0)}+`;
+        case "complete":
+            return usdText(spend.costMicroUsd ?? 0);
+    }
+}
+/** One sentence for a title or accessible label. */
+export function spendDescription(spend, tokenText) {
+    const parts = [];
+    if (spend.costMicroUsd !== null) {
+        if (spend.reportedCostAdjustmentMicroUsd > 0) {
+            parts.push(`${usdExact(spend.costMicroUsd)} estimated cost`);
+            parts.push(`${usdExact(spend.costMicroUsd - spend.reportedCostAdjustmentMicroUsd)} from recorded requests at API list prices`);
+            parts.push(`${usdExact(spend.reportedCostAdjustmentMicroUsd)} added from agent-reported session totals`);
+        }
+        else {
+            parts.push(`${usdExact(spend.costMicroUsd)} at API list prices`);
+        }
+    }
+    if (spend.unpricedTokens > 0) {
+        parts.push(`${tokenText(spend.unpricedTokens)} tokens ${spend.costMicroUsd === null ? "" : "more "}with no list price`);
+    }
+    if (spend.unrecordedOutput > 0) {
+        parts.push(`${spend.unrecordedOutput.toLocaleString()} ${spend.unrecordedOutput === 1 ? "reply" : "replies"} with unrecorded output`);
+    }
+    if (spend.billedMicroUsd !== null) {
+        parts.push(`${usdExact(spend.billedMicroUsd)} billed by the provider`);
+    }
+    return parts.length === 0 ? "No usage read from this agent's records" : parts.join(" · ");
+}

package/dist/lib/tint.d.ts

@@ -0,0 +1,9 @@
+import type { KeyValueStore } from "./room-storage.js";
+export declare function tintOf(seq: number): string;
+/** One room's dealer: its stored numbers, dealt once each. */
+export interface TintDealer {
+    /** Deal (or recall) the stored sequence number for a project id. */
+    projectSeq(projectId: string): number;
+    projectTint(projectId: string): string;
+}
+export declare function createTintDealer(store: KeyValueStore | null): TintDealer;

package/dist/lib/tint.js

@@ -0,0 +1,53 @@
+// PROJECT IDENTITY — the colour is DEALT, not derived (design record §3).
+// A project's hue is assigned the first time this room sees it, from the
+// golden-ratio sequence over a 333° wheel (a 27° band around --vf-select is
+// withheld), and the dealt number is stored so the colour never moves when
+// projects are added, deleted, or renamed. The store is the room's storage:
+// the design record prices this honestly — the colour is a property of when
+// the room first saw the project, so it does not travel between machines
+// until the number does.
+const TINT_H0 = 258;
+const TINT_SKIP_AT = 238;
+const TINT_SKIP_W = 27;
+const TINT_SPAN = 360 - TINT_SKIP_W;
+const PHI = 0.6180339887498949;
+/** Under the room's storage prefix, versioned: the dealt numbers by project. */
+const STORE_KEY = "tintSeq.v1";
+function tintHue(seq) {
+    const pos = (TINT_H0 + seq * PHI * TINT_SPAN) % TINT_SPAN;
+    return pos < TINT_SKIP_AT ? pos : pos + TINT_SKIP_W;
+}
+export function tintOf(seq) {
+    return `oklch(var(--tint-l) var(--tint-c) ${tintHue(seq).toFixed(1)})`;
+}
+export function createTintDealer(store) {
+    let seqs = null;
+    function load() {
+        try {
+            const raw = store?.getItem(STORE_KEY) ?? null;
+            if (raw)
+                return JSON.parse(raw);
+        }
+        catch {
+            // a blocked or corrupt store deals fresh numbers this run
+        }
+        return {};
+    }
+    function projectSeq(projectId) {
+        if (seqs === null)
+            seqs = load();
+        if (projectId in seqs)
+            return seqs[projectId];
+        const used = Object.values(seqs);
+        const next = used.length === 0 ? 0 : Math.max(...used) + 1;
+        seqs[projectId] = next;
+        try {
+            store?.setItem(STORE_KEY, JSON.stringify(seqs));
+        }
+        catch {
+            // storage refused; the deal holds for this run
+        }
+        return next;
+    }
+    return { projectSeq, projectTint: (projectId) => tintOf(projectSeq(projectId)) };
+}

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

@@ -0,0 +1,97 @@
+import type { ParticipantColor, ResponseRuntime, SessionRow, TimelineEntry } from "@vibefield/rosetta-protocol";
+import type { LedgerLine } from "./ledger.js";
+export type RuntimeProfileBasis = "observed" | "varies" | "configured" | "unknown";
+export interface RuntimeProfile {
+    readonly basis: RuntimeProfileBasis;
+    readonly label: string;
+    readonly model: string | null;
+    readonly effort: string | null;
+    readonly profileCount: number;
+}
+export type TeamMemberOperation = "start" | "known" | "add" | "resume";
+export interface TeamMemberPresentation {
+    readonly row: TimelineEntry;
+    readonly session: SessionRow | null;
+    readonly operation: TeamMemberOperation;
+    readonly team: string;
+    readonly name: string;
+    readonly color: ParticipantColor | null;
+    readonly objective: string;
+    readonly configuredModel: string | null;
+    readonly runtime: RuntimeProfile;
+}
+export interface TeamParticipantPresentation {
+    readonly color: ParticipantColor | null;
+    readonly runtime: RuntimeProfile;
+    readonly sessionId: string | null;
+}
+export interface WorkerThreadLinks {
+    /** The one durable disclosure that owns each ordinary worker document. */
+    readonly anchorRowByChild: ReadonlyMap<string, string>;
+    /** Children mounted below their earliest proven invocation. */
+    readonly childrenByRow: ReadonlyMap<string, readonly SessionRow[]>;
+    /** Later delegate/resume lines which navigate back to that disclosure. */
+    readonly referencedChildIdsByRow: ReadonlyMap<string, readonly string[]>;
+}
+/** Workflow workers belong to the workflow hierarchy even when pagination
+ * leaves their owning workflow row outside the loaded parent page. The title
+ * fallback keeps projections made before `workflow_run_id` was retained from
+ * leaking hundreds of legacy workflow workers into the parent timeline. */
+export declare function isWorkflowOwnedSession(session: SessionRow): boolean;
+/** Only genuinely standalone workers may use the timestamp-based fallback.
+ * Workflow workers wait for their owning run and mount under their exact
+ * phase/worker row through `workerThreadLinks`. */
+export declare function standaloneWorkerSessions(children: readonly SessionRow[], links: WorkerThreadLinks, indexedWorkflowChildren?: ReadonlySet<string>): readonly SessionRow[];
+export interface TeamReportWork {
+    readonly rows: readonly TimelineEntry[];
+    readonly actionCount: number;
+    readonly startedAt: number | null;
+    readonly endedAt: number | null;
+}
+export interface TeamChronology {
+    readonly rows: readonly TimelineEntry[];
+    /** Every suppressed transport copy points at the one rendered delivery. */
+    readonly duplicateRepresentatives: ReadonlyMap<string, string>;
+}
+export type CollaborationTimeBasis = "authored" | "observed_arrival" | "unknown";
+export interface CollaborationStamp {
+    readonly at: number | null;
+    readonly basis: CollaborationTimeBasis;
+}
+/** Response evidence wins over configuration. Split rows in one response are
+ * first joined by response id, then distinct model/effort pairs are counted. */
+export declare function runtimeProfile(rows: readonly TimelineEntry[], configuredModel: string | null, responseRuntimes?: readonly ResponseRuntime[]): RuntimeProfile;
+/** Direct child sessions that native evidence identifies as team members. */
+export declare function teamSessionIds(parentSessionId: string, directChildren: readonly SessionRow[], parentRows: readonly TimelineEntry[]): readonly string[];
+/** Roster facts and the start/add/resume operation for every proven team
+ * delegate row. The first observed member starts the team; subsequent rows add
+ * members unless the native request says resume. */
+export declare function teamMemberPresentations(rows: readonly TimelineEntry[], sessions: ReadonlyMap<string, SessionRow>, rowsBySession: ReadonlyMap<string, readonly TimelineEntry[]>, responseRuntimesBySession?: ReadonlyMap<string, readonly ResponseRuntime[]>, historyComplete?: boolean): ReadonlyMap<string, TeamMemberPresentation>;
+/** Resolve message senders back to roster facts. Names are native addresses;
+ * no timestamp or prose matching participates in this join. */
+export declare function teamParticipants(members: ReadonlyMap<string, TeamMemberPresentation>, knownSessions?: readonly SessionRow[], rowsBySession?: ReadonlyMap<string, readonly TimelineEntry[]>, responseRuntimesBySession?: ReadonlyMap<string, readonly ResponseRuntime[]>): ReadonlyMap<string, TeamParticipantPresentation>;
+/** Native authored time is the shared-chronology stamp when present. The
+ * containing row time is an explicitly labelled observed-delivery fallback. */
+export declare function collaborationStamp(row: TimelineEntry): CollaborationStamp;
+/** Add only delivered boundary events from team-member transcripts to the
+ * parent's chronology. The member's initial coordinator assignment stays
+ * private; later coordinator follow-ups are addressable team conversation and
+ * do interleave. A delivery id is the only cross-session dedupe key we trust;
+ * similar prose is never silently collapsed. Parent row order remains
+ * canonical, while child events enter the gap selected by native authored
+ * time, or their explicitly labelled observed-arrival fallback. */
+export declare function teamChronology(parentRows: readonly TimelineEntry[], rowsBySession: ReadonlyMap<string, readonly TimelineEntry[]>, coverage?: {
+    readonly hasEarlier: boolean;
+    readonly ready: boolean;
+}): TeamChronology;
+export declare function interleaveTeamCollaboration(parentRows: readonly TimelineEntry[], rowsBySession: ReadonlyMap<string, readonly TimelineEntry[]>): readonly TimelineEntry[];
+export declare function participantPresentation(participants: ReadonlyMap<string, TeamParticipantPresentation>, sender: string | null, team?: string | null): TeamParticipantPresentation | null;
+/** Give an ordinary Agent worker exactly one subthread. The earliest proven
+ * invocation owns it; subsequent delegate/resume rows are links back to that
+ * same disclosure. Team children are excluded because their delivered speech
+ * belongs to the shared parent chronology instead. */
+export declare function workerThreadLinks(lines: readonly LedgerLine[], parentSessionId: string, sessions: ReadonlyMap<string, SessionRow>, excludedSessionIds: ReadonlySet<string>): WorkerThreadLinks;
+/** Recover report work only when canonical evidence names the exact source
+ * session and inclusive timeline bounds. A shared task id alone is not a
+ * safe range: teammates can overlap work on the same task. */
+export declare function taskBoundedReportWork(reportRow: TimelineEntry, sourceRows: readonly TimelineEntry[]): TeamReportWork | null;