@vela-science/canopus 0.4.0-rc.1

package/capsules/formal-erdos-505-test-dim-one/README.md

@@ -0,0 +1,20 @@
+# Erdős 505 dimension-one verifier
+
+This target-specific capsule verifies one raw Lean proof term against the exact
+statement of `Erdos505.erdos_505.test_dim_one` from
+`google-deepmind/formal-conjectures` commit
+`c252a41054125b5fd9c8356e2137cd9b55337657`.
+
+The image build verifies that exact upstream commit, tree, and source-file
+hash, but the runtime deliberately does not import the admitted upstream
+theorem or the `FormalConjecturesUtil` whole-Mathlib umbrella. It retains only
+the transitive cache closure of `Mathlib.Analysis.InnerProductSpace.PiL2` and
+`Mathlib.Topology.MetricSpace.Bounded`; the reviewed capsule owns an exact copy
+of the target signature.
+
+The producer supplies only the term beginning with `by`. The capsule invokes
+Lean 4.27.0 inside the pinned verifier image and rejects `sorryAx` or any axiom
+outside `propext`, `Classical.choice`, and `Quot.sound`. Kernel success does not
+by itself establish statement fidelity or scientific acceptance; the exact
+source-bound target packet, capsule review, and Vela review boundary retain
+those distinctions.

package/capsules/formal-erdos-505-test-dim-one/verifier

@@ -0,0 +1,105 @@
+#!/bin/sh
+set -eu
+
+if [ "$#" -ne 1 ]; then
+  echo "usage: verifier <proof-term>" >&2
+  exit 2
+fi
+
+proof=$1
+if [ ! -f "$proof" ] || [ -L "$proof" ]; then
+  echo "proof artifact must be one regular file" >&2
+  exit 2
+fi
+
+size=$(wc -c < "$proof" | tr -d ' ')
+if [ "$size" -eq 0 ] || [ "$size" -gt 131072 ]; then
+  echo "proof artifact must contain 1..131072 bytes" >&2
+  exit 2
+fi
+
+if [ "$(head -c 2 "$proof")" != "by" ]; then
+  echo "proof artifact must begin with a Lean 'by' term" >&2
+  exit 2
+fi
+
+if LC_ALL=C grep -Eq '(^|[^A-Za-z0-9_])(sorry|admit|axiom|unsafe)([^A-Za-z0-9_]|$)' "$proof"; then
+  echo "proof artifact contains a forbidden trust-bypassing token" >&2
+  exit 2
+fi
+
+toolchain=/home/lean/.elan/toolchains/leanprover--lean4---v4.27.0/bin
+project=/home/lean/mathlib
+if [ ! -x "$toolchain/lean" ]; then
+  echo "frozen Lean 4.27.0 toolchain is unavailable" >&2
+  exit 3
+fi
+if [ ! -f "$project/.lake/build/lib/lean/Mathlib/Analysis/InnerProductSpace/PiL2.olean" ] \
+    || [ ! -f "$project/.lake/build/lib/lean/Mathlib/Topology/MetricSpace/Bounded.olean" ]; then
+  echo "frozen minimal Mathlib modules are unavailable" >&2
+  exit 3
+fi
+
+export PATH="$toolchain:/usr/local/bin:/usr/bin:/bin"
+export LC_ALL=C
+LEAN_PATH=$(
+  find "$project" -type d -path '*/.lake/build/lib/lean' -print \
+    | LC_ALL=C sort \
+    | paste -sd ':' -
+)
+if [ -z "$LEAN_PATH" ]; then
+  echo "frozen Mathlib module path is unavailable" >&2
+  exit 3
+fi
+export LEAN_PATH
+cd "$project"
+
+set +e
+output=$(
+  {
+    printf '%s\n' \
+      'import Mathlib.Analysis.InnerProductSpace.PiL2' \
+      'import Mathlib.Topology.MetricSpace.Bounded' \
+      '/-! # Frozen Canopus verification for Erdos 505, dimension one -/' \
+      'open Metric Set Classical' \
+      'namespace CanopusFormalErdos505' \
+      'theorem test_dim_one' \
+      '    (S : Set (EuclideanSpace ℝ (Fin 1)))' \
+      '    (hS : Bornology.IsBounded S) (hd : 0 < diam S) :' \
+      '    ∃ (F : Fin 2 → Set (EuclideanSpace ℝ (Fin 1))),' \
+      '      S ⊆ ⋃ i, F i ∧ ∀ i, diam (F i) < diam S :='
+    cat "$proof"
+    printf '%s\n' \
+      '#print axioms CanopusFormalErdos505.test_dim_one' \
+      'end CanopusFormalErdos505'
+  } | "$toolchain/lean" --stdin 2>&1
+)
+status=$?
+set -e
+
+printf '%s\n' "$output"
+if [ "$status" -ne 0 ]; then
+  exit "$status"
+fi
+if printf '%s\n' "$output" | grep -Fq 'sorryAx'; then
+  echo "kernel declaration depends on sorryAx" >&2
+  exit 4
+fi
+
+axiom_line=$(printf '%s\n' "$output" | sed -n "s/^'CanopusFormalErdos505.test_dim_one' depends on axioms: \[\(.*\)\]$/\1/p")
+if [ -n "$axiom_line" ]; then
+  for axiom in $(printf '%s' "$axiom_line" | tr ',' ' '); do
+    case "$axiom" in
+      propext|Classical.choice|Quot.sound) ;;
+      *)
+        echo "kernel declaration depends on forbidden axiom: $axiom" >&2
+        exit 4
+        ;;
+    esac
+  done
+elif ! printf '%s\n' "$output" | grep -Fq "'CanopusFormalErdos505.test_dim_one' does not depend on any axioms"; then
+  echo "axiom audit output was missing or malformed" >&2
+  exit 4
+fi
+
+echo "verified formal:erdos-505-test-dim-one with Lean 4.27.0"

