dominds 0.7.6 → 0.8.2

package/dist/llm/driver-v2/index.js

@@ -5,7 +5,9 @@ exports.driveDialogStream = driveDialogStream;
 exports.emitSayingEvents = emitSayingEvents;
 exports.supplyResponseToSupdialog = supplyResponseToSupdialog;
 exports.runBackendDriver = runBackendDriver;
+exports.restoreDialogHierarchy = restoreDialogHierarchy;
 const orchestrator_1 = require("./orchestrator");
+const restore_dialog_hierarchy_1 = require("./restore-dialog-hierarchy");
 exports.DRIVER_V2_IMPLEMENTATION_STATE = 'active';
 async function driveDialogStream(...args) {
     return await (0, orchestrator_1.driveDialogStream)(...args);
@@ -19,3 +21,6 @@ async function supplyResponseToSupdialog(...args) {
 function runBackendDriver() {
     return (0, orchestrator_1.runBackendDriver)();
 }
+async function restoreDialogHierarchy(...args) {
+    return await (0, restore_dialog_hierarchy_1.restoreDialogHierarchy)(...args);
+}

package/dist/llm/driver-v2/orchestrator.js

@@ -29,7 +29,7 @@ async function emitSayingEvents(...args) {
     return await (0, saying_events_1.emitSayingEvents)(dlg, content);
 }
 async function supplyResponseToSupdialog(...args) {
-    const [parentDialog, subdialogId, responseText, callType, callId, status] = args;
+    const [parentDialog, subdialogId, responseText, callType, callId, status, calleeResponseRef] = args;
     return await (0, supdialog_response_1.supplyResponseToSupdialogV2)({
         parentDialog,
         subdialogId,
@@ -37,6 +37,7 @@ async function supplyResponseToSupdialog(...args) {
         callType,
         callId,
         status,
+        calleeResponseRef,
         scheduleDrive: (dialog, options) => {
             void driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
         },
@@ -91,7 +92,7 @@ async function driveQueuedDialogsOnce() {
             const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(rootDialog.id.rootId);
             const lastTriggerAgeMs = lastTrigger !== undefined ? Math.max(0, Date.now() - lastTrigger.emittedAtMs) : undefined;
             if (status.subdialogs) {
-                log_1.log.info(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`, undefined, {
+                log_1.log.debug(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`, undefined, {
                     rootId: rootDialog.id.rootId,
                     waitingQ4H: status.q4h,
                     waitingSubdialogs: status.subdialogs,
@@ -111,7 +112,7 @@ async function driveQueuedDialogsOnce() {
                 });
             }
             if (status.q4h) {
-                log_1.log.info(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`, undefined, {
+                log_1.log.debug(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`, undefined, {
                     rootId: rootDialog.id.rootId,
                     waitingQ4H: status.q4h,
                     waitingSubdialogs: status.subdialogs,

package/dist/llm/driver-v2/policy.js

@@ -5,11 +5,10 @@ exports.validateDriverV2PolicyInvariants = validateDriverV2PolicyInvariants;
 exports.resolveDriverV2PolicyViolationKind = resolveDriverV2PolicyViolationKind;
 const dialog_1 = require("../../dialog");
 const system_prompt_parts_1 = require("../../minds/system-prompt-parts");
-function isFbrSelfTellaskHeadLine(tellaskHead) {
-    return /^\s*@self\b/.test(tellaskHead);
-}
 function isToollessFbrSelfSubdialog(dlg) {
-    return dlg instanceof dialog_1.SubDialog && isFbrSelfTellaskHeadLine(dlg.assignmentFromSup.tellaskHead);
+    if (!(dlg instanceof dialog_1.SubDialog))
+        return false;
+    return dlg.assignmentFromSup.callName === 'freshBootsReasoning';
 }
 function mergeModelParams(base, overlay) {
     if (!base && !overlay)
@@ -30,20 +29,20 @@ function buildFbrSystemPrompt(language) {
         ? [
             '# 扪心自问（FBR）支线对话',
             '',
-            '- 你正在处理一次由 `!?@self` 发起的 FBR 支线对话。',
-            '- 诉请正文是主要任务上下文；不要假设能访问诉请者对话历史。',
-            '- 若使用可恢复的 `!tellaskSession` 形式，你可以使用本支线对话自身的 `tellaskSession` 历史作为显式上下文。',
+            '- 你正在处理一次由 `freshBootsReasoning` 函数触发的 FBR 支线对话。',
+            '- 诉请正文是主要任务上下文；不要假设能访问上游对话历史。',
+            '- 若使用可恢复会话，你可以使用本支线对话自身的 tellaskSession 历史作为显式上下文。',
             '- 若诉请正文缺少关键上下文，请在输出中列出缺失信息与阻塞原因。',
-            '- 仅当必须澄清关键缺失上下文时，允许用 `!?@tellasker` 回问诉请者；除此之外不要发起任何诉请。',
+            '- 当前 FBR 为技术性禁函数工具模式：不得发起任何函数调用（包括 tellaskBack / tellask / tellaskSessionless / askHuman）。',
         ].join('\n')
         : [
             '# Fresh Boots Reasoning (FBR) sideline dialog',
             '',
-            '- This is an FBR sideline dialog created by `!?@self`.',
-            '- The tellask body is the primary task context; do not assume access to tellasker dialog history.',
-            '- If this is the resumable `!tellaskSession` form, you may use this sideline dialog’s own tellaskSession history as explicit context.',
+            '- This is an FBR sideline dialog triggered via the `freshBootsReasoning` function.',
+            '- The tellask body is the primary task context; do not assume access to upstream dialog history.',
+            '- If this is a resumable session, you may use this sideline dialog’s own tellaskSession history as explicit context.',
             '- If the tellask body is missing critical context, list what is missing and why it blocks reasoning.',
-            '- `!?@tellasker` is allowed only when you must clarify critical missing context; otherwise do not emit any tellasks.',
+            '- This FBR turn is in technical no-function mode: do not emit any function call (including tellaskBack / tellask / tellaskSessionless / askHuman).',
         ].join('\n');
     return prefix.trim();
 }
@@ -75,7 +74,7 @@ function buildDriverV2Policy(args) {
                 content: (0, system_prompt_parts_1.buildNoToolsNotice)(language),
             },
         ],
-        tellaskPolicy: 'tellasker_only',
+        tellaskPolicy: 'deny_all',
         allowFunctionCalls: false,
     };
 }
@@ -89,8 +88,8 @@ function validateDriverV2PolicyInvariants(policy, language) {
     if (policy.allowFunctionCalls) {
         return { ok: false, detail: 'FBR allowFunctionCalls must be false.' };
     }
-    if (policy.tellaskPolicy !== 'tellasker_only') {
-        return { ok: false, detail: 'FBR tellaskPolicy must be tellasker_only.' };
+    if (policy.tellaskPolicy !== 'deny_all') {
+        return { ok: false, detail: 'FBR tellaskPolicy must be deny_all.' };
     }
     const expectedNoToolsNotice = (0, system_prompt_parts_1.buildNoToolsNotice)(language);
     if (policy.prependedContextMessages.length !== 1) {
@@ -108,19 +107,14 @@ function validateDriverV2PolicyInvariants(policy, language) {
     }
     return { ok: true };
 }
-function hasTellaskPolicyViolation(policy, calls) {
+function hasTellaskPolicyViolation(policy, tellaskCallCount) {
     if (policy.tellaskPolicy === 'allow_any') {
         return false;
     }
-    return calls.some((call) => {
-        if (call.validation.kind !== 'valid') {
-            return true;
-        }
-        return call.validation.firstMention !== 'tellasker';
-    });
+    return tellaskCallCount > 0;
 }
 function resolveDriverV2PolicyViolationKind(args) {
-    const tellaskViolation = hasTellaskPolicyViolation(args.policy, args.tellaskCalls);
+    const tellaskViolation = hasTellaskPolicyViolation(args.policy, args.tellaskCallCount);
     const toolViolation = !args.policy.allowFunctionCalls && args.functionCallCount > 0;
     if (tellaskViolation && toolViolation) {
         return 'tellask_and_tool';

package/dist/llm/driver-v2/restore-dialog-hierarchy.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreDialogHierarchy = restoreDialogHierarchy;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dialog_1 = require("../../dialog");
+const dialog_global_registry_1 = require("../../dialog-global-registry");
+const dialog_instance_registry_1 = require("../../dialog-instance-registry");
+const log_1 = require("../../log");
+const persistence_1 = require("../../persistence");
+async function restoreDialogHierarchy(rootDialogId, status = 'running') {
+    try {
+        const rootDialogIdent = new dialog_1.DialogID(rootDialogId);
+        const rootMeta = await persistence_1.DialogPersistence.loadRootDialogMetadata(rootDialogIdent, status);
+        if (rootMeta?.supdialogId) {
+            throw new Error(`Expected root dialog ${rootDialogId} but found subdialog metadata with supdialogId: ${rootMeta.supdialogId}`);
+        }
+        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootDialogId, status);
+        if (!rootDialog) {
+            throw new Error(`Failed to restore dialog hierarchy for ${rootDialogId} from status ${status}`);
+        }
+        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+        const subdialogs = new Map();
+        const rootPath = persistence_1.DialogPersistence.getRootDialogPath(rootDialogIdent, status);
+        const subdialogsPath = path_1.default.join(rootPath, 'subdialogs');
+        let allSubdialogIds = [];
+        try {
+            const entries = await fs_1.default.promises.readdir(subdialogsPath, { withFileTypes: true });
+            allSubdialogIds = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        }
+        catch (err) {
+            const code = typeof err === 'object' && err !== null && 'code' in err
+                ? err.code
+                : undefined;
+            if (code !== 'ENOENT') {
+                log_1.log.warn(`Failed to read subdialogs directory: ${subdialogsPath}, returning empty array`, err);
+            }
+            allSubdialogIds = [];
+        }
+        for (const subdialogId of allSubdialogIds) {
+            const restoredSubdialogId = new dialog_1.DialogID(subdialogId, rootDialog.id.rootId);
+            const dialog = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, restoredSubdialogId, status);
+            if (dialog && dialog.id.selfId !== dialog.id.rootId) {
+                subdialogs.set(subdialogId, dialog);
+            }
+        }
+        let totalMessages = rootDialog.msgs.length;
+        let totalCourses = rootDialog.currentCourse;
+        for (const dialog of subdialogs.values()) {
+            totalMessages += dialog.msgs.length;
+            if (dialog.currentCourse > totalCourses) {
+                totalCourses = dialog.currentCourse;
+            }
+        }
+        const summary = {
+            totalMessages,
+            totalCourses,
+            completionStatus: 'incomplete',
+        };
+        return {
+            rootDialog,
+            subdialogs,
+            summary,
+        };
+    }
+    catch (error) {
+        log_1.log.error(`Failed to restore dialog hierarchy for ${rootDialogId}:`, error);
+        throw error;
+    }
+}

package/dist/llm/driver-v2/round.js

@@ -30,9 +30,11 @@ async function loadPendingDiagnosticsSnapshot(args) {
                 subdialogId: record.subdialogId,
                 callType: record.callType,
                 targetAgentId: record.targetAgentId,
-                tellaskSession: record.tellaskSession,
+                sessionSlug: record.sessionSlug,
                 createdAt: record.createdAt,
-                tellaskHeadSummary: record.tellaskHead.trim().slice(0, 160),
+                tellaskSummary: `${(record.mentionList ?? []).join(' ')} ${record.tellaskContent}`
+                    .trim()
+                    .slice(0, 160),
             })),
         };
     }
@@ -88,7 +90,7 @@ async function executeDriveRound(args) {
                 return;
             }
             if (latest && latest.runState && latest.runState.kind === 'proceeding_stop_requested') {
-                log_1.log.info('driver-v2 skip drive while stop request is still being processed', undefined, {
+                log_1.log.debug('driver-v2 skip drive while stop request is still being processed', undefined, {
                     dialogId: dialog.id.valueOf(),
                     reason: latest.runState.reason,
                 });
@@ -98,7 +100,7 @@ async function executeDriveRound(args) {
                 latest.runState &&
                 latest.runState.kind === 'interrupted' &&
                 !allowResumeFromInterrupted) {
-                log_1.log.info('driver-v2 skip drive for interrupted dialog without explicit resume/user prompt', undefined, {
+                log_1.log.debug('driver-v2 skip drive for interrupted dialog without explicit resume/user prompt', undefined, {
                     dialogId: dialog.id.valueOf(),
                     reason: latest.runState.reason,
                 });
@@ -118,7 +120,7 @@ async function executeDriveRound(args) {
             if (!suspension.canDrive) {
                 const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(dialog.id.rootId);
                 const lastTriggerAgeMs = lastTrigger !== undefined ? Math.max(0, Date.now() - lastTrigger.emittedAtMs) : undefined;
-                log_1.log.info('driver-v2 skip queued auto-drive while dialog is suspended', undefined, {
+                log_1.log.debug('driver-v2 skip queued auto-drive while dialog is suspended', undefined, {
                     dialogId: dialog.id.valueOf(),
                     rootId: dialog.id.rootId,
                     selfId: dialog.id.selfId,
@@ -227,11 +229,18 @@ async function executeDriveRound(args) {
         driveResult &&
         !driveResult.interrupted &&
         driveResult.lastAssistantSayingContent !== null) {
+        if (typeof driveResult.lastAssistantSayingGenseq !== 'number' ||
+            !Number.isFinite(driveResult.lastAssistantSayingGenseq) ||
+            driveResult.lastAssistantSayingGenseq <= 0) {
+            throw new Error(`Subdialog response supply invariant violation: missing lastAssistantSayingGenseq for dialog=${dialog.id.valueOf()}`);
+        }
+        const responseGenseq = Math.floor(driveResult.lastAssistantSayingGenseq);
         let supplied = false;
         if (subdialogReplyTarget) {
             supplied = await (0, supdialog_response_1.supplySubdialogResponseToSpecificCallerIfPendingV2)({
                 subdialog: dialog,
                 responseText: driveResult.lastAssistantSayingContent,
+                responseGenseq,
                 target: subdialogReplyTarget,
                 scheduleDrive: args.scheduleDrive,
             });
@@ -239,6 +248,7 @@ async function executeDriveRound(args) {
                 supplied = await (0, supdialog_response_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
                     subdialog: dialog,
                     responseText: driveResult.lastAssistantSayingContent,
+                    responseGenseq,
                     scheduleDrive: args.scheduleDrive,
                 });
             }
@@ -247,6 +257,7 @@ async function executeDriveRound(args) {
             supplied = await (0, supdialog_response_1.supplySubdialogResponseToAssignedCallerIfPendingV2)({
                 subdialog: dialog,
                 responseText: driveResult.lastAssistantSayingContent,
+                responseGenseq,
                 scheduleDrive: args.scheduleDrive,
             });
         }
@@ -267,7 +278,7 @@ async function executeDriveRound(args) {
                 await dialog.streamError(streamErr);
             }
             catch (streamErrPost) {
-                log_1.log.warn('driver-v2 failed to emit stream_error_evt for response supply violation', {
+                log_1.log.warn('driver-v2 failed to emit stream_error_evt for response supply violation', undefined, {
                     rootId: dialog.id.rootId,
                     selfId: dialog.id.selfId,
                     targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,
@@ -279,7 +290,7 @@ async function executeDriveRound(args) {
                     error: streamErrPost instanceof Error ? streamErrPost.message : String(streamErrPost),
                 });
             }
-            log_1.log.error('driver-v2 subdialog produced response but found no pending caller to supply', {
+            log_1.log.error('driver-v2 subdialog produced response but found no pending caller to supply', undefined, {
                 rootId: dialog.id.rootId,
                 selfId: dialog.id.selfId,
                 targetOwnerDialogId: subdialogReplyTarget.ownerDialogId,

package/dist/llm/driver-v2/runtime-utils.js

@@ -163,8 +163,7 @@ async function suspendForKeepGoingBudgetExhausted(options) {
     const language = dlg.getLastUserLanguageCode();
     const question = {
         id: questionId,
-        tellaskHead: '@human',
-        bodyContent: (0, driver_messages_1.formatQ4HDiligencePushBudgetExhausted)(language, { maxInjectCount }),
+        tellaskContent: (0, driver_messages_1.formatQ4HDiligencePushBudgetExhausted)(language, { maxInjectCount }),
         askedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
         callSiteRef: {
             course: dlg.currentCourse,
@@ -177,8 +176,7 @@ async function suspendForKeepGoingBudgetExhausted(options) {
         question: {
             id: question.id,
             selfId: dlg.id.selfId,
-            tellaskHead: question.tellaskHead,
-            bodyContent: question.bodyContent,
+            tellaskContent: question.tellaskContent,
             askedAt: question.askedAt,
             callId: question.callId,
             remainingCallIds: question.remainingCallIds,
@@ -349,7 +347,7 @@ async function runLlmRequestWithRetry(params) {
                     : `LLM failed: ${failure.message}`);
             }
             const backoffMs = Math.min(30000, 1000 * 2 ** attempt);
-            log_1.log.warn(`Retrying LLM request after retriable error`, {
+            log_1.log.warn(`Retrying LLM request after retriable error`, undefined, {
                 provider: params.provider,
                 attempt: attempt + 1,
                 backoffMs,

package/dist/llm/driver-v2/saying-events.js

@@ -1,43 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSayingEventsReceiver = createSayingEventsReceiver;
 exports.emitThinkingEvents = emitThinkingEvents;
 exports.emitSayingEvents = emitSayingEvents;
-const tellask_1 = require("../../tellask");
-function createSayingEventsReceiver(dlg) {
-    return {
-        markdownStart: async () => {
-            await dlg.markdownStart();
-        },
-        markdownChunk: async (chunk) => {
-            await dlg.markdownChunk(chunk);
-        },
-        markdownFinish: async () => {
-            await dlg.markdownFinish();
-        },
-        callStart: async (validation) => {
-            await dlg.callingStart(validation);
-        },
-        callHeadLineChunk: async (chunk) => {
-            await dlg.callingHeadlineChunk(chunk);
-        },
-        callHeadLineFinish: async () => {
-            await dlg.callingHeadlineFinish();
-        },
-        tellaskBodyStart: async () => {
-            await dlg.callingBodyStart();
-        },
-        tellaskBodyChunk: async (chunk) => {
-            await dlg.callingBodyChunk(chunk);
-        },
-        tellaskBodyFinish: async () => {
-            await dlg.callingBodyFinish();
-        },
-        callFinish: async (call) => {
-            await dlg.callingFinish(call.callId);
-        },
-    };
-}
 async function emitThinkingEvents(dlg, content) {
     if (!content.trim())
         return undefined;
@@ -49,10 +13,8 @@ async function emitThinkingEvents(dlg, content) {
 }
 async function emitSayingEvents(dlg, content) {
     if (!content.trim())
-        return [];
-    const receiver = createSayingEventsReceiver(dlg);
-    const parser = new tellask_1.TellaskStreamParser(receiver);
-    await parser.takeUpstreamChunk(content);
-    await parser.finalize();
-    return parser.getCollectedCalls();
+        return;
+    await dlg.markdownStart();
+    await dlg.markdownChunk(content);
+    await dlg.markdownFinish();
 }

package/dist/llm/driver-v2/supdialog-response.js

@@ -10,6 +10,7 @@ const log_1 = require("../../log");
 const persistence_1 = require("../../persistence");
 const runtime_language_1 = require("../../shared/runtime-language");
 const inter_dialog_format_1 = require("../../shared/utils/inter-dialog-format");
+const time_1 = require("../../shared/utils/time");
 const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
 const subdialog_txn_1 = require("./subdialog-txn");
 async function syncPendingTellaskReminderBestEffort(dlg, where) {
@@ -20,7 +21,7 @@ async function syncPendingTellaskReminderBestEffort(dlg, where) {
         await dlg.processReminderUpdates();
     }
     catch (err) {
-        log_1.log.warn('Failed to sync pending tellask reminder', {
+        log_1.log.warn('Failed to sync pending tellask reminder', undefined, {
             where,
             dialogId: dlg.id.selfId,
             rootId: dlg.id.rootId,
@@ -38,8 +39,44 @@ async function resolveOwnerDialogBySelfId(subdialog, ownerDialogId) {
         return existing;
     return await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, new dialog_1.DialogID(ownerDialogId, rootDialog.id.rootId), 'running');
 }
+async function resolveLatestAssignmentAnchorRef(args) {
+    const normalizedCallId = args.callId.trim();
+    if (normalizedCallId === '') {
+        return undefined;
+    }
+    const runningLatest = await persistence_1.DialogPersistence.loadDialogLatest(args.calleeDialogId, 'running');
+    const completedLatest = runningLatest
+        ? null
+        : await persistence_1.DialogPersistence.loadDialogLatest(args.calleeDialogId, 'completed');
+    const latest = runningLatest ?? completedLatest;
+    if (!latest) {
+        return undefined;
+    }
+    const status = runningLatest ? 'running' : 'completed';
+    const maxCourse = Math.floor(latest.currentCourse);
+    for (let course = maxCourse; course >= 1; course -= 1) {
+        const courseEvents = await persistence_1.DialogPersistence.loadCourseEvents(args.calleeDialogId, course, status);
+        for (let i = courseEvents.length - 1; i >= 0; i -= 1) {
+            const event = courseEvents[i];
+            if (event.type !== 'teammate_call_anchor_record') {
+                continue;
+            }
+            if (event.anchorRole !== 'assignment') {
+                continue;
+            }
+            if (event.callId.trim() !== normalizedCallId) {
+                continue;
+            }
+            if (!Number.isFinite(event.genseq) || event.genseq <= 0) {
+                continue;
+            }
+            return { course, genseq: Math.floor(event.genseq) };
+        }
+    }
+    return undefined;
+}
 async function supplyResponseToSupdialogV2(args) {
-    const { parentDialog, subdialogId, responseText, callType, callId, status = 'completed', scheduleDrive, } = args;
+    const { parentDialog, subdialogId, responseText, callType, callId, status = 'completed', calleeResponseRef, scheduleDrive, } = args;
     try {
         const result = await (0, subdialog_txn_1.withSubdialogTxnLock)(parentDialog.id, async () => {
             const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(parentDialog.id);
@@ -55,7 +92,9 @@ async function supplyResponseToSupdialogV2(args) {
             }
             let responderId = subdialogId.rootId;
             let responderAgentId;
-            let tellaskHead = responseText;
+            let callName = 'tellaskSessionless';
+            let mentionList;
+            let tellaskContent = responseText;
             let originMemberId;
             try {
                 let metadata = await persistence_1.DialogPersistence.loadDialogMetadata(subdialogId, 'running');
@@ -65,10 +104,9 @@ async function supplyResponseToSupdialogV2(args) {
                 if (metadata && metadata.assignmentFromSup) {
                     originMemberId = metadata.assignmentFromSup.originMemberId;
                     if (!pendingRecord) {
-                        const assignmentHead = metadata.assignmentFromSup.tellaskHead;
-                        if (typeof assignmentHead === 'string' && assignmentHead.trim() !== '') {
-                            tellaskHead = assignmentHead;
-                        }
+                        callName = metadata.assignmentFromSup.callName;
+                        mentionList = metadata.assignmentFromSup.mentionList;
+                        tellaskContent = metadata.assignmentFromSup.tellaskContent;
                     }
                 }
                 if (!pendingRecord && metadata && typeof metadata.agentId === 'string') {
@@ -79,7 +117,7 @@ async function supplyResponseToSupdialogV2(args) {
                 }
             }
             catch (err) {
-                log_1.log.warn('Failed to load subdialog metadata for response record', {
+                log_1.log.warn('Failed to load subdialog metadata for response record', undefined, {
                     parentId: parentDialog.id.selfId,
                     subdialogId: subdialogId.selfId,
                     error: err,
@@ -89,12 +127,15 @@ async function supplyResponseToSupdialogV2(args) {
                 originMemberId = parentDialog.agentId;
             }
             if (pendingRecord) {
+                callName = pendingRecord.callName;
                 responderId = pendingRecord.targetAgentId;
                 responderAgentId = pendingRecord.targetAgentId;
-                tellaskHead = pendingRecord.tellaskHead;
+                mentionList = pendingRecord.mentionList;
+                tellaskContent = pendingRecord.tellaskContent;
             }
-            if (tellaskHead.trim() === '') {
-                tellaskHead = responseText.slice(0, 100) + (responseText.length > 100 ? '...' : '');
+            if ((callName === 'tellask' || callName === 'tellaskSessionless') &&
+                (!Array.isArray(mentionList) || mentionList.length < 1)) {
+                mentionList = [`@${responderId}`];
             }
             await persistence_1.DialogPersistence.savePendingSubdialogs(parentDialog.id, filteredPending);
             const hasQ4H = await parentDialog.hasPendingQ4H();
@@ -105,17 +146,58 @@ async function supplyResponseToSupdialogV2(args) {
             return {
                 responderId,
                 responderAgentId,
-                tellaskHead,
+                callName,
+                mentionList,
+                tellaskContent,
                 originMemberId,
+                callId: pendingRecord?.callId,
+                callingCourse: pendingRecord &&
+                    typeof pendingRecord.callingCourse === 'number' &&
+                    Number.isFinite(pendingRecord.callingCourse) &&
+                    pendingRecord.callingCourse > 0
+                    ? Math.floor(pendingRecord.callingCourse)
+                    : undefined,
                 shouldRevive,
             };
         });
+        const normalizedCallId = typeof callId === 'string' ? callId.trim() : '';
+        const fallbackCallId = typeof result.callId === 'string' ? result.callId.trim() : '';
+        const resolvedCallId = normalizedCallId !== '' ? normalizedCallId : fallbackCallId;
+        if (resolvedCallId !== '' && calleeResponseRef) {
+            const assignmentRef = await resolveLatestAssignmentAnchorRef({
+                calleeDialogId: subdialogId,
+                callId: resolvedCallId,
+            });
+            if (!assignmentRef) {
+                log_1.log.error('Missing assignment anchor for teammate response anchor', undefined, {
+                    parentId: parentDialog.id.selfId,
+                    subdialogId: subdialogId.selfId,
+                    callId: resolvedCallId,
+                    responseCourse: calleeResponseRef.course,
+                    responseGenseq: calleeResponseRef.genseq,
+                });
+            }
+            const anchorRecord = {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'teammate_call_anchor_record',
+                anchorRole: 'response',
+                callId: resolvedCallId,
+                genseq: calleeResponseRef.genseq,
+                assignmentCourse: assignmentRef?.course,
+                assignmentGenseq: assignmentRef?.genseq,
+                callerDialogId: parentDialog.id.selfId,
+                callerCourse: result.callingCourse,
+            };
+            await persistence_1.DialogPersistence.appendEvent(subdialogId, calleeResponseRef.course, anchorRecord);
+        }
         await syncPendingTellaskReminderBestEffort(parentDialog, 'driver-v2:supplyResponseToSupdialog');
-        await parentDialog.receiveTeammateResponse(result.responderId, result.tellaskHead, status, subdialogId, {
+        await parentDialog.receiveTeammateResponse(result.responderId, result.callName, result.mentionList, result.tellaskContent, status, subdialogId, {
             response: responseText,
             agentId: result.responderAgentId ?? result.responderId,
-            callId: callId ?? '',
+            callId: resolvedCallId,
             originMemberId: result.originMemberId ?? parentDialog.agentId,
+            calleeCourse: calleeResponseRef?.course,
+            calleeGenseq: calleeResponseRef?.genseq,
         });
         // Keep in-memory dialog context in sync with live teammate-response events immediately.
         // v2 context assembly now relies on dialog msgs + persisted teammate_response_record only.
@@ -123,12 +205,16 @@ async function supplyResponseToSupdialogV2(args) {
             type: 'tellask_result_msg',
             role: 'tool',
             responderId: result.responderId,
-            tellaskHead: result.tellaskHead,
+            mentionList: result.mentionList,
+            tellaskContent: result.tellaskContent,
             status,
+            callId: resolvedCallId,
             content: (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                callName: result.callName,
                 responderId: result.responderId,
                 requesterId: result.originMemberId ?? parentDialog.agentId,
-                originalCallHeadLine: result.tellaskHead,
+                mentionList: result.mentionList,
+                tellaskContent: result.tellaskContent,
                 responseBody: responseText,
                 language: (0, runtime_language_1.getWorkLanguage)(),
             }),
@@ -139,7 +225,7 @@ async function supplyResponseToSupdialogV2(args) {
             const hasRegistryEntry = isRoot
                 ? dialog_global_registry_1.globalDialogRegistry.get(parentDialog.id.rootId) !== undefined
                 : false;
-            log_1.log.info(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} scheduling auto-revive`, undefined, {
+            log_1.log.debug(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} scheduling auto-revive`, undefined, {
                 rootId: parentDialog.id.rootId,
                 selfId: parentDialog.id.selfId,
                 via: isRoot && hasRegistryEntry ? 'backend_loop_trigger' : 'direct_schedule_drive',
@@ -164,16 +250,15 @@ async function supplyResponseToSupdialogV2(args) {
         }
     }
     catch (error) {
-        log_1.log.error('driver-v2 failed to supply subdialog response', {
+        log_1.log.error('driver-v2 failed to supply subdialog response', error, {
             parentId: parentDialog.id.selfId,
             subdialogId: subdialogId.selfId,
-            error,
         });
         throw error;
     }
 }
 async function supplySubdialogResponseToSpecificCallerIfPendingV2(args) {
-    const { subdialog, responseText, target, scheduleDrive } = args;
+    const { subdialog, responseText, responseGenseq, target, scheduleDrive } = args;
     const assignment = subdialog.assignmentFromSup;
     if (!assignment) {
         return false;
@@ -188,7 +273,7 @@ async function supplySubdialogResponseToSpecificCallerIfPendingV2(args) {
         return false;
     }
     if (pendingRecord.callType !== target.callType) {
-        log_1.log.warn('Reply target callType does not match pending callType; skipping stale reply target', {
+        log_1.log.warn('Reply target callType does not match pending callType; skipping stale reply target', undefined, {
             rootId: subdialog.rootDialog.id.rootId,
             subdialogId: subdialog.id.selfId,
             ownerDialogId: ownerDialog.id.selfId,
@@ -204,19 +289,20 @@ async function supplySubdialogResponseToSpecificCallerIfPendingV2(args) {
         callType: pendingRecord.callType,
         callId: target.callId,
         status: 'completed',
+        calleeResponseRef: { course: subdialog.currentCourse, genseq: responseGenseq },
         scheduleDrive,
     });
     return true;
 }
 async function supplySubdialogResponseToAssignedCallerIfPendingV2(args) {
-    const { subdialog, responseText, scheduleDrive } = args;
+    const { subdialog, responseText, responseGenseq, scheduleDrive } = args;
     const assignment = subdialog.assignmentFromSup;
     if (!assignment) {
         return false;
     }
     const callerDialog = await resolveOwnerDialogBySelfId(subdialog, assignment.callerDialogId);
     if (!callerDialog) {
-        log_1.log.warn('Missing caller dialog for subdialog response supply', {
+        log_1.log.warn('Missing caller dialog for subdialog response supply', undefined, {
             rootId: subdialog.rootDialog.id.rootId,
             subdialogId: subdialog.id.selfId,
             callerDialogId: assignment.callerDialogId,
@@ -235,6 +321,7 @@ async function supplySubdialogResponseToAssignedCallerIfPendingV2(args) {
         callType: pendingRecord.callType,
         callId: assignment.callId,
         status: 'completed',
+        calleeResponseRef: { course: subdialog.currentCourse, genseq: responseGenseq },
         scheduleDrive,
     });
     return true;