dominds 1.9.1 → 1.9.3

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

@@ -149,6 +149,7 @@ TL;DR：
 有一类提醒项来自运行时环境（例如后台进程状态、MCP 租用/到期等）。它们更像信号灯：
 
 - 你应该阅读并据此调整行为
+- 默认应“静默吸收”这类状态信号；除非它实际改变当前判断/计划/风险，否则不要在回复里专门确认、复述或总结它
 - 但它们的生命周期通常由系统管理（自动更新/自动清理），不要把它们当成个人工作日志
 - 在消息语义上，这类提醒应视为**系统提示**：通常落在 `role=user` 侧，并带显眼头标（如 `【系统提示】`），避免与个人工作提醒混淆
 

package/dist/docs/txt-editing-tools.md

@@ -114,6 +114,7 @@ Chinese version: [中文版](./txt-editing-tools.zh.md)
 
 - 每个 plan hunk 带 TTL（输出 `expires_at_ms`）。
 - hunk 存储于进程内内存；进程重启后丢失。
+- prepare 结果在 apply 前不会落盘；此时再次读取文件仍只能看到旧内容。若想基于该结果继续下一笔修改，必须先 apply 当前 hunk，再重新 prepare。
 - `apply_file_modification` 会检查：
   - hunk 是否存在且未过期
   - hunk 是否由当前成员规划（`WRONG_OWNER` 拒绝）
@@ -278,6 +279,7 @@ This is the design doc for `ws_mod` text editing as implemented.
 - Function tool calls in one message run in parallel → **prepare → apply must be two messages**.
 - Applies are serialized per file in-process (queue by `createdAtMs`, then `hunkId`).
 - `hunk_id` is TTL-limited and in-memory; apply checks ownership and access.
+- Before apply, the prepared change is not persisted, so re-reading still returns the old file content; if you want the next edit based on that prepared result, apply the current hunk first, then prepare again.
 - `create_new_file` creates a new file (empty content allowed) and refuses to overwrite existing files (YAML-only output).
 - `overwrite_entire_file` is the exception full-file overwrite tool, guarded by `known_old_total_lines/known_old_total_bytes`, and it refuses diff/patch-like content by default unless `content_format='diff'|'patch'`.
 - Some providers (e.g. Codex) may require “all fields present” in function calls; for those providers only, use sentinels like empty strings / 0 to express “unset/default”. For most providers, omit optional fields naturally.

package/dist/docs/txt-editing-tools.zh.md

@@ -114,6 +114,7 @@ updated: 2026-01-24
 
 - 每个 plan hunk 带 TTL（输出 `expires_at_ms`）。
 - hunk 存储于进程内内存；进程重启后丢失。
+- prepare 结果在 apply 前不会落盘；此时再次读取文件仍只能看到旧内容。若想基于该结果继续下一笔修改，必须先 apply 当前 hunk，再重新 prepare。
 - `apply_file_modification` 会检查：
   - hunk 是否存在且未过期
   - hunk 是否由当前成员规划（`WRONG_OWNER` 拒绝）

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

@@ -1,3 +1,4 @@
+import { type CallerCourseNumber } from '@longrun-ai/kernel/types/storage';
 import { Dialog, DialogID, SubDialog } from '../../dialog';
 import type { KernelDriverDriveCallOptions, KernelDriverSubdialogReplyTarget } from './types';
 export type SubdialogReplyTarget = KernelDriverSubdialogReplyTarget;
@@ -13,6 +14,7 @@ export declare function supplyResponseToSupdialog(args: {
         course: number;
         genseq: number;
     };
+    callerCourseOverride?: CallerCourseNumber;
     scheduleDrive: ScheduleDriveFn;
     subdialog?: SubDialog;
 }): Promise<void>;

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

