@kyo-so/cli 0.14.0 → 0.15.0

package/dist/index.js

@@ -183918,6 +183918,7 @@ ${typeof file2.content === "string" ? file2.content.slice(0, 2000) : ""}`)
 var CODEX_OPENROUTER_PROVIDER = "openrouter";
 var CODEX_DEFAULT_PROVIDER = "default";
 var CODEX_OPENROUTER_MODEL_REQUIRED_ISSUE = "codex_openrouter_model_required";
+var CODEX_OPENROUTER_POLICY_REQUIRES_PROVIDER_ISSUE = "codex_openrouter_policy_requires_provider";
 var baseAgentSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   type: exports_external.literal("acp").default("acp"),
@@ -183940,12 +183941,29 @@ var baseAgentSchema = exports_external.object({
     envWhitelist: exports_external.array(exports_external.string())
   })
 });
+var codexOpenRouterSchema = exports_external.object({
+  streamIdleTimeoutMs: exports_external.number().int().min(1000).optional(),
+  streamMaxRetries: exports_external.number().int().min(0).max(100).optional(),
+  requestMaxRetries: exports_external.number().int().min(0).max(100).optional()
+});
 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([])
+  })).default([]),
+  openRouter: codexOpenRouterSchema.default({})
 }).superRefine((agent, context) => {
+  const hasOpenRouterPolicy = Object.values(agent.openRouter).some((value) => value !== undefined);
+  if (hasOpenRouterPolicy && agent.provider !== CODEX_OPENROUTER_PROVIDER) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["openRouter"],
+      message: 'agents.codex.openRouter.* requires provider = "openrouter".',
+      params: {
+        kyosoIssue: CODEX_OPENROUTER_POLICY_REQUIRES_PROVIDER_ISSUE
+      }
+    });
+  }
   if (agent.provider !== CODEX_OPENROUTER_PROVIDER || (agent.model?.trim().length ?? 0) > 0) {
     return;
   }
@@ -184071,7 +184089,7 @@ function agentConfigLeafPaths(agent) {
     `agents.${agent}.auth.envWhitelist`
   ];
   if (agent === "codex") {
-    paths.push("agents.codex.provider", "agents.codex.allowProjectProvider");
+    paths.push("agents.codex.provider", "agents.codex.allowProjectProvider", "agents.codex.openRouter.streamIdleTimeoutMs", "agents.codex.openRouter.streamMaxRetries", "agents.codex.openRouter.requestMaxRetries");
   }
   return paths;
 }
@@ -184302,6 +184320,9 @@ var kyosoConfigOverridePaths = [
   "agents.codex.enabled",
   "agents.codex.model",
   "agents.codex.provider",
+  "agents.codex.openRouter.streamIdleTimeoutMs",
+  "agents.codex.openRouter.streamMaxRetries",
+  "agents.codex.openRouter.requestMaxRetries",
   "agents.codex.effort",
   "agents.codex.role",
   "agents.codex.timeoutMs",
@@ -185715,7 +185736,7 @@ async function loadProjectConfig(input) {
   const extension = extname2(requestedPath);
   if (extension === ".toml") {
     const projectTomlConfig = await loadTomlConfigFile(canonicalPath);
-    const projectChangesOpenRouterRoute = projectConfigChangesOpenRouterRoute(projectTomlConfig, input.baseConfig);
+    const projectChangesOpenRouterPolicy = projectConfigChangesOpenRouterPolicy(projectTomlConfig, input.baseConfig);
     await assertProjectOpenRouterAuthorization({
       projectConfig: projectTomlConfig,
       projectPath: requestedPath,
@@ -185733,7 +185754,7 @@ async function loadProjectConfig(input) {
       configPath: requestedPath,
       configTrustStatus: "not_found",
       source: { path: requestedPath, layer: "project_toml" },
-      warnings: projectChangesOpenRouterRoute ? [openRouterProjectConfigWarning(requestedPath)] : []
+      warnings: projectChangesOpenRouterPolicy ? [openRouterProjectConfigWarning(requestedPath)] : []
     };
   }
   if (extension === ".ts") {
@@ -185750,30 +185771,35 @@ function projectConfigSelectsDefaultProvider(config2) {
 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 projectConfigSuppliesOpenRouterPolicy(config2) {
+  return flattenLeaves(config2).some((leaf) => leaf.path.join(".").startsWith("agents.codex.openRouter."));
+}
+function projectConfigChangesOpenRouterPolicy(projectConfig, baseConfig) {
+  return projectConfigSelectsOpenRouter(projectConfig) || configSelectsOpenRouter(baseConfig) && !projectConfigSelectsDefaultProvider(projectConfig) && (projectConfigSuppliesCodexModel(projectConfig) || projectConfigSuppliesOpenRouterPolicy(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)) {
+  if (!projectConfigSelectsDefaultProvider(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"));
+  const shouldClearInheritedModel = !projectConfigSuppliesCodexModel(projectConfig);
+  const shouldClearInheritedOpenRouterPolicy = !projectConfigSuppliesOpenRouterPolicy(projectConfig);
+  const codexWithoutInheritedOpenRouterConfig = Object.fromEntries(Object.entries(mergedConfig.agents.codex).filter(([key]) => (!shouldClearInheritedModel || key !== "model") && (!shouldClearInheritedOpenRouterPolicy || key !== "openRouter")));
   return {
     ...mergedConfig,
     agents: {
       ...mergedConfig.agents,
-      codex: codexWithoutInheritedModel
+      codex: codexWithoutInheritedOpenRouterConfig
     }
   };
 }
 function openRouterProjectConfigWarning(configPath) {
-  return `Project config ${sanitizeWarningText(configPath)} changes Codex OpenRouter routing under user-global authorization; it can route Codex review content through OpenRouter.`;
+  return `Project config ${sanitizeWarningText(configPath)} changes Codex OpenRouter routing or transport retry policy under user-global authorization; it can route Codex review content through OpenRouter.`;
 }
 async function assertProjectOpenRouterAuthorization(input) {
-  if (!projectConfigChangesOpenRouterRoute(input.projectConfig, input.baseConfig)) {
+  if (!projectConfigChangesOpenRouterPolicy(input.projectConfig, input.baseConfig)) {
     return;
   }
   if (await projectProviderIsAuthorized(input.baseConfig, input.projectDirectory)) {
@@ -185838,7 +185864,7 @@ async function loadProjectTsConfig(input) {
   if (trustDecision.execute) {
     const userConfig = await loadUserConfig(canonicalPath, source);
     validateExplicitReviewBudgetThresholds(userConfig, input.baseConfig);
-    const projectChangesOpenRouterRoute = projectConfigChangesOpenRouterRoute(userConfig, input.baseConfig);
+    const projectChangesOpenRouterPolicy = projectConfigChangesOpenRouterPolicy(userConfig, input.baseConfig);
     await assertProjectOpenRouterAuthorization({
       projectConfig: userConfig,
       projectPath: requestedPath,
@@ -185851,7 +185877,7 @@ async function loadProjectTsConfig(input) {
       await trustConfig(trustStorePath, canonicalPath, configHash);
     }
     const projectMergedConfig = deepMerge2(input.baseConfig, userConfig);
-    if (projectChangesOpenRouterRoute) {
+    if (projectChangesOpenRouterPolicy) {
       warnings.push(openRouterProjectConfigWarning(requestedPath));
     }
     return {
@@ -185962,6 +185988,11 @@ async function exists(path) {
 
 // src/config/configOverrides.ts
 var NUMBER_VALUE = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+var UNSET_NUMBER_OVERRIDE_PATHS = new Set([
+  "agents.codex.openRouter.streamIdleTimeoutMs",
+  "agents.codex.openRouter.streamMaxRetries",
+  "agents.codex.openRouter.requestMaxRetries"
+]);
 function applyConfigOverrides(config2, assignments) {
   if (assignments.length === 0)
     return config2;
@@ -185969,9 +186000,9 @@ function applyConfigOverrides(config2, assignments) {
   const baseConfig = config2;
   const overridden = structuredClone(config2);
   for (const override of overrides) {
-    writePath2(overridden, override.path, parseConfigOverrideValue(override.value, readPath2(baseConfig, override.path)));
+    writePath2(overridden, override.path, parseConfigOverrideValue(override.value, readPath2(baseConfig, override.path), override.path));
   }
-  clearInheritedOpenRouterModelForProviderReset(baseConfig, overridden, overrides);
+  clearInheritedOpenRouterConfigForProviderReset(baseConfig, overridden, overrides);
   assertOpenRouterProviderOverrideIncludesModel(baseConfig, overridden, overrides);
   const parsed = kyosoConfigSchema.safeParse(overridden);
   if (parsed.success)
@@ -185992,17 +186023,23 @@ function assertOpenRouterProviderOverrideIncludesModel(baseConfig, overridden, o
   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) {
+function clearInheritedOpenRouterConfigForProviderReset(baseConfig, overridden, overrides) {
   const providerPath = ["agents", "codex", "provider"];
   const modelPath = ["agents", "codex", "model"];
+  const openRouterPath = ["agents", "codex", "openRouter"];
   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) {
+  const suppliesOpenRouterPolicy = overrides.some((override) => override.path.join(".").startsWith(`${openRouterPath.join(".")}.`));
+  if (!selectsDefaultProvider || readPath2(baseConfig, providerPath) !== CODEX_OPENROUTER_PROVIDER || readPath2(overridden, providerPath) !== CODEX_DEFAULT_PROVIDER) {
     return;
   }
   const codex = readPath2(overridden, ["agents", "codex"]);
-  if (isRecord4(codex))
+  if (!isRecord4(codex))
+    return;
+  if (!suppliesModel)
     delete codex.model;
+  if (!suppliesOpenRouterPolicy)
+    delete codex.openRouter;
 }
 function findAssignmentForPath(overrides, path) {
   for (let index = overrides.length - 1;index >= 0; index -= 1) {
@@ -186028,7 +186065,7 @@ function parseConfigOverride(assignment) {
     value: assignment.slice(separator + 1)
   };
 }
-function parseConfigOverrideValue(value, currentValue) {
+function parseConfigOverrideValue(value, currentValue, path) {
   if (typeof currentValue === "boolean") {
     if (value === "true")
       return true;
@@ -186036,7 +186073,7 @@ function parseConfigOverrideValue(value, currentValue) {
       return false;
     return value;
   }
-  if (typeof currentValue === "number" && NUMBER_VALUE.test(value)) {
+  if ((typeof currentValue === "number" || currentValue === undefined && UNSET_NUMBER_OVERRIDE_PATHS.has(path.join("."))) && NUMBER_VALUE.test(value)) {
     const parsed = Number(value);
     if (Number.isFinite(parsed))
       return parsed;
@@ -190003,6 +190040,29 @@ var legacyClientNotificationMethods = new Set([
   CLIENT_METHODS.elicitation_complete
 ]);
 
+// src/core/errors.ts
+class KyosoRequestError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "KyosoRequestError";
+  }
+}
+
+class KyosoCancellationError extends Error {
+  code = "REQUEST_CANCELLED";
+  constructor(message = "Kyoso review was cancelled.") {
+    super(message);
+    this.name = "KyosoCancellationError";
+  }
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted)
+    return;
+  throw new KyosoCancellationError(typeof signal.reason === "string" ? signal.reason : undefined);
+}
+
 // src/core/modelExecutionIdentity.ts
 var MODEL_EXECUTION_IDENTITY_MAX_CHARS = 160;
 var MODEL_PROVIDER_ROUTES = new Set([
@@ -190112,13 +190172,18 @@ var OPENROUTER_EXCLUDED_CREDENTIAL_ENV_KEYS = [
 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
-};
+function buildOpenRouterProviderPreset(options, baseUrl = OPENROUTER_BASE_URL) {
+  return {
+    name: "OpenRouter",
+    base_url: baseUrl,
+    env_key: OPENROUTER_API_KEY_ENV,
+    wire_api: "responses",
+    requires_openai_auth: false,
+    ...options.streamIdleTimeoutMs === undefined ? {} : { stream_idle_timeout_ms: options.streamIdleTimeoutMs },
+    ...options.streamMaxRetries === undefined ? {} : { stream_max_retries: options.streamMaxRetries },
+    ...options.requestMaxRetries === undefined ? {} : { request_max_retries: options.requestMaxRetries }
+  };
+}
 
 class ChildEnvPreflightError extends Error {
   code;
@@ -190177,7 +190242,7 @@ function buildChildEnvironment(parentEnv, whitelist, explicit, options = {}) {
   }
   if (openRouterSelected) {
     discardOpenRouterExcludedCredentials(env);
-    applyOpenRouterConfig(env, parentEnv, options.model, onCredentialPlaceholderDiscarded, options.onOpenRouterProvidersDiscarded ?? warnOpenRouterProvidersDiscarded);
+    applyOpenRouterConfig(env, parentEnv, options.model, options.openRouter, options.openRouterBaseUrlForTest, onCredentialPlaceholderDiscarded, options.onOpenRouterProvidersDiscarded ?? warnOpenRouterProvidersDiscarded);
   } else {
     applyModelConfig(env, options.agent, options.model);
   }
@@ -190234,7 +190299,7 @@ function applyModelConfig(env, agent, model) {
     env.CODEX_CONFIG = JSON.stringify({ model });
   }
 }
-function applyOpenRouterConfig(env, parentEnv, model, onCredentialPlaceholderDiscarded, onOpenRouterProvidersDiscarded) {
+function applyOpenRouterConfig(env, parentEnv, model, openRouter = {}, baseUrl = OPENROUTER_BASE_URL, 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.');
@@ -190262,7 +190327,7 @@ function applyOpenRouterConfig(env, parentEnv, model, onCredentialPlaceholderDis
     model: configuredModel,
     model_provider: KYOSO_OPENROUTER_PROVIDER_ID,
     model_providers: {
-      [KYOSO_OPENROUTER_PROVIDER_ID]: OPENROUTER_PROVIDER_PRESET
+      [KYOSO_OPENROUTER_PROVIDER_ID]: buildOpenRouterProviderPreset(openRouter, baseUrl)
     }
   });
 }
@@ -190379,6 +190444,117 @@ function limitAcpNdJsonLineBytes(input, maxLineBytes = MAX_ACP_NDJSON_LINE_BYTES
   }));
 }
 
+// src/acp/AgentOutputAccumulator.ts
+class AgentOutputAccumulator {
+  segments = new Map;
+  messageChunks = [];
+  retryEpoch = 0;
+  observedStreamRetries = 0;
+  discardedRetryMessageBytes = 0;
+  firstOutputAt;
+  lastAcpUpdateAt;
+  nextChunkSequence = 0;
+  addMessageChunk(text, meta3) {
+    this.noteOutput();
+    const id = meta3.messageId ?? `epoch-${this.retryEpoch}`;
+    const key = `${this.retryEpoch}\x00${id}`;
+    const phase = meta3.phase ?? "unknown";
+    let segment = this.segments.get(key);
+    if (!segment) {
+      segment = {
+        id,
+        phase,
+        retryEpoch: this.retryEpoch,
+        text: "",
+        abandoned: false,
+        lastChunkSequence: 0
+      };
+      this.segments.set(key, segment);
+    } else if (segment.phase === "unknown" && phase !== "unknown") {
+      segment.phase = phase;
+    }
+    const sequence = this.nextChunkSequence;
+    this.nextChunkSequence += 1;
+    segment.text += text;
+    segment.lastChunkSequence = sequence;
+    this.messageChunks.push({ segment, text, sequence });
+  }
+  addThoughtChunk(_text) {
+    this.noteOutput();
+  }
+  noteUpdate() {
+    this.lastAcpUpdateAt = new Date().toISOString();
+  }
+  markRetryBoundary() {
+    let discardedMessageBytes = 0;
+    for (const segment of this.segments.values()) {
+      if (segment.retryEpoch !== this.retryEpoch || segment.abandoned)
+        continue;
+      segment.abandoned = true;
+      discardedMessageBytes += Buffer.byteLength(segment.text, "utf8");
+    }
+    this.observedStreamRetries += 1;
+    this.discardedRetryMessageBytes += discardedMessageBytes;
+    this.retryEpoch += 1;
+    return { discardedMessageBytes };
+  }
+  finalRawText() {
+    if (this.observedStreamRetries === 0) {
+      return this.messageChunks.map((chunk) => chunk.text).join("");
+    }
+    const finalAnswer = [...this.segments.values()].filter((segment) => !segment.abandoned && segment.phase === "final_answer").sort((left, right) => left.lastChunkSequence - right.lastChunkSequence).at(-1);
+    if (finalAnswer)
+      return finalAnswer.text;
+    return this.messageChunks.filter((chunk) => !chunk.segment.abandoned && chunk.segment.retryEpoch === this.retryEpoch && chunk.segment.phase === "unknown").sort((left, right) => left.sequence - right.sequence).map((chunk) => chunk.text).join("");
+  }
+  metrics() {
+    return {
+      observedStreamRetries: this.observedStreamRetries,
+      discardedRetryMessageBytes: this.discardedRetryMessageBytes,
+      ...this.firstOutputAt === undefined ? {} : { firstOutputAt: this.firstOutputAt },
+      ...this.lastAcpUpdateAt === undefined ? {} : { lastAcpUpdateAt: this.lastAcpUpdateAt }
+    };
+  }
+  noteOutput() {
+    const timestamp = new Date().toISOString();
+    this.firstOutputAt ??= timestamp;
+    this.lastAcpUpdateAt = timestamp;
+  }
+}
+
+// src/acp/codexRetryUpdate.ts
+var RETRY_ATTEMPT_PATTERN = /Reconnecting\.\.\.\s*(\d+)\/(\d+)/;
+var DISPLAY_MESSAGE_FIELDS = ["title", "text", "message", "description"];
+function parseCodexRetryUpdate(update) {
+  if (!isRecord8(update) || update.sessionUpdate !== "session_info_update") {
+    return;
+  }
+  const meta3 = isRecord8(update._meta) ? update._meta : undefined;
+  const codex = meta3 && isRecord8(meta3.codex) ? meta3.codex : undefined;
+  const error51 = codex && isRecord8(codex.error) ? codex.error : undefined;
+  if (error51?.willRetry !== true)
+    return;
+  const rawMessage = typeof error51.message === "string" ? error51.message : findDisplayMessage(update) ?? "model stream retry";
+  const message = sanitizeTextForDisplay(rawMessage) || "model stream retry";
+  const attemptMatch = RETRY_ATTEMPT_PATTERN.exec(message);
+  return {
+    message,
+    ...attemptMatch?.[1] === undefined ? {} : { attempt: Number.parseInt(attemptMatch[1], 10) },
+    ...attemptMatch?.[2] === undefined ? {} : { maxRetries: Number.parseInt(attemptMatch[2], 10) }
+  };
+}
+function findDisplayMessage(update) {
+  for (const field of DISPLAY_MESSAGE_FIELDS) {
+    const value = update[field];
+    if (typeof value === "string")
+      return value;
+  }
+  return;
+}
+function isRecord8(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/core/findingAdmission.ts
 import { createHash as createHash2 } from "node:crypto";
 var SAFETY_CATEGORIES = new Set([
@@ -190860,7 +191036,7 @@ function isSeverity(value) {
   return typeof value === "string" && severities.includes(value);
 }
 function normalizeCisaSecureByDesign(value) {
-  if (!isRecord8(value))
+  if (!isRecord9(value))
     return;
   const normalized = {};
   const customerSecurityOutcomes = normalizeGateStatus(value.customerSecurityOutcomes);
@@ -190901,7 +191077,7 @@ function isEvidenceQuality(value) {
   return typeof value === "string" && evidenceQualities.includes(value);
 }
 function isStrictAgentOpinion(value) {
-  if (!isRecord8(value) || !hasOnlyKeys(value, STRICT_ROOT_KEYS))
+  if (!isRecord9(value) || !hasOnlyKeys(value, STRICT_ROOT_KEYS))
     return false;
   if (typeof value.summary !== "string")
     return false;
@@ -190911,7 +191087,7 @@ function isStrictAgentOpinion(value) {
   return value.cisaSecureByDesign === undefined || isStrictCisaSecureByDesign(value.cisaSecureByDesign);
 }
 function isStrictFinding(value) {
-  if (!isRecord8(value) || !hasOnlyKeys(value, STRICT_FINDING_KEYS)) {
+  if (!isRecord9(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)) {
@@ -190923,11 +191099,11 @@ function isStrictFinding(value) {
   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));
+  return Array.isArray(value) && value.every((item) => isRecord9(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)) {
+    if (!isRecord9(item) || !hasOnlyKeys(item, STRICT_EVIDENCE_REF_KEYS)) {
       return false;
     }
     if (item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
@@ -190943,7 +191119,7 @@ function isStrictEvidenceRefs(value) {
   });
 }
 function isStrictCisaSecureByDesign(value) {
-  if (!isRecord8(value) || !hasOnlyKeys(value, STRICT_CISA_KEYS))
+  if (!isRecord9(value) || !hasOnlyKeys(value, STRICT_CISA_KEYS))
     return false;
   for (const key of [
     "customerSecurityOutcomes",
@@ -190982,7 +191158,7 @@ function normalizeFindingFiles(value) {
   if (!Array.isArray(value))
     return;
   const files = value.flatMap((item) => {
-    if (!isRecord8(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
+    if (!isRecord9(item) || typeof item.path !== "string" || item.path.trim().length === 0) {
       return [];
     }
     const file2 = {
@@ -191002,7 +191178,7 @@ function normalizeEvidenceRefs2(value) {
   if (!Array.isArray(value))
     return;
   const references = value.slice(0, MAX_EVIDENCE_REFS2).flatMap((item) => {
-    if (!isRecord8(item) || item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
+    if (!isRecord9(item) || item.kind !== "file" && item.kind !== "diff_hunk" && item.kind !== "plan_clause") {
       return [];
     }
     const reference = { kind: item.kind };
@@ -191025,18 +191201,23 @@ function normalizeEvidenceRefs2(value) {
 function normalizeLineNumber(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= MAX_EVIDENCE_LINE2 ? value : undefined;
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/acp/AcpAgentProcess.ts
+var DEFAULT_PROGRESS_HEARTBEAT_MS = 15000;
+var ACTIVITY_PROGRESS_THROTTLE_MS = 3000;
+
 class SubprocessAcpAgentManager extends BaseAcpAgentManager {
   config;
   parentEnv;
-  constructor(config2, parentEnv = process.env) {
+  internalOptions;
+  constructor(config2, parentEnv = process.env, internalOptions = {}) {
     super();
     this.config = config2;
     this.parentEnv = parentEnv;
+    this.internalOptions = internalOptions;
   }
   async runAgent(input) {
     const agentConfig = this.config.agents[input.agent];
@@ -191057,7 +191238,9 @@ class SubprocessAcpAgentManager extends BaseAcpAgentManager {
         agent: input.agent,
         model: agentConfig.model,
         provider,
-        preferApiKey: agentConfig.auth.preferApiKey
+        preferApiKey: agentConfig.auth.preferApiKey,
+        openRouter: input.agent === "codex" ? this.config.agents.codex.openRouter : undefined,
+        openRouterBaseUrlForTest: input.agent === "codex" ? this.internalOptions.openRouterBaseUrlForTest : undefined
       });
     } catch (error51) {
       return {
@@ -191072,6 +191255,8 @@ class SubprocessAcpAgentManager extends BaseAcpAgentManager {
     try {
       return await runSubprocessAgent(input.agent, agentConfig, input, launchContext.env, launchContext.executionIdentity);
     } catch (error51) {
+      if (error51 instanceof KyosoCancellationError)
+        throw error51;
       return {
         agent: input.agent,
         role: input.role,
@@ -191084,6 +191269,7 @@ class SubprocessAcpAgentManager extends BaseAcpAgentManager {
   }
 }
 async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutionIdentity) {
+  throwIfAborted(input.signal);
   const startedAt = new Date().toISOString();
   const effectiveTimeoutMs = resolveEffectiveTimeoutMs(input);
   if (effectiveTimeoutMs <= 0) {
@@ -191099,12 +191285,20 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
       }
     };
   }
-  return new Promise((resolveResult) => {
+  return new Promise((resolveResult, rejectResult) => {
+    const abortController = new AbortController;
+    let cancelSession;
+    let timeout;
     const child = spawn(agentConfig.command, agentConfig.args, {
       cwd: input.workspaceDir,
       env,
       stdio: ["pipe", "pipe", "pipe"]
     });
+    let termination;
+    const terminate = () => {
+      termination ??= terminateChild(child);
+      return termination;
+    };
     let stdout = "";
     let stderr3 = "";
     let settled = false;
@@ -191120,18 +191314,44 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
         return;
       });
     });
-    const abortController = new AbortController;
+    let onAbort;
+    const cleanup = () => {
+      if (timeout)
+        clearTimeout(timeout);
+      if (onAbort)
+        input.signal?.removeEventListener("abort", onAbort);
+    };
     const resolveOnce = (result) => {
       if (settled)
         return;
       settled = true;
-      clearTimeout(timeout);
+      cleanup();
       const finalResult = spawned && result.executionIdentity === undefined ? { ...result, executionIdentity: launchExecutionIdentity } : result;
       (startedWrite ?? Promise.resolve()).then(() => resolveResult(finalResult));
     };
-    const timeout = setTimeout(() => {
+    const rejectOnce = (error51) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      rejectResult(error51);
+    };
+    onAbort = () => {
+      const cancellation = cancellationFromSignal(input.signal);
+      if (timeout)
+        clearTimeout(timeout);
+      abortController.abort(cancellation);
+      cancelSession?.();
+      terminate().then(() => rejectOnce(cancellation));
+    };
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    if (input.signal?.aborted) {
+      onAbort();
+      return;
+    }
+    timeout = setTimeout(() => {
       abortController.abort(new Error("Kyoso agent timeout"));
-      terminateChild(child);
+      terminate();
       const deadlineReached = input.deadlineAtEpochMs !== undefined && Date.now() >= input.deadlineAtEpochMs;
       resolveOnce({
         agent,
@@ -191160,7 +191380,9 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
         error: failure
       });
     });
-    runAcpClientWorkflow(child, input, abortController, resolveEffortConfigOption(agent, agentConfig.effort), launchExecutionIdentity).then(({
+    runAcpClientWorkflow(child, input, abortController, resolveEffortConfigOption(agent, agentConfig.effort), launchExecutionIdentity, (cancel) => {
+      cancelSession = cancel;
+    }).then(({
       rawText,
       warnings,
       usage,
@@ -191168,6 +191390,10 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
       thoughtBytes,
       outputBytes,
       outputWarningTriggered,
+      observedStreamRetries,
+      discardedRetryMessageBytes,
+      firstOutputAt,
+      lastAcpUpdateAt,
       stopReason,
       executionIdentity
     }) => {
@@ -191185,6 +191411,10 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
         thoughtBytes,
         outputBytes,
         outputWarningTriggered,
+        observedStreamRetries,
+        ...discardedRetryMessageBytes === 0 ? {} : { discardedRetryMessageBytes },
+        ...firstOutputAt === undefined ? {} : { firstOutputAt },
+        ...lastAcpUpdateAt === undefined ? {} : { lastAcpUpdateAt },
         stopReason,
         executionIdentity,
         ...usage ? { usage } : {},
@@ -191197,6 +191427,10 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
         }
       });
     }).catch((error51) => {
+      if (error51 instanceof KyosoCancellationError) {
+        terminate().then(() => rejectOnce(error51));
+        return;
+      }
       const outputLimitError = findOutputLimitError(error51, abortController);
       if (outputLimitError) {
         stdout = outputLimitError.rawText;
@@ -191211,6 +191445,12 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
           thoughtBytes: outputLimitError.thoughtBytes,
           outputBytes: outputLimitError.outputBytes,
           outputWarningTriggered: outputLimitError.outputWarningTriggered,
+          observedStreamRetries: outputLimitError.metrics.observedStreamRetries,
+          ...outputLimitError.metrics.discardedRetryMessageBytes === 0 ? {} : {
+            discardedRetryMessageBytes: outputLimitError.metrics.discardedRetryMessageBytes
+          },
+          ...outputLimitError.metrics.firstOutputAt === undefined ? {} : { firstOutputAt: outputLimitError.metrics.firstOutputAt },
+          ...outputLimitError.metrics.lastAcpUpdateAt === undefined ? {} : { lastAcpUpdateAt: outputLimitError.metrics.lastAcpUpdateAt },
           stopReason: "cancelled",
           startedAt,
           completedAt: new Date().toISOString(),
@@ -191221,6 +191461,31 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
         });
         return;
       }
+      if (error51 instanceof CodexTerminalSystemError) {
+        stdout = error51.rawText;
+        const failureText2 = [stderr3, formatAgentErrorDetail(error51)].filter((part) => part.trim().length > 0).join(`
+`);
+        resolveOnce({
+          agent,
+          role: input.role,
+          status: "failed",
+          rawText: stdout,
+          messageBytes: error51.messageBytes,
+          thoughtBytes: error51.thoughtBytes,
+          outputBytes: error51.outputBytes,
+          outputWarningTriggered: error51.outputWarningTriggered,
+          observedStreamRetries: error51.metrics.observedStreamRetries,
+          ...error51.metrics.discardedRetryMessageBytes === 0 ? {} : {
+            discardedRetryMessageBytes: error51.metrics.discardedRetryMessageBytes
+          },
+          ...error51.metrics.firstOutputAt === undefined ? {} : { firstOutputAt: error51.metrics.firstOutputAt },
+          ...error51.metrics.lastAcpUpdateAt === undefined ? {} : { lastAcpUpdateAt: error51.metrics.lastAcpUpdateAt },
+          startedAt,
+          completedAt: new Date().toISOString(),
+          error: buildAgentFailure(failureText2, "Agent process failed.")
+        });
+        return;
+      }
       if (error51 instanceof AcpNdJsonLineLimitError) {
         abortController.abort(error51);
         resolveOnce({
@@ -191252,7 +191517,7 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
         error: buildAgentFailure(failureText, "Agent process failed.")
       });
     }).finally(() => {
-      terminateChild(child);
+      terminate();
     });
     child.on("close", (code) => {
       if (settled || code === 0 || abortController.signal.aborted)
@@ -191270,7 +191535,7 @@ async function runSubprocessAgent(agent, agentConfig, input, env, launchExecutio
     });
   });
 }
-async function runAcpClientWorkflow(child, input, abortController, configOption, launchExecutionIdentity) {
+async function runAcpClientWorkflow(child, input, abortController, configOption, launchExecutionIdentity, onSessionReady) {
   if (!child.stdin || !child.stdout) {
     throw new Error("Agent process did not expose stdio streams.");
   }
@@ -191318,6 +191583,15 @@ async function runAcpClientWorkflow(child, input, abortController, configOption,
         kyosoReadOnly: true
       }
     }).withSession(async (session) => {
+      const cancelSession = () => {
+        ctx.notify(methods.agent.session.cancel, {
+          sessionId: session.sessionId
+        }).catch(() => {
+          return;
+        });
+      };
+      onSessionReady(cancelSession);
+      throwIfAborted(input.signal);
       const warnings = [];
       if (configOption) {
         await ctx.request(methods.agent.session.setConfigOption, { sessionId: session.sessionId, ...configOption }, { cancellationSignal: abortController.signal }).catch((error51) => {
@@ -191330,61 +191604,154 @@ async function runAcpClientWorkflow(child, input, abortController, configOption,
           console.error(`kyoso: ${warning}`);
         });
       }
-      const promptResponse = session.prompt(input.prompt, {
-        cancellationSignal: abortController.signal
-      });
-      promptResponse.catch(() => {
-        return;
-      });
-      let rawText = "";
+      const accumulator = new AgentOutputAccumulator;
       let messageBytes = 0;
       let thoughtBytes = 0;
       let outputBytes = 0;
       let outputWarningTriggered = false;
-      for (;; ) {
-        const message = await session.nextUpdate();
-        if (message.kind === "stop") {
-          const usage = normalizeUsage(message.response.usage);
-          return {
-            rawText,
-            warnings,
-            ...usage ? { usage } : {},
-            messageBytes,
-            thoughtBytes,
-            outputBytes,
-            outputWarningTriggered,
-            stopReason: message.stopReason,
-            executionIdentity: withReportedExecutionIdentity(launchExecutionIdentity, message.response._meta)
-          };
-        }
-        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 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(() => {
+      let codexReportedSystemError = false;
+      const sessionStartedAtEpochMs = Date.now();
+      let lastActivityAtEpochMs = 0;
+      const emitProgress = (event) => {
+        try {
+          const progress = input.onProgress?.(event);
+          Promise.resolve(progress).catch(() => {
             return;
           });
-          const error51 = new AgentOutputLimitError(retainedRawText, nextMessageBytes, nextThoughtBytes, nextOutputBytes, input.maxOutputBytes, nextOutputWarningTriggered);
-          abortController.abort(error51);
+        } catch {}
+      };
+      const heartbeatMs = input.heartbeatMs ?? DEFAULT_PROGRESS_HEARTBEAT_MS;
+      const heartbeat = input.onProgress && heartbeatMs > 0 ? setInterval(() => {
+        const now = Date.now();
+        const lastAcpUpdateAt = accumulator.metrics().lastAcpUpdateAt;
+        const lastUpdateEpochMs = lastAcpUpdateAt ? Date.parse(lastAcpUpdateAt) : sessionStartedAtEpochMs;
+        emitProgress({
+          type: "agent_waiting",
+          agent: input.agent,
+          elapsedMs: Math.max(0, now - sessionStartedAtEpochMs),
+          sinceLastAcpUpdateMs: Math.max(0, now - (Number.isFinite(lastUpdateEpochMs) ? lastUpdateEpochMs : sessionStartedAtEpochMs)),
+          ...input.streamIdleTimeoutMs === undefined ? {} : { streamIdleTimeoutMs: input.streamIdleTimeoutMs },
+          timestamp: new Date(now).toISOString()
+        });
+      }, heartbeatMs) : undefined;
+      heartbeat?.unref?.();
+      const stopHeartbeat = () => {
+        if (heartbeat)
+          clearInterval(heartbeat);
+      };
+      input.signal?.addEventListener("abort", stopHeartbeat, { once: true });
+      try {
+        const promptResponse = session.prompt(input.prompt, {
+          cancellationSignal: abortController.signal
+        });
+        const promptCompletion = promptResponse.catch((error51) => {
+          if (input.signal?.aborted) {
+            throw cancellationFromSignal(input.signal);
+          }
+          if (abortController.signal.aborted) {
+            const reason = abortController.signal.reason;
+            if (reason !== undefined)
+              throw reason;
+          }
           throw error51;
+        });
+        const promptFailure = promptCompletion.then(() => new Promise(() => {
+          return;
+        }));
+        for (;; ) {
+          const message = await Promise.race([
+            session.nextUpdate(),
+            promptFailure
+          ]);
+          if (message.kind === "stop") {
+            await promptCompletion;
+            if (codexReportedSystemError) {
+              throw new CodexTerminalSystemError(accumulator.finalRawText(), messageBytes, thoughtBytes, outputBytes, outputWarningTriggered, accumulator.metrics());
+            }
+            const usage = normalizeUsage(message.response.usage);
+            return {
+              rawText: accumulator.finalRawText(),
+              warnings,
+              ...usage ? { usage } : {},
+              messageBytes,
+              thoughtBytes,
+              outputBytes,
+              outputWarningTriggered,
+              ...accumulator.metrics(),
+              stopReason: message.stopReason,
+              executionIdentity: withReportedExecutionIdentity(launchExecutionIdentity, message.response._meta)
+            };
+          }
+          const update = message.update;
+          accumulator.noteUpdate();
+          const retry = parseCodexRetryUpdate(update);
+          if (retry) {
+            codexReportedSystemError = false;
+            const boundary = accumulator.markRetryBoundary();
+            emitProgress({
+              type: "agent_retrying",
+              agent: input.agent,
+              observedRetry: accumulator.metrics().observedStreamRetries,
+              ...retry.attempt === undefined ? {} : { attempt: retry.attempt },
+              ...retry.maxRetries === undefined ? {} : { maxRetries: retry.maxRetries },
+              reason: retry.message,
+              discardedMessageBytes: boundary.discardedMessageBytes,
+              timestamp: new Date().toISOString()
+            });
+            continue;
+          }
+          const codexThreadStatus = readCodexThreadStatus(update);
+          if (codexThreadStatus !== undefined) {
+            codexReportedSystemError = codexThreadStatus === "systemError";
+            continue;
+          }
+          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 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) {
+            if (isMessage) {
+              accumulator.addMessageChunk(utf8Prefix(update.content.text, input.maxOutputBytes - outputBytes), readChunkMeta(update));
+            }
+            const retainedRawText = accumulator.finalRawText();
+            await ctx.notify(methods.agent.session.cancel, {
+              sessionId: session.sessionId
+            }).catch(() => {
+              return;
+            });
+            const error51 = new AgentOutputLimitError(retainedRawText, nextMessageBytes, nextThoughtBytes, nextOutputBytes, input.maxOutputBytes, nextOutputWarningTriggered, accumulator.metrics());
+            abortController.abort(error51);
+            throw error51;
+          }
+          if (isMessage) {
+            accumulator.addMessageChunk(update.content.text, readChunkMeta(update));
+          } else {
+            accumulator.addThoughtChunk(update.content.text);
+          }
+          messageBytes = nextMessageBytes;
+          thoughtBytes = nextThoughtBytes;
+          outputBytes = nextOutputBytes;
+          outputWarningTriggered = nextOutputWarningTriggered;
+          const now = Date.now();
+          if (now - lastActivityAtEpochMs >= ACTIVITY_PROGRESS_THROTTLE_MS) {
+            lastActivityAtEpochMs = now;
+            emitProgress({
+              type: "agent_activity",
+              agent: input.agent,
+              activity: isMessage ? "message" : "thought",
+              totalOutputBytes: outputBytes,
+              timestamp: new Date(now).toISOString()
+            });
+          }
         }
-        if (isMessage) {
-          rawText += update.content.text;
-        }
-        messageBytes = nextMessageBytes;
-        thoughtBytes = nextThoughtBytes;
-        outputBytes = nextOutputBytes;
-        outputWarningTriggered = nextOutputWarningTriggered;
+      } finally {
+        stopHeartbeat();
+        input.signal?.removeEventListener("abort", stopHeartbeat);
       }
     });
   });
@@ -191408,7 +191775,8 @@ class AgentOutputLimitError extends Error {
   outputBytes;
   maxOutputBytes;
   outputWarningTriggered;
-  constructor(rawText, messageBytes, thoughtBytes, outputBytes, maxOutputBytes, outputWarningTriggered) {
+  metrics;
+  constructor(rawText, messageBytes, thoughtBytes, outputBytes, maxOutputBytes, outputWarningTriggered, metrics) {
     super(`Agent output exceeded ${maxOutputBytes} bytes.`);
     this.rawText = rawText;
     this.messageBytes = messageBytes;
@@ -191416,15 +191784,40 @@ class AgentOutputLimitError extends Error {
     this.outputBytes = outputBytes;
     this.maxOutputBytes = maxOutputBytes;
     this.outputWarningTriggered = outputWarningTriggered;
+    this.metrics = metrics;
     this.name = "AgentOutputLimitError";
   }
 }
+
+class CodexTerminalSystemError extends Error {
+  rawText;
+  messageBytes;
+  thoughtBytes;
+  outputBytes;
+  outputWarningTriggered;
+  metrics;
+  constructor(rawText, messageBytes, thoughtBytes, outputBytes, outputWarningTriggered, metrics) {
+    super(sanitizeTextForDisplay(rawText) || "Codex ACP reported a terminal system error.");
+    this.rawText = rawText;
+    this.messageBytes = messageBytes;
+    this.thoughtBytes = thoughtBytes;
+    this.outputBytes = outputBytes;
+    this.outputWarningTriggered = outputWarningTriggered;
+    this.metrics = metrics;
+    this.name = "CodexTerminalSystemError";
+  }
+}
 function findOutputLimitError(error51, abortController) {
   if (error51 instanceof AgentOutputLimitError)
     return error51;
   const reason = abortController.signal.reason;
   return reason instanceof AgentOutputLimitError ? reason : undefined;
 }
+function cancellationFromSignal(signal) {
+  if (signal?.reason instanceof KyosoCancellationError)
+    return signal.reason;
+  return new KyosoCancellationError(typeof signal?.reason === "string" ? signal.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));
@@ -191433,7 +191826,7 @@ function normalizeUsage(usage) {
   return normalizeModelTokenUsage(usage);
 }
 function withReportedExecutionIdentity(identity, metadata) {
-  const record2 = isRecord9(metadata) ? metadata : {};
+  const record2 = isRecord10(metadata) ? metadata : {};
   return createModelExecutionIdentity({
     providerRoute: identity.providerRoute,
     requestedModel: identity.requestedModel,
@@ -191441,7 +191834,26 @@ function withReportedExecutionIdentity(identity, metadata) {
     reportedModel: record2.model
   });
 }
-function isRecord9(value) {
+function readChunkMeta(update) {
+  const record2 = isRecord10(update) ? update : {};
+  const metadata = isRecord10(record2._meta) ? record2._meta : {};
+  const codex = isRecord10(metadata.codex) ? metadata.codex : {};
+  const phase = codex.phase === "commentary" || codex.phase === "final_answer" ? codex.phase : "unknown";
+  return {
+    ...typeof record2.messageId === "string" ? { messageId: record2.messageId } : {},
+    phase
+  };
+}
+function readCodexThreadStatus(update) {
+  const record2 = isRecord10(update) ? update : {};
+  if (record2.sessionUpdate !== "session_info_update")
+    return;
+  const metadata = isRecord10(record2._meta) ? record2._meta : {};
+  const codex = isRecord10(metadata.codex) ? metadata.codex : {};
+  const threadStatus = isRecord10(codex.threadStatus) ? codex.threadStatus : {};
+  return typeof threadStatus.type === "string" ? threadStatus.type : undefined;
+}
+function isRecord10(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function resolveEffortConfigOption(agent, effort) {
@@ -191507,14 +191919,40 @@ function assertWithinWorkspace(workspaceRoot, absolute) {
   }
 }
 function terminateChild(child) {
-  if (child.exitCode !== null || child.signalCode !== null)
-    return;
-  child.kill("SIGTERM");
-  const killTimer = setTimeout(() => {
-    if (child.exitCode === null && child.signalCode === null)
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve4) => {
+    let settled = false;
+    let killTimer;
+    let escalationTimer;
+    let onClose;
+    const settle = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (killTimer)
+        clearTimeout(killTimer);
+      if (escalationTimer)
+        clearTimeout(escalationTimer);
+      if (onClose)
+        child.off("close", onClose);
+      resolve4();
+    };
+    onClose = () => settle();
+    child.once("close", onClose);
+    child.kill("SIGTERM");
+    killTimer = setTimeout(() => {
+      if (child.exitCode !== null || child.signalCode !== null) {
+        settle();
+        return;
+      }
       child.kill("SIGKILL");
-  }, 2000);
-  killTimer.unref();
+      escalationTimer = setTimeout(settle, 500);
+      escalationTimer.unref();
+    }, 2000);
+    killTimer.unref();
+  });
 }
 function isMissingPathError2(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
@@ -191599,6 +192037,7 @@ class FakeAgentManager extends BaseAcpAgentManager {
     this.verifierScenarios = verifierScenarios;
   }
   async runAgent(input) {
+    throwIfAborted(input.signal);
     this.calls.push(input);
     const startedAt = new Date().toISOString();
     if (input.role === "finding_verifier") {
@@ -192294,18 +192733,6 @@ import { basename, dirname as dirname4, isAbsolute as isAbsolute4, join as join3
 
 // src/context/pathPolicy.ts
 import { normalize, sep } from "node:path";
-
-// src/core/errors.ts
-class KyosoRequestError extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "KyosoRequestError";
-  }
-}
-
-// src/context/pathPolicy.ts
 function normalizeRelativePath(path) {
   const normalized = normalize(path).replaceAll("\\", "/");
   if (normalized === "." || normalized.startsWith("..") || normalized.includes(`${sep}..${sep}`) || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized)) {
@@ -192961,6 +193388,161 @@ function buildContext(request, options) {
   }
 }
 
+// src/core/progressDispatcher.ts
+var DEFAULT_SINK_TIMEOUT_MS = 2000;
+var DEFAULT_MAX_QUEUE = 128;
+function isTransientEvent(event) {
+  return event.type === "agent_activity" || event.type === "agent_waiting";
+}
+function isSameCoalescibleEvent(previous, next) {
+  if (!previous || !isTransientEvent(previous) || !isTransientEvent(next)) {
+    return false;
+  }
+  return previous.type === next.type && previous.agent === next.agent;
+}
+function withoutThrowing(callback) {
+  try {
+    callback?.();
+  } catch {}
+}
+function createProgressDispatcher(sink, options = {}) {
+  if (!sink) {
+    return {
+      emit: () => {
+        return;
+      },
+      flush: async () => {
+        return;
+      }
+    };
+  }
+  const sinkTimeoutMs = options.sinkTimeoutMs ?? DEFAULT_SINK_TIMEOUT_MS;
+  const maxQueue = options.maxQueue ?? DEFAULT_MAX_QUEUE;
+  const queue = [];
+  const idleResolvers = new Set;
+  let disabled = false;
+  let processing = false;
+  const notifyIdle = () => {
+    if (processing || queue.length > 0)
+      return;
+    for (const resolve6 of idleResolvers)
+      resolve6();
+    idleResolvers.clear();
+  };
+  const waitForIdle = () => {
+    if (!processing && queue.length === 0)
+      return Promise.resolve();
+    return new Promise((resolve6) => idleResolvers.add(resolve6));
+  };
+  const disable = (reason) => {
+    if (disabled)
+      return;
+    disabled = true;
+    queue.length = 0;
+    withoutThrowing(() => options.onSinkDisabled?.(reason));
+    notifyIdle();
+  };
+  const deliver = async (event) => {
+    let timeout;
+    try {
+      const delivery = Promise.resolve().then(() => sink(event));
+      const timeoutResult = new Promise((resolve6) => {
+        timeout = setTimeout(() => resolve6("timeout"), sinkTimeoutMs);
+        timeout.unref?.();
+      });
+      const result = await Promise.race([
+        delivery.then(() => "delivered"),
+        timeoutResult
+      ]);
+      if (result === "timeout") {
+        disable(`Progress sink timed out after ${sinkTimeoutMs}ms.`);
+        return false;
+      }
+      return true;
+    } catch {
+      disable("Progress sink threw while handling an event.");
+      return false;
+    } finally {
+      if (timeout)
+        clearTimeout(timeout);
+    }
+  };
+  const drain = async () => {
+    try {
+      while (!disabled && queue.length > 0) {
+        const event = queue.shift();
+        if (!event)
+          continue;
+        if (!await deliver(event))
+          break;
+      }
+    } finally {
+      processing = false;
+      if (!disabled && queue.length > 0) {
+        startDrain();
+      } else {
+        notifyIdle();
+      }
+    }
+  };
+  const startDrain = () => {
+    if (processing || disabled || queue.length === 0)
+      return;
+    processing = true;
+    drain();
+  };
+  const makeRoomForMilestone = () => {
+    const transientIndex = queue.findIndex(isTransientEvent);
+    if (transientIndex >= 0) {
+      queue.splice(transientIndex, 1);
+      return true;
+    }
+    if (queue.length < maxQueue)
+      return true;
+    queue.shift();
+    return true;
+  };
+  return {
+    emit(event) {
+      try {
+        if (disabled)
+          return;
+        const previous = queue.at(-1);
+        if (isSameCoalescibleEvent(previous, event)) {
+          queue[queue.length - 1] = event;
+        } else if (queue.length < maxQueue) {
+          queue.push(event);
+        } else if (isTransientEvent(event)) {
+          return;
+        } else if (makeRoomForMilestone()) {
+          queue.push(event);
+        }
+        startDrain();
+      } catch {}
+    },
+    async flush(maxWaitMs = DEFAULT_SINK_TIMEOUT_MS) {
+      try {
+        const idle = waitForIdle();
+        if (maxWaitMs <= 0)
+          return;
+        let timeout;
+        try {
+          await Promise.race([
+            idle,
+            new Promise((resolve6) => {
+              timeout = setTimeout(resolve6, maxWaitMs);
+              timeout.unref?.();
+            })
+          ]);
+        } finally {
+          if (timeout)
+            clearTimeout(timeout);
+        }
+      } catch {}
+    }
+  };
+}
+
 // src/core/validateRequest.ts
 function validateReviewRequest(tool, request) {
   if (typeof request.goal !== "string" || request.goal.trim().length === 0) {
@@ -192976,7 +193558,7 @@ function validateReviewContract(request) {
   const contract = request.reviewContract;
   if (contract === undefined)
     return;
-  if (!isRecord10(contract)) {
+  if (!isRecord11(contract)) {
     throw new KyosoRequestError("reviewContract must be an object", "VALIDATION_ERROR");
   }
   const allowedKeys = new Set(["focus", "nonGoals", "acceptedRisks"]);
@@ -192993,7 +193575,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) => !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))) {
+  if (acceptedRisks !== undefined && (!Array.isArray(acceptedRisks) || acceptedRisks.length > 20 || acceptedRisks.some((risk) => !isRecord11(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");
   }
 }
@@ -193005,13 +193587,13 @@ function validateSelectedFiles(request) {
     throw new KyosoRequestError("selectedFiles must be an array", "VALIDATION_ERROR");
   }
   for (const file2 of selectedFiles) {
-    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") {
+    if (!isRecord11(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 isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -193272,7 +193854,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 (!isRecord11(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
+    if (!isRecord12(item) || typeof item.topic !== "string" || typeof item.judgeComment !== "string") {
       return [];
     }
     return [
@@ -193288,7 +193870,7 @@ function parseJudgeOutput(text, fallbackSummaryText) {
   return { summaryText, disagreementComments, analysis };
 }
 function parseAnalysis(value) {
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     return;
   if (!Array.isArray(value.blindSpots) || !Array.isArray(value.contradictions) || !Array.isArray(value.partialCoverage)) {
     return;
@@ -193296,7 +193878,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 (!isRecord11(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
+      if (!isRecord12(item) || typeof item.topic !== "string" || typeof item.detail !== "string") {
         return [];
       }
       return [
@@ -193307,7 +193889,7 @@ function parseAnalysis(value) {
       ];
     }),
     partialCoverage: value.partialCoverage.slice(0, ANALYSIS_MAX_ITEMS).flatMap((item) => {
-      if (!isRecord11(item) || typeof item.note !== "string")
+      if (!isRecord12(item) || typeof item.note !== "string")
         return [];
       const findingId = typeof item.findingId === "string" ? sanitizeAnalysisText(item.findingId) : undefined;
       return [
@@ -193354,10 +193936,31 @@ function extractFirstJsonObject2(text) {
   }
   return;
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/judge/signals.ts
+function linkSignals(timeoutMs, external3) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(new Error("judge timeout")), timeoutMs);
+  timeout.unref?.();
+  const onExternalAbort = () => controller.abort(external3?.reason);
+  if (external3) {
+    if (external3.aborted)
+      onExternalAbort();
+    else
+      external3.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    cleanup() {
+      clearTimeout(timeout);
+      external3?.removeEventListener("abort", onExternalAbort);
+    }
+  };
+}
+
 // src/judge/anthropic.ts
 var DEFAULT_ANTHROPIC_JUDGE_MODEL = "claude-haiku-4-5";
 function resolveAnthropicJudgeModel(env) {
@@ -193368,39 +193971,45 @@ async function runAnthropicJudge(input, timeoutMs) {
   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: {
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01",
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({
-      model: requestedModel,
-      max_tokens: JUDGE_MAX_OUTPUT_TOKENS,
-      temperature: 0,
-      messages: [
-        {
-          role: "user",
-          content: buildJudgePrompt(input.tool, input.result, input.summaryText, input.agentFindings)
-        }
-      ]
-    })
-  }, timeoutMs);
-  if (!response.ok)
-    throw new Error(`Anthropic judge failed with HTTP ${response.status}.`);
-  const payload = await response.json();
-  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.");
-  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 } : {}
-  };
+  const { signal, cleanup } = linkSignals(timeoutMs, input.signal);
+  try {
+    const response = await fetch(`${input.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com"}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: requestedModel,
+        max_tokens: JUDGE_MAX_OUTPUT_TOKENS,
+        temperature: 0,
+        messages: [
+          {
+            role: "user",
+            content: buildJudgePrompt(input.tool, input.result, input.summaryText, input.agentFindings)
+          }
+        ]
+      }),
+      signal
+    });
+    if (!response.ok)
+      throw new Error(`Anthropic judge failed with HTTP ${response.status}.`);
+    const payload = await response.json();
+    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.");
+    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 } : {}
+    };
+  } finally {
+    cleanup();
+  }
 }
 function normalizeUsage2(usage) {
   if (!usage)
@@ -193412,16 +194021,6 @@ function normalizeUsage2(usage) {
     cachedWriteTokens: usage.cache_creation_input_tokens
   });
 }