package/dist/src/activity/events.d.ts

@@ -0,0 +1,15 @@
+export declare const ACTIVITY_SCHEMA: "canopus.activity.v0";
+export declare const ACTIVITY_TYPES: readonly ["run.started", "workspace.prepared", "roots.verified", "target.offered", "work.skipped", "work.claimed", "engine.started", "engine.completed", "artifact.frozen", "artifacts.published", "verifier.completed", "candidate.finalized", "receipt.mapped", "landing.observed", "landing.bound", "landing.completed", "withdrawal_capability.retained", "reproduction.completed", "projection.written", "run.completed", "run.failed"];
+export type ActivityType = (typeof ACTIVITY_TYPES)[number];
+export interface ActivityEventBody {
+    schema: typeof ACTIVITY_SCHEMA;
+    run_id: string;
+    sequence: number;
+    at: string;
+    type: ActivityType;
+    previous: string | null;
+    payload: Record<string, unknown>;
+}
+export interface ActivityEvent extends ActivityEventBody {
+    event_digest: string;
+}

package/dist/src/activity/events.js

@@ -0,0 +1,24 @@
+export const ACTIVITY_SCHEMA = "canopus.activity.v0";
+export const ACTIVITY_TYPES = [
+    "run.started",
+    "workspace.prepared",
+    "roots.verified",
+    "target.offered",
+    "work.skipped",
+    "work.claimed",
+    "engine.started",
+    "engine.completed",
+    "artifact.frozen",
+    "artifacts.published",
+    "verifier.completed",
+    "candidate.finalized",
+    "receipt.mapped",
+    "landing.observed",
+    "landing.bound",
+    "landing.completed",
+    "withdrawal_capability.retained",
+    "reproduction.completed",
+    "projection.written",
+    "run.completed",
+    "run.failed",
+];

package/dist/src/activity/store.d.ts

@@ -0,0 +1,10 @@
+import { type ActivityEvent, type ActivityType } from "./events.js";
+export declare function readActivity(file: string): Promise<ActivityEvent[]>;
+export declare class ActivityStore {
+    #private;
+    private constructor();
+    static open(file: string, runId: string): Promise<ActivityStore>;
+    get tip(): string | null;
+    get events(): readonly ActivityEvent[];
+    append(type: ActivityType, payload: Record<string, unknown>): Promise<ActivityEvent>;
+}

