dominds 1.25.12 → 1.25.14

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

@@ -17,19 +17,21 @@
  */
 import type { DialogDisplayState, DialogInterruptionReason } from '@longrun-ai/kernel/types/display-state';
 import type { DialogExecutionMarker, DialogLatestFile } from '@longrun-ai/kernel/types/storage';
-import type { WebSocketMessage } from '@longrun-ai/kernel/types/wire';
+import type { RunControlCountsMessage, WebSocketMessage } from '@longrun-ai/kernel/types/wire';
 import { DialogID, type Dialog } from './dialog';
 type StopRequestedReason = 'user_stop' | 'emergency_stop';
 export type RunControlCountsSnapshot = {
     proceeding: number;
     resumable: number;
 };
-export declare function setDisplayStateBroadcaster(fn: (msg: WebSocketMessage) => void): void;
+export declare function getRunControlCountsSnapshotEpoch(): string;
+export declare function setDisplayStateBroadcaster(fn: ((msg: WebSocketMessage) => void) | null): void;
 export declare function isStoppedReasonResumable(reason: DialogInterruptionReason): boolean;
 export declare function isDisplayStateResumable(state: DialogDisplayState | undefined): boolean;
 export declare function isExecutionMarkerResumable(executionMarker: DialogExecutionMarker | undefined): boolean;
 export declare function isDialogLatestResumable(latest: DialogLatestFile | null | undefined): boolean;
 export declare function getRunControlCountsSnapshot(): Promise<RunControlCountsSnapshot>;
+export declare function createRunControlCountsMessage(): Promise<RunControlCountsMessage>;
 export declare function broadcastRunControlCountsSnapshot(): Promise<void>;
 export declare function hasActiveRun(dialogId: DialogID): boolean;
 export declare function getActiveRunSignal(dialogId: DialogID): AbortSignal | undefined;

package/dist/dialog-display-state.js

@@ -17,12 +17,14 @@
  *   so multi-tab views converge without polling.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunControlCountsSnapshotEpoch = getRunControlCountsSnapshotEpoch;
 exports.setDisplayStateBroadcaster = setDisplayStateBroadcaster;
 exports.isStoppedReasonResumable = isStoppedReasonResumable;
 exports.isDisplayStateResumable = isDisplayStateResumable;
 exports.isExecutionMarkerResumable = isExecutionMarkerResumable;
 exports.isDialogLatestResumable = isDialogLatestResumable;
 exports.getRunControlCountsSnapshot = getRunControlCountsSnapshot;
+exports.createRunControlCountsMessage = createRunControlCountsMessage;
 exports.broadcastRunControlCountsSnapshot = broadcastRunControlCountsSnapshot;
 exports.hasActiveRun = hasActiveRun;
 exports.getActiveRunSignal = getActiveRunSignal;
@@ -44,6 +46,7 @@ exports.reconcileDisplayStatesAfterRestart = reconcileDisplayStatesAfterRestart;
 exports.requestInterruptDialog = requestInterruptDialog;
 exports.requestEmergencyStopAll = requestEmergencyStopAll;
 const time_1 = require("@longrun-ai/kernel/utils/time");
+const crypto_1 = require("crypto");
 const dialog_1 = require("./dialog");
 const dialog_generation_run_1 = require("./dialog-generation-run");
 const dialog_global_registry_1 = require("./dialog-global-registry");
@@ -58,8 +61,14 @@ const log = (0, log_1.createLogger)('dialog-display-state');
 let broadcastToClients;
 const activeRunsByDialogKey = new Map();
 const quarantiningMainDialogIds = new Set();
