dominds 1.4.2 → 1.5.2

package/dist/llm/driver-v2-ref-only/core.js

@@ -0,0 +1,1710 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driveDialogStreamCoreV2 = driveDialogStreamCoreV2;
+const dialog_1 = require("../../dialog");
+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 persistence_1 = require("../../persistence");
+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 time_1 = require("../../shared/utils/time");
+const taskdoc_1 = require("../../utils/taskdoc");
+const client_1 = require("../client");
+const registry_1 = require("../gen/registry");
+const tools_projection_1 = require("../tools-projection");
+const context_1 = require("./context");
+const context_health_1 = require("./context-health");
+const policy_1 = require("./policy");
+const runtime_utils_1 = require("./runtime-utils");
+const saying_events_1 = require("./saying-events");
+const tellask_bridge_1 = require("./tellask-bridge");
+class DialogInterruptedError extends Error {
+    constructor(reason) {
+        super('Dialog interrupted');
+        this.reason = reason;
+    }
+}
+function throwIfAborted(abortSignal, dialog) {
+    if (!abortSignal?.aborted) {
+        return;
+    }
+    const stopRequested = (0, dialog_run_state_1.getStopRequestedReason)(dialog.id);
+    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.' });
+}
+function resolveMemberDiligencePushMax(team, agentId) {
+    const member = team.getMember(agentId);
+    if (member && member.diligence_push_max !== undefined) {
+        return member.diligence_push_max;
+    }
+    return diligence_1.DEFAULT_DILIGENCE_PUSH_MAX;
+}
+function emitDiligenceBudgetEvent(dlg, options) {
+    const maxInjectCount = Math.max(0, Math.floor(options.maxInjectCount));
+    const remainingCount = Math.max(0, Math.floor(options.nextRemainingBudget));
+    (0, evt_registry_1.postDialogEvent)(dlg, {
+        type: 'diligence_budget_evt',
+        maxInjectCount,
+        injectedCount: Math.max(0, maxInjectCount - remainingCount),
+        remainingCount,
+        disableDiligencePush: dlg.disableDiligencePush,
+    });
+}
+function resolveUpNextPrompt(dlg) {
+    const upNext = dlg.takeUpNext();
+    if (!upNext) {
+        return undefined;
+    }
+    return {
+        content: upNext.prompt,
+        msgId: upNext.msgId,
+        grammar: upNext.grammar ?? 'markdown',
+        userLanguageCode: upNext.userLanguageCode,
+        q4hAnswerCallIds: upNext.q4hAnswerCallIds,
+    };
+}
+function isUserOriginPrompt(prompt) {
+    if (!prompt) {
+        return false;
+    }
+    return (prompt.origin ?? 'user') === 'user';
+}
+function normalizeQ4HAnswerCallIds(raw) {
+    if (!raw || raw.length === 0)
+        return undefined;
+    const seen = new Set();
+    const normalized = [];
+    for (const value of raw) {
+        const callId = value.trim();
+        if (callId === '' || seen.has(callId))
+            continue;
+        seen.add(callId);
+        normalized.push(callId);
+    }
+    return normalized.length > 0 ? normalized : undefined;
+}
+async function emitUserMarkdown(dlg, content) {
+    if (!content.trim()) {
+        return;
+    }
+    await dlg.markdownStart();
+    await dlg.markdownChunk(content);
+    await dlg.markdownFinish();
+}
+function resolveModelInfo(providerCfg, model) {
+    return providerCfg.models[model];
+}
+const DRIVER_V2_DEFAULT_RETRY_POLICY = {
+    maxRetries: 5,
+    initialDelayMs: 1000,
+    backoffMultiplier: 2,
+    maxDelayMs: 30000,
+};
+const DRIVER_V2_EMPTY_LLM_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';
+function resolveRetryMaxRetries(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.maxRetries;
+    }
+    const normalized = Math.floor(raw);
+    if (normalized < 0) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.maxRetries;
+    }
+    return normalized;
+}
+function resolveRetryInitialDelayMs(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.initialDelayMs;
+    }
+    const normalized = Math.floor(raw);
+    if (normalized < 0) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.initialDelayMs;
+    }
+    return normalized;
+}
+function resolveRetryBackoffMultiplier(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.backoffMultiplier;
+    }
+    if (raw < 1) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.backoffMultiplier;
+    }
+    return raw;
+}
+function resolveRetryMaxDelayMs(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.maxDelayMs;
+    }
+    const normalized = Math.floor(raw);
+    if (normalized < 0) {
+        return DRIVER_V2_DEFAULT_RETRY_POLICY.maxDelayMs;
+    }
+    return normalized;
+}
+function resolveDriverV2RetryPolicy(providerCfg) {
+    const maxRetries = resolveRetryMaxRetries(providerCfg.llm_retry_max_retries);
+    const initialDelayMs = resolveRetryInitialDelayMs(providerCfg.llm_retry_initial_delay_ms);
+    const backoffMultiplier = resolveRetryBackoffMultiplier(providerCfg.llm_retry_backoff_multiplier);
+    const maxDelayMs = resolveRetryMaxDelayMs(providerCfg.llm_retry_max_delay_ms);
+    return {
+        maxRetries,
+        initialDelayMs,
+        backoffMultiplier,
+        maxDelayMs: Math.max(initialDelayMs, maxDelayMs),
+    };
+}
+function hasMeaningfulBatchOutput(messages) {
+    for (const msg of messages) {
+        if (msg.type === 'func_call_msg') {
+            return true;
+        }
+        if ((msg.type === 'saying_msg' || msg.type === 'thinking_msg') && msg.content.trim() !== '') {
+            return true;
+        }
+    }
+    return false;
+}
+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;
+    const defaultOptimal = 100000;
+    const effectiveOptimalMaxTokens = optimalMaxTokensConfigured !== undefined ? optimalMaxTokensConfigured : defaultOptimal;
+    const defaultCritical = Math.max(1, Math.floor(args.modelContextLimitTokens * 0.9));
+    const effectiveCriticalMaxTokens = criticalMaxTokensConfigured !== undefined ? criticalMaxTokensConfigured : defaultCritical;
+    return {
+        effectiveOptimalMaxTokens,
+        optimalMaxTokensConfigured,
+        effectiveCriticalMaxTokens,
+        criticalMaxTokensConfigured,
+    };
+}
+function resolveFbrEffortDefaultForTool(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 createFreshBootsReasoningTool(args) {
+    const fbrDefault = args.fbrEffortDefault;
+    const fbrDefaultHint = fbrDefault > 0
+        ? `Runtime default for \`effort\` is current member \`fbr_effort=${fbrDefault}\` when omitted.`
+        : 'Runtime default for `effort` is current member `fbr_effort=0` (FBR disabled unless reconfigured).';
+    const codexAuthHint = args.providerApiType === 'codex'
+        ? ` Codex-auth note: function arguments are often emitted with all fields present; if user did not specify intensity, pass \`effort: ${fbrDefault}\` explicitly.`
+        : '';
+    return {
+        type: 'func',
+        name: 'freshBootsReasoning',
+        description: 'Start an FBR sideline dialog for tool-less fresh-boots reasoning. tellaskContent MUST stay neutral and fact-oriented (Goal/Facts/Constraints/Evidence[/Unknowns]); do not issue analysis directives (for example “from the following dimensions”, “analyze in steps 1..N”, or “N rounds per dimension”). ' +
+            fbrDefaultHint +
+            codexAuthHint,
+        parameters: {
+            type: 'object',
+            properties: {
+                tellaskContent: {
+                    type: 'string',
+                    description: 'Use a neutral factual body: Goal/Facts/Constraints/Evidence (optional Unknowns). Avoid dimension checklists and stepwise directives (e.g. “from the following dimensions/aspects”, “analyze in steps 1..N”, “N rounds per dimension”).',
+                },
+                effort: {
+                    type: 'integer',
+                    description: `Optional FBR intensity override (0..100 integer). Runtime maps intensity N to N serial FBR passes in one sideline window. When omitted, runtime defaults to current member fbr_effort=${fbrDefault}.`,
+                },
+            },
+            required: ['tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('freshBootsReasoning is handled by driver-v2 tellask-special channel');
+        },
+    };
+}
+const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
+    {
+        type: 'func',
+        name: 'tellaskBack',
+        description: 'Ask back to the requester dialog in sideline context.',
+        parameters: {
+            type: 'object',
+            properties: {
+                tellaskContent: { type: 'string' },
+            },
+            required: ['tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('tellaskBack is handled by driver-v2 tellask-special channel');
+        },
+    },
+    {
+        type: 'func',
+        name: 'tellask',
+        description: 'Create or resume a teammate sideline dialog with sessionSlug.',
+        parameters: {
+            type: 'object',
+            properties: {
+                targetAgentId: { type: 'string' },
+                sessionSlug: { type: 'string' },
+                tellaskContent: { type: 'string' },
+            },
+            required: ['targetAgentId', 'sessionSlug', 'tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('tellask is handled by driver-v2 tellask-special channel');
+        },
+    },
+    {
+        type: 'func',
+        name: 'tellaskSessionless',
+        description: 'Create a one-shot teammate sideline dialog.',
+        parameters: {
+            type: 'object',
+            properties: {
+                targetAgentId: { type: 'string' },
+                tellaskContent: { type: 'string' },
+            },
+            required: ['targetAgentId', 'tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('tellaskSessionless is handled by driver-v2 tellask-special channel');
+        },
+    },
+    {
+        type: 'func',
+        name: 'askHuman',
+        description: 'Ask for required clarification/decision from human.',
+        parameters: {
+            type: 'object',
+            properties: {
+                tellaskContent: { type: 'string' },
+            },
+            required: ['tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('askHuman is handled by driver-v2 tellask-special channel');
+        },
+    },
+];
+function mergeTellaskSpecialVirtualTools(baseTools, options) {
+    const merged = [...baseTools];
+    const seen = new Set(merged.map((tool) => tool.name));
+    const freshBootsReasoning = createFreshBootsReasoningTool({
+        fbrEffortDefault: options.fbrEffortDefault,
+        providerApiType: options.providerApiType,
+    });
+    const specialTools = options.includeTellaskBack
+        ? [...TELLASK_SPECIAL_VIRTUAL_TOOLS, freshBootsReasoning]
+        : [
+            ...TELLASK_SPECIAL_VIRTUAL_TOOLS.filter((tool) => tool.name !== 'tellaskBack'),
+            freshBootsReasoning,
+        ];
+    for (const virtualTool of specialTools) {
+        if (seen.has(virtualTool.name)) {
+            throw new Error(`driver-v2 tool invariant violation: function tool name '${virtualTool.name}' collides with tellask-special virtual tool`);
+        }
+        merged.push(virtualTool);
+        seen.add(virtualTool.name);
+    }
+    return merged;
+}
+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,
+    };
+}
+async function buildProviderContext(args) {
+    const provider = args.agent.provider ?? args.team.memberDefaults.provider;
+    const model = args.agent.model ?? args.team.memberDefaults.model;
+    if (!provider) {
+        throw new Error(`Configuration Error: No provider configured for agent '${args.dialog.agentId}'. Please specify a provider in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
+    }
+    if (!model) {
+        throw new Error(`Configuration Error: No model configured for agent '${args.dialog.agentId}'. Please specify a model in the agent's configuration or in member_defaults section of .minds/team.yaml.`);
+    }
+    const llmCfg = await client_1.LlmConfig.load();
+    const providerCfg = llmCfg.getProvider(provider);
+    if (!providerCfg) {
+        throw new Error(`Provider configuration error: Provider '${provider}' not found for agent '${args.dialog.agentId}'. Please check .minds/llm.yaml and .minds/team.yaml configuration.`);
+    }
+    const modelInfo = resolveModelInfo(providerCfg, model);
+    if (!modelInfo) {
+        const uiLanguage = args.dialog.getUiLanguage();
+        const msg = uiLanguage === 'zh'
+            ? [
+                '配置错误：当前成员的模型配置无效。',
+                '',
+                `- member: ${args.agent.name} (${args.dialog.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: ${args.agent.name} (${args.dialog.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);
+    }
+    return { provider, model, providerCfg };
+}
+async function executeFunctionCalls(args) {
+    const { dialog, agent, agentTools, funcCalls, abortSignal } = args;
+    const functionPromises = funcCalls.map(async (func) => {
+        throwIfAborted(abortSignal, dialog);
+        const callGenseq = func.genseq;
+        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 dialog.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('driver-v2 failed to parse function arguments as JSON', undefined, {
+                    funcName: func.name,
+                    arguments: func.arguments,
+                    error: parseErr,
+                });
+            }
+        }
+        let result;
+        const argsValidation = (0, runtime_utils_1.validateFuncToolArguments)(tool, rawArgs);
+        if (argsValidation.ok) {
+            const argsObj = argsValidation.args;
+            await dialog.funcCallRequested(func.id, func.name, argsStr);
+            await dialog.persistFunctionCall(func.id, func.name, argsObj, callGenseq);
+            try {
+                throwIfAborted(abortSignal, dialog);
+                const output = await tool.call(dialog, agent, argsObj);
+                throwIfAborted(abortSignal, dialog);
+                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) {
+                const errText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+                result = {
+                    type: 'func_result_msg',
+                    id: func.id,
+                    name: func.name,
+                    content: `Function '${func.name}' execution failed: ${errText}`,
+                    role: 'tool',
+                    genseq: callGenseq,
+                };
+                if (abortSignal.aborted || err instanceof DialogInterruptedError) {
+                    throw err;
+                }
+            }
+        }
+        else {
+            result = {
+                type: 'func_result_msg',
+                id: func.id,
+                name: func.name,
+                content: `Invalid arguments: ${argsValidation.error}`,
+                role: 'tool',
+                genseq: callGenseq,
+            };
+        }
+        await dialog.receiveFuncResult(result);
+        return result;
+    });
+    return await Promise.all(functionPromises);
+}
+async function executeRoutedFunctionCalls(args) {
+    const { dialog, agent, agentTools, funcCalls, callbacks, abortSignal } = args;
+    if (funcCalls.length === 0) {
+        return { suspendForHuman: false, pairedMessages: [], tellaskToolOutputs: [] };
+    }
+    throwIfAborted(abortSignal, dialog);
+    const allowTellaskBack = dialog.id.rootId !== dialog.id.selfId;
+    const allowedSpecials = new Set([
+        'tellask',
+        'tellaskSessionless',
+        'askHuman',
+        'freshBootsReasoning',
+        ...(allowTellaskBack ? ['tellaskBack'] : []),
+    ]);
+    const classified = (0, tellask_bridge_1.classifyTellaskSpecialFunctionCalls)(funcCalls, { allowedSpecials });
+    const specialCallById = new Map(classified.specialCalls.map((call) => [call.callId, call]));
+    const toPersistedSpecialCallArgs = (call) => {
+        switch (call.callName) {
+            case 'tellaskBack':
+                return { tellaskContent: call.tellaskContent };
+            case 'askHuman':
+                return { tellaskContent: call.tellaskContent };
+            case 'freshBootsReasoning':
+                return {
+                    tellaskContent: call.tellaskContent,
+                    ...(call.effort !== undefined ? { effort: call.effort } : {}),
+                };
+            case 'tellask':
+                return {
+                    targetAgentId: call.targetAgentId,
+                    sessionSlug: call.sessionSlug,
+                    tellaskContent: call.tellaskContent,
+                };
+            case 'tellaskSessionless':
+                return {
+                    targetAgentId: call.targetAgentId,
+                    tellaskContent: call.tellaskContent,
+                };
+        }
+    };
+    for (const callMsg of funcCalls) {
+        throwIfAborted(abortSignal, dialog);
+        const special = specialCallById.get(callMsg.id);
+        if (!special) {
+            continue;
+        }
+        await dialog.persistFunctionCall(callMsg.id, callMsg.name, toPersistedSpecialCallArgs(special), callMsg.genseq);
+    }
+    const issueResults = [];
+    for (const issue of classified.parseIssues) {
+        const result = {
+            type: 'func_result_msg',
+            id: issue.call.id,
+            name: issue.call.name,
+            content: `Invalid arguments for tellask special function '${issue.call.name}': ${issue.error}`,
+            role: 'tool',
+            genseq: issue.call.genseq,
+        };
+        await dialog.receiveFuncResult(result);
+        issueResults.push(result);
+    }
+    throwIfAborted(abortSignal, dialog);
+    const specialResult = await (0, tellask_bridge_1.executeTellaskSpecialCalls)({
+        dlg: dialog,
+        agent,
+        calls: classified.specialCalls,
+        callbacks,
+    });
+    throwIfAborted(abortSignal, dialog);
+    const specialCallIds = new Set(classified.specialCalls.map((call) => call.callId));
+    const genericResults = await executeFunctionCalls({
+        dialog,
+        agent,
+        agentTools,
+        funcCalls: classified.normalCalls,
+        abortSignal,
+    });
+    const resultByCallId = new Map();
+    const register = (result) => {
+        const existing = resultByCallId.get(result.id);
+        if (existing) {
+            throw new Error(`driver-v2 function result invariant violation: duplicate call id '${result.id}'`);
+        }
+        resultByCallId.set(result.id, result);
+    };
+    for (const result of issueResults) {
+        register(result);
+    }
+    for (const result of genericResults) {
+        register(result);
+    }
+    const pairedMessages = [];
+    for (const call of funcCalls) {
+        pairedMessages.push(call);
+        const result = resultByCallId.get(call.id);
+        if (result) {
+            pairedMessages.push(result);
+            continue;
+        }
+        if (specialCallIds.has(call.id)) {
+            // Tellask-special calls get func_result via dynamic context projection instead of persisted records.
+            continue;
+        }
+        if (!result) {
+            throw new Error(`driver-v2 function result invariant violation: missing result for call id '${call.id}' (${call.name})`);
+        }
+    }
+    return {
+        suspendForHuman: specialResult.suspend,
+        pairedMessages,
+        tellaskToolOutputs: specialResult.toolOutputs,
+    };
+}
+function parseUnifiedTimestampMs(ts) {
+    const normalized = ts.trim();
+    if (normalized === '') {
+        return null;
+    }
+    const parsed = Date.parse(normalized.replace(' ', 'T'));
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+function formatElapsedSecondsText(startedAtMs) {
+    const language = (0, runtime_language_1.getWorkLanguage)();
+    if (startedAtMs === null) {
+        return language === 'zh' ? '未知时长' : 'unknown elapsed time';
+    }
+    const elapsedMs = Math.max(0, Date.now() - startedAtMs);
+    const elapsedSec = Math.floor(elapsedMs / 1000);
+    return language === 'zh' ? `${elapsedSec} 秒` : `${elapsedSec}s`;
+}
+function formatPendingSpecialFuncResult(name, startedAtMs) {
+    const language = (0, runtime_language_1.getWorkLanguage)();
+    const elapsed = formatElapsedSecondsText(startedAtMs);
+    if (name === 'askHuman') {
+        return language === 'zh'
+            ? `Q4H 仍在等待人类回复，已持续 ${elapsed}。`
+            : `Q4H is still waiting for human reply (elapsed ${elapsed}).`;
+    }
+    return language === 'zh'
+        ? `支线对话仍在进行中，已持续 ${elapsed}。`
+        : `Sideline dialog is still running (elapsed ${elapsed}).`;
+}
+function formatResolvedAskHumanResult() {
+    return (0, runtime_language_1.getWorkLanguage)() === 'zh'
+        ? 'Q4H 已结束等待状态，请参考后续用户消息。'
+        : 'Q4H wait is resolved; refer to subsequent user messages.';
+}
+async function projectTellaskSpecialFuncResultsForContext(args) {
+    const hasSpecialFuncCall = args.dialogMsgsForContext.some((msg) => msg.type === 'func_call_msg' && (0, tellask_bridge_1.isTellaskSpecialFunctionName)(msg.name));
+    if (!hasSpecialFuncCall) {
+        return [...args.dialogMsgsForContext];
+    }
+    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(args.dialog.id, args.dialog.status);
+    const pendingSubByCallId = new Map();
+    for (const pending of pendingSubdialogs) {
+        const callId = pending.callId.trim();
+        if (callId === '') {
+            continue;
+        }
+        pendingSubByCallId.set(callId, { createdAt: pending.createdAt });
+    }
+    const pendingQ4H = await persistence_1.DialogPersistence.loadQuestions4HumanState(args.dialog.id, args.dialog.status);
+    const pendingQ4HByCallId = new Map();
+    for (const question of pendingQ4H) {
+        if (typeof question.callId !== 'string') {
+            continue;
+        }
+        const callId = question.callId.trim();
+        if (callId === '') {
+            continue;
+        }
+        pendingQ4HByCallId.set(callId, { askedAt: question.askedAt });
+    }
+    const settledByCallId = new Map();
+    const existingSpecialFuncResults = new Map();
+    for (const msg of args.dialogMsgsForContext) {
+        if (msg.type === 'tellask_result_msg') {
+            const callId = typeof msg.callId === 'string' ? msg.callId.trim() : '';
+            if (callId !== '') {
+                settledByCallId.set(callId, msg.content);
+            }
+            continue;
+        }
+        if (msg.type === 'func_result_msg' && (0, tellask_bridge_1.isTellaskSpecialFunctionName)(msg.name)) {
+            existingSpecialFuncResults.set(msg.id, msg);
+        }
+    }
+    const projected = [];
+    const specialCallIds = new Set();
+    for (const msg of args.dialogMsgsForContext) {
+        if (msg.type === 'func_result_msg' && specialCallIds.has(msg.id)) {
+            continue;
+        }
+        projected.push(msg);
+        if (msg.type !== 'func_call_msg') {
+            continue;
+        }
+        if (!(0, tellask_bridge_1.isTellaskSpecialFunctionName)(msg.name)) {
+            continue;
+        }
+        specialCallIds.add(msg.id);
+        const settled = settledByCallId.get(msg.id);
+        if (settled !== undefined) {
+            projected.push({
+                type: 'func_result_msg',
+                role: 'tool',
+                genseq: msg.genseq,
+                id: msg.id,
+                name: msg.name,
+                content: settled,
+            });
+            continue;
+        }
+        const existingResult = existingSpecialFuncResults.get(msg.id);
+        if (existingResult) {
+            projected.push(existingResult);
+            continue;
+        }
+        if (msg.name === 'askHuman') {
+            const pendingQ4HState = pendingQ4HByCallId.get(msg.id);
+            const content = pendingQ4HState
+                ? formatPendingSpecialFuncResult(msg.name, parseUnifiedTimestampMs(pendingQ4HState.askedAt))
+                : formatResolvedAskHumanResult();
+            projected.push({
+                type: 'func_result_msg',
+                role: 'tool',
+                genseq: msg.genseq,
+                id: msg.id,
+                name: msg.name,
+                content,
+            });
+            continue;
+        }
+        const pendingSubState = pendingSubByCallId.get(msg.id);
+        projected.push({
+            type: 'func_result_msg',
+            role: 'tool',
+            genseq: msg.genseq,
+            id: msg.id,
+            name: msg.name,
+            content: formatPendingSpecialFuncResult(msg.name, pendingSubState ? parseUnifiedTimestampMs(pendingSubState.createdAt) : null),
+        });
+    }
+    return projected;
+}
+async function resetDiligenceBudgetAfterQ4H(dlg, team) {
+    try {
+        if (!(await dlg.hasPendingQ4H())) {
+            return;
+        }
+        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.error('driver-v2 failed to reset Diligence Push budget after Q4H', err, {
+            dialogId: dlg.id.valueOf(),
+        });
+        throw err;
+    }
+}
+async function maybeContinueWithDiligencePrompt(args) {
+    const { dlg, team, suppressDiligencePushForDrive } = args;
+    if (!(dlg instanceof dialog_1.RootDialog)) {
+        return { kind: 'break' };
+    }
+    const suspension = await dlg.getSuspensionStatus();
+    if (!suspension.canDrive) {
+        if (suspension.q4h) {
+            await resetDiligenceBudgetAfterQ4H(dlg, team);
+        }
+        return { kind: 'break' };
+    }
+    const prepared = await (0, runtime_utils_1.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') {
+        emitDiligenceBudgetEvent(dlg, {
+            maxInjectCount: prepared.maxInjectCount,
+            nextRemainingBudget: prepared.nextRemainingBudget,
+        });
+    }
+    if (prepared.kind === 'budget_exhausted') {
+        await (0, runtime_utils_1.suspendForKeepGoingBudgetExhausted)({
+            dlg,
+            maxInjectCount: prepared.maxInjectCount,
+        });
+        dlg.diligencePushRemainingBudget = 0;
+        return { kind: 'break' };
+    }
+    if (prepared.kind === 'prompt') {
+        return { kind: 'continue', prompt: prepared.prompt };
+    }
+    return { kind: 'break' };
+}
+async function maybeContinueWithHealthPromptBeforeDiligence(args) {
+    const { dlg, providerCfg, model } = args;
+    // This path is only used as a higher-priority alternative to Diligence Push.
+    if (!(dlg instanceof dialog_1.RootDialog)) {
+        return { kind: 'no_health_prompt' };
+    }
+    const snapshot = dlg.getLastContextHealth();
+    const modelInfoForRemediation = resolveModelInfo(providerCfg, model);
+    const cautionRemediationCadenceGenerations = (0, context_health_1.resolveCautionRemediationCadenceGenerations)(modelInfoForRemediation?.caution_remediation_cadence_generations);
+    const criticalCountdownRemaining = (0, context_health_1.resolveCriticalCountdownRemaining)(dlg.id.key(), snapshot);
+    const healthDecision = (0, context_health_1.decideDriverV2ContextHealth)({
+        dialogKey: dlg.id.key(),
+        snapshot,
+        hadUserPromptThisGen: false,
+        canInjectPromptThisGen: true,
+        cautionRemediationCadenceGenerations,
+        criticalCountdownRemaining,
+    });
+    if (healthDecision.kind === 'suspend') {
+        return { kind: 'health_suspend' };
+    }
+    if (healthDecision.kind !== 'continue') {
+        return { kind: 'no_health_prompt' };
+    }
+    if (healthDecision.reason === 'critical_force_new_course') {
+        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);
+        dlg.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
+        (0, context_health_1.resetContextHealthRoundState)(dlg.id.key());
+        const nextPrompt = resolveUpNextPrompt(dlg);
+        if (!nextPrompt) {
+            throw new Error(`driver-v2 critical force-new-course invariant violation: missing upNext prompt after startNewCourse for dialog=${dlg.id.valueOf()}`);
+        }
+        return { kind: 'health_continue', prompt: nextPrompt, resetTaskdoc: true };
+    }
+    const language = (0, runtime_language_1.getWorkLanguage)();
+    const guideText = healthDecision.reason === 'caution_soft_remediation'
+        ? (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
+            kind: 'caution',
+            mode: 'soft',
+        })
+        : (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
+            kind: 'critical',
+            mode: 'countdown',
+            promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
+            promptsTotal: context_health_1.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
+        });
+    return {
+        kind: 'health_continue',
+        prompt: {
+            content: guideText,
+            msgId: (0, id_1.generateShortId)(),
+            grammar: 'markdown',
+            userLanguageCode: language,
+        },
+        resetTaskdoc: false,
+    };
+}
+async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks) {
+    const suppressDiligencePushForDrive = driveOptions?.suppressDiligencePush === true;
+    const abortSignal = (0, dialog_run_state_1.createActiveRun)(dlg.id);
+    let finalRunState;
+    let finalResult;
+    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('driver-v2 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 lastAssistantSayingGenseq = null;
+    let lastFunctionCallGenseq = null;
+    let genIterNo = 0;
+    let pendingPrompt = humanPrompt;
+    let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
+    try {
+        while (true) {
+            genIterNo += 1;
+            throwIfAborted(abortSignal, dlg);
+            const minds = await (0, load_1.loadAgentMinds)(dlg.agentId, dlg);
+            const team = minds.team;
+            const policy = (0, policy_1.buildDriverV2Policy)({
+                dlg,
+                agent: minds.agent,
+                systemPrompt: minds.systemPrompt,
+                agentTools: minds.agentTools,
+                language: (0, runtime_language_1.getWorkLanguage)(),
+            });
+            const policyValidation = (0, policy_1.validateDriverV2PolicyInvariants)(policy, (0, runtime_language_1.getWorkLanguage)());
+            if (!policyValidation.ok) {
+                throw new Error(`driver-v2 policy invariant violation: ${policyValidation.detail}`);
+            }
+            let agent = policy.effectiveAgent;
+            let systemPrompt = policy.effectiveSystemPrompt;
+            const memories = minds.memories;
+            const agentTools = policy.effectiveAgentTools;
+            const { provider, model, providerCfg } = await buildProviderContext({
+                dialog: dlg,
+                team,
+                agent,
+            });
+            const retryPolicy = resolveDriverV2RetryPolicy(providerCfg);
+            const llmGen = (0, registry_1.getLlmGenerator)(providerCfg.apiType);
+            if (!llmGen) {
+                throw new Error(`LLM generator not found: API type '${providerCfg.apiType}' for provider '${provider}' in agent '${dlg.agentId}'. Please check .minds/llm.yaml configuration.`);
+            }
+            const canonicalFuncTools = agentTools.filter((t) => t.type === 'func');
+            const isSubdialog = dlg.id.rootId !== dlg.id.selfId;
+            const fbrEffortDefault = resolveFbrEffortDefaultForTool(agent);
+            const effectiveFuncTools = policy.allowFunctionCalls
+                ? mergeTellaskSpecialVirtualTools(canonicalFuncTools, {
+                    includeTellaskBack: isSubdialog,
+                    fbrEffortDefault,
+                    providerApiType: providerCfg.apiType,
+                })
+                : canonicalFuncTools;
+            const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, effectiveFuncTools);
+            const funcTools = projected.tools;
+            if (genIterNo > 1) {
+                const snapshot = dlg.getLastContextHealth();
+                const hasQueuedUpNext = dlg.hasUpNext() || pendingPrompt !== undefined;
+                const modelInfoForRemediation = resolveModelInfo(providerCfg, model);
+                const cautionRemediationCadenceGenerations = (0, context_health_1.resolveCautionRemediationCadenceGenerations)(modelInfoForRemediation?.caution_remediation_cadence_generations);
+                const criticalCountdownRemaining = (0, context_health_1.resolveCriticalCountdownRemaining)(dlg.id.key(), snapshot);
+                const healthDecision = (0, context_health_1.decideDriverV2ContextHealth)({
+                    dialogKey: dlg.id.key(),
+                    snapshot,
+                    hadUserPromptThisGen: isUserOriginPrompt(pendingPrompt),
+                    canInjectPromptThisGen: !hasQueuedUpNext,
+                    cautionRemediationCadenceGenerations,
+                    criticalCountdownRemaining,
+                });
+                if (healthDecision.kind === 'suspend') {
+                    log_1.log.debug('driver-v2 suspend iterative generation due to critical context while waiting for human prompt', undefined, {
+                        dialogId: dlg.id.valueOf(),
+                        rootId: dlg.id.rootId,
+                        selfId: dlg.id.selfId,
+                        genIterNo,
+                        pendingPromptOrigin: pendingPrompt?.origin ?? null,
+                    });
+                    break;
+                }
+                if (healthDecision.kind === 'continue') {
+                    if (healthDecision.reason === 'critical_force_new_course') {
+                        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);
+                        dlg.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
+                        (0, context_health_1.resetContextHealthRoundState)(dlg.id.key());
+                        const nextPrompt = resolveUpNextPrompt(dlg);
+                        if (!nextPrompt) {
+                            throw new Error(`driver-v2 critical force-new-course invariant violation: missing upNext prompt after startNewCourse for dialog=${dlg.id.valueOf()}`);
+                        }
+                        pendingPrompt = nextPrompt;
+                        skipTaskdocForThisDrive = false;
+                    }
+                    else if (!hasQueuedUpNext) {
+                        const language = (0, runtime_language_1.getWorkLanguage)();
+                        const guideText = healthDecision.reason === 'caution_soft_remediation'
+                            ? (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
+                                kind: 'caution',
+                                mode: 'soft',
+                            })
+                            : (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
+                                kind: 'critical',
+                                mode: 'countdown',
+                                promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
+                                promptsTotal: context_health_1.DRIVER_V2_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
+                            });
+                        pendingPrompt = {
+                            content: guideText,
+                            msgId: (0, id_1.generateShortId)(),
+                            grammar: 'markdown',
+                            userLanguageCode: language,
+                        };
+                    }
+                }
+            }
+            let suspendForHuman = false;
+            let llmGenModelForGen = model;
+            let contextHealthForGen;
+            await dlg.notifyGeneratingStart();
+            try {
+                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.debug('driver-v2 skip diligence prompt after disable toggle', undefined, {
+                            dialogId: dlg.id.valueOf(),
+                            msgId: currentPrompt.msgId,
+                        });
+                        break;
+                    }
+                    if (currentPrompt.skipTaskdoc === true) {
+                        skipTaskdocForThisDrive = true;
+                    }
+                    const promptContent = currentPrompt.content;
+                    const msgId = currentPrompt.msgId;
+                    const promptGrammar = currentPrompt.grammar;
+                    const persistedUserLanguageCode = currentPrompt.userLanguageCode ?? dlg.getLastUserLanguageCode();
+                    const q4hAnswerCallIds = normalizeQ4HAnswerCallIds(currentPrompt.q4hAnswerCallIds);
+                    await dlg.addChatMessages({
+                        type: 'prompting_msg',
+                        role: 'user',
+                        genseq: dlg.activeGenSeq,
+                        content: promptContent,
+                        msgId,
+                        grammar: promptGrammar,
+                    });
+                    await dlg.persistUserMessage(promptContent, msgId, promptGrammar, persistedUserLanguageCode, q4hAnswerCallIds);
+                    if (currentPrompt.subdialogReplyTarget) {
+                        const normalizedCallId = currentPrompt.subdialogReplyTarget.callId.trim();
+                        if (normalizedCallId === '') {
+                            throw new Error(`driver-v2 assignment anchor invariant violation: empty callId for subdialogReplyTarget (dialog=${dlg.id.valueOf()})`);
+                        }
+                        const rawCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+                        if (!Number.isFinite(rawCourse) || rawCourse <= 0) {
+                            throw new Error(`driver-v2 assignment anchor invariant violation: invalid course=${String(rawCourse)} (dialog=${dlg.id.valueOf()})`);
+                        }
+                        const rawGenseq = dlg.activeGenSeq;
+                        if (!Number.isFinite(rawGenseq) || rawGenseq <= 0) {
+                            throw new Error(`driver-v2 assignment anchor invariant violation: invalid genseq=${String(rawGenseq)} (dialog=${dlg.id.valueOf()})`);
+                        }
+                        const assignmentAnchor = {
+                            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                            type: 'teammate_call_anchor_record',
+                            anchorRole: 'assignment',
+                            callId: normalizedCallId,
+                            genseq: Math.floor(rawGenseq),
+                        };
+                        await persistence_1.DialogPersistence.appendEvent(dlg.id, Math.floor(rawCourse), assignmentAnchor);
+                    }
+                    await emitUserMarkdown(dlg, promptContent);
+                    (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,
+                        q4hAnswerCallIds,
+                    });
+                }
+                if (suspendForHuman) {
+                    await resetDiligenceBudgetAfterQ4H(dlg, team);
+                    break;
+                }
+                const taskDocMsg = dlg.taskDocPath && !skipTaskdocForThisDrive ? await (0, taskdoc_1.formatTaskDocContent)(dlg) : undefined;
+                const coursePrefixMsgs = (() => {
+                    const msgs = dlg.getCoursePrefixMsgs();
+                    return msgs.length > 0 ? [...msgs] : [];
+                })();
+                const rawDialogMsgsForContext = dlg.msgs.filter((m) => {
+                    if (!m)
+                        return false;
+                    if (m.type === 'ui_only_markdown_msg')
+                        return false;
+                    return true;
+                });
+                const dialogMsgsForContext = await projectTellaskSpecialFuncResultsForContext({
+                    dialog: dlg,
+                    dialogMsgsForContext: rawDialogMsgsForContext,
+                });
+                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: policy.prependedContextMessages,
+                        memories,
+                        taskDocMsg,
+                        coursePrefixMsgs,
+                        dialogMsgsForContext,
+                    },
+                    ephemeral: {},
+                    tail: {
+                        renderedReminders,
+                        languageGuideMsg: guideMsg,
+                    },
+                });
+                if (agent.streaming === false) {
+                    const nonStreamResult = await (0, runtime_utils_1.runLlmRequestWithRetry)({
+                        dlg,
+                        provider,
+                        abortSignal,
+                        maxRetries: retryPolicy.maxRetries,
+                        retryInitialDelayMs: retryPolicy.initialDelayMs,
+                        retryBackoffMultiplier: retryPolicy.backoffMultiplier,
+                        retryMaxDelayMs: retryPolicy.maxDelayMs,
+                        canRetry: () => true,
+                        doRequest: async () => {
+                            const batchResult = await llmGen.genMoreMessages(providerCfg, agent, systemPrompt, funcTools, ctxMsgs, dlg.activeGenSeq, abortSignal);
+                            if (!hasMeaningfulBatchOutput(batchResult.messages)) {
+                                throw {
+                                    status: 503,
+                                    code: DRIVER_V2_EMPTY_LLM_RESPONSE_ERROR_CODE,
+                                    message: `LLM returned empty response (provider=${provider}, model=${model}, streaming=false).`,
+                                };
+                            }
+                            return batchResult;
+                        },
+                    });
+                    if (typeof nonStreamResult.llmGenModel === 'string' &&
+                        nonStreamResult.llmGenModel.trim() !== '') {
+                        llmGenModelForGen = nonStreamResult.llmGenModel.trim();
+                    }
+                    contextHealthForGen = computeContextHealthSnapshot({
+                        providerCfg,
+                        model,
+                        usage: nonStreamResult.usage,
+                    });
+                    dlg.setLastContextHealth(contextHealthForGen);
+                    const nonStreamMsgs = nonStreamResult.messages;
+                    const assistantMsgs = nonStreamMsgs.filter((m) => m.type === 'saying_msg' || m.type === 'thinking_msg');
+                    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')) {
+                                if (msg.type === 'saying_msg') {
+                                    lastAssistantSayingContent = msg.content;
+                                    lastAssistantSayingGenseq = msg.genseq;
+                                    await dlg.persistAgentMessage(msg.content, msg.genseq, 'saying_msg');
+                                    await emitUserMarkdown(dlg, msg.content);
+                                }
+                                if (msg.type === 'thinking_msg') {
+                                    await (0, saying_events_1.emitThinkingEvents)(dlg, msg.content);
+                                }
+                            }
+                        }
+                    }
+                    const funcCalls = nonStreamMsgs.filter((m) => m.type === 'func_call_msg');
+                    for (const call of funcCalls) {
+                        const rawCallGenseq = call.genseq;
+                        if (!Number.isFinite(rawCallGenseq) || rawCallGenseq <= 0) {
+                            continue;
+                        }
+                        const callGenseq = Math.floor(rawCallGenseq);
+                        if (lastFunctionCallGenseq === null || callGenseq > lastFunctionCallGenseq) {
+                            lastFunctionCallGenseq = callGenseq;
+                        }
+                    }
+                    const toolPolicyViolation = (0, policy_1.resolveDriverV2PolicyViolationKind)({
+                        policy,
+                        tellaskCallCount: 0,
+                        functionCallCount: funcCalls.length,
+                    });
+                    if (toolPolicyViolation === '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;
+                        lastAssistantSayingGenseq = genseq;
+                        await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
+                        return {
+                            lastAssistantSayingContent,
+                            lastAssistantSayingGenseq,
+                            lastFunctionCallGenseq,
+                        };
+                    }
+                    const routedFunctionResult = await executeRoutedFunctionCalls({
+                        dialog: dlg,
+                        agent,
+                        agentTools,
+                        funcCalls,
+                        callbacks,
+                        abortSignal,
+                    });
+                    if (routedFunctionResult.tellaskToolOutputs.length > 0) {
+                        await dlg.addChatMessages(...routedFunctionResult.tellaskToolOutputs);
+                    }
+                    if (routedFunctionResult.pairedMessages.length > 0) {
+                        await dlg.addChatMessages(...routedFunctionResult.pairedMessages);
+                    }
+                    if (routedFunctionResult.suspendForHuman) {
+                        suspendForHuman = true;
+                    }
+                    if (dlg.hasUpNext()) {
+                        pendingPrompt = resolveUpNextPrompt(dlg);
+                        continue;
+                    }
+                    if (suspendForHuman) {
+                        await resetDiligenceBudgetAfterQ4H(dlg, team);
+                        break;
+                    }
+                    const shouldContinue = funcCalls.length > 0 ||
+                        routedFunctionResult.pairedMessages.length > 0 ||
+                        routedFunctionResult.tellaskToolOutputs.length > 0;
+                    if (!shouldContinue) {
+                        const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
+                            dlg,
+                            providerCfg,
+                            model,
+                        });
+                        if (healthFirst.kind === 'health_continue') {
+                            pendingPrompt = healthFirst.prompt;
+                            if (healthFirst.resetTaskdoc) {
+                                skipTaskdocForThisDrive = false;
+                            }
+                            continue;
+                        }
+                        if (healthFirst.kind === 'health_suspend') {
+                            break;
+                        }
+                        const next = await maybeContinueWithDiligencePrompt({
+                            dlg,
+                            team,
+                            suppressDiligencePushForDrive,
+                        });
+                        if (next.kind === 'continue') {
+                            pendingPrompt = next.prompt;
+                            continue;
+                        }
+                        break;
+                    }
+                    continue;
+                }
+                const newMsgs = [];
+                const streamedFuncCalls = [];
+                let currentThinkingContent = '';
+                let currentThinkingSignature = '';
+                let currentSayingContent = '';
+                let streamAttemptCourse;
+                let streamAttemptCheckpointOffset;
+                let streamAttemptSayingContent;
+                let streamAttemptSayingGenseq;
+                let streamSawWebSearchCall = false;
+                let streamActive = { kind: 'idle' };
+                const rollbackStreamAttempt = async () => {
+                    if (streamAttemptCourse === undefined || streamAttemptCheckpointOffset === undefined) {
+                        throw new Error(`driver-v2 stream retry invariant violation: missing checkpoint (dialog=${dlg.id.valueOf()})`);
+                    }
+                    await persistence_1.DialogPersistence.rollbackCourseFileToOffset(dlg.id, streamAttemptCourse, streamAttemptCheckpointOffset, dlg.status);
+                    (0, evt_registry_1.postDialogEvent)(dlg, {
+                        type: 'genseq_discard_evt',
+                        course: streamAttemptCourse,
+                        genseq: dlg.activeGenSeq,
+                        reason: 'retry',
+                    });
+                    streamActive = { kind: 'idle' };
+                    currentThinkingContent = '';
+                    currentThinkingSignature = '';
+                    currentSayingContent = '';
+                    streamAttemptSayingContent = undefined;
+                    streamAttemptSayingGenseq = undefined;
+                    streamSawWebSearchCall = false;
+                    streamedFuncCalls.length = 0;
+                    newMsgs.length = 0;
+                };
+                const streamResult = await (0, runtime_utils_1.runLlmRequestWithRetry)({
+                    dlg,
+                    provider,
+                    abortSignal,
+                    maxRetries: retryPolicy.maxRetries,
+                    retryInitialDelayMs: retryPolicy.initialDelayMs,
+                    retryBackoffMultiplier: retryPolicy.backoffMultiplier,
+                    retryMaxDelayMs: retryPolicy.maxDelayMs,
+                    canRetry: () => true,
+                    onRetry: rollbackStreamAttempt,
+                    onGiveUp: rollbackStreamAttempt,
+                    doRequest: async () => {
+                        streamAttemptCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+                        streamAttemptCheckpointOffset = await persistence_1.DialogPersistence.captureCourseFileOffset(dlg.id, streamAttemptCourse, dlg.status);
+                        streamActive = { kind: 'idle' };
+                        currentThinkingContent = '';
+                        currentThinkingSignature = '';
+                        currentSayingContent = '';
+                        streamAttemptSayingContent = undefined;
+                        streamAttemptSayingGenseq = undefined;
+                        streamSawWebSearchCall = false;
+                        streamedFuncCalls.length = 0;
+                        newMsgs.length = 0;
+                        const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, ctxMsgs, {
+                            streamError: async (detail) => {
+                                await dlg.streamError(detail);
+                            },
+                            thinkingStart: async () => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'idle') {
+                                    const detail = `Protocol violation: thinkingStart while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new Error(detail);
+                                }
+                                streamActive = { kind: 'thinking' };
+                                currentThinkingContent = '';
+                                currentThinkingSignature = '';
+                                await dlg.thinkingStart();
+                            },
+                            thinkingChunk: async (chunk) => {
+                                throwIfAborted(abortSignal, dlg);
+                                currentThinkingContent += chunk;
+                                const signatureMatch = currentThinkingContent.match(/<thinking[^>]*>(.*?)<\/thinking>/s);
+                                if (signatureMatch && signatureMatch[1]) {
+                                    currentThinkingSignature = signatureMatch[1].trim();
+                                }
+                                await dlg.thinkingChunk(chunk);
+                            },
+                            thinkingFinish: async () => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'thinking') {
+                                    const detail = `Protocol violation: thinkingFinish while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new Error(detail);
+                                }
+                                streamActive = { kind: 'idle' };
+                                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);
+                                if (streamActive.kind !== 'idle') {
+                                    const detail = `Protocol violation: sayingStart while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new Error(detail);
+                                }
+                                streamActive = { kind: 'saying' };
+                                currentSayingContent = '';
+                                await dlg.sayingStart();
+                            },
+                            sayingChunk: async (chunk) => {
+                                throwIfAborted(abortSignal, dlg);
+                                currentSayingContent += chunk;
+                                await dlg.sayingChunk(chunk);
+                            },
+                            sayingFinish: async () => {
+                                throwIfAborted(abortSignal, dlg);
+                                if (streamActive.kind !== 'saying') {
+                                    const detail = `Protocol violation: sayingFinish while ${streamActive.kind} is active`;
+                                    await dlg.streamError(detail);
+                                    throw new Error(detail);
+                                }
+                                streamActive = { kind: 'idle' };
+                                const sayingMessage = {
+                                    type: 'saying_msg',
+                                    role: 'assistant',
+                                    genseq: dlg.activeGenSeq,
+                                    content: currentSayingContent,
+                                };
+                                newMsgs.push(sayingMessage);
+                                streamAttemptSayingContent = currentSayingContent;
+                                streamAttemptSayingGenseq = sayingMessage.genseq;
+                                await dlg.sayingFinish();
+                            },
+                            funcCall: async (callId, name, args) => {
+                                throwIfAborted(abortSignal, dlg);
+                                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);
+                                streamSawWebSearchCall = true;
+                                await dlg.webSearchCall(call);
+                            },
+                        }, dlg.activeGenSeq, abortSignal);
+                        const hasThinkingContent = currentThinkingContent.trim() !== '';
+                        const hasSayingContent = (streamAttemptSayingContent ?? '').trim() !== '';
+                        const hasFunctionCall = streamedFuncCalls.length > 0;
+                        if (!hasThinkingContent &&
+                            !hasSayingContent &&
+                            !hasFunctionCall &&
+                            !streamSawWebSearchCall) {
+                            throw {
+                                status: 503,
+                                code: DRIVER_V2_EMPTY_LLM_RESPONSE_ERROR_CODE,
+                                message: `LLM returned empty response (provider=${provider}, model=${model}, streaming=true).`,
+                            };
+                        }
+                        return streamResult;
+                    },
+                });
+                if (typeof streamResult.llmGenModel === 'string' &&
+                    streamResult.llmGenModel.trim() !== '') {
+                    llmGenModelForGen = streamResult.llmGenModel.trim();
+                }
+                contextHealthForGen = computeContextHealthSnapshot({
+                    providerCfg,
+                    model,
+                    usage: streamResult.usage,
+                });
+                dlg.setLastContextHealth(contextHealthForGen);
+                const policyViolation = (0, policy_1.resolveDriverV2PolicyViolationKind)({
+                    policy,
+                    tellaskCallCount: 0,
+                    functionCallCount: streamedFuncCalls.length,
+                });
+                for (const call of streamedFuncCalls) {
+                    const rawCallGenseq = call.genseq;
+                    if (!Number.isFinite(rawCallGenseq) || rawCallGenseq <= 0) {
+                        continue;
+                    }
+                    const callGenseq = Math.floor(rawCallGenseq);
+                    if (lastFunctionCallGenseq === null || callGenseq > lastFunctionCallGenseq) {
+                        lastFunctionCallGenseq = callGenseq;
+                    }
+                }
+                if (policyViolation) {
+                    const violationText = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, runtime_language_1.getWorkLanguage)(), {
+                        kind: policyViolation,
+                    });
+                    const genseq = dlg.activeGenSeq ?? 0;
+                    newMsgs.push({
+                        type: 'saying_msg',
+                        role: 'assistant',
+                        genseq,
+                        content: violationText,
+                    });
+                    lastAssistantSayingContent = violationText;
+                    lastAssistantSayingGenseq = genseq;
+                    await dlg.addChatMessages(...newMsgs);
+                    await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
+                    return {
+                        lastAssistantSayingContent,
+                        lastAssistantSayingGenseq,
+                        lastFunctionCallGenseq,
+                    };
+                }
+                if (streamAttemptSayingContent !== undefined) {
+                    lastAssistantSayingContent = streamAttemptSayingContent;
+                    lastAssistantSayingGenseq =
+                        streamAttemptSayingGenseq === undefined ? null : streamAttemptSayingGenseq;
+                }
+                const routedFunctionResult = await executeRoutedFunctionCalls({
+                    dialog: dlg,
+                    agent,
+                    agentTools,
+                    funcCalls: streamedFuncCalls,
+                    callbacks,
+                    abortSignal,
+                });
+                if (routedFunctionResult.tellaskToolOutputs.length > 0) {
+                    newMsgs.push(...routedFunctionResult.tellaskToolOutputs);
+                }
+                if (routedFunctionResult.pairedMessages.length > 0) {
+                    newMsgs.push(...routedFunctionResult.pairedMessages);
+                }
+                if (routedFunctionResult.suspendForHuman) {
+                    suspendForHuman = true;
+                }
+                await dlg.addChatMessages(...newMsgs);
+                if (dlg.hasUpNext()) {
+                    pendingPrompt = resolveUpNextPrompt(dlg);
+                    continue;
+                }
+                if (dlg.remindersVer > pubRemindersVer) {
+                    await dlg.processReminderUpdates();
+                    pubRemindersVer = dlg.remindersVer;
+                }
+                if (suspendForHuman) {
+                    await resetDiligenceBudgetAfterQ4H(dlg, team);
+                    break;
+                }
+                const shouldContinue = streamedFuncCalls.length > 0 ||
+                    routedFunctionResult.pairedMessages.length > 0 ||
+                    routedFunctionResult.tellaskToolOutputs.length > 0;
+                if (!shouldContinue) {
+                    const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
+                        dlg,
+                        providerCfg,
+                        model,
+                    });
+                    if (healthFirst.kind === 'health_continue') {
+                        pendingPrompt = healthFirst.prompt;
+                        if (healthFirst.resetTaskdoc) {
+                            skipTaskdocForThisDrive = false;
+                        }
+                        continue;
+                    }
+                    if (healthFirst.kind === 'health_suspend') {
+                        break;
+                    }
+                    const next = await maybeContinueWithDiligencePrompt({
+                        dlg,
+                        team,
+                        suppressDiligencePushForDrive,
+                    });
+                    if (next.kind === 'continue') {
+                        pendingPrompt = next.prompt;
+                        continue;
+                    }
+                    break;
+                }
+            }
+            finally {
+                await dlg.notifyGeneratingFinish(contextHealthForGen, llmGenModelForGen);
+            }
+        }
+        throwIfAborted(abortSignal, dlg);
+        finalRunState = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+        throwIfAborted(abortSignal, dlg);
+        finalResult = {
+            lastAssistantSayingContent,
+            lastAssistantSayingGenseq,
+            lastFunctionCallGenseq,
+        };
+    }
+    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) {
+            finalRunState = { kind: 'interrupted', reason: interruptedReason };
+            (0, dialog_run_state_1.broadcastRunStateMarker)(dlg.id, { kind: 'interrupted', reason: interruptedReason });
+            finalResult = {
+                lastAssistantSayingContent,
+                lastAssistantSayingGenseq,
+                lastFunctionCallGenseq,
+            };
+        }
+        else {
+            const errText = (0, log_1.extractErrorDetails)(err).message;
+            try {
+                await dlg.streamError(errText);
+            }
+            catch {
+                // 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 },
+            });
+            finalResult = {
+                lastAssistantSayingContent,
+                lastAssistantSayingGenseq,
+                lastFunctionCallGenseq,
+            };
+        }
+    }
+    finally {
+        if (!finalRunState) {
+            try {
+                finalRunState = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
+            }
+            catch (stateErr) {
+                log_1.log.warn('driver-v2 failed to compute final run state; falling back to idle', stateErr, {
+                    dialogId: dlg.id.valueOf(),
+                });
+                finalRunState = { kind: 'idle_waiting_user' };
+            }
+        }
+        if (abortSignal.aborted &&
+            finalRunState.kind !== 'interrupted' &&
+            finalRunState.kind !== 'dead') {
+            const stopRequested = (0, dialog_run_state_1.getStopRequestedReason)(dlg.id);
+            const lateInterruptedReason = stopRequested === 'emergency_stop'
+                ? { kind: 'emergency_stop' }
+                : stopRequested === 'user_stop'
+                    ? { kind: 'user_stop' }
+                    : { kind: 'system_stop', detail: 'Aborted.' };
+            finalRunState = { kind: 'interrupted', reason: lateInterruptedReason };
+            if (finalResult) {
+                (0, dialog_run_state_1.broadcastRunStateMarker)(dlg.id, { kind: 'interrupted', reason: lateInterruptedReason });
+            }
+        }
+        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('driver-v2 failed to re-check runState before finalizing', err, {
+                dialogId: dlg.id.valueOf(),
+            });
+        }
+        await (0, dialog_run_state_1.setDialogRunState)(dlg.id, finalRunState);
+    }
+    if (!finalResult) {
+        throw new Error(`driver-v2 core invariant violation: missing final result (dialog=${dlg.id.valueOf()})`);
+    }
+    return finalResult;
+}