package/dist/src/activity/store.js

@@ -0,0 +1,165 @@
+import { constants } from "node:fs";
+import { mkdir, open } from "node:fs/promises";
+import path from "node:path";
+import { canonicalJson, contentDigest } from "../util/canonical.js";
+import { readBoundedRegularFile } from "../util/files.js";
+import { ACTIVITY_SCHEMA, ACTIVITY_TYPES, } from "./events.js";
+const MAX_ACTIVITY_BYTES = 64 * 1024 * 1024;
+const MAX_EVENT_BYTES = 1024 * 1024;
+function parseEvent(value, line) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`activity line ${line} is not an object`);
+    }
+    const event = value;
+    const expected = new Set([
+        "schema",
+        "run_id",
+        "sequence",
+        "at",
+        "type",
+        "previous",
+        "payload",
+        "event_digest",
+    ]);
+    if (Object.keys(event).some((key) => !expected.has(key)) || Object.keys(event).length !== expected.size) {
+        throw new Error(`activity line ${line} has an invalid field set`);
+    }
+    if (event.schema !== ACTIVITY_SCHEMA ||
+        typeof event.run_id !== "string" ||
+        event.run_id.length === 0 ||
+        typeof event.sequence !== "number" ||
+        !Number.isSafeInteger(event.sequence) ||
+        event.sequence < 0 ||
+        typeof event.at !== "string" ||
+        Number.isNaN(Date.parse(event.at)) ||
+        typeof event.type !== "string" ||
+        !ACTIVITY_TYPES.includes(event.type) ||
+        (event.previous !== null && typeof event.previous !== "string") ||
+        typeof event.payload !== "object" ||
+        event.payload === null ||
+        Array.isArray(event.payload) ||
+        typeof event.event_digest !== "string") {
+        throw new Error(`activity line ${line} is malformed`);
+    }
+    const body = {
+        schema: ACTIVITY_SCHEMA,
+        run_id: event.run_id,
+        sequence: event.sequence,
+        at: event.at,
+        type: event.type,
+        previous: event.previous,
+        payload: event.payload,
+    };
+    const expectedDigest = contentDigest(body);
+    if (event.event_digest !== expectedDigest) {
+        throw new Error(`activity line ${line} has an invalid event digest`);
+    }
+    return { ...body, event_digest: expectedDigest };
+}
+export async function readActivity(file) {
+    let bytes;
+    try {
+        bytes = await readBoundedRegularFile(file, MAX_ACTIVITY_BYTES);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const text = bytes.toString("utf8");
+    if (text.length !== 0 && !text.endsWith("\n")) {
+        throw new Error("activity log ends with a partial record");
+    }
+    const lines = text.split("\n").filter((line) => line.length > 0);
+    const events = [];
+    for (const [index, line] of lines.entries()) {
+        if (Buffer.byteLength(line) > MAX_EVENT_BYTES)
+            throw new Error(`activity line ${index + 1} is oversized`);
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            throw new Error(`activity line ${index + 1} is invalid JSON`);
+        }
+        const event = parseEvent(value, index + 1);
+        const previous = events.at(-1);
+        if (event.sequence !== index || event.previous !== (previous?.event_digest ?? null)) {
+            throw new Error(`activity line ${index + 1} breaks the append-only chain`);
+        }
+        if (previous !== undefined && event.run_id !== previous.run_id) {
+            throw new Error(`activity line ${index + 1} changes run_id`);
+        }
+        events.push(event);
+    }
+    return events;
+}
+export class ActivityStore {
+    #file;
+    #runId;
+    #events;
+    #queue = Promise.resolve();
+    constructor(file, runId, events) {
+        this.#file = file;
+        this.#runId = runId;
+        this.#events = events;
+    }
+    static async open(file, runId) {
+        if (!/^run_[a-z0-9-]{8,128}$/u.test(runId))
+            throw new Error("invalid run_id");
+        await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+        const events = await readActivity(file);
+        if (events.some((event) => event.run_id !== runId)) {
+            throw new Error("activity log belongs to a different run");
+        }
+        return new ActivityStore(file, runId, events);
+    }
+    get tip() {
+        return this.#events.at(-1)?.event_digest ?? null;
+    }
+    get events() {
+        return this.#events;
+    }
+    async append(type, payload) {
+        let resolveEvent;
+        let rejectEvent;
+        const result = new Promise((resolve, reject) => {
+            resolveEvent = resolve;
+            rejectEvent = reject;
+        });
+        this.#queue = this.#queue.then(async () => {
+            try {
+                if (!ACTIVITY_TYPES.includes(type))
+                    throw new Error(`unknown activity type ${type}`);
+                const body = {
+                    schema: ACTIVITY_SCHEMA,
+                    run_id: this.#runId,
+                    sequence: this.#events.length,
+                    at: new Date().toISOString(),
+                    type,
+                    previous: this.tip,
+                    payload,
+                };
+                const event = { ...body, event_digest: contentDigest(body) };
+                const line = canonicalJson(event);
+                if (Buffer.byteLength(line) > MAX_EVENT_BYTES)
+                    throw new Error("activity event is oversized");
+                const noFollow = "O_NOFOLLOW" in constants ? constants.O_NOFOLLOW : 0;
+                const handle = await open(this.#file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | noFollow, 0o600);
+                try {
+                    await handle.writeFile(line);
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+                this.#events = [...this.#events, event];
+                resolveEvent(event);
+            }
+            catch (error) {
+                rejectEvent(error);
+            }
+        });
+        return await result;
+    }
+}

