@vibefield/rosetta-room 0.0.0-stage → 0.1.1

package/dist/lib/image-media.d.ts

@@ -0,0 +1,6 @@
+import type { AssetRef } from "@vibefield/rosetta-protocol";
+/** File-format hints for image targets without a filename extension or MIME type.
+ * This only selects the existing viewer; the browser still validates/decodes it. */
+export declare function imageMediaTypeFromBytes(bytes: Uint8Array): string | null;
+/** Transcript images must be committed WebP bundles produced by ingestion. */
+export declare function isOptimizedImageAsset(asset: AssetRef): boolean;

package/dist/lib/image-media.js

@@ -0,0 +1,30 @@
+/** File-format hints for image targets without a filename extension or MIME type.
+ * This only selects the existing viewer; the browser still validates/decodes it. */
+export function imageMediaTypeFromBytes(bytes) {
+    const starts = (...prefix) => prefix.every((value, index) => bytes[index] === value);
+    const text = (start, length) => String.fromCharCode(...bytes.subarray(start, start + length));
+    if (starts(137, 80, 78, 71, 13, 10, 26, 10))
+        return "image/png";
+    if (starts(255, 216, 255))
+        return "image/jpeg";
+    if (["GIF87a", "GIF89a"].includes(text(0, 6)))
+        return "image/gif";
+    if (text(0, 4) === "RIFF" && text(8, 4) === "WEBP")
+        return "image/webp";
+    if (text(0, 2) === "BM")
+        return "image/bmp";
+    if (starts(0, 0, 1, 0))
+        return "image/x-icon";
+    if (text(4, 4) === "ftyp" && ["avif", "avis"].includes(text(8, 4)))
+        return "image/avif";
+    if (/^\s*(?:<\?xml[^>]*>\s*)?<svg[\s>]/i.test(new TextDecoder().decode(bytes.subarray(0, 512))))
+        return "image/svg+xml";
+    return null;
+}
+/** Transcript images must be committed WebP bundles produced by ingestion. */
+export function isOptimizedImageAsset(asset) {
+    const member = (value) => value?.media_type === "image/webp"
+        && value.byte_len > 0 && /^[a-f0-9]{64}$/.test(value.digest)
+        && value.url === `/api/assets/${value.digest}.webp`;
+    return member(asset) && ["rail", "tile", "tile2x", "preview"].every(variant => member(asset.image_variants?.[variant]));
+}

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

@@ -0,0 +1,50 @@
+import type { IngestProgress, RuntimeBackfill, SearchBuildProgress, SearchReadiness } from "@vibefield/rosetta-protocol";
+export interface ActivityFeed {
+    readonly ingest: IngestProgress | null;
+    readonly canonicalReady: boolean | null;
+    readonly searchReadiness: SearchReadiness | null;
+    readonly searchProgress: SearchBuildProgress | null;
+    readonly connectionError: string | null;
+    readonly startedAt: number | null;
+    readonly uptimeMs: number;
+    readonly receivedAt: number | null;
+}
+export interface ActivityPhase {
+    readonly key: string;
+    readonly title: string;
+    readonly detail: string;
+    readonly amount: string;
+    readonly step: number;
+    readonly current: number;
+    readonly total: number;
+    readonly unit: "bytes" | "files" | "documents" | "records" | null;
+    readonly fraction: number | null;
+    readonly active: boolean;
+}
+export declare const fraction: (done: number, total: number) => number | null;
+export declare function progressBytes(value: number): string;
+export declare function progressDuration(ms: number): string;
+/** Percentages describe the named step, never an invented overall ETA. */
+export declare function activityPhase(feed: ActivityFeed): ActivityPhase | null;
+export declare function runtimeActivity(row: RuntimeBackfill, restoring?: boolean): {
+    label: string;
+    fraction: number | null;
+};
+export interface ActivitySamples {
+    readonly identity: string;
+    readonly points: readonly {
+        at: number;
+        value: number;
+    }[];
+    readonly changedAt: number;
+    readonly rate: number | null;
+}
+/** Eight seconds of actual observations smooth variable batch sizes. A restart,
+ * phase transition, retry, or regressing counter starts a new sample window. */
+export declare function sampleActivity(previous: ActivitySamples | null, feed: ActivityFeed, phase: ActivityPhase): ActivitySamples;
+export interface IngestActivity {
+    readonly phase: ActivityPhase;
+    readonly feed: ActivityFeed;
+    readonly footer: string;
+    readonly elapsed: string;
+}

