dominds 1.16.0 → 1.16.1

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

@@ -16,7 +16,7 @@
  *   so multi-tab views converge without polling.
  */
 import type { DialogDisplayState, DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
-import type { DialogExecutionMarker } from '@longrun-ai/kernel/types/storage';
+import type { DialogExecutionMarker, DialogLatestFile } from '@longrun-ai/kernel/types/storage';
 import type { WebSocketMessage } from '@longrun-ai/kernel/types/wire';
 import { DialogID, type Dialog } from './dialog';
 type StopRequestedReason = 'user_stop' | 'emergency_stop';
@@ -28,6 +28,7 @@ export declare function setDisplayStateBroadcaster(fn: (msg: WebSocketMessage) =
 export declare function isStoppedReasonResumable(reason: DialogInterruptionReason): boolean;
 export declare function isDisplayStateResumable(state: DialogDisplayState | undefined): boolean;
 export declare function isExecutionMarkerResumable(executionMarker: DialogExecutionMarker | undefined): boolean;
+export declare function isDialogLatestResumable(latest: DialogLatestFile | null | undefined): boolean;
 export declare function getRunControlCountsSnapshot(): Promise<RunControlCountsSnapshot>;
 export declare function broadcastRunControlCountsSnapshot(): Promise<void>;
 export declare function hasActiveRun(dialogId: DialogID): boolean;

package/dist/dialog-display-state.js

@@ -21,6 +21,7 @@ exports.setDisplayStateBroadcaster = setDisplayStateBroadcaster;
 exports.isStoppedReasonResumable = isStoppedReasonResumable;
 exports.isDisplayStateResumable = isDisplayStateResumable;
 exports.isExecutionMarkerResumable = isExecutionMarkerResumable;
+exports.isDialogLatestResumable = isDialogLatestResumable;
 exports.getRunControlCountsSnapshot = getRunControlCountsSnapshot;
 exports.broadcastRunControlCountsSnapshot = broadcastRunControlCountsSnapshot;
 exports.hasActiveRun = hasActiveRun;
@@ -70,6 +71,11 @@ function isDisplayStateResumable(state) {
 function isExecutionMarkerResumable(executionMarker) {
     return (executionMarker?.kind === 'interrupted' && isStoppedReasonResumable(executionMarker.reason));
 }
+function isDialogLatestResumable(latest) {
+    return (latest?.displayState?.kind === 'stopped' &&
+        latest.displayState.continueEnabled &&
+        latest.executionMarker?.kind === 'interrupted');
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -103,7 +109,7 @@ async function getRunControlCountsSnapshot() {
         if (latest?.generating === true) {
             proceeding++;
         }
-        else if (isExecutionMarkerResumable(latest?.executionMarker)) {
+        else if (isDialogLatestResumable(latest)) {
             resumable++;
         }
     }

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

@@ -790,6 +790,7 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingChunk(content);
     await dlg.sayingFinish();
 }
+const KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD = 3;
 function resolveFuncToolFollowupMode(tool) {
     return tool?.followupMode ?? 'immediate';
 }
@@ -802,6 +803,20 @@ function shouldImmediatelyFollowUpToolOutcome(tool, outcome) {
     }
     return shouldImmediatelyFollowUpSuccessfulToolResult(tool);
 }
+function formatIdenticalUpdatePlanLoopStopDetail(language) {
+    return language === 'zh'
+        ? `检测到连续 ${String(KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD)} 次完全相同的 update_plan 自动续跑，已停止本次自动执行以避免自激发循环。你可以点击“继续”人工观察，或先修改计划内容再继续。`
+        : `Detected ${String(KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD)} consecutive identical update_plan auto-follow-up rounds. Stopped this automatic run to avoid a self-trigger loop. You can click Continue to inspect manually, or change the plan content before resuming.`;
+}
+function extractAssistantSayingRoundSignature(newMsgs) {
+    const contents = newMsgs
+        .filter((msg) => msg.type === 'saying_msg' && msg.role === 'assistant')
+        .map((msg) => msg.content);
+    if (contents.length === 0) {
+        return undefined;
+    }
+    return JSON.stringify(contents);
+}
 async function executeFunctionCalls(args) {
     const functionPromises = args.funcCalls.map(async (func) => {
         throwIfAborted(args.abortSignal, args.dlg);
@@ -944,6 +959,27 @@ async function executeFunctionRound(args) {
         }
         return shouldImmediatelyFollowUpToolOutcome(tool, outcome);
     });
+    const updatePlanOnlyRawArgumentsSignature = (() => {
+        if (tellaskRound.normalCalls.length === 0) {
+            return undefined;
+        }
+        if (tellaskRound.handledCallIds.length > 0 || tellaskRound.toolOutputs.length > 0) {
+            return undefined;
+        }
+        const signatures = [];
+        for (const call of tellaskRound.normalCalls) {
+            if (call.name !== 'update_plan') {
+                return undefined;
+            }
+            const outcome = genericOutcomeByCallId.get(call.id);
+            if (outcome !== 'success') {
+                return undefined;
+            }
+            const argsStr = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+            signatures.push(argsStr);
+        }
+        return JSON.stringify(signatures);
+    })();
     const resultByCallId = new Map();
     const register = (result) => {
         const existing = resultByCallId.get(result.id);
@@ -992,6 +1028,7 @@ async function executeFunctionRound(args) {
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         pairedMessages,
         tellaskToolOutputs: [...tellaskRound.toolOutputs],
+        updatePlanOnlyRawArgumentsSignature,
     };
 }
 async function resetDiligenceBudgetAfterQ4H(dlg, team) {
@@ -1139,6 +1176,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     let pendingPrompt = humanPrompt;
     let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
     let genIterNo = 0;
+    let consecutiveIdenticalUpdatePlanOnlyRounds = 0;
+    let lastIdenticalUpdatePlanRoundSignature;
     if (!humanPrompt) {
         try {
             const executionMarker = await (0, dialog_display_state_1.loadDialogExecutionMarker)(dlg.id, 'running');
@@ -1852,6 +1891,27 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     newMsgs.push(...routed.pairedMessages);
                 }
                 await dlg.addChatMessages(...newMsgs);
+                const assistantSayingRoundSignature = extractAssistantSayingRoundSignature(newMsgs);
+                const identicalUpdatePlanRoundSignature = routed.updatePlanOnlyRawArgumentsSignature !== undefined &&
+                    assistantSayingRoundSignature !== undefined
+                    ? JSON.stringify({
+                        assistantSayingRoundSignature,
+                        updatePlanRawArgumentsSignature: routed.updatePlanOnlyRawArgumentsSignature,
+                    })
+                    : undefined;
+                if (identicalUpdatePlanRoundSignature !== undefined) {
+                    if (identicalUpdatePlanRoundSignature === lastIdenticalUpdatePlanRoundSignature) {
+                        consecutiveIdenticalUpdatePlanOnlyRounds += 1;
+                    }
+                    else {
+                        consecutiveIdenticalUpdatePlanOnlyRounds = 1;
+                        lastIdenticalUpdatePlanRoundSignature = identicalUpdatePlanRoundSignature;
+                    }
+                }
+                else {
+                    consecutiveIdenticalUpdatePlanOnlyRounds = 0;
+                    lastIdenticalUpdatePlanRoundSignature = undefined;
+                }
                 const persistedFbrState = await loadDialogFbrState(dlg);
                 if (persistedFbrState) {
                     if (persistedFbrState.phase === 'finalization') {
@@ -1937,6 +1997,20 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     await resetDiligenceBudgetAfterQ4H(dlg, team);
                     break;
                 }
+                if (consecutiveIdenticalUpdatePlanOnlyRounds >=
+                    KERNEL_DRIVER_IDENTICAL_UPDATE_PLAN_ONLY_STOP_THRESHOLD) {
+                    const detail = formatIdenticalUpdatePlanLoopStopDetail((0, work_language_1.getWorkLanguage)());
+                    log_1.log.error(detail, new Error('kernel_driver_identical_update_plan_loop_stopped'), {
+                        dialogId: dlg.id.valueOf(),
+                        rootId: dlg.id.rootId,
+                        selfId: dlg.id.selfId,
+                        course: dlg.currentCourse,
+                        genseq: dlg.activeGenSeqOrUndefined ?? null,
+                        consecutiveIdenticalUpdatePlanOnlyRounds,
+                        identicalUpdatePlanRoundSignature,
+                    });
+                    throw new KernelDriverInterruptedError({ kind: 'system_stop', detail });
+                }
                 // Start an immediate post-tool generation only when this round produced tool outputs that
                 // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
                 // meaningful output, but they are not transcript/context inputs and therefore must not

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

@@ -272,6 +272,44 @@ function isRetriableLlmMessage(message) {
     }
     return false;
 }
+function readGenericRetriableMessage(err) {
+    if (err instanceof Error) {
+        const message = err.message.trim();
+        if (message !== '')
+            return message;
+        const name = err.name.trim();
+        return name !== '' ? name : undefined;
+    }
+    if (typeof err === 'string') {
+        const trimmed = err.trim();
+        return trimmed !== '' ? trimmed : undefined;
+    }
+    if (!isPlainObject(err)) {
+        return undefined;
+    }
+    if ('message' in err && typeof err.message === 'string') {
+        const trimmed = err.message.trim();
+        if (trimmed !== '')
+            return trimmed;
+    }
+    if ('error' in err &&
+        isPlainObject(err.error) &&
+        'message' in err.error &&
+        typeof err.error.message === 'string') {
+        const trimmed = err.error.message.trim();
+        if (trimmed !== '')
+            return trimmed;
+    }
+    if ('cause' in err &&
+        isPlainObject(err.cause) &&
+        'message' in err.cause &&
+        typeof err.cause.message === 'string') {
+        const trimmed = err.cause.message.trim();
+        if (trimmed !== '')
+            return trimmed;
+    }
+    return undefined;
+}
 function normalizeFailureDisposition(err, disposition) {
     const fallbackMessage = err instanceof Error
         ? err.message || err.name
@@ -290,6 +328,13 @@ function normalizeFailureDisposition(err, disposition) {
     };
 }
 function classifyGenericLlmFailure(err) {
+    // Ownership boundary:
+    // - Wrapper classifiers own provider/API semantics such as HTTP status handling, response-body
+    //   rejection semantics, rate limits, overload signals, and provider-advised backoff headers.
+    // - The runtime generic classifier only owns provider-agnostic transport/runtime failures such
+    //   as local timeout / socket / fetch failures and Dominds internal retriable error codes.
+    // When a new unexpected pattern appears, keep it here only if it is clearly transport/runtime
+    // scoped and not tied to any specific upstream API contract.
     const fallbackMessage = err instanceof Error
         ? err.message || err.name
         : typeof err === 'string'
@@ -317,23 +362,24 @@ function classifyGenericLlmFailure(err) {
             retryStrategy: 'aggressive',
         };
     }
-    {
-        const msg = err instanceof Error
-            ? err.message && err.message.length > 0
-                ? err.message
-                : err.name
-            : typeof err === 'string'
-                ? err
-                : undefined;
-        if (typeof msg === 'string' && msg.length > 0) {
-            if (isRetriableLlmMessage(msg)) {
-                return {
-                    kind: 'retriable',
-                    code: errCode ?? causeCode,
-                    message: msg,
-                    retryStrategy: 'aggressive',
-                };
-            }
+    const msg = readGenericRetriableMessage(err);
+    if (typeof msg === 'string' && isRetriableLlmMessage(msg)) {
+        return {
+            kind: 'retriable',
+            code: errCode ?? causeCode,
+            message: msg,
+            retryStrategy: 'aggressive',
+        };
+    }
+    if (isPlainObject(err) && 'cause' in err) {
+        const causeMessage = readGenericRetriableMessage(err.cause);
+        if (typeof causeMessage === 'string' && isRetriableLlmMessage(causeMessage)) {
+            return {
+                kind: 'retriable',
+                code: errCode ?? causeCode,
+                message: causeMessage,
+                retryStrategy: 'aggressive',
+            };
         }
     }
     return { kind: 'fatal', message: fallbackMessage };

package/dist/persistence.d.ts

@@ -258,6 +258,7 @@ type DialogLatestMutation = {
  */
 export declare class DialogPersistence {
     private static readonly DIALOGS_DIR;
+    private static readonly MALFORMED_DIR;
     private static readonly RUN_DIR;
     private static readonly DONE_DIR;
     private static readonly ARCHIVE_DIR;
@@ -313,6 +314,12 @@ export declare class DialogPersistence {
      * Get the path for a subdialog within a supdialog
      */
     static getSubdialogPath(dialogId: DialogID, status?: 'running' | 'completed' | 'archived'): string;
+    private static isMalformedDialogLoadError;
+    private static getMalformedRootDialogPath;
+    private static pathExists;
+    private static clearLatestWriteBackState;
+    private static quarantineMalformedRootDialog;
+    private static parseDialogLatestYaml;
     /**
      * Ensure dialog directory structure exists
      */

package/dist/persistence.js

@@ -3092,6 +3092,76 @@ class DialogPersistence {
         const rootPath = this.getRootDialogPath(new dialog_1.DialogID(dialogId.rootId), status);
         return path.join(rootPath, this.SUBDIALOGS_DIR, dialogId.selfId);
     }
+    static isMalformedDialogLoadError(error) {
+        return (error instanceof Error &&
+            (error.message.startsWith('Invalid latest.yaml in ') ||
+                error.message.startsWith('Invalid dialog metadata in ')));
+    }
+    static getMalformedRootDialogPath(dialogId, status) {
+        if (dialogId.rootId !== dialogId.selfId) {
+            throw new Error('Expected root dialog id');
+        }
+        void status;
+        return path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, dialogId.selfId);
+    }
+    static async pathExists(targetPath) {
+        try {
+            await fs.promises.access(targetPath);
+            return true;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    static clearLatestWriteBackState(dialogId, status) {
+        const key = this.getLatestWriteBackKey(dialogId, status);
+        const entry = this.latestWriteBack.get(key);
+        if (entry?.kind === 'scheduled') {
+            clearTimeout(entry.timer);
+        }
+        this.latestWriteBack.delete(key);
+        this.latestWriteBackMutexes.delete(key);
+    }
+    static async quarantineMalformedRootDialog(dialogId, status, reason, error) {
+        if (dialogId.rootId !== dialogId.selfId) {
+            throw error;
+        }
+        const sourcePath = this.getRootDialogPath(dialogId, status);
+        if (!(await this.pathExists(sourcePath))) {
+            return;
+        }
+        let destinationPath = this.getMalformedRootDialogPath(dialogId, status);
+        if (await this.pathExists(destinationPath)) {
+            destinationPath = path.join(this.getDialogsRootDir(), this.MALFORMED_DIR, `${dialogId.selfId}__${(0, node_crypto_1.randomUUID)()}`);
+        }
+        await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
+        await fs.promises.rename(sourcePath, destinationPath);
+        this.clearLatestWriteBackState(dialogId, status);
+        log_1.log.warn(`Quarantined malformed root dialog ${dialogId.selfId}`, undefined, {
+            status,
+            reason,
+            sourcePath,
+            destinationPath,
+            errorMessage: error.message,
+        });
+    }
+    static parseDialogLatestYaml(content, latestFilePath) {
+        let parsed;
+        try {
+            parsed = yaml.parse(content);
+        }
+        catch {
+            throw new Error(`Invalid latest.yaml in ${latestFilePath}`);
+        }
+        const latest = parseDialogLatestFile(parsed);
+        if (!latest) {
+            throw new Error(`Invalid latest.yaml in ${latestFilePath}`);
+        }
+        return latest;
+    }
     /**
      * Ensure dialog directory structure exists
      */
@@ -4532,7 +4602,13 @@ class DialogPersistence {
             const metadataFilePath = path.join(dialogPath, 'dialog.yaml');
             try {
                 const content = await fs.promises.readFile(metadataFilePath, 'utf-8');
-                const parsed = yaml.parse(content);
+                let parsed;
+                try {
+                    parsed = yaml.parse(content);
+                }
+                catch {
+                    throw new Error(`Invalid dialog metadata in ${metadataFilePath}`);
+                }
                 if (!isDialogMetadataFile(parsed)) {
                     throw new Error(`Invalid dialog metadata in ${metadataFilePath}`);
                 }
@@ -4547,6 +4623,10 @@ class DialogPersistence {
                 if (getErrorCode(error) === 'ENOENT') {
                     return null;
                 }
+                if (this.isMalformedDialogLoadError(error)) {
+                    await this.quarantineMalformedRootDialog(dialogId, status, 'loadRootDialogMetadata', error);
+                    return null;
+                }
                 throw error;
             }
         }
@@ -4650,17 +4730,16 @@ class DialogPersistence {
             const dialogPath = this.getDialogEventsPath(dialogId, status);
             const latestFilePath = path.join(dialogPath, 'latest.yaml');
             const content = await fs.promises.readFile(latestFilePath, 'utf-8');
-            const parsed = yaml.parse(content);
-            const latest = parseDialogLatestFile(parsed);
-            if (!latest) {
-                throw new Error(`Invalid latest.yaml in ${latestFilePath}`);
-            }
-            return latest;
+            return this.parseDialogLatestYaml(content, latestFilePath);
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT') {
                 return null;
             }
+            if (dialogId.rootId === dialogId.selfId && this.isMalformedDialogLoadError(error)) {
+                await this.quarantineMalformedRootDialog(dialogId, status, 'loadDialogLatest', error);
+                return null;
+            }
             throw error;
         }
     }
@@ -4736,17 +4815,16 @@ class DialogPersistence {
             const dialogPath = this.getDialogEventsPath(dialogId, status);
             const latestFilePath = path.join(dialogPath, 'latest.yaml');
             const content = await fs.promises.readFile(latestFilePath, 'utf-8');
-            const parsed = yaml.parse(content);
-            const latest = parseDialogLatestFile(parsed);
-            if (!latest) {
-                throw new Error(`Invalid latest.yaml in ${latestFilePath}`);
-            }
-            return latest;
+            return this.parseDialogLatestYaml(content, latestFilePath);
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT') {
                 return null;
             }
+            if (dialogId.rootId === dialogId.selfId && this.isMalformedDialogLoadError(error)) {
+                await this.quarantineMalformedRootDialog(dialogId, status, 'loadDialogLatestFromDisk', error);
+                return null;
+            }
             throw error;
         }
     }
@@ -5313,6 +5391,7 @@ class DialogPersistence {
 }
 exports.DialogPersistence = DialogPersistence;
 DialogPersistence.DIALOGS_DIR = '.dialogs';
+DialogPersistence.MALFORMED_DIR = 'malformed';
 DialogPersistence.RUN_DIR = 'run';
 DialogPersistence.DONE_DIR = 'done';
 DialogPersistence.ARCHIVE_DIR = 'archive';

package/dist/server/api-routes.js

@@ -62,13 +62,13 @@ const registry_snapshot_1 = require("../tools/registry-snapshot");
 const id_1 = require("../utils/id");
 const taskdoc_search_1 = require("../utils/taskdoc-search");
 const create_dialog_contract_1 = require("./create-dialog-contract");
+const dominds_self_update_1 = require("./dominds-self-update");
 const mime_types_1 = require("./mime-types");
 const setup_routes_1 = require("./setup-routes");
 const snippets_routes_1 = require("./snippets-routes");
 // Dialog lookup is performed via file-backed persistence; no in-memory registry
 const log = (0, log_1.createLogger)('api-routes');
 const PRIMING_WARNING_SAMPLE_MAX = 5;
-let cachedDomindsVersion;
 function resolveMemberDiligencePushMax(team, agentId) {
     const member = team.getMember(agentId);
     if (member && member.diligence_push_max !== undefined) {
@@ -81,26 +81,6 @@ function normalizeDiligencePushMax(value) {
         return 0;
     return Math.floor(value);
 }
-async function readDomindsPackageVersion() {
-    if (cachedDomindsVersion !== undefined)
-        return cachedDomindsVersion;
-    try {
-        const packagePath = path.join(__dirname, '..', '..', 'package.json');
-        const raw = await promises_1.default.readFile(packagePath, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (!isRecord(parsed)) {
-            cachedDomindsVersion = null;
-            return null;
-        }
-        const version = parsed['version'];
-        cachedDomindsVersion = typeof version === 'string' ? version : null;
-        return cachedDomindsVersion;
-    }
-    catch {
-        cachedDomindsVersion = null;
-        return null;
-    }
-}
 function getErrorCode(error) {
     if (typeof error !== 'object' || error === null)
         return undefined;
@@ -323,6 +303,14 @@ async function handleSaveCurrentCoursePriming(req, res) {
         return true;
     }
 }
+function parseDomindsSelfUpdateAction(body) {
+    if (!isRecord(body))
+        return null;
+    const action = body['action'];
+    if (action === 'install' || action === 'restart')
+        return action;
+    return null;
+}
 async function handleWorkspaceFilePreviewPage(req, res, pathname) {
     const pseudoPathRel = parseWorkspacePseudoPreviewPathname(pathname);
     if (pseudoPathRel !== null) {
@@ -962,14 +950,46 @@ async function handleWorkspaceFilePreviewPage(req, res, pathname) {
  */
 async function handleApiRoute(req, res, pathname, context) {
     try {
-        // Health check endpoint
-        if (pathname === '/api/health' && req.method === 'GET') {
-            return await handleHealthCheck(res, context);
-        }
         // Live reload endpoint for development
         if (pathname === '/api/live-reload' && req.method === 'GET') {
             return await handleLiveReload(res, context);
         }
+        if (pathname === '/api/dominds/self-update' && req.method === 'POST') {
+            const body = await readRequestBody(req);
+            let parsed;
+            try {
+                parsed = JSON.parse(body);
+            }
+            catch {
+                respondJson(res, 400, { success: false, error: 'Invalid JSON body' });
+                return true;
+            }
+            const action = parseDomindsSelfUpdateAction(parsed);
+            if (action === null) {
+                respondJson(res, 400, {
+                    success: false,
+                    error: "Invalid action. Expected 'install' or 'restart'",
+                });
+                return true;
+            }
+            try {
+                if (action === 'install') {
+                    const status = await (0, dominds_self_update_1.installLatestDominds)();
+                    respondJson(res, 200, { success: true, update: status });
+                    return true;
+                }
+                const status = await (0, dominds_self_update_1.restartDomindsIntoLatest)();
+                respondJson(res, 202, { success: true, update: status });
+                return true;
+            }
+            catch (error) {
+                respondJson(res, 409, {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
         // Team configuration endpoint (renamed)
         if (pathname === '/api/team/config' && req.method === 'GET') {
             return await handleGetTeamConfig(res);
@@ -1901,33 +1921,6 @@ async function handleGetToolsRegistry(req, res) {
         return true;
     }
 }
-/**
- * Health check endpoint
- */
-async function handleHealthCheck(res, context) {
-    try {
-        const version = (await readDomindsPackageVersion()) ?? 'unknown';
-        const workspace = process.cwd();
-        const healthData = {
-            ok: true,
-            timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-            server: 'dominds',
-            version,
-            // `workspace` is the canonical name used by WebUI indicators.
-            // Keep `rtws` for backward compatibility.
-            workspace,
-            rtws: workspace,
-            mode: context.mode,
-        };
-        respondJson(res, 200, healthData);
-        return true;
-    }
-    catch (error) {
-        log.error('Health check failed:', error);
-        respondJson(res, 500, { ok: false, error: 'Health check failed' });
-        return true;
-    }
-}
 /**
  * Live reload endpoint for development
  */
@@ -1998,14 +1991,27 @@ async function handleGetDialogs(res, status) {
         const rootDialogs = [];
         const ids = await persistence_1.DialogPersistence.listDialogs(status);
         for (const id of ids) {
-            const meta = await persistence_1.DialogPersistence.loadRootDialogMetadata(new dialog_1.DialogID(id), status);
+            const dialogId = new dialog_1.DialogID(id);
+            const meta = await persistence_1.DialogPersistence.loadRootDialogMetadata(dialogId, status);
             if (!meta)
                 continue;
             // Load latest.yaml for currentCourse and lastModified timestamp
-            const latest = await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(id), status);
-            const waitingForFreshBootsReasoning = await detectWaitingForFreshBootsReasoning(new dialog_1.DialogID(id), status);
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(dialogId, status);
+            const rootPath = persistence_1.DialogPersistence.getRootDialogPath(dialogId, status);
+            const rootStillExists = await promises_1.default
+                .access(rootPath)
+                .then(() => true)
+                .catch((error) => {
+                if (getErrorCode(error) === 'ENOENT') {
+                    return false;
+                }
+                throw error;
+            });
+            if (!rootStillExists) {
+                continue;
+            }
+            const waitingForFreshBootsReasoning = await detectWaitingForFreshBootsReasoning(dialogId, status);
             // Count subdialogs for this root dialog
-            const rootPath = persistence_1.DialogPersistence.getRootDialogPath(new dialog_1.DialogID(id), status);
             const subPath = path.join(rootPath, 'subdialogs');
             const subdialogCount = await countSubdialogs(subPath);
             rootDialogs.push({
@@ -2097,6 +2103,23 @@ async function handleGetDialogHierarchy(res, rootId, status) {
         }
         // Load latest.yaml for root dialog currentCourse and lastModified timestamp
         const rootLatest = await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(rootId), status);
+        const rootPath = persistence_1.DialogPersistence.getRootDialogPath(new dialog_1.DialogID(rootId), status);
+        const rootStillExists = await promises_1.default
+            .access(rootPath)
+            .then(() => true)
+            .catch((error) => {
+            if (getErrorCode(error) === 'ENOENT') {
+                return false;
+            }
+            throw error;
+        });
+        if (!rootStillExists) {
+            respondJson(res, 404, {
+                success: false,
+                error: `Root dialog ${rootId} was quarantined as malformed`,
+            });
+            return true;
+        }
         const rootInfo = {
             id: rootMeta.id,
             agentId: rootMeta.agentId,

package/dist/server/static-server.js

@@ -35,7 +35,6 @@ API Server is running in development mode
 Frontend (Vite dev server) should be started by your outer dev-server.sh
 
 Available API endpoints:
-• GET /api/health - Server health check
 • GET /api/live-reload - Development status
 • GET /api/team/config - Team configuration
 • GET /api/dialogs - List all dialogs

package/dist/server/websocket-handler.d.ts

@@ -1,4 +1,4 @@
-import type { WebSocketMessage } from '@longrun-ai/kernel/types';
+import type { DomindsRuntimeMode, WebSocketMessage } from '@longrun-ai/kernel/types';
 import { type LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { Server } from 'http';
 import { WebSocket, WebSocketServer } from 'ws';
@@ -10,7 +10,7 @@ export declare function handleWebSocketMessage(ws: WebSocket, packet: WebSocketM
 /**
  * Setup WebSocket server with dialog handling
  */
-export declare function setupWebSocketServer(httpServer: Server, clients: Set<WebSocket>, auth: AuthConfig, serverWorkLanguage: LanguageCode): WebSocketServer;
+export declare function setupWebSocketServer(httpServer: Server, clients: Set<WebSocket>, auth: AuthConfig, serverWorkLanguage: LanguageCode, mode: DomindsRuntimeMode): WebSocketServer;
 /**
  * Clean up all event channels and subscriptions
  */