@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.0

package/dist/review/git.js

@@ -0,0 +1,226 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { ReviewSchema as R } from "./schema.js";
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context";
+import { WorkspaceBinding } from "@ericsanchezok/synergy-harness/workspace";
+import { FileView } from "@ericsanchezok/synergy-local-runtime/file/view";
+import { WorktreeProcess } from "@ericsanchezok/synergy-local-runtime/workspace/process";
+export var ReviewGit;
+(function (ReviewGit) {
+    const maxBytes = 768 * 1024;
+    const hash = (value) => createHash("sha256").update(value).digest("hex");
+    async function validate(input) {
+        const workspace = ScopeContext.current.workspace;
+        if (!workspace || workspace.id !== input.workspaceID || workspace.generation !== input.generation)
+            throw new R.Conflict({ message: "The selected workspace changed. Refresh the comparison." });
+        await WorkspaceBinding.validate(input.workspaceID, ScopeContext.current.scope.id, input.generation);
+        if (!FileView.native())
+            throw new R.Invalid({ message: "Git comparison requires an active native workspace." });
+        return { id: input.workspaceID, generation: input.generation, root: workspace.path };
+    }
+    async function git(args, signal, diff = false) {
+        const result = await WorktreeProcess.run({
+            command: ["git", "-c", "core.quotepath=false", "-c", "core.fsmonitor=false", "--literal-pathspecs", ...args],
+            directory: FileView.directory(),
+            roots: [],
+            metadata: true,
+            env: { GIT_OPTIONAL_LOCKS: "0", GIT_NO_REPLACE_OBJECTS: "1", GIT_TERMINAL_PROMPT: "0" },
+            signal: AbortSignal.any([AbortSignal.timeout(30_000), ...(signal ? [signal] : [])]),
+        });
+        if (result.exitCode !== 0 && !(diff && result.exitCode === 1))
+            throw new R.Invalid({ message: result.stderr.toString().trim() || "The repository could not be read." });
+        return result.stdout;
+    }
+    async function ref(value, signal) {
+        if (value.startsWith("-") || /[\0\r\n]/.test(value))
+            throw new R.Invalid({ message: "Invalid comparison reference." });
+        return (await git(["rev-parse", "--verify", "--end-of-options", `${value}^{commit}`], signal)).toString().trim();
+    }
+    async function endpoints(input, signal) {
+        if (input.source === "branch") {
+            const [from, to] = await Promise.all([ref(input.from ?? "origin/dev", signal), ref(input.to ?? "HEAD", signal)]);
+            return { from, to };
+        }
+        const from = await ref("HEAD", signal).catch((error) => {
+            if (signal?.aborted)
+                throw error;
+            return "";
+        });
+        return { from, to: "worktree" };
+    }
+    async function currentVersion(file) {
+        const stat = await FileView.stat(file);
+        return stat?.entryVersion ?? "missing";
+    }
+    async function fileVersion(input, endpoint, file) {
+        return hash(JSON.stringify([
+            input.workspaceID,
+            input.generation,
+            endpoint.from,
+            endpoint.to,
+            file,
+            input.source === "worktree" ? await currentVersion(file) : "",
+        ]));
+    }
+    async function compare(raw, signal) {
+        const input = R.CompareInput.parse(raw);
+        const workspace = await validate(input);
+        const endpoint = await endpoints(input, signal);
+        const args = ["diff", "--no-ext-diff", "--no-textconv", "--no-renames"];
+        const references = [endpoint.from, ...(input.source === "branch" ? [endpoint.to] : []), "--", "."];
+        const [stats, names] = endpoint.from
+            ? await Promise.all([
+                git([...args, "--numstat", "-z", ...references], signal).then((bytes) => bytes.toString()),
+                git([...args, "--name-status", "-z", ...references], signal).then((bytes) => bytes.toString().split("\0")),
+            ])
+            : ["", []];
+        const statuses = new Map();
+        for (let index = 0; index + 1 < names.length; index += 2)
+            statuses.set(names[index + 1], names[index]);
+        const files = stats
+            .split("\0")
+            .filter(Boolean)
+            .map((record) => {
+            const first = record.indexOf("\t"), second = record.indexOf("\t", first + 1);
+            const additions = record.slice(0, first), deletions = record.slice(first + 1, second);
+            return {
+                file: record.slice(second + 1),
+                additions: Number(additions) || 0,
+                deletions: Number(deletions) || 0,
+                binary: additions === "-",
+                workspace,
+                status: statuses.get(record.slice(second + 1)) === "D"
+                    ? "deleted"
+                    : statuses.get(record.slice(second + 1)) === "A"
+                        ? "added"
+                        : "modified",
+                version: "",
+            };
+        });
+        if (input.source === "worktree") {
+            const untracked = (await git(["ls-files", "--others", "--exclude-standard", "-z", ...(!endpoint.from ? ["--cached"] : [])], signal))
+                .toString()
+                .split("\0")
+                .filter(Boolean);
+            if (new Set([...files.map((file) => file.file), ...untracked]).size > 5000)
+                throw new R.Invalid({ message: "The comparison exceeds the 5,000 file limit. Narrow the comparison." });
+            for (const filename of new Set(untracked)) {
+                signal?.throwIfAborted();
+                if (files.some((file) => file.file === filename))
+                    continue;
+                const after = await readCurrent(filename, signal);
+                if (after.kind === "missing")
+                    continue;
+                files.push({
+                    file: filename,
+                    additions: after.kind === "text"
+                        ? (after.content?.match(/\n/g)?.length ?? 0) + (after.content && !after.content.endsWith("\n") ? 1 : 0)
+                        : 0,
+                    deletions: 0,
+                    binary: after.kind !== "text",
+                    workspace,
+                    status: "added",
+                    version: "",
+                });
+            }
+        }
+        if (files.length > 5000)
+            throw new R.Invalid({ message: "The comparison exceeds the 5,000 file limit. Narrow the comparison." });
+        for (let offset = 0; offset < files.length; offset += 16)
+            await Promise.all(files.slice(offset, offset + 16).map(async (file) => {
+                file.version = await fileVersion(input, endpoint, file.file);
+            }));
+        await validate(input);
+        return { source: input.source, ...endpoint, files: files.sort((a, b) => a.file.localeCompare(b.file)) };
+    }
+    ReviewGit.compare = compare;
+    const missing = { kind: "missing", version: "missing", bytes: 0 };
+    function decode(bytes, version = hash(bytes)) {
+        const base = { version, bytes: bytes.length };
+        try {
+            if (bytes.includes(0))
+                throw new Error("binary");
+            return { ...base, kind: "text", content: new TextDecoder("utf-8", { fatal: true }).decode(bytes) };
+        }
+        catch {
+            return { ...base, kind: "binary", base64: bytes.toString("base64") };
+        }
+    }
+    async function readCurrent(file, signal) {
+        signal?.throwIfAborted();
+        const stat = await FileView.stat(file);
+        if (!stat)
+            return missing;
+        if (stat.kind !== "file")
+            return { kind: "symlink", version: stat.entryVersion, bytes: stat.size };
+        if (stat.size > maxBytes)
+            return { kind: "oversized", version: stat.entryVersion, bytes: stat.size };
+        const canonical = await FileView.canonical(file);
+        const relative = path.relative(await FileView.canonical("."), canonical);
+        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            throw new R.Invalid({ message: "The file resolves outside the workspace." });
+        const bytes = await FileView.bytes(file, undefined, maxBytes);
+        signal?.throwIfAborted();
+        if ((await FileView.stat(file))?.entryVersion !== stat.entryVersion)
+            throw new R.Conflict({ message: "The file changed while it was read." });
+        return decode(Buffer.from(bytes));
+    }
+    async function readObject(tree, file, signal) {
+        if (!tree)
+            return missing;
+        const listing = (await git(["ls-tree", "-l", "-z", tree, "--", file], signal)).toString();
+        if (!listing)
+            return missing;
+        const [mode, , oid, size] = listing.slice(0, listing.indexOf("\t")).trim().split(/\s+/);
+        const base = { version: oid, bytes: Number(size) || 0 };
+        if (mode === "120000" || mode === "160000")
+            return { ...base, kind: "symlink" };
+        if (Number(size) > maxBytes)
+            return { ...base, kind: "oversized" };
+        return decode(await git(["cat-file", "blob", oid], signal), oid);
+    }
+    async function file(raw, signal) {
+        const input = R.FileInput.parse(raw);
+        const workspace = await validate(input);
+        const endpoint = await endpoints(input, signal);
+        if ((await fileVersion(input, endpoint, input.file)) !== input.version)
+            throw new R.Conflict({ message: "This comparison changed. Refresh before continuing." });
+        const [before, after] = await Promise.all([
+            readObject(endpoint.from, input.file, signal),
+            input.source === "worktree" ? readCurrent(input.file, signal) : readObject(endpoint.to, input.file, signal),
+        ]);
+        const oversized = before.kind === "oversized" || after.kind === "oversized";
+        const added = before.kind === "missing" && input.source === "worktree";
+        const args = added
+            ? ["diff", "--no-index", "--binary", "--no-ext-diff", "--no-textconv", "--", "/dev/null", input.file]
+            : [
+                "diff",
+                "--binary",
+                "--no-ext-diff",
+                "--no-textconv",
+                "--no-renames",
+                endpoint.from,
+                ...(input.source === "branch" ? [endpoint.to] : []),
+                "--",
+                input.file,
+            ];
+        const patch = oversized ? "" : (await git(args, signal, added)).toString();
+        const lines = patch.split("\n");
+        const diff = {
+            file: input.file,
+            workspace,
+            patch,
+            preview: patch,
+            binary: before.kind === "binary" || after.kind === "binary",
+            additions: lines.filter((line) => line.startsWith("+") && !line.startsWith("+++")).length,
+            deletions: lines.filter((line) => line.startsWith("-") && !line.startsWith("---")).length,
+            beforeBytes: before.bytes,
+            afterBytes: after.bytes,
+        };
+        if ((await fileVersion(input, endpoint, input.file)) !== input.version)
+            throw new R.Conflict({ message: "This comparison changed while it was read." });
+        await validate(input);
+        return { before, after, diff, version: input.version };
+    }
+    ReviewGit.file = file;
+})(ReviewGit || (ReviewGit = {}));

