dominds 1.8.2 → 1.8.4

package/dist/apps/run-control.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAppDialogRunControl = applyAppDialogRunControl;
 exports.applyRegisteredAppDialogRunControls = applyRegisteredAppDialogRunControls;
+const log_1 = require("../log");
 const dialog_run_controls_1 = require("./dialog-run-controls");
 const runtime_1 = require("./runtime");
+const log = (0, log_1.createLogger)('apps-run-control');
 async function applyAppDialogRunControl(params) {
     const controlId = params.controlId.trim();
     if (controlId === '') {
@@ -18,10 +20,25 @@ async function applyAppDialogRunControl(params) {
 }
 async function applyRegisteredAppDialogRunControls(payload) {
     for (const control of (0, dialog_run_controls_1.listAppDialogRunControls)()) {
-        const result = await applyAppDialogRunControl({
-            controlId: control.id,
-            payload,
-        });
+        let result;
+        try {
+            result = await applyAppDialogRunControl({
+                controlId: control.id,
+                payload,
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            log.warn('App dialog run control failed; continuing without this app control', err, {
+                controlId: control.id,
+                dialogId: payload.dialog.selfId,
+                rootId: payload.dialog.rootId,
+                agentId: payload.agentId,
+                taskDocPath: payload.taskDocPath,
+                source: payload.source,
+            });
+            continue;
+        }
         if (result.kind === 'reject') {
             return result;
         }

package/dist/apps/runtime.js

@@ -29,6 +29,17 @@ let hostedAppsSignature = null;
 let appsRuntimeConfig = null;
 let refreshQueue = Promise.resolve();
 const registeredAppArtifactsById = new Map();
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function formatAppCapabilityUnavailableMessage(params) {
+    return [
+        `App capability unavailable: ${params.capability}`,
+        `appId=${params.appId}`,
+        `reason=${params.detail}`,
+        'This app-specific capability is unavailable for now. Continue with other available tools unless this app is required.',
+    ].join('\n');
+}
 function resolveRootDialogFor(dlg) {
     if (dlg instanceof dialog_1.RootDialog) {
         return dlg;
@@ -269,27 +280,46 @@ function registerAppArtifacts(app) {
             descriptionI18n: t.descriptionI18n,
             parameters: t.parameters,
             call: async (dlg, caller, args) => {
-                const host = await ensureAppsHostReadyForToolCalls();
-                const result = await host.callTool(t.name, args, {
-                    dialogId: dlg.id.selfId,
-                    rootDialogId: dlg.id.rootId,
-                    agentId: dlg.agentId,
-                    taskDocPath: dlg.taskDocPath,
-                    sessionSlug: dlg instanceof dialog_1.SubDialog ? dlg.sessionSlug : undefined,
-                    callerId: caller.id,
-                });
-                if (Array.isArray(result.reminderRequests) && result.reminderRequests.length > 0) {
-                    await (0, app_reminders_1.applyAppReminderRequests)(dlg, {
-                        appId: app.appId,
-                        reminderRequests: result.reminderRequests,
-                        resolveHostClient: waitForAppsHostClient,
+                try {
+                    const host = await ensureAppsHostReadyForToolCalls();
+                    const result = await host.callTool(t.name, args, {
+                        dialogId: dlg.id.selfId,
+                        rootDialogId: dlg.id.rootId,
+                        agentId: dlg.agentId,
+                        taskDocPath: dlg.taskDocPath,
+                        sessionSlug: dlg instanceof dialog_1.SubDialog ? dlg.sessionSlug : undefined,
+                        callerId: caller.id,
                     });
+                    if (Array.isArray(result.reminderRequests) && result.reminderRequests.length > 0) {
+                        await (0, app_reminders_1.applyAppReminderRequests)(dlg, {
+                            appId: app.appId,
+                            reminderRequests: result.reminderRequests,
+                            resolveHostClient: waitForAppsHostClient,
+                        });
+                    }
+                    if (Array.isArray(result.dialogReminderRequests) &&
+                        result.dialogReminderRequests.length > 0) {
+                        await applyDialogReminderRequestBatches(dlg, app.appId, result.dialogReminderRequests);
+                    }
+                    return result.output;
                 }
-                if (Array.isArray(result.dialogReminderRequests) &&
-                    result.dialogReminderRequests.length > 0) {
-                    await applyDialogReminderRequestBatches(dlg, app.appId, result.dialogReminderRequests);
+                catch (error) {
+                    const err = asError(error);
+                    log.warn('App tool call failed', err, {
+                        appId: app.appId,
+                        toolName: t.name,
+                        dialogId: dlg.id.valueOf(),
+                        rootId: dlg.id.rootId,
+                        selfId: dlg.id.selfId,
+                        agentId: dlg.agentId,
+                        callerId: caller.id,
+                    });
+                    throw new Error(formatAppCapabilityUnavailableMessage({
+                        appId: app.appId,
+                        capability: `tool:${t.name}`,
+                        detail: err.message,
+                    }));
                 }
-                return result.output;
             },
         }));
         registerAppToolset({
@@ -401,18 +431,30 @@ async function registerEnabledAppsToolProxies(params) {
     await run;
 }
 async function listDynamicAppToolsetsForMember(_params) {
-    await registerEnabledAppsToolProxies({ rtwsRootAbs: _params.rtwsRootAbs });
+    try {
+        await registerEnabledAppsToolProxies({ rtwsRootAbs: _params.rtwsRootAbs });
+    }
+    catch (error) {
+        log.warn(`Failed to refresh enabled app tool proxies while resolving dynamic toolsets for member '${_params.memberId}'; continuing without dynamic app toolsets.`, asError(error));
+        return [];
+    }
     if (!appsRuntimeConfig && !appsHostClient && !appsHostTransition) {
         return [];
     }
     if (!appsHostClient && !appsHostTransition) {
         return [];
     }
-    const host = await ensureAppsHostReadyForToolCalls();
-    return await host.listDynamicToolsets({
-        memberId: _params.memberId,
-        taskDocPath: _params.taskDocPath,
-    });
+    try {
+        const host = await ensureAppsHostReadyForToolCalls();
+        return await host.listDynamicToolsets({
+            memberId: _params.memberId,
+            taskDocPath: _params.taskDocPath,
+        });
+    }
+    catch (error) {
+        log.warn(`Failed to load dynamic app toolsets for member '${_params.memberId}'; continuing without dynamic app toolsets.`, asError(error));
+        return [];
+    }
 }
 async function initAppsRuntime(params) {
     appsRuntimeConfig = {

package/dist/dialog.js

@@ -52,6 +52,7 @@ const util_1 = require("util");
 const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
 const async_fifo_mutex_1 = require("./shared/async-fifo-mutex");
+const driver_messages_1 = require("./shared/i18n/driver-messages");
 const runtime_language_1 = require("./shared/runtime-language");
 const id_1 = require("./shared/utils/id");
 const inter_dialog_format_1 = require("./shared/utils/inter-dialog-format");
@@ -124,6 +125,7 @@ class Dialog {
         // This is an in-process cache only (not persisted), intended for small, stable “felt-sense” context
         // like Agent Priming transcripts.
         this._coursePrefixMsgs = [];
+        this._courseRuntimeNoticeMsgs = [];
         // Track whether the current course's initial events (user_text, generating_start)
         // have been fully processed. Used to ensure subdialog_final_response_evt arrives
         // only after parent events are emitted.
@@ -171,6 +173,7 @@ class Dialog {
         this._lastUserLanguageCode = (0, runtime_language_1.getWorkLanguage)();
         this._lastContextHealth = initialState?.contextHealth;
         this._lastContextHealthGenseq = undefined;
+        this.resetCourseLanguageNotice();
     }
     setLastContextHealth(snapshot) {
         this._lastContextHealth = snapshot;
@@ -203,6 +206,24 @@ class Dialog {
     setLastUserLanguageCode(language) {
         this._lastUserLanguageCode = language;
     }
+    buildCourseRuntimeNotice(content) {
+        return {
+            type: 'environment_msg',
+            role: 'user',
+            content,
+        };
+    }
+    resetCourseLanguageNotice() {
+        this._courseRuntimeNoticeMsgs = [
+            this.buildCourseRuntimeNotice((0, driver_messages_1.formatCurrentUserLanguagePreference)((0, runtime_language_1.getWorkLanguage)(), this._lastUserLanguageCode)),
+        ];
+    }
+    appendCourseLanguageChangedNotice(previousLanguage, nextLanguage) {
+        if (previousLanguage === nextLanguage) {
+            return;
+        }
+        this._courseRuntimeNoticeMsgs.push(this.buildCourseRuntimeNotice((0, driver_messages_1.formatUserLanguagePreferenceChangedNotice)((0, runtime_language_1.getWorkLanguage)(), previousLanguage, nextLanguage)));
+    }
     /**
      * Get the current callId for tellask call correlation
      *
@@ -470,7 +491,7 @@ class Dialog {
         this._coursePrefixMsgs = [...msgs];
     }
     getCoursePrefixMsgs() {
-        return this._coursePrefixMsgs;
+        return [...this._coursePrefixMsgs, ...this._courseRuntimeNoticeMsgs];
     }
     // only to be used by the driver
     async addChatMessages(...msgs) {
@@ -689,6 +710,7 @@ class Dialog {
             : this._currentCourse + 1;
         this._currentCourse = storeCourse;
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        this.resetCourseLanguageNotice();
         const normalized = this.setUpNextPrompt(nextPrompt);
         if (options?.skipEnqueueIntent !== true) {
             this._driveIntents.length = 0;

package/dist/docs/app-constitution.md

@@ -360,8 +360,10 @@ Suggested minimal asset shape:
 │           ├── persona.zh.md
 │           ├── knowledge.zh.md
 │           └── lessons.zh.md
+├── bin/
+│   └── <app>.js
 └── src/
-    └── app-host.ts
+    └── app.js
 ```
 
 Suggested team shape:

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

@@ -359,8 +359,10 @@ Web Dev App 需要明确区分三套命名，避免再次漂移：
 │           ├── persona.zh.md
 │           ├── knowledge.zh.md
 │           └── lessons.zh.md
+├── bin/
+│   └── <app>.js
 └── src/
-    └── app-host.ts
+    └── app.js
 ```
 
 建议的团队形态：

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

@@ -690,7 +690,7 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 
 1. 清除所有聊天消息
 2. 清除所有 Q4H 问题
-3. 增加“多程对话”（course）计数器
+3. 增加“某一程对话”（dialog course）计数器
 4. 更新对话的时间戳
 5. 将 `newCoursePrompt` 排队到 `dlg.upNext`，以便驱动程序可以启动新的协程并将其用作新一程的**第一个 `role=user` 消息**
 
@@ -882,7 +882,7 @@ interface SubdialogRegistry {
 
 - **层级支持**：用于子对话管理的父子关系
 - **内存管理**：持久化提醒和临时聊天消息
-- **清理头脑操作**：`startNewRound(newRoundPrompt)` 方法（清除消息，清除 Q4H，开启新一程对话，为下一轮驱动排队开启提示）
+- **清理头脑操作**：`startNewCourse(newCoursePrompt)` 方法（清除消息，清除 Q4H，开启新一程对话，并为下一次驱动排队开启提示）
 - **子对话管理**：专门子任务的创建和协调
 - **Q4H 管理**：用于问题跟踪的 `updateQuestions4Human()` 方法
 - **内存访问**：与差遣牒和团队/智能体内存的集成
@@ -899,7 +899,7 @@ interface SubdialogRegistry {
 - **对话存储**：`dominds/main/persistence.ts`
 - **Q4H 存储**：每个对话的 `q4h.yaml`（被 clear_mind 清除）
 - **提醒存储**：每个对话的 `reminders.json`
-- **事件持久化**：基于轮的 JSONL 文件
+- **事件持久化**：按程分文件的 JSONL 事件流
 - **注册表存储**：每个根对话的 `registry.yaml`
 
 **Q4H 持久化方法**：
@@ -983,9 +983,9 @@ interface RegistryMethods {
 - fork 后的 root/subdialog 都落到 `running/`，并拥有新的 rootId
 - 前端不得对 sideline dialog 暴露该入口；当前实现仅支持 fork root dialog
 
-### 子对话课程头（强制）
+### 支线对话起始角色提示（强制）
 
-每次子对话 course 开始时，运行时必须在 assignment prompt 前插入角色头：
+每当支线对话进入新一程时，运行时必须在 assignment prompt 前插入角色头：
 
 - ZH：`你是当前被诉请者对话（tellaskee dialog）的主理人；诉请者对话（tellasker dialog）为 @xxx（当前发起本次诉请）。`
 - EN：`You are the responder (tellaskee dialog) for this dialog; the tellasker dialog is @xxx (the current caller).`

package/dist/llm/kernel-driver/context.js

@@ -4,32 +4,6 @@ exports.buildDriveBaseContextMessages = buildDriveBaseContextMessages;
 exports.appendDriveEphemeralContext = appendDriveEphemeralContext;
 exports.appendDriveTailContext = appendDriveTailContext;
 exports.assembleDriveContextMessages = assembleDriveContextMessages;
-function findLastUserPromptLikeIndex(msgs) {
-    for (let i = msgs.length - 1; i >= 0; i--) {
-        const msg = msgs[i];
-        if (msg &&
-            (msg.type === 'prompting_msg' ||
-                msg.type === 'environment_msg' ||
-                msg.type === 'tellask_carryover_result_msg') &&
-            msg.role === 'user') {
-            return i;
-        }
-    }
-    return -1;
-}
-function insertBeforeLastUserPromptLike(msgs, toInsert) {
-    if (toInsert.length === 0)
-        return [...msgs];
-    const next = [...msgs];
-    const insertIndex = findLastUserPromptLikeIndex(next);
-    if (insertIndex >= 0) {
-        next.splice(insertIndex, 0, ...toInsert);
-    }
-    else {
-        next.push(...toInsert);
-    }
-    return next;
-}
 function buildDriveBaseContextMessages(parts) {
     return [
         ...parts.prependedContextMessages,
@@ -62,12 +36,9 @@ function hasUserPromptLikeAnchor(source) {
 }
 function appendDriveTailContext(source, parts) {
     if (hasUserPromptLikeAnchor(source)) {
-        return [...source, ...parts.renderedReminders, parts.languageGuideMsg];
-    }
-    if (parts.renderedReminders.length > 0) {
-        return [parts.languageGuideMsg, ...parts.renderedReminders];
+        return [...source, ...parts.renderedReminders];
     }
-    return [...source, parts.languageGuideMsg];
+    return [...source, ...parts.renderedReminders];
 }
 function assembleDriveContextMessages(args) {
     const baseMsgs = buildDriveBaseContextMessages(args.base);

package/dist/llm/kernel-driver/drive.js

@@ -10,6 +10,7 @@ const persistence_1 = require("../../persistence");
 const diligence_1 = require("../../shared/diligence");
 const driver_messages_1 = require("../../shared/i18n/driver-messages");
 const runtime_language_1 = require("../../shared/runtime-language");
+const storage_1 = require("../../shared/types/storage");
 const id_1 = require("../../shared/utils/id");
 const time_1 = require("../../shared/utils/time");
 const tool_1 = require("../../tool");
@@ -1121,6 +1122,10 @@ async function driveDialogStreamCore(dlg, humanPrompt, driveOptions, callbacks)
                             anchorRole: 'assignment',
                             callId: normalizedCallId,
                             genseq: dlg.activeGenSeq,
+                            ...(0, storage_1.toRootGenerationAnchor)({
+                                rootCourse: (dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : dlg).currentCourse,
+                                rootGenseq: (dlg instanceof dialog_1.SubDialog ? dlg.rootDialog : dlg).activeGenSeqOrUndefined ?? 0,
+                            }),
                         };
                         const course = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
                         await persistence_1.DialogPersistence.appendEvent(dlg.id, course, record, dlg.status);
@@ -1130,13 +1135,6 @@ async function driveDialogStreamCore(dlg, humanPrompt, driveOptions, callbacks)
                 pubRemindersVer = dlg.remindersVer;
                 const taskDocMsg = dlg.taskDocPath && !skipTaskdocForThisDrive ? await (0, taskdoc_1.formatTaskDocContent)(dlg) : undefined;
                 const renderedReminders = await renderRemindersForContext(dlg);
-                const uiLanguage = dlg.getLastUserLanguageCode();
-                const workingLanguage = (0, runtime_language_1.getWorkLanguage)();
-                const guideMsg = {
-                    type: 'environment_msg',
-                    role: 'user',
-                    content: (0, driver_messages_1.formatCurrentUserLanguagePreference)(workingLanguage, uiLanguage),
-                };
                 const ctxMsgs = (0, context_1.assembleDriveContextMessages)({
                     base: {
                         prependedContextMessages: policy.prependedContextMessages,
@@ -1146,7 +1144,7 @@ async function driveDialogStreamCore(dlg, humanPrompt, driveOptions, callbacks)
                         dialogMsgsForContext: await buildDialogMsgsForContext(dlg),
                     },
                     ephemeral: {},
-                    tail: { renderedReminders, languageGuideMsg: guideMsg },
+                    tail: { renderedReminders },
                 });
                 const newMsgs = [];
                 const streamedFuncCalls = [];

package/dist/llm/kernel-driver/subdialog.js

@@ -324,6 +324,14 @@ async function supplyResponseToSupdialog(args) {
                 anchorRole: 'response',
                 callId: resolvedCallId,
                 genseq: calleeResponseRef.genseq,
+                ...(0, storage_1.toRootGenerationAnchor)({
+                    rootCourse: parentDialog instanceof dialog_1.SubDialog
+                        ? parentDialog.rootDialog.currentCourse
+                        : parentDialog.currentCourse,
+                    rootGenseq: parentDialog instanceof dialog_1.SubDialog
+                        ? (parentDialog.rootDialog.activeGenSeqOrUndefined ?? 0)
+                        : (parentDialog.activeGenSeqOrUndefined ?? 0),
+                }),
                 assignmentCourse: assignmentRef !== undefined ? (0, storage_1.toAssignmentCourseNumber)(assignmentRef.course) : undefined,
                 assignmentGenseq: assignmentRef !== undefined
                     ? (0, storage_1.toAssignmentGenerationSeqNumber)(assignmentRef.genseq)

package/dist/minds/system-prompt.js

@@ -93,7 +93,7 @@ function buildTeammateTellaskPhaseContract(language) {
         zh: [
             '- 队友诉请必须遵循“发起 → 等待 → 判定 → 续推”四段协议：若目标未达成，立即发出下一轮诉请推进。',
             '- 对队友诉请而言，收到回贴即表示该轮调用已结束；不存在“对方仍在后台继续执行同一诉请”的默认语义。要继续必须显式再发一轮诉请函数（通常 \\`tellask\\` 复用同一 \\`sessionSlug\\`）。',
-            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（自动添加，手动删除）”提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
+            '- 只有在存在明确进行中诉请时，才可声明“等待回贴/等待结果”（通常应可在“⏳ 进行中诉请（共 N 路，自动添加，手动删除）”这类提醒项中观测到）；若该提醒项不存在，或提醒项已明确“当前没有执行中的诉请”，则“等待”是错误动作，必须执行下一动作（直接诉请或本地执行）。',
             '- 能由队友诉请完成的执行性工作，禁止转交 \\`askHuman\\` 做“转发员”；当你写“让 @X 执行 Y”时，必须在同一回复内直接发出 \\`tellask\\` 或 \\`tellaskSessionless\\`。',
             `- 当你在诉请正文里定义“回贴格式/交付格式”时，必须明确写入：\`Dominds 会自动注入回贴标记，禁止手写标记\`；不得要求被诉请者手写 \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR 标记（\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`）。`,
             '- 当你处于队友诉请触发的支线且需要澄清时，必须使用 \\`tellaskBack\\` 回问上游诉请者；\\`tellaskBack\\` 不携带 \\`sessionSlug\\`。',
@@ -102,7 +102,7 @@ function buildTeammateTellaskPhaseContract(language) {
         en: [
             '- Teammate Tellasks MUST follow four phases: “initiate -> wait -> judge -> continue”. If the objective is not met, immediately send the next Tellask round.',
             '- For teammate Tellasks, a delivered response closes that call round; there is no default “still running in background” state for the same Tellask. To continue, emit a new Tellask function call explicitly (usually \\`tellask\\` with the same \\`sessionSlug\\`).',
-            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in the “⏳ In-flight Tellasks (auto-added, manually deleted)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
+            '- You may claim “waiting for reply/result” only when a concrete pending Tellask exists (normally observable in a “⏳ In-flight Tellasks (N total, auto-added, manually deleted)” reminder). If that reminder is absent, or it explicitly states there are no in-flight Tellasks, waiting is a wrong action; execute the next action now (direct Tellask or local action).',
             '- Do not use \\`askHuman\\` as a relay for executable teammate work. If you write “ask @X to do Y”, emit \\`tellask\\` or \\`tellaskSessionless\\` in the same response.',
             `- When you define a “reply/delivery format” inside tellask body, you must explicitly include: \`Dominds auto-injects reply markers; do not hand-write markers\`; do not require the responder to hand-write \`${runtimeMarkers.finalCompleted}\` / \`${runtimeMarkers.tellaskBack}\` / FBR markers (\`${runtimeMarkers.fbrDirectReply}\` / \`${runtimeMarkers.fbrReasoningOnly}\`).`,
             '- When you are in a teammate-triggered sideline and need clarification, you MUST issue \\`tellaskBack\\` to ask back upstream; \\`tellaskBack\\` must not carry \\`sessionSlug\\`.',

package/dist/priming.js

@@ -749,6 +749,10 @@ function normalizePrimingRecordFromJson(raw) {
             const record = {
                 ts: '',
                 type,
+                ...(0, storage_1.toRootGenerationAnchor)({
+                    rootCourse: expectIntegerField(raw, 'rootCourse', context),
+                    rootGenseq: expectIntegerField(raw, 'rootGenseq', context),
+                }),
                 anchorRole,
                 callId: expectStringField(raw, 'callId', context),
                 genseq: expectIntegerField(raw, 'genseq', context),

package/dist/server/websocket-handler.js

@@ -83,6 +83,16 @@ function resolveUserLanguageCode(ws, raw, fallbackDialog) {
         return fallbackDialog.getLastUserLanguageCode();
     return (0, runtime_language_1.getWorkLanguage)();
 }
+function syncDialogLanguagePreference(dialog, language, options) {
+    const previousLanguage = dialog.getLastUserLanguageCode();
+    dialog.setUiLanguage(language);
+    dialog.setLastUserLanguageCode(language);
+    if (options?.appendSwitchNotice) {
+        dialog.appendCourseLanguageChangedNotice(previousLanguage, language);
+        return;
+    }
+    dialog.resetCourseLanguageNotice();
+}
 async function queueUserSupplementAtGenerationBoundary(dialog, prompt) {
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialog.id, 'running');
     const runStateKind = latest?.runState?.kind;
@@ -554,6 +564,10 @@ async function handleSetUiLanguage(ws, packet) {
         return;
     }
     wsUiLanguage.set(ws, parsed);
+    const liveDialog = wsLiveDlg.get(ws);
+    if (liveDialog) {
+        syncDialogLanguagePreference(liveDialog, parsed, { appendSwitchNotice: true });
+    }
     ws.send(JSON.stringify({ type: 'ui_language_set', uiLanguage: parsed }));
 }
 /**
@@ -575,6 +589,7 @@ async function handleCreateDialog(ws, packet) {
         const dialogUI = new persistence_1.DiskFileDialogStore(dialogId);
         // Create RootDialog instance with the new store
         const dialog = new dialog_1.RootDialog(dialogUI, taskDocPath, dialogId, agentId);
+        syncDialogLanguagePreference(dialog, resolveUserLanguageCode(ws, undefined, dialog));
         dialog_global_registry_1.globalDialogRegistry.register(dialog);
         // Setup WebSocket subscription for real-time events
         await setupWebSocketSubscription(ws, dialog);
@@ -720,6 +735,7 @@ async function handleDisplayDialog(ws, packet) {
             }
             dialog = loaded;
         }
+        syncDialogLanguagePreference(dialog, resolveUserLanguageCode(ws, undefined, dialog));
         // Subscribe BEFORE sending restoration events.
         // This avoids a race where new persisted events (e.g., Agent Priming replay) are emitted
         // between the restoration snapshot read and the subscription setup.

package/dist/server.js

@@ -128,8 +128,13 @@ async function startServer(opts = {}) {
     (0, websocket_handler_1.setupWebSocketServer)(httpServer.getHttpServer(), clients, config.auth ?? { kind: 'disabled' }, (0, runtime_language_1.getWorkLanguage)());
     // MCP is best-effort: startup must not be blocked by MCP config/server issues.
     (0, supervisor_1.startMcpSupervisor)();
-    // Apps host: optional. Any errors must be loud and should fail fast because toolsets/teammates may depend on apps.
-    await (0, runtime_1.initAppsRuntime)({ rtwsRootAbs: process.cwd(), kernel: { host, port } });
+    // Apps host is optional for server boot: app failures must stay loud, but they must not block WebUI startup.
+    try {
+        await (0, runtime_1.initAppsRuntime)({ rtwsRootAbs: process.cwd(), kernel: { host, port } });
+    }
+    catch (error) {
+        log.warn('Apps runtime initialization failed during server startup; continuing without app runtime capabilities until the app issue is fixed', error instanceof Error ? error : new Error(String(error)));
+    }
     // Crash recovery: any dialogs left in "proceeding" state are surfaced as interrupted/resumable.
     await (0, dialog_run_state_1.reconcileRunStatesAfterRestart)();
     // Tests may opt out so the process can shut down cleanly without a driver stop API.

package/dist/shared/diligence.js

@@ -30,7 +30,7 @@ exports.DILIGENCE_FALLBACK_TEXT = {
         '',
         '当该提醒项明确写出“当前没有任何执行中的诉请、没有其祂智能体在后台工作”时，任何“继续等待”的想法和行为都是错误的；如果你已经明确知晓这点，可手动删除该提醒项以免碍眼。',
         '',
-        '同理，若不存在“⏳ 进行中诉请（自动添加，手动删除）”提醒项，或某条历史诉请未出现在该提醒项中，都表示当前没有可等待的进行中诉请（通常代表该轮已回贴或已结束）；“继续等待”是错误动作，必须立即执行下一步：本地动作，或使用同一个 `sessionSlug` 再次调用 `tellask` 向对应队友发起下一轮诉请。',
+        '同理，若不存在“⏳ 进行中诉请（共 N 路，自动添加，手动删除）”这类提醒项，或某条历史诉请未出现在该提醒项中，都表示当前没有可等待的进行中诉请（通常代表该轮已回贴或已结束）；“继续等待”是错误动作，必须立即执行下一步：本地动作，或使用同一个 `sessionSlug` 再次调用 `tellask` 向对应队友发起下一轮诉请。',
     ].join('\n'),
     en: [
         'Do a self-check (run one FBR): does the Taskdoc already contain a sufficiently clear goal definition?',
@@ -59,6 +59,6 @@ exports.DILIGENCE_FALLBACK_TEXT = {
         '',
         'When this reminder explicitly says there are no in-flight Tellasks and no agents working in the background, any “keep waiting” thought or behavior is wrong; if you clearly know this, manually delete the reminder to reduce noise.',
         '',
-        'Likewise, if the “⏳ In-flight Tellasks (auto-added, manually deleted)” reminder is absent, or a historical Tellask is not listed in that reminder, there is no waitable in-flight Tellask for it at the moment (usually the previous round has replied or ended). “Keep waiting” is a wrong action; execute the next step immediately: local action, or launch a new Tellask round to the same teammate via `tellask` with the same `sessionSlug`.',
+        'Likewise, if a “⏳ In-flight Tellasks (N total, auto-added, manually deleted)” reminder is absent, or a historical Tellask is not listed in that reminder, there is no waitable in-flight Tellask for it at the moment (usually the previous round has replied or ended). “Keep waiting” is a wrong action; execute the next step immediately: local action, or launch a new Tellask round to the same teammate via `tellask` with the same `sessionSlug`.',
     ].join('\n'),
 };

package/dist/shared/i18n/driver-messages.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSystemNoticePrefix = formatSystemNoticePrefix;
 exports.formatCurrentUserLanguagePreference = formatCurrentUserLanguagePreference;
+exports.formatUserLanguagePreferenceChangedNotice = formatUserLanguagePreferenceChangedNotice;
 exports.formatNewCourseStartPrompt = formatNewCourseStartPrompt;
 exports.formatReminderItemGuide = formatReminderItemGuide;
 exports.formatQ4HDiligencePushBudgetExhausted = formatQ4HDiligencePushBudgetExhausted;
@@ -21,14 +22,53 @@ function formatCurrentUserLanguagePreference(workingLanguage, uiLanguage) {
     const prefix = formatSystemNoticePrefix(workingLanguage);
     if (workingLanguage === 'zh') {
         if (uiLanguage === workingLanguage) {
-            return `${prefix}\n你对用户的可见回复语言应使用：${uiName}。`;
+            return [
+                prefix,
+                '这是浏览器里的界面语言设置，不是新的用户指令；不要停下当前工作，也不要单独回复确认，只需在后续继续任务时遵守。',
+                `你对用户的可见回复语言应使用：${uiName}。`,
+            ].join('\n');
         }
-        return `${prefix}\n你对用户的可见回复语言应使用：${uiName}。\n你的内部工作语言保持为：${workingName}（用于系统提示、队友诉请与工具调用）。`;
+        return [
+            prefix,
+            '这是浏览器里的界面语言设置，不是新的用户指令；不要停下当前工作，也不要单独回复确认，只需在后续继续任务时遵守。',
+            `你对用户的可见回复语言应使用：${uiName}。`,
+            `你的内部工作语言保持为：${workingName}（用于系统提示、队友诉请与工具调用）。`,
+        ].join('\n');
     }
     if (uiLanguage === workingLanguage) {
-        return `${prefix}\nYour user-visible reply language should be: ${uiName}.`;
+        return [
+            prefix,
+            'This comes from a browser UI language change, not a new user instruction. Do not stop the current work or send a standalone acknowledgement; just follow it in subsequent work.',
+            `Your user-visible reply language should be: ${uiName}.`,
+        ].join('\n');
+    }
+    return [
+        prefix,
+        'This comes from a browser UI language change, not a new user instruction. Do not stop the current work or send a standalone acknowledgement; just follow it in subsequent work.',
+        `Your user-visible reply language should be: ${uiName}.`,
+        `Your internal work language remains: ${workingName} (system prompt, teammate comms, function tools).`,
+    ].join('\n');
+}
+function formatUserLanguagePreferenceChangedNotice(workingLanguage, previousUiLanguage, nextUiLanguage) {
+    const previousName = (0, language_1.formatLanguageName)(previousUiLanguage, workingLanguage);
+    const nextName = (0, language_1.formatLanguageName)(nextUiLanguage, workingLanguage);
+    const prefix = formatSystemNoticePrefix(workingLanguage);
+    if (workingLanguage === 'zh') {
+        return [
+            prefix,
+            '这是浏览器里的界面语言切换，不是新的用户指令；不要停下当前工作，不要只回复“收到/好的”，也不要把这条提示当成新的待办。',
+            `用户的界面语言已从 ${previousName} 切换为 ${nextName}。`,
+            `从现在起，你对用户的可见回复语言应使用：${nextName}。`,
+            '继续推进当前任务本身。',
+        ].join('\n');
     }
-    return `${prefix}\nYour user-visible reply language should be: ${uiName}.\nYour internal work language remains: ${workingName} (system prompt, teammate comms, function tools).`;
+    return [
+        prefix,
+        'This is a browser UI language change, not a new user instruction. Do not stop the current work, do not reply with a standalone "acknowledged/ok", and do not treat this notice as a new to-do.',
+        `The user UI language changed from ${previousName} to ${nextName}.`,
+        `From now on, your user-visible reply language should be: ${nextName}.`,
+        'Continue the current task itself.',
+    ].join('\n');
 }
 function formatNewCourseStartPrompt(language, args) {
     if (language === 'zh') {
@@ -39,10 +79,10 @@ function formatNewCourseStartPrompt(language, args) {
             '现在已经进入新一程：第一步先复核并整理接续包提醒项，以清醒头脑删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项；再继续推进任务。');
     }
     const prefix = args.source === 'clear_mind'
-        ? `This is course #${args.nextCourse} of the dialog. You just cleared your mind.`
-        : `System auto-started course #${args.nextCourse} of the dialog because context health is critical.`;
+        ? `This is dialog course #${args.nextCourse}. You just cleared your mind.`
+        : `System auto-started dialog course #${args.nextCourse} because context health is critical.`;
     return (`${prefix} ` +
-        'You are now in a new course: your first step is to review and rewrite any continuation-package reminders with a clear head, remove redundancy, correct biased or distorted bridge notes, compress them into high-quality reminders, and then continue the task.');
+        'You are now in a new dialog course: your first step is to review and rewrite any continuation-package reminders with a clear head, remove redundancy, correct biased or distorted bridge notes, compress them into high-quality reminders, and then continue the task.');
 }
 function formatReminderItemGuide(language, index, content, options) {
     function isRecord(value) {

package/dist/static/assets/{_basePickBy-DOCpneO0.js → _basePickBy-b79Z8z7v.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-DBZLqTK1.js";
-import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-C-RsyM0K.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-EKRe-CHy.js";
+import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-CzBEs1w4.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-DOCpneO0.js.map
+//# sourceMappingURL=_basePickBy-b79Z8z7v.js.map