dominds 1.13.2 → 1.15.2

package/dist/docs/issues/global-dialog-event-broadcaster-missing.md

@@ -0,0 +1,128 @@
+# Issue: `Global dialog event broadcaster missing`
+
+## Summary
+
+在没有初始化全局 dialog event broadcaster 的运行环境里，发布 `new_q4h_asked` / `q4h_answered` / `subdialog_created_evt` / `dlg_touched_evt` 会直接抛错：
+
+```text
+Global dialog event broadcaster missing: cannot publish new_q4h_asked for dialog=<id>
+```
+
+这不只是噪音日志。对于 `askHuman` / Q4H 链路，这个异常会被上层当作“Q4H 注册失败”处理，导致：
+
+- Q4H 状态文件其实已经写入
+- 但 runtime 仍然走失败分支
+- 追加 `stream_error_evt`
+- 向当前对话注入失败型 tellask result
+- 造成“持久化成功、广播缺失、业务语义却被当作失败”的错位
+
+## Observed In
+
+- `tests/recovery/reply-special-after-restart.ts`
+- 其它不启动完整 websocket server、但会触发 Q4H runtime 的脚本型 / test 型运行环境
+
+## Current Call Chain
+
+1. `main/llm/kernel-driver/tellask-special.ts`
+   `executeTellaskCall()` 在 Q4H 分支先调用 `DialogPersistence.appendQuestion4HumanState()` 落盘
+2. 同一分支随后调用 `postDialogEvent(dlg, { type: 'new_q4h_asked', ... })`
+3. `main/evt-registry.ts`
+   `dispatchGloballyIfNeeded()` 发现 `new_q4h_asked` 属于 global-only event
+4. 若 `globalDialogEventBroadcaster === null`，则直接 `throw`
+5. 异常被 `tellask-special.ts` 的 Q4H `try/catch` 捕获
+6. 上层误判为“Q4H register invariant violation”，转入失败补偿路径
+
+## Correct Contract
+
+这里应明确：**global dialog event broadcaster 不是可选增强，而是 runtime 必要基础设施**。
+
+也就是说：
+
+- 任何支持 dialog runtime 的运行环境，在进入对话驱动 / Q4H / 子对话逻辑前，都必须先完成 broadcaster bootstrap
+- WebUI server 只是其中一种 runtime；将来其它 runtime 也必须在位
+- 测试运行环境同样应按 runtime bootstrap 的方式安装 broadcaster，而不是在业务 helper 里零散补丁
+
+因此，这个问题的根因不是“event layer 应该 graceful degrade”，而是**存在未完成 broadcaster bootstrap 的 runtime**，并且这个缺陷直到业务路径中途才暴露。
+
+## Why It Happened
+
+此前全局 broadcaster 只在 `main/server/websocket-handler.ts` 的 websocket server 初始化阶段通过 `setGlobalDialogEventBroadcaster(...)` 安装。
+
+但脚本 / 测试 / recovery 运行环境也会直接触发同一批 global-only event。于是形成了：
+
+- dialog-scoped event registry 已可用
+- global broadcaster 尚未安装
+- `postDialogEvent()` 处理 global-only event 时立刻抛错
+- 上层业务把该异常误判成 Q4H 注册失败 / 业务失败
+
+## Impact
+
+### User-visible / behavior impact
+
+- `askHuman` 在未完成 runtime bootstrap 的环境下会被错误地当作失败处理
+- 当前对话会收到失败型 tellask result，而不是保持正常 pending Q4H 语义
+
+### Persistence / state consistency impact
+
+- Q4H state 已经写入，但 runtime 业务语义被标成失败
+- 形成“状态已存在、当前轮回答却说失败”的不一致
+
+### Test / diagnostics impact
+
+- 用例可能通过，但日志出现误导性错误
+- 排障时很难第一眼区分“runtime 缺少 broadcaster bootstrap”还是“Q4H 真的注册失败”
+
+## Repro
+
+1. 在不启动 websocket server、且未安装 recording broadcaster 的脚本环境里创建 dialog
+2. 触发 `askHuman`
+3. 观察日志出现 `Global dialog event broadcaster missing`
+4. 观察上层继续记录 `Q4H register invariant violation`
+
+## Root Cause
+
+根因不是 Q4H 注册本身，而是 runtime contract 与 bootstrap 现实不一致：
+
+- 契约上：broadcaster 是 mandatory infra
+- 现实里：只有 websocket server 显式安装，其它 runtime 没有统一 bootstrap
+
+于是“基础设施未初始化”在业务路径中被表象成“Q4H 注册失败”。
+
+## Resolution Direction
+
+按下面原则修：
+
+1. 保持 event layer 的强约束：global-only event 没有 broadcaster 时仍然应 loud fail
+2. 修复点应放在 runtime bootstrap，而不是在 Q4H/子对话业务链路里做“广播失败 best-effort”
+3. 所有 runtime 入口都必须在业务逻辑前安装 broadcaster
+   - WebUI server：安装 websocket fanout broadcaster
+   - tests / script runtimes：安装 recording broadcaster，可抓取广播内容，也可在无断言需求时忽略
+4. 测试不得再通过业务 helper 临时塞 `() => {}` 绕过问题；应通过统一 runtime bootstrap 安装 recorder
+5. 若 future runtime 漏装 broadcaster，应在 bootstrap 阶段或运行环境初始化阶段尽早暴露，而不是等到 `askHuman` 中途再炸
+
+## Rejected Direction
+
+以下方向不再采用：
+
+- 让 `dispatchGloballyIfNeeded()` graceful degrade
+- 在 `askHuman` 链路里把 broadcast 当成 best-effort
+- 允许测试/business helper 就地注入 noop broadcaster 掩盖 bootstrap 缺口
+
+这些做法都会继续模糊“mandatory infra”契约，让问题从 runtime 初始化阶段滑落到业务中途。
+
+## Applied Fix Direction
+
+当前约定下，正确修法是：
+
+- 新增统一 broadcaster bootstrap API
+- WebUI server 改为通过统一 bootstrap API 安装 websocket broadcaster
+- rtws tests 改为通过统一 runner 安装 recording broadcaster
+- kernel-driver helpers 不再偷偷安装 noop broadcaster，而是断言 runtime 已完成 bootstrap
+
+## Related Files
+
+- `main/bootstrap/global-dialog-event-broadcaster.ts`
+- `main/evt-registry.ts`
+- `main/server/websocket-handler.ts`
+- `tests/rtws-script-runner.ts`
+- `tests/kernel-driver/helpers.ts`