package/dist/review/routes.js

@@ -0,0 +1,45 @@
+import { Hono } from "hono";
+import { describeRoute, resolver, validator } from "hono-openapi";
+import { ReviewSchema as R } from "./schema.js";
+import { ReviewGit } from "./git.js";
+import { ReviewState } from "./state.js";
+const response = (schema) => ({
+    description: "Review result",
+    content: { "application/json": { schema: resolver(schema) } },
+});
+const errors = { 400: response(R.Invalid.Schema), 409: response(R.Conflict.Schema) };
+async function handle(load) {
+    try {
+        return Response.json(await load());
+    }
+    catch (error) {
+        if (error instanceof R.Invalid)
+            return Response.json(error.toObject(), { status: 400 });
+        if (error instanceof R.Conflict)
+            return Response.json(error.toObject(), { status: 409 });
+        throw error;
+    }
+}
+export function ReviewRoutes() {
+    return new Hono()
+        .get("/compare", describeRoute({
+        summary: "Compare Git file versions without mutations",
+        operationId: "review.compare",
+        responses: { 200: response(R.Comparison), ...errors },
+    }), validator("query", R.CompareInput), (c) => handle(() => ReviewGit.compare(c.req.valid("query"), c.req.raw.signal)))
+        .get("/file", describeRoute({
+        summary: "Read a version checked Git diff and its contents",
+        operationId: "review.file",
+        responses: { 200: response(R.Content), ...errors },
+    }), validator("query", R.FileInput), (c) => handle(() => ReviewGit.file(c.req.valid("query"), c.req.raw.signal)))
+        .get("/state/:sessionID", describeRoute({
+        summary: "Read session review notes",
+        operationId: "review.state.get",
+        responses: { 200: response(ReviewState.Result), ...errors },
+    }), validator("param", ReviewState.Input.pick({ sessionID: true })), (c) => handle(() => ReviewState.get(c.req.valid("param").sessionID)))
+        .put("/state/:sessionID", describeRoute({
+        summary: "Save session review notes with a revision check",
+        operationId: "review.state.update",
+        responses: { 200: response(ReviewState.Result), ...errors },
+    }), validator("param", ReviewState.Input.pick({ sessionID: true })), validator("json", ReviewState.Input.omit({ sessionID: true })), (c) => handle(() => ReviewState.update({ sessionID: c.req.valid("param").sessionID, ...c.req.valid("json") })));
+}

