@jitsusama/agentic-harness.core 0.1.0

package/dist/notes/verbs/queries.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `notes find` / `notes show` / `notes tree` / `notes types`.
+ */
+import { type NoteIndex } from "../../internal/notes/discovery.js";
+import { type NoteResult, type NoteToolParams } from "./shared.js";
+/** Accept a full id, or an unambiguous prefix of one. */
+export declare function resolveId(index: NoteIndex, ref: string): {
+    id: string;
+} | {
+    error: string;
+};
+export declare function find(notesRoot: string, params: NoteToolParams): NoteResult;
+export declare function show(notesRoot: string, params: NoteToolParams): NoteResult;
+export declare function tree(notesRoot: string, params: NoteToolParams): NoteResult;
+export declare function types(notesRoot: string): NoteResult;

package/dist/notes/verbs/queries.js

@@ -0,0 +1,116 @@
+/**
+ * `notes find` / `notes show` / `notes tree` / `notes types`.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { discoverNotes, } from "../../internal/notes/discovery.js";
+import { NOTE_TYPES } from "../types.js";
+import { ok, refuse } from "./shared.js";
+/** Accept a full id, or an unambiguous prefix of one. */
+export function resolveId(index, ref) {
+    if (index.notes.has(ref))
+        return { id: ref };
+    const matches = [...index.notes.keys()].filter((id) => id.startsWith(ref) || id.includes(ref));
+    if (matches.length === 1)
+        return { id: matches[0] };
+    if (matches.length > 1) {
+        return {
+            error: `"${ref}" is ambiguous, matches: ${matches.slice(0, 10).join(", ")}`,
+        };
+    }
+    return { error: `no note matches "${ref}"` };
+}
+function matchesFilters(entry, index, params) {
+    const fm = entry.doc.frontMatter;
+    if (params.type && fm.type !== params.type)
+        return false;
+    if (params.tags && !fm.tags.includes(params.tags))
+        return false;
+    if (params.parent) {
+        const resolved = resolveId(index, params.parent);
+        if ("error" in resolved)
+            return false;
+        if (fm.parent !== resolved.id)
+            return false;
+    }
+    if (params.since && fm.created < params.since)
+        return false;
+    if (params.until && fm.created > params.until)
+        return false;
+    return true;
+}
+export function find(notesRoot, params) {
+    const { index } = discoverNotes(notesRoot);
+    let results = [...index.notes.values()].filter((e) => matchesFilters(e, index, params));
+    if (params.q) {
+        const needle = params.q.toLowerCase();
+        results = results.filter((e) => {
+            const haystack = `${e.doc.frontMatter.title}\n${e.doc.body}`.toLowerCase();
+            return haystack.includes(needle);
+        });
+    }
+    results.sort((a, b) => a.doc.frontMatter.created.localeCompare(b.doc.frontMatter.created));
+    if (params.limit)
+        results = results.slice(0, params.limit);
+    const rows = results.map((e) => ({
+        id: e.doc.frontMatter.id,
+        type: e.doc.frontMatter.type,
+        created: e.doc.frontMatter.created,
+        title: e.doc.frontMatter.title,
+    }));
+    return ok(`${rows.length} match(es)`, { count: rows.length, notes: rows });
+}
+export function show(notesRoot, params) {
+    if (!params.id)
+        return refuse("show needs an id");
+    const { index } = discoverNotes(notesRoot);
+    const resolved = resolveId(index, params.id);
+    if ("error" in resolved)
+        return refuse(resolved.error);
+    const path = join(notesRoot, resolved.id, "README.md");
+    const text = readFileSync(path, "utf8");
+    return ok(text, { id: resolved.id, path });
+}
+function renderSubtree(index, id, depth, out) {
+    const entry = index.notes.get(id);
+    if (!entry)
+        return;
+    out.push({
+        id,
+        depth,
+        type: entry.doc.frontMatter.type,
+        title: entry.doc.frontMatter.title,
+    });
+    for (const childId of index.children.get(id) ?? []) {
+        renderSubtree(index, childId, depth + 1, out);
+    }
+}
+export function tree(notesRoot, params) {
+    const { index } = discoverNotes(notesRoot);
+    const rows = [];
+    if (params.id) {
+        const resolved = resolveId(index, params.id);
+        if ("error" in resolved)
+            return refuse(resolved.error);
+        renderSubtree(index, resolved.id, 0, rows);
+    }
+    else {
+        for (const rootId of index.children.get("") ?? []) {
+            renderSubtree(index, rootId, 0, rows);
+        }
+    }
+    const message = rows
+        .map((r) => `${"  ".repeat(r.depth)}- ${r.id}  [${r.type}]  ${r.title}`)
+        .join("\n");
+    return ok(message || "(empty)", { rows });
+}
+export function types(notesRoot) {
+    const { index } = discoverNotes(notesRoot);
+    const counts = Object.fromEntries(NOTE_TYPES.map((t) => [t, 0]));
+    for (const entry of index.notes.values()) {
+        counts[entry.doc.frontMatter.type] =
+            (counts[entry.doc.frontMatter.type] ?? 0) + 1;
+    }
+    const message = NOTE_TYPES.map((t) => `${t.padEnd(10)} ${counts[t]}`).join("\n");
+    return ok(message, { counts });
+}

