dominds 1.23.0 → 1.23.2

package/dist/access-control.js

@@ -311,13 +311,13 @@ function getAccessDeniedMessage(operation, targetPath, language = 'en') {
         lines.push('');
         if (language === 'zh') {
             lines.push(`- 说明：\`*.tsk/\` 是封装差遣牒。通用文件工具无法读/写/列目录/删除其中内容（硬编码无条件拒绝）。`);
-            lines.push(`- 提示：新增章节请使用 \`do_mind\`；少量追加请使用 \`mind_more\`（默认 progress：\`mind_more({\"items\":[\"...\"]})\`）；改写已有整章请使用带当前内容哈希的 \`change_mind\`（顶层：\`change_mind({\"selector\":\"goals|constraints|progress\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`；额外章节：先 \`recall_taskdoc\` 取得 \`content_hash\`，再 \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`）。`);
-            lines.push(`- 提示：读取额外章节请使用函数工具 \`recall_taskdoc\`：\`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`。`);
+            lines.push(`- 提示：新增章节请使用 \`do_mind\`；少量追加请使用 \`mind_more\`（默认 progress：\`mind_more({\"items\":[\"...\"]})\`）；改写已有整章请先用 \`recall_taskdoc\` 取得当前内容哈希，再使用带 \`previous_content_hash\` 的 \`change_mind\`（顶层示例：先 \`recall_taskdoc({\"selector\":\"progress\"})\`，再 \`change_mind({\"selector\":\"progress\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`；额外章节：先 \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`，再 \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`）。`);
+            lines.push(`- 提示：读取章节或取得 content_hash 请使用函数工具 \`recall_taskdoc\`：顶层 \`recall_taskdoc({\"selector\":\"progress\"})\`；额外章节 \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`。`);
         }
         else {
             lines.push(`- Note: \`*.tsk/\` is an encapsulated Taskdoc. It is hard-denied for all general file tools.`);
-            lines.push(`- Hint: To create a section, use \`do_mind\`; for small append-only updates, use \`mind_more\` (defaults to progress: \`mind_more({\"items\":[\"...\"]})\`); for full-section replacements, use \`change_mind\` with the current content hash (top-level: \`change_mind({\"selector\":\"goals|constraints|progress\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`; extra sections: call \`recall_taskdoc\` for \`content_hash\` first, then \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"sha256:...\"})\`).`);
-            lines.push(`- Hint: To read extra sections, use \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`.`);
+            lines.push(`- Hint: To create a section, use \`do_mind\`; for small append-only updates, use \`mind_more\` (defaults to progress: \`mind_more({\"items\":[\"...\"]})\`); for full-section replacements, call \`recall_taskdoc\` for the current content hash first, then use \`change_mind\` with \`previous_content_hash\` (top-level example: first \`recall_taskdoc({\"selector\":\"progress\"})\`, then \`change_mind({\"selector\":\"progress\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`; extra sections: first \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`, then \`change_mind({\"category\":\"<category>\",\"selector\":\"<selector>\",\"content\":\"...\",\"previous_content_hash\":\"crc32:...\"})\`).`);
+            lines.push(`- Hint: To read a section or get content_hash, use \`recall_taskdoc\`: top-level \`recall_taskdoc({\"selector\":\"progress\"})\`; extra section \`recall_taskdoc({\"category\":\"<category>\",\"selector\":\"<selector>\"})\`.`);
         }
     }
     if (isMindsPath(targetPath)) {

package/dist/cli/webui.js

@@ -134,7 +134,14 @@ async function main() {
         const { language: resolvedLanguage, source } = (0, work_language_1.resolveWorkLanguage)({ env: process.env });
         (0, work_language_1.setWorkLanguage)(resolvedLanguage);
         log.info(`working language: ${(0, work_language_1.getWorkLanguage)()} (source: ${source})`);
-        const started = await (0, server_1.startServer)({ port, host, mode, strictPort, portAutoDirection });
+        const started = await (0, server_1.startServer)({
+            port,
+            host,
+            mode,
+            strictPort,
+            portAutoDirection,
+            returnAfterListen: true,
+        });
         const httpServer = started.httpServer;
         const auth = started.auth;
         const baseUrl = `http://${started.host}:${started.port}`;

package/dist/dialog-display-state.d.ts

@@ -52,6 +52,7 @@ export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker:
 }): void;
 export declare function computeIdleDisplayState(dlg: Dialog): Promise<DialogDisplayState>;
 export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'pending_sideDialogs_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