package/dist/review/schema.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { SnapshotSchema } from "@ericsanchezok/synergy-harness/session/snapshot-schema";
+import { NamedError } from "@ericsanchezok/synergy-util/error";
+export var ReviewSchema;
+(function (ReviewSchema) {
+    ReviewSchema.Invalid = NamedError.create("ReviewInvalid", z.object({ message: z.string() }));
+    ReviewSchema.Conflict = NamedError.create("ReviewConflict", z.object({ message: z.string() }));
+    ReviewSchema.CompareInput = z.object({
+        source: z.enum(["worktree", "branch"]),
+        workspaceID: z.string().min(1),
+        generation: z.coerce.number().int().positive(),
+        from: z.string().min(1).max(200).optional(),
+        to: z.string().min(1).max(200).optional(),
+    });
+    ReviewSchema.File = SnapshotSchema.FileDiff.extend({
+        version: z.string(),
+        status: z.enum(["modified", "added", "deleted"]),
+    }).meta({ ref: "ReviewComparisonFile" });
+    ReviewSchema.Comparison = z
+        .object({
+        source: z.enum(["worktree", "branch"]),
+        from: z.string(),
+        to: z.string(),
+        files: z.array(ReviewSchema.File).max(5000),
+    })
+        .meta({ ref: "ReviewComparison" });
+    ReviewSchema.FileInput = ReviewSchema.CompareInput.extend({ file: SnapshotSchema.FilePath, version: z.string().min(1) });
+    ReviewSchema.Content = SnapshotSchema.FileVersions.extend({
+        diff: SnapshotSchema.FileDiff,
+        version: z.string(),
+    }).meta({ ref: "ReviewFileContent" });
+})(ReviewSchema || (ReviewSchema = {}));