package/dist/src/artifact/freeze.d.ts

@@ -0,0 +1,21 @@
+import type { FrozenArtifact } from "../contracts/candidate.js";
+export declare class ArtifactError extends Error {
+    constructor(message: string);
+}
+export interface FrozenArtifactLocation {
+    artifact: FrozenArtifact;
+    frozenPath: string;
+}
+export declare function hashRegularFile(file: string, maxBytes: number): Promise<{
+    digest: string;
+    bytes: number;
+}>;
+export declare function freezeArtifact(options: {
+    sourceRoot: string;
+    artifactRoot: string;
+    path: string;
+    kind: string;
+    maxBytes: number;
+}): Promise<FrozenArtifactLocation>;
+export declare function sealArtifactStore(root: string): Promise<void>;
+export declare function verifyFrozenArtifact(frozen: FrozenArtifactLocation, maxBytes: number): Promise<void>;

package/dist/src/artifact/freeze.js

@@ -0,0 +1,177 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { chmod, link, lstat, mkdir, open, readdir, unlink, } from "node:fs/promises";
+import path from "node:path";
+import { relativePathAt } from "../contracts/validation.js";
+export class ArtifactError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ArtifactError";
+    }
+}
+function below(root, child) {
+    const relative = path.relative(root, child);
+    return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+export async function hashRegularFile(file, maxBytes) {
+    const noFollow = "O_NOFOLLOW" in constants ? constants.O_NOFOLLOW : 0;
+    const handle = await open(file, constants.O_RDONLY | noFollow);
+    try {
+        const before = await handle.stat();
+        if (!before.isFile() || before.nlink !== 1) {
+            throw new ArtifactError("artifact must be one singly linked regular file");
+        }
+        if (before.size > maxBytes) {
+            throw new ArtifactError(`artifact exceeds ${maxBytes} bytes`);
+        }
+        const hash = createHash("sha256");
+        const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, Math.max(1, maxBytes + 1)));
+        let bytes = 0;
+        while (true) {
+            const remaining = maxBytes + 1 - bytes;
+            if (remaining <= 0)
+                throw new ArtifactError(`artifact exceeds ${maxBytes} bytes`);
+            const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, remaining), null);
+            if (bytesRead === 0)
+                break;
+            bytes += bytesRead;
+            if (bytes > maxBytes)
+                throw new ArtifactError(`artifact exceeds ${maxBytes} bytes`);
+            hash.update(buffer.subarray(0, bytesRead));
+        }
+        const after = await handle.stat();
+        if (before.dev !== after.dev ||
+            before.ino !== after.ino ||
+            before.size !== after.size ||
+            before.mtimeMs !== after.mtimeMs ||
+            bytes !== before.size) {
+            throw new ArtifactError("artifact changed while it was being hashed");
+        }
+        return { digest: `sha256:${hash.digest("hex")}`, bytes };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function copyBounded(source, target, maxBytes) {
+    const noFollow = "O_NOFOLLOW" in constants ? constants.O_NOFOLLOW : 0;
+    const sourceHandle = await open(source, constants.O_RDONLY | noFollow);
+    const targetHandle = await open(target, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    try {
+        const before = await sourceHandle.stat();
+        if (!before.isFile() || before.nlink !== 1) {
+            throw new ArtifactError("artifact must be one singly linked regular file");
+        }
+        if (before.size > maxBytes)
+            throw new ArtifactError(`artifact exceeds ${maxBytes} bytes`);
+        const hash = createHash("sha256");
+        const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, Math.max(1, maxBytes + 1)));
+        let bytes = 0;
+        while (true) {
+            const remaining = maxBytes + 1 - bytes;
+            if (remaining <= 0)
+                throw new ArtifactError(`artifact exceeds ${maxBytes} bytes`);
+            const { bytesRead } = await sourceHandle.read(buffer, 0, Math.min(buffer.length, remaining), null);
+            if (bytesRead === 0)
+                break;
+            bytes += bytesRead;
+            if (bytes > maxBytes)
+                throw new ArtifactError(`artifact exceeds ${maxBytes} bytes`);
+            hash.update(buffer.subarray(0, bytesRead));
+            let offset = 0;
+            while (offset < bytesRead) {
+                const write = await targetHandle.write(buffer, offset, bytesRead - offset, null);
+                offset += write.bytesWritten;
+            }
+        }
+        await targetHandle.sync();
+        const after = await sourceHandle.stat();
+        if (before.dev !== after.dev ||
+            before.ino !== after.ino ||
+            before.size !== after.size ||
+            before.mtimeMs !== after.mtimeMs ||
+            bytes !== before.size) {
+            throw new ArtifactError("artifact changed while it was being frozen");
+        }
+        return { digest: `sha256:${hash.digest("hex")}`, bytes };
+    }
+    finally {
+        await Promise.all([sourceHandle.close(), targetHandle.close()]);
+    }
+}
+export async function freezeArtifact(options) {
+    const relative = relativePathAt(options.path, "artifact.path");
+    if (options.kind.length === 0 || options.kind.length > 128) {
+        throw new ArtifactError("artifact kind length must be 1..128");
+    }
+    const sourceRoot = path.resolve(options.sourceRoot);
+    const source = path.resolve(sourceRoot, relative);
+    if (!below(sourceRoot, source)) {
+        throw new ArtifactError("artifact path escapes the worker output root");
+    }
+    const sourceStat = await lstat(source);
+    if (sourceStat.isSymbolicLink())
+        throw new ArtifactError("artifact path is a symbolic link");
+    await mkdir(options.artifactRoot, { recursive: true, mode: 0o700 });
+    const temporary = path.join(options.artifactRoot, `.freeze-${randomUUID()}`);
+    let copied;
+    try {
+        copied = await copyBounded(source, temporary, options.maxBytes);
+        const frozenPath = path.join(options.artifactRoot, copied.digest.slice(7));
+        try {
+            await link(temporary, frozenPath);
+            await chmod(frozenPath, 0o444);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const existing = await hashRegularFile(frozenPath, options.maxBytes);
+            if (existing.digest !== copied.digest || existing.bytes !== copied.bytes) {
+                throw new ArtifactError("existing content-addressed artifact does not match its name");
+            }
+        }
+        await unlink(temporary);
+        const frozen = await hashRegularFile(frozenPath, options.maxBytes);
+        if (frozen.digest !== copied.digest || frozen.bytes !== copied.bytes) {
+            throw new ArtifactError("frozen artifact failed its immediate digest check");
+        }
+        return {
+            artifact: { path: relative, kind: options.kind, digest: copied.digest, bytes: copied.bytes },
+            frozenPath,
+        };
+    }
+    catch (error) {
+        try {
+            await unlink(temporary);
+        }
+        catch (unlinkError) {
+            if (unlinkError.code !== "ENOENT")
+                throw unlinkError;
+        }
+        throw error;
+    }
+}
+export async function sealArtifactStore(root) {
+    const visit = async (current) => {
+        const stat = await lstat(current);
+        if (stat.isSymbolicLink())
+            throw new ArtifactError("artifact store contains a symbolic link");
+        if (stat.isDirectory()) {
+            for (const child of await readdir(current))
+                await visit(path.join(current, child));
+            await chmod(current, 0o555);
+            return;
+        }
+        if (!stat.isFile() || stat.nlink !== 1) {
+            throw new ArtifactError("artifact store contains a non-regular or linked file");
+        }
+        await chmod(current, 0o444);
+    };
+    await visit(root);
+}
+export async function verifyFrozenArtifact(frozen, maxBytes) {
+    const observed = await hashRegularFile(frozen.frozenPath, maxBytes);
+    if (observed.digest !== frozen.artifact.digest || observed.bytes !== frozen.artifact.bytes) {
+        throw new ArtifactError(`frozen artifact ${frozen.artifact.path} no longer matches its record`);
+    }
+}

