dominds 1.24.3 → 1.25.0

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/apps/runtime.js

@@ -98,9 +98,6 @@ async function resolveTargetDialog(sourceDlg, target) {
             matches.push(dialog);
         };
         pushMatch(await ensureDialogLoadedBySelfId(sourceRoot, target.dialogId));
-        for (const loadedRoot of dialog_global_registry_1.globalDialogRegistry.getAll()) {
-            pushMatch(await ensureDialogLoadedBySelfId(loadedRoot, target.dialogId));
-        }
         if (target.dialogId !== sourceRoot.id.rootId) {
             pushMatch(await ensureMainDialogLoaded(target.dialogId));
         }

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

@@ -51,7 +51,7 @@ export declare function broadcastDisplayStateMarker(dialogId: DialogID, marker:
     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

@@ -255,10 +255,12 @@ function clearActiveRun(dialogId, options) {
         return;
     }
     clearQuarantiningMainDialogIfIdle(dialogId.rootId);
-    if (dialogId.selfId === dialogId.rootId && options?.notifyBackendLoop !== false) {
+    if (options?.notifyBackendLoop !== false) {
         dialog_global_registry_1.globalDialogRegistry.notifyActiveRunCleared(dialogId.rootId, {
             source: 'dialog_display_state_active_run_clear',
-            reason: 'root_active_run_cleared',
+            reason: dialogId.selfId === dialogId.rootId
+                ? 'root_active_run_cleared'
+                : 'sideDialog_active_run_cleared',
         });
     }
     syncRunControlCountsAfterActiveRunChange('clear_active_run', dialogId);
@@ -774,7 +776,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(),
                 });
             }
@@ -803,7 +805,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;
@@ -16,7 +16,19 @@ export type DriveTriggerMeta = Readonly<{
 }>;
 declare class GlobalDialogRegistry {
     private static instance;
+    /**
+     * 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 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.
+     */
     private readonly entries;
+    private readonly queuedRootIds;
+    private readonly queuedRootIdSet;
+    private queuedRootIdReadIndex;
     private readonly lastDriveTriggerByRootId;
     private readonly driveTriggerPubChan;
     private driveTriggerSubChan;
@@ -24,16 +36,19 @@ declare class GlobalDialogRegistry {
     get(rootId: string): MainDialog | undefined;
     register(mainDialog: MainDialog): void;
     unregister(rootId: string): void;
+    private enqueueRoot;
+    private compactQueuedRootsIfNeeded;
+    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;
-    getAll(): MainDialog[];
+    consumeQueuedMainDialogs(): MainDialog[];
     get size(): number;
 }
 export declare const globalDialogRegistry: GlobalDialogRegistry;

package/dist/dialog-global-registry.js

@@ -8,7 +8,19 @@ const persistence_1 = require("./persistence");
 const log = (0, log_1.createLogger)('dialog-global-registry');
 class GlobalDialogRegistry {
     constructor() {
+        /**
+         * 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 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.
+         */
         this.entries = new Map();
+        this.queuedRootIds = [];
+        this.queuedRootIdSet = new Set();
+        this.queuedRootIdReadIndex = 0;
         this.lastDriveTriggerByRootId = new Map();
         this.driveTriggerPubChan = (0, evt_1.createPubChan)();
         this.driveTriggerSubChan = (0, evt_1.createSubChan)(this.driveTriggerPubChan);
@@ -34,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,
                 });
@@ -60,17 +72,53 @@ class GlobalDialogRegistry {
     }
     unregister(rootId) {
         this.entries.delete(rootId);
+        this.queuedRootIdSet.delete(rootId);
         this.lastDriveTriggerByRootId.delete(rootId);
         (0, dialog_1.scheduleGlobalDialogMutexCleanupForRoot)(rootId);
     }
+    enqueueRoot(rootId) {
+        if (this.queuedRootIdSet.has(rootId)) {
+            return;
+        }
+        this.queuedRootIdSet.add(rootId);
+        this.queuedRootIds.push(rootId);
+    }
+    compactQueuedRootsIfNeeded() {
+        if (this.queuedRootIdReadIndex === 0) {
+            return;
+        }
+        if (this.queuedRootIdReadIndex < 256 &&
+            this.queuedRootIdReadIndex * 2 < this.queuedRootIds.length) {
+            return;
+        }
+        this.queuedRootIds.splice(0, this.queuedRootIdReadIndex);
+        this.queuedRootIdReadIndex = 0;
+    }
+    compactSparseQueuedRootsIfNeeded() {
+        if (this.queuedRootIds.length < 512) {
+            return;
+        }
+        if (this.queuedRootIdSet.size * 2 >= this.queuedRootIds.length - this.queuedRootIdReadIndex) {
+            return;
+        }
+        const compacted = [];
+        for (let index = this.queuedRootIdReadIndex; index < this.queuedRootIds.length; index += 1) {
+            const rootId = this.queuedRootIds[index];
+            if (rootId !== undefined && this.queuedRootIdSet.has(rootId)) {
+                compacted.push(rootId);
+            }
+        }
+        this.queuedRootIds.splice(0, this.queuedRootIds.length, ...compacted);
+        this.queuedRootIdReadIndex = 0;
+    }
     publishDriveTrigger(args) {
         const trigger = {
             type: 'drive_trigger_evt',
             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(),
@@ -88,44 +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,
         });
     }
@@ -138,39 +189,57 @@ class GlobalDialogRegistry {
         if (!entry) {
             return;
         }
-        if (!entry.activeRunClearedWakePending || !entry.wakeQueued) {
-            entry.activeRunClearedWakePending = false;
+        if (!entry.activeRunClearedDrivePending) {
+            entry.activeRunClearedDrivePending = false;
             return;
         }
-        const currentWakeQueued = entry ? entry.wakeQueued : null;
-        entry.activeRunClearedWakePending = false;
+        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,
         });
     }
     noteActiveRunBlockedQueuedDrive(rootId) {
         const entry = this.entries.get(rootId);
-        if (!entry || !entry.wakeQueued) {
+        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);
     }
-    getAll() {
-        return Array.from(this.entries.values()).map((entry) => entry.mainDialog);
+    consumeQueuedMainDialogs() {
+        const queued = [];
+        while (this.queuedRootIdReadIndex < this.queuedRootIds.length) {
+            const rootId = this.queuedRootIds[this.queuedRootIdReadIndex];
+            this.queuedRootIdReadIndex += 1;
+            if (rootId === undefined || !this.queuedRootIdSet.has(rootId)) {
+                continue;
+            }
+            this.queuedRootIdSet.delete(rootId);
+            const entry = this.entries.get(rootId);
+            if (!entry) {
+                continue;
+            }
+            entry.driveQueued = false;
+            queued.push(entry.mainDialog);
+        }
+        this.compactQueuedRootsIfNeeded();
+        return queued;
     }
     get size() {
         return this.entries.size;

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);
+}