dominds 1.24.4 → 1.25.1

package/README.md

@@ -69,7 +69,7 @@ Dominds is an AI-powered DevOps framework that creates autonomous agentic teams
 
 ### Prerequisites
 
-- **Node.js (with npm bundled)**: Version 24.x LTS
+- **Node.js (with npm bundled)**: Version 24.5+ LTS
 - **npm (if used directly)**: Use the npm bundled with your installed Node.js 24 LTS; current minimum in this repo is `11.9.0`, and newer versions are allowed.
 - **LLM provider configured for your team**: Dominds ships with a built-in provider catalog [main/llm/defaults.yaml](./main/llm/defaults.yaml) including Codex (ChatGPT) and Anthropic, plus several Anthropic-compatible endpoints (e.g. MiniMax, Z.ai, BigModel). You’ll need valid credentials for at least one provider.
 - **pnpm (optional)**: Recommended only if you’re developing Dominds itself. Prefer enabling the pinned CLI once via `npm run setup:pm`. If Corepack shims cannot be enabled in your environment, install `pnpm@10` manually.
@@ -80,6 +80,53 @@ For repo development, initialize the package manager once after `nvm use --lts`:
 npm run setup:pm
 ```
 
+### Proxy Support
+
+Dominds can use Node's built-in environment proxy handling on Windows, macOS, and Linux.
+
+Default behavior:
+
+- `DOMINDS_USE_ENV_PROXY` is enabled by default.
+- When enabled, Dominds calls Node's runtime env-proxy initializer early in CLI startup.
+- Dominds does not set or clear `NODE_USE_ENV_PROXY`; leave that variable for users who intentionally want Node startup-time or child-process behavior.
+- Set `DOMINDS_USE_ENV_PROXY=0` to stop Dominds from auto-enabling env-proxy support.
+
+Supported proxy variables:
+
+- `HTTP_PROXY`
+- `HTTPS_PROXY`
+- `NO_PROXY`
+- `http_proxy`
+- `https_proxy`
+- `no_proxy`
+
+Practical guidance:
+
+- Set both `HTTP_PROXY` and `HTTPS_PROXY` when your network uses the same proxy for both schemes. Lowercase forms also work.
+- Use `NO_PROXY` for localhost, loopback, and internal domains that should bypass the proxy.
+- Values should be standard proxy URLs, for example `http://proxy.company.com:8080`.
+- If your shell already exports proxy variables, Dominds will read them too; clear unrelated proxy vars if you want a clean test environment.
+
+Examples:
+
+```bash
+# Windows PowerShell
+$env:HTTP_PROXY = "http://proxy.company.com:8080"
+$env:HTTPS_PROXY = "http://proxy.company.com:8080"
+$env:NO_PROXY = "localhost,127.0.0.1,.corp.local"
+dominds
+
+# macOS / Linux shell
+export HTTP_PROXY="http://proxy.company.com:8080"
+export HTTPS_PROXY="http://proxy.company.com:8080"
+export NO_PROXY="localhost,127.0.0.1,.corp.local"
+dominds
+
+# Disable Dominds env-proxy handling
+export DOMINDS_USE_ENV_PROXY=0
+dominds
+```
+
 ### Install Dominds
 
 ```bash

package/README.zh.md

@@ -23,7 +23,7 @@ Dominds 是一款面向开发运作（DevOps）场景的智能体框架，它将
 
 ### 环境要求
 
-- **Node.js（含 npm）**：版本 24.x LTS
+- **Node.js（含 npm）**：版本 24.5+ LTS
 - **npm（如直接使用）**：使用当前安装的 Node.js 24 LTS 自带 npm；本仓库当前最低要求为 `11.9.0`，更高版本也允许。
 - **至少一个可用的 LLM 服务提供商**：Dominds 内置提供商目录（路径：[main/llm/defaults.yaml](./main/llm/defaults.yaml)），需为其中至少一个提供商配置有效凭证（通过环境变量设置）。
 - **pnpm（可选）**：仅在开发 Dominds 本体时推荐使用。优先执行一次 `npm run setup:pm` 启用并缓存仓库固定的 pnpm；若你的环境无法启用 Corepack shim，再手动安装 `pnpm@10`。
@@ -34,6 +34,53 @@ Dominds 是一款面向开发运作（DevOps）场景的智能体框架，它将
 npm run setup:pm
 ```
 