package/dist/notes/verbs/reindex.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `notes reindex`: regenerate the notes root's INDEX.md.
+ *
+ * A static, human-browsable snapshot -- not the source of
+ * truth. Every other verb reads the notes fresh off disk on
+ * every call; this file exists purely for a person (or a
+ * plain-text grep) scanning the archive outside the CLI, and
+ * goes stale the moment a note changes until the next
+ * `reindex`.
+ */
+import { type NoteResult } from "./shared.js";
+export declare function reindex(notesRoot: string): NoteResult;

package/dist/notes/verbs/reindex.js

@@ -0,0 +1,35 @@
+/**
+ * `notes reindex`: regenerate the notes root's INDEX.md.
+ *
+ * A static, human-browsable snapshot -- not the source of
+ * truth. Every other verb reads the notes fresh off disk on
+ * every call; this file exists purely for a person (or a
+ * plain-text grep) scanning the archive outside the CLI, and
+ * goes stale the moment a note changes until the next
+ * `reindex`.
+ */
+import { join } from "node:path";
+import { discoverNotes } from "../../internal/notes/discovery.js";
+import { atomicWriteFile } from "../../internal/notes/io.js";
+import { ok } from "./shared.js";
+function escapeTableCell(value) {
+    return value.replace(/\|/g, "\\|");
+}
+export function reindex(notesRoot) {
+    const { index } = discoverNotes(notesRoot);
+    const rows = [...index.notes.values()].sort((a, b) => a.doc.frontMatter.created.localeCompare(b.doc.frontMatter.created));
+    const lines = [
+        "# Note Index",
+        "",
+        `${rows.length} notes. Regenerate with \`notes reindex\`.`,
+        "",
+        "| id | type | created | title |",
+        "|---|---|---|---|",
+        ...rows.map((r) => {
+            const fm = r.doc.frontMatter;
+            return `| ${fm.id} | ${fm.type} | ${fm.created.slice(0, 8)} | ${escapeTableCell(fm.title)} |`;
+        }),
+    ];
+    atomicWriteFile(join(notesRoot, "INDEX.md"), `${lines.join("\n")}\n`);
+    return ok(`wrote INDEX.md (${rows.length} notes)`, { count: rows.length });
+}

package/dist/notes/verbs/shared.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared types and helpers for the notes verb modules.
+ *
+ * Unlike quest, notes has no persisted cross-invocation
+ * state (no "loaded note", nothing to remember between CLI
+ * calls) -- every verb is self-contained given a
+ * `notesRoot` and its params. See `bin/notes.ts` for the
+ * CLI wiring this implies.
+ */
+import type { NoteType } from "../types.js";
+export interface NoteToolParams {
+    id?: string;
+    type?: string;
+    title?: string;
+    tags?: string;
+    add?: string;
+    remove?: string;
+    parent?: string;
+    created?: string;
+    q?: string;
+    since?: string;
+    until?: string;
+    limit?: number;
+}
+export type NoteResult = {
+    ok: true;
+    message: string;
+    details?: Record<string, unknown>;
+} | {
+    ok: false;
+    guidance: string;
+};
+/** Build a structured refusal result. */
+export declare function refuse(guidance: string): NoteResult;
+/** Build a structured success result. */
+export declare function ok(message: string, details?: Record<string, unknown>): NoteResult;
+export declare function isNoteType(value: string): value is NoteType;

