dominds 1.19.2 → 1.20.1

package/dist/docs/idle-reminder-wake.zh.md

@@ -0,0 +1,227 @@
+# Idle reminder wake 设计
+
+英文版：[English](./idle-reminder-wake.md)
+
+本文定义一种 driver 级后台协程机制：当对话进入 `idle_waiting_user` 后，runtime 可以等待 reminder owner 产生的可唤醒事件；若事件到达时对话仍处于 idle，则把事件打包成一条 `role=user` 的系统提示消息，并继续驱动对话。
+
+本文是设计文档。它描述业务语义、owner 接口、取消模型与当前落地场景，不规定最终代码拆分。
+
+---
+
+## 背景
+
+现有 reminder owner 已负责维护提醒项的真实语义，例如 `shell_cmd` daemon reminder 能在下一次 reminder 更新时发现 daemon 已退出，并把提醒项更新为终态。
+
+但这条链路有一个缺口：如果 daemon 在对话 idle 期间退出，系统只会在下一次打开对话、显示 reminders 或新一轮 drive 时发现。对用户而言，长期运行的 shell 命令已经完成，但对话没有被自动唤醒，也不会主动说明进程已退出。
+
+这个问题不应由 `shell_cmd` 工具直接驱动对话解决。driver 是唯一应决定对话是否继续运行的组件；reminder owner 只负责解释自己拥有的 reminder 何时产生了值得唤醒模型的环境事件。
+
+---
+
+## 目标
+
+- 在对话真正进入 `idle_waiting_user` 后，启动一个可取消的后台 await 协程。
+- 允许 reminder owner 暴露“可唤醒事件”，例如 daemon exited。
+- 事件到达时先短暂聚合，再形成一条 runtime `role=user` 系统提示消息。
+- 若聚合完成后对话仍是 idle，使用普通 driver 路径继续驱动。
+- 任意新的继续驱动动作都取消已有 idle await 协程。
+- 保持 owner metadata 语义封装：framework 只按 owner 路由，不偷看 owner meta。
+- 保证幂等：同一个环境事件不能重复插入系统提示。
+
+## 非目标
+
+- 不把普通 reminder 内容变更都视为唤醒信号。
+- 不让 reminder owner 直接调用 `driveDialogStream`。
+- 不把 idle await 协程纳入 `activeRun`，以免 UI 把等待环境事件误判为 proceeding。
+- 不在对话 blocked、stopped、dead 或 completed/archived 时自动唤醒。
+- 不把 daemon stdout/stderr 的每次增长都作为唤醒事件；当前场景只处理 daemon lifecycle exit。
+
+---
+
+## 核心结论
+
+### 1. Driver 拥有 idle wake 生命周期
+
+当 `driveDialogStreamCore` 最终把 display state 设置为 `idle_waiting_user` 后，driver 外层启动一个 dialog-scoped idle wake task。
+
+该 task：
+
+- 不持有 dialog mutex
+- 不创建 active run
+- 不改变 display state
+- 只等待 owner 提供的 wake event
+- 在新一轮 drive 开始前被取消
+
+这样可以保证“等待环境事件”不是“正在工作”，也不会抢占用户可见的运行控制语义。
+
+### 2. Reminder owner 只报告 wake event
+
+`ReminderOwner` 增加可选接口：
+
+```ts
+export type ReminderWakeEvent = Readonly<{
+  eventId: string;
+  reminderId: string;
+  content: string;
+  updatedContent?: string;
+  updatedMeta?: JsonValue;
+}>;
+
+export interface ReminderOwner {
+  readonly name: string;
+  updateReminder(dlg: Dialog, reminder: Reminder): Promise<ReminderUpdateResult>;
+  renderReminder(dlg: Dialog, reminder: Reminder): Promise<ChatMessage>;
+
+  waitForReminderWakeEvent?(
+    dlg: Dialog,
+    reminders: readonly Reminder[],
+    signal: AbortSignal,
+  ): Promise<ReminderWakeEvent | readonly ReminderWakeEvent[] | null>;
+}
+```
+
+`content` 是 owner 已经格式化好的系统提示正文，必须以 `【系统提示】` / `[System notice]` 开头。它不是用户真实输入，但当前 provider role 限制下会经 runtime prompt 路径持久化为 `role=user` 消息。
+
+`eventId` 是 owner 范围内稳定幂等键。owner 必须能在 reminder meta 或 owner 自己的状态中记录该事件已经投递，防止重复 wake。
+
+### 3. 首个事件到达后进入短聚合窗口
+
+driver 不应在第一个 wake event 到达后立刻 drive。它应：
+
+1. await 到第一个 wake event
+2. 打开一个约 500ms 的聚合窗口
+3. 收集同一 dialog 当前 idle wake task 下其它 owner/reminder 已经到达的 wake event
+4. 对收集到的事件做稳定排序与去重
+5. 打包形成一条 runtime prompt
+
+这样可以避免多个 daemon 在相近时间退出时连续触发多轮 drive。用户和模型看到的是一条合并的环境状态消息，而不是多条碎片化系统提示。
+
+### 4. Wake 后必须重新检查真实状态
+
+聚合窗口结束后，driver 必须重新从 persistence 检查：
+
+- dialog 仍存在且 status 为 running
+- display state 仍是 `idle_waiting_user`
+- execution marker 不是 dead，也不是需要人工 resume 的 interrupted
+- 没有 pending Q4H
+- 没有 blocking pending sideDialog
+- 当前没有 active run
+
+只有这些条件都满足，才允许以 wake prompt 继续驱动。否则丢弃本次 wake，并只保留 owner 的幂等/状态更新。
+
+### 5. 任意 drive 都取消 idle wake task
+
+进入任何新 drive 前，runtime 必须取消该 dialog 已存在的 idle wake task。包括：
+
+- 用户发送新消息
+- 手动 Continue / Resume All
+- Q4H answer 恢复
+- sideDialog response 恢复
+- Diligence Push / 其它 runtime auto-drive
+- 本机制自己的 wake drive
+
+取消后，旧 task 即使有 promise resolve，也不得产生副作用。
+
+---
+
+## Wake 消息格式
+
+owner event 的 `content` 应聚焦事实，不给模型伪造用户诉求。
+
+daemon exit 示例：
+
+```text
+【系统提示】
+后台进程已退出。这是 runtime 环境事件，不是新的用户指令。
+
+- PID: 12345
+- 命令: pnpm run build
+- 退出状态: code 0, signal null
+
+请根据当前任务上下文判断是否需要查看最终 stdout/stderr 或向用户汇报结果；不要只回复“收到”。
+```
+
+driver 聚合多条事件时，应保留每条事件的事实块，并加一个总前缀：
+
+```text
+【系统提示】
+以下是对话空闲期间发生的 runtime 环境事件。这些事件不是新的用户指令。
+
+1. 后台进程已退出 ...
+2. 后台进程已退出 ...
+
+请结合当前任务上下文继续推进；若这些事件不影响当前工作，不要发送占位式确认。
+```
+
+---
+
+## Shell daemon exit 当前落地场景
+
+`shellCmdReminderOwner` 实现 `waitForReminderWakeEvent`。
+
+语义：
+
+- 只关注该 owner 拥有的 daemon reminders。
+- 只在 daemon 从 running 进入 exited/gone 时产生 wake event。
+- stdout/stderr 增长不产生 wake event。
+- 如果 reminder meta 已标记对应 exit event 已投递，则返回 `null`。
+- event 到达后，owner 同时提供终态 reminder 的 `updatedContent` / `updatedMeta`，由 driver 在投递 wake 前持久化。
+
+需要补充的 meta：
+
+- `originRootId`：恢复 origin dialog 时必须知道 root。
+- `originDialogId`：已有字段，继续表示 self id。
+- `exitWakeEventId`：稳定事件 id，例如 `shellCmd:daemonExited:<pid>:<startTime>`。
+- `exitWakeNotifiedAt`：该事件已被 runtime 采纳并投递的时间。
+
+daemon runner 如果能提供可 await 的 exit 信号，应优先使用；如果当前只能通过本地 IPC 状态检查实现，轮询必须封装在 owner 内部，driver 不承担 daemon 专属扫描逻辑。
+
+---
+
+## 取消与并发模型
+
+每个 dialog 最多一个 idle wake task。
+
+建议 runtime 维护：
+
+```ts
+type IdleReminderWakeTask = Readonly<{
+  dialogKey: string;
+  controller: AbortController;
+  startedAt: string;
+}>;
+```
+
+新 drive preflight 的第一步取消旧 task。取消是幂等的。
+
+idle wake task resolve 后也必须再次检查自己仍是当前 task；如果已经被替换或取消，直接返回。
+
+---
+
+## 崩溃恢复
+
+idle wake task 本身不持久化。后端重启后不会恢复“正在等待”的 promise。
+
+恢复后的首次正常 driver/display/reminder 更新仍会修正 reminder 终态。若需要重启后也主动唤醒 idle dialog，可以补充“启动时对 running idle dialogs 重新安装 idle wake task”的 bootstrap。该能力不是当前机制闭环的必要条件。
+
+---
+
+## 观测与错误处理
+
+owner wait 接口必须 loud by default：
+
+- 非取消错误应 structured log，字段包含 `rootId`、`selfId`、`ownerName`、`reminderId`、`eventId`（若有）。
+- owner 不得吞掉不合理状态，例如重复 event id 与不同内容冲突。
+- driver 若发现聚合后的状态不允许 revive，应记录 debug/warn 级别诊断，但不应把被丢弃的 wake 作为用户可见消息。
+
+---
+
+## 实现顺序
+
+1. 增加 `ReminderWakeEvent` 与 `ReminderOwner.waitForReminderWakeEvent?` 类型。
+2. 增加 driver 侧 idle wake task 管理：start/cancel/race/500ms 聚合/状态复检。
+3. 在所有 drive 入口 preflight 取消该 dialog 的 idle wake task。
+4. 在 driver 最终落到 `idle_waiting_user` 后启动 idle wake task。
+5. 实现 `shellCmdReminderOwner` 的 daemon exit wake event。
+6. 为 daemon reminder meta 补充 `originRootId` 与 wake 幂等字段。
+7. 补测试：单 daemon 退出唤醒、多 daemon 500ms 聚合、用户消息取消、blocked 不唤醒、幂等不重复。