package/dist/lib/ingest-activity.js

@@ -0,0 +1,151 @@
+const number = (value) => value.toLocaleString();
+export const fraction = (done, total) => total > 0
+    ? Math.max(0, Math.min(1, done / total)) : null;
+export function progressBytes(value) {
+    if (value < 1_000)
+        return `${Math.max(0, Math.round(value))} B`;
+    if (value < 1_000_000)
+        return `${(value / 1_000).toFixed(0)} KB`;
+    if (value < 1_000_000_000)
+        return `${(value / 1_000_000).toFixed(1)} MB`;
+    return `${(value / 1_000_000_000).toFixed(2)} GB`;
+}
+export function progressDuration(ms) {
+    const seconds = Math.floor(Math.max(0, ms) / 1_000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3_600)
+        return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    return `${Math.floor(seconds / 3_600)}h ${Math.floor((seconds % 3_600) / 60)}m`;
+}
+/** Percentages describe the named step, never an invented overall ETA. */
+export function activityPhase(feed) {
+    const ingest = feed.ingest;
+    if (ingest?.phase === "awaiting_consent" || feed.receivedAt === null)
+        return null;
+    const runtimes = ingest?.runtimes ?? [];
+    const sessions = runtimes.reduce((sum, row) => sum + row.sessions_total, 0);
+    const base = {
+        key: "discovering", title: "Finding your history", step: 1,
+        detail: "Checking the agents on this Mac. Your history stays on this device.",
+        amount: "Looking for conversations…", current: 0, total: 0,
+        unit: null, fraction: null, active: true,
+    };
+    if (ingest?.phase === "discovering")
+        return base;
+    if (ingest?.phase === "restoring") {
+        const current = runtimes.filter((row) => row.state === "streaming")
+            .reduce((sum, row) => sum + row.records, 0);
+        return { ...base, key: "restoring", title: "Restoring saved progress",
+            detail: "Recovering saved conversations so your import can continue.",
+            amount: `${number(current)} items restored`, current, unit: "records" };
+    }
+    if (ingest?.phase === "metadata_ready")
+        return {
+            ...base, key: "paused", title: "History scan complete", active: false,
+            detail: "Transcript import is paused after scanning your history.",
+            amount: `${number(sessions)} sessions found`,
+        };
+    if (ingest?.phase === "finalizing" || ingest?.phase === "publishing")
+        return {
+            ...base, key: ingest.phase, step: 3,
+            title: ingest.phase === "publishing" ? "Saving your archive" : "Finishing your archive",
+            detail: ingest.phase === "publishing"
+                ? "Saving your history to this device. Search is next."
+                : "Checking conversations and preparing your activity summaries.",
+            amount: `${number(sessions)} sessions imported`,
+        };
+    if (ingest && ingest.phase !== "live") {
+        const scanning = runtimes.length === 0 || runtimes.some((row) => row.state === "skimming") ||
+            runtimes.every((row) => row.state === "queued");
+        if (scanning) {
+            const current = runtimes.reduce((sum, row) => sum + row.files_skimmed, 0);
+            const total = runtimes.reduce((sum, row) => sum + row.files_total, 0);
+            return {
+                ...base, key: "metadata", title: "Discovering conversations",
+                detail: `${number(sessions)} sessions found. Projects appear as each agent is scanned.`,
+                amount: `${number(current)} files checked`, current, total, unit: "files",
+                fraction: fraction(current, total),
+            };
+        }
+        if (runtimes.some((row) => row.state === "streaming")) {
+            const current = runtimes.reduce((sum, row) => sum + row.bytes_streamed, 0);
+            const total = runtimes.some((row) => row.bytes_total === 0 && row.sessions_total > 0) ? 0
+                : runtimes.reduce((sum, row) => sum + row.bytes_total, 0);
+            return {
+                ...base, key: "reading", title: "Reading conversations", step: 2,
+                detail: "You can browse conversations as each agent becomes ready.",
+                amount: `${progressBytes(current)} processed`, current, total, unit: "bytes",
+                fraction: fraction(current, total),
+            };
+        }
+        return {
+            ...base, key: "organizing", title: "Organizing conversations", step: 3,
+            detail: "Putting messages and tool activity in order before they become available.",
+            amount: `${number(sessions)} sessions found`,
+        };
+    }
+    if (feed.searchReadiness === "failed")
+        return {
+            ...base, key: "search_failed", title: "Search needs attention", step: 4, active: false,
+            detail: "Your conversations are available. Search will retry automatically.",
+            amount: "Ready to browse",
+        };
+    if (feed.canonicalReady && feed.searchReadiness === "ready")
+        return {
+            ...base, key: "ready", title: "Your archive is ready", step: 4, active: false,
+            detail: "Browse and search all your conversations.",
+            amount: `${number(sessions)} sessions imported`, fraction: 1,
+        };
+    // Routine live repair must not reopen the first-run import panel.
+    if (feed.canonicalReady && !feed.searchProgress &&
+        (feed.searchReadiness === "catching-up" || feed.searchReadiness === "stale"))
+        return null;
+    if (feed.canonicalReady) {
+        const progress = feed.searchProgress;
+        const indexing = !progress || progress.stage === "indexing";
+        return {
+            ...base, key: `search_${progress?.stage ?? "waiting"}`, step: 4,
+            title: indexing ? "Preparing search" : "Finishing search",
+            detail: indexing ? "Your conversations are ready to browse. Search will be available shortly."
+                : progress.stage === "publishing" ? "Saving the search index. Your conversations are ready to browse."
+                    : "Checking the search index. Your conversations are ready to browse.",
+            amount: progress ? `${number(progress.documents_done)} of ${number(progress.documents_total)} messages`
+                : "Ready to browse",
+            current: progress?.documents_done ?? 0, total: progress?.documents_total ?? 0,
+            unit: indexing ? "documents" : null,
+            fraction: indexing && progress ? fraction(progress.documents_done, progress.documents_total) : null,
+        };
+    }
+    return base;
+}
+export function runtimeActivity(row, restoring = false) {
+    if (restoring && row.state === "streaming")
+        return { label: `${number(row.records)} items restored`, fraction: null };
+    switch (row.state) {
+        case "queued": return { label: row.sessions_total ? "Waiting to read" : "Waiting to scan", fraction: null };
+        case "skimming": return { label: `${number(row.sessions_total)} sessions found`, fraction: fraction(row.files_skimmed, row.files_total) };
+        case "streaming": return { label: `${progressBytes(row.bytes_streamed)} processed`, fraction: fraction(row.bytes_streamed, row.bytes_total) };
+        case "preparing": return { label: "Organizing conversations", fraction: null };
+        case "applying": return { label: "Making conversations available", fraction: null };
+        case "done": return { label: "Ready to browse", fraction: 1 };
+    }
+}
+/** Eight seconds of actual observations smooth variable batch sizes. A restart,
+ * phase transition, retry, or regressing counter starts a new sample window. */
+export function sampleActivity(previous, feed, phase) {
+    const at = feed.receivedAt ?? 0;
+    const identity = `${feed.startedAt}:${phase.key}:${phase.unit}`;
+    const last = previous?.points.at(-1);
+    if (!previous || previous.identity !== identity || !last || phase.current < last.value || at < last.at) {
+        return { identity, points: [{ at, value: phase.current }], changedAt: at, rate: null };
+    }
+    if (at === last.at || feed.connectionError)
+        return previous;
+    const points = [...previous.points.filter((point) => at - point.at <= 8_000), { at, value: phase.current }];
+    const first = points[0];
+    const changedAt = phase.current !== last.value ? at : previous.changedAt;
+    const rate = at - first.at >= 1_000 && at - changedAt < 4_000
+        ? (phase.current - first.value) * 1_000 / (at - first.at) : null;
+    return { identity, points, changedAt, rate: rate !== null && rate > 0 ? rate : null };
+}