+const runControlCountsSnapshotEpoch = (0, crypto_1.randomUUID)();
+let runControlCountsSnapshotSeq = 0;
+let runControlCountsSnapshotQueue = Promise.resolve();
+function getRunControlCountsSnapshotEpoch() {
+    return runControlCountsSnapshotEpoch;
+}
 function setDisplayStateBroadcaster(fn) {
-    broadcastToClients = fn;
+    broadcastToClients = fn ?? undefined;
 }
 function syncRunControlCountsAfterActiveRunChange(trigger, dialogId) {
     void (async () => {
@@ -259,16 +268,27 @@ async function getRunControlCountsSnapshot() {
     }
     return { proceeding, resumable };
 }
-async function broadcastRunControlCountsSnapshot() {
-    if (!broadcastToClients)
-        return;
+async function createRunControlCountsMessageUnqueued() {
     const counts = await getRunControlCountsSnapshot();
-    broadcastToClients({
+    const snapshotSeq = ++runControlCountsSnapshotSeq;
+    return {
         type: 'run_control_counts_evt',
         proceeding: counts.proceeding,
         resumable: counts.resumable,
+        snapshotEpoch: runControlCountsSnapshotEpoch,
+        snapshotSeq,
         timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-    });
+    };
+}
+function createRunControlCountsMessage() {
+    const nextSnapshot = runControlCountsSnapshotQueue.then(() => createRunControlCountsMessageUnqueued());
+    runControlCountsSnapshotQueue = nextSnapshot.then(() => undefined, () => undefined);
+    return nextSnapshot;
+}
+async function broadcastRunControlCountsSnapshot() {
+    if (!broadcastToClients)
+        return;
+    broadcastToClients(await createRunControlCountsMessage());
 }
 function hasActiveRun(dialogId) {
     return activeRunsByDialogKey.has(dialogId.key());

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

@@ -1676,6 +1676,9 @@ async function executeDriveRound(args) {
                 replyContinuationScope.target() ??
                 calleeDialogReplyTarget;
         activeTellaskReplyDirective = activeTellaskReplyDirective ?? replyContinuationScope.directive();
+        if (driveResult.lastFunctionCallGenseq !== null) {
+            activePromptWasReplyToolReminder = false;
+        }
         interruptedBySignal = (0, dialog_display_state_1.getActiveRunSignal)(dialog.id)?.aborted === true;
         if (!interruptedBySignal) {
             const queuedFollowUp = dialog.peekQueuedPrompt();

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

@@ -47,5 +47,6 @@ export declare function supplySideDialogResponseToAssignedAskerIfPendingV2(args:
         callId: string;
         replyCallName: 'replyTellask' | 'replyTellaskSessionless' | 'replyTellaskBack';
     };
+    allowExplicitReplyWithoutAssignmentAnchor?: boolean;
     scheduleDrive: ScheduleDriveFn;
 }): Promise<boolean>;

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

@@ -381,15 +381,7 @@ async function supplyResponseToAskerDialog(args) {
             }), callerDialog.status);
             if (maybeSideDialog) {
                 const displayState = await (0, dialog_display_state_1.computeIdleDisplayState)(maybeSideDialog);
-                await persistence_1.DialogPersistence.mutateDialogLatest(sideDialogId, () => ({
-                    kind: 'patch',
-                    patch: {
-                        displayState,
-                        executionMarker: displayState.kind === 'stopped'
-                            ? { kind: 'interrupted', reason: displayState.reason }
-                            : undefined,
-                    },
-                }), callerDialog.status);
+                await (0, dialog_display_state_1.setDialogDisplayState)(sideDialogId, displayState, callerDialog.status);
             }
         }
         await syncPendingTellaskReminderBestEffort(callerDialog, 'kernel-driver:supplyResponseToAskerDialog');
@@ -655,18 +647,36 @@ async function supplySideDialogResponseToAssignedAskerIfPendingV2(args) {
             status: sideDialog.status,
         });
         if (!assignmentAnchorRef) {
-            log_1.log.debug('Skip assigned Type B response supply before updated assignment is rendered locally', undefined, {
-                rootId: sideDialog.mainDialog.id.rootId,
-                sideDialogId: sideDialog.id.selfId,
-                askerDialogId: askerDialog.id.selfId,
-                callId: activeCalleeDispatch.callId,
-                responseGenseq,
-            });
-            return false;
+            const replyResolution = args.replyResolution;
+            if (args.allowExplicitReplyWithoutAssignmentAnchor === true &&
+                args.deliveryMode === 'reply_tool' &&
+                replyResolution !== undefined) {
+                log_1.log.warn('Delivering assigned Type B reply without local assignment anchor', undefined, {
+                    rootId: sideDialog.mainDialog.id.rootId,
+                    sideDialogId: sideDialog.id.selfId,
+                    askerDialogId: askerDialog.id.selfId,
+                    callId: activeCalleeDispatch.callId,
+                    replyCallId: replyResolution.callId,
+                    replyCallName: replyResolution.replyCallName,
+                    responseCourse: sideDialog.currentCourse,
+                    responseGenseq,
+                });
+            }
+            else {
+                log_1.log.debug('Skip assigned Type B response supply before updated assignment is rendered locally', undefined, {
+                    rootId: sideDialog.mainDialog.id.rootId,
+                    sideDialogId: sideDialog.id.selfId,
+                    askerDialogId: askerDialog.id.selfId,
+                    callId: activeCalleeDispatch.callId,
+                    responseGenseq,
+                });
+                return false;
+            }
         }