package/dist/docs/mcp-support.md

@@ -98,6 +98,12 @@ Releasing:
 
 - Agents should call `mcp_release({"serverId":"<serverId>"})` (from `mcp_admin`) to release the
   leased runtime instance for the current dialog.
+- `mcp_restart({"serverId":"<serverId>"})` enables a disabled server (`enabled: true`) before
+  starting it. After a successful restart, Dominds replaces the global runtime and clears all dialog
+  leases on the old runtime.
+- `mcp_disable({"serverId":"<serverId>"})` disables a server (`enabled: false`) and stops any loaded
+  runtime/leases. Disabled servers remain visible as zero-tool MCP toolsets, and their configured
+  manual remains readable with an explicit disabled notice.
 
 ### Shared behavior (`truely-stateless: true`)
 
@@ -397,6 +403,11 @@ This is a Dominds-oriented schema. It is intentionally small and should be easy
 version: 1
 servers:
   <serverId>:
+    # Optional operational switch. `mcp_disable` writes this to false; `mcp_restart`
+    # writes it back to true before starting the server.
+    # Disabled servers start no runtime and expose a zero-tool toolset/manual marked disabled.
+    enabled: true
+
     # Concurrency model (IMPORTANT)
     # - Default false: per-dialog client leasing (safer for stateful servers)
     # - True: shared client across dialogs (only for servers that are truly stateless)