package/dist/review/state.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { Session } from "@ericsanchezok/synergy-harness/session";
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context";
+import { Storage } from "@ericsanchezok/synergy-harness/storage/storage";
+import { StoragePath } from "@ericsanchezok/synergy-harness/storage/path";
+import { Identifier } from "@ericsanchezok/synergy-harness/id/id";
+import { Bus } from "@ericsanchezok/synergy-harness/bus";
+import { BusEvent } from "@ericsanchezok/synergy-harness/bus/bus-event";
+import { ReviewSchema } from "./schema.js";
+export var ReviewState;
+(function (ReviewState) {
+    ReviewState.Comment = z
+        .object({
+        id: z.string().min(1).max(100),
+        source: z.string().max(500),
+        fileKey: z.string().max(2000),
+        file: z.string().max(2000),
+        version: z.string().max(200),
+        side: z.enum(["additions", "deletions"]),
+        start: z.number().int().positive(),
+        end: z.number().int().positive(),
+        excerpt: z.string().max(12_000),
+        text: z.string().min(1).max(12_000),
+        resolved: z.boolean(),
+    })
+        .refine((item) => item.end >= item.start && item.end - item.start < 200, "Invalid comment range")
+        .meta({ ref: "ReviewComment" });
+    ReviewState.Value = z
+        .object({
+        version: z.literal(1),
+        comments: z.array(ReviewState.Comment).max(200),
+        viewed: z.record(z.string().max(2500), z.string().max(200)).refine((value) => Object.keys(value).length <= 5000),
+    })
+        .meta({ ref: "ReviewStateValue" });
+    ReviewState.Result = z
+        .object({ revision: z.number().int().nonnegative(), state: ReviewState.Value })
+        .meta({ ref: "ReviewStateResult" });
+    ReviewState.Input = z
+        .object({ sessionID: Identifier.schema("session"), revision: z.number().int().nonnegative(), state: ReviewState.Value })
+        .meta({ ref: "ReviewStateInput" });
+    ReviewState.Updated = BusEvent.define("review.state.updated", z.object({ sessionID: Identifier.schema("session"), revision: z.number().int().nonnegative() }));
+    async function key(sessionID) {
+        const session = await Session.get(sessionID);
+        if (session.scope.id !== ScopeContext.current.scope.id)
+            throw new ReviewSchema.Invalid({ message: "Review belongs to another scope." });
+        return StoragePath.sessionReview(session.scope.id, sessionID);
+    }
+    async function get(sessionID) {
+        const target = await key(sessionID);
+        try {
+            const record = await Storage.versioned(target);
+            return { revision: Number(record.revision), state: ReviewState.Value.parse(record.value) };
+        }
+        catch (error) {
+            if (!(error instanceof Storage.NotFoundError))
+                throw error;
+            return { revision: 0, state: { version: 1, comments: [], viewed: {} } };
+        }
+    }
+    ReviewState.get = get;
+    async function update(raw) {
+        const input = ReviewState.Input.parse(raw);
+        const target = await key(input.sessionID);
+        const result = await Storage.transaction(async (tx) => {
+            const record = await tx.versioned(target).catch((error) => {
+                if (!(error instanceof Storage.NotFoundError))
+                    throw error;
+                return undefined;
+            });
+            if (Number(record?.revision ?? 0) !== input.revision)
+                throw new ReviewSchema.Conflict({ message: "Review notes changed. Reload before saving." });
+            await tx.write(target, input.state, { expectedRevision: BigInt(input.revision) });
+            return { revision: input.revision + 1, state: input.state };
+        });
+        await Bus.publish(ReviewState.Updated, { sessionID: input.sessionID, revision: result.revision });
+        return result;
+    }
+    ReviewState.update = update;
+})(ReviewState || (ReviewState = {}));