+### 代理支持
+
+Dominds 在 Windows、macOS、Linux 上都可以使用 Node 内建的环境变量代理能力。
+
+默认行为：
+
+- `DOMINDS_USE_ENV_PROXY` 默认启用。
+- 启用后，Dominds 会在 CLI 启动早期调用 Node 的运行时环境代理初始化。
+- Dominds 不会设置或清理 `NODE_USE_ENV_PROXY`；这个变量留给确实需要 Node 启动期行为或子进程继承语义的用户自己管理。
+- 若要让 Dominds 不再自动开启环境代理支持，设置 `DOMINDS_USE_ENV_PROXY=0`。
+
+支持的代理变量：
+
+- `HTTP_PROXY`
+- `HTTPS_PROXY`
+- `NO_PROXY`
+- `http_proxy`
+- `https_proxy`
+- `no_proxy`
+
+实践建议：
+
+- 若同一网络对 HTTP/HTTPS 都走同一代理，建议 `HTTP_PROXY` 和 `HTTPS_PROXY` 一起设置。小写变量名同样有效。
+- `NO_PROXY` 用于排除 localhost、回环地址和内网域名。
+- 代理值应使用标准 URL 形式，例如 `http://proxy.company.com:8080`。
+- 如果你的 shell 已经导出了代理变量，Dominds 也会读取它们；想要干净的测试环境时，请清掉无关的代理变量。
+
+示例：
+
+```bash
+# Windows PowerShell
+$env:HTTP_PROXY = "http://proxy.company.com:8080"
+$env:HTTPS_PROXY = "http://proxy.company.com:8080"
+$env:NO_PROXY = "localhost,127.0.0.1,.corp.local"
+dominds
+
+# macOS / Linux shell
+export HTTP_PROXY="http://proxy.company.com:8080"
+export HTTPS_PROXY="http://proxy.company.com:8080"
+export NO_PROXY="localhost,127.0.0.1,.corp.local"
+dominds
+
+# 关闭 Dominds 的环境代理支持
+export DOMINDS_USE_ENV_PROXY=0
+dominds
+```
+
 ### 安装 Dominds
 
 ```bash

package/dist/cli.d.ts

@@ -28,4 +28,5 @@
  *   dominds webui
  */
 import './tools/builtins';
+export declare function configureEnvProxySupport(): void;
 export declare function main(): Promise<void>;

package/dist/cli.js

@@ -62,8 +62,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureEnvProxySupport = configureEnvProxySupport;
 exports.main = main;
 const fs = __importStar(require("fs"));
+const http = __importStar(require("node:http"));
 const path = __importStar(require("path"));
 const runtime_1 = require("./apps/runtime");
 const dotenv_1 = require("./bootstrap/dotenv");
@@ -81,6 +83,24 @@ const update_1 = require("./cli/update");
 const validate_team_def_1 = require("./cli/validate-team-def");
 const webui_1 = require("./cli/webui");
 require("./tools/builtins");
+function configureEnvProxySupport() {
+    const domindsUseEnvProxy = process.env.DOMINDS_USE_ENV_PROXY?.trim();
+    if (domindsUseEnvProxy === '0') {
+        return;
+    }
+    try {
+        const setGlobalProxyFromEnv = http.setGlobalProxyFromEnv;
+        if (typeof setGlobalProxyFromEnv !== 'function') {
+            console.error('Error: DOMINDS_USE_ENV_PROXY requires Node.js 24.5+ because http.setGlobalProxyFromEnv() is unavailable.');
+            process.exit(1);
+        }
+        setGlobalProxyFromEnv(process.env);
+    }
+    catch (err) {
+        console.error('Error: invalid proxy environment configuration:', err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
 function printHelp() {
     console.log(`
 Dominds CLI - AI-driven DevOps framework with persistent memory
