dominds 1.16.1 → 1.16.2

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

@@ -35,6 +35,10 @@ export declare function hasActiveRun(dialogId: DialogID): boolean;
 export declare function getActiveRunSignal(dialogId: DialogID): AbortSignal | undefined;
 export declare function createActiveRun(dialogId: DialogID): AbortSignal;
 export declare function clearActiveRun(dialogId: DialogID): void;
+export declare function clearRootDialogQuarantiningIfIdle(rootDialogId: DialogID): void;
+export declare function markRootDialogQuarantining(rootDialogId: DialogID): void;
+export declare function clearRootDialogQuarantining(rootDialogId: DialogID): void;
+export declare function forceStopActiveRunsForRootDialog(rootDialogId: 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>;

package/dist/dialog-display-state.js

@@ -28,6 +28,10 @@ exports.hasActiveRun = hasActiveRun;
 exports.getActiveRunSignal = getActiveRunSignal;
 exports.createActiveRun = createActiveRun;
 exports.clearActiveRun = clearActiveRun;
+exports.clearRootDialogQuarantiningIfIdle = clearRootDialogQuarantiningIfIdle;
+exports.markRootDialogQuarantining = markRootDialogQuarantining;
+exports.clearRootDialogQuarantining = clearRootDialogQuarantining;
+exports.forceStopActiveRunsForRootDialog = forceStopActiveRunsForRootDialog;
 exports.getStopRequestedReason = getStopRequestedReason;
 exports.loadDialogExecutionMarker = loadDialogExecutionMarker;
 exports.setDialogExecutionMarker = setDialogExecutionMarker;
@@ -40,12 +44,15 @@ exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
 const time_1 = require("@longrun-ai/kernel/utils/time");
 const dialog_1 = require("./dialog");
+const dialog_interruption_1 = require("./dialog-interruption");
 const evt_registry_1 = require("./evt-registry");
 const log_1 = require("./log");
 const persistence_1 = require("./persistence");
+const persistence_errors_1 = require("./persistence-errors");
 const log = (0, log_1.createLogger)('dialog-display-state');
 let broadcastToClients;
 const activeRunsByDialogKey = new Map();
+const quarantiningRootDialogIds = new Set();
 function setDisplayStateBroadcaster(fn) {
     broadcastToClients = fn;
 }
@@ -63,7 +70,7 @@ function syncRunControlCountsAfterActiveRunChange(trigger, dialogId) {
     })();
 }
 function isStoppedReasonResumable(reason) {
-    return reason.kind !== 'llm_retry_stopped';
+    return (0, dialog_interruption_1.isInterruptionReasonManualResumeEligible)(reason);
 }
 function isDisplayStateResumable(state) {
     return state?.kind === 'stopped' && state.continueEnabled;
@@ -93,27 +100,49 @@ function shouldBroadcastRunControlCounts(previous, next) {
 async function getRunControlCountsSnapshot() {
     let proceeding = 0;
     let resumable = 0;
-    const activeRunDialogKeys = new Set(activeRunsByDialogKey.keys());
+    const activeRunKeysByDialogKey = new Map(activeRunsByDialogKey.entries());
     const seenDialogKeys = new Set();
     const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
     for (const dialogId of dialogIds) {
-        const dialogKey = dialogId.key();
-        seenDialogKeys.add(dialogKey);
-        // Active in-memory drives are authoritative for "proceeding". This avoids transient
-        // under-count windows when displayState persistence lags behind an already started drive.
-        if (activeRunDialogKeys.has(dialogKey)) {
-            proceeding++;
+        try {
+            const dialogKey = dialogId.key();
+            seenDialogKeys.add(dialogKey);
+            if (quarantiningRootDialogIds.has(dialogId.rootId)) {
+                continue;
+            }
+            // listAllDialogIds() is intentionally a candidate scan. Per-dialog latest reads below may
+            // still quarantine one malformed dialog without invalidating the rest of the snapshot.
+            const activeRun = activeRunKeysByDialogKey.get(dialogKey);
+            if (activeRun) {
+                proceeding++;
+                continue;
+            }
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+            if (latest?.generating === true) {
+                proceeding++;
+            }
+            else if (isDialogLatestResumable(latest)) {
+                resumable++;
+            }
+        }
+        catch (error) {
+            if (!(0, persistence_errors_1.findDomindsPersistenceFileError)(error)) {
+                throw error;
+            }
+            log.warn('Skipping malformed dialog during run-control snapshot rebuild', error, {
+                dialogId: dialogId.valueOf(),
+            });
             continue;
         }
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
-        if (latest?.generating === true) {
-            proceeding++;
+    }
+    for (const [dialogKey, activeRun] of activeRunKeysByDialogKey.entries()) {
+        if (!activeRun) {
+            continue;
         }
-        else if (isDialogLatestResumable(latest)) {
-            resumable++;
+        const [rootId] = dialogKey.includes('#') ? dialogKey.split('#') : [dialogKey];
+        if (!rootId || quarantiningRootDialogIds.has(rootId)) {
+            continue;
         }
-    }
-    for (const dialogKey of activeRunDialogKeys) {
         if (!seenDialogKeys.has(dialogKey)) {
             proceeding++;
         }
@@ -151,10 +180,68 @@ function createActiveRun(dialogId) {
 }
 function clearActiveRun(dialogId) {
     const deleted = activeRunsByDialogKey.delete(dialogId.key());
-    if (!deleted)
+    if (!deleted) {
+        clearQuarantiningRootDialogIfIdle(dialogId.rootId);
         return;
+    }
+    clearQuarantiningRootDialogIfIdle(dialogId.rootId);
     syncRunControlCountsAfterActiveRunChange('clear_active_run', dialogId);
 }
+function clearQuarantiningRootDialogIfIdle(rootId) {
+    for (const key of activeRunsByDialogKey.keys()) {
+        const [candidateRootId] = key.includes('#') ? key.split('#') : [key];
+        if (candidateRootId === rootId) {
+            return;
+        }
+    }
+    quarantiningRootDialogIds.delete(rootId);
+}
+function clearRootDialogQuarantiningIfIdle(rootDialogId) {
+    clearQuarantiningRootDialogIfIdle(rootDialogId.selfId);
+}
+function markRootDialogQuarantining(rootDialogId) {
+    quarantiningRootDialogIds.add(rootDialogId.selfId);
+}
+function clearRootDialogQuarantining(rootDialogId) {
+    quarantiningRootDialogIds.delete(rootDialogId.selfId);
+}
+async function forceStopActiveRunsForRootDialog(rootDialogId) {
+    for (const key of Array.from(activeRunsByDialogKey.keys())) {
+        const [rootId, selfId] = key.includes('#') ? key.split('#') : [key, key];
+        if (!rootId || !selfId)
+            continue;
+        if (rootId !== rootDialogId.selfId)
+            continue;
+        const dialogId = new dialog_1.DialogID(selfId, rootId);
+        const run = activeRunsByDialogKey.get(key);
+        if (!run)
+            continue;
+        if (!run.stopRequested) {
+            run.stopRequested = 'emergency_stop';
+            try {
+                await setDialogDisplayState(dialogId, {
+                    kind: 'proceeding_stop_requested',
+                    reason: 'emergency_stop',
+                });
+            }
+            catch (error) {
+                log.warn('Failed to persist stop-requested state while forcing root dialog stop', error, {
+                    dialogId: dialogId.valueOf(),
+                    rootDialogId: rootDialogId.valueOf(),
+                });
+            }
+        }
+        try {
+            run.abortController.abort();
+        }
+        catch (error) {
+            log.warn('Failed to abort active run while forcing root dialog stop', error, {
+                dialogId: dialogId.valueOf(),
+                rootDialogId: rootDialogId.valueOf(),
+            });
+        }
+    }
+}
 function getStopRequestedReason(dialogId) {
     return activeRunsByDialogKey.get(dialogId.key())?.stopRequested;
 }
@@ -350,10 +437,36 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
     }
     return { kind: 'idle_waiting_user' };
 }
+async function computeIdleDisplayStateForReconciliation(dialogId) {
+    try {
+        return await computeIdleDisplayStateFromPersistence(dialogId);
+    }
+    catch (error) {
+        if (!(0, persistence_errors_1.findDomindsPersistenceFileError)(error)) {
+            throw error;
+        }
+        log.warn('Skipping malformed dialog during display-state idle reconstruction', error, {
+            dialogId: dialogId.valueOf(),
+        });
+        return null;
+    }
+}
 async function reconcileDisplayStatesAfterRestart() {
     const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
     for (const dialogId of dialogIds) {
-        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+        let latest;
+        try {
+            latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+        }
+        catch (error) {
+            if (!(0, persistence_errors_1.findDomindsPersistenceFileError)(error)) {
+                throw error;
+            }
+            log.warn('Skipping malformed dialog during display-state restart reconciliation', error, {
+                dialogId: dialogId.valueOf(),
+            });
+            continue;
+        }
         const existing = latest?.displayState;
         const existingMarker = latest?.executionMarker;
         if (existingMarker && existingMarker.kind === 'dead' && dialogId.selfId !== dialogId.rootId) {
@@ -380,7 +493,10 @@ async function reconcileDisplayStatesAfterRestart() {
             (existing !== undefined &&
                 (existing.kind === 'proceeding' || existing.kind === 'proceeding_stop_requested'));
         if (wasProceeding) {
-            const nextIdle = await computeIdleDisplayStateFromPersistence(dialogId);
+            const nextIdle = await computeIdleDisplayStateForReconciliation(dialogId);
+            if (!nextIdle) {
+                continue;
+            }
             const next = nextIdle.kind === 'blocked'
                 ? nextIdle
                 : {
@@ -406,7 +522,10 @@ async function reconcileDisplayStatesAfterRestart() {
             continue;
         }
         if (!existing) {
-            const inferred = await computeIdleDisplayStateFromPersistence(dialogId);
+            const inferred = await computeIdleDisplayStateForReconciliation(dialogId);
+            if (!inferred) {
+                continue;
+            }
             try {
                 await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
                     kind: 'patch',

package/dist/dialog-fork.js

@@ -473,21 +473,29 @@ async function appendForkBaselineState(plan, baselineSubdialogCreatedRecords) {
 }
 async function persistForkPlan(args) {
     const { plan } = args;
-    let rewrittenMetadata;
     if (plan.targetId.selfId === plan.targetId.rootId) {
-        rewrittenMetadata = {
-            ...plan.metadata,
+        if (plan.metadata.supdialogId !== undefined ||
+            plan.metadata.sessionSlug !== undefined ||
+            plan.metadata.assignmentFromSup !== undefined) {
+            throw new Error(`fork root plan received subdialog metadata: ${plan.targetId.valueOf()}`);
+        }
+        const rewrittenMetadata = {
             id: plan.targetId.selfId,
+            agentId: plan.metadata.agentId,
+            taskDocPath: plan.metadata.taskDocPath,
             createdAt: args.now,
+            ...(plan.metadata.priming ? { priming: plan.metadata.priming } : {}),
         };
+        await persistence_1.DialogPersistence.saveRootDialogMetadata(plan.targetId, rewrittenMetadata, 'running');
     }
     else {
         if (plan.metadata.supdialogId === undefined) {
             throw new Error(`fork subdialog plan missing supdialog metadata: ${plan.targetId.valueOf()}`);
         }
-        rewrittenMetadata = rewriteSubdialogMetadataForFork(plan.metadata, plan.sourceId.rootId, plan.targetId.rootId);
+        const rewrittenMetadata = rewriteSubdialogMetadataForFork(plan.metadata, plan.sourceId.rootId, plan.targetId.rootId);
+        await persistence_1.DialogPersistence.ensureSubdialogDirectory(plan.targetId, 'running');
+        await persistence_1.DialogPersistence.saveSubdialogMetadata(plan.targetId, rewrittenMetadata, 'running');
     }
-    await persistence_1.DialogPersistence.saveDialogMetadata(plan.targetId, rewrittenMetadata, 'running');
     for (const course of plan.retainedCourses) {
         for (const event of course.events) {
             await persistence_1.DialogPersistence.appendEvent(plan.targetId, course.course, rewriteRecordForFork(event, plan.targetId.rootId), 'running');

package/dist/dialog-interruption.d.ts

@@ -0,0 +1,18 @@
+import type { DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
+/**
+ * Decides whether a finalized stopped dialog should expose manual Continue.
+ *
+ * This only applies to the persisted/broadcast final stopped state after the driver has fully
+ * unwound and confirmed an interrupted terminal projection. Transient interruption markers and
+ * retry-stop progress events must stay disabled until that final stopped state is written. Do not
+ * "simplify" this by enabling Continue earlier: that would let the UI offer a resume action before
+ * the dialog is actually resumable again, reintroducing exactly the class of race/false-positive
+ * bugs this split is here to prevent.
+ *
+ * `llm_retry_stopped` is intentionally resumable here:
+ * - manual Continue starts a fresh drive invocation, which naturally resets per-run retry state
+ *   and provider-quirk tracking state;
+ * - it does NOT reset process-wide adaptive smart-rate backoff, which is shared by
+ *   provider/model and should keep protecting the system.
+ */
+export declare function isInterruptionReasonManualResumeEligible(reason: DialogInterruptionReason): boolean;

package/dist/dialog-interruption.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInterruptionReasonManualResumeEligible = isInterruptionReasonManualResumeEligible;
+/**
+ * Decides whether a finalized stopped dialog should expose manual Continue.
+ *
+ * This only applies to the persisted/broadcast final stopped state after the driver has fully
+ * unwound and confirmed an interrupted terminal projection. Transient interruption markers and
+ * retry-stop progress events must stay disabled until that final stopped state is written. Do not
+ * "simplify" this by enabling Continue earlier: that would let the UI offer a resume action before
+ * the dialog is actually resumable again, reintroducing exactly the class of race/false-positive
+ * bugs this split is here to prevent.
+ *
+ * `llm_retry_stopped` is intentionally resumable here:
+ * - manual Continue starts a fresh drive invocation, which naturally resets per-run retry state
+ *   and provider-quirk tracking state;
+ * - it does NOT reset process-wide adaptive smart-rate backoff, which is shared by
+ *   provider/model and should keep protecting the system.
+ */
+function isInterruptionReasonManualResumeEligible(reason) {
+    switch (reason.kind) {
+        case 'user_stop':
+        case 'emergency_stop':
+        case 'server_restart':
+        case 'fork_continue_ready':
+        case 'system_stop':
+        case 'llm_retry_stopped':
+            return true;
+        default: {
+            const _exhaustive = reason;
+            return _exhaustive;
+        }
+    }
+}