package/dist/docs/mcp-support.zh.md

@@ -75,6 +75,8 @@ Dominds 的行为：
 释放：
 
 - 智能体应调用 `mcp_release({"serverId":"<serverId>"})`（来自 `mcp_admin`）来释放当前对话持有的租赁运行时实例。
+- `mcp_restart({"serverId":"<serverId>"})` 会先启用被禁用的 server（`enabled: true`），再启动它。成功重启后，Dominds 会替换全局 runtime，并清理旧 runtime 上的全部对话 lease。
+- `mcp_disable({"serverId":"<serverId>"})` 会禁用 server（`enabled: false`），并停止已加载 runtime/lease。禁用 server 仍作为 0 工具 MCP toolset 可见，已配置手册也会带明确 disabled 提示继续可读。
 
 ### 共享行为（`truely-stateless: true`）
 
@@ -322,6 +324,11 @@ headers:
 version: 1
 servers:
   <serverId>:
+    # 可选运维开关。`mcp_disable` 会把它写成 false；`mcp_restart`
+    # 会在启动前写回 true。
+    # disabled server 不启动 runtime，并暴露为带 disabled 标记的 0 工具 toolset/手册。
+    enabled: true
+
     # 并发模型（重要）
     # - 默认 false：每对话客户端租赁（对有状态服务器更安全）
     # - True：跨对话共享客户端（仅适用于真正无状态的服务器）