package/dist/docs/llm-provider-isolation.md

@@ -0,0 +1,35 @@
+# LLM Provider Isolation
+
+## Principle
+
+Dominds treats each LLM provider wrapper as an isolated protocol adapter, not as a flavor of a shared "OpenAI-like" abstraction.
+
+This means:
+
+- `apiType: codex` owns Codex-native request fields, stream events, tool semantics, and defaults.
+- `apiType: openai` owns OpenAI Responses request fields, stream events, tool semantics, and defaults.
+- `apiType: openai-compatible` owns Chat Completions semantics, even when it reuses the `model_params.openai.*` namespace.
+
+Similar field names across wrappers do not imply compatibility. For example, `reasoning_effort`, `verbosity`, `parallel_tool_calls`, and web search controls may look similar but can still differ in accepted values, payload shape, lifecycle events, validation rules, and runtime meaning.
+
+## Hard Rules
+
+- A wrapper must only read its own provider namespace when building requests.
+- A wrapper must only interpret its own provider-native stream events.
+- A wrapper must not silently fall back to another provider's params, aliases, or event assumptions.
+- Cross-provider convergence is allowed only at the driver/storage/UI boundary, after provider-native events have already been decoded into discriminated unions.
+
+## Why
+
+This isolation keeps provider integrations honest:
+
+- fewer accidental "compatible by coincidence" behaviors
+- easier debugging when providers diverge
+- less hidden coupling between wrappers
+- safer upgrades when official APIs evolve independently
+
+## Current Boundary
+
+The backend currently uses provider-specific web search event variants inside wrappers and projects them into a narrower dialog event shape in `main/llm/kernel-driver/drive.ts`.
+
+That projection layer is intentional: it is the compatibility boundary. Wrapper code on either side should stay provider-native.

