dominds 1.13.2 → 1.15.2

package/dist/persistence.js

@@ -51,9 +51,81 @@ const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
 const async_fifo_mutex_1 = require("./runtime/async-fifo-mutex");
 const reply_prompt_copy_1 = require("./runtime/reply-prompt-copy");
-const work_language_1 = require("./runtime/work-language");
 const tool_1 = require("./tool");
 const registry_1 = require("./tools/registry");
+function isTellaskBusinessCallName(value) {
+    return (value === 'tellask' ||
+        value === 'tellaskSessionless' ||
+        value === 'tellaskBack' ||
+        value === 'askHuman' ||
+        value === 'freshBootsReasoning');
+}
+function isSuppressedTellaskPlaceholderFuncResult(args) {
+    if (!isTellaskBusinessCallName(args.name)) {
+        return false;
+    }
+    const raw = args.content.trim();
+    if (raw === '') {
+        return false;
+    }
+    if (raw === 'Q4H 已结束等待状态，请参考 askHuman 结果气泡。' ||
+        raw === 'Q4H wait is resolved; refer to the askHuman result bubble.') {
+        return true;
+    }
+    if (raw.startsWith('Q4H 仍在等待人类回复，已持续 ') ||
+        raw.startsWith('Q4H is still waiting for human reply (elapsed ')) {
+        return true;
+    }
+    if (raw.startsWith('支线对话仍在进行中，已持续 ') ||
+        raw.startsWith('Sideline dialog is still running (elapsed ')) {
+        return true;
+    }
+    return false;
+}
+function buildTellaskResultRoute(route, fallback) {
+    const effective = route ?? fallback;
+    if (!effective)
+        return undefined;
+    return {
+        ...(effective.calleeDialogId ? { calleeDialogId: effective.calleeDialogId } : {}),
+        ...(typeof effective.calleeCourse === 'number'
+            ? { calleeCourse: (0, storage_1.toCalleeCourseNumber)(effective.calleeCourse) }
+            : {}),
+        ...(typeof effective.calleeGenseq === 'number'
+            ? { calleeGenseq: (0, storage_1.toCalleeGenerationSeqNumber)(effective.calleeGenseq) }
+            : {}),
+    };
+}
+function requireNonEmptyTrimmedString(value, field, context) {
+    if (typeof value !== 'string') {
+        throw new Error(`${context} invariant violation: missing ${field}`);
+    }
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        throw new Error(`${context} invariant violation: empty ${field}`);
+    }
+    return trimmed;
+}
+function requireTellaskResultResponderId(result, context) {
+    return requireNonEmptyTrimmedString(result.responder?.responderId ?? result.responderId, 'responderId', `${context} (callId=${result.callId}, callName=${result.callName})`);
+}
+function requireTellaskResultContent(result, context) {
+    return requireNonEmptyTrimmedString(result.call?.tellaskContent ?? result.tellaskContent, 'tellaskContent', `${context} (callId=${result.callId}, callName=${result.callName})`);
+}
+function resolveTellaskResultMentionList(result, context) {
+    const mentionList = result.call?.mentionList ?? result.mentionList;
+    if (mentionList === undefined) {
+        return [];
+    }
+    if (!Array.isArray(mentionList) || mentionList.some((item) => typeof item !== 'string')) {
+        throw new Error(`${context} invariant violation: invalid mentionList ` +
+            `(callId=${result.callId}, callName=${result.callName})`);
+    }
+    return [...mentionList];
+}
+function requireTellaskResultSessionSlug(result, context) {
+    return requireNonEmptyTrimmedString(result.call?.sessionSlug ?? result.sessionSlug, 'sessionSlug', `${context} (callId=${result.callId}, callName=${result.callName})`);
+}
 function getErrorCode(error) {
     if (typeof error !== 'object' || error === null)
         return undefined;
@@ -93,114 +165,315 @@ function cloneRootGenerationAnchor(anchor) {
         rootGenseq: anchor.rootGenseq,
     };
 }
