dominds 0.7.6 → 0.8.2

package/dist/llm/driver-v2/tellask-bridge.js

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeTellaskCalls = executeTellaskCalls;
+exports.isTellaskSpecialFunctionName = isTellaskSpecialFunctionName;
+exports.classifyTellaskSpecialFunctionCalls = classifyTellaskSpecialFunctionCalls;
+exports.executeTellaskSpecialCalls = executeTellaskSpecialCalls;
 const util_1 = require("util");
 const dialog_1 = require("../../dialog");
 const evt_registry_1 = require("../../evt-registry");
@@ -47,6 +49,194 @@ const time_1 = require("../../shared/utils/time");
 const team_1 = require("../../team");
 const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
 const subdialog_txn_1 = require("./subdialog-txn");
+const TELLASK_SPECIAL_FUNCTION_NAMES = [
+    'tellaskBack',
+    'tellask',
+    'tellaskSessionless',
+    'askHuman',
+    'freshBootsReasoning',
+];
+function isTellaskSpecialFunctionName(name) {
+    return TELLASK_SPECIAL_FUNCTION_NAMES.includes(name);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseFuncCallArgsObject(call) {
+    try {
+        const parsed = JSON.parse(call.arguments || '{}');
+        if (!isRecord(parsed)) {
+            return { ok: false, error: 'arguments must be a JSON object' };
+        }
+        return { ok: true, value: parsed };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `arguments must be valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+function readRequiredStringField(obj, field) {
+    const value = obj[field];
+    if (typeof value !== 'string') {
+        return { ok: false, error: `field '${field}' must be a string` };
+    }
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return { ok: false, error: `field '${field}' must not be empty` };
+    }
+    return { ok: true, value: trimmed };
+}
+function readOptionalStringField(obj, field) {
+    const value = obj[field];
+    if (value === undefined) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed === '' ? null : trimmed;
+}
+function readTargetAgentId(obj) {
+    const target = readOptionalStringField(obj, 'targetAgentId') ??
+        readOptionalStringField(obj, 'agentId') ??
+        readOptionalStringField(obj, 'target');
+    if (!target) {
+        return {
+            ok: false,
+            error: "missing target agent id (expected 'targetAgentId' or 'agentId')",
+        };
+    }
+    return { ok: true, value: target };
+}
+function normalizeTeammateTargetAgentId(rawTarget) {
+    const trimmed = rawTarget.trim();
+    const withoutAt = trimmed.startsWith('@') ? trimmed.slice(1).trim() : trimmed;
+    if (withoutAt === '') {
+        return {
+            ok: false,
+            error: 'targetAgentId must not be empty',
+        };
+    }
+    return { ok: true, value: withoutAt };
+}
+function parseTellaskSpecialCall(call) {
+    if (!isTellaskSpecialFunctionName(call.name)) {
+        return { ok: false, error: `unsupported tellask special function '${call.name}'` };
+    }
+    const argsResult = parseFuncCallArgsObject(call);
+    if (!argsResult.ok) {
+        return argsResult;
+    }
+    const args = argsResult.value;
+    const tellaskContent = readRequiredStringField(args, 'tellaskContent');
+    if (!tellaskContent.ok) {
+        return tellaskContent;
+    }
+    switch (call.name) {
+        case 'tellaskBack': {
+            return {
+                ok: true,
+                value: {
+                    callId: call.id,
+                    callName: 'tellaskBack',
+                    tellaskContent: tellaskContent.value,
+                },
+            };
+        }
+        case 'askHuman': {
+            return {
+                ok: true,
+                value: {
+                    callId: call.id,
+                    callName: 'askHuman',
+                    tellaskContent: tellaskContent.value,
+                },
+            };
+        }
+        case 'freshBootsReasoning': {
+            return {
+                ok: true,
+                value: {
+                    callId: call.id,
+                    callName: 'freshBootsReasoning',
+                    tellaskContent: tellaskContent.value,
+                },
+            };
+        }
+        case 'tellask': {
+            const target = readTargetAgentId(args);
+            if (!target.ok) {
+                return target;
+            }
+            const normalizedTarget = normalizeTeammateTargetAgentId(target.value);
+            if (!normalizedTarget.ok) {
+                return normalizedTarget;
+            }
+            const sessionSlug = readRequiredStringField(args, 'sessionSlug');
+            if (!sessionSlug.ok) {
+                return sessionSlug;
+            }
+            if (!isValidSessionSlug(sessionSlug.value)) {
+                return {
+                    ok: false,
+                    error: "field 'sessionSlug' must match <alpha>[<alnum|_|->]*(.<segment>)*, e.g. 'build-loop' or 'repo.sync'",
+                };
+            }
+            return {
+                ok: true,
+                value: {
+                    callId: call.id,
+                    callName: 'tellask',
+                    targetAgentId: normalizedTarget.value,
+                    sessionSlug: sessionSlug.value,
+                    mentionList: [`@${normalizedTarget.value}`],
+                    tellaskContent: tellaskContent.value,
+                },
+            };
+        }
+        case 'tellaskSessionless': {
+            const target = readTargetAgentId(args);
+            if (!target.ok) {
+                return target;
+            }
+            const normalizedTarget = normalizeTeammateTargetAgentId(target.value);
+            if (!normalizedTarget.ok) {
+                return normalizedTarget;
+            }
+            return {
+                ok: true,
+                value: {
+                    callId: call.id,
+                    callName: 'tellaskSessionless',
+                    targetAgentId: normalizedTarget.value,
+                    mentionList: [`@${normalizedTarget.value}`],
+                    tellaskContent: tellaskContent.value,
+                },
+            };
+        }
+    }
+}
+function classifyTellaskSpecialFunctionCalls(funcCalls) {
+    const specialCalls = [];
+    const normalCalls = [];
+    const parseIssues = [];
+    for (const call of funcCalls) {
+        if (!isTellaskSpecialFunctionName(call.name)) {
+            normalCalls.push(call);
+            continue;
+        }
+        const parsed = parseTellaskSpecialCall(call);
+        if (!parsed.ok) {
+            parseIssues.push({ call, error: parsed.error });
+            continue;
+        }
+        specialCalls.push(parsed.value);
+    }
+    return { specialCalls, normalCalls, parseIssues };
+}
 function showErrorToAi(err) {
     try {
         if (err instanceof Error) {
@@ -76,7 +266,7 @@ async function syncPendingTellaskReminderBestEffort(dlg, where) {
         await dlg.processReminderUpdates();
     }
     catch (err) {
-        log_1.log.warn('Failed to sync pending tellask reminder', {
+        log_1.log.warn('Failed to sync pending tellask reminder', undefined, {
             where,
             dialogId: dlg.id.selfId,
             rootId: dlg.id.rootId,
@@ -84,75 +274,12 @@ async function syncPendingTellaskReminderBestEffort(dlg, where) {
         });
     }
 }
-function isValidTellaskSession(tellaskSession) {
-    const segments = tellaskSession.split('.');
+function isValidSessionSlug(sessionSlug) {
+    const segments = sessionSlug.split('.');
     if (segments.length === 0)
         return false;
     return segments.every((segment) => /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(segment));
 }
-function parseTellaskSessionDirectiveFromHeadline(tellaskHead) {
-    const re = /(^|\s)!tellaskSession\s+([^\s]+)/g;
-    const ids = [];
-    for (const match of tellaskHead.matchAll(re)) {
-        const raw = match[2] ?? '';
-        const candidate = raw.trim();
-        const m = candidate.match(/^([a-zA-Z][a-zA-Z0-9_-]*(?:\.[a-zA-Z0-9_-]+)*)/);
-        const tellaskSession = (m?.[1] ?? '').trim();
-        if (!isValidTellaskSession(tellaskSession)) {
-            return { kind: 'invalid' };
-        }
-        ids.push(tellaskSession);
-    }
-    const unique = Array.from(new Set(ids));
-    if (unique.length === 0)
-        return { kind: 'none' };
-    if (unique.length === 1)
-        return { kind: 'one', tellaskSession: unique[0] ?? '' };
-    return { kind: 'multiple' };
-}
-function extractSingleTellaskSessionFromHeadline(tellaskHead) {
-    const parsed = parseTellaskSessionDirectiveFromHeadline(tellaskHead);
-    if (parsed.kind === 'one')
-        return parsed.tellaskSession;
-    return null;
-}
-function parseTeammateTellask(firstMention, tellaskHead, currentDialog) {
-    if (firstMention === 'self') {
-        const agentId = currentDialog?.agentId ?? 'self';
-        const tellaskSession = extractSingleTellaskSessionFromHeadline(tellaskHead);
-        if (tellaskSession) {
-            return {
-                type: 'B',
-                agentId,
-                tellaskSession,
-            };
-        }
-        return {
-            type: 'C',
-            agentId,
-        };
-    }
-    const tellaskSession = extractSingleTellaskSessionFromHeadline(tellaskHead);
-    if (tellaskSession) {
-        return {
-            type: 'B',
-            agentId: firstMention,
-            tellaskSession,
-        };
-    }
-    if (currentDialog &&
-        currentDialog.supdialog &&
-        firstMention === currentDialog.supdialog.agentId) {
-        return {
-            type: 'A',
-            agentId: firstMention,
-        };
-    }
-    return {
-        type: 'C',
-        agentId: firstMention,
-    };
-}
 function resolveFbrEffort(member) {
     const raw = member?.fbr_effort;
     if (typeof raw !== 'number' || !Number.isFinite(raw))
@@ -183,8 +310,8 @@ async function scheduleInheritedAgentPrimingForSubdialog(callerDialog, subdialog
     const agentPrimingModule = await agentPrimingModulePromise;
     await agentPrimingModule.scheduleAgentPrimingForNewDialog(subdialog, { mode: inheritedMode });
 }
-async function createSubDialogWithInheritedPriming(callerDialog, targetAgentId, tellaskHead, tellaskBody, options) {
-    const subdialog = await callerDialog.createSubDialog(targetAgentId, tellaskHead, tellaskBody, options);
+async function createSubDialogWithInheritedPriming(callerDialog, targetAgentId, mentionList, tellaskContent, options) {
+    const subdialog = await callerDialog.createSubDialog(targetAgentId, mentionList, tellaskContent, options);
     await scheduleInheritedAgentPrimingForSubdialog(callerDialog, subdialog);
     return subdialog;
 }
@@ -192,14 +319,14 @@ async function updateSubdialogAssignment(subdialog, assignment) {
     subdialog.assignmentFromSup = assignment;
     await persistence_1.DialogPersistence.updateSubdialogAssignment(subdialog.id, assignment);
 }
-async function lookupLiveRegisteredSubdialog(rootDialog, agentId, tellaskSession) {
-    const existing = rootDialog.lookupSubdialog(agentId, tellaskSession);
+async function lookupLiveRegisteredSubdialog(rootDialog, agentId, sessionSlug) {
+    const existing = rootDialog.lookupSubdialog(agentId, sessionSlug);
     if (!existing) {
         return undefined;
     }
-    const existingSession = existing.tellaskSession;
+    const existingSession = existing.sessionSlug;
     if (!existingSession) {
-        throw new Error(`Type B registry invariant violation: lookupSubdialog returned entry without tellaskSession (root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
+        throw new Error(`Type B registry invariant violation: lookupSubdialog returned entry without sessionSlug (root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
     }
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(existing.id, rootDialog.status);
     const runState = latest?.runState;
@@ -211,11 +338,11 @@ async function lookupLiveRegisteredSubdialog(rootDialog, agentId, tellaskSession
         throw new Error(`Failed to unregister dead registered subdialog: root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()} session=${existingSession}`);
     }
     await rootDialog.saveSubdialogRegistry();
-    log_1.log.info('Pruned dead registered subdialog from Type B registry', undefined, {
+    log_1.log.debug('Pruned dead registered subdialog from Type B registry', undefined, {
         rootId: rootDialog.id.rootId,
         subdialogId: existing.id.selfId,
         agentId: existing.agentId,
-        tellaskSession: existingSession,
+        sessionSlug: existingSession,
     });
     return undefined;
 }
@@ -241,181 +368,21 @@ async function extractSupdialogResponseForTypeA(supdialog) {
         return extractLastAssistantResponse(supdialog.msgs, 'Supdialog completed without producing output.');
     }
     catch (err) {
-        log_1.log.warn('Failed to extract supdialog response for Type A', { error: err });
+        log_1.log.warn('Failed to extract supdialog response for Type A', err);
         return 'Supdialog completed with errors.';
     }
 }
-function isValidMentionChar(char) {
-    const charCode = char.charCodeAt(0);
-    return ((charCode >= 48 && charCode <= 57) ||
-        (charCode >= 65 && charCode <= 90) ||
-        (charCode >= 97 && charCode <= 122) ||
-        char === '_' ||
-        char === '-' ||
-        char === '.' ||
-        /\p{L}/u.test(char) ||
-        /\p{N}/u.test(char));
-}
-function trimTrailingDots(value) {
-    let out = value;
-    while (out.endsWith('.'))
-        out = out.slice(0, -1);
-    return out;
-}
-function isMentionBoundaryChar(char) {
-    if (char === '' || char === '\n' || char === '\t' || char === ' ')
-        return true;
-    return !isValidMentionChar(char);
-}
-function extractMentionIdsFromHeadline(tellaskHead) {
-    const out = [];
-    const seen = new Set();
-    for (let i = 0; i < tellaskHead.length; i++) {
-        const ch = tellaskHead[i] ?? '';
-        if (ch !== '@')
-            continue;
-        const prev = i === 0 ? '' : (tellaskHead[i - 1] ?? '');
-        if (!isMentionBoundaryChar(prev))
-            continue;
-        let j = i + 1;
-        let raw = '';
-        while (j < tellaskHead.length) {
-            const c = tellaskHead[j] ?? '';
-            if (c !== '' && isValidMentionChar(c)) {
-                raw += c;
-                j += 1;
-                continue;
-            }
-            break;
-        }
-        const id = trimTrailingDots(raw);
-        if (id === '')
-            continue;
-        if (!seen.has(id)) {
-            seen.add(id);
-            out.push(id);
-        }
-        i = j - 1;
-    }
-    return out;
-}
-async function emitMalformedTellaskResponses(dlg, collectedCalls) {
-    const toolOutputs = [];
-    const language = (0, runtime_language_1.getWorkLanguage)();
-    for (const call of collectedCalls) {
-        if (call.validation.kind !== 'malformed')
-            continue;
-        const firstLineAfterPrefix = (call.tellaskHead.split('\n')[0] ?? '').trim();
-        const msg = (0, driver_messages_1.formatDomindsNoteMalformedTellaskCall)(language, call.validation.reason, {
-            firstLineAfterPrefix,
-        });
-        toolOutputs.push({
-            type: 'environment_msg',
-            role: 'user',
-            content: msg,
-        });
-        toolOutputs.push({
-            type: 'tellask_result_msg',
-            role: 'tool',
-            responderId: 'dominds',
-            tellaskHead: call.tellaskHead,
-            status: 'failed',
-            content: msg,
-        });
-        await dlg.receiveTeammateCallResult('dominds', call.tellaskHead, msg, 'failed', call.callId);
-        dlg.clearCurrentCallId();
-    }
-    return toolOutputs;
-}
-async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, callId, callbacks, options) {
+async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbacks, options) {
     const toolOutputs = [];
     let suspend = false;
     const subdialogsCreated = [];
+    const callName = options.callName;
+    const parseResult = options.parseResult;
+    const normalizedMentionList = mentionList ?? [];
+    const isFreshBootsCall = callName === 'freshBootsReasoning';
     const team = await team_1.Team.load();
-    const isSelfAlias = firstMention === 'self';
-    const isTellaskerAlias = firstMention === 'tellasker';
-    const member = isSelfAlias
-        ? team.getMember(dlg.agentId)
-        : isTellaskerAlias
-            ? null
-            : team.getMember(firstMention);
-    const allowMultiTeammateTargets = options?.allowMultiTeammateTargets ?? true;
-    if (allowMultiTeammateTargets && member && !isSelfAlias && !isTellaskerAlias) {
-        const mentioned = extractMentionIdsFromHeadline(tellaskHead);
-        const uniqueMentioned = Array.from(new Set(mentioned));
-        const knownTargets = uniqueMentioned.filter((id) => team.getMember(id) !== null);
-        if (!knownTargets.includes(firstMention)) {
-            knownTargets.unshift(firstMention);
-        }
-        if (knownTargets.length >= 2) {
-            const unknown = uniqueMentioned.filter((id) => team.getMember(id) === null &&
-                id !== 'self' &&
-                id !== 'tellasker' &&
-                id !== 'human' &&
-                id !== 'dominds');
-            if (unknown.length > 0) {
-                const msg = (0, driver_messages_1.formatDomindsNoteInvalidMultiTeammateTargets)((0, runtime_language_1.getWorkLanguage)(), { unknown });
-                toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                toolOutputs.push({
-                    type: 'tellask_result_msg',
-                    role: 'tool',
-                    responderId: 'dominds',
-                    tellaskHead,
-                    status: 'failed',
-                    content: msg,
-                });
-                await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
-                dlg.clearCurrentCallId();
-                return { toolOutputs, suspend: false, subdialogsCreated: [] };
-            }
-            if (options?.skipTellaskSessionDirectiveValidation !== true) {
-                const tellaskSessionDirective = parseTellaskSessionDirectiveFromHeadline(tellaskHead);
-                if (tellaskSessionDirective.kind === 'multiple') {
-                    const msg = (0, driver_messages_1.formatDomindsNoteMultipleTellaskSessionDirectives)((0, runtime_language_1.getWorkLanguage)());
-                    toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                    toolOutputs.push({
-                        type: 'tellask_result_msg',
-                        role: 'tool',
-                        responderId: 'dominds',
-                        tellaskHead,
-                        status: 'failed',
-                        content: msg,
-                    });
-                    await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
-                    dlg.clearCurrentCallId();
-                    return { toolOutputs, suspend: false, subdialogsCreated: [] };
-                }
-                if (tellaskSessionDirective.kind === 'invalid') {
-                    const msg = (0, driver_messages_1.formatDomindsNoteInvalidTellaskSessionDirective)((0, runtime_language_1.getWorkLanguage)());
-                    toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                    toolOutputs.push({
-                        type: 'tellask_result_msg',
-                        role: 'tool',
-                        responderId: 'dominds',
-                        tellaskHead,
-                        status: 'failed',
-                        content: msg,
-                    });
-                    await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
-                    dlg.clearCurrentCallId();
-                    return { toolOutputs, suspend: false, subdialogsCreated: [] };
-                }
-            }
-            const perTargetResults = await Promise.all(knownTargets.map(async (targetId) => {
-                return await executeTellaskCall(dlg, agent, targetId, tellaskHead, body, callId, callbacks, {
-                    allowMultiTeammateTargets: false,
-                    collectiveTargets: knownTargets,
-                    skipTellaskSessionDirectiveValidation: true,
-                });
-            }));
-            return {
-                toolOutputs: perTargetResults.flatMap((r) => r.toolOutputs),
-                suspend: perTargetResults.some((r) => r.suspend),
-                subdialogsCreated: perTargetResults.flatMap((r) => r.subdialogsCreated),
-            };
-        }
-    }
-    const isQ4H = firstMention === 'human';
+    const member = parseResult !== null && parseResult.type !== 'A' ? team.getMember(parseResult.agentId) : null;
+    const isQ4H = callName === 'askHuman';
     if (isQ4H) {
         try {
             const normalizedCallId = callId.trim();
@@ -428,8 +395,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 .filter((value) => value !== '' && value !== normalizedCallId)));
             const question = {
                 id: questionId,
-                tellaskHead: tellaskHead.trim(),
-                bodyContent: body.trim(),
+                tellaskContent: body.trim(),
                 askedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 callId: normalizedCallId,
                 remainingCallIds: normalizedRemainingCallIds.length > 0 ? normalizedRemainingCallIds : undefined,
@@ -444,8 +410,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 question: {
                     id: question.id,
                     selfId: dlg.id.selfId,
-                    tellaskHead: question.tellaskHead,
-                    bodyContent: question.bodyContent,
+                    tellaskContent: question.tellaskContent,
                     askedAt: question.askedAt,
                     callId: question.callId,
                     remainingCallIds: question.remainingCallIds,
@@ -471,7 +436,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
             }
             log_1.log.error('Q4H: Failed to register question', q4hErr, {
                 dialogId: dlg.id.selfId,
-                tellaskHead: tellaskHead.substring(0, 100),
+                callId,
             });
             const msg = (0, driver_messages_1.formatDomindsNoteQ4HRegisterFailed)((0, runtime_language_1.getWorkLanguage)(), { error: errMsg });
             toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
@@ -479,89 +444,47 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 type: 'tellask_result_msg',
                 role: 'tool',
                 responderId: 'dominds',
-                tellaskHead,
+                mentionList: normalizedMentionList,
+                tellaskContent: body,
                 status: 'failed',
+                callId,
                 content: msg,
             });
-            await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
+            await dlg.receiveTeammateCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
             dlg.clearCurrentCallId();
             return { toolOutputs, suspend: false, subdialogsCreated: [] };
         }
     }
-    if (member || isSelfAlias || isTellaskerAlias) {
-        if (isTellaskerAlias && !(dlg instanceof dialog_1.SubDialog)) {
-            const response = (0, driver_messages_1.formatDomindsNoteTellaskerOnlyInSidelineDialog)((0, runtime_language_1.getWorkLanguage)());
-            try {
-                await dlg.receiveTeammateResponse('dominds', tellaskHead, 'failed', dlg.id, {
-                    response,
-                    agentId: 'dominds',
-                    callId,
-                    originMemberId: dlg.agentId,
-                });
-            }
-            catch (err) {
-                log_1.log.warn('Failed to emit @tellasker misuse response', err, {
-                    dialogId: dlg.id.selfId,
-                    agentId: dlg.agentId,
-                });
-            }
-            return { toolOutputs, suspend: false, subdialogsCreated: [] };
+    if (parseResult) {
+        if (callName === 'tellaskBack' && parseResult.type !== 'A') {
+            throw new Error(`tellaskBack invariant violation: expected Type A parseResult (callId=${callId}, got=${parseResult.type})`);
         }
-        if (options?.skipTellaskSessionDirectiveValidation !== true) {
-            const tellaskSessionDirective = parseTellaskSessionDirectiveFromHeadline(tellaskHead);
-            if (isTellaskerAlias && tellaskSessionDirective.kind !== 'none') {
-                const response = (0, driver_messages_1.formatDomindsNoteTellaskerNoTellaskSession)((0, runtime_language_1.getWorkLanguage)());
-                try {
-                    await dlg.receiveTeammateResponse('dominds', tellaskHead, 'failed', dlg.id, {
-                        response,
-                        agentId: 'dominds',
-                        callId,
-                        originMemberId: dlg.agentId,
-                    });
-                }
-                catch (err) {
-                    log_1.log.warn('Failed to emit @tellasker !tellaskSession syntax error response', err, {
-                        dialogId: dlg.id.selfId,
-                        agentId: dlg.agentId,
-                    });
-                }
-                return { toolOutputs, suspend: false, subdialogsCreated: [] };
-            }
-            if (tellaskSessionDirective.kind === 'multiple') {
-                const msg = (0, driver_messages_1.formatDomindsNoteMultipleTellaskSessionDirectives)((0, runtime_language_1.getWorkLanguage)());
-                toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                toolOutputs.push({
-                    type: 'tellask_result_msg',
-                    role: 'tool',
-                    responderId: 'dominds',
-                    tellaskHead,
-                    status: 'failed',
-                    content: msg,
-                });
-                await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
-                dlg.clearCurrentCallId();
-                return { toolOutputs, suspend: false, subdialogsCreated: [] };
-            }
-            if (tellaskSessionDirective.kind === 'invalid') {
-                const msg = (0, driver_messages_1.formatDomindsNoteInvalidTellaskSessionDirective)((0, runtime_language_1.getWorkLanguage)());
-                toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                toolOutputs.push({
-                    type: 'tellask_result_msg',
-                    role: 'tool',
-                    responderId: 'dominds',
-                    tellaskHead,
-                    status: 'failed',
-                    content: msg,
-                });
-                await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
-                dlg.clearCurrentCallId();
-                return { toolOutputs, suspend: false, subdialogsCreated: [] };
-            }
+        const subdialogCallName = callName === 'tellaskBack' ? 'freshBootsReasoning' : callName;
+        const rawCallingCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+        const callingCourse = Number.isFinite(rawCallingCourse) && rawCallingCourse > 0
+            ? Math.floor(rawCallingCourse)
+            : undefined;
+        const firstMentionForError = options.targetForError ?? parseResult.agentId;
+        if (parseResult.type !== 'A' && member === null) {
+            const msg = (0, driver_messages_1.formatDomindsNoteTellaskForTeammatesOnly)((0, runtime_language_1.getWorkLanguage)(), {
+                firstMention: firstMentionForError,
+            });
+            toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
+            toolOutputs.push({
+                type: 'tellask_result_msg',
+                role: 'tool',
+                responderId: 'dominds',
+                mentionList: normalizedMentionList,
+                tellaskContent: body,
+                status: 'failed',
+                callId,
+                content: msg,
+            });
+            await dlg.receiveTeammateCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
+            dlg.clearCurrentCallId();
+            return { toolOutputs, suspend: false, subdialogsCreated: [] };
         }
-        const parseResult = isTellaskerAlias
-            ? { type: 'A', agentId: dlg.supdialog.agentId }
-            : parseTeammateTellask(firstMention, tellaskHead, dlg);
-        if (isSelfAlias) {
+        if (isFreshBootsCall) {
             const fbrEffort = resolveFbrEffort(member);
             if (fbrEffort < 1) {
                 const msg = (0, driver_messages_1.formatDomindsNoteFbrDisabled)((0, runtime_language_1.getWorkLanguage)());
@@ -570,11 +493,13 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                     type: 'tellask_result_msg',
                     role: 'tool',
                     responderId: 'dominds',
-                    tellaskHead,
+                    mentionList: normalizedMentionList,
+                    tellaskContent: body,
                     status: 'failed',
+                    callId,
                     content: msg,
                 });
-                await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
+                await dlg.receiveTeammateCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
                 dlg.clearCurrentCallId();
                 return { toolOutputs, suspend: false, subdialogsCreated: [] };
             }
@@ -584,7 +509,8 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 const createdSubs = [];
                 const pendingRecords = [];
                 for (let i = 1; i <= fbrEffort; i++) {
-                    const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, tellaskHead, body, {
+                    const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, mentionList, body, {
+                        callName: subdialogCallName,
                         originMemberId,
                         callerDialogId: callerDialog.id.selfId,
                         callId,
@@ -594,8 +520,12 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                     pendingRecords.push({
                         subdialogId: sub.id.selfId,
                         createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        tellaskHead,
+                        callName: subdialogCallName,
+                        mentionList,
+                        tellaskContent: body,
                         targetAgentId: parseResult.agentId,
+                        callId,
+                        callingCourse,
                         callType: 'C',
                     });
                 }
@@ -609,10 +539,11 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 for (const sub of createdSubs) {
                     const initPrompt = {
                         content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                            callName: subdialogCallName,
                             fromAgentId: dlg.agentId,
                             toAgentId: sub.agentId,
-                            tellaskHead,
-                            tellaskBody: body,
+                            mentionList,
+                            tellaskContent: body,
                             language: (0, runtime_language_1.getWorkLanguage)(),
                             collectiveTargets: options?.collectiveTargets ?? [sub.agentId],
                         }),
@@ -646,16 +577,18 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                         type: 'tellask_result_msg',
                         role: 'tool',
                         responderId: 'dominds',
-                        tellaskHead,
+                        mentionList: normalizedMentionList,
+                        tellaskContent: body,
                         status: 'failed',
+                        callId,
                         content: msg,
                     });
-                    await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
+                    await dlg.receiveTeammateCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
                     dlg.clearCurrentCallId();
                     return { toolOutputs, suspend: false, subdialogsCreated: [] };
                 }
                 const pendingOwner = callerDialog;
-                const baseSession = parseResult.tellaskSession;
+                const baseSession = parseResult.sessionSlug;
                 const derivedPrefix = `${baseSession}.fbr-`;
                 const createdOrExisting = await (0, subdialog_txn_1.withSubdialogTxnLock)(rootDialog.id, async () => {
                     const results = [];
@@ -664,14 +597,14 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                             return [baseSession];
                         const set = new Set();
                         for (const sub of rootDialog.getRegisteredSubdialogs()) {
-                            const tellaskSession = sub.tellaskSession;
-                            if (typeof tellaskSession !== 'string')
+                            const sessionSlug = sub.sessionSlug;
+                            if (typeof sessionSlug !== 'string')
                                 continue;
                             if (sub.agentId !== parseResult.agentId)
                                 continue;
-                            if (!tellaskSession.startsWith(derivedPrefix))
+                            if (!sessionSlug.startsWith(derivedPrefix))
                                 continue;
-                            set.add(tellaskSession);
+                            set.add(sessionSlug);
                         }
                         while (set.size < desired) {
                             const candidate = `${derivedPrefix}${(0, id_1.generateShortId)()}`;
@@ -688,10 +621,10 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                     };
                     const sessions = ensurePoolSessions(fbrEffort);
                     for (const derivedSession of sessions) {
-                        const indexedHeadLine = tellaskHead;
                         const assignment = {
-                            tellaskHead: indexedHeadLine,
-                            tellaskBody: body,
+                            callName: subdialogCallName,
+                            mentionList,
+                            tellaskContent: body,
                             originMemberId,
                             callerDialogId: callerDialog.id.selfId,
                             callId,
@@ -708,24 +641,23 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                             results.push({
                                 kind: 'existing',
                                 subdialog: existing,
-                                tellaskSession: derivedSession,
-                                indexedHeadLine,
+                                sessionSlug: derivedSession,
                             });
                             continue;
                         }
-                        const created = await createSubDialogWithInheritedPriming(rootDialog, parseResult.agentId, indexedHeadLine, body, {
+                        const created = await createSubDialogWithInheritedPriming(rootDialog, parseResult.agentId, mentionList, body, {
+                            callName: subdialogCallName,
                             originMemberId,
                             callerDialogId: callerDialog.id.selfId,
                             callId,
-                            tellaskSession: derivedSession,
+                            sessionSlug: derivedSession,
                             collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                         });
                         rootDialog.registerSubdialog(created);
                         results.push({
                             kind: 'created',
                             subdialog: created,
-                            tellaskSession: derivedSession,
-                            indexedHeadLine,
+                            sessionSlug: derivedSession,
                         });
                     }
                     await rootDialog.saveSubdialogRegistry();
@@ -734,10 +666,14 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 const pendingRecords = createdOrExisting.map((r) => ({
                     subdialogId: r.subdialog.id.selfId,
                     createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                    tellaskHead: r.indexedHeadLine,
+                    callName: subdialogCallName,
+                    mentionList,
+                    tellaskContent: body,
                     targetAgentId: parseResult.agentId,
+                    callId,
+                    callingCourse,
                     callType: 'B',
-                    tellaskSession: r.tellaskSession,
+                    sessionSlug: r.sessionSlug,
                 }));
                 await (0, subdialog_txn_1.withSubdialogTxnLock)(pendingOwner.id, async () => {
                     const toRemove = new Set(pendingRecords.map((p) => p.subdialogId));
@@ -751,10 +687,11 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 for (const r of createdOrExisting) {
                     const prompt = {
                         content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                            callName: subdialogCallName,
                             fromAgentId: dlg.agentId,
                             toAgentId: r.subdialog.agentId,
-                            tellaskHead: r.indexedHeadLine,
-                            tellaskBody: body,
+                            mentionList,
+                            tellaskContent: body,
                             language: (0, runtime_language_1.getWorkLanguage)(),
                             collectiveTargets: options?.collectiveTargets ?? [r.subdialog.agentId],
                         }),
@@ -772,44 +709,43 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 return { toolOutputs, suspend: true, subdialogsCreated };
             }
         }
-        const isDirectSelfCall = !isSelfAlias && !isTellaskerAlias && parseResult.agentId === dlg.agentId;
+        const isDirectSelfCall = !isFreshBootsCall && parseResult.agentId === dlg.agentId;
         if (isDirectSelfCall) {
-            const response = (0, driver_messages_1.formatDomindsNoteDirectSelfCall)((0, runtime_language_1.getWorkLanguage)());
-            try {
-                await dlg.receiveTeammateResponse('dominds', tellaskHead, 'completed', dlg.id, {
-                    response,
-                    agentId: 'dominds',
-                    callId,
-                    originMemberId: dlg.agentId,
-                });
-            }
-            catch (err) {
-                log_1.log.warn('Failed to emit self-tellask correction response', err, {
-                    dialogId: dlg.id.selfId,
-                    agentId: dlg.agentId,
-                });
-            }
+            const msg = (0, driver_messages_1.formatDomindsNoteDirectSelfCall)((0, runtime_language_1.getWorkLanguage)());
+            toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
+            toolOutputs.push({
+                type: 'tellask_result_msg',
+                role: 'tool',
+                responderId: 'dominds',
+                mentionList: normalizedMentionList,
+                tellaskContent: body,
+                status: 'failed',
+                callId,
+                content: msg,
+            });
+            await dlg.receiveTeammateCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
+            dlg.clearCurrentCallId();
+            return { toolOutputs, suspend: false, subdialogsCreated: [] };
         }
         if (parseResult.type === 'A') {
             if (dlg instanceof dialog_1.SubDialog) {
                 const supdialog = dlg.supdialog;
                 dlg.setSuspensionState('suspended');
                 try {
-                    const tellaskHeadForSupdialog = isTellaskerAlias && tellaskHead.startsWith('@tellasker')
-                        ? `@${supdialog.agentId}${tellaskHead.slice('@tellasker'.length)}`
-                        : tellaskHead;
                     const assignment = dlg.assignmentFromSup;
                     const supPrompt = {
                         content: (0, inter_dialog_format_1.formatSupdialogCallPrompt)({
                             fromAgentId: dlg.agentId,
                             toAgentId: supdialog.agentId,
                             subdialogRequest: {
-                                tellaskHead: tellaskHeadForSupdialog,
-                                tellaskBody: body,
+                                callName,
+                                mentionList,
+                                tellaskContent: body,
                             },
                             supdialogAssignment: {
-                                tellaskHead: assignment.tellaskHead,
-                                tellaskBody: assignment.tellaskBody,
+                                callName: assignment.callName,
+                                mentionList: assignment.mentionList,
+                                tellaskContent: assignment.tellaskContent,
                             },
                             language: (0, runtime_language_1.getWorkLanguage)(),
                         }),
@@ -819,9 +755,11 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                     await callbacks.driveDialog(supdialog, { humanPrompt: supPrompt, waitInQue: true });
                     const responseText = await extractSupdialogResponseForTypeA(supdialog);
                     const responseContent = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                        callName,
                         responderId: parseResult.agentId,
                         requesterId: dlg.agentId,
-                        originalCallHeadLine: tellaskHead,
+                        mentionList,
+                        tellaskContent: body,
                         responseBody: responseText,
                         language: (0, runtime_language_1.getWorkLanguage)(),
                     });
@@ -830,11 +768,13 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                         type: 'tellask_result_msg',
                         role: 'tool',
                         responderId: parseResult.agentId,
-                        tellaskHead,
+                        mentionList,
+                        tellaskContent: body,
                         status: 'completed',
+                        callId,
                         content: responseContent,
                     });
-                    await dlg.receiveTeammateResponse(parseResult.agentId, tellaskHead, 'completed', supdialog.id, {
+                    await dlg.receiveTeammateResponse(parseResult.agentId, callName, mentionList, body, 'completed', supdialog.id, {
                         response: responseText,
                         agentId: parseResult.agentId,
                         callId,
@@ -849,11 +789,13 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                         type: 'tellask_result_msg',
                         role: 'tool',
                         responderId: parseResult.agentId,
-                        tellaskHead,
+                        mentionList,
+                        tellaskContent: body,
                         status: 'failed',
+                        callId,
                         content: errorText,
                     });
-                    await dlg.receiveTeammateResponse(parseResult.agentId, tellaskHead, 'failed', supdialog.id, {
+                    await dlg.receiveTeammateResponse(parseResult.agentId, callName, mentionList, body, 'failed', supdialog.id, {
                         response: errorText,
                         agentId: parseResult.agentId,
                         callId,
@@ -862,7 +804,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 }
             }
             else {
-                log_1.log.warn('Type A call on dialog without supdialog, falling back to Type C', {
+                log_1.log.warn('Type A call on dialog without supdialog, falling back to Type C', undefined, {
                     dialogId: dlg.id.selfId,
                 });
             }
@@ -877,24 +819,29 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 rootDialog = dlg.rootDialog;
             }
             if (!rootDialog) {
-                log_1.log.warn('Type B call without root dialog, falling back to Type C', {
+                log_1.log.warn('Type B call without root dialog, falling back to Type C', undefined, {
                     dialogId: dlg.id.selfId,
                 });
                 try {
-                    const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, tellaskHead, body, {
+                    const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, mentionList, body, {
+                        callName: subdialogCallName,
                         originMemberId: dlg.agentId,
                         callerDialogId: callerDialog.id.selfId,
                         callId,
-                        tellaskSession: parseResult.tellaskSession,
+                        sessionSlug: parseResult.sessionSlug,
                         collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                     });
                     const pendingRecord = {
                         subdialogId: sub.id.selfId,
                         createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                        tellaskHead,
+                        callName: subdialogCallName,
+                        mentionList,
+                        tellaskContent: body,
                         targetAgentId: parseResult.agentId,
+                        callId,
+                        callingCourse,
                         callType: 'C',
-                        tellaskSession: parseResult.tellaskSession,
+                        sessionSlug: parseResult.sessionSlug,
                     };
                     await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
                         await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord);
@@ -902,10 +849,11 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                     await syncPendingTellaskReminderBestEffort(dlg, 'driver-v2:executeTellaskCall:TypeB-fallback:appendPending');
                     const initPrompt = {
                         content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                            callName: subdialogCallName,
                             fromAgentId: dlg.agentId,
                             toAgentId: sub.agentId,
-                            tellaskHead,
-                            tellaskBody: body,
+                            mentionList,
+                            tellaskContent: body,
                             language: (0, runtime_language_1.getWorkLanguage)(),
                             collectiveTargets: options?.collectiveTargets ?? [sub.agentId],
                         }),
@@ -928,8 +876,9 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
             else {
                 const originMemberId = dlg.agentId;
                 const assignment = {
-                    tellaskHead,
-                    tellaskBody: body,
+                    callName: subdialogCallName,
+                    mentionList,
+                    tellaskContent: body,
                     originMemberId,
                     callerDialogId: callerDialog.id.selfId,
                     callId,
@@ -937,7 +886,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 };
                 const pendingOwner = callerDialog;
                 const result = await (0, subdialog_txn_1.withSubdialogTxnLock)(rootDialog.id, async () => {
-                    const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, parseResult.tellaskSession);
+                    const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, parseResult.sessionSlug);
                     if (existing) {
                         try {
                             await updateSubdialogAssignment(existing, assignment);
@@ -947,11 +896,12 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                         }
                         return { kind: 'existing', subdialog: existing };
                     }
-                    const created = await createSubDialogWithInheritedPriming(rootDialog, parseResult.agentId, tellaskHead, body, {
+                    const created = await createSubDialogWithInheritedPriming(rootDialog, parseResult.agentId, mentionList, body, {
+                        callName: subdialogCallName,
                         originMemberId,
                         callerDialogId: callerDialog.id.selfId,
                         callId,
-                        tellaskSession: parseResult.tellaskSession,
+                        sessionSlug: parseResult.sessionSlug,
                         collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                     });
                     rootDialog.registerSubdialog(created);
@@ -961,10 +911,14 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 const pendingRecord = {
                     subdialogId: result.subdialog.id.selfId,
                     createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                    tellaskHead,
+                    callName: subdialogCallName,
+                    mentionList,
+                    tellaskContent: body,
                     targetAgentId: parseResult.agentId,
+                    callId,
+                    callingCourse,
                     callType: 'B',
-                    tellaskSession: parseResult.tellaskSession,
+                    sessionSlug: parseResult.sessionSlug,
                 };
                 await (0, subdialog_txn_1.withSubdialogTxnLock)(pendingOwner.id, async () => {
                     await persistence_1.DialogPersistence.mutatePendingSubdialogs(pendingOwner.id, (previous) => {
@@ -977,10 +931,11 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 if (result.kind === 'existing') {
                     const resumePrompt = {
                         content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                            callName: subdialogCallName,
                             fromAgentId: dlg.agentId,
                             toAgentId: result.subdialog.agentId,
-                            tellaskHead,
-                            tellaskBody: body,
+                            mentionList,
+                            tellaskContent: body,
                             language: (0, runtime_language_1.getWorkLanguage)(),
                             collectiveTargets: options?.collectiveTargets ?? [result.subdialog.agentId],
                         }),
@@ -997,10 +952,11 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 else {
                     const initPrompt = {
                         content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                            callName: subdialogCallName,
                             fromAgentId: rootDialog.agentId,
                             toAgentId: result.subdialog.agentId,
-                            tellaskHead,
-                            tellaskBody: body,
+                            mentionList,
+                            tellaskContent: body,
                             language: (0, runtime_language_1.getWorkLanguage)(),
                             collectiveTargets: options?.collectiveTargets ?? [result.subdialog.agentId],
                         }),
@@ -1020,7 +976,8 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
         }
         if (parseResult.type === 'C') {
             try {
-                const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, tellaskHead, body, {
+                const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, mentionList, body, {
+                    callName: subdialogCallName,
                     originMemberId: dlg.agentId,
                     callerDialogId: dlg.id.selfId,
                     callId,
@@ -1029,8 +986,12 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 const pendingRecord = {
                     subdialogId: sub.id.selfId,
                     createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                    tellaskHead,
+                    callName: subdialogCallName,
+                    mentionList,
+                    tellaskContent: body,
                     targetAgentId: parseResult.agentId,
+                    callId,
+                    callingCourse,
                     callType: 'C',
                 };
                 await (0, subdialog_txn_1.withSubdialogTxnLock)(dlg.id, async () => {
@@ -1039,10 +1000,11 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 await syncPendingTellaskReminderBestEffort(dlg, 'driver-v2:executeTellaskCall:TypeC:appendPending');
                 const initPrompt = {
                     content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                        callName,
                         fromAgentId: dlg.agentId,
                         toAgentId: sub.agentId,
-                        tellaskHead,
-                        tellaskBody: body,
+                        mentionList,
+                        tellaskContent: body,
                         language: (0, runtime_language_1.getWorkLanguage)(),
                         collectiveTargets: options?.collectiveTargets ?? [sub.agentId],
                     }),
@@ -1064,83 +1026,223 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
         }
     }
     else {
-        const msg = (0, driver_messages_1.formatDomindsNoteTellaskForTeammatesOnly)((0, runtime_language_1.getWorkLanguage)(), { firstMention });
+        const msg = callName === 'tellaskBack'
+            ? (0, driver_messages_1.formatDomindsNoteTellaskerOnlyInSidelineDialog)((0, runtime_language_1.getWorkLanguage)())
+            : (0, driver_messages_1.formatDomindsNoteTellaskForTeammatesOnly)((0, runtime_language_1.getWorkLanguage)(), {
+                firstMention: options.targetForError ?? 'unknown',
+            });
         toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
         toolOutputs.push({
             type: 'tellask_result_msg',
             role: 'tool',
             responderId: 'dominds',
-            tellaskHead,
+            mentionList: normalizedMentionList,
+            tellaskContent: body,
             status: 'failed',
+            callId,
             content: msg,
         });
-        await dlg.receiveTeammateCallResult('dominds', tellaskHead, msg, 'failed', callId);
+        await dlg.receiveTeammateCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
         dlg.clearCurrentCallId();
     }
     return { toolOutputs, suspend, subdialogsCreated };
 }
-async function executeTellaskCalls(args) {
-    const { dlg, agent, collectedCalls } = args;
-    const callbacks = ensureCallbacks(args.callbacks);
-    const malformedToolOutputs = await emitMalformedTellaskResponses(dlg, collectedCalls);
-    const validCalls = collectedCalls.filter((call) => call.validation.kind === 'valid');
-    const q4hCalls = validCalls.filter((call) => call.validation.firstMention === 'human');
-    const nonQ4HCalls = validCalls
-        .filter((call) => call.validation.firstMention !== 'human')
-        .map((call) => ({ ...call }));
-    let mergedQ4HCall = null;
-    if (q4hCalls.length === 1) {
-        mergedQ4HCall = { ...q4hCalls[0] };
+async function emitTellaskSpecialCallEvents(args) {
+    await args.dlg.callingStart({
+        callName: args.callName,
+        callId: args.callId,
+        mentionList: args.mentionList,
+        tellaskContent: args.tellaskContent,
+    });
+}
+function toExecutableValidTellaskCall(call) {
+    switch (call.callName) {
+        case 'tellaskBack':
+            return {
+                callName: call.callName,
+                tellaskContent: call.tellaskContent,
+                callId: call.callId,
+            };
+        case 'tellask':
+            return {
+                callName: call.callName,
+                mentionList: [...call.mentionList],
+                tellaskContent: call.tellaskContent,
+                targetAgentId: call.targetAgentId,
+                sessionSlug: call.sessionSlug,
+                callId: call.callId,
+            };
+        case 'tellaskSessionless':
+            return {
+                callName: call.callName,
+                mentionList: [...call.mentionList],
+                tellaskContent: call.tellaskContent,
+                targetAgentId: call.targetAgentId,
+                callId: call.callId,
+            };
+        case 'askHuman':
+            return {
+                callName: call.callName,
+                tellaskContent: call.tellaskContent,
+                callId: call.callId,
+            };
+        case 'freshBootsReasoning':
+            return {
+                callName: call.callName,
+                tellaskContent: call.tellaskContent,
+                callId: call.callId,
+            };
     }
-    else if (q4hCalls.length > 1) {
-        const primary = q4hCalls[0];
-        const remainingCallIds = q4hCalls
-            .slice(1)
-            .map((call) => call.callId.trim())
-            .filter((callId) => callId !== '');
-        const language = (0, runtime_language_1.getWorkLanguage)();
-        const intro = language === 'zh'
-            ? `我这次有 ${q4hCalls.length} 个问题，想请你一次性回复：`
-            : `I have ${q4hCalls.length} questions this round. Please answer them in one response:`;
-        const mergedBody = [
-            intro,
-            ...q4hCalls.map((call, index) => {
-                const body = call.body.trim();
-                const normalizedBody = body !== ''
-                    ? body
-                    : language === 'zh'
-                        ? '请结合当前上下文补充这一项。'
-                        : 'Please provide this item based on the current context.';
-                return language === 'zh'
-                    ? `问题 ${index + 1}：\n${normalizedBody}`
-                    : `Question ${index + 1}:\n${normalizedBody}`;
-            }),
-        ].join('\n\n');
-        mergedQ4HCall = {
-            ...primary,
-            body: mergedBody,
-            q4hRemainingCallIds: remainingCallIds.length > 0 ? remainingCallIds : undefined,
-        };
-        log_1.log.info('Q4H multi-question normalized into a single prompt', undefined, {
-            rootId: dlg.id.rootId,
-            selfId: dlg.id.selfId,
-            mergedCount: q4hCalls.length,
-            primaryCallId: primary.callId,
-            remainingCallIds,
-        });
+}
+function normalizeQ4HCalls(calls, dlg) {
+    const q4hCalls = calls.filter((call) => call.callName === 'askHuman');
+    const nonQ4HCalls = calls
+        .filter((call) => call.callName !== 'askHuman')
+        .map((call) => {
+        switch (call.callName) {
+            case 'tellask':
+            case 'tellaskSessionless':
+                return { ...call, mentionList: [...call.mentionList] };
+            case 'tellaskBack':
+            case 'freshBootsReasoning':
+                return { ...call };
+        }
+    });
+    if (q4hCalls.length <= 1) {
+        return q4hCalls.length === 1 ? [...nonQ4HCalls, { ...q4hCalls[0] }] : nonQ4HCalls;
     }
-    const executionCalls = mergedQ4HCall
-        ? [...nonQ4HCalls, mergedQ4HCall]
-        : nonQ4HCalls;
+    const primary = q4hCalls[0];
+    const remainingCallIds = q4hCalls
+        .slice(1)
+        .map((call) => call.callId.trim())
+        .filter((callId) => callId !== '');
+    const language = (0, runtime_language_1.getWorkLanguage)();
+    const intro = language === 'zh'
+        ? `我这次有 ${q4hCalls.length} 个问题，想请你一次性回复：`
+        : `I have ${q4hCalls.length} questions this round. Please answer them in one response:`;
+    const mergedBody = [
+        intro,
+        ...q4hCalls.map((call, index) => {
+            const body = call.tellaskContent.trim();
+            const normalizedBody = body !== ''
+                ? body
+                : language === 'zh'
+                    ? '请结合当前上下文补充这一项。'
+                    : 'Please provide this item based on the current context.';
+            return language === 'zh'
+                ? `问题 ${index + 1}：\n${normalizedBody}`
+                : `Question ${index + 1}:\n${normalizedBody}`;
+        }),
+    ].join('\n\n');
+    const mergedQ4HCall = {
+        callName: 'askHuman',
+        callId: primary.callId,
+        tellaskContent: mergedBody,
+        q4hRemainingCallIds: remainingCallIds.length > 0 ? remainingCallIds : undefined,
+    };
+    log_1.log.debug('Q4H multi-question normalized into a single prompt', undefined, {
+        rootId: dlg.id.rootId,
+        selfId: dlg.id.selfId,
+        mergedCount: q4hCalls.length,
+        primaryCallId: primary.callId,
+        remainingCallIds,
+    });
+    return [...nonQ4HCalls, mergedQ4HCall];
+}
+async function executeValidTellaskCalls(args) {
+    const executionCalls = normalizeQ4HCalls(args.calls, args.dlg);
     const results = [];
     for (const call of executionCalls) {
-        const result = await executeTellaskCall(dlg, agent, call.validation.firstMention, call.tellaskHead, call.body, call.callId, callbacks, {
+        const runtimeMentionList = (() => {
+            switch (call.callName) {
+                case 'tellask':
+                case 'tellaskSessionless':
+                    return call.mentionList;
+                case 'tellaskBack':
+                case 'askHuman':
+                case 'freshBootsReasoning':
+                    return undefined;
+            }
+        })();
+        if (args.emitCallEvents) {
+            await emitTellaskSpecialCallEvents({
+                dlg: args.dlg,
+                callName: call.callName,
+                mentionList: runtimeMentionList,
+                tellaskContent: call.tellaskContent,
+                callId: call.callId,
+            });
+        }
+        let targetForError;
+        let parseResult;
+        switch (call.callName) {
+            case 'tellaskBack': {
+                targetForError = args.dlg instanceof dialog_1.SubDialog ? args.dlg.supdialog.agentId : undefined;
+                parseResult =
+                    args.dlg instanceof dialog_1.SubDialog ? { type: 'A', agentId: args.dlg.supdialog.agentId } : null;
+                break;
+            }
+            case 'tellask': {
+                const targetAgentId = call.targetAgentId;
+                if (targetAgentId.trim() === '') {
+                    throw new Error(`tellask invariant violation: missing targetAgentId for callId=${call.callId}`);
+                }
+                if (!call.sessionSlug) {
+                    throw new Error(`tellask invariant violation: missing sessionSlug for callId=${call.callId}`);
+                }
+                targetForError = targetAgentId;
+                parseResult = { type: 'B', agentId: targetAgentId, sessionSlug: call.sessionSlug };
+                break;
+            }
+            case 'tellaskSessionless': {
+                const targetAgentId = call.targetAgentId;
+                if (targetAgentId.trim() === '') {
+                    throw new Error(`tellaskSessionless invariant violation: missing targetAgentId for callId=${call.callId}`);
+                }
+                targetForError = targetAgentId;
+                parseResult = { type: 'C', agentId: targetAgentId };
+                break;
+            }
+            case 'askHuman': {
+                targetForError = undefined;
+                parseResult = null;
+                break;
+            }
+            case 'freshBootsReasoning': {
+                targetForError = args.dlg.agentId;
+                parseResult = { type: 'C', agentId: args.dlg.agentId };
+                break;
+            }
+        }
+        const result = await executeTellaskCall(args.dlg, args.agent, runtimeMentionList, call.tellaskContent, call.callId, args.callbacks, {
+            callName: call.callName,
+            parseResult,
+            targetForError,
             q4hRemainingCallIds: call.q4hRemainingCallIds,
         });
         results.push(result);
     }
-    const suspend = results.some((result) => result.suspend);
-    const toolOutputs = [...malformedToolOutputs, ...results.flatMap((result) => result.toolOutputs)];
-    const subdialogsCreated = results.flatMap((result) => result.subdialogsCreated);
-    return { suspend, toolOutputs, subdialogsCreated };
+    return {
+        suspend: results.some((result) => result.suspend),
+        toolOutputs: results.flatMap((result) => result.toolOutputs),
+        subdialogsCreated: results.flatMap((result) => result.subdialogsCreated),
+    };
+}
+async function executeTellaskSpecialCalls(args) {
+    const callbacks = ensureCallbacks(args.callbacks);
+    if (args.calls.length === 0) {
+        return { suspend: false, toolOutputs: [], subdialogsCreated: [] };
+    }
+    const tellaskResult = await executeValidTellaskCalls({
+        dlg: args.dlg,
+        agent: args.agent,
+        calls: args.calls.map((call) => toExecutableValidTellaskCall(call)),
+        callbacks,
+        emitCallEvents: true,
+    });
+    return {
+        suspend: tellaskResult.suspend,
+        toolOutputs: tellaskResult.toolOutputs,
+        subdialogsCreated: tellaskResult.subdialogsCreated,
+    };
 }