dominds 1.16.8 → 1.17.0

package/README.md

@@ -203,7 +203,7 @@ Then:
 
 Platform note:
 
-- On Windows, the runtime does not register the `codex_style_tools` toolset. Do not grant `codex_style_tools` in `.minds/team.yaml` for Windows hosts.
+- On Windows, the runtime does not register the `codex_inspect_and_patch_tools` toolset. Do not grant `codex_inspect_and_patch_tools` in `.minds/team.yaml` for Windows hosts.
 
 ## Start from scratch
 

package/README.zh.md

@@ -142,7 +142,7 @@ dominds
 
 平台说明：
 
-- Windows 运行时不会注册 `codex_style_tools` 工具集。在 Windows 主机上的 `.minds/team.yaml` 中不要授予 `codex_style_tools`。
+- Windows 运行时不会注册 `codex_inspect_and_patch_tools` 工具集。在 Windows 主机上的 `.minds/team.yaml` 中不要授予 `codex_inspect_and_patch_tools`。
 
 ## 从零开始（空文件夹启动）
 

package/dist/dialog-display-state.js

@@ -417,6 +417,13 @@ async function computeIdleDisplayState(dlg) {
             continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
         };
     }
+    if (latest?.pendingCourseStartPrompt) {
+        return {
+            kind: 'stopped',
+            reason: { kind: 'pending_course_start' },
+            continueEnabled: true,
+        };
+    }
     const hasQ4H = await dlg.hasPendingQ4H();
     const hasSubdialogs = await dlg.hasPendingSubdialogs();
     if (hasQ4H && hasSubdialogs) {
@@ -449,6 +456,13 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
             continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
         };
     }
+    if (latest?.pendingCourseStartPrompt) {
+        return {
+            kind: 'stopped',
+            reason: { kind: 'pending_course_start' },
+            continueEnabled: true,
+        };
+    }
     const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
     const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
     const hasQ4H = q4h.length > 0;
@@ -502,6 +516,13 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
                 continueEnabled: isStoppedReasonResumable(latest.executionMarker.reason),
             };
         }
+        if (latest.pendingCourseStartPrompt) {
+            return {
+                kind: 'stopped',
+                reason: { kind: 'pending_course_start' },
+                continueEnabled: true,
+            };
+        }
         const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
         const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
         const hasQ4H = q4h.length > 0;