package/dist/docs/team_mgmt-toolset.md

@@ -384,7 +384,9 @@ Notes:
 
 - MCP tool names are global across all toolsets (built-in + MCP). Collisions cause tools to be
   skipped and should surface via Problems + logs.
-- `mcp_admin` is a built-in toolset that contains `mcp_restart` (best-effort per-server restart).
+- `mcp_admin` is a built-in toolset for MCP operations: `mcp_restart` enables/restarts a server,
+  `mcp_disable` disables a server while keeping its zero-tool toolset/manual visible, and
+  `mcp_release` releases the current dialog lease.
 - Optional manual information can live in `.minds/mcp.yaml` at `servers.<serverId>.manual`:
   - `contentFile`: the topic-file directory prefix for the formal runtime manual; the final `man({ "toolsetId": "<serverId>" })` content shown to the LLM is loaded from here
   - `content` / `sections`: inline team-management guidance shown in the `team_mgmt` MCP chapter (`sections` supports `[{ title, content }]` or `{ "<title>": "<content>" }`)
@@ -635,4 +637,5 @@ This avoids needing to grant full rtws access to configure the team.
   - Confirm the teammate is granted the relevant `<serverId>` toolset in `.minds/team.yaml`.
 - **MCP server keeps failing to (re)load**:
   - Check Problems details (missing env var, invalid tool name, collisions, connection errors).
-  - After fixing config, use `mcp_restart` (from `mcp_admin`) for a best-effort per-server restart.
+  - After fixing config, use `mcp_restart` (from `mcp_admin`) to enable/restart the server. Use
+    `mcp_disable` to disable it while keeping the configured manual visible as a zero-tool toolset.

package/dist/docs/team_mgmt-toolset.zh.md

@@ -321,7 +321,8 @@ members:
 注意：
 
 - MCP 工具名称在所有工具集（内置 + MCP）中是全局的。冲突导致工具被跳过，应通过问题 + 日志暴露
-- `mcp_admin` 是一个内置工具集，包含 `mcp_restart`（每个服务器最佳努力重启）
+- `mcp_admin` 是 MCP 运维内置工具集：`mcp_restart` 启用/重启 server，`mcp_disable` 禁用
+  server 并保留 0 工具 toolset/手册可见性，`mcp_release` 释放当前对话 lease
 - 可选手册：可在 `.minds/mcp.yaml` 的 `servers.<serverId>.manual` 提供手册相关信息：
   - `contentFile`：正式 runtime 手册的 topic 文件目录前缀；`man({ "toolsetId": "<serverId>" })` 最终给 LLM 看的正文从这里加载
   - `content` / `sections`：补充给 `team_mgmt` MCP 章节看的 inline 团队管理说明（`sections` 支持 `[{ title, content }]` 或 `{ "<title>": "<content>" }`）
@@ -540,4 +541,5 @@ members:
   - 确认队友在 `.minds/team.yaml` 中被授予了相关的 `<serverId>` 工具集
 - **MCP 服务器持续 (re)load 失败**：
   - 检查问题详细信息（缺少 env 变量、无效的工具名称、冲突、连接错误）