@@ -163,6 +183,7 @@ async function main() {
             }
         }
         (0, dotenv_1.loadRtwsDotenv)({ cwd: process.cwd() });
+        configureEnvProxySupport();
         await runSubcommand('webui', []);
         return;
     }
@@ -214,6 +235,7 @@ async function main() {
         // Precedence: `.env` then `.env.local` (later overwrites earlier), and both
         // overwrite any existing process.env values.
         (0, dotenv_1.loadRtwsDotenv)({ cwd: process.cwd() });
+        configureEnvProxySupport();
     }
     const shouldLoadApps = subcommand !== 'webui' &&
         subcommand !== 'create' &&

package/dist/dialog-display-state.d.ts

@@ -43,15 +43,15 @@ export declare function clearMainDialogQuarantining(mainDialogId: DialogID): voi
 export declare function forceStopActiveRunsForMainDialog(mainDialogId: DialogID): Promise<void>;
 export declare function getStopRequestedReason(dialogId: DialogID): StopRequestedReason | undefined;
 export declare function loadDialogExecutionMarker(dialogId: DialogID, status?: 'running' | 'completed' | 'archived'): Promise<DialogExecutionMarker | undefined>;
-export declare function setDialogExecutionMarker(dialogId: DialogID, executionMarker: DialogExecutionMarker | undefined): Promise<void>;
-export declare function clearDialogInterruptedExecutionMarker(dialogId: DialogID): Promise<void>;
-export declare function setDialogDisplayState(dialogId: DialogID, displayState: DialogDisplayState): Promise<void>;
+export declare function setDialogExecutionMarker(dialogId: DialogID, executionMarker: DialogExecutionMarker | undefined, status?: 'running' | 'completed' | 'archived'): Promise<void>;
+export declare function clearDialogInterruptedExecutionMarker(dialogId: DialogID, status?: 'running' | 'completed' | 'archived'): Promise<void>;
+export declare function setDialogDisplayState(dialogId: DialogID, displayState: DialogDisplayState, status?: 'running' | 'completed' | 'archived'): Promise<void>;
 export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker: {
     kind: 'interrupted' | 'resumed';
     reason?: DialogInterruptionReason;
 }): void;
 export declare function computeIdleDisplayState(dlg: Dialog): Promise<DialogDisplayState>;
-export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'active_callee_dispatches_changed' | 'q4h_changed'): Promise<DialogLatestFile | null>;
+export declare function refreshRunControlProjectionFromPersistenceFacts(dialogId: DialogID, trigger: 'resume_dialog' | 'resume_all' | 'run_control_snapshot' | 'active_callee_dispatches_changed' | 'q4h_changed' | 'restart_reconciliation'): Promise<DialogLatestFile | null>;
 export declare function reconcileDisplayStatesAfterRestart(): Promise<void>;
 export declare function requestInterruptDialog(dialogId: DialogID, reason: StopRequestedReason): Promise<{
     applied: boolean;

package/dist/dialog-display-state.js

@@ -327,7 +327,7 @@ async function loadDialogExecutionMarker(dialogId, status = 'running') {
     const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
     return latest?.executionMarker;
 }
-async function setDialogExecutionMarker(dialogId, executionMarker) {
+async function setDialogExecutionMarker(dialogId, executionMarker, status = 'running') {
     if (executionMarker?.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
         log.warn('Rejecting dead executionMarker for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
@@ -338,20 +338,21 @@ async function setDialogExecutionMarker(dialogId, executionMarker) {
         await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
             kind: 'patch',
             patch: { executionMarker },
-        }));
+        }), status);
     }
     catch (err) {
         log.warn('Failed to persist dialog executionMarker', err, {
             dialogId: dialogId.valueOf(),
             rootId: dialogId.rootId,
             selfId: dialogId.selfId,
+            status,
             intendedExecutionMarker: executionMarker ?? null,
         });
     }
 }
