dominds 1.25.0 → 1.25.2

package/README.md

@@ -103,7 +103,8 @@ Supported proxy variables:
 Practical guidance:
 
 - Set both `HTTP_PROXY` and `HTTPS_PROXY` when your network uses the same proxy for both schemes. Lowercase forms also work.
-- Use `NO_PROXY` for localhost, loopback, and internal domains that should bypass the proxy.
+- Use `NO_PROXY` for hosts that should bypass the proxy. Node's built-in support includes exact hosts, suffix matches like `.company.com`, wildcard hosts like `*.company.com`, exact IPs, IP ranges like `192.168.1.1-192.168.1.100`, and `host:port` entries.
+- `NO_PROXY` syntax is not standardized across languages and clients. Do not assume CIDR notation such as `192.168.0.0/16` is supported unless the specific runtime documents it.
 - Values should be standard proxy URLs, for example `http://proxy.company.com:8080`.
 - If your shell already exports proxy variables, Dominds will read them too; clear unrelated proxy vars if you want a clean test environment.
 
@@ -113,13 +114,13 @@ Examples:
 # Windows PowerShell
 $env:HTTP_PROXY = "http://proxy.company.com:8080"
 $env:HTTPS_PROXY = "http://proxy.company.com:8080"
-$env:NO_PROXY = "localhost,127.0.0.1,.corp.local"
+$env:NO_PROXY = "localhost,127.0.0.1,.corp.local,192.168.1.1-192.168.1.100"
 dominds
 
 # macOS / Linux shell
 export HTTP_PROXY="http://proxy.company.com:8080"
 export HTTPS_PROXY="http://proxy.company.com:8080"
-export NO_PROXY="localhost,127.0.0.1,.corp.local"
+export NO_PROXY="localhost,127.0.0.1,.corp.local,192.168.1.1-192.168.1.100"
 dominds
 
 # Disable Dominds env-proxy handling

package/README.zh.md

@@ -57,7 +57,8 @@ Dominds 在 Windows、macOS、Linux 上都可以使用 Node 内建的环境变
 实践建议：
 
 - 若同一网络对 HTTP/HTTPS 都走同一代理，建议 `HTTP_PROXY` 和 `HTTPS_PROXY` 一起设置。小写变量名同样有效。
-- `NO_PROXY` 用于排除 localhost、回环地址和内网域名。
+- `NO_PROXY` 用于排除不经过代理的主机。Node 内置支持包括精确主机名、后缀匹配（如 `.company.com`）、通配主机（如 `*.company.com`）、精确 IP、IP 范围（如 `192.168.1.1-192.168.1.100`）以及带端口的主机名。
+- `NO_PROXY` 的语法在不同语言和客户端里并没有统一标准。除非目标运行时明确支持，不要把 CIDR 写法如 `192.168.0.0/16` 当成默认可用。
 - 代理值应使用标准 URL 形式，例如 `http://proxy.company.com:8080`。
 - 如果你的 shell 已经导出了代理变量，Dominds 也会读取它们；想要干净的测试环境时，请清掉无关的代理变量。
 
@@ -67,13 +68,13 @@ Dominds 在 Windows、macOS、Linux 上都可以使用 Node 内建的环境变
 # Windows PowerShell
 $env:HTTP_PROXY = "http://proxy.company.com:8080"
 $env:HTTPS_PROXY = "http://proxy.company.com:8080"
-$env:NO_PROXY = "localhost,127.0.0.1,.corp.local"
+$env:NO_PROXY = "localhost,127.0.0.1,.corp.local,192.168.1.1-192.168.1.100"
 dominds
 
 # macOS / Linux shell
 export HTTP_PROXY="http://proxy.company.com:8080"
 export HTTPS_PROXY="http://proxy.company.com:8080"
-export NO_PROXY="localhost,127.0.0.1,.corp.local"
+export NO_PROXY="localhost,127.0.0.1,.corp.local,192.168.1.1-192.168.1.100"
 dominds
 
 # 关闭 Dominds 的环境代理支持

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

@@ -43,9 +43,9 @@ export declare function clearMainDialogQuarantining(mainDialogId: DialogID): voi
 export declare function forceStopActiveRunsForMainDialog(mainDialogId: DialogID): Promise<void>;
 export declare function getStopRequestedReason(dialogId: DialogID): StopRequestedReason | undefined;
 export declare function loadDialogExecutionMarker(dialogId: DialogID, status?: 'running' | 'completed' | 'archived'): Promise<DialogExecutionMarker | undefined>;