+export declare function isRecoverableGeneratingLatest(latest: DialogLatestFile | null): boolean;
 export declare function reconcileDisplayStatesAfterRestart(): Promise<void>;
 export declare function requestInterruptDialog(dialogId: DialogID, reason: StopRequestedReason): Promise<{
     applied: boolean;

package/dist/dialog-display-state.js

@@ -40,6 +40,7 @@ exports.setDialogDisplayState = setDialogDisplayState;
 exports.broadcastDisplayStateMarker = broadcastDisplayStateMarker;
 exports.computeIdleDisplayState = computeIdleDisplayState;
 exports.refreshRunControlProjectionFromPersistenceFacts = refreshRunControlProjectionFromPersistenceFacts;
+exports.isRecoverableGeneratingLatest = isRecoverableGeneratingLatest;
 exports.reconcileDisplayStatesAfterRestart = reconcileDisplayStatesAfterRestart;
 exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
@@ -580,6 +581,19 @@ async function computeIdleDisplayStateForReconciliation(dialogId) {
         return null;
     }
 }
+function isRecoverableGeneratingLatest(latest) {
+    if (latest?.generating !== true) {
+        return false;
+    }
+    const marker = latest.executionMarker;
+    if (!marker) {
+        return true;
+    }
+    if (marker.kind === 'dead') {
+        return false;
+    }
+    return marker.kind !== 'interrupted' || marker.reason.kind === 'pending_course_start';
+}
 async function reconcileDisplayStatesAfterRestart() {
     const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
     for (const dialogId of dialogIds) {
@@ -618,10 +632,28 @@ async function reconcileDisplayStatesAfterRestart() {
             }
             continue;
         }
-        const wasProceeding = latest?.generating === true ||
-            (existing !== undefined &&
-                (existing.kind === 'proceeding' || existing.kind === 'proceeding_stop_requested'));
-        if (wasProceeding) {
+        if (isRecoverableGeneratingLatest(latest)) {
+            try {
+                await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
+                    kind: 'patch',
+                    patch: {
+                        needsDrive: true,
+                        displayState: { kind: 'proceeding' },
+                        executionMarker: existingMarker?.kind === 'interrupted' &&
+                            existingMarker.reason.kind === 'pending_course_start'
+                            ? undefined
+                            : existingMarker,
+                    },
+                }));
+            }
+            catch (err) {
+                log.warn('Failed to preserve proceeding dialog for auto-drive after restart', err, {
+                    dialogId: dialogId.valueOf(),
+                });
+            }
+            continue;
+        }
+        if (latest?.generating === true || latest?.needsDrive === true) {
             const nextIdle = await computeIdleDisplayStateForReconciliation(dialogId);
             if (!nextIdle) {
                 continue;

package/dist/docs/encapsulated-taskdoc.md

@@ -149,7 +149,7 @@ Below is the canonical copy. If you need to rephrase it for UI layout, you MUST
 
 - Any `.tsk/` directory and its subpaths (`**/*.tsk/**`) are encapsulated state: general file tools MUST NOT read/write/list them (e.g. `read_file` / `write_file` / `list_dir`).
 - Taskdoc updates MUST go through explicit Taskdoc function tools: `do_mind` creates a new section, `mind_more` appends small entries to an existing section, `change_mind` replaces an existing section, and `never_mind` deletes a section.
-- To read extra sections that are NOT auto-injected, use the function tool `recall_taskdoc({ category, selector })`.
+- To read any Taskdoc section or get its `content_hash`, use the function tool `recall_taskdoc({ selector, category? })`.
 
 **Taskdoc auto-injection rules (system prompt)**
 
@@ -219,25 +219,25 @@ Hard prohibitions:
 - `contracts|acceptance|grants|runbook|decisions|risks` MUST NOT be written outside `category="bearinmind"`.
 - No other category is auto-injected into the system prompt (only an index may be shown).
 
-`previous_content_hash` is the `sha256:...` hash of the current section content after Dominds' canonical Markdown file-ending normalization. It is not stored as extra state.
+`previous_content_hash` is the `crc32:...` checksum of the current section content after Dominds' canonical Markdown file-ending normalization. It is not stored as extra state.
 
-- For auto-injected top-level sections (`goals`, `constraints`, `progress`), the injected Taskdoc status block shows each current `content_hash`.
-- For non-auto-injected sections, call `recall_taskdoc({ category, selector })`; its result includes `content_hash`.
+- For top-level sections (`goals`, `constraints`, `progress`), call `recall_taskdoc({ selector })`; its result includes `content_hash`.
+- For extra non-auto-injected sections, call `recall_taskdoc({ category, selector })`; its result includes `content_hash`.
 - On hash mismatch, the write MUST fail. The agent must re-read/review the current section and retry only after fully merging existing content.
 - If the proposed replacement would overwrite, delete, or materially replace existing content, the agent must have either direct human confirmation for that replacement, or a human-approved explicit SOP/acceptance standard that authorizes the replacement after considering the existing content.
 
-### `recall_taskdoc` (read-only; for non-auto-injected sections)
+### `recall_taskdoc` (read-only; for Taskdoc sections and content_hash)
 
 Because general file tools cannot read anything under `*.tsk/`, Dominds provides a dedicated read tool:
 
 ```
-recall_taskdoc({ category, selector })
+recall_taskdoc({ selector, category? })
 ```
 
 Behavior:
 
 - Reads `bearinmind/<whitelisted>.md` or `<category>/<selector>.md`.
-- The top-level three sections (`goals` / `constraints` / `progress`) are already auto-injected, so `recall_taskdoc` does not read them.
+- The top-level three sections (`goals` / `constraints` / `progress`) are auto-injected as content, but their `content_hash` is only returned by `recall_taskdoc`.
 - Returns the section `content_hash` for use as `change_mind.previous_content_hash`.
 
 Example (bearinmind):
@@ -257,8 +257,11 @@ Call the function tool `recall_taskdoc` with:
 Example:
 
 ```text
+Call the function tool `recall_taskdoc` with:
+{ "selector": "constraints" }
+
 Call the function tool `change_mind` with:
-{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n", "previous_content_hash": "sha256:..." }
+{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n", "previous_content_hash": "crc32:..." }
 ```
 
 ### Behavioral rules

package/dist/docs/encapsulated-taskdoc.zh.md

@@ -148,7 +148,7 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 
 - 任何 `.tsk/` 目录及其子路径（`**/*.tsk/**`）都是封装状态：禁止使用任何通用文件工具读取/写入/列目录（例如 `read_file` / `write_file` / `list_dir` 等）。
 - 更新差遣牒只能使用显式差遣牒函数工具：`do_mind` 创建新章节，`mind_more` 向已有章节追加少量条目，`change_mind` 替换已有章节，`never_mind` 删除章节。
-- 读取"不会自动注入上下文"的额外章节，只能使用函数工具 `recall_taskdoc({ category, selector })`。
+- 读取任意差遣牒章节或取得其 `content_hash`，只能使用函数工具 `recall_taskdoc({ selector, category? })`。
 
 **差遣牒自动注入规则（系统提示）**
 
@@ -164,7 +164,7 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 
 - Any `.tsk/` directory and its subpaths (`**/*.tsk/**`) are encapsulated state: general file tools MUST NOT read/write/list them (e.g. `read_file` / `write_file` / `list_dir`).
 - Taskdoc updates MUST go through explicit Taskdoc function tools: `do_mind` creates a new section, `mind_more` appends small entries to an existing section, `change_mind` replaces an existing section, and `never_mind` deletes a section.
-- To read extra sections that are NOT auto-injected, use the function tool `recall_taskdoc({ category, selector })`.
+- To read any Taskdoc section or get its `content_hash`, use the function tool `recall_taskdoc({ selector, category? })`.
 
 **Taskdoc auto-injection rules (system prompt)**
 
@@ -230,25 +230,25 @@ Dominds 必须从任务包构造一个**有效差遣牒**用于提示词和 UI
 - `contracts|acceptance|grants|runbook|decisions|risks` 不得在 `category="bearinmind"` 之外编写。
 - 没有其他类别会自动注入系统提示（只会显示一个索引）。
 
-`previous_content_hash` 是当前章节内容在 Dominds 规范化 Markdown 文件结尾之后得到的 `sha256:...` 哈希；它不是额外持久状态。
+`previous_content_hash` 是当前章节内容在 Dominds 规范化 Markdown 文件结尾之后得到的 `crc32:...` 校验值；它不是额外持久状态。
 
-- 顶层自动注入章节（`goals`、`constraints`、`progress`）的当前 `content_hash` 会显示在注入的差遣牒状态块中。
-- 非自动注入章节需要先调用 `recall_taskdoc({ category, selector })`；返回结果会包含 `content_hash`。
+- 顶层章节（`goals`、`constraints`、`progress`）需要调用 `recall_taskdoc({ selector })`；返回结果会包含 `content_hash`。
+- 额外非自动注入章节需要调用 `recall_taskdoc({ category, selector })`；返回结果会包含 `content_hash`。
 - 哈希不匹配时写入必须失败。智能体必须重新读取/回顾当前章节，并且只在充分合并原有内容后重试。
 - 如果拟替换内容会冲掉、删除或实质替换原有内容，智能体必须已获得该替换的直接人类确认，或存在人类认可的明确 SOP/验收标准，并且已按该标准考虑过原有内容。
 
-### `recall_taskdoc`（只读；用于非自动注入的部分）
+### `recall_taskdoc`（只读；用于差遣牒章节与 content_hash）
 
 因为通用文件工具无法读取 `*.tsk/` 下的任何内容，Dominds 提供了一个专门的读取工具：
 
 ```
-recall_taskdoc({ category, selector })
+recall_taskdoc({ selector, category? })
 ```
 
 行为：
 
 - 读取 `bearinmind/<whitelisted>.md` 或 `<category>/<selector>.md`。
-- 顶层三段（`goals` / `constraints` / `progress`）已经自动注入，因此 `recall_taskdoc` 不会读取它们。
+- 顶层三段（`goals` / `constraints` / `progress`）会自动注入正文，但其 `content_hash` 只通过 `recall_taskdoc` 返回。
 - 返回章节 `content_hash`，供 `change_mind.previous_content_hash` 使用。
 
 示例（bearinmind）：
@@ -268,8 +268,11 @@ recall_taskdoc({ category, selector })
 示例：
 
 ```text
+使用函数工具 `recall_taskdoc` 调用：
+{ "selector": "constraints" }
+
 使用函数工具 `change_mind` 调用：
-{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n" }
+{ "selector": "constraints", "content": "- MUST not browse the web.\n- MUST keep responses under 10 lines unless asked otherwise.\n", "previous_content_hash": "crc32:..." }
 ```
 
 ### 行为规则

package/dist/llm/defaults.yaml

@@ -484,6 +484,7 @@ providers:
     models:
       kimi-for-coding:
         name: Kimi For Coding
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: true
         supports_tool_choice: false
@@ -603,6 +604,7 @@ providers:
         context_window: '128K'
       kimi-k2.6:
         name: Kimi-K2.6
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: true
         supports_tool_choice: false
@@ -613,6 +615,7 @@ providers:
         context_window: '200K'
       kimi-k2.5:
         name: Kimi-K2.5
+        optimal_max_tokens: 180000
         supports_thinking: true
         default_thinking: false
         supports_tool_choice: false

package/dist/llm/gen/mock.js

@@ -66,13 +66,11 @@ const log_1 = require("../../log");
 const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const gen_1 = require("../gen");
 const stop_reason_i18n_1 = require("../stop-reason-i18n");
-const REPLY_TOOL_REMINDER_PREFIXES = [
-    '[Dominds replyTellask required]',
-    '[Dominds 必须调用回复工具]',
-];
 const RUNTIME_PROMPT_WRAPPER_PREFIXES = [
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_EN,
     reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_ZH,
+    reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_EN,
+    reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_ZH,
     reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_EN,
     reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_ZH,
     reply_prompt_copy_1.REPLY_SUPPRESSION_PREFIX_EN,
@@ -277,8 +275,7 @@ class MockGen {
         return null;
     }
     buildReplyToolReminderAutoResponse(input, role, context) {
-        if (role !== 'user' ||
-            !REPLY_TOOL_REMINDER_PREFIXES.some((prefix) => input.startsWith(prefix))) {
+        if (role !== 'user' || !(0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(input)) {
             return null;
         }
         const toolMatch = input.match(/`(replyTellask(?:Sessionless|Back)?)`/);

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

@@ -23,12 +23,8 @@ const idle_reminder_wake_1 = require("./idle-reminder-wake");
 const reply_guidance_1 = require("./reply-guidance");
 const sideDialog_1 = require("./sideDialog");
 const tellask_special_1 = require("./tellask-special");
-const REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds replyTellask required]';
-const REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 必须调用回复工具]';
 function isReplyToolReminderPrompt(prompt) {
-    return (typeof prompt?.content === 'string' &&
-        (prompt.content.startsWith(REPLY_TOOL_REMINDER_PREFIX_EN) ||
-            prompt.content.startsWith(REPLY_TOOL_REMINDER_PREFIX_ZH)));
+    return typeof prompt?.content === 'string' && (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.content);
 }
 function isIgnorablePostResponseAnchorTailEvent(type) {
     return type === 'tellask_reply_resolution_record' || type === 'gen_finish_record';
@@ -37,7 +33,6 @@ async function buildReplyToolReminderPrompt(args) {
     return (0, reply_prompt_copy_1.buildReplyToolReminderText)({
         language: args.language,
         directive: args.directive,
-        prefix: args.language === 'zh' ? REPLY_TOOL_REMINDER_PREFIX_ZH : REPLY_TOOL_REMINDER_PREFIX_EN,
         replyTargetAgentId: await (0, reply_guidance_1.resolveReplyTargetAgentId)({
             dlg: args.dlg,
             directive: args.directive,
@@ -280,6 +275,7 @@ async function inspectNoPromptSideDialogDrive(args) {
             : undefined;
     const explicitInterruptedResumeAllowed = args.driveOptions?.allowResumeFromInterrupted === true &&
         latest?.executionMarker?.kind === 'interrupted';
+    const inProgressGenerationResumeAllowed = args.driveOptions?.resumeInProgressGeneration === true;
     const supplyResponseParentReviveAllowed = source === 'kernel_driver_supply_response_parent_revive' &&
         hasNoPromptSideDialogResumeEntitlement(args.dialog, args.driveOptions);
     if (lastEvent?.type === 'tellask_anchor_record' && lastEvent.anchorRole === 'response') {
@@ -292,7 +288,9 @@ async function inspectNoPromptSideDialogDrive(args) {
             lastEvent,
         };
     }
-    if (!explicitInterruptedResumeAllowed && !supplyResponseParentReviveAllowed) {
+    if (!explicitInterruptedResumeAllowed &&
+        !inProgressGenerationResumeAllowed &&
+        !supplyResponseParentReviveAllowed) {
         return {
             shouldReject: true,
             source,
@@ -578,7 +576,7 @@ async function executeDriveRound(args) {
                 : hasEntitledParentRevive
                     ? await loadFreshSuspensionStatusFromPersistence(dialog, driveOptions)
                     : await dialog.getSuspensionStatus({
-                        allowPendingSideDialogs: false,
+                        allowPendingSideDialogs: driveOptions?.resumeInProgressGeneration === true,
                     });
             const queuedPrompt = dialog.peekUpNext();
             const queuedSideDialogPromptCanResume = dialog instanceof dialog_1.SideDialog && queuedPrompt !== undefined;
@@ -810,8 +808,7 @@ async function executeDriveRound(args) {
                                 });
                             }
                             else {
-                                const shouldDirectFallbackAfterParentRevive = hasParentReviveEntitlement(dialog, driveOptions);
-                                if (!activePromptWasReplyToolReminder && !shouldDirectFallbackAfterParentRevive) {
+                                if (!activePromptWasReplyToolReminder) {
                                     const language = (0, work_language_1.getWorkLanguage)();
                                     followUp =
                                         sideDialogReplyTarget === undefined
@@ -846,7 +843,6 @@ async function executeDriveRound(args) {
                                         dialogId: dialog.id.valueOf(),
                                         targetCallId: activeTellaskReplyDirective.targetCallId,
                                         targetOwnerDialogId: sideDialogReplyTarget?.ownerDialogId,
-                                        directFallbackAfterParentRevive: shouldDirectFallbackAfterParentRevive,
                                     });
                                 }
                                 else {
@@ -1015,7 +1011,8 @@ async function executeDriveRound(args) {
                                         : { skipTaskdoc: followUp.skipTaskdoc }),
                                 };
                                 if (followUp.kind === 'registered_assignment_update' ||
-                                    followUp.kind === 'new_course_runtime_sideDialog') {
+                                    followUp.kind === 'new_course_runtime_sideDialog' ||
+                                    followUp.kind === 'runtime_sideDialog_reply_reminder') {
                                     const prompt = {
                                         ...runtimeCommon,
                                         tellaskReplyDirective: followUp.tellaskReplyDirective,
@@ -1023,7 +1020,8 @@ async function executeDriveRound(args) {
                                     };
                                     return prompt;
                                 }
-                                if (followUp.kind === 'new_course_runtime_reply') {
+                                if (followUp.kind === 'new_course_runtime_reply' ||
+                                    followUp.kind === 'runtime_reply_reminder') {
                                     const prompt = {
                                         ...runtimeCommon,
                                         tellaskReplyDirective: followUp.tellaskReplyDirective,

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

@@ -46,12 +46,14 @@ async function driveQueuedDialogsOnce() {
                 dialog_global_registry_1.globalDialogRegistry.noteActiveRunBlockedQueuedDrive(mainDialog.id.rootId);
                 continue;
             }
-            if (!(await mainDialog.canDrive())) {
+            const resumeInProgressGeneration = latest?.generating === true;
+            if (!resumeInProgressGeneration && !(await mainDialog.canDrive())) {
                 continue;
             }
             await (0, engine_1.driveDialogStream)(mainDialog, undefined, true, {
                 source: 'kernel_driver_backend_loop',
                 reason: 'global_dialog_registry_needs_drive',
+                ...(resumeInProgressGeneration ? { resumeInProgressGeneration: true } : {}),
             });
             const status = await mainDialog.getSuspensionStatus();
             const shouldStayQueued = mainDialog.hasUpNext() || !status.canDrive;

package/dist/llm/kernel-driver/reply-guidance.js

@@ -11,8 +11,6 @@ const interjection_pause_stop_1 = require("../../runtime/interjection-pause-stop
 const reply_prompt_copy_1 = require("../../runtime/reply-prompt-copy");
 const work_language_1 = require("../../runtime/work-language");
 const tellask_special_1 = require("./tellask-special");
-const REPLY_TOOL_REMINDER_PREFIX_EN = '[Dominds replyTellask required]';
-const REPLY_TOOL_REMINDER_PREFIX_ZH = '[Dominds 必须调用回复工具]';
 async function resolveReplyTargetAgentId(args) {
     const mainDialog = args.dlg instanceof dialog_1.MainDialog
         ? args.dlg
@@ -30,13 +28,11 @@ async function resolveReplyTargetAgentId(args) {
 function buildPromptContentWithExactReplyToolName(args) {
     const isFbrSideDialog = args.dlg instanceof dialog_1.SideDialog &&
         args.dlg.assignmentFromAsker.callName === 'freshBootsReasoning';
-    const noActivePrefix = args.language === 'zh'
-        ? '[Dominds 当前无跨对话回复义务]'
-        : '[Dominds no active inter-dialog reply]';
+    const noActivePrefix = args.language === 'zh' ? reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_ZH : reply_prompt_copy_1.NO_ACTIVE_REPLY_PREFIX_EN;
     const activePrefix = args.language === 'zh' ? reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_ZH : reply_prompt_copy_1.ACTIVE_REPLY_TOOL_PREFIX_EN;
     const reminderPrefixes = [
-        REPLY_TOOL_REMINDER_PREFIX_EN,
-        REPLY_TOOL_REMINDER_PREFIX_ZH,
+        reply_prompt_copy_1.REPLY_TOOL_REMINDER_PREFIX_EN,
+        reply_prompt_copy_1.REPLY_TOOL_REMINDER_PREFIX_ZH,
         reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_EN,
         reply_prompt_copy_1.REPLY_REASSERTION_PREFIX_ZH,
     ];

package/dist/llm/kernel-driver/types.d.ts

@@ -7,6 +7,7 @@ export type KernelDriverDriveSource = 'unspecified' | 'ws_user_message' | 'ws_us
 export type KernelDriverDriveOptions = Readonly<{
     suppressDiligencePush?: boolean;
     allowResumeFromInterrupted?: boolean;
+    resumeInProgressGeneration?: boolean;
     noPromptSideDialogResumeEntitlement?: Readonly<{
         ownerDialogId: string;
         reason: 'reply_tellask_back_delivered';

package/dist/minds/minds-i18n.js

@@ -55,7 +55,7 @@ function taskdocCanonicalCopy(language) {
             '',
             '- 任何 `.tsk/` 目录及其子路径（`**/*.tsk/**`）都是封装状态：禁止使用任何通用文件工具读取/写入/列目录（例如 `read_file` / `write_file` / `list_dir` 等）。',
             '- 更新 Taskdoc 只能使用函数工具 `do_mind` / `mind_more` / `change_mind` / `never_mind`：缺失章节用 `do_mind` 创建；少量新增用 `mind_more` 追加（默认 progress）；需要删除陈旧项、重排或压缩时用 `change_mind` 整章替换；确需删除整章文件时用 `never_mind`。',
-            '- 读取“不会自动注入上下文”的额外章节，只能使用函数工具 `recall_taskdoc({ category, selector })`。',
+            '- 读取章节或取得 `change_mind.previous_content_hash` 需要使用函数工具 `recall_taskdoc({ selector, category? })`；顶层三段省略 `category`，额外章节传入 `category`。',
             '',
             '**Taskdoc 自动注入规则（系统提示）**',
             '',
@@ -71,7 +71,7 @@ function taskdocCanonicalCopy(language) {
         '',
         '- Any `.tsk/` directory and its subpaths (`**/*.tsk/**`) are encapsulated state: general file tools MUST NOT read/write/list them (e.g. `read_file` / `write_file` / `list_dir`).',
         '- Taskdoc updates MUST go through `do_mind` / `mind_more` / `change_mind` / `never_mind`: use `do_mind` to create missing sections, use `mind_more` for small append-only additions (defaults to progress), use `change_mind` for full-section replacement when cleanup, reordering, or compression is needed, and use `never_mind` when a whole section file should be deleted.',
-        '- To read extra sections that are NOT auto-injected, use the function tool `recall_taskdoc({ category, selector })`.',
+        '- To read a section or get `change_mind.previous_content_hash`, use the function tool `recall_taskdoc({ selector, category? })`; omit `category` for top-level sections and pass it for extra sections.',
         '',
         '**Taskdoc auto-injection rules (system prompt)**',
         '',

package/dist/minds/system-prompt-parts.js

@@ -148,11 +148,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineZh = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? '当前是告急处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；允许多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+            : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是告急处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；本程允许先保留多条粗略提醒项求稳，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? '当前是吃紧处置态：支线对话不要维护差遣牒，也不要整理差遣牒更新提案；把当前对话历史中下一程需要知道的讨论细节、下一步、关键定位、运行/验证信息、临时路径/ID/样例输入和恢复依据写入接续包提醒项。提醒项长度没有技术限制，宁可完整一些；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
-                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并且能带上当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
+                : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步。当前是吃紧处置态：先检查当前对话历史里尚未落文档的讨论细节；能作为全队共享状态/决策/约束/目标的，主线优先用 `do_mind` 新增章节保存；只有在确实需要改写已有章节、已完成合并并先调用 `recall_taskdoc` 取得当前 `content_hash` 作为 `previous_content_hash` 时，才用 `change_mind`。接续包提醒项只留差遣牒仍未覆盖、但恢复工作容易丢的细节；若一时来不及，可先保留多条粗略提醒项过桥，但不要在当前程提前做“新一程清醒复核”。系统真正开启新一程后，第一步再复核整理：删除冗余、纠正偏激/失真思路，再收敛成高质量提醒项。'
             : '不要把长日志/大段 tool output 直接塞进差遣牒；差遣牒只写结论+下一步；提醒项也只留可扫读摘录。接续包提醒项默认应保持结构化、便于快速恢复。';
     const contextHealthLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
@@ -166,11 +166,11 @@ function getMemoryPromptCopy(ctx) {
     const taskdocLogLineEn = ctx.contextHealthPromptMode === 'critical'
         ? ctx.isSideDialog
             ? 'Current mode is critical remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+            : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is critical remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. Rough multi-reminder bridge notes are acceptable in this course, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
         : ctx.contextHealthPromptMode === 'caution'
             ? ctx.isSideDialog
                 ? 'Current mode is caution remediation: in a Side Dialog, do not maintain Taskdoc and do not draft Taskdoc update proposals. Put discussion details from current dialog history that the next course needs to know, next actions, key pointers, run/verify info, volatile paths/IDs/sample inputs, and resume reasoning into continuation-package reminders. Reminder length has no technical limit, so prefer being complete. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
-                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you can pass the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
+                : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps. Current mode is caution remediation: first review current-dialog discussion details not yet written into documentation. If they belong to team-shared state, decisions, constraints, or goals, prefer creating a new section with `do_mind`; use `change_mind` only when an existing section truly needs rewriting, you have merged against the current content, and you have first called `recall_taskdoc` to get the current `content_hash` as `previous_content_hash`. Continuation-package reminders should keep only details still not covered by Taskdoc but easy to lose during resume. If needed, rough multi-reminder bridge notes are acceptable, but do not perform the new-course “clear-headed review” early. Once the system actually starts the new course, the first step is to review/rewrite them: remove redundancy, correct biased or distorted bridge notes, then compress them into high-quality reminders.'
             : 'Do not paste long logs/tool outputs into Taskdoc; Taskdoc should record decisions + next steps; reminders should also keep only scannable excerpts. Keep continuation-package reminders structured and fast to resume from by default.';
     if (ctx.language === 'zh') {
         return {
@@ -181,7 +181,7 @@ function getMemoryPromptCopy(ctx) {
             taskdocSemanticsLine: '- 章节语义约定：`progress` 是全队共享、准实时、可扫读的任务公告牌，用来记录当前有效状态、关键决策、下一步与仍成立阻塞；不是流水账，也不是个人工作记录。`goals` / `constraints` 是较稳定的任务契约；每次更新都必须保留仍然有效的他人条目。',
             taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不要维护差遣牒，也不要整理差遣牒更新提案；把下一程需要恢复的细节写入足够详尽的接续包提醒项。'
-                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，用 \`change_mind\` 整章替换并先对照“上下文中注入的当前内容”做合并，同时带上当前 \`content_hash\` 作为 \`previous_content_hash\`；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
+                : `- 更新差遣牒时：少量新增条目可用 \`mind_more\` 追加（默认 progress）；缺失章节用 \`do_mind\` 创建；需要删除陈旧项、重排结构或压缩时，先对照上下文中注入的当前内容完成合并，再调用 \`recall_taskdoc\` 取得当前 \`content_hash\`，然后用带 \`previous_content_hash\` 的 \`change_mind\` 整章替换；需要删除整章文件时用 \`never_mind\`；禁止覆盖/抹掉他人条目；自己负责维护的条目必须标注责任人（例如 \`- [owner:@${ctx.agentId}] ...\` 或用 \`### @${ctx.agentId}\` 分块）。`,
             progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
                 ? '- 当前处于支线对话的上下文健康处置态：本程不更新 `progress`；只把下一程接续所需信息写入提醒项。'
                 : '- 更新 `progress` 时：它必须始终是可供全队扫读的完整当前快照，而不是只追加自己这一轮的零散笔记。',
@@ -202,7 +202,7 @@ function getMemoryPromptCopy(ctx) {
             sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
                 ? `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒追加条目/更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`
                 : '工作流：停止扩张上下文 → 维护足够详尽的接续包提醒项（`add_reminder` 或 `update_reminder`，长度没有技术限制）→ 然后 `clear_mind` 开启新一程。',
-            mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
+            mainDialogWorkflowLine: '工作流：先做事 -> 再提炼（`update_reminder` + `mind_more(progress)`；需要压缩/删旧时先 `recall_taskdoc` 取得 `content_hash`，再用带 `previous_content_hash` 的 `change_mind`；要删除整章文件时用 `never_mind`）-> 然后 `clear_mind` 清空噪音。',
             contextHealthLine: contextHealthLineZh,
             taskdocLogLine: taskdocLogLineZh,
         };
@@ -215,7 +215,7 @@ function getMemoryPromptCopy(ctx) {
         taskdocSemanticsLine: '- Section semantics: `progress` is the team-shared, quasi-real-time, scannable task bulletin board for current effective state, key decisions, next steps, and still-active blockers; it is not a raw log or personal work record. `goals` / `constraints` are the more stable task contract; every update must preserve still-valid entries from others.',
         taskdocSectionReplaceLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals in this course; put resume-critical details into sufficiently detailed continuation-package reminders.'
-            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, use \`change_mind\` for a full-section replacement based on the current injected content and include the current \`content_hash\` as \`previous_content_hash\`; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
+            : `- When updating Taskdoc: use \`mind_more\` for small append-only additions (defaults to progress); create missing sections with \`do_mind\`; when stale entries must be removed, reordered, or compressed, first merge against the current injected content, then call \`recall_taskdoc\` to get the current \`content_hash\`, then use \`change_mind\` for a full-section replacement with that value as \`previous_content_hash\`; when a whole section file should be removed, use \`never_mind\`; do not overwrite other contributors; add an explicit owner tag for entries you maintain (e.g., \`- [owner:@${ctx.agentId}] ...\` or a \`### @${ctx.agentId}\` block).`,
         progressLine: ctx.isSideDialog && ctx.contextHealthPromptMode !== 'normal'
             ? '- Current mode is context-health remediation in a Side Dialog: do not update `progress` in this course; put resume-critical information into reminders only.'
             : '- When updating `progress`, keep it as a complete, team-scannable current snapshot instead of appending only your own latest notes.',
@@ -236,7 +236,7 @@ function getMemoryPromptCopy(ctx) {
         sideDialogWorkflowLine: ctx.contextHealthPromptMode === 'normal'
             ? `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft append entries, a merged replacement, or a section deletion and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`
             : 'Workflow: stop expanding context → maintain sufficiently detailed continuation-package reminders (`add_reminder` or `update_reminder`, with no technical length limit) → then `clear_mind` to start a new course.',
-        mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; use `change_mind` with `previous_content_hash` when compression/deletion is needed; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
+        mainDialogWorkflowLine: 'Workflow: do work -> distill (`update_reminder` + `mind_more(progress)`; when compression/deletion is needed, first use `recall_taskdoc` to get `content_hash`, then use `change_mind` with `previous_content_hash`; use `never_mind` when removing a whole section file) -> then `clear_mind` to drop noise.',
         contextHealthLine: contextHealthLineEn,
         taskdocLogLine: taskdocLogLineEn,
     };

package/dist/persistence.js

@@ -3764,6 +3764,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             case 'pending_sideDialogs_reconciled_record':
             case 'sideDialog_registry_reconciled_record':
             case 'sideDialog_responses_reconciled_record':
+            case 'tellask_anchor_record':
                 break;
             case 'tellask_carryover_record': {
                 const base = {

package/dist/recovery/proceeding-drive.d.ts

@@ -0,0 +1 @@
+export declare function recoverProceedingDrivesAfterRestart(): Promise<void>;