@@ -605,7 +626,7 @@ async function reconcileDisplayStatesAfterRestart() {
             if (!nextIdle) {
                 continue;
             }
-            const next = nextIdle.kind === 'blocked'
+            const next = nextIdle.kind === 'blocked' || nextIdle.kind === 'stopped' || nextIdle.kind === 'dead'
                 ? nextIdle
                 : {
                     kind: 'stopped',

package/dist/dialog-instance-registry.js

@@ -24,6 +24,39 @@ function clampNonNegativeFiniteInt(value, fallback) {
         return fallback;
     return Math.max(0, Math.floor(value));
 }
+async function resolvePendingCourseStartPromptForRestore(args) {
+    const pending = args.latest?.pendingCourseStartPrompt;
+    if (!pending) {
+        return { pendingCourseStartPrompt: undefined };
+    }
+    const alreadyPersisted = args.messages.some((message) => {
+        return message.type === 'prompting_msg' && message.msgId === pending.msgId;
+    });
+    if (alreadyPersisted) {
+        if (args.status === 'running') {
+            await persistence_1.DialogPersistence.clearPendingCourseStartPrompt(args.dialogId, pending.msgId, args.status);
+        }
+        return { pendingCourseStartPrompt: undefined };
+    }
+    return {
+        pendingCourseStartPrompt: {
+            content: pending.content,
+            msgId: pending.msgId,
+            grammar: 'markdown',
+            origin: 'runtime',
+            ...(pending.userLanguageCode === undefined
+                ? {}
+                : { userLanguageCode: pending.userLanguageCode }),
+            ...(pending.tellaskReplyDirective === undefined
+                ? {}
+                : { tellaskReplyDirective: pending.tellaskReplyDirective }),
+            ...(pending.skipTaskdoc === undefined ? {} : { skipTaskdoc: pending.skipTaskdoc }),
+            ...(pending.subdialogReplyTarget === undefined
+                ? {}
+                : { subdialogReplyTarget: pending.subdialogReplyTarget }),
+        },
+    };
+}
 async function getOrRestoreRootDialog(rootId, status) {
     const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
     if (existing) {
@@ -41,6 +74,12 @@ async function getOrRestoreRootDialog(rootId, status) {
         return undefined;
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialogId, status);
+    const { pendingCourseStartPrompt } = await resolvePendingCourseStartPromptForRestore({
+        dialogId: rootDialogId,
+        status,
+        messages: rootState.messages,
+        latest,
+    });
     let diligencePushMax = diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
     try {
         const team = await team_1.Team.load();
@@ -56,6 +95,7 @@ async function getOrRestoreRootDialog(rootId, status) {
         reminders: rootState.reminders,
         currentCourse: rootState.currentCourse,
         contextHealth: rootState.contextHealth,
+        pendingCourseStartPrompt,
     });
     const persistedDisableDiligencePush = latest && typeof latest.disableDiligencePush === 'boolean'
         ? latest.disableDiligencePush
@@ -97,6 +137,12 @@ async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds =
     if (!state)
         return undefined;
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(targetId, status);
+    const { pendingCourseStartPrompt } = await resolvePendingCourseStartPromptForRestore({
+        dialogId: targetId,
+        status,
+        messages: state.messages,
+        latest,
+    });
     const assignmentFromSup = state.metadata.assignmentFromSup;
     if (!assignmentFromSup)
         return undefined;
@@ -112,6 +158,7 @@ async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds =
         reminders: state.reminders,
         currentCourse: state.currentCourse,
         contextHealth: state.contextHealth,
+        pendingCourseStartPrompt,
     });
     subdialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
     if (subdialog.sessionSlug) {

package/dist/dialog-interruption.d.ts

@@ -16,3 +16,4 @@ import type { DialogInterruptionReason } from '@longrun-ai/kernel/types/display-
  *   provider/model and should keep protecting the system.
  */
 export declare function isInterruptionReasonManualResumeEligible(reason: DialogInterruptionReason): boolean;
+export declare function doesInterruptionReasonRequireExplicitResume(reason: DialogInterruptionReason): boolean;

package/dist/dialog-interruption.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isInterruptionReasonManualResumeEligible = isInterruptionReasonManualResumeEligible;
+exports.doesInterruptionReasonRequireExplicitResume = doesInterruptionReasonRequireExplicitResume;
 /**
  * Decides whether a finalized stopped dialog should expose manual Continue.
  *
@@ -22,6 +23,24 @@ function isInterruptionReasonManualResumeEligible(reason) {
         case 'user_stop':
         case 'emergency_stop':
         case 'server_restart':
+        case 'pending_course_start':
+        case 'fork_continue_ready':
+        case 'system_stop':
+        case 'llm_retry_stopped':
+            return true;
+        default: {
+            const _exhaustive = reason;
+            return _exhaustive;
+        }
+    }
+}
+function doesInterruptionReasonRequireExplicitResume(reason) {
+    switch (reason.kind) {
+        case 'pending_course_start':
+            return false;
+        case 'user_stop':
+        case 'emergency_stop':
+        case 'server_restart':
         case 'fork_continue_ready':
         case 'system_stop':
         case 'llm_retry_stopped':

package/dist/dialog.d.ts

@@ -106,6 +106,7 @@ export interface DialogInitParams {
         createdAt?: string;
         updatedAt?: string;
         contextHealth?: ContextHealthSnapshot;
+        pendingCourseStartPrompt?: DialogPrompt;
     };
 }
 export type VisibleReminderTarget = Readonly<{
@@ -678,7 +679,7 @@ export declare abstract class DialogStore {
     /**
      * Start a new course in storage
      */
-    startNewCourse(_dialog: Dialog, _newCoursePrompt: string): Promise<void>;
+    startNewCourse(_dialog: Dialog, _newCoursePrompt: DialogPrompt): Promise<void>;
     /**
      * Handle stream error
      */

package/dist/dialog.js

@@ -67,6 +67,38 @@ function getGlobalDialogMutex(dialogId) {
 function compareVisibleReminderTargetOrder(a, b) {
     return (0, tool_1.compareReminderDisplayOrder)(a.reminder, b.reminder);
 }
+function buildSubdialogAssignmentPromptMeta(subdialog) {
+    const assignment = subdialog.assignmentFromSup;
+    switch (assignment.callName) {
+        case 'tellask':
+            return {
+                tellaskReplyDirective: {
+                    expectedReplyCallName: 'replyTellask',
+                    targetCallId: assignment.callId,
+                    tellaskContent: assignment.tellaskContent,
+                },
+                subdialogReplyTarget: {
+                    ownerDialogId: assignment.callerDialogId,
+                    callType: 'B',
+                    callId: assignment.callId,
+                },
+            };
+        case 'tellaskSessionless':
+        case 'freshBootsReasoning':
+            return {
+                tellaskReplyDirective: {
+                    expectedReplyCallName: 'replyTellaskSessionless',
+                    targetCallId: assignment.callId,
+                    tellaskContent: assignment.tellaskContent,
+                },
+                subdialogReplyTarget: {
+                    ownerDialogId: assignment.callerDialogId,
+                    callType: 'C',
+                    callId: assignment.callId,
+                },
+            };
+    }
+}
 /**
  * Abstract base class for all dialog types.
  * Contains common properties and methods shared between RootDialog and SubDialog.
@@ -132,6 +164,9 @@ class Dialog {
         this._lastUserLanguageCode = (0, work_language_1.getWorkLanguage)();
         this._lastContextHealth = initialState?.contextHealth;
         this._lastContextHealthGenseq = undefined;
+        if (initialState?.pendingCourseStartPrompt) {
+            this.setNewCourseStartPrompt(initialState.pendingCourseStartPrompt);
+        }
         this.resetCourseLanguageNotice();
     }
     setLastContextHealth(snapshot) {
@@ -844,6 +879,7 @@ class Dialog {
             grammar: 'markdown',
             userLanguageCode: this._lastUserLanguageCode,
             origin: 'runtime',
+            ...(this instanceof SubDialog ? buildSubdialogAssignmentPromptMeta(this) : {}),
         };
         const runControlSpec = options?.runControl ?? this._activeRunControlSpec;
         let nextPrompt = basePrompt;
@@ -863,7 +899,7 @@ class Dialog {
         await this.dlgStore.clearQuestions4Human(this);
         // Delegate to DialogStore for course start persistence
         if (this.dlgStore) {
-            await this.dlgStore.startNewCourse(this, nextPrompt.content);
+            await this.dlgStore.startNewCourse(this, nextPrompt);
         }
         const storeCourse = this.dlgStore
             ? await this.dlgStore.loadCurrentCourse(this.id)

package/dist/docs/app-constitution.md

@@ -444,7 +444,7 @@ Suggested team shape:
   - non-goal: does not directly edit product code or take over build/process management.
 - `web_developer`
   - primary responsibility: implement UI/interaction fixes, consume `web_tester` findings, and close the loop;
-  - default toolsets: code-edit/search tools such as `codex_style_tools` (or equivalent) plus optional access to read tester evidence;
+  - default toolsets: code-edit/search tools such as `codex_inspect_and_patch_tools` (or equivalent) plus optional access to read tester evidence;
   - non-goal: should not blur browser acceptance into an implicit “I also tested it” posture; when acceptance is needed, it should explicitly tell/ask `web_tester`.
 
 Suggested `team.yaml` fragment:
@@ -463,7 +463,7 @@ members:
     icon: '🛠️'
     toolsets:
       - ws_read
-      - codex_style_tools
+      - codex_inspect_and_patch_tools
 ```
 
 Requirements for the `playwright_interactive` toolset design:

package/dist/docs/app-constitution.zh.md

@@ -443,7 +443,7 @@ Web Dev App 需要明确区分三套命名，避免再次漂移：
   - 非目标：不直接修改业务代码；不接管构建/进程管理。
 - `web_developer`
   - 主要职责：实现页面/UI/交互修复，消费 `web_tester` 的缺陷报告并完成闭环。
-  - 默认工具集：代码修改/检索工具（如 `codex_style_tools` 或等价工具）+ 可选读取 `web_tester` 产出的证据。
+  - 默认工具集：代码修改/检索工具（如 `codex_inspect_and_patch_tools` 或等价工具）+ 可选读取 `web_tester` 产出的证据。
   - 非目标：不把浏览器验收职责模糊地“顺手做掉”；需要时应显式 tellask `web_tester` 做验收。
 
 建议的 `team.yaml` 片段：
@@ -462,7 +462,7 @@ members:
     icon: '🛠️'
     toolsets:
       - ws_read
-      - codex_style_tools
+      - codex_inspect_and_patch_tools
 ```
 
 关于 `playwright_interactive` 工具集的设计要求：

package/dist/docs/dialog-system.md

@@ -168,6 +168,8 @@ When a dialog still carries an inter-dialog reply obligation, but the user tempo
 5. As long as the user keeps sending new messages, the dialog stays in temporary interjection-chat handling, and that paused projection remains in place only if it was established in the first place.
 6. Only an explicit UI `Continue` attempts to restore the original task.
 
+**Strict boundary**: a formal `askHuman` answer is not part of this "user interjection" category. As soon as a prompt carries a real `q4hAnswerCallId`, it belongs to the askHuman reply channel and semantically continues an already-materialized question/answer chain; it must never be downgraded into temporary local side-chat.
+
 **Key point**: this `stopped` state is only a temporary run-control / UI projection. It is not the same as an ordinary system-stop failure, and it is not the final business source of truth. It also does not apply to every interjection; it exists only when there really is a parked original task to resume.
 
 After the user clicks `Continue`, the backend MUST re-evaluate fresh persistence facts and decide which true-source case now applies. It must not infer the result purely from the visible `displayState`:
@@ -183,6 +185,7 @@ After the user clicks `Continue`, the backend MUST re-evaluate fresh persistence
 
 - `refreshRunControlProjectionFromPersistenceFacts()` MUST preserve the special "interjection handled; original task paused" `stopped` projection until the user explicitly clicks `Continue`; otherwise the UI collapses back to ordinary `blocked` too early and breaks multi-turn interjection UX. Conversely, when there is no parked original task, this paused projection should not be created at all.
 - The actual outcome of `Continue` MUST be decided in the resume drive path by re-reading fresh persistence facts. "Continue is clickable" does not mean "the dialog will definitely enter proceeding immediately".
+- If `Continue` reveals that the true state is still `blocked`, the reply-obligation reassertion copy should be materialized immediately as a runtime guide in both `dlg.msgs` and persisted course history, while also surfacing as a frontend bubble. That lets the later real resume path rely on ordinary context replay instead of synthesizing a second duplicate runtime prompt.
 - The run-control toolbar's `resumable` count should align with "manual Continue attempt is meaningful". Therefore an interjection-paused `stopped` dialog still counts as resumable even when underlying blocker facts remain, because the business meaning of `Continue` there is "exit the temporary paused projection and re-evaluate from source-of-truth facts".
 
 **Mental-model warning**:
@@ -190,6 +193,7 @@ After the user clicks `Continue`, the backend MUST re-evaluate fresh persistence
 - Do not reason about this flow from `displayState.kind === 'stopped'` alone.
 - Do not reason about it from blocker facts alone and then wonder why the UI still shows `stopped`.
 - Do not reason about it from `resume_dialog` eligibility alone and assume resumption always means immediate running.
+- Do not flatten every `origin === 'user'` prompt into "interjection"; a non-empty `q4hAnswerCallId` means askHuman answer continuation and follows a different semantic path.
 
 You need all of the following together to understand the behavior correctly:
 

package/dist/docs/dialog-system.zh.md

@@ -167,6 +167,8 @@
 5. 只要用户继续发送新消息，就继续作为插话临时对话处理；这个 paused projection 仅在它已被建立时持续保持。
 6. 只有用户显式点击 UI `Continue`，系统才尝试恢复原任务。
 
+**严格边界**：`askHuman` 的正式回答不属于这里的“用户插话”。只要一条 prompt 带着真实的 `q4hAnswerCallId`，它就属于 askHuman 回复通道，语义上是在继续已 materialize 的提问/应答链路，绝不能被压入“本地临时插话聊天”。
+
 **关键点**：这里的 `stopped` 只是一个临时 run-control / UI 投影，不等于普通 system-stop 失败，也不是最终的业务真源；并且它不是所有插话都会出现，只在“确有一个待恢复的原任务被临时停靠”时出现。
 
 点击 `Continue` 后，后端必须重新从 persistence 真源判定当前对话属于哪一种情况，而不能只根据表面的 `displayState` 做静态推断：
@@ -182,6 +184,7 @@
 
 - `refreshRunControlProjectionFromPersistenceFacts()` 在用户尚未点击 `Continue` 前，必须保留这层“插话已处理；原任务已暂停”的 `stopped` 投影；否则 UI 会过早塌回普通 `blocked`，破坏多轮插话体验。反过来，如果当前其实没有待恢复原任务，则根本不应建立这层 paused projection。
 - 真正决定 `Continue` 结果的逻辑，必须在恢复驱动路径中重新读取 fresh persistence facts；不能把“可点 Continue”误解为“必然立即 proceeding”。
+- 若 `Continue` 后真源仍是 `blocked`，回复责任重申文案应当立即作为 runtime guide 同时进入 `dlg.msgs` 与持久化课程历史，并同步发前端气泡；这样后面真正恢复 drive 时只需正常读取上下文，不应再额外补发一条重复的 runtime prompt。
 - run-control 工具栏中的 `resumable` 计数，应与“是否允许手动 Continue 尝试”保持一致。因此，处于 interjection-paused `stopped` 的对话即便底层仍有 blocker，也应计入 `resumable`；因为 `Continue` 的业务语义正是“退出这层临时 paused projection，并从真源重判下一步”。
 
 **心智模型提醒**：
@@ -189,6 +192,7 @@
 - 不能只看 `displayState.kind === 'stopped'` 就理解这条链路。
 - 不能只看 blocker facts 就理解为什么 UI 仍显示 `stopped`。
 - 也不能只看 `resume_dialog` eligibility 就推断恢复后一定马上运行。
+- 更不能把所有 `origin === 'user'` 的输入都笼统视作“用户插话”；`q4hAnswerCallId` 非空的 prompt 是 askHuman answer continuation，必须按另一条语义链处理。
 
 必须把以下几块一起看，才能形成完整且精确的理解：
 

package/dist/docs/team_mgmt-toolset.md

@@ -533,7 +533,7 @@ Best practices:
 
 - Make `member_defaults` conservative. Grant additional tools/dirs on a per-member basis.
 - Prefer toolsets over individually enumerating tools unless you need a one-off tool.
-- Platform note: Windows runtime intentionally does not register `codex_style_tools`; do not grant that toolset in `.minds/team.yaml` on Windows hosts.
+- Platform note: Windows runtime intentionally does not register `codex_inspect_and_patch_tools`; do not grant that toolset in `.minds/team.yaml` on Windows hosts.
 - Keep `.minds/team.yaml` ownership tight; only the team manager should be able to edit it.
 - Avoid repeating built-in constraints in `team.yaml`:
   - `*.tsk/**` (encapsulated Taskdocs) are hard-denied for all general file tools.

package/dist/docs/team_mgmt-toolset.zh.md

@@ -452,7 +452,7 @@ members:
 
 - 使 `member_defaults` 保守。按成员授予额外的工具/目录
 - 优先使用工具集而不是单独枚举工具，除非你需要一次性工具
-- 平台说明：Windows 运行时不会注册 `codex_style_tools`；在 Windows 主机上的 `.minds/team.yaml` 中不要授予该工具集
+- 平台说明：Windows 运行时不会注册 `codex_inspect_and_patch_tools`；在 Windows 主机上的 `.minds/team.yaml` 中不要授予该工具集
 - 保持 `.minds/team.yaml` 的所有权严格；只有团队管理者应该能够编辑它
 - 避免在 `team.yaml` 中重复内置约束：
   - `*.tsk/**`（封装的差遣牒任务包）对所有通用文件工具被硬性拒绝

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

@@ -11,15 +11,7 @@ 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 function resolveCodexInstructions(systemPrompt: string): string;
 export declare class CodexGen implements LlmGenerator {
     get apiType(): string;
     classifyFailure(error: unknown): LlmFailureDisposition | undefined;

package/dist/llm/gen/codex.js

@@ -35,7 +35,6 @@ 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");
@@ -47,7 +46,6 @@ const tool_output_limit_1 = require("./tool-output-limit");
 const tool_result_image_ingest_1 = require("./tool-result-image-ingest");
 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.
@@ -116,29 +114,8 @@ function tryExtractApiReturnedModel(value) {
     const trimmed = model.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
-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 spliceCodexBuiltinPrompt({
-        template: baseInstructions,
-        defaultModel: options.defaultModel,
-        loadPrompt: options.loadPrompt,
-    });
+function resolveCodexInstructions(systemPrompt) {
+    return systemPrompt.trim().length > 0 ? systemPrompt : codexFallbackInstructions;
 }
 function funcToolToCodex(funcTool) {
     // MCP schemas are passed through to providers. Codex tool schema types are narrower; runtime
@@ -534,10 +511,7 @@ class CodexGen {
         if (!agent.model) {
             throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
         }
-        const instructions = resolveCodexInstructions(systemPrompt, {
-            defaultModel: agent.model,
-            loadPrompt: codexAuth.loadCodexPromptSync,
-        });
+        const instructions = resolveCodexInstructions(systemPrompt);
         const payload = await buildCodexRequest(providerConfig, agent, instructions, funcTools, requestContext, context, receiver.toolResultImageIngest);
         let sayingStarted = false;
         let thinkingStarted = false;