package/dist/lib/ingest.d.ts

@@ -0,0 +1,25 @@
+import type { IngestProgress, ProjectBackfill, SessionRow } from "@vibefield/rosetta-protocol";
+/** The backfill is still running: veils may be down, cards may cook. */
+export declare function isIngestActive(ingest: IngestProgress | null): boolean;
+/** The census (skim) has not yet named every session: the LISTS themselves
+ * are still incomplete, so the list sections stay veiled. */
+export declare function isCensusRunning(ingest: IngestProgress | null): boolean;
+/** Census meter: files skimmed over the discovery walk's total. */
+export declare function censusProgress(ingest: IngestProgress | null): number | null;
+/** Stream meter: transcript bytes read over the census's byte total. */
+export declare function backfillProgress(ingest: IngestProgress | null): number | null;
+/** A session whose figures are still cooking. During the backfill this is
+ * the cooking card; during live it marks a transcript still being read. */
+export declare function isSessionCooking(session: SessionRow): boolean;
+/** The daemon's per-project backfill fold, keyed the way the room keys
+ * projects — the canonical id, with the daemon's unassigned bucket under
+ * UNASSIGNED_PROJECT_ID. Empty until the skims settle the plan, and empty
+ * on a daemon too old to carry the fold, so every consumer degrades to the
+ * meta-derived cooking state it had before. */
+export declare function projectBackfills(ingest: IngestProgress | null): ReadonlyMap<string, ProjectBackfill>;
+/** One project's byte meter, 0..1. A source that grew mid-backfill can
+ * overshoot its census total, so the meter clamps; null when the census
+ * counted nothing to read. */
+export declare function projectBackfillProgress(row: ProjectBackfill): number | null;
+/** "2,314 of 5,912 sessions" — the veil labels' one counting form. */
+export declare function sessionCountLabel(indexed: number, total: number): string;