package/dist/stats/aggregator.js

@@ -0,0 +1,252 @@
+import { RolloutSnapshot } from "@ericsanchezok/synergy-harness/session/rollout/snapshot";
+import { RolloutAccounting } from "@ericsanchezok/synergy-harness/session/rollout/accounting";
+import { MessageV2 } from "@ericsanchezok/synergy-harness/session/message-v2";
+export var Aggregator;
+(function (Aggregator) {
+    const emptyTokenBreakdown = () => ({
+        input: 0,
+        output: 0,
+        reasoning: 0,
+        cache: { read: 0, write: 0 },
+    });
+    function addTokens(target, source) {
+        target.input += source.input;
+        target.output += source.output;
+        target.reasoning += source.reasoning;
+        target.cache.read += source.cache.read;
+        target.cache.write += source.cache.write;
+    }
+    async function digest(session) {
+        // Pass scopeID directly to avoid requireSession looking up session_index,
+        // which may be missing for legacy or reclaimed sessions.
+        const scopeID = session.scope?.id;
+        const messages = [];
+        for await (const msg of MessageV2.stream({
+            scopeID,
+            sessionID: session.id,
+        })) {
+            messages.push(msg);
+        }
+        const rollout = await RolloutSnapshot.read({ kind: "session", scopeID: session.scope.id, sessionID: session.id });
+        const recordedRoots = new Set(rollout.runs.map((run) => run.id));
+        const accounting = RolloutAccounting.summarize(rollout);
+        const tokens = emptyTokenBreakdown();
+        let cost = 0;
+        let turns = 0;
+        let messageCount = 0;
+        let errorCount = 0;
+        let compactionCount = 0;
+        let retryCount = 0;
+        const modelUsage = {};
+        const agentUsage = {};
+        const toolUsage = {};
+        const hourlyTurns = {};
+        function hourKey(timestamp) {
+            const d = new Date(timestamp);
+            return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}T${String(d.getHours()).padStart(2, "0")}`;
+        }
+        for (const msg of MessageV2.deriveSemantics(messages.toSorted((a, b) => a.info.time.created - b.info.time.created))) {
+            messageCount++;
+            if (msg.info.role === "user" && msg.info.isRoot) {
+                turns++;
+                const key = hourKey(msg.info.time.created);
+                hourlyTurns[key] = (hourlyTurns[key] ?? 0) + 1;
+            }
+            if (msg.info.role === "assistant") {
+                const info = msg.info;
+                const legacy = info.accounting?.kind !== "inherited" &&
+                    info.accounting?.kind !== "imported" &&
+                    info.accounting?.kind !== "rollout" &&
+                    !recordedRoots.has(info.rootID ?? info.parentID);
+                const messageTokens = legacy ? info.tokens : emptyTokenBreakdown();
+                const messageCost = legacy ? info.cost : 0;
+                if (legacy) {
+                    accounting.legacy.cost += info.cost;
+                    accounting.legacy.messages++;
+                }
+                addTokens(tokens, messageTokens);
+                cost += messageCost;
+                if (info.error !== undefined)
+                    errorCount++;
+                const modelKey = `${info.providerID}/${info.modelID}`;
+                const modelEntry = modelUsage[modelKey] ?? {
+                    messages: 0,
+                    tokens: emptyTokenBreakdown(),
+                    cost: 0,
+                    totalResponseMs: 0,
+                };
+                modelEntry.messages++;
+                addTokens(modelEntry.tokens, messageTokens);
+                modelEntry.cost += messageCost;
+                if (legacy) {
+                    modelEntry.accounting ??= RolloutAccounting.empty();
+                    modelEntry.accounting.legacy.cost += messageCost;
+                    modelEntry.accounting.legacy.messages++;
+                }
+                if (legacy && info.time.completed !== undefined) {
+                    modelEntry.totalResponseMs += info.time.completed - info.time.created;
+                }
+                modelUsage[modelKey] = modelEntry;
+                const agentEntry = agentUsage[info.agent] ?? {
+                    messages: 0,
+                    tokens: emptyTokenBreakdown(),
+                    cost: 0,
+                };
+                agentEntry.messages++;
+                addTokens(agentEntry.tokens, messageTokens);
+                agentEntry.cost += messageCost;
+                if (legacy) {
+                    agentEntry.accounting ??= RolloutAccounting.empty();
+                    agentEntry.accounting.legacy.cost += messageCost;
+                    agentEntry.accounting.legacy.messages++;
+                }
+                agentUsage[info.agent] = agentEntry;
+            }
+            for (const part of msg.parts) {
+                if (part.type === "tool") {
+                    const toolEntry = toolUsage[part.tool] ?? {
+                        calls: 0,
+                        successes: 0,
+                        errors: 0,
+                        totalDurationMs: 0,
+                        timedSamples: 0,
+                    };
+                    toolEntry.calls++;
+                    if (part.state.status === "completed") {
+                        toolEntry.successes++;
+                        if (part.state.time.start !== undefined && part.state.time.end !== undefined) {
+                            toolEntry.totalDurationMs += part.state.time.end - part.state.time.start;
+                            toolEntry.timedSamples = (toolEntry.timedSamples ?? 0) + 1;
+                        }
+                    }
+                    if (part.state.status === "error") {
+                        toolEntry.errors++;
+                    }
+                    toolUsage[part.tool] = toolEntry;
+                }
+                if (part.type === "compaction")
+                    compactionCount++;
+                if (part.type === "retry")
+                    retryCount++;
+            }
+        }
+        const totals = { tokens, cost, modelUsage, agentUsage };
+        addCalls(rollout, totals);
+        cost = totals.cost;
+        const endpoint = session.endpoint
+            ? {
+                kind: session.endpoint.kind,
+                type: session.endpoint.kind === "channel" ? session.endpoint.channel.type : undefined,
+            }
+            : undefined;
+        const interaction = session.interaction
+            ? {
+                mode: session.interaction.mode,
+                source: session.interaction.source,
+            }
+            : undefined;
+        return {
+            sessionID: session.id,
+            scopeID: session.scope.id,
+            created: session.time.created,
+            updated: session.time.updated,
+            rolloutRevision: rollout.revision,
+            accounting,
+            archived: session.time.archived,
+            pinned: session.pinned !== undefined,
+            parentID: session.parentID,
+            endpoint,
+            interaction,
+            turns,
+            messages: messageCount,
+            tokens,
+            cost,
+            modelUsage,
+            agentUsage,
+            toolUsage,
+            hourlyTurns,
+            additions: session.summary?.additions ?? 0,
+            deletions: session.summary?.deletions ?? 0,
+            files: session.summary?.files ?? 0,
+            compactionCount,
+            retryCount,
+            errorCount,
+            durationMs: session.time.updated - session.time.created,
+        };
+    }
+    Aggregator.digest = digest;
+    function addCalls(rollout, totals) {
+        const attemptsByCall = Map.groupBy(rollout.attempts, (attempt) => attempt.callID);
+        for (const call of rollout.calls) {
+            const entry = RolloutAccounting.summarize({
+                calls: [call],
+                attempts: attemptsByCall.get(call.id) ?? [],
+                gaps: [],
+            });
+            const usage = {
+                input: entry.tokens.uncached.known,
+                output: entry.tokens.output.known,
+                reasoning: entry.tokens.reasoning.known,
+                cache: { read: entry.tokens.cacheRead.known, write: entry.tokens.cacheWrite.known },
+            };
+            const knownCost = RolloutAccounting.knownExpense(entry);
+            addTokens(totals.tokens, usage);
+            totals.cost += knownCost;
+            const modelKey = `${call.model.providerID}/${call.model.modelID}`;
+            const modelEntry = totals.modelUsage[modelKey] ?? {
+                messages: 0,
+                tokens: emptyTokenBreakdown(),
+                cost: 0,
+                totalResponseMs: 0,
+            };
+            addTokens(modelEntry.tokens, usage);
+            modelEntry.cost += knownCost;
+            if (call.ended !== undefined)
+                modelEntry.totalResponseMs += call.ended - call.started;
+            modelEntry.accounting = RolloutAccounting.merge([modelEntry.accounting ?? RolloutAccounting.empty(), entry]);
+            totals.modelUsage[modelKey] = modelEntry;
+            const agentKey = call.agent ?? call.purpose;
+            const agentEntry = totals.agentUsage[agentKey] ?? { messages: 0, tokens: emptyTokenBreakdown(), cost: 0 };
+            addTokens(agentEntry.tokens, usage);
+            agentEntry.cost += knownCost;
+            agentEntry.accounting = RolloutAccounting.merge([agentEntry.accounting ?? RolloutAccounting.empty(), entry]);
+            totals.agentUsage[agentKey] = agentEntry;
+        }
+    }
+    function operation(rollout) {
+        if (rollout.owner.kind !== "operation")
+            throw new Error("Expected independent operation");
+        const started = rollout.runs.map((run) => run.started);
+        const result = {
+            operationID: rollout.owner.operationID,
+            scopeID: rollout.owner.scopeID,
+            rolloutRevision: rollout.revision,
+            created: started.length ? Math.min(...started) : 0,
+            updated: Math.max(0, ...rollout.runs.map((run) => run.ended ?? run.started)),
+            turns: 0,
+            tokens: emptyTokenBreakdown(),
+            cost: 0,
+            modelUsage: {},
+            agentUsage: {},
+            accounting: RolloutAccounting.summarize(rollout),
+        };
+        addCalls(rollout, result);
+        return result;
+    }
+    Aggregator.operation = operation;
+    async function digestAll(sessions, onProgress) {
+        const results = [];
+        const batchSize = 20;
+        for (let i = 0; i < sessions.length; i += batchSize) {
+            const batch = sessions.slice(i, i + batchSize);
+            const batchResults = await Promise.all(batch.map((s) => digest(s)));
+            for (const r of batchResults) {
+                if (r)
+                    results.push(r);
+            }
+            onProgress?.(Math.min(i + batchSize, sessions.length), sessions.length);
+        }
+        return results;
+    }
+    Aggregator.digestAll = digestAll;
+})(Aggregator || (Aggregator = {}));