-async function fetchWithTimeout(url2, init, timeoutMs) {
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  timeout.unref?.();
-  try {
-    return await fetch(url2, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(timeout);
-  }
-}
 
 // src/judge/deterministicFallback.ts
 function runDeterministicJudge(result, summaryText) {
@@ -193444,39 +194043,45 @@ async function runOpenAiJudge(input, timeoutMs) {
   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: {
-      authorization: `Bearer ${apiKey}`,
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({
-      model: requestedModel,
-      response_format: { type: "json_object" },
-      messages: [
-        {
-          role: "user",
-          content: buildJudgePrompt(input.tool, input.result, input.summaryText, input.agentFindings)
-        }
-      ],
-      max_completion_tokens: JUDGE_MAX_OUTPUT_TOKENS,
-      temperature: 0
-    })
-  }, timeoutMs);
-  if (!response.ok)
-    throw new Error(`OpenAI judge failed with HTTP ${response.status}.`);
-  const payload = await response.json();
-  const content = payload.choices?.[0]?.message?.content;
-  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 } : {}
-  };
+  const { signal, cleanup } = linkSignals(timeoutMs, input.signal);
+  try {
+    const response = await fetch(`${input.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1"}/chat/completions`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: requestedModel,
+        response_format: { type: "json_object" },
+        messages: [
+          {
+            role: "user",
+            content: buildJudgePrompt(input.tool, input.result, input.summaryText, input.agentFindings)
+          }
+        ],
+        max_completion_tokens: JUDGE_MAX_OUTPUT_TOKENS,
+        temperature: 0
+      }),
+      signal
+    });
+    if (!response.ok)
+      throw new Error(`OpenAI judge failed with HTTP ${response.status}.`);
+    const payload = await response.json();
+    const content = payload.choices?.[0]?.message?.content;
+    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 } : {}
+    };
+  } finally {
+    cleanup();
+  }
 }
 function normalizeUsage3(usage) {
   if (!usage)
@@ -193489,16 +194094,6 @@ function normalizeUsage3(usage) {
     thoughtTokens: usage.completion_tokens_details?.reasoning_tokens
   });
 }
