dominds 1.2.5 → 1.2.7

package/dist/llm/driver.js

@@ -0,0 +1,4093 @@
+"use strict";
+/**
+ * Module: llm/driver
+ *
+ * Drives dialog streaming end-to-end:
+ * - Loads minds/tools, selects generator, streams outputs
+ * - Parses tellask blocks (teammate tellasks), handles human prompts
+ * - Supports autonomous teammate tellasks: when an agent mentions a teammate (e.g., @teammate), a subdialog is created and driven; the parent logs the initiating assistant bubble and system creation/result, while subdialog conversation stays in the subdialog
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSayingEventsReceiver = createSayingEventsReceiver;
+exports.emitThinkingEvents = emitThinkingEvents;
+exports.emitSayingEvents = emitSayingEvents;
+exports.driveDialogStream = driveDialogStream;
+exports.driveDialogStreamCoreV1 = driveDialogStreamCoreV1;
+exports.runBackendDriver = runBackendDriver;
+exports.checkAndReviveSuspendedDialogs = checkAndReviveSuspendedDialogs;
+exports.restoreDialogHierarchy = restoreDialogHierarchy;
+exports.parseTeammateTellask = parseTeammateTellask;
+exports.continueDialogWithHumanResponse = continueDialogWithHumanResponse;
+exports.continueRootDialog = continueRootDialog;
+exports.createSubdialogForSupdialog = createSubdialogForSupdialog;
+exports.supplyResponseToSupdialog = supplyResponseToSupdialog;
+exports.areAllSubdialogsSatisfied = areAllSubdialogsSatisfied;
+exports.incorporateSubdialogResponses = incorporateSubdialogResponses;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dialog_1 = require("../dialog");
+const util_1 = require("util");
+const dialog_global_registry_1 = require("../dialog-global-registry");
+const dialog_instance_registry_1 = require("../dialog-instance-registry");
+const dialog_run_state_1 = require("../dialog-run-state");
+const evt_registry_1 = require("../evt-registry");
+const log_1 = require("../log");
+const load_1 = require("../minds/load");
+const system_prompt_parts_1 = require("../minds/system-prompt-parts");
+const persistence_1 = require("../persistence");
+const problems_1 = require("../problems");
+const async_fifo_mutex_1 = require("../shared/async-fifo-mutex");
+const diligence_1 = require("../shared/diligence");
+const driver_messages_1 = require("../shared/i18n/driver-messages");
+const runtime_language_1 = require("../shared/runtime-language");
+const id_1 = require("../shared/utils/id");
+const inter_dialog_format_1 = require("../shared/utils/inter-dialog-format");
+const time_1 = require("../shared/utils/time");
+const team_1 = require("../team");
+const tellask_1 = require("../tellask");
+const tool_1 = require("../tool");
+const pending_tellask_reminder_1 = require("../tools/pending-tellask-reminder");
+const id_2 = require("../utils/id");
+const taskdoc_1 = require("../utils/taskdoc");
+const client_1 = require("./client");
+const context_1 = require("./driver-v2/context");
+const registry_1 = require("./gen/registry");
+const tools_projection_1 = require("./tools-projection");
+const DEFAULT_KEEP_GOING_MAX_NUM_PROMPTS = diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
+function isNodeErrorWithCode(error) {
+    return error instanceof Error && 'code' in error;
+}
+function resolveMemberDiligencePushMax(team, agentId) {
+    const member = team.getMember(agentId);
+    if (member && member.diligence_push_max !== undefined) {
+        return member.diligence_push_max;
+    }
+    return DEFAULT_KEEP_GOING_MAX_NUM_PROMPTS;
+}
+async function syncPendingTellaskReminderBestEffort(dlg, where) {
+    try {
+        const changed = await (0, pending_tellask_reminder_1.syncPendingTellaskReminderState)(dlg);
+        if (!changed)
+            return;
+        await dlg.processReminderUpdates();
+    }
+    catch (err) {
+        log_1.log.warn('Failed to sync pending tellask reminder', {
+            where,
+            dialogId: dlg.id.selfId,
+            rootId: dlg.id.rootId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+function stripMarkdownFrontmatter(raw) {
+    // We no longer honor frontmatter config in diligence files.
+    // If frontmatter exists, strip it to preserve backward compatibility with old files.
+    const match = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?([\s\S]*)$/);
+    return match ? (match[1] ?? '') : raw;
+}
+async function resolveRtwsDiligenceConfig(workLanguage) {
+    const langSpecificPath = path.resolve(process.cwd(), '.minds', `diligence.${workLanguage}.md`);
+    const genericPath = path.resolve(process.cwd(), '.minds', 'diligence.md');
+    async function resolveFromFile(filePath) {
+        let raw;
+        try {
+            raw = await fs.promises.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (isNodeErrorWithCode(error) && error.code === 'ENOENT') {
+                return null;
+            }
+            log_1.log.warn('Failed to read rtws diligence file; falling back to built-in defaults', error, {
+                filePath,
+            });
+            return {
+                kind: 'enabled',
+                diligenceText: diligence_1.DILIGENCE_FALLBACK_TEXT[workLanguage],
+            };
+        }
+        const trimmed = raw.trim();
+        // Existing empty file explicitly disables Diligence Push.
+        if (trimmed === '') {
+            return { kind: 'disabled', reason: 'empty_file' };
+        }
+        const bodyTrimmed = stripMarkdownFrontmatter(raw).trim();
+        if (bodyTrimmed === '') {
+            return { kind: 'disabled', reason: 'empty_body' };
+        }
+        return { kind: 'enabled', diligenceText: bodyTrimmed };
+    }
+    const langSpecific = await resolveFromFile(langSpecificPath);
+    if (langSpecific) {
+        return langSpecific;
+    }
+    const generic = await resolveFromFile(genericPath);
+    if (generic) {
+        return generic;
+    }
+    // No diligence file found: use built-in prompt + default max.
+    return {
+        kind: 'enabled',
+        diligenceText: diligence_1.DILIGENCE_FALLBACK_TEXT[workLanguage],
+    };
+}
+async function maybePrepareDiligenceAutoContinuePrompt(options) {
+    if (!options.isRootDialog) {
+        return { kind: 'disabled', nextRemainingBudget: options.remainingBudget };
+    }
+    if (options.dlg.disableDiligencePush || options.suppressDiligencePush === true) {
+        const normalizedRemaining = typeof options.remainingBudget === 'number' && Number.isFinite(options.remainingBudget)
+            ? Math.max(0, Math.floor(options.remainingBudget))
+            : 0;
+        return { kind: 'disabled', nextRemainingBudget: normalizedRemaining };
+    }
+    const resolved = await resolveRtwsDiligenceConfig((0, runtime_language_1.getWorkLanguage)());
+    if (resolved.kind === 'disabled') {
+        return { kind: 'disabled', nextRemainingBudget: options.remainingBudget };
+    }
+    const maxInjectCount = typeof options.diligencePushMax === 'number' && Number.isFinite(options.diligencePushMax)
+        ? Math.floor(options.diligencePushMax)
+        : 0;
+    const normalizedRemaining = typeof options.remainingBudget === 'number' && Number.isFinite(options.remainingBudget)
+        ? Math.max(0, Math.floor(options.remainingBudget))
+        : 0;
+    // When max <= 0, Diligence Push is disabled by config, but can be manually refilled via UI.
+    if (maxInjectCount < 1) {
+        if (normalizedRemaining < 1) {
+            return { kind: 'disabled', nextRemainingBudget: 0 };
+        }
+        const prompt = {
+            content: resolved.diligenceText,
+            msgId: (0, id_1.generateShortId)(),
+            grammar: 'markdown',
+            origin: 'diligence_push',
+            persistMode: 'persist',
+        };
+        return {
+            kind: 'prompt',
+            prompt,
+            maxInjectCount: 0,
+            nextRemainingBudget: normalizedRemaining - 1,
+        };
+    }
+    const currentRemaining = Math.min(normalizedRemaining, maxInjectCount);
+    if (currentRemaining < 1) {
+        return { kind: 'budget_exhausted', maxInjectCount, nextRemainingBudget: 0 };
+    }
+    const prompt = {
+        content: resolved.diligenceText,
+        msgId: (0, id_1.generateShortId)(),
+        grammar: 'markdown',
+        origin: 'diligence_push',
+        persistMode: 'persist',
+    };
+    return {
+        kind: 'prompt',
+        prompt,
+        maxInjectCount,
+        nextRemainingBudget: currentRemaining - 1,
+    };
+}
+async function suspendForKeepGoingBudgetExhausted(options) {
+    const { dlg, maxInjectCount } = options;
+    const questionId = `q4h-${(0, id_2.generateDialogID)()}`;
+    const language = dlg.getLastUserLanguageCode();
+    const question = {
+        id: questionId,
+        tellaskHead: '@human',
+        bodyContent: (0, driver_messages_1.formatQ4HDiligencePushBudgetExhausted)(language, { maxInjectCount }),
+        askedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        callSiteRef: {
+            course: dlg.currentCourse,
+            messageIndex: dlg.msgs.length,
+        },
+    };
+    await persistence_1.DialogPersistence.appendQuestion4HumanState(dlg.id, question);
+    const newQuestionEvent = {
+        type: 'new_q4h_asked',
+        question: {
+            id: question.id,
+            selfId: dlg.id.selfId,
+            tellaskHead: question.tellaskHead,
+            bodyContent: question.bodyContent,
+            askedAt: question.askedAt,
+            callId: question.callId,
+            callSiteRef: question.callSiteRef,
+            rootId: dlg.id.rootId,
+            agentId: dlg.agentId,
+            taskDocPath: dlg.taskDocPath,
+        },
+    };
+    (0, evt_registry_1.postDialogEvent)(dlg, newQuestionEvent);
+}
+function showErrorToAi(err) {
+    try {
+        if (err instanceof Error) {
+            return `${err.name}: ${err.message}${err.stack ? `\n${err.stack}` : ''}`;
+        }
+        if (typeof err === 'string') {
+            const s = err.trim();
+            return s.length > 500 ? s.slice(0, 497) + '...' : s;
+        }
+        return (0, util_1.inspect)(err, { depth: 5, breakLength: 120, compact: false, sorted: true });
+    }
+    catch (fallbackErr) {
+        return `Unknown error of type ${typeof err}`;
+    }
+}
+class DialogInterruptedError extends Error {
+    constructor(reason) {
+        super('Dialog interrupted');
+        this.reason = reason;
+    }
+}
+function throwIfAborted(abortSignal, dlgId) {
+    if (!abortSignal?.aborted)
+        return;
+    const stopRequested = (0, dialog_run_state_1.getStopRequestedReason)(dlgId);
+    if (stopRequested === 'emergency_stop') {
+        throw new DialogInterruptedError({ kind: 'emergency_stop' });
+    }
+    if (stopRequested === 'user_stop') {
+        throw new DialogInterruptedError({ kind: 'user_stop' });
+    }
+    throw new DialogInterruptedError({ kind: 'system_stop', detail: 'Aborted.' });
+}
+/**
+ * Validate streaming configuration for a team member.
+ * Streaming supports function tools; no restrictions to enforce here.
+ */
+function validateStreamingConfiguration(_agent, _agentTools) { }
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validateFuncToolArguments(tool, rawArgs) {
+    if (!isPlainObject(rawArgs)) {
+        return { ok: false, error: 'Arguments must be an object' };
+    }
+    if (tool.argsValidation === 'passthrough') {
+        return { ok: true, args: rawArgs };
+    }
+    const validation = (0, tool_1.validateArgs)(tool.parameters, rawArgs);
+    return validation.ok
+        ? { ok: true, args: rawArgs }
+        : { ok: false, error: validation.error };
+}
+function classifyLlmFailure(err) {
+    const fallbackMessage = err instanceof Error
+        ? err.message || err.name
+        : typeof err === 'string'
+            ? err
+            : JSON.stringify(err);
+    if (err instanceof Error && err.message === 'AbortError') {
+        return { kind: 'fatal', message: 'Aborted.' };
+    }
+    {
+        const msg = err instanceof Error
+            ? err.message && err.message.length > 0
+                ? err.message
+                : err.name
+            : typeof err === 'string'
+                ? err
+                : undefined;
+        if (typeof msg === 'string' && msg.length > 0) {
+            const lower = msg.toLowerCase();
+            if (lower.includes('fetch failed') || lower.includes('socket hang up')) {
+                return { kind: 'retriable', message: msg };
+            }
+            if (lower.includes('terminated')) {
+                return { kind: 'retriable', message: msg };
+            }
+            if (lower.includes('timeout') ||
+                lower.includes('timed out') ||
+                lower.includes('rate limit')) {
+                return { kind: 'retriable', message: msg };
+            }
+        }
+    }
+    if (isPlainObject(err)) {
+        const status = 'status' in err && typeof err.status === 'number'
+            ? err.status
+            : 'statusCode' in err && typeof err.statusCode === 'number'
+                ? err.statusCode
+                : undefined;
+        const code = 'code' in err && typeof err.code === 'string'
+            ? err.code
+            : 'errno' in err && typeof err.errno === 'string'
+                ? err.errno
+                : undefined;
+        const msg = 'message' in err && typeof err.message === 'string' && err.message.length > 0
+            ? err.message
+            : fallbackMessage;
+        if (typeof status === 'number') {
+            if (status === 408 || status === 429 || status >= 500) {
+                return { kind: 'retriable', status, message: msg };
+            }
+            if (status >= 400 && status < 500) {
+                return { kind: 'rejected', status, message: msg };
+            }
+        }
+        if (typeof code === 'string') {
+            const retriableCodes = new Set([
+                'ETIMEDOUT',
+                'ECONNRESET',
+                'ECONNREFUSED',
+                'EAI_AGAIN',
+                'ENOTFOUND',
+                'ENETUNREACH',
+                'EHOSTUNREACH',
+                // undici / Node.js fetch
+                'UND_ERR_CONNECT_TIMEOUT',
+                'UND_ERR_HEADERS_TIMEOUT',
+                'UND_ERR_BODY_TIMEOUT',
+                'UND_ERR_SOCKET',
+            ]);
+            if (retriableCodes.has(code)) {
+                return { kind: 'retriable', code, message: msg };
+            }
+        }
+        const lower = msg.toLowerCase();
+        if (lower.includes('fetch failed') || lower.includes('socket hang up')) {
+            return { kind: 'retriable', message: msg };
+        }
+        if (lower.includes('terminated')) {
+            return { kind: 'retriable', message: msg };
+        }
+        if (lower.includes('timeout') || lower.includes('timed out') || lower.includes('rate limit')) {
+            return { kind: 'retriable', message: msg };
+        }
+    }
+    return { kind: 'fatal', message: fallbackMessage };
+}
+async function sleepWithAbort(ms, abortSignal) {
+    if (abortSignal?.aborted) {
+        throw new Error('AbortError');
+    }
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    if (abortSignal?.aborted) {
+        throw new Error('AbortError');
+    }
+}
+async function runLlmRequestWithRetry(params) {
+    const providerProblemId = `llm/provider_rejected/${params.dlg.id.valueOf()}`;
+    for (let attempt = 0; attempt <= params.maxRetries; attempt++) {
+        try {
+            const res = await params.doRequest();
+            (0, problems_1.removeProblem)(providerProblemId);
+            return res;
+        }
+        catch (err) {
+            if (params.abortSignal?.aborted) {
+                throw err;
+            }
+            const failure = classifyLlmFailure(err);
+            const detail = (0, log_1.extractErrorDetails)(err).message;
+            if (failure.kind === 'rejected') {
+                (0, problems_1.upsertProblem)({
+                    kind: 'llm_provider_rejected_request',
+                    source: 'llm',
+                    id: providerProblemId,
+                    severity: 'error',
+                    timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                    message: `LLM provider rejected the request`,
+                    detail: {
+                        dialogId: params.dlg.id.valueOf(),
+                        provider: params.provider,
+                        errorText: detail,
+                    },
+                });
+                try {
+                    await params.dlg.streamError(detail);
+                }
+                catch (_emitErr) {
+                    // best-effort
+                }
+                throw new DialogInterruptedError({
+                    kind: 'system_stop',
+                    detail: `Provider '${params.provider}' rejected the request: ${failure.message}`,
+                });
+            }
+            const canRetry = failure.kind === 'retriable' && params.canRetry();
+            const isLastAttempt = attempt >= params.maxRetries;
+            if (!canRetry || isLastAttempt) {
+                try {
+                    await params.dlg.streamError(detail);
+                }
+                catch (_emitErr) {
+                    // best-effort
+                }
+                throw new DialogInterruptedError({
+                    kind: 'system_stop',
+                    detail: canRetry
+                        ? `LLM failed after retries: ${failure.message}`
+                        : `LLM failed: ${failure.message}`,
+                });
+            }
+            // Exponential backoff with cap. (No jitter for determinism.)
+            // We intentionally use a larger cap because transient provider termination errors often
+            // recover only after a few seconds.
+            const backoffMs = Math.min(30000, 1000 * 2 ** attempt);
+            log_1.log.warn(`Retrying LLM request after retriable error`, {
+                provider: params.provider,
+                attempt: attempt + 1,
+                backoffMs,
+                failure,
+            });
+            await sleepWithAbort(backoffMs, params.abortSignal);
+            continue;
+        }
+    }
+    throw new DialogInterruptedError({ kind: 'system_stop', detail: 'LLM failed.' });
+}
+function resolveModelContextLimitTokens(modelInfo) {
+    if (modelInfo &&
+        typeof modelInfo.context_length === 'number' &&
+        Number.isFinite(modelInfo.context_length)) {
+        const n = Math.floor(modelInfo.context_length);
+        return n > 0 ? n : null;
+    }
+    if (modelInfo &&
+        typeof modelInfo.input_length === 'number' &&
+        Number.isFinite(modelInfo.input_length)) {
+        const n = Math.floor(modelInfo.input_length);
+        return n > 0 ? n : null;
+    }
+    return null;
+}
+function resolveEffectiveOptimalMaxTokens(args) {
+    const configuredOptimal = args.modelInfo &&
+        typeof args.modelInfo.optimal_max_tokens === 'number' &&
+        Number.isFinite(args.modelInfo.optimal_max_tokens)
+        ? Math.floor(args.modelInfo.optimal_max_tokens)
+        : undefined;
+    const optimalMaxTokensConfigured = configuredOptimal !== undefined && configuredOptimal > 0 ? configuredOptimal : undefined;
+    const configuredCritical = args.modelInfo &&
+        typeof args.modelInfo.critical_max_tokens === 'number' &&
+        Number.isFinite(args.modelInfo.critical_max_tokens)
+        ? Math.floor(args.modelInfo.critical_max_tokens)
+        : undefined;
+    const criticalMaxTokensConfigured = configuredCritical !== undefined && configuredCritical > 0 ? configuredCritical : undefined;
+    // Default threshold (when not configured): 100K.
+    const defaultOptimal = 100000;
+    const effectiveOptimalMaxTokens = optimalMaxTokensConfigured !== undefined ? optimalMaxTokensConfigured : defaultOptimal;
+    // Default threshold (when not configured): 90% of hard max.
+    const defaultCritical = Math.max(1, Math.floor(args.modelContextLimitTokens * 0.9));
+    const effectiveCriticalMaxTokens = criticalMaxTokensConfigured !== undefined ? criticalMaxTokensConfigured : defaultCritical;
+    return {
+        effectiveOptimalMaxTokens,
+        optimalMaxTokensConfigured,
+        effectiveCriticalMaxTokens,
+        criticalMaxTokensConfigured,
+    };
+}
+function computeContextHealthSnapshot(args) {
+    const modelInfo = args.providerCfg.models[args.model];
+    const modelContextWindowText = modelInfo && typeof modelInfo.context_window === 'string'
+        ? modelInfo.context_window
+        : undefined;
+    const modelContextLimitTokens = resolveModelContextLimitTokens(modelInfo);
+    if (modelContextLimitTokens === null) {
+        return { kind: 'unavailable', reason: 'model_limit_unavailable', modelContextWindowText };
+    }
+    const { effectiveOptimalMaxTokens, optimalMaxTokensConfigured, effectiveCriticalMaxTokens, criticalMaxTokensConfigured, } = resolveEffectiveOptimalMaxTokens({
+        modelInfo,
+        modelContextLimitTokens,
+    });
+    if (args.usage.kind !== 'available') {
+        return {
+            kind: 'unavailable',
+            reason: 'usage_unavailable',
+            modelContextWindowText,
+            modelContextLimitTokens,
+            effectiveOptimalMaxTokens,
+            optimalMaxTokensConfigured,
+            effectiveCriticalMaxTokens,
+            criticalMaxTokensConfigured,
+        };
+    }
+    const hardUtil = args.usage.promptTokens / modelContextLimitTokens;
+    const optimalUtil = args.usage.promptTokens / effectiveOptimalMaxTokens;
+    const level = args.usage.promptTokens > effectiveCriticalMaxTokens
+        ? 'critical'
+        : args.usage.promptTokens > effectiveOptimalMaxTokens
+            ? 'caution'
+            : 'healthy';
+    return {
+        kind: 'available',
+        promptTokens: args.usage.promptTokens,
+        completionTokens: args.usage.completionTokens,
+        totalTokens: args.usage.totalTokens,
+        modelContextWindowText,
+        modelContextLimitTokens,
+        effectiveOptimalMaxTokens,
+        optimalMaxTokensConfigured,
+        effectiveCriticalMaxTokens,
+        criticalMaxTokensConfigured,
+        hardUtil,
+        optimalUtil,
+        level,
+    };
+}
+const contextHealthV3StateByDialogKey = new Map();
+function getContextHealthV3State(dlg) {
+    const key = dlg.id.key();
+    const existing = contextHealthV3StateByDialogKey.get(key);
+    if (existing)
+        return existing;
+    const created = {};
+    contextHealthV3StateByDialogKey.set(key, created);
+    return created;
+}
+function resetContextHealthV3State(dlg) {
+    contextHealthV3StateByDialogKey.delete(dlg.id.key());
+}
+const defaultCautionHardCadenceGenerations = 10;
+const defaultCriticalCountdownGenerations = 5;
+function shouldInjectCautionRemediationGuide(args) {
+    const { dlg } = args;
+    const state = getContextHealthV3State(dlg);
+    const modelInfo = args.providerCfg.models[args.model];
+    const cadence = modelInfo &&
+        typeof modelInfo.caution_remediation_cadence_generations === 'number' &&
+        Number.isFinite(modelInfo.caution_remediation_cadence_generations)
+        ? Math.floor(modelInfo.caution_remediation_cadence_generations)
+        : undefined;
+    const effectiveCadence = typeof cadence === 'number' && Number.isFinite(cadence) && cadence > 0
+        ? Math.floor(cadence)
+        : defaultCautionHardCadenceGenerations;
+    const genSeq = dlg.activeGenSeq;
+    if (genSeq === undefined)
+        return true;
+    const lastInjected = state.lastCautionGuideInjectedAtGenSeq;
+    if (lastInjected === undefined)
+        return true;
+    return genSeq - lastInjected >= effectiveCadence;
+}
+async function applyContextHealthV3Remediation(args) {
+    const { dlg } = args;
+    const snapshot = dlg.getLastContextHealth();
+    if (!snapshot || snapshot.kind !== 'available') {
+        resetContextHealthV3State(dlg);
+        return { kind: 'proceed', ctxMsgs: args.ctxMsgs };
+    }
+    if (snapshot.level === 'healthy') {
+        resetContextHealthV3State(dlg);
+        return { kind: 'proceed', ctxMsgs: args.ctxMsgs };
+    }
+    if (snapshot.level === 'caution') {
+        const state = getContextHealthV3State(dlg);
+        if (state.lastSeenLevel !== 'caution') {
+            state.lastSeenLevel = 'caution';
+            state.criticalCountdownRemaining = undefined;
+        }
+        if (!shouldInjectCautionRemediationGuide({
+            dlg,
+            providerCfg: args.providerCfg,
+            model: args.model,
+        })) {
+            return { kind: 'proceed', ctxMsgs: args.ctxMsgs };
+        }
+        // Caution remediation at cadence (including the entry injection): require reminder curation
+        // (no forced clear_mind).
+        const activeGenSeq = dlg.activeGenSeqOrUndefined;
+        if (activeGenSeq === undefined) {
+            return { kind: 'proceed', ctxMsgs: args.ctxMsgs };
+        }
+        const guideText = (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)((0, runtime_language_1.getWorkLanguage)(), {
+            kind: 'caution',
+            mode: 'soft',
+        });
+        state.lastCautionGuideInjectedAtGenSeq = activeGenSeq;
+        // Prefer a recorded user prompt (visible in UI) when there isn't already a user prompt
+        // in this generation.
+        if (!args.hadUserPromptThisGen) {
+            const msgId = (0, id_1.generateShortId)();
+            const userLanguageCode = (0, runtime_language_1.getWorkLanguage)();
+            const promptMsg = {
+                type: 'prompting_msg',
+                role: 'user',
+                genseq: activeGenSeq,
+                msgId,
+                grammar: 'markdown',
+                content: guideText,
+            };
+            await dlg.addChatMessages(promptMsg);
+            await dlg.persistUserMessage(guideText, msgId, 'markdown', userLanguageCode);
+            await emitUserMarkdown(dlg, guideText);
+            try {
+                (0, evt_registry_1.postDialogEvent)(dlg, {
+                    type: 'end_of_user_saying_evt',
+                    course: dlg.currentCourse,
+                    genseq: activeGenSeq,
+                    msgId,
+                    content: guideText,
+                    grammar: 'markdown',
+                    userLanguageCode,
+                });
+            }
+            catch (err) {
+                log_1.log.warn('Failed to emit end_of_user_saying_evt for caution guide prompt', err);
+            }
+            return { kind: 'proceed', ctxMsgs: [...args.ctxMsgs, promptMsg] };
+        }
+        // Fallback: still guide the LLM even if we cannot safely emit a second user prompt for UI.
+        const guide = { type: 'environment_msg', role: 'user', content: guideText };
+        return { kind: 'proceed', ctxMsgs: [...args.ctxMsgs, guide] };
+    }
+    if (snapshot.level === 'critical') {
+        const state = getContextHealthV3State(dlg);
+        if (state.lastSeenLevel !== 'critical') {
+            state.lastSeenLevel = 'critical';
+            state.criticalCountdownRemaining = defaultCriticalCountdownGenerations;
+        }
+        const promptsBeforeAutoClear = typeof state.criticalCountdownRemaining === 'number' &&
+            Number.isFinite(state.criticalCountdownRemaining)
+            ? Math.floor(state.criticalCountdownRemaining)
+            : defaultCriticalCountdownGenerations;
+        if (promptsBeforeAutoClear <= 0) {
+            // Countdown exhausted: force-start a new course directly. Do not simulate an LLM tool call
+            // because this is system remediation, not agent action.
+            const language = (0, runtime_language_1.getWorkLanguage)();
+            const newCoursePrompt = language === 'zh'
+                ? '系统因上下文已告急（critical）而自动开启新一程对话，请继续推进任务。'
+                : 'System auto-started a new dialog course because context health is critical. Please continue the task.';
+            await dlg.startNewCourse(newCoursePrompt);
+            // Context health snapshot is inherently tied to the previous prompt/context. After clearing,
+            // invalidate it so the next generation can recompute without stale remediation.
+            dlg.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
+            resetContextHealthV3State(dlg);
+            const nextPrompt = resolveUpNextPrompt(dlg);
+            return { kind: 'continue', nextPrompt };
+        }
+        const guideText = (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)((0, runtime_language_1.getWorkLanguage)(), {
+            kind: 'critical',
+            mode: 'countdown',
+            promptsRemainingAfterThis: promptsBeforeAutoClear - 1,
+            promptsTotal: defaultCriticalCountdownGenerations,
+        });
+        state.criticalCountdownRemaining = promptsBeforeAutoClear - 1;
+        // Prefer a recorded prompt (visible in UI as user prompt) when there isn't already a
+        // user prompt in this generation.
+        if (!args.hadUserPromptThisGen) {
+            const msgId = (0, id_1.generateShortId)();
+            const userLanguageCode = (0, runtime_language_1.getWorkLanguage)();
+            const promptMsg = {
+                type: 'prompting_msg',
+                role: 'user',
+                genseq: dlg.activeGenSeq,
+                msgId,
+                grammar: 'markdown',
+                content: guideText,
+            };
+            await dlg.addChatMessages(promptMsg);
+            await dlg.persistUserMessage(guideText, msgId, 'markdown', userLanguageCode);
+            await emitUserMarkdown(dlg, guideText);
+            try {
+                (0, evt_registry_1.postDialogEvent)(dlg, {
+                    type: 'end_of_user_saying_evt',
+                    course: dlg.currentCourse,
+                    genseq: dlg.activeGenSeq,
+                    msgId,
+                    content: guideText,
+                    grammar: 'markdown',
+                    userLanguageCode,
+                });
+            }
+            catch (err) {
+                log_1.log.warn('Failed to emit end_of_user_saying_evt for critical countdown prompt', err);
+            }
+            return { kind: 'proceed', ctxMsgs: [...args.ctxMsgs, promptMsg] };
+        }
+        // Fallback: still guide the LLM even if we cannot safely emit a second user prompt for UI.
+        const guide = {
+            type: 'environment_msg',
+            role: 'user',
+            content: guideText,
+        };
+        return { kind: 'proceed', ctxMsgs: [...args.ctxMsgs, guide] };
+    }
+    const _exhaustive = snapshot.level;
+    return _exhaustive;
+}
+// === UNIFIED STREAMING HANDLERS ===
+/**
+ * Create a TellaskEventsReceiver for unified saying event emission.
+ * Handles tellask call blocks and markdown using TellaskStreamParser.
+ * Used by both streaming and non-streaming modes.
+ */
+function createSayingEventsReceiver(dlg) {
+    return {
+        markdownStart: async () => {
+            await dlg.markdownStart();
+        },
+        markdownChunk: async (chunk) => {
+            await dlg.markdownChunk(chunk);
+        },
+        markdownFinish: async () => {
+            await dlg.markdownFinish();
+        },
+        callStart: async (validation) => {
+            await dlg.callingStart(validation);
+        },
+        callHeadLineChunk: async (chunk) => {
+            await dlg.callingHeadlineChunk(chunk);
+        },
+        callHeadLineFinish: async () => {
+            await dlg.callingHeadlineFinish();
+        },
+        tellaskBodyStart: async () => {
+            await dlg.callingBodyStart();
+        },
+        tellaskBodyChunk: async (chunk) => {
+            await dlg.callingBodyChunk(chunk);
+        },
+        tellaskBodyFinish: async () => {
+            await dlg.callingBodyFinish();
+        },
+        callFinish: async (call, _upstreamEndOffset) => {
+            await dlg.callingFinish(call.callId);
+        },
+    };
+}
+/**
+ * Emit thinking events for a thinking message (non-streaming mode).
+ * Emits thinkingStart, thinkingChunk with full content, and thinkingFinish.
+ * Returns the extracted signature for caller to use.
+ */
+async function emitThinkingEvents(dlg, content) {
+    if (!content.trim())
+        return undefined;
+    await dlg.thinkingStart();
+    await dlg.thinkingChunk(content);
+    await dlg.thinkingFinish();
+    // Extract and return signature for caller to use
+    const signatureMatch = content.match(/<thinking[^>]*>(.*?)<\/thinking>/s);
+    return signatureMatch?.[1]?.trim();
+}
+/**
+ * Emit saying events using TellaskStreamParser (non-streaming mode).
+ * Processes the entire content at once, handling markdown + tellask calls.
+ */
+async function emitSayingEvents(dlg, content) {
+    if (!content.trim())
+        return [];
+    const receiver = createSayingEventsReceiver(dlg);
+    const parser = new tellask_1.TellaskStreamParser(receiver);
+    await parser.takeUpstreamChunk(content);
+    await parser.finalize();
+    return parser.getCollectedCalls();
+}
+async function emitUserMarkdown(dlg, content) {
+    if (!content.trim()) {
+        return;
+    }
+    await dlg.markdownStart();
+    await dlg.markdownChunk(content);
+    await dlg.markdownFinish();
+}
+function resolveUpNextPrompt(dlg, humanPrompt) {
+    if (humanPrompt) {
+        return humanPrompt;
+    }
+    const upNext = dlg.takeUpNext();
+    if (!upNext) {
+        return undefined;
+    }
+    return {
+        content: upNext.prompt,
+        msgId: upNext.msgId,
+        grammar: 'markdown',
+        userLanguageCode: upNext.userLanguageCode,
+    };
+}
+function scheduleUpNextDrive(dlg, upNext) {
+    const prompt = {
+        content: upNext.prompt,
+        msgId: upNext.msgId,
+        grammar: 'markdown',
+        userLanguageCode: upNext.userLanguageCode,
+    };
+    void driveDialogStream(dlg, prompt, true);
+}
+const suspensionStateMutexes = new Map();
+async function withSuspensionStateLock(dialogId, fn) {
+    const key = dialogId.key();
+    let mutex = suspensionStateMutexes.get(key);
+    if (!mutex) {
+        mutex = new async_fifo_mutex_1.AsyncFifoMutex();
+        suspensionStateMutexes.set(key, mutex);
+    }
+    const release = await mutex.acquire();
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}
+async function hasQueuedSubdialogResponses(dialogId) {
+    try {
+        const queued = await withSuspensionStateLock(dialogId, async () => {
+            return await persistence_1.DialogPersistence.loadSubdialogResponsesQueue(dialogId);
+        });
+        return queued.length > 0;
+    }
+    catch (err) {
+        log_1.log.warn('Failed to check queued subdialog responses; suppressing diligence as safe default', {
+            dialogId: dialogId.valueOf(),
+            error: err,
+        });
+        // Fail safe: if we cannot verify queue emptiness, do not inject diligence prompts.
+        return true;
+    }
+}
+// TODO: certain scenarios should pass `waitInQue=true`:
+//        - supdialog call for clarification
+/**
+ * Drive a dialog stream with the following phases:
+ *
+ * Phase 1 - Lock Acquisition:
+ *   - Attempt to acquire exclusive lock for the dialog using mutex
+ *   - If dialog is already being driven, either wait in queue or throw error
+ *
+ * Phase 2 - Human Prompt Processing (first iteration only):
+ *   - If humanPrompt is provided, add it as a prompting_msg
+ *   - Persist user message to storage
+ *
+ * Phase 3 - User Tellask Call Block Collection & Execution:
+ *   - Parse user text for tellask blocks using TellaskStreamParser
+ *   - Execute tellasks (teammate tellasks / Q4H / supdialog)
+ *   - Handle subdialog creation for @teammate mentions
+ *
+ * Phase 4 - Context Building:
+ *   - Load agent minds (team, agent, system prompt, memories, tools)
+ *   - Build context messages: memories, Taskdoc, assignment from supdialog, dialog msgs
+ *   - Process and render reminders
+ *
+ * Phase 5 - LLM Generation:
+ *   - For streaming=false: Generate all messages at once
+ *   - For streaming=true: Stream responses with thinking/saying events
+ *
+ * Phase 6 - Function/Tellask Call Execution:
+ *   - Execute function calls (non-streaming mode)
+ *   - Execute tellask calls (streaming mode)
+ *   - Collect and persist results
+ *
+ * Phase 7 - Loop or Complete:
+ *   - Check if more generation iterations are needed
+ *   - Continue loop if new function calls or tool outputs exist
+ *   - Break and release lock when complete
+ */
+async function driveDialogStream(dlg, humanPrompt, waitInQue = false, driveOptions) {
+    if (!waitInQue && dlg.isLocked()) {
+        throw new Error(`Dialog busy driven, see how it proceeded and try again.`);
+    }
+    const allowResumeFromInterrupted = driveOptions?.allowResumeFromInterrupted === true || humanPrompt?.origin === 'user';
+    const release = await dlg.acquire();
+    let followUp;
+    let driveResult;
+    let subdialogReplyTarget;
+    try {
+        // "dead" is an irreversible UI state (primarily for subdialogs). If a dialog is marked dead
+        // in latest.yaml, do not proceed with driving. This guards against races/cross-client drive.
+        try {
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, 'running');
+            if (dlg.id.selfId !== dlg.id.rootId &&
+                latest &&
+                latest.runState &&
+                latest.runState.kind === 'dead') {
+                return;
+            }
+            if (latest && latest.runState && latest.runState.kind === 'proceeding_stop_requested') {
+                log_1.log.info('Skip drive while stop request is still being processed', undefined, {
+                    dialogId: dlg.id.valueOf(),
+                    reason: latest.runState.reason,
+                });
+                return;
+            }
+            if (latest &&
+                latest.runState &&
+                latest.runState.kind === 'interrupted' &&
+                !allowResumeFromInterrupted) {
+                log_1.log.info('Skip drive for interrupted dialog without explicit resume/user prompt', undefined, {
+                    dialogId: dlg.id.valueOf(),
+                    reason: latest.runState.reason,
+                });
+                return;
+            }
+        }
+        catch (err) {
+            log_1.log.warn('Failed to check runState before drive; proceeding best-effort', err, {
+                dialogId: dlg.id.valueOf(),
+            });
+        }
+        const effectivePrompt = resolveUpNextPrompt(dlg, humanPrompt);
+        subdialogReplyTarget = effectivePrompt?.subdialogReplyTarget;
+        if (effectivePrompt && effectivePrompt.userLanguageCode) {
+            dlg.setLastUserLanguageCode(effectivePrompt.userLanguageCode);
+        }
+        driveResult = await _driveDialogStream(dlg, effectivePrompt, driveOptions);
+        // Do not auto-chain upNext when this drive ended in interrupted state
+        // (user/emergency/system stop). upNext remains queued for explicit manual resume.
+        if (!driveResult.interrupted) {
+            followUp = dlg.takeUpNext();
+        }
+    }
+    finally {
+        release();
+    }
+    if (followUp) {
+        scheduleUpNextDrive(dlg, followUp);
+    }
+    else if (dlg instanceof dialog_1.SubDialog &&
+        driveResult &&
+        !driveResult.interrupted &&
+        driveResult.lastAssistantSayingContent !== null) {
+        const suspension = await dlg.getSuspensionStatus();
+        if (!suspension.canDrive) {
+            log_1.log.info('Skip supplying subdialog response because dialog is still suspended', {
+                rootId: dlg.id.rootId,
+                selfId: dlg.id.selfId,
+                waitingQ4H: suspension.q4h,
+                waitingSubdialogs: suspension.subdialogs,
+            });
+            return;
+        }
+        if (subdialogReplyTarget) {
+            await supplySubdialogResponseToSpecificCallerIfPending(dlg, driveResult.lastAssistantSayingContent, subdialogReplyTarget);
+        }
+        else {
+            await supplySubdialogResponseToAssignedCallerIfPending(dlg, driveResult.lastAssistantSayingContent);
+        }
+    }
+}
+// Transitional bridge for driver-v2 development.
+// Keeps v1 behavior unchanged while allowing v2 to invoke the core generation loop directly.
+async function driveDialogStreamCoreV1(dlg, humanPrompt, driveOptions) {
+    return await _driveDialogStream(dlg, humanPrompt, driveOptions);
+}
+/**
+ * Backend coroutine that continuously drives dialogs.
+ * Uses dynamic canDrive() checks instead of stored suspend state.
+ */
+async function runBackendDriver() {
+    while (true) {
+        try {
+            const dialogsToDrive = dialog_global_registry_1.globalDialogRegistry.getDialogsNeedingDrive();
+            for (const rootDialog of dialogsToDrive) {
+                try {
+                    const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialog.id, 'running');
+                    const runStateKind = latest?.runState?.kind;
+                    if (runStateKind === 'interrupted' || runStateKind === 'proceeding_stop_requested') {
+                        dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId);
+                        await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                        continue;
+                    }
+                    if (!(await rootDialog.canDrive())) {
+                        continue;
+                    }
+                    const release = await rootDialog.acquire();
+                    try {
+                        await driveDialogToSuspension(rootDialog);
+                    }
+                    finally {
+                        release();
+                    }
+                    const status = await rootDialog.getSuspensionStatus();
+                    const shouldStayQueued = rootDialog.hasUpNext() || !status.canDrive;
+                    if (shouldStayQueued) {
+                        dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(rootDialog.id.rootId);
+                        await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, true, rootDialog.status);
+                    }
+                    else {
+                        dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId);
+                        await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                    }
+                    if (status.subdialogs) {
+                        log_1.log.info(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`);
+                    }
+                    if (status.q4h) {
+                        log_1.log.info(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`);
+                    }
+                }
+                catch (err) {
+                    log_1.log.error(`Error driving dialog ${rootDialog.id.rootId}:`, err, undefined, {
+                        dialogId: rootDialog.id.rootId,
+                    });
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        catch (loopErr) {
+            log_1.log.error('Error in backend driver loop:', loopErr);
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    }
+}
+/**
+ * Drive a dialog until it suspends or completes.
+ * Called with mutex already acquired.
+ */
+async function driveDialogToSuspension(dlg) {
+    try {
+        const effectivePrompt = resolveUpNextPrompt(dlg);
+        if (effectivePrompt && effectivePrompt.userLanguageCode) {
+            dlg.setLastUserLanguageCode(effectivePrompt.userLanguageCode);
+        }
+        await _driveDialogStream(dlg, effectivePrompt);
+    }
+    catch (err) {
+        log_1.log.warn(`Error in driveDialogToSuspension for ${dlg.id.selfId}:`, err);
+        throw err;
+    }
+}
+/**
+ * Frontend-triggered revive check (crash-recovery).
+ */
+async function checkAndReviveSuspendedDialogs() {
+    const allDialogs = dialog_global_registry_1.globalDialogRegistry.getAll();
+    for (const rootDialog of allDialogs) {
+        const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(rootDialog.id);
+        if (pending.length > 0) {
+            const allSatisfied = await areAllSubdialogsSatisfied(rootDialog.id);
+            if (allSatisfied) {
+                await withSuspensionStateLock(rootDialog.id, async () => {
+                    await persistence_1.DialogPersistence.clearPendingSubdialogs(rootDialog.id);
+                    await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, true, rootDialog.status);
+                });
+                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(rootDialog.id.rootId);
+                log_1.log.info(`All subdialogs complete for ${rootDialog.id.rootId}, auto-reviving`);
+            }
+        }
+        const subdialogs = rootDialog.getAllDialogs().filter((d) => d !== rootDialog);
+        for (const subdialog of subdialogs) {
+            try {
+                const latest = await persistence_1.DialogPersistence.loadDialogLatest(subdialog.id, 'running');
+                if (latest && latest.runState && latest.runState.kind === 'dead') {
+                    continue;
+                }
+            }
+            catch (err) {
+                log_1.log.warn('Failed to check runState for subdialog revival; proceeding best-effort', err, {
+                    dialogId: subdialog.id.valueOf(),
+                });
+            }
+            const hasAnswer = await checkQ4HAnswered(subdialog.id);
+            if (hasAnswer && !(await subdialog.hasPendingQ4H())) {
+                void driveDialogStream(subdialog, undefined, true);
+                log_1.log.info(`Q4H answered for dialog ${subdialog.id.selfId}, auto-reviving`);
+            }
+        }
+    }
+}
+async function checkQ4HAnswered(dialogId) {
+    try {
+        const questions = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId);
+        return questions.length === 0;
+    }
+    catch (err) {
+        log_1.log.warn(`Error checking Q4H state ${dialogId.key()}:`, err);
+        return false;
+    }
+}
+async function _driveDialogStream(dlg, humanPrompt, driveOptions) {
+    const suppressDiligencePushForDrive = driveOptions?.suppressDiligencePush === true;
+    const abortSignal = (0, dialog_run_state_1.createActiveRun)(dlg.id);
+    let finalRunState;
+    let shouldEmitResumedMarker = false;
+    if (!humanPrompt) {
+        try {
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, 'running');
+            shouldEmitResumedMarker =
+                latest !== null &&
+                    latest !== undefined &&
+                    latest.runState !== undefined &&
+                    latest.runState.kind === 'interrupted';
+        }
+        catch (err) {
+            log_1.log.warn('Failed to load latest.yaml for resumption marker', err, {
+                dialogId: dlg.id.valueOf(),
+            });
+        }
+    }
+    if (shouldEmitResumedMarker) {
+        (0, dialog_run_state_1.broadcastRunStateMarker)(dlg.id, { kind: 'resumed' });
+    }
+    await (0, dialog_run_state_1.setDialogRunState)(dlg.id, { kind: 'proceeding' });
+    let pubRemindersVer = dlg.remindersVer;
+    let lastAssistantSayingContent = null;
+    let generationHadError = false;
+    let tookSubdialogResponses = false;
+    let takenSubdialogResponses = [];
+    // Keep injected subdialog replies visible across all gen iterations in the same drive.
+    // Without this, iteration #2 (e.g. after a function call) can lose reply context from iteration #1.
+    let subdialogResponseContextMsgs = [];
+    // Internal prompt is drive-scoped priming context and never persisted.
+    let internalDrivePromptMsg;
+    let committedTakenSubdialogResponses = false;
+    let genIterNo = 0;
+    let pendingPrompt = humanPrompt;
+    let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
+    try {
+        while (true) {
+            genIterNo++;
+            throwIfAborted(abortSignal, dlg.id);
+            // reload the agent's minds from disk every course, in case the disk files changed by human or ai meanwhile
+            const minds = await (0, load_1.loadAgentMinds)(dlg.agentId, dlg);
+            const team = minds.team;
+            let agent = minds.agent;
+            let systemPrompt = minds.systemPrompt;
+            const memories = minds.memories;
+            let agentTools = minds.agentTools;
+            const drivePolicy = buildDrivePolicy({
+                dlg,
+                agent,
+                systemPrompt,
+                agentTools,
+                language: (0, runtime_language_1.getWorkLanguage)(),
+            });
+            const drivePolicyValidation = validateDrivePolicyInvariants(drivePolicy, (0, runtime_language_1.getWorkLanguage)());
+            if (!drivePolicyValidation.ok) {
+                throw new Error(`FBR policy isolation violation: ${drivePolicyValidation.detail}`);
+            }
+            agent = drivePolicy.effectiveAgent;
+            systemPrompt = drivePolicy.effectiveSystemPrompt;
+            agentTools = drivePolicy.effectiveAgentTools;
+            // reload cfgs every course, in case it's been updated by human or ai meanwhile
+            // Validate streaming configuration
+            try {
+                validateStreamingConfiguration(agent, agentTools);
+            }
+            catch (error) {
+                log_1.log.warn(`Streaming configuration error for agent ${dlg.agentId}:`, error);
+                throw error;
+            }
+            // Validate that required provider and model are configured
+            // Validate that required provider and model are configured
+            const provider = agent.provider ?? team.memberDefaults.provider;
+            const model = agent.model ?? team.memberDefaults.model;
+            if (!provider) {
+                const error = new Error(`Configuration Error: No provider configured for agent '${dlg.agentId}'. Please specify a provider in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
+                log_1.log.warn(`Provider not configured for agent ${dlg.agentId}`, error);
+                throw error;
+            }
+            if (!model) {
+                const error = new Error(`Configuration Error: No model configured for agent '${dlg.agentId}'. Please specify a model in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
+                log_1.log.warn(`Model not configured for agent ${dlg.agentId}`, error);
+                throw error;
+            }
+            const llmCfg = await client_1.LlmConfig.load();
+            const providerCfg = llmCfg.getProvider(provider);
+            if (!providerCfg) {
+                const error = new Error(`Provider configuration error: Provider '${provider}' not found for agent '${dlg.agentId}'. Please check .minds/llm.yaml and .minds/team.yaml configuration.`);
+                log_1.log.warn(`Provider not found for agent ${dlg.agentId}`, error);
+                throw error;
+            }
+            const modelsUnknown = providerCfg.models;
+            const models = typeof modelsUnknown === 'object' && modelsUnknown !== null && !Array.isArray(modelsUnknown)
+                ? modelsUnknown
+                : undefined;
+            const modelInfo = models ? models[model] : undefined;
+            if (!modelInfo) {
+                const uiLanguage = dlg.getUiLanguage();
+                const msg = uiLanguage === 'zh'
+                    ? [
+                        '配置错误：当前成员的模型配置无效。',
+                        '',
+                        `- member: ${agent.name} (${dlg.agentId})`,
+                        `- provider: ${provider}`,
+                        `- model: ${model}（这是 model key；在该 provider 的 models 列表中不存在，或该 provider 缺少 models 配置）`,
+                        '',
+                        '请联系团队管理者修复：',
+                        `- 在 .minds/team.yaml 中把该成员的 provider/model 改成有效 key；或`,
+                        `- 在 .minds/llm.yaml 的 providers.${provider}.models 下补齐该 model key。`,
+                        '',
+                        '提示：你也可以打开 WebUI 的 `/setup` 查看当前 rtws（运行时工作区）可用的 provider/model 列表。',
+                        '',
+                        '团队管理者修复后建议运行：`team_mgmt_validate_team_cfg({})`。',
+                    ].join('\n')
+                    : [
+                        'Configuration error: invalid model selection for this member.',
+                        '',
+                        `- member: ${agent.name} (${dlg.agentId})`,
+                        `- provider: ${provider}`,
+                        `- model: ${model} (this is a model key; not found under this provider's models list, or the provider has no models configured)`,
+                        '',
+                        'Please contact your team manager to fix:',
+                        `- Update the member's provider/model keys in .minds/team.yaml, or`,
+                        `- Add the model key under .minds/llm.yaml providers.${provider}.models.`,
+                        '',
+                        'Tip: you can also open the WebUI `/setup` page to see available provider/model keys for this rtws (runtime workspace).',
+                        '',
+                        'After the fix, the team manager should run: `team_mgmt_validate_team_cfg({})`.',
+                    ].join('\n');
+                throw new Error(msg);
+            }
+            const llmGen = (0, registry_1.getLlmGenerator)(providerCfg.apiType);
+            if (!llmGen) {
+                const error = new Error(`LLM generator not found: API type '${providerCfg.apiType}' for provider '${provider}' in agent '${dlg.agentId}'. Please check .minds/llm.yaml configuration.`);
+                log_1.log.warn(`LLM generator not found for agent ${dlg.agentId}`, error);
+                throw error;
+            }
+            const canonicalFuncTools = agentTools.filter((t) => t.type === 'func');
+            const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, canonicalFuncTools);
+            const funcTools = projected.tools;
+            let suspendForHuman = false;
+            let promptContent = '';
+            let contextHealthForGen;
+            let llmGenModelForGen = model;
+            try {
+                throwIfAborted(abortSignal, dlg.id);
+                await dlg.notifyGeneratingStart();
+                const currentPrompt = pendingPrompt;
+                pendingPrompt = undefined;
+                if (currentPrompt) {
+                    const promptOrigin = currentPrompt.origin ?? 'user';
+                    const isDiligencePrompt = promptOrigin === 'diligence_push';
+                    if (isDiligencePrompt && (dlg.disableDiligencePush || suppressDiligencePushForDrive)) {
+                        log_1.log.info('Skip diligence prompt after disable toggle', {
+                            dialogId: dlg.id.valueOf(),
+                            msgId: currentPrompt.msgId,
+                        });
+                        break;
+                    }
+                    if (currentPrompt.skipTaskdoc === true) {
+                        skipTaskdocForThisDrive = true;
+                    }
+                    promptContent = currentPrompt.content;
+                    const msgId = currentPrompt.msgId;
+                    const promptGrammar = currentPrompt.grammar;
+                    const persistedUserLanguageCode = currentPrompt.userLanguageCode ?? dlg.getLastUserLanguageCode();
+                    const requestedPersistMode = currentPrompt.persistMode ?? 'persist';
+                    const persistMode = isDiligencePrompt ? 'persist' : requestedPersistMode;
+                    if (isDiligencePrompt && requestedPersistMode !== 'persist') {
+                        log_1.log.warn('Diligence prompt must be persisted; forcing persist mode', {
+                            dialogId: dlg.id.valueOf(),
+                            msgId,
+                            requestedPersistMode,
+                        });
+                    }
+                    if (persistMode === 'internal') {
+                        const injected = currentPrompt.content.trim();
+                        internalDrivePromptMsg = injected
+                            ? {
+                                type: 'environment_msg',
+                                role: 'user',
+                                content: injected,
+                            }
+                            : undefined;
+                    }
+                    else {
+                        await dlg.addChatMessages({
+                            type: 'prompting_msg',
+                            role: 'user',
+                            genseq: dlg.activeGenSeq,
+                            content: promptContent,
+                            msgId: msgId,
+                            grammar: promptGrammar,
+                        });
+                        // Persist user message to storage FIRST
+                        await dlg.persistUserMessage(promptContent, msgId, promptGrammar, persistedUserLanguageCode);
+                    }
+                    if (persistMode !== 'internal' && promptGrammar === 'tellask') {
+                        // Collect and execute tellask calls from user text using streaming parser
+                        throwIfAborted(abortSignal, dlg.id);
+                        const collectedUserCalls = await emitSayingEvents(dlg, promptContent);
+                        throwIfAborted(abortSignal, dlg.id);
+                        const userResult = await executeTellaskCalls(dlg, agent, collectedUserCalls);
+                        if (dlg.hasUpNext()) {
+                            return { lastAssistantSayingContent, interrupted: false };
+                        }
+                        if (userResult.toolOutputs.length > 0) {
+                            await dlg.addChatMessages(...userResult.toolOutputs);
+                        }
+                        if (userResult.suspend) {
+                            suspendForHuman = true;
+                        }
+                        // No teammate-call fallback here: rely exclusively on TellaskStreamParser.
+                        // Pending subdialogs are tracked in persistence (pending-subdialogs.json) as the source of truth.
+                    }
+                    else if (persistMode !== 'internal') {
+                        await emitUserMarkdown(dlg, promptContent);
+                    }
+                    if (persistMode !== 'internal') {
+                        try {
+                            (0, evt_registry_1.postDialogEvent)(dlg, {
+                                type: 'end_of_user_saying_evt',
+                                course: dlg.currentCourse,
+                                genseq: dlg.activeGenSeq,
+                                msgId,
+                                content: promptContent,
+                                grammar: promptGrammar,
+                                userLanguageCode: persistedUserLanguageCode,
+                            });
+                        }
+                        catch (err) {
+                            log_1.log.warn('Failed to emit end_of_user_saying_evt', err);
+                        }
+                    }
+                }
+                if (suspendForHuman) {
+                    break;
+                }
+                // Take any queued subdialog responses (once per drive) and inject them as fresh user context.
+                // This is the core "revival" mechanism: the parent is driven again when all pending subdialogs
+                // are resolved, and the queued responses become the next user-visible input to the model.
+                if (genIterNo === 1 && !tookSubdialogResponses) {
+                    tookSubdialogResponses = true;
+                    try {
+                        takenSubdialogResponses = await withSuspensionStateLock(dlg.id, async () => {
+                            return await persistence_1.DialogPersistence.takeSubdialogResponses(dlg.id);
+                        });
+                    }
+                    catch (err) {
+                        log_1.log.warn('Failed to take subdialog responses for injection', {
+                            dialogId: dlg.id.selfId,
+                            error: err,
+                        });
+                        generationHadError = true;
+                        takenSubdialogResponses = [];
+                    }
+                }
+                // use fresh memory + updated msgs from dialog object
+                // Build ctxMsgs messages in logical order, then inject reminders as late as possible:
+                // 1) memories
+                // 2) Taskdoc (user)
+                // 3) historical dialog msgs
+                // Finally, render reminders and place them immediately before the last 'user' message
+                // so they are salient for the next response without polluting earlier context.
+                const taskDocMsg = dlg.taskDocPath && !skipTaskdocForThisDrive ? await (0, taskdoc_1.formatTaskDocContent)(dlg) : undefined;
+                const coursePrefixMsgs = (() => {
+                    const msgs = dlg.getCoursePrefixMsgs();
+                    return msgs.length > 0 ? [...msgs] : [];
+                })();
+                const dialogMsgsForContext = dlg.msgs.filter((m) => {
+                    if (!m)
+                        return false;
+                    if (m.type === 'ui_only_markdown_msg')
+                        return false;
+                    return true;
+                });
+                if (genIterNo === 1 && takenSubdialogResponses.length > 0) {
+                    subdialogResponseContextMsgs = takenSubdialogResponses.map((response) => ({
+                        type: 'environment_msg',
+                        role: 'user',
+                        content: (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                            responderId: response.responderId,
+                            requesterId: response.originMemberId,
+                            originalCallHeadLine: response.tellaskHead,
+                            responseBody: response.response,
+                            language: (0, runtime_language_1.getWorkLanguage)(),
+                        }),
+                    }));
+                }
+                await dlg.processReminderUpdates();
+                const renderedReminders = dlg.reminders.length > 0
+                    ? await Promise.all(dlg.reminders.map(async (reminder, index) => {
+                        if (reminder.owner) {
+                            return await reminder.owner.renderReminder(dlg, reminder, index);
+                        }
+                        return {
+                            type: 'environment_msg',
+                            role: 'user',
+                            content: (0, driver_messages_1.formatReminderItemGuide)((0, runtime_language_1.getWorkLanguage)(), index + 1, reminder.content, { meta: reminder.meta }),
+                        };
+                    }))
+                    : [];
+                const uiLanguage = dlg.getLastUserLanguageCode();
+                const workingLanguage = (0, runtime_language_1.getWorkLanguage)();
+                const guideMsg = {
+                    type: 'transient_guide_msg',
+                    role: 'assistant',
+                    content: (0, driver_messages_1.formatCurrentUserLanguagePreference)(workingLanguage, uiLanguage),
+                };
+                const ctxMsgs = (0, context_1.assembleDriveContextMessages)({
+                    base: {
+                        prependedContextMessages: drivePolicy.prependedContextMessages,
+                        memories,
+                        taskDocMsg,
+                        coursePrefixMsgs,
+                        dialogMsgsForContext,
+                    },
+                    ephemeral: {
+                        subdialogResponseContextMsgs,
+                        internalDrivePromptMsg,
+                    },
+                    tail: {
+                        renderedReminders,
+                        languageGuideMsg: guideMsg,
+                    },
+                });
+                const remediation = await applyContextHealthV3Remediation({
+                    dlg,
+                    agent,
+                    agentTools,
+                    providerCfg,
+                    provider,
+                    systemPrompt,
+                    funcTools,
+                    ctxMsgs,
+                    llmGen,
+                    abortSignal,
+                    model,
+                    hadUserPromptThisGen: currentPrompt !== undefined,
+                });
+                if (remediation.kind === 'continue') {
+                    if (remediation.contextHealthForGen) {
+                        contextHealthForGen = remediation.contextHealthForGen;
+                    }
+                    pendingPrompt = remediation.nextPrompt;
+                    continue;
+                }
+                if (remediation.kind === 'suspend') {
+                    if (remediation.contextHealthForGen) {
+                        contextHealthForGen = remediation.contextHealthForGen;
+                    }
+                    suspendForHuman = true;
+                    break;
+                }
+                const ctxMsgsForGen = remediation.ctxMsgs;
+                if (agent.streaming === false) {
+                    if (llmGen.apiType === 'codex') {
+                        const detail = `Team config error: member '${agent.id}' has streaming=false but provider apiType=codex requires streaming=true (provider='${providerCfg.name}', genseq=${String(dlg.activeGenSeq)}).`;
+                        log_1.log.error(detail, new Error('team_config_invalid_streaming'));
+                        await dlg.streamError(detail);
+                        throw new Error(detail);
+                    }
+                    let nonStreamResult;
+                    try {
+                        throwIfAborted(abortSignal, dlg.id);
+                        nonStreamResult = await runLlmRequestWithRetry({
+                            dlg,
+                            provider,
+                            abortSignal,
+                            maxRetries: 5,
+                            canRetry: () => true,
+                            doRequest: async () => {
+                                return await llmGen.genMoreMessages(providerCfg, agent, systemPrompt, funcTools, ctxMsgsForGen, dlg.activeGenSeq, abortSignal);
+                            },
+                        });
+                    }
+                    catch (err) {
+                        if (abortSignal.aborted) {
+                            throwIfAborted(abortSignal, dlg.id);
+                        }
+                        generationHadError = true;
+                        throw err;
+                    }
+                    if (typeof nonStreamResult.llmGenModel === 'string' &&
+                        nonStreamResult.llmGenModel.trim() !== '') {
+                        llmGenModelForGen = nonStreamResult.llmGenModel.trim();
+                    }
+                    if (!agent.model) {
+                        throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
+                    }
+                    contextHealthForGen = computeContextHealthSnapshot({
+                        providerCfg,
+                        model: agent.model,
+                        usage: nonStreamResult.usage,
+                    });
+                    dlg.setLastContextHealth(contextHealthForGen);
+                    const nonStreamMsgs = nonStreamResult.messages;
+                    const assistantMsgs = nonStreamMsgs.filter((m) => m.type === 'saying_msg' || m.type === 'thinking_msg');
+                    const collectedAssistantCalls = [];
+                    if (assistantMsgs.length > 0) {
+                        await dlg.addChatMessages(...assistantMsgs);
+                        for (const msg of assistantMsgs) {
+                            if (msg.role === 'assistant' &&
+                                msg.genseq !== undefined &&
+                                (msg.type === 'thinking_msg' || msg.type === 'saying_msg')) {
+                                // Only persist saying_msg - thinking_msg is persisted via thinkingFinish
+                                if (msg.type === 'saying_msg') {
+                                    lastAssistantSayingContent = msg.content;
+                                    await dlg.persistAgentMessage(msg.content, msg.genseq, 'saying_msg');
+                                }
+                                // Emit thinking events using shared handler (non-streaming mode)
+                                if (msg.type === 'thinking_msg') {
+                                    await emitThinkingEvents(dlg, msg.content);
+                                }
+                                // Emit saying events using shared TellaskStreamParser integration
+                                if (msg.type === 'saying_msg') {
+                                    const calls = await emitSayingEvents(dlg, msg.content);
+                                    collectedAssistantCalls.push(...calls);
+                                }
+                            }
+                        }
+                    }
+                    const nonStreamingTellaskViolation = resolveDrivePolicyViolationKind({
+                        policy: drivePolicy,
+                        tellaskCalls: collectedAssistantCalls,
+                        functionCallCount: 0,
+                    });
+                    if (nonStreamingTellaskViolation === 'tellask') {
+                        const violationText = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, runtime_language_1.getWorkLanguage)(), {
+                            kind: 'tellask',
+                        });
+                        const genseq = dlg.activeGenSeq ?? 0;
+                        await dlg.addChatMessages({
+                            type: 'saying_msg',
+                            role: 'assistant',
+                            genseq,
+                            content: violationText,
+                        });
+                        lastAssistantSayingContent = violationText;
+                        await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
+                        return { lastAssistantSayingContent, interrupted: false };
+                    }
+                    if (collectedAssistantCalls.length > 0) {
+                        throwIfAborted(abortSignal, dlg.id);
+                        const assistantResult = await executeTellaskCalls(dlg, agent, collectedAssistantCalls);
+                        if (dlg.hasUpNext()) {
+                            return { lastAssistantSayingContent, interrupted: false };
+                        }
+                        if (assistantResult.toolOutputs.length > 0) {
+                            await dlg.addChatMessages(...assistantResult.toolOutputs);
+                        }
+                        if (assistantResult.suspend) {
+                            suspendForHuman = true;
+                        }
+                    }
+                    const funcCalls = nonStreamMsgs.filter((m) => m.type === 'func_call_msg');
+                    const nonStreamingToolViolation = resolveDrivePolicyViolationKind({
+                        policy: drivePolicy,
+                        tellaskCalls: [],
+                        functionCallCount: funcCalls.length,
+                    });
+                    if (nonStreamingToolViolation === 'tool') {
+                        const violationText = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, runtime_language_1.getWorkLanguage)(), {
+                            kind: 'tool',
+                        });
+                        const genseq = dlg.activeGenSeq ?? 0;
+                        await dlg.addChatMessages({
+                            type: 'saying_msg',
+                            role: 'assistant',
+                            genseq,
+                            content: violationText,
+                        });
+                        lastAssistantSayingContent = violationText;
+                        await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
+                        return { lastAssistantSayingContent, interrupted: false };
+                    }
+                    const functionPromises = funcCalls.map(async (func) => {
+                        throwIfAborted(abortSignal, dlg.id);
+                        // Use the genseq from the func_call_msg to ensure tool results share the same generation sequence
+                        // This is critical for correct grouping in reconstructAnthropicContext()
+                        const callGenseq = func.genseq;
+                        // Use the LLM-allocated unique id for tracking
+                        // This id comes from func_call_msg and is the proper unique identifier
+                        const callId = func.id;
+                        // argsStr is still needed for UI event (funcCallRequested)
+                        const argsStr = typeof func.arguments === 'string'
+                            ? func.arguments
+                            : JSON.stringify(func.arguments ?? {});
+                        const tool = agentTools.find((t) => t.type === 'func' && t.name === func.name);
+                        if (!tool) {
+                            const errorResult = {
+                                type: 'func_result_msg',
+                                id: func.id,
+                                name: func.name,
+                                content: `Tool '${func.name}' not found`,
+                                role: 'tool',
+                                genseq: callGenseq,
+                            };
+                            await dlg.receiveFuncResult(errorResult);
+                            return errorResult;
+                        }
+                        let rawArgs = {};
+                        if (typeof func.arguments === 'string' && func.arguments.trim()) {
+                            try {
+                                rawArgs = JSON.parse(func.arguments);
+                            }
+                            catch (parseErr) {
+                                rawArgs = null;
+                                log_1.log.warn('Failed to parse function arguments as JSON', {
+                                    funcName: func.name,
+                                    arguments: func.arguments,
+                                    error: parseErr,
+                                });
+                            }
+                        }
+                        let result;
+                        const argsValidation = validateFuncToolArguments(tool, rawArgs);
+                        if (argsValidation.ok) {
+                            const argsObj = argsValidation.args;
+                            // Emit func_call_requested event to build the func-call section UI
+                            try {
+                                await dlg.funcCallRequested(func.id, func.name, argsStr);
+                            }
+                            catch (err) {
+                                log_1.log.warn('Failed to emit func_call_requested event', err);
+                            }
+                            try {
+                                await dlg.persistFunctionCall(func.id, func.name, argsObj, callGenseq);
+                            }
+                            catch (err) {
+                                log_1.log.warn('Failed to persist function call', err);
+                            }
+                            try {
+                                throwIfAborted(abortSignal, dlg.id);
+                                const output = await tool.call(dlg, agent, argsObj);
+                                const normalized = typeof output === 'string'
+                                    ? { content: output, contentItems: undefined }
+                                    : {
+                                        content: typeof output.content === 'string' ? output.content : String(output),
+                                        contentItems: Array.isArray(output.contentItems)
+                                            ? output.contentItems
+                                            : undefined,
+                                    };
+                                result = {
+                                    type: 'func_result_msg',
+                                    id: func.id,
+                                    name: func.name,
+                                    content: String(normalized.content),
+                                    contentItems: normalized.contentItems,
+                                    role: 'tool',
+                                    genseq: callGenseq,
+                                };
+                            }
+                            catch (err) {
+                                result = {
+                                    type: 'func_result_msg',
+                                    id: func.id,
+                                    name: func.name,
+                                    content: `Function '${func.name}' execution failed: ${showErrorToAi(err)}`,
+                                    role: 'tool',
+                                    genseq: callGenseq,
+                                };
+                            }
+                        }
+                        else {
+                            result = {
+                                type: 'func_result_msg',
+                                id: func.id,
+                                name: func.name,
+                                content: `Invalid arguments: ${argsValidation.error}`,
+                                role: 'tool',
+                                genseq: callGenseq,
+                            };
+                        }
+                        await dlg.receiveFuncResult(result);
+                        return result;
+                    });
+                    const funcResults = await Promise.all(functionPromises);
+                    await Promise.resolve();
+                    // Add function calls AND results to dialog messages so LLM sees tool context in next iteration
+                    // Both are needed: func_call_msg for the tool definition, func_result_msg for the output
+                    if (funcCalls.length > 0) {
+                        const paired = [];
+                        for (let i = 0; i < funcCalls.length; i++) {
+                            paired.push(funcCalls[i]);
+                            paired.push(funcResults[i]);
+                        }
+                        await dlg.addChatMessages(...paired);
+                    }
+                    if (dlg.hasUpNext()) {
+                        pendingPrompt = resolveUpNextPrompt(dlg);
+                        continue;
+                    }
+                    if (suspendForHuman) {
+                        try {
+                            // Q4H suspension resets Diligence Push budget so post-Q4H continuation gets a fresh counter.
+                            if (await dlg.hasPendingQ4H()) {
+                                const configuredMax = resolveMemberDiligencePushMax(team, dlg.agentId);
+                                if (typeof configuredMax === 'number' && Number.isFinite(configuredMax)) {
+                                    const next = Math.floor(configuredMax);
+                                    dlg.diligencePushRemainingBudget =
+                                        next > 0 ? next : Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                }
+                                else {
+                                    dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                }
+                                void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                    kind: 'patch',
+                                    patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                                }));
+                            }
+                        }
+                        catch (err) {
+                            log_1.log.warn('Failed to check Q4H state for Diligence Push reset', err, {
+                                dialogId: dlg.id.valueOf(),
+                            });
+                        }
+                        break;
+                    }
+                    // Continue only when this round executed function tools.
+                    // Tellask-only rounds must stop and wait for sideline/backfill feedback.
+                    const shouldContinue = funcCalls.length > 0 || (funcResults.length > 0 && funcCalls.length === 0);
+                    if (!shouldContinue) {
+                        // Diligence Push (root dialog only): prevent ALL stopping except legitimate suspension.
+                        // If disabled (empty diligence file) or budget exhausted, we suspend via Q4H.
+                        if (dlg instanceof dialog_1.RootDialog) {
+                            const suspension = await dlg.getSuspensionStatus();
+                            if (!suspension.canDrive) {
+                                if (suspension.q4h) {
+                                    const configuredMax = resolveMemberDiligencePushMax(team, dlg.agentId);
+                                    if (typeof configuredMax === 'number' && Number.isFinite(configuredMax)) {
+                                        const next = Math.floor(configuredMax);
+                                        dlg.diligencePushRemainingBudget =
+                                            next > 0 ? next : Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                    }
+                                    else {
+                                        dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                    }
+                                    void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                        kind: 'patch',
+                                        patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                                    }));
+                                }
+                                break;
+                            }
+                            const hasQueuedResponses = await hasQueuedSubdialogResponses(dlg.id);
+                            if (hasQueuedResponses) {
+                                log_1.log.info('Skip diligence prompt while subdialog responses are still queued', {
+                                    dialogId: dlg.id.valueOf(),
+                                });
+                                break;
+                            }
+                            const prepared = await maybePrepareDiligenceAutoContinuePrompt({
+                                dlg,
+                                isRootDialog: true,
+                                remainingBudget: dlg.diligencePushRemainingBudget,
+                                diligencePushMax: resolveMemberDiligencePushMax(team, dlg.agentId),
+                                suppressDiligencePush: suppressDiligencePushForDrive,
+                            });
+                            dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
+                            void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                kind: 'patch',
+                                patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                            }));
+                            if (prepared.kind !== 'disabled') {
+                                (0, evt_registry_1.postDialogEvent)(dlg, {
+                                    type: 'diligence_budget_evt',
+                                    maxInjectCount: prepared.maxInjectCount,
+                                    injectedCount: Math.max(0, prepared.maxInjectCount - prepared.nextRemainingBudget),
+                                    remainingCount: Math.max(0, prepared.nextRemainingBudget),
+                                    disableDiligencePush: dlg.disableDiligencePush || suppressDiligencePushForDrive,
+                                });
+                            }
+                            if (prepared.kind === 'budget_exhausted') {
+                                await suspendForKeepGoingBudgetExhausted({
+                                    dlg,
+                                    maxInjectCount: prepared.maxInjectCount,
+                                });
+                                dlg.diligencePushRemainingBudget = 0;
+                                break;
+                            }
+                            if (prepared.kind === 'prompt') {
+                                pendingPrompt = prepared.prompt;
+                                continue;
+                            }
+                        }
+                        break;
+                    }
+                    continue;
+                }
+                else {
+                    const newMsgs = [];
+                    const streamedFuncCalls = [];
+                    // Track thinking content for signature extraction during streaming
+                    let currentThinkingContent = '';
+                    let currentThinkingSignature = '';
+                    let currentSayingContent = '';
+                    let sawAnyStreamContent = false;
+                    // Create receiver using shared helper (unified TellaskStreamParser integration)
+                    const receiver = createSayingEventsReceiver(dlg);
+                    // Direct streaming parser that forwards events without state tracking
+                    const parser = new tellask_1.TellaskStreamParser(receiver);
+                    let streamActive = { kind: 'idle' };
+                    let streamResult;
+                    try {
+                        streamResult = await runLlmRequestWithRetry({
+                            dlg,
+                            provider,
+                            abortSignal,
+                            maxRetries: 5,
+                            canRetry: () => !sawAnyStreamContent,
+                            doRequest: async () => {
+                                return await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, ctxMsgsForGen, {
+                                    streamError: async (detail) => {
+                                        await dlg.streamError(detail);
+                                    },
+                                    thinkingStart: async () => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        sawAnyStreamContent = true;
+                                        if (streamActive.kind !== 'idle') {
+                                            const detail = `Protocol violation: thinkingStart while ${streamActive.kind} is active (genseq=${String(dlg.activeGenSeq)}, provider=${providerCfg.apiType})`;
+                                            log_1.log.error(detail, new Error('stream_overlap_violation'));
+                                            await dlg.streamError(detail);
+                                            throw new Error(detail);
+                                        }
+                                        streamActive = { kind: 'thinking' };
+                                        currentThinkingContent = '';
+                                        currentThinkingSignature = '';
+                                        await dlg.thinkingStart();
+                                    },
+                                    thinkingChunk: async (chunk) => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        sawAnyStreamContent = true;
+                                        currentThinkingContent += chunk;
+                                        // Extract Anthropic thinking signature from content
+                                        const signatureMatch = currentThinkingContent.match(/<thinking[^>]*>(.*?)<\/thinking>/s);
+                                        if (signatureMatch && signatureMatch[1]) {
+                                            currentThinkingSignature = signatureMatch[1].trim();
+                                        }
+                                        await dlg.thinkingChunk(chunk);
+                                    },
+                                    thinkingFinish: async () => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        if (streamActive.kind !== 'thinking') {
+                                            const detail = `Protocol violation: thinkingFinish while ${streamActive.kind} is active (genseq=${String(dlg.activeGenSeq)}, provider=${providerCfg.apiType})`;
+                                            log_1.log.error(detail, new Error('stream_overlap_violation'));
+                                            await dlg.streamError(detail);
+                                            throw new Error(detail);
+                                        }
+                                        streamActive = { kind: 'idle' };
+                                        // Create thinking message with genseq and signature
+                                        const genseq = dlg.activeGenSeq;
+                                        if (genseq) {
+                                            const thinkingMessage = {
+                                                type: 'thinking_msg',
+                                                role: 'assistant',
+                                                genseq,
+                                                content: currentThinkingContent,
+                                                provider_data: currentThinkingSignature
+                                                    ? { signature: currentThinkingSignature }
+                                                    : undefined,
+                                            };
+                                            newMsgs.push(thinkingMessage);
+                                        }
+                                        await dlg.thinkingFinish();
+                                    },
+                                    sayingStart: async () => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        sawAnyStreamContent = true;
+                                        if (streamActive.kind !== 'idle') {
+                                            const detail = `Protocol violation: sayingStart while ${streamActive.kind} is active (genseq=${String(dlg.activeGenSeq)}, provider=${providerCfg.apiType})`;
+                                            log_1.log.error(detail, new Error('stream_overlap_violation'));
+                                            await dlg.streamError(detail);
+                                            throw new Error(detail);
+                                        }
+                                        streamActive = { kind: 'saying' };
+                                        currentSayingContent = '';
+                                        await dlg.sayingStart();
+                                    },
+                                    sayingChunk: async (chunk) => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        sawAnyStreamContent = true;
+                                        currentSayingContent += chunk;
+                                        await parser.takeUpstreamChunk(chunk);
+                                        // Dialog store handles persistence - maintain ordering guarantee
+                                        await dlg.sayingChunk(chunk);
+                                    },
+                                    sayingFinish: async () => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        if (streamActive.kind !== 'saying') {
+                                            const detail = `Protocol violation: sayingFinish while ${streamActive.kind} is active (genseq=${String(dlg.activeGenSeq)}, provider=${providerCfg.apiType})`;
+                                            log_1.log.error(detail, new Error('stream_overlap_violation'));
+                                            await dlg.streamError(detail);
+                                            throw new Error(detail);
+                                        }
+                                        streamActive = { kind: 'idle' };
+                                        await parser.finalize();
+                                        const sayingMessage = {
+                                            type: 'saying_msg',
+                                            role: 'assistant',
+                                            genseq: dlg.activeGenSeq,
+                                            content: currentSayingContent,
+                                        };
+                                        newMsgs.push(sayingMessage);
+                                        lastAssistantSayingContent = currentSayingContent;
+                                        await dlg.sayingFinish();
+                                    },
+                                    funcCall: async (callId, name, args) => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        sawAnyStreamContent = true;
+                                        const genseq = dlg.activeGenSeq;
+                                        if (genseq === undefined) {
+                                            return;
+                                        }
+                                        streamedFuncCalls.push({
+                                            type: 'func_call_msg',
+                                            role: 'assistant',
+                                            genseq,
+                                            id: callId,
+                                            name,
+                                            arguments: args,
+                                        });
+                                    },
+                                    webSearchCall: async (call) => {
+                                        throwIfAborted(abortSignal, dlg.id);
+                                        sawAnyStreamContent = true;
+                                        await dlg.webSearchCall(call);
+                                    },
+                                }, dlg.activeGenSeq, abortSignal);
+                            },
+                        });
+                    }
+                    catch (err) {
+                        if (abortSignal.aborted) {
+                            throwIfAborted(abortSignal, dlg.id);
+                        }
+                        generationHadError = true;
+                        log_1.log.error(`LLM gen error:`, err);
+                        throw err;
+                    }
+                    if (!streamResult) {
+                        throw new Error('Internal error: missing stream result after successful generation');
+                    }
+                    if (typeof streamResult.llmGenModel === 'string' &&
+                        streamResult.llmGenModel.trim() !== '') {
+                        llmGenModelForGen = streamResult.llmGenModel.trim();
+                    }
+                    if (!agent.model) {
+                        throw new Error(`Internal error: Model is undefined for agent '${agent.id}'`);
+                    }
+                    contextHealthForGen = computeContextHealthSnapshot({
+                        providerCfg,
+                        model: agent.model,
+                        usage: streamResult.usage,
+                    });
+                    dlg.setLastContextHealth(contextHealthForGen);
+                    // Execute collected calls concurrently after streaming completes
+                    const collectedCalls = parser.getCollectedCalls();
+                    const malformedToolOutputs = await emitMalformedTellaskResponses(dlg, collectedCalls);
+                    if (collectedCalls.length > 0 && !collectedCalls[0].callId) {
+                        throw new Error('Collected calls missing callId - parser should have allocated one per call');
+                    }
+                    const validCalls = collectedCalls.filter((call) => call.validation.kind === 'valid');
+                    const streamingPolicyViolation = resolveDrivePolicyViolationKind({
+                        policy: drivePolicy,
+                        tellaskCalls: collectedCalls,
+                        functionCallCount: streamedFuncCalls.length,
+                    });
+                    if (streamingPolicyViolation) {
+                        const violationText = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, runtime_language_1.getWorkLanguage)(), {
+                            kind: streamingPolicyViolation,
+                        });
+                        const genseq = dlg.activeGenSeq ?? 0;
+                        newMsgs.push({
+                            type: 'saying_msg',
+                            role: 'assistant',
+                            genseq,
+                            content: violationText,
+                        });
+                        lastAssistantSayingContent = violationText;
+                        await dlg.addChatMessages(...newMsgs);
+                        await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
+                        return { lastAssistantSayingContent, interrupted: false };
+                    }
+                    throwIfAborted(abortSignal, dlg.id);
+                    const results = await Promise.all(validCalls.map((call) => executeTellaskCall(dlg, agent, call.validation.firstMention, call.tellaskHead, call.body, call.callId)));
+                    if (dlg.hasUpNext()) {
+                        return { lastAssistantSayingContent, interrupted: false };
+                    }
+                    // Combine results from all concurrent calls.
+                    if (malformedToolOutputs.length > 0) {
+                        newMsgs.push(...malformedToolOutputs);
+                    }
+                    for (const result of results) {
+                        if (result.toolOutputs.length > 0) {
+                            newMsgs.push(...result.toolOutputs);
+                        }
+                        if (result.suspend) {
+                            suspendForHuman = true;
+                        }
+                    }
+                    const funcResults = [];
+                    if (streamedFuncCalls.length > 0) {
+                        const functionPromises = streamedFuncCalls.map(async (func) => {
+                            throwIfAborted(abortSignal, dlg.id);
+                            // Use the genseq from the func_call_msg to ensure tool results share the same generation sequence
+                            // This is critical for correct grouping in reconstructAnthropicContext()
+                            const callGenseq = func.genseq;
+                            // Use the LLM-allocated unique id for tracking
+                            // This id comes from func_call_msg and is the proper unique identifier
+                            const callId = func.id;
+                            // argsStr is still needed for UI event (funcCallRequested)
+                            const argsStr = typeof func.arguments === 'string'
+                                ? func.arguments
+                                : JSON.stringify(func.arguments ?? {});
+                            const tool = agentTools.find((t) => t.type === 'func' && t.name === func.name);
+                            if (!tool) {
+                                const errorResult = {
+                                    type: 'func_result_msg',
+                                    id: func.id,
+                                    name: func.name,
+                                    content: `Tool '${func.name}' not found`,
+                                    role: 'tool',
+                                    genseq: callGenseq,
+                                };
+                                await dlg.receiveFuncResult(errorResult);
+                                return errorResult;
+                            }
+                            let rawArgs = {};
+                            if (typeof func.arguments === 'string' && func.arguments.trim()) {
+                                try {
+                                    rawArgs = JSON.parse(func.arguments);
+                                }
+                                catch (parseErr) {
+                                    rawArgs = null;
+                                    log_1.log.warn('Failed to parse function arguments as JSON', {
+                                        funcName: func.name,
+                                        arguments: func.arguments,
+                                        error: parseErr,
+                                    });
+                                }
+                            }
+                            let result;
+                            const argsValidation = validateFuncToolArguments(tool, rawArgs);
+                            if (argsValidation.ok) {
+                                const argsObj = argsValidation.args;
+                                // Emit func_call_requested event to build the func-call section UI
+                                try {
+                                    await dlg.funcCallRequested(func.id, func.name, argsStr);
+                                }
+                                catch (err) {
+                                    log_1.log.warn('Failed to emit func_call_requested event', err);
+                                }
+                                try {
+                                    await dlg.persistFunctionCall(func.id, func.name, argsObj, callGenseq);
+                                }
+                                catch (err) {
+                                    log_1.log.warn('Failed to persist function call', err);
+                                }
+                                try {
+                                    throwIfAborted(abortSignal, dlg.id);
+                                    const output = await tool.call(dlg, agent, argsObj);
+                                    const normalized = typeof output === 'string'
+                                        ? { content: output, contentItems: undefined }
+                                        : {
+                                            content: typeof output.content === 'string' ? output.content : String(output),
+                                            contentItems: Array.isArray(output.contentItems)
+                                                ? output.contentItems
+                                                : undefined,
+                                        };
+                                    result = {
+                                        type: 'func_result_msg',
+                                        id: func.id,
+                                        name: func.name,
+                                        content: String(normalized.content),
+                                        contentItems: normalized.contentItems,
+                                        role: 'tool',
+                                        genseq: callGenseq,
+                                    };
+                                }
+                                catch (err) {
+                                    result = {
+                                        type: 'func_result_msg',
+                                        id: func.id,
+                                        name: func.name,
+                                        content: `Function '${func.name}' execution failed: ${showErrorToAi(err)}`,
+                                        role: 'tool',
+                                        genseq: callGenseq,
+                                    };
+                                }
+                            }
+                            else {
+                                result = {
+                                    type: 'func_result_msg',
+                                    id: func.id,
+                                    name: func.name,
+                                    content: `Invalid arguments: ${argsValidation.error}`,
+                                    role: 'tool',
+                                    genseq: callGenseq,
+                                };
+                            }
+                            await dlg.receiveFuncResult(result);
+                            return result;
+                        });
+                        funcResults.push(...(await Promise.all(functionPromises)));
+                    }
+                    if (streamedFuncCalls.length > 0) {
+                        for (let i = 0; i < streamedFuncCalls.length; i++) {
+                            newMsgs.push(streamedFuncCalls[i]);
+                            if (i < funcResults.length) {
+                                newMsgs.push(funcResults[i]);
+                            }
+                        }
+                    }
+                    await dlg.addChatMessages(...newMsgs);
+                    if (dlg.hasUpNext()) {
+                        pendingPrompt = resolveUpNextPrompt(dlg);
+                        continue;
+                    }
+                    // After tool execution, check latest remindersVer with published info,
+                    // publish new version to propagate updated reminders to ui
+                    if (dlg.remindersVer > pubRemindersVer) {
+                        try {
+                            await dlg.processReminderUpdates();
+                            pubRemindersVer = dlg.remindersVer;
+                        }
+                        catch (err) {
+                            log_1.log.warn('Failed to propagate reminder text after tools', err);
+                        }
+                    }
+                    await Promise.resolve();
+                    if (suspendForHuman) {
+                        try {
+                            // Q4H suspension resets Diligence Push budget so post-Q4H continuation gets a fresh counter.
+                            if (await dlg.hasPendingQ4H()) {
+                                const configuredMax = resolveMemberDiligencePushMax(team, dlg.agentId);
+                                if (typeof configuredMax === 'number' && Number.isFinite(configuredMax)) {
+                                    const next = Math.floor(configuredMax);
+                                    dlg.diligencePushRemainingBudget =
+                                        next > 0 ? next : Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                }
+                                else {
+                                    dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                }
+                            }
+                        }
+                        catch (err) {
+                            log_1.log.warn('Failed to check Q4H state for Diligence Push reset', err, {
+                                dialogId: dlg.id.valueOf(),
+                            });
+                        }
+                        break;
+                    }
+                    // Continue only when this round executed function tools.
+                    // Tellask-only rounds must stop and wait for sideline/backfill feedback.
+                    const shouldContinue = streamedFuncCalls.length > 0 || funcResults.length > 0;
+                    if (!shouldContinue) {
+                        // Diligence Push (root dialog only): prevent ALL stopping except legitimate suspension.
+                        if (dlg instanceof dialog_1.RootDialog) {
+                            const suspension = await dlg.getSuspensionStatus();
+                            if (!suspension.canDrive) {
+                                if (suspension.q4h) {
+                                    const configuredMax = resolveMemberDiligencePushMax(team, dlg.agentId);
+                                    if (typeof configuredMax === 'number' && Number.isFinite(configuredMax)) {
+                                        const next = Math.floor(configuredMax);
+                                        dlg.diligencePushRemainingBudget =
+                                            next > 0 ? next : Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                    }
+                                    else {
+                                        dlg.diligencePushRemainingBudget = Math.max(0, Math.floor(dlg.diligencePushRemainingBudget));
+                                    }
+                                    void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                        kind: 'patch',
+                                        patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                                    }));
+                                }
+                                break;
+                            }
+                            const hasQueuedResponses = await hasQueuedSubdialogResponses(dlg.id);
+                            if (hasQueuedResponses) {
+                                log_1.log.info('Skip diligence prompt while subdialog responses are still queued', {
+                                    dialogId: dlg.id.valueOf(),
+                                });
+                                break;
+                            }
+                            const prepared = await maybePrepareDiligenceAutoContinuePrompt({
+                                dlg,
+                                isRootDialog: true,
+                                remainingBudget: dlg.diligencePushRemainingBudget,
+                                diligencePushMax: resolveMemberDiligencePushMax(team, dlg.agentId),
+                                suppressDiligencePush: suppressDiligencePushForDrive,
+                            });
+                            dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
+                            void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+                                kind: 'patch',
+                                patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+                            }));
+                            if (prepared.kind !== 'disabled') {
+                                (0, evt_registry_1.postDialogEvent)(dlg, {
+                                    type: 'diligence_budget_evt',
+                                    maxInjectCount: prepared.maxInjectCount,
+                                    injectedCount: Math.max(0, prepared.maxInjectCount - prepared.nextRemainingBudget),
+                                    remainingCount: Math.max(0, prepared.nextRemainingBudget),
+                                    disableDiligencePush: dlg.disableDiligencePush || suppressDiligencePushForDrive,
+                                });
+                            }
+                            if (prepared.kind === 'budget_exhausted') {
+                                await suspendForKeepGoingBudgetExhausted({
+                                    dlg,
+                                    maxInjectCount: prepared.maxInjectCount,
+                                });
+                                dlg.diligencePushRemainingBudget = 0;
+                                break;
+                            }
+                            if (prepared.kind === 'prompt') {
+                                pendingPrompt = prepared.prompt;
+                                continue;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            finally {
+                await dlg.notifyGeneratingFinish(contextHealthForGen, llmGenModelForGen);
+            }
+        }
+        finalRunState = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+        return { lastAssistantSayingContent, interrupted: false };
+    }
+    catch (err) {
+        const stopRequested = (0, dialog_run_state_1.getStopRequestedReason)(dlg.id);
+        const interruptedReason = err instanceof DialogInterruptedError
+            ? err.reason
+            : abortSignal.aborted
+                ? stopRequested === 'emergency_stop'
+                    ? { kind: 'emergency_stop' }
+                    : stopRequested === 'user_stop'
+                        ? { kind: 'user_stop' }
+                        : { kind: 'system_stop', detail: 'Aborted.' }
+                : undefined;
+        if (interruptedReason) {
+            // If subdialog responses were taken during this drive, interruption means they
+            // should be rolled back for retry instead of being committed as consumed.
+            generationHadError = true;
+            finalRunState = { kind: 'interrupted', reason: interruptedReason };
+            (0, dialog_run_state_1.broadcastRunStateMarker)(dlg.id, { kind: 'interrupted', reason: interruptedReason });
+            return { lastAssistantSayingContent, interrupted: true };
+        }
+        generationHadError = true;
+        const errText = (0, log_1.extractErrorDetails)(err).message;
+        try {
+            await dlg.streamError(errText);
+        }
+        catch (_emitErr) {
+            // best-effort
+        }
+        finalRunState = { kind: 'interrupted', reason: { kind: 'system_stop', detail: errText } };
+        (0, dialog_run_state_1.broadcastRunStateMarker)(dlg.id, {
+            kind: 'interrupted',
+            reason: { kind: 'system_stop', detail: errText },
+        });
+        return { lastAssistantSayingContent, interrupted: true };
+    }
+    finally {
+        (0, dialog_run_state_1.clearActiveRun)(dlg.id);
+        if (!finalRunState) {
+            try {
+                finalRunState = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+            }
+            catch (stateErr) {
+                log_1.log.warn('Failed to compute final run state; falling back to idle', stateErr, {
+                    dialogId: dlg.id.valueOf(),
+                });
+                finalRunState = { kind: 'idle_waiting_user' };
+            }
+        }
+        // "dead" is irreversible. If another actor declared this dialog dead during an in-flight
+        // generation, do not overwrite it with a computed idle/interrupted state.
+        try {
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(dlg.id, 'running');
+            if (dlg.id.selfId !== dlg.id.rootId &&
+                latest &&
+                latest.runState &&
+                latest.runState.kind === 'dead') {
+                finalRunState = latest.runState;
+            }
+        }
+        catch (err) {
+            log_1.log.warn('Failed to re-check runState before finalizing; proceeding best-effort', err, {
+                dialogId: dlg.id.valueOf(),
+            });
+        }
+        await (0, dialog_run_state_1.setDialogRunState)(dlg.id, finalRunState);
+        if (tookSubdialogResponses) {
+            try {
+                await withSuspensionStateLock(dlg.id, async () => {
+                    if (generationHadError) {
+                        await persistence_1.DialogPersistence.rollbackTakenSubdialogResponses(dlg.id);
+                    }
+                    else {
+                        await persistence_1.DialogPersistence.commitTakenSubdialogResponses(dlg.id);
+                        committedTakenSubdialogResponses = true;
+                    }
+                });
+            }
+            catch (err2) {
+                log_1.log.warn('Failed to finalize subdialog response queue after drive', {
+                    dialogId: dlg.id.selfId,
+                    error: err2,
+                });
+            }
+        }
+        if (committedTakenSubdialogResponses && takenSubdialogResponses.length > 0) {
+            try {
+                const mirroredMsgs = takenSubdialogResponses.map((response) => ({
+                    type: 'tellask_result_msg',
+                    role: 'tool',
+                    responderId: response.responderId,
+                    tellaskHead: response.tellaskHead,
+                    status: response.status ?? 'completed',
+                    content: (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                        responderId: response.responderId,
+                        requesterId: response.originMemberId,
+                        originalCallHeadLine: response.tellaskHead,
+                        responseBody: response.response,
+                        language: (0, runtime_language_1.getWorkLanguage)(),
+                    }),
+                }));
+                await dlg.addChatMessages(...mirroredMsgs);
+            }
+            catch (err) {
+                log_1.log.warn('Failed to mirror committed subdialog responses into dialog msgs', {
+                    dialogId: dlg.id.selfId,
+                    error: err,
+                });
+            }
+        }
+    }
+} // Close while loop
+// Dialog stream has completed - no need to mark queue as complete since we're using receivers
+// === SINGLE DIALOG HIERARCHY RESTORATION API ===
+/**
+ * Single API for restoring the complete dialog hierarchy (main dialog + all subdialogs)
+ * This is the only public restoration API - all serialization is implicit
+ */
+async function restoreDialogHierarchy(rootDialogId, status = 'running') {
+    try {
+        const rootDialogIdent = new dialog_1.DialogID(rootDialogId);
+        // Assert that the ID refers to a root dialog, not a subdialog selfId.
+        const rootMeta = await persistence_1.DialogPersistence.loadRootDialogMetadata(rootDialogIdent, status);
+        if (rootMeta?.supdialogId) {
+            throw new Error(`Expected root dialog ${rootDialogId} but found subdialog metadata with supdialogId: ${rootMeta.supdialogId}`);
+        }
+        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootDialogId, status);
+        if (!rootDialog) {
+            throw new Error(`Failed to restore dialog hierarchy for ${rootDialogId} from status ${status}`);
+        }
+        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+        // Restore all subdialogs under this root by reading the persisted subdialogs directory,
+        // then ensuring each subdialog is loaded into the root dialog's local registry.
+        const subdialogs = new Map();
+        const rootPath = persistence_1.DialogPersistence.getRootDialogPath(rootDialogIdent, status);
+        const subPath = path.join(rootPath, persistence_1.DialogPersistence.SUBDIALOGS_DIR);
+        let allSubdialogIds = [];
+        try {
+            const entries = await fs.promises.readdir(subPath, { withFileTypes: true });
+            allSubdialogIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch (err) {
+            const code = typeof err === 'object' && err !== null && 'code' in err
+                ? err.code
+                : undefined;
+            if (code !== 'ENOENT') {
+                log_1.log.warn(`Failed to read subdialogs directory: ${subPath}, returning empty array`, err);
+            }
+            allSubdialogIds = [];
+        }
+        for (const subdialogId of allSubdialogIds) {
+            const restoredSubdialogId = new dialog_1.DialogID(subdialogId, rootDialog.id.rootId);
+            const dialog = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, restoredSubdialogId, status);
+            if (dialog && dialog.id.selfId !== dialog.id.rootId) {
+                subdialogs.set(subdialogId, dialog);
+            }
+        }
+        // Calculate summary statistics
+        let totalMessages = rootDialog.msgs.length;
+        let totalCourses = rootDialog.currentCourse;
+        for (const dlg of subdialogs.values()) {
+            totalMessages += dlg.msgs.length;
+            if (dlg.currentCourse > totalCourses)
+                totalCourses = dlg.currentCourse;
+        }
+        const summary = {
+            totalMessages,
+            totalCourses,
+            completionStatus: 'incomplete',
+        };
+        return {
+            rootDialog,
+            subdialogs,
+            summary,
+        };
+    }
+    catch (error) {
+        log_1.log.error(`Failed to restore dialog hierarchy for ${rootDialogId}:`, error);
+        throw error;
+    }
+}
+function isValidTellaskSession(tellaskSession) {
+    const segments = tellaskSession.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 isFbrSelfTellaskHeadLine(tellaskHead) {
+    return /^\s*@self\b/.test(tellaskHead);
+}
+function replaceTellaskSessionDirective(tellaskHead, tellaskSession) {
+    // Replace the first occurrence only. If missing, append it as a best-effort.
+    const re = /(^|\s)!tellaskSession\s+([^\s]+)/;
+    if (re.test(tellaskHead)) {
+        return tellaskHead.replace(re, (m, p1) => `${String(p1)}!tellaskSession ${tellaskSession}`);
+    }
+    return `${tellaskHead} !tellaskSession ${tellaskSession}`;
+}
+function resolveFbrEffort(member) {
+    const raw = member?.fbr_effort;
+    if (typeof raw !== 'number' || !Number.isFinite(raw))
+        return 0;
+    if (!Number.isInteger(raw))
+        return 0;
+    if (raw < 0)
+        return 0;
+    if (raw > 100)
+        return 0;
+    return raw;
+}
+function mergeModelParams(base, overlay) {
+    if (!base && !overlay)
+        return undefined;
+    if (!base)
+        return overlay;
+    if (!overlay)
+        return base;
+    return {
+        max_tokens: overlay.max_tokens ?? base.max_tokens,
+        codex: { ...(base.codex ?? {}), ...(overlay.codex ?? {}) },
+        openai: { ...(base.openai ?? {}), ...(overlay.openai ?? {}) },
+        anthropic: { ...(base.anthropic ?? {}), ...(overlay.anthropic ?? {}) },
+    };
+}
+function buildDrivePolicy(args) {
+    const { dlg, agent, systemPrompt, agentTools, language } = args;
+    if (!isToollessFbrSelfSubdialog(dlg)) {
+        return {
+            mode: 'default',
+            effectiveAgent: agent,
+            effectiveSystemPrompt: systemPrompt,
+            effectiveAgentTools: agentTools,
+            prependedContextMessages: [],
+            tellaskPolicy: 'allow_any',
+            allowFunctionCalls: true,
+        };
+    }
+    const effectiveAgent = Object.assign(Object.create(agent), {
+        model_params: mergeModelParams(agent.model_params, agent.fbr_model_params),
+    });
+    return {
+        mode: 'fbr_toolless',
+        effectiveAgent,
+        effectiveSystemPrompt: buildFbrSystemPrompt(language),
+        effectiveAgentTools: [],
+        prependedContextMessages: [
+            {
+                type: 'environment_msg',
+                role: 'user',
+                content: (0, system_prompt_parts_1.buildNoToolsNotice)(language),
+            },
+        ],
+        tellaskPolicy: 'tellasker_only',
+        allowFunctionCalls: false,
+    };
+}
+function hasTellaskPolicyViolation(policy, calls) {
+    if (policy.tellaskPolicy === 'allow_any') {
+        return false;
+    }
+    return calls.some((call) => {
+        if (call.validation.kind !== 'valid') {
+            return true;
+        }
+        return call.validation.firstMention !== 'tellasker';
+    });
+}
+function resolveDrivePolicyViolationKind(args) {
+    const tellaskViolation = hasTellaskPolicyViolation(args.policy, args.tellaskCalls);
+    const toolViolation = !args.policy.allowFunctionCalls && args.functionCallCount > 0;
+    if (tellaskViolation && toolViolation) {
+        return 'tellask_and_tool';
+    }
+    if (tellaskViolation) {
+        return 'tellask';
+    }
+    if (toolViolation) {
+        return 'tool';
+    }
+    return null;
+}
+function validateDrivePolicyInvariants(policy, language) {
+    if (policy.mode !== 'fbr_toolless') {
+        return { ok: true };
+    }
+    const expectedSystemPrompt = buildFbrSystemPrompt(language);
+    if (policy.effectiveSystemPrompt !== expectedSystemPrompt) {
+        return {
+            ok: false,
+            detail: 'FBR must use buildFbrSystemPrompt(language) exactly.',
+        };
+    }
+    if (policy.effectiveAgentTools.length > 0) {
+        return {
+            ok: false,
+            detail: 'FBR effectiveAgentTools must be empty.',
+        };
+    }
+    if (policy.allowFunctionCalls) {
+        return {
+            ok: false,
+            detail: 'FBR allowFunctionCalls must be false.',
+        };
+    }
+    if (policy.tellaskPolicy !== 'tellasker_only') {
+        return {
+            ok: false,
+            detail: 'FBR tellaskPolicy must be tellasker_only.',
+        };
+    }
+    const expectedNoToolsNotice = (0, system_prompt_parts_1.buildNoToolsNotice)(language);
+    if (policy.prependedContextMessages.length !== 1) {
+        return {
+            ok: false,
+            detail: 'FBR must prepend exactly one no-tools notice message.',
+        };
+    }
+    const [notice] = policy.prependedContextMessages;
+    if (!notice ||
+        notice.type !== 'environment_msg' ||
+        notice.role !== 'user' ||
+        notice.content !== expectedNoToolsNotice) {
+        return {
+            ok: false,
+            detail: 'FBR prepended notice must exactly match buildNoToolsNotice(language).',
+        };
+    }
+    return { ok: true };
+}
+function buildFbrSystemPrompt(language) {
+    const prefix = language === 'zh'
+        ? [
+            '# 扪心自问（FBR）支线对话',
+            '',
+            '- 你正在处理一次由 `!?@self` 发起的 FBR 支线对话。',
+            '- 诉请正文是主要任务上下文；不要假设能访问诉请者对话历史。',
+            '- 若使用可恢复的 `!tellaskSession` 形式，你可以使用本支线对话自身的 `tellaskSession` 历史作为显式上下文。',
+            '- 若诉请正文缺少关键上下文，请在输出中列出缺失信息与阻塞原因。',
+            '- 仅当必须澄清关键缺失上下文时，允许用 `!?@tellasker` 回问诉请者；除此之外不要发起任何诉请。',
+        ].join('\n')
+        : [
+            '# Fresh Boots Reasoning (FBR) sideline dialog',
+            '',
+            '- This is an FBR sideline dialog created by `!?@self`.',
+            '- The tellask body is the primary task context; do not assume access to tellasker dialog history.',
+            '- If this is the resumable `!tellaskSession` form, you may use this sideline dialog’s own tellaskSession history as explicit context.',
+            '- If the tellask body is missing critical context, list what is missing and why it blocks reasoning.',
+            '- `!?@tellasker` is allowed only when you must clarify critical missing context; otherwise do not emit any tellasks.',
+        ].join('\n');
+    return prefix.trim();
+}
+function isToollessFbrSelfSubdialog(dlg) {
+    return dlg instanceof dialog_1.SubDialog && isFbrSelfTellaskHeadLine(dlg.assignmentFromSup.tellaskHead);
+}
+/**
+ * Parse a teammate tellask pattern and return the appropriate type result.
+ *
+ * Patterns:
+ * - @<supdialogAgentId> (in subdialog context, matching supdialog.agentId) → Type A (supdialog suspension)
+ * - @<agentId> !tellaskSession <tellaskSession> → Type B (registered subdialog)
+ * - @<agentId> → Type C (transient subdialog)
+ *
+ * @param firstMention The first teammate mention extracted by the streaming parser (e.g., "teammate")
+ * @param tellaskHead The full headline text from the streaming parser
+ * @param currentDialog Optional current dialog context to detect Type A (subdialog calling parent)
+ * @returns The parsed TeammateTellaskParseResult
+ */
+function parseTeammateTellask(firstMention, tellaskHead, currentDialog) {
+    // Fresh Boots Reasoning (FBR) syntax sugar:
+    // `@self` always targets the current dialog's agentId (same persona/config).
+    //
+    // This avoids ambiguous `@teammate`-to-`@teammate` self-tellasks which can also be produced accidentally
+    // by echoing/quoting an assignment headline. We keep parsing behavior the same for all other
+    // mentions.
+    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,
+        };
+    }
+    // Phase 11: Check if this is a Type A call (subdialog calling its direct parent)
+    // Type A only applies when:
+    // 1. A current dialog context is provided
+    // 2. The current dialog is a SubDialog (has a supdialog)
+    // 3. The @agentId matches the supdialog's agentId
+    if (currentDialog &&
+        currentDialog.supdialog &&
+        firstMention === currentDialog.supdialog.agentId) {
+        return {
+            type: 'A',
+            agentId: firstMention,
+        };
+    }
+    // Type C: Any @agentId is a transient subdialog call
+    return {
+        type: 'C',
+        agentId: firstMention,
+    };
+}
+// === CONVENIENCE METHODS USING SINGLE RESTORATION API ===
+/**
+ * Continue dialog with human response (uses single restoration API)
+ */
+async function continueDialogWithHumanResponse(rootDialogId, humanPrompt, options) {
+    try {
+        // Restore the complete dialog hierarchy (pure restoration, no continuation)
+        const result = await restoreDialogHierarchy(rootDialogId, 'running');
+        // Then perform continuation separately
+        if (options?.targetSubdialogId && result.subdialogs.has(options.targetSubdialogId)) {
+            // Continue specific subdialog
+            const targetSubdialog = result.subdialogs.get(options.targetSubdialogId);
+            await driveDialogStream(targetSubdialog, humanPrompt);
+        }
+        else {
+            // Continue root dialog
+            await driveDialogStream(result.rootDialog, humanPrompt);
+        }
+    }
+    catch (error) {
+        log_1.log.error(`Failed to continue dialog with human response:`, error);
+        throw error;
+    }
+}
+/**
+ * Continue root dialog with followup message (uses single restoration API)
+ */
+async function continueRootDialog(rootDialogId, humanPrompt) {
+    try {
+        // Restore the complete dialog hierarchy (pure restoration, no continuation)
+        const result = await restoreDialogHierarchy(rootDialogId, 'running');
+        // Then perform continuation separately
+        await driveDialogStream(result.rootDialog, humanPrompt);
+    }
+    catch (error) {
+        log_1.log.error(`Failed to continue root dialog:`, error);
+        throw error;
+    }
+}
+/**
+ * Unified function to extract the last assistant message from an array of messages.
+ * Prefers saying_msg over thinking_msg, returns full content without truncation.
+ *
+ * @param messages Array of chat messages to search
+ * @param defaultMessage Default message if no assistant message found
+ * @returns The extracted message content or default
+ */
+function extractLastAssistantResponse(messages, defaultMessage) {
+    let responseText = '';
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.type === 'saying_msg' && typeof msg.content === 'string') {
+            responseText = msg.content;
+            break;
+        }
+        if (msg.type === 'thinking_msg' && typeof msg.content === 'string') {
+            responseText = msg.content;
+            // Keep looking for a saying_msg which is more complete
+        }
+    }
+    // If no assistant message found, use the default
+    if (!responseText) {
+        responseText = defaultMessage;
+    }
+    return responseText;
+}
+/**
+ * Phase 11: Extract response from supdialog's current messages for Type A mechanism.
+ * Used when a subdialog calls its parent (supdialog) and needs the parent's response.
+ * Reads from the in-memory dialog object which contains the latest messages after driving.
+ *
+ * @param supdialog The supdialog that was just driven
+ * @returns The response text from the supdialog's last assistant message
+ */
+async function extractSupdialogResponseForTypeA(supdialog) {
+    try {
+        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 });
+        return 'Supdialog completed with errors.';
+    }
+}
+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);
+    if (!existing) {
+        return undefined;
+    }
+    const existingSession = existing.tellaskSession;
+    if (!existingSession) {
+        throw new Error(`Type B registry invariant violation: lookupSubdialog returned entry without tellaskSession (root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(existing.id, rootDialog.status);
+    const runState = latest?.runState;
+    if (!runState || runState.kind !== 'dead') {
+        return existing;
+    }
+    const removed = rootDialog.unregisterSubdialog(existing.agentId, existingSession);
+    if (!removed) {
+        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, {
+        rootId: rootDialog.id.rootId,
+        subdialogId: existing.id.selfId,
+        agentId: existing.agentId,
+        tellaskSession: existingSession,
+    });
+    return undefined;
+}
+let agentPrimingModulePromise = null;
+async function scheduleInheritedAgentPrimingForSubdialog(callerDialog, subdialog) {
+    const rootDialog = callerDialog instanceof dialog_1.RootDialog
+        ? callerDialog
+        : callerDialog instanceof dialog_1.SubDialog
+            ? callerDialog.rootDialog
+            : undefined;
+    if (!rootDialog)
+        return;
+    const inheritedMode = rootDialog.subdialogAgentPrimingMode;
+    if (inheritedMode === 'skip')
+        return;
+    if (!agentPrimingModulePromise) {
+        agentPrimingModulePromise = Promise.resolve().then(() => __importStar(require('../agent-priming')));
+    }
+    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);
+    await scheduleInheritedAgentPrimingForSubdialog(callerDialog, subdialog);
+    return subdialog;
+}
+async function resolveOwnerDialogBySelfId(subdialog, ownerDialogId) {
+    const rootDialog = subdialog.rootDialog;
+    if (ownerDialogId === rootDialog.id.selfId) {
+        return rootDialog;
+    }
+    const existing = rootDialog.lookupDialog(ownerDialogId);
+    if (existing)
+        return existing;
+    return await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, new dialog_1.DialogID(ownerDialogId, rootDialog.id.rootId), 'running');
+}
+async function supplySubdialogResponseToSpecificCallerIfPending(subdialog, responseText, target) {
+    const assignment = subdialog.assignmentFromSup;
+    if (!assignment) {
+        return false;
+    }
+    const ownerDialog = await resolveOwnerDialogBySelfId(subdialog, target.ownerDialogId);
+    if (!ownerDialog) {
+        return false;
+    }
+    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(ownerDialog.id);
+    const pendingRecord = pending.find((p) => p.subdialogId === subdialog.id.selfId);
+    if (!pendingRecord) {
+        return false;
+    }
+    if (pendingRecord.callType !== target.callType) {
+        log_1.log.warn('Reply target callType does not match pending callType; skipping stale reply target', {
+            rootId: subdialog.rootDialog.id.rootId,
+            subdialogId: subdialog.id.selfId,
+            ownerDialogId: ownerDialog.id.selfId,
+            targetCallType: target.callType,
+            pendingCallType: pendingRecord.callType,
+        });
+        return false;
+    }
+    await supplyResponseToSupdialog(ownerDialog, subdialog.id, responseText, pendingRecord.callType, target.callId, 'completed');
+    return true;
+}
+async function supplySubdialogResponseToAssignedCallerIfPending(subdialog, responseText) {
+    const assignment = subdialog.assignmentFromSup;
+    if (!assignment) {
+        return false;
+    }
+    const callerDialog = await resolveOwnerDialogBySelfId(subdialog, assignment.callerDialogId);
+    if (!callerDialog) {
+        log_1.log.warn('Missing caller dialog for subdialog response supply', {
+            rootId: subdialog.rootDialog.id.rootId,
+            subdialogId: subdialog.id.selfId,
+            callerDialogId: assignment.callerDialogId,
+        });
+        return false;
+    }
+    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(callerDialog.id);
+    const pendingRecord = pending.find((p) => p.subdialogId === subdialog.id.selfId);
+    if (!pendingRecord) {
+        return false;
+    }
+    await supplyResponseToSupdialog(callerDialog, subdialog.id, responseText, pendingRecord.callType, assignment.callId, 'completed');
+    return true;
+}
+// === PHASE 6: SUBDIALOG SUPPLY MECHANISM ===
+/**
+ * Create a Type A subdialog for supdialog suspension.
+ * Creates subdialog, persists pending record, and returns suspended promise.
+ *
+ * Type A: Supdialog suspension call where subdialog calls parent and parent suspends.
+ *
+ * @param supdialog The supdialog making the call
+ * @param targetAgentId The agent to handle the subdialog
+ * @param tellaskHead The headline for the subdialog
+ * @param tellaskBody The body content for the subdialog
+ * @returns Promise resolving when subdialog is created and pending record saved
+ */
+async function createSubdialogForSupdialog(supdialog, targetAgentId, tellaskHead, tellaskBody, callId) {
+    try {
+        // Create the subdialog
+        const subdialog = await createSubDialogWithInheritedPriming(supdialog, targetAgentId, tellaskHead, tellaskBody, {
+            originMemberId: supdialog.agentId,
+            callerDialogId: supdialog.id.selfId,
+            callId,
+            collectiveTargets: [targetAgentId],
+        });
+        // Persist pending subdialog record
+        const pendingRecord = {
+            subdialogId: subdialog.id.selfId,
+            createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            tellaskHead,
+            targetAgentId,
+            callType: 'A',
+        };
+        // Load existing pending subdialogs and add new one
+        await withSuspensionStateLock(supdialog.id, async () => {
+            await persistence_1.DialogPersistence.appendPendingSubdialog(supdialog.id, pendingRecord);
+        });
+        await syncPendingTellaskReminderBestEffort(supdialog, 'createSubdialogForSupdialog:appendPending');
+        // Drive the subdialog asynchronously
+        void (async () => {
+            try {
+                const initPrompt = {
+                    content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                        fromAgentId: supdialog.agentId,
+                        toAgentId: subdialog.agentId,
+                        tellaskHead,
+                        tellaskBody: tellaskBody,
+                        language: (0, runtime_language_1.getWorkLanguage)(),
+                        collectiveTargets: [targetAgentId],
+                    }),
+                    msgId: (0, id_1.generateShortId)(),
+                    grammar: 'markdown',
+                    subdialogReplyTarget: {
+                        ownerDialogId: supdialog.id.selfId,
+                        callType: 'A',
+                        callId,
+                    },
+                };
+                await driveDialogStream(subdialog, initPrompt, true);
+            }
+            catch (err) {
+                log_1.log.warn('Type A subdialog processing error:', err);
+            }
+        })();
+    }
+    catch (error) {
+        log_1.log.error('Failed to create Type A subdialog for supdialog', {
+            supdialogId: supdialog.id.selfId,
+            targetAgentId,
+            error,
+        });
+        throw error;
+    }
+}
+/**
+ * Create a Type B registered subdialog with registry lookup/register.
+ * Creates or resumes a registered subdialog tracked in registry.yaml.
+ *
+ * Type B: @<agentId> !tellaskSession <tellaskSession> - Creates/resumes registered subdialog.
+ *
+ * @param rootDialog The root dialog making the call
+ * @param agentId The agent to handle the subdialog
+ * @param tellaskSession The tellask session key for registry lookup
+ * @param tellaskHead The headline for the subdialog
+ * @param tellaskBody The body content for the subdialog
+ * @returns Promise resolving when subdialog is created/registered
+ */
+/**
+ * Supply a response from a completed subdialog to the supdialog.
+ * Writes the response to persistence for later incorporation.
+ *
+ * @param parentDialog The supdialog that created the subdialog
+ * @param subdialogId The ID of the completed subdialog
+ * @param responseText The full response text from the subdialog
+ * @param callType The call type ('A', 'B', or 'C')
+ * @param callId Optional callId for Type C subdialog tracking
+ */
+async function supplyResponseToSupdialog(parentDialog, subdialogId, responseText, callType, callId, status = 'completed') {
+    try {
+        const result = await withSuspensionStateLock(parentDialog.id, async () => {
+            const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(parentDialog.id);
+            let pendingRecord;
+            const filteredPending = [];
+            for (const pending of pendingSubdialogs) {
+                if (pending.subdialogId === subdialogId.selfId) {
+                    pendingRecord = pending;
+                }
+                else {
+                    filteredPending.push(pending);
+                }
+            }
+            let responderId = subdialogId.rootId;
+            let responderAgentId;
+            let tellaskHead = responseText;
+            let originMemberId;
+            try {
+                let metadata = await persistence_1.DialogPersistence.loadDialogMetadata(subdialogId, 'running');
+                if (!metadata) {
+                    metadata = await persistence_1.DialogPersistence.loadDialogMetadata(subdialogId, 'completed');
+                }
+                if (metadata && metadata.assignmentFromSup) {
+                    originMemberId = metadata.assignmentFromSup.originMemberId;
+                    if (!pendingRecord) {
+                        const assignmentHead = metadata.assignmentFromSup.tellaskHead;
+                        if (typeof assignmentHead === 'string' && assignmentHead.trim() !== '') {
+                            tellaskHead = assignmentHead;
+                        }
+                    }
+                }
+                if (!pendingRecord && metadata && typeof metadata.agentId === 'string') {
+                    if (metadata.agentId.trim() !== '') {
+                        responderId = metadata.agentId;
+                        responderAgentId = metadata.agentId;
+                    }
+                }
+            }
+            catch (err) {
+                log_1.log.warn('Failed to load subdialog metadata for response record', {
+                    parentId: parentDialog.id.selfId,
+                    subdialogId: subdialogId.selfId,
+                    error: err,
+                });
+            }
+            if (!originMemberId) {
+                originMemberId = parentDialog.agentId;
+            }
+            if (pendingRecord) {
+                responderId = pendingRecord.targetAgentId;
+                responderAgentId = pendingRecord.targetAgentId;
+                tellaskHead = pendingRecord.tellaskHead;
+            }
+            if (tellaskHead.trim() === '') {
+                tellaskHead = responseText.slice(0, 100) + (responseText.length > 100 ? '...' : '');
+            }
+            const responseContent = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                responderId,
+                requesterId: originMemberId,
+                originalCallHeadLine: tellaskHead,
+                responseBody: responseText,
+                language: (0, runtime_language_1.getWorkLanguage)(),
+            });
+            const completedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+            const responseId = (0, id_1.generateShortId)();
+            await persistence_1.DialogPersistence.appendSubdialogResponse(parentDialog.id, {
+                responseId,
+                subdialogId: subdialogId.selfId,
+                response: responseText,
+                completedAt,
+                status,
+                callType,
+                tellaskHead,
+                responderId,
+                originMemberId,
+                callId: callId ?? '',
+            });
+            await persistence_1.DialogPersistence.savePendingSubdialogs(parentDialog.id, filteredPending);
+            const hasQ4H = await parentDialog.hasPendingQ4H();
+            const shouldRevive = !hasQ4H && filteredPending.length === 0;
+            if (shouldRevive && parentDialog instanceof dialog_1.RootDialog) {
+                await persistence_1.DialogPersistence.setNeedsDrive(parentDialog.id, true, parentDialog.status);
+            }
+            return {
+                responderId,
+                responderAgentId,
+                tellaskHead,
+                originMemberId,
+                responseContent,
+                filteredPendingCount: filteredPending.length,
+                shouldRevive,
+            };
+        });
+        const resolvedAgentId = result.responderAgentId ?? result.responderId;
+        const resolvedOriginMemberId = result.originMemberId ?? parentDialog.agentId;
+        const resolvedCallId = callId ?? '';
+        await syncPendingTellaskReminderBestEffort(parentDialog, 'supplyResponseToSupdialog:savePending');
+        await parentDialog.receiveTeammateResponse(result.responderId, result.tellaskHead, status, subdialogId, {
+            response: responseText,
+            agentId: resolvedAgentId,
+            callId: resolvedCallId,
+            originMemberId: resolvedOriginMemberId,
+        });
+        if (result.shouldRevive) {
+            log_1.log.info(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} auto-reviving`);
+            if (parentDialog instanceof dialog_1.RootDialog) {
+                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(parentDialog.id.rootId);
+            }
+            const suppressDiligencePushForReviveDrive = parentDialog.disableDiligencePush;
+            void driveDialogStream(parentDialog, undefined, true, {
+                suppressDiligencePush: suppressDiligencePushForReviveDrive,
+            });
+        }
+    }
+    catch (error) {
+        log_1.log.error('Failed to supply subdialog response', {
+            parentId: parentDialog.id.selfId,
+            subdialogId: subdialogId.selfId,
+            error,
+        });
+        throw error;
+    }
+}
+/**
+ * Check if all pending Type A subdialogs are satisfied (have responses).
+ *
+ * @param rootDialogId The root dialog ID to check
+ * @returns Promise<boolean> True if all Type A subdialogs have responses
+ */
+async function areAllSubdialogsSatisfied(rootDialogId) {
+    try {
+        const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(rootDialogId);
+        const responses = await persistence_1.DialogPersistence.loadSubdialogResponses(rootDialogId);
+        // Check if any pending subdialogs have responses
+        const pendingIds = new Set(pendingSubdialogs.map((p) => p.subdialogId));
+        const respondedIds = new Set(responses.map((r) => r.subdialogId));
+        // Check if all pending subdialogs have been responded to
+        for (const pendingId of pendingIds) {
+            if (!respondedIds.has(pendingId)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        log_1.log.error('Failed to check subdialog satisfaction', {
+            rootDialogId: rootDialogId.selfId,
+            error,
+        });
+        return false;
+    }
+}
+/**
+ * Incorporate subdialog responses into the supdialog and resume.
+ * Reads responses from persistence and clears them after incorporation.
+ *
+ * @param rootDialog The root dialog to resume
+ * @returns Promise<Array<{ subdialogId: string; response: string; callType: 'A' | 'B' | 'C' }>>
+ *   Array of incorporated responses (response holds full response text)
+ */
+async function incorporateSubdialogResponses(rootDialog) {
+    try {
+        const responses = await persistence_1.DialogPersistence.loadSubdialogResponses(rootDialog.id);
+        // Incorporate each response
+        for (const response of responses) {
+            const subdialogId = new dialog_1.DialogID(response.subdialogId, rootDialog.id.rootId);
+            // Emit subdialog response event (payload contains full response text)
+            await rootDialog.postSubdialogResponse(subdialogId, response.response);
+        }
+        // Clear responses after incorporation
+        await persistence_1.DialogPersistence.saveSubdialogResponses(rootDialog.id, []);
+        // Clear pending subdialogs that have been responded to
+        const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(rootDialog.id);
+        const respondedIds = new Set(responses.map((r) => r.subdialogId));
+        const filteredPending = pendingSubdialogs.filter((p) => !respondedIds.has(p.subdialogId));
+        await persistence_1.DialogPersistence.savePendingSubdialogs(rootDialog.id, filteredPending);
+        await syncPendingTellaskReminderBestEffort(rootDialog, 'incorporateSubdialogResponses:savePending');
+        return responses;
+    }
+    catch (error) {
+        log_1.log.error('Failed to incorporate subdialog responses', {
+            rootDialogId: rootDialog.id.selfId,
+            error,
+        });
+        throw error;
+    }
+}
+/**
+ * Collect tellask calls using the streaming parser, then execute them
+ */
+async function executeTellaskCalls(dlg, agent, collectedCalls) {
+    const malformedToolOutputs = await emitMalformedTellaskResponses(dlg, collectedCalls);
+    const validCalls = collectedCalls.filter((call) => call.validation.kind === 'valid');
+    // Execute collected calls concurrently
+    const results = await Promise.all(validCalls.map((call) => executeTellaskCall(dlg, agent, call.validation.firstMention, call.tellaskHead, call.body, call.callId)));
+    // Combine results from all concurrent calls
+    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 };
+}
+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;
+}
+/**
+ * Execute a single tellask call using Phase 5 3-Type Taxonomy.
+ * Handles Type A (supdialog suspension), Type B (registered subdialog), and Type C (transient subdialog).
+ */
+async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, callId, options) {
+    const toolOutputs = [];
+    let suspend = false;
+    const subdialogsCreated = [];
+    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);
+    // Multi-teammate fan-out (collective teammate tellask):
+    // A single tellask block can target multiple teammates by including multiple teammate mentions
+    // anywhere inside the (possibly multiline) headline. The full headline/body is passed verbatim
+    // to each target so each subdialog can see this is a collective assignment.
+    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, {
+                    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),
+            };
+        }
+    }
+    // === Q4H: Handle @human teammate tellasks (Questions for Human) ===
+    // Q4H works for both user-initiated and assistant-initiated @human calls
+    const isQ4H = firstMention === 'human';
+    if (isQ4H) {
+        try {
+            // Create HumanQuestion entry
+            const questionId = `q4h-${(0, id_2.generateDialogID)()}`;
+            const question = {
+                id: questionId,
+                tellaskHead: tellaskHead.trim(),
+                bodyContent: body.trim(),
+                askedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                callId: callId.trim() === '' ? undefined : callId,
+                callSiteRef: {
+                    course: dlg.currentCourse,
+                    messageIndex: dlg.msgs.length,
+                },
+            };
+            await persistence_1.DialogPersistence.appendQuestion4HumanState(dlg.id, question);
+            // Emit new_q4h_asked event
+            const newQuestionEvent = {
+                type: 'new_q4h_asked',
+                question: {
+                    id: question.id,
+                    selfId: dlg.id.selfId,
+                    tellaskHead: question.tellaskHead,
+                    bodyContent: question.bodyContent,
+                    askedAt: question.askedAt,
+                    callId: question.callId,
+                    callSiteRef: question.callSiteRef,
+                    rootId: dlg.id.rootId,
+                    agentId: dlg.agentId,
+                    taskDocPath: dlg.taskDocPath,
+                },
+            };
+            (0, evt_registry_1.postDialogEvent)(dlg, newQuestionEvent);
+            // Return empty output and suspend for human answer
+            return { toolOutputs, suspend: true, subdialogsCreated: [] };
+        }
+        catch (q4hErr) {
+            const errMsg = q4hErr instanceof Error ? q4hErr.message : String(q4hErr);
+            const streamErr = `Q4H register invariant violation: dialog=${dlg.id.selfId} callId=${callId.trim()} reason=${errMsg}`;
+            try {
+                await dlg.streamError(streamErr);
+            }
+            catch (streamErrPost) {
+                log_1.log.warn('Q4H: failed to emit stream_error_evt', streamErrPost, {
+                    dialogId: dlg.id.selfId,
+                });
+            }
+            log_1.log.error('Q4H: Failed to register question', q4hErr, {
+                dialogId: dlg.id.selfId,
+                tellaskHead: tellaskHead.substring(0, 100),
+            });
+            const msg = (0, driver_messages_1.formatDomindsNoteQ4HRegisterFailed)((0, runtime_language_1.getWorkLanguage)(), { error: errMsg });
+            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 (member || isSelfAlias || isTellaskerAlias) {
+        // This is a teammate tellask - parse using Phase 5 taxonomy (Type A/B/C).
+        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 (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 parseResult = isTellaskerAlias
+            ? { type: 'A', agentId: dlg.supdialog.agentId }
+            : parseTeammateTellask(firstMention, tellaskHead, dlg);
+        // `@self` FBR enhancements:
+        // - Respect per-member fbr_effort (0 disables; 1..100 fan-out)
+        // - Fan-out creates multiple sideline dialogs concurrently for a single `@self` tellask
+        if (isSelfAlias) {
+            const fbrEffort = resolveFbrEffort(member);
+            if (fbrEffort < 1) {
+                const msg = (0, driver_messages_1.formatDomindsNoteFbrDisabled)((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 callerDialog = dlg;
+            const originMemberId = dlg.agentId;
+            if (parseResult.type === 'C') {
+                const createdSubs = [];
+                const pendingRecords = [];
+                for (let i = 1; i <= fbrEffort; i++) {
+                    const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, tellaskHead, body, {
+                        originMemberId,
+                        callerDialogId: callerDialog.id.selfId,
+                        callId,
+                        collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
+                    });
+                    createdSubs.push(sub);
+                    pendingRecords.push({
+                        subdialogId: sub.id.selfId,
+                        createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                        tellaskHead,
+                        targetAgentId: parseResult.agentId,
+                        callType: 'C',
+                    });
+                }
+                await withSuspensionStateLock(dlg.id, async () => {
+                    await persistence_1.DialogPersistence.mutatePendingSubdialogs(dlg.id, (previous) => ({
+                        kind: 'replace',
+                        records: [...previous, ...pendingRecords],
+                    }));
+                });
+                await syncPendingTellaskReminderBestEffort(dlg, 'executeTellaskCall:FBR-TypeC:replacePending');
+                for (const sub of createdSubs) {
+                    void (async () => {
+                        try {
+                            const initPrompt = {
+                                content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                                    fromAgentId: dlg.agentId,
+                                    toAgentId: sub.agentId,
+                                    tellaskHead,
+                                    tellaskBody: body,
+                                    language: (0, runtime_language_1.getWorkLanguage)(),
+                                    collectiveTargets: options?.collectiveTargets ?? [sub.agentId],
+                                }),
+                                msgId: (0, id_1.generateShortId)(),
+                                grammar: 'markdown',
+                                subdialogReplyTarget: {
+                                    ownerDialogId: callerDialog.id.selfId,
+                                    callType: 'C',
+                                    callId,
+                                },
+                            };
+                            await driveDialogStream(sub, initPrompt, true);
+                        }
+                        catch (err) {
+                            log_1.log.warn('FBR Type C subdialog processing error:', err);
+                        }
+                    })();
+                    subdialogsCreated.push(sub.id);
+                }
+                return { toolOutputs, suspend: true, subdialogsCreated };
+            }
+            if (parseResult.type === 'B') {
+                let rootDialog;
+                if (dlg instanceof dialog_1.RootDialog) {
+                    rootDialog = dlg;
+                }
+                else if (dlg instanceof dialog_1.SubDialog) {
+                    rootDialog = dlg.rootDialog;
+                }
+                if (!rootDialog) {
+                    const msg = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, runtime_language_1.getWorkLanguage)(), {
+                        kind: 'internal_error',
+                    });
+                    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 pendingOwner = callerDialog;
+                const baseSession = parseResult.tellaskSession;
+                const derivedPrefix = `${baseSession}.fbr-`;
+                const createdOrExisting = await withSuspensionStateLock(rootDialog.id, async () => {
+                    const results = [];
+                    const ensurePoolSessions = (desired) => {
+                        if (desired <= 1)
+                            return [baseSession];
+                        const set = new Set();
+                        for (const sub of rootDialog.getRegisteredSubdialogs()) {
+                            const tellaskSession = sub.tellaskSession;
+                            if (typeof tellaskSession !== 'string')
+                                continue;
+                            if (sub.agentId !== parseResult.agentId)
+                                continue;
+                            if (!tellaskSession.startsWith(derivedPrefix))
+                                continue;
+                            set.add(tellaskSession);
+                        }
+                        while (set.size < desired) {
+                            const candidate = `${derivedPrefix}${(0, id_1.generateShortId)()}`;
+                            set.add(candidate);
+                        }
+                        const pool = Array.from(set);
+                        for (let i = pool.length - 1; i >= 1; i--) {
+                            const j = Math.floor(Math.random() * (i + 1));
+                            const tmp = pool[i];
+                            pool[i] = pool[j];
+                            pool[j] = tmp;
+                        }
+                        return pool.slice(0, desired);
+                    };
+                    const sessions = ensurePoolSessions(fbrEffort);
+                    for (const derivedSession of sessions) {
+                        // Important: do not embed stable per-instance indexing into the headline.
+                        // Even with `!tellaskSession`, fan-out instances should not look like “self #1/#2/#3”.
+                        const indexedHeadLine = tellaskHead;
+                        const assignment = {
+                            tellaskHead: indexedHeadLine,
+                            tellaskBody: body,
+                            originMemberId,
+                            callerDialogId: callerDialog.id.selfId,
+                            callId,
+                            collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
+                        };
+                        const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, derivedSession);
+                        if (existing) {
+                            try {
+                                await updateSubdialogAssignment(existing, assignment);
+                            }
+                            catch (err) {
+                                log_1.log.warn('Failed to update registered FBR subdialog assignment', err);
+                            }
+                            results.push({
+                                kind: 'existing',
+                                subdialog: existing,
+                                tellaskSession: derivedSession,
+                                indexedHeadLine,
+                            });
+                            continue;
+                        }
+                        const created = await createSubDialogWithInheritedPriming(rootDialog, parseResult.agentId, indexedHeadLine, body, {
+                            originMemberId,
+                            callerDialogId: callerDialog.id.selfId,
+                            callId,
+                            tellaskSession: derivedSession,
+                            collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
+                        });
+                        rootDialog.registerSubdialog(created);
+                        results.push({
+                            kind: 'created',
+                            subdialog: created,
+                            tellaskSession: derivedSession,
+                            indexedHeadLine,
+                        });
+                    }
+                    await rootDialog.saveSubdialogRegistry();
+                    return results;
+                });
+                const pendingRecords = createdOrExisting.map((r) => ({
+                    subdialogId: r.subdialog.id.selfId,
+                    createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                    tellaskHead: r.indexedHeadLine,
+                    targetAgentId: parseResult.agentId,
+                    callType: 'B',
+                    tellaskSession: r.tellaskSession,
+                }));
+                await withSuspensionStateLock(pendingOwner.id, async () => {
+                    const toRemove = new Set(pendingRecords.map((p) => p.subdialogId));
+                    await persistence_1.DialogPersistence.mutatePendingSubdialogs(pendingOwner.id, (previous) => {
+                        const next = previous.filter((p) => !toRemove.has(p.subdialogId));
+                        next.push(...pendingRecords);
+                        return { kind: 'replace', records: next };
+                    });
+                });
+                await syncPendingTellaskReminderBestEffort(pendingOwner, 'executeTellaskCall:FBR-TypeB:replacePending');
+                for (const r of createdOrExisting) {
+                    void (async () => {
+                        try {
+                            const prompt = {
+                                content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                                    fromAgentId: dlg.agentId,
+                                    toAgentId: r.subdialog.agentId,
+                                    tellaskHead: r.indexedHeadLine,
+                                    tellaskBody: body,
+                                    language: (0, runtime_language_1.getWorkLanguage)(),
+                                    collectiveTargets: options?.collectiveTargets ?? [r.subdialog.agentId],
+                                }),
+                                msgId: (0, id_1.generateShortId)(),
+                                grammar: 'markdown',
+                                subdialogReplyTarget: {
+                                    ownerDialogId: pendingOwner.id.selfId,
+                                    callType: 'B',
+                                    callId,
+                                },
+                            };
+                            await driveDialogStream(r.subdialog, prompt, true);
+                        }
+                        catch (err) {
+                            log_1.log.warn(r.kind === 'existing'
+                                ? 'FBR Type B registered subdialog resumption error:'
+                                : 'FBR Type B subdialog processing error:', err);
+                        }
+                    })();
+                    subdialogsCreated.push(r.subdialog.id);
+                }
+                return { toolOutputs, suspend: true, subdialogsCreated };
+            }
+        }
+        // If the agent calls itself via `@<agentId>` (instead of `@self`), allow it to proceed
+        // (self-tellasks are useful for FBR), but emit a correction bubble so the user can distinguish
+        // intentional self-FBR from accidental echo/quote triggers.
+        const isDirectSelfCall = !isSelfAlias && !isTellaskerAlias && 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,
+                });
+            }
+        }
+        // Phase 11: Type A handling - subdialog calling its direct parent (supdialog)
+        // This suspends the subdialog, drives the supdialog for one course, then returns to subdialog
+        if (parseResult.type === 'A') {
+            // Type A is only valid from a subdialog (calling back to its supdialog).
+            if (dlg instanceof dialog_1.SubDialog) {
+                const supdialog = dlg.supdialog;
+                // Suspend the subdialog
+                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,
+                            },
+                            supdialogAssignment: {
+                                tellaskHead: assignment.tellaskHead,
+                                tellaskBody: assignment.tellaskBody,
+                            },
+                            language: (0, runtime_language_1.getWorkLanguage)(),
+                        }),
+                        msgId: (0, id_1.generateShortId)(),
+                        grammar: 'markdown',
+                    };
+                    // Drive the supdialog for one course (queue if already driving)
+                    await driveDialogStream(supdialog, supPrompt, true);
+                    // Extract response from supdialog's last assistant message
+                    const responseText = await extractSupdialogResponseForTypeA(supdialog);
+                    const responseContent = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                        responderId: parseResult.agentId,
+                        requesterId: dlg.agentId,
+                        originalCallHeadLine: tellaskHead,
+                        responseBody: responseText,
+                        language: (0, runtime_language_1.getWorkLanguage)(),
+                    });
+                    // Resume the subdialog with the supdialog's response
+                    dlg.setSuspensionState('resumed');
+                    const resultMsg = {
+                        type: 'tellask_result_msg',
+                        role: 'tool',
+                        responderId: parseResult.agentId,
+                        tellaskHead,
+                        status: 'completed',
+                        content: responseContent,
+                    };
+                    toolOutputs.push(resultMsg);
+                    await dlg.receiveTeammateResponse(parseResult.agentId, tellaskHead, 'completed', supdialog.id, {
+                        response: responseText,
+                        agentId: parseResult.agentId,
+                        callId,
+                        originMemberId: dlg.agentId,
+                    });
+                }
+                catch (err) {
+                    log_1.log.warn('Type A supdialog processing error:', err);
+                    // Resume the subdialog even on error
+                    dlg.setSuspensionState('resumed');
+                    const errorText = `❌ **Error processing request to @${parseResult.agentId}:**\n\n${showErrorToAi(err)}`;
+                    const resultMsg = {
+                        type: 'tellask_result_msg',
+                        role: 'tool',
+                        responderId: parseResult.agentId,
+                        tellaskHead,
+                        status: 'failed',
+                        content: errorText,
+                    };
+                    toolOutputs.push(resultMsg);
+                    await dlg.receiveTeammateResponse(parseResult.agentId, tellaskHead, 'failed', supdialog.id, {
+                        response: errorText,
+                        agentId: parseResult.agentId,
+                        callId,
+                        originMemberId: dlg.agentId,
+                    });
+                }
+            }
+            else {
+                log_1.log.warn('Type A call on dialog without supdialog, falling back to Type C', {
+                    dialogId: dlg.id.selfId,
+                });
+                // Fall through to Type C handling
+            }
+        }
+        else if (parseResult.type === 'B') {
+            // Type B: Registered subdialog with tellaskSession (root registry, caller can be root or subdialog)
+            const callerDialog = dlg;
+            let rootDialog;
+            if (dlg instanceof dialog_1.RootDialog) {
+                rootDialog = dlg;
+            }
+            else if (dlg instanceof dialog_1.SubDialog) {
+                rootDialog = dlg.rootDialog;
+            }
+            if (!rootDialog) {
+                log_1.log.warn('Type B call without root dialog, falling back to Type C', {
+                    dialogId: dlg.id.selfId,
+                });
+                try {
+                    const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, tellaskHead, body, {
+                        originMemberId: dlg.agentId,
+                        callerDialogId: callerDialog.id.selfId,
+                        callId,
+                        tellaskSession: parseResult.tellaskSession,
+                        collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
+                    });
+                    const pendingRecord = {
+                        subdialogId: sub.id.selfId,
+                        createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                        tellaskHead,
+                        targetAgentId: parseResult.agentId,
+                        callType: 'C',
+                        tellaskSession: parseResult.tellaskSession,
+                    };
+                    await withSuspensionStateLock(dlg.id, async () => {
+                        await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord);
+                    });
+                    await syncPendingTellaskReminderBestEffort(dlg, 'executeTellaskCall:TypeB-fallback:appendPending');
+                    const task = (async () => {
+                        try {
+                            const initPrompt = {
+                                content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                                    fromAgentId: dlg.agentId,
+                                    toAgentId: sub.agentId,
+                                    tellaskHead,
+                                    tellaskBody: body,
+                                    language: (0, runtime_language_1.getWorkLanguage)(),
+                                    collectiveTargets: options?.collectiveTargets ?? [sub.agentId],
+                                }),
+                                msgId: (0, id_1.generateShortId)(),
+                                grammar: 'markdown',
+                                subdialogReplyTarget: {
+                                    ownerDialogId: callerDialog.id.selfId,
+                                    callType: 'C',
+                                    callId,
+                                },
+                            };
+                            await driveDialogStream(sub, initPrompt, true);
+                        }
+                        catch (err) {
+                            log_1.log.warn('Type B fallback subdialog processing error:', err);
+                        }
+                    })();
+                    void task;
+                    subdialogsCreated.push(sub.id);
+                    suspend = true;
+                }
+                catch (err) {
+                    log_1.log.warn('Type B fallback subdialog creation error:', err);
+                }
+            }
+            else {
+                const originMemberId = dlg.agentId;
+                const assignment = {
+                    tellaskHead,
+                    tellaskBody: body,
+                    originMemberId,
+                    callerDialogId: callerDialog.id.selfId,
+                    callId,
+                    collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
+                };
+                const pendingOwner = callerDialog;
+                const result = await withSuspensionStateLock(rootDialog.id, async () => {
+                    const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, parseResult.tellaskSession);
+                    if (existing) {
+                        try {
+                            await updateSubdialogAssignment(existing, assignment);
+                        }
+                        catch (err) {
+                            log_1.log.warn('Failed to update registered subdialog assignment', err);
+                        }
+                        return { kind: 'existing', subdialog: existing };
+                    }
+                    const created = await createSubDialogWithInheritedPriming(rootDialog, parseResult.agentId, tellaskHead, body, {
+                        originMemberId,
+                        callerDialogId: callerDialog.id.selfId,
+                        callId,
+                        tellaskSession: parseResult.tellaskSession,
+                        collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
+                    });
+                    rootDialog.registerSubdialog(created);
+                    await rootDialog.saveSubdialogRegistry();
+                    return { kind: 'created', subdialog: created };
+                });
+                const pendingRecord = {
+                    subdialogId: result.subdialog.id.selfId,
+                    createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                    tellaskHead,
+                    targetAgentId: parseResult.agentId,
+                    callType: 'B',
+                    tellaskSession: parseResult.tellaskSession,
+                };
+                await withSuspensionStateLock(pendingOwner.id, async () => {
+                    await persistence_1.DialogPersistence.mutatePendingSubdialogs(pendingOwner.id, (previous) => {
+                        const next = previous.filter((p) => p.subdialogId !== pendingRecord.subdialogId);
+                        next.push(pendingRecord);
+                        return { kind: 'replace', records: next };
+                    });
+                });
+                await syncPendingTellaskReminderBestEffort(pendingOwner, 'executeTellaskCall:TypeB:replacePending');
+                const task = (async () => {
+                    try {
+                        if (result.kind === 'existing') {
+                            const resumePrompt = {
+                                content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                                    fromAgentId: dlg.agentId,
+                                    toAgentId: result.subdialog.agentId,
+                                    tellaskHead,
+                                    tellaskBody: body,
+                                    language: (0, runtime_language_1.getWorkLanguage)(),
+                                    collectiveTargets: options?.collectiveTargets ?? [result.subdialog.agentId],
+                                }),
+                                msgId: (0, id_1.generateShortId)(),
+                                grammar: 'markdown',
+                                subdialogReplyTarget: {
+                                    ownerDialogId: pendingOwner.id.selfId,
+                                    callType: 'B',
+                                    callId,
+                                },
+                            };
+                            await driveDialogStream(result.subdialog, resumePrompt, true);
+                            return;
+                        }
+                        const initPrompt = {
+                            content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                                fromAgentId: rootDialog.agentId,
+                                toAgentId: result.subdialog.agentId,
+                                tellaskHead,
+                                tellaskBody: body,
+                                language: (0, runtime_language_1.getWorkLanguage)(),
+                                collectiveTargets: options?.collectiveTargets ?? [result.subdialog.agentId],
+                            }),
+                            msgId: (0, id_1.generateShortId)(),
+                            grammar: 'markdown',
+                            subdialogReplyTarget: {
+                                ownerDialogId: pendingOwner.id.selfId,
+                                callType: 'B',
+                                callId,
+                            },
+                        };
+                        await driveDialogStream(result.subdialog, initPrompt, true);
+                    }
+                    catch (err) {
+                        log_1.log.warn(result.kind === 'existing'
+                            ? 'Type B registered subdialog resumption error:'
+                            : 'Type B subdialog processing error:', err);
+                    }
+                })();
+                void task;
+                subdialogsCreated.push(result.subdialog.id);
+                suspend = true;
+            }
+        }
+        // Type C: Transient subdialog (unregistered)
+        if (parseResult.type === 'C') {
+            try {
+                const sub = await createSubDialogWithInheritedPriming(dlg, parseResult.agentId, tellaskHead, body, {
+                    originMemberId: dlg.agentId,
+                    callerDialogId: dlg.id.selfId,
+                    callId,
+                    collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
+                });
+                const pendingRecord = {
+                    subdialogId: sub.id.selfId,
+                    createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                    tellaskHead,
+                    targetAgentId: parseResult.agentId,
+                    callType: 'C',
+                };
+                await withSuspensionStateLock(dlg.id, async () => {
+                    await persistence_1.DialogPersistence.appendPendingSubdialog(dlg.id, pendingRecord);
+                });
+                await syncPendingTellaskReminderBestEffort(dlg, 'executeTellaskCall:TypeC:appendPending');
+                const task = (async () => {
+                    try {
+                        const initPrompt = {
+                            content: (0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                                fromAgentId: dlg.agentId,
+                                toAgentId: sub.agentId,
+                                tellaskHead,
+                                tellaskBody: body,
+                                language: (0, runtime_language_1.getWorkLanguage)(),
+                                collectiveTargets: options?.collectiveTargets ?? [sub.agentId],
+                            }),
+                            msgId: (0, id_1.generateShortId)(),
+                            grammar: 'markdown',
+                            subdialogReplyTarget: {
+                                ownerDialogId: dlg.id.selfId,
+                                callType: 'C',
+                                callId,
+                            },
+                        };
+                        // Type C: Move to done/ on completion (handled by subdialog completion)
+                        await driveDialogStream(sub, initPrompt, true);
+                    }
+                    catch (err) {
+                        log_1.log.warn('Type C subdialog processing error:', err);
+                    }
+                })();
+                void task;
+                subdialogsCreated.push(sub.id);
+                suspend = true;
+            }
+            catch (err) {
+                log_1.log.warn('Subdialog creation error:', err);
+            }
+        }
+    }
+    else {
+        // Not a team member: tellask is reserved for teammate tellasks.
+        // All tools (including dialog control tools) must use native function-calling.
+        const msg = (0, driver_messages_1.formatDomindsNoteTellaskForTeammatesOnly)((0, runtime_language_1.getWorkLanguage)(), { firstMention });
+        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, subdialogsCreated };
+}
+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;
+}