dominds 1.16.5 → 1.16.6

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

@@ -676,7 +676,7 @@ async function executeDriveRound(args) {
                     }
                     else {
                         await (0, tellask_special_1.deliverTellaskBackReplyFromDirective)({
-                            dlg: dialog,
+                            replyingDialog: dialog,
                             directive: activeTellaskReplyDirective,
                             replyContent: driveResult.lastAssistantSayingContent,
                             callbacks: {

package/dist/llm/kernel-driver/tellask-special.d.ts

@@ -67,7 +67,7 @@ export type InvalidTellaskFunctionCall = Readonly<{
 export declare function isTellaskCallFunctionName(name: string): name is TellaskCallFunctionName;
 export declare function loadLatestActiveTellaskReplyDirective(dialog: Dialog): Promise<TellaskReplyDirective | undefined>;
 export declare function deliverTellaskBackReplyFromDirective(args: {
-    dlg: Dialog;
+    replyingDialog: Dialog;
     directive: Extract<TellaskReplyDirective, {
         expectedReplyCallName: 'replyTellaskBack';
     }>;

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

@@ -136,39 +136,48 @@ function buildTellaskBackReplyDirective(args) {
     };
 }
 async function deliverTellaskBackReplyFromDirective(args) {
-    const rootDialog = args.dlg instanceof dialog_1.RootDialog
-        ? args.dlg
-        : args.dlg instanceof dialog_1.SubDialog
-            ? args.dlg.rootDialog
+    // Type-A ask-back is the one place where the local "caller/callee" intuition flips:
+    // the dialog running `replyTellaskBack` is the ask-back responder, while
+    // directive.targetDialogId points to the ask-back requester that must receive the canonical
+    // tellaskBack result. Keep those roles explicit, otherwise it is very easy to accidentally
+    // write the same business result once from the reply-tool path and then again from a fallback
+    // path that treats the responder's plain assistant words as if they were the canonical reply.
+    const rootDialog = args.replyingDialog instanceof dialog_1.RootDialog
+        ? args.replyingDialog
+        : args.replyingDialog instanceof dialog_1.SubDialog
+            ? args.replyingDialog.rootDialog
             : undefined;
     if (!rootDialog) {
         throw new Error('replyTellaskBack invariant violation: missing root dialog');
     }
-    const targetDialogId = new dialog_1.DialogID(args.directive.targetDialogId, rootDialog.id.rootId);
-    const targetDialog = rootDialog.lookupDialog(targetDialogId.selfId) ??
-        (await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, targetDialogId, rootDialog.status));
-    if (!targetDialog) {
-        throw new Error(`replyTellaskBack invariant violation: target dialog ${targetDialogId.selfId} not found`);
+    const askBackRequesterDialogId = new dialog_1.DialogID(args.directive.targetDialogId, rootDialog.id.rootId);
+    const askBackRequesterDialog = rootDialog.lookupDialog(askBackRequesterDialogId.selfId) ??
+        (await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, askBackRequesterDialogId, rootDialog.status));
+    if (!askBackRequesterDialog) {
+        throw new Error(`replyTellaskBack invariant violation: target dialog ${askBackRequesterDialogId.selfId} not found`);
     }
-    targetDialog.setSuspensionState('resumed');
     const response = (0, inter_dialog_format_1.formatTellaskResponseContent)({
         callName: 'tellaskBack',
-        responderId: args.dlg.agentId,
-        requesterId: targetDialog.agentId,
+        responderId: args.replyingDialog.agentId,
+        requesterId: askBackRequesterDialog.agentId,
         tellaskContent: args.directive.tellaskContent,
         responseBody: args.replyContent,
         status: 'completed',
         deliveryMode: args.deliveryMode,
         language: (0, work_language_1.getWorkLanguage)(),
     });
-    const replyMirror = await targetDialog.receiveTellaskResponse(args.dlg.agentId, 'tellaskBack', undefined, args.directive.tellaskContent, 'completed', args.dlg.id, {
+    const replyMirror = await askBackRequesterDialog.receiveTellaskResponse(args.replyingDialog.agentId, 'tellaskBack', undefined, args.directive.tellaskContent, 'completed', args.replyingDialog.id, {
         response,
-        agentId: args.dlg.agentId,
+        agentId: args.replyingDialog.agentId,
         callId: args.directive.targetCallId,
-        originMemberId: targetDialog.agentId,
+        originMemberId: askBackRequesterDialog.agentId,
     });
-    await targetDialog.addChatMessages(replyMirror);
-    await reviveDialogIfUnblocked(targetDialog, args.callbacks, 'reply_tellask_back_delivered');
+    await askBackRequesterDialog.addChatMessages(replyMirror);
+    // Do not mark the requester resumed until the canonical tellaskBack result has actually been
+    // persisted and mirrored locally. Otherwise a write failure here would leave suspension state
+    // claiming "resumed" while the business fact never landed.
+    askBackRequesterDialog.setSuspensionState('resumed');
+    await reviveDialogIfUnblocked(askBackRequesterDialog, args.callbacks, 'reply_tellask_back_delivered');
 }
 function isReplyTellaskCallRecord(record) {
     return isReplyTellaskCallName(record.name);
@@ -883,9 +892,29 @@ function extractLastAssistantResponse(messages, defaultMessage) {
     }
     return responseText;
 }
-async function extractSupdialogResponseForTypeA(supdialog) {
+function findDeliveredTellaskBackReplyOnAskBackRequester(args) {
+    // `replyTellaskBack` persists the canonical tellaskBack business result onto the ask-back
+    // requester dialog immediately. Type-A orchestration must check that canonical delivery first
+    // before it even considers any fallback extraction from responder plaintext, or we risk a
+    // second final result with the same target callId.
+    for (let i = args.requesterDialog.msgs.length - 1; i >= 0; i -= 1) {
+        const msg = args.requesterDialog.msgs[i];
+        if (msg.type !== 'tellask_result_msg' || msg.callName !== 'tellaskBack') {
+            continue;
+        }
+        if (msg.callId !== args.targetCallId) {
+            continue;
+        }
+        return msg;
+    }
+    return undefined;
+}
+async function extractAskBackResponderPlaintextFallback(args) {
+    // This fallback is intentionally second-class: it exists only for legacy/plain-reply flows
+    // where no explicit `replyTellaskBack` canonical result has been delivered. It must never
+    // compete with or overwrite an already delivered canonical tellaskBack result.
     try {
-        return extractLastAssistantResponse(supdialog.msgs, 'Supdialog completed without producing output.');
+        return extractLastAssistantResponse(args.responderDialog.msgs, 'Supdialog completed without producing output.');
     }
     catch (err) {
         log_1.log.warn('Failed to extract supdialog response for Type A', err);
@@ -1158,14 +1187,20 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
         }
         if (parseResult.type === 'A') {
             if (dlg instanceof dialog_1.SubDialog) {
-                const supdialog = dlg.supdialog;
-                dlg.setSuspensionState('suspended');
+                // Identity map for Type-A ask-back:
+                // - `askBackRequesterDialog` is the sideline dialog that asked upstream for clarification.
+                // - `askBackResponderDialog` is the upstream dialog that must answer that ask-back.
+                // The original tellask relationship is the opposite of the current ask-back relationship,
+                // so variable names like "supdialog" or "target" are too lossy here and invite bugs.
+                const askBackRequesterDialog = dlg;
+                const askBackResponderDialog = dlg.supdialog;
+                askBackRequesterDialog.setSuspensionState('suspended');
                 try {
-                    const assignment = dlg.assignmentFromSup;
+                    const assignment = askBackRequesterDialog.assignmentFromSup;
                     const supPrompt = {
                         content: (0, inter_dialog_format_1.formatSupdialogCallPrompt)({
-                            fromAgentId: dlg.agentId,
-                            toAgentId: supdialog.agentId,
+                            fromAgentId: askBackRequesterDialog.agentId,
+                            toAgentId: askBackResponderDialog.agentId,
                             subdialogRequest: {
                                 callName,
                                 mentionList,
@@ -1182,12 +1217,12 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         grammar: 'markdown',
                         origin: 'runtime',
                         tellaskReplyDirective: buildTellaskBackReplyDirective({
-                            targetDialogId: dlg.id.selfId,
+                            targetDialogId: askBackRequesterDialog.id.selfId,
                             targetCallId: callId,
                             tellaskContent: body,
                         }),
                     };
-                    await callbacks.driveDialog(supdialog, {
+                    await callbacks.driveDialog(askBackResponderDialog, {
                         humanPrompt: supPrompt,
                         waitInQue: true,
                         driveOptions: {
@@ -1195,20 +1230,34 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                             reason: 'type_a_supdialog_roundtrip',
                         },
                     });
-                    const responseText = await extractSupdialogResponseForTypeA(supdialog);
+                    const explicitReplyDelivery = findDeliveredTellaskBackReplyOnAskBackRequester({
+                        requesterDialog: askBackRequesterDialog,
+                        targetCallId: callId,
+                    });
+                    if (explicitReplyDelivery) {
+                        // Important invariant: once the responder used `replyTellaskBack`, that write is the
+                        // single source of truth. Do not also synthesize another tellask result from the
+                        // responder's generic assistant words, even if those words look "compatible".
+                        askBackRequesterDialog.setSuspensionState('resumed');
+                        toolOutputs.push(explicitReplyDelivery);
+                        return toolOutputs;
+                    }
+                    const responseText = await extractAskBackResponderPlaintextFallback({
+                        responderDialog: askBackResponderDialog,
+                    });
                     const responseContent = (0, inter_dialog_format_1.formatTellaskResponseContent)({
                         callName,
                         responderId: parseResult.agentId,
-                        requesterId: dlg.agentId,
+                        requesterId: askBackRequesterDialog.agentId,
                         mentionList,
                         tellaskContent: body,
                         responseBody: responseText,
                         status: 'completed',
                         language: (0, work_language_1.getWorkLanguage)(),
                     });
-                    dlg.setSuspensionState('resumed');
+                    askBackRequesterDialog.setSuspensionState('resumed');
                     toolOutputs.push(buildTellaskResultToolOutput({
-                        genseq: dlg.activeGenSeqOrUndefined ?? 1,
+                        genseq: askBackRequesterDialog.activeGenSeqOrUndefined ?? 1,
                         callId,
                         callName,
                         content: responseContent,
@@ -1217,24 +1266,24 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         tellaskContent: body,
                         mentionList,
                         agentId: parseResult.agentId,
-                        originMemberId: dlg.agentId,
-                        calleeDialogId: supdialog.id.selfId,
+                        originMemberId: askBackRequesterDialog.agentId,
+                        calleeDialogId: askBackResponderDialog.id.selfId,
                     }));
-                    await dlg.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'completed', supdialog.id, {
+                    await askBackRequesterDialog.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'completed', askBackResponderDialog.id, {
                         response: responseContent,
                         agentId: parseResult.agentId,
                         callId,
-                        originMemberId: dlg.agentId,
+                        originMemberId: askBackRequesterDialog.agentId,
                     });
                 }
                 catch (err) {
                     log_1.log.warn('Type A supdialog processing error:', err);
-                    dlg.setSuspensionState('resumed');
+                    askBackRequesterDialog.setSuspensionState('resumed');
                     const errorText = `❌ **Error processing request to @${parseResult.agentId}:**\n\n${showErrorToAi(err)}`;
                     const errorContent = (0, inter_dialog_format_1.formatTellaskResponseContent)({
                         callName,
                         responderId: parseResult.agentId,
-                        requesterId: dlg.agentId,
+                        requesterId: askBackRequesterDialog.agentId,
                         mentionList,
                         tellaskContent: body,
                         responseBody: errorText,
@@ -1242,7 +1291,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         language: (0, work_language_1.getWorkLanguage)(),
                     });
                     toolOutputs.push(buildTellaskResultToolOutput({
-                        genseq: dlg.activeGenSeqOrUndefined ?? 1,
+                        genseq: askBackRequesterDialog.activeGenSeqOrUndefined ?? 1,
                         callId,
                         callName,
                         content: errorContent,
@@ -1251,14 +1300,14 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         tellaskContent: body,
                         mentionList,
                         agentId: parseResult.agentId,
-                        originMemberId: dlg.agentId,
-                        calleeDialogId: supdialog.id.selfId,
+                        originMemberId: askBackRequesterDialog.agentId,
+                        calleeDialogId: askBackResponderDialog.id.selfId,
                     }));
-                    await dlg.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'failed', supdialog.id, {
+                    await askBackRequesterDialog.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'failed', askBackResponderDialog.id, {
                         response: errorContent,
                         agentId: parseResult.agentId,
                         callId,
-                        originMemberId: dlg.agentId,
+                        originMemberId: askBackRequesterDialog.agentId,
                     });
                 }
             }
@@ -1779,7 +1828,7 @@ async function executeReplyTellaskCall(args) {
                 throw new Error('replyTellaskBack invariant violation: unexpected active reply directive');
             }
             await deliverTellaskBackReplyFromDirective({
-                dlg: args.dlg,
+                replyingDialog: args.dlg,
                 directive: activeDirective,
                 replyContent: args.call.replyContent,
                 callbacks: args.callbacks,

package/dist/persistence.d.ts

@@ -72,6 +72,9 @@ export declare class DiskFileDialogStore extends DialogStore {
      * Ensure subdialog directory exists (delegate to DialogPersistence)
      */
     private ensureSubdialogDirectory;
+    private findExistingFuncResultRecord;
+    private findExistingTellaskResultRecord;
+    private raiseDuplicateCallResultInvariantViolation;
     /**
      * Append event to course JSONL file (delegate to DialogPersistence)
      */

package/dist/persistence.js

@@ -1433,6 +1433,19 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         if (!Number.isFinite(genseq) || genseq <= 0) {
             throw new Error(`receiveFuncResult invariant violation: missing valid genseq for func result ${funcResult.id}`);
         }
+        const existingFuncResult = await this.findExistingFuncResultRecord(dialog, funcResult.id);
+        if (existingFuncResult) {
+            await this.raiseDuplicateCallResultInvariantViolation({
+                dialog,
+                kind: 'func_result',
+                callId: funcResult.id,
+                callName: funcResult.name,
+                incomingCourse: course,
+                incomingGenseq: genseq,
+                existingCourse: existingFuncResult.course,
+                existingGenseq: existingFuncResult.record.genseq,
+            });
+        }
         const funcResultRecord = buildFuncResultRecord(funcResult, genseq);
         await this.appendEvent(dialog, course, funcResultRecord);
         // Send event to frontend
@@ -1464,6 +1477,19 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 ...result,
                 genseq,
             };
+        const existingTellaskResult = await this.findExistingTellaskResultRecord(dialog, normalizedResult.callId);
+        if (existingTellaskResult) {
+            await this.raiseDuplicateCallResultInvariantViolation({
+                dialog,
+                kind: 'tellask_result',
+                callId: normalizedResult.callId,
+                callName: normalizedResult.callName,
+                incomingCourse: course,
+                incomingGenseq: genseq,
+                existingCourse: existingTellaskResult.course,
+                existingGenseq: existingTellaskResult.record.genseq,
+            });
+        }
         const record = buildTellaskResultRecord(normalizedResult, genseq);
         await this.appendEvent(dialog, course, record);
         (0, evt_registry_1.postDialogEvent)(dialog, buildTellaskResultEvent(normalizedResult, course));
@@ -1489,6 +1515,74 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     async ensureSubdialogDirectory(dialogId) {
         return await DialogPersistence.ensureSubdialogDirectory(dialogId);
     }
+    async findExistingFuncResultRecord(dialog, callId) {
+        const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
+        const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
+        for (let course = 1; course <= maxCourse; course += 1) {
+            const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
+            for (const event of events) {
+                if (event.type !== 'func_result_record') {
+                    continue;
+                }
+                if (event.id !== callId) {
+                    continue;
+                }
+                return { course, record: event };
+            }
+        }
+        return undefined;
+    }
+    async findExistingTellaskResultRecord(dialog, callId) {
+        const latest = await DialogPersistence.loadDialogLatest(dialog.id, dialog.status);
+        const maxCourse = latest?.currentCourse ?? dialog.currentCourse;
+        for (let course = 1; course <= maxCourse; course += 1) {
+            const events = await DialogPersistence.loadCourseEvents(dialog.id, course, dialog.status);
+            for (const event of events) {
+                if (event.type !== 'tellask_result_record') {
+                    continue;
+                }
+                if (event.callId !== callId) {
+                    continue;
+                }
+                return { course, record: event };
+            }
+        }
+        return undefined;
+    }
+    async raiseDuplicateCallResultInvariantViolation(args) {
+        // Duplicate final results are not harmless transcript noise. They mean two different program
+        // paths both believed they owned the same business-level completion fact for one callId.
+        // In ask-back flows this usually points to identity confusion between requester/responder or
+        // canonical reply-tool delivery versus fallback plaintext synthesis. We fail fast here so the
+        // second writer keeps its own stack trace instead of silently corrupting the dialog transcript.
+        const err = new Error(`${args.kind} duplicate callId invariant violation: rootId=${args.dialog.id.rootId} selfId=${args.dialog.id.selfId} ` +
+            `callId=${args.callId} callName=${args.callName} existingCourse=${args.existingCourse} ` +
+            `existingGenseq=${args.existingGenseq} incomingCourse=${args.incomingCourse} incomingGenseq=${args.incomingGenseq}`);
+        log_1.log.error('Duplicate call result detected; rejecting second write', err, {
+            rootId: args.dialog.id.rootId,
+            selfId: args.dialog.id.selfId,
+            callId: args.callId,
+            callName: args.callName,
+            kind: args.kind,
+            existingCourse: args.existingCourse,
+            existingGenseq: args.existingGenseq,
+            incomingCourse: args.incomingCourse,
+            incomingGenseq: args.incomingGenseq,
+        });
+        try {
+            await this.streamError(args.dialog, err.message);
+        }
+        catch (streamErr) {
+            log_1.log.warn('Failed to emit stream_error_evt for duplicate call result', streamErr, {
+                rootId: args.dialog.id.rootId,
+                selfId: args.dialog.id.selfId,
+                callId: args.callId,
+                callName: args.callName,
+                kind: args.kind,
+            });
+        }
+        throw err;
+    }
     /**
      * Append event to course JSONL file (delegate to DialogPersistence)
      */
@@ -1953,7 +2047,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     async streamError(dialog, error) {
         log_1.log.error(`Dialog stream error '${error}'`, new Error(), { dialog });
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const genseq = typeof dialog.activeGenSeq === 'number' ? dialog.activeGenSeq : undefined;
+        const genseq = dialog.activeGenSeqOrUndefined;
         // Enhanced stream error event with better error classification
         const streamErrorEvent = {
             type: 'stream_error_evt',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.16.5",
+  "version": "1.16.6",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -52,8 +52,8 @@
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@longrun-ai/shell": "1.8.13",
     "@longrun-ai/kernel": "1.8.13",
+    "@longrun-ai/shell": "1.8.13",
     "@longrun-ai/codex-auth": "0.12.0"
   },
   "devDependencies": {