-async function fetchWithTimeout2(url2, init, timeoutMs) {
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  timeout.unref?.();
-  try {
-    return await fetch(url2, { ...init, signal: controller.signal });
-  } finally {
-    clearTimeout(timeout);
-  }
-}
 
 // src/judge/provider.ts
 function resolveJudgeProvider(provider, env) {
@@ -193552,6 +194147,9 @@ async function runJudge(input) {
       ...output.usage ? { usage: output.usage } : {}
     };
   } catch (error51) {
+    if (input.signal?.aborted) {
+      throw new KyosoCancellationError("Kyoso review was cancelled during judge execution.");
+    }
     return {
       provider,
       status: "failed_fallback",
@@ -193883,11 +194481,11 @@ function canonicalJson(value) {
 function canonicalize(value) {
   if (Array.isArray(value))
     return value.map(canonicalize);
-  if (!isRecord12(value))
+  if (!isRecord13(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 isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -193901,7 +194499,7 @@ var REVIEW_BUDGET_KEYS = new Set([
 ]);
 var MODEL_CALL_KINDS = ["primary", "verifier", "judge"];
 function resolveReviewBudget(ceiling, requested) {
-  if (requested !== undefined && !isRecord13(requested)) {
+  if (requested !== undefined && !isRecord14(requested)) {
     throw new KyosoRequestError("options.reviewBudget must be an object.", "REVIEW_BUDGET_INVALID");
   }
   for (const [key, value] of Object.entries(requested ?? {})) {
@@ -194091,6 +194689,10 @@ class ReviewBudgetTracker {
     current.thoughtBytes = values.thoughtBytes;
     current.outputBytes = values.outputBytes;
     current.outputWarningTriggered = values.outputWarningTriggered;
+    current.observedStreamRetries = values.observedStreamRetries;
+    current.discardedRetryMessageBytes = values.discardedRetryMessageBytes;
+    current.firstOutputAt = values.firstOutputAt;
+    current.lastAcpUpdateAt = values.lastAcpUpdateAt;
     current.salvaged = values.salvaged;
     current.reportedFindings = values.reportedFindings;
     current.findingsTargetExceeded = values.findingsTargetExceeded;
@@ -194205,6 +194807,12 @@ class ReviewBudgetTracker {
       ...reservation.thoughtBytes !== undefined ? { thoughtBytes: reservation.thoughtBytes } : {},
       ...reservation.outputBytes !== undefined ? { outputBytes: reservation.outputBytes } : {},
       ...reservation.outputWarningTriggered !== undefined ? { outputWarningTriggered: reservation.outputWarningTriggered } : {},
+      ...reservation.observedStreamRetries !== undefined ? { observedStreamRetries: reservation.observedStreamRetries } : {},
+      ...reservation.discardedRetryMessageBytes !== undefined ? {
+        discardedRetryMessageBytes: reservation.discardedRetryMessageBytes
+      } : {},
+      ...reservation.firstOutputAt !== undefined ? { firstOutputAt: reservation.firstOutputAt } : {},
+      ...reservation.lastAcpUpdateAt !== undefined ? { lastAcpUpdateAt: reservation.lastAcpUpdateAt } : {},
       ...reservation.salvaged !== undefined ? { salvaged: reservation.salvaged } : {},
       ...reservation.reportedFindings !== undefined ? { reportedFindings: reservation.reportedFindings } : {},
       ...reservation.findingsTargetExceeded !== undefined ? { findingsTargetExceeded: reservation.findingsTargetExceeded } : {},
@@ -194245,7 +194853,7 @@ function emptyReviewModelCallPlan() {
     ceilingEffects: []
   };
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -194307,7 +194915,7 @@ function parseVerificationVerdicts(rawText) {
     if (!Array.isArray(parsed.verdicts))
       return;
     return parsed.verdicts.flatMap((item) => {
-      if (!isRecord14(item))
+      if (!isRecord15(item))
         return [];
       if (typeof item.findingId !== "string")
         return [];
@@ -194385,11 +194993,12 @@ function verificationNote(reasoning) {
 function isVerdict(value) {
   return value === "confirmed" || value === "refuted" || value === "uncertain";
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/core/runReview.ts
+var MAX_AGENT_RETRY_PROGRESS_EVENTS = 100;
 function requestForRecursionFingerprint(request) {
   try {
     return scanAndRedactSecrets(request).redactedRequest;
@@ -194405,138 +195014,368 @@ async function runReview(tool, request, options = {}) {
   const auditEnv = { ...process.env, ...options.env };
   const traceWriterFactory = options.traceWriterFactory ?? createTraceWriter;
   let snapshot;
+  let activeTrace;
+  let progressDeliveryFailure;
+  let writeProgressDeliveryFailure;
+  let reviewFailureReported = false;
+  const dispatcher = createProgressDispatcher(options.onProgress, {
+    onSinkDisabled: (reason) => {
+      if (progressDeliveryFailure !== undefined)
+        return;
+      progressDeliveryFailure = reason;
+      writeProgressDeliveryFailure?.(reason);
+    }
+  });
+  const phaseStartedAt = new Map;
+  const startPhase = (phase) => {
+    throwIfAborted(options.signal);
+    phaseStartedAt.set(phase, Date.now());
+    dispatcher.emit({
+      type: "phase_started",
+      traceId,
+      phase,
+      timestamp: new Date().toISOString()
+    });
+  };
+  const completePhase = (phase) => {
+    dispatcher.emit({
+      type: "phase_completed",
+      traceId,
+      phase,
+      durationMs: Math.max(0, Date.now() - (phaseStartedAt.get(phase) ?? Date.now())),
+      timestamp: new Date().toISOString()
+    });
+  };
+  const skipPhase = (phase, reason) => {
+    dispatcher.emit({
+      type: "phase_skipped",
+      traceId,
+      phase,
+      reason,
+      timestamp: new Date().toISOString()
+    });
+  };
+  const reportReviewCompleted = async (result) => {
+    dispatcher.emit({
+      type: "review_completed",
+      traceId,
+      decision: result.decision,
+      completionStatus: result.completion.status,
+      durationMs: Math.max(0, Date.now() - startedAtEpochMs),
+      timestamp: new Date().toISOString()
+    });
+    await dispatcher.flush();
+    if (progressDeliveryFailure !== undefined) {
+      result.audit.warnings = Array.from(new Set([
+        ...result.audit.warnings ?? [],
+        `PROGRESS_DELIVERY_FAILED: ${progressDeliveryFailure}`
+      ]));
+    }
+  };
+  const completeReview = async (result) => {
+    await reportReviewCompleted(result);
+    return result;
+  };
+  const reportReviewFailure = async (error51, trace) => {
+    if (reviewFailureReported)
+      return;
+    reviewFailureReported = true;
+    const timestamp = new Date().toISOString();
+    if (error51 instanceof KyosoCancellationError) {
+      dispatcher.emit({ type: "review_cancelled", traceId, timestamp });
+      await trace?.write({ type: "review_cancelled", traceId, timestamp }).catch(() => {
+        return;
+      });
+    } else {
+      dispatcher.emit({
+        type: "review_failed",
+        traceId,
+        ...error51 instanceof KyosoRequestError ? { errorCode: error51.code } : {},
+        timestamp
+      });
+      await trace?.write({
+        type: "review_failed",
+        traceId,
+        ...error51 instanceof KyosoRequestError ? { errorCode: error51.code } : {},
+        timestamp
+      }).catch(() => {
+        return;
+      });
+    }
+    await dispatcher.flush();
+  };
+  dispatcher.emit({
+    type: "review_started",
+    traceId,
+    tool,
+    timestamp: new Date().toISOString()
+  });
   try {
-    assertNotChildAgent(options.env ?? process.env);
-  } catch (error51) {
-    if (error51 instanceof KyosoRequestError) {
-      const config2 = kyosoConfigSchema.parse(defaultConfig);
-      const reviewBudget = resolveReviewBudget(config2.reviewBudget, undefined);
-      const budgetTracker = new ReviewBudgetTracker(reviewBudget, startedAtEpochMs, configuredReviewModelCallPlan(config2, reviewBudget, options.env ?? process.env));
-      const requestFingerprint = createRequestFingerprint({
+    try {
+      throwIfAborted(options.signal);
+      assertNotChildAgent(options.env ?? process.env);
+    } catch (error51) {
+      if (error51 instanceof KyosoRequestError) {
+        const config2 = kyosoConfigSchema.parse(defaultConfig);
+        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: reviewBudget,
+          entrypoint: options.entrypoint
+        });
+        const trace2 = traceWriterFactory({
+          enabled: config2.audit.enabled,
+          directory: config2.audit.directory,
+          traceId,
+          cwd,
+          env: auditEnv
+        });
+        activeTrace = trace2;
+        writeProgressDeliveryFailure = (reason) => {
+          trace2.write({
+            type: "progress_delivery_failed",
+            traceId,
+            reason,
+            timestamp: new Date().toISOString()
+          }).catch(() => {
+            return;
+          });
+        };
+        if (progressDeliveryFailure !== undefined) {
+          writeProgressDeliveryFailure(progressDeliveryFailure);
+        }
+        try {
+          await trace2.write({
+            type: "request_received",
+            traceId,
+            tool,
+            timestamp: new Date().toISOString()
+          });
+          await writeReviewBudgetPlanned({
+            trace: trace2,
+            traceId,
+            budgetTracker,
+            requestFingerprint
+          });
+          return await completeReview(await buildPolicyBlockResult({
+            tool,
+            trace: trace2,
+            traceId,
+            startedAt,
+            networkMode: config2.network.defaultMode,
+            cisaPolicy: config2.securityReview.cisaSecureByDesign,
+            warning: error51.message,
+            budgetTracker,
+            requestFingerprint,
+            coverage: unavailableReviewCoverage(requestForRecursionFingerprint(request), "recursive invocation blocked before agent execution", config2.reviewPolicy.additionalLenses),
+            finding: {
+              id: "KYOSO-1",
+              severity: "critical",
+              category: "other",
+              title: "Recursive Kyoso invocation blocked",
+              evidence: error51.message,
+              recommendation: "Do not expose Kyoso MCP tools to Kyoso child agents.",
+              disposition: "gate",
+              changeRelation: "unknown",
+              evidenceQuality: "concrete",
+              evidenceRefs: [],
+              policyReasons: ["kyoso_policy", "recursive_invocation"],
+              fingerprint: "",
+              sourceAgents: ["kyoso_policy"],
+              confidence: "high"
+            },
+            redactionsApplied: 0
+          }));
+        } finally {
+          await trace2.finalize();
+        }
+      }
+      throw error51;
+    }
+    startPhase("preflight");
+    const baseLoaded = options.config !== undefined ? {
+      config: options.config,
+      configHash: options.configHash,
+      configTrustStatus: "trusted",
+      sources: [],
+      warnings: []
+    } : await loadConfig({
+      cwd,
+      configPath: options.configPath,
+      ignoreConfig: options.ignoreConfig,
+      trustConfig: options.trustConfig,
+      allowUnknownConfig: options.allowUnknownConfig,
+      promptForTrust: options.promptForTrust,
+      trustStorePath: options.trustStorePath,
+      env: options.env,
+      trustPrompt: options.trustPrompt
+    });
+    const loaded = options.configOverrides && options.configOverrides.length > 0 ? {
+      ...baseLoaded,
+      config: applyConfigOverrides(baseLoaded.config, options.configOverrides)
+    } : baseLoaded;
+    completePhase("preflight");
+    const trace = traceWriterFactory({
+      enabled: loaded.config.audit.enabled,
+      directory: loaded.config.audit.directory,
+      traceId,
+      cwd,
+      includeRawAgentOutput: loaded.config.audit.includeRawAgentOutput,
+      env: auditEnv
+    });
+    activeTrace = trace;
+    const warnings = [...loaded.warnings, ...trace.warnings];
+    writeProgressDeliveryFailure = (reason) => {
+      warnings.push(`PROGRESS_DELIVERY_FAILED: ${reason}`);
+      trace.write({
+        type: "progress_delivery_failed",
+        traceId,
+        reason,
+        timestamp: new Date().toISOString()
+      }).catch(() => {
+        return;
+      });
+    };
+    if (progressDeliveryFailure !== undefined) {
+      writeProgressDeliveryFailure(progressDeliveryFailure);
+    }
+    try {
+      await trace.write({
+        type: "request_received",
+        traceId,
         tool,
-        request: requestForRecursionFingerprint(request),
-        config: config2,
-        roles: resolveAgentRoles(config2),
-        budget: reviewBudget,
-        entrypoint: options.entrypoint
+        timestamp: new Date().toISOString()
       });
-      const trace2 = traceWriterFactory({
-        enabled: config2.audit.enabled,
-        directory: config2.audit.directory,
+      await trace.write({
+        type: "config_loaded",
         traceId,
-        cwd,
-        env: auditEnv
+        configHash: loaded.configHash,
+        configPath: loaded.configPath,
+        configSources: loaded.sources,
+        configTrustStatus: loaded.configTrustStatus,
+        timestamp: new Date().toISOString()
       });
-      try {
-        await trace2.write({
-          type: "request_received",
-          traceId,
+      validateReviewRequest(tool, request);
+      const reviewBudget = resolveReviewBudget(loaded.config.reviewBudget, request.options?.reviewBudget);
+      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) {
+        throw new KyosoRequestError("unrestricted network mode is disabled by config", "NETWORK_MODE_DISABLED");
+      }
+      const disabledPolicy = disabledReviewPolicy(tool, loaded.config, options.entrypoint);
+      if (disabledPolicy) {
+        const redactedRequest = requestForRecursionFingerprint(request);
+        const requestFingerprint2 = createRequestFingerprint({
           tool,
-          timestamp: new Date().toISOString()
+          request: redactedRequest,
+          config: loaded.config,
+          roles: resolveAgentRoles(loaded.config),
+          budget: reviewBudget,
+          entrypoint: options.entrypoint
         });
         await writeReviewBudgetPlanned({
-          trace: trace2,
+          trace,
           traceId,
           budgetTracker,
-          requestFingerprint
+          requestFingerprint: requestFingerprint2
         });
-        return await buildPolicyBlockResult({
+        const warning = disabledPolicy.warning;
+        return await completeReview(await buildPolicyBlockResult({
           tool,
-          trace: trace2,
+          trace,
           traceId,
           startedAt,
-          networkMode: config2.network.defaultMode,
-          cisaPolicy: config2.securityReview.cisaSecureByDesign,
-          warning: error51.message,
+          configHash: loaded.configHash,
+          networkMode,
+          cisaPolicy: loaded.config.securityReview.cisaSecureByDesign,
+          warning,
           budgetTracker,
-          requestFingerprint,
-          coverage: unavailableReviewCoverage(requestForRecursionFingerprint(request), "recursive invocation blocked before agent execution", config2.reviewPolicy.additionalLenses),
+          requestFingerprint: requestFingerprint2,
+          coverage: unavailableReviewCoverage(redactedRequest, disabledPolicy.coverageReason, loaded.config.reviewPolicy.additionalLenses),
           finding: {
             id: "KYOSO-1",
             severity: "critical",
             category: "other",
-            title: "Recursive Kyoso invocation blocked",
-            evidence: error51.message,
-            recommendation: "Do not expose Kyoso MCP tools to Kyoso child agents.",
+            title: disabledPolicy.title,
+            evidence: warning,
+            recommendation: disabledPolicy.recommendation,
             disposition: "gate",
             changeRelation: "unknown",
             evidenceQuality: "concrete",
             evidenceRefs: [],
-            policyReasons: ["kyoso_policy", "recursive_invocation"],
+            policyReasons: ["kyoso_policy", disabledPolicy.policyReason],
             fingerprint: "",
             sourceAgents: ["kyoso_policy"],
             confidence: "high"
           },
           redactionsApplied: 0
+        }));
+      }
+      if (networkMode === "unrestricted" && loaded.config.network.warnOnUnrestricted) {
+        warnings.push("Network mode is unrestricted; write policy remains denied.");
+      }
+      startPhase("context");
+      const secretScan = scanAndRedactSecrets(request);
+      await trace.write({
+        type: "secret_scan_completed",
+        traceId,
+        detected: secretScan.detected,
+        redactions: secretScan.redactions,
+        timestamp: new Date().toISOString()
+      });
+      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,
+          entrypoint: options.entrypoint
         });
-      } finally {
-        await trace2.finalize();
+        await writeReviewBudgetPlanned({
+          trace,
+          traceId,
+          budgetTracker,
+          requestFingerprint: requestFingerprint2
+        });
+        skipPhase("context", "secret_detected");
+        return await completeReview(await buildSecretBlockResult({
+          tool,
+          trace,
+          traceId,
+          startedAt,
+          configHash: loaded.configHash,
+          networkMode,
+          cisaPolicy: loaded.config.securityReview.cisaSecureByDesign,
+          additionalLenses: loaded.config.reviewPolicy.additionalLenses,
+          secretScan,
+          warnings,
+          budgetTracker,
+          requestFingerprint: requestFingerprint2
+        }));
       }
-    }
-    throw error51;
-  }
-  const baseLoaded = options.config !== undefined ? {
-    config: options.config,
-    configHash: options.configHash,
-    configTrustStatus: "trusted",
-    sources: [],
-    warnings: []
-  } : await loadConfig({
-    cwd,
-    configPath: options.configPath,
-    ignoreConfig: options.ignoreConfig,
-    trustConfig: options.trustConfig,
-    allowUnknownConfig: options.allowUnknownConfig,
-    promptForTrust: options.promptForTrust,
-    trustStorePath: options.trustStorePath,
-    env: options.env,
-    trustPrompt: options.trustPrompt
-  });
-  const loaded = options.configOverrides && options.configOverrides.length > 0 ? {
-    ...baseLoaded,
-    config: applyConfigOverrides(baseLoaded.config, options.configOverrides)
-  } : baseLoaded;
-  const trace = traceWriterFactory({
-    enabled: loaded.config.audit.enabled,
-    directory: loaded.config.audit.directory,
-    traceId,
-    cwd,
-    includeRawAgentOutput: loaded.config.audit.includeRawAgentOutput,
-    env: auditEnv
-  });
-  const warnings = [...loaded.warnings, ...trace.warnings];
-  try {
-    await trace.write({
-      type: "request_received",
-      traceId,
-      tool,
-      timestamp: new Date().toISOString()
-    });
-    await trace.write({
-      type: "config_loaded",
-      traceId,
-      configHash: loaded.configHash,
-      configPath: loaded.configPath,
-      configSources: loaded.sources,
-      configTrustStatus: loaded.configTrustStatus,
-      timestamp: new Date().toISOString()
-    });
-    validateReviewRequest(tool, request);
-    const reviewBudget = resolveReviewBudget(loaded.config.reviewBudget, request.options?.reviewBudget);
-    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) {
-      throw new KyosoRequestError("unrestricted network mode is disabled by config", "NETWORK_MODE_DISABLED");
-    }
-    const disabledPolicy = disabledReviewPolicy(tool, loaded.config, options.entrypoint);
-    if (disabledPolicy) {
-      const redactedRequest = requestForRecursionFingerprint(request);
-      const requestFingerprint2 = createRequestFingerprint({
+      const denyPatterns = mergeDenyPatterns(loaded.config.workspace.deny, secretScan.redactedRequest.workspace?.denyRead);
+      const allowPatterns = secretScan.redactedRequest.workspace?.allowRead ?? [];
+      const built = buildContext(secretScan.redactedRequest, {
+        maxContextBytes: loaded.config.workspace.maxContextBytes,
+        maxDiffBytes: loaded.config.workspace.maxDiffBytes,
+        denyPatterns,
+        allowPatterns
+      });
+      warnings.push(...built.warnings);
+      completePhase("context");
+      const agentRoles = resolveAgentRoles(loaded.config);
+      const requestFingerprint = createRequestFingerprint({
         tool,
-        request: redactedRequest,
+        request: built.request,
         config: loaded.config,
-        roles: resolveAgentRoles(loaded.config),
+        roles: agentRoles,
         budget: reviewBudget,
         entrypoint: options.entrypoint
       });
@@ -194544,370 +195383,308 @@ async function runReview(tool, request, options = {}) {
         trace,
         traceId,
         budgetTracker,
-        requestFingerprint: requestFingerprint2
+        requestFingerprint
       });
-      const warning = disabledPolicy.warning;
-      return await buildPolicyBlockResult({
-        tool,
-        trace,
-        traceId,
-        startedAt,
-        configHash: loaded.configHash,
-        networkMode,
-        cisaPolicy: loaded.config.securityReview.cisaSecureByDesign,
-        warning,
-        budgetTracker,
-        requestFingerprint: requestFingerprint2,
-        coverage: unavailableReviewCoverage(redactedRequest, disabledPolicy.coverageReason, loaded.config.reviewPolicy.additionalLenses),
-        finding: {
-          id: "KYOSO-1",
-          severity: "critical",
-          category: "other",
-          title: disabledPolicy.title,
-          evidence: warning,
-          recommendation: disabledPolicy.recommendation,
-          disposition: "gate",
-          changeRelation: "unknown",
-          evidenceQuality: "concrete",
-          evidenceRefs: [],
-          policyReasons: ["kyoso_policy", disabledPolicy.policyReason],
-          fingerprint: "",
-          sourceAgents: ["kyoso_policy"],
-          confidence: "high"
-        },
-        redactionsApplied: 0
-      });
-    }
-    if (networkMode === "unrestricted" && loaded.config.network.warnOnUnrestricted) {
-      warnings.push("Network mode is unrestricted; write policy remains denied.");
-    }
-    const secretScan = scanAndRedactSecrets(request);
-    await trace.write({
-      type: "secret_scan_completed",
-      traceId,
-      detected: secretScan.detected,
-      redactions: secretScan.redactions,
-      timestamp: new Date().toISOString()
-    });
-    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,
-        entrypoint: options.entrypoint
+      warnings.push(...plannedBudgetWarnings(budgetTracker));
+      startPhase("snapshot");
+      snapshot = await createSnapshot(traceId, tool, built.request, {
+        denyPatterns,
+        allowPatterns,
+        agentRoles
       });
-      await writeReviewBudgetPlanned({
-        trace,
+      await trace.write({
+        type: "snapshot_created",
         traceId,
-        budgetTracker,
-        requestFingerprint: requestFingerprint2
+        path: snapshot.root,
+        fileCount: snapshot.fileCount,
+        timestamp: new Date().toISOString()
       });
-      return await buildSecretBlockResult({
+      completePhase("snapshot");
+      const manager = options.agentManager ?? defaultAgentManager(loaded.config, options.env ?? process.env);
+      startPhase("primary");
+      const agentResults = await runAgents({
         tool,
-        trace,
+        request: built.request,
+        config: loaded.config,
         traceId,
-        startedAt,
-        configHash: loaded.configHash,
+        workspaceDir: snapshot.root,
         networkMode,
-        cisaPolicy: loaded.config.securityReview.cisaSecureByDesign,
-        additionalLenses: loaded.config.reviewPolicy.additionalLenses,
-        secretScan,
+        manager,
+        trace,
         warnings,
         budgetTracker,
-        requestFingerprint: requestFingerprint2
+        progressDispatcher: dispatcher,
+        signal: options.signal,
+        progressHeartbeatMs: options.progressHeartbeatMs
       });
-    }
-    const denyPatterns = mergeDenyPatterns(loaded.config.workspace.deny, secretScan.redactedRequest.workspace?.denyRead);
-    const allowPatterns = secretScan.redactedRequest.workspace?.allowRead ?? [];
-    const built = buildContext(secretScan.redactedRequest, {
-      maxContextBytes: loaded.config.workspace.maxContextBytes,
-      maxDiffBytes: loaded.config.workspace.maxDiffBytes,
-      denyPatterns,
-      allowPatterns
-    });
-    warnings.push(...built.warnings);
-    const agentRoles = resolveAgentRoles(loaded.config);
-    const requestFingerprint = createRequestFingerprint({
-      tool,
-      request: built.request,
-      config: loaded.config,
-      roles: agentRoles,
-      budget: reviewBudget,
-      entrypoint: options.entrypoint
-    });
-    await writeReviewBudgetPlanned({
-      trace,
-      traceId,
-      budgetTracker,
-      requestFingerprint
-    });
-    warnings.push(...plannedBudgetWarnings(budgetTracker));
-    snapshot = await createSnapshot(traceId, tool, built.request, {
-      denyPatterns,
-      allowPatterns,
-      agentRoles
-    });
-    await trace.write({
-      type: "snapshot_created",
-      traceId,
-      path: snapshot.root,
-      fileCount: snapshot.fileCount,
-      timestamp: new Date().toISOString()
-    });
-    const manager = options.agentManager ?? defaultAgentManager(loaded.config, options.env ?? process.env);
-    const agentResults = await runAgents({
-      tool,
-      request: built.request,
-      config: loaded.config,
-      traceId,
-      workspaceDir: snapshot.root,
-      networkMode,
-      manager,
-      trace,
-      warnings,
-      budgetTracker
-    });
-    warnings.push(...agentResults.flatMap((result) => (result.warnings ?? []).map((warning) => `Agent ${result.agent} ${warning}`)));
-    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);
-    const reviewMode = enabledAgents.length === 1 ? "single_agent" : "multi_agent";
-    const completed = normalizedAgentResults.filter((result) => result.status === "completed");
-    const attempted = normalizedAgentResults.filter((result) => result.status !== "skipped");
-    const degraded = completed.length !== attempted.length || enabledAgents.length === 0;
-    const coverage = buildReviewCoverage({
-      request: built.request,
-      additionalLenses: loaded.config.reviewPolicy.additionalLenses,
-      agentResults: normalizedAgentResults
-    });
-    if (isCoverageIncomplete(coverage, {
-      multiAgentRequired: loaded.config.reviewPolicy.multiAgentRequired
-    })) {
-      budgetTracker.markIncomplete("coverage_incomplete");
-      warnings.push(formatCoverageWarning(coverage, loaded.config));
-    }
-    let aggregate = aggregateAgentResults(normalizedAgentResults, {
-      reviewMode
-    });
-    if (secretScan.detected && allowSecretOverride) {
+      completePhase("primary");
+      warnings.push(...agentResults.flatMap((result) => (result.warnings ?? []).map((warning) => `Agent ${result.agent} ${warning}`)));
+      startPhase("aggregation");
+      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);
+      const reviewMode = enabledAgents.length === 1 ? "single_agent" : "multi_agent";
+      const completed = normalizedAgentResults.filter((result) => result.status === "completed");
+      const attempted = normalizedAgentResults.filter((result) => result.status !== "skipped");
+      const degraded = completed.length !== attempted.length || enabledAgents.length === 0;
+      const coverage = buildReviewCoverage({
+        request: built.request,
+        additionalLenses: loaded.config.reviewPolicy.additionalLenses,
+        agentResults: normalizedAgentResults
+      });
+      if (isCoverageIncomplete(coverage, {
+        multiAgentRequired: loaded.config.reviewPolicy.multiAgentRequired
+      })) {
+        budgetTracker.markIncomplete("coverage_incomplete");
+        warnings.push(formatCoverageWarning(coverage, loaded.config));
+      }
+      let aggregate = aggregateAgentResults(normalizedAgentResults, {
+        reviewMode
+      });
+      if (secretScan.detected && allowSecretOverride) {
+        aggregate = {
+          ...aggregate,
+          findings: reindexFindings([
+            buildSecretFinding(secretScan, {
+              id: "KYOSO-1",
+              blocked: false
+            }),
+            ...aggregate.findings
+          ])
+        };
+      }
+      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: [
+            ...aggregate.findings,
+            {
+              id: `KYOSO-${aggregate.findings.length + 1}`,
+              severity: "critical",
+              category: "other",
+              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.",
+              disposition: "gate",
+              changeRelation: "unknown",
+              evidenceQuality: "concrete",
+              evidenceRefs: [],
+              policyReasons: ["kyoso_policy", "coverage_incomplete"],
+              fingerprint: "",
+              sourceAgents: ["kyoso_policy"],
+              confidence: "high"
+            }
+          ]
+        };
+      }
       aggregate = {
         ...aggregate,
-        findings: reindexFindings([
-          buildSecretFinding(secretScan, {
-            id: "KYOSO-1",
-            blocked: false
-          }),
-          ...aggregate.findings
-        ])
+        findings: admitFindings({
+          tool,
+          request: built.request,
+          findings: aggregate.findings,
+          reviewMode
+        })
       };
-    }
-    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.");
+      await trace.write({
+        type: "aggregation_completed",
+        traceId,
+        findingCount: aggregate.findings.length,
+        timestamp: new Date().toISOString()
+      });
+      completePhase("aggregation");
+      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") {
+        startPhase("verification");
+        warnings.push(...await runFindingVerification({
+          tool,
+          request: built.request,
+          config: loaded.config,
+          traceId,
+          workspaceDir: snapshot.root,
+          networkMode,
+          manager,
+          trace,
+          findings: aggregate.findings,
+          budgetTracker,
+          signal: options.signal
+        }));
+        completePhase("verification");
+      } else {
+        skipPhase("verification", verificationMode === "skipped_single_agent" ? "single_agent_review" : "verification_disabled");
       }
       aggregate = {
         ...aggregate,
-        findings: [
-          ...aggregate.findings,
-          {
-            id: `KYOSO-${aggregate.findings.length + 1}`,
-            severity: "critical",
-            category: "other",
-            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.",
-            disposition: "gate",
-            changeRelation: "unknown",
-            evidenceQuality: "concrete",
-            evidenceRefs: [],
-            policyReasons: ["kyoso_policy", "coverage_incomplete"],
-            fingerprint: "",
-            sourceAgents: ["kyoso_policy"],
-            confidence: "high"
-          }
-        ]
+        findings: admitFindings({
+          tool,
+          request: built.request,
+          findings: aggregate.findings,
+          reviewMode
+        })
       };
-    }
-    aggregate = {
-      ...aggregate,
-      findings: admitFindings({
+      if (aggregate.findings.some((finding) => finding.disposition === "disputed")) {
+        budgetTracker.markIncomplete("disputed_finding");
+      }
+      const cisaPolicy = loaded.config.securityReview.cisaSecureByDesign;
+      const cisa = tool === "security_review" && cisaPolicy.enabled ? computeCisaGate(aggregate.findings, normalizedAgentResults, cisaPolicy) : undefined;
+      const budgetBeforeJudge = budgetTracker.snapshot();
+      const decision = budgetBeforeJudge.completion.status === "incomplete" ? "block" : decide({
         tool,
-        request: built.request,
         findings: aggregate.findings,
-        reviewMode
-      })
-    };
-    await trace.write({
-      type: "aggregation_completed",
-      traceId,
-      findingCount: aggregate.findings.length,
-      timestamp: new Date().toISOString()
-    });
-    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({
+        cisa: cisaPolicy.gate ? cisa : undefined,
+        degraded,
+        secretScan: { detected: secretScan.detected, blocked: false }
+      });
+      const completedAt = new Date().toISOString();
+      const resultWithoutMarkdown = {
+        decision,
+        completion: budgetBeforeJudge.completion,
+        executionBudget: budgetBeforeJudge.executionBudget,
+        requestFingerprint,
+        degraded,
+        agentsUsed,
+        reviewMode,
+        coverage,
+        ...verificationMode ? { verificationMode } : {},
+        findings: aggregate.findings,
+        cisaSecureByDesign: cisa,
+        disagreements: aggregate.disagreements,
+        testsToAdd: selectRegressionTests(aggregate.testsToAdd),
+        residualRisks: tool === "security_review" && aggregate.residualRisks.length === 0 ? [
+          "No residual risks were reported by completed agents; verify security assumptions before release."
+        ] : aggregate.residualRisks,
+        openQuestions: Array.from(new Set([
+          ...aggregate.openQuestions,
+          ...buildAdmissionOpenQuestions(aggregate.findings)
+        ])),
+        agentOpinions: normalizedAgentResults.map((result) => agentOpinionSummary(result, request.options?.includeAgentRawOutputs === true)),
+        audit: {
+          traceId,
+          startedAt,
+          completedAt,
+          agentsUsed,
+          redactionsApplied: secretScan.redactions,
+          networkMode,
+          workspaceMode: "temp_snapshot",
+          configHash: loaded.configHash,
+          warnings: Array.from(new Set([...warnings, ...trace.warnings])),
+          modelCalls: budgetBeforeJudge.modelCalls
+        }
+      };
+      const summaryText = defaultSummaryText(resultWithoutMarkdown);
+      startPhase("judge");
+      const judge = await runBudgetedJudge({
         tool,
-        request: built.request,
-        config: loaded.config,
-        traceId,
-        workspaceDir: snapshot.root,
-        networkMode,
-        manager,
+        result: resultWithoutMarkdown,
+        summaryText,
+        agentFindings: buildJudgeAgentFindings(normalizedAgentResults),
+        config: loaded.config.judge,
+        requestedProvider: request.options?.judgeProvider,
+        env: options.env ?? process.env,
+        budgetTracker,
         trace,
-        findings: aggregate.findings,
-        budgetTracker
+        traceId,
+        signal: options.signal
+      });
+      completePhase("judge");
+      startPhase("finalize");
+      const judgeComments = new Map(judge.output.disagreementComments.map((comment) => [
+        comment.topic,
+        comment.judgeComment
+      ]));
+      const disagreements = resultWithoutMarkdown.disagreements.map((disagreement) => ({
+        ...disagreement,
+        judgeComment: judgeComments.get(disagreement.topic) ?? disagreement.judgeComment
       }));
-    }
-    aggregate = {
-      ...aggregate,
-      findings: admitFindings({
+      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,
+        decision: finalDecision,
+        completion: budgetAfterJudge.completion,
+        executionBudget: budgetAfterJudge.executionBudget,
+        disagreements,
+        ...crossModelAnalysis ? { crossModelAnalysis } : {},
+        audit: {
+          ...resultWithoutMarkdown.audit,
+          completedAt: new Date().toISOString(),
+          warnings: finalWarnings,
+          modelCalls: budgetAfterJudge.modelCalls
+        }
+      };
+      const judgeEvent = {
+        type: "judge_completed",
+        traceId,
+        provider: judge.provider,
+        status: judge.status,
+        ...judge.executionIdentity ? { executionIdentity: judge.executionIdentity } : {},
+        timestamp: new Date().toISOString()
+      };
+      if (judge.error)
+        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: finalDecision,
+        timestamp: new Date().toISOString()
+      });
+      await trace.write({
+        type: "response_sent",
+        traceId,
+        timestamp: new Date().toISOString()
+      });
+      completePhase("finalize");
+      await reportReviewCompleted(resultAfterJudge);
+      return await finalizeReviewResult({
         tool,
-        request: built.request,
-        findings: aggregate.findings,
-        reviewMode
-      })
-    };
-    if (aggregate.findings.some((finding) => finding.disposition === "disputed")) {
-      budgetTracker.markIncomplete("disputed_finding");
+        trace,
+        result: resultAfterJudge,
+        summaryText: resultAfterJudge.completion.status === "incomplete" ? defaultSummaryText(resultAfterJudge) : judge.output.summaryText
+      });
+    } catch (error51) {
+      await reportReviewFailure(error51, trace);
+      throw error51;
+    } finally {
+      await trace.finalize();
+      if (snapshot)
+        await cleanupSnapshot(snapshot.root);
     }
-    const cisaPolicy = loaded.config.securityReview.cisaSecureByDesign;
-    const cisa = tool === "security_review" && cisaPolicy.enabled ? computeCisaGate(aggregate.findings, normalizedAgentResults, cisaPolicy) : undefined;
-    const budgetBeforeJudge = budgetTracker.snapshot();
-    const decision = budgetBeforeJudge.completion.status === "incomplete" ? "block" : decide({
-      tool,
-      findings: aggregate.findings,
-      cisa: cisaPolicy.gate ? cisa : undefined,
-      degraded,
-      secretScan: { detected: secretScan.detected, blocked: false }
-    });
-    const completedAt = new Date().toISOString();
-    const resultWithoutMarkdown = {
-      decision,
-      completion: budgetBeforeJudge.completion,
-      executionBudget: budgetBeforeJudge.executionBudget,
-      requestFingerprint,
-      degraded,
-      agentsUsed,
-      reviewMode,
-      coverage,
-      ...verificationMode ? { verificationMode } : {},
-      findings: aggregate.findings,
-      cisaSecureByDesign: cisa,
-      disagreements: aggregate.disagreements,
-      testsToAdd: selectRegressionTests(aggregate.testsToAdd),
-      residualRisks: tool === "security_review" && aggregate.residualRisks.length === 0 ? [
-        "No residual risks were reported by completed agents; verify security assumptions before release."
-      ] : aggregate.residualRisks,
-      openQuestions: Array.from(new Set([
-        ...aggregate.openQuestions,
-        ...buildAdmissionOpenQuestions(aggregate.findings)
-      ])),
-      agentOpinions: normalizedAgentResults.map((result) => agentOpinionSummary(result, request.options?.includeAgentRawOutputs === true)),
-      audit: {
-        traceId,
-        startedAt,
-        completedAt,
-        agentsUsed,
-        redactionsApplied: secretScan.redactions,
-        networkMode,
-        workspaceMode: "temp_snapshot",
-        configHash: loaded.configHash,
-        warnings: Array.from(new Set([...warnings, ...trace.warnings])),
-        modelCalls: budgetBeforeJudge.modelCalls
-      }
-    };
-    const summaryText = defaultSummaryText(resultWithoutMarkdown);
-    const judge = await runBudgetedJudge({
-      tool,
-      result: resultWithoutMarkdown,
-      summaryText,
-      agentFindings: buildJudgeAgentFindings(normalizedAgentResults),
-      config: loaded.config.judge,
-      requestedProvider: request.options?.judgeProvider,
-      env: options.env ?? process.env,
-      budgetTracker,
-      trace,
-      traceId
-    });
-    const judgeComments = new Map(judge.output.disagreementComments.map((comment) => [
-      comment.topic,
-      comment.judgeComment
-    ]));
-    const disagreements = resultWithoutMarkdown.disagreements.map((disagreement) => ({
-      ...disagreement,
-      judgeComment: judgeComments.get(disagreement.topic) ?? disagreement.judgeComment
-    }));
-    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,
-      decision: finalDecision,
-      completion: budgetAfterJudge.completion,
-      executionBudget: budgetAfterJudge.executionBudget,
-      disagreements,
-      ...crossModelAnalysis ? { crossModelAnalysis } : {},
-      audit: {
-        ...resultWithoutMarkdown.audit,
-        completedAt: new Date().toISOString(),
-        warnings: finalWarnings,
-        modelCalls: budgetAfterJudge.modelCalls
-      }
-    };
-    const judgeEvent = {
-      type: "judge_completed",
-      traceId,
-      provider: judge.provider,
-      status: judge.status,
-      ...judge.executionIdentity ? { executionIdentity: judge.executionIdentity } : {},
-      timestamp: new Date().toISOString()
-    };
-    if (judge.error)
-      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: finalDecision,
-      timestamp: new Date().toISOString()
-    });
-    await trace.write({
-      type: "response_sent",
-      traceId,
-      timestamp: new Date().toISOString()
-    });
-    return await finalizeReviewResult({
-      tool,
-      trace,
-      result: resultAfterJudge,
-      summaryText: resultAfterJudge.completion.status === "incomplete" ? defaultSummaryText(resultAfterJudge) : judge.output.summaryText
-    });
-  } finally {
-    await trace.finalize();
-    if (snapshot)
-      await cleanupSnapshot(snapshot.root);
+  } catch (error51) {
+    await reportReviewFailure(error51, activeTrace);
+    throw error51;
   }
 }
+function durationMsBetween(startedAt, completedAt) {
+  if (!startedAt || !completedAt)
+    return 0;
+  const start = Date.parse(startedAt);
+  const end = Date.parse(completedAt);
+  if (!Number.isFinite(start) || !Number.isFinite(end))
+    return 0;
+  return Math.max(0, end - start);
+}
 async function runFindingVerification(input) {
   const allowDemotionRequested = input.config.verification.allowDemotion;
   const selection = selectVerificationTargets(input.findings, input.config.verification.maxFindings);
@@ -195069,6 +195846,7 @@ async function runFindingVerification(input) {
     warnOutputBytes: input.budgetTracker.budget.effectiveWarnAgentOutputBytes,
     maxOutputBytes: input.budgetTracker.budget.maxAgentOutputBytes,
     networkMode: input.networkMode,
+    signal: input.signal,
     onStarted: (executionIdentity) => {
       input.budgetTracker.markStarted(group.reservation, executionIdentity);
       const event = buildAgentStartedEvent({
@@ -195086,6 +195864,8 @@ async function runFindingVerification(input) {
   try {
     results = await input.manager.runAll(agentInputs);
   } catch (error51) {
+    if (error51 instanceof KyosoCancellationError)
+      throw error51;
     for (const group of scheduledGroups) {
       applyVerificationVerdicts(group.targets, group.verifier, undefined);
       await finalizeModelCallResult({
@@ -195310,6 +196090,19 @@ async function recordSkippedJudgeCall(input, reason) {
 async function runAgents(input) {
   const agentRoles = resolveAgentRoles(input.config);
   const enabledAgents = ["codex", "claude"].filter((agent) => input.config.agents[agent].enabled);
+  const openRouter = input.config.agents.codex.openRouter;
+  const hasOpenRouterRetryPolicy = Object.values(openRouter).some((value) => value !== undefined);
+  if (enabledAgents.includes("codex") && input.config.agents.codex.provider === CODEX_OPENROUTER_PROVIDER && hasOpenRouterRetryPolicy) {
+    await input.trace.write({
+      type: "openrouter_retry_policy_resolved",
+      traceId: input.traceId,
+      streamIdleTimeoutMs: openRouter.streamIdleTimeoutMs,
+      streamMaxRetries: openRouter.streamMaxRetries,
+      requestMaxRetries: openRouter.requestMaxRetries,
+      source: "kyoso_config",
+      timestamp: new Date().toISOString()
+    });
+  }
   if (enabledAgents.length === 0)
     return [];
   const reservationResult = input.budgetTracker.reserveMany(enabledAgents.map((agent) => ({ kind: "primary", agent })));
@@ -195395,6 +196188,8 @@ async function runAgents(input) {
   const agentInputs = enabledAgents.map((agent) => {
     const agentConfig = input.config.agents[agent];
     const role = agentRoles[agent] ?? agentConfig.role;
+    let emittedRetryProgressEvents = 0;
+    let retryProgressLimitWarned = false;
     const reservation = reservations.get(agent);
     if (!reservation) {
       throw new Error(`Missing primary budget reservation for ${agent}.`);
@@ -195415,15 +196210,27 @@ async function runAgents(input) {
       warnOutputBytes: input.budgetTracker.budget.effectiveWarnAgentOutputBytes,
       maxOutputBytes: input.budgetTracker.budget.maxAgentOutputBytes,
       networkMode: input.networkMode,
+      signal: input.signal,
+      heartbeatMs: input.progressHeartbeatMs,
+      ...agent === "codex" && input.config.agents.codex.provider === CODEX_OPENROUTER_PROVIDER && openRouter.streamIdleTimeoutMs !== undefined ? { streamIdleTimeoutMs: openRouter.streamIdleTimeoutMs } : {},
       onStarted: (executionIdentity) => {
         input.budgetTracker.markStarted(reservation, executionIdentity);
         if (!acceptingStartedEvents)
           return Promise.resolve();
+        const progressExecutionIdentity = input.budgetTracker.executionIdentity(reservation);
+        input.progressDispatcher.emit({
+          type: "agent_started",
+          traceId: input.traceId,
+          agent,
+          role,
+          ...progressExecutionIdentity ? { executionIdentity: progressExecutionIdentity } : {},
+          timestamp: new Date().toISOString()
+        });
         const event = buildAgentStartedEvent({
           traceId: input.traceId,
           agent,
           role,
-          executionIdentity: input.budgetTracker.executionIdentity(reservation)
+          executionIdentity: progressExecutionIdentity
         });
         const write = (async () => {
           try {
@@ -195434,6 +196241,33 @@ async function runAgents(input) {
         })();
         startedWrites.push(write);
         return write;
+      },
+      onProgress: (event) => {
+        if (!acceptingStartedEvents)
+          return;
+        input.progressDispatcher.emit({ ...event, traceId: input.traceId });
+        if (event.type !== "agent_retrying")
+          return;
+        if (emittedRetryProgressEvents >= MAX_AGENT_RETRY_PROGRESS_EVENTS) {
+          if (!retryProgressLimitWarned) {
+            retryProgressLimitWarned = true;
+            input.warnings.push(`AGENT_RETRY_PROGRESS_LIMIT: ${agent} emitted more than ${MAX_AGENT_RETRY_PROGRESS_EVENTS} retry progress events; later events were omitted from the audit trace.`);
+          }
+          return;
+        }
+        emittedRetryProgressEvents += 1;
+        const write = (async () => {
+          try {
+            await input.trace.write({
+              ...event,
+              traceId: input.traceId,
+              type: "agent_retrying"
+            });
+          } catch {
+            input.warnings.push("AUDIT_WRITE_FAILED: agent_retrying event could not be recorded.");
+          }
+        })();
+        startedWrites.push(write);
       }
     };
   });
@@ -195441,6 +196275,8 @@ async function runAgents(input) {
   try {
     results = await input.manager.runAll(agentInputs);
   } catch (error51) {
+    if (error51 instanceof KyosoCancellationError)
+      throw error51;
     const detail = sanitizeTextForDisplay(error51 instanceof Error ? error51.message : String(error51));
     input.warnings.push(`Primary-agent execution failed: ${detail}`);
     results = agentInputs.map((agentInput) => ({
@@ -195491,6 +196327,16 @@ async function runAgents(input) {
     if (result.status !== "completed") {
       input.budgetTracker.markIncomplete("coverage_incomplete");
     }
+    input.progressDispatcher.emit({
+      type: "agent_completed",
+      traceId: input.traceId,
+      agent: result.agent,
+      status: result.status,
+      durationMs: durationMsBetween(result.startedAt, result.completedAt),
+      ...result.outputBytes === undefined ? {} : { outputBytes: result.outputBytes },
+      ...result.observedStreamRetries === undefined ? {} : { observedStreamRetries: result.observedStreamRetries },
+      timestamp: new Date().toISOString()
+    });
   }
   await Promise.all(normalizedResults.map((result) => {
     const event = {
@@ -195581,6 +196427,12 @@ async function finalizeModelCallResult(input) {
     ...thoughtBytes === undefined ? {} : { thoughtBytes },
     ...outputBytes === undefined ? {} : { outputBytes },
     ...outputWarningTriggered === undefined ? {} : { outputWarningTriggered },
+    ...input.result.observedStreamRetries === undefined ? {} : { observedStreamRetries: input.result.observedStreamRetries },
+    ...input.result.discardedRetryMessageBytes === undefined ? {} : {
+      discardedRetryMessageBytes: input.result.discardedRetryMessageBytes
+    },
+    ...input.result.firstOutputAt === undefined ? {} : { firstOutputAt: input.result.firstOutputAt },
+    ...input.result.lastAcpUpdateAt === undefined ? {} : { lastAcpUpdateAt: input.result.lastAcpUpdateAt },
     ...input.result.salvaged === undefined ? {} : { salvaged: input.result.salvaged },
     ...input.result.reportedFindings === undefined ? {} : { reportedFindings: input.result.reportedFindings },
     ...input.result.findingsTargetExceeded === undefined ? {} : { findingsTargetExceeded: input.result.findingsTargetExceeded },
@@ -195619,6 +196471,12 @@ async function finalizeModelCallResult(input) {
     ...thoughtBytes === undefined ? {} : { thoughtBytes },
     ...outputBytes === undefined ? {} : { outputBytes },
     ...outputWarningTriggered === undefined ? {} : { outputWarningTriggered },
+    ...input.result.observedStreamRetries === undefined ? {} : { observedStreamRetries: input.result.observedStreamRetries },
+    ...input.result.discardedRetryMessageBytes === undefined ? {} : {
+      discardedRetryMessageBytes: input.result.discardedRetryMessageBytes
+    },
+    ...input.result.firstOutputAt === undefined ? {} : { firstOutputAt: input.result.firstOutputAt },
+    ...input.result.lastAcpUpdateAt === undefined ? {} : { lastAcpUpdateAt: input.result.lastAcpUpdateAt },
     ...input.result.salvaged === undefined ? {} : { salvaged: input.result.salvaged },
     ...input.result.reportedFindings === undefined ? {} : { reportedFindings: input.result.reportedFindings },
     ...input.result.findingsTargetExceeded === undefined ? {} : { findingsTargetExceeded: input.result.findingsTargetExceeded },
@@ -196042,5 +196900,6 @@ function resolveNetworkMode(requested, configDefault, mcpNetworkMode) {
 }
 export {
   runReview,
-  defineConfig
+  defineConfig,
+  KyosoCancellationError
 };