package/dist/notes/verbs/shared.js

@@ -0,0 +1,29 @@
+/**
+ * Shared types and helpers for the notes verb modules.
+ *
+ * Unlike quest, notes has no persisted cross-invocation
+ * state (no "loaded note", nothing to remember between CLI
+ * calls) -- every verb is self-contained given a
+ * `notesRoot` and its params. See `bin/notes.ts` for the
+ * CLI wiring this implies.
+ */
+/** The shared mark for no, reused from quest for the same reason: one mark for no across every surface. */
+const REFUSED = "⊘";
+/** Build a structured refusal result. */
+export function refuse(guidance) {
+    return { ok: false, guidance: `${REFUSED} ${guidance}` };
+}
+/** Build a structured success result. */
+export function ok(message, details) {
+    return { ok: true, message, details };
+}
+export function isNoteType(value) {
+    return (value === "journal" ||
+        value === "reference" ||
+        value === "faith" ||
+        value === "financial" ||
+        value === "gaming" ||
+        value === "travel" ||
+        value === "writing" ||
+        value === "inbox");
+}

package/dist/observability/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Observability: first-class run telemetry for subagent and
+ * council fan-outs.
+ *
+ * The parent session records one {@link RunRecord} per
+ * subagent as it finishes, into a SQLite table kept in its
+ * own database file. Rows are queryable on demand, roll up
+ * into periodic per-model and per-persona summaries before
+ * they age out, and drive a compact status-line figure.
+ */
+export { type RunRecorder, type RunRecordInput, recordRunEverywhere, registerRunRecorder, runRecordFrom, } from "./recorder.js";
+export { openRunStore, type RunQuery, type RunStore } from "./store.js";
+export type { RunCost, RunRecord, RunRollup, RunSummary, RunTokens, VerifyOutcome, } from "./types.js";

package/dist/observability/index.js

@@ -0,0 +1,12 @@
+/**
+ * Observability: first-class run telemetry for subagent and
+ * council fan-outs.
+ *
+ * The parent session records one {@link RunRecord} per
+ * subagent as it finishes, into a SQLite table kept in its
+ * own database file. Rows are queryable on demand, roll up
+ * into periodic per-model and per-persona summaries before
+ * they age out, and drive a compact status-line figure.
+ */
+export { recordRunEverywhere, registerRunRecorder, runRecordFrom, } from "./recorder.js";
+export { openRunStore } from "./store.js";

package/dist/observability/recorder.d.ts

@@ -0,0 +1,50 @@
+import type { RunCost, RunRecord, RunTokens } from "./types.js";
+/** A sink that persists a run record. */
+export type RunRecorder = (record: RunRecord) => void;
+/**
+ * Per-subagent result as a producer sees it. Both the fleet
+ * dispatcher and the council runner expose usage,
+ * verification, warnings and an exit code; this is the
+ * subset {@link runRecordFrom} needs.
+ */
+export interface RunRecordInput {
+    readonly runId: string;
+    readonly subagentId: string;
+    readonly kind: string;
+    readonly model: string;
+    readonly persona: string;
+    readonly startedAt: number;
+    readonly result: {
+        readonly exitCode: number;
+        readonly warnings: readonly string[];
+        readonly usage?: {
+            readonly tokens: RunTokens;
+            readonly cost: RunCost;
+        };
+        readonly verification?: {
+            readonly ok: boolean;
+            /** Verify attempts observed; one means no retry. */
+            readonly attempts?: number;
+        };
+    };
+}
+/**
+ * Build a {@link RunRecord} from a producer's per-subagent
+ * result. Verify outcome derives from the verification
+ * block when present, and usage falls back to zeros for a
+ * run that reported none (older pi, a crashed child).
+ */
+export declare function runRecordFrom(input: RunRecordInput): RunRecord;
+/**
+ * Register a sink for run records. Returns an unregister
+ * function. The observability extension registers a writer
+ * to its store; when nothing is registered, producers that
+ * emit records are cheap no-ops.
+ */
+export declare function registerRunRecorder(recorder: RunRecorder): () => void;
+/**
+ * Emit a record to every registered sink. Producers call
+ * this unconditionally; a throwing sink never disturbs the
+ * run being recorded.
+ */
+export declare function recordRunEverywhere(record: RunRecord): void;

