dominds 0.1.0

package/dist/dialog-global-registry.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalDialogRegistry = void 0;
+const persistence_1 = require("./persistence");
+class GlobalDialogRegistry {
+    constructor() {
+        this.entries = new Map();
+    }
+    static getInstance() {
+        if (!GlobalDialogRegistry.instance) {
+            GlobalDialogRegistry.instance = new GlobalDialogRegistry();
+        }
+        return GlobalDialogRegistry.instance;
+    }
+    get(rootId) {
+        return this.entries.get(rootId)?.rootDialog;
+    }
+    register(rootDialog) {
+        // This registry is keyed by the *tree root id*.
+        // Only the canonical root dialog (selfId === rootId) should be stored here.
+        if (rootDialog.id.selfId !== rootDialog.id.rootId) {
+            return;
+        }
+        const existing = this.entries.get(rootDialog.id.rootId);
+        if (existing) {
+            return;
+        }
+        this.entries.set(rootDialog.id.rootId, { rootDialog, needsDrive: false });
+        void (async () => {
+            try {
+                const needsDrive = await persistence_1.DialogPersistence.getNeedsDrive(rootDialog.id);
+                if (needsDrive) {
+                    this.markNeedsDrive(rootDialog.id.rootId);
+                }
+            }
+            catch {
+                // Best-effort hydration; backend driver will still function for runtime-triggered drives.
+            }
+        })();
+    }
+    unregister(rootId) {
+        this.entries.delete(rootId);
+    }
+    markNeedsDrive(rootId) {
+        const entry = this.entries.get(rootId);
+        if (entry) {
+            entry.needsDrive = true;
+        }
+    }
+    markNotNeedingDrive(rootId) {
+        const entry = this.entries.get(rootId);
+        if (entry) {
+            entry.needsDrive = false;
+        }
+    }
+    getDialogsNeedingDrive() {
+        return Array.from(this.entries.values())
+            .filter((entry) => entry.needsDrive)
+            .map((entry) => entry.rootDialog);
+    }
+    getAll() {
+        return Array.from(this.entries.values()).map((entry) => entry.rootDialog);
+    }
+    get size() {
+        return this.entries.size;
+    }
+}
+exports.globalDialogRegistry = GlobalDialogRegistry.getInstance();

package/dist/dialog-instance-registry.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrRestoreRootDialog = getOrRestoreRootDialog;
+exports.ensureDialogLoaded = ensureDialogLoaded;
+const dialog_1 = require("./dialog");
+const dialog_global_registry_1 = require("./dialog-global-registry");
+const persistence_1 = require("./persistence");
+async function getOrRestoreRootDialog(rootId, status) {
+    const existing = dialog_global_registry_1.globalDialogRegistry.get(rootId);
+    if (existing) {
+        existing.setPersistenceStatus(status);
+        await existing.loadSubdialogRegistry();
+        await existing.loadPendingSubdialogsFromPersistence();
+        return existing;
+    }
+    const rootDialogId = new dialog_1.DialogID(rootId);
+    const rootState = await persistence_1.DialogPersistence.restoreDialog(rootDialogId, status);
+    if (!rootState)
+        return undefined;
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialogId, status);
+    const rootStore = new persistence_1.DiskFileDialogStore(rootDialogId);
+    const rootDialog = new dialog_1.RootDialog(rootStore, rootState.metadata.taskDocPath, rootDialogId, rootState.metadata.agentId, {
+        messages: rootState.messages,
+        reminders: rootState.reminders,
+        currentRound: rootState.currentRound,
+        contextHealth: rootState.contextHealth,
+    });
+    rootDialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
+    rootDialog.setPersistenceStatus(status);
+    dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+    // Keep the in-memory root dialog fully hydrated regardless of persistence status
+    // (running/completed/archived) so subdialog lookup is stable across UI navigation.
+    await rootDialog.loadSubdialogRegistry();
+    await rootDialog.loadPendingSubdialogsFromPersistence();
+    return rootDialog;
+}
+async function ensureDialogLoaded(rootDialog, targetId, status, visitedSelfIds = new Set()) {
+    if (targetId.selfId === targetId.rootId)
+        return rootDialog;
+    const existing = rootDialog.lookupDialog(targetId.selfId);
+    if (existing)
+        return existing;
+    if (visitedSelfIds.has(targetId.selfId))
+        return undefined;
+    visitedSelfIds.add(targetId.selfId);
+    const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(targetId, status);
+    if (!metadata)
+        return undefined;
+    // Ensure parent dialog (supdialog) exists in root registry for SubDialog.supdialog resolution.
+    if (metadata.supdialogId && metadata.supdialogId !== targetId.rootId) {
+        await ensureDialogLoaded(rootDialog, new dialog_1.DialogID(metadata.supdialogId, targetId.rootId), status, visitedSelfIds);
+    }
+    const state = await persistence_1.DialogPersistence.restoreDialog(targetId, status);
+    if (!state)
+        return undefined;
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(targetId, status);
+    const assignmentFromSup = state.metadata.assignmentFromSup;
+    if (!assignmentFromSup)
+        return undefined;
+    // Ensure the caller dialog exists so SubDialog can resolve its effective supdialog.
+    if (assignmentFromSup.callerDialogId &&
+        assignmentFromSup.callerDialogId !== targetId.rootId &&
+        assignmentFromSup.callerDialogId !== targetId.selfId) {
+        await ensureDialogLoaded(rootDialog, new dialog_1.DialogID(assignmentFromSup.callerDialogId, targetId.rootId), status, visitedSelfIds);
+    }
+    const store = new persistence_1.DiskFileDialogStore(targetId);
+    const subdialog = new dialog_1.SubDialog(store, rootDialog, state.metadata.taskDocPath, targetId, state.metadata.agentId, assignmentFromSup, state.metadata.tellaskSession, {
+        messages: state.messages,
+        reminders: state.reminders,
+        currentRound: state.currentRound,
+        contextHealth: state.contextHealth,
+    });
+    subdialog.disableDiligencePush = latest?.disableDiligencePush ?? false;
+    if (subdialog.tellaskSession) {
+        rootDialog.registerSubdialog(subdialog);
+    }
+    return subdialog;
+}

