cohorte 2.10.1 → 3.0.0-dev.0

package/dist/chunks/src-Cu3TxNob.mjs

@@ -0,0 +1,783 @@
+import { randomFillSync } from "node:crypto";
+import { Type } from "typebox";
+//#region ../../packages/base/src/json.ts
+const JsonValueCyclic = Type.Cyclic({ JsonValue: Type.Union([
+	Type.Null(),
+	Type.Boolean(),
+	Type.Number(),
+	Type.String(),
+	Type.Array(Type.Ref("JsonValue")),
+	Type.Record(Type.String(), Type.Ref("JsonValue"))
+]) }, "JsonValue");
+/**
+* The schema of {@link JsonValue}. Its static type is the hand-written alias rather than the type derived from
+* the cyclic schema: the two are the same type (the assertion below breaks `tsc` if they drift), but the alias
+* costs the compiler nothing where the derived one is re-expanded inside every schema that embeds a JSON value.
+*
+* NOT named `JsonValue` like its type, on purpose. Biome 2.5.14 (type-aware because of nursery/noFloatingPromises)
+* overflows its stack on a RECURSIVE UNION whose name is shared by a TypeBox const, as soon as a class that extends
+* Error holds a value of that type — `CohorteError.info.details` does. It then exits 0, so the lint looks green
+* while nothing was checked. DESIGN 2.1 lists `JsonValue` as a type only (it is not `[S]`), so no contract moves.
+* KEEP THE EXPLICIT ANNOTATION too: having to INFER this call is the other way into the same overflow (a
+* `typeof JsonValueSchema`, or a namespace import of the barrel, is enough). See docs/v3/requests/U0.02.md R1.
+*/
+const JsonValueSchema = Type.Unsafe(JsonValueCyclic);
+const isPlainObject = (value) => {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+const isJson = (value, ancestors) => {
+	if (value === null) return true;
+	switch (typeof value) {
+		case "boolean":
+		case "string": return true;
+		case "number": return Number.isFinite(value);
+		case "object": break;
+		default: return false;
+	}
+	if (ancestors.has(value)) return false;
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			for (let index = 0; index < value.length; index += 1) if (!(index in value) || !isJson(value[index], ancestors)) return false;
+			return true;
+		}
+		if (!isPlainObject(value)) return false;
+		return Object.values(value).every((member) => isJson(member, ancestors));
+	} finally {
+		ancestors.delete(value);
+	}
+};
+/** Structural guard: finite numbers only, no `undefined`, no hole, plain objects only, no cycle. Never throws on data. */
+function isJsonValue(value) {
+	try {
+		return isJson(value, /* @__PURE__ */ new Set());
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region ../../packages/base/src/errors.ts
+/** Spec 24, in spec order. Closed: a fourteenth class would be a MAJOR of both frontiers. */
+const ERROR_CLASSES = [
+	"configuration",
+	"validation",
+	"permission",
+	"security",
+	"provider-transient",
+	"provider-terminal",
+	"tool-transient",
+	"tool-terminal",
+	"conflict",
+	"budget",
+	"timeout",
+	"corruption",
+	"human-required"
+];
+const ErrorClass = Type.Union([
+	Type.Literal("configuration"),
+	Type.Literal("validation"),
+	Type.Literal("permission"),
+	Type.Literal("security"),
+	Type.Literal("provider-transient"),
+	Type.Literal("provider-terminal"),
+	Type.Literal("tool-transient"),
+	Type.Literal("tool-terminal"),
+	Type.Literal("conflict"),
+	Type.Literal("budget"),
+	Type.Literal("timeout"),
+	Type.Literal("corruption"),
+	Type.Literal("human-required")
+]);
+const ERROR_CODE_PATTERN = "^[a-z]+(?:-[a-z]+)*/[a-z0-9]+(?:-[a-z0-9]+)*$";
+const ErrorInfoCyclic = Type.Cyclic({ ErrorInfo: Type.Object({
+	code: Type.String({ pattern: ERROR_CODE_PATTERN }),
+	class: ErrorClass,
+	message: Type.String(),
+	impact: Type.String(),
+	retryable: Type.Boolean(),
+	retryAfterMs: Type.Optional(Type.Number({ minimum: 0 })),
+	remediation: Type.String(),
+	cause: Type.Optional(Type.Ref("ErrorInfo")),
+	details: Type.Optional(Type.Record(Type.String(), JsonValueSchema))
+}, { additionalProperties: false }) }, "ErrorInfo");
+/**
+* The schema of {@link ErrorInfo}, under the name of its type ([S], DESIGN §2). The static type is the DESIGN
+* interface and the assertion below keeps it equal to what the schema derives: an `ErrorInfo` sits in dozens of
+* event payloads, and a derived recursive type would be re-expanded in each of them.
+*
+* KEEP THE EXPLICIT `TUnsafe<ErrorInfo>` ANNOTATION. Biome 2.5.14 is type-aware (nursery/noFloatingPromises) and
+* overflows its stack when it has to INFER this call for a const that shares its name with a recursive type, as
+* soon as a class extending Error holds that type — `CohorteError.info` does. Biome then exits 0: the lint looks
+* green while nothing was checked. With the annotation it has nothing to infer. See docs/v3/requests/U0.02.md R1.
+*/
+const ErrorInfo = Type.Unsafe(ErrorInfoCyclic);
+//#endregion
+//#region ../../packages/base/src/catalogue.ts
+/** DESIGN 2.8, column "CLI exit": the exit code of a process that waited for a run which ended on an error of that class. */
+const EXIT_CODE_BY_CLASS = Object.freeze({
+	configuration: 10,
+	validation: 11,
+	permission: 12,
+	security: 13,
+	"provider-transient": 14,
+	"provider-terminal": 14,
+	"tool-transient": 15,
+	"tool-terminal": 15,
+	conflict: 16,
+	budget: 17,
+	timeout: 18,
+	corruption: 19,
+	"human-required": 20
+});
+const RETRY = true;
+const NO_RETRY = false;
+const row = (code, retryable, impact, remediation) => ({
+	code,
+	retryable,
+	impact,
+	remediation
+});
+/**
+* APPEND-ONLY. A code is a public, stable identifier (spec 24): never rename one, never remove one, never move one
+* to another class; add new rows at the END of their class block. `impact` says what the error means for the run,
+* `remediation` is the imperative next action (spec 21). Every `<class>/unexpected` row is the landing place of a
+* throwable nobody classified (DESIGN 2.8) and is never retried.
+*/
+const ERROR_CATALOGUE_ROWS = [
+	row("configuration/policy-invalid", NO_RETRY, "The security policy is missing or cannot be parsed, so nothing may execute and the run does not start.", "Fix the policy keys named in the message in .cohorte/config.yaml, then run `cohorte doctor`."),
+	row("configuration/phase-not-available", NO_RETRY, "The requested phase or pipeline profile is not part of this version, so the run does not start.", "Choose a profile that `cohorte doctor` lists as available, or upgrade Cohorte."),
+	row("configuration/incompatible-state-schema", NO_RETRY, "The state database was written by an incompatible Cohorte version and is left untouched.", "Run the Cohorte version named in the message, or back up the state and run `cohorte migrate --apply`."),
+	row("configuration/platform-unsupported", NO_RETRY, "This operating system or architecture cannot provide what the configuration requires, so the run does not start.", "Run on a supported platform, or relax the requirement named in the message in your user configuration."),
+	row("configuration/telemetry-remote-unavailable", NO_RETRY, "Remote telemetry is configured but does not exist in this version; nothing was sent.", "Remove the remote telemetry settings; local logs and metrics stay available."),
+	row("configuration/worktree-root-protected", NO_RETRY, "The configured worktree root lies inside a protected directory, so no worktree can be created there.", "Set git.worktreeRoot to a directory outside the protected roots, or remove the setting to use the default."),
+	row("configuration/provision-store-unavailable", NO_RETRY, "Dependencies cannot be provisioned offline because the package manager store is not reachable.", "Populate the package manager store (install once with network access), then start the run again."),
+	row("configuration/engine-init", NO_RETRY, "The agent runtime could not initialise its model engine, so the agent never started.", "Run `cohorte doctor` and fix the provider or model configuration it reports."),
+	row("configuration/fake-script-unmatched", NO_RETRY, "The fake runtime script has no entry for this spawn request, so the scripted run cannot continue.", "Add a matching entry to the fake runtime script, or correct the spawn fields it matches on."),
+	row("configuration/unexpected", NO_RETRY, "An unclassified configuration failure stopped the run before or while it started.", "Read the message, run `cohorte doctor`, and report the error if the configuration looks correct."),
+	row("validation/tool-input", NO_RETRY, "A tool call did not match the input schema of the tool and was not executed.", "Nothing to do if the agent recovers; otherwise inspect the rejected call with `cohorte logs`."),
+	row("validation/agent-output", NO_RETRY, "The final output of the agent does not match the schema of its phase, so it cannot be used.", "Inspect the agent transcript; retry the phase or escalate the model tier."),
+	row("validation/agent-no-result", NO_RETRY, "The agent stopped without delivering a structured result, so its phase has no outcome.", "Retry the phase; if it repeats, inspect the transcript and escalate the model tier."),
+	row("validation/spec", NO_RETRY, "The spec file is invalid, so the run cannot be planned from it.", "Fix the fields named in the message in the spec file, then start the run again."),
+	row("validation/invalid-id", NO_RETRY, "A value is not a well-formed identifier of the expected kind and was refused before reaching a path, a ref or the store.", "Pass an identifier of the shape named in the message, as printed by `cohorte status`."),
+	row("validation/unexpected", NO_RETRY, "An unclassified validation failure made a value unusable.", "Read the message, inspect the offending input with `cohorte logs`, and report the error if the input looks valid."),
+	row("permission/tool-not-granted", NO_RETRY, "The agent called a tool its role was not granted; the call was denied and nothing executed.", "Nothing to do if the agent adapts; grant the tool to the role in the configuration if the call was legitimate."),
+	row("permission/path-outside-grant", NO_RETRY, "The agent addressed a path outside what its grant allows; the call was denied and nothing was read or written.", "Nothing to do if the agent adapts; widen the ownership of the surface if the path legitimately belongs to it."),
+	row("permission/command-not-allowed", NO_RETRY, "The command is not in the allowlist of the command policy; it was denied and nothing executed.", "Add a rule for the command to the command policy if it is legitimate, then resume."),
+	row("permission/network-denied", NO_RETRY, "The call needs network access, which agents never have in this version; it was denied.", "Provide what the agent needed locally, for example through provisioning, then resume."),
+	row("permission/denied-by-human", NO_RETRY, "A human denied the approval request; the call was not executed.", "Nothing to do; approve a new request if the denial was a mistake."),
+	row("permission/unexpected", NO_RETRY, "An unclassified permission failure denied the call; nothing executed.", "Read the message and inspect the denied call with `cohorte logs`."),
+	row("security/symlink-escape", NO_RETRY, "A path resolves through a symbolic link to a location outside its allowed root; the run is blocked and its worktrees are frozen.", "Inspect the link named in the message, remove it if it is hostile, then acknowledge with `cohorte resume --ack`."),
+	row("security/protected-path", NO_RETRY, "The agent targeted a protected path such as .git, .cohorte or a credential file; the run is blocked.", "Inspect the attempted call with `cohorte logs`, then acknowledge with `cohorte resume --ack` or cancel the run."),
+	row("security/write-outside-ownership", NO_RETRY, "Changes were found outside the ownership of the surface that produced them; they are not integrated and the run is blocked.", "Inspect the diff of the frozen worktree, revert or re-assign the files, then acknowledge with `cohorte resume --ack`."),
+	row("security/runtime-pin-mismatch", NO_RETRY, "The installed runtime no longer matches the pin taken when the run started; no agent is spawned.", "Reinstall the pinned Cohorte and runtime versions named in the message, then resume."),
+	row("security/asset-hash-mismatch", NO_RETRY, "An embedded prompt, skill, schema or migration does not match its recorded hash; the installation is not trusted.", "Reinstall Cohorte from the registry and compare with `cohorte doctor`."),
+	row("security/pin-tampered", NO_RETRY, "The recorded runtime pin or run snapshot was modified after the run started; the run is blocked.", "Inspect the run directory for tampering; start a new run if the snapshot cannot be trusted."),
+	row("security/runtime-inside-target", NO_RETRY, "Cohorte is running from inside the repository it would modify, so agents could rewrite their own supervisor; the run does not start.", "Run an installed Cohorte that lives outside the target repository."),
+	row("security/auth-mode-violation", NO_RETRY, "A request was about to use another billing mode than the one the run plan allows; it was stopped before leaving the machine.", "Check the provider authentication with `cohorte auth status`; opt in to metered billing explicitly if that is intended."),
+	row("security/auth-endpoint-mismatch", NO_RETRY, "The provider endpoint differs from the pinned one for this authentication mode; no credential was sent.", "Remove the endpoint override, or pin the endpoint in your user configuration if it is legitimate."),
+	row("security/command-auth-invalid", NO_RETRY, "A control command carried a missing, unknown or wrong authenticator; it was rejected and never applied.", "Send the command again through the `cohorte` CLI as the user who owns the project key."),
+	row("security/event-chain-broken", NO_RETRY, "The event history of the run fails its hash chain or anchor check, so it may have been rewritten; the run is blocked.", "Inspect the state database and its backups; never delete the run, restore a verified backup instead."),
+	row("security/root-refused", NO_RETRY, "Cohorte refuses to run as root; nothing was started.", "Run Cohorte as an unprivileged user."),
+	row("security/sandbox-unavailable", NO_RETRY, "The required operating-system sandbox is not available, so commands would run unconfined; the run does not start.", "Follow the sandbox remediation printed by `cohorte doctor`, or opt in to best-effort isolation in your user configuration."),
+	row("security/secret-staged", NO_RETRY, "A secret was detected in the changes about to be committed; the commit was not created and the run is blocked.", "Remove the secret from the worktree and rotate it, then acknowledge with `cohorte resume --ack`."),
+	row("security/command-trampoline", NO_RETRY, "The command would launch another program on behalf of the agent (a shell, an interpreter flag, an exec wrapper); it was denied.", "Inspect the attempted command with `cohorte logs`; expose the real program through the command policy if it is legitimate."),
+	row("security/project-policy-untrusted", NO_RETRY, "The configuration of the repository loosens security settings that only the local user may loosen; the run does not start.", "Review the keys named in the message, then grant them with `cohorte config trust` or set them in your user configuration."),
+	row("security/deps-tampered", NO_RETRY, "Provisioned dependencies changed after they were installed and sealed; the run is blocked.", "Inspect the slot named in the message, then provision it again from the lockfile."),
+	row("security/review-ref-mutated", NO_RETRY, "The immutable ref under review changed while it was being reviewed; the review result cannot be trusted.", "Inspect who moved the ref, then run the review again on a fresh ref."),
+	row("security/command-global-option", NO_RETRY, "The command carries a global option that redirects the program (for git: -C, -c, --git-dir, --work-tree); it was denied.", "Inspect the attempted command with `cohorte logs`; no configuration allows these options."),
+	row("security/gate-internal-error", NO_RETRY, "A stage of the permission gate failed unexpectedly; the call was denied because the gate fails closed.", "Report the error with the run logs; resume once the cause is understood."),
+	row("security/redaction-failed", NO_RETRY, "The redactor failed on an event; the payload was dropped instead of being stored unredacted.", "Report the error with the run logs; the dropped payload is not recoverable."),
+	row("security/unexpected", NO_RETRY, "An unclassified security failure blocked the run; its worktrees are frozen.", "Inspect the run with `cohorte logs` before acknowledging with `cohorte resume --ack`."),
+	row("provider-transient/rate-limited", RETRY, "The provider is rate limiting requests; the request is retried with a bounded back-off.", "Nothing to do; if it persists, lower the agent concurrency or wait for the limit to reset."),
+	row("provider-transient/overloaded", RETRY, "The provider is overloaded or returned a server error; the request is retried with a bounded back-off.", "Nothing to do; check the status page of the provider if it persists."),
+	row("provider-transient/network", RETRY, "The connection to the provider failed; the request is retried with a bounded back-off.", "Check the network connection and any proxy settings if it persists."),
+	row("provider-transient/credential-store-locked", RETRY, "The credential store is locked by another process; the request is retried shortly.", "Close other programs that use the same login if it persists."),
+	row("provider-transient/unexpected", NO_RETRY, "An unclassified provider failure interrupted a model request; it is not retried because its cause is unknown.", "Read the message, then resume the run; report the error if it repeats."),
+	row("provider-terminal/auth-required", NO_RETRY, "The provider needs a new login; the run is suspended until authentication is restored.", "Run `cohorte auth login`, then `cohorte resume`."),
+	row("provider-terminal/quota-exceeded", NO_RETRY, "The plan limit of the provider is reached; the run is suspended until the quota resets.", "Wait for the reset time shown by `cohorte status`, then resume; automatic resume does it when enabled."),
+	row("provider-terminal/entitlement", NO_RETRY, "The account is not entitled to this model or usage; the request cannot succeed as configured.", "Choose a model your plan includes, or change the plan with the provider."),
+	row("provider-terminal/model-not-found", NO_RETRY, "The configured model does not exist for this provider; the agent cannot start.", "Correct the model in the tier table of the configuration; `cohorte doctor` lists the known models."),
+	row("provider-terminal/policy-refused", NO_RETRY, "The provider refused the request under its usage policies; repeating it unchanged will not help.", "Inspect the refused request in the transcript and rephrase the task or the spec."),
+	row("provider-terminal/unexpected", NO_RETRY, "An unclassified provider failure ended a model request for good.", "Read the message and the transcript; report the error if the request looks valid."),
+	row("tool-transient/spawn-failed", RETRY, "The process of a tool could not be started; the call is retried once.", "Check that the program exists on the pinned PATH reported by `cohorte doctor` if it persists."),
+	row("tool-transient/interrupted", RETRY, "A tool call was interrupted before it finished, for example by a host restart; it is replayed when that is safe.", "Nothing to do; inspect the effect journal with `cohorte inspect` if the call is reported in doubt."),
+	row("tool-transient/agent-process-exit", RETRY, "The process of the agent exited without settling; a fresh incarnation takes over from the file ledger.", "Nothing to do; check the memory and the logs of the machine if it repeats."),
+	row("tool-transient/cancelled", RETRY, "The tool call was cancelled before it finished because its agent or its run was paused or cancelled.", "Nothing to do; resume the run to let the agent issue the call again."),
+	row("tool-transient/unexpected", NO_RETRY, "An unclassified failure interrupted a tool call; it is not retried because its cause is unknown.", "Read the message and inspect the call with `cohorte logs`; report the error if it repeats."),
+	row("tool-terminal/nonzero-exit", NO_RETRY, "The command exited with a non-zero status; the result was handed to the agent.", "Nothing to do; the agent sees the output and decides what to do next."),
+	row("tool-terminal/output-cap", NO_RETRY, "The output of the tool exceeded its cap and was truncated or the process was stopped.", "Nothing to do; narrow the command if the agent keeps hitting the cap."),
+	row("tool-terminal/patch-preimage-mismatch", NO_RETRY, "The file no longer matches the content the patch was written against; nothing was written.", "Nothing to do; the agent must read the file again before patching it."),
+	row("tool-terminal/unexpected", NO_RETRY, "An unclassified failure ended a tool call; an error result was handed to the agent.", "Read the message and inspect the call with `cohorte logs`."),
+	row("conflict/merge", NO_RETRY, "The branch of a surface does not merge cleanly into the integration branch; the conflict goes to a fix round or to a human.", "Let the fix round resolve it, or resolve the conflict on the integration branch and resume."),
+	row("conflict/zone-reserved", NO_RETRY, "Another agent holds the lock on an overlapping zone of files; the writer must wait for it.", "Nothing to do; it clears when the holder finishes. Cancel the holder if it is stuck."),
+	row("conflict/incarnation-exists", NO_RETRY, "An incarnation of this agent is already registered; a second one was refused.", "Nothing to do; if no such process is alive, `cohorte resume` sweeps the stale incarnation."),
+	row("conflict/command-id-reuse", NO_RETRY, "A command identifier was reused with a different body; the second command was rejected.", "Send the command again with a fresh identifier."),
+	row("conflict/run-host-alive", NO_RETRY, "A run host already drives this run; a second one was refused.", "Observe the run with `cohorte tail`; stop the other host first if you mean to replace it."),
+	row("conflict/lease-lost", NO_RETRY, "This run host lost its lease to a newer one and was fenced off; it stopped writing.", "Nothing to do; the newer host owns the run. Observe it with `cohorte status`."),
+	row("conflict/reconcile-human-edit", NO_RETRY, "A generated file was edited by hand since it was rendered; reconcile will not overwrite it.", "Keep your edit and mark the field as overridden, or restore the generated content, then plan the reconcile again."),
+	row("conflict/not-running", NO_RETRY, "The command applies to a running pipeline only and the run is not running; it was rejected.", "Check the state with `cohorte status` and use the command that fits it."),
+	row("conflict/run-terminal", NO_RETRY, "The run has already ended; the command was rejected.", "Start a new run; a completed or cancelled run cannot change."),
+	row("conflict/run-active", NO_RETRY, "The run is active, and this command applies to a halted run only; it was rejected.", "Wait for the run to halt, or pause it, before sending this command."),
+	row("conflict/run-halted", NO_RETRY, "The run is halted (FAILED or BLOCKED) rather than running; the command was rejected. A halted run is not over.", "Resume it the way its state allows — `cohorte retry` out of FAILED, `cohorte resume --ack` out of BLOCKED."),
+	row("conflict/use-retry", NO_RETRY, "The run is FAILED, and this command resumes a suspended run only; it was rejected.", "Use `cohorte retry` to resume a FAILED run."),
+	row("conflict/use-resume", NO_RETRY, "The run is suspended, and this command resumes a FAILED run only; it was rejected.", "Use `cohorte resume` to resume a suspended run."),
+	row("conflict/use-resume-ack", NO_RETRY, "The run is BLOCKED by a security stop, and this command does not acknowledge it; it was rejected.", "Read the stop record, then use `cohorte resume --ack` to acknowledge it and resume."),
+	row("conflict/run-blocked", NO_RETRY, "The run is BLOCKED by a security stop; the command was rejected while the stop stands.", "Read the stop record and resume with `cohorte resume --ack` before sending this command again."),
+	row("conflict/unexpected", NO_RETRY, "An unclassified conflict stopped an operation; the state it competed for was left as it was.", "Check the state with `cohorte status`, then repeat the operation."),
+	row("budget/tokens", NO_RETRY, "A token budget is exhausted; the run waits for a human decision.", "Raise the budget with `cohorte approve`, or cancel the run."),
+	row("budget/tool-calls-exhausted", NO_RETRY, "The tool-call budget of the agent is exhausted; further calls are refused.", "Raise the tool-call budget with `cohorte approve`, or let the agent conclude with what it has."),
+	row("budget/context-window", NO_RETRY, "The conversation no longer fits the context window of the model; a fresh incarnation continues with a smaller context built by Cohorte.", "Nothing to do; split the task or narrow the ownership if it repeats."),
+	row("budget/fix-rounds", NO_RETRY, "The maximum number of fix rounds is reached with findings still open; the run waits for a human decision.", "Review the open findings, then raise the limit with `cohorte approve` or take over by hand."),
+	row("budget/provider", NO_RETRY, "The budget configured for this provider is exhausted; the run waits for a human decision.", "Raise the provider budget with `cohorte approve`, or cancel the run."),
+	row("budget/estimated-quota", NO_RETRY, "The estimated share of the plan quota used by this run reached its limit; the run waits for a human decision.", "Raise the limit with `cohorte approve`, or wait for the quota window to reset."),
+	row("budget/incarnations", NO_RETRY, "The agent was restarted as many times as allowed and is now failed.", "Inspect why the agent keeps dying with `cohorte logs`, then retry the phase."),
+	row("budget/unexpected", NO_RETRY, "An unclassified budget failure stopped the run from spending more.", "Check the counters with `cohorte status`, then approve a higher budget or cancel the run."),
+	row("timeout/tool", RETRY, "A tool call exceeded its time limit and its process tree was killed; the call is retried once.", "Raise the timeout of the command in the configuration if the command is legitimately slow."),
+	row("timeout/model-request", RETRY, "A model request exceeded its time limit; it is retried with a bounded back-off.", "Nothing to do; check the network and the status of the provider if it persists."),
+	row("timeout/agent", RETRY, "The agent exceeded its wall-clock limit and was stopped; the retry policy decides what follows.", "Raise the agent time limit, or split the task, if the work is legitimately long."),
+	row("timeout/run", NO_RETRY, "The run exceeded its wall-clock budget; it waits for a human decision.", "Extend the run with `cohorte approve`, or cancel it."),
+	row("timeout/unexpected", NO_RETRY, "An unclassified timeout stopped an operation; it is not retried because its cause is unknown.", "Read the message, then resume the run; report the error if it repeats."),
+	row("corruption/event-gap", NO_RETRY, "The event sequence of the run has a gap or a duplicate; the store refuses to open it and deletes nothing.", "Restore the state database from a backup; keep the damaged file for inspection."),
+	row("corruption/projection-mismatch", NO_RETRY, "The stored projections disagree with what the events replay to; the run is not resumed from them.", "Run `cohorte doctor --verify-state` to see which projection differs from the event log, and report it; the events are the truth."),
+	row("corruption/snapshot-hash", NO_RETRY, "A state snapshot does not match its recorded hash; it is ignored and an older one is used when available.", "Nothing to do if resume succeeds; otherwise restore the state database from a backup."),
+	row("corruption/incompatible-schema", NO_RETRY, "The schema of the state database is not one this version can read; it refuses to open it and never migrates on its own.", "Run the Cohorte version that wrote the database, or back up the state and run `cohorte migrate --apply`."),
+	row("corruption/unexpected", NO_RETRY, "An unclassified integrity failure made stored state untrustworthy; nothing was deleted.", "Back up the .cohorte/state directory before anything else, then run `cohorte doctor`."),
+	row("human-required/approval", NO_RETRY, "A call needs the approval of a human; the run waits and nothing executes meanwhile.", "Review the request with `cohorte status`, then `cohorte approve` or `cohorte deny`."),
+	row("human-required/approval-timeout", NO_RETRY, "An approval request expired without an answer; the call was not executed.", "Resume the run to let the agent ask again, then answer in time."),
+	row("human-required/blocked-ack", NO_RETRY, "The run is blocked after a security event and needs a human to inspect it.", "Inspect the run with `cohorte logs`, then acknowledge with `cohorte resume --ack` or cancel it."),
+	row("human-required/in-doubt-effect", NO_RETRY, "An effect was interrupted and cannot be proven done or not done; repeating it blindly could apply it twice.", "Inspect the effect with `cohorte inspect`, then resolve it by hand and resume."),
+	row("human-required/unexpected", NO_RETRY, "An unclassified situation needs a human decision; the run waits.", "Check what the run waits for with `cohorte status`, then answer it.")
+];
+const classOf = (code) => {
+	const prefix = code.slice(0, code.indexOf("/"));
+	const found = ERROR_CLASSES.find((candidate) => candidate === prefix);
+	if (!found) throw new TypeError(`error catalogue: ${code} does not start with an error class`);
+	return found;
+};
+const build = () => {
+	const catalogue = Object.create(null);
+	for (const { code, retryable, impact, remediation } of ERROR_CATALOGUE_ROWS) {
+		if (code in catalogue) throw new TypeError(`error catalogue: ${code} is listed twice`);
+		const errorClass = classOf(code);
+		catalogue[code] = Object.freeze({
+			class: errorClass,
+			retryable,
+			impact,
+			remediation,
+			exit: EXIT_CODE_BY_CLASS[errorClass]
+		});
+	}
+	return Object.freeze(catalogue);
+};
+/** DESIGN 2.8 (PLAN PC-1: the data lives in base so that L2 packages can mint complete `ErrorInfo`s). */
+const ERROR_CATALOGUE = build();
+function isErrorCode(code) {
+	return Object.hasOwn(ERROR_CATALOGUE, code);
+}
+//#endregion
+//#region ../../packages/base/src/taxonomy.ts
+const MAX_MESSAGE_LENGTH = 2e3;
+/** "single paragraph" (DESIGN 2.1): one line, bounded. Redaction is NOT done here: only a Redactor seals. */
+const paragraph = (text) => {
+	const flat = text.replace(/\s+/g, " ").trim();
+	return flat.length > MAX_MESSAGE_LENGTH ? `${flat.slice(0, 1999)}…` : flat;
+};
+/** Returns `info` itself when its chain is already within bounds, a truncated copy otherwise. */
+const capCause = (info, remaining) => {
+	if (!info.cause) return info;
+	if (remaining === 0) {
+		const { cause: _dropped, ...rest } = info;
+		return {
+			...rest,
+			details: {
+				...rest.details,
+				causeChainTruncated: true
+			}
+		};
+	}
+	const capped = capCause(info.cause, remaining - 1);
+	return capped === info.cause ? info : {
+		...info,
+		cause: capped
+	};
+};
+/** A frozen copy of the chain, so that a thrown error cannot be edited on its way up. `details` are shared, not copied. */
+const frozenChain = (info) => Object.freeze(info.cause ? {
+	...info,
+	cause: frozenChain(info.cause)
+} : { ...info });
+/**
+* Mints a complete `ErrorInfo` from the catalogue: class, retryability, impact and remediation come from the row of
+* `code`, never from the call site (PLAN PC-1).
+*/
+function errorOf(code, message, extra = {}) {
+	const entry = ERROR_CATALOGUE[code];
+	if (!entry || !isErrorCode(code)) throw new TypeError(`errorOf: ${String(code)} is not in ERROR_CATALOGUE`);
+	const { retryAfterMs, cause, details } = extra;
+	const info = {
+		code,
+		class: entry.class,
+		message: paragraph(message),
+		impact: entry.impact,
+		retryable: entry.retryable,
+		...isRetryAfterMs(retryAfterMs) ? { retryAfterMs } : {},
+		remediation: entry.remediation,
+		...cause === void 0 || cause === null ? {} : { cause: isCanonical(cause, 5) ? cause : wireSafe(cause, 4, UNCLASSIFIED) },
+		...details === void 0 ? {} : { details: isDetails(details) ? details : { detailsDropped: true } }
+	};
+	return capCause(info, 5);
+}
+/** Where an error lands when even the caller's fallback class is not one of the thirteen (a JS caller, a cast, a decoded wire value). */
+const UNCLASSIFIED = "validation/unexpected";
+const isClassified = (info) => {
+	try {
+		return isErrorCode(info.code) && ERROR_CATALOGUE[info.code]?.class === info.class;
+	} catch {
+		return false;
+	}
+};
+const INFO_KEYS = /* @__PURE__ */ new Set([
+	"code",
+	"class",
+	"message",
+	"impact",
+	"retryable",
+	"retryAfterMs",
+	"remediation",
+	"cause",
+	"details"
+]);
+const isRetryAfterMs = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+const isDetails = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && isJsonValue(value);
+/**
+* True when `info` is exactly what `errorOf` would mint: strict JSON, a catalogue code under its own class, the
+* catalogue's impact, retryability and remediation, no foreign member, and a cause chain of the same kind no deeper
+* than `remaining`. "Is JSON" alone is not enough: a cast can carry a security code as a retryable tool error.
+*/
+const isCanonical = (info, remaining) => {
+	try {
+		return isJsonValue(info) && isClassified(info) && hasCanonicalMembers(info, remaining);
+	} catch {
+		return false;
+	}
+};
+const hasCanonicalMembers = (info, remaining) => {
+	const raw = info;
+	const entry = isErrorCode(info.code) ? ERROR_CATALOGUE[info.code] : void 0;
+	if (!entry || raw.impact !== entry.impact || raw.retryable !== entry.retryable) return false;
+	if (raw.remediation !== entry.remediation || typeof raw.message !== "string") return false;
+	if (!Object.keys(info).every((key) => INFO_KEYS.has(key))) return false;
+	if ("retryAfterMs" in info && !isRetryAfterMs(raw.retryAfterMs)) return false;
+	if ("details" in info && !isDetails(raw.details)) return false;
+	if (!("cause" in info)) return true;
+	return remaining > 0 && typeof raw.cause === "object" && raw.cause !== null && isCanonical(info.cause, remaining - 1);
+};
+/**
+* Rebuilds an `ErrorInfo` that is not what `errorOf` mints (an `undefined` optional, a Date in `details`, a cast, a
+* call-site `retryable`) WITHOUT reclassifying it: a `security/*` error must stay one across every boundary (I2).
+* The catalogue row of its own code restores class, impact, retryability and remediation; `fallback` is used only
+* when the code is not a catalogue code of the claimed class. Never throws.
+*/
+const wireSafe = (info, remaining, fallback) => {
+	if (isCanonical(info, remaining)) return info;
+	try {
+		const raw = info;
+		const code = isClassified(info) && isErrorCode(info.code) ? info.code : fallback;
+		const extra = {};
+		if (isRetryAfterMs(raw.retryAfterMs)) extra.retryAfterMs = raw.retryAfterMs;
+		let truncated = false;
+		if (typeof raw.cause === "object" && raw.cause !== null) {
+			if (remaining > 0) extra.cause = wireSafe(raw.cause, remaining - 1, fallback);
+			else truncated = true;
+		}
+		if (raw.details !== void 0) extra.details = isDetails(raw.details) ? raw.details : { detailsDropped: true };
+		if (truncated) extra.details = {
+			...extra.details,
+			causeChainTruncated: true
+		};
+		return errorOf(code, typeof raw.message === "string" ? raw.message : "unknown error", extra);
+	} catch {
+		return errorOf(fallback, "unknown error (unreadable)", { details: { thrown: "unreadable" } });
+	}
+};
+var CohorteError = class extends Error {
+	info;
+	constructor(info, options) {
+		super(`${info.code}: ${info.message}`, options && "cause" in options ? { cause: options.cause } : void 0);
+		this.name = "CohorteError";
+		const safe = isClassified(info) ? wireSafe(info, 5, UNCLASSIFIED) : info;
+		this.info = frozenChain(capCause(safe, 5));
+	}
+};
+/** What a Wave-0 typed stub throws (DESIGN 10.1 rule 3). Deliberately not a `CohorteError`: reaching one is a bug, not a run outcome. */
+var NotImplemented = class extends Error {
+	constructor(what) {
+		super(what ? `not implemented: ${what}` : "not implemented");
+		this.name = "NotImplemented";
+	}
+};
+const describeThrown = (thrown) => {
+	const kind = thrown === null ? "null" : typeof thrown;
+	const unknown = `unknown error (${kind})`;
+	switch (typeof thrown) {
+		case "string": return {
+			message: thrown || unknown,
+			details: { thrown: kind }
+		};
+		case "number":
+		case "bigint":
+		case "boolean":
+		case "symbol": return {
+			message: String(thrown),
+			details: { thrown: kind }
+		};
+		case "object":
+		case "function": break;
+		default: return {
+			message: unknown,
+			details: { thrown: kind }
+		};
+	}
+	if (thrown === null) return {
+		message: unknown,
+		details: { thrown: kind }
+	};
+	const record = thrown;
+	const isError = thrown instanceof Error;
+	const name = isError && typeof record.name === "string" && record.name ? record.name : void 0;
+	const text = typeof record.message === "string" && record.message ? record.message : name ?? unknown;
+	const details = { thrown: name ?? kind };
+	if (isError && typeof record.code === "string" && record.code) details.errorCode = record.code;
+	return {
+		message: text,
+		details
+	};
+};
+const fallbackCode = (fallback) => {
+	try {
+		if (isErrorCode(fallback.code) && ERROR_CATALOGUE[fallback.code]?.class === fallback.class) return fallback.code;
+		const unexpected = `${fallback.class}/unexpected`;
+		return isErrorCode(unexpected) ? unexpected : UNCLASSIFIED;
+	} catch {
+		return UNCLASSIFIED;
+	}
+};
+const convert = (thrown, fallback, remaining) => {
+	let info;
+	let jsCause;
+	try {
+		if (thrown instanceof CohorteError) {
+			info = thrown.info;
+			jsCause = info.cause ? void 0 : thrown.cause;
+		} else {
+			const { message, details } = describeThrown(thrown);
+			info = errorOf(fallback, message, { details });
+			jsCause = thrown instanceof Error ? thrown.cause : void 0;
+		}
+	} catch {
+		info = errorOf(fallback, "unknown error (unreadable)", { details: { thrown: "unreadable" } });
+		jsCause = void 0;
+	}
+	if (jsCause === void 0 || jsCause === null) return capCause(info, remaining);
+	if (remaining === 0) return {
+		...info,
+		details: {
+			...info.details,
+			causeChainTruncated: true
+		}
+	};
+	return {
+		...info,
+		cause: convert(jsCause, fallback, remaining - 1)
+	};
+};
+/**
+* Total: never throws, whatever was thrown and whatever `fallback` holds. A `CohorteError` keeps its own
+* classification, even when its `ErrorInfo` has to be rebuilt to be strict JSON. Anything else becomes
+* `fallback.code` when that is a catalogue code of `fallback.class`, and `<fallback.class>/unexpected` otherwise
+* (DESIGN 2.8), so the result is always a catalogue code with its impact and remediation. `Error.cause` is
+* followed, at most MAX_CAUSE_DEPTH deep.
+*/
+function toErrorInfo(e, fallback) {
+	const code = fallbackCode(fallback);
+	return wireSafe(convert(e, code, 5), 5, code);
+}
+//#endregion
+//#region ../../packages/base/src/ids.ts
+/** Token-safe for François' single ${token} slot, for refs and for paths. */
+const ID_PATTERN = "^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$";
+const ISO_INSTANT_PATTERN = "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\\.[0-9]{3}Z$";
+/** The shape each kind of DESIGN 2.1 has, as a pattern (for schemas) and as words (for a human). */
+const ID_SHAPES = {
+	RunId: {
+		pattern: "^run_[0-9a-f]{32}$",
+		shape: "run_<32 lowercase hex digits>"
+	},
+	AgentId: {
+		pattern: "^agt_[A-Za-z0-9.-]+_[A-Za-z0-9_.-]+$",
+		shape: "agt_<role>_<surface|main>[_<n>]"
+	},
+	PhaseRunId: {
+		pattern: "^phs_[A-Z][A-Z_]*_[0-9]+$",
+		shape: "phs_<STATE>_<iteration>"
+	},
+	EventId: {
+		pattern: "^evt_[0-9a-f]{32}$",
+		shape: "evt_<32 lowercase hex digits>"
+	},
+	CommandId: {
+		pattern: "^cmd_[0-9a-f]{32}$",
+		shape: "cmd_<32 lowercase hex digits>"
+	},
+	ApprovalId: {
+		pattern: "^apr_[0-9a-f]{32}$",
+		shape: "apr_<32 lowercase hex digits>"
+	},
+	ToolCallId: {
+		pattern: "^tc_[0-9]+_[0-9]+$",
+		shape: "tc_<incarnation>_<ordinal>"
+	},
+	EffectId: {
+		pattern: "^eff_[0-9a-f]{32}$",
+		shape: "eff_<32 lowercase hex digits>"
+	},
+	ArtifactId: {
+		pattern: "^art_[0-9a-f]{32}$",
+		shape: "art_<32 lowercase hex digits>"
+	},
+	FindingId: {
+		pattern: "^fnd_[0-9a-f]{16}$",
+		shape: "fnd_<16 lowercase hex digits>"
+	},
+	SpecId: {
+		pattern: ID_PATTERN,
+		shape: "letters, digits, \"_\", \".\" and \"-\" (at most 128, not starting with \".\" or \"-\")"
+	},
+	SurfaceId: {
+		pattern: ID_PATTERN,
+		shape: "letters, digits, \"_\", \".\" and \"-\" (at most 128, not starting with \".\" or \"-\")"
+	},
+	Sha256: {
+		pattern: "^[0-9a-f]{64}$",
+		shape: "64 lowercase hex digits"
+	},
+	IsoInstant: {
+		pattern: ISO_INSTANT_PATTERN,
+		shape: "an RFC 3339 UTC instant with milliseconds, such as 2026-01-01T00:00:00.000Z"
+	}
+};
+ID_SHAPES.SpecId;
+const compiled = /* @__PURE__ */ new Map();
+const regExpOf = (pattern) => {
+	let found = compiled.get(pattern);
+	if (!found) {
+		found = new RegExp(pattern);
+		compiled.set(pattern, found);
+	}
+	return found;
+};
+/**
+* ID_PATTERN plus the three things it lets through that `git check-ref-format` refuses in a ref component:
+* "..", a trailing "." and a trailing ".lock". Ids reach branch names (`cohorte/<runId>/<slot>/<n>`, DESIGN 5.1).
+*/
+function isSafeId(raw) {
+	return regExpOf("^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$").test(raw) && !raw.includes("..") && !raw.endsWith(".") && !raw.endsWith(".lock");
+}
+/** Renders a date as an IsoInstant. Throws a RangeError on an invalid date or a year outside 0000-9999. */
+function toIsoInstant(value) {
+	const text = new Date(value).toISOString();
+	if (!regExpOf(ISO_INSTANT_PATTERN).test(text)) throw new RangeError(`toIsoInstant: ${text} is outside the years 0000-9999`);
+	return text;
+}
+const idSchema = (kind, options = {}) => Type.Unsafe(Type.String({
+	...options,
+	pattern: ID_SHAPES[kind].pattern
+}));
+const RunId = idSchema("RunId");
+const AgentId = idSchema("AgentId", { maxLength: 128 });
+const PhaseRunId = idSchema("PhaseRunId", { maxLength: 128 });
+const EventId = idSchema("EventId");
+const CommandId = idSchema("CommandId");
+const ApprovalId = idSchema("ApprovalId");
+const ToolCallId = idSchema("ToolCallId", { maxLength: 128 });
+const EffectId = idSchema("EffectId");
+const ArtifactId = idSchema("ArtifactId");
+const FindingId = idSchema("FindingId");
+const SpecId = idSchema("SpecId");
+const SurfaceId = idSchema("SurfaceId");
+const Sha256 = idSchema("Sha256");
+const IsoInstant = idSchema("IsoInstant", { format: "date-time" });
+//#endregion
+//#region ../../packages/base/src/model.ts
+const ModelCapability = Type.Union([
+	Type.Literal("fast"),
+	Type.Literal("coding"),
+	Type.Literal("reasoning"),
+	Type.Literal("vision"),
+	Type.Literal("cheap")
+]);
+/** Spec 10, VERBATIM. Thinking level is NOT part of ModelRef: it travels next to it (SpawnRequest.thinking, tier table). */
+const ModelRef = Type.Object({
+	provider: Type.String(),
+	model: Type.String(),
+	capability: Type.Optional(ModelCapability)
+}, { additionalProperties: false });
+const ThinkingLevel = Type.Union([
+	Type.Literal("off"),
+	Type.Literal("minimal"),
+	Type.Literal("low"),
+	Type.Literal("medium"),
+	Type.Literal("high"),
+	Type.Literal("xhigh")
+]);
+/** spec 10: exactly these two */
+const AuthMode = Type.Union([Type.Literal("subscription"), Type.Literal("api")]);
+/** A number exists only for a metered leg (authMode 'api'). NEVER 'not_applicable' for a metered leg (I8). */
+const MonetaryCost = Type.Union([Type.Literal("not_applicable"), Type.Object({
+	currency: Type.Literal("USD"),
+	amount: Type.Number({ minimum: 0 }),
+	basis: Type.Union([Type.Literal("catalogue"), Type.Literal("estimate")]),
+	priceCatalogVersion: Type.String()
+}, { additionalProperties: false })]);
+//#endregion
+//#region ../../packages/base/src/ports.ts
+const ok = (value) => ({
+	ok: true,
+	value
+});
+const err = (error) => ({
+	ok: false,
+	error
+});
+/** The wall clock. `sleep` rejects with `signal.reason` when aborted, and keeps the process alive while it waits. */
+const systemClock = Object.freeze({
+	now: () => toIsoInstant(Date.now()),
+	monotonicMs: () => performance.now(),
+	sleep: (ms, signal) => new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	})
+});
+/** What comes before the underscore of a generated id: `run`, `evt`, `cmd`, `apr`, `eff`, ... */
+const ID_PREFIX_PATTERN = "^[a-z][a-z0-9]{0,15}$";
+const idPrefix = new RegExp(ID_PREFIX_PATTERN);
+/** Shared by every IdSource so that the real one and the test one refuse the same prefixes. */
+function assertIdPrefix(prefix) {
+	if (typeof prefix !== "string" || !idPrefix.test(prefix)) throw new TypeError(`IdSource: invalid prefix ${JSON.stringify(prefix)} (expected ${ID_PREFIX_PATTERN})`);
+}
+const TAIL_LIMIT = 1n << 74n;
+const RAND_B_MASK = (1n << 62n) - 1n;
+const VARIANT = 2n << 62n;
+const MAX_TIMESTAMP = 2 ** 48 - 1;
+/**
+* The real IdSource: `<prefix>_<uuidv7 without dashes>`.
+*
+* Not `crypto.randomUUIDv7()`: that one draws all 74 random bits afresh, so two ids of the same millisecond come
+* out in random order (measured on Node 24.21: about half of consecutive pairs are inverted), and `@types/node` 24
+* does not declare it. Ids are event, command and effect keys: they must sort in minting order. This generator is
+* RFC 9562 method 2 (monotonic random): inside one millisecond, or while the wall clock stalls or steps back, the
+* 74-bit tail is INCREMENTED by a random step; when it would overflow, the timestamp moves one millisecond ahead.
+* Every id of one source is therefore strictly greater than the previous one, whatever its prefix.
+*/
+function createUuidV7IdSource(options = {}) {
+	const now = options.now ?? Date.now;
+	const random = options.random ?? ((bytes) => void randomFillSync(bytes));
+	const tailBytes = /* @__PURE__ */ new Uint8Array(10);
+	const stepBytes = /* @__PURE__ */ new Uint8Array(4);
+	let lastTimestamp = -1;
+	let tail = 0n;
+	const bigintOf = (bytes) => {
+		let value = 0n;
+		for (const byte of bytes) value = value << 8n | BigInt(byte);
+		return value;
+	};
+	const freshTail = () => {
+		random(tailBytes);
+		return bigintOf(tailBytes) & TAIL_LIMIT - 1n;
+	};
+	const nextHex = () => {
+		const wallClock = Math.min(Math.max(Math.trunc(now()), 0), MAX_TIMESTAMP);
+		if (wallClock > lastTimestamp) {
+			lastTimestamp = wallClock;
+			tail = freshTail();
+		} else {
+			random(stepBytes);
+			tail += 1n + bigintOf(stepBytes);
+			if (tail >= TAIL_LIMIT) {
+				lastTimestamp += 1;
+				tail = freshTail();
+			}
+		}
+		const randA = tail >> 62n;
+		const randB = tail & RAND_B_MASK;
+		return lastTimestamp.toString(16).padStart(12, "0") + "7" + randA.toString(16).padStart(3, "0") + (VARIANT | randB).toString(16).padStart(16, "0");
+	};
+	return { next(prefix) {
+		assertIdPrefix(prefix);
+		return `${prefix}_${nextHex()}`;
+	} };
+}
+const Redaction = Type.Object({
+	path: Type.String({ pattern: "^(?:/(?:[^/~]|~[01])*)*$" }),
+	reason: Type.Union([
+		Type.Literal("secret-value"),
+		Type.Literal("secret-pattern"),
+		Type.Literal("env-value"),
+		Type.Literal("private-key"),
+		Type.Literal("sensitive-path"),
+		Type.Literal("size")
+	]),
+	detector: Type.String(),
+	sha256: Type.Optional(Sha256)
+}, { additionalProperties: false });
+//#endregion
+//#region ../../packages/base/src/usage.ts
+const count = () => Type.Integer({ minimum: 0 });
+const TokenUsage = Type.Object({
+	input: count(),
+	output: count(),
+	cacheRead: count(),
+	cacheWrite: count(),
+	total: count()
+}, { additionalProperties: false });
+const QuotaWindow = Type.Object({
+	name: Type.String(),
+	usedPercent: Type.Optional(Type.Number({ minimum: 0 })),
+	resetsAt: Type.Optional(IsoInstant),
+	limitLabel: Type.Optional(Type.String())
+}, { additionalProperties: false });
+const QuotaInfo = Type.Union([Type.Object({ known: Type.Literal(false) }, { additionalProperties: false }), Type.Object({
+	known: Type.Literal(true),
+	source: Type.Union([Type.Literal("response-headers"), Type.Literal("error")]),
+	provider: Type.String(),
+	windows: Type.Array(QuotaWindow),
+	observedAt: IsoInstant
+}, { additionalProperties: false })]);
+/** Lives in base (not in the protocol vocabulary) because `security` (BudgetReader, 2.6.1) needs it and may not import `protocol`. `protocol` re-exports it. */
+const BudgetCounters = Type.Object({
+	tokens: Type.Optional(count()),
+	modelRequests: Type.Optional(count()),
+	toolCalls: Type.Optional(count()),
+	wallClockMs: Type.Optional(Type.Number({ minimum: 0 })),
+	retries: Type.Optional(count()),
+	fixRounds: Type.Optional(count()),
+	contextTokens: Type.Optional(count()),
+	concurrentAgents: Type.Optional(count()),
+	estimatedQuotaPercent: Type.Optional(Type.Number({ minimum: 0 }))
+}, { additionalProperties: false });
+//#endregion
+export { toIsoInstant as A, ErrorInfo as B, PhaseRunId as C, SurfaceId as D, SpecId as E, EXIT_CODE_BY_CLASS as F, isErrorCode as I, ERROR_CLASSES as L, NotImplemented as M, errorOf as N, ToolCallId as O, toErrorInfo as P, ERROR_CODE_PATTERN as R, IsoInstant as S, Sha256 as T, JsonValueSchema as V, CommandId as _, createUuidV7IdSource as a, FindingId as b, systemClock as c, ModelRef as d, MonetaryCost as f, ArtifactId as g, ApprovalId as h, Redaction as i, CohorteError as j, isSafeId as k, AuthMode as l, AgentId as m, QuotaInfo as n, err as o, ThinkingLevel as p, TokenUsage as r, ok as s, BudgetCounters as t, ModelCapability as u, EffectId as v, RunId as w, ID_PATTERN as x, EventId as y, ErrorClass as z };
+
+//# sourceMappingURL=src-Cu3TxNob.mjs.map