dominds 0.7.1 → 0.7.3

package/dist/dialog-global-registry.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalDialogRegistry = void 0;
 const persistence_1 = require("./persistence");
+const evt_1 = require("./shared/evt");
 class GlobalDialogRegistry {
     constructor() {
         this.entries = new Map();
+        this.driveTriggerPubChan = (0, evt_1.createPubChan)();
+        this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
     }
     static getInstance() {
         if (!GlobalDialogRegistry.instance) {
@@ -30,7 +33,10 @@ class GlobalDialogRegistry {
             try {
                 const needsDrive = await persistence_1.DialogPersistence.getNeedsDrive(rootDialog.id);
                 if (needsDrive) {
-                    this.markNeedsDrive(rootDialog.id.rootId);
+                    this.markNeedsDrive(rootDialog.id.rootId, {
+                        source: 'dialog_registry_hydration',
+                        reason: 'persisted_needs_drive_true',
+                    });
                 }
             }
             catch {
@@ -41,17 +47,66 @@ class GlobalDialogRegistry {
     unregister(rootId) {
         this.entries.delete(rootId);
     }
-    markNeedsDrive(rootId) {
+    publishDriveTrigger(args) {
+        this.driveTriggerPubChan.write({
+            type: 'drive_trigger_evt',
+            action: args.action,
+            rootId: args.rootId,
+            entryFound: args.entryFound,
+            previousNeedsDrive: args.previousNeedsDrive,
+            nextNeedsDrive: args.nextNeedsDrive,
+            source: args.meta.source,
+            reason: args.meta.reason,
+            emittedAtMs: Date.now(),
+        });
+    }
+    async waitForDriveTrigger() {
+        for (;;) {
+            const trigger = await this.driveTriggerSubChan.read();
+            if (trigger !== evt_1.EndOfStream) {
+                return trigger;
+            }
+            // Recreate subscription if EOS is ever observed (should not happen in normal runtime).
+            this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
+        }
+    }
+    markNeedsDrive(rootId, meta) {
+        const triggerMeta = meta ?? {
+            source: 'unknown',
+            reason: 'unspecified',
+        };
         const entry = this.entries.get(rootId);
+        const previousNeedsDrive = entry ? entry.needsDrive : null;
         if (entry) {
             entry.needsDrive = true;
         }
+        this.publishDriveTrigger({
+            action: 'mark_needs_drive',
+            rootId,
+            entryFound: entry !== undefined,
+            previousNeedsDrive,
+            nextNeedsDrive: true,
+            meta: triggerMeta,
+        });
     }
-    markNotNeedingDrive(rootId) {
+    markNotNeedingDrive(rootId, meta) {
+        const triggerMeta = meta ?? {
+            source: 'unknown',
+            reason: 'unspecified',
+        };
         const entry = this.entries.get(rootId);
+        const previousNeedsDrive = entry ? entry.needsDrive : null;
         if (entry) {
             entry.needsDrive = false;
         }
+        this.publishDriveTrigger({
+            action: 'mark_not_needing_drive',
+            rootId,
+            entryFound: entry !== undefined,
+            previousNeedsDrive,
+            nextNeedsDrive: false,
+            meta: triggerMeta,
+        });
     }
     getDialogsNeedingDrive() {
         return Array.from(this.entries.values())

package/dist/dialog.js

@@ -502,9 +502,26 @@ class Dialog {
         this._upNext = {
             prompt: trimmed,
             msgId: (0, id_1.generateShortId)(),
+            grammar: 'markdown',
             userLanguageCode: this._lastUserLanguageCode,
         };
     }
+    queueUpNextPrompt(options) {
+        if (this._upNext !== undefined) {
+            throw new Error(`UpNext prompt overwrite violation: dialog=${this.id.valueOf()} existingMsgId=${this._upNext.msgId} incomingMsgId=${options.msgId}`);
+        }
+        const trimmed = options.prompt.trim();
+        if (!trimmed) {
+            throw new Error('Prompt is required to queue upNext');
+        }
+        this._upNext = {
+            prompt: trimmed,
+            msgId: options.msgId,
+            grammar: options.grammar,
+            userLanguageCode: options.userLanguageCode ?? this._lastUserLanguageCode,
+        };
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+    }
     hasUpNext() {
         return this._upNext !== undefined;
     }

package/dist/docs/dialog-system.md

@@ -60,7 +60,8 @@ A **subdlg.yaml** file indexes pending subdialogs that a supdialog is waiting fo
 
 ### Subdialog Registry
 
-The **subdialog registry** is a root dialog-scoped Map that maintains persistent references to registered subdialogs. The registry uses `agentId!tellaskSession` as its key format and is never deleted during the dialog lifecycle. It moves with the root to `done/` when the root completes, and is rebuilt on root load by scanning done/ subdialog YAMLs.
+The **subdialog registry** is a root dialog-scoped Map that maintains persistent references to registered subdialogs. The registry uses `agentId!tellaskSession` as its key format. It moves with the root to `done/` when the root completes, and is rebuilt on root load by scanning done/ subdialog YAMLs.
+If a sideline dialog is declared dead, its Type B registry entry is removed so the same `agentId!tellaskSession` can start a brand-new sideline dialog on the next Tellask.
 
 ### Teammate Tellask
 
@@ -367,6 +368,7 @@ flowchart TD
 7. **State Preservation Contract**:
    - `clear_mind`: Clears messages, clears Q4H index, preserves reminders, preserves registry
    - Subdialog completion: Writes response to supdialog, removes from pending list (registry unchanged)
+   - Subdialog declared dead: marks runState dead and removes its Type B registry entry; same slug can be reused as a fresh sideline dialog
    - Q4H answer: Clears the answered question from index, continues the dialog
 
 ---
@@ -770,14 +772,14 @@ The **subdialog registry** is a root-dialog-scoped data structure that maintains
 
 ### Key Characteristics
 
-| Aspect          | Description                                            |
-| --------------- | ------------------------------------------------------ |
-| **Scope**       | Root dialog only (not accessible to subdialogs)        |
-| **Key Format**  | `agentId!tellaskSession` (single-level Map)            |
-| **Storage**     | `registry.yaml` in root dialog directory               |
-| **Lifecycle**   | Never deleted during dialog lifetime                   |
-| **Persistence** | Moves with root to `done/` when root completes         |
-| **Restoration** | Rebuilt on root load by scanning done/ subdialog YAMLs |
+| Aspect          | Description                                                     |
+| --------------- | --------------------------------------------------------------- |
+| **Scope**       | Root dialog only (not accessible to subdialogs)                 |
+| **Key Format**  | `agentId!tellaskSession` (single-level Map)                     |
+| **Storage**     | `registry.yaml` in root dialog directory                        |
+| **Lifecycle**   | Retained during normal runs; dead subdialog entries are removed |
+| **Persistence** | Moves with root to `done/` when root completes                  |
+| **Restoration** | Rebuilt on root load by scanning done/ subdialog YAMLs          |
 
 ### Registry Operations
 
@@ -1310,13 +1312,13 @@ The Dominds dialog system provides a robust framework for hierarchical, human-in
 
 ### Four Core Mechanisms
 
-| Mechanism              | Purpose                       | Survives Clarity | Cleared By    |
-| ---------------------- | ----------------------------- | ---------------- | ------------- |
-| **Dialog Hierarchy**   | Parent-child task delegation  | N/A              | N/A           |
-| **Q4H**                | Human input requests          | No               | clear_mind    |
-| **Mental Clarity**     | Context reset tools           | N/A              | N/A           |
-| **Reminders**          | Persistent working memory     | Yes              | N/A           |
-| **Subdialog Registry** | Registered subdialog tracking | Yes              | Never deleted |
+| Mechanism              | Purpose                       | Survives Clarity | Cleared By                                   |
+| ---------------------- | ----------------------------- | ---------------- | -------------------------------------------- |
+| **Dialog Hierarchy**   | Parent-child task delegation  | N/A              | N/A                                          |
+| **Q4H**                | Human input requests          | No               | clear_mind                                   |
+| **Mental Clarity**     | Context reset tools           | N/A              | N/A                                          |
+| **Reminders**          | Persistent working memory     | Yes              | N/A                                          |
+| **Subdialog Registry** | Registered subdialog tracking | Yes              | dead-entry prune on `declare_subdialog_dead` |
 
 ### Three Types of Teammate Tellasks
 

package/dist/docs/dialog-system.zh.md

@@ -60,7 +60,7 @@
 
 ### 子对话注册表
 
-**子对话注册表** 是根对话作用域的 Map，维护对已注册子对话的持久引用。注册表使用 `agentId!tellaskSession` 作为其键格式，在对话生命周期中永远不会被删除。当根完成时，它随根移动到 `done/`，并在根加载时通过扫描 done/ 子对话 YAML 重建。
+**子对话注册表** 是根对话作用域的 Map，维护对已注册子对话的持久引用。注册表使用 `agentId!tellaskSession` 作为其键格式。当根完成时，它随根移动到 `done/`，并在根加载时通过扫描 done/ 子对话 YAML 重建。若某个支线对话被宣布卡死，其对应的 TYPE B 注册表条目会被移除，以便后续可用同一 `agentId!tellaskSession` 创建全新的支线对话。
 
 ### 队友 Tellask
 
@@ -225,7 +225,7 @@ LLM 发出：!?@orchestrator 我应该如何处理数据库迁移？
 
 - 每次 Tellask 都会执行注册表查找
 - 支持**恢复**先前的子对话
-- 已注册的子对话在注册表中持久存在直到根完成
+- 已注册的子对话在正常流程中会保留；若支线被宣布卡死，其条目会从注册表移除
 - 注册表是根对话作用域的（子对话无法访问）
 
 **示例**：
@@ -358,6 +358,7 @@ flowchart TD
 7. **状态保留契约**：
    - `clear_mind`：清除消息，清除 Q4H 索引，保留提醒，保留注册表
    - 子对话完成：向父对话写入响应，从待处理列表中删除（注册表不变）
+   - 子对话宣布卡死：将 runState 标记为 dead，并移除对应 TYPE B 注册表条目；同一 slug 可作为全新支线重新发起
    - Q4H 回答：从索引中清除已回答的问题，继续对话
 
 ---
@@ -755,14 +756,14 @@ async function checkSubdialogRevival(supdialog: Dialog): Promise<void> {
 
 ### 关键特征
 
-| 方面         | 描述                                      |
-| ------------ | ----------------------------------------- |
-| **作用域**   | 仅限根对话（子对话无法访问）              |
-| **键格式**   | `agentId!tellaskSession`（单级 Map）      |
-| **存储**     | 根对话目录中的 `registry.yaml`            |
-| **生命周期** | 在对话生命周期中永远不会被删除            |
-| **持久化**   | 根完成时随根移动到 `done/`                |
-| **恢复**     | 在根加载时通过扫描 done/ 子对话 YAML 重建 |
+| 方面         | 描述                                       |
+| ------------ | ------------------------------------------ |
+| **作用域**   | 仅限根对话（子对话无法访问）               |
+| **键格式**   | `agentId!tellaskSession`（单级 Map）       |
+| **存储**     | 根对话目录中的 `registry.yaml`             |
+| **生命周期** | 正常流程保留；被宣布卡死的子对话条目会移除 |
+| **持久化**   | 根完成时随根移动到 `done/`                 |
+| **恢复**     | 在根加载时通过扫描 done/ 子对话 YAML 重建  |
 
 ### 注册表操作
 
@@ -917,7 +918,7 @@ interface RegistryMethods {
 
 **导航**：每个子对话都保持对其父级的引用，向上遍历到主对话。
 
-**注册表**：已注册的子对话（TYPE B Tellask）在根对话的注册表中跟踪，并在重启后持久化。
+**注册表**：已注册的子对话（TYPE B Tellask）在根对话的注册表中跟踪，并在重启后持久化；若子对话被宣布卡死，其条目会被裁剪，不再参与后续同 slug 复用。
 
 ### 生命周期管理
 
@@ -1309,13 +1310,13 @@ Dominds 对话系统为层次化、人在回路的 AI 协作提供了一个强
 
 ### 四个核心机制
 
-| 机制             | 目的             | 存活于清晰度 | 清除方式   |
-| ---------------- | ---------------- | ------------ | ---------- |
-| **对话层次结构** | 父子任务委托     | N/A          | N/A        |
-| **Q4H**          | 人机交互请求     | 否           | clear_mind |
-| **心智清晰度**   | 上下文重置工具   | N/A          | N/A        |
-| **提醒项**       | 持久化工作内存   | 是           | N/A        |
-| **子对话注册表** | 已注册子对话跟踪 | 是           | 永不删除   |
+| 机制             | 目的             | 存活于清晰度 | 清除方式                                  |
+| ---------------- | ---------------- | ------------ | ----------------------------------------- |
+| **对话层次结构** | 父子任务委托     | N/A          | N/A                                       |
+| **Q4H**          | 人机交互请求     | 否           | clear_mind                                |
+| **心智清晰度**   | 上下文重置工具   | N/A          | N/A                                       |
+| **提醒项**       | 持久化工作内存   | 是           | N/A                                       |
+| **子对话注册表** | 已注册子对话跟踪 | 是           | `declare_subdialog_dead` 时裁剪 dead 条目 |
 
 ### 三种队友 Tellask 类型
 
@@ -1334,5 +1335,5 @@ Dominds 对话系统为层次化、人在回路的 AI 协作提供了一个强
 
 - **Q4H**：持久化，由清晰度操作清除
 - **提醒项**：持久化，在清晰度操作中存活
-- **注册表**：持久化，在清晰度操作中存活，完成时移至 done/
+- **注册表**：持久化，在清晰度操作中存活，完成时移至 done/；dead 条目会在宣布卡死时被裁剪
 - **子对话**：已注册的子对话在注册表中持久化；临时子对话不会被注册

package/dist/evt-registry.js

@@ -25,13 +25,18 @@ class DialogEventRegistryImpl {
     setQ4HBroadcaster(fn) {
         this.q4hBroadcaster = fn;
     }
-    broadcastIfQ4H(evt) {
-        // Only broadcast Q4H events; all other dialog events remain dialog-scoped streams.
+    dispatchQ4HGloballyIfNeeded(evt) {
+        // Q4H MUST be global-only: emit to all clients via broadcaster and do not
+        // also write into dialog-scoped stream, otherwise subscribed clients will
+        // receive duplicate deliveries via two independent paths.
         if (evt.type !== 'new_q4h_asked' && evt.type !== 'q4h_answered')
-            return;
+            return false;
         const fn = this.q4hBroadcaster;
-        if (fn)
-            fn(evt);
+        if (!fn) {
+            throw new Error(`Q4H broadcaster missing: cannot publish ${evt.type} for dialog=${evt.dialog.selfId}`);
+        }
+        fn(evt);
+        return true;
     }
     /**
      * Get or create a PubChan for a specific dialog ID
@@ -75,13 +80,17 @@ class DialogEventRegistryImpl {
      */
     postEvent(dlg, event) {
         const typedEvent = this.createTypedEvent(dlg.id, event);
-        this.broadcastIfQ4H(typedEvent);
+        if (this.dispatchQ4HGloballyIfNeeded(typedEvent)) {
+            return;
+        }
         const chan = this.getPubChan(dlg.id);
         chan.write(typedEvent);
     }
     postEventById(dialogId, event) {
         const typedEvent = this.createTypedEvent(dialogId, event);
-        this.broadcastIfQ4H(typedEvent);
+        if (this.dispatchQ4HGloballyIfNeeded(typedEvent)) {
+            return;
+        }
         const chan = this.getPubChan(dialogId);
         chan.write(typedEvent);
     }

package/dist/llm/driver-v2/context.js

@@ -39,7 +39,8 @@ function buildDriveBaseContextMessages(parts) {
 }
 function appendDriveEphemeralContext(base, parts) {
     const next = [...base];
-    if (parts.subdialogResponseContextMsgs.length > 0) {
+    if (Array.isArray(parts.subdialogResponseContextMsgs) &&
+        parts.subdialogResponseContextMsgs.length > 0) {
         next.push(...parts.subdialogResponseContextMsgs);
     }
     if (parts.internalDrivePromptMsg) {

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

@@ -10,7 +10,6 @@ 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 inter_dialog_format_1 = require("../../shared/utils/inter-dialog-format");
 const tellask_1 = require("../../tellask");
 const taskdoc_1 = require("../../utils/taskdoc");
 const client_1 = require("../client");
@@ -20,7 +19,6 @@ const context_1 = require("./context");
 const policy_1 = require("./policy");
 const runtime_utils_1 = require("./runtime-utils");
 const saying_events_1 = require("./saying-events");
-const subdialog_txn_1 = require("./subdialog-txn");
 const tellask_bridge_1 = require("./tellask-bridge");
 class DialogInterruptedError extends Error {
     constructor(reason) {
@@ -56,7 +54,7 @@ function resolveUpNextPrompt(dlg) {
     return {
         content: upNext.prompt,
         msgId: upNext.msgId,
-        grammar: 'markdown',
+        grammar: upNext.grammar ?? 'markdown',
         userLanguageCode: upNext.userLanguageCode,
     };
 }
@@ -71,6 +69,93 @@ async function emitUserMarkdown(dlg, content) {
 function resolveModelInfo(providerCfg, model) {
     return providerCfg.models[model];
 }
+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 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;
@@ -123,21 +208,6 @@ async function buildProviderContext(args) {
     }
     return { provider, model, providerCfg };
 }
-async function hasQueuedSubdialogResponses(dialog) {
-    try {
-        const queued = await (0, subdialog_txn_1.withSubdialogTxnLock)(dialog.id, async () => {
-            return await persistence_1.DialogPersistence.loadSubdialogResponsesQueue(dialog.id);
-        });
-        return queued.length > 0;
-    }
-    catch (err) {
-        log_1.log.warn('driver-v2 failed to check queued subdialog responses; suppressing diligence as safe default', {
-            dialogId: dialog.id.valueOf(),
-            error: err,
-        });
-        return true;
-    }
-}
 async function executeFunctionCalls(args) {
     const { dialog, agent, agentTools, funcCalls, abortSignal } = args;
     const functionPromises = funcCalls.map(async (func) => {
@@ -270,13 +340,6 @@ async function maybeContinueWithDiligencePrompt(args) {
         }
         return { kind: 'break' };
     }
-    const queuedResponses = await hasQueuedSubdialogResponses(dlg);
-    if (queuedResponses) {
-        log_1.log.info('driver-v2 skip diligence prompt while subdialog responses remain queued', {
-            dialogId: dlg.id.valueOf(),
-        });
-        return { kind: 'break' };
-    }
     const prepared = await (0, runtime_utils_1.maybePrepareDiligenceAutoContinuePrompt)({
         dlg,
         isRootDialog: true,
@@ -328,12 +391,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
     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 = [];
-    let subdialogResponseContextMsgs = [];
     let internalDrivePromptMsg;
-    let committedTakenSubdialogResponses = false;
     let genIterNo = 0;
     let pendingPrompt = humanPrompt;
     let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
@@ -372,6 +430,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             const funcTools = projected.tools;
             let suspendForHuman = false;
             let llmGenModelForGen = model;
+            let contextHealthForGen;
             await dlg.notifyGeneratingStart();
             try {
                 const currentPrompt = pendingPrompt;
@@ -460,20 +519,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     await resetDiligenceBudgetAfterQ4H(dlg, team);
                     break;
                 }
-                if (genIterNo === 1 && !tookSubdialogResponses) {
-                    tookSubdialogResponses = true;
-                    try {
-                        takenSubdialogResponses = await (0, subdialog_txn_1.takeSubdialogResponses)(dlg.id);
-                    }
-                    catch (err) {
-                        log_1.log.warn('driver-v2 failed to take subdialog responses for injection', {
-                            dialogId: dlg.id.selfId,
-                            error: err,
-                        });
-                        generationHadError = true;
-                        takenSubdialogResponses = [];
-                    }
-                }
                 const taskDocMsg = dlg.taskDocPath && !skipTaskdocForThisDrive ? await (0, taskdoc_1.formatTaskDocContent)(dlg) : undefined;
                 const coursePrefixMsgs = (() => {
                     const msgs = dlg.getCoursePrefixMsgs();
@@ -486,19 +531,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         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) => {
@@ -530,7 +562,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         dialogMsgsForContext,
                     },
                     ephemeral: {
-                        subdialogResponseContextMsgs,
                         internalDrivePromptMsg,
                     },
                     tail: {
@@ -553,6 +584,12 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         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');
                     const collectedAssistantCalls = [];
@@ -802,6 +839,12 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     streamResult.llmGenModel.trim() !== '') {
                     llmGenModelForGen = streamResult.llmGenModel.trim();
                 }
+                contextHealthForGen = computeContextHealthSnapshot({
+                    providerCfg,
+                    model,
+                    usage: streamResult.usage,
+                });
+                dlg.setLastContextHealth(contextHealthForGen);
                 const collectedCalls = parser.getCollectedCalls();
                 const policyViolation = (0, policy_1.resolveDriverV2PolicyViolationKind)({
                     policy,
@@ -887,7 +930,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                 }
             }
             finally {
-                await dlg.notifyGeneratingFinish(undefined, llmGenModelForGen);
+                await dlg.notifyGeneratingFinish(contextHealthForGen, llmGenModelForGen);
             }
         }
         finalRunState = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
@@ -905,12 +948,10 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         : { kind: 'system_stop', detail: 'Aborted.' }
                 : undefined;
         if (interruptedReason) {
-            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);
@@ -953,63 +994,5 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             });
         }
         await (0, dialog_run_state_1.setDialogRunState)(dlg.id, finalRunState);
-        if (tookSubdialogResponses) {
-            try {
-                if (generationHadError) {
-                    await (0, subdialog_txn_1.rollbackTakenSubdialogResponses)(dlg.id);
-                }
-                else {
-                    await (0, subdialog_txn_1.commitTakenSubdialogResponses)(dlg.id);
-                    committedTakenSubdialogResponses = true;
-                }
-            }
-            catch (err2) {
-                log_1.log.warn('driver-v2 failed to finalize subdialog response queue after drive', {
-                    dialogId: dlg.id.selfId,
-                    error: err2,
-                });
-            }
-        }
-        if (committedTakenSubdialogResponses && takenSubdialogResponses.length > 0) {
-            try {
-                const mirroredMsgs = [];
-                for (const response of takenSubdialogResponses) {
-                    const 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)(),
-                    });
-                    const status = response.status ?? 'completed';
-                    const alreadyMirrored = dlg.msgs.some((msg) => msg.type === 'tellask_result_msg' &&
-                        msg.role === 'tool' &&
-                        msg.responderId === response.responderId &&
-                        msg.tellaskHead === response.tellaskHead &&
-                        msg.status === status &&
-                        msg.content === content);
-                    if (alreadyMirrored) {
-                        continue;
-                    }
-                    mirroredMsgs.push({
-                        type: 'tellask_result_msg',
-                        role: 'tool',
-                        responderId: response.responderId,
-                        tellaskHead: response.tellaskHead,
-                        status,
-                        content,
-                    });
-                }
-                if (mirroredMsgs.length > 0) {
-                    await dlg.addChatMessages(...mirroredMsgs);
-                }
-            }
-            catch (err) {
-                log_1.log.warn('driver-v2 failed to mirror committed subdialog responses into dialog msgs', {
-                    dialogId: dlg.id.selfId,
-                    error: err,
-                });
-            }
-        }
     }
 }