package/dist/dialog-run-state.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * Module: dialog-run-state
+ *
+ * Owns the authoritative proceeding/idle/interrupted/blocked/terminal state for dialogs,
+ * plus best-effort cancellation for in-flight dialog drives.
+ *
+ * Design constraints:
+ * - State is persisted to latest.yaml (`DialogLatestFile.runState`) so it survives restarts.
+ * - "Stop" is best-effort: it aborts in-flight LLM streaming and lets the driver unwind.
+ * - Broadcasting is optional: when configured, run-state updates are pushed to all WS clients
+ *   so multi-tab views converge without polling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRunStateBroadcaster = setRunStateBroadcaster;
+exports.hasActiveRun = hasActiveRun;
+exports.getActiveRunSignal = getActiveRunSignal;
+exports.createActiveRun = createActiveRun;
+exports.clearActiveRun = clearActiveRun;
+exports.getStopRequestedReason = getStopRequestedReason;
+exports.setDialogRunState = setDialogRunState;
+exports.broadcastRunStateMarker = broadcastRunStateMarker;
+exports.computeIdleRunState = computeIdleRunState;
+exports.reconcileRunStatesAfterRestart = reconcileRunStatesAfterRestart;
+exports.requestInterruptDialog = requestInterruptDialog;
+exports.requestEmergencyStopAll = requestEmergencyStopAll;
+const dialog_1 = require("./dialog");
+const evt_registry_1 = require("./evt-registry");
+const log_1 = require("./log");
+const persistence_1 = require("./persistence");
+const log = (0, log_1.createLogger)('dialog-run-state');
+let broadcastToClients;
+const activeRunsByDialogKey = new Map();
+function setRunStateBroadcaster(fn) {
+    broadcastToClients = fn;
+}
+function hasActiveRun(dialogId) {
+    return activeRunsByDialogKey.has(dialogId.key());
+}
+function getActiveRunSignal(dialogId) {
+    const run = activeRunsByDialogKey.get(dialogId.key());
+    return run?.abortController.signal;
+}
+function createActiveRun(dialogId) {
+    const key = dialogId.key();
+    const existing = activeRunsByDialogKey.get(key);
+    if (existing) {
+        return existing.abortController.signal;
+    }
+    const run = { abortController: new AbortController() };
+    activeRunsByDialogKey.set(key, run);
+    return run.abortController.signal;
+}
+function clearActiveRun(dialogId) {
+    activeRunsByDialogKey.delete(dialogId.key());
+}
+function getStopRequestedReason(dialogId) {
+    return activeRunsByDialogKey.get(dialogId.key())?.stopRequested;
+}
+async function setDialogRunState(dialogId, runState) {
+    try {
+        await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
+            kind: 'patch',
+            patch: { runState },
+        }));
+    }
+    catch (err) {
+        log.warn('Failed to persist dialog runState', err, { dialogId: dialogId.valueOf() });
+    }
+    const typed = evt_registry_1.dialogEventRegistry.createTypedEvent(dialogId, {
+        type: 'dlg_run_state_evt',
+        runState,
+    });
+    if (broadcastToClients) {
+        broadcastToClients(typed);
+    }
+}
+function broadcastRunStateMarker(dialogId, marker) {
+    const typed = evt_registry_1.dialogEventRegistry.createTypedEvent(dialogId, {
+        type: 'dlg_run_state_marker_evt',
+        kind: marker.kind,
+        reason: marker.reason,
+    });
+    if (broadcastToClients) {
+        broadcastToClients(typed);
+    }
+}
+async function computeIdleRunState(dlg) {
+    if (dlg.status === 'completed' || dlg.status === 'archived') {
+        return { kind: 'terminal', status: dlg.status };
+    }
+    const hasQ4H = await dlg.hasPendingQ4H();
+    const hasSubdialogs = await dlg.hasPendingSubdialogs();
+    if (hasQ4H && hasSubdialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    }
+    if (hasQ4H) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    }
+    if (hasSubdialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    }
+    return { kind: 'idle_waiting_user' };
+}
+async function computeIdleRunStateFromPersistence(dialogId) {
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+    const status = latest?.status;
+    if (status === 'completed' || status === 'archived') {
+        return { kind: 'terminal', status };
+    }
+    const q4h = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialogId, 'running');
+    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialogId, 'running');
+    const hasQ4H = q4h.length > 0;
+    const hasSubdialogs = pendingSubdialogs.length > 0;
+    if (hasQ4H && hasSubdialogs) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input_and_subdialogs' } };
+    }
+    if (hasQ4H) {
+        return { kind: 'blocked', reason: { kind: 'needs_human_input' } };
+    }
+    if (hasSubdialogs) {
+        return { kind: 'blocked', reason: { kind: 'waiting_for_subdialogs' } };
+    }
+    return { kind: 'idle_waiting_user' };
+}
+async function reconcileRunStatesAfterRestart() {
+    const dialogIds = await persistence_1.DialogPersistence.listAllDialogIds('running');
+    for (const dialogId of dialogIds) {
+        const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, 'running');
+        const existing = latest?.runState;
+        const wasProceeding = latest?.generating === true ||
+            (existing !== undefined &&
+                (existing.kind === 'proceeding' || existing.kind === 'proceeding_stop_requested'));
+        if (wasProceeding) {
+            const nextIdle = await computeIdleRunStateFromPersistence(dialogId);
+            const next = nextIdle.kind === 'blocked'
+                ? nextIdle
+                : { kind: 'interrupted', reason: { kind: 'server_restart' } };
+            try {
+                await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
+                    kind: 'patch',
+                    patch: { generating: false, runState: next },
+                }));
+            }
+            catch (err) {
+                log.warn('Failed to reconcile proceeding dialog after restart', err, {
+                    dialogId: dialogId.valueOf(),
+                });
+            }
+            continue;
+        }
+        if (!existing) {
+            const inferred = await computeIdleRunStateFromPersistence(dialogId);
+            try {
+                await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
+                    kind: 'patch',
+                    patch: { runState: inferred },
+                }));
+            }
+            catch (err) {
+                log.warn('Failed to backfill missing runState', err, { dialogId: dialogId.valueOf() });
+            }
+        }
+    }
+}
+async function requestInterruptDialog(dialogId, reason) {
+    const key = dialogId.key();
+    const run = activeRunsByDialogKey.get(key);
+    if (!run) {
+        return { applied: false };
+    }
+    if (run.stopRequested) {
+        return { applied: false };
+    }
+    run.stopRequested = reason;
+    await setDialogRunState(dialogId, { kind: 'proceeding_stop_requested', reason });
+    try {
+        run.abortController.abort();
+    }
+    catch (err) {
+        log.warn('Failed to abort active run', err, { dialogId: dialogId.valueOf() });
+    }
+    return { applied: true };
+}
+async function requestEmergencyStopAll() {
+    const keys = [...activeRunsByDialogKey.keys()];
+    let interrupted = 0;
+    for (const key of keys) {
+        const [rootId, selfId] = key.includes('#') ? key.split('#') : [key, key];
+        if (!rootId || !selfId)
+            continue;
+        const dialogId = new dialog_1.DialogID(selfId, rootId);
+        const res = await requestInterruptDialog(dialogId, 'emergency_stop');
+        if (res.applied)
+            interrupted++;
+    }
+    return { interrupted };
+}