-  - 修复配置后，使用 `mcp_admin` 中的 `mcp_restart` 进行每个服务器的最佳努力重启
+  - 修复配置后，使用 `mcp_admin` 中的 `mcp_restart` 启用/重启 server。若需禁用，使用
+    `mcp_disable`，它会保留 0 工具 toolset 和已配置手册可见性

package/dist/docs/tool-availability-protocol.md

@@ -79,7 +79,8 @@ Non-goals:
 Update triggers:
 
 - `.minds/mcp.yaml` reload
-- `mcp_restart`
+- `mcp_restart` (also writes `enabled: true` when a configured MCP server is disabled)
+- `mcp_disable` (writes `enabled: false`; the server remains visible as a zero-tool toolset/manual)
 - MCP collision-resolution re-registration
 
 ### 2. Runtime Lease Protocol
@@ -105,7 +106,8 @@ Update triggers:
 
 - first MCP tool call acquires a lease
 - `mcp_release`
-- restart/stop tears leases down
+- successful `mcp_restart` tears old-runtime leases down
+- `mcp_disable` tears loaded runtime leases down
 
 ### 3. Member Tool-Binding Protocol
 

package/dist/llm/client.d.ts

@@ -80,3 +80,5 @@ export declare class LlmConfig {
 export declare namespace LlmConfig {
     function load(): Promise<LlmConfig>;
 }
+export declare function getBuiltinDefaultsYamlPath(): string;
+export declare function readBuiltinDefaultsYamlRaw(): Promise<string>;

package/dist/llm/client.js

@@ -4,10 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlmConfig = void 0;
+exports.getBuiltinDefaultsYamlPath = getBuiltinDefaultsYamlPath;
+exports.readBuiltinDefaultsYamlRaw = readBuiltinDefaultsYamlRaw;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
 const log_1 = require("../log");
+const BUILTIN_DEFAULTS_YAML_PATH = path_1.default.join(__dirname, 'defaults.yaml');
+// Special-case cache: built-in defaults are immutable at runtime, so this file may be cached
+// forever to survive dogfooding rebuild windows. Do not generalize this to rtws/user-editable files.
+let builtinDefaultsYamlRawCache;
+let builtinDefaultsYamlRawReadPromise;
 /**
  * LlmConfig
  *
@@ -28,8 +35,7 @@ exports.LlmConfig = LlmConfig;
 (function (LlmConfig) {
     async function load() {
         // Load default providers from YAML file
-        const defaultsPath = path_1.default.join(__dirname, 'defaults.yaml');
-        const rawDefaults = await promises_1.default.readFile(defaultsPath, 'utf-8');
+        const rawDefaults = await readBuiltinDefaultsYamlRaw();
         const parsedDefaults = yaml_1.default.parse(rawDefaults);
         if (!isRecord(parsedDefaults) || !isRecord(parsedDefaults.providers)) {
             throw new Error('Invalid defaults.yaml: expected providers object');
@@ -64,6 +70,30 @@ exports.LlmConfig = LlmConfig;
     }
     LlmConfig.load = load;
 })(LlmConfig || (exports.LlmConfig = LlmConfig = {}));
+function getBuiltinDefaultsYamlPath() {
+    return BUILTIN_DEFAULTS_YAML_PATH;
+}
+async function readBuiltinDefaultsYamlRaw() {
+    if (builtinDefaultsYamlRawCache !== undefined)
+        return builtinDefaultsYamlRawCache;
+    if (builtinDefaultsYamlRawReadPromise === undefined) {
+        builtinDefaultsYamlRawReadPromise = promises_1.default
+            .readFile(BUILTIN_DEFAULTS_YAML_PATH, 'utf-8')
+            .then((raw) => {
+            const parsed = yaml_1.default.parse(raw);
+            if (!isRecord(parsed) || !isRecord(parsed.providers)) {
+                throw new Error('Invalid defaults.yaml: expected providers object');
+            }
+            builtinDefaultsYamlRawCache = raw;
+            return raw;
+        })
+            .catch((error) => {
+            builtinDefaultsYamlRawReadPromise = undefined;
+            throw error;
+        });
+    }
+    return builtinDefaultsYamlRawReadPromise;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }

package/dist/llm/defaults.yaml

@@ -100,6 +100,15 @@ providers:
           min: 1
           description: Provider-specific max tokens override.
     models:
+      gpt-5.5:
+        name: GPT-5.5
+        optimal_max_tokens: 350000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
+        context_length: 400000
+        input_length: 272000
+        output_length: 128000
+        context_window: '400K'
       gpt-5.4:
         name: GPT-5.4
         optimal_max_tokens: 200000
@@ -653,20 +662,34 @@ providers:
           type: boolean
           description: Supported via thinking field (budget_tokens is ignored by DeepSeek).
     models:
+      deepseek-v4-flash:
+        name: DeepSeek-V4-Flash
+        supports_image_input: false
+        context_length: 1000000
+        input_length: 1000000
+        output_length: 384000
+        context_window: '1M'
+      deepseek-v4-pro:
+        name: DeepSeek-V4-Pro
+        supports_image_input: false
+        context_length: 1000000
+        input_length: 1000000
+        output_length: 384000
+        context_window: '1M'
       deepseek-chat:
-        name: DeepSeek-V3.2
+        name: DeepSeek-V4-Flash (non-thinking alias)
         supports_image_input: false
-        context_length: 128000
-        input_length: 128000
-        output_length: 8192
-        context_window: '128K'
+        context_length: 1000000
+        input_length: 1000000
+        output_length: 384000
+        context_window: '1M'
       deepseek-reasoner:
-        name: DeepSeek-R1 (reasoner, V3.2 thinking mode)
+        name: DeepSeek-V4-Flash (thinking alias)
         supports_image_input: false
-        context_length: 128000
-        input_length: 128000
-        output_length: 65536
-        context_window: '128K'
+        context_length: 1000000
+        input_length: 1000000
+        output_length: 384000
+        context_window: '1M'
   aliyun-bailian:
     name: Aliyun Bailian Coding Plan
     apiType: anthropic
@@ -846,6 +869,24 @@ providers:
           min: 1
           description: Provider-specific max tokens override.
     models:
+      gpt-5.5:
+        name: GPT-5.5
+        optimal_max_tokens: 350000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
+        context_length: 1000000
+        input_length: 1000000
+        output_length: 128000
+        context_window: '1M'
+      gpt-5.5-pro:
+        name: GPT-5.5 Pro
+        optimal_max_tokens: 600000
+        # Caution remediation reinjection cadence in generation turns (default: 10).
+        caution_remediation_cadence_generations: 10
+        context_length: 1000000
+        input_length: 1000000
+        output_length: 128000
+        context_window: '1M'
       gpt-5.4:
         name: GPT-5.4
         optimal_max_tokens: 200000

package/dist/llm/gen/codex.js

@@ -654,6 +654,21 @@ class CodexGen {
         // NOTE: `@longrun-ai/codex-auth` is an ESM package (`"type": "module"`). The Dominds backend is
         // compiled as CommonJS, so Node.js requires a dynamic `import()` for runtime access here.
         const codexAuth = await Promise.resolve().then(() => __importStar(require('@longrun-ai/codex-auth')));
+        const authPreparation = codexAuth.prepareCodexFileAuth({
+            codexHome,
+            codexHomeEnvVar: providerConfig.apiKeyEnvVar,
+            providerName: `Dominds codex provider '${providerConfig.name}'`,
+        });
+        if (authPreparation.kind === 'action_required') {
+            throw new Error(codexAuth.formatCodexFileAuthActionRequired(authPreparation));
+        }
+        if (authPreparation.changedConfigToFile) {
+            log.info('Codex CLI auth storage switched to file mode for Dominds codex provider', undefined, {
+                codexHome: authPreparation.codexHome,
+                configPath: authPreparation.configPath,
+                previousStoreMode: authPreparation.previousStoreMode,
+            });
+        }
         const manager = new codexAuth.AuthManager({ codexHome });
         const client = await codexAuth.createChatGptClientFromManager(manager, {
             baseUrl: providerConfig.baseUrl,

package/dist/llm/kernel-driver/drive.js

@@ -1189,14 +1189,17 @@ async function maybeContinueWithHealthPromptBeforeDiligence(args) {
         return { kind: 'health_continue', prompt: nextPrompt, resetTaskdoc: true };
     }
     const language = (0, work_language_1.getWorkLanguage)();
+    const dialogScope = dlg instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
     const guideText = healthDecision.reason === 'caution_soft_remediation'
         ? (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
             kind: 'caution',
             mode: 'soft',
+            dialogScope,
         })
         : (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
             kind: 'critical',
             mode: 'countdown',
+            dialogScope,
             promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
             promptsTotal: context_health_1.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
         });
@@ -1381,14 +1384,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         }
                         else if (!hasQueuedUpNext) {
                             const language = (0, work_language_1.getWorkLanguage)();
+                            const dialogScope = dlg instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
                             const guideText = healthDecision.reason === 'caution_soft_remediation'
                                 ? (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
                                     kind: 'caution',
                                     mode: 'soft',
+                                    dialogScope,
                                 })
                                 : (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
                                     kind: 'critical',
                                     mode: 'countdown',
+                                    dialogScope,
                                     promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
                                     promptsTotal: context_health_1.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
                                 });

package/dist/llm/kernel-driver/flow.js

@@ -19,6 +19,7 @@ const client_1 = require("../client");
 const context_health_1 = require("./context-health");
 const drive_1 = require("./drive");
 const guardrails_1 = require("./guardrails");
+const idle_reminder_wake_1 = require("./idle-reminder-wake");
 const reply_guidance_1 = require("./reply-guidance");
 const sideDialog_1 = require("./sideDialog");
 const tellask_special_1 = require("./tellask-special");
@@ -459,6 +460,7 @@ async function resolveEffectivePrompt(dialog, humanPrompt) {
 }
 async function executeDriveRound(args) {
     const [dialog, humanPrompt, waitInQue, driveOptions] = args.driveArgs;
+    (0, idle_reminder_wake_1.cancelIdleReminderWake)(dialog.id, driveOptions?.reason ?? 'drive_start');
     if (!waitInQue && dialog.isLocked()) {
         throw new Error('Dialog busy driven, see how it proceeded and try again.');
     }
@@ -681,14 +683,17 @@ async function executeDriveRound(args) {
             }
             else if (!hasQueuedUpNext) {
                 const language = (0, work_language_1.getWorkLanguage)();
+                const dialogScope = dialog instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
                 const guideText = healthDecision.reason === 'caution_soft_remediation'
                     ? (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
                         kind: 'caution',
                         mode: 'soft',
+                        dialogScope,
                     })
                     : (0, driver_messages_1.formatAgentFacingContextHealthV3RemediationGuide)(language, {
                         kind: 'critical',
                         mode: 'countdown',
+                        dialogScope,
                         promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dialog.id.key()),
                         promptsTotal: context_health_1.KERNEL_DRIVER_DEFAULT_CRITICAL_COUNTDOWN_GENERATIONS,
                     });
@@ -1077,5 +1082,9 @@ async function executeDriveRound(args) {
             (0, dialog_display_state_1.clearActiveRun)(dialog.id);
         }
         release();
+        (0, idle_reminder_wake_1.maybeStartIdleReminderWake)(dialog, {
+            scheduleDrive: args.scheduleDrive,
+            driveDialog: args.driveDialog,
+        }, driveOptions?.reason ?? 'drive_finished');
     }
 }

package/dist/llm/kernel-driver/idle-reminder-wake.d.ts

@@ -0,0 +1,4 @@
+import { Dialog, DialogID } from '../../dialog';
+import type { KernelDriverDriveCallbacks } from './types';
+export declare function cancelIdleReminderWake(dialogId: DialogID, reason: string): void;
+export declare function maybeStartIdleReminderWake(dialog: Dialog, callbacks: KernelDriverDriveCallbacks, reason: string): void;