@kyo-so/cli 0.12.0 → 0.13.0

package/dist/index.js

@@ -183780,7 +183780,8 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/core/constants.ts
-var DEFAULT_AGENT_TIMEOUT_MS = 120000;
+var DEFAULT_AGENT_TIMEOUT_MS = 600000;
+var DEFAULT_WARN_AGENT_OUTPUT_BYTES = 524288;
 var MAX_AGENT_OUTPUT_BYTES = 1048576;
 var JUDGE_MAX_OUTPUT_TOKENS = 4096;
 var RAW_OUTPUT_MAX_CHARS = 16384;
@@ -183929,7 +183930,7 @@ var baseAgentSchema = exports_external.object({
     "architecture_security_reviewer",
     "combined_reviewer"
   ]),
-  timeoutMs: exports_external.number().int().positive().default(120000),
+  timeoutMs: exports_external.number().int().positive().default(DEFAULT_AGENT_TIMEOUT_MS),
   env: exports_external.record(exports_external.string(), exports_external.string()).default({}),
   auth: exports_external.object({
     mode: exports_external.literal("passthrough").default("passthrough"),
@@ -183960,6 +183961,7 @@ var codexAgentSchema = baseAgentSchema.extend({
 var reviewBudgetSchema = exports_external.object({
   maxModelCalls: exports_external.number().int().positive(),
   maxTotalWallTimeMs: exports_external.number().int().positive(),
+  warnAgentOutputBytes: exports_external.number().int().positive().max(MAX_AGENT_OUTPUT_BYTES),
   maxAgentOutputBytes: exports_external.number().int().positive().max(MAX_AGENT_OUTPUT_BYTES),
   maxFindingsPerAgent: exports_external.number().int().positive(),
   skipOptionalPhasesWhenTokenUsageUnknown: exports_external.boolean()
@@ -184035,13 +184037,21 @@ var kyosoConfigSchema = exports_external.object({
   })
 }).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."
-  });
+  if (config2.reviewBudget.maxModelCalls < enabledPrimaryReviewers) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["reviewBudget", "maxModelCalls"],
+      message: "must be greater than or equal to the number of enabled primary reviewers."
+    });
+  }
+  const inheritedLegacyHardLimit = config2.reviewBudget.warnAgentOutputBytes === DEFAULT_WARN_AGENT_OUTPUT_BYTES && config2.reviewBudget.maxAgentOutputBytes <= DEFAULT_WARN_AGENT_OUTPUT_BYTES;
+  if (config2.reviewBudget.warnAgentOutputBytes >= config2.reviewBudget.maxAgentOutputBytes && !inheritedLegacyHardLimit) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["reviewBudget", "warnAgentOutputBytes"],
+      message: "must be less than reviewBudget.maxAgentOutputBytes."
+    });
+  }
 });
 function agentConfigLeafPaths(agent) {
   const paths = [
@@ -184104,6 +184114,7 @@ var kyosoConfigKnownLeafPaths = [
   "verification.allowDemotion",
   "reviewBudget.maxModelCalls",
   "reviewBudget.maxTotalWallTimeMs",
+  "reviewBudget.warnAgentOutputBytes",
   "reviewBudget.maxAgentOutputBytes",
   "reviewBudget.maxFindingsPerAgent",
   "reviewBudget.skipOptionalPhasesWhenTokenUsageUnknown",
@@ -184149,9 +184160,9 @@ var defaultConfig = {
       enabled: true,
       type: "acp",
       command: "npx",
-      args: ["-y", "@agentclientprotocol/codex-acp@1.1.2"],
+      args: ["-y", "@agentclientprotocol/codex-acp@1.1.4"],
       role: "implementation_reviewer",
-      timeoutMs: 120000,
+      timeoutMs: DEFAULT_AGENT_TIMEOUT_MS,
       allowProjectProvider: [],
       env: {
         INITIAL_AGENT_MODE: "read-only",
@@ -184176,7 +184187,7 @@ var defaultConfig = {
       command: "npx",
       args: ["-y", "@agentclientprotocol/claude-agent-acp@0.58.1"],
       role: "architecture_security_reviewer",
-      timeoutMs: 300000,
+      timeoutMs: DEFAULT_AGENT_TIMEOUT_MS,
       env: {
         KYOSO_CHILD_AGENT: "1"
       },
@@ -184257,10 +184268,11 @@ var defaultConfig = {
   },
   reviewBudget: {
     maxModelCalls: 4,
-    maxTotalWallTimeMs: 480000,
-    maxAgentOutputBytes: 65536,
+    maxTotalWallTimeMs: 660000,
+    warnAgentOutputBytes: DEFAULT_WARN_AGENT_OUTPUT_BYTES,
+    maxAgentOutputBytes: 1048576,
     maxFindingsPerAgent: 10,
-    skipOptionalPhasesWhenTokenUsageUnknown: true
+    skipOptionalPhasesWhenTokenUsageUnknown: false
   },
   audit: {
     enabled: true,
@@ -185576,6 +185588,7 @@ async function loadConfig(options = {}) {
   if (!options.ignoreConfig) {
     if (await exists(globalConfigPath)) {
       const globalConfig2 = await loadTomlConfigFile(globalConfigPath);
+      validateExplicitReviewBudgetThresholds(globalConfig2, defaultConfig);
       const globalConfigWarnings = collectGlobalConfigWarnings(globalConfigPath, globalConfig2);
       const securitySensitiveWarnings = globalConfigWarnings.filter((warning) => warning.startsWith("security-sensitive unknown settings "));
       if (securitySensitiveWarnings.length > 0 && !options.allowUnknownConfig) {
@@ -185824,6 +185837,7 @@ async function loadProjectTsConfig(input) {
   });
   if (trustDecision.execute) {
     const userConfig = await loadUserConfig(canonicalPath, source);
+    validateExplicitReviewBudgetThresholds(userConfig, input.baseConfig);
     const projectChangesOpenRouterRoute = projectConfigChangesOpenRouterRoute(userConfig, input.baseConfig);
     await assertProjectOpenRouterAuthorization({
       projectConfig: userConfig,
@@ -185917,6 +185931,23 @@ function deepMerge2(base, override) {
   }
   return result;
 }
+function validateExplicitReviewBudgetThresholds(config2, baseConfig) {
+  const reviewBudget = readRecord(config2, "reviewBudget");
+  if (!reviewBudget || !Object.prototype.hasOwnProperty.call(reviewBudget, "warnAgentOutputBytes")) {
+    return;
+  }
+  const warnAgentOutputBytes = reviewBudget.warnAgentOutputBytes;
+  const maxAgentOutputBytes = Object.prototype.hasOwnProperty.call(reviewBudget, "maxAgentOutputBytes") ? reviewBudget.maxAgentOutputBytes : readRecord(baseConfig, "reviewBudget")?.maxAgentOutputBytes;
+  if (typeof warnAgentOutputBytes === "number" && typeof maxAgentOutputBytes === "number" && warnAgentOutputBytes >= maxAgentOutputBytes) {
+    throw new Error("reviewBudget.warnAgentOutputBytes must be less than reviewBudget.maxAgentOutputBytes.");
+  }
+}
+function readRecord(value, key) {
+  if (!isRecord3(value))
+    return;
+  const nested = value[key];
+  return isRecord3(nested) ? nested : undefined;
+}
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -189972,6 +190003,55 @@ var legacyClientNotificationMethods = new Set([
   CLIENT_METHODS.elicitation_complete
 ]);
 
+// src/core/modelExecutionIdentity.ts
+var MODEL_EXECUTION_IDENTITY_MAX_CHARS = 160;
+var MODEL_PROVIDER_ROUTES = new Set([
+  "codex_default",
+  "claude_default",
+  "openrouter",
+  "openai",
+  "anthropic"
+]);
+function createModelExecutionIdentity(input) {
+  const requestedModel = sanitizeIdentityValue(input.requestedModel);
+  const reportedProvider = sanitizeIdentityValue(input.reportedProvider);
+  const reportedModel = sanitizeIdentityValue(input.reportedModel);
+  const reportingStatus = reportedProvider !== undefined || reportedModel !== undefined ? "reported" : requestedModel !== undefined ? "requested_only" : "unknown";
+  return {
+    providerRoute: input.providerRoute,
+    ...requestedModel ? { requestedModel } : {},
+    ...reportedProvider ? { reportedProvider } : {},
+    ...reportedModel ? { reportedModel } : {},
+    reportingStatus
+  };
+}
+function normalizeModelExecutionIdentity(value) {
+  if (!isRecord6(value) || !isModelProviderRoute(value.providerRoute)) {
+    return;
+  }
+  return createModelExecutionIdentity({
+    providerRoute: value.providerRoute,
+    requestedModel: value.requestedModel,
+    reportedProvider: value.reportedProvider,
+    reportedModel: value.reportedModel
+  });
+}
+function sanitizeIdentityValue(value) {
+  if (typeof value !== "string")
+    return;
+  const sanitized = sanitizeTextForDisplay(value, MODEL_EXECUTION_IDENTITY_MAX_CHARS);
+  if (sanitized.includes(REDACTION) || /(?:https?|wss?):\/\//i.test(sanitized) || /\b(?:api[_-]?key|base[_-]?url|credential|secret|token|password)\b/i.test(sanitized) || /[{}=]/.test(sanitized)) {
+    return;
+  }
+  return sanitized.length > 0 ? sanitized : undefined;
+}
+function isModelProviderRoute(value) {
+  return typeof value === "string" && MODEL_PROVIDER_ROUTES.has(value);
+}
+function isRecord6(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/core/tokenUsage.ts
 var TOKEN_USAGE_KEYS = [
   "totalTokens",
@@ -189982,7 +190062,7 @@ var TOKEN_USAGE_KEYS = [
   "cachedWriteTokens"
 ];
 function normalizeModelTokenUsage(usage) {
-  if (!isRecord6(usage))
+  if (!isRecord7(usage))
     return;
   const normalized = {};
   for (const key of TOKEN_USAGE_KEYS) {
@@ -189995,7 +190075,7 @@ function normalizeModelTokenUsage(usage) {
 function isTokenCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -190048,7 +190128,19 @@ class ChildEnvPreflightError extends Error {
     this.name = "ChildEnvPreflightError";
   }
 }
-function buildChildEnv(parentEnv, whitelist, explicit, options = {}) {
+function buildChildLaunchContext(parentEnv, whitelist, explicit, options) {
+  const env = buildChildEnvironment(parentEnv, whitelist, explicit, options);
+  const openRouterSelected = options.agent === "codex" && options.provider === CODEX_OPENROUTER_PROVIDER;
+  const requestedModel = options.agent === "claude" ? env.ANTHROPIC_MODEL : readCodexRequestedModel(env.CODEX_CONFIG);
+  return {
+    env,
+    executionIdentity: createModelExecutionIdentity({
+      providerRoute: openRouterSelected ? "openrouter" : options.agent === "codex" ? "codex_default" : "claude_default",
+      requestedModel
+    })
+  };
+}
+function buildChildEnvironment(parentEnv, whitelist, explicit, options = {}) {
   if (!parentEnv.PATH) {
     throw new Error("PATH is required to launch ACP child agents.");
   }
@@ -190095,6 +190187,19 @@ function buildChildEnv(parentEnv, whitelist, explicit, options = {}) {
   }
   return env;
 }
+function readCodexRequestedModel(value) {
+  if (!value)
+    return;
+  try {
+    const parsed = JSON.parse(value);
+    if (!isPlainObject2(parsed) || typeof parsed.model !== "string") {
+      return;
+    }
+    return parsed.model;
+  } catch {
+    return;
+  }
+}
 function canCopyEnvValue(key, value, onCredentialPlaceholderDiscarded) {
   if (!isUnexpandedCredentialEnvValue(key, value))
     return true;
@@ -190235,6 +190340,45 @@ class BaseAcpAgentManager {
   }
 }
 
+// src/acp/ndJsonLineLimit.ts
+var JSON_STRING_MAX_ESCAPE_EXPANSION = 6;
+var ACP_NDJSON_ENVELOPE_BYTES = 2 * 1048576;
+var NEWLINE_BYTE = 10;
+var MAX_ACP_NDJSON_LINE_BYTES = MAX_AGENT_OUTPUT_BYTES * JSON_STRING_MAX_ESCAPE_EXPANSION + ACP_NDJSON_ENVELOPE_BYTES;
+
+class AcpNdJsonLineLimitError extends Error {
+  maxLineBytes;
+  constructor(maxLineBytes) {
+    super(`ACP NDJSON line exceeded ${maxLineBytes} bytes.`);
+    this.maxLineBytes = maxLineBytes;
+    this.name = "AcpNdJsonLineLimitError";
+  }
+}
+function limitAcpNdJsonLineBytes(input, maxLineBytes = MAX_ACP_NDJSON_LINE_BYTES) {
+  if (!Number.isSafeInteger(maxLineBytes) || maxLineBytes <= 0) {
+    throw new RangeError("ACP NDJSON line limit must be a positive integer.");
+  }
+  let pendingLineBytes = 0;
+  return input.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      let start = 0;
+      for (;; ) {
+        const newlineIndex = chunk.indexOf(NEWLINE_BYTE, start);
+        const end = newlineIndex === -1 ? chunk.byteLength : newlineIndex;
+        pendingLineBytes += end - start;
+        if (pendingLineBytes > maxLineBytes) {
+          throw new AcpNdJsonLineLimitError(maxLineBytes);
+        }
+        if (newlineIndex === -1)
+          break;
+        pendingLineBytes = 0;
+        start = newlineIndex + 1;
+      }
+      controller.enqueue(chunk);
+    }
+  }));
+}
+
 // src/core/findingAdmission.ts
 import { createHash as createHash2 } from "node:crypto";
 var SAFETY_CATEGORIES = new Set([
@@ -190576,6 +190720,43 @@ var evidenceQualities = [
 ];
 var MAX_EVIDENCE_REFS2 = 20;
 var MAX_EVIDENCE_LINE2 = 1e6;
+var STRICT_ROOT_KEYS = new Set([
+  "summary",
+  "findings",
+  "testsToAdd",
+  "residualRisks",
+  "openQuestions",
+  "cisaSecureByDesign"
+]);
+var STRICT_FINDING_KEYS = new Set([
+  "severity",
+  "category",
+  "title",
+  "evidence",
+  "recommendation",
+  "disposition",
+  "changeRelation",
+  "evidenceQuality",
+  "evidenceRefs",
+  "files",
+  "confidence",
+  "cisaMapping"
+]);
+var STRICT_FILE_KEYS = new Set(["path", "lineStart", "lineEnd"]);
+var STRICT_EVIDENCE_REF_KEYS = new Set([
+  "kind",
+  "path",
+  "lineStart",
+  "lineEnd",
+  "label"
+]);
+var STRICT_CISA_KEYS = new Set([
+  "customerSecurityOutcomes",
+  "secureByDefault",
+  "transparencyAndAccountability",
+  "governance",
+  "notes"
+]);
 function normalizeAgentOutput(agent, role, rawText) {
   const json2 = extractFirstJsonObject(rawText);
   if (!json2)
@@ -190609,6 +190790,19 @@ function normalizeAgentOutput(agent, role, rawText) {
     return parseFailureOpinion(agent, role, `Structured parse failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
   }
 }
+function parseAgentOutputStrict(agent, role, rawText) {
+  const json2 = extractFirstJsonObject(rawText);
+  if (!json2)
+    return;
+  try {
+    const parsed = JSON.parse(json2);
+    if (!isStrictAgentOpinion(parsed))
+      return;
+    return normalizeAgentOutput(agent, role, json2);
+  } catch {
+    return;
+  }
+}
 function extractFirstJsonObject(text) {
   const start = text.indexOf("{");
   if (start === -1)
@@ -190666,7 +190860,7 @@ function isSeverity(value) {
   return typeof value === "string" && severities.includes(value);
 }
 function normalizeCisaSecureByDesign(value) {
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     return;
   const normalized = {};
   const customerSecurityOutcomes = normalizeGateStatus(value.customerSecurityOutcomes);
@@ -190706,6 +190900,78 @@ function isChangeRelation(value) {
 function isEvidenceQuality(value) {
   return typeof value === "string" && evidenceQualities.includes(value);
 }
+function isStrictAgentOpinion(value) {
+  if (!isRecord8(value) || !hasOnlyKeys(value, STRICT_ROOT_KEYS))
+    return false;
+  if (typeof value.summary !== "string")
+    return false;
+  if (!Array.isArray(value.findings) || !value.findings.every(isStrictFinding) || !isStringArray(value.testsToAdd) || !isStringArray(value.residualRisks) || !isStringArray(value.openQuestions)) {
+    return false;
+  }
+  return value.cisaSecureByDesign === undefined || isStrictCisaSecureByDesign(value.cisaSecureByDesign);
+}
+function isStrictFinding(value) {
+  if (!isRecord8(value) || !hasOnlyKeys(value, STRICT_FINDING_KEYS)) {
+    return false;
+  }
+  if (!isSeverity(value.severity) || !isCategory(value.category) || !isNonEmptyString(value.title) || !isNonEmptyString(value.evidence) || !isNonEmptyString(value.recommendation) || !isConfidence(value.confidence)) {
+    return false;
+  }
+  if (value.disposition !== undefined && !isDisposition(value.disposition) || value.changeRelation !== undefined && !isChangeRelation(value.changeRelation) || value.evidenceQuality !== undefined && !isEvidenceQuality(value.evidenceQuality) || value.files !== undefined && !isStrictFindingFiles(value.files) || value.evidenceRefs !== undefined && !isStrictEvidenceRefs(value.evidenceRefs) || value.cisaMapping !== undefined && !isStringArray(value.cisaMapping)) {
+    return false;
+  }
+  return true;
+}
+function isStrictFindingFiles(value) {
+  return Array.isArray(value) && value.every((item) => isRecord8(item) && hasOnlyKeys(item, STRICT_FILE_KEYS) && isNonEmptyString(item.path) && isOptionalLineNumber(item.lineStart) && isOptionalLineNumber(item.lineEnd));
+}
+function isStrictEvidenceRefs(value) {
+  return Array.isArray(value) && value.length <= MAX_EVIDENCE_REFS2 && value.every((item) => {
+    if (!isRecord8(item) || !hasOnlyKeys(item, STRICT_EVIDENCE_REF_KEYS)) {
+      return false;
+    }
+    if (item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
+      return false;
+    }
+    if (!isOptionalNonEmptyString(item.path) || !isOptionalNonEmptyString(item.label) || !isOptionalLineNumber(item.lineStart) || !isOptionalLineNumber(item.lineEnd)) {
+      return false;
+    }
+    if (item.kind === "file" || item.kind === "diff_hunk") {
+      return item.path !== undefined && item.lineStart !== undefined;
+    }
+    return item.label !== undefined || item.lineStart !== undefined;
+  });
+}
+function isStrictCisaSecureByDesign(value) {
+  if (!isRecord8(value) || !hasOnlyKeys(value, STRICT_CISA_KEYS))
+    return false;
+  for (const key of [
+    "customerSecurityOutcomes",
+    "secureByDefault",
+    "transparencyAndAccountability",
+    "governance"
+  ]) {
+    if (value[key] !== undefined && !normalizeGateStatus(value[key])) {
+      return false;
+    }
+  }
+  return value.notes === undefined || isStringArray(value.notes);
+}
+function hasOnlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isOptionalNonEmptyString(value) {
+  return value === undefined || isNonEmptyString(value);
+}
+function isOptionalLineNumber(value) {
+  return value === undefined || normalizeLineNumber(value) !== undefined;
+}
 function normalizeStringList(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string").map((item) => sanitizeText(item)) : [];
 }
@@ -190716,7 +190982,7 @@ function normalizeFindingFiles(value) {
   if (!Array.isArray(value))
     return;
   const files = value.flatMap((item) => {
-    if (!isRecord7(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
+    if (!isRecord8(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
       return [];
     }
     const file2 = {
@@ -190736,7 +191002,7 @@ function normalizeEvidenceRefs2(value) {
   if (!Array.isArray(value))
     return;
   const references = value.slice(0, MAX_EVIDENCE_REFS2).flatMap((item) => {
-    if (!isRecord7(item) || item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
+    if (!isRecord8(item) || item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
       return [];
     }
     const reference = { kind: item.kind };
@@ -190759,7 +191025,7 @@ function normalizeEvidenceRefs2(value) {
 function normalizeLineNumber(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= MAX_EVIDENCE_LINE2 ? value : undefined;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -190785,9 +191051,9 @@ class SubprocessAcpAgentManager extends BaseAcpAgentManager {
       };
     }
     const provider = input.agent === "codex" ? this.config.agents.codex.provider : undefined;
-    let env;
+    let launchContext;
     try {
-      env = buildChildEnv(this.parentEnv, agentConfig.auth.envWhitelist, agentConfig.env, {
+      launchContext = buildChildLaunchContext(this.parentEnv, agentConfig.auth.envWhitelist, agentConfig.env, {
         agent: input.agent,
         model: agentConfig.model,
         provider,
@@ -190804,7 +191070,7 @@ class SubprocessAcpAgentManager extends BaseAcpAgentManager {
       };
     }
     try {
-      return await runSubprocessAgent(input.agent, agentConfig, input, env);
+      return await runSubprocessAgent(input.agent, agentConfig, input, launchContext.env, launchContext.executionIdentity);
     } catch (error51) {
       return {
         agent: input.agent,
@@ -190817,7 +191083,7 @@ class SubprocessAcpAgentManager extends BaseAcpAgentManager {
     }
   }
 }
-async function runSubprocessAgent(agent, agentConfig, input, env) {
+async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutionIdentity) {
   const startedAt = new Date().toISOString();
   const effectiveTimeoutMs = resolveEffectiveTimeoutMs(input);
   if (effectiveTimeoutMs <= 0) {
@@ -190842,11 +191108,15 @@ async function runSubprocessAgent(agent, agentConfig, input, env) {
     let stdout = "";
     let stderr3 = "";
     let settled = false;
+    let spawned = false;
     let startedWrite;
     child.once("spawn", () => {
       if (settled)
         return;
-      startedWrite = Promise.resolve().then(() => input.onStarted?.()).catch(() => {
+      spawned = true;
+      startedWrite = Promise.resolve().then(async () => {
+        await input.onStarted?.(launchExecutionIdentity);
+      }).catch(() => {
         return;
       });
     });
@@ -190856,7 +191126,8 @@ async function runSubprocessAgent(agent, agentConfig, input, env) {
         return;
       settled = true;
       clearTimeout(timeout);
-      (startedWrite ?? Promise.resolve()).then(() => resolveResult(result));
+      const finalResult = spawned && result.executionIdentity === undefined ? { ...result, executionIdentity: launchExecutionIdentity } : result;
+      (startedWrite ?? Promise.resolve()).then(() => resolveResult(finalResult));
     };
     const timeout = setTimeout(() => {
       abortController.abort(new Error("Kyoso agent timeout"));
@@ -190889,7 +191160,17 @@ async function runSubprocessAgent(agent, agentConfig, input, env) {
         error: failure
       });
     });
-    runAcpClientWorkflow(child, input, abortController, resolveEffortConfigOption(agent, agentConfig.effort)).then(({ rawText, warnings, usage, outputBytes, stopReason }) => {
+    runAcpClientWorkflow(child, input, abortController, resolveEffortConfigOption(agent, agentConfig.effort), launchExecutionIdentity).then(({
+      rawText,
+      warnings,
+      usage,
+      messageBytes,
+      thoughtBytes,
+      outputBytes,
+      outputWarningTriggered,
+      stopReason,
+      executionIdentity
+    }) => {
       stdout = rawText;
       const completed = stopReason === "end_turn";
       resolveOnce({
@@ -190900,8 +191181,12 @@ async function runSubprocessAgent(agent, agentConfig, input, env) {
         normalized: normalizeAgentOutput(agent, input.role, rawText),
         startedAt,
         completedAt: new Date().toISOString(),
+        messageBytes,
+        thoughtBytes,
         outputBytes,
+        outputWarningTriggered,
         stopReason,
+        executionIdentity,
         ...usage ? { usage } : {},
         ...warnings.length > 0 ? { warnings } : {},
         ...completed ? {} : {
@@ -190915,18 +191200,40 @@ async function runSubprocessAgent(agent, agentConfig, input, env) {
       const outputLimitError = findOutputLimitError(error51, abortController);
       if (outputLimitError) {
         stdout = outputLimitError.rawText;
+        const normalized = parseAgentOutputStrict(agent, input.role, stdout);
         resolveOnce({
           agent,
           role: input.role,
           status: "failed",
           rawText: stdout,
+          ...normalized ? { normalized, salvaged: true } : {},
+          messageBytes: outputLimitError.messageBytes,
+          thoughtBytes: outputLimitError.thoughtBytes,
           outputBytes: outputLimitError.outputBytes,
+          outputWarningTriggered: outputLimitError.outputWarningTriggered,
           stopReason: "cancelled",
           startedAt,
           completedAt: new Date().toISOString(),
           error: {
             code: "AGENT_OUTPUT_LIMIT",
-            message: `Agent output exceeded ${outputLimitError.maxOutputBytes} bytes and was cancelled.`
+            message: `Agent output exceeded the ${outputLimitError.maxOutputBytes}-byte hard limit (message: ${outputLimitError.messageBytes}, thought: ${outputLimitError.thoughtBytes}, total: ${outputLimitError.outputBytes}) and was cancelled. Adjust user-global reviewBudget.maxAgentOutputBytes to change this ceiling.`
+          }
+        });
+        return;
+      }
+      if (error51 instanceof AcpNdJsonLineLimitError) {
+        abortController.abort(error51);
+        resolveOnce({
+          agent,
+          role: input.role,
+          status: "failed",
+          rawText: stdout,
+          stopReason: "cancelled",
+          startedAt,
+          completedAt: new Date().toISOString(),
+          error: {
+            code: "AGENT_PROTOCOL_LIMIT",
+            message: `Agent emitted an ACP NDJSON line above the ${error51.maxLineBytes}-byte transport limit and was cancelled.`
           }
         });
         return;
@@ -190963,13 +191270,13 @@ async function runSubprocessAgent(agent, agentConfig, input, env) {
     });
   });
 }
-async function runAcpClientWorkflow(child, input, abortController, configOption) {
+async function runAcpClientWorkflow(child, input, abortController, configOption, launchExecutionIdentity) {
   if (!child.stdin || !child.stdout) {
     throw new Error("Agent process did not expose stdio streams.");
   }
   const output = Writable.toWeb(child.stdin);
   const inputStream = Readable.toWeb(child.stdout);
-  const stream2 = ndJsonStream(output, inputStream);
+  const stream2 = ndJsonStream(output, limitAcpNdJsonLineBytes(inputStream));
   const app = client({ name: "kyoso" }).onRequest(methods.client.session.requestPermission, () => ({
     outcome: { outcome: "cancelled" }
   })).onRequest(methods.client.fs.readTextFile, async (ctx) => ({
@@ -191030,7 +191337,10 @@ async function runAcpClientWorkflow(child, input, abortController, configOption)
         return;
       });
       let rawText = "";
+      let messageBytes = 0;
+      let thoughtBytes = 0;
       let outputBytes = 0;
+      let outputWarningTriggered = false;
       for (;; ) {
         const message = await session.nextUpdate();
         if (message.kind === "stop") {
@@ -191039,8 +191349,12 @@ async function runAcpClientWorkflow(child, input, abortController, configOption)
             rawText,
             warnings,
             ...usage ? { usage } : {},
+            messageBytes,
+            thoughtBytes,
             outputBytes,
-            stopReason: message.stopReason
+            outputWarningTriggered,
+            stopReason: message.stopReason,
+            executionIdentity: withReportedExecutionIdentity(launchExecutionIdentity, message.response._meta)
           };
         }
         const update = message.update;
@@ -191048,35 +191362,60 @@ async function runAcpClientWorkflow(child, input, abortController, configOption)
           continue;
         }
         const chunkBytes = Buffer.byteLength(update.content.text, "utf8");
-        const nextOutputBytes = outputBytes + chunkBytes;
+        const isMessage = update.sessionUpdate === "agent_message_chunk";
+        const nextMessageBytes = messageBytes + (isMessage ? chunkBytes : 0);
+        const nextThoughtBytes = thoughtBytes + (isMessage ? 0 : chunkBytes);
+        const nextOutputBytes = nextMessageBytes + nextThoughtBytes;
+        const nextOutputWarningTriggered = outputWarningTriggered || input.warnOutputBytes !== undefined && nextOutputBytes >= input.warnOutputBytes;
         if (input.maxOutputBytes !== undefined && nextOutputBytes > input.maxOutputBytes) {
+          const retainedRawText = isMessage ? `${rawText}${utf8Prefix(update.content.text, input.maxOutputBytes - outputBytes)}` : rawText;
           await ctx.notify(methods.agent.session.cancel, {
             sessionId: session.sessionId
           }).catch(() => {
             return;
           });
-          const error51 = new AgentOutputLimitError(rawText, nextOutputBytes, input.maxOutputBytes);
+          const error51 = new AgentOutputLimitError(retainedRawText, nextMessageBytes, nextThoughtBytes, nextOutputBytes, input.maxOutputBytes, nextOutputWarningTriggered);
           abortController.abort(error51);
           throw error51;
         }
-        if (update.sessionUpdate === "agent_message_chunk") {
+        if (isMessage) {
           rawText += update.content.text;
         }
+        messageBytes = nextMessageBytes;
+        thoughtBytes = nextThoughtBytes;
         outputBytes = nextOutputBytes;
+        outputWarningTriggered = nextOutputWarningTriggered;
       }
     });
   });
 }
+function utf8Prefix(input, maxBytes) {
+  const encoded = new TextEncoder().encode(input);
+  const budget = Math.max(0, Math.min(maxBytes, encoded.byteLength));
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  for (let end = budget;end > 0; end -= 1) {
+    try {
+      return decoder.decode(encoded.subarray(0, end));
+    } catch {}
+  }
+  return "";
+}
 
 class AgentOutputLimitError extends Error {
   rawText;
+  messageBytes;
+  thoughtBytes;
   outputBytes;
   maxOutputBytes;
-  constructor(rawText, outputBytes, maxOutputBytes) {
+  outputWarningTriggered;
+  constructor(rawText, messageBytes, thoughtBytes, outputBytes, maxOutputBytes, outputWarningTriggered) {
     super(`Agent output exceeded ${maxOutputBytes} bytes.`);
     this.rawText = rawText;
+    this.messageBytes = messageBytes;
+    this.thoughtBytes = thoughtBytes;
     this.outputBytes = outputBytes;
     this.maxOutputBytes = maxOutputBytes;
+    this.outputWarningTriggered = outputWarningTriggered;
     this.name = "AgentOutputLimitError";
   }
 }
@@ -191093,6 +191432,18 @@ function resolveEffectiveTimeoutMs(input) {
 function normalizeUsage(usage) {
   return normalizeModelTokenUsage(usage);
 }
+function withReportedExecutionIdentity(identity, metadata) {
+  const record2 = isRecord9(metadata) ? metadata : {};
+  return createModelExecutionIdentity({
+    providerRoute: identity.providerRoute,
+    requestedModel: identity.requestedModel,
+    reportedProvider: record2.provider,
+    reportedModel: record2.model
+  });
+}
+function isRecord9(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function resolveEffortConfigOption(agent, effort) {
   if (!effort)
     return;
@@ -191402,6 +191753,9 @@ function buildAgentPrompt(tool, request, agent, role, policy = {}) {
     "A formal finding requires a concrete file/line, diff hunk, or plan clause; an actual failure or exploit path; a change relation; and an executable recommendation.",
     "Put insufficiently supported hypotheses in openQuestions instead of findings.",
     "Do not create formal findings for style, formatting, generic hardening, unrelated pre-existing issues, duplicate tests, implementation-detail tests, or exhaustive boundary matrices.",
+    ...policy.maxFindingsTarget === undefined ? [] : [
+      `Avoid duplicates and aim for at most ${policy.maxFindingsTarget} findings in severity order, but do not hide a material finding solely to meet this target.`
+    ],
     "Recommend only specific regression scenarios tied to changed behavior, with at most three testsToAdd entries.",
     "Critical and High safety issues must still be reported when they match a non-goal.",
     "Write each finding title in concise English, regardless of the language used elsewhere. Titles are compared across agents for deduplication.",
@@ -192336,6 +192690,12 @@ function sanitizeForAudit(value, options = {}) {
   if (typeof value === "object" && value !== null) {
     const result = {};
     for (const [key, nested] of Object.entries(value)) {
+      if (key === "executionIdentity") {
+        const identity = normalizeModelExecutionIdentity(nested);
+        if (identity)
+          result[key] = identity;
+        continue;
+      }
       if (/raw|content|env|credential|token|secret|password/i.test(key) && !(options.includeRawAgentOutput && key === "rawText") && !isUsageMetadata(key, nested)) {
         continue;
       }
@@ -192616,7 +192976,7 @@ function validateReviewContract(request) {
   const contract = request.reviewContract;
   if (contract === undefined)
     return;
-  if (!isRecord8(contract)) {
+  if (!isRecord10(contract)) {
     throw new KyosoRequestError("reviewContract must be an object", "VALIDATION_ERROR");
   }
   const allowedKeys = new Set(["focus", "nonGoals", "acceptedRisks"]);
@@ -192633,7 +192993,7 @@ function validateReviewContract(request) {
     throw new KyosoRequestError("reviewContract.nonGoals must contain at most 20 non-empty strings of 500 characters or fewer", "VALIDATION_ERROR");
   }
   const acceptedRisks = contract.acceptedRisks;
-  if (acceptedRisks !== undefined && (!Array.isArray(acceptedRisks) || acceptedRisks.length > 20 || acceptedRisks.some((risk) => !isRecord8(risk) || typeof risk.findingFingerprint !== "string" || !/^sha256:[0-9a-f]{64}$/.test(risk.findingFingerprint) || typeof risk.rationale !== "string" || risk.rationale.trim().length === 0 || risk.rationale.length > 500))) {
+  if (acceptedRisks !== undefined && (!Array.isArray(acceptedRisks) || acceptedRisks.length > 20 || acceptedRisks.some((risk) => !isRecord10(risk) || typeof risk.findingFingerprint !== "string" || !/^sha256:[0-9a-f]{64}$/.test(risk.findingFingerprint) || typeof risk.rationale !== "string" || risk.rationale.trim().length === 0 || risk.rationale.length > 500))) {
     throw new KyosoRequestError("reviewContract.acceptedRisks must contain valid finding fingerprints and bounded rationales", "VALIDATION_ERROR");
   }
 }
@@ -192645,13 +193005,13 @@ function validateSelectedFiles(request) {
     throw new KyosoRequestError("selectedFiles must be an array", "VALIDATION_ERROR");
   }
   for (const file2 of selectedFiles) {
-    if (!isRecord8(file2) || typeof file2.path !== "string" || file2.path.trim().length === 0 || typeof file2.content !== "string" || file2.language !== undefined && typeof file2.language !== "string" || file2.truncated !== undefined && typeof file2.truncated !== "boolean") {
+    if (!isRecord10(file2) || typeof file2.path !== "string" || file2.path.trim().length === 0 || typeof file2.content !== "string" || file2.language !== undefined && typeof file2.language !== "string" || file2.truncated !== undefined && typeof file2.truncated !== "boolean") {
       throw new KyosoRequestError("selectedFiles entries require string path/content and valid optional metadata", "VALIDATION_ERROR");
     }
     normalizeRelativePath(file2.path);
   }
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -192664,7 +193024,7 @@ function renderMarkdownResult(tool, result, options = {}) {
     `**Mode:** ${tool}`,
     `**Completion:** ${formatCompletion(result)}`,
     `**Request fingerprint:** ${shortFingerprint(result.requestFingerprint)}`,
-    `**Agents:** ${result.agentOpinions.map((opinion) => `${title(opinion.agent)} ${opinion.status}`).join(", ")}`,
+    `**Agents:** ${result.agentOpinions.map((opinion) => `${title(opinion.agent)} ${opinion.status}${opinion.salvaged ? " (salvaged)" : ""}`).join(", ")}`,
     `**Review mode:** ${formatReviewMode(result)}`,
     ...result.verificationMode ? [
       `**Verification mode:** ${formatVerificationMode(result.verificationMode)}`
@@ -192715,7 +193075,7 @@ function renderMarkdownResult(tool, result, options = {}) {
   }
   lines.push("", "## Agent Opinions", "");
   for (const opinion of result.agentOpinions) {
-    lines.push(`### ${title(opinion.agent)}`, "", `${opinion.summary} (${opinion.status})`, "");
+    lines.push(`### ${title(opinion.agent)}`, "", `${opinion.summary} (${opinion.status}${opinion.salvaged ? ", salvaged" : ""})`, "");
   }
   lines.push("", "## Disagreements", "");
   if (result.reviewMode === "single_agent") {
@@ -192746,17 +193106,50 @@ function defaultSummaryText(result) {
 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 byteBreakdowns = new Map;
+  for (const call of result.audit.modelCalls) {
+    if (call.status !== "completed" || !call.agent)
+      continue;
+    const current = byteBreakdowns.get(call.agent) ?? {
+      messageBytes: 0,
+      thoughtBytes: 0
+    };
+    current.messageBytes += call.messageBytes ?? 0;
+    current.thoughtBytes += call.thoughtBytes ?? 0;
+    byteBreakdowns.set(call.agent, current);
+  }
+  const outputLines = agentOutputs.length > 0 ? agentOutputs.map(([agent, bytes]) => {
+    const breakdown = byteBreakdowns.get(agent);
+    return `- ${title(agent)}: ${bytes} bytes${breakdown ? ` (message: ${breakdown.messageBytes}, thought: ${breakdown.thoughtBytes})` : ""}`;
+  }) : ["- None reported."];
+  const identityLines = result.audit.modelCalls.filter((call) => call.status === "completed").map((call) => {
+    const label = [call.kind, call.agent].filter(Boolean).join("/");
+    const identity = call.executionIdentity;
+    if (!identity)
+      return `- ${label}: identity=unknown`;
+    const reportedIdentity = [
+      identity.reportedProvider ? `reportedProvider=${escapeMarkdownText(identity.reportedProvider)}` : undefined,
+      identity.reportedModel ? `reportedModel=${escapeMarkdownText(identity.reportedModel)}` : undefined
+    ].filter((value) => value !== undefined);
+    return `- ${label}: route=${identity.providerRoute}, requested=${escapeMarkdownText(identity.requestedModel ?? "unknown")}${reportedIdentity.length > 0 ? `, ${reportedIdentity.join(", ")}` : ""}, reporting=${identity.reportingStatus}`;
+  });
   const totalTokens = budget.tokenUsage.totals.totalTokens;
+  const plan = budget.modelCallPlan;
+  const outputLimits = budget.effectiveWarnAgentOutputBytes === undefined ? `${budget.maxAgentOutputBytes} bytes hard (soft warning disabled)` : `${budget.effectiveWarnAgentOutputBytes} bytes soft / ${budget.maxAgentOutputBytes} bytes hard`;
   return [
     "",
     "## Execution Budget",
     "",
-    `- Model calls: ${budget.modelCalls.planned} planned / ${budget.modelCalls.consumed} consumed / ${budget.modelCalls.skipped} skipped`,
+    `- Model calls: ${budget.modelCalls.planned} planned / ${budget.modelCalls.consumed} consumed / ${budget.modelCalls.skipped} skipped / ${budget.maxModelCalls} ceiling`,
+    `- Potential calls: ${plan.potentialTotalCalls} total (${plan.requiredPrimaryCalls} primary, ${plan.potentialVerifierCalls} verifier, ${plan.potentialJudgeCalls} judge)`,
     `- 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 limits: ${outputLimits}`,
+    `- Findings target: ${budget.maxFindingsPerAgent} per primary agent (soft)`,
     "- Agent output:",
-    ...outputLines
+    ...outputLines,
+    "- Model identities:",
+    ...identityLines.length > 0 ? identityLines : ["- None completed."]
   ];
 }
 function formatCompletion(result) {
@@ -192879,7 +193272,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 (!isRecord9(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
+    if (!isRecord11(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
       return [];
     }
     return [
@@ -192895,7 +193288,7 @@ function parseJudgeOutput(text, fallbackSummaryText) {
   return { summaryText, disagreementComments, analysis };
 }
 function parseAnalysis(value) {
-  if (!isRecord9(value))
+  if (!isRecord11(value))
     return;
   if (!Array.isArray(value.blindSpots) || !Array.isArray(value.contradictions) || !Array.isArray(value.partialCoverage)) {
     return;
@@ -192903,7 +193296,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 (!isRecord9(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
+      if (!isRecord11(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
         return [];
       }
       return [
@@ -192914,7 +193307,7 @@ function parseAnalysis(value) {
       ];
     }),
     partialCoverage: value.partialCoverage.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => {
-      if (!isRecord9(item) || typeof item.note !== "string")
+      if (!isRecord11(item) || typeof item.note !== "string")
         return [];
       const findingId = typeof item.findingId === "string" ? sanitizeAnalysisText(item.findingId) : undefined;
       return [
@@ -192961,15 +193354,20 @@ function extractFirstJsonObject2(text) {
   }
   return;
 }
-function isRecord9(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/judge/anthropic.ts
+var DEFAULT_ANTHROPIC_JUDGE_MODEL = "claude-haiku-4-5";
+function resolveAnthropicJudgeModel(env) {
+  return env.KYOSO_ANTHROPIC_JUDGE_MODEL ?? DEFAULT_ANTHROPIC_JUDGE_MODEL;
+}
 async function runAnthropicJudge(input, timeoutMs) {
   const apiKey = input.env.ANTHROPIC_API_KEY;
   if (!apiKey)
     throw new Error("ANTHROPIC_API_KEY is not configured.");
+  const requestedModel = resolveAnthropicJudgeModel(input.env);
   const response = await fetchWithTimeout(`${input.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com"}/v1/messages`, {
     method: "POST",
     headers: {
@@ -192978,7 +193376,7 @@ async function runAnthropicJudge(input, timeoutMs) {
       "content-type": "application/json"
     },
     body: JSON.stringify({
-      model: input.env.KYOSO_ANTHROPIC_JUDGE_MODEL ?? "claude-haiku-4-5",
+      model: requestedModel,
       max_tokens: JUDGE_MAX_OUTPUT_TOKENS,
       temperature: 0,
       messages: [
@@ -192996,8 +193394,11 @@ async function runAnthropicJudge(input, timeoutMs) {
   if (!content)
     throw new Error("Anthropic judge response did not include text content.");
   const usage = normalizeUsage2(payload.usage);
+  const reportedModel = typeof payload.model === "string" ? payload.model : undefined;
   return {
     output: parseJudgeOutput(content, input.summaryText),
+    requestedModel,
+    ...reportedModel ? { reportedModel } : {},
     ...usage ? { usage } : {}
   };
 }
@@ -193034,10 +193435,15 @@ function runDeterministicJudge(result, summaryText) {
 }
 
 // src/judge/openai.ts
+var DEFAULT_OPENAI_JUDGE_MODEL = "gpt-5.4-mini";
+function resolveOpenAiJudgeModel(env) {
+  return env.KYOSO_OPENAI_JUDGE_MODEL ?? DEFAULT_OPENAI_JUDGE_MODEL;
+}
 async function runOpenAiJudge(input, timeoutMs) {
   const apiKey = input.env.OPENAI_API_KEY ?? input.env.CODEX_API_KEY;
   if (!apiKey)
     throw new Error("OPENAI_API_KEY is not configured.");
+  const requestedModel = resolveOpenAiJudgeModel(input.env);
   const response = await fetchWithTimeout2(`${input.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1"}/chat/completions`, {
     method: "POST",
     headers: {
@@ -193045,7 +193451,7 @@ async function runOpenAiJudge(input, timeoutMs) {
       "content-type": "application/json"
     },
     body: JSON.stringify({
-      model: input.env.KYOSO_OPENAI_JUDGE_MODEL ?? "gpt-5.4-mini",
+      model: requestedModel,
       response_format: { type: "json_object" },
       messages: [
         {
@@ -193064,8 +193470,11 @@ async function runOpenAiJudge(input, timeoutMs) {
   if (!content)
     throw new Error("OpenAI judge response did not include content.");
   const usage = normalizeUsage3(payload.usage);
+  const reportedModel = typeof payload.model === "string" ? payload.model : undefined;
   return {
     output: parseJudgeOutput(content, input.summaryText),
+    requestedModel,
+    ...reportedModel ? { reportedModel } : {},
     ...usage ? { usage } : {}
   };
 }
@@ -193105,26 +193514,41 @@ function resolveJudgeProvider(provider, env) {
     return "anthropic";
   return "deterministic_fallback";
 }
+function resolveJudgeCallRoute(mode, provider, env) {
+  const resolvedProvider = resolveJudgeProvider(provider, env);
+  const credentialAvailable = resolvedProvider === "openai" && (hasEnv2(env, "OPENAI_API_KEY") || hasEnv2(env, "CODEX_API_KEY")) || resolvedProvider === "anthropic" && hasEnv2(env, "ANTHROPIC_API_KEY");
+  return {
+    provider: resolvedProvider,
+    llmAvailable: mode === "deterministic_plus_llm" && credentialAvailable
+  };
+}
 async function runJudge(input) {
   const fallback = runDeterministicJudge(input.result, input.summaryText);
-  if (input.config.mode === "deterministic_only") {
+  const configuredProvider = input.requestedProvider ?? input.config.provider;
+  const route = resolveJudgeCallRoute(input.config.mode, configuredProvider, input.env);
+  if (!route.llmAvailable) {
     return {
       provider: "deterministic_fallback",
       status: "deterministic_fallback",
       output: fallback
     };
   }
-  const configuredProvider = input.requestedProvider ?? input.config.provider;
-  const provider = resolveJudgeProvider(configuredProvider, input.env);
-  if (provider === "deterministic_fallback") {
-    return { provider, status: "deterministic_fallback", output: fallback };
-  }
+  const provider = route.provider;
+  const requestExecutionIdentity = createModelExecutionIdentity({
+    providerRoute: provider === "openai" ? "openai" : "anthropic",
+    requestedModel: provider === "openai" ? resolveOpenAiJudgeModel(input.env) : resolveAnthropicJudgeModel(input.env)
+  });
   try {
     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,
+      executionIdentity: createModelExecutionIdentity({
+        providerRoute: requestExecutionIdentity.providerRoute,
+        requestedModel: output.requestedModel,
+        reportedModel: output.reportedModel
+      }),
       ...output.usage ? { usage: output.usage } : {}
     };
   } catch (error51) {
@@ -193132,6 +193556,7 @@ async function runJudge(input) {
       provider,
       status: "failed_fallback",
       output: fallback,
+      executionIdentity: requestExecutionIdentity,
       error: error51 instanceof Error ? error51.message : String(error51)
     };
   }
@@ -193458,11 +193883,11 @@ function canonicalJson(value) {
 function canonicalize(value) {
   if (Array.isArray(value))
     return value.map(canonicalize);
-  if (!isRecord10(value))
+  if (!isRecord12(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 isRecord10(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -193476,12 +193901,10 @@ var REVIEW_BUDGET_KEYS = new Set([
 ]);
 var MODEL_CALL_KINDS = ["primary", "verifier", "judge"];
 function resolveReviewBudget(ceiling, requested) {
-  if (requested === undefined)
-    return ceiling;
-  if (!isRecord11(requested)) {
+  if (requested !== undefined && !isRecord13(requested)) {
     throw new KyosoRequestError("options.reviewBudget must be an object.", "REVIEW_BUDGET_INVALID");
   }
-  for (const [key, value] of Object.entries(requested)) {
+  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");
     }
@@ -193502,36 +193925,105 @@ function resolveReviewBudget(ceiling, requested) {
     "maxFindingsPerAgent"
   ];
   for (const key of numericKeys) {
-    const value = requested[key];
+    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) {
+  if (ceiling.skipOptionalPhasesWhenTokenUsageUnknown && requested?.skipOptionalPhasesWhenTokenUsageUnknown === false) {
     throw new KyosoRequestError("options.reviewBudget.skipOptionalPhasesWhenTokenUsageUnknown cannot relax the user-global ceiling.", "REVIEW_BUDGET_EXCEEDS_CEILING");
   }
+  const maxAgentOutputBytes = requested?.maxAgentOutputBytes ?? ceiling.maxAgentOutputBytes;
+  return {
+    maxModelCalls: requested?.maxModelCalls ?? ceiling.maxModelCalls,
+    maxTotalWallTimeMs: requested?.maxTotalWallTimeMs ?? ceiling.maxTotalWallTimeMs,
+    warnAgentOutputBytes: ceiling.warnAgentOutputBytes,
+    maxAgentOutputBytes,
+    maxFindingsPerAgent: requested?.maxFindingsPerAgent ?? ceiling.maxFindingsPerAgent,
+    skipOptionalPhasesWhenTokenUsageUnknown: ceiling.skipOptionalPhasesWhenTokenUsageUnknown || requested?.skipOptionalPhasesWhenTokenUsageUnknown === true,
+    ...ceiling.warnAgentOutputBytes < maxAgentOutputBytes ? { effectiveWarnAgentOutputBytes: ceiling.warnAgentOutputBytes } : {}
+  };
+}
+function buildReviewModelCallPlan(input) {
+  const requiredPrimaryCalls = nonNegativeInteger(input.requiredPrimaryCalls);
+  const potentialVerifierCalls = input.verificationEnabled && requiredPrimaryCalls === 2 ? Math.min(2, nonNegativeInteger(input.verificationMaxFindings)) : 0;
+  const potentialJudgeCalls = input.llmJudgeAvailable ? 1 : 0;
+  const potentialTotalCalls = requiredPrimaryCalls + potentialVerifierCalls + potentialJudgeCalls;
+  const ceilingEffects = [];
+  const availableCalls = nonNegativeInteger(input.maxModelCalls);
+  if (availableCalls < requiredPrimaryCalls) {
+    if (requiredPrimaryCalls > 0) {
+      ceilingEffects.push({
+        kind: "primary",
+        action: "skip",
+        calls: requiredPrimaryCalls,
+        reason: "model_call_budget"
+      });
+    }
+    if (potentialVerifierCalls > 0) {
+      ceilingEffects.push({
+        kind: "verifier",
+        action: "skip",
+        calls: potentialVerifierCalls,
+        reason: "model_call_budget"
+      });
+    }
+    if (potentialJudgeCalls > 0) {
+      ceilingEffects.push({
+        kind: "judge",
+        action: "deterministic_fallback",
+        calls: potentialJudgeCalls,
+        reason: "model_call_budget"
+      });
+    }
+  } else {
+    let remainingCalls = availableCalls - requiredPrimaryCalls;
+    const verifierCalls = Math.min(potentialVerifierCalls, remainingCalls);
+    remainingCalls -= verifierCalls;
+    const skippedVerifierCalls = potentialVerifierCalls - verifierCalls;
+    if (skippedVerifierCalls > 0) {
+      ceilingEffects.push({
+        kind: "verifier",
+        action: "skip",
+        calls: skippedVerifierCalls,
+        reason: "model_call_budget"
+      });
+    }
+    const judgeCalls = Math.min(potentialJudgeCalls, remainingCalls);
+    const fallbackJudgeCalls = potentialJudgeCalls - judgeCalls;
+    if (fallbackJudgeCalls > 0) {
+      ceilingEffects.push({
+        kind: "judge",
+        action: "deterministic_fallback",
+        calls: fallbackJudgeCalls,
+        reason: "model_call_budget"
+      });
+    }
+  }
   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
+    requiredPrimaryCalls,
+    potentialVerifierCalls,
+    potentialJudgeCalls,
+    potentialTotalCalls,
+    ceilingEffects
   };
 }
 
 class ReviewBudgetTracker {
   budget;
   startedAtEpochMs;
+  modelCallPlan;
   deadlineAtEpochMs;
   reservations = new Map;
   skippedCalls = [];
   incompleteReasons = new Set;
   nextReservationId = 1;
-  constructor(budget, startedAtEpochMs = Date.now()) {
+  constructor(budget, startedAtEpochMs = Date.now(), modelCallPlan = emptyReviewModelCallPlan()) {
     this.budget = budget;
     this.startedAtEpochMs = startedAtEpochMs;
+    this.modelCallPlan = modelCallPlan;
     this.deadlineAtEpochMs = startedAtEpochMs + budget.maxTotalWallTimeMs;
   }
   remainingWallTimeMs(now = Date.now()) {
@@ -193575,24 +194067,35 @@ class ReviewBudgetTracker {
     }
     return { reservation };
   }
-  markStarted(reservation) {
+  markStarted(reservation, executionIdentity) {
     const current = this.reservations.get(reservation.id);
     if (!current || current.status !== "reserved")
       return;
     current.status = "started";
+    current.executionIdentity = normalizeModelExecutionIdentity(executionIdentity);
   }
   hasStarted(reservation) {
     const current = this.reservations.get(reservation.id);
     return current?.status === "started" || current?.status === "completed";
   }
+  executionIdentity(reservation) {
+    return this.reservations.get(reservation.id)?.executionIdentity;
+  }
   complete(reservation, values = {}) {
     const current = this.reservations.get(reservation.id);
     if (!current || current.status === "skipped" || current.status === "completed") {
       return;
     }
     current.status = "completed";
+    current.messageBytes = values.messageBytes;
+    current.thoughtBytes = values.thoughtBytes;
     current.outputBytes = values.outputBytes;
+    current.outputWarningTriggered = values.outputWarningTriggered;
+    current.salvaged = values.salvaged;
+    current.reportedFindings = values.reportedFindings;
+    current.findingsTargetExceeded = values.findingsTargetExceeded;
     current.usage = normalizeModelTokenUsage(values.usage);
+    current.executionIdentity = normalizeModelExecutionIdentity(values.executionIdentity) ?? current.executionIdentity;
     current.stopReason = values.stopReason;
   }
   skip(reservation, reason) {
@@ -193665,12 +194168,16 @@ class ReviewBudgetTracker {
       },
       executionBudget: {
         maxModelCalls: this.budget.maxModelCalls,
+        modelCallPlan: this.modelCallPlan,
         modelCalls: { planned, consumed, skipped, byKind },
         wallTime: {
           limitMs: this.budget.maxTotalWallTimeMs,
           consumedMs,
           remainingMs: this.remainingWallTimeMs(now)
         },
+        ...this.budget.effectiveWarnAgentOutputBytes !== undefined ? {
+          effectiveWarnAgentOutputBytes: this.budget.effectiveWarnAgentOutputBytes
+        } : {},
         maxAgentOutputBytes: this.budget.maxAgentOutputBytes,
         maxFindingsPerAgent: this.budget.maxFindingsPerAgent,
         skipOptionalPhasesWhenTokenUsageUnknown: this.budget.skipOptionalPhasesWhenTokenUsageUnknown,
@@ -193694,8 +194201,15 @@ class ReviewBudgetTracker {
       ...reservation.agent ? { agent: reservation.agent } : {},
       status: reservation.status === "completed" ? "completed" : "skipped",
       ...reservation.reason ? { reason: reservation.reason } : {},
+      ...reservation.messageBytes !== undefined ? { messageBytes: reservation.messageBytes } : {},
+      ...reservation.thoughtBytes !== undefined ? { thoughtBytes: reservation.thoughtBytes } : {},
       ...reservation.outputBytes !== undefined ? { outputBytes: reservation.outputBytes } : {},
+      ...reservation.outputWarningTriggered !== undefined ? { outputWarningTriggered: reservation.outputWarningTriggered } : {},
+      ...reservation.salvaged !== undefined ? { salvaged: reservation.salvaged } : {},
+      ...reservation.reportedFindings !== undefined ? { reportedFindings: reservation.reportedFindings } : {},
+      ...reservation.findingsTargetExceeded !== undefined ? { findingsTargetExceeded: reservation.findingsTargetExceeded } : {},
       ...reservation.usage ? { usage: reservation.usage } : {},
+      ...reservation.executionIdentity ? { executionIdentity: reservation.executionIdentity } : {},
       ...reservation.stopReason ? { stopReason: reservation.stopReason } : {}
     }));
     return [...reservations, ...this.skippedCalls];
@@ -193719,7 +194233,19 @@ function addUsage(total, usage) {
 function isPositiveInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value > 0;
 }
-function isRecord11(value) {
+function nonNegativeInteger(value) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function emptyReviewModelCallPlan() {
+  return {
+    requiredPrimaryCalls: 0,
+    potentialVerifierCalls: 0,
+    potentialJudgeCalls: 0,
+    potentialTotalCalls: 0,
+    ceilingEffects: []
+  };
+}
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -193781,7 +194307,7 @@ function parseVerificationVerdicts(rawText) {
     if (!Array.isArray(parsed.verdicts))
       return;
     return parsed.verdicts.flatMap((item) => {
-      if (!isRecord12(item))
+      if (!isRecord14(item))
         return [];
       if (typeof item.findingId !== "string")
         return [];
@@ -193859,7 +194385,7 @@ function verificationNote(reasoning) {
 function isVerdict(value) {
   return value === "confirmed" || value === "refuted" || value === "uncertain";
 }
-function isRecord12(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -193884,13 +194410,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 reviewBudget = resolveReviewBudget(config2.reviewBudget, undefined);
+      const budgetTracker = new ReviewBudgetTracker(reviewBudget, startedAtEpochMs, configuredReviewModelCallPlan(config2, reviewBudget, options.env ?? process.env));
       const requestFingerprint = createRequestFingerprint({
         tool,
         request: requestForRecursionFingerprint(request),
         config: config2,
         roles: resolveAgentRoles(config2),
-        budget: config2.reviewBudget,
+        budget: reviewBudget,
         entrypoint: options.entrypoint
       });
       const trace2 = traceWriterFactory({
@@ -193996,7 +194523,7 @@ async function runReview(tool, request, options = {}) {
     });
     validateReviewRequest(tool, request);
     const reviewBudget = resolveReviewBudget(loaded.config.reviewBudget, request.options?.reviewBudget);
-    const budgetTracker = new ReviewBudgetTracker(reviewBudget, startedAtEpochMs);
+    const budgetTracker = new ReviewBudgetTracker(reviewBudget, startedAtEpochMs, configuredReviewModelCallPlan(loaded.config, reviewBudget, options.env ?? process.env, request.options?.judgeProvider));
     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) {
@@ -194117,6 +194644,7 @@ async function runReview(tool, request, options = {}) {
       budgetTracker,
       requestFingerprint
     });
+    warnings.push(...plannedBudgetWarnings(budgetTracker));
     snapshot = await createSnapshot(traceId, tool, built.request, {
       denyPatterns,
       allowPatterns,
@@ -194143,11 +194671,9 @@ async function runReview(tool, request, options = {}) {
       budgetTracker
     });
     warnings.push(...agentResults.flatMap((result) => (result.warnings ?? []).map((warning) => `Agent ${result.agent} ${warning}`)));
-    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 normalizedAgentResults = agentResults.map((result) => normalizeAgentRunResult(result, reviewBudget.maxFindingsPerAgent));
+    for (const result of normalizedAgentResults.filter((item) => item.findingsTargetExceeded)) {
+      warnings.push(`Agent ${result.agent} reported ${result.reportedFindings} findings, above the soft target of ${reviewBudget.maxFindingsPerAgent}; all findings were retained.`);
     }
     const enabledAgents = ["codex", "claude"].filter((agent) => loaded.config.agents[agent].enabled);
     const agentsUsed = normalizedAgentResults.filter((result) => result.status !== "skipped").map((result) => result.agent);
@@ -194321,6 +194847,11 @@ async function runReview(tool, request, options = {}) {
     }));
     const crossModelAnalysis = buildCrossModelAnalysis(judge, reviewMode);
     const budgetAfterJudge = budgetTracker.snapshot();
+    const finalWarnings = Array.from(new Set([
+      ...resultWithoutMarkdown.audit.warnings ?? [],
+      ...outputWarningMessages(budgetAfterJudge),
+      ...tokenUsageWarningMessages(budgetTracker, budgetAfterJudge)
+    ]));
     const finalDecision = budgetAfterJudge.completion.status === "incomplete" ? "block" : decision;
     const resultAfterJudge = {
       ...resultWithoutMarkdown,
@@ -194332,6 +194863,7 @@ async function runReview(tool, request, options = {}) {
       audit: {
         ...resultWithoutMarkdown.audit,
         completedAt: new Date().toISOString(),
+        warnings: finalWarnings,
         modelCalls: budgetAfterJudge.modelCalls
       }
     };
@@ -194340,6 +194872,7 @@ async function runReview(tool, request, options = {}) {
       traceId,
       provider: judge.provider,
       status: judge.status,
+      ...judge.executionIdentity ? { executionIdentity: judge.executionIdentity } : {},
       timestamp: new Date().toISOString()
     };
     if (judge.error)
@@ -194533,11 +195066,20 @@ async function runFindingVerification(input) {
     workspaceDir: input.workspaceDir,
     timeoutMs: Math.min(input.config.verification.timeoutMs, input.budgetTracker.remainingWallTimeMs()),
     deadlineAtEpochMs: input.budgetTracker.deadlineAtEpochMs,
+    warnOutputBytes: input.budgetTracker.budget.effectiveWarnAgentOutputBytes,
     maxOutputBytes: input.budgetTracker.budget.maxAgentOutputBytes,
     networkMode: input.networkMode,
-    onStarted: () => {
-      input.budgetTracker.markStarted(group.reservation);
-      return Promise.resolve();
+    onStarted: (executionIdentity) => {
+      input.budgetTracker.markStarted(group.reservation, executionIdentity);
+      const event = buildAgentStartedEvent({
+        traceId: input.traceId,
+        agent: group.verifier,
+        role: "finding_verifier",
+        executionIdentity: input.budgetTracker.executionIdentity(group.reservation)
+      });
+      return input.trace.write(event).catch(() => {
+        warnings.push("AUDIT_WRITE_FAILED: agent_started event could not be recorded.");
+      });
     }
   }));
   let results;
@@ -194679,8 +195221,8 @@ function buildCrossModelAnalysis(judge, reviewMode) {
 }
 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") {
+  const judgeRoute = resolveJudgeCallRoute(input.config.mode, configuredProvider, input.env);
+  if (!judgeRoute.llmAvailable) {
     return runJudge(input);
   }
   const fallback = () => runJudge({
@@ -194739,8 +195281,10 @@ async function runBudgetedJudge(input) {
   const judge = await runJudge({ ...input, timeoutMs });
   const usage = normalizeModelTokenUsage(judge.usage);
   input.budgetTracker.complete(reservation, {
-    ...usage ? { usage } : {}
+    ...usage ? { usage } : {},
+    ...judge.executionIdentity ? { executionIdentity: judge.executionIdentity } : {}
   });
+  const executionIdentity = input.budgetTracker.executionIdentity(reservation);
   await input.trace.write({
     type: "model_call_completed",
     traceId: input.traceId,
@@ -194748,6 +195292,7 @@ async function runBudgetedJudge(input) {
     provider: judge.provider,
     resultStatus: judge.status,
     ...usage ? { usage } : {},
+    ...executionIdentity ? { executionIdentity } : {},
     timestamp: new Date().toISOString()
   });
   return judge;
@@ -194861,30 +195406,25 @@ async function runAgents(input) {
       tool: input.tool,
       prompt: buildAgentPrompt(input.tool, input.request, agent, role, {
         requiredLenses,
-        cisaEnabled: input.config.securityReview.cisaSecureByDesign.enabled
+        cisaEnabled: input.config.securityReview.cisaSecureByDesign.enabled,
+        maxFindingsTarget: input.budgetTracker.budget.maxFindingsPerAgent
       }),
       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,
+      warnOutputBytes: input.budgetTracker.budget.effectiveWarnAgentOutputBytes,
       maxOutputBytes: input.budgetTracker.budget.maxAgentOutputBytes,
       networkMode: input.networkMode,
-      onStarted: () => {
-        input.budgetTracker.markStarted(reservation);
+      onStarted: (executionIdentity) => {
+        input.budgetTracker.markStarted(reservation, executionIdentity);
         if (!acceptingStartedEvents)
           return Promise.resolve();
-        const event = {
-          type: "agent_started",
+        const event = buildAgentStartedEvent({
           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;
-        }
+          executionIdentity: input.budgetTracker.executionIdentity(reservation)
+        });
         const write = (async () => {
           try {
             await input.trace.write(event);
@@ -194936,7 +195476,8 @@ async function runAgents(input) {
       }
     };
   });
-  for (const result of orderedResults) {
+  const normalizedResults = orderedResults.map((result) => normalizeAgentRunResult(result, input.budgetTracker.budget.maxFindingsPerAgent));
+  for (const result of normalizedResults) {
     const reservation = reservations.get(result.agent);
     if (!reservation)
       continue;
@@ -194951,7 +195492,7 @@ async function runAgents(input) {
       input.budgetTracker.markIncomplete("coverage_incomplete");
     }
   }
-  await Promise.all(orderedResults.map((result) => {
+  await Promise.all(normalizedResults.map((result) => {
     const event = {
       type: "agent_completed",
       traceId: input.traceId,
@@ -194966,12 +195507,20 @@ async function runAgents(input) {
       event.errorCode = result.error.code;
       event.errorDetail = result.error.detail;
     }
+    if (result.salvaged !== undefined)
+      event.salvaged = result.salvaged;
+    if (result.reportedFindings !== undefined) {
+      event.reportedFindings = result.reportedFindings;
+    }
+    if (result.findingsTargetExceeded !== undefined) {
+      event.findingsTargetExceeded = result.findingsTargetExceeded;
+    }
     if (input.config.audit.includeRawAgentOutput && result.rawText) {
       event.rawText = sanitizeTextForRawOutput(result.rawText);
     }
     return input.trace.write(event);
   }));
-  return orderedResults;
+  return normalizedResults;
 }
 async function skipReservedPrimaryAgents(input) {
   const results = [];
@@ -195021,20 +195570,44 @@ async function finalizeModelCallResult(input) {
     });
     return;
   }
-  input.budgetTracker.markStarted(input.reservation);
+  input.budgetTracker.markStarted(input.reservation, input.result.executionIdentity);
   const usage = normalizeModelTokenUsage(input.result.usage);
-  const outputBytes = input.result.outputBytes ?? (input.result.rawText ? Buffer.byteLength(input.result.rawText, "utf8") : undefined);
+  const { messageBytes, thoughtBytes, outputBytes } = resolveOutputByteMetrics(input.result);
+  const warningThreshold = input.budgetTracker.budget.effectiveWarnAgentOutputBytes;
+  const warningTriggered = warningThreshold !== undefined && outputBytes !== undefined && (input.result.outputWarningTriggered === true || outputBytes >= warningThreshold);
+  const outputWarningTriggered = warningTriggered || input.result.outputWarningTriggered !== undefined ? warningTriggered : undefined;
   input.budgetTracker.complete(input.reservation, {
+    ...messageBytes === undefined ? {} : { messageBytes },
+    ...thoughtBytes === undefined ? {} : { thoughtBytes },
     ...outputBytes === undefined ? {} : { outputBytes },
+    ...outputWarningTriggered === undefined ? {} : { outputWarningTriggered },
+    ...input.result.salvaged === undefined ? {} : { salvaged: input.result.salvaged },
+    ...input.result.reportedFindings === undefined ? {} : { reportedFindings: input.result.reportedFindings },
+    ...input.result.findingsTargetExceeded === undefined ? {} : { findingsTargetExceeded: input.result.findingsTargetExceeded },
     ...usage ? { usage } : {},
+    ...input.result.executionIdentity ? { executionIdentity: input.result.executionIdentity } : {},
     ...input.result.stopReason ? { stopReason: input.result.stopReason } : {}
   });
+  const executionIdentity = input.budgetTracker.executionIdentity(input.reservation);
   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");
   }
+  if (outputWarningTriggered && warningThreshold !== undefined && messageBytes !== undefined && thoughtBytes !== undefined && outputBytes !== undefined) {
+    await input.trace.write({
+      type: "agent_output_warning",
+      traceId: input.traceId,
+      kind: input.reservation.kind,
+      agent: input.reservation.agent,
+      thresholdBytes: warningThreshold,
+      messageBytes,
+      thoughtBytes,
+      outputBytes,
+      timestamp: new Date().toISOString()
+    });
+  }
   await input.trace.write({
     type: "model_call_completed",
     traceId: input.traceId,
@@ -195042,12 +195615,55 @@ async function finalizeModelCallResult(input) {
     agent: input.reservation.agent,
     resultStatus: input.result.status,
     ...input.result.error?.code ? { errorCode: input.result.error.code } : {},
+    ...messageBytes === undefined ? {} : { messageBytes },
+    ...thoughtBytes === undefined ? {} : { thoughtBytes },
     ...outputBytes === undefined ? {} : { outputBytes },
+    ...outputWarningTriggered === undefined ? {} : { outputWarningTriggered },
+    ...input.result.salvaged === undefined ? {} : { salvaged: input.result.salvaged },
+    ...input.result.reportedFindings === undefined ? {} : { reportedFindings: input.result.reportedFindings },
+    ...input.result.findingsTargetExceeded === undefined ? {} : { findingsTargetExceeded: input.result.findingsTargetExceeded },
     ...usage ? { usage } : {},
+    ...executionIdentity ? { executionIdentity } : {},
     ...input.result.stopReason ? { stopReason: input.result.stopReason } : {},
     timestamp: new Date().toISOString()
   });
 }
+function buildAgentStartedEvent(input) {
+  const executionIdentity = normalizeModelExecutionIdentity(input.executionIdentity);
+  return {
+    type: "agent_started",
+    traceId: input.traceId,
+    agent: input.agent,
+    role: input.role,
+    ...executionIdentity ? { executionIdentity } : {},
+    ...executionIdentity?.requestedModel ? { model: executionIdentity.requestedModel } : {},
+    ...executionIdentity?.providerRoute === "openrouter" ? { provider: "openrouter" } : {},
+    timestamp: new Date().toISOString()
+  };
+}
+function resolveOutputByteMetrics(result) {
+  const rawTextBytes = result.rawText ? Buffer.byteLength(result.rawText, "utf8") : undefined;
+  let messageBytes = result.messageBytes;
+  let thoughtBytes = result.thoughtBytes;
+  if (messageBytes === undefined && thoughtBytes === undefined) {
+    if (rawTextBytes !== undefined) {
+      messageBytes = rawTextBytes;
+      thoughtBytes = result.outputBytes === undefined ? 0 : Math.max(0, result.outputBytes - rawTextBytes);
+    } else if (result.outputBytes !== undefined) {
+      messageBytes = result.outputBytes;
+      thoughtBytes = 0;
+    }
+  } else if (messageBytes === undefined) {
+    messageBytes = result.outputBytes === undefined ? rawTextBytes ?? 0 : Math.max(0, result.outputBytes - (thoughtBytes ?? 0));
+  } else if (thoughtBytes === undefined) {
+    thoughtBytes = result.outputBytes === undefined ? 0 : Math.max(0, result.outputBytes - messageBytes);
+  }
+  return {
+    ...messageBytes === undefined ? {} : { messageBytes },
+    ...thoughtBytes === undefined ? {} : { thoughtBytes },
+    ...messageBytes === undefined || thoughtBytes === undefined ? {} : { outputBytes: messageBytes + thoughtBytes }
+  };
+}
 function isPreflightAgentFailure(result) {
   return result.status === "failed" && [
     "AGENT_CONFIG_INVALID",
@@ -195125,24 +195741,11 @@ function normalizeAgentRunResult(result, maxFindingsPerAgent) {
     ...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
+  const reportedFindings = normalizedResult.normalized?.findings.length;
+  return reportedFindings === undefined ? normalizedResult : {
+    ...normalizedResult,
+    reportedFindings,
+    findingsTargetExceeded: reportedFindings > maxFindingsPerAgent
   };
 }
 function agentOpinionSummary(result, includeRawText = false) {
@@ -195151,7 +195754,8 @@ function agentOpinionSummary(result, includeRawText = false) {
     role: result.role,
     summary: result.normalized?.summary ?? sanitizeTextForDisplay(result.error?.message ?? result.status),
     status: result.status,
-    errorCode: result.error?.code
+    errorCode: result.error?.code,
+    ...result.salvaged === undefined ? {} : { salvaged: result.salvaged }
   };
   if (includeRawText && result.rawText) {
     opinion.rawText = sanitizeTextForRawOutput(result.rawText);
@@ -195353,12 +195957,60 @@ async function writeReviewBudgetPlanned(input) {
     requestFingerprint: input.requestFingerprint,
     maxModelCalls: snapshot.executionBudget.maxModelCalls,
     maxTotalWallTimeMs: snapshot.executionBudget.wallTime.limitMs,
+    ...snapshot.executionBudget.effectiveWarnAgentOutputBytes !== undefined ? {
+      effectiveWarnAgentOutputBytes: snapshot.executionBudget.effectiveWarnAgentOutputBytes
+    } : {},
     maxAgentOutputBytes: snapshot.executionBudget.maxAgentOutputBytes,
     maxFindingsPerAgent: snapshot.executionBudget.maxFindingsPerAgent,
     skipOptionalPhasesWhenTokenUsageUnknown: snapshot.executionBudget.skipOptionalPhasesWhenTokenUsageUnknown,
+    ...snapshot.executionBudget.modelCallPlan,
     timestamp: new Date().toISOString()
   });
 }
+function plannedBudgetWarnings(budgetTracker) {
+  const fallbackCalls = budgetTracker.modelCallPlan.ceilingEffects.filter((effect) => effect.kind === "judge" && effect.action === "deterministic_fallback" && effect.reason === "model_call_budget").reduce((total, effect) => total + effect.calls, 0);
+  if (fallbackCalls === 0)
+    return [];
+  return [
+    `The potential model-call plan requires ${budgetTracker.modelCallPlan.potentialTotalCalls} calls, above maxModelCalls=${budgetTracker.budget.maxModelCalls}; ${fallbackCalls} LLM judge call(s) will use deterministic fallback if higher-priority calls consume the available capacity.`
+  ];
+}
+function outputWarningMessages(snapshot) {
+  const threshold = snapshot.executionBudget.effectiveWarnAgentOutputBytes;
+  if (threshold === undefined)
+    return [];
+  return snapshot.modelCalls.flatMap((call) => {
+    if (call.status !== "completed" || !call.outputWarningTriggered || !call.agent) {
+      return [];
+    }
+    const messageBytes = call.messageBytes ?? 0;
+    const thoughtBytes = call.thoughtBytes ?? 0;
+    const outputBytes = call.outputBytes ?? messageBytes + thoughtBytes;
+    const outcome = call.stopReason === "cancelled" ? "the hard breaker subsequently stopped execution." : "execution continued.";
+    return [
+      `Agent ${call.agent} ${call.kind} output reached the ${threshold}-byte soft threshold (message: ${messageBytes}, thought: ${thoughtBytes}, total: ${outputBytes}); ${outcome}`
+    ];
+  });
+}
+function tokenUsageWarningMessages(budgetTracker, snapshot) {
+  const unknownCalls = snapshot.executionBudget.tokenUsage.unknownCalls;
+  if (budgetTracker.budget.skipOptionalPhasesWhenTokenUsageUnknown || unknownCalls === 0) {
+    return [];
+  }
+  return [
+    `Token usage was not reported for ${unknownCalls} completed call(s); budget enforcement continued using calls, wall time, and bytes.`
+  ];
+}
+function configuredReviewModelCallPlan(config2, budget, env, requestedJudgeProvider) {
+  const judgeRoute = resolveJudgeCallRoute(config2.judge.mode, requestedJudgeProvider ?? config2.judge.provider, env);
+  return buildReviewModelCallPlan({
+    maxModelCalls: budget.maxModelCalls,
+    requiredPrimaryCalls: Object.values(config2.agents).filter((agent) => agent.enabled).length,
+    verificationEnabled: config2.verification.enabled,
+    verificationMaxFindings: config2.verification.maxFindings,
+    llmJudgeAvailable: judgeRoute.llmAvailable
+  });
+}
 async function writeReviewBudgetCompleted(input) {
   const snapshot = input.budgetTracker.snapshot();
   await input.trace.write({