dominds 1.27.1 → 1.27.3

package/dist/apps/runtime.js

@@ -123,7 +123,9 @@ async function resolveTargetDialog(sourceDlg, target) {
         }
         return sideDialog;
     }
-    const matches = targetRoot.getAllDialogs().filter((dialog) => dialog.agentId === target.agentId);
+    const matches = targetRoot
+        .getLoadedDialogTreeSnapshot()
+        .filter((dialog) => dialog.agentId === target.agentId);
     if (matches.length === 1) {
         return matches[0];
     }

package/dist/dialog-global-registry.d.ts

@@ -1,4 +1,4 @@
-import { type MainDialog } from './dialog';
+import { type Dialog, type MainDialog } from './dialog';
 export type DriveTriggerEvent = Readonly<{
     type: 'drive_trigger_evt';
     action: 'queue_root_drive' | 'clear_root_drive_queue' | 'active_run_cleared';
@@ -47,6 +47,16 @@ declare class GlobalDialogRegistry {
     noteActiveRunBlockedQueuedDrive(rootId: string): void;
     hasPendingActiveRunClearedDrive(rootId: string): boolean;
     isRootDriveQueued(rootId: string): boolean;
+    /**
+     * One-shot runtime snapshot for shared-reminder impact routing.
+     *
+     * This intentionally does not enumerate persisted "all running dialogs". It walks only the roots
+     * this runtime has already registered, and includes only dialogs with direct in-memory evidence
+     * of current work: locked running main dialogs and the loaded active-callee frontier under each
+     * root. Dialogs that merely remain in memory/history but have no current-work signal are not
+     * considered parallel work.
+     */
+    getLoadedInFlightDialogsForSharedReminderImpact(): Dialog[];
     getLastDriveTrigger(rootId: string): DriveTriggerEvent | undefined;
     consumeQueuedMainDialogs(): MainDialog[];
     get size(): number;

package/dist/dialog-global-registry.js

@@ -218,6 +218,51 @@ class GlobalDialogRegistry {
     isRootDriveQueued(rootId) {
         return this.entries.get(rootId)?.driveQueued === true;
     }
+    /**
+     * One-shot runtime snapshot for shared-reminder impact routing.
+     *
+     * This intentionally does not enumerate persisted "all running dialogs". It walks only the roots
+     * this runtime has already registered, and includes only dialogs with direct in-memory evidence
+     * of current work: locked running main dialogs and the loaded active-callee frontier under each
+     * root. Dialogs that merely remain in memory/history but have no current-work signal are not
+     * considered parallel work.
+     */
+    getLoadedInFlightDialogsForSharedReminderImpact() {
+        const dialogs = [];
+        for (const entry of this.entries.values()) {
+            const rootDialog = entry.mainDialog;
+            const visitedDialogIds = new Set();
+            const stack = [];
+            if (rootDialog.status === 'running' && rootDialog.isLocked()) {
+                dialogs.push(rootDialog);
+                visitedDialogIds.add(rootDialog.id.valueOf());
+            }
+            for (const calleeId of rootDialog.activeCalleeDialogIds) {
+                const loadedCallee = rootDialog.lookupDialog(calleeId.selfId);
+                if (loadedCallee && loadedCallee.status === 'running') {
+                    stack.push(loadedCallee);
+                }
+            }
+            while (stack.length > 0) {
+                const current = stack.pop();
+                if (!current || visitedDialogIds.has(current.id.valueOf())) {
+                    continue;
+                }
+                visitedDialogIds.add(current.id.valueOf());
+                if (current.status !== 'running') {
+                    continue;
+                }
+                dialogs.push(current);
+                for (const calleeId of current.activeCalleeDialogIds) {
+                    const loadedCallee = rootDialog.lookupDialog(calleeId.selfId);
+                    if (loadedCallee && loadedCallee.status === 'running') {
+                        stack.push(loadedCallee);
+                    }
+                }
+            }
+        }
+        return dialogs;
+    }
     getLastDriveTrigger(rootId) {
         return this.lastDriveTriggerByRootId.get(rootId);
     }

package/dist/dialog.d.ts

@@ -14,7 +14,7 @@
  */
 import type { ContextHealthSnapshot } from '@longrun-ai/kernel/types/context-health';
 import type { DialogEvent, NativeToolCallPayload, ReminderContent, WebSearchCallAction, WebSearchCallSource } from '@longrun-ai/kernel/types/dialog';
-import type { DialogCalleeReplyTarget, DialogQueuedDeferredQ4HAnswerState, DialogQueuedPromptState, DialogQueuedUserGenerationBoundaryState, DialogRunControlSpec, DialogRuntimePrompt, DialogUserPrompt, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
+import type { DialogCalleeReplyTarget, DialogQueuedDeferredQ4HAnswerState, DialogQueuedPromptState, DialogQueuedUserGenerationBoundaryState, DialogRunControlSpec, DialogRuntimePrompt, DialogRuntimeSideDialogPrompt, DialogUserPrompt, DriveIntent } from '@longrun-ai/kernel/types/drive-intent';
 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';
@@ -130,6 +130,7 @@ export declare function buildSideDialogAskerStack(args: {
     askerDialogId: string;
     assignment: AssignmentFromAsker;
 }): DialogAskerStackState;
+export declare function buildSideDialogAssignmentPromptMeta(sideDialog: SideDialog): Pick<DialogRuntimeSideDialogPrompt, 'tellaskReplyDirective' | 'calleeDialogReplyTarget'>;
 /**
  * Abstract base class for all dialog types.
  * Contains common properties and methods shared between MainDialog and SideDialog.
@@ -274,6 +275,8 @@ export declare abstract class Dialog {
     private processReminderCollection;
     private buildVisibleReminderContents;
     private emitFullRemindersUpdate;
+    private reportReminderRuntimeFailure;
+    private dispatchSharedReminderOwnerUpdateImpacts;
     /**
      * Emits current visible reminders without reconciling tool-owned state or writing persistence.
      * This is for read-only dialog display, especially completed/archived dialogs opened from old tabs.
@@ -370,6 +373,13 @@ export declare abstract class Dialog {
         tellaskReplyDirective: TellaskReplyDirective;
         skipTaskdoc?: boolean;
     }): Promise<DialogQueuedPromptState>;
+    queueRuntimeGuidePrompt(options: {
+        prompt: string;
+        msgId: string;
+        grammar: 'markdown';
+        userLanguageCode?: LanguageCode;
+        skipTaskdoc?: boolean;
+    }): Promise<DialogQueuedPromptState>;
     queueRuntimeSideDialogPrompt(options: {
         prompt: string;
         msgId: string;
@@ -528,9 +538,9 @@ export declare class MainDialog extends Dialog {
      */
     lookupDialog(selfId: string): Dialog | undefined;
     /**
-     * Get all registered dialogs in this dialog tree.
+     * Snapshot of dialogs loaded in this root's in-memory dialog tree.
      */
-    getAllDialogs(): Dialog[];
+    getLoadedDialogTreeSnapshot(): Dialog[];
     /**
      * Remove a dialog from the local registry.
      */

package/dist/dialog.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DialogStore = exports.MainDialog = exports.SideDialog = exports.Dialog = exports.DialogID = exports.InvalidReminderIndexError = void 0;
 exports.scheduleGlobalDialogMutexCleanupForRoot = scheduleGlobalDialogMutexCleanupForRoot;
 exports.buildSideDialogAskerStack = buildSideDialogAskerStack;
+exports.buildSideDialogAssignmentPromptMeta = buildSideDialogAssignmentPromptMeta;
 const id_1 = require("@longrun-ai/kernel/utils/id");
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const util_1 = require("util");
@@ -571,6 +572,7 @@ class Dialog {
     }
     async processReminderCollection(reminders) {
         let changed = false;
+        const updatedReminderIds = [];
         const indicesToRemove = [];
         for (let i = 0; i < reminders.length; i++) {
             const reminder = reminders[i];
@@ -598,26 +600,42 @@ class Dialog {
                             priority: reminder.priority,
                             renderMode: reminder.renderMode,
                         });
-                        const contentChanged = updatedReminder.content !== reminder.content;
-                        const metaChanged = updatedReminder.meta !== reminder.meta;
-                        if (contentChanged || metaChanged) {
+                        const reminderChanged = (0, tool_1.computeReminderRenderRevision)(updatedReminder) !==
+                            (0, tool_1.computeReminderRenderRevision)(reminder);
+                        if (reminderChanged) {
                             reminders[i] = updatedReminder;
                             changed = true;
+                            updatedReminderIds.push(updatedReminder.id);
                         }
                         break;
                     }
                     case 'keep':
                         break;
+                    default: {
+                        const _exhaustive = result.treatment;
+                        return _exhaustive;
+                    }
                 }
             }
             catch (error) {
-                log_1.log.error(`Error updating reminder from tool ${reminder.owner}:`, error);
+                const detail = `Reminder owner update failed ` +
+                    `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse}, ` +
+                    `reminderId=${reminder.id}, owner=${reminder.owner.name}, taskDocPath=${this.taskDocPath})`;
+                await this.reportReminderRuntimeFailure(detail, error, {
+                    rootId: this.id.rootId,
+                    selfId: this.id.selfId,
+                    course: this.currentCourse,
+                    reminderId: reminder.id,
+                    ownerName: reminder.owner.name,
+                    taskDocPath: this.taskDocPath,
+                });
+                throw error;
             }
         }
         for (let i = indicesToRemove.length - 1; i >= 0; i--) {
             reminders.splice(indicesToRemove[i], 1);
         }
-        return changed;
+        return { changed, updatedReminderIds };
     }
     buildVisibleReminderContents(taskSharedReminders, runtimeReminders) {
         const visibleReminders = [
@@ -643,6 +661,32 @@ class Dialog {
         };
         (0, evt_registry_1.postDialogEvent)(this, fullRemindersEvt);
     }
+    async reportReminderRuntimeFailure(detail, error, context) {
+        try {
+            await this.streamError(detail);
+        }
+        catch (streamError) {
+            log_1.log.warn('Failed to emit stream_error_evt for reminder runtime failure', streamError, {
+                ...context,
+                streamErrorMessage: streamError instanceof Error ? streamError.message : String(streamError),
+            });
+        }
+        log_1.log.error(detail, error, {
+            ...context,
+            errorMessage: error instanceof Error ? error.message : String(error),
+        });
+    }
+    async dispatchSharedReminderOwnerUpdateImpacts(reminderIds, scope) {
+        const { dispatchSharedReminderUpdateImpact } = await import('./runtime/shared-reminder-update-impact.js');
+        for (const reminderId of reminderIds) {
+            await dispatchSharedReminderUpdateImpact({
+                updater: this,
+                reminderId,
+                scope,
+                language: (0, work_language_1.getWorkLanguage)(),
+            });
+        }
+    }
     /**
      * Emits current visible reminders without reconciling tool-owned state or writing persistence.
      * This is for read-only dialog display, especially completed/archived dialogs opened from old tabs.
@@ -674,10 +718,10 @@ class Dialog {
         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 taskSharedChanged = await this.processReminderCollection(taskSharedReminders);
-        const runtimeChanged = await this.processReminderCollection(runtimeReminders);
-        if (localChanged || taskSharedChanged || runtimeChanged) {
+        const localResult = await this.processReminderCollection(this.reminders);
+        const taskSharedResult = await this.processReminderCollection(taskSharedReminders);
+        const runtimeResult = await this.processReminderCollection(runtimeReminders);
+        if (localResult.changed || taskSharedResult.changed || runtimeResult.changed) {
             this.touchReminders();
         }
         // Centralized persistence - called when emitting event.
@@ -686,26 +730,55 @@ class Dialog {
             await this.dlgStore.persistReminders(this, this.reminders);
         }
         catch (err) {
-            log_1.log.warn('Failed to persist reminders', err, { dialogId: this.id.valueOf() });
+            const detail = `Failed to persist dialog-local reminders ` +
+                `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse})`;
+            await this.reportReminderRuntimeFailure(detail, err, {
+                rootId: this.id.rootId,
+                selfId: this.id.selfId,
+                course: this.currentCourse,
+                taskDocPath: this.taskDocPath,
+            });
+            throw err;
         }
         try {
             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(),
+            const detail = `Failed to persist task-scoped reminders ` +
+                `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse}, ` +
+                `agentId=${this.agentId}, taskDocPath=${this.taskDocPath})`;
+            await this.reportReminderRuntimeFailure(detail, err, {
+                rootId: this.id.rootId,
+                selfId: this.id.selfId,
+                course: this.currentCourse,
                 agentId: this.agentId,
                 taskDocPath: this.taskDocPath,
             });
+            throw err;
         }
+        await this.dispatchSharedReminderOwnerUpdateImpacts(taskSharedResult.updatedReminderIds, 'task');
         try {
             await (0, shared_reminders_1.replaceSharedReminders)(runtimeTarget, runtimeReminders);
         }
         catch (err) {
-            log_1.log.warn('Failed to persist agent-scoped reminders', err, {
-                dialogId: this.id.valueOf(),
+            const detail = `Failed to persist agent-scoped reminders ` +
+                `(rootId=${this.id.rootId}, selfId=${this.id.selfId}, course=${this.currentCourse}, ` +
+                `agentId=${this.agentId})`;
+            await this.reportReminderRuntimeFailure(detail, err, {
+                rootId: this.id.rootId,
+                selfId: this.id.selfId,
+                course: this.currentCourse,
                 agentId: this.agentId,
+                taskDocPath: this.taskDocPath,
             });
+            throw err;
+        }
+        for (const reminderId of runtimeResult.updatedReminderIds) {
+            const reminder = runtimeReminders.find((candidate) => candidate.id === reminderId);
+            if (!reminder) {
+                throw new Error(`Updated shared reminder ${reminderId} disappeared before update impact dispatch`);
+            }
+            await this.dispatchSharedReminderOwnerUpdateImpacts([reminderId], reminder.scope === 'runtime' ? 'runtime' : 'agent');
         }
         const reminders = this.buildVisibleReminderContents(taskSharedReminders, runtimeReminders);
         this.emitFullRemindersUpdate(reminders);
@@ -1167,6 +1240,24 @@ class Dialog {
         });
         return created;
     }
+    async queueRuntimeGuidePrompt(options) {
+        const common = this.runtimePromptCommon(options);
+        const created = {
+            ...common,
+            kind: 'new_course_runtime_guide',
+            skipTaskdoc: options.skipTaskdoc,
+        };
+        this.enqueueQueuedPromptState(created);
+        await this.persistPendingRuntimePrompt({
+            content: created.prompt,
+            msgId: created.msgId,
+            grammar: created.grammar ?? 'markdown',
+            userLanguageCode: created.userLanguageCode,
+            origin: 'runtime',
+            skipTaskdoc: created.skipTaskdoc,
+        });
+        return created;
+    }
     async queueRuntimeSideDialogPrompt(options) {
         const common = this.runtimePromptCommon(options);
         const created = {
@@ -1859,7 +1950,7 @@ exports.SideDialog = SideDialog;
  */
 class MainDialog extends Dialog {
     _status = 'running';
-    // Tracks all dialogs in this dialog tree for O(1) lookup
+    // Tracks dialogs loaded into this root's in-memory dialog tree for O(1) lookup
     _localRegistry = new Map();
     // Tracks Type-B registered sideDialogs by agentId!sessionSlug
     _sideDialogRegistry = new Map();
@@ -1886,9 +1977,9 @@ class MainDialog extends Dialog {
         return this._localRegistry.get(selfId);
     }
     /**
-     * Get all registered dialogs in this dialog tree.
+     * Snapshot of dialogs loaded in this root's in-memory dialog tree.
      */
-    getAllDialogs() {
+    getLoadedDialogTreeSnapshot() {
         return Array.from(this._localRegistry.values());
     }
     /**

package/dist/docs/daemon-cmd-runner.md

@@ -115,6 +115,8 @@ Ownership boundaries are simple:
 - `pid: number`
 - `stdout?: boolean`
 - `stderr?: boolean`
+- `wait_for_new_output?: boolean`
+- `timeout_ms?: number`
 
 ### Semantics
 
@@ -123,6 +125,9 @@ Ownership boundaries are simple:
 - output order is always `stdout` first, then `stderr`
 - each stream gets its own heading, content block, and scroll notice
 - unrequested streams are omitted entirely
+- when `wait_for_new_output=true`, the runner waits until at least one requested stream receives output after the request is accepted
+- if `timeout_ms` is provided, the wait is bounded by that many milliseconds, capped at `86400000` (24h), and returns the current snapshot with an explicit timeout notice
+- `timeout_ms` cannot be combined with `wait_for_new_output=false`; that contradictory argument set returns an error
 
 ### Why this is better
 

package/dist/docs/daemon-cmd-runner.zh.md

@@ -114,6 +114,8 @@ runner 自己作为进程组 leader，daemon 默认继承该 pgid。这样 `stop
   - `pid: number`
   - `stdout?: boolean`
   - `stderr?: boolean`
+  - `wait_for_new_output?: boolean`
+  - `timeout_ms?: number`
 
 ### 语义
 
@@ -122,6 +124,9 @@ runner 自己作为进程组 leader，daemon 默认继承该 pgid。这样 `stop
 - 返回顺序固定为 `stdout` 在前、`stderr` 在后
 - 每个流各自带自己的标题、内容、scroll notice
 - 未请求的流不展示
+- `wait_for_new_output=true` 时，runner 会等到请求的流中至少一个在请求被接受后出现新输出再返回
+- 提供 `timeout_ms` 时，等待最多持续指定毫秒数，上限为 `86400000`（24 小时）；超时后返回当前快照，并显式提示等待超时
+- `timeout_ms` 不可与 `wait_for_new_output=false` 同时使用；这种矛盾参数会直接报错
 
 ### 取舍理由