dominds 1.24.4 → 1.25.1

package/dist/dialog.js

@@ -48,9 +48,9 @@ const work_language_1 = require("./runtime/work-language");
 const shared_reminders_1 = require("./shared-reminders");
 const tool_1 = require("./tool");
 const id_2 = require("./utils/id");
-async function wakeRootDialogDrive(rootId, meta) {
+async function queueRootDialogDrive(rootId, meta) {
     const { globalDialogRegistry } = await Promise.resolve().then(() => __importStar(require('./dialog-global-registry')));
-    globalDialogRegistry.wakeDrive(rootId, meta);
+    globalDialogRegistry.queueRootDrive(rootId, meta);
 }
 class InvalidReminderIndexError extends Error {
     constructor(index, total) {
@@ -228,7 +228,7 @@ class Dialog {
         this._currentCourse = 1;
         this._remindersVer = 0;
         // Prompts queued for future drives (set by startNewCourse or deferred-resume flows).
-        this._upNextQueue = [];
+        this._queuedPrompts = [];
         this._driveIntents = [];
         this._driveIntentMode = 'legacy';
         // Course prefix messages injected into LLM context on every course.
@@ -243,7 +243,7 @@ class Dialog {
         // Track the generation sequence when _generationStarted was set
         // Used to ensure proper ordering when multiple generations occur
         this._generationStartedGenseq = 0;
-        // Pending sideDialog IDs (for auto-revive tracking)
+        // Pending sideDialog IDs (for active callee tracking)
         this._activeCalleeDialogIds = [];
         // Phase 11: Suspension state for Type A sideDialog mechanism
         // Tracks whether this dialog is in normal state, suspended, or resuming from suspension
@@ -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) => ({
@@ -755,11 +777,11 @@ class Dialog {
         return this._updatedAt;
     }
     replaceQueuedPromptState(existingMsgId, nextPrompt) {
-        const queueIndex = this._upNextQueue.findIndex((prompt) => prompt.msgId === existingMsgId);
+        const queueIndex = this._queuedPrompts.findIndex((prompt) => prompt.msgId === existingMsgId);
         if (queueIndex < 0) {
-            throw new Error(`UpNext prompt replacement invariant violation: dialog=${this.id.valueOf()} existingMsgId=${existingMsgId}`);
+            throw new Error(`Queued prompt replacement invariant violation: dialog=${this.id.valueOf()} existingMsgId=${existingMsgId}`);
         }
-        this._upNextQueue[queueIndex] = nextPrompt;
+        this._queuedPrompts[queueIndex] = nextPrompt;
         for (let index = this._driveIntents.length - 1; index >= 0; index -= 1) {
             const intent = this._driveIntents[index];
             if (intent.kind !== 'prompt' || intent.prompt.msgId !== existingMsgId)
@@ -822,7 +844,7 @@ class Dialog {
                         }
                         default: {
                             const _exhaustive = nextPrompt;
-                            throw new Error(`UpNext prompt replacement invariant violation: unsupported queued prompt`);
+                            throw new Error(`Queued prompt replacement invariant violation: unsupported queued prompt`);
                         }
                     }
                 })(),
@@ -830,7 +852,7 @@ class Dialog {
             };
             return nextPrompt;
         }
-        throw new Error(`UpNext prompt replacement invariant violation: missing drive intent dialog=${this.id.valueOf()} existingMsgId=${existingMsgId}`);
+        throw new Error(`Queued prompt replacement invariant violation: missing drive intent dialog=${this.id.valueOf()} existingMsgId=${existingMsgId}`);
     }
     setPendingRuntimePrompt(prompt) {
         const prepared = typeof prompt === 'string'
@@ -875,7 +897,7 @@ class Dialog {
                     const prompt = runtimeCommon;
                     return prompt;
                 })();
-        this._upNextQueue = [
+        this._queuedPrompts = [
             normalized.calleeDialogReplyTarget !== undefined
                 ? {
                     kind: 'new_course_runtime_sideDialog',
@@ -927,7 +949,7 @@ class Dialog {
         return normalizedExisting;
     }
     enqueueQueuedPromptState(state) {
-        this._upNextQueue.push(state);
+        this._queuedPrompts.push(state);
         const promptCommon = {
             content: state.prompt,
             ...(state.contentItems === undefined ? {} : { contentItems: state.contentItems }),
@@ -980,7 +1002,7 @@ class Dialog {
                     }
                     default: {
                         const _exhaustive = state;
-                        throw new Error(`UpNext enqueue invariant violation: unsupported queued prompt`);
+                        throw new Error(`Queued prompt enqueue invariant violation: unsupported queued prompt`);
                     }
                 }
             })(),
@@ -988,14 +1010,14 @@ class Dialog {
         });
         this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
     }
-    peekLatestUpNext() {
-        if (this._upNextQueue.length === 0) {
+    peekLatestQueuedPrompt() {
+        if (this._queuedPrompts.length === 0) {
             return undefined;
         }
-        return this._upNextQueue[this._upNextQueue.length - 1];
+        return this._queuedPrompts[this._queuedPrompts.length - 1];
     }
     queueUserPromptAtGenerationBoundary(options) {
-        const existing = this.peekLatestUpNext();
+        const existing = this.peekLatestQueuedPrompt();
         const trimmed = options.prompt.trim();
         if (!trimmed) {
             throw new Error('Prompt is required to queue generation-boundary user prompt');
@@ -1050,7 +1072,7 @@ class Dialog {
         return created;
     }
     queueRegisteredAssignmentUpdatePrompt(options) {
-        const existing = this.peekLatestUpNext();
+        const existing = this.peekLatestQueuedPrompt();
         const trimmed = options.prompt.trim();
         if (!trimmed) {
             throw new Error('Prompt is required to queue registered assignment update');
@@ -1093,7 +1115,7 @@ class Dialog {
     async persistPendingRuntimePrompt(prompt) {
         await this.dlgStore.persistPendingRuntimePrompt(this, prompt);
         if (this.id.selfId === this.id.rootId) {
-            await wakeRootDialogDrive(this.id.rootId, {
+            await queueRootDialogDrive(this.id.rootId, {
                 source: 'dialog_runtime_prompt',
                 reason: `queued_runtime_prompt:${prompt.msgId}`,
             });
@@ -1155,14 +1177,14 @@ class Dialog {
         });
         return created;
     }
-    hasUpNext() {
-        return this._upNextQueue.length > 0;
+    hasQueuedPrompt() {
+        return this._queuedPrompts.length > 0;
     }
-    peekUpNext() {
-        return this._upNextQueue[0];
+    peekQueuedPrompt() {
+        return this._queuedPrompts[0];
     }
-    takeUpNext() {
-        return this._upNextQueue.shift();
+    takeQueuedPrompt() {
+        return this._queuedPrompts.shift();
     }
     setActiveRunControlSpec(spec) {
         this._activeRunControlSpec = spec;
@@ -1244,7 +1266,7 @@ class Dialog {
             await this.dlgStore.startNewCourse(this, nextPrompt);
         }
         if (this.id.selfId === this.id.rootId) {
-            await wakeRootDialogDrive(this.id.rootId, {
+            await queueRootDialogDrive(this.id.rootId, {
                 source: 'dialog_start_new_course',
                 reason: `queued_runtime_prompt:${nextPrompt.msgId}`,
             });
@@ -1265,6 +1287,7 @@ class Dialog {
                 runControl: runControlSpec,
             });
         }
+        return normalized;
     }
     // Proxy methods for DialogStore - route calls through dialog object instead of direct dlgStore access
     async receiveFuncResult(result) {
@@ -1498,7 +1521,15 @@ class Dialog {
         // Mark generation as started with the actual genseq
         // This ensures sideDialog_final_response_evt waits for both user_text and generating_start_evt
         this.markGenerationStarted();
-        return this.dlgStore.notifyGeneratingStart(this, msgId);
+        try {
+            return await this.dlgStore.notifyGeneratingStart(this, msgId);
+        }
+        catch (err) {
+            this._generationStarted = false;
+            this._generationStartedGenseq = 0;
+            this._activeGenCourse = undefined;
+            throw err;
+        }
     }
     async notifyGeneratingFinish(contextHealth, llmGenModel) {
         if (contextHealth) {
@@ -1507,17 +1538,12 @@ class Dialog {
         try {
             await this.dlgStore.notifyGeneratingFinish(this, contextHealth, llmGenModel);
         }
-        catch (err) {
-            log_1.log.warn('notifyGeneratingFinish failed', undefined, {
-                genseq: this._activeGenSeq,
-                error: err,
-                message: err instanceof Error ? err.message : String(err),
-            });
+        finally {
+            // Reset generation tracking for the next course even when persistence fails loudly.
+            this._generationStarted = false;
+            this._generationStartedGenseq = 0;
+            this._activeGenCourse = undefined;
         }
-        // Reset generation tracking for the next course
-        this._generationStarted = false;
-        this._generationStartedGenseq = 0;
-        this._activeGenCourse = undefined;
     }
     async streamError(error) {
         if (this.dlgStore) {

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/dialog-system.md

@@ -729,7 +729,7 @@ sequenceDiagram
   Side-->>Store: persist final response
   Driver-->>Asker: supply result-arrival fact + clear pending callee
   opt result arrival creates an explicit drive source
-    Driver-->>Asker: set needsDrive=true
+    Driver-->>Asker: upsert result_arrival trigger + wake queue
   end
 ```
 
@@ -1231,7 +1231,7 @@ Dominds' runtime does **not** persist a single enum-like “awaiting …” stat
 driven is derived from persisted facts:
 
 - Persisted status (API/index): `running | completed | archived`
-- Persisted `latest.yaml`: `status`, `needsDrive`, `generating`
+- Persisted `latest.yaml`: `status`, `nextStep.triggers`, `generating`
 - Derived gates: `hasPendingQ4H()`; active callee dispatches are background callee facts, not a drive gate
 
 **Persisted status lifecycle:**
@@ -1250,12 +1250,12 @@ stateDiagram-v2
 flowchart TD
   A[status=running] --> B{canDrive?\\n(no pending Q4H)}
   B -- no --> S[Suspended\\n(waiting on Q4H)]
-  S -->|Q4H answered| C{needsDrive?}
+  S -->|Q4H answered| C{nextStep trigger?}
   R[result arrival] --> C
-  B -- yes --> C{needsDrive?}
+  B -- yes --> C{nextStep trigger?}
   C -- no --> I[Idle\\n(waiting for trigger)]
   C -- yes --> D[Drive loop\\n(generating=true while streaming)]
-  D --> E{hasUpNext?}
+  D --> E{hasQueuedPrompt?}
   E -- yes --> C
   E -- no --> I
 ```
@@ -1306,7 +1306,7 @@ sequenceDiagram
   Side-->>Driver: final response
   Driver-->>Tellasker: supply result-arrival fact + clear pending callee
   opt result arrival creates an explicit drive source
-    Driver-->>Tellasker: set `needsDrive=true`
+    Driver-->>Tellasker: upsert result_arrival trigger + wake queue
   end
 ```
 
@@ -1381,7 +1381,7 @@ sequenceDiagram
   Side-->>Asker: sideDialog response supplied to tellasker (result-arrival fact; clears this pending callee)
 
   opt Asker has a result-arrival drive source
-    Asker-->>Asker: set needsDrive=true (result-arrival handling)
+    Asker-->>Asker: upsert result_arrival trigger + wake queue (result-arrival handling)
   end
 ```
 

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

@@ -714,7 +714,7 @@ sequenceDiagram
   Side-->>Store: 持久化最终响应
   Driver-->>Asker: 供应结果到达事实 + 清除 pending callee
   opt 结果到达形成显式驱动源
-    Driver-->>Asker: 设置 needsDrive=true
+    Driver-->>Asker: 写入 result_arrival trigger + Wake Queue
   end
 ```
 
@@ -1214,7 +1214,7 @@ Dominds 的运行时**不**持久化单一的类似枚举的 "awaiting …" 状
 驱动是从持久化的事实派生的：
 
 - 持久化状态（API/索引）：`running | completed | archived`
-- 持久化 `latest.yaml`：`status`、`needsDrive`、`generating`
+- 持久化 `latest.yaml`：`status`、`nextStep.triggers`、`generating`
 - 派生的门控：`hasPendingQ4H()`；active callee dispatches 是后台被诉请者事实，不是驱动门控
 
 **持久化状态生命周期**：
@@ -1286,7 +1286,7 @@ sequenceDiagram
   Side-->>Driver: 最终响应
   Driver-->>Tellasker: 供应结果到达事实 + 清除 pending callee
   opt 结果到达形成显式驱动源
-    Driver-->>Tellasker: 设置 needsDrive=true（结果到达处理）
+    Driver-->>Tellasker: 写入 result_arrival trigger + Wake Queue（结果到达处理）
   end
 ```
 
@@ -1358,7 +1358,7 @@ sequenceDiagram
   Side-->>Asker: callee 响应供应给诉请者（结果到达事实；清除该 pending callee）
 
   opt 诉请者有 result-arrival 驱动事实
-    Asker-->>Asker: 设置 needsDrive=true（结果到达处理）
+    Asker-->>Asker: 写入 result_arrival trigger + Wake Queue（结果到达处理）
   end
 ```