@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.0

package/src/review/git.ts

@@ -0,0 +1,221 @@
+import { createHash } from "node:crypto"
+import path from "node:path"
+import { ReviewSchema as R } from "./schema"
+import { ScopeContext } from "@ericsanchezok/synergy-harness/scope/context"
+import { WorkspaceBinding } from "@ericsanchezok/synergy-harness/workspace"
+import { SnapshotSchema } from "@ericsanchezok/synergy-harness/session/snapshot-schema"
+import { FileView } from "@ericsanchezok/synergy-local-runtime/file/view"
+import { WorktreeProcess } from "@ericsanchezok/synergy-local-runtime/workspace/process"
+
+export namespace ReviewGit {
+  const maxBytes = 768 * 1024
+  const hash = (value: string | Uint8Array) => createHash("sha256").update(value).digest("hex")
+  async function validate(input: R.CompareInput) {
+    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: string[], signal?: AbortSignal, 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: string, signal?: AbortSignal) {
+    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: R.CompareInput, signal?: AbortSignal) {
+    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: string) {
+    const stat = await FileView.stat(file)
+    return stat?.entryVersion ?? "missing"
+  }
+  async function fileVersion(input: R.CompareInput, endpoint: { from: string; to: string }, file: string) {
+    return hash(
+      JSON.stringify([
+        input.workspaceID,
+        input.generation,
+        endpoint.from,
+        endpoint.to,
+        file,
+        input.source === "worktree" ? await currentVersion(file) : "",
+      ]),
+    )
+  }
+  export async function compare(raw: R.CompareInput, signal?: AbortSignal) {
+    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<string, string>()
+    for (let index = 0; index + 1 < names.length; index += 2) statuses.set(names[index + 1]!, names[index]!)
+    const files: R.File[] = 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)) }
+  }
+  const missing: SnapshotSchema.FileVersion = { kind: "missing", version: "missing", bytes: 0 }
+  function decode(bytes: Buffer, version = hash(bytes)): SnapshotSchema.FileVersion {
+    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: string, signal?: AbortSignal): Promise<SnapshotSchema.FileVersion> {
+    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: string, file: string, signal?: AbortSignal): Promise<SnapshotSchema.FileVersion> {
+    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)
+  }
+  export async function file(raw: import("zod").z.infer<typeof R.FileInput>, signal?: AbortSignal) {
+    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 }
+  }
+}

package/src/review/routes.ts

@@ -0,0 +1,65 @@
+import { Hono } from "hono"
+import { describeRoute, resolver, validator } from "hono-openapi"
+import { z } from "zod"
+import { ReviewSchema as R } from "./schema"
+import { ReviewGit } from "./git"
+import { ReviewState } from "./state"
+
+const response = (schema: z.ZodType) => ({
+  description: "Review result",
+  content: { "application/json": { schema: resolver(schema) } },
+})
+const errors = { 400: response(R.Invalid.Schema), 409: response(R.Conflict.Schema) }
+async function handle<T>(load: () => Promise<T>) {
+  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/src/review/schema.ts

@@ -0,0 +1,34 @@
+import { z } from "zod"
+import { SnapshotSchema } from "@ericsanchezok/synergy-harness/session/snapshot-schema"
+import { NamedError } from "@ericsanchezok/synergy-util/error"
+
+export namespace ReviewSchema {
+  export const Invalid = NamedError.create("ReviewInvalid", z.object({ message: z.string() }))
+  export const Conflict = NamedError.create("ReviewConflict", z.object({ message: z.string() }))
+  export const 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(),
+  })
+  export type CompareInput = z.infer<typeof CompareInput>
+  export const File = SnapshotSchema.FileDiff.extend({
+    version: z.string(),
+    status: z.enum(["modified", "added", "deleted"]),
+  }).meta({ ref: "ReviewComparisonFile" })
+  export type File = z.infer<typeof File>
+  export const Comparison = z
+    .object({
+      source: z.enum(["worktree", "branch"]),
+      from: z.string(),
+      to: z.string(),
+      files: z.array(File).max(5000),
+    })
+    .meta({ ref: "ReviewComparison" })
+  export const FileInput = CompareInput.extend({ file: SnapshotSchema.FilePath, version: z.string().min(1) })
+  export const Content = SnapshotSchema.FileVersions.extend({
+    diff: SnapshotSchema.FileDiff,
+    version: z.string(),
+  }).meta({ ref: "ReviewFileContent" })
+}