package/dist/docs/llm-provider-isolation.zh.md

@@ -0,0 +1,35 @@
+# LLM Provider 隔离原则
+
+## 原则
+
+Dominds 把每个 LLM provider wrapper 视为独立的协议适配器，而不是某种“大一统 OpenAI-like 抽象”的一个变体。
+
+这意味着：
+
+- `apiType: codex` 只负责 Codex 原生的请求字段、流事件、工具语义和默认行为。
+- `apiType: openai` 只负责 OpenAI Responses 原生的请求字段、流事件、工具语义和默认行为。
+- `apiType: openai-compatible` 虽然复用 `model_params.openai.*` 命名空间，但它负责的是 Chat Completions 语义，不是 Codex，也不是 Responses。
+
+不同 wrapper 下看起来同名的字段，不代表它们可以互相兼容。比如 `reasoning_effort`、`verbosity`、`parallel_tool_calls`、web search 相关开关，名字可能相似，但可接受值、请求载荷形状、流事件生命周期、校验规则和运行时含义都可能不同。
+
+## 强约束
+
+- wrapper 构造请求时，只能读取自己的 provider 参数命名空间。
+- wrapper 解析流事件时，只能解释自己的 provider 原生事件。
+- wrapper 内禁止静默 fallback 到别的 provider 参数、别名或事件假设。
+- 只有在 driver / storage / UI 边界，才允许把 provider-native 事件投影成更窄的共享形态，而且前提是 wrapper 侧已经先完成了 provider-native 解码。
+
+## 为什么
+
+这样做是为了让 provider 集成保持诚实：
+
+- 减少“碰巧兼容”带来的隐式行为
+- 在 provider 分叉时更容易排查问题
+- 降低 wrapper 之间的隐藏耦合
+- 在官方 API 各自演化时，升级更安全
+
+## 当前边界
+
+目前后端在 wrapper 内保留 provider-specific 的 web search 事件类型，再在 `main/llm/kernel-driver/drive.ts` 投影成较窄的 dialog 事件形态。
+
+这个投影层是有意设计的，它就是兼容边界。边界两侧的 wrapper 代码都应继续保持 provider-native。

package/dist/llm/client.d.ts