-export declare function setDialogExecutionMarker(dialogId: DialogID, executionMarker: DialogExecutionMarker | undefined): Promise<void>;
-export declare function clearDialogInterruptedExecutionMarker(dialogId: DialogID): Promise<void>;
-export declare function setDialogDisplayState(dialogId: DialogID, displayState: DialogDisplayState): Promise<void>;
+export declare function setDialogExecutionMarker(dialogId: DialogID, executionMarker: DialogExecutionMarker | undefined, status?: 'running' | 'completed' | 'archived'): Promise<void>;
+export declare function clearDialogInterruptedExecutionMarker(dialogId: DialogID, status?: 'running' | 'completed' | 'archived'): Promise<void>;
+export declare function setDialogDisplayState(dialogId: DialogID, displayState: DialogDisplayState, status?: 'running' | 'completed' | 'archived'): Promise<void>;
 export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker: {
     kind: 'interrupted' | 'resumed';
     reason?: DialogInterruptionReason;

package/dist/dialog-display-state.js

@@ -327,7 +327,7 @@ async function loadDialogExecutionMarker(dialogId, status = 'running') {
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
     return latest?.executionMarker;
 }
-async function setDialogExecutionMarker(dialogId, executionMarker) {
+async function setDialogExecutionMarker(dialogId, executionMarker, status = 'running') {
     if (executionMarker?.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
         log.warn('Rejecting dead executionMarker for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
@@ -338,20 +338,21 @@ async function setDialogExecutionMarker(dialogId, executionMarker) {
         await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
             kind: 'patch',
             patch: { executionMarker },
-        }));
+        }), status);
     }
     catch (err) {
         log.warn('Failed to persist dialog executionMarker', err, {
             dialogId: dialogId.valueOf(),
             rootId: dialogId.rootId,
             selfId: dialogId.selfId,
+            status,
             intendedExecutionMarker: executionMarker ?? null,
         });
     }
 }