package/src/review/state.ts

@@ -0,0 +1,77 @@
+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"
+
+export namespace ReviewState {
+  export const 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" })
+  export const Value = z
+    .object({
+      version: z.literal(1),
+      comments: z.array(Comment).max(200),
+      viewed: z.record(z.string().max(2500), z.string().max(200)).refine((value) => Object.keys(value).length <= 5000),
+    })
+    .meta({ ref: "ReviewStateValue" })
+  export const Result = z
+    .object({ revision: z.number().int().nonnegative(), state: Value })
+    .meta({ ref: "ReviewStateResult" })
+  export const Input = z
+    .object({ sessionID: Identifier.schema("session"), revision: z.number().int().nonnegative(), state: Value })
+    .meta({ ref: "ReviewStateInput" })
+  export const Updated = BusEvent.define(
+    "review.state.updated",
+    z.object({ sessionID: Identifier.schema("session"), revision: z.number().int().nonnegative() }),
+  )
+  async function key(sessionID: string) {
+    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)
+  }
+  export async function get(sessionID: string): Promise<z.infer<typeof Result>> {
+    const target = await key(sessionID)
+    try {
+      const record = await Storage.versioned<z.infer<typeof Value>>(target)
+      return { revision: Number(record.revision), state: Value.parse(record.value) }
+    } catch (error) {
+      if (!(error instanceof Storage.NotFoundError)) throw error
+      return { revision: 0, state: { version: 1, comments: [], viewed: {} } }
+    }
+  }
+  export async function update(raw: z.infer<typeof Input>) {
+    const input = Input.parse(raw)
+    const target = await key(input.sessionID)
+    const result = await Storage.transaction(async (tx) => {
+      const record = await tx.versioned<z.infer<typeof Value>>(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(Updated, { sessionID: input.sessionID, revision: result.revision })
+    return result
+  }
+}

package/src/stats/aggregator.ts

@@ -0,0 +1,277 @@
+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"
+import type { Info as SessionInfo } from "@ericsanchezok/synergy-harness/session/types"
+import type * as Stats from "./types"
+
+export namespace Aggregator {
+  const emptyTokenBreakdown = (): Stats.TokenBreakdown => ({
+    input: 0,
+    output: 0,
+    reasoning: 0,
+    cache: { read: 0, write: 0 },
+  })
+
+  function addTokens(target: Stats.TokenBreakdown, source: Stats.TokenBreakdown) {
+    target.input += source.input
+    target.output += source.output
+    target.reasoning += source.reasoning
+    target.cache.read += source.cache.read
+    target.cache.write += source.cache.write
+  }
+
+  export type DigestProgress = (current: number, total: number) => void
+
+  export async function digest(session: SessionInfo): Promise<Stats.SessionDigest> {
+    // Pass scopeID directly to avoid requireSession looking up session_index,
+    // which may be missing for legacy or reclaimed sessions.
+    const scopeID = (session.scope as { id: string })?.id
+    const messages: MessageV2.WithParts[] = []
+    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: Stats.SessionDigest["modelUsage"] = {}
+    const agentUsage: Stats.SessionDigest["agentUsage"] = {}
+    const toolUsage: Stats.SessionDigest["toolUsage"] = {}
+    const hourlyTurns: Stats.SessionDigest["hourlyTurns"] = {}
+
+    function hourKey(timestamp: number) {
+      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,
+    }
+  }
+
+  function addCalls(
+    rollout: RolloutSnapshot.Info,
+    totals: Pick<Stats.SessionDigest, "tokens" | "cost" | "modelUsage" | "agentUsage">,
+  ) {
+    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
+    }
+  }
+
+  export function operation(rollout: RolloutSnapshot.Info): Stats.OperationDigest {
+    if (rollout.owner.kind !== "operation") throw new Error("Expected independent operation")
+    const started = rollout.runs.map((run) => run.started)
+    const result: Stats.OperationDigest = {
+      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
+  }
+
+  export async function digestAll(
+    sessions: SessionInfo[],
+    onProgress?: DigestProgress,
+  ): Promise<Stats.SessionDigest[]> {
+    const results: Stats.SessionDigest[] = []
+    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
+  }
+}