package/dist/lib/ingest.js

@@ -0,0 +1,70 @@
+import { UNASSIGNED_PROJECT_ID } from "./model.js";
+/** The backfill is still running: veils may be down, cards may cook. */
+export function isIngestActive(ingest) {
+    return ingest !== null && ingest.phase !== "live";
+}
+/** The census (skim) has not yet named every session: the LISTS themselves
+ * are still incomplete, so the list sections stay veiled. */
+export function isCensusRunning(ingest) {
+    if (!isIngestActive(ingest))
+        return false;
+    if (ingest === null)
+        return true;
+    // The explicit audit seam proves every bounded skim has committed. Runtime
+    // rows remain queued because complete-record streaming has not started.
+    if (ingest.phase === "metadata_ready")
+        return false;
+    if (ingest.runtimes.length === 0)
+        return true;
+    return ingest.runtimes.some((runtime) => runtime.state === "queued" || runtime.state === "skimming");
+}
+/** Census meter: files skimmed over the discovery walk's total. */
+export function censusProgress(ingest) {
+    if (ingest === null)
+        return null;
+    const totals = ingest.runtimes.reduce((sum, runtime) => ({
+        done: sum.done + runtime.files_skimmed,
+        all: sum.all + runtime.files_total,
+    }), { done: 0, all: 0 });
+    return totals.all > 0 ? totals.done / totals.all : null;
+}
+/** Stream meter: transcript bytes read over the census's byte total. */
+export function backfillProgress(ingest) {
+    if (ingest === null)
+        return null;
+    const totals = ingest.runtimes.reduce((sum, runtime) => ({
+        done: sum.done +
+            (runtime.state === "done" ? runtime.bytes_total : runtime.bytes_streamed),
+        all: sum.all + runtime.bytes_total,
+    }), { done: 0, all: 0 });
+    return totals.all > 0 ? Math.min(1, totals.done / totals.all) : null;
+}
+/** A session whose figures are still cooking. During the backfill this is
+ * the cooking card; during live it marks a transcript still being read. */
+export function isSessionCooking(session) {
+    return session.stream_state !== "indexed";
+}
+/** The daemon's per-project backfill fold, keyed the way the room keys
+ * projects — the canonical id, with the daemon's unassigned bucket under
+ * UNASSIGNED_PROJECT_ID. Empty until the skims settle the plan, and empty
+ * on a daemon too old to carry the fold, so every consumer degrades to the
+ * meta-derived cooking state it had before. */
+export function projectBackfills(ingest) {
+    const index = new Map();
+    for (const row of ingest?.projects ?? []) {
+        index.set(row.project_id ?? UNASSIGNED_PROJECT_ID, row);
+    }
+    return index;
+}
+/** One project's byte meter, 0..1. A source that grew mid-backfill can
+ * overshoot its census total, so the meter clamps; null when the census
+ * counted nothing to read. */
+export function projectBackfillProgress(row) {
+    if (row.bytes_total === 0)
+        return null;
+    return Math.min(1, row.bytes_streamed / row.bytes_total);
+}
+/** "2,314 of 5,912 sessions" — the veil labels' one counting form. */
+export function sessionCountLabel(indexed, total) {
+    return `${indexed.toLocaleString()} of ${total.toLocaleString()} sessions`;
+}