package/dist/src/artifact/materialize.d.ts

@@ -0,0 +1,6 @@
+import type { CandidateDraft } from "../engines/engine.js";
+export declare function materializeDraftArtifacts(options: {
+    draft: CandidateDraft;
+    outputRoot: string;
+    maxTotalBytes: number;
+}): Promise<void>;

package/dist/src/artifact/materialize.js

@@ -0,0 +1,29 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+function below(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return (relative !== "" &&
+        relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+export async function materializeDraftArtifacts(options) {
+    const root = path.resolve(options.outputRoot);
+    const seen = new Set();
+    let total = 0;
+    for (const artifact of options.draft.artifacts) {
+        if (seen.has(artifact.path))
+            throw new Error(`duplicate engine artifact ${artifact.path}`);
+        seen.add(artifact.path);
+        const target = path.resolve(root, artifact.path);
+        if (!below(root, target))
+            throw new Error(`engine artifact escapes output root: ${artifact.path}`);
+        const bytes = Buffer.from(artifact.content, "utf8");
+        total += bytes.length;
+        if (total > options.maxTotalBytes) {
+            throw new Error(`inline engine artifacts exceed ${options.maxTotalBytes} bytes`);
+        }
+        await mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
+        await writeFile(target, bytes, { flag: "wx", mode: 0o600 });
+    }
+}

package/dist/src/budget/enforce.d.ts

@@ -0,0 +1,30 @@
+import type { MissionBudgets } from "../contracts/mission.js";
+export type BudgetDimension = "max_research_wall_time_ms" | "max_research_processes" | "max_research_output_bytes" | "max_prompt_bytes" | "max_artifact_bytes" | "max_attempts" | "max_observed_tokens";
+export declare class BudgetExceeded extends Error {
+    readonly dimension: BudgetDimension;
+    constructor(dimension: BudgetDimension, used: number, limit: number);
+}
+export interface BudgetSnapshot {
+    research_elapsed_ms: number;
+    research_processes: number;
+    research_output_bytes: number;
+    prompt_bytes: number;
+    artifact_bytes: number;
+    attempts: number;
+    observed_tokens: number;
+}
+export declare class BudgetTracker {
+    #private;
+    constructor(limits: MissionBudgets, now?: () => number);
+    assertTime(): number;
+    beginAttempt(): number;
+    beginProcess(): number;
+    addOutput(bytes: number): number;
+    addPrompt(bytes: number): number;
+    addArtifact(bytes: number): number;
+    addTokens(tokens: number): number;
+    remainingTimeMs(): number;
+    remainingOutputBytes(): number;
+    remainingArtifactBytes(): number;
+    snapshot(): BudgetSnapshot;
+}