-        if (sideDialog.currentCourse < assignmentAnchorRef.course ||
-            (sideDialog.currentCourse === assignmentAnchorRef.course &&
-                responseGenseq < assignmentAnchorRef.genseq)) {
+        if (assignmentAnchorRef !== undefined &&
+            (sideDialog.currentCourse < assignmentAnchorRef.course ||
+                (sideDialog.currentCourse === assignmentAnchorRef.course &&
+                    responseGenseq < assignmentAnchorRef.genseq))) {
             log_1.log.debug('Skip assigned stale Type B response supply from before latest local assignment', undefined, {
                 rootId: sideDialog.mainDialog.id.rootId,
                 sideDialogId: sideDialog.id.selfId,

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

@@ -1957,13 +1957,16 @@ async function executeReplyTellaskCall(args) {
                 sideDialog: args.dlg,
                 responseText: args.call.replyContent,
                 responseGenseq: genseq,
+                deliveryMode: 'reply_tool',
                 replyResolution: {
                     callId: args.call.callId,
                     replyCallName: args.call.callName,
                 },
+                allowExplicitReplyWithoutAssignmentAnchor: true,
                 scheduleDrive: args.callbacks.scheduleDrive,
             });
             if (!supplied) {
+                await persistence_1.DialogPersistence.clearPendingReplyDeliveryForCall(args.dlg.id, args.call.callId, args.dlg.status);
                 return {
                     delivered: false,
                     messages: [

package/dist/persistence.d.ts

@@ -660,6 +660,7 @@ export declare class DialogPersistence {
     static loadActiveTellaskReplyObligation(dialogId: DialogID, status?: DialogStatusKind): Promise<TellaskReplyDirective | undefined>;
     static markReplyDeliveryDelivered(dialogId: DialogID, replyCallId: string, deliveredAt: string, status?: DialogStatusKind): Promise<void>;
     static markReplyDeliveryToolResultRecorded(dialogId: DialogID, replyCallId: string, status?: DialogStatusKind): Promise<void>;
+    static clearPendingReplyDeliveryForCall(dialogId: DialogID, replyCallId: string, status?: DialogStatusKind): Promise<void>;
     static lookupRecordedTellaskCall(dialogId: DialogID, callId: string, status?: DialogStatusKind): Promise<DialogTellaskCallState['calls'][number] | undefined>;
     static recordTellaskCall(dialogId: DialogID, record: TellaskCallRecord, course: number, status?: DialogStatusKind): Promise<void>;
     static hasRecordedTellaskResult(dialogId: DialogID, callId: string, status?: DialogStatusKind): Promise<boolean>;

package/dist/persistence.js

@@ -8431,6 +8431,24 @@ class DialogPersistence {
             };
         }, status);
     }
+    static async clearPendingReplyDeliveryForCall(dialogId, replyCallId, status = 'running') {
+        await this.mutateDialogLatest(dialogId, (previous) => {
+            const replyDelivery = previous.replyDelivery;
+            if (!replyDelivery ||
+                replyDelivery.replyCallId !== replyCallId ||
+                replyDelivery.status !== 'pending') {
+                return { kind: 'noop' };
+            }
+            return {
+                kind: 'patch',
+                patch: {
+                    replyDelivery: undefined,
+                    nextStep: removeNextStepTrigger(previous.nextStep, (trigger) => trigger.kind === 'reply_delivery_recovery' &&
+                        trigger.replyDeliveryId === replyDelivery.replyDeliveryId),
+                },
+            };
+        }, status);
+    }
     static async lookupRecordedTellaskCall(dialogId, callId, status = 'running') {
         const normalizedCallId = callId.trim();
         if (normalizedCallId === '') {

package/dist/server/api-routes.js

@@ -66,6 +66,7 @@ const id_1 = require("../utils/id");
 const taskdoc_search_1 = require("../utils/taskdoc-search");
 const taskdoc_search_worker_client_1 = require("../utils/taskdoc-search-worker-client");
 const create_dialog_contract_1 = require("./create-dialog-contract");
+const dialog_forensics_routes_1 = require("./dialog-forensics-routes");
 const dominds_runtime_status_1 = require("./dominds-runtime-status");
 const dominds_self_update_1 = require("./dominds-self-update");
 const mime_types_1 = require("./mime-types");
@@ -1063,6 +1064,12 @@ async function handleApiRoute(req, res, pathname, context) {
         if (pathname === '/api/info' && req.method === 'GET') {
             return await handleGetRuntimeInfo(res, context);
         }
+        if (pathname === '/api/dialog-forensics.zip' && req.method === 'GET') {
+            return await (0, dialog_forensics_routes_1.handleDialogForensicsZipRoute)(req.url, res);
+        }
+        if (pathname === '/api/rtws/raw' && req.method === 'GET') {
+            return await handleGetRtwsRaw(req, res);
+        }
         if (pathname === '/api/dominds/self-update' && req.method === 'POST') {
             const body = await readRequestBody(req);
             let parsed;
@@ -1407,6 +1414,64 @@ async function handleApiRoute(req, res, pathname, context) {
         return true;
     }
 }
+function encodeContentDispositionFilenameStar(name) {
+    return encodeURIComponent(name).replace(/['()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function contentDispositionInlineFilename(name) {
+    const fallback = name.replace(/[^\x20-\x7e]|[\r\n\\"]/g, '_');
+    return `inline; filename="${fallback}"; filename*=UTF-8''${encodeContentDispositionFilenameStar(name)}`;
+}
+async function handleGetRtwsRaw(req, res) {
+    const urlObj = new URL(req.url ?? '', 'http://127.0.0.1');
+    const rawPath = urlObj.searchParams.get('path');
+    if (rawPath === null || rawPath.trim() === '') {
+        respondJson(res, 400, { success: false, error: '`path` is required' });
+        return true;
+    }
+    const pathRel = normalizeRtwsRelativePath(rawPath, { allowRoot: false });
+    if (pathRel === null) {
+        respondJson(res, 400, { success: false, error: 'Invalid rtws path' });
+        return true;
+    }
+    try {
+        const resolved = await resolveWorkspacePreviewPath(pathRel);
+        const stat = await promises_1.default.stat(resolved.candidateAbsPath);
+        if (!stat.isFile()) {
+            respondJson(res, 400, {
+                success: false,
+                error: 'Path must resolve to a file',
+                path: pathRel,
+            });
+            return true;
+        }
+        const headBytes = await readFileHead(resolved.candidateAbsPath, 512);
+        const mimeType = (0, mime_types_1.sniffMimeType)(pathRel, headBytes);
+        const data = await promises_1.default.readFile(resolved.candidateAbsPath);
+        res.writeHead(200, {
+            'Content-Type': mimeType,
+            'Content-Length': data.byteLength,
+            'Content-Disposition': contentDispositionInlineFilename(path.basename(pathRel)),
+            'Cache-Control': 'no-store',
+            'X-Content-Type-Options': 'nosniff',
+        });
+        res.end(data);
+        return true;
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        if (code === 'ENOENT') {
+            respondJson(res, 404, { success: false, error: 'Path not found', path: pathRel });
+            return true;
+        }
+        if (code === 'OUTSIDE_RTWS') {
+            respondJson(res, 403, { success: false, error: 'Path resolves outside rtws', path: pathRel });
+            return true;
+        }
+        log.error('Failed to read rtws raw file', error, { path: pathRel });
+        respondJson(res, 500, { success: false, error: 'Failed to read rtws raw file', path: pathRel });
+        return true;
+    }
+}
 function resolveRtwsDiligencePath(lang) {
     const parsed = typeof lang === 'string' ? (0, language_1.normalizeLanguageCode)(lang) : null;
     if (parsed === 'zh')
@@ -2217,12 +2282,15 @@ async function handleGetDialogs(res, status) {
 }
 async function handleGetRunControlCounts(res) {
     try {
-        const counts = await (0, dialog_display_state_1.getRunControlCountsSnapshot)();
+        const counts = await (0, dialog_display_state_1.createRunControlCountsMessage)();
         respondJson(res, 200, {
             success: true,
             counts: {
                 proceeding: counts.proceeding,
                 resumable: counts.resumable,
+                snapshotEpoch: counts.snapshotEpoch,
+                snapshotSeq: counts.snapshotSeq,
+                timestamp: counts.timestamp,
             },
         });
         return true;
@@ -2706,13 +2774,7 @@ function broadcastDialogDeletes(clients, message) {
 async function broadcastRunControlCounts(clients) {
     if (!clients)
         return;
-    const counts = await (0, dialog_display_state_1.getRunControlCountsSnapshot)();
-    const data = JSON.stringify({
-        type: 'run_control_counts_evt',
-        proceeding: counts.proceeding,
-        resumable: counts.resumable,
-        timestamp: (0, time_1.formatUnifiedTimestamp)(new Date()),
-    });
+    const data = JSON.stringify(await (0, dialog_display_state_1.createRunControlCountsMessage)());
     for (const ws of clients) {
         if (ws.readyState === 1) {
             ws.send(data);

package/dist/server/dialog-forensics-routes.d.ts

@@ -0,0 +1,2 @@
+import type { ServerResponse } from 'http';
+export declare function handleDialogForensicsZipRoute(reqUrl: string | undefined, res: ServerResponse): Promise<boolean>;