dominds 1.24.2 → 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/reply-guidance.js

@@ -125,9 +125,6 @@ async function resolveFreshCurrentSideDialogAssignmentDirective(args) {
     if (!latest) {
         return undefined;
     }
-    if (latest.pendingRuntimePrompt?.msgId !== args.prompt.msgId) {
-        return undefined;
-    }
     if (latest.sideDialogFinalResponse?.callId === currentAssignmentDirective.targetCallId.trim()) {
         return undefined;
     }

package/dist/llm/kernel-driver/tellask-special.d.ts

@@ -122,6 +122,7 @@ export type TellaskFunctionRoundResult = Readonly<{
     hasImmediateTellaskOutputs: boolean;
     immediateTellaskOutputCallIds: readonly string[];
     shouldStopAfterReplyTool: boolean;
+    shouldStopAfterPendingTellaskWait: boolean;
 }>;
 export declare function processTellaskFunctionRound(args: {
     dlg: Dialog;

package/dist/llm/kernel-driver/tellask-special.js

@@ -2390,6 +2390,7 @@ async function processTellaskFunctionRound(args) {
     const tellaskToolOutputs = [];
     const immediateTellaskOutputCallIds = [];
     let hasImmediateTellaskOutputs = false;
+    let shouldStopAfterPendingTellaskWait = false;
     for (const output of tellaskExecution.toolOutputs) {
         if (output.type === 'func_result_msg') {
             const result = output;
@@ -2445,6 +2446,7 @@ async function processTellaskFunctionRound(args) {
         });
         tellaskFuncResultByCallId.set(call.callId, pendingResult);
         tellaskFuncResults.push(pendingResult);
+        shouldStopAfterPendingTellaskWait = true;
     }
     for (const result of tellaskFuncResults) {
         await persistTellaskFuncResult(args.dlg, result);
@@ -2459,5 +2461,6 @@ async function processTellaskFunctionRound(args) {
         hasImmediateTellaskOutputs,
         immediateTellaskOutputCallIds,
         shouldStopAfterReplyTool: orderedInvalidCalls.length === 0 && tellaskExecution.successfulReplyCallIds.length > 0,
+        shouldStopAfterPendingTellaskWait,
     };
 }

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';
@@ -21,9 +28,6 @@ export type KernelDriverDriveOptions = Readonly<{
         sideDialogId?: string;
         callType?: 'A' | 'B' | 'C';
         callId?: string;
-    }> | Readonly<{
-        callerDialogId: string;
-        reason: 'reply_obligation_follow_up';
     }> | Readonly<{
         callerDialogId: string;
         reason: 'resolved_pending_sideDialog_reply';
@@ -115,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,7 +502,11 @@ 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[]>;
     private static setDialogDriveWatched;
     static syncDriveWatchForDialogLatest(dialogId: DialogID, latest: DialogLatestFile, status?: DialogStatusKind): Promise<void>;

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,
@@ -412,6 +414,16 @@ function getErrorCode(error) {
     const maybeCode = error.code;
     return typeof maybeCode === 'string' ? maybeCode : undefined;
 }
+const RETRYABLE_FILESYSTEM_ERROR_CODES = new Set(['ENOENT', 'EPERM', 'EACCES', 'EBUSY']);
+const FILESYSTEM_RETRY_BASE_DELAY_MS = 20;
+const FILESYSTEM_RETRY_MAX_DELAY_MS = 250;
+function getFilesystemRetryDelayMs(attempt) {
+    const delayMs = FILESYSTEM_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+    return Math.min(FILESYSTEM_RETRY_MAX_DELAY_MS, delayMs);
+}
+async function sleepForFilesystemRetry(attempt) {
+    await new Promise((resolve) => setTimeout(resolve, getFilesystemRetryDelayMs(attempt)));
+}
 function isGenericUnexpectedEofLikeError(error) {
     const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
     return message.includes('unexpected eof') || message.includes('unexpected end');
@@ -1417,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;
@@ -1461,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;
@@ -1527,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',
@@ -1535,6 +1609,7 @@ function parseDialogNextStepTrigger(value) {
                     genseq: (0, storage_1.toCallSiteGenseqNo)(genseq),
                 },
                 reasons,
+                ...(continuation === undefined ? {} : { continuation }),
             };
         }
         case 'mainline_diligence': {
@@ -1906,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;
@@ -2062,6 +2143,7 @@ function parseDialogLatestFile(value) {
         displayState,
         executionMarker,
         generationRunState,
+        backendDriveStall,
         nextStep,
         userWait,
         replyDelivery,
@@ -2675,6 +2757,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                         generating: true,
                         displayState: { kind: 'proceeding' },
                         executionMarker: undefined,
+                        backendDriveStall: undefined,
                         nextStep,
                         generationRunState: {
                             kind: 'open',
@@ -2697,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 = [];
@@ -4731,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()}`;
@@ -4738,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`;
@@ -6696,7 +6791,7 @@ class DialogPersistence {
         const normalized = this.normalizeDriveWatchFile(file);
         const filePath = this.getDriveWatchFilePath(rootDialogId, status);
         if (normalized.dialogs.length === 0) {
-            await fs.promises.rm(filePath, { force: true });
+            await this.removeWithRetry(filePath);
             return;
         }
         const dialogPath = this.getMainDialogPath(rootDialogId, status);
@@ -6706,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);
@@ -6720,6 +6882,24 @@ class DialogPersistence {
             release();
         }
     }
+    static async removeWithRetry(filePath, maxRetries = 5) {
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await fs.promises.rm(filePath, { force: true });
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                const errorCode = getErrorCode(error);
+                if (!RETRYABLE_FILESYSTEM_ERROR_CODES.has(errorCode ?? '') || attempt === maxRetries) {
+                    throw error;
+                }
+                await sleepForFilesystemRetry(attempt);
+            }
+        }
+        throw lastError;
+    }
     static async loadDriveWatchedDialogIds(rootDialogId, status = 'running') {
         try {
             const file = await this.loadDriveWatchFromDisk(rootDialogId, status);
@@ -7753,11 +7933,12 @@ class DialogPersistence {
                     throw error;
                 }
                 lastError = error instanceof Error ? error : new Error(String(error));
-                if (getErrorCode(error) !== 'ENOENT' || attempt === maxRetries) {
+                const errorCode = getErrorCode(error);
+                if (!RETRYABLE_FILESYSTEM_ERROR_CODES.has(errorCode ?? '') || attempt === maxRetries) {
                     throw error;
                 }
-                // Exponential backoff for ENOENT (race condition or sync issue)
-                await new Promise((resolve) => setTimeout(resolve, 20 * attempt));
+                // Exponential backoff for transient filesystem contention.
+                await sleepForFilesystemRetry(attempt);
             }
         }
         throw lastError;
@@ -8603,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();