-async function clearDialogInterruptedExecutionMarker(dialogId) {
+async function clearDialogInterruptedExecutionMarker(dialogId, status = 'running') {
     try {
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
         if (latest?.executionMarker?.kind !== 'interrupted') {
             return;
         }
@@ -359,12 +360,13 @@ async function clearDialogInterruptedExecutionMarker(dialogId) {
     catch (err) {
         log.warn('Failed to inspect executionMarker before clearing interrupted marker', err, {
             dialogId: dialogId.valueOf(),
+            status,
         });
         return;
     }
-    await setDialogExecutionMarker(dialogId, undefined);
+    await setDialogExecutionMarker(dialogId, undefined, status);
 }
-async function setDialogDisplayState(dialogId, displayState) {
+async function setDialogDisplayState(dialogId, displayState, status = 'running') {
     if (displayState.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
         log.warn('Rejecting dead displayState for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
@@ -376,7 +378,7 @@ async function setDialogDisplayState(dialogId, displayState) {
     // "dead" is irreversible. Once a dialog is marked dead, do not allow overwriting it with
     // another state (best-effort; races may still exist across concurrent writers).
     try {
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
         previousDisplayState = latest?.displayState;
         previousExecutionMarker = latest?.executionMarker;
         if (dialogId.selfId !== dialogId.rootId &&
@@ -400,6 +402,7 @@ async function setDialogDisplayState(dialogId, displayState) {
     catch (err) {
         log.warn('Failed to check existing displayState before setDialogDisplayState', err, {
             dialogId: dialogId.valueOf(),
+            status,
         });
     }
     const nextExecutionMarker = displayState.kind === 'stopped'
@@ -413,13 +416,14 @@ async function setDialogDisplayState(dialogId, displayState) {
         await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
             kind: 'patch',
             patch: { displayState, executionMarker: nextExecutionMarker },
-        }));
+        }), status);
     }
     catch (err) {
         log.warn('Failed to persist dialog displayState', err, {
             dialogId: dialogId.valueOf(),
             rootId: dialogId.rootId,
             selfId: dialogId.selfId,
+            status,
             intendedDisplayState: displayState,
         });
     }

package/dist/dialog.d.ts

@@ -19,6 +19,7 @@ import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { ActiveCalleesFile, CalleeCourseNumber, CalleeGenerationSeqNumber, CallSiteCourseNo, CallSiteGenseqNo, DialogAskerStackState, DialogLatestFile, DialogMetadataFile, DialogNextStepTrigger, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } from './llm/client';
 import type { ToolResultImageIngest, UserImageIngest } from './llm/gen';
+import { type SharedReminderTarget } from './shared-reminders';
 import type { JsonValue } from './tool';
 import { Reminder, ReminderOptions, ReminderOwner } from './tool';
 export declare class InvalidReminderIndexError extends Error {
@@ -105,10 +106,10 @@ export type VisibleReminderTarget = Readonly<{
     index: number;
     reminder: Reminder;
 }> | Readonly<{
-    source: 'agent_shared';
+    source: 'runtime';
     index: number;
     reminder: Reminder;
-    agentId: string;
+    target: SharedReminderTarget;
 }>;
 /**
  * Assignment from askerDialog for sideDialogs
@@ -239,7 +240,6 @@ export declare abstract class Dialog {
     }>;
     get activeCalleeDialogIds(): ReadonlyArray<DialogID>;
     addActiveCalleeDialogs(ids: DialogID[]): void;
-    removeActiveCalleeDispatch(id: DialogID): void;
     clearActiveCalleeDialogs(): void;
     /**
      * Load active callee dispatches from persistence into memory.

package/dist/dialog.js

@@ -457,9 +457,6 @@ class Dialog {
     addActiveCalleeDialogs(ids) {
         this._activeCalleeDialogIds.push(...ids);
     }
-    removeActiveCalleeDispatch(id) {
-        this._activeCalleeDialogIds = this._activeCalleeDialogIds.filter((activeCallee) => activeCallee.selfId !== id.selfId);
-    }
     clearActiveCalleeDialogs() {
         this._activeCalleeDialogIds = [];
     }
@@ -544,17 +541,23 @@ class Dialog {
             index,
             reminder,
         }));
-        const sharedReminders = await (0, shared_reminders_1.loadAgentSharedReminders)(this.agentId);
-        for (let index = 0; index < sharedReminders.length; index += 1) {
-            const reminder = sharedReminders[index];
-            if (!reminder)
-                continue;
-            targets.push({
-                source: 'agent_shared',
-                index,
-                reminder,
-                agentId: this.agentId,
-            });
+        const sharedTargets = [
+            { kind: 'task', agentId: this.agentId, taskDocPath: this.taskDocPath },
+            { kind: 'agent', agentId: this.agentId },
+        ];
+        for (const sharedTarget of sharedTargets) {
+            const sharedReminders = await (0, shared_reminders_1.loadSharedReminders)(sharedTarget);
+            for (let index = 0; index < sharedReminders.length; index += 1) {
+                const reminder = sharedReminders[index];
+                if (!reminder)
+                    continue;
+                targets.push({
+                    source: 'runtime',
+                    index,
+                    reminder,
+                    target: sharedTarget,
+                });
+            }
         }
         // Visible reminders are always merged into a single newest-first stream regardless of
         // storage scope, so UI rendering, reminder injection, and reminder-id targeting agree.
@@ -632,10 +635,18 @@ class Dialog {
      * Returns reminder contents with metadata for the frontend.
      */
     async processReminderUpdates() {
-        const sharedReminders = await (0, shared_reminders_1.loadAgentSharedReminders)(this.agentId);
+        const taskSharedTarget = {
+            kind: 'task',
+            agentId: this.agentId,
+            taskDocPath: this.taskDocPath,
+        };
+        const runtimeTarget = { kind: 'agent', agentId: this.agentId };
+        const taskSharedReminders = await (0, shared_reminders_1.loadSharedReminders)(taskSharedTarget);
+        const runtimeReminders = await (0, shared_reminders_1.loadSharedReminders)(runtimeTarget);
         const localChanged = await this.processReminderCollection(this.reminders);
-        const sharedChanged = await this.processReminderCollection(sharedReminders);
-        if (localChanged || sharedChanged) {
+        const taskSharedChanged = await this.processReminderCollection(taskSharedReminders);
+        const runtimeChanged = await this.processReminderCollection(runtimeReminders);
+        if (localChanged || taskSharedChanged || runtimeChanged) {
             this.touchReminders();
         }
         // Centralized persistence - called when emitting event.
@@ -647,17 +658,28 @@ class Dialog {
             log_1.log.warn('Failed to persist reminders', err, { dialogId: this.id.valueOf() });
         }
         try {
-            await (0, shared_reminders_1.replaceAgentSharedReminders)(this.agentId, sharedReminders);
+            await (0, shared_reminders_1.replaceSharedReminders)(taskSharedTarget, taskSharedReminders);
+        }
+        catch (err) {
+            log_1.log.warn('Failed to persist task-scoped reminders', err, {
+                dialogId: this.id.valueOf(),
+                agentId: this.agentId,
+                taskDocPath: this.taskDocPath,
+            });
+        }
+        try {
+            await (0, shared_reminders_1.replaceSharedReminders)(runtimeTarget, runtimeReminders);
         }
         catch (err) {
-            log_1.log.warn('Failed to persist agent-shared reminders', err, {
+            log_1.log.warn('Failed to persist agent-scoped reminders', err, {
                 dialogId: this.id.valueOf(),
                 agentId: this.agentId,
             });
         }
         const visibleReminders = [
             ...this.reminders.map((reminder) => (0, tool_1.cloneReminder)(reminder)),
-            ...sharedReminders,
+            ...taskSharedReminders,
+            ...runtimeReminders,
         ];
         visibleReminders.sort(tool_1.compareReminderDisplayOrder);
         const reminders = visibleReminders.map((r) => ({

package/dist/docs/design.md

@@ -10,6 +10,10 @@ Dominds implements **Social Division of Labor** for AI agents - a systematic app
 
 **Key Design Principle**: Agents operate in **autonomous "YOLO mode"** with **Fresh Boots Reasoning** - making independent decisions with clean mental states through strategic context reset and task-centered focus architecture.
 
+**Liveness Principle**: If humans and agents can still continue the business dialogue with reasonable judgment, the system should prefer keeping the conversation alive. Technical projection drift, local semantic noise, or imperfect intermediate states should not automatically override the business continuation path. Only conflicts that would cause wrong delivery, duplicate consumption, unaccountable behavior, or broken safety boundaries must stop the path loudly.
+
+**Expressiveness Principle**: After liveness, the system should keep business intent direct and easy to state. Prefer fewer extra abstractions, fewer newly invented labels, and less technical phrasing that obscures the business meaning. Specific “this should not be too wordy” judgments belong in the concrete business scenario, not as a low-level instruction to optimize for shortest paths or quiet logs.
+
 ## Table of Contents
 
 1. [The Problem: Agentic Disorientation](#the-problem-agentic-disorientation)

package/dist/docs/design.zh.md

@@ -10,6 +10,10 @@ Dominds 为 AI 智能体实现了**社会分工**——一种通过战略性心
 
 **关键设计原则**：智能体在**自主 "YOLO 模式"** 下运行，配备**扪心自问（FBR）**——通过战略性上下文重置和以任务为中心的专注架构，以干净的心理状态做出独立决策。
 
+**保活原则**：只要人类与智能体还能基于当前业务判断继续推进，系统就应优先让对话继续跑下去；技术投影、局部语义失真、日志噪音或中间态不洁净，不应自动覆盖业务接续路径。真正会导致错误交付、重复消费、不可判责或安全边界破坏的冲突，才必须阻断并 loud diagnostic。
+
+**顺直原则**：在不削弱保活的前提下，业务意图的表达还应尽量更直白，少一点额外抽象、少一点新口径、少一点技术性兜圈子。真正“这里不该太啰嗦”的判断，应体现在具体业务场景里，而不是把“最短路径”“少噪音”这类技术抽象当成低阶工作的直接原则。
+
 ## 目录
 
 1. [问题：智能体迷失方向](#问题智能体迷失方向)

package/dist/docs/dlg-drive-algo.zh.md

@@ -8,6 +8,10 @@
 
 任何进入 drive core 的动作，都必须先由一个本地化的业务 continuation handler 认领。技术形态上的“没有 human prompt”不是业务授权，不能作为 drive 的依据。
 
+同时，drive algorithm 的最高产品目标是**业务保活**。技术不变量服务于“对话能正确地继续”，而不是反过来要求业务对话为技术投影的瞬时洁净让路。若旧 course 的残留 follow-up、displayState 投影抖动、日志诊断噪声等问题不会造成错误交付、重复消费或不可判责，且新的 runtime prompt / 人类判断 / 智能体判断已经给出明确接续路径，系统应优先让对话继续，并保留足够诊断信号供后续自愈。只有会破坏业务消费账本、跨 dialog reply routing、Q4H 等待边界或安全交付边界的冲突，才应阻断 unsafe path。
+
+在保活之下，还要继续追求**顺直**：这里说的不是工程意义上的“最短路径”或“少噪音”，而是业务意图表达要更直白，少额外抽象、少新口径、少让技术概念盖住业务意思。真正“这里不该太啰嗦”的判断应在具体业务场景里落地，而不是把这些技术抽象当成低阶工作的直接口令。
+
 ## 背景问题
 
 历史实现里存在两个过宽的技术概念：
@@ -309,6 +313,7 @@ Stale cleanup:
 
 - 只能清理本 follow-up trigger；
 - 不能用“近期是否生成过内容”之类 transcript 猜测。
+- 如果一个更新的 pending runtime prompt 已经开启新 course，旧 course 的 follow-up 不应和新 prompt 在同一 gen turn 中竞争 business continuation；此类残留应被视为被新 course prompt 取代，loud warn 后清理对应 trigger，让新程继续运行。
 
 注意：pending tellask dispatch ack 不是 immediate follow-up 的理由。只有真正需要当前 LLM 立刻消化的 tool result、invalid tool recovery、reply delivery result 等，才应形成 follow-up。
 

package/dist/docs/roadmap.md

@@ -83,3 +83,5 @@ Positioning: Dominds only schedules and orchestrates; everything else becomes an
 - **rtws-first**: scope capabilities/state by rtws for project/team isolation and reuse.
 - **protocol-first**: align kernel↔Apps and frontend↔backend via stable protocols; avoid “must upgrade together” coupling.
 - **debuggability as a first-class feature**: every streaming/concurrent/collaboration mechanism must be replayable, diagnosable, and explainable.
+- **Liveness first, semantic self-healing**: Dominds is not trying to make the technical state machine look perfect at every instant. The product goal is to keep the human-agent business dialog running whenever it can still make progress. When technical friction, local semantic drift, or projection inconsistency appears, prefer preserving dialog liveness if human and agent judgment can continue the work and later interactions can semantically self-heal. Conflicts that would cause wrong delivery, duplicate consumption, or unaccountable behavior must still emit loud diagnostics.
+- **Expressiveness second, fewer abstractions**: after liveness, prefer business intent to be stated more directly, with fewer extra abstractions, fewer newly invented labels, and less technical phrasing that hides the business meaning. Specific “this should not be too wordy” judgments belong in the concrete business scenario, not as a low-level instruction to chase the shortest path or the quietest log.

package/dist/docs/roadmap.zh.md

@@ -83,3 +83,5 @@ Dominds 的长期方向是把“智能体分工协作”沉淀为一个可复用
 - **rtws-first**：能力与状态以 rtws 为边界，便于按项目/团队隔离与复用。
 - **协议优先**：内核与 Apps、前端与后端以稳定协议对齐，避免“只能一起升级”的紧耦合。
 - **可调试性是一等公民**：任何流式/并发/分工机制都必须可复盘、可定位、可解释。
+- **保活优先，语义可自愈**：Dominds 的产品目标不是让技术状态机在每个瞬间都显得完美，而是让人类与智能体组成的业务对话尽量继续运行。遇到技术磕绊、局部语义失真或投影不一致时，只要仍能基于人类和智能体的判断继续推进，并能在后续交互中语义上自愈，系统应优先保活；真正会导致错误交付、重复消费或无法判责的冲突仍必须 loud diagnostic。
+- **顺直优先，少额外抽象**：在不削弱保活的前提下，系统还应尽量让业务意图的表达更直白，少加额外抽象、少造新口径、少用技术概念遮住业务意思。真正的“这里不该太啰嗦”应体现在具体业务场景的表达里，而不是把“短路径”或“少噪音”当作低阶工作的直接口令。

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

@@ -49,9 +49,9 @@
  *
  * // Turn 2: Tool error (func_result_msg with role='tool'), LLM self-corrects
  * # docs/e2e-story-test/reminders.md: Tool syntax error recovery
- * - message: "Error: Invalid args. Use: add_reminder({ content: string, position?: number, scope?: \"dialog\" | \"personal\" }) (omit position to append)."
+ * - message: "Error: Invalid args. Use: add_reminder({ content: string, scope?: \"dialog\" | \"task\" | \"agent\" }) (omitting scope means task)."
  *   role: "tool"
- *   response: "Call the function tool `add_reminder` with {\"content\":\"Goals...\",\"position\":1}"
+ *   response: "Call the function tool `add_reminder` with {\"content\":\"Goals...\",\"scope\":\"task\"}"
  */
 import type { Team } from '../../team';
 import type { FuncTool } from '../../tool';

package/dist/llm/gen/mock.js

@@ -50,9 +50,9 @@
  *
  * // Turn 2: Tool error (func_result_msg with role='tool'), LLM self-corrects
  * # docs/e2e-story-test/reminders.md: Tool syntax error recovery
- * - message: "Error: Invalid args. Use: add_reminder({ content: string, position?: number, scope?: \"dialog\" | \"personal\" }) (omit position to append)."
+ * - message: "Error: Invalid args. Use: add_reminder({ content: string, scope?: \"dialog\" | \"task\" | \"agent\" }) (omitting scope means task)."
  *   role: "tool"
- *   response: "Call the function tool `add_reminder` with {\"content\":\"Goals...\",\"position\":1}"
+ *   response: "Call the function tool `add_reminder` with {\"content\":\"Goals...\",\"scope\":\"task\"}"
  */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };

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

@@ -138,6 +138,12 @@ function buildInterruptedFuncResult(args) {
         genseq: args.callGenseq,
     };
 }
+function sameOpenGenerationRun(state, course, genseq) {
+    return (state?.kind === 'open' &&
+        state.course === course &&
+        genseq !== undefined &&
+        state.genseq === genseq);
+}
 function sameDialogBusinessContinuation(left, right) {
     if (left.kind !== right.kind)
         return false;
@@ -211,7 +217,7 @@ async function persistDialogFbrState(dialog, fbrState) {
     await persistence_1.DialogPersistence.mutateDialogLatest(dialog.id, () => ({
         kind: 'patch',
         patch: { fbrState },
-    }));
+    }), dialog.status);
 }
 function buildKernelDriverFbrPrompt(dlg, state) {
     const collectiveTargets = dlg.assignmentFromAsker.collectiveTargets &&
@@ -1571,7 +1577,7 @@ async function preserveDiligenceBudgetAcrossQ4H(dlg) {
         void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
             kind: 'patch',
             patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
-        }));
+        }), dlg.status);
     }
     catch (err) {
         log_1.log.error('kernel-driver failed to preserve Diligence Push budget after Q4H', err, {
@@ -1604,7 +1610,7 @@ async function maybeContinueWithDiligencePrompt(args) {
         void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
             kind: 'patch',
             patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
-        }));
+        }), dlg.status);
     }
     if (dlg instanceof dialog_1.MainDialog && prepared.kind !== 'disabled') {
         emitDiligenceBudgetEvent(dlg, {
@@ -3022,29 +3028,50 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
             reason: lateInterruptedReason,
             continueEnabled: resolveStoppedContinueEnabled(lateInterruptedReason),
         };
-        (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, { kind: 'interrupted', reason: lateInterruptedReason });
     }
+    let shouldPersistFinalDisplayProjection = true;
     try {
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, 'running');
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, dlg.status);
         if (dlg.id.selfId !== dlg.id.rootId && latest?.executionMarker?.kind === 'dead') {
             finalDisplayState = { kind: 'dead', reason: latest.executionMarker.reason };
         }
+        else if (finalDisplayState.kind === 'stopped' &&
+            latest?.generating === true &&
+            !sameOpenGenerationRun(latest.generationRunState, dlg.activeGenCourseOrUndefined ?? dlg.currentCourse, dlg.activeGenSeqOrUndefined)) {
+            shouldPersistFinalDisplayProjection = false;
+            log_1.log.debug('Skipped stale stopped projection from superseded generation to preserve liveness', undefined, {
+                dialogId: dlg.id.valueOf(),
+                rootId: dlg.id.rootId,
+                selfId: dlg.id.selfId,
+                activeCourse: dlg.activeGenCourseOrUndefined ?? dlg.currentCourse,
+                activeGenseq: dlg.activeGenSeqOrUndefined ?? null,
+                latestGenerationRunState: latest.generationRunState ?? null,
+                latestDisplayState: latest.displayState ?? null,
+                reason: 'newer_generation_active',
+            });
+        }
     }
     catch (err) {
         log_1.log.warn('kernel-driver failed to re-check displayState before finalizing', err, {
             dialogId: dlg.id.valueOf(),
         });
     }
-    if (finalDisplayState.kind === 'stopped') {
-        await (0, dialog_display_state_1.setDialogExecutionMarker)(dlg.id, {
-            kind: 'interrupted',
-            reason: finalDisplayState.reason,
-        });
-    }
-    else if (finalDisplayState.kind !== 'dead') {
-        await (0, dialog_display_state_1.clearDialogInterruptedExecutionMarker)(dlg.id);
+    if (shouldPersistFinalDisplayProjection) {
+        if (finalDisplayState.kind === 'stopped') {
+            await (0, dialog_display_state_1.setDialogExecutionMarker)(dlg.id, {
+                kind: 'interrupted',
+                reason: finalDisplayState.reason,
+            }, dlg.status);
+            (0, dialog_display_state_1.broadcastDisplayStateMarker)(dlg.id, {
+                kind: 'interrupted',
+                reason: finalDisplayState.reason,
+            });
+        }
+        else if (finalDisplayState.kind !== 'dead') {
+            await (0, dialog_display_state_1.clearDialogInterruptedExecutionMarker)(dlg.id, dlg.status);
+        }
+        await (0, dialog_display_state_1.setDialogDisplayState)(dlg.id, finalDisplayState, dlg.status);
     }
-    await (0, dialog_display_state_1.setDialogDisplayState)(dlg.id, finalDisplayState);
     return {
         lastAssistantSayingContent,
         lastAssistantSayingGenseq,

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

@@ -4,7 +4,7 @@ export declare function driveDialogStream(...driveArgs: KernelDriverDriveArgs):
 export declare function emitSayingEventsBridge(...args: KernelDriverEmitSayingArgs): KernelDriverEmitSayingResult;
 export declare function supplyResponseToAskerDialog(...args: KernelDriverSupplyResponseArgs): KernelDriverSupplyResponseResult;
 export declare function driveDialogStreamCore(dlg: Dialog, callbacks: KernelDriverDriveCallbacks, humanPrompt?: KernelDriverDriveArgs[1], driveOptions?: KernelDriverDriveArgs[3]): Promise<KernelDriverCoreResult>;
-export declare function supplyResponseToSideDialogBridge(callerDialog: Dialog, sideDialogId: DialogID, responseText: string, callType: 'A' | 'B' | 'C', callId?: string, status?: 'completed' | 'failed', calleeResponseRef?: {
+export declare function supplyResponseToSideDialogBridge(callerDialog: Dialog, sideDialogId: DialogID, responseText: string, callType: 'A' | 'B' | 'C', callId: string, status?: 'completed' | 'failed', calleeResponseRef?: {
     course: number;
     genseq: number;
 }, directFallbackSource?: 'saying' | 'thinking_only'): Promise<void>;

package/dist/llm/kernel-driver/idle-reminder-wake.js

@@ -130,7 +130,7 @@ async function applyWakeEventUpdates(dialog, events) {
             });
             continue;
         }
-        await (0, shared_reminders_1.mutateAgentSharedReminders)(target.agentId, (reminders) => {
+        await (0, shared_reminders_1.mutateSharedReminders)(target.target, (reminders) => {
             const index = reminders.findIndex((reminder) => reminder.id === target.reminder.id);
             if (index < 0) {
                 throw new Error(`idle reminder wake invariant violation: shared reminder ${target.reminder.id} disappeared before update`);

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

@@ -8,7 +8,7 @@ export declare function supplyResponseToAskerDialog(args: {
     sideDialogId: DialogID;
     responseText: string;
     callType: 'A' | 'B' | 'C';
-    callId?: string;
+    callId: string;
     status?: 'completed' | 'failed';
     deliveryMode?: 'reply_tool' | 'direct_fallback';
     directFallbackSource?: 'saying' | 'thinking_only';

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

@@ -137,14 +137,18 @@ async function resolveLatestAssignmentAnchorRef(args) {
 }
 async function supplyResponseToAskerDialog(args) {
     const { callerDialog, sideDialogId, responseText, callType, callId, status = 'completed', deliveryMode = 'reply_tool', directFallbackSource, calleeResponseRef, askerCourseOverride, scheduleDrive, sideDialog: maybeSideDialog, } = args;
+    const requestedCallId = typeof callId === 'string' ? callId.trim() : '';
+    if (requestedCallId === '') {
+        throw new Error(`sideDialog response supply invariant violation: callId is required ` +
+            `(callerId=${callerDialog.id.selfId}, sideDialogId=${sideDialogId.selfId})`);
+    }
     try {
         const result = await (0, sideDialog_txn_1.withSideDialogTxnLock)(callerDialog.id, async () => {
             const activeCalleeDispatches = await persistence_1.DialogPersistence.loadActiveCalleeDispatches(callerDialog.id, callerDialog.status);
             let activeCalleeDispatch;
-            const requestedCallId = typeof callId === 'string' ? callId.trim() : '';
             for (const dispatch of activeCalleeDispatches) {
                 if (dispatch.calleeDialogId === sideDialogId.selfId &&
-                    (requestedCallId === '' || dispatch.callId === requestedCallId) &&
+                    dispatch.callId === requestedCallId &&
                     activeCalleeDispatch === undefined) {
                     activeCalleeDispatch = dispatch;
                 }
@@ -239,7 +243,7 @@ async function supplyResponseToAskerDialog(args) {
                 shouldDriveContinuation,
             };
         });
-        const normalizedCallId = typeof callId === 'string' ? callId.trim() : '';
+        const normalizedCallId = requestedCallId;
         const fallbackCallId = typeof result.callId === 'string' ? result.callId.trim() : '';
         const resolvedCallId = normalizedCallId !== '' ? normalizedCallId : fallbackCallId;
         const rootForLookup = callerDialog instanceof dialog_1.MainDialog

package/dist/llm/kernel-driver/tellask-special.js

@@ -1216,7 +1216,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     executionMarker: undefined,
                     fbrState: initialFbrState,
                 },
-            }));
+            }), sub.status);
             await syncPendingTellaskReminderBestEffort(dlg, 'kernel-driver:executeTellaskCall:FBR:appendPending');
             const initPrompt = {
                 content: (0, fbr_1.buildFbrPromptForState)({
@@ -1542,10 +1542,6 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                                         const previousOwnerId = previousAssignment.askerDialogId === pendingOwner.id.selfId
                                             ? pendingOwner.id
                                             : new dialog_1.DialogID(previousAssignment.askerDialogId, mainDialog.id.rootId);
-                                        await persistence_1.DialogPersistence.removeActiveCallee(previousOwnerId, {
-                                            batchId: replacedPending.batchId,
-                                            callId: replacedPending.callId,
-                                        }, pendingOwner.status);
                                         if (previousOwnerId.selfId !== pendingOwner.id.selfId) {
                                             const previousOwnerDialog = mainDialog.lookupDialog(previousOwnerId.selfId) ??
                                                 (await (0, dialog_instance_registry_1.ensureDialogLoaded)(mainDialog, previousOwnerId, pendingOwner.status));
@@ -1562,7 +1558,6 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                                             }
                                         }
                                     }
-                                    await persistence_1.DialogPersistence.upsertActiveCalleeFromPendingRecord(pendingOwner.id, pendingRecord, pendingOwner.status);
                                     await updateSideDialogAssignment(existing, assignment, {
                                         replacePendingCallId: previousAssignment.callId,
                                         replacePendingAskerDialogId: previousAssignment.askerDialogId,

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

@@ -75,7 +75,7 @@ export type KernelDriverSupplyResponseArgs = [
     sideDialogId: DialogID,
     responseText: string,
     callType: 'A' | 'B' | 'C',
-    callId?: string,
+    callId: string,
     status?: 'completed' | 'failed',
     calleeResponseRef?: {
         course: number;

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

@@ -188,8 +188,8 @@ function getMemoryPromptCopy(ctx) {
             injectedTaskdocLine: '- 重要：差遣牒内容会被系统以内联形式注入到上下文中（本轮生成视角下即为最新；注入内容不包括全局约束）。需要回顾时请直接基于上下文里的差遣牒内容回顾与决策，不要试图用通用文件工具读取 `*.tsk/` 下的文件（会被拒绝）。',
             constraintsLine: '- 约定：`constraints` 只写任务特有的硬要求，不得写入系统提示/工具文档里已明确且由系统强制执行的通用规则（例如 `*.tsk/` 封装禁止通用文件工具）。一经发现重复，必须删除并告知用户。',
             remindersLine: ctx.isSideDialog
-                ? '- 提醒项（以 `reminder_id` 标识，工作集）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，整理“结构化接续包提醒项”；提醒项保留恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，支线对话不要维护差遣牒，也不要整理差遣牒更新提案；只维护足够详尽的接续包提醒项，提醒项长度没有技术限制，允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。'
-                : '- 提醒项（以 `reminder_id` 标识，工作集）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，先把尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再整理“结构化接续包提醒项”；提醒项只保留差遣牒仍未覆盖、但恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，则允许先保留多条粗略提醒项把信息带过桥；当前程只做落文档、保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
+                ? '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，整理“结构化接续包提醒项”；提醒项保留恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，支线对话不要维护差遣牒，也不要整理差遣牒更新提案；只维护足够详尽的接续包提醒项，提醒项长度没有技术限制，允许先保留多条粗略提醒项把信息带过桥；当前程只做保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。'
+                : '- 提醒项（以 `reminder_id` 标识，手头工作）：当前对话的高频工作记录/关键细节（偏私有，不作为全队公告）；默认保持少量（常见 1–3 条），优先 `update_reminder` 压缩/合并，不再需要就 `delete_reminder`。准备 `clear_mind` 开启新一程对话时，先把尚未落实到文档、且下一程需要知会的讨论细节落到差遣牒合适章节，再整理“结构化接续包提醒项”；提醒项只保留差遣牒仍未覆盖、但恢复工作容易丢的细节（如第一步、关键定位、运行/验证信息、临时 ids/路径）。若系统已把当前程切到吃紧/告急处置态，则允许先保留多条粗略提醒项把信息带过桥；当前程只做落文档、保信息 + clear_mind；只有系统实际开启新一程后，第一步才是以清醒头脑复核并整理这些接续包/粗略提醒项：删除冗余、纠正偏激或失真的过桥思路、压缩成高质量提醒项。',
             teamMemoryLine: '- 团队记忆：稳定的团队约定/工程规约（跨任务共享）。',
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；记忆会在每次生成时自动注入上下文，应保持少量且准确（关键文档/代码的精确路径 + 最小必要事实）。不要记录具体任务状态。',
             skillsLine: '- Skills：可复用操作指引/检查清单/触发条件与边界。工作区关联强的事实、路径、局部契约进 memory/env；独立于工作区内容的“怎么做”进 skill。skill 不授予工具权限；需要脚本/MCP/外部能力时应配套 app/toolset/权限配置。',
@@ -223,8 +223,8 @@ function getMemoryPromptCopy(ctx) {
         injectedTaskdocLine: '- Important: the Taskdoc content is injected inline into the context (the latest as of this generation; injected content excludes global constraints). Review the injected Taskdoc instead of trying to read files under `*.tsk/` via general file tools (they will be rejected).',
         constraintsLine: '- Convention: Taskdoc `constraints` must contain task-specific requirements only; do not include global, system-enforced rules already stated in system prompt/tool docs (e.g. `.tsk/` encapsulation bans general file tools). If duplication is found, you MUST remove it and notify the user.',
         remindersLine: ctx.isSideDialog
-            ? '- Reminders (addressed by `reminder_id`, working set): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, create a structured continuation-package reminder that preserves details easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, you are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; only maintain sufficiently detailed continuation-package reminders. Reminder length has no technical limit, rough multi-reminder bridge notes are acceptable, and in the current course you should only preserve volatile information and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
-            : '- Reminders (addressed by `reminder_id`, working set): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, first record undocumented discussion details that the next course needs to know into the appropriate Taskdoc sections, then create a structured continuation-package reminder. Reminders should keep only details still not covered by Taskdoc but easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, rough multi-reminder bridge notes are acceptable; in the current course, only document missing details, preserve volatile information, and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
+            ? '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, create a structured continuation-package reminder that preserves details easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, you are in a Side Dialog: do not maintain Taskdoc and do not draft Taskdoc update proposals; only maintain sufficiently detailed continuation-package reminders. Reminder length has no technical limit, rough multi-reminder bridge notes are acceptable, and in the current course you should only preserve volatile information and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.'
+            : '- Reminders (addressed by `reminder_id`, current work): your high-frequency per-dialog worklog + critical details (not a team bulletin board); keep it small by default (often 1–3 items), prefer `update_reminder` to compress/merge, and delete when obsolete. When preparing `clear_mind` to start a new course, first record undocumented discussion details that the next course needs to know into the appropriate Taskdoc sections, then create a structured continuation-package reminder. Reminders should keep only details still not covered by Taskdoc but easy to lose during resume (first step, key pointers, run/verify info, volatile ids/paths). If the system has already put the current course into caution/critical remediation, rough multi-reminder bridge notes are acceptable; in the current course, only document missing details, preserve volatile information, and clear_mind. Only after the system actually starts the new course does the mandatory first step become reviewing and rewriting those continuation/rough reminders with a clear head: remove redundancy, correct biased or distorted bridge notes, and compress them into high-quality reminders.',
         teamMemoryLine: '- Team memory: stable shared conventions (cross-task).',
         personalMemoryLine: '- Personal memory: stable personal habits/preferences and responsibility-scope knowledge. Memory is automatically injected into context on each generation: keep it small and accurate (exact key doc/code paths + minimal key facts); do not store per-task state.',
         skillsLine: '- Skills: reusable operating guidance, checklists, triggers, and boundaries. Workspace-coupled facts, paths, and local contracts belong in memory/env; workspace-independent “how to do it” procedures belong in skills. Skills do not grant tool permissions; pair scripts/MCP/external capabilities with apps/toolsets/permission configuration.',