@kyo-so/cli 0.9.1 → 0.11.0

package/dist/index.js

@@ -169500,6 +169500,9 @@ function defineConfig(config) {
 // src/core/runReview.ts
 import { resolve as resolve6 } from "node:path";
 
+// src/config/schema.ts
+import { isAbsolute } from "node:path";
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -183776,8 +183779,19 @@ function date4(params) {
 
 // node_modules/zod/v4/classic/external.js
 config(en_default());
+// src/core/constants.ts
+var DEFAULT_AGENT_TIMEOUT_MS = 120000;
+var MAX_AGENT_OUTPUT_BYTES = 1048576;
+var JUDGE_MAX_OUTPUT_TOKENS = 4096;
+var RAW_OUTPUT_MAX_CHARS = 16384;
+var TRACE_DIR = ".kyoso/traces";
+var KYOSO_CHILD_AGENT = "KYOSO_CHILD_AGENT";
+
 // src/config/schema.ts
-var agentSchema = exports_external.object({
+var CODEX_OPENROUTER_PROVIDER = "openrouter";
+var CODEX_DEFAULT_PROVIDER = "default";
+var CODEX_OPENROUTER_MODEL_REQUIRED_ISSUE = "codex_openrouter_model_required";
+var baseAgentSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   type: exports_external.literal("acp").default("acp"),
   command: exports_external.string(),
@@ -183799,6 +183813,31 @@ var agentSchema = exports_external.object({
     envWhitelist: exports_external.array(exports_external.string())
   })
 });
+var codexAgentSchema = baseAgentSchema.extend({
+  provider: exports_external.enum([CODEX_OPENROUTER_PROVIDER, CODEX_DEFAULT_PROVIDER]).optional(),
+  allowProjectProvider: exports_external.array(exports_external.string().min(1).refine(isAbsolute, {
+    message: "must contain only absolute project directory paths for exact matching"
+  })).default([])
+}).superRefine((agent, context) => {
+  if (agent.provider !== CODEX_OPENROUTER_PROVIDER || (agent.model?.trim().length ?? 0) > 0) {
+    return;
+  }
+  context.addIssue({
+    code: exports_external.ZodIssueCode.custom,
+    path: ["model"],
+    message: 'model must be a non-empty string when provider is "openrouter".',
+    params: {
+      kyosoIssue: CODEX_OPENROUTER_MODEL_REQUIRED_ISSUE
+    }
+  });
+});
+var reviewBudgetSchema = exports_external.object({
+  maxModelCalls: exports_external.number().int().positive(),
+  maxTotalWallTimeMs: exports_external.number().int().positive(),
+  maxAgentOutputBytes: exports_external.number().int().positive().max(MAX_AGENT_OUTPUT_BYTES),
+  maxFindingsPerAgent: exports_external.number().int().positive(),
+  skipOptionalPhasesWhenTokenUsageUnknown: exports_external.boolean()
+});
 var kyosoConfigSchema = exports_external.object({
   entrypoints: exports_external.object({
     mcp: exports_external.boolean(),
@@ -183811,8 +183850,8 @@ var kyosoConfigSchema = exports_external.object({
     diffReview: exports_external.boolean()
   }),
   agents: exports_external.object({
-    codex: agentSchema,
-    claude: agentSchema
+    codex: codexAgentSchema,
+    claude: baseAgentSchema
   }),
   workspace: exports_external.object({
     mode: exports_external.literal("temp_snapshot"),
@@ -183856,6 +183895,7 @@ var kyosoConfigSchema = exports_external.object({
     timeoutMs: exports_external.number().int().positive().default(90000),
     allowDemotion: exports_external.boolean().default(false)
   }),
+  reviewBudget: reviewBudgetSchema,
   audit: exports_external.object({
     enabled: exports_external.boolean(),
     format: exports_external.literal("jsonl"),
@@ -183863,9 +183903,18 @@ var kyosoConfigSchema = exports_external.object({
     includeRawAgentOutput: exports_external.boolean(),
     includeFileContents: exports_external.boolean()
   })
+}).superRefine((config2, context) => {
+  const enabledPrimaryReviewers = Object.values(config2.agents).filter((agent) => agent.enabled).length;
+  if (config2.reviewBudget.maxModelCalls >= enabledPrimaryReviewers)
+    return;
+  context.addIssue({
+    code: exports_external.ZodIssueCode.custom,
+    path: ["reviewBudget", "maxModelCalls"],
+    message: "must be greater than or equal to the number of enabled primary reviewers."
+  });
 });
 function agentConfigLeafPaths(agent) {
-  return [
+  const paths = [
     `agents.${agent}.enabled`,
     `agents.${agent}.type`,
     `agents.${agent}.command`,
@@ -183881,6 +183930,10 @@ function agentConfigLeafPaths(agent) {
     `agents.${agent}.auth.recommendedEnv`,
     `agents.${agent}.auth.envWhitelist`
   ];
+  if (agent === "codex") {
+    paths.push("agents.codex.provider", "agents.codex.allowProjectProvider");
+  }
+  return paths;
 }
 var kyosoConfigKnownLeafPaths = [
   "entrypoints.mcp",
@@ -183917,6 +183970,11 @@ var kyosoConfigKnownLeafPaths = [
   "verification.maxFindings",
   "verification.timeoutMs",
   "verification.allowDemotion",
+  "reviewBudget.maxModelCalls",
+  "reviewBudget.maxTotalWallTimeMs",
+  "reviewBudget.maxAgentOutputBytes",
+  "reviewBudget.maxFindingsPerAgent",
+  "reviewBudget.skipOptionalPhasesWhenTokenUsageUnknown",
   "audit.enabled",
   "audit.format",
   "audit.directory",
@@ -183936,6 +183994,7 @@ var kyosoConfigSecuritySensitivePrefixes = [
   "secrets",
   "securityReview",
   "verification",
+  "reviewBudget",
   "workspace"
 ];
 
@@ -183956,6 +184015,7 @@ var defaultConfig = {
       args: ["-y", "@agentclientprotocol/codex-acp@1.1.2"],
       role: "implementation_reviewer",
       timeoutMs: 120000,
+      allowProjectProvider: [],
       env: {
         INITIAL_AGENT_MODE: "read-only",
         KYOSO_CHILD_AGENT: "1"
@@ -184048,7 +184108,7 @@ var defaultConfig = {
     }
   },
   judge: {
-    mode: "deterministic_plus_llm",
+    mode: "deterministic_only",
     provider: "auto",
     timeoutMs: 60000
   },
@@ -184058,6 +184118,13 @@ var defaultConfig = {
     timeoutMs: 90000,
     allowDemotion: false
   },
+  reviewBudget: {
+    maxModelCalls: 4,
+    maxTotalWallTimeMs: 480000,
+    maxAgentOutputBytes: 65536,
+    maxFindingsPerAgent: 10,
+    skipOptionalPhasesWhenTokenUsageUnknown: true
+  },
   audit: {
     enabled: true,
     format: "jsonl",
@@ -184068,17 +184135,21 @@ var defaultConfig = {
 };
 
 // src/config/loadConfig.ts
-import { access, readFile as readFile3 } from "node:fs/promises";
+import { access, readFile as readFile3, realpath } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { stderr, stdin } from "node:process";
-import { extname as extname2, join as join2, resolve as resolve2 } from "node:path";
+import { dirname as dirname3, extname as extname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // src/config/projectScope.ts
 var PROJECT_GLOBAL_ONLY_MESSAGE = "Move global-only settings to the user global config:";
+var PROJECT_GLOBAL_ONLY_REASONS = {
+  "agents.codex.allowProjectProvider": "must be a user-global exact project-directory allowlist"
+};
 var kyosoConfigOverridePaths = [
   "agents.codex.enabled",
   "agents.codex.model",
+  "agents.codex.provider",
   "agents.codex.effort",
   "agents.codex.role",
   "agents.codex.timeoutMs",
@@ -184118,6 +184189,11 @@ function collectProjectScopeViolations(config2) {
   const violations = [];
   for (const leaf of leaves) {
     const path = leaf.path.join(".");
+    const globalOnlyReason = projectGlobalOnlyReason(leaf.path);
+    if (globalOnlyReason) {
+      violations.push({ path, reason: globalOnlyReason });
+      continue;
+    }
     if (!isAllowedProjectPath(leaf.path)) {
       violations.push({ path });
       continue;
@@ -184128,6 +184204,15 @@ function collectProjectScopeViolations(config2) {
   }
   return violations.sort((left, right) => left.path.localeCompare(right.path));
 }
+function projectGlobalOnlyReason(path) {
+  const exactReason = PROJECT_GLOBAL_ONLY_REASONS[path.join(".")];
+  if (exactReason)
+    return exactReason;
+  if (path[0] === "reviewBudget") {
+    return "must be a user-global review budget ceiling";
+  }
+  return;
+}
 function isAllowedProjectPath(path) {
   const [top, second, third, fourth] = path;
   if (isAllowedConfigOverridePath(path))
@@ -184258,12 +184343,6 @@ function isRecord(value) {
 // src/security/redact.ts
 var REDACTION = "[KYOSO_REDACTED]";
 
-// src/core/constants.ts
-var DEFAULT_AGENT_TIMEOUT_MS = 120000;
-var RAW_OUTPUT_MAX_CHARS = 16384;
-var TRACE_DIR = ".kyoso/traces";
-var KYOSO_CHILD_AGENT = "KYOSO_CHILD_AGENT";
-
 // src/security/sanitizeText.ts
 var SENSITIVE_TEXT_PATTERNS = [
   /\bsk-(?:proj-)?[A-Za-z0-9_-]{8,}\b/g,
@@ -184278,7 +184357,7 @@ function sanitizeText(value) {
   return SENSITIVE_TEXT_PATTERNS.reduce((text, pattern) => text.replace(pattern, REDACTION), value);
 }
 function sanitizeTextForDisplay(value, maxChars = 240) {
-  const compact = sanitizeText(value).replace(/\s+/g, " ").trim();
+  const compact = sanitizeText(value).replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "").replace(/\s+/g, " ").trim();
   if (compact.length <= maxChars)
     return compact;
   return `${compact.slice(0, Math.max(0, maxChars - 3))}...`;
@@ -185322,6 +185401,25 @@ function isMissingPathError(error51) {
 }
 
 // src/config/loadConfig.ts
+var configValidationContexts = new WeakMap;
+class ProjectOpenRouterAuthorizationError extends Error {
+  code = "PROJECT_OPENROUTER_AUTHORIZATION_REQUIRED";
+  projectPath;
+  projectDirectory;
+  layer;
+  globalConfigPath;
+  constructor(input) {
+    const projectPath = sanitizeWarningText(input.projectPath);
+    const projectDirectory = sanitizeWarningText(input.projectDirectory);
+    const globalConfigPath = sanitizeWarningText(input.globalConfigPath);
+    super(`Project config ${projectPath} changes Codex OpenRouter routing, but its directory ${projectDirectory} is not in the user-global allowlist. Add ${JSON.stringify(projectDirectory)} to agents.codex.allowProjectProvider in ${globalConfigPath} to permit project-level external provider routing.`);
+    this.name = "ProjectOpenRouterAuthorizationError";
+    this.projectPath = projectPath;
+    this.projectDirectory = projectDirectory;
+    this.layer = input.layer;
+    this.globalConfigPath = globalConfigPath;
+  }
+}
 var KNOWN_GLOBAL_CONFIG_LEAF_PATHS = new Set(kyosoConfigKnownLeafPaths);
 var GLOBAL_CONFIG_RECORD_PREFIXES = kyosoConfigRecordPrefixes.map((path) => path.split("."));
 var SECURITY_SENSITIVE_GLOBAL_PREFIXES = kyosoConfigSecuritySensitivePrefixes.map((path) => path.split("."));
@@ -185349,11 +185447,12 @@ async function loadConfig(options = {}) {
     }
     if (options.configPath) {
       const explicitConfigPath = resolve2(cwd, options.configPath);
-      if (!await exists(explicitConfigPath)) {
+      const projectConfig = await resolveProjectConfigIdentity(explicitConfigPath);
+      if (!projectConfig) {
         throw new Error(`Config file not found: ${explicitConfigPath} (from --config)`);
       }
       const loaded = await loadProjectConfig({
-        configPath: explicitConfigPath,
+        projectConfig,
         baseConfig: mergedConfig,
         globalConfigPath,
         options
@@ -185367,19 +185466,29 @@ async function loadConfig(options = {}) {
     } else {
       const projectTomlPath = resolve2(cwd, "kyoso.toml");
       const projectTsPath = resolve2(cwd, "kyoso.config.ts");
-      const hasProjectToml = await exists(projectTomlPath);
-      const hasProjectTs = await exists(projectTsPath);
-      if (hasProjectToml) {
-        mergedConfig = mergeProjectTomlConfig(mergedConfig, await loadTomlConfigFile(projectTomlPath), { projectPath: projectTomlPath, globalConfigPath });
-        configPath = projectTomlPath;
-        sources.push({ path: projectTomlPath, layer: "project_toml" });
-        if (hasProjectTs) {
+      const projectToml = await resolveProjectConfigIdentity(projectTomlPath);
+      const projectTs = await resolveProjectConfigIdentity(projectTsPath);
+      if (projectToml) {
+        const loaded = await loadProjectConfig({
+          projectConfig: projectToml,
+          baseConfig: mergedConfig,
+          globalConfigPath,
+          options
+        });
+        mergedConfig = loaded.mergedConfig;
+        configPath = loaded.configPath;
+        configHash = loaded.configHash;
+        configTrustStatus = loaded.configTrustStatus;
+        sources.push(loaded.source);
+        warnings.push(...loaded.warnings);
+        if (projectTs) {
           warnings.push(`kyoso.config.ts was ignored because kyoso.toml takes precedence: ${projectTsPath}`);
         }
-      } else if (hasProjectTs) {
+      } else if (projectTs) {
         const loaded = await loadProjectTsConfig({
-          configPath: projectTsPath,
+          projectConfig: projectTs,
           baseConfig: mergedConfig,
+          globalConfigPath,
           options
         });
         mergedConfig = loaded.mergedConfig;
@@ -185391,9 +185500,17 @@ async function loadConfig(options = {}) {
       }
     }
   }
-  const parsed = kyosoConfigSchema.parse(mergedConfig);
+  const parsed = kyosoConfigSchema.safeParse(mergedConfig);
+  if (!parsed.success) {
+    const source = sources.at(-1);
+    configValidationContexts.set(parsed.error, {
+      source,
+      projectTsExecuted: source?.layer === "project_ts" && isTrustedProjectConfigExecution(configTrustStatus)
+    });
+    throw parsed.error;
+  }
   return {
-    config: parsed,
+    config: parsed.data,
     configPath,
     configHash,
     configTrustStatus,
@@ -185441,62 +185558,170 @@ function pathStartsWith(path, prefix) {
   return path.length >= prefix.length && prefix.every((part, index) => path[index] === part);
 }
 async function loadProjectConfig(input) {
-  const extension = extname2(input.configPath);
+  const { canonicalDirectory, canonicalPath, requestedPath } = input.projectConfig;
+  const extension = extname2(requestedPath);
   if (extension === ".toml") {
+    const projectTomlConfig = await loadTomlConfigFile(canonicalPath);
+    const projectChangesOpenRouterRoute = projectConfigChangesOpenRouterRoute(projectTomlConfig, input.baseConfig);
+    await assertProjectOpenRouterAuthorization({
+      projectConfig: projectTomlConfig,
+      projectPath: requestedPath,
+      projectDirectory: canonicalDirectory,
+      layer: "project_toml",
+      baseConfig: input.baseConfig,
+      globalConfigPath: input.globalConfigPath
+    });
+    const projectMergedConfig = mergeProjectTomlConfig(input.baseConfig, projectTomlConfig, {
+      projectPath: requestedPath,
+      globalConfigPath: input.globalConfigPath
+    });
     return {
-      mergedConfig: mergeProjectTomlConfig(input.baseConfig, await loadTomlConfigFile(input.configPath), {
-        projectPath: input.configPath,
-        globalConfigPath: input.globalConfigPath
-      }),
-      configPath: input.configPath,
+      mergedConfig: applyProjectCodexProviderReset(input.baseConfig, projectTomlConfig, projectMergedConfig),
+      configPath: requestedPath,
       configTrustStatus: "not_found",
-      source: { path: input.configPath, layer: "project_toml" },
-      warnings: []
+      source: { path: requestedPath, layer: "project_toml" },
+      warnings: projectChangesOpenRouterRoute ? [openRouterProjectConfigWarning(requestedPath)] : []
     };
   }
   if (extension === ".ts") {
     return await loadProjectTsConfig(input);
   }
-  throw new Error(`Unsupported config file extension for ${input.configPath}. Expected .toml or .ts.`);
+  throw new Error(`Unsupported config file extension for ${requestedPath}. Expected .toml or .ts.`);
+}
+function projectConfigSelectsOpenRouter(config2) {
+  return flattenLeaves(config2).some((leaf) => leaf.path.join(".") === "agents.codex.provider" && leaf.value === CODEX_OPENROUTER_PROVIDER);
+}
+function projectConfigSelectsDefaultProvider(config2) {
+  return flattenLeaves(config2).some((leaf) => leaf.path.join(".") === "agents.codex.provider" && leaf.value === CODEX_DEFAULT_PROVIDER);
+}
+function projectConfigSuppliesCodexModel(config2) {
+  return flattenLeaves(config2).some((leaf) => leaf.path.join(".") === "agents.codex.model");
+}
+function projectConfigChangesOpenRouterRoute(projectConfig, baseConfig) {
+  return projectConfigSelectsOpenRouter(projectConfig) || configSelectsOpenRouter(baseConfig) && projectConfigSuppliesCodexModel(projectConfig) && !projectConfigSelectsDefaultProvider(projectConfig);
+}
+function configSelectsOpenRouter(config2) {
+  return flattenLeaves(config2).some((leaf) => leaf.path.join(".") === "agents.codex.provider" && leaf.value === CODEX_OPENROUTER_PROVIDER);
+}
+function applyProjectCodexProviderReset(baseConfig, projectConfig, mergedConfig) {
+  if (!projectConfigSelectsDefaultProvider(projectConfig) || projectConfigSuppliesCodexModel(projectConfig) || !configSelectsOpenRouter(baseConfig) || !isRecord3(mergedConfig) || !isRecord3(mergedConfig.agents) || !isRecord3(mergedConfig.agents.codex)) {
+    return mergedConfig;
+  }
+  const codexWithoutInheritedModel = Object.fromEntries(Object.entries(mergedConfig.agents.codex).filter(([key]) => key !== "model"));
+  return {
+    ...mergedConfig,
+    agents: {
+      ...mergedConfig.agents,
+      codex: codexWithoutInheritedModel
+    }
+  };
+}
+function openRouterProjectConfigWarning(configPath) {
+  return `Project config ${sanitizeWarningText(configPath)} changes Codex OpenRouter routing under user-global authorization; it can route Codex review content through OpenRouter.`;
+}
+async function assertProjectOpenRouterAuthorization(input) {
+  if (!projectConfigChangesOpenRouterRoute(input.projectConfig, input.baseConfig)) {
+    return;
+  }
+  if (await projectProviderIsAuthorized(input.baseConfig, input.projectDirectory)) {
+    return;
+  }
+  throw new ProjectOpenRouterAuthorizationError({
+    projectPath: input.projectPath,
+    projectDirectory: input.projectDirectory,
+    layer: input.layer,
+    globalConfigPath: input.globalConfigPath
+  });
+}
+async function projectProviderIsAuthorized(config2, projectDirectory) {
+  if (!isRecord3(config2))
+    return false;
+  const agents = config2.agents;
+  if (!isRecord3(agents))
+    return false;
+  const codex = agents.codex;
+  if (!isRecord3(codex) || !Array.isArray(codex.allowProjectProvider)) {
+    return false;
+  }
+  for (const directory of codex.allowProjectProvider) {
+    if (typeof directory !== "string" || !isAbsolute2(directory))
+      continue;
+    const allowedDirectory = await existingRealpath(directory);
+    if (allowedDirectory === projectDirectory)
+      return true;
+  }
+  return false;
+}
+async function resolveProjectConfigIdentity(requestedPath) {
+  const canonicalPath = await existingRealpath(requestedPath);
+  return canonicalPath === undefined ? undefined : {
+    requestedPath,
+    canonicalPath,
+    canonicalDirectory: dirname3(canonicalPath)
+  };
+}
+async function existingRealpath(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return;
+  }
 }
 async function loadProjectTsConfig(input) {
+  const { canonicalDirectory, canonicalPath, requestedPath } = input.projectConfig;
   const warnings = [
     'kyoso.config.ts is deprecated; migrate to kyoso.toml (see README "Configuration")'
   ];
-  const source = await readFile3(input.configPath, "utf8");
+  const source = await readFile3(canonicalPath, "utf8");
   const configHash = hashConfigSource(source);
   const trustStorePath = input.options.trustStorePath ?? defaultTrustedConfigStorePath(input.options.env);
-  const trusted = await isTrustedConfig(trustStorePath, input.configPath, configHash);
+  const trusted = await isTrustedConfig(trustStorePath, canonicalPath, configHash);
   const trustDecision = await resolveTrustDecision({
-    configPath: input.configPath,
+    configPath: requestedPath,
     configHash,
     trusted,
     options: input.options
   });
   if (trustDecision.execute) {
-    const userConfig = await loadUserConfig(input.configPath, source);
+    const userConfig = await loadUserConfig(canonicalPath, source);
+    const projectChangesOpenRouterRoute = projectConfigChangesOpenRouterRoute(userConfig, input.baseConfig);
+    await assertProjectOpenRouterAuthorization({
+      projectConfig: userConfig,
+      projectPath: requestedPath,
+      projectDirectory: canonicalDirectory,
+      layer: "project_ts",
+      baseConfig: input.baseConfig,
+      globalConfigPath: input.globalConfigPath
+    });
     if (trustDecision.shouldPersist) {
-      await trustConfig(trustStorePath, input.configPath, configHash);
+      await trustConfig(trustStorePath, canonicalPath, configHash);
+    }
+    const projectMergedConfig = deepMerge2(input.baseConfig, userConfig);
+    if (projectChangesOpenRouterRoute) {
+      warnings.push(openRouterProjectConfigWarning(requestedPath));
     }
     return {
-      mergedConfig: deepMerge2(input.baseConfig, userConfig),
-      configPath: input.configPath,
+      mergedConfig: applyProjectCodexProviderReset(input.baseConfig, userConfig, projectMergedConfig),
+      configPath: requestedPath,
       configHash,
       configTrustStatus: trustDecision.status,
-      source: { path: input.configPath, layer: "project_ts" },
+      source: { path: requestedPath, layer: "project_ts" },
       warnings
     };
   }
-  warnings.push(`untrusted config was not executed: ${input.configPath}; run \`kyoso doctor --trust-config\` or pass \`--trust-config\` once to trust it`);
+  warnings.push(`untrusted config was not executed: ${requestedPath}; run \`kyoso doctor --trust-config\` or pass \`--trust-config\` once to trust it`);
   return {
     mergedConfig: input.baseConfig,
-    configPath: input.configPath,
+    configPath: requestedPath,
     configHash,
     configTrustStatus: trustDecision.status,
-    source: { path: input.configPath, layer: "project_ts" },
+    source: { path: requestedPath, layer: "project_ts" },
     warnings
   };
 }
+function isTrustedProjectConfigExecution(status) {
+  return status === "trusted" || status === "trusted_by_flag" || status === "trusted_interactively";
+}
 async function loadUserConfig(configPath, source) {
   try {
     const loaded = await loadConfigModule(configPath, source);
@@ -185575,6 +185800,8 @@ function applyConfigOverrides(config2, assignments) {
   for (const override of overrides) {
     writePath2(overridden, override.path, parseConfigOverrideValue(override.value, readPath2(baseConfig, override.path)));
   }
+  clearInheritedOpenRouterModelForProviderReset(baseConfig, overridden, overrides);
+  assertOpenRouterProviderOverrideIncludesModel(baseConfig, overridden, overrides);
   const parsed = kyosoConfigSchema.safeParse(overridden);
   if (parsed.success)
     return parsed.data;
@@ -185583,6 +185810,29 @@ function applyConfigOverrides(config2, assignments) {
   const assignment = findAssignmentForPath(overrides, issuePath) ?? assignments.at(-1) ?? "";
   throw new Error(`Invalid --set value ${JSON.stringify(assignment)}: ${issuePath}: ${issue2?.message ?? "config validation failed"}.`);
 }
+function assertOpenRouterProviderOverrideIncludesModel(baseConfig, overridden, overrides) {
+  const providerPath = ["agents", "codex", "provider"];
+  const modelPath = ["agents", "codex", "model"];
+  const selectsOpenRouter = readPath2(overridden, providerPath) === CODEX_OPENROUTER_PROVIDER;
+  const alreadySelected = readPath2(baseConfig, providerPath) === CODEX_OPENROUTER_PROVIDER;
+  const suppliesModel = overrides.some((override) => override.path.join(".") === modelPath.join("."));
+  if (!selectsOpenRouter || alreadySelected || suppliesModel)
+    return;
+  const assignment = findAssignmentForPath(overrides, providerPath.join(".")) ?? "agents.codex.provider=openrouter";
+  throw new Error(`Invalid --set value ${JSON.stringify(assignment)}: selecting agents.codex.provider=openrouter requires agents.codex.model in the same --set invocation.`);
+}
+function clearInheritedOpenRouterModelForProviderReset(baseConfig, overridden, overrides) {
+  const providerPath = ["agents", "codex", "provider"];
+  const modelPath = ["agents", "codex", "model"];
+  const selectsDefaultProvider = overrides.some((override) => override.path.join(".") === providerPath.join(".") && override.value === CODEX_DEFAULT_PROVIDER);
+  const suppliesModel = overrides.some((override) => override.path.join(".") === modelPath.join("."));
+  if (!selectsDefaultProvider || suppliesModel || readPath2(baseConfig, providerPath) !== CODEX_OPENROUTER_PROVIDER || readPath2(overridden, providerPath) !== CODEX_DEFAULT_PROVIDER) {
+    return;
+  }
+  const codex = readPath2(overridden, ["agents", "codex"]);
+  if (isRecord4(codex))
+    delete codex.model;
+}
 function findAssignmentForPath(overrides, path) {
   for (let index = overrides.length - 1;index >= 0; index -= 1) {
     const override = overrides[index];
@@ -185650,8 +185900,8 @@ function isRecord4(value) {
 
 // src/acp/AcpAgentProcess.ts
 import { spawn } from "node:child_process";
-import { readFile as readFile4, realpath } from "node:fs/promises";
-import { isAbsolute, relative, resolve as resolve3 } from "node:path";
+import { readFile as readFile4, realpath as realpath2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, relative, resolve as resolve3 } from "node:path";
 import { Readable, Writable } from "node:stream";
 
 // node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -189582,7 +189832,35 @@ var legacyClientNotificationMethods = new Set([
   CLIENT_METHODS.elicitation_complete
 ]);
 
+// src/core/tokenUsage.ts
+var TOKEN_USAGE_KEYS = [
+  "totalTokens",
+  "inputTokens",
+  "outputTokens",
+  "thoughtTokens",
+  "cachedReadTokens",
+  "cachedWriteTokens"
+];
+function normalizeModelTokenUsage(usage) {
+  if (!isRecord6(usage))
+    return;
+  const normalized = {};
+  for (const key of TOKEN_USAGE_KEYS) {
+    const value = usage[key];
+    if (isTokenCount(value))
+      normalized[key] = value;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function isTokenCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/utils/env.ts
+import { stderr as stderr2 } from "node:process";
 var MINIMAL_ENV_KEYS = [
   "PATH",
   "HOME",
@@ -189596,29 +189874,110 @@ var MINIMAL_ENV_KEYS = [
   "USERNAME",
   "SystemRoot"
 ];
+var CREDENTIAL_ENV_KEYS = new Set([
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CODEX_ACCESS_TOKEN",
+  "CODEX_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY"
+]);
+var CREDENTIAL_LIKE_ENV_KEY_PATTERN = /(?:^|_)(?:KEY|TOKEN|SECRET|PASSWORD)$/i;
+var UNEXPANDED_ENV_PLACEHOLDER_PATTERN = /^\s*(?:\$\{[A-Za-z_][A-Za-z0-9_]*\}|\$[A-Za-z_][A-Za-z0-9_]*|%[A-Za-z_][A-Za-z0-9_]*%)\s*$/;
+var OPENROUTER_EXCLUDED_CREDENTIAL_ENV_KEYS = [
+  "OPENAI_API_KEY",
+  "CODEX_API_KEY",
+  "CODEX_ACCESS_TOKEN"
+];
+var OPENROUTER_API_KEY_ENV = "OPENROUTER_API_KEY";
+var KYOSO_OPENROUTER_PROVIDER_ID = "kyoso-openrouter";
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+var OPENROUTER_PROVIDER_PRESET = {
+  name: "OpenRouter",
+  base_url: OPENROUTER_BASE_URL,
+  env_key: OPENROUTER_API_KEY_ENV,
+  wire_api: "responses",
+  requires_openai_auth: false
+};
+
+class ChildEnvPreflightError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChildEnvPreflightError";
+  }
+}
 function buildChildEnv(parentEnv, whitelist, explicit, options = {}) {
   if (!parentEnv.PATH) {
     throw new Error("PATH is required to launch ACP child agents.");
   }
   const env = {};
+  const warnedCredentialPlaceholderKeys = new Set;
+  const onCredentialPlaceholderDiscarded = (key) => {
+    if (warnedCredentialPlaceholderKeys.has(key))
+      return;
+    warnedCredentialPlaceholderKeys.add(key);
+    (options.onCredentialPlaceholderDiscarded ?? warnCredentialPlaceholderDiscarded)(key);
+  };
+  const openRouterSelected = options.agent === "codex" && options.provider === CODEX_OPENROUTER_PROVIDER;
   for (const key of MINIMAL_ENV_KEYS) {
     if (parentEnv[key])
       env[key] = parentEnv[key];
   }
   for (const key of whitelist) {
-    if (parentEnv[key])
+    if (key === OPENROUTER_API_KEY_ENV && !openRouterSelected)
+      continue;
+    if (parentEnv[key] && canCopyEnvValue(key, parentEnv[key], onCredentialPlaceholderDiscarded)) {
       env[key] = parentEnv[key];
+    }
   }
   for (const [key, value] of Object.entries(explicit)) {
-    env[key] = value;
+    if (key === OPENROUTER_API_KEY_ENV && !openRouterSelected) {
+      if (value.trim().length > 0) {
+        (options.onOpenRouterCredentialWithheld ?? warnOpenRouterCredentialWithheld)(key);
+      }
+      continue;
+    }
+    if (canCopyEnvValue(key, value, onCredentialPlaceholderDiscarded)) {
+      env[key] = value;
+    }
+  }
+  if (openRouterSelected) {
+    discardOpenRouterExcludedCredentials(env);
+    applyOpenRouterConfig(env, parentEnv, options.model, onCredentialPlaceholderDiscarded, options.onOpenRouterProvidersDiscarded ?? warnOpenRouterProvidersDiscarded);
+  } else {
+    applyModelConfig(env, options.agent, options.model);
   }
-  applyModelConfig(env, options.agent, options.model);
   env.KYOSO_CHILD_AGENT = "1";
   if (options.agent === "claude") {
     applyClaudeAuthPreference(env, options.preferApiKey === true);
   }
   return env;
 }
+function canCopyEnvValue(key, value, onCredentialPlaceholderDiscarded) {
+  if (!isUnexpandedCredentialEnvValue(key, value))
+    return true;
+  (onCredentialPlaceholderDiscarded ?? warnCredentialPlaceholderDiscarded)(key);
+  return false;
+}
+function warnCredentialPlaceholderDiscarded(key) {
+  stderr2.write(`kyoso: ignored an unexpanded credential placeholder for ${key}; ensure the client expands it before starting Kyoso.
+`);
+}
+function warnOpenRouterCredentialWithheld(key) {
+  stderr2.write(`kyoso: ignored explicit ${key} because the OpenRouter provider is not selected for this child.
+`);
+}
+function warnOpenRouterProvidersDiscarded(count) {
+  stderr2.write(`kyoso: discarded foreign CODEX_CONFIG.model_providers entries: ${count}; provider IDs and configuration values were not displayed.
+`);
+}
+function discardOpenRouterExcludedCredentials(env) {
+  for (const key of OPENROUTER_EXCLUDED_CREDENTIAL_ENV_KEYS) {
+    delete env[key];
+  }
+}
 function applyModelConfig(env, agent, model) {
   if (!model)
     return;
@@ -189630,7 +189989,67 @@ function applyModelConfig(env, agent, model) {
     env.CODEX_CONFIG = JSON.stringify({ model });
   }
 }
+function applyOpenRouterConfig(env, parentEnv, model, onCredentialPlaceholderDiscarded, onOpenRouterProvidersDiscarded) {
+  const configuredModel = model?.trim();
+  if (!configuredModel) {
+    throw new ChildEnvPreflightError("AGENT_CONFIG_INVALID", 'agents.codex.provider="openrouter" requires a non-empty agents.codex.model.');
+  }
+  if (!hasEnv(env, OPENROUTER_API_KEY_ENV)) {
+    const parentKey = nonEmptyEnv(parentEnv, OPENROUTER_API_KEY_ENV);
+    if (parentKey)
+      env[OPENROUTER_API_KEY_ENV] = parentKey;
+    else if (isUnexpandedCredentialEnvValue(OPENROUTER_API_KEY_ENV, parentEnv[OPENROUTER_API_KEY_ENV] ?? "")) {
+      onCredentialPlaceholderDiscarded(OPENROUTER_API_KEY_ENV);
+    }
+  }
+  if (!hasEnv(env, OPENROUTER_API_KEY_ENV)) {
+    throw new ChildEnvPreflightError("OPENROUTER_KEY_MISSING", 'agents.codex.provider="openrouter" requires OPENROUTER_API_KEY, but it is not visible to the Kyoso process. Add OPENROUTER_API_KEY to the MCP registration, restart the client, then run `kyoso doctor`.');
+  }
+  const config2 = parseCodexConfig(env.CODEX_CONFIG);
+  assertOpenRouterConfigDoesNotSelectProfile(config2);
+  if (config2.model_providers !== undefined && !isPlainObject2(config2.model_providers)) {
+    throw new ChildEnvPreflightError("AGENT_CONFIG_INVALID", "CODEX_CONFIG.model_providers must be a JSON object for the OpenRouter provider.");
+  }
+  reportDiscardedOpenRouterProviders(config2.model_providers, onOpenRouterProvidersDiscarded);
+  env.MODEL_PROVIDER = KYOSO_OPENROUTER_PROVIDER_ID;
+  env.CODEX_CONFIG = JSON.stringify({
+    ...config2,
+    model: configuredModel,
+    model_provider: KYOSO_OPENROUTER_PROVIDER_ID,
+    model_providers: {
+      [KYOSO_OPENROUTER_PROVIDER_ID]: OPENROUTER_PROVIDER_PRESET
+    }
+  });
+}
+function reportDiscardedOpenRouterProviders(modelProviders, onDiscarded) {
+  if (!isPlainObject2(modelProviders))
+    return;
+  const foreignProviderCount = Object.keys(modelProviders).filter((providerId) => providerId !== KYOSO_OPENROUTER_PROVIDER_ID).length;
+  if (foreignProviderCount > 0)
+    onDiscarded(foreignProviderCount);
+}
+function parseCodexConfig(value) {
+  if (!value)
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new ChildEnvPreflightError("AGENT_CONFIG_INVALID", "CODEX_CONFIG must contain a JSON object for the OpenRouter provider.");
+  }
+  if (!isPlainObject2(parsed)) {
+    throw new ChildEnvPreflightError("AGENT_CONFIG_INVALID", "CODEX_CONFIG must contain a JSON object for the OpenRouter provider.");
+  }
+  return parsed;
+}
+function assertOpenRouterConfigDoesNotSelectProfile(config2) {
+  if (Object.hasOwn(config2, "profile") || Object.hasOwn(config2, "profiles")) {
+    throw new ChildEnvPreflightError("AGENT_CONFIG_INVALID", "CODEX_CONFIG.profile and CODEX_CONFIG.profiles are not supported for the OpenRouter provider.");
+  }
+}
 function applyClaudeAuthPreference(env, preferApiKey) {
+  discardUnusableEnvValue(env, "ANTHROPIC_API_KEY");
+  discardUnusableEnvValue(env, "CLAUDE_CODE_OAUTH_TOKEN");
   const hasApiKey = hasEnv(env, "ANTHROPIC_API_KEY");
   const hasOAuthToken = hasEnv(env, "CLAUDE_CODE_OAUTH_TOKEN");
   if (!hasApiKey || !hasOAuthToken)
@@ -189641,8 +190060,32 @@ function applyClaudeAuthPreference(env, preferApiKey) {
     delete env.ANTHROPIC_API_KEY;
   }
 }
+function discardUnusableEnvValue(env, key) {
+  if (env[key] !== undefined && !hasEnv(env, key)) {
+    delete env[key];
+  }
+}
+function hasUsableEnvValue(env, key) {
+  return nonEmptyEnv(env, key) !== undefined;
+}
+function isUnexpandedEnvPlaceholder(value) {
+  return typeof value === "string" && UNEXPANDED_ENV_PLACEHOLDER_PATTERN.test(value);
+}
 function hasEnv(env, key) {
-  return typeof env[key] === "string" && env[key].trim().length > 0;
+  return hasUsableEnvValue(env, key);
+}
+function nonEmptyEnv(env, key) {
+  const value = env[key];
+  return typeof value === "string" && value.trim().length > 0 && !isUnexpandedCredentialEnvValue(key, value) ? value : undefined;
+}
+function isUnexpandedCredentialEnvValue(key, value) {
+  return (CREDENTIAL_ENV_KEYS.has(key) || CREDENTIAL_LIKE_ENV_KEY_PATTERN.test(key)) && isUnexpandedEnvPlaceholder(value);
+}
+function isPlainObject2(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return Object.getPrototypeOf(value) === Object.prototype;
 }
 
 // src/acp/AcpAgentManager.ts
@@ -189761,7 +190204,7 @@ function isSeverity(value) {
   return typeof value === "string" && severities.includes(value);
 }
 function normalizeCisaSecureByDesign(value) {
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     return;
   const normalized = {};
   const customerSecurityOutcomes = normalizeGateStatus(value.customerSecurityOutcomes);
@@ -189802,7 +190245,7 @@ function normalizeFindingFiles(value) {
   if (!Array.isArray(value))
     return;
   const files = value.flatMap((item) => {
-    if (!isRecord6(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
+    if (!isRecord7(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
       return [];
     }
     const file2 = {
@@ -189821,38 +190264,80 @@ function normalizeFindingFiles(value) {
 function normalizeLineNumber(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/acp/AcpAgentProcess.ts
 class SubprocessAcpAgentManager extends BaseAcpAgentManager {
   config;
-  constructor(config2) {
+  parentEnv;
+  constructor(config2, parentEnv = process.env) {
     super();
     this.config = config2;
+    this.parentEnv = parentEnv;
   }
   async runAgent(input) {
     const agentConfig = this.config.agents[input.agent];
+    const startedAt = new Date().toISOString();
     if (!agentConfig.enabled) {
       return {
         agent: input.agent,
         role: input.role,
         status: "skipped",
-        startedAt: new Date().toISOString(),
-        completedAt: new Date().toISOString()
+        startedAt,
+        completedAt: startedAt
+      };
+    }
+    const provider = input.agent === "codex" ? this.config.agents.codex.provider : undefined;
+    let env;
+    try {
+      env = buildChildEnv(this.parentEnv, agentConfig.auth.envWhitelist, agentConfig.env, {
+        agent: input.agent,
+        model: agentConfig.model,
+        provider,
+        preferApiKey: agentConfig.auth.preferApiKey
+      });
+    } catch (error51) {
+      return {
+        agent: input.agent,
+        role: input.role,
+        status: "failed",
+        startedAt,
+        completedAt: new Date().toISOString(),
+        error: buildPreflightFailure(error51)
+      };
+    }
+    try {
+      return await runSubprocessAgent(input.agent, agentConfig, input, env);
+    } catch (error51) {
+      return {
+        agent: input.agent,
+        role: input.role,
+        status: "failed",
+        startedAt,
+        completedAt: new Date().toISOString(),
+        error: buildAgentFailure(formatAgentErrorDetail(error51), "Agent process failed.")
       };
     }
-    return runSubprocessAgent(input.agent, agentConfig, input);
   }
 }
-async function runSubprocessAgent(agent, agentConfig, input) {
+async function runSubprocessAgent(agent, agentConfig, input, env) {
   const startedAt = new Date().toISOString();
-  const env = buildChildEnv(process.env, agentConfig.auth.envWhitelist, agentConfig.env, {
-    agent,
-    model: agentConfig.model,
-    preferApiKey: agentConfig.auth.preferApiKey
-  });
+  const effectiveTimeoutMs = resolveEffectiveTimeoutMs(input);
+  if (effectiveTimeoutMs <= 0) {
+    return {
+      agent,
+      role: input.role,
+      status: "timeout",
+      startedAt,
+      completedAt: startedAt,
+      error: {
+        code: "REVIEW_DEADLINE_EXCEEDED",
+        message: "Review deadline was reached before the agent could start."
+      }
+    };
+  }
   return new Promise((resolveResult) => {
     const child = spawn(agentConfig.command, agentConfig.args, {
       cwd: input.workspaceDir,
@@ -189860,19 +190345,28 @@ async function runSubprocessAgent(agent, agentConfig, input) {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";
-    let stderr2 = "";
+    let stderr3 = "";
     let settled = false;
+    let startedWrite;
+    child.once("spawn", () => {
+      if (settled)
+        return;
+      startedWrite = Promise.resolve().then(() => input.onStarted?.()).catch(() => {
+        return;
+      });
+    });
     const abortController = new AbortController;
     const resolveOnce = (result) => {
       if (settled)
         return;
       settled = true;
       clearTimeout(timeout);
-      resolveResult(result);
+      (startedWrite ?? Promise.resolve()).then(() => resolveResult(result));
     };
     const timeout = setTimeout(() => {
       abortController.abort(new Error("Kyoso agent timeout"));
       terminateChild(child);
+      const deadlineReached = input.deadlineAtEpochMs !== undefined && Date.now() >= input.deadlineAtEpochMs;
       resolveOnce({
         agent,
         role: input.role,
@@ -189880,13 +190374,13 @@ async function runSubprocessAgent(agent, agentConfig, input) {
         startedAt,
         completedAt: new Date().toISOString(),
         error: {
-          code: "AGENT_TIMEOUT",
-          message: `Agent timed out after ${input.timeoutMs}ms`
+          code: deadlineReached ? "REVIEW_DEADLINE_EXCEEDED" : "AGENT_TIMEOUT",
+          message: deadlineReached ? "Review deadline reached before the agent completed." : `Agent timed out after ${effectiveTimeoutMs}ms`
         }
       });
-    }, input.timeoutMs);
+    }, effectiveTimeoutMs);
     child.stderr.on("data", (chunk) => {
-      stderr2 += chunk.toString("utf8");
+      stderr3 += chunk.toString("utf8");
     });
     child.on("error", (error51) => {
       const failure = buildAgentFailure(error51.message, "Agent process could not be started.");
@@ -189900,22 +190394,51 @@ async function runSubprocessAgent(agent, agentConfig, input) {
         error: failure
       });
     });
-    runAcpClientWorkflow(child, input, abortController.signal, resolveEffortConfigOption(agent, agentConfig.effort)).then(({ rawText, warnings }) => {
+    runAcpClientWorkflow(child, input, abortController, resolveEffortConfigOption(agent, agentConfig.effort)).then(({ rawText, warnings, usage, outputBytes, stopReason }) => {
       stdout = rawText;
+      const completed = stopReason === "end_turn";
       resolveOnce({
         agent,
         role: input.role,
-        status: "completed",
+        status: completed ? "completed" : "failed",
         rawText,
         normalized: normalizeAgentOutput(agent, input.role, rawText),
         startedAt,
         completedAt: new Date().toISOString(),
-        ...warnings.length > 0 ? { warnings } : {}
+        outputBytes,
+        stopReason,
+        ...usage ? { usage } : {},
+        ...warnings.length > 0 ? { warnings } : {},
+        ...completed ? {} : {
+          error: {
+            code: "AGENT_STOPPED_EARLY",
+            message: `Agent stopped before completing the review: ${stopReason}.`
+          }
+        }
       });
     }).catch((error51) => {
+      const outputLimitError = findOutputLimitError(error51, abortController);
+      if (outputLimitError) {
+        stdout = outputLimitError.rawText;
+        resolveOnce({
+          agent,
+          role: input.role,
+          status: "failed",
+          rawText: stdout,
+          outputBytes: outputLimitError.outputBytes,
+          stopReason: "cancelled",
+          startedAt,
+          completedAt: new Date().toISOString(),
+          error: {
+            code: "AGENT_OUTPUT_LIMIT",
+            message: `Agent output exceeded ${outputLimitError.maxOutputBytes} bytes and was cancelled.`
+          }
+        });
+        return;
+      }
       if (abortController.signal.aborted)
         return;
-      const failureText = [stderr2, formatAgentErrorDetail(error51)].filter((part) => part.trim().length > 0).join(`
+      const failureText = [stderr3, formatAgentErrorDetail(error51)].filter((part) => part.trim().length > 0).join(`
 `);
       resolveOnce({
         agent,
@@ -189940,12 +190463,12 @@ async function runSubprocessAgent(agent, agentConfig, input) {
         rawText: stdout,
         startedAt,
         completedAt: new Date().toISOString(),
-        error: buildAgentFailure(stderr2, fallback)
+        error: buildAgentFailure(stderr3, fallback)
       });
     });
   });
 }
-async function runAcpClientWorkflow(child, input, signal, configOption) {
+async function runAcpClientWorkflow(child, input, abortController, configOption) {
   if (!child.stdin || !child.stdout) {
     throw new Error("Agent process did not expose stdio streams.");
   }
@@ -189995,8 +190518,8 @@ async function runAcpClientWorkflow(child, input, signal, configOption) {
     }).withSession(async (session) => {
       const warnings = [];
       if (configOption) {
-        await ctx.request(methods.agent.session.setConfigOption, { sessionId: session.sessionId, ...configOption }, { cancellationSignal: signal }).catch((error51) => {
-          if (signal.aborted)
+        await ctx.request(methods.agent.session.setConfigOption, { sessionId: session.sessionId, ...configOption }, { cancellationSignal: abortController.signal }).catch((error51) => {
+          if (abortController.signal.aborted)
             return;
           const sanitizedValue = sanitizeTextForDisplay(configOption.value);
           const detail = sanitizeTextForDisplay(formatAgentErrorDetail(error51));
@@ -190006,14 +190529,75 @@ async function runAcpClientWorkflow(child, input, signal, configOption) {
         });
       }
       const promptResponse = session.prompt(input.prompt, {
-        cancellationSignal: signal
+        cancellationSignal: abortController.signal
+      });
+      promptResponse.catch(() => {
+        return;
       });
-      const text = await session.readText();
-      await promptResponse;
-      return { rawText: text, warnings };
+      let rawText = "";
+      let outputBytes = 0;
+      for (;; ) {
+        const message = await session.nextUpdate();
+        if (message.kind === "stop") {
+          const usage = normalizeUsage(message.response.usage);
+          return {
+            rawText,
+            warnings,
+            ...usage ? { usage } : {},
+            outputBytes,
+            stopReason: message.stopReason
+          };
+        }
+        const update = message.update;
+        if (update.sessionUpdate !== "agent_message_chunk" && update.sessionUpdate !== "agent_thought_chunk" || update.content.type !== "text") {
+          continue;
+        }
+        const chunkBytes = Buffer.byteLength(update.content.text, "utf8");
+        const nextOutputBytes = outputBytes + chunkBytes;
+        if (input.maxOutputBytes !== undefined && nextOutputBytes > input.maxOutputBytes) {
+          await ctx.notify(methods.agent.session.cancel, {
+            sessionId: session.sessionId
+          }).catch(() => {
+            return;
+          });
+          const error51 = new AgentOutputLimitError(rawText, nextOutputBytes, input.maxOutputBytes);
+          abortController.abort(error51);
+          throw error51;
+        }
+        if (update.sessionUpdate === "agent_message_chunk") {
+          rawText += update.content.text;
+        }
+        outputBytes = nextOutputBytes;
+      }
     });
   });
 }
+
+class AgentOutputLimitError extends Error {
+  rawText;
+  outputBytes;
+  maxOutputBytes;
+  constructor(rawText, outputBytes, maxOutputBytes) {
+    super(`Agent output exceeded ${maxOutputBytes} bytes.`);
+    this.rawText = rawText;
+    this.outputBytes = outputBytes;
+    this.maxOutputBytes = maxOutputBytes;
+    this.name = "AgentOutputLimitError";
+  }
+}
+function findOutputLimitError(error51, abortController) {
+  if (error51 instanceof AgentOutputLimitError)
+    return error51;
+  const reason = abortController.signal.reason;
+  return reason instanceof AgentOutputLimitError ? reason : undefined;
+}
+function resolveEffectiveTimeoutMs(input) {
+  const deadlineRemaining = input.deadlineAtEpochMs === undefined ? Number.POSITIVE_INFINITY : input.deadlineAtEpochMs - Date.now();
+  return Math.max(0, Math.min(input.timeoutMs, deadlineRemaining));
+}
+function normalizeUsage(usage) {
+  return normalizeModelTokenUsage(usage);
+}
 function resolveEffortConfigOption(agent, effort) {
   if (!effort)
     return;
@@ -190024,7 +190608,7 @@ function resolveEffortConfigOption(agent, effort) {
   return;
 }
 async function readWorkspaceFile(workspaceDir, requestedPath, line, limit) {
-  const workspaceRoot = await realpath(workspaceDir);
+  const workspaceRoot = await realpath2(workspaceDir);
   const candidates = resolveReadablePaths(workspaceRoot, requestedPath);
   let content;
   for (const absolute of candidates) {
@@ -190047,7 +190631,7 @@ async function readWorkspaceFile(workspaceDir, requestedPath, line, limit) {
 `);
 }
 async function resolveReadableFile(workspaceRoot, absolute) {
-  const realPath = await realpath(absolute).catch((error51) => {
+  const realPath = await realpath2(absolute).catch((error51) => {
     if (isMissingPathError2(error51))
       return;
     throw error51;
@@ -190066,7 +190650,7 @@ function resolveReadablePaths(workspaceRoot, requestedPath) {
   }
   const repoPath = resolve3(workspaceRoot, "repo", relativePath);
   assertWithinWorkspace(workspaceRoot, repoPath);
-  return isAbsolute(requestedPath) ? [primary, repoPath] : [repoPath, primary];
+  return isAbsolute3(requestedPath) ? [primary, repoPath] : [repoPath, primary];
 }
 function assertWithinWorkspace(workspaceRoot, absolute) {
   const relativePath = relative(workspaceRoot, absolute);
@@ -190098,6 +190682,20 @@ function buildAgentFailure(rawDetail, fallbackMessage) {
     ...detail ? { detail } : {}
   };
 }
+function buildPreflightFailure(error51) {
+  if (error51 instanceof ChildEnvPreflightError) {
+    return {
+      code: error51.code,
+      message: error51.message
+    };
+  }
+  const detail = sanitizeTextForDisplay(formatAgentErrorDetail(error51));
+  return {
+    code: "AGENT_CONFIG_INVALID",
+    message: "Agent configuration is invalid. Run kyoso doctor and check agent configuration.",
+    ...detail ? { detail } : {}
+  };
+}
 function safeAgentFailureMessage(code, fallbackMessage) {
   if (code === "AUTH_FAILED") {
     return "Agent authentication failed. Run kyoso doctor and check configured credentials.";
@@ -190113,15 +190711,15 @@ function safeAgentFailureMessage(code, fallbackMessage) {
   }
   return sanitizeTextForDisplay(fallbackMessage);
 }
-function classifyAgentFailure(stderr2) {
-  if (/spawn/i.test(stderr2))
+function classifyAgentFailure(stderr3) {
+  if (/spawn/i.test(stderr3))
     return "AGENT_SPAWN_FAILED";
-  if (/ENOTFOUND|ENOTCACHED|ECONNREFUSED|ETIMEDOUT|registry\.npmjs\.org|network request|cache mode/i.test(stderr2)) {
+  if (/ENOTFOUND|ENOTCACHED|ECONNREFUSED|ETIMEDOUT|registry\.npmjs\.org|network request|cache mode/i.test(stderr3)) {
     return "AGENT_NETWORK_FAILED";
   }
-  if (/auth|api key|login|credential/i.test(stderr2))
+  if (/auth|api key|login|credential/i.test(stderr3))
     return "AUTH_FAILED";
-  if (/permission|policy|write|terminal/i.test(stderr2))
+  if (/permission|policy|write|terminal/i.test(stderr3))
     return "PERMISSION_DENIED";
   return "AGENT_FAILED";
 }
@@ -190158,9 +190756,24 @@ class FakeAgentManager extends BaseAcpAgentManager {
     this.calls.push(input);
     const startedAt = new Date().toISOString();
     if (input.role === "finding_verifier") {
+      await input.onStarted?.();
       return verifierResult(input, startedAt, this.verifierScenarios[input.agent] ?? "confirmed");
     }
     const scenario = this.scenarios[input.agent] ?? "success";
+    if (scenario === "preflight_failure" || scenario === "openrouter_key_missing") {
+      return {
+        agent: input.agent,
+        role: input.role,
+        status: "failed",
+        startedAt,
+        completedAt: new Date().toISOString(),
+        error: {
+          code: scenario === "openrouter_key_missing" ? "OPENROUTER_KEY_MISSING" : "AGENT_CONFIG_INVALID",
+          message: scenario === "openrouter_key_missing" ? "Fake OpenRouter key is missing." : "Fake agent configuration is invalid."
+        }
+      };
+    }
+    await input.onStarted?.();
     if (scenario === "timeout") {
       return {
         agent: input.agent,
@@ -190206,9 +190819,10 @@ ${JSON.stringify(opinion)}
       role: input.role,
       status: "completed",
       rawText,
-      normalized: scenario === "success" ? opinion : undefined,
+      normalized: scenario === "success" || scenario === "unknown_usage" ? opinion : undefined,
       startedAt,
-      completedAt: new Date().toISOString()
+      completedAt: new Date().toISOString(),
+      ...scenario === "unknown_usage" ? {} : { usage: fakeUsage() }
     };
   }
 }
@@ -190242,9 +190856,13 @@ function verifierResult(input, startedAt, scenario) {
     status: "completed",
     rawText,
     startedAt,
-    completedAt: new Date().toISOString()
+    completedAt: new Date().toISOString(),
+    usage: fakeUsage()
   };
 }
+function fakeUsage() {
+  return { totalTokens: 20, inputTokens: 12, outputTokens: 8 };
+}
 function findingIdsFromPrompt(prompt) {
   return Array.from(prompt.matchAll(/^Finding ID: (.+)$/gm)).map((match) => match[1] ?? "");
 }
@@ -190784,8 +191402,8 @@ function normalizeTitle(value) {
 
 // src/audit/stateRoot.ts
 import { createHash as createHash2 } from "node:crypto";
-import { lstat, mkdir as mkdir2, realpath as realpath2 } from "node:fs/promises";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join3, resolve as resolve5 } from "node:path";
+import { lstat, mkdir as mkdir2, realpath as realpath3 } from "node:fs/promises";
+import { basename, dirname as dirname4, isAbsolute as isAbsolute4, join as join3, resolve as resolve5 } from "node:path";
 
 // src/context/pathPolicy.ts
 import { normalize, sep } from "node:path";
@@ -190876,7 +191494,7 @@ async function resolveAuditStateRoot(options) {
     return { warnings: [...warnings, AUDIT_WARNING_UNSUPPORTED_CAPABILITY] };
   }
   try {
-    const workspaceRoot = await realpath2(resolve5(options.cwd));
+    const workspaceRoot = await realpath3(resolve5(options.cwd));
     const candidate = resolveStateBaseCandidate(options.env ?? process.env);
     if (!candidate)
       throw new Error("missing trusted state base");
@@ -190905,7 +191523,7 @@ async function resolveAuditStateRoot(options) {
   }
 }
 async function ensureTrustedDirectory(options) {
-  const realRoot = await realpath2(options.root);
+  const realRoot = await realpath3(options.root);
   assertSafeDirectory(realRoot, options.uid, await lstat(realRoot));
   if (options.workspaceRoot && isPathWithin(realRoot, options.workspaceRoot)) {
     throw new Error("trusted directory resolves inside workspace");
@@ -190922,7 +191540,7 @@ async function ensureTrustedDirectory(options) {
       entry = await lstat(next);
     }
     assertSafeDirectory(next, options.uid, entry);
-    const realNext = await realpath2(next);
+    const realNext = await realpath3(next);
     if (!isPathWithin(realNext, realRoot)) {
       throw new Error("managed directory escaped trusted root");
     }
@@ -190938,7 +191556,7 @@ function isResolvedAuditStateRoot(resolution) {
 }
 function validateAuditDirectory(directory, warnings) {
   try {
-    if (directory.trim().length === 0 || isAbsolute2(directory) || directory.split(/[\\/]+/).includes("..")) {
+    if (directory.trim().length === 0 || isAbsolute4(directory) || directory.split(/[\\/]+/).includes("..")) {
       throw new Error("unsafe logical directory");
     }
     const normalized = normalizeRelativePath(directory);
@@ -190953,11 +191571,11 @@ function validateAuditDirectory(directory, warnings) {
 }
 function resolveStateBaseCandidate(env) {
   const xdgStateHome = env.XDG_STATE_HOME?.trim();
-  if (xdgStateHome && isAbsolute2(xdgStateHome)) {
+  if (xdgStateHome && isAbsolute4(xdgStateHome)) {
     return resolve5(xdgStateHome);
   }
   const home = env.HOME?.trim();
-  if (!home || !isAbsolute2(home))
+  if (!home || !isAbsolute4(home))
     return;
   return join3(resolve5(home), ".local", "state");
 }
@@ -190969,7 +191587,7 @@ async function ensureTrustedStateBase(options) {
   assertSafeDirectory(existing.path, options.uid, await lstat(existing.path), {
     allowFilesystemRoot: true
   });
-  const realExisting = await realpath2(existing.path);
+  const realExisting = await realpath3(existing.path);
   if (isPathWithin(realExisting, options.workspaceRoot)) {
     throw new Error("state base resolves inside workspace");
   }
@@ -190980,7 +191598,7 @@ async function ensureTrustedStateBase(options) {
     await createDirectory(current);
     const entry = await lstat(current);
     assertSafeDirectory(current, options.uid, entry);
-    const realCurrent = await realpath2(current);
+    const realCurrent = await realpath3(current);
     if (!isPathWithin(realCurrent, realExisting)) {
       throw new Error("state base changed while being created");
     }
@@ -190989,7 +191607,7 @@ async function ensureTrustedStateBase(options) {
     }
     current = realCurrent;
   }
-  const stateBase = await realpath2(current);
+  const stateBase = await realpath3(current);
   assertSafeDirectory(stateBase, options.uid, await lstat(stateBase));
   if (isPathWithin(stateBase, options.workspaceRoot)) {
     throw new Error("state base resolves inside workspace");
@@ -191008,7 +191626,7 @@ async function findExistingAncestor(candidate) {
       }
       return { path: current, missingSegments };
     }
-    const parent = dirname3(current);
+    const parent = dirname4(current);
     if (parent === current)
       throw new Error("state base has no existing ancestor");
     missingSegments.unshift(basename(current));
@@ -191041,12 +191659,12 @@ function getCurrentUid(getuid) {
   }
 }
 function isFilesystemRoot(path) {
-  return dirname3(path) === path;
+  return dirname4(path) === path;
 }
 async function assertTrustedAncestorChain(path, uid) {
   let child = path;
   while (!isFilesystemRoot(child)) {
-    const parent = dirname3(child);
+    const parent = dirname4(child);
     const [parentStat, childStat] = await Promise.all([
       lstat(parent),
       lstat(child)
@@ -191094,7 +191712,7 @@ function isAlreadyExistsError(error51) {
 
 // src/audit/safeTraceFile.ts
 import { constants } from "node:fs";
-import { lstat as lstat2, open, realpath as realpath3, stat } from "node:fs/promises";
+import { lstat as lstat2, open, realpath as realpath4, stat } from "node:fs/promises";
 import { join as join4 } from "node:path";
 var AUDIT_WARNING_UNSUPPORTED_OPEN_CAPABILITY = "AUDIT_DISABLED_UNSUPPORTED_CAPABILITY: Audit trace writing requires unavailable filesystem capabilities.";
 async function openVerifiedTraceFile(options) {
@@ -191124,7 +191742,7 @@ async function openVerifiedTraceFile(options) {
     const [handleStat, pathStat, realTracePath] = await Promise.all([
       handle.stat({ bigint: true }),
       stat(tracePath, { bigint: true }),
-      realpath3(tracePath)
+      realpath4(tracePath)
     ]);
     if (!handleStat.isFile() || !pathStat.isFile() || handleStat.dev !== pathStat.dev || handleStat.ino !== pathStat.ino || !isPathWithin(realTracePath, options.kyosoRoot)) {
       throw new Error("trace file identity could not be verified");
@@ -191167,6 +191785,16 @@ async function optionalLstat2(path) {
 }
 
 // src/audit/sanitize.ts
+var USAGE_METADATA_KEYS = new Set([
+  "tokenUsage",
+  "totalTokens",
+  "inputTokens",
+  "outputTokens",
+  "thoughtTokens",
+  "cachedReadTokens",
+  "cachedWriteTokens",
+  "skipOptionalPhasesWhenTokenUsageUnknown"
+]);
 function sanitizeForAudit(value, options = {}) {
   if (typeof value === "string")
     return sanitizeText(value);
@@ -191175,7 +191803,7 @@ function sanitizeForAudit(value, options = {}) {
   if (typeof value === "object" && value !== null) {
     const result = {};
     for (const [key, nested] of Object.entries(value)) {
-      if (/raw|content|env|credential|token|secret|password/i.test(key) && !(options.includeRawAgentOutput && key === "rawText")) {
+      if (/raw|content|env|credential|token|secret|password/i.test(key) && !(options.includeRawAgentOutput && key === "rawText") && !isUsageMetadata(key, nested)) {
         continue;
       }
       result[key] = sanitizeForAudit(nested, options);
@@ -191184,6 +191812,17 @@ function sanitizeForAudit(value, options = {}) {
   }
   return value;
 }
+function isUsageMetadata(key, value) {
+  if (!USAGE_METADATA_KEYS.has(key))
+    return false;
+  if (key === "tokenUsage") {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  if (key === "skipOptionalPhasesWhenTokenUsageUnknown") {
+    return typeof value === "boolean";
+  }
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
 
 // src/audit/trace.ts
 var AUDIT_WARNING_WRITE_FAILED = "AUDIT_WRITE_FAILED: Audit trace writing failed; no further audit events will be written.";
@@ -191449,6 +192088,8 @@ function renderMarkdownResult(tool, result, options = {}) {
     "",
     `**Decision:** ${result.decision}`,
     `**Mode:** ${tool}`,
+    `**Completion:** ${formatCompletion(result)}`,
+    `**Request fingerprint:** ${shortFingerprint(result.requestFingerprint)}`,
     `**Agents:** ${result.agentOpinions.map((opinion) => `${title(opinion.agent)} ${opinion.status}`).join(", ")}`,
     `**Review mode:** ${formatReviewMode(result)}`,
     ...result.verificationMode ? [
@@ -191460,6 +192101,7 @@ function renderMarkdownResult(tool, result, options = {}) {
     "",
     options.summaryText ?? defaultSummaryText(result)
   ];
+  lines.push(...formatExecutionBudget(result));
   if (result.cisaSecureByDesign) {
     lines.push("", "## CISA Secure by Design Gate", "", "| Dimension | Status | Notes |", "|---|---|---|", `| Customer Security Outcomes | ${result.cisaSecureByDesign.customerSecurityOutcomes} | ${notes(result.cisaSecureByDesign.notes)} |`, `| Secure by Default | ${result.cisaSecureByDesign.secureByDefault} | ${notes(result.cisaSecureByDesign.notes)} |`, `| Transparency & Accountability | ${result.cisaSecureByDesign.transparencyAndAccountability} | ${notes(result.cisaSecureByDesign.notes)} |`, `| Governance | ${result.cisaSecureByDesign.governance} | ${notes(result.cisaSecureByDesign.notes)} |`);
   }
@@ -191512,8 +192154,37 @@ function renderMarkdownResult(tool, result, options = {}) {
 `);
 }
 function defaultSummaryText(result) {
+  if (result.completion.status === "incomplete") {
+    const reasons = result.completion.reasons.length > 0 ? result.completion.reasons.join(", ") : "unspecified coverage gap";
+    return `Review incomplete (${reasons}). Decision is block because review coverage is incomplete, not because a code finding was established.`;
+  }
   return result.findings.length === 0 ? "No blocking findings were detected from the supplied context." : `${result.findings.length} finding(s) require attention.`;
 }
+function formatExecutionBudget(result) {
+  const budget = result.executionBudget;
+  const agentOutputs = Object.entries(budget.agentOutputBytes);
+  const outputLines = agentOutputs.length > 0 ? agentOutputs.map(([agent, bytes]) => `- ${title(agent)}: ${bytes} bytes`) : ["- None reported."];
+  const totalTokens = budget.tokenUsage.totals.totalTokens;
+  return [
+    "",
+    "## Execution Budget",
+    "",
+    `- Model calls: ${budget.modelCalls.planned} planned / ${budget.modelCalls.consumed} consumed / ${budget.modelCalls.skipped} skipped`,
+    `- Wall time: ${budget.wallTime.consumedMs}ms consumed / ${budget.wallTime.limitMs}ms limit`,
+    `- Token usage: ${budget.tokenUsage.status} (${budget.tokenUsage.reportedCalls} reported, ${budget.tokenUsage.unknownCalls} unknown${totalTokens === undefined ? "" : `, ${totalTokens} total`})`,
+    "- Agent output:",
+    ...outputLines
+  ];
+}
+function formatCompletion(result) {
+  if (result.completion.status === "complete")
+    return "complete";
+  const reasons = result.completion.reasons.join(", ") || "unspecified";
+  return `incomplete (${reasons}; retryable=${String(result.completion.retryable)})`;
+}
+function shortFingerprint(value) {
+  return value.length <= 20 ? value : `${value.slice(0, 20)}…`;
+}
 function title(value) {
   return value.slice(0, 1).toUpperCase() + value.slice(1);
 }
@@ -191602,7 +192273,7 @@ function parseJudgeOutput(text, fallbackSummaryText) {
   const parsed = JSON.parse(json2);
   const summaryText = typeof parsed.summaryText === "string" && parsed.summaryText.trim().length > 0 ? sanitizeText(parsed.summaryText) : fallbackSummaryText;
   const disagreementComments = Array.isArray(parsed.disagreementComments) ? parsed.disagreementComments.flatMap((item) => {
-    if (!isRecord7(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
+    if (!isRecord8(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
       return [];
     }
     return [
@@ -191618,7 +192289,7 @@ function parseJudgeOutput(text, fallbackSummaryText) {
   return { summaryText, disagreementComments, analysis };
 }
 function parseAnalysis(value) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return;
   if (!Array.isArray(value.blindSpots) || !Array.isArray(value.contradictions) || !Array.isArray(value.partialCoverage)) {
     return;
@@ -191626,7 +192297,7 @@ function parseAnalysis(value) {
   return {
     blindSpots: value.blindSpots.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => typeof item === "string" ? [sanitizeAnalysisText(item)] : []),
     contradictions: value.contradictions.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => {
-      if (!isRecord7(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
+      if (!isRecord8(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
         return [];
       }
       return [
@@ -191637,7 +192308,7 @@ function parseAnalysis(value) {
       ];
     }),
     partialCoverage: value.partialCoverage.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => {
-      if (!isRecord7(item) || typeof item.note !== "string")
+      if (!isRecord8(item) || typeof item.note !== "string")
         return [];
       const findingId = typeof item.findingId === "string" ? sanitizeAnalysisText(item.findingId) : undefined;
       return [
@@ -191684,7 +192355,7 @@ function extractFirstJsonObject2(text) {
   }
   return;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -191702,7 +192373,7 @@ async function runAnthropicJudge(input, timeoutMs) {
     },
     body: JSON.stringify({
       model: input.env.KYOSO_ANTHROPIC_JUDGE_MODEL ?? "claude-haiku-4-5",
-      max_tokens: 4096,
+      max_tokens: JUDGE_MAX_OUTPUT_TOKENS,
       temperature: 0,
       messages: [
         {
@@ -191718,7 +192389,21 @@ async function runAnthropicJudge(input, timeoutMs) {
   const content = payload.content?.find((item) => item.type === "text" && item.text)?.text;
   if (!content)
     throw new Error("Anthropic judge response did not include text content.");
-  return parseJudgeOutput(content, input.summaryText);
+  const usage = normalizeUsage2(payload.usage);
+  return {
+    output: parseJudgeOutput(content, input.summaryText),
+    ...usage ? { usage } : {}
+  };
+}
+function normalizeUsage2(usage) {
+  if (!usage)
+    return;
+  return normalizeModelTokenUsage({
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cachedReadTokens: usage.cache_read_input_tokens,
+    cachedWriteTokens: usage.cache_creation_input_tokens
+  });
 }
 async function fetchWithTimeout(url2, init, timeoutMs) {
   const controller = new AbortController;
@@ -191762,6 +192447,7 @@ async function runOpenAiJudge(input, timeoutMs) {
           content: buildJudgePrompt(input.tool, input.result, input.summaryText, input.agentFindings)
         }
       ],
+      max_completion_tokens: JUDGE_MAX_OUTPUT_TOKENS,
       temperature: 0
     })
   }, timeoutMs);
@@ -191771,7 +192457,22 @@ async function runOpenAiJudge(input, timeoutMs) {
   const content = payload.choices?.[0]?.message?.content;
   if (!content)
     throw new Error("OpenAI judge response did not include content.");
-  return parseJudgeOutput(content, input.summaryText);
+  const usage = normalizeUsage3(payload.usage);
+  return {
+    output: parseJudgeOutput(content, input.summaryText),
+    ...usage ? { usage } : {}
+  };
+}
+function normalizeUsage3(usage) {
+  if (!usage)
+    return;
+  return normalizeModelTokenUsage({
+    totalTokens: usage.total_tokens,
+    inputTokens: usage.prompt_tokens,
+    outputTokens: usage.completion_tokens,
+    cachedReadTokens: usage.prompt_tokens_details?.cached_tokens,
+    thoughtTokens: usage.completion_tokens_details?.reasoning_tokens
+  });
 }
 async function fetchWithTimeout2(url2, init, timeoutMs) {
   const controller = new AbortController;
@@ -191813,8 +192514,13 @@ async function runJudge(input) {
     return { provider, status: "deterministic_fallback", output: fallback };
   }
   try {
-    const output = provider === "openai" ? await runOpenAiJudge(input, input.config.timeoutMs) : await runAnthropicJudge(input, input.config.timeoutMs);
-    return { provider, status: "completed", output };
+    const output = provider === "openai" ? await runOpenAiJudge(input, input.timeoutMs ?? input.config.timeoutMs) : await runAnthropicJudge(input, input.timeoutMs ?? input.config.timeoutMs);
+    return {
+      provider,
+      status: "completed",
+      output: output.output,
+      ...output.usage ? { usage: output.usage } : {}
+    };
   } catch (error51) {
     return {
       provider,
@@ -192020,7 +192726,7 @@ function decide(input) {
 
 // src/workspace/createSnapshot.ts
 import { chmod, mkdir as mkdir3, mkdtemp, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname5, join as join5 } from "node:path";
 import { tmpdir } from "node:os";
 async function createSnapshot(traceId, tool, request, options = {}) {
   const root = await mkdtemp(join5(tmpdir(), `kyoso-${traceId}-`));
@@ -192036,7 +192742,7 @@ async function createSnapshot(traceId, tool, request, options = {}) {
     if (!isAllowedPath(relative2, options.allowPatterns ?? []))
       continue;
     const dest = join5(repoDir, relative2);
-    await mkdir3(dirname4(dest), { recursive: true });
+    await mkdir3(dirname5(dest), { recursive: true });
     await writeFile2(dest, file2.content, "utf8");
     await chmod(dest, 292).catch(() => {
       return;
@@ -192087,6 +192793,304 @@ function newTraceId() {
   return `tr_${randomUUID()}`;
 }
 
+// src/core/requestFingerprint.ts
+import { createHash as createHash3 } from "node:crypto";
+var REVIEW_CONTRACT_VERSION = "2026-07-15-v1";
+function createRequestFingerprint(input) {
+  const reviewers = ["codex", "claude"].filter((agent) => input.config.agents[agent].enabled).map((agent) => ({
+    agent,
+    role: input.roles[agent] ?? input.config.agents[agent].role,
+    model: input.config.agents[agent].model ?? null,
+    provider: agent === "codex" ? input.config.agents.codex.provider ?? "default" : "default"
+  }));
+  const request = structuredClone(input.request);
+  if (request.options)
+    delete request.options.includeAgentRawOutputs;
+  const payload = {
+    reviewContractVersion: REVIEW_CONTRACT_VERSION,
+    tool: input.tool,
+    request,
+    reviewers,
+    verification: input.config.verification,
+    judge: {
+      ...input.config.judge,
+      requestedProvider: input.request.options?.judgeProvider ?? null
+    },
+    executionBudget: input.budget
+  };
+  return `sha256:${createHash3("sha256").update(canonicalJson(payload), "utf8").digest("hex")}`;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (!isRecord9(value))
+    return value;
+  return Object.fromEntries(Object.entries(value).filter(([, child]) => child !== undefined).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, canonicalize(child)]));
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/reviewBudget.ts
+var REVIEW_BUDGET_KEYS = new Set([
+  "maxModelCalls",
+  "maxTotalWallTimeMs",
+  "maxAgentOutputBytes",
+  "maxFindingsPerAgent",
+  "skipOptionalPhasesWhenTokenUsageUnknown"
+]);
+var MODEL_CALL_KINDS = ["primary", "verifier", "judge"];
+function resolveReviewBudget(ceiling, requested) {
+  if (requested === undefined)
+    return ceiling;
+  if (!isRecord10(requested)) {
+    throw new KyosoRequestError("options.reviewBudget must be an object.", "REVIEW_BUDGET_INVALID");
+  }
+  for (const [key, value] of Object.entries(requested)) {
+    if (!REVIEW_BUDGET_KEYS.has(key)) {
+      throw new KyosoRequestError(`options.reviewBudget.${key} is not supported.`, "REVIEW_BUDGET_INVALID");
+    }
+    if (key === "skipOptionalPhasesWhenTokenUsageUnknown") {
+      if (typeof value !== "boolean") {
+        throw new KyosoRequestError(`options.reviewBudget.${key} must be a boolean.`, "REVIEW_BUDGET_INVALID");
+      }
+      continue;
+    }
+    if (!isPositiveInteger(value)) {
+      throw new KyosoRequestError(`options.reviewBudget.${key} must be a positive integer.`, "REVIEW_BUDGET_INVALID");
+    }
+  }
+  const numericKeys = [
+    "maxModelCalls",
+    "maxTotalWallTimeMs",
+    "maxAgentOutputBytes",
+    "maxFindingsPerAgent"
+  ];
+  for (const key of numericKeys) {
+    const value = requested[key];
+    if (value === undefined)
+      continue;
+    if (value > ceiling[key]) {
+      throw new KyosoRequestError(`options.reviewBudget.${key} cannot exceed the user-global ceiling.`, "REVIEW_BUDGET_EXCEEDS_CEILING");
+    }
+  }
+  if (ceiling.skipOptionalPhasesWhenTokenUsageUnknown && requested.skipOptionalPhasesWhenTokenUsageUnknown === false) {
+    throw new KyosoRequestError("options.reviewBudget.skipOptionalPhasesWhenTokenUsageUnknown cannot relax the user-global ceiling.", "REVIEW_BUDGET_EXCEEDS_CEILING");
+  }
+  return {
+    maxModelCalls: requested.maxModelCalls ?? ceiling.maxModelCalls,
+    maxTotalWallTimeMs: requested.maxTotalWallTimeMs ?? ceiling.maxTotalWallTimeMs,
+    maxAgentOutputBytes: requested.maxAgentOutputBytes ?? ceiling.maxAgentOutputBytes,
+    maxFindingsPerAgent: requested.maxFindingsPerAgent ?? ceiling.maxFindingsPerAgent,
+    skipOptionalPhasesWhenTokenUsageUnknown: ceiling.skipOptionalPhasesWhenTokenUsageUnknown || requested.skipOptionalPhasesWhenTokenUsageUnknown === true
+  };
+}
+
+class ReviewBudgetTracker {
+  budget;
+  startedAtEpochMs;
+  deadlineAtEpochMs;
+  reservations = new Map;
+  skippedCalls = [];
+  incompleteReasons = new Set;
+  nextReservationId = 1;
+  constructor(budget, startedAtEpochMs = Date.now()) {
+    this.budget = budget;
+    this.startedAtEpochMs = startedAtEpochMs;
+    this.deadlineAtEpochMs = startedAtEpochMs + budget.maxTotalWallTimeMs;
+  }
+  remainingWallTimeMs(now = Date.now()) {
+    return Math.max(0, this.deadlineAtEpochMs - now);
+  }
+  hasDeadlineExpired(now = Date.now()) {
+    return this.remainingWallTimeMs(now) === 0;
+  }
+  reserveMany(inputs) {
+    if (this.hasDeadlineExpired())
+      return { failure: { reason: "deadline" } };
+    if (this.usedCapacity() + inputs.length > this.budget.maxModelCalls) {
+      return { failure: { reason: "model_call_budget" } };
+    }
+    const reservations = inputs.map((input) => {
+      const reservation = {
+        id: this.nextReservationId,
+        kind: input.kind,
+        ...input.agent ? { agent: input.agent } : {},
+        status: "reserved"
+      };
+      this.reservations.set(reservation.id, reservation);
+      this.nextReservationId += 1;
+      return reservation;
+    });
+    return {
+      reservations: reservations.map(({ id, kind, agent }) => ({
+        id,
+        kind,
+        ...agent ? { agent } : {}
+      }))
+    };
+  }
+  reserve(input) {
+    const result = this.reserveMany([input]);
+    if ("failure" in result)
+      return result;
+    const reservation = result.reservations[0];
+    if (!reservation) {
+      return { failure: { reason: "model_call_budget" } };
+    }
+    return { reservation };
+  }
+  markStarted(reservation) {
+    const current = this.reservations.get(reservation.id);
+    if (!current || current.status !== "reserved")
+      return;
+    current.status = "started";
+  }
+  hasStarted(reservation) {
+    const current = this.reservations.get(reservation.id);
+    return current?.status === "started" || current?.status === "completed";
+  }
+  complete(reservation, values = {}) {
+    const current = this.reservations.get(reservation.id);
+    if (!current || current.status === "skipped" || current.status === "completed") {
+      return;
+    }
+    current.status = "completed";
+    current.outputBytes = values.outputBytes;
+    current.usage = normalizeModelTokenUsage(values.usage);
+    current.stopReason = values.stopReason;
+  }
+  skip(reservation, reason) {
+    const current = this.reservations.get(reservation.id);
+    if (!current || current.status !== "reserved")
+      return;
+    current.status = "skipped";
+    current.reason = reason;
+  }
+  recordSkipped(input) {
+    this.skippedCalls.push({
+      kind: input.kind,
+      ...input.agent ? { agent: input.agent } : {},
+      status: "skipped",
+      reason: input.reason
+    });
+  }
+  markIncomplete(reason) {
+    this.incompleteReasons.add(reason);
+  }
+  isTokenUsageUnknown() {
+    return Array.from(this.reservations.values()).some((reservation) => reservation.status === "completed" && reservation.usage === undefined);
+  }
+  snapshot(now = Date.now()) {
+    const calls = this.modelCalls();
+    const byKind = Object.fromEntries(MODEL_CALL_KINDS.map((kind) => [
+      kind,
+      { planned: 0, consumed: 0, skipped: 0 }
+    ]));
+    let planned = 0;
+    let consumed = 0;
+    let skipped = 0;
+    const agentOutputBytes = {};
+    const usageTotals = {};
+    let reportedCalls = 0;
+    let unknownCalls = 0;
+    for (const reservation of this.reservations.values()) {
+      planned += 1;
+      byKind[reservation.kind].planned += 1;
+      if (reservation.status === "completed") {
+        consumed += 1;
+        byKind[reservation.kind].consumed += 1;
+        if (reservation.agent && reservation.outputBytes !== undefined) {
+          agentOutputBytes[reservation.agent] = (agentOutputBytes[reservation.agent] ?? 0) + reservation.outputBytes;
+        }
+        if (reservation.usage) {
+          reportedCalls += 1;
+          addUsage(usageTotals, reservation.usage);
+        } else {
+          unknownCalls += 1;
+        }
+      }
+      if (reservation.status === "skipped") {
+        skipped += 1;
+        byKind[reservation.kind].skipped += 1;
+      }
+    }
+    for (const call of this.skippedCalls) {
+      skipped += 1;
+      byKind[call.kind].skipped += 1;
+    }
+    const tokenStatus = consumed === 0 || reportedCalls === 0 ? "unknown" : unknownCalls === 0 ? "reported" : "partial";
+    const completionReasons = Array.from(this.incompleteReasons).sort();
+    const consumedMs = Math.max(0, now - this.startedAtEpochMs);
+    return {
+      completion: {
+        status: completionReasons.length > 0 ? "incomplete" : "complete",
+        reasons: completionReasons,
+        retryable: false
+      },
+      executionBudget: {
+        maxModelCalls: this.budget.maxModelCalls,
+        modelCalls: { planned, consumed, skipped, byKind },
+        wallTime: {
+          limitMs: this.budget.maxTotalWallTimeMs,
+          consumedMs,
+          remainingMs: this.remainingWallTimeMs(now)
+        },
+        maxAgentOutputBytes: this.budget.maxAgentOutputBytes,
+        maxFindingsPerAgent: this.budget.maxFindingsPerAgent,
+        skipOptionalPhasesWhenTokenUsageUnknown: this.budget.skipOptionalPhasesWhenTokenUsageUnknown,
+        agentOutputBytes,
+        tokenUsage: {
+          status: tokenStatus,
+          reportedCalls,
+          unknownCalls,
+          totals: usageTotals
+        }
+      },
+      modelCalls: calls
+    };
+  }
+  usedCapacity() {
+    return Array.from(this.reservations.values()).filter((reservation) => reservation.status === "reserved" || reservation.status === "started" || reservation.status === "completed").length;
+  }
+  modelCalls() {
+    const reservations = Array.from(this.reservations.values()).filter((reservation) => reservation.status === "completed" || reservation.status === "skipped").map((reservation) => ({
+      kind: reservation.kind,
+      ...reservation.agent ? { agent: reservation.agent } : {},
+      status: reservation.status === "completed" ? "completed" : "skipped",
+      ...reservation.reason ? { reason: reservation.reason } : {},
+      ...reservation.outputBytes !== undefined ? { outputBytes: reservation.outputBytes } : {},
+      ...reservation.usage ? { usage: reservation.usage } : {},
+      ...reservation.stopReason ? { stopReason: reservation.stopReason } : {}
+    }));
+    return [...reservations, ...this.skippedCalls];
+  }
+}
+function addUsage(total, usage) {
+  for (const key of [
+    "totalTokens",
+    "inputTokens",
+    "outputTokens",
+    "thoughtTokens",
+    "cachedReadTokens",
+    "cachedWriteTokens"
+  ]) {
+    const value = usage[key];
+    if (value === undefined)
+      continue;
+    total[key] = (total[key] ?? 0) + value;
+  }
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/core/verification.ts
 var REAL_AGENTS = ["codex", "claude"];
 var VERIFIABLE_SEVERITIES = new Set(["critical", "high"]);
@@ -192128,9 +193132,12 @@ function groupVerificationTargetsByVerifier(targets) {
     findings
   }));
 }
-function markVerificationOverflow(targets) {
+function markVerificationOverflow(targets, reason) {
   for (const target of targets) {
-    target.finding.verification = { status: "not_verified" };
+    target.finding.verification = {
+      status: "not_verified",
+      ...reason ? { note: reason } : {}
+    };
   }
 }
 function parseVerificationVerdicts(rawText) {
@@ -192142,7 +193149,7 @@ function parseVerificationVerdicts(rawText) {
     if (!Array.isArray(parsed.verdicts))
       return;
     return parsed.verdicts.flatMap((item) => {
-      if (!isRecord8(item))
+      if (!isRecord11(item))
         return [];
       if (typeof item.findingId !== "string")
         return [];
@@ -192220,15 +193227,23 @@ function verificationNote(reasoning) {
 function isVerdict(value) {
   return value === "confirmed" || value === "refuted" || value === "uncertain";
 }
-function isRecord8(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/core/runReview.ts
+function requestForRecursionFingerprint(request) {
+  try {
+    return scanAndRedactSecrets(request).redactedRequest;
+  } catch {
+    return { goal: "" };
+  }
+}
 async function runReview(tool, request, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const traceId = newTraceId();
-  const startedAt = new Date().toISOString();
+  const startedAtEpochMs = Date.now();
+  const startedAt = new Date(startedAtEpochMs).toISOString();
   const auditEnv = { ...process.env, ...options.env };
   const traceWriterFactory = options.traceWriterFactory ?? createTraceWriter;
   let snapshot;
@@ -192237,6 +193252,14 @@ async function runReview(tool, request, options = {}) {
   } catch (error51) {
     if (error51 instanceof KyosoRequestError) {
       const config2 = kyosoConfigSchema.parse(defaultConfig);
+      const budgetTracker = new ReviewBudgetTracker(config2.reviewBudget, startedAtEpochMs);
+      const requestFingerprint = createRequestFingerprint({
+        tool,
+        request: requestForRecursionFingerprint(request),
+        config: config2,
+        roles: resolveAgentRoles(config2),
+        budget: config2.reviewBudget
+      });
       const trace2 = traceWriterFactory({
         enabled: config2.audit.enabled,
         directory: config2.audit.directory,
@@ -192251,6 +193274,12 @@ async function runReview(tool, request, options = {}) {
           tool,
           timestamp: new Date().toISOString()
         });
+        await writeReviewBudgetPlanned({
+          trace: trace2,
+          traceId,
+          budgetTracker,
+          requestFingerprint
+        });
         return await buildPolicyBlockResult({
           tool,
           trace: trace2,
@@ -192258,6 +193287,8 @@ async function runReview(tool, request, options = {}) {
           startedAt,
           networkMode: config2.network.defaultMode,
           warning: error51.message,
+          budgetTracker,
+          requestFingerprint,
           finding: {
             id: "KYOSO-1",
             severity: "critical",
@@ -192323,6 +193354,8 @@ async function runReview(tool, request, options = {}) {
       timestamp: new Date().toISOString()
     });
     validateReviewRequest(tool, request);
+    const reviewBudget = resolveReviewBudget(loaded.config.reviewBudget, request.options?.reviewBudget);
+    const budgetTracker = new ReviewBudgetTracker(reviewBudget, startedAtEpochMs);
     assertTrustedWorkspaceRoot(request.workspace?.root, loaded.config.workspace.root, cwd);
     const networkMode = resolveNetworkMode(request.options?.network, loaded.config.network.defaultMode, options.mcpNetworkMode);
     if (networkMode === "unrestricted" && !loaded.config.network.allowUnrestricted) {
@@ -192341,6 +193374,19 @@ async function runReview(tool, request, options = {}) {
     });
     const allowSecretOverride = loaded.config.secrets.allowOverride && request.options?.allowSecretRedaction === true;
     if (secretScan.detected && loaded.config.secrets.blockOnDetectedSecret && !allowSecretOverride) {
+      const requestFingerprint2 = createRequestFingerprint({
+        tool,
+        request: secretScan.redactedRequest,
+        config: loaded.config,
+        roles: resolveAgentRoles(loaded.config),
+        budget: reviewBudget
+      });
+      await writeReviewBudgetPlanned({
+        trace,
+        traceId,
+        budgetTracker,
+        requestFingerprint: requestFingerprint2
+      });
       return await buildSecretBlockResult({
         tool,
         trace,
@@ -192349,7 +193395,9 @@ async function runReview(tool, request, options = {}) {
         configHash: loaded.configHash,
         networkMode,
         secretScan,
-        warnings
+        warnings,
+        budgetTracker,
+        requestFingerprint: requestFingerprint2
       });
     }
     const denyPatterns = mergeDenyPatterns(loaded.config.workspace.deny, secretScan.redactedRequest.workspace?.denyRead);
@@ -192362,6 +193410,19 @@ async function runReview(tool, request, options = {}) {
     });
     warnings.push(...built.warnings);
     const agentRoles = resolveAgentRoles(loaded.config);
+    const requestFingerprint = createRequestFingerprint({
+      tool,
+      request: built.request,
+      config: loaded.config,
+      roles: agentRoles,
+      budget: reviewBudget
+    });
+    await writeReviewBudgetPlanned({
+      trace,
+      traceId,
+      budgetTracker,
+      requestFingerprint
+    });
     snapshot = await createSnapshot(traceId, tool, built.request, {
       denyPatterns,
       allowPatterns,
@@ -192374,7 +193435,7 @@ async function runReview(tool, request, options = {}) {
       fileCount: snapshot.fileCount,
       timestamp: new Date().toISOString()
     });
-    const manager = options.agentManager ?? defaultAgentManager(loaded.config);
+    const manager = options.agentManager ?? defaultAgentManager(loaded.config, options.env ?? process.env);
     const agentResults = await runAgents({
       tool,
       request: built.request,
@@ -192383,14 +193444,23 @@ async function runReview(tool, request, options = {}) {
       workspaceDir: snapshot.root,
       networkMode,
       manager,
-      trace
+      trace,
+      warnings,
+      budgetTracker
     });
     warnings.push(...agentResults.flatMap((result) => (result.warnings ?? []).map((warning) => `Agent ${result.agent} ${warning}`)));
-    const normalizedAgentResults = agentResults.map(normalizeAgentRunResult);
-    const agentsUsed = normalizedAgentResults.map((result) => result.agent);
-    const reviewMode = agentsUsed.length === 1 ? "single_agent" : "multi_agent";
+    const normalized = agentResults.map((result) => normalizeAgentRunResult(result, reviewBudget.maxFindingsPerAgent));
+    const normalizedAgentResults = normalized.map((item) => item.result);
+    for (const item of normalized.filter((item2) => item2.findingsCapped)) {
+      budgetTracker.markIncomplete("coverage_incomplete");
+      warnings.push(`Agent ${item.result.agent} findings were capped at ${reviewBudget.maxFindingsPerAgent}; review coverage is incomplete.`);
+    }
+    const enabledAgents = ["codex", "claude"].filter((agent) => loaded.config.agents[agent].enabled);
+    const agentsUsed = normalizedAgentResults.filter((result) => result.status !== "skipped").map((result) => result.agent);
+    const reviewMode = enabledAgents.length === 1 ? "single_agent" : "multi_agent";
     const completed = normalizedAgentResults.filter((result) => result.status === "completed");
-    const degraded = completed.length !== agentResults.length;
+    const attempted = normalizedAgentResults.filter((result) => result.status !== "skipped");
+    const degraded = completed.length !== attempted.length || enabledAgents.length === 0;
     let aggregate = aggregateAgentResults(normalizedAgentResults, {
       reviewMode
     });
@@ -192406,7 +193476,12 @@ async function runReview(tool, request, options = {}) {
         ])
       };
     }
-    if (completed.length === 0) {
+    if (completed.length === 0 && (attempted.length > 0 || enabledAgents.length === 0)) {
+      const noPrimaryAgents = enabledAgents.length === 0;
+      if (noPrimaryAgents) {
+        budgetTracker.markIncomplete("coverage_incomplete");
+        warnings.push("No primary review agents are enabled; review coverage is incomplete.");
+      }
       aggregate = {
         ...aggregate,
         findings: [
@@ -192415,9 +193490,9 @@ async function runReview(tool, request, options = {}) {
             id: `KYOSO-${aggregate.findings.length + 1}`,
             severity: "critical",
             category: "other",
-            title: "All backend agents failed",
-            evidence: normalizedAgentResults.map((result) => `${result.agent}: ${result.error?.code ?? result.status}`).join("; "),
-            recommendation: "Run kyoso doctor and retry after agent authentication or adapter issues are fixed.",
+            title: noPrimaryAgents ? "No primary review agents enabled" : "All backend agents failed",
+            evidence: noPrimaryAgents ? "Both configured primary reviewers are disabled." : normalizedAgentResults.map((result) => `${result.agent}: ${result.error?.code ?? result.status}`).join("; "),
+            recommendation: noPrimaryAgents ? "Enable at least one primary reviewer before running Kyoso." : "Run kyoso doctor and retry after agent authentication or adapter issues are fixed.",
             sourceAgents: ["kyoso_policy"],
             confidence: "high"
           }
@@ -192430,7 +193505,7 @@ async function runReview(tool, request, options = {}) {
       findingCount: aggregate.findings.length,
       timestamp: new Date().toISOString()
     });
-    const verificationMode = loaded.config.verification.enabled && reviewMode === "single_agent" ? "skipped_single_agent" : loaded.config.verification.enabled ? "cross_agent" : undefined;
+    const verificationMode = loaded.config.verification.enabled && reviewMode === "single_agent" ? "skipped_single_agent" : loaded.config.verification.enabled && enabledAgents.length > 1 ? "cross_agent" : undefined;
     if (verificationMode === "cross_agent") {
       warnings.push(...await runFindingVerification({
         tool,
@@ -192441,11 +193516,16 @@ async function runReview(tool, request, options = {}) {
         networkMode,
         manager,
         trace,
-        findings: aggregate.findings
+        findings: aggregate.findings,
+        budgetTracker
       }));
     }
+    if (aggregate.findings.some((finding) => finding.verification?.status === "refuted")) {
+      budgetTracker.markIncomplete("disputed_finding");
+    }
     const cisa = tool === "security_review" ? computeCisaGate(aggregate.findings, normalizedAgentResults) : undefined;
-    const decision = decide({
+    const budgetBeforeJudge = budgetTracker.snapshot();
+    const decision = budgetBeforeJudge.completion.status === "incomplete" ? "block" : decide({
       tool,
       findings: aggregate.findings,
       cisa,
@@ -192455,6 +193535,9 @@ async function runReview(tool, request, options = {}) {
     const completedAt = new Date().toISOString();
     const resultWithoutMarkdown = {
       decision,
+      completion: budgetBeforeJudge.completion,
+      executionBudget: budgetBeforeJudge.executionBudget,
+      requestFingerprint,
       degraded,
       agentsUsed,
       reviewMode,
@@ -192476,18 +193559,22 @@ async function runReview(tool, request, options = {}) {
         networkMode,
         workspaceMode: "temp_snapshot",
         configHash: loaded.configHash,
-        warnings: Array.from(new Set([...warnings, ...trace.warnings]))
+        warnings: Array.from(new Set([...warnings, ...trace.warnings])),
+        modelCalls: budgetBeforeJudge.modelCalls
       }
     };
     const summaryText = defaultSummaryText(resultWithoutMarkdown);
-    const judge = await runJudge({
+    const judge = await runBudgetedJudge({
       tool,
       result: resultWithoutMarkdown,
       summaryText,
       agentFindings: buildJudgeAgentFindings(normalizedAgentResults),
       config: loaded.config.judge,
       requestedProvider: request.options?.judgeProvider,
-      env: options.env ?? process.env
+      env: options.env ?? process.env,
+      budgetTracker,
+      trace,
+      traceId
     });
     const judgeComments = new Map(judge.output.disagreementComments.map((comment) => [
       comment.topic,
@@ -192498,10 +193585,20 @@ async function runReview(tool, request, options = {}) {
       judgeComment: judgeComments.get(disagreement.topic) ?? disagreement.judgeComment
     }));
     const crossModelAnalysis = buildCrossModelAnalysis(judge, reviewMode);
+    const budgetAfterJudge = budgetTracker.snapshot();
+    const finalDecision = budgetAfterJudge.completion.status === "incomplete" ? "block" : decision;
     const resultAfterJudge = {
       ...resultWithoutMarkdown,
+      decision: finalDecision,
+      completion: budgetAfterJudge.completion,
+      executionBudget: budgetAfterJudge.executionBudget,
       disagreements,
-      ...crossModelAnalysis ? { crossModelAnalysis } : {}
+      ...crossModelAnalysis ? { crossModelAnalysis } : {},
+      audit: {
+        ...resultWithoutMarkdown.audit,
+        completedAt: new Date().toISOString(),
+        modelCalls: budgetAfterJudge.modelCalls
+      }
     };
     const judgeEvent = {
       type: "judge_completed",
@@ -192514,10 +193611,16 @@ async function runReview(tool, request, options = {}) {
       judgeEvent.error = judge.error;
     await trace.write(judgeEvent);
     resultAfterJudge.audit.completedAt = new Date().toISOString();
+    await writeReviewBudgetCompleted({
+      trace,
+      traceId,
+      budgetTracker,
+      requestFingerprint
+    });
     await trace.write({
       type: "decision_completed",
       traceId,
-      decision,
+      decision: finalDecision,
       timestamp: new Date().toISOString()
     });
     await trace.write({
@@ -192529,7 +193632,7 @@ async function runReview(tool, request, options = {}) {
       tool,
       trace,
       result: resultAfterJudge,
-      summaryText: judge.output.summaryText
+      summaryText: resultAfterJudge.completion.status === "incomplete" ? defaultSummaryText(resultAfterJudge) : judge.output.summaryText
     });
   } finally {
     await trace.finalize();
@@ -192540,37 +193643,180 @@ async function runReview(tool, request, options = {}) {
 async function runFindingVerification(input) {
   const allowDemotionRequested = input.config.verification.allowDemotion;
   const selection = selectVerificationTargets(input.findings, input.config.verification.maxFindings);
-  markVerificationOverflow(selection.overflow);
-  if (selection.selected.length === 0)
-    return [];
   const warnings = [];
-  const groups = groupVerificationTargetsByVerifier(selection.selected);
+  if (selection.overflow.length > 0) {
+    markVerificationOverflow(selection.overflow, "verification_max_findings");
+    input.budgetTracker.markIncomplete("coverage_incomplete");
+  }
+  if (selection.selected.length === 0)
+    return warnings;
+  const potentialGroups = groupVerificationTargetsByVerifier(selection.selected);
   await input.trace.write({
     type: "verification_started",
     traceId: input.traceId,
     targetCount: selection.selected.length,
     notVerifiedCount: selection.overflow.length,
-    verifierCount: groups.length,
+    verifierCount: potentialGroups.length,
     timeoutMs: input.config.verification.timeoutMs,
     allowDemotionRequested,
     timestamp: new Date().toISOString()
   });
-  const agentInputs = groups.map(({ verifier, findings }) => ({
+  if (input.budgetTracker.budget.skipOptionalPhasesWhenTokenUsageUnknown && input.budgetTracker.isTokenUsageUnknown()) {
+    markVerificationOverflow(selection.selected, "token_usage_unknown");
+    input.budgetTracker.markIncomplete("token_usage_unknown");
+    input.budgetTracker.markIncomplete("coverage_incomplete");
+    warnings.push("Finding verification was skipped because primary-agent token usage was not reported.");
+    for (const group of potentialGroups) {
+      input.budgetTracker.recordSkipped({
+        kind: "verifier",
+        agent: group.verifier,
+        reason: "token_usage_unknown"
+      });
+      await input.trace.write({
+        type: "model_call_skipped",
+        traceId: input.traceId,
+        kind: "verifier",
+        agent: group.verifier,
+        reason: "token_usage_unknown",
+        timestamp: new Date().toISOString()
+      });
+    }
+    await input.trace.write({
+      type: "verification_completed",
+      traceId: input.traceId,
+      counts: countVerificationStatuses(input.findings),
+      timestamp: new Date().toISOString()
+    });
+    return warnings;
+  }
+  const groups = new Map;
+  const unavailableVerifiers = new Map;
+  for (const target of selection.selected) {
+    const existing = groups.get(target.verifier);
+    if (existing) {
+      existing.targets.push(target);
+      continue;
+    }
+    const unavailable = unavailableVerifiers.get(target.verifier);
+    if (unavailable) {
+      markVerificationOverflow([target], unavailable === "model_call_budget" ? "budget_exhausted" : "deadline");
+      continue;
+    }
+    const reservationResult = input.budgetTracker.reserve({
+      kind: "verifier",
+      agent: target.verifier
+    });
+    if ("failure" in reservationResult) {
+      unavailableVerifiers.set(target.verifier, reservationResult.failure.reason);
+      markVerificationOverflow([target], reservationResult.failure.reason === "model_call_budget" ? "budget_exhausted" : "deadline");
+      input.budgetTracker.recordSkipped({
+        kind: "verifier",
+        agent: target.verifier,
+        reason: reservationResult.failure.reason
+      });
+      input.budgetTracker.markIncomplete(reservationResult.failure.reason);
+      input.budgetTracker.markIncomplete("coverage_incomplete");
+      await input.trace.write({
+        type: "review_budget_exhausted",
+        traceId: input.traceId,
+        phase: "verification",
+        kind: "verifier",
+        agent: target.verifier,
+        reason: reservationResult.failure.reason,
+        timestamp: new Date().toISOString()
+      });
+      await input.trace.write({
+        type: "model_call_skipped",
+        traceId: input.traceId,
+        kind: "verifier",
+        agent: target.verifier,
+        reason: reservationResult.failure.reason,
+        timestamp: new Date().toISOString()
+      });
+      continue;
+    }
+    const group = {
+      verifier: target.verifier,
+      targets: [target],
+      reservation: reservationResult.reservation
+    };
+    groups.set(target.verifier, group);
+    await input.trace.write({
+      type: "model_call_reserved",
+      traceId: input.traceId,
+      kind: "verifier",
+      agent: target.verifier,
+      timestamp: new Date().toISOString()
+    });
+  }
+  const scheduledGroups = [];
+  for (const group of groups.values()) {
+    const timeoutMs = Math.min(input.config.verification.timeoutMs, input.budgetTracker.remainingWallTimeMs());
+    if (timeoutMs > 0) {
+      scheduledGroups.push(group);
+      continue;
+    }
+    input.budgetTracker.skip(group.reservation, "deadline");
+    input.budgetTracker.markIncomplete("deadline");
+    input.budgetTracker.markIncomplete("coverage_incomplete");
+    markVerificationOverflow(group.targets, "deadline");
+    await input.trace.write({
+      type: "review_budget_exhausted",
+      traceId: input.traceId,
+      phase: "verification",
+      kind: "verifier",
+      agent: group.verifier,
+      reason: "deadline",
+      timestamp: new Date().toISOString()
+    });
+    await input.trace.write({
+      type: "model_call_skipped",
+      traceId: input.traceId,
+      kind: "verifier",
+      agent: group.verifier,
+      reason: "deadline",
+      timestamp: new Date().toISOString()
+    });
+  }
+  if (scheduledGroups.length === 0) {
+    await input.trace.write({
+      type: "verification_completed",
+      traceId: input.traceId,
+      counts: countVerificationStatuses(input.findings),
+      timestamp: new Date().toISOString()
+    });
+    return warnings;
+  }
+  const agentInputs = scheduledGroups.map((group) => ({
     traceId: input.traceId,
-    agent: verifier,
+    agent: group.verifier,
     role: "finding_verifier",
     tool: input.tool,
-    prompt: buildFindingVerifierPrompt(input.tool, input.request, verifier, findings),
+    prompt: buildFindingVerifierPrompt(input.tool, input.request, group.verifier, group.targets.map((target) => target.finding)),
     workspaceDir: input.workspaceDir,
-    timeoutMs: input.config.verification.timeoutMs,
-    networkMode: input.networkMode
+    timeoutMs: Math.min(input.config.verification.timeoutMs, input.budgetTracker.remainingWallTimeMs()),
+    deadlineAtEpochMs: input.budgetTracker.deadlineAtEpochMs,
+    maxOutputBytes: input.budgetTracker.budget.maxAgentOutputBytes,
+    networkMode: input.networkMode,
+    onStarted: () => {
+      input.budgetTracker.markStarted(group.reservation);
+      return Promise.resolve();
+    }
   }));
   let results;
   try {
     results = await input.manager.runAll(agentInputs);
   } catch (error51) {
-    for (const group of groups) {
-      applyVerificationVerdicts(selection.selected, group.verifier, undefined);
+    for (const group of scheduledGroups) {
+      applyVerificationVerdicts(group.targets, group.verifier, undefined);
+      await finalizeModelCallResult({
+        budgetTracker: input.budgetTracker,
+        reservation: group.reservation,
+        result: failedVerifierResult(group.verifier, "AGENT_MANAGER_FAILED"),
+        trace: input.trace,
+        traceId: input.traceId
+      });
+      input.budgetTracker.markIncomplete("coverage_incomplete");
     }
     const message = `Finding verification failed: ${sanitizeTextForDisplay(error51 instanceof Error ? error51.message : String(error51))}`;
     warnings.push(message);
@@ -192583,9 +193829,32 @@ async function runFindingVerification(input) {
     });
     return warnings;
   }
-  for (const result of results) {
+  const resultByAgent = new Map(results.map((result) => [result.agent, result]));
+  for (const group of scheduledGroups) {
+    const result = resultByAgent.get(group.verifier);
+    if (!result) {
+      applyVerificationVerdicts(group.targets, group.verifier, undefined);
+      await finalizeModelCallResult({
+        budgetTracker: input.budgetTracker,
+        reservation: group.reservation,
+        result: failedVerifierResult(group.verifier, "AGENT_RESULT_MISSING"),
+        trace: input.trace,
+        traceId: input.traceId
+      });
+      input.budgetTracker.markIncomplete("coverage_incomplete");
+      warnings.push(`Finding verification by ${group.verifier} did not return a result.`);
+      continue;
+    }
+    await finalizeModelCallResult({
+      budgetTracker: input.budgetTracker,
+      reservation: group.reservation,
+      result,
+      trace: input.trace,
+      traceId: input.traceId
+    });
     if (result.status !== "completed") {
-      applyVerificationVerdicts(selection.selected, result.agent, undefined);
+      applyVerificationVerdicts(group.targets, result.agent, undefined);
+      input.budgetTracker.markIncomplete("coverage_incomplete");
       const message = `Finding verification by ${result.agent} ${result.status}: ${result.error?.message ?? result.error?.code ?? "no detail"}`;
       warnings.push(sanitizeTextForDisplay(message));
       await input.trace.write({
@@ -192599,8 +193868,9 @@ async function runFindingVerification(input) {
       continue;
     }
     const verdicts = parseVerificationVerdicts(result.rawText);
-    applyVerificationVerdicts(selection.selected, result.agent, verdicts);
+    applyVerificationVerdicts(group.targets, result.agent, verdicts);
     if (!verdicts) {
+      input.budgetTracker.markIncomplete("coverage_incomplete");
       const message = `Finding verification by ${result.agent} returned malformed verdict JSON.`;
       warnings.push(message);
       await input.trace.write({
@@ -192620,6 +193890,20 @@ async function runFindingVerification(input) {
   });
   return warnings;
 }
+function failedVerifierResult(agent, code) {
+  const timestamp = new Date().toISOString();
+  return {
+    agent,
+    role: "finding_verifier",
+    status: "failed",
+    startedAt: timestamp,
+    completedAt: timestamp,
+    error: {
+      code,
+      message: "The agent manager did not return a verification result."
+    }
+  };
+}
 function buildJudgeAgentFindings(results) {
   return results.flatMap((result) => {
     if (!result.normalized)
@@ -192656,27 +193940,277 @@ function buildCrossModelAnalysis(judge, reviewMode) {
     provider: judge.provider
   };
 }
-async function runAgents(input) {
-  const agentRoles = resolveAgentRoles(input.config);
-  const agentInputs = ["codex", "claude"].filter((agent) => input.config.agents[agent].enabled).map((agent) => ({
+async function runBudgetedJudge(input) {
+  const configuredProvider = input.requestedProvider ?? input.config.provider;
+  const provider = resolveJudgeProvider(configuredProvider, input.env);
+  if (input.config.mode === "deterministic_only" || provider === "deterministic_fallback") {
+    return runJudge(input);
+  }
+  const fallback = () => runJudge({
+    ...input,
+    config: { ...input.config, mode: "deterministic_only" }
+  });
+  if (input.budgetTracker.snapshot().completion.status === "incomplete") {
+    await recordSkippedJudgeCall(input, "review_incomplete");
+    return fallback();
+  }
+  if (input.budgetTracker.budget.skipOptionalPhasesWhenTokenUsageUnknown && input.budgetTracker.isTokenUsageUnknown()) {
+    await recordSkippedJudgeCall(input, "token_usage_unknown");
+    return fallback();
+  }
+  const reservationResult = input.budgetTracker.reserve({ kind: "judge" });
+  if ("failure" in reservationResult) {
+    await recordSkippedJudgeCall(input, reservationResult.failure.reason);
+    await input.trace.write({
+      type: "review_budget_exhausted",
+      traceId: input.traceId,
+      phase: "judge",
+      kind: "judge",
+      reason: reservationResult.failure.reason,
+      timestamp: new Date().toISOString()
+    });
+    return fallback();
+  }
+  const reservation = reservationResult.reservation;
+  await input.trace.write({
+    type: "model_call_reserved",
     traceId: input.traceId,
-    agent,
-    role: agentRoles[agent] ?? input.config.agents[agent].role,
-    tool: input.tool,
-    prompt: buildAgentPrompt(input.tool, input.request, agent, agentRoles[agent] ?? input.config.agents[agent].role),
-    workspaceDir: input.workspaceDir,
-    timeoutMs: input.request.options?.maxAgentTimeoutMs ?? input.config.agents[agent].timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS,
-    networkMode: input.networkMode
-  }));
-  await Promise.all(agentInputs.map((agentInput) => input.trace.write({
-    type: "agent_started",
+    kind: "judge",
+    timestamp: new Date().toISOString()
+  });
+  const timeoutMs = Math.min(input.config.timeoutMs, input.budgetTracker.remainingWallTimeMs());
+  if (timeoutMs <= 0) {
+    input.budgetTracker.skip(reservation, "deadline");
+    await input.trace.write({
+      type: "review_budget_exhausted",
+      traceId: input.traceId,
+      phase: "judge",
+      kind: "judge",
+      reason: "deadline",
+      timestamp: new Date().toISOString()
+    });
+    await input.trace.write({
+      type: "model_call_skipped",
+      traceId: input.traceId,
+      kind: "judge",
+      reason: "deadline",
+      timestamp: new Date().toISOString()
+    });
+    return fallback();
+  }
+  input.budgetTracker.markStarted(reservation);
+  const judge = await runJudge({ ...input, timeoutMs });
+  const usage = normalizeModelTokenUsage(judge.usage);
+  input.budgetTracker.complete(reservation, {
+    ...usage ? { usage } : {}
+  });
+  await input.trace.write({
+    type: "model_call_completed",
     traceId: input.traceId,
-    agent: agentInput.agent,
-    role: agentInput.role,
+    kind: "judge",
+    provider: judge.provider,
+    resultStatus: judge.status,
+    ...usage ? { usage } : {},
     timestamp: new Date().toISOString()
-  })));
-  const results = await input.manager.runAll(agentInputs);
-  await Promise.all(results.map((result) => {
+  });
+  return judge;
+}
+async function recordSkippedJudgeCall(input, reason) {
+  input.budgetTracker.recordSkipped({ kind: "judge", reason });
+  await input.trace.write({
+    type: "model_call_skipped",
+    traceId: input.traceId,
+    kind: "judge",
+    reason,
+    timestamp: new Date().toISOString()
+  });
+}
+async function runAgents(input) {
+  const agentRoles = resolveAgentRoles(input.config);
+  const enabledAgents = ["codex", "claude"].filter((agent) => input.config.agents[agent].enabled);
+  if (enabledAgents.length === 0)
+    return [];
+  const reservationResult = input.budgetTracker.reserveMany(enabledAgents.map((agent) => ({ kind: "primary", agent })));
+  if ("failure" in reservationResult) {
+    input.budgetTracker.markIncomplete(reservationResult.failure.reason);
+    input.budgetTracker.markIncomplete("coverage_incomplete");
+    await input.trace.write({
+      type: "review_budget_exhausted",
+      traceId: input.traceId,
+      phase: "primary",
+      reason: reservationResult.failure.reason,
+      requiredCalls: enabledAgents.length,
+      timestamp: new Date().toISOString()
+    });
+    for (const agent of enabledAgents) {
+      input.budgetTracker.recordSkipped({
+        kind: "primary",
+        agent,
+        reason: reservationResult.failure.reason
+      });
+      await input.trace.write({
+        type: "model_call_skipped",
+        traceId: input.traceId,
+        kind: "primary",
+        agent,
+        reason: reservationResult.failure.reason,
+        timestamp: new Date().toISOString()
+      });
+    }
+    return enabledAgents.map((agent) => {
+      const role = agentRoles[agent] ?? input.config.agents[agent].role;
+      const timestamp = new Date().toISOString();
+      return {
+        agent,
+        role,
+        status: "skipped",
+        startedAt: timestamp,
+        completedAt: timestamp,
+        error: {
+          code: reservationResult.failure.reason === "deadline" ? "REVIEW_DEADLINE_EXCEEDED" : "MODEL_CALL_BUDGET_EXHAUSTED",
+          message: reservationResult.failure.reason === "deadline" ? "Review deadline was reached before primary agents could start." : "The review model-call budget cannot reserve all primary agents."
+        }
+      };
+    });
+  }
+  const reservations = new Map(reservationResult.reservations.map((reservation) => [
+    reservation.agent,
+    reservation
+  ]));
+  for (const reservation of reservationResult.reservations) {
+    await input.trace.write({
+      type: "model_call_reserved",
+      traceId: input.traceId,
+      kind: reservation.kind,
+      agent: reservation.agent,
+      timestamp: new Date().toISOString()
+    });
+  }
+  if (input.budgetTracker.remainingWallTimeMs() <= 0) {
+    input.budgetTracker.markIncomplete("deadline");
+    input.budgetTracker.markIncomplete("coverage_incomplete");
+    await input.trace.write({
+      type: "review_budget_exhausted",
+      traceId: input.traceId,
+      phase: "primary",
+      reason: "deadline",
+      timestamp: new Date().toISOString()
+    });
+    return await skipReservedPrimaryAgents({
+      trace: input.trace,
+      traceId: input.traceId,
+      budgetTracker: input.budgetTracker,
+      config: input.config,
+      agents: enabledAgents,
+      agentRoles,
+      reservations,
+      reason: "deadline"
+    });
+  }
+  const startedWrites = [];
+  let acceptingStartedEvents = true;
+  const agentInputs = enabledAgents.map((agent) => {
+    const agentConfig = input.config.agents[agent];
+    const role = agentRoles[agent] ?? agentConfig.role;
+    const reservation = reservations.get(agent);
+    if (!reservation) {
+      throw new Error(`Missing primary budget reservation for ${agent}.`);
+    }
+    return {
+      traceId: input.traceId,
+      agent,
+      role,
+      tool: input.tool,
+      prompt: buildAgentPrompt(input.tool, input.request, agent, role),
+      workspaceDir: input.workspaceDir,
+      timeoutMs: Math.min(input.request.options?.maxAgentTimeoutMs ?? Number.POSITIVE_INFINITY, agentConfig.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS, input.budgetTracker.remainingWallTimeMs()),
+      deadlineAtEpochMs: input.budgetTracker.deadlineAtEpochMs,
+      maxOutputBytes: input.budgetTracker.budget.maxAgentOutputBytes,
+      networkMode: input.networkMode,
+      onStarted: () => {
+        input.budgetTracker.markStarted(reservation);
+        if (!acceptingStartedEvents)
+          return Promise.resolve();
+        const event = {
+          type: "agent_started",
+          traceId: input.traceId,
+          agent,
+          role,
+          timestamp: new Date().toISOString()
+        };
+        if (agentConfig.model) {
+          event.model = sanitizeTextForDisplay(agentConfig.model);
+        }
+        if (agent === "codex" && input.config.agents.codex.provider === CODEX_OPENROUTER_PROVIDER) {
+          event.provider = CODEX_OPENROUTER_PROVIDER;
+        }
+        const write = (async () => {
+          try {
+            await input.trace.write(event);
+          } catch {
+            input.warnings.push("AUDIT_WRITE_FAILED: agent_started event could not be recorded.");
+          }
+        })();
+        startedWrites.push(write);
+        return write;
+      }
+    };
+  });
+  let results;
+  try {
+    results = await input.manager.runAll(agentInputs);
+  } catch (error51) {
+    const detail = sanitizeTextForDisplay(error51 instanceof Error ? error51.message : String(error51));
+    input.warnings.push(`Primary-agent execution failed: ${detail}`);
+    results = agentInputs.map((agentInput) => ({
+      agent: agentInput.agent,
+      role: agentInput.role,
+      status: "failed",
+      startedAt: new Date().toISOString(),
+      completedAt: new Date().toISOString(),
+      error: {
+        code: "AGENT_MANAGER_FAILED",
+        message: "The agent manager did not return a review result."
+      }
+    }));
+  }
+  acceptingStartedEvents = false;
+  await Promise.all(startedWrites);
+  const resultByAgent = new Map(results.map((result) => [result.agent, result]));
+  const orderedResults = enabledAgents.map((agent) => {
+    const existing = resultByAgent.get(agent);
+    if (existing)
+      return existing;
+    const role = agentRoles[agent] ?? input.config.agents[agent].role;
+    const timestamp = new Date().toISOString();
+    return {
+      agent,
+      role,
+      status: "failed",
+      startedAt: timestamp,
+      completedAt: timestamp,
+      error: {
+        code: "AGENT_RESULT_MISSING",
+        message: "The agent manager did not return a review result."
+      }
+    };
+  });
+  for (const result of orderedResults) {
+    const reservation = reservations.get(result.agent);
+    if (!reservation)
+      continue;
+    await finalizeModelCallResult({
+      budgetTracker: input.budgetTracker,
+      reservation,
+      result,
+      trace: input.trace,
+      traceId: input.traceId
+    });
+    if (result.status !== "completed") {
+      input.budgetTracker.markIncomplete("coverage_incomplete");
+    }
+  }
+  await Promise.all(orderedResults.map((result) => {
     const event = {
       type: "agent_completed",
       traceId: input.traceId,
@@ -192696,8 +194230,92 @@ async function runAgents(input) {
     }
     return input.trace.write(event);
   }));
+  return orderedResults;
+}
+async function skipReservedPrimaryAgents(input) {
+  const results = [];
+  for (const agent of input.agents) {
+    const reservation = input.reservations.get(agent);
+    if (reservation)
+      input.budgetTracker.skip(reservation, input.reason);
+    await input.trace.write({
+      type: "model_call_skipped",
+      traceId: input.traceId,
+      kind: "primary",
+      agent,
+      reason: input.reason,
+      timestamp: new Date().toISOString()
+    });
+    const timestamp = new Date().toISOString();
+    results.push({
+      agent,
+      role: input.agentRoles[agent] ?? input.config.agents[agent].role,
+      status: "skipped",
+      startedAt: timestamp,
+      completedAt: timestamp,
+      error: {
+        code: "REVIEW_DEADLINE_EXCEEDED",
+        message: "Review deadline was reached before the agent could start."
+      }
+    });
+  }
   return results;
 }
+async function finalizeModelCallResult(input) {
+  const reason = input.result.error?.code ?? input.result.status;
+  const hasStarted = input.budgetTracker.hasStarted(input.reservation);
+  const canSkip = input.result.status === "skipped" || isPreflightAgentFailure(input.result) || !hasStarted && input.result.error?.code === "REVIEW_DEADLINE_EXCEEDED";
+  if (canSkip && !hasStarted) {
+    input.budgetTracker.skip(input.reservation, reason);
+    if (input.result.error?.code === "REVIEW_DEADLINE_EXCEEDED") {
+      input.budgetTracker.markIncomplete("deadline");
+    }
+    await input.trace.write({
+      type: "model_call_skipped",
+      traceId: input.traceId,
+      kind: input.reservation.kind,
+      agent: input.reservation.agent,
+      reason,
+      timestamp: new Date().toISOString()
+    });
+    return;
+  }
+  input.budgetTracker.markStarted(input.reservation);
+  const usage = normalizeModelTokenUsage(input.result.usage);
+  const outputBytes = input.result.outputBytes ?? (input.result.rawText ? Buffer.byteLength(input.result.rawText, "utf8") : undefined);
+  input.budgetTracker.complete(input.reservation, {
+    ...outputBytes === undefined ? {} : { outputBytes },
+    ...usage ? { usage } : {},
+    ...input.result.stopReason ? { stopReason: input.result.stopReason } : {}
+  });
+  if (input.result.error?.code === "AGENT_OUTPUT_LIMIT") {
+    input.budgetTracker.markIncomplete("agent_output_limit");
+  }
+  if (input.result.error?.code === "REVIEW_DEADLINE_EXCEEDED") {
+    input.budgetTracker.markIncomplete("deadline");
+  }
+  await input.trace.write({
+    type: "model_call_completed",
+    traceId: input.traceId,
+    kind: input.reservation.kind,
+    agent: input.reservation.agent,
+    resultStatus: input.result.status,
+    ...input.result.error?.code ? { errorCode: input.result.error.code } : {},
+    ...outputBytes === undefined ? {} : { outputBytes },
+    ...usage ? { usage } : {},
+    ...input.result.stopReason ? { stopReason: input.result.stopReason } : {},
+    timestamp: new Date().toISOString()
+  });
+}
+function isPreflightAgentFailure(result) {
+  return result.status === "failed" && [
+    "AGENT_CONFIG_INVALID",
+    "OPENROUTER_KEY_MISSING",
+    "AGENT_SPAWN_FAILED",
+    "AGENT_MANAGER_FAILED",
+    "AGENT_RESULT_MISSING"
+  ].includes(result.error?.code ?? "");
+}
 function resolveAgentRoles(config2) {
   const enabledAgents = ["codex", "claude"].filter((agent) => config2.agents[agent].enabled);
   const singleAgentMode = enabledAgents.length === 1;
@@ -192707,19 +194325,36 @@ function resolveAgentRoles(config2) {
   }
   return roles;
 }
-function defaultAgentManager(config2) {
-  if (process.env.KYOSO_TEST_FAKE_AGENTS === "1")
+function defaultAgentManager(config2, parentEnv) {
+  if (parentEnv.KYOSO_TEST_FAKE_AGENTS === "1") {
     return new FakeAgentManager;
-  return new SubprocessAcpAgentManager(config2);
-}
-function normalizeAgentRunResult(result) {
-  if (result.status === "completed" && result.rawText && !result.normalized) {
-    return {
-      ...result,
-      normalized: normalizeAgentOutput(result.agent, result.role, result.rawText)
-    };
   }
-  return result;
+  return new SubprocessAcpAgentManager(config2, parentEnv);
+}
+function normalizeAgentRunResult(result, maxFindingsPerAgent) {
+  const normalizedResult = result.status === "completed" && result.rawText && !result.normalized ? {
+    ...result,
+    normalized: normalizeAgentOutput(result.agent, result.role, result.rawText)
+  } : result;
+  const normalized = normalizedResult.normalized;
+  const findings = normalized?.findings;
+  if (!normalized || !findings || findings.length <= maxFindingsPerAgent) {
+    return { result: normalizedResult, findingsCapped: false };
+  }
+  const limitedFindings = findings.map((finding, index) => ({ finding, index })).sort((left, right) => {
+    const severity = compareSeverity(left.finding.severity, right.finding.severity);
+    return severity === 0 ? left.index - right.index : severity;
+  }).slice(0, maxFindingsPerAgent).map(({ finding }) => finding);
+  return {
+    result: {
+      ...normalizedResult,
+      normalized: {
+        ...normalized,
+        findings: limitedFindings
+      }
+    },
+    findingsCapped: true
+  };
 }
 function agentOpinionSummary(result, includeRawText = false) {
   const opinion = {
@@ -192741,8 +194376,12 @@ async function buildSecretBlockResult(input) {
   });
   const cisa = input.tool === "security_review" ? computeCisaGate([finding], []) : undefined;
   const completedAt = new Date().toISOString();
+  const budget = input.budgetTracker.snapshot();
   const resultWithoutMarkdown = {
     decision: "block",
+    completion: budget.completion,
+    executionBudget: budget.executionBudget,
+    requestFingerprint: input.requestFingerprint,
     degraded: false,
     agentsUsed: [],
     reviewMode: "multi_agent",
@@ -192778,9 +194417,16 @@ async function buildSecretBlockResult(input) {
       networkMode: input.networkMode,
       workspaceMode: "temp_snapshot",
       configHash: input.configHash,
-      warnings: input.warnings
+      warnings: input.warnings,
+      modelCalls: budget.modelCalls
     }
   };
+  await writeReviewBudgetCompleted({
+    trace: input.trace,
+    traceId: input.traceId,
+    budgetTracker: input.budgetTracker,
+    requestFingerprint: input.requestFingerprint
+  });
   await input.trace.write({
     type: "decision_completed",
     traceId: input.traceId,
@@ -192823,8 +194469,12 @@ function reindexFindings(findings) {
 }
 async function buildPolicyBlockResult(input) {
   const completedAt = new Date().toISOString();
+  const budget = input.budgetTracker.snapshot();
   const resultWithoutMarkdown = {
     decision: "block",
+    completion: budget.completion,
+    executionBudget: budget.executionBudget,
+    requestFingerprint: input.requestFingerprint,
     degraded: false,
     agentsUsed: [],
     reviewMode: "multi_agent",
@@ -192843,9 +194493,16 @@ async function buildPolicyBlockResult(input) {
       networkMode: input.networkMode,
       workspaceMode: "temp_snapshot",
       configHash: input.configHash,
-      warnings: [input.warning]
+      warnings: [input.warning],
+      modelCalls: budget.modelCalls
     }
   };
+  await writeReviewBudgetCompleted({
+    trace: input.trace,
+    traceId: input.traceId,
+    budgetTracker: input.budgetTracker,
+    requestFingerprint: input.requestFingerprint
+  });
   await input.trace.write({
     type: "decision_completed",
     traceId: input.traceId,
@@ -192882,6 +194539,33 @@ async function finalizeReviewResult(input) {
     })
   };
 }
+async function writeReviewBudgetPlanned(input) {
+  const snapshot = input.budgetTracker.snapshot();
+  await input.trace.write({
+    type: "review_budget_planned",
+    traceId: input.traceId,
+    requestFingerprint: input.requestFingerprint,
+    maxModelCalls: snapshot.executionBudget.maxModelCalls,
+    maxTotalWallTimeMs: snapshot.executionBudget.wallTime.limitMs,
+    maxAgentOutputBytes: snapshot.executionBudget.maxAgentOutputBytes,
+    maxFindingsPerAgent: snapshot.executionBudget.maxFindingsPerAgent,
+    skipOptionalPhasesWhenTokenUsageUnknown: snapshot.executionBudget.skipOptionalPhasesWhenTokenUsageUnknown,
+    timestamp: new Date().toISOString()
+  });
+}
+async function writeReviewBudgetCompleted(input) {
+  const snapshot = input.budgetTracker.snapshot();
+  await input.trace.write({
+    type: "review_budget_completed",
+    traceId: input.traceId,
+    requestFingerprint: input.requestFingerprint,
+    completion: snapshot.completion,
+    modelCalls: snapshot.executionBudget.modelCalls,
+    wallTime: snapshot.executionBudget.wallTime,
+    tokenUsage: snapshot.executionBudget.tokenUsage,
+    timestamp: new Date().toISOString()
+  });
+}
 function mergeDenyPatterns(configDeny, requestDeny) {
   return Array.from(new Set([...configDeny, ...requestDeny ?? []]));
 }