@@ -1,4 +1,4 @@
-export type { ChatMessage, EnvironmentMsg, FuncCallMsg, FuncResultMsg, PromptingMsg, SayingMsg, TellaskCallResultMsg, TellaskCarryoverResultMsg, ThinkingMsg, TransientGuideMsg, UiOnlyMarkdownMsg, } from '@longrun-ai/kernel/types/chat-message';
+export type { ChatMessage, EnvironmentMsg, FuncCallMsg, FuncResultMsg, PromptingMsg, SayingMsg, TellaskCarryoverMsg, TellaskResultMsg, ThinkingMsg, TransientGuideMsg, } from '@longrun-ai/kernel/types/chat-message';
 export interface ModelInfo {
     name?: string;
     context_length?: number;
@@ -52,6 +52,7 @@ export type ProviderApiType = 'codex' | 'anthropic' | 'mock' | 'openai' | 'opena
 export type ProviderConfig = {
     name: string;
     apiType: ProviderApiType;
+    apiQuirks?: string | string[];
     baseUrl: string;
     apiKeyEnvVar: string;
     tool_result_max_chars?: number;

package/dist/llm/defaults.yaml

@@ -4,6 +4,8 @@
 # - llm_retry_conservative_delay_ms: base delay for provider-classified conservative retries (default 30000; fixed for first 10 retries, then ramps by x1.5 with the normal max-delay cap).
 # - llm_retry_backoff_multiplier: exponential factor between retries (default 1.5).
 # - llm_retry_max_delay_ms: upper bound for retry delay (default 1800000 / 30m).
+# - apiQuirks: optional provider/gateway quirk profile(s) for non-standard transport behavior
+#   and retry classification. Example: `apiQuirks: xcode.best`.
 # - tool_result_max_chars: optional transport-level cap for a single tool-result text payload
 #   before Dominds projects it into the provider request. Use this when a provider/gateway enforces
 #   a stricter per-item string limit than Dominds' built-in defaults.
@@ -27,6 +29,9 @@ providers:
           min: 1
           description: Maximum tokens to generate (provider-agnostic override).
       codex:
+        # Isolation principle:
+        # - These hints describe the Codex wrapper only.
+        # - Same-looking fields under `openai` are not aliases and are not fallback-compatible.
         reasoning_effort:
           prominent: true
           default: high
@@ -701,14 +706,23 @@ providers:
     apiKeyEnvVar: OPENAI_API_KEY
     tech_spec_url: https://platform.openai.com/docs
     api_mgmt_url: https://platform.openai.com/api-keys
+    # These are documentation hints for humans/agents; they are not auto-applied.
     model_param_options:
       general:
         max_tokens:
+          # Provider-agnostic cap on generated tokens.
           type: integer
           min: 1
           description: Maximum tokens to generate (provider-agnostic override).
       openai:
+        # Isolation principle:
+        # - These hints describe the OpenAI Responses wrapper only.
+        # - Same-looking fields under `codex` are not aliases and are not fallback-compatible.
         reasoning_effort:
+          prominent: true
+          default: high
+          # Trade latency/cost for quality on reasoning-capable models.
+          # Allowed: none | minimal | low | medium | high | xhigh
           type: enum
           values: [none, minimal, low, medium, high, xhigh]
           description: Reasoning effort level (when supported by the model).
@@ -717,36 +731,136 @@ providers:
           default: auto
           values: [auto, concise, detailed, none]
           description: Reasoning summary detail level (when supported by the model).
+        service_tier:
+          prominent: true
+          type: enum
+          values: [auto, default, flex, scale, priority]
+          description: Responses `service_tier` request parameter.
         verbosity:
+          prominent: true
+          default: medium
+          # Control response detail level on GPT-5 series models.
+          # Allowed: low | medium | high
           type: enum
           values: [low, medium, high]
           description: Response verbosity/detail level (GPT-5 series).
         temperature:
+          # Randomness; use 0–0.2 for tool-calling / deterministic behavior.
           type: number
           min: 0
           max: 2
           description: Sampling temperature (0–2).
         top_p:
+          # Nucleus sampling; usually leave unset if using temperature.
           type: number
           min: 0
           max: 1
           description: Nucleus sampling probability (0–1).
-        json_response:
+        parallel_tool_calls:
           type: boolean
-          description: Force JSON object output mode.
+          description: Responses `parallel_tool_calls` request parameter.
+        safety_identifier:
+          type: string
+          description: Responses `safety_identifier` request parameter.
+        text_format:
+          prominent: true
+          default: text
+          type: enum
+          values: [text, json_object, json_schema]
+          description: Responses `text.format.type`. Prefer `json_schema` over legacy `json_object`.
+        text_format_json_schema_name:
+          type: string
+          description: Required when `text_format=json_schema`; mapped to `text.format.name`.
+        text_format_json_schema:
+          type: string
+          description: Required when `text_format=json_schema`; JSON-encoded schema object mapped to `text.format.schema`.
+        text_format_json_schema_strict:
+          type: boolean
+          description: Optional `text.format.strict` when `text_format=json_schema`.
+        web_search_tool:
+          prominent: true
+          type: boolean
+          description: "Enable native Responses `tools: [{type:'web_search'}]`."
+        web_search_context_size:
+          type: enum
+          default: medium
+          values: [low, medium, high]
+          description: Native web_search `search_context_size`.
+        web_search_allowed_domains:
+          type: string_array
+          description: Native web_search `filters.allowed_domains`.
+        web_search_include_sources:
+          type: boolean
+          description: Include `web_search_call.action.sources` in the response payload.
         max_tokens:
           type: integer
           min: 1
           description: Provider-specific max tokens override.
     models:
-      gpt-5.2:
-        name: GPT-5.2
+      gpt-5.4:
+        name: GPT-5.4
+        optimal_max_tokens: 200000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
+        context_length: 272000
+        input_length: 272000
+        output_length: 32768
+        context_window: '272K'
+      gpt-5.4-mini:
+        name: GPT-5.4 Mini
+        optimal_max_tokens: 200000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
         context_length: 272000
         input_length: 272000
         output_length: 32768
         context_window: '272K'
+      gpt-5.3-codex:
+        name: GPT-5.3 Codex
+        optimal_max_tokens: 200000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
+        context_length: 272000
+        input_length: 272000
+        output_length: 32768
+        context_window: '272K'
+      gpt-5.3-codex-spark:
+        name: GPT-5.3 Codex Spark
+        optimal_max_tokens: 80000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 3
+        context_length: 128000
+        input_length: 128000
+        output_length: 32768
+        context_window: '128K'
       gpt-5.2-codex:
         name: GPT-5.2 Codex
+        optimal_max_tokens: 200000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
+        context_length: 272000
+        input_length: 272000
+        output_length: 32768
+        context_window: '272K'
+      gpt-5.2:
+        name: GPT-5.2
+        optimal_max_tokens: 200000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
+        context_length: 272000
+        input_length: 272000
+        output_length: 32768
+        context_window: '272K'
+      gpt-5.1-codex-mini:
+        name: GPT-5.1 Codex Mini
+        optimal_max_tokens: 200000
+        context_length: 272000
+        input_length: 272000
+        output_length: 32768
+        context_window: '272K'
+      gpt-5.1-codex-max:
+        name: GPT-5.1 Codex Max
+        optimal_max_tokens: 200000
         context_length: 272000
         input_length: 272000
         output_length: 32768

package/dist/llm/gen/anthropic.js

@@ -376,9 +376,7 @@ function chatMessageToContentBlocks(chatMsg) {
         return [block];
     }
     // Handle saying and thinking messages from assistant
-    if (chatMsg.type === 'saying_msg' ||
-        chatMsg.type === 'ui_only_markdown_msg' ||
-        chatMsg.type === 'thinking_msg') {
+    if (chatMsg.type === 'saying_msg' || chatMsg.type === 'thinking_msg') {
         const block = { type: 'text', text: chatMsg.content };
         return [block];
     }
@@ -406,7 +404,7 @@ function chatMessageToContentBlocks(chatMsg) {
         return [block];
     }
     // Handle tellask call results (NOT LLM-native tool use; represented as role='user' text)
-    if (chatMsg.type === 'tellask_result_msg' || chatMsg.type === 'tellask_carryover_result_msg') {
+    if (chatMsg.type === 'tellask_result_msg' || chatMsg.type === 'tellask_carryover_msg') {
         const msg = {
             type: 'text',
             text: chatMsg.content,

package/dist/llm/gen/codex.d.ts

@@ -2,6 +2,8 @@
  * Module: llm/gen/codex
  *
  * ChatGPT Codex responses integration (streaming-only).
+ * Isolation principle: this wrapper owns Codex-native request/stream semantics and must not reuse
+ * OpenAI Responses parameter namespaces or event interpretations.
  */
 import type { ChatGptResponsesRequest } from '@longrun-ai/codex-auth';
 import type { Team } from '../../team';
@@ -9,6 +11,15 @@ import type { FuncTool } from '../../tool';
 import type { ChatMessage, ProviderConfig } from '../client';
 import type { LlmBatchResult, LlmFailureDisposition, LlmGenerator, LlmRequestContext, LlmStreamReceiver, LlmStreamResult } from '../gen';
 export declare function resolveCodexServiceTier(serviceTier: ChatGptResponsesRequest['service_tier'] | undefined): Exclude<NonNullable<ChatGptResponsesRequest['service_tier']>, 'default'> | undefined;
+export declare function spliceCodexBuiltinPrompt(params: {
+    template: string;
+    defaultModel: string;
+    loadPrompt: (model: string) => string | null;
+}): string;
+export declare function resolveCodexInstructions(systemPrompt: string, options?: {
+    defaultModel?: string;
+    loadPrompt?: (model: string) => string | null;
+}): string;
 export declare class CodexGen implements LlmGenerator {
     get apiType(): string;
     classifyFailure(error: unknown): LlmFailureDisposition | undefined;

package/dist/llm/gen/codex.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodexGen = void 0;
 exports.resolveCodexServiceTier = resolveCodexServiceTier;
+exports.spliceCodexBuiltinPrompt = spliceCodexBuiltinPrompt;
+exports.resolveCodexInstructions = resolveCodexInstructions;
 const log_1 = require("../../log");
 const i18n_text_1 = require("../../runtime/i18n-text");
 const work_language_1 = require("../../runtime/work-language");
@@ -44,6 +46,7 @@ const tool_call_context_1 = require("./tool-call-context");
 const tool_output_limit_1 = require("./tool-output-limit");
 const log = (0, log_1.createLogger)('llm/codex');
 const codexFallbackInstructions = 'You are Codex CLI.';
+const CODEX_SYSTEM_PROMPT_DIRECTIVE_PATTERN = /^([ \t]*)@codex-system-prompt(?::([A-Za-z0-9._-]+))?([ \t]*)$/gm;
 function resolveCodexServiceTier(serviceTier) {
     // The ChatGPT codex backend rejects the literal `default` tier even though some SDK typings
     // still list it. Omitting the field preserves the standard tier semantics without a 400.
@@ -112,19 +115,29 @@ function tryExtractApiReturnedModel(value) {
     const trimmed = model.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
-async function resolveCodexInstructions(model, systemPrompt, loadPrompt) {
-    const basePrompt = await loadPrompt(model);
-    const trimmedSystemPrompt = systemPrompt.trim();
-    if (!basePrompt) {
-        return {
-            instructions: trimmedSystemPrompt.length > 0 ? systemPrompt : codexFallbackInstructions,
-            assistantPrelude: null,
-        };
+function spliceCodexBuiltinPrompt(params) {
+    let replaced = false;
+    const resolved = params.template.replace(CODEX_SYSTEM_PROMPT_DIRECTIVE_PATTERN, (_match, leading, overrideModel, trailing) => {
+        const selectedModel = overrideModel ?? params.defaultModel;
+        const prompt = params.loadPrompt(selectedModel);
+        if (prompt === null) {
+            throw new Error(`Bundled Codex prompt template not found for model: ${selectedModel}`);
+        }
+        replaced = true;
+        return `${leading}${prompt}${trailing}`;
+    });
+    return replaced ? resolved : params.template;
+}
+function resolveCodexInstructions(systemPrompt, options) {
+    const baseInstructions = systemPrompt.trim().length > 0 ? systemPrompt : codexFallbackInstructions;
+    if (options?.defaultModel === undefined || options.loadPrompt === undefined) {
+        return baseInstructions;
     }
-    return {
-        instructions: basePrompt,
-        assistantPrelude: trimmedSystemPrompt.length > 0 ? trimmedSystemPrompt : null,
-    };
+    return spliceCodexBuiltinPrompt({
+        template: baseInstructions,
+        defaultModel: options.defaultModel,
+        loadPrompt: options.loadPrompt,
+    });
 }
 function funcToolToCodex(funcTool) {
     // MCP schemas are passed through to providers. Codex tool schema types are narrower; runtime
@@ -145,16 +158,12 @@ const CODEX_JSON_RESPONSE_SCHEMA = {
     additionalProperties: true,
 };
 function resolveCodexWebSearchMode(agent) {
-    const codexParams = agent.model_params?.codex ?? agent.model_params?.openai;
-    return codexParams?.web_search ?? 'live';
+    return agent.model_params?.codex?.web_search ?? 'live';
 }
 function resolveCodexJsonResponseEnabled(agent) {
     const providerSpecific = agent.model_params?.codex?.json_response;
     if (providerSpecific !== undefined)
         return providerSpecific;
-    const openAiSpecific = agent.model_params?.openai?.json_response;
-    if (openAiSpecific !== undefined)
-        return openAiSpecific;
     return agent.model_params?.json_response === true;
 }
 function buildCodexNativeTools(agent) {
@@ -168,7 +177,8 @@ function buildCodexNativeTools(agent) {
     return [webSearchTool];
 }
 function buildCodexTextControls(agent) {
-    const codexParams = agent.model_params?.codex ?? agent.model_params?.openai;
+    // Provider isolation rule: the Codex wrapper only consumes `model_params.codex.*`.
+    const codexParams = agent.model_params?.codex;
     const text = {};
     if (codexParams && codexParams.verbosity) {
         text.verbosity = codexParams.verbosity;
@@ -184,7 +194,8 @@ function buildCodexTextControls(agent) {
     return Object.keys(text).length > 0 ? text : undefined;
 }
 function buildCodexReasoning(agent) {
-    const codexParams = agent.model_params?.codex ?? agent.model_params?.openai;
+    // Provider isolation rule: do not borrow OpenAI Responses params inside the Codex wrapper.
+    const codexParams = agent.model_params?.codex;
     if (codexParams?.reasoning_effort === undefined && codexParams?.reasoning_summary === undefined) {
         return null;
     }
@@ -214,6 +225,7 @@ function assertNoCodexNativeToolCollisions(funcTools, nativeTools) {
 }
 function toLlmWebSearchCall(item, itemId, phase) {
     return {
+        source: 'codex',
         phase,
         itemId,
         status: item.status,
@@ -290,12 +302,11 @@ function chatMessageToCodexItems(msg) {
             return [messageItem('user', msg.content)];
         case 'transient_guide_msg':
         case 'saying_msg':
-        case 'ui_only_markdown_msg':
             return [messageItem('assistant', msg.content)];
         case 'thinking_msg':
             return [thinkingMessageToCodexReasoningItem(msg)];
         case 'tellask_result_msg':
-        case 'tellask_carryover_result_msg':
+        case 'tellask_carryover_msg':
             return [messageItem('user', msg.content)];
         case 'func_call_msg':
             return [
@@ -402,17 +413,13 @@ async function buildCodexInput(context, providerConfig) {
     }
     return input;
 }
-async function buildCodexRequest(providerConfig, agent, instructions, assistantPrelude, funcTools, requestContext, context) {
+async function buildCodexRequest(providerConfig, agent, instructions, funcTools, requestContext, context) {
     if (!agent.model) {
         throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
     }
-    const input = [];
-    if (assistantPrelude) {
-        // Codex backend rejects system messages; pass extra instructions as prior assistant context.
-        input.push(messageItem('assistant', assistantPrelude));
-    }
-    input.push(...(await buildCodexInput(context, providerConfig)));
-    const codexParams = agent.model_params?.codex ?? agent.model_params?.openai;
+    const input = await buildCodexInput(context, providerConfig);
+    // Provider isolation rule: request construction must only read Codex-native params here.
+    const codexParams = agent.model_params?.codex;
     const parallelToolCalls = codexParams?.parallel_tool_calls ?? true;
     const reasoning = buildCodexReasoning(agent);
     const include = reasoning !== null ? ['reasoning.encrypted_content'] : [];
@@ -462,8 +469,11 @@ class CodexGen {
         if (!agent.model) {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
-        const resolvedInstructions = await resolveCodexInstructions(agent.model, systemPrompt, codexAuth.loadCodexPrompt);
-        const payload = await buildCodexRequest(providerConfig, agent, resolvedInstructions.instructions, resolvedInstructions.assistantPrelude, funcTools, requestContext, context);
+        const instructions = resolveCodexInstructions(systemPrompt, {
+            defaultModel: agent.model,
+            loadPrompt: codexAuth.loadCodexPromptSync,
+        });
+        const payload = await buildCodexRequest(providerConfig, agent, instructions, funcTools, requestContext, context);
         let sayingStarted = false;
         let thinkingStarted = false;
         let sawOutputText = false;

package/dist/llm/gen/failure-classifier.js

@@ -115,6 +115,23 @@ function classifyOpenAiLikeFailure(error) {
     const lowerMessage = message.toLowerCase();
     const status = readErrorStatus(error);
     const code = readErrorCode(error);
+    if (code === 'OPENAI_MALFORMED_BATCH_OUTPUT_ITEM') {
+        return {
+            kind: 'fatal',
+            message,
+            status,
+            code,
+        };
+    }
+    if (code === 'XCODE_BEST_STREAM_INTERNAL_ERROR') {
+        return {
+            kind: 'retriable',
+            message,
+            status,
+            code,
+            retryStrategy: 'aggressive',
+        };
+    }
     if (status === 503 || status === 529 || isConservativeRetryMessage(lowerMessage)) {
         return {
             kind: 'retriable',