dominds 1.24.2 → 1.24.3

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

@@ -70,6 +70,125 @@ async function queueReplyReminderFollowUp(args) {
 function isReplyToolReminderPrompt(prompt) {
     return typeof prompt?.content === 'string' && (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.content);
 }
+function hasSameReplyDirective(left, right) {
+    return (left.expectedReplyCallName === right.expectedReplyCallName &&
+        left.targetDialogId === right.targetDialogId &&
+        left.targetCallId === right.targetCallId &&
+        left.tellaskContent === right.tellaskContent);
+}
+function buildCurrentSideDialogAssignmentReplyDirective(dialog) {
+    switch (dialog.assignmentFromAsker.callName) {
+        case 'tellask':
+            return {
+                expectedReplyCallName: 'replyTellask',
+                targetDialogId: dialog.assignmentFromAsker.askerDialogId,
+                targetCallId: dialog.assignmentFromAsker.callId,
+                tellaskContent: dialog.assignmentFromAsker.tellaskContent,
+            };
+        case 'tellaskSessionless':
+        case 'freshBootsReasoning':
+            return {
+                expectedReplyCallName: 'replyTellaskSessionless',
+                targetDialogId: dialog.assignmentFromAsker.askerDialogId,
+                targetCallId: dialog.assignmentFromAsker.callId,
+                tellaskContent: dialog.assignmentFromAsker.tellaskContent,
+            };
+        default: {
+            const _exhaustive = dialog.assignmentFromAsker.callName;
+            throw new Error(`Unsupported sideDialog assignment callName: ${_exhaustive}`);
+        }
+    }
+}
+function isQueuedReplyObligationContinuation(prompt) {
+    return ((prompt.kind === 'new_course_runtime_reply' ||
+        prompt.kind === 'new_course_runtime_sideDialog') &&
+        (0, reply_prompt_copy_1.isReplyToolReminderPromptContent)(prompt.prompt));
+}
+function latestHasTellaskResultForCallId(latest, targetCallId) {
+    return (latest?.tellaskResults.results.some((entry) => entry.callId.trim() === targetCallId) === true);
+}
+async function claimQueuedReplyObligationContinuation(args) {
+    const directive = args.prompt.tellaskReplyDirective;
+    const targetCallId = directive.targetCallId.trim();
+    const targetDialogId = directive.targetDialogId.trim();
+    if (targetCallId === '' || targetDialogId === '') {
+        throw new Error(`reply obligation continuation invariant violation: empty target identity ` +
+            `(dialog=${args.dialog.id.valueOf()}, targetDialogId=${directive.targetDialogId}, targetCallId=${directive.targetCallId})`);
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    if (latest?.sideDialogFinalResponse?.callId.trim() === targetCallId) {
+        return 'stale';
+    }
+    if (latestHasTellaskResultForCallId(latest, targetCallId)) {
+        return 'stale';
+    }
+    const targetLatest = targetDialogId === args.dialog.id.selfId
+        ? latest
+        : await persistence_1.DialogPersistence.loadDialogLatest(new dialog_1.DialogID(targetDialogId, args.dialog.id.rootId), args.dialog.status);
+    if (latestHasTellaskResultForCallId(targetLatest, targetCallId)) {
+        return 'stale';
+    }
+    if (args.dialog instanceof dialog_1.SideDialog) {
+        const assignmentDirective = buildCurrentSideDialogAssignmentReplyDirective(args.dialog);
+        if (hasSameReplyDirective(assignmentDirective, directive)) {
+            return 'claimed';
+        }
+    }
+    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
+    if (!activeDirective) {
+        return 'stale';
+    }
+    if (activeDirective.targetCallId !== directive.targetCallId) {
+        return 'stale';
+    }
+    if (!hasSameReplyDirective(activeDirective, directive)) {
+        throw new Error(`reply obligation continuation invariant violation: active obligation changed for callId=${directive.targetCallId} ` +
+            `(dialog=${args.dialog.id.valueOf()}, expectedReplyCallName=${directive.expectedReplyCallName}, ` +
+            `activeReplyCallName=${activeDirective.expectedReplyCallName}, targetDialogId=${directive.targetDialogId}, ` +
+            `activeTargetDialogId=${activeDirective.targetDialogId})`);
+    }
+    return 'claimed';
+}
+async function resolveSideDialogReplyDirectiveForAssistantOutput(args) {
+    const replyTarget = args.replyTarget;
+    const targetCallId = replyTarget?.callId.trim();
+    if (!replyTarget || !targetCallId) {
+        return args.currentDirective;
+    }
+    if (args.currentDirective?.targetCallId === targetCallId) {
+        return args.currentDirective;
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
+    if (!latest) {
+        return args.currentDirective;
+    }
+    if (latest.sideDialogFinalResponse?.callId.trim() === targetCallId) {
+        return args.currentDirective;
+    }
+    if (latestHasTellaskResultForCallId(latest, targetCallId)) {
+        return args.currentDirective;
+    }
+    const assignmentDirective = buildCurrentSideDialogAssignmentReplyDirective(args.dialog);
+    if (assignmentDirective.targetCallId !== targetCallId) {
+        return args.currentDirective;
+    }
+    if (assignmentDirective.targetDialogId !== replyTarget.callerDialogId ||
+        assignmentDirective.targetCallId !== replyTarget.callId) {
+        return args.currentDirective;
+    }
+    const latestAssignmentAnchor = latest.latestAssignmentAnchor;
+    if (latestAssignmentAnchor?.callId !== targetCallId ||
+        args.responseGenseq < latestAssignmentAnchor.assignmentGenseq) {
+        return args.currentDirective;
+    }
+    const activeDirective = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
+    if (activeDirective && !hasSameReplyDirective(activeDirective, assignmentDirective)) {
+        throw new Error(`sideDialog assistant output reply directive invariant violation: active obligation does not match latest assignment ` +
+            `(dialog=${args.dialog.id.valueOf()}, targetCallId=${targetCallId}, ` +
+            `activeTargetCallId=${activeDirective.targetCallId}, assignmentTargetCallId=${assignmentDirective.targetCallId})`);
+    }
+    return activeDirective ?? assignmentDirective;
+}
 function hasQ4HAnswerCallId(callId) {
     return typeof callId === 'string' && callId.trim() !== '';
 }
@@ -294,13 +413,6 @@ async function clearStaleSideDialogRunControlForFinalResponse(args) {
         previousNextStepTriggerCount: latest.nextStep.triggers.length,
     };
 }
-function hasNoPromptSideDialogResumeEntitlement(dialog, driveOptions) {
-    const entitlement = driveOptions?.noPromptSideDialogResumeEntitlement;
-    if (!entitlement) {
-        return false;
-    }
-    return entitlement.callerDialogId === dialog.id.selfId;
-}
 function hasResultArrivalTrigger(latest) {
     return latest?.nextStep.triggers.some((trigger) => trigger.kind === 'result_arrival') === true;
 }
@@ -418,10 +530,6 @@ async function inspectNoPromptSideDialogDrive(args) {
     const supplyResponseCallerReviveAllowed = hasCallerReviveEntitlement(args.dialog, args.driveOptions) &&
         (!resolvedPendingSideDialogReplyEntitlement || resultArrivalTriggerPresent);
     const backendLoopDurableWorkAllowed = source === 'kernel_driver_backend_loop' && resultArrivalTriggerPresent;
-    const replyObligationFollowUpAllowed = source === 'kernel_driver_follow_up' &&
-        args.driveOptions?.noPromptSideDialogResumeEntitlement?.reason ===
-            'reply_obligation_follow_up' &&
-        hasNoPromptSideDialogResumeEntitlement(args.dialog, args.driveOptions);
     const finalResponseResultArrivalReviveAllowed = sideDialogFinalResponseCallId !== undefined &&
         ((resolvedPendingSideDialogReplyEntitlement && resultArrivalTriggerPresent) ||
             backendLoopDurableWorkAllowed ||
@@ -436,11 +544,20 @@ async function inspectNoPromptSideDialogDrive(args) {
             sideDialogFinalResponseCallId,
         };
     }
+    if (resolvedPendingSideDialogReplyEntitlement && !resultArrivalTriggerPresent) {
+        return {
+            shouldReject: true,
+            source,
+            rejection: 'stale_consumed_result_arrival',
+            displayState,
+            currentCourse,
+            sideDialogFinalResponseCallId,
+        };
+    }
     if (!explicitInterruptedResumeAllowed &&
         !inProgressGenerationResumeAllowed &&
         !supplyResponseCallerReviveAllowed &&
-        !backendLoopDurableWorkAllowed &&
-        !replyObligationFollowUpAllowed) {
+        !backendLoopDurableWorkAllowed) {
         return {
             shouldReject: true,
             source,
@@ -544,71 +661,96 @@ async function surfaceRuntimeGuide(dialog, content) {
 }
 async function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
-        return { prompt: humanPrompt, fromUpNext: false };
+        return { prompt: humanPrompt, fromUpNext: false, droppedStaleQueuedContinuation: false };
     }
-    const upNext = dialog.peekUpNext();
-    if (!upNext) {
-        return {
-            prompt: await maybeResolveDeferredReplyReassertionPrompt(dialog),
-            fromUpNext: false,
-        };
-    }
-    return {
-        fromUpNext: true,
-        prompt: (() => {
-            const normalizedUserLanguageCode = upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
-                ? upNext.userLanguageCode
-                : undefined;
-            const common = {
-                content: upNext.prompt,
-                msgId: upNext.msgId,
-                grammar: upNext.grammar ?? 'markdown',
-                userLanguageCode: normalizedUserLanguageCode,
-                runControl: upNext.runControl,
+    let droppedStaleQueuedContinuation = false;
+    for (;;) {
+        const upNext = dialog.peekUpNext();
+        if (!upNext) {
+            return {
+                prompt: await maybeResolveDeferredReplyReassertionPrompt(dialog),
+                fromUpNext: false,
+                droppedStaleQueuedContinuation,
             };
-            switch (upNext.kind) {
-                case 'user_generation_boundary':
-                case 'deferred_q4h_answer': {
-                    const prompt = {
-                        ...common,
-                        origin: 'user',
-                        ...(upNext.q4hAnswerCallId === undefined
-                            ? {}
-                            : { q4hAnswerCallId: upNext.q4hAnswerCallId }),
-                    };
-                    return prompt;
+        }
+        if (isQueuedReplyObligationContinuation(upNext)) {
+            const claim = await claimQueuedReplyObligationContinuation({ dialog, prompt: upNext });
+            if (claim === 'stale') {
+                const discarded = dialog.takeUpNext();
+                if (!discarded || discarded.msgId !== upNext.msgId) {
+                    throw new Error(`reply obligation continuation invariant violation: expected queued prompt ${upNext.msgId} before stale discard`);
                 }
-                case 'registered_assignment_update':
-                case 'new_course_runtime_guide':
-                case 'new_course_runtime_reply':
-                case 'new_course_runtime_sideDialog': {
-                    const runtimeCommon = {
-                        ...common,
-                        origin: 'runtime',
-                        ...(upNext.skipTaskdoc === undefined ? {} : { skipTaskdoc: upNext.skipTaskdoc }),
-                    };
-                    if (upNext.kind === 'registered_assignment_update' ||
-                        upNext.kind === 'new_course_runtime_sideDialog') {
+                await persistence_1.DialogPersistence.clearPendingRuntimePrompt(dialog.id, upNext.msgId, dialog.status);
+                log_1.log.debug('kernel-driver dropped stale reply obligation continuation', undefined, {
+                    dialogId: dialog.id.valueOf(),
+                    rootId: dialog.id.rootId,
+                    selfId: dialog.id.selfId,
+                    msgId: upNext.msgId,
+                    targetCallId: upNext.tellaskReplyDirective.targetCallId,
+                    expectedReplyCallName: upNext.tellaskReplyDirective.expectedReplyCallName,
+                });
+                droppedStaleQueuedContinuation = true;
+                continue;
+            }
+        }
+        return {
+            fromUpNext: true,
+            droppedStaleQueuedContinuation,
+            prompt: (() => {
+                const normalizedUserLanguageCode = upNext.userLanguageCode === 'zh' || upNext.userLanguageCode === 'en'
+                    ? upNext.userLanguageCode
+                    : undefined;
+                const common = {
+                    content: upNext.prompt,
+                    msgId: upNext.msgId,
+                    grammar: upNext.grammar ?? 'markdown',
+                    userLanguageCode: normalizedUserLanguageCode,
+                    runControl: upNext.runControl,
+                };
+                switch (upNext.kind) {
+                    case 'user_generation_boundary':
+                    case 'deferred_q4h_answer': {
                         const prompt = {
-                            ...runtimeCommon,
-                            tellaskReplyDirective: upNext.tellaskReplyDirective,
-                            calleeDialogReplyTarget: upNext.calleeDialogReplyTarget,
+                            ...common,
+                            origin: 'user',
+                            ...(upNext.q4hAnswerCallId === undefined
+                                ? {}
+                                : { q4hAnswerCallId: upNext.q4hAnswerCallId }),
                         };
                         return prompt;
                     }
-                    if (upNext.kind === 'new_course_runtime_reply') {
-                        const prompt = {
-                            ...runtimeCommon,
-                            tellaskReplyDirective: upNext.tellaskReplyDirective,
+                    case 'registered_assignment_update':
+                    case 'new_course_runtime_guide':
+                    case 'new_course_runtime_reply':
+                    case 'new_course_runtime_sideDialog': {
+                        const runtimeCommon = {
+                            ...common,
+                            origin: 'runtime',
+                            ...(upNext.skipTaskdoc === undefined ? {} : { skipTaskdoc: upNext.skipTaskdoc }),
                         };
+                        if (upNext.kind === 'registered_assignment_update' ||
+                            upNext.kind === 'new_course_runtime_sideDialog') {
+                            const prompt = {
+                                ...runtimeCommon,
+                                tellaskReplyDirective: upNext.tellaskReplyDirective,
+                                calleeDialogReplyTarget: upNext.calleeDialogReplyTarget,
+                            };
+                            return prompt;
+                        }
+                        if (upNext.kind === 'new_course_runtime_reply') {
+                            const prompt = {
+                                ...runtimeCommon,
+                                tellaskReplyDirective: upNext.tellaskReplyDirective,
+                            };
+                            return prompt;
+                        }
+                        const prompt = runtimeCommon;
                         return prompt;
                     }
-                    const prompt = runtimeCommon;
-                    return prompt;
                 }
-            }
-        })(),
-    };
+            })(),
+        };
+    }
 }
 async function executeDriveRound(args) {
     const [dialog, humanPrompt, waitInQue, driveOptions] = args.driveArgs;
@@ -656,7 +798,7 @@ async function executeDriveRound(args) {
                     if (!cleanup.cleared) {
                         await persistence_1.DialogPersistence.removeDriveWatchForDialog(dialog.id, dialog.status);
                     }
-                    log_1.log.warn('Dropped stale no-prompt sideDialog drive after final response anchor', undefined, {
+                    log_1.log.debug('Dropped stale no-prompt sideDialog drive after final response anchor', undefined, {
                         dialogId: dialog.id.valueOf(),
                         rootId: dialog.id.rootId,
                         selfId: dialog.id.selfId,
@@ -713,6 +855,22 @@ async function executeDriveRound(args) {
                 try {
                     const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });
                     if (inspection.shouldReject) {
+                        if (inspection.rejection === 'stale_consumed_result_arrival') {
+                            log_1.log.debug('Dropped stale no-prompt sideDialog caller revive after result arrival', undefined, {
+                                dialogId: dialog.id.valueOf(),
+                                rootId: dialog.id.rootId,
+                                selfId: dialog.id.selfId,
+                                source: inspection.source,
+                                reason: driveOptions?.reason ?? null,
+                                rejection: inspection.rejection,
+                                allowResumeFromInterrupted: driveOptions?.allowResumeFromInterrupted === true,
+                                displayState: inspection.displayState ?? null,
+                                currentCourse: inspection.currentCourse,
+                                sideDialogFinalResponseCallId: inspection.sideDialogFinalResponseCallId ?? null,
+                                waitInQue,
+                            });
+                            return;
+                        }
                         log_1.log.error('Rejected unexpected no-prompt sideDialog drive request', undefined, {
                             dialogId: dialog.id.valueOf(),
                             rootId: dialog.id.rootId,
@@ -909,6 +1067,18 @@ async function executeDriveRound(args) {
             dialog,
             latest: latestBeforeCore,
         }));
+        if (resolvedPrompt.droppedStaleQueuedContinuation &&
+            effectivePrompt === undefined &&
+            !(0, dialog_drive_work_1.hasDurableDriveWork)(latestBeforeCore)) {
+            log_1.log.debug('kernel-driver stopped after dropping stale queued continuation', undefined, {
+                dialogId: dialog.id.valueOf(),
+                rootId: dialog.id.rootId,
+                selfId: dialog.id.selfId,
+                source: driveSource,
+                reason: driveOptions?.reason ?? null,
+            });
+            return;
+        }
         await applyRegisteredDialogRunControlsBeforeDrive({
             dialog,
             humanPrompt,
@@ -942,7 +1112,7 @@ async function executeDriveRound(args) {
                 replyGuidance.deferredReplyReassertionDirective !== undefined;
         activeTellaskReplyDirective = replyGuidance.activeReplyDirective;
         activePromptWasReplyToolReminder = isReplyToolReminderPrompt(effectivePrompt);
-        const activePromptCarriesReplyDirective = effectivePrompt?.tellaskReplyDirective !== undefined &&
+        let activePromptCarriesReplyDirective = effectivePrompt?.tellaskReplyDirective !== undefined &&
             activeTellaskReplyDirective !== undefined &&
             effectivePrompt.tellaskReplyDirective.targetCallId ===
                 activeTellaskReplyDirective.targetCallId;
@@ -973,7 +1143,31 @@ async function executeDriveRound(args) {
         calleeDialogReplyTarget = driveResult.lastAssistantReplyTarget ?? calleeDialogReplyTarget;
         interruptedBySignal = (0, dialog_display_state_1.getActiveRunSignal)(dialog.id)?.aborted === true;
         if (!interruptedBySignal) {
-            followUp = dialog.takeUpNext();
+            const queuedFollowUp = dialog.takeUpNext();
+            if (queuedFollowUp && isQueuedReplyObligationContinuation(queuedFollowUp)) {
+                const claim = await claimQueuedReplyObligationContinuation({
+                    dialog,
+                    prompt: queuedFollowUp,
+                });
+                if (claim === 'stale') {
+                    await persistence_1.DialogPersistence.clearPendingRuntimePrompt(dialog.id, queuedFollowUp.msgId, dialog.status);
+                    log_1.log.debug('kernel-driver dropped stale reply obligation follow-up after core', undefined, {
+                        dialogId: dialog.id.valueOf(),
+                        rootId: dialog.id.rootId,
+                        selfId: dialog.id.selfId,
+                        msgId: queuedFollowUp.msgId,
+                        targetCallId: queuedFollowUp.tellaskReplyDirective.targetCallId,
+                        expectedReplyCallName: queuedFollowUp.tellaskReplyDirective.expectedReplyCallName,
+                    });
+                    followUp = undefined;
+                }
+                else {
+                    followUp = queuedFollowUp;
+                }
+            }
+            else {
+                followUp = queuedFollowUp;
+            }
         }
         let tailError;
         try {
@@ -1021,6 +1215,31 @@ async function executeDriveRound(args) {
                         });
                     }
                     else {
+                        const replyDirectiveForAssistantOutput = await resolveSideDialogReplyDirectiveForAssistantOutput({
+                            dialog,
+                            responseGenseq: directFallbackResponse.responseGenseq,
+                            replyTarget: driveResult.lastAssistantReplyTarget,
+                            currentDirective: activeTellaskReplyDirective,
+                        });
+                        if (replyDirectiveForAssistantOutput !== undefined &&
+                            replyDirectiveForAssistantOutput.targetCallId !==
+                                activeTellaskReplyDirective?.targetCallId) {
+                            // `driveDialogStreamCore` may already have consumed a queued assignment-update prompt
+                            // inside the same drive, so rebind the tail decision to the assistant output target.
+                            log_1.log.debug('kernel-driver rebound sideDialog reply directive to latest assistant output target', undefined, {
+                                dialogId: dialog.id.valueOf(),
+                                previousTargetCallId: activeTellaskReplyDirective?.targetCallId ?? null,
+                                nextTargetCallId: replyDirectiveForAssistantOutput.targetCallId,
+                                responseGenseq: directFallbackResponse.responseGenseq,
+                                replyTargetCallId: driveResult.lastAssistantReplyTarget?.callId ?? null,
+                            });
+                        }
+                        activeTellaskReplyDirective = replyDirectiveForAssistantOutput;
+                        activePromptCarriesReplyDirective =
+                            activePromptCarriesReplyDirective ||
+                                (activeTellaskReplyDirective !== undefined &&
+                                    driveResult.lastAssistantReplyTarget?.callId ===
+                                        activeTellaskReplyDirective.targetCallId);
                         const hasFollowUp = followUp !== undefined;
                         const suspension = await dialog.getSuspensionStatus();
                         const backgroundCalleeBlocksImplicitReply = suspension.backgroundCalleeDialogs &&
@@ -1195,12 +1414,6 @@ async function executeDriveRound(args) {
                         driveOptions: {
                             source: 'kernel_driver_follow_up',
                             reason: 'follow_up_prompt',
-                            noPromptSideDialogResumeEntitlement: dialog instanceof dialog_1.SideDialog
-                                ? {
-                                    callerDialogId: dialog.id.selfId,
-                                    reason: 'reply_obligation_follow_up',
-                                }
-                                : undefined,
                         },
                     });
                     return driveResult;

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

@@ -21,9 +21,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';

package/dist/persistence.d.ts

@@ -478,6 +478,7 @@ export declare class DialogPersistence {
     private static loadDriveWatchFromDisk;
     private static writeDriveWatchToDisk;
     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

@@ -412,6 +412,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');
@@ -6696,7 +6706,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);
@@ -6720,6 +6730,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 +7781,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.24.2",
+  "version": "1.24.3",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -53,8 +53,8 @@
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
     "@longrun-ai/codex-auth": "0.13.0",
-    "@longrun-ai/kernel": "1.14.0",
-    "@longrun-ai/shell": "1.14.0"
+    "@longrun-ai/shell": "1.14.0",
+    "@longrun-ai/kernel": "1.14.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",

package/webapp/dist/assets/{_basePickBy-DBvh4H3k.js → _basePickBy-ZLV93S3E.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-CQmc9B-o.js";
-import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-DuQ1OCMG.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-D0wSOJ06.js";
+import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-CDCDAfqP.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-DBvh4H3k.js.map
+//# sourceMappingURL=_basePickBy-ZLV93S3E.js.map