package/dist/lib/model-labels.d.ts

@@ -0,0 +1,5 @@
+export declare function modelColor(modelId: string): string;
+export declare function formatModelLabel(modelId: string): string;
+/** Resolve palette collisions once for a project's model set, so selecting
+ * another day keeps a model's color and adjacent legend entries stay distinct. */
+export declare function createModelColors(ids: readonly string[]): Readonly<Record<string, string>>;

package/dist/lib/model-labels.js

@@ -0,0 +1,28 @@
+export function modelColor(modelId) {
+    let hash = 2166136261;
+    for (let index = 0; index < modelId.length; index += 1) {
+        hash ^= modelId.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return `var(--vf-accent-${((hash >>> 0) % 8) + 1})`;
+}
+export function formatModelLabel(modelId) {
+    return modelId.startsWith("claude-") ? modelId.slice("claude-".length) : modelId;
+}
+/** Resolve palette collisions once for a project's model set, so selecting
+ * another day keeps a model's color and adjacent legend entries stay distinct. */
+export function createModelColors(ids) {
+    const colors = Object.create(null);
+    const used = new Set();
+    for (const id of [...new Set(ids)].sort()) {
+        const preferred = modelColor(id);
+        let color = preferred;
+        for (let index = 1; used.has(color) && index <= 8; index++)
+            color = `var(--vf-accent-${index})`;
+        if (used.has(color))
+            color = `color-mix(in srgb, ${preferred} 65%, var(--vf-text-primary))`;
+        colors[id] = color;
+        used.add(color);
+    }
+    return colors;
+}

package/dist/lib/model.d.ts

@@ -0,0 +1,73 @@
+import type { ContributionRow, HeatmapDay, ProjectRow, SessionRow } from "@vibefield/rosetta-protocol";
+import type { AgentShare } from "./agents.js";
+import type { Spend } from "./spend.js";
+export interface ProjectStats {
+    /** Daily token totals over the heatmap's window (53 Sunday-aligned weeks
+     * ending today), from /heatmap?since_ms=…. */
+    heat: readonly HeatmapDay[];
+    /** Per-root-session contribution (tokens, messages, …), whole project life. */
+    contribution: readonly ContributionRow[];
+}
+export interface ProjectViewModel {
+    readonly row: ProjectRow;
+    readonly tint: string;
+    /** Tokens across the project's whole life (root contributions include
+     * their subagent trees). */
+    readonly lifetimeTokens: number;
+    /** List-price spend across the project's whole life — the project card's
+     * primary figure and the ledger's default ranking (§4.1.3). */
+    readonly lifetimeSpend: Spend;
+    /** List-price spend over the last 30 days, the same heatmap tail. */
+    readonly spendLast30Days: Spend;
+    /** List-price spend over the 53-week window. */
+    readonly spendLast53Weeks: Spend;
+    /** Tokens over the last 30 days — the ledger's stated window. */
+    readonly tokensLast30Days: number;
+    /** 15 two-day buckets, oldest first — the activity shape. */
+    readonly recentTokenBuckets: readonly number[];
+    /** 53×7 daily totals from the grid's Sunday; cells after today are -1.
+     * The heatmap is all of it and the 30-day figures are its tail, so the
+     * charts are views of one number and cannot disagree. */
+    readonly dailyTokens: readonly number[];
+    /** Index of today inside dailyTokens. */
+    readonly currentDayIndex: number;
+    /** Tokens over the whole 53-week window — the summary panel's stated window. */
+    readonly tokensLast53Weeks: number;
+    /** Message rows across the project's whole life (contribution sum). */
+    readonly lifetimeMessages: number;
+    readonly agents: readonly AgentShare[];
+    readonly lastActiveMs: number | null;
+    readonly rootSessionCount: number;
+    /** Every session of the project, subagents included — the readiness base. */
+    readonly sessionCount: number;
+    /** Sessions the stream phase has fully indexed. */
+    readonly indexedSessionCount: number;
+    /** Folded over session stream_state. Aggregate requests have their own
+     * statsReady gate and may finish after transcripts become browseable. */
+    readonly readiness: "pending" | "partial" | "ready";
+    /** Aggregate requests finish separately from transcript publication. */
+    readonly statsReady: boolean;
+}
+/** Client-only bucket for sessions whose adapters have no native cwd fact.
+ * It is deliberately not persisted as a canonical project. */
+export declare const UNASSIGNED_PROJECT_ID = "__rosetta_unassigned__";
+export declare function projectKey(session: SessionRow): string;
+export declare function unassignedProject(): ProjectRow;
+export declare const ACTIVITY_HEATMAP_WEEK_COUNT = 53;
+export declare const ACTIVITY_HEATMAP_DAY_COUNT: number;
+/** Midnight of the Sunday opening the grid's first column. */
+export declare function getActivityGridStartTimestamp(currentTimestamp: number): number;
+/** The viewer's offset, minutes east of UTC — passed to /heatmap so the
+ * daemon buckets days the way this screen will label them. */
+export declare function getViewerUtcOffsetMinutes(): number;
+/** The viewer-offset day key for a timestamp — the exact form the heatmap
+ * endpoint was asked to bucket in. */
+export declare function getCalendarDayKey(timestamp: number): string;
+export declare function buildProjectViewModel(projectRow: ProjectRow, allSessions: readonly SessionRow[], projectStats: ProjectStats | undefined, getRuntimeKind: (runtimeId: string) => string, currentTimestamp: number, 
+/** The room's dealt colour for a project (`TintDealer.projectTint`). */
+projectTint: (projectId: string) => string): ProjectViewModel;
+export interface SnippetPart {
+    text: string;
+    mark: boolean;
+}
+export declare function parseSnippet(snippet: string): SnippetPart[];

package/dist/lib/model.js

@@ -0,0 +1,141 @@
+import { NO_SPEND, addSpend, spendOf, sumSpend } from "./spend.js";
+import { sessionLastActive } from "./session-activity.js";
+const DAY_IN_MS = 86_400_000;
+/** Client-only bucket for sessions whose adapters have no native cwd fact.
+ * It is deliberately not persisted as a canonical project. */
+export const UNASSIGNED_PROJECT_ID = "__rosetta_unassigned__";
+export function projectKey(session) {
+    return session.project_id ?? UNASSIGNED_PROJECT_ID;
+}
+export function unassignedProject() {
+    return {
+        id: UNASSIGNED_PROJECT_ID,
+        name: "Unassigned sessions",
+        root_paths: [],
+        git_repo: null,
+    };
+}
+/* ── heatmap grid: 53 columns of weeks, Sunday-aligned, ending today ────── */
+export const ACTIVITY_HEATMAP_WEEK_COUNT = 53;
+export const ACTIVITY_HEATMAP_DAY_COUNT = ACTIVITY_HEATMAP_WEEK_COUNT * 7;
+function startOfDay(ms) {
+    const d = new Date(ms);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+}
+/** Midnight of the Sunday opening the grid's first column. */
+export function getActivityGridStartTimestamp(currentTimestamp) {
+    const today = startOfDay(currentTimestamp);
+    return (today -
+        ((ACTIVITY_HEATMAP_WEEK_COUNT - 1) * 7 + new Date(today).getDay()) * DAY_IN_MS);
+}
+/** The viewer's offset, minutes east of UTC — passed to /heatmap so the
+ * daemon buckets days the way this screen will label them. */
+export function getViewerUtcOffsetMinutes() {
+    return -new Date().getTimezoneOffset();
+}
+/** The viewer-offset day key for a timestamp — the exact form the heatmap
+ * endpoint was asked to bucket in. */
+export function getCalendarDayKey(timestamp) {
+    const d = new Date(timestamp + getViewerUtcOffsetMinutes() * 60_000);
+    return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+/** The full 53×7 grid, zero-filled from sparse heatmap days; cells after
+ * today hold -1 (not yet, which is not the same as empty). */
+function createActivitySeries(heatmapDays, currentTimestamp) {
+    const tokensByDay = new Map(heatmapDays.map((day) => [day.day, day.tokens]));
+    const startTimestamp = getActivityGridStartTimestamp(currentTimestamp);
+    const currentDayKey = getCalendarDayKey(currentTimestamp);
+    const dailyTokens = [];
+    let currentDayIndex = ACTIVITY_HEATMAP_DAY_COUNT - 1;
+    for (let index = 0; index < ACTIVITY_HEATMAP_DAY_COUNT; index += 1) {
+        const key = getCalendarDayKey(startTimestamp + index * DAY_IN_MS + DAY_IN_MS / 2);
+        if (key === currentDayKey)
+            currentDayIndex = index;
+        dailyTokens.push(index > currentDayIndex ? -1 : (tokensByDay.get(key) ?? 0));
+    }
+    return { dailyTokens, currentDayIndex };
+}
+export function buildProjectViewModel(projectRow, allSessions, projectStats, getRuntimeKind, currentTimestamp, 
+/** The room's dealt colour for a project (`TintDealer.projectTint`). */
+projectTint) {
+    const projectSessions = allSessions.filter((session) => projectKey(session) === projectRow.id);
+    const rootSessions = projectSessions.filter((session) => session.parent_session_id === null);
+    const indexedSessionCount = projectSessions.filter((session) => session.stream_state === "indexed").length;
+    const readiness = indexedSessionCount === projectSessions.length
+        ? "ready"
+        : indexedSessionCount === 0
+            ? "pending"
+            : "partial";
+    const { dailyTokens, currentDayIndex } = createActivitySeries(projectStats?.heat ?? [], currentTimestamp);
+    // The ledger's 30-day figures are the same series' tail, so the heatmap,
+    // the sparkline, and the figure can never disagree.
+    const dailyTokensLast30Days = Array.from({ length: 30 }, (_, dayIndex) => Math.max(0, dailyTokens[currentDayIndex - (29 - dayIndex)] ?? 0));
+    const recentTokenBuckets = Array.from({ length: 15 }, (_, bucketIndex) => [dailyTokensLast30Days[bucketIndex * 2], dailyTokensLast30Days[bucketIndex * 2 + 1]].reduce((total, value) => total + (value ?? 0), 0));
+    const tokensLast30Days = dailyTokensLast30Days.reduce((total, value) => total + value, 0);
+    const tokensLast53Weeks = dailyTokens.reduce((total, value) => total + Math.max(0, value), 0);
+    const lifetimeTokens = (projectStats?.contribution ?? []).reduce((total, contribution) => total + contribution.tokens, 0);
+    const lifetimeSpend = sumSpend(projectStats?.contribution ?? []);
+    // Spend windows come from the same heatmap days as the token windows.
+    const thirtyDayKeys = new Set(Array.from({ length: 30 }, (_, dayIndex) => getCalendarDayKey(currentTimestamp - (29 - dayIndex) * DAY_IN_MS)));
+    let spendLast30Days = NO_SPEND;
+    let spendLast53Weeks = NO_SPEND;
+    for (const day of projectStats?.heat ?? []) {
+        const spend = spendOf(day);
+        spendLast53Weeks = addSpend(spendLast53Weeks, spend);
+        if (thirtyDayKeys.has(day.day))
+            spendLast30Days = addSpend(spendLast30Days, spend);
+    }
+    const lifetimeMessages = (projectStats?.contribution ?? []).reduce((total, contribution) => total + contribution.messages, 0);
+    const sessionCountByRuntimeKind = new Map();
+    for (const session of rootSessions) {
+        const runtimeKind = getRuntimeKind(session.runtime_id);
+        sessionCountByRuntimeKind.set(runtimeKind, (sessionCountByRuntimeKind.get(runtimeKind) ?? 0) + 1);
+    }
+    const totalSessionCount = rootSessions.length || 1;
+    const agents = [...sessionCountByRuntimeKind.entries()]
+        .map(([kind, count]) => ({
+        kind,
+        pct: Math.round((count / totalSessionCount) * 100),
+    }))
+        .sort((left, right) => right.pct - left.pct);
+    const lastActiveMs = rootSessions.reduce((latest, session) => {
+        const at = sessionLastActive(session);
+        return at === null ? latest : latest === null ? at : Math.max(latest, at);
+    }, null);
+    return {
+        row: projectRow,
+        tint: projectTint(projectRow.id),
+        lifetimeTokens,
+        lifetimeSpend,
+        spendLast30Days,
+        spendLast53Weeks,
+        tokensLast30Days,
+        recentTokenBuckets,
+        dailyTokens,
+        currentDayIndex,
+        tokensLast53Weeks,
+        lifetimeMessages,
+        agents,
+        lastActiveMs,
+        rootSessionCount: rootSessions.length,
+        sessionCount: projectSessions.length,
+        indexedSessionCount,
+        readiness,
+        statsReady: projectStats !== undefined,
+    };
+}
+export function parseSnippet(snippet) {
+    const parts = [];
+    const re = /\[([^\]]*)\]/g;
+    let at = 0;
+    for (let m = re.exec(snippet); m !== null; m = re.exec(snippet)) {
+        if (m.index > at)
+            parts.push({ text: snippet.slice(at, m.index), mark: false });
+        parts.push({ text: m[1], mark: true });
+        at = m.index + m[0].length;
+    }
+    if (at < snippet.length)
+        parts.push({ text: snippet.slice(at), mark: false });
+    return parts;
+}

package/dist/lib/motion.d.ts

@@ -0,0 +1,13 @@
+/** Shared timing for small, interruptible movements in the reading surfaces. */
+export declare const SETTLE_EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
+export declare const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+export declare function prefersReducedMotion(): boolean;
+/** FLIP in scroll-content coordinates, so ordinary scrolling never looks like
+ * a reorder. Only rows crossing the viewport acquire animation layers. */
+export declare class ListMotion {
+    private positions;
+    private animations;
+    private initialized;
+    update(container: HTMLElement, reduced: boolean): void;
+    cancel(): void;
+}