-async function clearDialogInterruptedExecutionMarker(dialogId) {
+async function clearDialogInterruptedExecutionMarker(dialogId, status = 'running') {
     try {
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
         if (latest?.executionMarker?.kind !== 'interrupted') {
             return;
         }
@@ -359,12 +360,13 @@ async function clearDialogInterruptedExecutionMarker(dialogId) {
     catch (err) {
         log.warn('Failed to inspect executionMarker before clearing interrupted marker', err, {
             dialogId: dialogId.valueOf(),
+            status,
         });
         return;
     }
-    await setDialogExecutionMarker(dialogId, undefined);
+    await setDialogExecutionMarker(dialogId, undefined, status);
 }
-async function setDialogDisplayState(dialogId, displayState) {
+async function setDialogDisplayState(dialogId, displayState, status = 'running') {
     if (displayState.kind === 'dead' && dialogId.selfId === dialogId.rootId) {
         log.warn('Rejecting dead displayState for main dialog (main dialogs must not be dead)', undefined, {
             dialogId: dialogId.valueOf(),
@@ -376,7 +378,7 @@ async function setDialogDisplayState(dialogId, displayState) {
     // "dead" is irreversible. Once a dialog is marked dead, do not allow overwriting it with
     // another state (best-effort; races may still exist across concurrent writers).
     try {
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
         previousDisplayState = latest?.displayState;
         previousExecutionMarker = latest?.executionMarker;
         if (dialogId.selfId !== dialogId.rootId &&
@@ -400,6 +402,7 @@ async function setDialogDisplayState(dialogId, displayState) {
     catch (err) {
         log.warn('Failed to check existing displayState before setDialogDisplayState', err, {
             dialogId: dialogId.valueOf(),
+            status,
         });
     }
     const nextExecutionMarker = displayState.kind === 'stopped'
@@ -413,13 +416,14 @@ async function setDialogDisplayState(dialogId, displayState) {
         await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
             kind: 'patch',
             patch: { displayState, executionMarker: nextExecutionMarker },
-        }));
+        }), status);
     }
     catch (err) {
         log.warn('Failed to persist dialog displayState', err, {
             dialogId: dialogId.valueOf(),
             rootId: dialogId.rootId,
             selfId: dialogId.selfId,
+            status,
             intendedDisplayState: displayState,
         });
     }
@@ -776,7 +780,7 @@ async function reconcileDisplayStatesAfterRestart() {
                 }));
             }
             catch (err) {
-                log.warn('Failed to preserve proceeding dialog for auto-drive after restart', err, {
+                log.warn('Failed to preserve open-generation dialog for auto-drive after restart', err, {
                     dialogId: dialogId.valueOf(),
                 });
             }
@@ -805,7 +809,21 @@ async function reconcileDisplayStatesAfterRestart() {
                 }));
             }
             catch (err) {
-                log.warn('Failed to reconcile proceeding dialog after restart', err, {
+                log.warn('Failed to reconcile open-generation dialog after restart', err, {
+                    dialogId: dialogId.valueOf(),
+                });
+            }
+            continue;
+        }
+        if (latest.userWait?.kind === 'awaiting_user_answer' ||
+            latest.pendingRuntimePrompt !== undefined ||
+            latest.executionMarker?.kind === 'interrupted' ||
+            isNonIdleDisplayProjection(latest.displayState)) {
+            try {
+                await refreshRunControlProjectionFromPersistenceFacts(dialogId, 'restart_reconciliation');
+            }
+            catch (err) {
+                log.warn('Failed to refresh stale run-control projection after restart', err, {
                     dialogId: dialogId.valueOf(),
                 });
             }

package/dist/dialog-drive-work.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasRecoverableGenerationBeyondFinalResponse = hasRecoverableGenerationBeyondFinalResponse;
 exports.hasDurableDriveWork = hasDurableDriveWork;
 const dialog_generation_run_1 = require("./dialog-generation-run");
+// Backend drive work is a wake routing filter only. It must stay deliberately shallow: this module
+// says "some persisted continuation source may need a handler", not "the dialog has business value
+// to drive". Each concrete continuation handler must locally re-read and claim its own business
+// facts before starting or continuing a generation. Do not add generic de-dup/fingerprint/cleanup
+// policy here; that would merge unrelated business continuations into one spaghetti gate.
 function hasResultArrivalTrigger(latest) {
     return latest.nextStep.triggers.some((trigger) => trigger.kind === 'result_arrival');
 }

package/dist/dialog-global-registry.d.ts

@@ -1,11 +1,11 @@
 import { type MainDialog } from './dialog';
 export type DriveTriggerEvent = Readonly<{
     type: 'drive_trigger_evt';
-    action: 'wake_drive' | 'clear_drive_wake' | 'active_run_cleared';
+    action: 'queue_root_drive' | 'clear_root_drive_queue' | 'active_run_cleared';
     rootId: string;
     entryFound: boolean;
-    previousWakeQueued: boolean | null;
-    nextWakeQueued: boolean;
+    previousDriveQueued: boolean | null;
+    nextDriveQueued: boolean;
     source: string;
     reason: string;
     emittedAtMs: number;
@@ -20,7 +20,8 @@ declare class GlobalDialogRegistry {
      * Runtime-owned roots keyed by rootId.
      *
      * Do not add an API that enumerates this map for backend driving. A dialog becomes driveable only
-     * through an explicit business/runtime wake (`wakeDrive`, result arrival, active-run clear, etc.).
+     * through an explicit business/runtime scheduling event (`queueRootDrive`, result arrival,
+     * active-run clear, etc.).
      * Reintroducing "scan every loaded root and see what happens" makes hidden polling loops easy to
      * create and obscures the business event that should own the next action.
      */
@@ -40,12 +41,12 @@ declare class GlobalDialogRegistry {
     private compactSparseQueuedRootsIfNeeded;
     private publishDriveTrigger;
     waitForDriveTrigger(): Promise<DriveTriggerEvent>;
-    wakeDrive(rootId: string, meta?: DriveTriggerMeta): void;
-    clearDriveWake(rootId: string, meta?: DriveTriggerMeta): void;
+    queueRootDrive(rootId: string, meta?: DriveTriggerMeta): void;
+    clearRootDriveQueue(rootId: string, meta?: DriveTriggerMeta): void;
     notifyActiveRunCleared(rootId: string, meta?: DriveTriggerMeta): void;
     noteActiveRunBlockedQueuedDrive(rootId: string): void;
-    hasPendingActiveRunClearedWake(rootId: string): boolean;
-    isDriveWakeQueued(rootId: string): boolean;
+    hasPendingActiveRunClearedDrive(rootId: string): boolean;
+    isRootDriveQueued(rootId: string): boolean;
     getLastDriveTrigger(rootId: string): DriveTriggerEvent | undefined;
     consumeQueuedMainDialogs(): MainDialog[];
     get size(): number;

package/dist/dialog-global-registry.js

@@ -12,7 +12,8 @@ class GlobalDialogRegistry {
          * Runtime-owned roots keyed by rootId.
          *
          * Do not add an API that enumerates this map for backend driving. A dialog becomes driveable only
-         * through an explicit business/runtime wake (`wakeDrive`, result arrival, active-run clear, etc.).
+         * through an explicit business/runtime scheduling event (`queueRootDrive`, result arrival,
+         * active-run clear, etc.).
          * Reintroducing "scan every loaded root and see what happens" makes hidden polling loops easy to
          * create and obscures the business event that should own the next action.
          */
@@ -45,24 +46,24 @@ class GlobalDialogRegistry {
         }
         this.entries.set(mainDialog.id.rootId, {
             mainDialog,
-            wakeQueued: false,
-            activeRunClearedWakePending: false,
+            driveQueued: false,
+            activeRunClearedDrivePending: false,
         });
         void (async () => {
             try {
                 const hasPendingNextStepTriggers = await persistence_1.DialogPersistence.hasPendingNextStepTriggers(mainDialog.id);
-                const watchedDialogIds = await persistence_1.DialogPersistence.loadDriveWatchedDialogIds(mainDialog.id);
-                if (hasPendingNextStepTriggers || watchedDialogIds.length > 0) {
-                    this.wakeDrive(mainDialog.id.rootId, {
+                const wakeQueueEntries = await persistence_1.DialogPersistence.loadWakeQueueEntries(mainDialog.id);
+                if (hasPendingNextStepTriggers || wakeQueueEntries.length > 0) {
+                    this.queueRootDrive(mainDialog.id.rootId, {
                         source: 'dialog_registry_hydration',
                         reason: hasPendingNextStepTriggers
                             ? 'persisted_next_step_triggers'
-                            : 'persisted_drive_watch',
+                            : 'persisted_wake_queue',
                     });
                 }
             }
             catch (error) {
-                log.warn('Failed to hydrate persisted drive wake for registered main dialog', error, {
+                log.warn('Failed to hydrate persisted root drive queue for registered main dialog', error, {
                     rootId: mainDialog.id.rootId,
                     selfId: mainDialog.id.selfId,
                 });
@@ -116,8 +117,8 @@ class GlobalDialogRegistry {
             action: args.action,
             rootId: args.rootId,
             entryFound: args.entryFound,
-            previousWakeQueued: args.previousWakeQueued,
-            nextWakeQueued: args.nextWakeQueued,
+            previousDriveQueued: args.previousDriveQueued,
+            nextDriveQueued: args.nextDriveQueued,
             source: args.meta.source,
             reason: args.meta.reason,
             emittedAtMs: Date.now(),
@@ -135,47 +136,47 @@ class GlobalDialogRegistry {
             this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
         }
     }
-    wakeDrive(rootId, meta) {
+    queueRootDrive(rootId, meta) {
         const triggerMeta = meta ?? {
             source: 'unknown',
             reason: 'unspecified',
         };
         const entry = this.entries.get(rootId);
-        const previousWakeQueued = entry ? entry.wakeQueued : null;
+        const previousDriveQueued = entry ? entry.driveQueued : null;
         if (entry) {
-            entry.wakeQueued = true;
-            // A fresh queueing trigger supersedes any earlier "wake me once active run clears" debt.
-            entry.activeRunClearedWakePending = false;
+            entry.driveQueued = true;
+            // A fresh root drive queueing supersedes any earlier "drive once active run clears" debt.
+            entry.activeRunClearedDrivePending = false;
             this.enqueueRoot(rootId);
         }
         this.publishDriveTrigger({
-            action: 'wake_drive',
+            action: 'queue_root_drive',
             rootId,
             entryFound: entry !== undefined,
-            previousWakeQueued,
-            nextWakeQueued: true,
+            previousDriveQueued,
+            nextDriveQueued: true,
             meta: triggerMeta,
         });
     }
-    clearDriveWake(rootId, meta) {
+    clearRootDriveQueue(rootId, meta) {
         const triggerMeta = meta ?? {
             source: 'unknown',
             reason: 'unspecified',
         };
         const entry = this.entries.get(rootId);
-        const previousWakeQueued = entry ? entry.wakeQueued : null;
+        const previousDriveQueued = entry ? entry.driveQueued : null;
         if (entry) {
-            entry.wakeQueued = false;
-            entry.activeRunClearedWakePending = false;
+            entry.driveQueued = false;
+            entry.activeRunClearedDrivePending = false;
             this.queuedRootIdSet.delete(rootId);
             this.compactSparseQueuedRootsIfNeeded();
         }
         this.publishDriveTrigger({
-            action: 'clear_drive_wake',
+            action: 'clear_root_drive_queue',
             rootId,
             entryFound: entry !== undefined,
-            previousWakeQueued,
-            nextWakeQueued: false,
+            previousDriveQueued,
+            nextDriveQueued: false,
             meta: triggerMeta,
         });
     }
@@ -188,20 +189,20 @@ class GlobalDialogRegistry {
         if (!entry) {
             return;
         }
-        if (!entry.activeRunClearedWakePending) {
-            entry.activeRunClearedWakePending = false;
+        if (!entry.activeRunClearedDrivePending) {
+            entry.activeRunClearedDrivePending = false;
             return;
         }
-        const currentWakeQueued = entry.wakeQueued;
-        entry.activeRunClearedWakePending = false;
-        entry.wakeQueued = true;
+        const currentDriveQueued = entry.driveQueued;
+        entry.activeRunClearedDrivePending = false;
+        entry.driveQueued = true;
         this.enqueueRoot(rootId);
         this.publishDriveTrigger({
             action: 'active_run_cleared',
             rootId,
             entryFound: true,
-            previousWakeQueued: currentWakeQueued,
-            nextWakeQueued: entry.wakeQueued,
+            previousDriveQueued: currentDriveQueued,
+            nextDriveQueued: entry.driveQueued,
             meta: triggerMeta,
         });
     }
@@ -210,13 +211,13 @@ class GlobalDialogRegistry {
         if (!entry) {
             return;
         }
-        entry.activeRunClearedWakePending = true;
+        entry.activeRunClearedDrivePending = true;
     }
-    hasPendingActiveRunClearedWake(rootId) {
-        return this.entries.get(rootId)?.activeRunClearedWakePending === true;
+    hasPendingActiveRunClearedDrive(rootId) {
+        return this.entries.get(rootId)?.activeRunClearedDrivePending === true;
     }
-    isDriveWakeQueued(rootId) {
-        return this.entries.get(rootId)?.wakeQueued === true;
+    isRootDriveQueued(rootId) {
+        return this.entries.get(rootId)?.driveQueued === true;
     }
     getLastDriveTrigger(rootId) {
         return this.lastDriveTriggerByRootId.get(rootId);
@@ -234,7 +235,7 @@ class GlobalDialogRegistry {
             if (!entry) {
                 continue;
             }
-            entry.wakeQueued = false;
+            entry.driveQueued = false;
             queued.push(entry.mainDialog);
         }
         this.compactQueuedRootsIfNeeded();

package/dist/dialog-instance-registry.js

@@ -35,6 +35,13 @@ async function resolvePendingRuntimePromptForRestore(args) {
     if (alreadyPersisted) {
         if (args.status === 'running') {
             await persistence_1.DialogPersistence.clearPendingRuntimePrompt(args.dialogId, pending.msgId, args.status);
+            const latestAfterClear = await persistence_1.DialogPersistence.loadDialogLatest(args.dialogId, args.status);
+            if (latestAfterClear) {
+                await persistence_1.DialogPersistence.syncWakeQueueForDialogLatest(args.dialogId, latestAfterClear, args.status);
+            }
+            else {
+                await persistence_1.DialogPersistence.removeWakeQueueEntriesForDialog(args.dialogId, args.status);
+            }
         }
         return { pendingRuntimePrompt: undefined };
     }

package/dist/dialog-interruption.d.ts

@@ -1,4 +1,5 @@
 import type { DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
+import type { DialogExecutionMarker } from '@longrun-ai/kernel/types/storage';
 /**
  * Decides whether a finalized stopped dialog should expose manual Continue.
  *
@@ -17,3 +18,4 @@ import type { DialogInterruptionReason } from '@longrun-ai/kernel/types/display-
  */
 export declare function isInterruptionReasonManualResumeEligible(reason: DialogInterruptionReason): boolean;
 export declare function doesInterruptionReasonRequireExplicitResume(reason: DialogInterruptionReason): boolean;
+export declare function isInterruptedDialogBlockedWithoutExplicitResume(marker: DialogExecutionMarker | undefined, explicitResumeAuthorized: boolean): boolean;

package/dist/dialog-interruption.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isInterruptionReasonManualResumeEligible = isInterruptionReasonManualResumeEligible;
 exports.doesInterruptionReasonRequireExplicitResume = doesInterruptionReasonRequireExplicitResume;
+exports.isInterruptedDialogBlockedWithoutExplicitResume = isInterruptedDialogBlockedWithoutExplicitResume;
 /**
  * Decides whether a finalized stopped dialog should expose manual Continue.
  *
@@ -53,3 +54,8 @@ function doesInterruptionReasonRequireExplicitResume(reason) {
         }
     }
 }
+function isInterruptedDialogBlockedWithoutExplicitResume(marker, explicitResumeAuthorized) {
+    return (marker?.kind === 'interrupted' &&
+        doesInterruptionReasonRequireExplicitResume(marker.reason) &&
+        !explicitResumeAuthorized);
+}

package/dist/dialog.d.ts

@@ -19,6 +19,7 @@ import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { ActiveCalleesFile, CalleeCourseNumber, CalleeGenerationSeqNumber, CallSiteCourseNo, CallSiteGenseqNo, DialogAskerStackState, DialogLatestFile, DialogMetadataFile, DialogNextStepTrigger, HumanQuestion, ProviderData, ReasoningPayload, TellaskCallRecordName, TellaskReplyDirective } from '@longrun-ai/kernel/types/storage';
 import { ChatMessage, FuncResultMsg, TellaskCarryoverMsg, TellaskResultMsg } from './llm/client';
 import type { ToolResultImageIngest, UserImageIngest } from './llm/gen';
+import { type SharedReminderTarget } from './shared-reminders';
 import type { JsonValue } from './tool';
 import { Reminder, ReminderOptions, ReminderOwner } from './tool';
 export declare class InvalidReminderIndexError extends Error {
@@ -105,10 +106,10 @@ export type VisibleReminderTarget = Readonly<{
     index: number;
     reminder: Reminder;
 }> | Readonly<{
-    source: 'agent_shared';
+    source: 'runtime';
     index: number;
     reminder: Reminder;
-    agentId: string;
+    target: SharedReminderTarget;
 }>;
 /**
  * Assignment from askerDialog for sideDialogs
@@ -150,7 +151,7 @@ export declare abstract class Dialog {
     protected _lastUserLanguageCode: LanguageCode;
     protected _lastContextHealth?: ContextHealthSnapshot;
     protected _lastContextHealthGenseq?: number;
-    protected _upNextQueue: DialogQueuedPromptState[];
+    protected _queuedPrompts: DialogQueuedPromptState[];
     protected _driveIntents: DriveIntent[];
     protected _activeRunControlSpec?: DialogRunControlSpec;
     protected _newCourseHook?: NewCourseHook;
@@ -239,7 +240,6 @@ export declare abstract class Dialog {
     }>;
     get activeCalleeDialogIds(): ReadonlyArray<DialogID>;
     addActiveCalleeDialogs(ids: DialogID[]): void;
-    removeActiveCalleeDispatch(id: DialogID): void;
     clearActiveCalleeDialogs(): void;
     /**
      * Load active callee dispatches from persistence into memory.
@@ -327,7 +327,7 @@ export declare abstract class Dialog {
     private setPendingRuntimePrompt;
     private mergePromptQ4HAnswerCallId;
     private enqueueQueuedPromptState;
-    private peekLatestUpNext;
+    private peekLatestQueuedPrompt;
     queueUserPromptAtGenerationBoundary(options: {
         prompt: string;
         contentItems?: DialogQueuedUserGenerationBoundaryState['contentItems'];
@@ -372,9 +372,9 @@ export declare abstract class Dialog {
         skipTaskdoc?: boolean;
         calleeDialogReplyTarget: DialogCalleeReplyTarget;
     }): Promise<DialogQueuedPromptState>;
-    hasUpNext(): boolean;
-    peekUpNext(): DialogQueuedPromptState | undefined;
-    takeUpNext(): DialogQueuedPromptState | undefined;
+    hasQueuedPrompt(): boolean;
+    peekQueuedPrompt(): DialogQueuedPromptState | undefined;
+    takeQueuedPrompt(): DialogQueuedPromptState | undefined;
     setActiveRunControlSpec(spec?: DialogRunControlSpec): void;
     getActiveRunControlSpec(): DialogRunControlSpec | undefined;
     setNewCourseHook(hook?: NewCourseHook): void;
@@ -392,7 +392,7 @@ export declare abstract class Dialog {
         reason?: string;
         skipRunControlHook?: boolean;
         skipEnqueueIntent?: boolean;
-    }): Promise<void>;
+    }): Promise<DialogRuntimePrompt>;
     receiveFuncResult(result: FuncResultMsg): Promise<void>;
     receiveTellaskResult(result: TellaskResultMsg): Promise<void>;
     receiveTellaskCarryover(result: TellaskCarryoverMsg): Promise<void>;