dominds 1.24.3 → 1.24.4

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

@@ -13,6 +13,18 @@ const log_1 = require("../../log");
 const persistence_1 = require("../../persistence");
 const persistence_errors_1 = require("../../persistence-errors");
 const engine_1 = require("./engine");
+function formatDriveError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            ...(typeof error.stack === 'string' && error.stack.trim() !== ''
+                ? { stack: error.stack }
+                : {}),
+        };
+    }
+    return { message: String(error) };
+}
 function formatDriveTriggerForLog(trigger) {
     return {
         action: trigger.action,
@@ -26,7 +38,7 @@ function formatDriveTriggerForLog(trigger) {
     };
 }
 async function listLiveDialogsWithDurableDriveWork() {
-    const liveDialogs = dialog_global_registry_1.globalDialogRegistry.getAll();
+    const liveDialogs = dialog_global_registry_1.globalDialogRegistry.consumeQueuedMainDialogs();
     const queued = [];
     for (const mainDialog of liveDialogs) {
         let watchedDialogIds;
@@ -42,6 +54,7 @@ async function listLiveDialogsWithDurableDriveWork() {
         }
         const candidateDialogs = [mainDialog];
         let hadCandidateInspectionError = false;
+        let hadStalledCandidateForRoot = false;
         for (const watchedDialogId of watchedDialogIds) {
             let watchedDialog;
             try {
@@ -95,13 +108,24 @@ async function listLiveDialogsWithDurableDriveWork() {
             if (!(0, dialog_drive_work_1.hasDurableDriveWork)(latest)) {
                 continue;
             }
+            const durableWorkFingerprint = persistence_1.DialogPersistence.buildBackendDriveDurableWorkFingerprint(latest, dialog.id.selfId === dialog.id.rootId ? watchedDialogIds : []);
+            if (latest.backendDriveStall?.durableWorkFingerprint === durableWorkFingerprint) {
+                hadStalledCandidateForRoot = true;
+                log_1.log.warn('Backend driver skipped stalled durable work pending new facts', undefined, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                    stallRecordId: latest.backendDriveStall.recordId,
+                });
+                continue;
+            }
             hasQueuedCandidateForRoot = true;
             queued.push({
                 rootDialog: mainDialog,
                 dialog,
             });
         }
-        if (!hasQueuedCandidateForRoot && !hadCandidateInspectionError) {
+        if (!hasQueuedCandidateForRoot && !hadCandidateInspectionError && !hadStalledCandidateForRoot) {
             dialog_global_registry_1.globalDialogRegistry.clearDriveWake(mainDialog.id.rootId, {
                 source: 'kernel_driver_backend_loop',
                 reason: 'no_durable_drive_work',
@@ -111,29 +135,6 @@ async function listLiveDialogsWithDurableDriveWork() {
     }
     return queued;
 }
-async function reassertLiveRootWakeForDurableWork() {
-    for (const mainDialog of dialog_global_registry_1.globalDialogRegistry.getAll()) {
-        try {
-            const rootHasPendingNextStepTriggers = await persistence_1.DialogPersistence.hasPendingNextStepTriggers(mainDialog.id, mainDialog.status);
-            const watchedDialogIds = await persistence_1.DialogPersistence.loadDriveWatchedDialogIds(mainDialog.id, mainDialog.status);
-            if (!rootHasPendingNextStepTriggers && watchedDialogIds.length === 0) {
-                continue;
-            }
-            dialog_global_registry_1.globalDialogRegistry.wakeDrive(mainDialog.id.rootId, {
-                source: 'kernel_driver_backend_loop',
-                reason: rootHasPendingNextStepTriggers
-                    ? 'root_next_step_still_pending'
-                    : 'drive_watch_still_pending',
-            });
-        }
-        catch (error) {
-            log_1.log.error('Backend driver failed to reassert root wake for durable work', error, {
-                rootId: mainDialog.id.rootId,
-                selfId: mainDialog.id.selfId,
-            });
-        }
-    }
-}
 async function driveQueuedDialogsOnce() {
     const dialogsToDrive = await listLiveDialogsWithDurableDriveWork();
     for (const { rootDialog, dialog } of dialogsToDrive) {
@@ -143,7 +144,6 @@ async function driveQueuedDialogsOnce() {
                 await persistence_1.DialogPersistence.removeDriveWatchForDialog(dialog.id, dialog.status);
                 continue;
             }
-            const currentHasPendingNextStepTriggers = (latestForDrive?.nextStep.triggers.length ?? 0) > 0;
             const currentResumeInProgressGeneration = (0, dialog_generation_run_1.getRecoverableGenerationRunState)(latestForDrive) !== undefined;
             const currentHasBackendDurableWork = (0, dialog_drive_work_1.hasDurableDriveWork)(latestForDrive);
             const executionMarker = latestForDrive?.executionMarker;
@@ -203,20 +203,27 @@ async function driveQueuedDialogsOnce() {
             const stillHasDurableWork = (0, dialog_drive_work_1.hasDurableDriveWork)(latestAfterDrive);
             const shouldStayQueued = dialog.hasUpNext() || !status.canDrive || stillHasDurableWork;
             if (shouldStayQueued) {
-                dialog_global_registry_1.globalDialogRegistry.wakeDrive(rootDialog.id.rootId, {
-                    source: 'kernel_driver_backend_loop',
-                    reason: dialog.hasUpNext()
-                        ? 'post_drive_upnext_pending'
-                        : stillHasDurableWork
-                            ? 'post_drive_durable_work_pending'
-                            : 'post_drive_suspended',
-                });
-                if (dialog.id.selfId === dialog.id.rootId) {
-                    await persistence_1.DialogPersistence.upsertRootDriveWakeTrigger(dialog.id, dialog.hasUpNext()
-                        ? 'post_drive_upnext_pending'
-                        : stillHasDurableWork
-                            ? 'post_drive_durable_work_pending'
-                            : 'post_drive_suspended', dialog.status);
+                const canRetryImmediately = dialog.hasUpNext() || (status.canDrive && stillHasDurableWork);
+                if (canRetryImmediately) {
+                    dialog_global_registry_1.globalDialogRegistry.wakeDrive(rootDialog.id.rootId, {
+                        source: 'kernel_driver_backend_loop',
+                        reason: dialog.hasUpNext()
+                            ? 'post_drive_upnext_pending'
+                            : 'post_drive_durable_work_pending',
+                    });
+                    if (dialog.id.selfId === dialog.id.rootId) {
+                        await persistence_1.DialogPersistence.upsertRootDriveWakeTrigger(dialog.id, dialog.hasUpNext() ? 'post_drive_upnext_pending' : 'post_drive_durable_work_pending', dialog.status);
+                    }
+                }
+                else {
+                    log_1.log.debug('Backend driver left durable work parked until the blocking state changes', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        waitingQ4H: status.q4h,
+                        backgroundCalleeDialogs: status.backgroundCalleeDialogs,
+                        stillHasDurableWork,
+                    });
                 }
             }
             else {
@@ -289,14 +296,47 @@ async function driveQueuedDialogsOnce() {
                 const rootHasPendingNextStepTriggers = await persistence_1.DialogPersistence.hasPendingNextStepTriggers(rootId, dialog.status);
                 const watchedDialogIds = await persistence_1.DialogPersistence.loadDriveWatchedDialogIds(rootId, dialog.status);
                 if (rootHasPendingNextStepTriggers || watchedDialogIds.length > 0) {
-                    dialog_global_registry_1.globalDialogRegistry.wakeDrive(dialog.id.rootId, {
-                        source: 'kernel_driver_backend_loop',
-                        reason: 'drive_error_durable_work_pending',
+                    const durableWorkFingerprint = persistence_1.DialogPersistence.buildBackendDriveDurableWorkFingerprint(latestAfterError, dialog.id.selfId === dialog.id.rootId ? watchedDialogIds : []);
+                    const record = await persistence_1.DialogPersistence.appendBackendDriveStallRecord(dialog.id, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        status: dialog.status,
+                        reason: 'backend_drive_error',
+                        durableWorkFingerprint,
+                        latestSummary: latestAfterError === null
+                            ? null
+                            : {
+                                currentCourse: latestAfterError.currentCourse,
+                                status: latestAfterError.status,
+                                generating: latestAfterError.generating ?? false,
+                                displayState: latestAfterError.displayState ?? null,
+                                executionMarker: latestAfterError.executionMarker ?? null,
+                                generationRunState: latestAfterError.generationRunState ?? null,
+                                nextStepTriggerCount: latestAfterError.nextStep.triggers.length,
+                                pendingRuntimePromptMsgId: latestAfterError.pendingRuntimePrompt?.msgId ?? null,
+                                replyDelivery: latestAfterError.replyDelivery ?? null,
+                                userWait: latestAfterError.userWait ?? null,
+                                sideDialogFinalResponse: latestAfterError.sideDialogFinalResponse ?? null,
+                            },
+                        error: formatDriveError(err),
+                        context: {
+                            rootHasPendingNextStepTriggers,
+                            watchedDialogCount: watchedDialogIds.length,
+                        },
+                    }, dialog.status);
+                    log_1.log.warn('Backend driver persisted stalled durable work after drive error', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        stallRecordId: record.recordId,
+                        rootHasPendingNextStepTriggers,
+                        watchedDialogCount: watchedDialogIds.length,
                     });
                 }
             }
-            catch (requeueErr) {
-                log_1.log.error('Failed to requeue durable work after backend drive error', requeueErr, {
+            catch (stallErr) {
+                log_1.log.error('Failed to persist backend drive stall after drive error', stallErr, {
                     dialogId: dialog.id.valueOf(),
                     rootId: dialog.id.rootId,
                     selfId: dialog.id.selfId,
@@ -304,7 +344,6 @@ async function driveQueuedDialogsOnce() {
             }
         }
     }
-    await reassertLiveRootWakeForDurableWork();
 }
 function isBackendDriverAborted(options) {
     return options?.abortSignal?.aborted === true;

package/dist/llm/kernel-driver/types.d.ts

@@ -1,6 +1,6 @@
 import type { DialogDisplayState, DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
 import type { DialogDiligencePrompt, DialogPrompt, DialogRunControlSpec, DialogRuntimeGuidePrompt, DialogRuntimePrompt, DialogRuntimeReplyPrompt, DialogRuntimeSideDialogPrompt, DialogUserPrompt } from '@longrun-ai/kernel/types/drive-intent';
-import type { CallSiteCourseNo, CallSiteGenseqNo } from '@longrun-ai/kernel/types/storage';
+import type { CallSiteCourseNo, CallSiteGenseqNo, DialogBusinessContinuation } from '@longrun-ai/kernel/types/storage';
 import type { Dialog, DialogID } from '../../dialog';
 export type KernelDriverRunControl = DialogRunControlSpec;
 export type KernelDriverDriveSource = 'unspecified' | 'ws_user_message' | 'ws_user_answer' | 'ws_diligence_push' | 'ws_resume_dialog' | 'ws_resume_all' | 'kernel_driver_backend_loop' | 'kernel_driver_follow_up' | 'kernel_driver_sideDialog_init' | 'kernel_driver_sideDialog_resume' | 'kernel_driver_fbr_sideDialog_round' | 'kernel_driver_type_a_askerDialog_call' | 'kernel_driver_supply_response_caller_revive' | 'kernel_driver_idle_reminder_wake';
@@ -8,7 +8,14 @@ export type KernelDriverDriveOptions = Readonly<{
     suppressDiligencePush?: boolean;
     allowResumeFromInterrupted?: boolean;
     resumeInProgressGeneration?: boolean;
-    criticalUserInterjectionRuntimeGuide?: string;
+    /**
+     * Business continuation identity for no-prompt driver iterations.
+     *
+     * This is deliberately part of the drive contract instead of being rediscovered from old
+     * transcript/assignment records. A continuation must tell the next iteration what business
+     * obligation it is continuing, or the driver treats it as no business continuation.
+     */
+    businessContinuation?: DialogBusinessContinuation;
     noPromptSideDialogResumeEntitlement?: Readonly<{
         callerDialogId: string;
         reason: 'reply_tellask_back_delivered';
@@ -112,6 +119,7 @@ export type KernelDriverCoreResult = {
     lastAssistantThinkingGenseq: number | null;
     lastFunctionCallGenseq: number | null;
     lastAssistantReplyTarget?: KernelDriverCalleeReplyTarget;
+    lastBusinessContinuation: DialogBusinessContinuation;
     fbrConclusion?: {
         responseText: string;
         responseGenseq: number;

package/dist/persistence.d.ts

@@ -87,7 +87,7 @@ export declare class DiskFileDialogStore extends DialogStore {
      * CRITICAL: This must be called BEFORE any substream events (thinking_start, markdown_start, etc.)
      * to ensure proper event ordering on the frontend.
      */
-    notifyGeneratingStart(dialog: Dialog, msgId?: string): Promise<void>;
+    notifyGeneratingStart(dialog: Dialog, msgId?: string): Promise<readonly DialogNextStepTrigger[]>;
     private getResultArrivalBatchIdsFromAcceptedTriggers;
     /**
      * Notify end of LLM generation for frontend bubble management
@@ -259,6 +259,28 @@ type DialogLatestMutation = {
     kind: 'replace';
     next: DialogLatestFile;
 };
+export type BackendDriveStallWrite = Readonly<{
+    dialogId: string;
+    rootId: string;
+    selfId: string;
+    status: DialogStatusKind;
+    reason: 'backend_drive_error';
+    durableWorkFingerprint: string;
+    latestSummary: Record<string, unknown> | null;
+    error: {
+        name?: string;
+        message: string;
+        stack?: string;
+    };
+    context: {
+        rootHasPendingNextStepTriggers: boolean;
+        watchedDialogCount: number;
+    };
+}>;
+export type BackendDriveStallRecord = BackendDriveStallWrite & Readonly<{
+    recordId: string;
+    recordedAt: string;
+}>;
 type MainDialogWriteBackCancellationToken = Readonly<{
     scopeKey: string;
     generation: number;
@@ -285,6 +307,7 @@ export declare class DialogPersistence {
     private static readonly q4hWriteBack;
     private static readonly activeCalleesMutexes;
     private static readonly driveWatchMutexes;
+    private static readonly backendDriveStallMutexes;
     private static readonly courseAppendMutexes;
     private static readonly mainDialogWriteBackCancelGenerations;
     private static getLatestWriteBackMutex;
@@ -293,8 +316,10 @@ export declare class DialogPersistence {
     private static getCourseAppendMutexKey;
     private static getActiveCalleesMutex;
     private static getDriveWatchMutex;
+    private static getBackendDriveStallMutex;
     private static getLatestWriteBackKey;
     private static getDriveWatchKey;
+    private static getBackendDriveStallKey;
     private static getQ4HWriteBackKey;
     private static getActiveCalleesKey;
     private static getMainDialogWriteBackCancelScopeKey;
@@ -477,6 +502,9 @@ export declare class DialogPersistence {
     private static normalizeDriveWatchFile;
     private static loadDriveWatchFromDisk;
     private static writeDriveWatchToDisk;
+    private static getBackendDriveStallJsonlPath;
+    static buildBackendDriveDurableWorkFingerprint(latest: DialogLatestFile | null, watchedDialogIds?: readonly DialogID[]): string;
+    static appendBackendDriveStallRecord(dialogId: DialogID, write: BackendDriveStallWrite, status?: DialogStatusKind): Promise<BackendDriveStallRecord>;
     private static mutateDriveWatch;
     private static removeWithRetry;
     static loadDriveWatchedDialogIds(rootDialogId: DialogID, status?: DialogStatusKind): Promise<readonly DialogID[]>;

package/dist/persistence.js

@@ -98,6 +98,7 @@ function summarizeLatestProjectionState(latest) {
         displayState: latest.displayState ?? null,
         executionMarker: latest.executionMarker ?? null,
         generationRunState: latest.generationRunState ?? null,
+        backendDriveStall: latest.backendDriveStall ?? null,
         nextStepTriggerCount: latest.nextStep.triggers.length,
         userWait: latest.userWait ?? null,
         replyDelivery: latest.replyDelivery ?? null,
@@ -135,6 +136,7 @@ function summarizeLatestMutationPatch(patch) {
         displayState: patch.displayState ?? null,
         executionMarker: patch.executionMarker ?? null,
         generationRunState: patch.generationRunState ?? null,
+        backendDriveStall: patch.backendDriveStall ?? null,
         nextStepTriggerCount: patch.nextStep?.triggers.length ?? null,
         userWait: patch.userWait ?? null,
         replyDelivery: patch.replyDelivery ?? null,
@@ -1427,6 +1429,32 @@ function parseDialogGenerationRunState(value) {
     }
     return null;
 }
+function parseDialogBackendDriveStallState(value) {
+    if (!isRecord(value))
+        return null;
+    if (value.kind !== 'backend_drive_error')
+        return null;
+    if (typeof value.recordId !== 'string' || value.recordId.trim() === '')
+        return null;
+    if (typeof value.durableWorkFingerprint !== 'string' ||
+        value.durableWorkFingerprint.trim() === '') {
+        return null;
+    }
+    if (typeof value.failedAt !== 'string' || value.failedAt.trim() === '')
+        return null;
+    if (value.errorName !== undefined && typeof value.errorName !== 'string')
+        return null;
+    if (typeof value.errorMessage !== 'string' || value.errorMessage.trim() === '')
+        return null;
+    return {
+        kind: 'backend_drive_error',
+        recordId: value.recordId,
+        durableWorkFingerprint: value.durableWorkFingerprint,
+        failedAt: value.failedAt,
+        ...(value.errorName === undefined ? {} : { errorName: value.errorName }),
+        errorMessage: value.errorMessage,
+    };
+}
 function parseStringArrayField(value) {
     if (!Array.isArray(value))
         return null;
@@ -1471,6 +1499,35 @@ function parseDialogFollowupReason(value) {
             return null;
     }
 }
+function parseDialogBusinessContinuation(value) {
+    if (!isRecord(value))
+        return null;
+    switch (value.kind) {
+        case 'none':
+            return { kind: 'none' };
+        case 'inter_dialog_reply': {
+            const tellaskReplyDirective = parseTellaskReplyDirective(value.tellaskReplyDirective);
+            if (tellaskReplyDirective === null)
+                return null;
+            if (value.calleeDialogReplyTarget === undefined) {
+                return {
+                    kind: 'inter_dialog_reply',
+                    tellaskReplyDirective,
+                };
+            }
+            const calleeDialogReplyTarget = parseDialogCalleeReplyTarget(value.calleeDialogReplyTarget);
+            if (calleeDialogReplyTarget === null)
+                return null;
+            return {
+                kind: 'inter_dialog_reply',
+                tellaskReplyDirective,
+                calleeDialogReplyTarget,
+            };
+        }
+        default:
+            return null;
+    }
+}
 function parseDialogNextStepTrigger(value) {
     if (!isRecord(value))
         return null;
@@ -1537,6 +1594,13 @@ function parseDialogNextStepTrigger(value) {
                     return null;
                 reasons.push(reason);
             }
+            const continuation = (() => {
+                if (value.continuation === undefined)
+                    return undefined;
+                return parseDialogBusinessContinuation(value.continuation);
+            })();
+            if (continuation === null)
+                return null;
             return {
                 ...base,
                 kind: 'followup',
@@ -1545,6 +1609,7 @@ function parseDialogNextStepTrigger(value) {
                     genseq: (0, storage_1.toCallSiteGenseqNo)(genseq),
                 },
                 reasons,
+                ...(continuation === undefined ? {} : { continuation }),
             };
         }
         case 'mainline_diligence': {
@@ -1916,6 +1981,12 @@ function parseDialogLatestFile(value) {
         : parseDialogGenerationRunState(generationRunStateRaw);
     if (generationRunState === null)
         return null;
+    const backendDriveStallRaw = value.backendDriveStall;
+    const backendDriveStall = backendDriveStallRaw === undefined
+        ? undefined
+        : parseDialogBackendDriveStallState(backendDriveStallRaw);
+    if (backendDriveStall === null)
+        return null;
     const nextStepRaw = value.nextStep;
     if (nextStepRaw === undefined)
         return null;
@@ -2072,6 +2143,7 @@ function parseDialogLatestFile(value) {
         displayState,
         executionMarker,
         generationRunState,
+        backendDriveStall,
         nextStep,
         userWait,
         replyDelivery,
@@ -2685,6 +2757,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                         generating: true,
                         displayState: { kind: 'proceeding' },
                         executionMarker: undefined,
+                        backendDriveStall: undefined,
                         nextStep,
                         generationRunState: {
                             kind: 'open',
@@ -2707,6 +2780,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         catch (err) {
             log_1.log.warn('Failed to persist gen_start event', err);
         }
+        return acceptedTriggers;
     }
     getResultArrivalBatchIdsFromAcceptedTriggers(triggerIds) {
         const batchIds = [];
@@ -4741,6 +4815,14 @@ class DialogPersistence {
         this.driveWatchMutexes.set(key, created);
         return created;
     }
+    static getBackendDriveStallMutex(key) {
+        const existing = this.backendDriveStallMutexes.get(key);
+        if (existing)
+            return existing;
+        const created = new async_fifo_mutex_1.AsyncFifoMutex();
+        this.backendDriveStallMutexes.set(key, created);
+        return created;
+    }
     static getLatestWriteBackKey(dialogId, status) {
         // Include dialogs root dir to avoid cross-test/process.cwd collisions.
         return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}`;
@@ -4748,6 +4830,9 @@ class DialogPersistence {
     static getDriveWatchKey(rootDialogId, status) {
         return `${this.getDialogsRootDir()}|${status}|${rootDialogId.rootId}|drive-watch`;
     }
+    static getBackendDriveStallKey(dialogId, status) {
+        return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}|backend-drive-stall`;
+    }
     static getQ4HWriteBackKey(dialogId, status) {
         // Include dialogs root dir to avoid cross-test/process.cwd collisions.
         return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}|q4h`;
@@ -6716,6 +6801,73 @@ class DialogPersistence {
         await fs.promises.writeFile(tempFile, jsonContent, 'utf-8');
         await this.renameWithRetry(tempFile, filePath, 5);
     }
+    static getBackendDriveStallJsonlPath(dialogId, status) {
+        return path.join(this.getDialogEventsPath(dialogId, status), 'backend-drive-stalls.jsonl');
+    }
+    static buildBackendDriveDurableWorkFingerprint(latest, watchedDialogIds = []) {
+        if (latest === null) {
+            return JSON.stringify({ latest: null });
+        }
+        const nextStepTriggers = sortNextStepTriggersForConsumption(latest.nextStep.triggers).map((trigger) => ({
+            triggerId: trigger.triggerId,
+            kind: trigger.kind,
+            seq: trigger.seq,
+            createdAt: trigger.createdAt,
+            payload: trigger,
+        }));
+        return JSON.stringify({
+            currentCourse: latest.currentCourse,
+            status: latest.status,
+            generating: latest.generating ?? false,
+            displayState: latest.displayState ?? null,
+            executionMarker: latest.executionMarker ?? null,
+            nextStepTriggers,
+            pendingRuntimePromptMsgId: latest.pendingRuntimePrompt?.msgId ?? null,
+            generationRunState: latest.generationRunState ?? null,
+            replyDelivery: latest.replyDelivery ?? null,
+            sideDialogFinalResponse: latest.sideDialogFinalResponse ?? null,
+            latestAssignmentAnchor: latest.latestAssignmentAnchor ?? null,
+            userWait: latest.userWait ?? null,
+            watchedDialogIds: watchedDialogIds.map((dialogId) => dialogId.valueOf()).sort(),
+        });
+    }
+    static async appendBackendDriveStallRecord(dialogId, write, status = 'running') {
+        const recordedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        const record = {
+            ...write,
+            recordId: (0, node_crypto_1.randomUUID)(),
+            recordedAt,
+        };
+        const key = this.getBackendDriveStallKey(dialogId, status);
+        const mutex = this.getBackendDriveStallMutex(key);
+        const release = await mutex.acquire();
+        try {
+            const filePath = this.getBackendDriveStallJsonlPath(dialogId, status);
+            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.promises.appendFile(filePath, `${JSON.stringify(record)}\n`, 'utf-8');
+            await this.mutateDialogLatest(dialogId, () => ({
+                kind: 'patch',
+                patch: {
+                    backendDriveStall: {
+                        kind: 'backend_drive_error',
+                        recordId: record.recordId,
+                        durableWorkFingerprint: write.durableWorkFingerprint,
+                        failedAt: recordedAt,
+                        ...(write.error.name === undefined ? {} : { errorName: write.error.name }),
+                        errorMessage: write.error.message,
+                    },
+                },
+            }), status);
+            return record;
+        }
+        finally {
+            release();
+            const current = this.backendDriveStallMutexes.get(key);
+            if (current === mutex && !mutex.isLocked()) {
+                this.backendDriveStallMutexes.delete(key);
+            }
+        }
+    }
     static async mutateDriveWatch(rootDialogId, mutator, status = 'running') {
         const key = this.getDriveWatchKey(rootDialogId, status);
         const mutex = this.getDriveWatchMutex(key);
@@ -8632,5 +8784,6 @@ DialogPersistence.q4hWriteBackMutexes = new Map();
 DialogPersistence.q4hWriteBack = new Map();
 DialogPersistence.activeCalleesMutexes = new Map();
 DialogPersistence.driveWatchMutexes = new Map();
+DialogPersistence.backendDriveStallMutexes = new Map();
 DialogPersistence.courseAppendMutexes = new Map();
 DialogPersistence.mainDialogWriteBackCancelGenerations = new Map();

package/dist/runtime/driver-messages.d.ts

@@ -1,5 +1,6 @@
 import { type LanguageCode } from '@longrun-ai/kernel/types/language';
 export declare function formatSystemNoticePrefix(language: LanguageCode): string;
+export declare function isAgentFacingCriticalUserInterjectionRemediationGuideContent(content: string): boolean;
 export declare function formatAutoMaintainedReminderManualMirrorBan(language: LanguageCode): string;
 export declare function formatCurrentUserLanguagePreference(workingLanguage: LanguageCode, uiLanguage: LanguageCode): string;
 export declare function formatUserLanguagePreferenceChangedNotice(workingLanguage: LanguageCode, previousUiLanguage: LanguageCode, nextUiLanguage: LanguageCode): string;

package/dist/runtime/driver-messages.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSystemNoticePrefix = formatSystemNoticePrefix;
+exports.isAgentFacingCriticalUserInterjectionRemediationGuideContent = isAgentFacingCriticalUserInterjectionRemediationGuideContent;
 exports.formatAutoMaintainedReminderManualMirrorBan = formatAutoMaintainedReminderManualMirrorBan;
 exports.formatCurrentUserLanguagePreference = formatCurrentUserLanguagePreference;
 exports.formatUserLanguagePreferenceChangedNotice = formatUserLanguagePreferenceChangedNotice;
@@ -23,6 +24,10 @@ const language_1 = require("@longrun-ai/kernel/types/language");
 function formatSystemNoticePrefix(language) {
     return language === 'zh' ? '【系统提示】' : '[System notice]';
 }
+function isAgentFacingCriticalUserInterjectionRemediationGuideContent(content) {
+    return (content.startsWith(`${formatSystemNoticePrefix('zh')} 上下文状态：🔴 告急；收到用户插话`) ||
+        content.startsWith(`${formatSystemNoticePrefix('en')} Context state: 🔴 critical; user interjection received`));
+}
 function formatAutoMaintainedReminderManualMirrorBan(language) {
     return language === 'zh'
         ? '这条状态由系统维护；禁止把它抄进、改写进、或同步维护到你手工创建的提醒项里。'
@@ -570,7 +575,7 @@ function formatAgentFacingCriticalUserInterjectionRemediationGuide(language, arg
         return [
             `${formatSystemNoticePrefix(language)} 上下文状态：🔴 告急；收到用户插话`,
             '',
-            '下面紧跟的是一条真实用户消息，不是普通运行时处置提示；必须把它当作有效用户轮次处理，让用户看到你已经接住了这次插话。',
+            '本轮刚收到的用户消息是真实用户插话，不是普通运行时处置提示；必须把它当作有效用户轮次处理，让用户看到你已经接住了这次插话。',
             '',
             `这次用户轮次已计入告急处置倒计数。系统最多再提醒你 ${args.promptsRemainingAfterThis} 次，之后将自动清理头脑开启新一程对话。`,
             '',
@@ -584,7 +589,7 @@ function formatAgentFacingCriticalUserInterjectionRemediationGuide(language, arg
     return [
         `${formatSystemNoticePrefix(language)} Context state: 🔴 critical; user interjection received`,
         '',
-        'The next message is a real user message, not an ordinary runtime remediation notice. Treat it as an effective user turn and make the system reaction visible to the user.',
+        'The user message just received in this turn is a real user interjection, not an ordinary runtime remediation notice. Treat it as an effective user turn and make the system reaction visible to the user.',
         '',
         `This user turn has been counted toward critical remediation. System will remind you ${args.promptsRemainingAfterThis} more time(s), then automatically clear mind.`,
         '',

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

@@ -2,12 +2,25 @@ import type { DomindsRuntimeMode, WebSocketMessage } from '@longrun-ai/kernel/ty
 import { type LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { Server } from 'http';
 import { WebSocket, WebSocketServer } from 'ws';
+import { Dialog } from '../dialog';
 import type { AuthConfig } from './auth';
+export declare function resolveUserMessageLanguageCodeForTest(args: {
+    ws: WebSocket;
+    raw: unknown;
+    fallbackDialog?: Dialog;
+}): LanguageCode;
 export declare function shouldQueueUserSupplementAtGenerationBoundary(args: {
     latestGenerating: boolean;
     inMemoryGenerating: boolean;
     isLocked: boolean;
 }): boolean;
+type UserMessageIngressPrompt = {
+    content: string;
+    msgId: string;
+    grammar: 'markdown';
+    userLanguageCode?: LanguageCode;
+};
+export declare function wrapCriticalUserInterjectionPromptAtIngress(dialog: Dialog, prompt: UserMessageIngressPrompt): UserMessageIngressPrompt;
 /**
  * Handle incoming WebSocket messages
  */
@@ -20,3 +33,4 @@ export declare function setupWebSocketServer(httpServer: Server, clients: Set<We
  * Clean up all event channels and subscriptions
  */
 export declare function cleanupEventSystems(): void;
+export {};