@lchase/kiln 0.8.0 → 0.10.0

package/dist/events.js

@@ -0,0 +1,393 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { closeSync, existsSync, linkSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, writeSync, } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { redactDeep } from "./redact.js";
+/**
+ * Append-only event log at `<kilnDir>/events.jsonl` (`~/.kiln/events.jsonl`
+ * when that directory is the kiln home). One module writes it. One reader
+ * parses it. A write failure is reported and does not escape to the caller.
+ *
+ * `run_id` and `step` are null when the moment has none. `job_id` is null
+ * for `config.reloaded`, `kiln.paused`, `kiln.resumed`, and `budget.blocked`,
+ * which are not a job.
+ */
+export const EVENT_NAMES = [
+    "job.added",
+    "job.retried",
+    "run.started",
+    "phase.started",
+    "phase.finished",
+    "gate.opened",
+    "gate.resolved",
+    "run.failed",
+    "run.finished",
+    "pr.opened",
+    "pr.feedback",
+    "worktree.cleaned",
+    "worktree.kept",
+    "config.reloaded",
+    "needs-human",
+    "kiln.paused",
+    "kiln.resumed",
+    "budget.blocked",
+];
+const ISO_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+const once = z.string().min(1).optional();
+const JobAdded = z.object({
+    repo: z.string().min(1),
+    workflow: z.string().min(1),
+    title: z.string().min(1),
+    source_kind: z.string().min(1).optional(),
+    once,
+});
+const JobRetried = z.object({
+    by: z.literal("human"),
+    repo: z.string().min(1),
+    once,
+});
+const RunStarted = z.object({
+    kiln_version: z.string().min(1),
+    yak_version: z.string().min(1),
+    workflow: z.string().min(1),
+    prompts_hash: z.string().min(1),
+    repo: z.string().min(1),
+    once,
+});
+const PhaseStarted = z.object({
+    iteration: z.number().int().nonnegative().optional(),
+    once,
+});
+const PhaseFinished = z.object({
+    outcome: z.enum(["completed", "failed"]),
+    iteration: z.number().int().nonnegative().optional(),
+    cached: z.boolean().optional(),
+    skipped: z.boolean().optional(),
+    reason: z.string().min(1).optional(),
+    detail: z.string().min(1).optional(),
+    verdict: z.string().min(1).optional(),
+    test_command: z.string().min(1).optional(),
+    exit_code: z.number().int().optional(),
+    once,
+});
+const GateOpened = z.object({
+    prompt: z.string().min(1).optional(),
+    note: z.string().min(1).optional(),
+    edit: z.string().min(1).optional(),
+    once,
+});
+const GateResolved = z.object({
+    decision: z.string().min(1),
+    by: z.string().min(1),
+    repo: z.string().min(1).optional(),
+    note: z.string().min(1).optional(),
+    edit: z.string().min(1).optional(),
+    once,
+});
+const costFields = {
+    /** Sum of yak `budget.consumed` tokens. Null when the journal did not report any. */
+    tokens: z.number().nonnegative().nullable().optional(),
+    /** Sum of reported dollars. Null when the journal did not report any. Never invented. */
+    usd: z.number().nonnegative().nullable().optional(),
+};
+const RunFailed = z.object({
+    reason: z.string().min(1).optional(),
+    detail: z.string().min(1).optional(),
+    status: z.string().min(1).optional(),
+    class: z.enum(["transient", "deterministic", "budget"]).optional(),
+    fingerprint: z.string().min(1).optional(),
+    ...costFields,
+    once,
+});
+const RunFinished = z.object({
+    status: z.literal("ok"),
+    ...costFields,
+    once,
+});
+const PrOpened = z.object({
+    number: z.number().int().positive(),
+    url: z.string().min(1),
+    branch: z.string().min(1),
+    base: z.string().min(1),
+    once,
+});
+const PrFeedback = z.object({
+    round: z.number().int().positive(),
+    trigger: z.enum(["ci", "review"]),
+    outcome: z.enum(["fixed", "pushed"]).optional(),
+    items: z.number().int().nonnegative().optional(),
+    once,
+});
+const Worktree = z.object({ once });
+const ConfigReloaded = z.object({ once });
+const NeedsHuman = z.object({
+    reason: z.string().min(1),
+    once,
+});
+const FactoryToggle = z.object({ once });
+const BudgetBlocked = z.object({
+    day: z.string().min(1),
+    usd: z.number().nonnegative(),
+    cap: z.number().nonnegative(),
+    once,
+});
+const envelope = {
+    id: z.string().min(1),
+    ts: z.string().regex(ISO_UTC, "ts must be ISO-8601 UTC"),
+    run_id: z.string().min(1).nullable(),
+    step: z.string().min(1).nullable(),
+};
+export const EventSchema = z.discriminatedUnion("event", [
+    z.object({ ...envelope, event: z.literal("job.added"), job_id: z.string().min(1), properties: JobAdded }),
+    z.object({ ...envelope, event: z.literal("job.retried"), job_id: z.string().min(1), properties: JobRetried }),
+    z.object({ ...envelope, event: z.literal("run.started"), job_id: z.string().min(1), properties: RunStarted }),
+    z.object({ ...envelope, event: z.literal("phase.started"), job_id: z.string().min(1), properties: PhaseStarted }),
+    z.object({ ...envelope, event: z.literal("phase.finished"), job_id: z.string().min(1), properties: PhaseFinished }),
+    z.object({ ...envelope, event: z.literal("gate.opened"), job_id: z.string().min(1), properties: GateOpened }),
+    z.object({ ...envelope, event: z.literal("gate.resolved"), job_id: z.string().min(1), properties: GateResolved }),
+    z.object({ ...envelope, event: z.literal("run.failed"), job_id: z.string().min(1), properties: RunFailed }),
+    z.object({ ...envelope, event: z.literal("run.finished"), job_id: z.string().min(1), properties: RunFinished }),
+    z.object({ ...envelope, event: z.literal("pr.opened"), job_id: z.string().min(1), properties: PrOpened }),
+    z.object({ ...envelope, event: z.literal("pr.feedback"), job_id: z.string().min(1), properties: PrFeedback }),
+    z.object({ ...envelope, event: z.literal("worktree.cleaned"), job_id: z.string().min(1), properties: Worktree }),
+    z.object({ ...envelope, event: z.literal("worktree.kept"), job_id: z.string().min(1), properties: Worktree }),
+    z.object({
+        ...envelope,
+        event: z.literal("config.reloaded"),
+        job_id: z.string().min(1).nullable(),
+        properties: ConfigReloaded,
+    }),
+    z.object({ ...envelope, event: z.literal("needs-human"), job_id: z.string().min(1), properties: NeedsHuman }),
+    z.object({
+        ...envelope,
+        event: z.literal("kiln.paused"),
+        job_id: z.string().min(1).nullable(),
+        properties: FactoryToggle,
+    }),
+    z.object({
+        ...envelope,
+        event: z.literal("kiln.resumed"),
+        job_id: z.string().min(1).nullable(),
+        properties: FactoryToggle,
+    }),
+    z.object({
+        ...envelope,
+        event: z.literal("budget.blocked"),
+        job_id: z.string().min(1).nullable(),
+        properties: BudgetBlocked,
+    }),
+]);
+const LOCK_WAIT_MS = 5_000;
+const pauseBuf = new Int32Array(new SharedArrayBuffer(4));
+export function eventsPath(kilnDir) {
+    return join(kilnDir, "events.jsonl");
+}
+/**
+ * Append one JSON line. Concurrent callers in this process take a file lock
+ * and each lock holder performs one `write` of the full line, so lines do
+ * not interleave. A failure is printed and swallowed.
+ *
+ * `properties.once` is an idempotency key. A later append with the same
+ * job, run, event, step, and `once` is a no-op. Moments that should repeat
+ * (a second manual retry, a second config reload) omit it.
+ */
+export function appendEvent(kilnDir, draft) {
+    let line;
+    let event;
+    try {
+        event = buildEvent(draft);
+        line = `${JSON.stringify(event)}\n`;
+    }
+    catch (error) {
+        report(error);
+        return;
+    }
+    try {
+        withEventsLock(kilnDir, () => {
+            if (alreadyRecorded(kilnDir, event))
+                return;
+            writeLine(eventsPath(kilnDir), line);
+        });
+    }
+    catch (error) {
+        report(error);
+    }
+}
+/** Parse the log. A blank line is ignored. Any other bad line is skipped. */
+export function readEvents(kilnDir, options = {}) {
+    const warn = options.warn ?? ((message) => console.error(message));
+    const path = eventsPath(kilnDir);
+    if (!existsSync(path))
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        warn(`kiln: event log unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+    const events = [];
+    const lines = raw.split("\n");
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line === undefined || line.trim() === "")
+            continue;
+        const parsed = parseLine(line);
+        if (!parsed) {
+            warn(`kiln: skipped event log line ${index + 1}`);
+            continue;
+        }
+        events.push(parsed);
+    }
+    return events;
+}
+export function eventsForJob(kilnDir, jobId, options) {
+    return readEvents(kilnDir, options).filter((event) => event.job_id === jobId);
+}
+function buildEvent(draft) {
+    const properties = redactDeep(draft.properties);
+    const candidate = {
+        id: draft.id ?? randomUUID(),
+        ts: draft.ts ?? new Date().toISOString(),
+        job_id: draft.job_id,
+        run_id: draft.run_id ?? null,
+        event: draft.event,
+        step: draft.step ?? null,
+        properties,
+    };
+    const parsed = EventSchema.safeParse(candidate);
+    if (!parsed.success) {
+        throw new Error(`refused ${draft.event}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return parsed.data;
+}
+function parseLine(line) {
+    try {
+        const parsed = EventSchema.safeParse(JSON.parse(line));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function alreadyRecorded(kilnDir, event) {
+    const key = event.properties.once;
+    if (!key)
+        return false;
+    const path = eventsPath(kilnDir);
+    if (!existsSync(path))
+        return false;
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return false;
+    }
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.job_id === event.job_id &&
+                parsed.run_id === event.run_id &&
+                parsed.event === event.event &&
+                parsed.step === event.step &&
+                parsed.properties?.once === key) {
+                return true;
+            }
+        }
+        catch {
+            // A corrupt line does not count as a recorded event.
+        }
+    }
+    return false;
+}
+/** One `write` of the whole line, including the newline. */
+function writeLine(path, line) {
+    const fd = openSync(path, "a");
+    try {
+        const buf = Buffer.from(line);
+        const wrote = writeSync(fd, buf, 0, buf.length);
+        if (wrote !== buf.length) {
+            throw new Error(`short write (${wrote} of ${buf.length})`);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Exclusive append across threads in this process. The lock file holds the
+ * pid. Another thread in the same process shares that pid and waits. A
+ * later process may remove a lock whose pid is gone.
+ */
+function withEventsLock(kilnDir, fn) {
+    mkdirSync(kilnDir, { recursive: true });
+    const lockPath = join(kilnDir, "events.lock");
+    const tmp = `${lockPath}.${process.pid}.${randomBytes(4).toString("hex")}`;
+    writeFileSync(tmp, String(process.pid));
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    let held = false;
+    try {
+        while (!held) {
+            try {
+                linkSync(tmp, lockPath);
+                held = true;
+            }
+            catch (error) {
+                if (!isErrno(error, "EEXIST"))
+                    throw error;
+                if (lockHolderDead(lockPath)) {
+                    rmSync(lockPath, { force: true });
+                    continue;
+                }
+                if (Date.now() > deadline)
+                    throw new Error("timed out waiting for the event log lock");
+                Atomics.wait(pauseBuf, 0, 0, 5);
+            }
+        }
+        fn();
+    }
+    finally {
+        if (held)
+            rmSync(lockPath, { force: true });
+        rmSync(tmp, { force: true });
+    }
+}
+function lockHolderDead(lockPath) {
+    let holder = Number.NaN;
+    try {
+        holder = Number(readFileSync(lockPath, "utf8").trim());
+    }
+    catch {
+        return true;
+    }
+    if (holder === process.pid)
+        return false;
+    return !pidAlive(holder);
+}
+function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isErrno(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function report(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+        console.error(`kiln: event log: ${message}`);
+    }
+    catch {
+        // The caller still continues when stderr itself fails.
+    }
+}

package/dist/evidence.js

@@ -0,0 +1,140 @@
+import { readEvents } from "./events.js";
+import { redact } from "./redact.js";
+const REVIEW_STEPS = ["security", "ux", "ui", "code"];
+/**
+ * Short factual Evidence section for a pull request body, built from the
+ * job's events. The whole section goes through `redact`.
+ */
+export function evidenceSection(events, jobId) {
+    const rows = events.filter((event) => event.job_id === jobId);
+    const lines = ["## Evidence", ""];
+    const version = versionLine(rows);
+    if (version)
+        lines.push(version);
+    const phases = phaseLine(rows);
+    if (phases)
+        lines.push(phases);
+    const test = testLine(rows);
+    if (test)
+        lines.push(test);
+    const reviews = reviewLine(rows);
+    if (reviews)
+        lines.push(reviews);
+    const feedback = feedbackLine(rows);
+    if (feedback)
+        lines.push(feedback);
+    const gates = gateLine(rows);
+    if (gates)
+        lines.push(gates);
+    if (lines.length === 2)
+        lines.push("- (no events)");
+    return redact(`${lines.join("\n")}\n`);
+}
+export function evidenceSectionFor(kilnDir, jobId) {
+    return evidenceSection(readEvents(kilnDir), jobId);
+}
+function versionLine(events) {
+    const started = [...events].reverse().find((event) => event.event === "run.started");
+    if (!started || started.event !== "run.started")
+        return undefined;
+    const props = started.properties;
+    const hash = props.prompts_hash.length > 12 ? props.prompts_hash.slice(0, 12) : props.prompts_hash;
+    return `- versions: kiln ${props.kiln_version}, yak ${props.yak_version}, workflow ${props.workflow}, prompts ${hash}`;
+}
+function phaseLine(events) {
+    const order = [];
+    const failed = new Set();
+    for (const event of events) {
+        if (!event.step)
+            continue;
+        if ((event.event === "phase.started" || event.event === "phase.finished") && !order.includes(event.step)) {
+            order.push(event.step);
+        }
+        if (event.event === "phase.finished" && event.properties.outcome === "failed")
+            failed.add(event.step);
+    }
+    if (order.length === 0)
+        return undefined;
+    const shown = order.map((step) => (failed.has(step) ? `${step} failed` : step));
+    return `- phases: ${shown.join(", ")}`;
+}
+function testLine(events) {
+    const verify = [...events].reverse().find((event) => event.event === "phase.finished" && event.step === "verify");
+    if (!verify || verify.event !== "phase.finished")
+        return undefined;
+    const command = verify.properties.test_command;
+    const exit = verify.properties.exit_code;
+    if (!command && exit === undefined)
+        return undefined;
+    const commandText = command ? `\`${command}\`` : "(command not recorded)";
+    const result = exit === undefined ? "result unknown" : `exit ${exit}`;
+    return `- test: ${commandText} ${result}`;
+}
+function reviewLine(events) {
+    const latest = new Map();
+    for (const event of events) {
+        if (event.event !== "phase.finished" || !event.step || !REVIEW_STEPS.includes(event.step)) {
+            continue;
+        }
+        if (event.properties.verdict)
+            latest.set(event.step, event.properties.verdict);
+    }
+    const parts = REVIEW_STEPS.flatMap((step) => {
+        const verdict = latest.get(step);
+        return verdict ? [`${step} ${verdict}`] : [];
+    });
+    if (parts.length === 0)
+        return undefined;
+    return `- reviews: ${parts.join(", ")}`;
+}
+function feedbackLine(events) {
+    const rounds = new Map();
+    for (const event of events) {
+        if (event.event !== "pr.feedback")
+            continue;
+        const previous = rounds.get(event.properties.round);
+        rounds.set(event.properties.round, {
+            trigger: event.properties.trigger,
+            items: event.properties.items ?? previous?.items,
+            outcome: event.properties.outcome ?? previous?.outcome,
+        });
+    }
+    if (rounds.size === 0)
+        return undefined;
+    const parts = [...rounds.entries()]
+        .sort((left, right) => left[0] - right[0])
+        .map(([round, info]) => {
+        const items = info.items === undefined ? "" : ` (${info.items} ${info.items === 1 ? "item" : "items"})`;
+        const outcome = info.outcome ? ` ${info.outcome}` : "";
+        return `round ${round} ${info.trigger}${items}${outcome}`;
+    });
+    return `- feedback: ${parts.join("; ")}`;
+}
+function gateLine(events) {
+    const opened = events.filter((event) => event.event === "gate.opened");
+    const resolved = new Map();
+    for (const event of events) {
+        if (event.event === "gate.resolved" && event.step)
+            resolved.set(event.step, event);
+    }
+    const steps = new Set();
+    for (const event of opened)
+        if (event.step)
+            steps.add(event.step);
+    for (const step of resolved.keys())
+        steps.add(step);
+    if (steps.size === 0)
+        return undefined;
+    const parts = [];
+    for (const step of steps) {
+        const answer = resolved.get(step);
+        if (!answer) {
+            parts.push(`${step} open`);
+            continue;
+        }
+        const edit = answer.properties.edit || answer.properties.note;
+        const noted = edit ? ", edit noted" : "";
+        parts.push(`${step} by ${answer.properties.by}: ${answer.properties.decision}${noted}`);
+    }
+    return `- gates: ${parts.join("; ")}`;
+}

package/dist/failure.js

@@ -0,0 +1,140 @@
+import { createHash } from "node:crypto";
+import { redact } from "./redact.js";
+/**
+ * One failed run is transient, deterministic, or budget.
+ * Transient may retry with backoff inside the attempt cap.
+ * Deterministic does not. A cap hit is budget and stops in Needs human.
+ */
+export const FAILURE_CLASSES = ["transient", "deterministic", "budget"];
+const TRANSIENT = [
+    /\b429\b/,
+    /rate limit/i,
+    /too many requests/i,
+    /\b5\d\d\b/,
+    /internal server error/i,
+    /bad gateway/i,
+    /service unavailable/i,
+    /gateway timeout/i,
+    /ECONNRESET|ECONNREFUSED|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|EPIPE/i,
+    /socket hang up/i,
+    /network (?:error|unreachable|is down)/i,
+    /fetch failed/i,
+    /connection (?:reset|refused|timed out|closed)/i,
+    /container never started/i,
+    /failed to start (?:the )?(?:container|sandbox)/i,
+    /docker daemon/i,
+    /cannot connect to the docker/i,
+    /OCI runtime/i,
+    /error creating container/i,
+    /sandbox (?:start|flake)/i,
+];
+const DETERMINISTIC = [
+    /\berror TS\d+\b/,
+    /type error/i,
+    /cannot find name/i,
+    /is not assignable/i,
+    /syntax error/i,
+    /\bAssertionError\b/,
+    /\b(?:tests?|assertion) failed\b/i,
+    /\bfailing tests?\b/i,
+    /\bbuild failed\b/i,
+    /\bcompilation failed\b/i,
+    /\bcompile error\b/i,
+    /npm ERR!/i,
+];
+/** A container or sandbox that did not start. Those are transient. */
+export function isSandboxStartFlake(text) {
+    return /container never started|failed to start (?:the )?(?:container|sandbox)|docker daemon|cannot connect to the docker|OCI runtime|error creating container|sandbox (?:start|flake)/i.test(text);
+}
+/**
+ * Strip timestamps, temp and worktree paths, hex ids, and line numbers so
+ * the same failure hashes the same way across runs.
+ */
+export function normalizeFailureText(text) {
+    let out = redact(text).replace(/\r\n/g, "\n").trim();
+    out = out.replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g, "<ts>");
+    out = out.replace(/\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/g, "<ts>");
+    out = out.replace(/(?:\/private)?\/(?:tmp|var\/folders)\/[^\s'")\]:]+/g, "<tmp>");
+    out = out.replace(/[^\s'")\]]*[/\\]\.yak[/\\]worktrees[/\\][^\s'")\]:]+/g, "<worktree>");
+    out = out.replace(/[^\s'")\]]+[/\\]worktrees[/\\][^\s'")\]:]+/g, "<worktree>");
+    out = out.replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "<id>");
+    out = out.replace(/\b[0-9a-f]{8,}\b/gi, "<id>");
+    out = out.replace(/:(\d+)(?::\d+)?\b/g, ":<line>");
+    out = out.replace(/\bline\s+\d+\b/gi, "line <line>");
+    out = out.replace(/[ \t]+/g, " ");
+    out = out.replace(/\n{3,}/g, "\n\n");
+    return out.toLowerCase();
+}
+/** Stable id for one normalized failure. */
+export function failureFingerprint(text) {
+    return createHash("sha256").update(normalizeFailureText(text)).digest("hex");
+}
+/**
+ * Transient when the text is a network, rate-limit, 5xx, or start flake.
+ * A test, build, or type error is deterministic and wins over a transient
+ * pattern in the same text. Anything else is deterministic.
+ */
+export function classifyFailureText(text) {
+    if (DETERMINISTIC.some((pattern) => pattern.test(text)))
+        return "deterministic";
+    if (TRANSIENT.some((pattern) => pattern.test(text)))
+        return "transient";
+    return "deterministic";
+}
+/**
+ * The only decision for what a recorded failure does next.
+ * Attempt cap wins over the fingerprint breaker when both trip on the same run.
+ */
+export function decideFailure(input) {
+    const fingerprint = failureFingerprint(input.text);
+    const deterministicHit = DETERMINISTIC.some((pattern) => pattern.test(input.text));
+    const transientHit = TRANSIENT.some((pattern) => pattern.test(input.text));
+    // Stall, crash, orphan, and a bare non-zero exit stay transient unless the
+    // text is a test, build, or type error, or the failure is blocked.
+    let failureClass = deterministicHit
+        ? "deterministic"
+        : transientHit || (input.operational && !input.blocked)
+            ? "transient"
+            : "deterministic";
+    let retry = failureClass === "transient" && !input.blocked;
+    let needsHuman;
+    if (input.attempt >= input.maxAttempts) {
+        failureClass = "budget";
+        retry = false;
+        needsHuman = "attempt-cap";
+    }
+    else if (input.sameFingerprint >= input.maxSameFingerprint) {
+        retry = false;
+        needsHuman = "fingerprint";
+    }
+    else if (input.blocked || failureClass === "deterministic") {
+        retry = false;
+    }
+    return { class: failureClass, fingerprint, retry, ...(needsHuman ? { needsHuman } : {}) };
+}
+/** Sum yak `budget.consumed` lines. Missing numbers stay null. Never invents a figure. */
+export function costFromJournal(events) {
+    let tokens = 0;
+    let usd = 0;
+    let sawTokens = false;
+    let sawUsd = false;
+    for (const event of events) {
+        if (!event || typeof event !== "object")
+            continue;
+        const record = event;
+        if (record.t !== "budget.consumed")
+            continue;
+        if (typeof record.tokens === "number" && Number.isFinite(record.tokens) && record.tokens >= 0) {
+            tokens += record.tokens;
+            sawTokens = true;
+        }
+        if (typeof record.usd === "number" && Number.isFinite(record.usd) && record.usd >= 0) {
+            usd += record.usd;
+            sawUsd = true;
+        }
+    }
+    return {
+        tokens: sawTokens ? tokens : null,
+        usd: sawUsd ? usd : null,
+    };
+}