package/dist/observability/recorder.js

@@ -0,0 +1,77 @@
+import { processGlobal } from "../internal/process-global.js";
+const ZERO_TOKENS = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    total: 0,
+};
+const ZERO_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    total: 0,
+};
+/**
+ * Build a {@link RunRecord} from a producer's per-subagent
+ * result. Verify outcome derives from the verification
+ * block when present, and usage falls back to zeros for a
+ * run that reported none (older pi, a crashed child).
+ */
+export function runRecordFrom(input) {
+    const { result } = input;
+    return {
+        runId: input.runId,
+        subagentId: input.subagentId,
+        kind: input.kind,
+        model: input.model,
+        persona: input.persona,
+        verifyOutcome: result.verification === undefined
+            ? "none"
+            : result.verification.ok
+                ? "passed"
+                : "failed",
+        // Attempts beyond the first that were needed to reach the
+        // recorded verify result. Zero when the first attempt was
+        // the last, whether it passed or the reviewer never retried.
+        retriesToValid: Math.max(0, (result.verification?.attempts ?? 1) - 1),
+        warningCount: result.warnings.length,
+        exitCode: result.exitCode,
+        tokens: result.usage?.tokens ?? ZERO_TOKENS,
+        cost: result.usage?.cost ?? ZERO_COST,
+        startedAt: input.startedAt,
+    };
+}
+// Process-global so a producer extension's recordRunEverywhere
+// reaches the sink another extension registered; a module-level
+// Set would give each extension its own, and records would never
+// reach the writer.
+const recorders = processGlobal("pi:observability-recorders", () => new Set());
+/**
+ * Register a sink for run records. Returns an unregister
+ * function. The observability extension registers a writer
+ * to its store; when nothing is registered, producers that
+ * emit records are cheap no-ops.
+ */
+export function registerRunRecorder(recorder) {
+    recorders.add(recorder);
+    return () => {
+        recorders.delete(recorder);
+    };
+}
+/**
+ * Emit a record to every registered sink. Producers call
+ * this unconditionally; a throwing sink never disturbs the
+ * run being recorded.
+ */
+export function recordRunEverywhere(record) {
+    for (const recorder of recorders) {
+        try {
+            recorder(record);
+        }
+        catch {
+            // Telemetry is best-effort and must never fail a run.
+        }
+    }
+}

package/dist/observability/store.d.ts

@@ -0,0 +1,22 @@
+import type { RunRecord, RunRollup, RunSummary } from "./types.js";
+/** Filter for {@link RunStore.queryRuns}. */
+export interface RunQuery {
+    readonly runId?: string;
+}
+/** A SQLite-backed store of subagent run records. */
+export interface RunStore {
+    recordRun(record: RunRecord): Promise<void>;
+    queryRuns(filter?: RunQuery): Promise<RunRecord[]>;
+    summarizeRun(runId: string): Promise<RunSummary | null>;
+    rollupBefore(cutoffMs: number): Promise<{
+        rolledRows: number;
+    }>;
+    queryRollups(): Promise<RunRollup[]>;
+    close(): Promise<void>;
+}
+/**
+ * Open (creating if needed) a run store at the given path.
+ * WAL mode plus a busy timeout keep the single parent writer
+ * safe against readers; subagents never touch the file.
+ */
+export declare function openRunStore(dbPath: string): Promise<RunStore>;

package/dist/observability/store.js