@@ -148,7 +148,7 @@ async function resolveLatestAssignmentAnchorRef(args) {
     return undefined;
 }
 async function supplyResponseToSupdialog(args) {
-    const { parentDialog, subdialogId, responseText, callType, callId, status = 'completed', calleeResponseRef, scheduleDrive, subdialog: maybeSubdialog, } = args;
+    const { parentDialog, subdialogId, responseText, callType, callId, status = 'completed', calleeResponseRef, callerCourseOverride, scheduleDrive, subdialog: maybeSubdialog, } = args;
     try {
         const result = await (0, subdialog_txn_1.withSubdialogTxnLock)(parentDialog.id, async () => {
             const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(parentDialog.id, parentDialog.status);
@@ -231,6 +231,9 @@ async function supplyResponseToSupdialog(args) {
                 sessionSlug,
                 callId: pendingRecord?.callId,
                 callingCourse: pendingRecord?.callingCourse,
+                callerCourse: pendingRecord?.callingCourse !== undefined
+                    ? (0, storage_1.toCallerCourseNumber)(pendingRecord.callingCourse)
+                    : callerCourseOverride,
                 shouldRevive,
             };
         });
@@ -271,6 +274,10 @@ async function supplyResponseToSupdialog(args) {
             })
             : undefined;
         if (resolvedCallId !== '' && calleeResponseRef) {
+            if (result.callerCourse === undefined) {
+                throw new Error(`tellask response anchor invariant violation: missing callerCourse ` +
+                    `(parentId=${parentDialog.id.selfId}, subdialogId=${subdialogId.selfId}, callId=${resolvedCallId})`);
+            }
             const assignmentRef = await resolveLatestAssignmentAnchorRef({
                 calleeDialogId: subdialogId,
                 callId: resolvedCallId,
@@ -308,9 +315,7 @@ async function supplyResponseToSupdialog(args) {
                     ? (0, storage_1.toAssignmentGenerationSeqNumber)(assignmentRef.genseq)
                     : undefined,
                 callerDialogId: parentDialog.id.selfId,
-                callerCourse: result.callingCourse !== undefined
-                    ? (0, storage_1.toCallerCourseNumber)(result.callingCourse)
-                    : undefined,
+                callerCourse: result.callerCourse,
             };
             await persistence_1.DialogPersistence.appendEvent(subdialogId, calleeResponseRef.course, anchorRecord, parentDialog.status);
         }

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

@@ -386,15 +386,13 @@ async function finishRegisteredTellaskReplacement(args) {
     const { ownerDialog, subdialog, pendingRecord, responseBody } = args;
     const language = (0, work_language_1.getWorkLanguage)();
     const requesterId = ownerDialog.agentId;
-    const response = (0, inter_dialog_format_1.formatTellaskResponseContent)({
-        callName: pendingRecord.callName,
+    const response = (0, inter_dialog_format_1.formatTellaskReplacementNoticeContent)({
         responderId: subdialog.agentId,
         requesterId,
         mentionList: pendingRecord.mentionList,
         sessionSlug: pendingRecord.sessionSlug,
         tellaskContent: pendingRecord.tellaskContent,
         responseBody,
-        status: 'failed',
         language,
     });
     const carryoverOriginCourse = pendingRecord.callingCourse;
@@ -800,6 +798,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     course: sub.currentCourse,
                     genseq: finalized.responseGenseq,
                 },
+                callerCourseOverride: callingCourse !== undefined ? (0, storage_1.toCallerCourseNumber)(callingCourse) : undefined,
                 scheduleDrive: callbacks.scheduleDrive,
             });
             sub.setFbrConclusionToolsEnabled(false);

package/dist/persistence.js

@@ -2260,22 +2260,37 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 break;
             }
             case 'tellask_call_anchor_record': {
-                const anchorEvent = {
-                    type: 'tellask_call_anchor_evt',
-                    course,
-                    genseq: event.genseq,
-                    anchorRole: event.anchorRole ?? 'response',
-                    callId: event.callId,
-                    assignmentCourse: event.assignmentCourse,
-                    assignmentGenseq: event.assignmentGenseq,
-                    callerDialogId: event.callerDialogId,
-                    callerCourse: event.callerCourse,
-                    dialog: {
-                        selfId: dialog.id.selfId,
-                        rootId: dialog.id.rootId,
-                    },
-                    timestamp: event.ts,
-                };
+                const anchorEvent = event.anchorRole === 'assignment'
+                    ? {
+                        type: 'tellask_call_anchor_evt',
+                        course,
+                        genseq: event.genseq,
+                        anchorRole: 'assignment',
+                        callId: event.callId,
+                        assignmentCourse: event.assignmentCourse,
+                        assignmentGenseq: event.assignmentGenseq,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    }
+                    : {
+                        type: 'tellask_call_anchor_evt',
+                        course,
+                        genseq: event.genseq,
+                        anchorRole: 'response',
+                        callId: event.callId,
+                        assignmentCourse: event.assignmentCourse,
+                        assignmentGenseq: event.assignmentGenseq,
+                        callerDialogId: event.callerDialogId,
+                        callerCourse: event.callerCourse,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    };
                 if (ws.readyState === 1) {
                     ws.send(JSON.stringify(anchorEvent));
                 }

package/dist/priming.js

@@ -746,27 +746,47 @@ function normalizePrimingRecordFromJson(raw) {
             if (callerDialogId !== undefined && typeof callerDialogId !== 'string') {
                 throw new Error(`${context}.callerDialogId must be a string when provided`);
             }
-            const record = {
+            const baseRecord = {
                 ts: '',
                 type,
                 ...(0, storage_1.toRootGenerationAnchor)({
                     rootCourse: expectIntegerField(raw, 'rootCourse', context),
                     rootGenseq: expectIntegerField(raw, 'rootGenseq', context),
                 }),
-                anchorRole,
                 callId: expectStringField(raw, 'callId', context),
                 genseq: expectIntegerField(raw, 'genseq', context),
+                ...(assignmentCourse !== undefined
+                    ? { assignmentCourse: (0, storage_1.toAssignmentCourseNumber)(assignmentCourse) }
+                    : {}),
+                ...(assignmentGenseq !== undefined
+                    ? { assignmentGenseq: (0, storage_1.toAssignmentGenerationSeqNumber)(assignmentGenseq) }
+                    : {}),
             };
-            if (assignmentCourse !== undefined) {
-                record.assignmentCourse = (0, storage_1.toAssignmentCourseNumber)(assignmentCourse);
-            }
-            if (assignmentGenseq !== undefined) {
-                record.assignmentGenseq = (0, storage_1.toAssignmentGenerationSeqNumber)(assignmentGenseq);
-            }
-            if (callerDialogId !== undefined)
-                record.callerDialogId = callerDialogId;
-            if (callerCourse !== undefined) {
-                record.callerCourse = (0, storage_1.toCallerCourseNumber)(callerCourse);
+            let record;
+            switch (anchorRole) {
+                case 'assignment':
+                    if (callerDialogId !== undefined || callerCourse !== undefined) {
+                        throw new Error(`${context} assignment anchor must not provide callerDialogId/callerCourse`);
+                    }
+                    record = {
+                        ...baseRecord,
+                        anchorRole: 'assignment',
+                    };
+                    break;
+                case 'response':
+                    if (typeof callerDialogId !== 'string' || callerDialogId.trim() === '') {
+                        throw new Error(`${context}.callerDialogId must be a non-empty string for response`);
+                    }
+                    if (callerCourse === undefined) {
+                        throw new Error(`${context}.callerCourse is required for response`);
+                    }
+                    record = {
+                        ...baseRecord,
+                        anchorRole: 'response',
+                        callerDialogId,
+                        callerCourse: (0, storage_1.toCallerCourseNumber)(callerCourse),
+                    };
+                    break;
             }
             if (sourceTag)
                 record.sourceTag = sourceTag;

package/dist/runtime/driver-messages.js

@@ -78,12 +78,12 @@ function formatRegisteredTellaskCallerUpdateNotice(language) {
     if (language === 'zh') {
         return [
             prefix,
-            '刚才那轮诉请先不用继续等待了；对方接下来会按你更新后的要求继续处理，请以后续要求为准。',
+            '刚才那轮诉请不用再等了；对方接下来会按你刚更新的要求继续处理，后续请以最新要求为准。',
         ].join('\n');
     }
     return [
         prefix,
-        'You no longer need to wait on that earlier request. The teammate will continue from your updated request, so follow the later request from here.',
+        'You no longer need to wait on that earlier request. The teammate will continue under your updated request, so treat the latest request as the one now in effect.',
     ].join('\n');
 }
 function formatRegisteredTellaskCalleeUpdateNotice(language) {
@@ -188,7 +188,7 @@ function formatReminderItemGuide(language, index, content, options) {
             return [
                 `提醒项 #${index}（工具状态）`,
                 '',
-                '我把这条当作工具维护的状态参考，不把它自动当成我现在必须立刻执行的指令。',
+                '我把这条当作工具维护的状态参考。默认不在对外回复里专门确认、复述或总结它；只有它实际改变当前判断、计划或风险时，我才提炼真正相关的部分。',
                 '',
                 `这条提醒项由工具 ${managementTool} 管理；如果我要调整它，就用 ${managementTool}（不要用 update_reminder）。`,
                 '',
@@ -232,7 +232,7 @@ function formatReminderItemGuide(language, index, content, options) {
         const updateExampleSafe = updateExample ?? `${managementTool}({ ... })`;
         return `REMINDER ITEM #${index} (TOOL STATE)
 
-I treat this as a tool-maintained state reference, not as an automatic must-do command.
+I treat this as a tool-maintained state reference. By default I should not explicitly acknowledge, restate, or summarize it in my outward reply; I should only extract the parts that materially change my current judgment, plan, or risk.
 
 This reminder is managed by tool ${managementTool}; if I need to change it, I should use ${managementTool} instead of update_reminder.
 

package/dist/runtime/inter-dialog-format.d.ts

@@ -48,6 +48,15 @@ export type TellaskResponseFormatInput = {
     status?: 'completed' | 'failed';
     language?: LanguageCode;
 };
+export type TellaskReplacementNoticeFormatInput = {
+    responderId: string;
+    requesterId: string;
+    mentionList?: string[];
+    sessionSlug?: string;
+    tellaskContent: string;
+    responseBody: string;
+    language?: LanguageCode;
+};
 export type TellaskCarryoverResultFormatInput = {
     originCourse: number;
     callName: 'tellask' | 'tellaskSessionless' | 'freshBootsReasoning';
@@ -70,4 +79,5 @@ export declare function formatAssignmentFromSupdialog(input: SubdialogAssignment
 export declare function formatUpdatedAssignmentFromSupdialog(input: SubdialogAssignmentFormatInput): string;
 export declare function formatSupdialogCallPrompt(input: SupdialogCallPromptInput): string;
 export declare function formatTellaskResponseContent(input: TellaskResponseFormatInput): string;
+export declare function formatTellaskReplacementNoticeContent(input: TellaskReplacementNoticeFormatInput): string;
 export declare function formatTellaskCarryoverResultContent(input: TellaskCarryoverResultFormatInput): string;

package/dist/runtime/inter-dialog-format.js

@@ -18,6 +18,7 @@ exports.formatAssignmentFromSupdialog = formatAssignmentFromSupdialog;
 exports.formatUpdatedAssignmentFromSupdialog = formatUpdatedAssignmentFromSupdialog;
 exports.formatSupdialogCallPrompt = formatSupdialogCallPrompt;
 exports.formatTellaskResponseContent = formatTellaskResponseContent;
+exports.formatTellaskReplacementNoticeContent = formatTellaskReplacementNoticeContent;
 exports.formatTellaskCarryoverResultContent = formatTellaskCarryoverResultContent;
 const driver_messages_1 = require("./driver-messages");
 const markdown_format_1 = require("./markdown-format");
@@ -219,6 +220,26 @@ function formatTellaskResponseContent(input) {
             : `regarding the original tellask: ${mentionLine} • ${sessionSlug}`;
     return `${markerPrefix}${hello}\n\n${(0, markdown_format_1.markdownQuote)(input.responseBody)}\n\n${tail}\n\n${(0, markdown_format_1.markdownQuote)(tellaskContent)}\n`;
 }
+function formatTellaskReplacementNoticeContent(input) {
+    const language = input.language ?? 'en';
+    const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');
+    const responseBody = requireNonEmpty(input.responseBody, 'responseBody');
+    const mentionIds = (input.mentionList ?? [])
+        .map((item) => stripMentionPrefix(item))
+        .filter((item) => item !== '');
+    const mentionLine = mentionIds.length === 0
+        ? `@${requireNonEmpty(input.requesterId, 'requesterId')}`
+        : mentionIds.map((mentionId) => `@${mentionId}`).join(' ');
+    const sessionSlug = input.sessionSlug?.trim() ?? '';
+    const tail = language === 'zh'
+        ? sessionSlug === ''
+            ? `对应原始诉请： ${mentionLine}`
+            : `对应原始诉请： ${mentionLine} • ${sessionSlug}`
+        : sessionSlug === ''
+            ? `applies to the original tellask: ${mentionLine}`
+            : `applies to the original tellask: ${mentionLine} • ${sessionSlug}`;
+    return `${responseBody}\n\n${tail}\n\n${(0, markdown_format_1.markdownQuote)(tellaskContent)}\n`;
+}
 function formatTellaskCarryoverResultContent(input) {
     const language = input.language ?? 'en';
     const tellaskContent = requireNonEmpty(input.tellaskContent, 'tellaskContent');