-function formatCrashRecoveredFuncResultContent(toolName) {
-    if ((0, work_language_1.getWorkLanguage)() === 'zh') {
-        return (`Function '${toolName}' execution failed: ` +
-            'Dominds 在该工具调用发出后发生了进程意外退出，原调用未能产出结果。' +
-            '这是启动恢复阶段自动补记的失败结果，请基于当前上下文判断是否需要重试。');
-    }
-    return (`Function '${toolName}' execution failed: ` +
-        'Dominds exited unexpectedly after this tool call was persisted, so no tool result was produced. ' +
-        'This failure record was added automatically during startup recovery; decide whether to retry.');
-}
-function readPersistedTellaskStringArg(arguments_, field, callName, callId) {
-    const value = arguments_[field];
-    if (typeof value !== 'string' || value.trim() === '') {
-        throw new Error(`tellask special persistence invariant violation: missing ${field} for ${callName} (callId=${callId})`);
-    }
-    return value;
+function buildFuncCallRecord(args) {
+    return {
+        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        type: 'func_call_record',
+        genseq: args.genseq,
+        id: args.id,
+        name: args.name,
+        rawArgumentsText: args.rawArgumentsText,
+    };
 }
-function readPersistedTellaskOptionalNumberArg(arguments_, field, callName, callId) {
-    const value = arguments_[field];
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        throw new Error(`tellask special persistence invariant violation: invalid ${field} for ${callName} (callId=${callId})`);
-    }
-    return value;
+function buildFuncResultRecord(funcResult, genseq) {
+    return {
+        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        type: 'func_result_record',
+        id: funcResult.id,
+        name: funcResult.name,
+        content: funcResult.content,
+        contentItems: funcResult.contentItems,
+        genseq,
+    };
 }
-function buildTellaskSpecialCallRecord(args) {
-    const base = {
+function buildTellaskCallRecord(args) {
+    return {
         ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-        type: 'tellask_special_call_record',
+        type: 'tellask_call_record',
         genseq: args.genseq,
         id: args.id,
+        name: args.name,
+        rawArgumentsText: args.rawArgumentsText,
+        deliveryMode: args.deliveryMode,
     };
-    switch (args.name) {
-        case 'tellaskBack':
-            return {
-                ...base,
-                name: args.name,
-                tellaskContent: readPersistedTellaskStringArg(args.arguments_, 'tellaskContent', args.name, args.id),
-            };
+}
+function buildTellaskResultRecord(result, genseq) {
+    if (!isTellaskBusinessCallName(result.callName)) {
+        throw new Error(`buildTellaskResultRecord invariant violation: ${result.callName} is not a tellask business result`);
+    }
+    const responderId = requireTellaskResultResponderId(result, 'buildTellaskResultRecord');
+    const tellaskContent = requireTellaskResultContent(result, 'buildTellaskResultRecord');
+    const route = buildTellaskResultRoute(result.route, {
+        calleeDialogId: result.calleeDialogId,
+        calleeCourse: result.calleeCourse,
+        calleeGenseq: result.calleeGenseq,
+    });
+    const base = {
+        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        type: 'tellask_result_record',
+        genseq,
+        callId: result.callId,
+        status: result.status,
+        content: result.content,
+        ...(typeof result.calling_genseq === 'number'
+            ? { calling_genseq: (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq) }
+            : {}),
+        responder: {
+            responderId,
+            ...((result.responder?.agentId ?? result.agentId)
+                ? { agentId: result.responder?.agentId ?? result.agentId }
+                : {}),
+            ...((result.responder?.originMemberId ?? result.originMemberId)
+                ? { originMemberId: result.responder?.originMemberId ?? result.originMemberId }
+                : {}),
+        },
+        ...(route ? { route } : {}),
+    };
+    switch (result.callName) {
         case 'tellask':
             return {
                 ...base,
-                name: args.name,
-                targetAgentId: readPersistedTellaskStringArg(args.arguments_, 'targetAgentId', args.name, args.id),
-                sessionSlug: readPersistedTellaskStringArg(args.arguments_, 'sessionSlug', args.name, args.id),
-                tellaskContent: readPersistedTellaskStringArg(args.arguments_, 'tellaskContent', args.name, args.id),
+                callName: result.callName,
+                call: {
+                    tellaskContent,
+                    mentionList: resolveTellaskResultMentionList(result, 'buildTellaskResultRecord'),
+                    sessionSlug: requireTellaskResultSessionSlug(result, 'buildTellaskResultRecord'),
+                },
             };
         case 'tellaskSessionless':
             return {
                 ...base,
-                name: args.name,
-                targetAgentId: readPersistedTellaskStringArg(args.arguments_, 'targetAgentId', args.name, args.id),
-                tellaskContent: readPersistedTellaskStringArg(args.arguments_, 'tellaskContent', args.name, args.id),
-            };
-        case 'replyTellask':
-        case 'replyTellaskSessionless':
-        case 'replyTellaskBack':
-            return {
-                ...base,
-                name: args.name,
-                replyContent: readPersistedTellaskStringArg(args.arguments_, 'replyContent', args.name, args.id),
+                callName: result.callName,
+                call: {
+                    tellaskContent,
+                    mentionList: resolveTellaskResultMentionList(result, 'buildTellaskResultRecord'),
+                },
             };
+        case 'tellaskBack':
         case 'askHuman':
+        case 'freshBootsReasoning':
             return {
                 ...base,
-                name: args.name,
-                tellaskContent: readPersistedTellaskStringArg(args.arguments_, 'tellaskContent', args.name, args.id),
-            };
-        case 'freshBootsReasoning': {
-            const effort = readPersistedTellaskOptionalNumberArg(args.arguments_, 'effort', args.name, args.id);
-            return {
-                ...base,
-                name: args.name,
-                tellaskContent: readPersistedTellaskStringArg(args.arguments_, 'tellaskContent', args.name, args.id),
-                ...(effort !== undefined ? { effort } : {}),
+                callName: result.callName,
+                call: {
+                    tellaskContent,
+                },
             };
-        }
     }
 }
-function formatTellaskSpecialCallArguments(record) {
-    switch (record.name) {
-        case 'tellaskBack':
-            return JSON.stringify({ tellaskContent: record.tellaskContent });
-        case 'tellask':
-            return JSON.stringify({
-                targetAgentId: record.targetAgentId,
-                sessionSlug: record.sessionSlug,
-                tellaskContent: record.tellaskContent,
-            });
-        case 'tellaskSessionless':
-            return JSON.stringify({
-                targetAgentId: record.targetAgentId,
-                tellaskContent: record.tellaskContent,
-            });
-        case 'replyTellask':
-        case 'replyTellaskSessionless':
-        case 'replyTellaskBack':
-            return JSON.stringify({ replyContent: record.replyContent });
-        case 'askHuman':
-            return JSON.stringify({ tellaskContent: record.tellaskContent });
-        case 'freshBootsReasoning':
-            return JSON.stringify({
-                tellaskContent: record.tellaskContent,
-                ...(record.effort !== undefined ? { effort: record.effort } : {}),
-            });
+function buildTellaskCarryoverRecord(result, genseq) {
+    return {
+        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        type: 'tellask_carryover_record',
+        genseq,
+        originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+        carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
+        responderId: result.responderId,
+        callName: result.callName,
+        tellaskContent: result.tellaskContent,
+        status: result.status,
+        response: result.response,
+        content: result.content,
+        agentId: result.agentId,
+        callId: result.callId,
+        originMemberId: result.originMemberId,
+        ...(result.callName === 'tellask'
+            ? {
+                sessionSlug: result.sessionSlug,
+                mentionList: result.mentionList,
+            }
+            : result.callName === 'tellaskSessionless'
+                ? {
+                    mentionList: result.mentionList,
+                }
+                : {}),
+        ...(result.calleeDialogId ? { calleeDialogId: result.calleeDialogId } : {}),
+        ...(typeof result.calleeCourse === 'number' ? { calleeCourse: result.calleeCourse } : {}),
+        ...(typeof result.calleeGenseq === 'number' ? { calleeGenseq: result.calleeGenseq } : {}),
+    };
+}
+function buildTellaskResultEvent(result, course) {
+    if (!isTellaskBusinessCallName(result.callName)) {
+        throw new Error(`buildTellaskResultEvent invariant violation: ${result.callName} is not a tellask business result`);
+    }
+    const responderId = requireTellaskResultResponderId(result, 'buildTellaskResultEvent');
+    const tellaskContent = requireTellaskResultContent(result, 'buildTellaskResultEvent');
+    const route = buildTellaskResultRoute(result.route, {
+        calleeDialogId: result.calleeDialogId,
+        calleeCourse: result.calleeCourse,
+        calleeGenseq: result.calleeGenseq,
+    });
+    if (result.callName === 'tellask') {
+        const effectiveSessionSlug = requireTellaskResultSessionSlug(result, 'buildTellaskResultEvent');
+        return {
+            type: 'tellask_result_evt',
+            course,
+            genseq: result.genseq,
+            calling_genseq: typeof result.calling_genseq === 'number'
+                ? (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq)
+                : undefined,
+            callId: result.callId,
+            callName: result.callName,
+            status: result.status,
+            content: result.content,
+            call: {
+                tellaskContent,
+                mentionList: resolveTellaskResultMentionList(result, 'buildTellaskResultEvent'),
+                sessionSlug: effectiveSessionSlug,
+            },
+            responder: {
+                responderId,
+                ...((result.responder?.agentId ?? result.agentId)
+                    ? { agentId: result.responder?.agentId ?? result.agentId }
+                    : {}),
+                ...((result.responder?.originMemberId ?? result.originMemberId)
+                    ? { originMemberId: result.responder?.originMemberId ?? result.originMemberId }
+                    : {}),
+            },
+            ...(route ? { route } : {}),
+        };
+    }
+    if (result.callName === 'tellaskSessionless') {
+        return {
+            type: 'tellask_result_evt',
+            course,
+            genseq: result.genseq,
+            calling_genseq: typeof result.calling_genseq === 'number'
+                ? (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq)
+                : undefined,
+            callId: result.callId,
+            callName: result.callName,
+            status: result.status,
+            content: result.content,
+            call: {
+                tellaskContent,
+                mentionList: resolveTellaskResultMentionList(result, 'buildTellaskResultEvent'),
+            },
+            responder: {
+                responderId,
+                ...((result.responder?.agentId ?? result.agentId)
+                    ? { agentId: result.responder?.agentId ?? result.agentId }
+                    : {}),
+                ...((result.responder?.originMemberId ?? result.originMemberId)
+                    ? { originMemberId: result.responder?.originMemberId ?? result.originMemberId }
+                    : {}),
+            },
+            ...(route ? { route } : {}),
+        };
+    }
+    return {
+        type: 'tellask_result_evt',
+        course,
+        genseq: result.genseq,
+        calling_genseq: typeof result.calling_genseq === 'number'
+            ? (0, storage_1.toCallingGenerationSeqNumber)(result.calling_genseq)
+            : undefined,
+        callId: result.callId,
+        callName: result.callName,
+        status: result.status,
+        content: result.content,
+        call: {
+            tellaskContent,
+        },
+        responder: {
+            responderId,
+            ...((result.responder?.agentId ?? result.agentId)
+                ? { agentId: result.responder?.agentId ?? result.agentId }
+                : {}),
+            ...((result.responder?.originMemberId ?? result.originMemberId)
+                ? { originMemberId: result.responder?.originMemberId ?? result.originMemberId }
+                : {}),
+        },
+        ...(route ? { route } : {}),
+    };
+}
+function buildTellaskCarryoverEvent(result, course) {
+    if (result.callName === 'tellask') {
+        const sessionSlug = result.sessionSlug?.trim();
+        if (!sessionSlug) {
+            throw new Error(`buildTellaskCarryoverEvent invariant violation: missing sessionSlug for tellask call ${result.callId}`);
+        }
+        return {
+            type: 'tellask_carryover_evt',
+            course,
+            genseq: result.genseq,
+            originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+            carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
+            responderId: result.responderId,
+            callName: result.callName,
+            sessionSlug,
+            mentionList: result.mentionList ?? [],
+            tellaskContent: result.tellaskContent,
+            status: result.status,
+            response: result.response,
+            content: result.content,
+            agentId: result.agentId,
+            callId: result.callId,
+            originMemberId: result.originMemberId,
+            ...(result.calleeDialogId ? { calleeDialogId: result.calleeDialogId } : {}),
+            ...(typeof result.calleeCourse === 'number'
+                ? { calleeCourse: (0, storage_1.toCalleeCourseNumber)(result.calleeCourse) }
+                : {}),
+            ...(typeof result.calleeGenseq === 'number'
+                ? { calleeGenseq: (0, storage_1.toCalleeGenerationSeqNumber)(result.calleeGenseq) }
+                : {}),
+        };
+    }
+    if (result.callName === 'tellaskSessionless') {
+        return {
+            type: 'tellask_carryover_evt',
+            course,
+            genseq: result.genseq,
+            originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+            carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
+            responderId: result.responderId,
+            callName: result.callName,
+            mentionList: result.mentionList ?? [],
+            tellaskContent: result.tellaskContent,
+            status: result.status,
+            response: result.response,
+            content: result.content,
+            agentId: result.agentId,
+            callId: result.callId,
+            originMemberId: result.originMemberId,
+            ...(result.calleeDialogId ? { calleeDialogId: result.calleeDialogId } : {}),
+            ...(typeof result.calleeCourse === 'number'
+                ? { calleeCourse: (0, storage_1.toCalleeCourseNumber)(result.calleeCourse) }
+                : {}),
+            ...(typeof result.calleeGenseq === 'number'
+                ? { calleeGenseq: (0, storage_1.toCalleeGenerationSeqNumber)(result.calleeGenseq) }
+                : {}),
+        };
     }
+    return {
+        type: 'tellask_carryover_evt',
+        course,
+        genseq: result.genseq,
+        originCourse: (0, storage_1.toCallingCourseNumber)(result.originCourse),
+        carryoverCourse: (0, storage_1.toDialogCourseNumber)(result.carryoverCourse),
+        responderId: result.responderId,
+        callName: result.callName,
+        tellaskContent: result.tellaskContent,
+        status: result.status,
+        response: result.response,
+        content: result.content,
+        agentId: result.agentId,
+        callId: result.callId,
+        originMemberId: result.originMemberId,
+        ...(result.calleeDialogId ? { calleeDialogId: result.calleeDialogId } : {}),
+        ...(typeof result.calleeCourse === 'number'
+            ? { calleeCourse: (0, storage_1.toCalleeCourseNumber)(result.calleeCourse) }
+            : {}),
+        ...(typeof result.calleeGenseq === 'number'
+            ? { calleeGenseq: (0, storage_1.toCalleeGenerationSeqNumber)(result.calleeGenseq) }
+            : {}),
+    };
+}
+function formatTellaskCallArguments(record) {
+    return record.rawArgumentsText;
+}
+function isReplyTellaskCallRecordName(name) {
+    return (name === 'replyTellask' || name === 'replyTellaskSessionless' || name === 'replyTellaskBack');
 }
 function resolveRootGenerationAnchor(dialog) {
     const rootDialog = dialog instanceof dialog_1.SubDialog ? dialog.rootDialog : dialog;
@@ -643,41 +916,92 @@ function isSubdialogResponseRecord(value) {
 }
 // Remove old type definitions - now using kernel/types/storage.ts
 const id_1 = require("./utils/id");
-function parseReplayTellaskSpecialCall(record) {
+function parseReplayTellaskCall(record) {
+    if (record.deliveryMode !== 'tellask_call_start') {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(record.rawArgumentsText);
+    }
+    catch (error) {
+        throw new Error(`persisted tellask rawArgumentsText is not valid JSON for replay (callId=${record.id}, name=${record.name}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`persisted tellask rawArgumentsText must decode to an object for replay (callId=${record.id}, name=${record.name})`);
+    }
+    const args = parsed;
     switch (record.name) {
-        case 'tellaskBack':
+        case 'tellaskBack': {
+            const tellaskContent = args['tellaskContent'];
+            if (typeof tellaskContent !== 'string' || tellaskContent.trim() === '') {
+                throw new Error(`persisted tellaskBack missing tellaskContent (callId=${record.id})`);
+            }
             return {
                 callName: 'tellaskBack',
-                tellaskContent: record.tellaskContent,
+                tellaskContent,
                 callId: record.id,
             };
-        case 'askHuman':
+        }
+        case 'askHuman': {
+            const tellaskContent = args['tellaskContent'];
+            if (typeof tellaskContent !== 'string' || tellaskContent.trim() === '') {
+                throw new Error(`persisted askHuman missing tellaskContent (callId=${record.id})`);
+            }
             return {
                 callName: 'askHuman',
-                tellaskContent: record.tellaskContent,
+                tellaskContent,
                 callId: record.id,
             };
-        case 'freshBootsReasoning':
+        }
+        case 'freshBootsReasoning': {
+            const tellaskContent = args['tellaskContent'];
+            if (typeof tellaskContent !== 'string' || tellaskContent.trim() === '') {
+                throw new Error(`persisted freshBootsReasoning missing tellaskContent (callId=${record.id})`);
+            }
             return {
                 callName: 'freshBootsReasoning',
-                tellaskContent: record.tellaskContent,
+                tellaskContent,
                 callId: record.id,
             };
-        case 'tellask':
+        }
+        case 'tellask': {
+            const targetAgentId = args['targetAgentId'];
+            const sessionSlug = args['sessionSlug'];
+            const tellaskContent = args['tellaskContent'];
+            if (typeof targetAgentId !== 'string' || targetAgentId.trim() === '') {
+                throw new Error(`persisted tellask missing targetAgentId (callId=${record.id})`);
+            }
+            if (typeof sessionSlug !== 'string' || sessionSlug.trim() === '') {
+                throw new Error(`persisted tellask missing sessionSlug (callId=${record.id})`);
+            }
+            if (typeof tellaskContent !== 'string' || tellaskContent.trim() === '') {
+                throw new Error(`persisted tellask missing tellaskContent (callId=${record.id})`);
+            }
             return {
                 callName: 'tellask',
-                mentionList: [`@${record.targetAgentId}`],
-                sessionSlug: record.sessionSlug,
-                tellaskContent: record.tellaskContent,
+                mentionList: [`@${targetAgentId}`],
+                sessionSlug,
+                tellaskContent,
                 callId: record.id,
             };
-        case 'tellaskSessionless':
+        }
+        case 'tellaskSessionless': {
+            const targetAgentId = args['targetAgentId'];
+            const tellaskContent = args['tellaskContent'];
+            if (typeof targetAgentId !== 'string' || targetAgentId.trim() === '') {
+                throw new Error(`persisted tellaskSessionless missing targetAgentId (callId=${record.id})`);
+            }
+            if (typeof tellaskContent !== 'string' || tellaskContent.trim() === '') {
+                throw new Error(`persisted tellaskSessionless missing tellaskContent (callId=${record.id})`);
+            }
             return {
                 callName: 'tellaskSessionless',
-                mentionList: [`@${record.targetAgentId}`],
-                tellaskContent: record.tellaskContent,
+                mentionList: [`@${targetAgentId}`],
+                tellaskContent,
                 callId: record.id,
             };
+        }
         case 'replyTellask':
         case 'replyTellaskSessionless':
         case 'replyTellaskBack':
@@ -686,6 +1010,16 @@ function parseReplayTellaskSpecialCall(record) {
             return null;
     }
 }
+function isTellaskCallFunctionName(name) {
+    return (name === 'tellaskBack' ||
+        name === 'tellask' ||
+        name === 'tellaskSessionless' ||
+        name === 'replyTellask' ||
+        name === 'replyTellaskSessionless' ||
+        name === 'replyTellaskBack' ||
+        name === 'askHuman' ||
+        name === 'freshBootsReasoning');
+}
 /**
  * Uses append-only pattern for events, exceptional overwrite for reminders
  */
@@ -844,455 +1178,54 @@ 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}`);
         }
-        // Persist function result record
-        const funcResultRecord = {
-            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            type: 'func_result_record',
-            id: funcResult.id,
-            name: funcResult.name,
-            content: funcResult.content,
-            contentItems: funcResult.contentItems,
-            genseq,
-        };
+        const funcResultRecord = buildFuncResultRecord(funcResult, genseq);
         await this.appendEvent(dialog, course, funcResultRecord);
         // Send event to frontend
-        const funcResultEvt = {
-            type: 'func_result_evt',
-            id: funcResult.id,
+        if (!isSuppressedTellaskPlaceholderFuncResult({
             name: funcResult.name,
             content: funcResult.content,
-            contentItems: funcResult.contentItems,
-            course,
-        };
-        (0, evt_registry_1.postDialogEvent)(dialog, funcResultEvt);
+        })) {
+            const funcResultEvt = {
+                type: 'func_result_evt',
+                id: funcResult.id,
+                name: funcResult.name,
+                content: funcResult.content,
+                contentItems: funcResult.contentItems,
+                course,
+            };
+            (0, evt_registry_1.postDialogEvent)(dialog, funcResultEvt);
+        }
     }
-    /**
-     * Receive and handle tellask call results with callId for inline result display
-     *
-     * Call Types:
-     * - tellask-special function call (inline bubble)
-     *   - Result displays INLINE in the same bubble
-     *   - Uses callId for correlation between call_start and response
-     *   - Uses receiveTellaskCallResult() + callId parameter
-     *
-     * - Tellask sideline response (subdialog response bubble)
-     *   - Result displays in SEPARATE bubble (subdialog response)
-     *   - Uses calleeDialogId for correlation
-     *   - Uses receiveTellaskResponse() instead
-     *
-     * @param dialog - The dialog receiving the response
-     * @param responderId - ID of the tool/agent that responded (e.g., "add_reminder")
-     * @param mentionList - Mention list of the original call
-     * @param tellaskContent - Tellask content of the original call
-     * @param result - The result content to display
-     * @param status - Response status ('completed' | 'failed')
-     * @param callId - Correlation ID from call_start_evt (REQUIRED for inline display)
-     */
-    async receiveTellaskCallResult(dialog, responderId, callName, mentionList, tellaskContent, result, status, callId) {
+    async receiveTellaskResult(dialog, result) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const calling_genseq = dialog.activeGenSeqOrUndefined !== undefined
-            ? (0, storage_1.toCallingGenerationSeqNumber)(dialog.activeGenSeqOrUndefined)
-            : undefined;
-        // Persist record WITH callId for replay correlation
-        const ev = (() => {
-            switch (callName) {
-                case 'tellask':
-                case 'tellaskSessionless':
-                    return {
-                        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        type: 'tellask_call_result_record',
-                        responderId,
-                        callName,
-                        mentionList: mentionList ?? [],
-                        tellaskContent,
-                        status,
-                        result,
-                        calling_genseq,
-                        callId,
-                    };
-                case 'tellaskBack':
-                case 'askHuman':
-                case 'freshBootsReasoning':
-                    return {
-                        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        type: 'tellask_call_result_record',
-                        responderId,
-                        callName,
-                        tellaskContent,
-                        status,
-                        result,
-                        calling_genseq,
-                        callId,
-                    };
-            }
-        })();
-        await this.appendEvent(dialog, course, ev);
-        // Emit TellaskCallResultEvent WITH callId for UI correlation
-        const toolResponseEvt = (() => {
-            switch (callName) {
-                case 'tellask':
-                case 'tellaskSessionless':
-                    return {
-                        type: 'tellask_call_result_evt',
-                        responderId,
-                        callName,
-                        mentionList: mentionList ?? [],
-                        tellaskContent,
-                        status,
-                        result,
-                        course,
-                        calling_genseq,
-                        callId,
-                    };
-                case 'tellaskBack':
-                case 'askHuman':
-                case 'freshBootsReasoning':
-                    return {
-                        type: 'tellask_call_result_evt',
-                        responderId,
-                        callName,
-                        tellaskContent,
-                        status,
-                        result,
-                        course,
-                        calling_genseq,
-                        callId,
-                    };
-            }
-        })();
-        (0, evt_registry_1.postDialogEvent)(dialog, toolResponseEvt);
-    }
-    /**
-     * Receive and handle tellask responses (separate bubble for subdialog/supdialog replies)
-     *
-     * Call Types:
-     * - Tellask sideline response
-     *   - Result displays in SEPARATE bubble (subdialog or supdialog response)
-     *   - Uses calleeDialogId for correlation (not callId)
-     *   - Uses this method (receiveTellaskResponse)
-     *
-     * @param dialog - The dialog receiving the response
-     * @param responderId - ID of the responder agent (e.g., "coder")
-     * @param mentionList - Mention list of the original tellask
-     * @param tellaskContent - Tellask content of the original tellask
-     * @param status - Response status ('completed' | 'failed')
-     * @param calleeDialogId - ID of the callee dialog (subdialog OR supdialog) for navigation links
-     */
-    async receiveTellaskResponse(dialog, responderId, callName, mentionList, tellaskContent, status, calleeDialogId, options) {
-        const currentCourse = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const calling_genseq = dialog.activeGenSeqOrUndefined !== undefined
-            ? (0, storage_1.toCallingGenerationSeqNumber)(dialog.activeGenSeqOrUndefined)
-            : undefined;
-        const calleeDialogSelfId = calleeDialogId ? calleeDialogId.selfId : undefined;
-        const response = options.response;
-        const agentId = options.agentId;
-        const callId = options.callId;
-        const originMemberId = options.originMemberId;
-        const originCourse = options.originCourse;
-        const carryoverContent = options.carryoverContent;
-        const carryoverText = typeof carryoverContent === 'string' && carryoverContent.trim() !== ''
-            ? carryoverContent
-            : undefined;
-        const sessionSlug = typeof options.sessionSlug === 'string' && options.sessionSlug.trim() !== ''
-            ? options.sessionSlug.trim()
-            : undefined;
-        const calleeCourse = options.calleeCourse;
-        const calleeGenseq = options.calleeGenseq;
-        const normalizedMentionList = mentionList ?? [];
-        const isCrossCourseCarryover = originCourse !== undefined && originCourse !== currentCourse;
-        if (!isCrossCourseCarryover) {
-            const responseCourse = originCourse ?? currentCourse;
-            const ev = (() => {
-                switch (callName) {
-                    case 'tellask':
-                        if (!sessionSlug) {
-                            throw new Error(`receiveTellaskResponse invariant violation: missing sessionSlug for tellask ` +
-                                `(dialogId=${dialog.id.selfId}, callId=${callId})`);
-                        }
-                        return {
-                            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                            type: 'tellask_response_record',
-                            responderId,
-                            callName,
-                            sessionSlug,
-                            calleeDialogId: calleeDialogSelfId,
-                            calleeCourse,
-                            calleeGenseq,
-                            mentionList: normalizedMentionList,
-                            tellaskContent,
-                            status,
-                            calling_genseq,
-                            response,
-                            agentId,
-                            callId,
-                            originMemberId,
-                        };
-                    case 'tellaskSessionless':
-                        return {
-                            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                            type: 'tellask_response_record',
-                            responderId,
-                            callName,
-                            calleeDialogId: calleeDialogSelfId,
-                            calleeCourse,
-                            calleeGenseq,
-                            mentionList: normalizedMentionList,
-                            tellaskContent,
-                            status,
-                            calling_genseq,
-                            response,
-                            agentId,
-                            callId,
-                            originMemberId,
-                        };
-                    case 'tellaskBack':
-                    case 'freshBootsReasoning':
-                        return {
-                            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                            type: 'tellask_response_record',
-                            responderId,
-                            callName,
-                            calleeDialogId: calleeDialogSelfId,
-                            calleeCourse,
-                            calleeGenseq,
-                            tellaskContent,
-                            status,
-                            calling_genseq,
-                            response,
-                            agentId,
-                            callId,
-                            originMemberId,
-                        };
-                }
-            })();
-            await this.appendEvent(dialog, responseCourse, ev);
-            const tellaskResponseEvt = (() => {
-                switch (callName) {
-                    case 'tellask':
-                        if (!sessionSlug) {
-                            throw new Error(`receiveTellaskResponse invariant violation: missing sessionSlug for tellask ` +
-                                `(dialogId=${dialog.id.selfId}, callId=${callId})`);
-                        }
-                        return {
-                            type: 'tellask_response_evt',
-                            responderId,
-                            callName,
-                            sessionSlug,
-                            calleeDialogId: calleeDialogSelfId,
-                            calleeCourse,
-                            calleeGenseq,
-                            mentionList: normalizedMentionList,
-                            tellaskContent,
-                            status,
-                            course: responseCourse,
-                            calling_genseq,
-                            response,
-                            agentId,
-                            callId,
-                            originMemberId,
-                        };
-                    case 'tellaskSessionless':
-                        return {
-                            type: 'tellask_response_evt',
-                            responderId,
-                            callName,
-                            calleeDialogId: calleeDialogSelfId,
-                            calleeCourse,
-                            calleeGenseq,
-                            mentionList: normalizedMentionList,
-                            tellaskContent,
-                            status,
-                            course: responseCourse,
-                            calling_genseq,
-                            response,
-                            agentId,
-                            callId,
-                            originMemberId,
-                        };
-                    case 'tellaskBack':
-                    case 'freshBootsReasoning':
-                        return {
-                            type: 'tellask_response_evt',
-                            responderId,
-                            callName,
-                            calleeDialogId: calleeDialogSelfId,
-                            calleeCourse,
-                            calleeGenseq,
-                            tellaskContent,
-                            status,
-                            course: responseCourse,
-                            calling_genseq,
-                            response,
-                            agentId,
-                            callId,
-                            originMemberId,
-                        };
-                }
-            })();
-            (0, evt_registry_1.postDialogEvent)(dialog, tellaskResponseEvt);
-            return;
-        }
-        if (!originCourse) {
-            throw new Error(`receiveTellaskResponse invariant violation: missing originCourse for cross-course carryover ` +
-                `(dialogId=${dialog.id.selfId}, callId=${callId}, currentCourse=${currentCourse})`);
-        }
-        if (callName === 'tellaskBack') {
-            throw new Error(`tellask carryover does not support tellaskBack (dialogId=${dialog.id.selfId}, callId=${callId})`);
+        const genseq = dialog.activeGenSeqOrUndefined ?? result.genseq;
+        if (!Number.isFinite(genseq) || genseq <= 0) {
+            throw new Error(`receiveTellaskResult invariant violation: missing valid genseq for tellask result ${result.callId}`);
         }
-        if (carryoverText === undefined) {
-            throw new Error(`receiveTellaskResponse invariant violation: missing carryoverContent for cross-course tellask ` +
-                `(dialogId=${dialog.id.selfId}, callId=${callId}, originCourse=${originCourse}, currentCourse=${currentCourse})`);
+        const normalizedResult = genseq === result.genseq
+            ? result
+            : {
+                ...result,
+                genseq,
+            };
+        const record = buildTellaskResultRecord(normalizedResult, genseq);
+        await this.appendEvent(dialog, course, record);
+        (0, evt_registry_1.postDialogEvent)(dialog, buildTellaskResultEvent(normalizedResult, course));
+    }
+    async receiveTellaskCarryover(dialog, result) {
+        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        const genseq = dialog.activeGenSeqOrUndefined ?? result.genseq;
+        if (!Number.isFinite(genseq) || genseq <= 0) {
+            throw new Error(`receiveTellaskCarryover invariant violation: missing valid genseq for tellask carryover ${result.callId}`);
         }
-        const carryoverCallRecord = {
-            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            type: 'tellask_call_carryover_record',
-            responderId,
-            status,
-            callId,
-            carryoverCourse: (0, storage_1.toDialogCourseNumber)(currentCourse),
-        };
-        await this.appendEvent(dialog, originCourse, carryoverCallRecord);
-        const carryoverCallEvent = {
-            type: 'tellask_call_carryover_evt',
-            course: originCourse,
-            responderId,
-            status,
-            callId,
-            carryoverCourse: (0, storage_1.toDialogCourseNumber)(currentCourse),
-        };
-        (0, evt_registry_1.postDialogEvent)(dialog, carryoverCallEvent);
-        const carryoverRecord = (() => {
-            switch (callName) {
-                case 'tellask':
-                    if (!sessionSlug) {
-                        throw new Error(`receiveTellaskResponse invariant violation: missing sessionSlug for tellask carryover ` +
-                            `(dialogId=${dialog.id.selfId}, callId=${callId})`);
-                    }
-                    return {
-                        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        type: 'tellask_carryover_result_record',
-                        originCourse,
-                        responderId,
-                        callName,
-                        sessionSlug,
-                        mentionList: normalizedMentionList,
-                        tellaskContent,
-                        status,
-                        response,
-                        content: carryoverText,
-                        agentId,
-                        callId,
-                        originMemberId,
-                        calleeDialogId: calleeDialogSelfId,
-                        calleeCourse,
-                        calleeGenseq,
-                    };
-                case 'tellaskSessionless':
-                    return {
-                        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        type: 'tellask_carryover_result_record',
-                        originCourse,
-                        responderId,
-                        callName,
-                        mentionList: normalizedMentionList,
-                        tellaskContent,
-                        status,
-                        response,
-                        content: carryoverText,
-                        agentId,
-                        callId,
-                        originMemberId,
-                        calleeDialogId: calleeDialogSelfId,
-                        calleeCourse,
-                        calleeGenseq,
-                    };
-                case 'freshBootsReasoning':
-                    return {
-                        ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        type: 'tellask_carryover_result_record',
-                        originCourse,
-                        responderId,
-                        callName,
-                        tellaskContent,
-                        status,
-                        response,
-                        content: carryoverText,
-                        agentId,
-                        callId,
-                        originMemberId,
-                        calleeDialogId: calleeDialogSelfId,
-                        calleeCourse,
-                        calleeGenseq,
-                    };
-            }
-        })();
-        await this.appendEvent(dialog, currentCourse, carryoverRecord);
-        const carryoverEvent = (() => {
-            switch (callName) {
-                case 'tellask':
-                    if (!sessionSlug) {
-                        throw new Error(`receiveTellaskResponse invariant violation: missing sessionSlug for tellask carryover evt ` +
-                            `(dialogId=${dialog.id.selfId}, callId=${callId})`);
-                    }
-                    return {
-                        type: 'tellask_carryover_result_evt',
-                        course: currentCourse,
-                        originCourse,
-                        responderId,
-                        callName,
-                        sessionSlug,
-                        mentionList: normalizedMentionList,
-                        tellaskContent,
-                        status,
-                        response,
-                        content: carryoverText,
-                        agentId,
-                        callId,
-                        originMemberId,
-                        calleeDialogId: calleeDialogSelfId,
-                        calleeCourse,
-                        calleeGenseq,
-                    };
-                case 'tellaskSessionless':
-                    return {
-                        type: 'tellask_carryover_result_evt',
-                        course: currentCourse,
-                        originCourse,
-                        responderId,
-                        callName,
-                        mentionList: normalizedMentionList,
-                        tellaskContent,
-                        status,
-                        response,
-                        content: carryoverText,
-                        agentId,
-                        callId,
-                        originMemberId,
-                        calleeDialogId: calleeDialogSelfId,
-                        calleeCourse,
-                        calleeGenseq,
-                    };
-                case 'freshBootsReasoning':
-                    return {
-                        type: 'tellask_carryover_result_evt',
-                        course: currentCourse,
-                        originCourse,
-                        responderId,
-                        callName,
-                        tellaskContent,
-                        status,
-                        response,
-                        content: carryoverText,
-                        agentId,
-                        callId,
-                        originMemberId,
-                        calleeDialogId: calleeDialogSelfId,
-                        calleeCourse,
-                        calleeGenseq,
-                    };
-            }
-        })();
-        (0, evt_registry_1.postDialogEvent)(dialog, carryoverEvent);
+        const normalizedResult = genseq === result.genseq
+            ? result
+            : {
+                ...result,
+                genseq,
+            };
+        await this.appendEvent(dialog, course, buildTellaskCarryoverRecord(normalizedResult, genseq));
+        (0, evt_registry_1.postDialogEvent)(dialog, buildTellaskCarryoverEvent(normalizedResult, course));
     }
     /**
      * Ensure subdialog directory exists (delegate to DialogPersistence)
@@ -1306,6 +1239,9 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     async appendEvent(dialog, course, event) {
         await DialogPersistence.appendEvent(this.dialogId, course, attachRootGenerationRef(dialog, event));
     }
+    async appendEvents(dialog, course, events) {
+        await DialogPersistence.appendEvents(this.dialogId, course, events.map((event) => attachRootGenerationRef(dialog, event)));
+    }
     /**
      * Notify start of LLM generation for frontend bubble management
      * CRITICAL: This must be called BEFORE any substream events (thinking_start, markdown_start, etc.)
@@ -1573,6 +1509,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
             type: 'web_search_call_record',
             genseq: dialog.activeGenSeq,
+            source: payload.source,
             phase: payload.phase,
             itemId,
             status: payload.status,
@@ -1583,6 +1520,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             type: 'web_search_call_evt',
             course,
             genseq: dialog.activeGenSeq,
+            source: payload.source,
             phase: payload.phase,
             itemId,
             status: payload.status,
@@ -1590,6 +1528,111 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         };
         (0, evt_registry_1.postDialogEvent)(dialog, evt);
     }
+    async nativeToolCall(dialog, payload) {
+        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        const itemId = 'itemId' in payload && typeof payload.itemId === 'string' ? payload.itemId.trim() : undefined;
+        let record;
+        let evt;
+        if (payload.itemType === 'custom_tool_call') {
+            const callId = payload.callId.trim();
+            if (callId === '') {
+                log_1.log.error('Protocol violation: custom nativeToolCall called without callId; dropping event', new Error('native_tool_call_empty_call_id'), {
+                    dialog,
+                    itemType: payload.itemType,
+                    phase: payload.phase,
+                    itemId: payload.itemId,
+                    status: payload.status,
+                });
+                return;
+            }
+            if (itemId !== undefined && itemId === '') {
+                log_1.log.error('Protocol violation: custom nativeToolCall called with empty optional itemId; dropping event', new Error('native_tool_call_empty_optional_item_id'), {
+                    dialog,
+                    itemType: payload.itemType,
+                    phase: payload.phase,
+                    callId,
+                    status: payload.status,
+                });
+                return;
+            }
+            record = {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'native_tool_call_record',
+                genseq: dialog.activeGenSeq,
+                source: payload.source,
+                itemType: payload.itemType,
+                phase: payload.phase,
+                callId,
+                ...(itemId !== undefined && itemId !== '' ? { itemId } : {}),
+                status: payload.status,
+                title: payload.title,
+                summary: payload.summary,
+                detail: payload.detail,
+            };
+            evt = {
+                type: 'native_tool_call_evt',
+                course,
+                genseq: dialog.activeGenSeq,
+                source: payload.source,
+                itemType: payload.itemType,
+                phase: payload.phase,
+                callId,
+                ...(itemId !== undefined && itemId !== '' ? { itemId } : {}),
+                status: payload.status,
+                title: payload.title,
+                summary: payload.summary,
+                detail: payload.detail,
+            };
+        }
+        else {
+            if ('callId' in payload) {
+                log_1.log.error('Protocol violation: non-custom nativeToolCall called with unexpected callId; dropping event', new Error('native_tool_call_unexpected_call_id'), {
+                    dialog,
+                    itemType: payload.itemType,
+                    phase: payload.phase,
+                    status: payload.status,
+                });
+                return;
+            }
+            if (itemId === undefined || itemId === '') {
+                log_1.log.error('Protocol violation: non-custom nativeToolCall called without itemId; dropping event', new Error('native_tool_call_empty_item_id'), {
+                    dialog,
+                    itemType: payload.itemType,
+                    phase: payload.phase,
+                    status: payload.status,
+                });
+                return;
+            }
+            record = {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'native_tool_call_record',
+                genseq: dialog.activeGenSeq,
+                source: payload.source,
+                itemType: payload.itemType,
+                phase: payload.phase,
+                itemId,
+                status: payload.status,
+                title: payload.title,
+                summary: payload.summary,
+                detail: payload.detail,
+            };
+            evt = {
+                type: 'native_tool_call_evt',
+                course,
+                genseq: dialog.activeGenSeq,
+                source: payload.source,
+                itemType: payload.itemType,
+                phase: payload.phase,
+                itemId,
+                status: payload.status,
+                title: payload.title,
+                summary: payload.summary,
+                detail: payload.detail,
+            };
+        }
+        await this.appendEvent(dialog, course, record);
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
     /**
      * Emit stream error for current generation lifecycle (uses active genseq when present)
      */
@@ -1641,25 +1684,15 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * Note: The end_of_user_saying_evt is emitted by the driver after user content
      * is rendered and any tellask calls are parsed/executed.
      */
-    async persistUserMessage(dialog, content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds, tellaskReplyDirective) {
+    async persistUserMessage(dialog, content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallId, tellaskReplyDirective) {
         const course = dialog.currentCourse;
         // Use activeGenSeqOrUndefined to handle case when genseq hasn't been initialized yet
         const genseq = dialog.activeGenSeqOrUndefined ?? 1;
-        const normalizedQ4HAnswerCallIds = (() => {
-            if (!q4hAnswerCallIds || q4hAnswerCallIds.length === 0) {
-                return undefined;
-            }
-            const seen = new Set();
-            const normalized = [];
-            for (const raw of q4hAnswerCallIds) {
-                const callId = raw.trim();
-                if (callId === '' || seen.has(callId))
-                    continue;
-                seen.add(callId);
-                normalized.push(callId);
-            }
-            return normalized.length > 0 ? normalized : undefined;
-        })();
+        const normalizedQ4HAnswerCallId = typeof q4hAnswerCallId === 'string' && q4hAnswerCallId.trim() !== ''
+            ? q4hAnswerCallId.trim()
+            : undefined;
+        // `q4hAnswerCallId` marks continuation glue for a resumed round after askHuman is answered.
+        // The canonical answer fact is persisted separately in tellask result/carryover records.
         const humanEv = {
             ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
             type: 'human_text_record',
@@ -1669,7 +1702,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             grammar,
             origin,
             userLanguageCode,
-            q4hAnswerCallIds: normalizedQ4HAnswerCallIds,
+            q4hAnswerCallId: normalizedQ4HAnswerCallId,
             tellaskReplyDirective,
         };
         await this.appendEvent(dialog, course, humanEv);
@@ -1737,29 +1770,100 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     /**
      * Persist a function call to storage
      */
-    async persistFunctionCall(dialog, id, name, arguments_, genseq) {
+    async persistFunctionCall(dialog, id, name, rawArgumentsText, genseq) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const funcCallEvent = {
-            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            type: 'func_call_record',
-            genseq,
-            id,
-            name,
-            arguments: arguments_,
-        };
+        const funcCallEvent = buildFuncCallRecord({ id, name, rawArgumentsText, genseq });
         await this.appendEvent(dialog, course, funcCallEvent);
         // NOTE: func_call_evt REMOVED - persistence uses FuncCallRecord directly
         // UI display uses func_call_requested_evt instead
     }
-    async persistTellaskSpecialCall(dialog, id, name, arguments_, genseq) {
+    async persistTellaskCall(dialog, id, name, rawArgumentsText, genseq, options) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
-        const tellaskCallEvent = buildTellaskSpecialCallRecord({
+        const tellaskCallEvent = buildTellaskCallRecord({
             id,
             name,
-            arguments_,
+            rawArgumentsText,
             genseq,
+            deliveryMode: options?.deliveryMode ??
+                (isReplyTellaskCallRecordName(name) ? 'func_call_requested' : 'tellask_call_start'),
+        });
+        await this.appendEvent(dialog, course, tellaskCallEvent);
+        if (isReplyTellaskCallRecordName(name)) {
+            const funcCallEvt = {
+                type: 'func_call_requested_evt',
+                funcId: id,
+                funcName: name,
+                arguments: formatTellaskCallArguments(tellaskCallEvent),
+                course,
+                genseq: dialog.activeGenSeqOrUndefined ?? genseq,
+            };
+            (0, evt_registry_1.postDialogEvent)(dialog, funcCallEvt);
+        }
+    }
+    async persistFunctionCallResultPair(dialog, id, name, rawArgumentsText, genseq, result) {
+        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        const resultGenseq = dialog.activeGenSeqOrUndefined ?? result.genseq;
+        if (!Number.isFinite(resultGenseq) || resultGenseq <= 0) {
+            throw new Error(`persistFunctionCallResultPair invariant violation: missing valid genseq for func result ${result.id}`);
+        }
+        await this.appendEvents(dialog, course, [
+            buildFuncCallRecord({ id, name, rawArgumentsText, genseq }),
+            buildFuncResultRecord(result, resultGenseq),
+        ]);
+        if (!isSuppressedTellaskPlaceholderFuncResult({
+            name: result.name,
+            content: result.content,
+        })) {
+            const funcResultEvt = {
+                type: 'func_result_evt',
+                id: result.id,
+                name: result.name,
+                content: result.content,
+                contentItems: result.contentItems,
+                course,
+            };
+            (0, evt_registry_1.postDialogEvent)(dialog, funcResultEvt);
+        }
+    }
+    async persistTellaskCallResultPair(dialog, args) {
+        const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
+        const resultGenseq = dialog.activeGenSeqOrUndefined ?? args.result.genseq;
+        if (!Number.isFinite(resultGenseq) || resultGenseq <= 0) {
+            throw new Error(`persistTellaskCallResultPair invariant violation: missing valid genseq for tellask result ${args.result.type === 'func_result_msg' ? args.result.id : args.result.callId}`);
+        }
+        const callRecord = buildTellaskCallRecord({
+            id: args.id,
+            name: args.name,
+            rawArgumentsText: args.rawArgumentsText,
+            genseq: args.genseq,
+            deliveryMode: args.deliveryMode,
         });
-        await this.appendEvent(dialog, course, tellaskCallEvent);
+        if (args.result.type === 'func_result_msg') {
+            await this.appendEvents(dialog, course, [
+                callRecord,
+                buildFuncResultRecord(args.result, resultGenseq),
+            ]);
+            if (!isSuppressedTellaskPlaceholderFuncResult({
+                name: args.result.name,
+                content: args.result.content,
+            })) {
+                const funcResultEvt = {
+                    type: 'func_result_evt',
+                    id: args.result.id,
+                    name: args.result.name,
+                    content: args.result.content,
+                    contentItems: args.result.contentItems,
+                    course,
+                };
+                (0, evt_registry_1.postDialogEvent)(dialog, funcResultEvt);
+            }
+            return;
+        }
+        await this.appendEvents(dialog, course, [
+            callRecord,
+            buildTellaskResultRecord(args.result, resultGenseq),
+        ]);
+        (0, evt_registry_1.postDialogEvent)(dialog, buildTellaskResultEvent(args.result, course));
     }
     /**
      * Update questions for human state (exceptional overwrite pattern)
@@ -2034,6 +2138,12 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         }
         switch (event.type) {
             case 'human_text_record': {
+                if (typeof event.q4hAnswerCallId === 'string' && event.q4hAnswerCallId.trim() !== '') {
+                    // Q4H-annotated human_text_record is a technical continuation marker for a resumed drive.
+                    // The canonical answer fact already exists in tellask result/carryover records, so UI
+                    // replay must not emit it as another user prompt bubble.
+                    break;
+                }
                 const genseq = event.genseq;
                 const content = event.content || '';
                 const grammar = 'markdown';
@@ -2093,7 +2203,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                         grammar,
                         origin,
                         userLanguageCode,
-                        q4hAnswerCallIds: event.q4hAnswerCallIds,
+                        q4hAnswerCallId: event.q4hAnswerCallId,
                         dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
                         timestamp: event.ts,
                     }));
@@ -2264,28 +2374,16 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 const content = event.content || '';
                 if (!content.trim())
                     break;
-                const dialogIdent = { selfId: dialog.id.selfId, rootId: dialog.id.rootId };
                 if (ws.readyState === 1) {
-                    ws.send(JSON.stringify({
-                        type: 'markdown_start_evt',
-                        course,
-                        genseq: event.genseq,
-                        dialog: dialogIdent,
-                        timestamp: event.ts,
-                    }));
-                    ws.send(JSON.stringify({
-                        type: 'markdown_chunk_evt',
-                        chunk: content,
+                    const uiOnlyMarkdownEvt = {
+                        type: 'ui_only_markdown_evt',
                         course,
                         genseq: event.genseq,
-                        dialog: dialogIdent,
-                        timestamp: event.ts,
-                    }));
+                        content,
+                    };
                     ws.send(JSON.stringify({
-                        type: 'markdown_finish_evt',
-                        course,
-                        genseq: event.genseq,
-                        dialog: dialogIdent,
+                        ...uiOnlyMarkdownEvt,
+                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
                         timestamp: event.ts,
                     }));
                 }
@@ -2297,7 +2395,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                     type: 'func_call_requested_evt',
                     funcId: event.id,
                     funcName: event.name,
-                    arguments: JSON.stringify(event.arguments),
+                    arguments: event.rawArgumentsText,
                     course,
                     genseq: event.genseq,
                     dialog: {
@@ -2311,8 +2409,27 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
-            case 'tellask_special_call_record': {
-                const specialCall = parseReplayTellaskSpecialCall(event);
+            case 'tellask_call_record': {
+                if (event.deliveryMode === 'func_call_requested') {
+                    const replyCall = {
+                        type: 'func_call_requested_evt',
+                        funcId: event.id,
+                        funcName: event.name,
+                        arguments: formatTellaskCallArguments(event),
+                        course,
+                        genseq: event.genseq,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    };
+                    if (ws.readyState === 1) {
+                        ws.send(JSON.stringify(replyCall));
+                    }
+                    break;
+                }
+                const specialCall = parseReplayTellaskCall(event);
                 if (!specialCall) {
                     break;
                 }
@@ -2378,6 +2495,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 const webSearchCall = {
                     type: 'web_search_call_evt',
+                    source: event.source,
                     phase: event.phase,
                     itemId,
                     status: event.status,
@@ -2395,7 +2513,108 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
+            case 'native_tool_call_record': {
+                let nativeToolCall;
+                if (event.itemType === 'custom_tool_call') {
+                    const callId = typeof event.callId === 'string' ? event.callId.trim() : '';
+                    if (callId === '') {
+                        log_1.log.error('Protocol violation: persisted custom native_tool_call_record missing callId; skipping WS event', new Error('persisted_native_tool_call_record_missing_call_id'), {
+                            dialog,
+                            course,
+                            genseq: event.genseq,
+                            itemType: event.itemType,
+                            phase: event.phase,
+                            itemId: event.itemId,
+                        });
+                        break;
+                    }
+                    if (typeof event.itemId === 'string' && event.itemId.trim() === '') {
+                        log_1.log.error('Protocol violation: persisted custom native_tool_call_record carried empty optional itemId; skipping WS event', new Error('persisted_native_tool_call_record_empty_optional_item_id'), {
+                            dialog,
+                            course,
+                            genseq: event.genseq,
+                            itemType: event.itemType,
+                            phase: event.phase,
+                            callId,
+                        });
+                        break;
+                    }
+                    nativeToolCall = {
+                        type: 'native_tool_call_evt',
+                        source: event.source,
+                        itemType: event.itemType,
+                        phase: event.phase,
+                        callId,
+                        ...(typeof event.itemId === 'string' && event.itemId.trim() !== ''
+                            ? { itemId: event.itemId.trim() }
+                            : {}),
+                        status: event.status,
+                        title: event.title,
+                        summary: event.summary,
+                        detail: event.detail,
+                        course,
+                        genseq: event.genseq,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    };
+                }
+                else {
+                    if ('callId' in event) {
+                        log_1.log.error('Protocol violation: persisted non-custom native_tool_call_record carried unexpected callId; skipping WS event', new Error('persisted_native_tool_call_record_unexpected_call_id'), {
+                            dialog,
+                            course,
+                            genseq: event.genseq,
+                            itemType: event.itemType,
+                            phase: event.phase,
+                            callId: event.callId,
+                        });
+                        break;
+                    }
+                    const itemId = typeof event.itemId === 'string' ? event.itemId.trim() : '';
+                    if (itemId === '') {
+                        log_1.log.error('Protocol violation: persisted native_tool_call_record missing itemId; skipping WS event', new Error('persisted_native_tool_call_record_missing_item_id'), {
+                            dialog,
+                            course,
+                            genseq: event.genseq,
+                            itemType: event.itemType,
+                            phase: event.phase,
+                        });
+                        break;
+                    }
+                    nativeToolCall = {
+                        type: 'native_tool_call_evt',
+                        source: event.source,
+                        itemType: event.itemType,
+                        phase: event.phase,
+                        itemId,
+                        status: event.status,
+                        title: event.title,
+                        summary: event.summary,
+                        detail: event.detail,
+                        course,
+                        genseq: event.genseq,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    };
+                }
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(nativeToolCall));
+                }
+                break;
+            }
             case 'func_result_record': {
+                if (isSuppressedTellaskPlaceholderFuncResult({
+                    name: event.name,
+                    content: event.content,
+                })) {
+                    break;
+                }
                 // Handle function result events from persistence
                 const funcResult = {
                     type: 'func_result_evt',
@@ -2415,6 +2634,45 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
+            case 'tellask_result_record': {
+                const base = {
+                    type: 'tellask_result_evt',
+                    course,
+                    genseq: event.genseq,
+                    callId: event.callId,
+                    status: event.status,
+                    content: event.content,
+                    ...(event.calling_genseq !== undefined ? { calling_genseq: event.calling_genseq } : {}),
+                    responder: event.responder,
+                    ...(event.route ? { route: event.route } : {}),
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                const tellaskResultEvent = event.callName === 'tellask'
+                    ? {
+                        ...base,
+                        callName: event.callName,
+                        call: event.call,
+                    }
+                    : event.callName === 'tellaskSessionless'
+                        ? {
+                            ...base,
+                            callName: event.callName,
+                            call: event.call,
+                        }
+                        : {
+                            ...base,
+                            callName: event.callName,
+                            call: event.call,
+                        };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(tellaskResultEvent));
+                }
+                break;
+            }
             case 'quest_for_sup_record': {
                 // Handle subdialog creation requests
                 const subdialogId = new dialog_1.DialogID(event.subDialogId, dialog.id.rootId);
@@ -2470,55 +2728,6 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
-            case 'tellask_call_result_record': {
-                // Handle tellask-call inline results
-                const responseEvent = (() => {
-                    switch (event.callName) {
-                        case 'tellask':
-                        case 'tellaskSessionless':
-                            return {
-                                type: 'tellask_call_result_evt',
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                mentionList: event.mentionList,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                result: event.result,
-                                callId: event.callId || '',
-                                course,
-                                calling_genseq: event.calling_genseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
-                        case 'tellaskBack':
-                        case 'askHuman':
-                        case 'freshBootsReasoning':
-                            return {
-                                type: 'tellask_call_result_evt',
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                result: event.result,
-                                callId: event.callId || '',
-                                course,
-                                calling_genseq: event.calling_genseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
-                    }
-                })();
-                if (ws.readyState === 1) {
-                    ws.send(JSON.stringify(responseEvent));
-                }
-                break;
-            }
             case 'tellask_call_anchor_record': {
                 const anchorEvent = event.anchorRole === 'assignment'
                     ? {
@@ -2556,210 +2765,56 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 }
                 break;
             }
-            case 'tellask_call_carryover_record': {
-                const carryoverEvent = {
-                    type: 'tellask_call_carryover_evt',
+            case 'subdialog_created_record':
+            case 'reminders_reconciled_record':
+            case 'questions4human_reconciled_record':
+            case 'pending_subdialogs_reconciled_record':
+            case 'subdialog_registry_reconciled_record':
+            case 'subdialog_responses_reconciled_record':
+                break;
+            case 'tellask_carryover_record': {
+                const base = {
+                    type: 'tellask_carryover_evt',
                     course,
+                    genseq: event.genseq,
+                    originCourse: event.originCourse,
+                    carryoverCourse: event.carryoverCourse,
                     responderId: event.responderId,
+                    tellaskContent: event.tellaskContent,
                     status: event.status,
+                    response: event.response,
+                    content: event.content,
+                    agentId: event.agentId,
                     callId: event.callId,
-                    carryoverCourse: event.carryoverCourse,
+                    originMemberId: event.originMemberId,
+                    ...(event.calleeDialogId ? { calleeDialogId: event.calleeDialogId } : {}),
+                    ...(event.calleeCourse !== undefined ? { calleeCourse: event.calleeCourse } : {}),
+                    ...(event.calleeGenseq !== undefined ? { calleeGenseq: event.calleeGenseq } : {}),
                     dialog: {
                         selfId: dialog.id.selfId,
                         rootId: dialog.id.rootId,
                     },
                     timestamp: event.ts,
                 };
-                if (ws.readyState === 1) {
-                    ws.send(JSON.stringify(carryoverEvent));
-                }
-                break;
-            }
-            case 'tellask_carryover_result_record': {
-                const carryoverEvent = (() => {
-                    switch (event.callName) {
-                        case 'tellask':
-                            return {
-                                type: 'tellask_carryover_result_evt',
-                                course,
-                                originCourse: event.originCourse,
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                sessionSlug: event.sessionSlug,
-                                mentionList: event.mentionList,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                response: event.response,
-                                content: event.content,
-                                agentId: event.agentId,
-                                callId: event.callId,
-                                originMemberId: event.originMemberId,
-                                calleeDialogId: event.calleeDialogId,
-                                calleeCourse: event.calleeCourse,
-                                calleeGenseq: event.calleeGenseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
-                        case 'tellaskSessionless':
-                            return {
-                                type: 'tellask_carryover_result_evt',
-                                course,
-                                originCourse: event.originCourse,
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                mentionList: event.mentionList,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                response: event.response,
-                                content: event.content,
-                                agentId: event.agentId,
-                                callId: event.callId,
-                                originMemberId: event.originMemberId,
-                                calleeDialogId: event.calleeDialogId,
-                                calleeCourse: event.calleeCourse,
-                                calleeGenseq: event.calleeGenseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
-                        case 'freshBootsReasoning':
-                            return {
-                                type: 'tellask_carryover_result_evt',
-                                course,
-                                originCourse: event.originCourse,
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                response: event.response,
-                                content: event.content,
-                                agentId: event.agentId,
-                                callId: event.callId,
-                                originMemberId: event.originMemberId,
-                                calleeDialogId: event.calleeDialogId,
-                                calleeCourse: event.calleeCourse,
-                                calleeGenseq: event.calleeGenseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
-                    }
-                })();
-                if (ws.readyState === 1) {
-                    ws.send(JSON.stringify(carryoverEvent));
-                }
-                break;
-            }
-            case 'subdialog_created_record':
-            case 'reminders_reconciled_record':
-            case 'questions4human_reconciled_record':
-            case 'pending_subdialogs_reconciled_record':
-            case 'subdialog_registry_reconciled_record':
-            case 'subdialog_responses_reconciled_record':
-                break;
-            case 'tellask_response_record': {
-                // Handle tellask response events (separate bubble for tellask sideline replies)
-                const mentionList = (() => {
-                    switch (event.callName) {
-                        case 'tellask':
-                        case 'tellaskSessionless':
-                            return event.mentionList;
-                        case 'tellaskBack':
-                        case 'freshBootsReasoning':
-                            return undefined;
+                const tellaskCarryoverEvent = event.callName === 'tellask'
+                    ? {
+                        ...base,
+                        callName: event.callName,
+                        sessionSlug: event.sessionSlug,
+                        mentionList: event.mentionList,
                     }
-                })();
-                const tellaskResponseEvent = (() => {
-                    switch (event.callName) {
-                        case 'tellask': {
-                            const sessionSlug = typeof event.sessionSlug === 'string' && event.sessionSlug.trim() !== ''
-                                ? event.sessionSlug.trim()
-                                : undefined;
-                            if (!sessionSlug) {
-                                throw new Error(`Replay tellask_response_record invariant violation: missing sessionSlug for tellask ` +
-                                    `(rootId=${dialog.id.rootId}, selfId=${dialog.id.selfId}, course=${course}, callId=${event.callId})`);
-                            }
-                            return {
-                                type: 'tellask_response_evt',
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                sessionSlug,
-                                calleeDialogId: event.calleeDialogId,
-                                calleeCourse: event.calleeCourse,
-                                calleeGenseq: event.calleeGenseq,
-                                mentionList,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                response: event.response,
-                                agentId: event.agentId,
-                                callId: event.callId,
-                                originMemberId: event.originMemberId,
-                                course,
-                                calling_genseq: event.calling_genseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
+                    : event.callName === 'tellaskSessionless'
+                        ? {
+                            ...base,
+                            callName: event.callName,
+                            mentionList: event.mentionList,
                         }
-                        case 'tellaskSessionless':
-                            return {
-                                type: 'tellask_response_evt',
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                calleeDialogId: event.calleeDialogId,
-                                calleeCourse: event.calleeCourse,
-                                calleeGenseq: event.calleeGenseq,
-                                mentionList,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                response: event.response,
-                                agentId: event.agentId,
-                                callId: event.callId,
-                                originMemberId: event.originMemberId,
-                                course,
-                                calling_genseq: event.calling_genseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
-                        case 'tellaskBack':
-                        case 'freshBootsReasoning':
-                            return {
-                                type: 'tellask_response_evt',
-                                responderId: event.responderId,
-                                callName: event.callName,
-                                calleeDialogId: event.calleeDialogId,
-                                calleeCourse: event.calleeCourse,
-                                calleeGenseq: event.calleeGenseq,
-                                tellaskContent: event.tellaskContent,
-                                status: event.status,
-                                response: event.response,
-                                agentId: event.agentId,
-                                callId: event.callId,
-                                originMemberId: event.originMemberId,
-                                course,
-                                calling_genseq: event.calling_genseq,
-                                dialog: {
-                                    selfId: dialog.id.selfId,
-                                    rootId: dialog.id.rootId,
-                                },
-                                timestamp: event.ts,
-                            };
-                    }
-                })();
+                        : {
+                            ...base,
+                            callName: event.callName,
+                        };
                 if (ws.readyState === 1) {
-                    ws.send(JSON.stringify(tellaskResponseEvent));
+                    ws.send(JSON.stringify(tellaskCarryoverEvent));
                 }
                 break;
             }
@@ -2791,71 +2846,6 @@ exports.DiskFileDialogStore = DiskFileDialogStore;
  * Utility class for managing dialog persistence
  */
 class DialogPersistence {
-    static async repairInterruptedFunctionCallsOnRestore(args) {
-        const repaired = [];
-        const unresolvedById = new Map();
-        for (const event of args.events) {
-            if (event.type === 'func_call_record') {
-                unresolvedById.set(event.id, event);
-                repaired.push(event);
-                continue;
-            }
-            if (event.type === 'func_result_record') {
-                if (!unresolvedById.has(event.id)) {
-                    const repairCall = {
-                        ts: event.ts,
-                        type: 'func_call_record',
-                        genseq: event.genseq,
-                        id: event.id,
-                        name: event.name,
-                        arguments: {},
-                    };
-                    log_1.log.error('Recovered orphaned persisted func_result_record by synthesizing missing func_call_record during dialog restore', new Error('dialog_restore_recovered_orphaned_func_result'), {
-                        rootId: args.dialogId.rootId,
-                        selfId: args.dialogId.selfId,
-                        course: args.course,
-                        genseq: event.genseq,
-                        callId: event.id,
-                        toolName: event.name,
-                    });
-                    repaired.push(repairCall);
-                }
-                else {
-                    unresolvedById.delete(event.id);
-                }
-                repaired.push(event);
-                continue;
-            }
-            repaired.push(event);
-        }
-        if (args.status !== 'running') {
-            return repaired;
-        }
-        if (unresolvedById.size === 0) {
-            return repaired;
-        }
-        for (const call of unresolvedById.values()) {
-            const repairRecord = {
-                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                type: 'func_result_record',
-                id: call.id,
-                name: call.name,
-                content: formatCrashRecoveredFuncResultContent(call.name),
-                genseq: call.genseq,
-            };
-            log_1.log.error('Recovered unresolved persisted func_call_record after unexpected process exit', new Error('dialog_restore_recovered_func_call'), {
-                rootId: args.dialogId.rootId,
-                selfId: args.dialogId.selfId,
-                course: args.course,
-                genseq: call.genseq,
-                callId: call.id,
-                toolName: call.name,
-            });
-            await this.appendEvent(args.dialogId, args.course, repairRecord, args.status);
-            repaired.push(repairRecord);
-        }
-        return repaired;
-    }
     static getLatestWriteBackMutex(key) {
         const existing = this.latestWriteBackMutexes.get(key);
         if (existing)
@@ -2911,7 +2901,6 @@ class DialogPersistence {
     static cloneQuestions4Human(questions) {
         return questions.map((question) => ({
             ...question,
-            remainingCallIds: question.remainingCallIds ? [...question.remainingCallIds] : undefined,
             callSiteRef: { ...question.callSiteRef },
         }));
     }
@@ -3294,10 +3283,13 @@ class DialogPersistence {
     /**
      * Append event to course JSONL file (append-only pattern)
      */
-    static async appendEvent(dialogId, course, event, status = 'running') {
+    static async appendEvents(dialogId, course, events, status = 'running') {
         const appendMutexKey = this.getCourseAppendMutexKey(dialogId, course, status);
         const release = await this.getCourseAppendMutex(appendMutexKey).acquire();
         try {
+            if (events.length === 0) {
+                return;
+            }
             const dialogPath = this.getDialogEventsPath(dialogId, status);
             const courseFilename = this.getCourseFilename(course);
             const courseFilePath = path.join(dialogPath, courseFilename);
@@ -3306,8 +3298,8 @@ class DialogPersistence {
             // Serialize appends per dialog+course file. Concurrent `appendFile` calls can interleave and
             // corrupt JSONL lines (e.g. tool results appended in parallel), which later manifests as
             // `Unterminated string in JSON ...` during resume.
-            const eventLine = JSON.stringify(event) + '\n';
-            await fs.promises.appendFile(courseFilePath, eventLine, 'utf-8');
+            const serialized = events.map((event) => JSON.stringify(event)).join('\n') + '\n';
+            await fs.promises.appendFile(courseFilePath, serialized, 'utf-8');
             // Update latest.yaml with new lastModified timestamp
             await this.mutateDialogLatest(dialogId, () => ({
                 kind: 'patch',
@@ -3318,13 +3310,16 @@ class DialogPersistence {
             }), status);
         }
         catch (error) {
-            log_1.log.error(`Failed to append event to dialog ${dialogId} course ${course}:`, error);
+            log_1.log.error(`Failed to append events to dialog ${dialogId} course ${course}:`, error);
             throw error;
         }
         finally {
             release();
         }
     }
+    static async appendEvent(dialogId, course, event, status = 'running') {
+        await this.appendEvents(dialogId, course, [event], status);
+    }
     static async persistRuntimeGuide(dialog, content, genseq) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
         const ev = {
@@ -3741,29 +3736,26 @@ class DialogPersistence {
     }
     static async appendQuestion4HumanState(dialogId, question, status = 'running') {
         const questionId = question.id;
-        const normalizedCallId = typeof question.callId === 'string' && question.callId.trim() !== ''
-            ? question.callId.trim()
-            : null;
+        const normalizedCallId = question.callId.trim();
+        if (normalizedCallId === '') {
+            throw new Error(`Q4H append invariant violation: empty callId (dialog=${dialogId.valueOf()} questionId=${questionId})`);
+        }
         await this.mutateQuestions4HumanState(dialogId, (previousQuestions) => {
             const byId = previousQuestions.find((q) => q.id === questionId);
             if (byId) {
                 throw new Error(`Q4H duplicate question id violation: dialog=${dialogId.valueOf()} status=${status} questionId=${questionId} existingAskedAt=${byId.askedAt} incomingAskedAt=${question.askedAt}`);
             }
-            if (normalizedCallId) {
-                const byCallId = previousQuestions.find((q) => {
-                    return typeof q.callId === 'string' && q.callId.trim() === normalizedCallId;
-                });
-                if (byCallId) {
-                    throw new Error(`Q4H duplicate call id violation: dialog=${dialogId.valueOf()} status=${status} callId=${normalizedCallId} existingQuestionId=${byCallId.id} incomingQuestionId=${questionId} existingAskedAt=${byCallId.askedAt} incomingAskedAt=${question.askedAt}`);
-                }
+            const byCallId = previousQuestions.find((q) => q.callId.trim() === normalizedCallId);
+            if (byCallId) {
+                throw new Error(`Q4H duplicate call id violation: dialog=${dialogId.valueOf()} status=${status} callId=${normalizedCallId} existingQuestionId=${byCallId.id} incomingQuestionId=${questionId} existingAskedAt=${byCallId.askedAt} incomingAskedAt=${question.askedAt}`);
             }
             if (previousQuestions.length > 0) {
                 const existingIds = previousQuestions.map((q) => q.id).join(',');
                 const existingCallIds = previousQuestions
-                    .map((q) => (typeof q.callId === 'string' ? q.callId.trim() : ''))
+                    .map((q) => q.callId.trim())
                     .filter((value) => value !== '')
                     .join(',');
-                throw new Error(`Q4H multi-pending violation: dialog=${dialogId.valueOf()} status=${status} existingCount=${previousQuestions.length} existingQuestionIds=${existingIds} existingCallIds=${existingCallIds} incomingQuestionId=${questionId} incomingCallId=${normalizedCallId ?? ''}`);
+                throw new Error(`Q4H multi-pending violation: dialog=${dialogId.valueOf()} status=${status} existingCount=${previousQuestions.length} existingQuestionIds=${existingIds} existingCallIds=${existingCallIds} incomingQuestionId=${questionId} incomingCallId=${normalizedCallId}`);
             }
             return { kind: 'append', question };
         }, status);
@@ -4929,8 +4921,11 @@ class DialogPersistence {
         }
     }
     /**
-     * Restore dialog from disk using JSONL events (optimized: only latest course loaded)
-     * For historical courses, use loadCourseEvents() on-demand for UI navigation
+     * Restore dialog from disk using JSONL events (optimized: only latest course loaded).
+     * Historical-course ask/tellask context that still matters to the current round must already be
+     * represented via latest-course carryover records; older courses themselves are not reloaded into
+     * LLM context during restore. For historical courses, use loadCourseEvents() on-demand for UI
+     * navigation.
      */
     static async restoreDialog(dialogId, status = 'running') {
         try {
@@ -4940,16 +4935,11 @@ class DialogPersistence {
                 return null;
             }
             const reminders = await this.loadReminderState(dialogId, status);
-            // Only load latest course for dialog state restoration
+            // Only load latest course for dialog state restoration. Cross-course business context should
+            // already have been materialized into latest-course carryover records when needed.
             const currentCourse = await this.getCurrentCourseNumber(dialogId, status);
             const latestEvents = await this.readCourseEvents(dialogId, currentCourse, status);
-            const repairedEvents = await this.repairInterruptedFunctionCallsOnRestore({
-                dialogId,
-                course: currentCourse,
-                status,
-                events: latestEvents,
-            });
-            const reconstructedState = await this.rebuildFromEvents(repairedEvents, metadata, reminders, currentCourse);
+            const reconstructedState = await this.rebuildFromEvents(latestEvents, metadata, reminders, currentCourse);
             return reconstructedState;
         }
         catch (error) {
@@ -4964,7 +4954,7 @@ class DialogPersistence {
         return await this.readCourseEvents(dialogId, course, status);
     }
     /**
-     * Reconstruct dialog state from JSONL events (optimized: only latest course needed)
+     * Reconstruct dialog state from JSONL events (optimized: only latest course needed).
      */
     static async rebuildFromEvents(events, metadata, reminders, currentCourse) {
         // Events are already in chronological order from JSONL file (append-only pattern)
@@ -4995,15 +4985,6 @@ class DialogPersistence {
                     });
                     break;
                 }
-                case 'ui_only_markdown_record': {
-                    messages.push({
-                        type: 'ui_only_markdown_msg',
-                        role: 'assistant',
-                        genseq: event.genseq,
-                        content: event.content,
-                    });
-                    break;
-                }
                 case 'runtime_guide_record': {
                     messages.push({
                         type: 'transient_guide_msg',
@@ -5013,6 +4994,11 @@ class DialogPersistence {
                     break;
                 }
                 case 'human_text_record': {
+                    if (typeof event.q4hAnswerCallId === 'string' && event.q4hAnswerCallId.trim() !== '') {
+                        // Keep this out of transcript reconstruction: it is only the continuation glue for an
+                        // answered askHuman call, not a persisted business-level user prompt fact.
+                        break;
+                    }
                     // Convert human text to prompting message
                     messages.push({
                         type: 'prompting_msg',
@@ -5034,18 +5020,18 @@ class DialogPersistence {
                         genseq: event.genseq,
                         id: event.id,
                         name: event.name,
-                        arguments: event.arguments ? JSON.stringify(event.arguments) : '{}',
+                        arguments: event.rawArgumentsText,
                     });
                     break;
                 }
-                case 'tellask_special_call_record': {
+                case 'tellask_call_record': {
                     messages.push({
                         type: 'func_call_msg',
                         role: 'assistant',
                         genseq: event.genseq,
                         id: event.id,
                         name: event.name,
-                        arguments: formatTellaskSpecialCallArguments(event),
+                        arguments: formatTellaskCallArguments(event),
                     });
                     break;
                 }
@@ -5053,6 +5039,10 @@ class DialogPersistence {
                     // UI-only timeline event for native web_search tool call visualization.
                     // Must not be injected into LLM context reconstruction.
                     break;
+                case 'native_tool_call_record':
+                    // UI-only timeline event for OpenAI Responses native tool visualization.
+                    // Must not be injected into LLM context reconstruction.
+                    break;
                 case 'func_result_record': {
                     // Convert function result to ChatMessage
                     messages.push({
@@ -5066,69 +5056,68 @@ class DialogPersistence {
                     });
                     break;
                 }
-                case 'tellask_call_result_record': {
-                    // Convert tellask-call inline result to ChatMessage
-                    const mentionList = (() => {
-                        switch (event.callName) {
-                            case 'tellask':
-                            case 'tellaskSessionless':
-                                return event.mentionList;
-                            case 'tellaskBack':
-                            case 'askHuman':
-                            case 'freshBootsReasoning':
-                                return undefined;
-                        }
-                    })();
+                case 'tellask_result_record': {
                     messages.push({
                         type: 'tellask_result_msg',
                         role: 'tool',
-                        responderId: event.responderId,
-                        mentionList,
-                        tellaskContent: event.tellaskContent,
-                        status: event.status,
+                        genseq: event.genseq,
                         callId: event.callId,
-                        content: event.result,
-                    });
-                    break;
-                }
-                case 'tellask_call_carryover_record':
-                    break;
-                case 'tellask_response_record': {
-                    // Convert tellask response to ChatMessage (separate bubble)
-                    // Note: Tellask responses are stored as separate records but use same message type
-                    const mentionList = (() => {
-                        switch (event.callName) {
-                            case 'tellask':
-                            case 'tellaskSessionless':
-                                return event.mentionList;
-                            case 'tellaskBack':
-                            case 'freshBootsReasoning':
-                                return undefined;
-                        }
-                    })();
-                    messages.push({
-                        type: 'tellask_result_msg',
-                        role: 'tool',
-                        responderId: event.responderId,
-                        mentionList,
-                        tellaskContent: event.tellaskContent,
+                        callName: event.callName,
                         status: event.status,
-                        callId: event.callId,
-                        content: event.response,
+                        content: event.content,
+                        ...(event.calling_genseq !== undefined ? { calling_genseq: event.calling_genseq } : {}),
+                        call: event.call,
+                        responder: event.responder,
+                        ...(event.route ? { route: event.route } : {}),
+                        responderId: event.responder.responderId,
+                        ...(event.callName === 'tellask' || event.callName === 'tellaskSessionless'
+                            ? { mentionList: event.call.mentionList }
+                            : {}),
+                        tellaskContent: event.call.tellaskContent,
+                        ...(event.callName === 'tellask' ? { sessionSlug: event.call.sessionSlug } : {}),
+                        ...(event.responder.agentId ? { agentId: event.responder.agentId } : {}),
+                        ...(event.responder.originMemberId
+                            ? { originMemberId: event.responder.originMemberId }
+                            : {}),
+                        ...(event.route?.calleeDialogId ? { calleeDialogId: event.route.calleeDialogId } : {}),
+                        ...(event.route?.calleeCourse !== undefined
+                            ? { calleeCourse: event.route.calleeCourse }
+                            : {}),
+                        ...(event.route?.calleeGenseq !== undefined
+                            ? { calleeGenseq: event.route.calleeGenseq }
+                            : {}),
                     });
                     break;
                 }
-                case 'tellask_carryover_result_record': {
+                case 'tellask_carryover_record': {
                     messages.push({
-                        type: 'tellask_carryover_result_msg',
+                        type: 'tellask_carryover_msg',
                         role: 'user',
+                        genseq: event.genseq,
                         content: event.content,
                         originCourse: event.originCourse,
+                        carryoverCourse: event.carryoverCourse,
                         responderId: event.responderId,
                         callName: event.callName,
                         tellaskContent: event.tellaskContent,
                         status: event.status,
+                        response: event.response,
+                        agentId: event.agentId,
                         callId: event.callId,
+                        originMemberId: event.originMemberId,
+                        ...(event.callName === 'tellask'
+                            ? {
+                                mentionList: event.mentionList,
+                                sessionSlug: event.sessionSlug,
+                            }
+                            : event.callName === 'tellaskSessionless'
+                                ? {
+                                    mentionList: event.mentionList,
+                                }
+                                : {}),
+                        ...(event.calleeDialogId ? { calleeDialogId: event.calleeDialogId } : {}),
+                        ...(event.calleeCourse !== undefined ? { calleeCourse: event.calleeCourse } : {}),
+                        ...(event.calleeGenseq !== undefined ? { calleeGenseq: event.calleeGenseq } : {}),
                     });
                     break;
                 }
@@ -5149,6 +5138,9 @@ class DialogPersistence {
                     // This record is UI navigation metadata for deep links in callee dialogs.
                     // It does not contribute to model context or chat transcript reconstruction.
                     break;
+                case 'ui_only_markdown_record':
+                    // UI-only records are replay-only rendering facts. They do not enter dialog messages or ctx.
+                    break;
                 case 'subdialog_created_record':
                 case 'reminders_reconciled_record':
                 case 'questions4human_reconciled_record':