@@ -0,0 +1,213 @@
+import { openDb } from "../internal/sqlite/db.js";
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS runs (
+	run_id TEXT NOT NULL,
+	subagent_id TEXT NOT NULL,
+	kind TEXT NOT NULL,
+	model TEXT NOT NULL,
+	persona TEXT NOT NULL,
+	verify_outcome TEXT NOT NULL,
+	retries_to_valid INTEGER NOT NULL,
+	warning_count INTEGER NOT NULL,
+	exit_code INTEGER NOT NULL,
+	tokens_input INTEGER NOT NULL,
+	tokens_output INTEGER NOT NULL,
+	tokens_cache_read INTEGER NOT NULL,
+	tokens_cache_write INTEGER NOT NULL,
+	tokens_total INTEGER NOT NULL,
+	cost_input REAL NOT NULL,
+	cost_output REAL NOT NULL,
+	cost_cache_read REAL NOT NULL,
+	cost_cache_write REAL NOT NULL,
+	cost_total REAL NOT NULL,
+	started_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS runs_run_id ON runs (run_id);
+CREATE INDEX IF NOT EXISTS runs_started_at ON runs (started_at);
+CREATE TABLE IF NOT EXISTS rollups (
+	week_start INTEGER NOT NULL,
+	model TEXT NOT NULL,
+	persona TEXT NOT NULL,
+	run_count INTEGER NOT NULL,
+	total_retries INTEGER NOT NULL,
+	total_warnings INTEGER NOT NULL,
+	tokens_total INTEGER NOT NULL,
+	cost_total REAL NOT NULL,
+	cache_read INTEGER NOT NULL,
+	fresh_input INTEGER NOT NULL,
+	PRIMARY KEY (week_start, model, persona)
+);
+`;
+/**
+ * Open (creating if needed) a run store at the given path.
+ * WAL mode plus a busy timeout keep the single parent writer
+ * safe against readers; subagents never touch the file.
+ */
+export async function openRunStore(dbPath) {
+    const db = await openDb(dbPath);
+    await db.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+    await db.exec(SCHEMA);
+    return new SqliteRunStore(db);
+}
+class SqliteRunStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async recordRun(record) {
+        await this.db.run(`INSERT INTO runs (
+				run_id, subagent_id, kind, model, persona, verify_outcome,
+				retries_to_valid, warning_count, exit_code,
+				tokens_input, tokens_output, tokens_cache_read, tokens_cache_write, tokens_total,
+				cost_input, cost_output, cost_cache_read, cost_cache_write, cost_total,
+				started_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            record.runId,
+            record.subagentId,
+            record.kind,
+            record.model,
+            record.persona,
+            record.verifyOutcome,
+            record.retriesToValid,
+            record.warningCount,
+            record.exitCode,
+            record.tokens.input,
+            record.tokens.output,
+            record.tokens.cacheRead,
+            record.tokens.cacheWrite,
+            record.tokens.total,
+            record.cost.input,
+            record.cost.output,
+            record.cost.cacheRead,
+            record.cost.cacheWrite,
+            record.cost.total,
+            record.startedAt,
+        ]);
+    }
+    async queryRuns(filter = {}) {
+        const where = filter.runId ? "WHERE run_id = ?" : "";
+        const params = filter.runId ? [filter.runId] : [];
+        const rows = await this.db.all(`SELECT * FROM runs ${where} ORDER BY started_at ASC`, params);
+        return rows.map(rowToRecord);
+    }
+    async summarizeRun(runId) {
+        const rows = await this.db.all(`SELECT
+				COUNT(*) AS subagent_count,
+				SUM(CASE WHEN verify_outcome = 'passed' THEN 1 ELSE 0 END) AS passed,
+				SUM(CASE WHEN verify_outcome = 'failed' THEN 1 ELSE 0 END) AS failed,
+				SUM(retries_to_valid) AS total_retries,
+				SUM(warning_count) AS total_warnings,
+				SUM(tokens_input) AS tokens_input,
+				SUM(tokens_output) AS tokens_output,
+				SUM(tokens_cache_read) AS tokens_cache_read,
+				SUM(tokens_cache_write) AS tokens_cache_write,
+				SUM(tokens_total) AS tokens_total,
+				SUM(cost_input) AS cost_input,
+				SUM(cost_output) AS cost_output,
+				SUM(cost_cache_read) AS cost_cache_read,
+				SUM(cost_cache_write) AS cost_cache_write,
+				SUM(cost_total) AS cost_total
+			FROM runs WHERE run_id = ?`, [runId]);
+        const row = rows[0];
+        if (!row || row.subagent_count === 0)
+            return null;
+        const freshInput = row.tokens_input + row.tokens_cache_read;
+        return {
+            runId,
+            subagentCount: row.subagent_count,
+            passed: row.passed,
+            failed: row.failed,
+            totalRetries: row.total_retries,
+            totalWarnings: row.total_warnings,
+            tokens: {
+                input: row.tokens_input,
+                output: row.tokens_output,
+                cacheRead: row.tokens_cache_read,
+                cacheWrite: row.tokens_cache_write,
+                total: row.tokens_total,
+            },
+            cost: {
+                input: row.cost_input,
+                output: row.cost_output,
+                cacheRead: row.cost_cache_read,
+                cacheWrite: row.cost_cache_write,
+                total: row.cost_total,
+            },
+            cacheReadRatio: freshInput === 0 ? 0 : row.tokens_cache_read / freshInput,
+        };
+    }
+    async rollupBefore(cutoffMs) {
+        const counted = await this.db.all("SELECT COUNT(*) AS n FROM runs WHERE started_at < ?", [cutoffMs]);
+        const rolledRows = counted[0]?.n ?? 0;
+        if (rolledRows === 0)
+            return { rolledRows: 0 };
+        await this.db.run(`INSERT INTO rollups (
+				week_start, model, persona, run_count, total_retries, total_warnings,
+				tokens_total, cost_total, cache_read, fresh_input
+			)
+			SELECT
+				(started_at / ${WEEK_MS}) * ${WEEK_MS} AS week_start,
+				model, persona,
+				COUNT(*), SUM(retries_to_valid), SUM(warning_count),
+				SUM(tokens_total), SUM(cost_total),
+				SUM(tokens_cache_read), SUM(tokens_input + tokens_cache_read)
+			FROM runs WHERE started_at < ?
+			GROUP BY week_start, model, persona
+			ON CONFLICT(week_start, model, persona) DO UPDATE SET
+				run_count = run_count + excluded.run_count,
+				total_retries = total_retries + excluded.total_retries,
+				total_warnings = total_warnings + excluded.total_warnings,
+				tokens_total = tokens_total + excluded.tokens_total,
+				cost_total = cost_total + excluded.cost_total,
+				cache_read = cache_read + excluded.cache_read,
+				fresh_input = fresh_input + excluded.fresh_input`, [cutoffMs]);
+        await this.db.run("DELETE FROM runs WHERE started_at < ?", [cutoffMs]);
+        return { rolledRows };
+    }
+    async queryRollups() {
+        const rows = await this.db.all("SELECT * FROM rollups ORDER BY week_start ASC, model ASC, persona ASC");
+        return rows.map((row) => ({
+            weekStart: row.week_start,
+            model: row.model,
+            persona: row.persona,
+            runCount: row.run_count,
+            totalRetries: row.total_retries,
+            totalWarnings: row.total_warnings,
+            tokensTotal: row.tokens_total,
+            costTotal: row.cost_total,
+            cacheReadRatio: row.fresh_input === 0 ? 0 : row.cache_read / row.fresh_input,
+        }));
+    }
+    async close() {
+        await this.db.close();
+    }
+}
+function rowToRecord(row) {
+    return {
+        runId: row.run_id,
+        subagentId: row.subagent_id,
+        kind: row.kind,
+        model: row.model,
+        persona: row.persona,
+        verifyOutcome: row.verify_outcome,
+        retriesToValid: row.retries_to_valid,
+        warningCount: row.warning_count,
+        exitCode: row.exit_code,
+        tokens: {
+            input: row.tokens_input,
+            output: row.tokens_output,
+            cacheRead: row.tokens_cache_read,
+            cacheWrite: row.tokens_cache_write,
+            total: row.tokens_total,
+        },
+        cost: {
+            input: row.cost_input,
+            output: row.cost_output,
+            cacheRead: row.cost_cache_read,
+            cacheWrite: row.cost_cache_write,
+            total: row.cost_total,
+        },
+        startedAt: row.started_at,
+    };
+}