dominds 0.1.0

package/dist/persistence.js

@@ -0,0 +1,3128 @@
+"use strict";
+/**
+ * Module: persistence
+ *
+ * Modern dialog persistence with strong typing and latest.yaml support.
+ * Provides file-based storage with append-only events and atomic operations.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogPersistence = exports.DiskFileDialogStore = void 0;
+const fs = __importStar(require("fs"));
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("path"));
+const yaml = __importStar(require("yaml"));
+const dialog_1 = require("./dialog");
+const evt_registry_1 = require("./evt-registry");
+const log_1 = require("./log");
+const async_fifo_mutex_1 = require("./shared/async-fifo-mutex");
+const runtime_language_1 = require("./shared/runtime-language");
+const inter_dialog_format_1 = require("./shared/utils/inter-dialog-format");
+const time_1 = require("./shared/utils/time");
+const registry_1 = require("./tools/registry");
+function getErrorCode(error) {
+    if (typeof error !== 'object' || error === null)
+        return undefined;
+    const maybeCode = error.code;
+    return typeof maybeCode === 'string' ? maybeCode : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function normalizeQ4HKind(value) {
+    return value === 'keep_going_budget_exhausted' ||
+        value === 'context_health_critical' ||
+        value === 'generic'
+        ? value
+        : 'generic';
+}
+function isAssignmentFromSup(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.headLine !== 'string')
+        return false;
+    if (typeof value.callBody !== 'string')
+        return false;
+    if (typeof value.originMemberId !== 'string')
+        return false;
+    if (typeof value.callerDialogId !== 'string')
+        return false;
+    if (typeof value.callId !== 'string')
+        return false;
+    if ('collectiveTargets' in value) {
+        const collectiveTargets = value.collectiveTargets;
+        if (collectiveTargets === undefined)
+            return true;
+        if (!Array.isArray(collectiveTargets))
+            return false;
+        if (!collectiveTargets.every((item) => typeof item === 'string'))
+            return false;
+    }
+    return true;
+}
+function isRootDialogMetadataFile(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'string')
+        return false;
+    if (typeof value.agentId !== 'string')
+        return false;
+    if (typeof value.taskDocPath !== 'string')
+        return false;
+    if (typeof value.createdAt !== 'string')
+        return false;
+    if (value.supdialogId !== undefined)
+        return false;
+    if (value.tellaskSession !== undefined)
+        return false;
+    if (value.assignmentFromSup !== undefined)
+        return false;
+    return true;
+}
+function isSubdialogMetadataFile(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'string')
+        return false;
+    if (typeof value.agentId !== 'string')
+        return false;
+    if (typeof value.taskDocPath !== 'string')
+        return false;
+    if (typeof value.createdAt !== 'string')
+        return false;
+    if (typeof value.supdialogId !== 'string')
+        return false;
+    if (value.tellaskSession !== undefined && typeof value.tellaskSession !== 'string')
+        return false;
+    if (!isAssignmentFromSup(value.assignmentFromSup))
+        return false;
+    return true;
+}
+function isDialogMetadataFile(value) {
+    return isRootDialogMetadataFile(value) || isSubdialogMetadataFile(value);
+}
+function isDialogLatestFile(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.currentRound === 'number' &&
+        typeof value.lastModified === 'string' &&
+        (value.status === 'active' || value.status === 'completed' || value.status === 'archived') &&
+        (value.disableDiligencePush === undefined || typeof value.disableDiligencePush === 'boolean'));
+}
+function isSubdialogResponseRecord(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.responseId !== 'string')
+        return false;
+    if (typeof value.subdialogId !== 'string')
+        return false;
+    if (typeof value.response !== 'string')
+        return false;
+    if (typeof value.completedAt !== 'string')
+        return false;
+    if (value.callType !== 'A' && value.callType !== 'B' && value.callType !== 'C')
+        return false;
+    if (typeof value.headLine !== 'string')
+        return false;
+    if (typeof value.responderId !== 'string')
+        return false;
+    if (typeof value.originMemberId !== 'string')
+        return false;
+    if (typeof value.callId !== 'string')
+        return false;
+    return true;
+}
+// Remove old type definitions - now using shared/types/storage.ts
+const tellask_1 = require("./tellask");
+const id_1 = require("./utils/id");
+/**
+ * Uses append-only pattern for events, exceptional overwrite for reminders
+ */
+class DiskFileDialogStore extends dialog_1.DialogStore {
+    constructor(dialogId) {
+        super();
+        // Track saying/thinking content for persistence
+        this.sayingContent = '';
+        this.thinkingContent = '';
+        this.dialogId = dialogId;
+    }
+    // === DialogStore interface methods (for compatibility) ===
+    /**
+     * Create subdialog with automatic persistence
+     */
+    async createSubDialog(supdialog, targetAgentId, headLine, callBody, options) {
+        const generatedId = (0, id_1.generateDialogID)();
+        // For subdialogs, use the supdialog's root dialog ID as the root
+        const subdialogId = new dialog_1.DialogID(generatedId, supdialog.id.rootId);
+        // Prepare subdialog store
+        const subdialogStore = new DiskFileDialogStore(subdialogId);
+        const subdialog = new dialog_1.SubDialog(subdialogStore, supdialog, supdialog.taskDocPath, subdialogId, targetAgentId, {
+            headLine,
+            callBody,
+            originMemberId: options.originMemberId,
+            callerDialogId: options.callerDialogId,
+            callId: options.callId,
+        }, options.tellaskSession);
+        // Initial subdialog user prompt is now persisted at first drive (driver.ts)
+        // Ensure subdialog directory and persist metadata under supdialog/.subdialogs/
+        await this.ensureSubdialogDirectory(subdialogId);
+        const metadata = {
+            id: subdialogId.selfId,
+            agentId: targetAgentId,
+            taskDocPath: supdialog.taskDocPath,
+            createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            supdialogId: supdialog.id.selfId,
+            tellaskSession: options.tellaskSession,
+            assignmentFromSup: {
+                headLine,
+                callBody,
+                originMemberId: options.originMemberId,
+                callerDialogId: options.callerDialogId,
+                callId: options.callId,
+            },
+        };
+        await DialogPersistence.saveSubdialogMetadata(subdialogId, metadata);
+        await DialogPersistence.saveDialogMetadata(subdialogId, metadata);
+        // Initialize latest.yaml via the mutation API (write-back will flush).
+        await DialogPersistence.mutateDialogLatest(subdialogId, () => ({
+            kind: 'replace',
+            next: {
+                currentRound: 1,
+                lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                status: 'active',
+                messageCount: 0,
+                functionCallCount: 0,
+                subdialogCount: 0,
+                runState: { kind: 'idle_waiting_user' },
+                disableDiligencePush: false,
+            },
+        }));
+        // Supdialog clarification context is persisted in subdialog metadata (supdialogCall)
+        const parentRound = await DialogPersistence.getCurrentRoundNumber(supdialog.id);
+        const subdialogCreatedEvt = {
+            type: 'subdialog_created_evt',
+            dialog: {
+                selfId: subdialogId.selfId,
+                rootId: subdialogId.rootId,
+            },
+            timestamp: new Date().toISOString(),
+            round: parentRound,
+            parentDialog: {
+                selfId: supdialog.id.selfId,
+                rootId: supdialog.id.rootId,
+            },
+            subDialog: {
+                selfId: subdialogId.selfId,
+                rootId: subdialogId.rootId,
+            },
+            targetAgentId,
+            headLine,
+            callBody,
+        };
+        // Post subdialog_created_evt to PARENT's PubChan so frontend can receive it
+        // The frontend subscribes to the parent's events, not the subdialog's
+        (0, evt_registry_1.postDialogEvent)(supdialog, subdialogCreatedEvt);
+        return subdialog;
+    }
+    /**
+     * Receive and handle function call results (includes logging)
+     */
+    async receiveFuncResult(dialog, funcResult) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        // Persist function result record
+        const funcResultRecord = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'func_result_record',
+            id: funcResult.id,
+            name: funcResult.name,
+            content: funcResult.content,
+            genseq: dialog.activeGenSeq,
+        };
+        await this.appendEvent(round, funcResultRecord);
+        // Send event to frontend
+        const funcResultEvt = {
+            type: 'func_result_evt',
+            id: funcResult.id,
+            name: funcResult.name,
+            content: funcResult.content,
+            round,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, funcResultEvt);
+    }
+    /**
+     * Receive and handle tellask tool responses with callId for inline result display
+     *
+     * Call Types:
+     * - Tellask Call (inline bubble): !?@<mention-id>
+     *   - Result displays INLINE in the same bubble
+     *   - Uses callId for correlation between call_start and response
+     *   - Uses receiveToolResponse() + callId parameter
+     *
+     * - Teammate Tellask: !?@agentName (e.g., !?@coder, !?@tester)
+     *   - Result displays in SEPARATE bubble (subdialog response)
+     *   - Uses calleeDialogId for correlation
+     *   - Uses receiveTeammateResponse() instead
+     *
+     * @param dialog - The dialog receiving the response
+     * @param responderId - ID of the tool/agent that responded (e.g., "add_reminder")
+     * @param headLine - Headline of the original tool call
+     * @param result - The result content to display
+     * @param status - Response status ('completed' | 'failed')
+     * @param callId - Correlation ID from call_start_evt (REQUIRED for inline display)
+     */
+    async receiveToolResponse(dialog, responderId, headLine, result, status, callId) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const calling_genseq = dialog.activeGenSeqOrUndefined;
+        // Persist record WITH callId for replay correlation
+        const ev = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'tool_call_result_record',
+            responderId,
+            headLine,
+            status,
+            result,
+            calling_genseq,
+            callId,
+        };
+        await this.appendEvent(round, ev);
+        // Emit ToolCallResponseEvent WITH callId for UI correlation
+        const toolResponseEvt = {
+            type: 'tool_call_response_evt',
+            responderId,
+            headLine,
+            status,
+            result,
+            round,
+            calling_genseq,
+            callId,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, toolResponseEvt);
+    }
+    /**
+     * Receive and handle TEAMMATE TELLASK responses (separate bubble for @agentName tellasks)
+     *
+     * Call Types:
+     * - Teammate Tellask: !?@agentName (e.g., !?@coder, !?@tester)
+     *   - Result displays in SEPARATE bubble (subdialog or supdialog response)
+     *   - Uses calleeDialogId for correlation (not callId)
+     *   - Uses this method (receiveTeammateResponse)
+     *
+     * @param dialog - The dialog receiving the response
+     * @param responderId - ID of the teammate agent (e.g., "coder")
+     * @param headLine - Headline of the original teammate tellask
+     * @param status - Response status ('completed' | 'failed')
+     * @param calleeDialogId - ID of the callee dialog (subdialog OR supdialog) for navigation links
+     */
+    async receiveTeammateResponse(dialog, responderId, headLine, status, calleeDialogId, options) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const calling_genseq = dialog.activeGenSeqOrUndefined;
+        const calleeDialogSelfId = calleeDialogId ? calleeDialogId.selfId : undefined;
+        const response = options.response;
+        const agentId = options.agentId;
+        const callId = options.callId;
+        const originMemberId = options.originMemberId;
+        const result = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+            responderId,
+            requesterId: originMemberId,
+            originalCallHeadLine: headLine,
+            responseBody: response,
+            language: (0, runtime_language_1.getWorkLanguage)(),
+        });
+        const ev = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'teammate_response_record',
+            responderId,
+            calleeDialogId: calleeDialogSelfId,
+            headLine,
+            status,
+            result,
+            calling_genseq,
+            response,
+            agentId,
+            callId,
+            originMemberId,
+        };
+        await this.appendEvent(round, ev);
+        const teammateResponseEvt = {
+            type: 'teammate_response_evt',
+            responderId,
+            calleeDialogId: calleeDialogSelfId,
+            headLine,
+            status,
+            result,
+            round,
+            calling_genseq,
+            response,
+            agentId,
+            callId,
+            originMemberId,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, teammateResponseEvt);
+    }
+    /**
+     * Ensure subdialog directory exists (delegate to DialogPersistence)
+     */
+    async ensureSubdialogDirectory(dialogId) {
+        return await DialogPersistence.ensureSubdialogDirectory(dialogId);
+    }
+    /**
+     * Append event to round JSONL file (delegate to DialogPersistence)
+     */
+    async appendEvent(round, event) {
+        await DialogPersistence.appendEvent(this.dialogId, round, event);
+    }
+    /**
+     * Notify start of LLM generation for frontend bubble management
+     * CRITICAL: This must be called BEFORE any substream events (thinking_start, markdown_start, etc.)
+     * to ensure proper event ordering on the frontend.
+     */
+    async notifyGeneratingStart(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const genseq = dialog.activeGenSeq;
+        try {
+            const ev = {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'gen_start_record',
+                genseq: genseq,
+            };
+            await this.appendEvent(round, ev);
+            // Emit generating_start_evt event
+            // This event MUST be emitted and processed before any substream events
+            // to ensure the frontend has created the generation bubble before receiving
+            // thinking/markdown/calling events
+            const genStartEvt = {
+                type: 'generating_start_evt',
+                round,
+                genseq: genseq,
+            };
+            (0, evt_registry_1.postDialogEvent)(dialog, genStartEvt);
+            // Update generating flag in latest.yaml
+            await DialogPersistence.mutateDialogLatest(this.dialogId, () => ({
+                kind: 'patch',
+                patch: { generating: true },
+            }));
+        }
+        catch (err) {
+            log_1.log.warn('Failed to persist gen_start event', err);
+        }
+    }
+    /**
+     * Notify end of LLM generation for frontend bubble management
+     */
+    async notifyGeneratingFinish(dialog, contextHealth, llmGenModel) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const genseq = dialog.activeGenSeq;
+        if (genseq === undefined) {
+            throw new Error('Missing active genseq for notifyGeneratingFinish');
+        }
+        try {
+            const ev = {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'gen_finish_record',
+                genseq: genseq,
+                contextHealth,
+                llmGenModel,
+            };
+            await this.appendEvent(round, ev);
+            // Emit generating_finish_evt event (this was missing, causing double triggering issue)
+            const genFinishEvt = {
+                type: 'generating_finish_evt',
+                round,
+                genseq: genseq,
+                llmGenModel,
+            };
+            (0, evt_registry_1.postDialogEvent)(dialog, genFinishEvt);
+            if (contextHealth) {
+                const ctxEvt = {
+                    type: 'context_health_evt',
+                    round,
+                    genseq,
+                    contextHealth,
+                };
+                (0, evt_registry_1.postDialogEvent)(dialog, ctxEvt);
+            }
+            // Update generating flag in latest.yaml
+            await DialogPersistence.mutateDialogLatest(this.dialogId, () => ({
+                kind: 'patch',
+                patch: { generating: false },
+            }));
+        }
+        catch (err) {
+            log_1.log.warn('Failed to persist gen_finish event', err);
+        }
+    }
+    async sayingStart(dialog) {
+        // Reset saying content tracker
+        this.sayingContent = '';
+    }
+    async sayingChunk(dialog, chunk) {
+        // Collect saying content for persistence
+        this.sayingContent += chunk;
+    }
+    async sayingFinish(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const sayingContent = this.sayingContent.trim();
+        // Persist saying content as a message event
+        if (sayingContent) {
+            const sayingMessageEvent = {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'agent_words_record',
+                genseq: dialog.activeGenSeq,
+                content: sayingContent,
+            };
+            await this.appendEvent(round, sayingMessageEvent);
+        }
+    }
+    async thinkingStart(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        // Reset thinking content tracker
+        this.thinkingContent = '';
+        const thinkingStartEvt = {
+            type: 'thinking_start_evt',
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, thinkingStartEvt);
+    }
+    async thinkingChunk(dialog, chunk) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        // Collect thinking content for persistence
+        this.thinkingContent += chunk;
+        const thinkingChunkEvt = {
+            type: 'thinking_chunk_evt',
+            chunk,
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, thinkingChunkEvt);
+    }
+    async thinkingFinish(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        // Persist thinking content as a message event
+        if (this.thinkingContent.trim()) {
+            const thinkingMessageEvent = {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'agent_thought_record',
+                genseq: dialog.activeGenSeq,
+                content: this.thinkingContent.trim(),
+            };
+            await this.appendEvent(round, thinkingMessageEvent);
+        }
+        const thinkingFinishEvt = {
+            type: 'thinking_finish_evt',
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, thinkingFinishEvt);
+    }
+    async markdownStart(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const markdownStartEvt = {
+            type: 'markdown_start_evt',
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, markdownStartEvt);
+    }
+    async markdownChunk(dialog, chunk) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'markdown_chunk_evt',
+            chunk,
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    async markdownFinish(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'markdown_finish_evt',
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    // Tellask call streaming methods
+    async callingStart(dialog, validation) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'tool_call_start_evt',
+            validation,
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    async callingHeadlineChunk(dialog, chunk) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'tool_call_headline_chunk_evt',
+            chunk,
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    async callingHeadlineFinish(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'tool_call_headline_finish_evt',
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    async callingBodyStart(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'tool_call_body_start_evt',
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    async callingBodyChunk(dialog, chunk) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'tool_call_body_chunk_evt',
+            chunk,
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    async callingBodyFinish(dialog) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'tool_call_body_finish_evt',
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    async callingFinish(dialog, callId) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const evt = {
+            type: 'tool_call_finish_evt',
+            callId,
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, evt);
+    }
+    // Function call events (non-streaming mode - single event captures entire call)
+    async funcCallRequested(dialog, funcId, funcName, argumentsStr) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const funcCallEvt = {
+            type: 'func_call_requested_evt',
+            funcId,
+            funcName,
+            arguments: argumentsStr,
+            round,
+            genseq: dialog.activeGenSeq,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, funcCallEvt);
+    }
+    /**
+     * Emit stream error for current generation lifecycle (uses active genseq when present)
+     */
+    async streamError(dialog, error) {
+        log_1.log.error(`Dialog stream error '${error}'`, new Error(), { dialog });
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const genseq = typeof dialog.activeGenSeq === 'number' ? dialog.activeGenSeq : undefined;
+        // Enhanced stream error event with better error classification
+        const streamErrorEvent = {
+            type: 'stream_error_evt',
+            round,
+            genseq,
+            error,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, streamErrorEvent);
+    }
+    /**
+     * Start new round (append-only JSONL + exceptional reminder persistence)
+     */
+    async startNewRound(dialog, _newRoundPrompt) {
+        const previousRound = dialog.currentRound;
+        const newRound = previousRound + 1;
+        // Persist reminders state for new round (exceptional overwrite)
+        // Use the currently attached dialog's reminders to avoid stale state
+        await this.persistReminders(dialog, dialog.reminders || []);
+        // Update latest.yaml with new round (lastModified is set by persistence layer)
+        await DialogPersistence.mutateDialogLatest(this.dialogId, () => ({
+            kind: 'patch',
+            patch: { currentRound: newRound },
+        }));
+        // Post round update event
+        const roundUpdateEvt = {
+            type: 'round_update',
+            round: newRound,
+            totalRounds: newRound,
+        };
+        (0, evt_registry_1.postDialogEvent)(dialog, roundUpdateEvt);
+    }
+    /**
+     * Persist reminder state (exceptional overwrite pattern)
+     * Note: Event emission is handled by processReminderUpdates() in Dialog
+     */
+    async persistReminders(dialog, reminders) {
+        await DialogPersistence._saveReminderState(this.dialogId, reminders);
+    }
+    /**
+     * Persist a user message to storage
+     * Note: The end_of_user_saying_evt is emitted by the driver after user content
+     * is rendered and any tellask calls are parsed/executed.
+     */
+    async persistUserMessage(dialog, content, msgId, grammar, userLanguageCode) {
+        const round = dialog.currentRound;
+        // Use activeGenSeqOrUndefined to handle case when genseq hasn't been initialized yet
+        const genseq = dialog.activeGenSeqOrUndefined ?? 1;
+        const humanEv = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'human_text_record',
+            genseq: genseq,
+            content: String(content || ''),
+            msgId: msgId,
+            grammar,
+            userLanguageCode,
+        };
+        await this.appendEvent(round, humanEv);
+        // Note: end_of_user_saying_evt is now emitted by llm/driver.ts after tellask calls complete
+    }
+    /**
+     * Persist an assistant message to storage
+     */
+    async persistAgentMessage(dialog, content, genseq, type, provider_data) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const event = type === 'thinking_msg'
+            ? {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'agent_thought_record',
+                genseq,
+                content: content || '',
+                provider_data,
+            }
+            : {
+                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                type: 'agent_words_record',
+                genseq,
+                content: content || '',
+            };
+        await this.appendEvent(round, event);
+    }
+    /**
+     * Persist a function call to storage
+     */
+    async persistFunctionCall(dialog, id, name, arguments_, genseq) {
+        const round = dialog.activeGenRoundOrUndefined ?? dialog.currentRound;
+        const funcCallEvent = {
+            ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            type: 'func_call_record',
+            genseq,
+            id,
+            name,
+            arguments: arguments_,
+        };
+        await this.appendEvent(round, funcCallEvent);
+        // NOTE: func_call_evt REMOVED - persistence uses FuncCallRecord directly
+        // UI display uses func_call_requested_evt instead
+    }
+    /**
+     * Update questions for human state (exceptional overwrite pattern)
+     */
+    async updateQuestions4Human(dialog, questions) {
+        await DialogPersistence._saveQuestions4HumanState(this.dialogId, questions);
+    }
+    /**
+     * Load Questions for Human state from storage
+     */
+    async loadQuestions4Human(dialogId, status) {
+        return await DialogPersistence.loadQuestions4HumanState(dialogId, status);
+    }
+    async loadDialogMetadata(dialogId, status) {
+        return await DialogPersistence.loadDialogMetadata(dialogId, status);
+    }
+    async loadPendingSubdialogs(rootDialogId, status) {
+        const records = await DialogPersistence.loadPendingSubdialogs(rootDialogId, status);
+        return records.map((record) => ({
+            subdialogId: new dialog_1.DialogID(record.subdialogId, rootDialogId.rootId),
+            createdAt: record.createdAt,
+            headLine: record.headLine,
+            targetAgentId: record.targetAgentId,
+            callType: record.callType,
+            tellaskSession: record.tellaskSession,
+        }));
+    }
+    async saveSubdialogRegistry(rootDialogId, entries, status) {
+        await DialogPersistence.saveSubdialogRegistry(rootDialogId, entries, status);
+    }
+    async loadSubdialogRegistry(rootDialog, status) {
+        const entries = await DialogPersistence.loadSubdialogRegistry(rootDialog.id, status);
+        for (const entry of entries) {
+            if (!entry.tellaskSession)
+                continue;
+            const existing = rootDialog.lookupDialog(entry.subdialogId.selfId);
+            if (existing) {
+                if (existing instanceof dialog_1.SubDialog && existing.tellaskSession) {
+                    rootDialog.registerSubdialog(existing);
+                }
+                continue;
+            }
+            const subdialogState = await DialogPersistence.restoreDialog(entry.subdialogId, status);
+            if (!subdialogState)
+                continue;
+            const assignmentFromSup = subdialogState.metadata.assignmentFromSup;
+            if (!assignmentFromSup)
+                continue;
+            const subdialogStore = new DiskFileDialogStore(entry.subdialogId);
+            const subdialog = new dialog_1.SubDialog(subdialogStore, rootDialog, subdialogState.metadata.taskDocPath, new dialog_1.DialogID(entry.subdialogId.selfId, rootDialog.id.rootId), subdialogState.metadata.agentId, assignmentFromSup, entry.tellaskSession, {
+                messages: subdialogState.messages,
+                reminders: subdialogState.reminders,
+                currentRound: subdialogState.currentRound,
+            });
+            rootDialog.registerSubdialog(subdialog);
+        }
+    }
+    /**
+     * Clear Questions for Human state in storage
+     */
+    async clearQuestions4Human(dialog) {
+        const previousQuestions = await DialogPersistence.loadQuestions4HumanState(dialog.id);
+        const previousCount = previousQuestions.length;
+        if (previousCount > 0) {
+            await DialogPersistence.clearQuestions4HumanState(dialog.id);
+            // Emit q4h_answered events for each removed question
+            for (const q of previousQuestions) {
+                const answeredEvent = {
+                    type: 'q4h_answered',
+                    questionId: q.id,
+                    selfId: dialog.id.selfId,
+                };
+                (0, evt_registry_1.postDialogEvent)(dialog, answeredEvent);
+            }
+        }
+    }
+    /**
+     * Get current questions for human count for UI decoration
+     */
+    async getQuestions4HumanCount() {
+        const questions = await DialogPersistence.loadQuestions4HumanState(this.dialogId);
+        return questions.length;
+    }
+    /**
+     * Load current round number from persisted metadata
+     */
+    async loadCurrentRound(dialogId) {
+        return await DialogPersistence.getCurrentRoundNumber(dialogId, 'running');
+    }
+    /**
+     * Get next sequence number for generation
+     */
+    async getNextSeq(dialogId, round) {
+        return await DialogPersistence.getNextSeq(dialogId, round, 'running');
+    }
+    /**
+     * Send dialog events directly to a specific WebSocket connection for dialog restoration
+     * CRITICAL: This bypasses PubChan to ensure only the requesting session receives restoration events
+     * Unlike replayDialogEvents(), this sends events directly to ws.send() instead of postDialogEvent()
+     * @param ws - WebSocket connection to send events to
+     * @param dialog - Dialog object containing metadata
+     * @param round - Optional round number (uses dialog.currentRound if not provided)
+     * @param totalRounds - Optional total rounds count (defaults to round/currentRound)
+     */
+    async sendDialogEventsDirectly(ws, dialog, round, totalRounds, status = 'running') {
+        try {
+            // Use provided round or fallback to dialog.currentRound (which may be stale for new Dialog objects)
+            const currentRound = round ?? dialog.currentRound;
+            const effectiveTotalRounds = totalRounds ?? currentRound;
+            const persistenceEvents = await DialogPersistence.readRoundEvents(dialog.id, currentRound, status);
+            // Send round_update event directly to this WebSocket only
+            ws.send(JSON.stringify({
+                type: 'round_update',
+                dialog: {
+                    selfId: dialog.id.selfId,
+                    rootId: dialog.id.rootId,
+                },
+                round: currentRound,
+                totalRounds: effectiveTotalRounds,
+            }));
+            // Events are already in chronological order from JSONL file (append-only pattern)
+            // Send each persistence event directly to the requesting WebSocket
+            for (const event of persistenceEvents) {
+                await this.sendEventDirectlyToWebSocket(ws, dialog, currentRound, event);
+            }
+            // Rehydrate reminders from dialog state
+            const dialogState = await DialogPersistence.restoreDialog(dialog.id, status);
+            const rehydrated = (dialogState?.reminders ?? []).map((r) => {
+                return { content: r.content, owner: r.owner, meta: r.meta };
+            });
+            dialog.reminders.length = 0;
+            dialog.reminders.push(...rehydrated);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to send dialog events directly for ${dialog.id.selfId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Send a single persistence event directly to a WebSocket connection
+     * CRITICAL: Avoid PubChan completely for dialog restoration to the single client's display_dialog request
+     */
+    async sendEventDirectlyToWebSocket(ws, dialog, round, event) {
+        switch (event.type) {
+            case 'human_text_record': {
+                const genseq = event.genseq;
+                const content = event.content || '';
+                const grammar = event.grammar ?? 'tellask';
+                const userLanguageCode = event.userLanguageCode;
+                if (content) {
+                    if (grammar === 'tellask') {
+                        const receiver = {
+                            markdownStart: async () => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'markdown_start_evt',
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            markdownChunk: async (chunk) => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'markdown_chunk_evt',
+                                        chunk,
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            markdownFinish: async () => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'markdown_finish_evt',
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            callStart: async (validation) => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool_call_start_evt',
+                                        validation,
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            callHeadLineChunk: async (chunk) => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool_call_headline_chunk_evt',
+                                        chunk,
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            callHeadLineFinish: async () => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool_call_headline_finish_evt',
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            callBodyStart: async () => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool_call_body_start_evt',
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            callBodyChunk: async (chunk) => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool_call_body_chunk_evt',
+                                        chunk,
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            callBodyFinish: async () => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool_call_body_finish_evt',
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                            callFinish: async (_callId) => {
+                                if (ws.readyState === 1) {
+                                    ws.send(JSON.stringify({
+                                        type: 'tool_call_finish_evt',
+                                        callId: _callId,
+                                        round,
+                                        genseq,
+                                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                        timestamp: event.ts,
+                                    }));
+                                }
+                            },
+                        };
+                        // Parse user content through TellaskStreamParser (same as live mode)
+                        const streamingParser = new tellask_1.TellaskStreamParser(receiver);
+                        await streamingParser.takeUpstreamChunk(content);
+                        await streamingParser.finalize();
+                    }
+                    else {
+                        if (ws.readyState === 1) {
+                            ws.send(JSON.stringify({
+                                type: 'markdown_start_evt',
+                                round,
+                                genseq,
+                                dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                timestamp: event.ts,
+                            }));
+                            ws.send(JSON.stringify({
+                                type: 'markdown_chunk_evt',
+                                chunk: content,
+                                round,
+                                genseq,
+                                dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                timestamp: event.ts,
+                            }));
+                            ws.send(JSON.stringify({
+                                type: 'markdown_finish_evt',
+                                round,
+                                genseq,
+                                dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                                timestamp: event.ts,
+                            }));
+                        }
+                    }
+                }
+                // Emit end_of_user_saying_evt to signal frontend to render <hr/> separator
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify({
+                        type: 'end_of_user_saying_evt',
+                        round,
+                        genseq,
+                        msgId: event.msgId,
+                        content,
+                        grammar,
+                        userLanguageCode,
+                        dialog: { selfId: dialog.id.selfId, rootId: dialog.id.rootId },
+                        timestamp: event.ts,
+                    }));
+                }
+                break;
+            }
+            case 'gen_start_record': {
+                // Create generating_start_evt event using persisted genseq directly
+                const genStartWireEvent = {
+                    type: 'generating_start_evt',
+                    round,
+                    genseq: event.genseq,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                // Send directly to WebSocket (NO PubChan emission)
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(genStartWireEvent));
+                }
+                break;
+            }
+            case 'gen_finish_record': {
+                // Create generating_finish_evt event using persisted genseq directly
+                const genFinishWireEvent = {
+                    type: 'generating_finish_evt',
+                    round,
+                    genseq: event.genseq,
+                    llmGenModel: typeof event.llmGenModel === 'string' ? event.llmGenModel : undefined,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                // Send directly to WebSocket (NO PubChan emission)
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(genFinishWireEvent));
+                }
+                if (event.contextHealth) {
+                    const ctxWireEvent = {
+                        type: 'context_health_evt',
+                        round,
+                        genseq: event.genseq,
+                        contextHealth: event.contextHealth,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    };
+                    if (ws.readyState === 1) {
+                        ws.send(JSON.stringify(ctxWireEvent));
+                    }
+                }
+                break;
+            }
+            case 'agent_thought_record': {
+                // Replay thinking content as thinking events
+                const content = event.content || '';
+                if (content) {
+                    // Start thinking phase
+                    const thinkingStartEvent = {
+                        type: 'thinking_start_evt',
+                        round,
+                        genseq: event.genseq,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    };
+                    if (ws.readyState === 1) {
+                        ws.send(JSON.stringify(thinkingStartEvent));
+                    }
+                    const thinkingChunks = this.createOptimalChunks(content);
+                    for (const chunk of thinkingChunks) {
+                        const thinkingChunkEvent = {
+                            type: 'thinking_chunk_evt',
+                            chunk,
+                            round,
+                            genseq: event.genseq,
+                            dialog: {
+                                selfId: dialog.id.selfId,
+                                rootId: dialog.id.rootId,
+                            },
+                            timestamp: event.ts,
+                        };
+                        if (ws.readyState === 1) {
+                            ws.send(JSON.stringify(thinkingChunkEvent));
+                        }
+                    }
+                    // Finish thinking phase
+                    const thinkingFinishEvent = {
+                        type: 'thinking_finish_evt',
+                        round,
+                        genseq: event.genseq,
+                        dialog: {
+                            selfId: dialog.id.selfId,
+                            rootId: dialog.id.rootId,
+                        },
+                        timestamp: event.ts,
+                    };
+                    if (ws.readyState === 1) {
+                        ws.send(JSON.stringify(thinkingFinishEvent));
+                    }
+                }
+                break;
+            }
+            case 'agent_words_record': {
+                // Replay assistant text using ad-hoc event receiver with closure-based WebSocket access
+                const content = event.content || '';
+                if (content) {
+                    // Create ad-hoc receiver similar to driver pattern with closure-based WebSocket access
+                    const receiver = {
+                        markdownStart: async () => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'markdown_start_evt',
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        markdownChunk: async (chunk) => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'markdown_chunk_evt',
+                                    chunk,
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        markdownFinish: async () => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'markdown_finish_evt',
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        callStart: async (validation) => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'tool_call_start_evt',
+                                    validation,
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        callHeadLineChunk: async (chunk) => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'tool_call_headline_chunk_evt',
+                                    chunk,
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        callHeadLineFinish: async () => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'tool_call_headline_finish_evt',
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        callBodyStart: async () => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'tool_call_body_start_evt',
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        callBodyChunk: async (chunk) => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'tool_call_body_chunk_evt',
+                                    chunk,
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        callBodyFinish: async () => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'tool_call_body_finish_evt',
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                        callFinish: async (callId) => {
+                            if (ws.readyState === 1) {
+                                ws.send(JSON.stringify({
+                                    type: 'tool_call_finish_evt',
+                                    callId,
+                                    round,
+                                    genseq: event.genseq,
+                                    dialog: {
+                                        selfId: dialog.id.selfId,
+                                        rootId: dialog.id.rootId,
+                                    },
+                                    timestamp: event.ts,
+                                }));
+                            }
+                        },
+                    };
+                    // Use the same TellaskStreamParser that live streaming uses
+                    const streamingParser = new tellask_1.TellaskStreamParser(receiver);
+                    // Stream the content through the parser to ensure consistent event emission
+                    await streamingParser.takeUpstreamChunk(content);
+                    await streamingParser.finalize();
+                }
+                break;
+            }
+            case 'func_call_record': {
+                // Handle function call events from persistence
+                // NOTE: func_call_evt REMOVED - emit func_call_requested_evt for UI instead
+                const funcCall = {
+                    type: 'func_call_requested_evt',
+                    funcId: event.id,
+                    funcName: event.name,
+                    arguments: JSON.stringify(event.arguments),
+                    round,
+                    genseq: event.genseq,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(funcCall));
+                }
+                break;
+            }
+            case 'func_result_record': {
+                // Handle function result events from persistence
+                const funcResult = {
+                    type: 'func_result_evt',
+                    id: event.id,
+                    name: event.name,
+                    content: event.content,
+                    round,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(funcResult));
+                }
+                break;
+            }
+            case 'quest_for_sup_record': {
+                // Handle subdialog creation requests
+                const subdialogCreatedEvent = {
+                    type: 'subdialog_created_evt',
+                    dialog: {
+                        // Add dialog field for proper event routing
+                        selfId: event.subDialogId,
+                        rootId: dialog.id.rootId,
+                    },
+                    parentDialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    subDialog: {
+                        selfId: event.subDialogId,
+                        rootId: dialog.id.rootId, // Use parent's rootId for subdialog's rootId
+                    },
+                    targetAgentId: 'unknown', // Will be resolved during actual subdialog creation
+                    headLine: event.headLine,
+                    callBody: event.callBody,
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(subdialogCreatedEvent));
+                }
+                break;
+            }
+            case 'tool_call_result_record': {
+                // Handle tool call results
+                const responseEvent = {
+                    type: 'tool_call_response_evt',
+                    responderId: event.responderId,
+                    headLine: event.headLine,
+                    status: event.status,
+                    result: event.result,
+                    callId: event.callId || '',
+                    round,
+                    calling_genseq: event.calling_genseq,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(responseEvent));
+                }
+                break;
+            }
+            case 'teammate_response_record': {
+                // Handle teammate response events (separate bubble for @teammate tellasks)
+                const formattedResult = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                    responderId: event.responderId,
+                    requesterId: event.originMemberId,
+                    originalCallHeadLine: event.headLine,
+                    responseBody: event.response,
+                    language: (0, runtime_language_1.getWorkLanguage)(),
+                });
+                const teammateResponseEvent = {
+                    type: 'teammate_response_evt',
+                    responderId: event.responderId,
+                    calleeDialogId: event.calleeDialogId,
+                    headLine: event.headLine,
+                    status: event.status,
+                    result: formattedResult,
+                    response: event.response,
+                    agentId: event.agentId,
+                    callId: event.callId,
+                    originMemberId: event.originMemberId,
+                    round,
+                    calling_genseq: event.calling_genseq,
+                    dialog: {
+                        selfId: dialog.id.selfId,
+                        rootId: dialog.id.rootId,
+                    },
+                    timestamp: event.ts,
+                };
+                if (ws.readyState === 1) {
+                    ws.send(JSON.stringify(teammateResponseEvent));
+                }
+                break;
+            }
+            default:
+                // Unknown event type - log but don't crash
+                log_1.log.warn(`Unknown persistence event type during direct WebSocket send`, undefined, event);
+                break;
+        }
+    }
+    /**
+     * Create optimal text chunks for websocket transmission
+     * Splits content into 1MB pieces for efficient websocket streaming
+     */
+    createOptimalChunks(content, maxChunk = 1000000) {
+        const chunks = [];
+        let remaining = content.trim();
+        while (remaining.length > 0) {
+            // Use 1MB chunks for optimal websocket transmission
+            const targetSize = Math.min(remaining.length, maxChunk);
+            const chunk = remaining.slice(0, targetSize);
+            chunks.push(chunk);
+            remaining = remaining.slice(chunk.length).trim();
+        }
+        return chunks.filter((chunk) => chunk.length > 0);
+    }
+}
+exports.DiskFileDialogStore = DiskFileDialogStore;
+/**
+ * Utility class for managing dialog persistence
+ */
+class DialogPersistence {
+    static getLatestWriteBackMutex(key) {
+        const existing = this.latestWriteBackMutexes.get(key);
+        if (existing)
+            return existing;
+        const created = new async_fifo_mutex_1.AsyncFifoMutex();
+        this.latestWriteBackMutexes.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()}`;
+    }
+    /**
+     * Get the base dialogs directory path
+     */
+    static getDialogsRootDir() {
+        return path.join(process.cwd(), this.DIALOGS_DIR);
+    }
+    /**
+     * Save dialog state to JSON file for persistence (internal use only)
+     */
+    static async saveDialogState(state) {
+        try {
+            const dialogPath = await this.ensureRootDialogDirectory(new dialog_1.DialogID(state.metadata.id));
+            // Save state as JSON file
+            const stateFile = path.join(dialogPath, 'state.json');
+            await fs.promises.writeFile(stateFile, JSON.stringify({
+                metadata: state.metadata,
+                currentRound: state.currentRound,
+                messages: state.messages,
+                reminders: state.reminders,
+                savedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            }, null, 2), 'utf-8');
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save dialog state for ${state.metadata.id}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Load dialog state from JSON file
+     */
+    static async loadDialogState(dialogId) {
+        try {
+            const dialogPath = this.getRootDialogPath(dialogId, 'running');
+            const stateFile = path.join(dialogPath, 'state.json');
+            // Check if state file exists
+            try {
+                await fs.promises.access(stateFile);
+            }
+            catch {
+                log_1.log.warn(`No state file found for dialog ${dialogId.selfId}, returning null`);
+                return null;
+            }
+            const stateData = JSON.parse(await fs.promises.readFile(stateFile, 'utf-8'));
+            return {
+                metadata: stateData.metadata,
+                currentRound: stateData.currentRound,
+                messages: stateData.messages,
+                reminders: stateData.reminders || [],
+            };
+        }
+        catch (error) {
+            log_1.log.error(`Failed to load dialog state for root ${dialogId.selfId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Get the full path for a dialog directory
+     */
+    static getRootDialogPath(dialogId, status = 'running') {
+        if (dialogId.rootId !== dialogId.selfId) {
+            throw new Error('Expected root dialog id');
+        }
+        let statusDir;
+        if (status === 'running') {
+            statusDir = this.RUN_DIR;
+        }
+        else if (status === 'completed') {
+            statusDir = this.DONE_DIR;
+        }
+        else {
+            statusDir = this.ARCHIVE_DIR;
+        }
+        return path.join(this.getDialogsRootDir(), statusDir, dialogId.selfId);
+    }
+    /**
+     * Get the events/state directory for a dialog (composite ID for subdialogs)
+     */
+    static getDialogEventsPath(dialogId, status = 'running') {
+        // Root dialogs store events under their own directory.
+        // Subdialogs store events under the root's subdialogs/<self> directory.
+        if (dialogId.rootId === dialogId.selfId) {
+            return this.getRootDialogPath(dialogId, status);
+        }
+        return this.getSubdialogPath(dialogId, status);
+    }
+    /**
+     * Get the path for a subdialog within a supdialog
+     */
+    static getSubdialogPath(dialogId, status = 'running') {
+        if (dialogId.rootId === dialogId.selfId) {
+            throw new Error('Expected subdialog id (self differs from root)');
+        }
+        const rootPath = this.getRootDialogPath(new dialog_1.DialogID(dialogId.rootId), status);
+        return path.join(rootPath, this.SUBDIALOGS_DIR, dialogId.selfId);
+    }
+    /**
+     * Ensure dialog directory structure exists
+     */
+    static async ensureRootDialogDirectory(dialogId, status = 'running') {
+        const dialogPath = this.getRootDialogPath(dialogId, status);
+        try {
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            return dialogPath;
+        }
+        catch (error) {
+            log_1.log.error(`Failed to create dialog directory ${dialogPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Ensure subdialog directory structure exists
+     */
+    static async ensureSubdialogDirectory(dialogId, status = 'running') {
+        const subdialogPath = this.getSubdialogPath(dialogId, status);
+        try {
+            await fs.promises.mkdir(subdialogPath, { recursive: true });
+            return subdialogPath;
+        }
+        catch (error) {
+            log_1.log.error(`Failed to create subdialog directory ${subdialogPath}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Mark a dialog as completed
+     */
+    static async markDialogCompleted(dialogId) {
+        try {
+            const dialogPath = this.getRootDialogPath(dialogId, 'running');
+            const completedPath = this.getRootDialogPath(dialogId, 'completed');
+            await fs.promises.mkdir(completedPath, { recursive: true });
+            // Move files from current to completed
+            const files = await fs.promises.readdir(dialogPath);
+            for (const file of files) {
+                const src = path.join(dialogPath, file);
+                const dest = path.join(completedPath, file);
+                await fs.promises.rename(src, dest);
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to mark dialog ${dialogId} as completed:`, error);
+            throw error;
+        }
+    }
+    /**
+     * List all dialog IDs by scanning for dialog.yaml files and validating their IDs
+     */
+    static async listDialogs(status = 'running') {
+        try {
+            const statusDir = this.getDialogsRootDir();
+            const specificDir = path.join(statusDir, status === 'running'
+                ? this.RUN_DIR
+                : status === 'completed'
+                    ? this.DONE_DIR
+                    : this.ARCHIVE_DIR);
+            const validDialogIds = [];
+            // Recursively find all dialog.yaml files
+            const findDialogYamls = async (dirPath, relativePath = '') => {
+                try {
+                    const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const fullPath = path.join(dirPath, entry.name);
+                        const entryRelativePath = path.join(relativePath, entry.name);
+                        if (entry.isDirectory()) {
+                            // Recursively search subdirectories
+                            await findDialogYamls(fullPath, entryRelativePath);
+                        }
+                        else if (entry.name === 'dialog.yaml') {
+                            // Found a dialog.yaml file, record its ID regardless of nesting structure
+                            try {
+                                const content = await fs.promises.readFile(fullPath, 'utf-8');
+                                const parsed = yaml.parse(content);
+                                if (parsed?.id && typeof parsed.id === 'string') {
+                                    validDialogIds.push(parsed.id);
+                                }
+                            }
+                            catch (yamlError) {
+                                log_1.log.warn(`🔍 listDialogs: Failed to parse dialog.yaml at ${fullPath}:`, yamlError);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    log_1.log.warn(`🔍 listDialogs: Error reading directory ${dirPath}:`, error);
+                }
+            };
+            try {
+                // Check if directory exists before trying to read it
+                const dirExists = await fs.promises
+                    .stat(specificDir)
+                    .then(() => true)
+                    .catch(() => false);
+                if (dirExists) {
+                    await findDialogYamls(specificDir);
+                }
+                return validDialogIds;
+            }
+            catch (error) {
+                log_1.log.warn(`🔍 listDialogs: Error processing directory ${specificDir}:`, error instanceof Error ? error.message : String(error));
+                return [];
+            }
+        }
+        catch (error) {
+            log_1.log.error('Failed to list dialogs:', error);
+            return [];
+        }
+    }
+    /**
+     * List all dialog IDs (root + subdialogs) together with their root IDs.
+     * This is the only safe way to enumerate subdialogs because their directory names
+     * are not guaranteed to be their selfId.
+     */
+    static async listAllDialogIds(status = 'running') {
+        const statusDir = this.getDialogsRootDir();
+        const specificDir = path.join(statusDir, status === 'running'
+            ? this.RUN_DIR
+            : status === 'completed'
+                ? this.DONE_DIR
+                : this.ARCHIVE_DIR);
+        const result = [];
+        const rootDialogIdByDialogYamlPath = new Map();
+        const readDialogYamlId = async (dialogYamlPath) => {
+            const cached = rootDialogIdByDialogYamlPath.get(dialogYamlPath);
+            if (cached !== undefined)
+                return cached;
+            try {
+                const content = await fs.promises.readFile(dialogYamlPath, 'utf-8');
+                const parsed = yaml.parse(content);
+                if (typeof parsed !== 'object' || parsed === null) {
+                    rootDialogIdByDialogYamlPath.set(dialogYamlPath, null);
+                    return null;
+                }
+                const idValue = parsed.id;
+                if (typeof idValue !== 'string' || idValue.trim() === '') {
+                    rootDialogIdByDialogYamlPath.set(dialogYamlPath, null);
+                    return null;
+                }
+                const normalized = idValue.trim();
+                rootDialogIdByDialogYamlPath.set(dialogYamlPath, normalized);
+                return normalized;
+            }
+            catch {
+                rootDialogIdByDialogYamlPath.set(dialogYamlPath, null);
+                return null;
+            }
+        };
+        const inferRootIdFromRelativeDir = async (relativeDir) => {
+            const dir = relativeDir.trim();
+            if (dir === '' || dir === '.' || dir === path.sep)
+                return null;
+            const segments = dir.split(path.sep).filter((seg) => seg.length > 0 && seg !== '.');
+            if (segments.length === 0)
+                return null;
+            // Root dialog IDs in this repo can contain path separators (e.g. "f4/44/cd85c4e2").
+            // The root dialog directory is therefore nested (RUN_DIR/<rootId>/dialog.yaml).
+            //
+            // To infer the rootId for any dialog.yaml we find (root or subdialog), scan prefixes of the
+            // directory path and pick the first prefix that is itself a valid root dialog directory:
+            // - it has a dialog.yaml
+            // - its dialog.yaml id matches the prefix joined with '/'
+            for (let i = 1; i <= segments.length; i++) {
+                const prefixSegs = segments.slice(0, i);
+                const candidateDialogYamlPath = path.join(specificDir, ...prefixSegs, 'dialog.yaml');
+                const id = await readDialogYamlId(candidateDialogYamlPath);
+                const expectedId = prefixSegs.join('/');
+                if (id === expectedId)
+                    return expectedId;
+            }
+            return null;
+        };
+        const findDialogYamls = async (dirPath, relativePath = '') => {
+            let entries;
+            try {
+                entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+            }
+            catch (err) {
+                log_1.log.warn(`🔍 listAllDialogIds: Error reading directory ${dirPath}:`, err);
+                return;
+            }
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+                const entryRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+                if (entry.isDirectory()) {
+                    await findDialogYamls(fullPath, entryRelativePath);
+                    continue;
+                }
+                if (entry.name !== 'dialog.yaml')
+                    continue;
+                const relDir = path.dirname(entryRelativePath);
+                const rootId = await inferRootIdFromRelativeDir(relDir);
+                if (!rootId)
+                    continue;
+                try {
+                    const content = await fs.promises.readFile(fullPath, 'utf-8');
+                    const parsed = yaml.parse(content);
+                    if (typeof parsed !== 'object' || parsed === null)
+                        continue;
+                    const idValue = parsed.id;
+                    if (typeof idValue !== 'string' || idValue.trim() === '')
+                        continue;
+                    result.push(new dialog_1.DialogID(idValue, rootId));
+                }
+                catch (yamlError) {
+                    log_1.log.warn(`🔍 listAllDialogIds: Failed to parse dialog.yaml at ${fullPath}:`, yamlError);
+                }
+            }
+        };
+        const dirExists = await fs.promises
+            .stat(specificDir)
+            .then(() => true)
+            .catch(() => false);
+        if (!dirExists)
+            return [];
+        await findDialogYamls(specificDir);
+        return result;
+    }
+    // === NEW JSONL ROUND-BASED METHODS ===
+    /**
+     * Append event to round JSONL file (append-only pattern)
+     */
+    static async appendEvent(dialogId, round, event, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const roundFilename = this.getRoundFilename(round);
+            const roundFilePath = path.join(dialogPath, roundFilename);
+            // Ensure directory exists
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            // Atomic append operation
+            const eventLine = JSON.stringify(event) + '\n';
+            await fs.promises.appendFile(roundFilePath, eventLine, 'utf-8');
+            // Update latest.yaml with new lastModified timestamp
+            await this.mutateDialogLatest(dialogId, () => ({
+                kind: 'patch',
+                patch: {
+                    lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                    currentRound: round,
+                },
+            }), status);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to append event to dialog ${dialogId} round ${round}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Read all events from round JSONL file
+     */
+    static async readRoundEvents(dialogId, round, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const roundFilename = this.getRoundFilename(round);
+            const roundFilePath = path.join(dialogPath, roundFilename);
+            try {
+                const content = await fs.promises.readFile(roundFilePath, 'utf-8');
+                const events = [];
+                for (const line of content.trim().split('\n')) {
+                    if (line.trim()) {
+                        events.push(JSON.parse(line));
+                    }
+                }
+                return events;
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    // Round file doesn't exist - return empty array
+                    return [];
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to read round events for dialog ${dialogId} round ${round}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Compute next sequence number for a round by scanning existing events
+     */
+    static async getNextSeq(dialogId, round, status = 'running') {
+        const events = await this.readRoundEvents(dialogId, round, status);
+        let maxSeq = 0;
+        for (const ev of events) {
+            if ('genseq' in ev && typeof ev.genseq === 'number' && ev.genseq > maxSeq) {
+                maxSeq = ev.genseq;
+            }
+        }
+        return maxSeq + 1;
+    }
+    /**
+     * Get current round number from latest.yaml (performance optimization)
+     * UI navigation can assume natural numbering schema back to 1
+     */
+    static async getCurrentRoundNumber(dialogId, status = 'running') {
+        try {
+            const latest = await this.loadDialogLatest(dialogId, status);
+            return latest?.currentRound || 1;
+        }
+        catch (error) {
+            log_1.log.error(`Failed to get current round for dialog ${dialogId}:`, error);
+            return 1;
+        }
+    }
+    /**
+     * Save reminder state (exceptional overwrite pattern) (internal use only)
+     */
+    static async _saveReminderState(dialogId, reminders, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            const remindersFilePath = path.join(dialogPath, 'reminders.json');
+            const reminderState = {
+                reminders: reminders.map((r, index) => ({
+                    id: `reminder-${index}`,
+                    content: r.content,
+                    ownerName: r.owner ? r.owner.name : undefined,
+                    meta: r.meta,
+                    createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                    priority: 'medium',
+                })),
+                updatedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            };
+            // Atomic write operation
+            const tempFile = `${remindersFilePath}.${process.pid}.${Date.now()}.tmp`;
+            await fs.promises.writeFile(tempFile, JSON.stringify(reminderState, null, 2), 'utf-8');
+            await fs.promises.rename(tempFile, remindersFilePath);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save reminder state for dialog ${dialogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Load reminder state
+     */
+    static async loadReminderState(dialogId, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const remindersFilePath = path.join(dialogPath, 'reminders.json');
+            try {
+                const content = await fs.promises.readFile(remindersFilePath, 'utf-8');
+                const reminderState = JSON.parse(content);
+                return reminderState.reminders.map((r) => {
+                    const ownerNameFromFile = typeof r.ownerName === 'string' ? r.ownerName : undefined;
+                    const owner = ownerNameFromFile ? (0, registry_1.getReminderOwner)(ownerNameFromFile) : undefined;
+                    return {
+                        id: r.id,
+                        content: r.content,
+                        owner,
+                        meta: r.meta,
+                        createdAt: r.createdAt,
+                        priority: r.priority,
+                    };
+                });
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    // reminders.json doesn't exist - return empty array
+                    return [];
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to load reminder state for dialog ${dialogId}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Save questions for human state (exceptional overwrite pattern) (internal use only)
+     */
+    static async _saveQuestions4HumanState(dialogId, questions, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const questionsFilePath = path.join(dialogPath, 'q4h.yaml');
+            const questionsState = {
+                questions,
+                updatedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            };
+            // Atomic write operation
+            const tempFile = questionsFilePath + '.tmp';
+            const yamlContent = yaml.stringify(questionsState);
+            await fs.promises.writeFile(tempFile, yamlContent, 'utf-8');
+            await fs.promises.rename(tempFile, questionsFilePath);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save q4h.yaml for dialog ${dialogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Load questions for human state
+     */
+    static async loadQuestions4HumanState(dialogId, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const questionsFilePath = path.join(dialogPath, 'q4h.yaml');
+            try {
+                const content = await fs.promises.readFile(questionsFilePath, 'utf-8');
+                const questionsState = yaml.parse(content);
+                return questionsState.questions.map((q) => ({
+                    ...q,
+                    kind: normalizeQ4HKind(q.kind),
+                }));
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    // q4h.yaml doesn't exist - return empty array
+                    return [];
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to load q4h.yaml for dialog ${dialogId}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Load all Q4H questions from all running dialogs (for global Q4H display)
+     * Returns array of questions with their dialog context for frontend display
+     */
+    static async loadAllQ4HState() {
+        try {
+            // Get all running dialogs (root + subdialogs) with correct rootId association.
+            const dialogIds = await this.listAllDialogIds('running');
+            const allQuestions = [];
+            for (const dialogIdObj of dialogIds) {
+                try {
+                    const questions = await this.loadQuestions4HumanState(dialogIdObj, 'running');
+                    const metadata = await this.loadDialogMetadata(dialogIdObj, 'running');
+                    if (metadata && questions.length > 0) {
+                        for (const q of questions) {
+                            allQuestions.push({
+                                ...q,
+                                selfId: dialogIdObj.selfId,
+                                rootId: dialogIdObj.rootId,
+                                agentId: metadata.agentId,
+                                taskDocPath: metadata.taskDocPath,
+                            });
+                        }
+                    }
+                }
+                catch (err) {
+                    log_1.log.warn(`Failed to load Q4H for dialog ${dialogIdObj.valueOf()}:`, err);
+                }
+            }
+            return allQuestions;
+        }
+        catch (error) {
+            log_1.log.error('Failed to load all Q4H state:', error);
+            return [];
+        }
+    }
+    static async clearQuestions4HumanState(dialogId, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const questionsFilePath = path.join(dialogPath, 'q4h.yaml');
+            let previousCount = 0;
+            let existingQuestions = [];
+            try {
+                existingQuestions = await this.loadQuestions4HumanState(dialogId, status);
+                previousCount = existingQuestions.length;
+            }
+            catch (err) {
+                log_1.log.debug('No existing questions state found, using default count', err);
+            }
+            await fs.promises.rm(questionsFilePath, { force: true });
+            // Emit q4h_answered events for each removed question
+            for (const q of existingQuestions) {
+                const answeredEvent = {
+                    type: 'q4h_answered',
+                    questionId: q.id,
+                    selfId: dialogId.selfId,
+                };
+                (0, evt_registry_1.postDialogEventById)(dialogId, answeredEvent);
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to clear q4h.yaml for dialog ${dialogId}:`, error);
+        }
+    }
+    // === PHASE 6: SUBDIALOG SUPPLY PERSISTENCE ===
+    /**
+     * Save pending subdialogs for Type A supply mechanism.
+     * Tracks subdialogs that were created but not yet completed.
+     */
+    static async savePendingSubdialogs(rootDialogId, pendingSubdialogs, status = 'running') {
+        try {
+            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            const filePath = path.join(dialogPath, 'pending-subdialogs.json');
+            // Atomic write operation
+            const tempFile = filePath + '.tmp';
+            await fs.promises.writeFile(tempFile, JSON.stringify(pendingSubdialogs, null, 2), 'utf-8');
+            await fs.promises.rename(tempFile, filePath);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save pending subdialogs for dialog ${rootDialogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Load pending subdialogs for Type A supply mechanism.
+     */
+    static async loadPendingSubdialogs(rootDialogId, status = 'running') {
+        try {
+            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            const filePath = path.join(dialogPath, 'pending-subdialogs.json');
+            try {
+                const content = await fs.promises.readFile(filePath, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    return [];
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to load pending subdialogs for dialog ${rootDialogId}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Get the path for storing subdialog responses (supports both root and subdialog parents).
+     * For Type C subdialogs created inside another subdialog, responses are stored at the parent's level.
+     */
+    static getDialogResponsesPath(dialogId, status = 'running') {
+        // Root dialogs store responses in their own directory.
+        // Subdialogs store responses in the parent's location (root or subdialog).
+        if (dialogId.rootId === dialogId.selfId) {
+            // Root dialog: use root's directory
+            return this.getRootDialogPath(dialogId, status);
+        }
+        // Subdialog: store in parent's subdialogs directory
+        // The parent is always identified by rootId (could be root or parent subdialog)
+        const parentSelfId = dialogId.rootId;
+        const rootPath = this.getRootDialogPath(new dialog_1.DialogID(parentSelfId), status);
+        return path.join(rootPath, this.SUBDIALOGS_DIR, dialogId.selfId);
+    }
+    /**
+     * Save subdialog responses for Type A supply mechanism.
+     * Tracks responses from completed subdialogs.
+     */
+    static async saveSubdialogResponses(rootDialogId, responses, status = 'running') {
+        try {
+            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            const filePath = path.join(dialogPath, 'subdialog-responses.json');
+            // Atomic write operation
+            const tempFile = filePath + '.tmp';
+            await fs.promises.writeFile(tempFile, JSON.stringify(responses, null, 2), 'utf-8');
+            await fs.promises.rename(tempFile, filePath);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save subdialog responses for dialog ${rootDialogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Load subdialog responses for Type A supply mechanism.
+     */
+    static async loadSubdialogResponses(rootDialogId, status = 'running') {
+        try {
+            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            const filePath = path.join(dialogPath, 'subdialog-responses.json');
+            const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+            try {
+                const results = [];
+                const tryReadArray = async (p) => {
+                    try {
+                        const content = await fs.promises.readFile(p, 'utf-8');
+                        const parsed = JSON.parse(content);
+                        return Array.isArray(parsed) ? parsed : [];
+                    }
+                    catch (error) {
+                        if (getErrorCode(error) === 'ENOENT') {
+                            return [];
+                        }
+                        throw error;
+                    }
+                };
+                const primary = await tryReadArray(filePath);
+                const inflight = await tryReadArray(inflightPath);
+                for (const item of [...primary, ...inflight]) {
+                    if (isSubdialogResponseRecord(item)) {
+                        results.push(item);
+                    }
+                }
+                // Deduplicate by responseId (primary wins over inflight order is irrelevant)
+                const byId = new Map();
+                for (const r of results) {
+                    byId.set(r.responseId, r);
+                }
+                return Array.from(byId.values());
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    return [];
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to load subdialog responses for dialog ${rootDialogId}:`, error);
+            return [];
+        }
+    }
+    static async loadSubdialogResponsesQueue(dialogId, status = 'running') {
+        try {
+            const dialogPath = this.getDialogResponsesPath(dialogId, status);
+            const filePath = path.join(dialogPath, 'subdialog-responses.json');
+            const content = await fs.promises.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+            return parsed.filter(isSubdialogResponseRecord);
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    static async appendSubdialogResponse(dialogId, response, status = 'running') {
+        const existing = await this.loadSubdialogResponsesQueue(dialogId, status);
+        existing.push(response);
+        await this.saveSubdialogResponses(dialogId, existing, status);
+    }
+    static async takeSubdialogResponses(dialogId, status = 'running') {
+        const dialogPath = this.getDialogResponsesPath(dialogId, status);
+        await fs.promises.mkdir(dialogPath, { recursive: true });
+        const filePath = path.join(dialogPath, 'subdialog-responses.json');
+        const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+        // If a previous processing file exists, merge it back so it will be re-processed.
+        try {
+            await fs.promises.access(inflightPath);
+            await this.rollbackTakenSubdialogResponses(dialogId, status);
+        }
+        catch {
+            // no-op
+        }
+        try {
+            await fs.promises.rename(filePath, inflightPath);
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+        try {
+            const raw = await fs.promises.readFile(inflightPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+            return parsed.filter(isSubdialogResponseRecord);
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    static async commitTakenSubdialogResponses(dialogId, status = 'running') {
+        const dialogPath = this.getDialogResponsesPath(dialogId, status);
+        const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+        await fs.promises.rm(inflightPath, { force: true });
+    }
+    static async rollbackTakenSubdialogResponses(dialogId, status = 'running') {
+        const dialogPath = this.getDialogResponsesPath(dialogId, status);
+        await fs.promises.mkdir(dialogPath, { recursive: true });
+        const filePath = path.join(dialogPath, 'subdialog-responses.json');
+        const inflightPath = path.join(dialogPath, 'subdialog-responses.processing.json');
+        let inflight = [];
+        try {
+            const raw = await fs.promises.readFile(inflightPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            inflight = Array.isArray(parsed) ? parsed : [];
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return;
+            }
+            throw error;
+        }
+        let primary = [];
+        try {
+            const raw = await fs.promises.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            primary = Array.isArray(parsed) ? parsed : [];
+        }
+        catch (error) {
+            if (getErrorCode(error) !== 'ENOENT') {
+                throw error;
+            }
+        }
+        const merged = [...inflight, ...primary].filter(isSubdialogResponseRecord);
+        const byId = new Map();
+        for (const r of merged) {
+            byId.set(r.responseId, r);
+        }
+        const result = Array.from(byId.values());
+        const tempFile = filePath + '.tmp';
+        await fs.promises.writeFile(tempFile, JSON.stringify(result, null, 2), 'utf-8');
+        await fs.promises.rename(tempFile, filePath);
+        await fs.promises.rm(inflightPath, { force: true });
+    }
+    /**
+     * Save root dialog metadata (write-once pattern)
+     */
+    static async saveRootDialogMetadata(dialogId, metadata, status = 'running') {
+        try {
+            const dialogPath = this.getRootDialogPath(dialogId, status);
+            // Ensure dialog directory exists first
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            // Atomic write operation
+            const metadataFilePath = path.join(dialogPath, 'dialog.yaml');
+            const tempFile = metadataFilePath + '.tmp';
+            const yamlContent = yaml.stringify(metadata);
+            await fs.promises.writeFile(tempFile, yamlContent, 'utf-8');
+            await fs.promises.rename(tempFile, metadataFilePath);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save dialog YAML for dialog ${dialogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Save dialog metadata (universal - works with any DialogID)
+     */
+    static async saveDialogMetadata(dialogId, metadata, status = 'running') {
+        if (dialogId.rootId === dialogId.selfId) {
+            if (!isRootDialogMetadataFile(metadata)) {
+                throw new Error(`Expected root dialog metadata for ${dialogId.selfId}`);
+            }
+            return this.saveRootDialogMetadata(dialogId, metadata, status);
+        }
+        // For subdialogs, delegate to saveSubdialogMetadata
+        if (!isSubdialogMetadataFile(metadata)) {
+            throw new Error(`Expected subdialog metadata for ${dialogId.selfId}`);
+        }
+        return this.saveSubdialogMetadata(dialogId, metadata, status);
+    }
+    /**
+     * Save dialog metadata (legacy - use saveRootDialogMetadata instead)
+     * @deprecated
+     */
+    static async _saveDialogMetadata(dialogId, metadata, status = 'running') {
+        return this.saveRootDialogMetadata(dialogId, metadata, status);
+    }
+    /**
+     * Save subdialog metadata under the supdialog's .subdialogs directory
+     */
+    static async saveSubdialogMetadata(dialogId, metadata, status = 'running') {
+        try {
+            const subPath = this.getSubdialogPath(dialogId, status);
+            const metadataFilePath = path.join(subPath, 'dialog.yaml');
+            await fs.promises.mkdir(subPath, { recursive: true });
+            const tempFile = metadataFilePath + '.tmp';
+            const yamlContent = yaml.stringify(metadata);
+            await fs.promises.writeFile(tempFile, yamlContent, 'utf-8');
+            await fs.promises.rename(tempFile, metadataFilePath);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save subdialog YAML for ${dialogId.selfId} under root dialog ${dialogId.rootId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Update assignmentFromSup for an existing subdialog.
+     * Persists both subdialog metadata locations for consistency.
+     */
+    static async updateSubdialogAssignment(dialogId, assignment, status = 'running') {
+        if (dialogId.rootId === dialogId.selfId) {
+            throw new Error('updateSubdialogAssignment expects a subdialog id');
+        }
+        const metadata = await this.loadDialogMetadata(dialogId, status);
+        if (!metadata || !isSubdialogMetadataFile(metadata)) {
+            throw new Error(`Missing dialog metadata for subdialog ${dialogId.selfId}`);
+        }
+        const next = {
+            ...metadata,
+            assignmentFromSup: assignment,
+        };
+        await this.saveSubdialogMetadata(dialogId, next, status);
+        await this.saveDialogMetadata(dialogId, next, status);
+    }
+    /**
+     * Load root dialog metadata
+     */
+    static async loadRootDialogMetadata(dialogId, status = 'running') {
+        try {
+            const dialogPath = this.getRootDialogPath(dialogId, status);
+            const metadataFilePath = path.join(dialogPath, 'dialog.yaml');
+            try {
+                const content = await fs.promises.readFile(metadataFilePath, 'utf-8');
+                const parsed = yaml.parse(content);
+                if (!isDialogMetadataFile(parsed)) {
+                    throw new Error(`Invalid dialog metadata in ${metadataFilePath}`);
+                }
+                // Validate that the ID in the file matches the expected dialogId
+                if (parsed.id !== dialogId.selfId) {
+                    log_1.log.warn(`Dialog ID mismatch in ${metadataFilePath}: expected ${dialogId.selfId}, got ${parsed.id}`);
+                    return null;
+                }
+                return parsed;
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    return null;
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to load dialog YAML for dialog ${dialogId.selfId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Load dialog metadata (universal - works with any DialogID)
+     */
+    static async loadDialogMetadata(dialogId, status = 'running') {
+        // For root dialogs, use the selfId
+        // For subdialogs, this is more complex - we need to find the root metadata
+        if (dialogId.rootId === dialogId.selfId) {
+            return this.loadRootDialogMetadata(dialogId, status);
+        }
+        // For subdialogs, we need to load from the subdialog location
+        const subdialogPath = this.getSubdialogPath(dialogId, status);
+        const metadataFilePath = path.join(subdialogPath, 'dialog.yaml');
+        try {
+            const content = await fs.promises.readFile(metadataFilePath, 'utf-8');
+            const parsed = yaml.parse(content);
+            if (!isDialogMetadataFile(parsed)) {
+                throw new Error(`Invalid dialog metadata in ${metadataFilePath}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Save latest.yaml with current round and lastModified info
+     */
+    static async writeDialogLatestToDisk(dialogId, latest, status = 'running') {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const latestFilePath = path.join(dialogPath, 'latest.yaml');
+            // Ensure directory exists before writing (handles race conditions and new dialogs)
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            // NOTE: Use a unique temp file name to avoid collisions when multiple updates
+            // happen concurrently for the same dialog (e.g., parallel tool responses).
+            const tempFile = path.join(dialogPath, `.${path.basename(latestFilePath)}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+            const yamlContent = yaml.stringify(latest);
+            await fs.promises.writeFile(tempFile, yamlContent, 'utf-8');
+            // Rename with retry logic for filesystem sync issues
+            await this.renameWithRetry(tempFile, latestFilePath, yamlContent);
+            // todo: publish RoundEvent here or where more suitable?
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save latest.yaml for dialog ${dialogId.selfId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Rename with retry logic to handle filesystem sync issues
+     */
+    static async renameWithRetry(source, destination, yamlContent, maxRetries = 5) {
+        let lastError;
+        const destinationDir = path.dirname(destination);
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // Ensure directory exists (handles race conditions)
+                await fs.promises.mkdir(destinationDir, { recursive: true });
+                // Check if source file exists, re-create if missing
+                try {
+                    await fs.promises.access(source);
+                }
+                catch {
+                    // Source file missing - re-create it
+                    await fs.promises.writeFile(source, yamlContent, 'utf-8');
+                }
+                await fs.promises.rename(source, destination);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (getErrorCode(error) !== 'ENOENT' || attempt === maxRetries) {
+                    throw error;
+                }
+                // Exponential backoff for ENOENT (race condition or sync issue)
+                await new Promise((resolve) => setTimeout(resolve, 20 * attempt));
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Load latest.yaml for current round and lastModified info
+     */
+    static async loadDialogLatest(dialogId, status = 'running') {
+        try {
+            const key = this.getLatestWriteBackKey(dialogId, status);
+            const staged = this.latestWriteBack.get(key);
+            if (staged) {
+                return staged.latest;
+            }
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const latestFilePath = path.join(dialogPath, 'latest.yaml');
+            const content = await fs.promises.readFile(latestFilePath, 'utf-8');
+            const parsed = yaml.parse(content);
+            if (!isDialogLatestFile(parsed)) {
+                throw new Error(`Invalid latest.yaml in ${latestFilePath}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Delta-only latest.yaml update API.
+     *
+     * Callers provide a mutation callback which is applied against the most recent
+     * staged state (or disk fallback). This avoids read-modify-write races in user code
+     * and allows lock-free-ish coalescing to disk via the write-back buffer.
+     */
+    static async mutateDialogLatest(dialogId, mutator, status = 'running') {
+        const key = this.getLatestWriteBackKey(dialogId, status);
+        const mutex = this.getLatestWriteBackMutex(key);
+        const release = await mutex.acquire();
+        try {
+            const staged = this.latestWriteBack.get(key);
+            const existing = (staged
+                ? staged.latest
+                : await this.loadDialogLatestFromDisk(dialogId, status)) || {
+                currentRound: 1,
+                lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                status: 'active',
+            };
+            const mutation = mutator(existing);
+            let updated;
+            if (mutation.kind === 'noop') {
+                return existing;
+            }
+            else if (mutation.kind === 'replace') {
+                updated = {
+                    ...mutation.next,
+                    lastModified: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                };
+            }
+            else if (mutation.kind === 'patch') {
+                updated = {
+                    ...existing,
+                    ...mutation.patch,
+                    lastModified: mutation.patch.lastModified || (0, time_1.formatUnifiedTimestamp)(new Date()),
+                };
+            }
+            else {
+                const _exhaustive = mutation;
+                throw new Error(`Unhandled dialog latest mutation: ${String(_exhaustive)}`);
+            }
+            const pending = this.latestWriteBack.get(key);
+            if (!pending) {
+                const timer = setTimeout(() => {
+                    void this.flushLatestWriteBack(key);
+                }, this.LATEST_WRITEBACK_WINDOW_MS);
+                this.latestWriteBack.set(key, {
+                    kind: 'scheduled',
+                    dialogId,
+                    status,
+                    latest: updated,
+                    timer,
+                });
+                return updated;
+            }
+            pending.latest = updated;
+            if (pending.kind === 'flushing') {
+                pending.dirty = true;
+            }
+            // Keep the existing timer to ensure a bounded flush window.
+            return updated;
+        }
+        finally {
+            release();
+        }
+    }
+    static async loadDialogLatestFromDisk(dialogId, status) {
+        try {
+            const dialogPath = this.getDialogEventsPath(dialogId, status);
+            const latestFilePath = path.join(dialogPath, 'latest.yaml');
+            const content = await fs.promises.readFile(latestFilePath, 'utf-8');
+            const parsed = yaml.parse(content);
+            if (!isDialogLatestFile(parsed)) {
+                throw new Error(`Invalid latest.yaml in ${latestFilePath}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    static async flushLatestWriteBack(key) {
+        const mutex = this.getLatestWriteBackMutex(key);
+        let captured;
+        {
+            const release = await mutex.acquire();
+            try {
+                const entry = this.latestWriteBack.get(key);
+                if (!entry)
+                    return;
+                if (entry.kind === 'flushing')
+                    return;
+                if (entry.kind !== 'scheduled')
+                    return;
+                clearTimeout(entry.timer);
+                const latestToWrite = entry.latest;
+                const inFlight = this.writeDialogLatestToDisk(entry.dialogId, latestToWrite, entry.status);
+                captured = {
+                    dialogId: entry.dialogId,
+                    status: entry.status,
+                    latestToWrite,
+                    inFlight,
+                };
+                this.latestWriteBack.set(key, {
+                    kind: 'flushing',
+                    dialogId: entry.dialogId,
+                    status: entry.status,
+                    latest: entry.latest,
+                    dirty: false,
+                    inFlight,
+                });
+            }
+            finally {
+                release();
+            }
+        }
+        if (!captured)
+            return;
+        try {
+            await captured.inFlight;
+        }
+        catch (error) {
+            const release = await mutex.acquire();
+            try {
+                const entry = this.latestWriteBack.get(key);
+                if (!entry)
+                    return;
+                if (entry.kind !== 'flushing')
+                    return;
+                if (entry.inFlight !== captured.inFlight)
+                    return;
+                const timer = setTimeout(() => {
+                    void this.flushLatestWriteBack(key);
+                }, this.LATEST_WRITEBACK_WINDOW_MS);
+                this.latestWriteBack.set(key, {
+                    kind: 'scheduled',
+                    dialogId: entry.dialogId,
+                    status: entry.status,
+                    latest: entry.latest,
+                    timer,
+                });
+            }
+            finally {
+                release();
+            }
+            return;
+        }
+        const release = await mutex.acquire();
+        try {
+            const entry = this.latestWriteBack.get(key);
+            if (!entry)
+                return;
+            if (entry.kind !== 'flushing')
+                return;
+            if (entry.inFlight !== captured.inFlight)
+                return;
+            if (!entry.dirty) {
+                this.latestWriteBack.delete(key);
+                return;
+            }
+            const timer = setTimeout(() => {
+                void this.flushLatestWriteBack(key);
+            }, this.LATEST_WRITEBACK_WINDOW_MS);
+            this.latestWriteBack.set(key, {
+                kind: 'scheduled',
+                dialogId: entry.dialogId,
+                status: entry.status,
+                latest: entry.latest,
+                timer,
+            });
+        }
+        finally {
+            release();
+        }
+    }
+    static async setNeedsDrive(dialogId, needsDrive, status = 'running') {
+        await this.mutateDialogLatest(dialogId, () => ({ kind: 'patch', patch: { needsDrive } }), status);
+    }
+    static async getNeedsDrive(dialogId, status = 'running') {
+        const latest = await this.loadDialogLatest(dialogId, status);
+        return latest?.needsDrive === true;
+    }
+    // === FILE SYSTEM UTILITIES ===
+    /**
+     * Get round filename from round number
+     */
+    static getRoundFilename(round) {
+        return `round-${round.toString().padStart(3, '0')}.jsonl`;
+    }
+    /**
+     * Extract round number from filename
+     */
+    static getRoundFromFilename(filename) {
+        const match = filename.match(/^round-(\d+)\.jsonl$/);
+        if (!match) {
+            throw new Error(`Invalid round filename: ${filename}`);
+        }
+        return parseInt(match[1], 10);
+    }
+    /**
+     * Get dialog status from file system path
+     */
+    static getStatusFromPath(dialogPath) {
+        const parentDir = path.basename(path.dirname(dialogPath));
+        if (parentDir === this.RUN_DIR)
+            return 'running';
+        if (parentDir === this.DONE_DIR)
+            return 'completed';
+        if (parentDir === this.ARCHIVE_DIR)
+            return 'archived';
+        throw new Error(`Unknown dialog status from path: ${parentDir}`);
+    }
+    static async loadQuestions4Human(dialogId, round, status = 'running') {
+        const questions = await this.loadQuestions4HumanState(dialogId, status);
+        return {
+            round,
+            questions,
+            createdAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            updatedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+        };
+    }
+    /**
+     * Count subdialogs under a root dialog (no single-layer listing exposed)
+     */
+    static async countAllSubdialogsUnderRoot(rootDialogId, status = 'running') {
+        try {
+            const rootPath = this.getRootDialogPath(rootDialogId, status);
+            const subdialogsPath = path.join(rootPath, this.SUBDIALOGS_DIR);
+            try {
+                const entries = await fs.promises.readdir(subdialogsPath, { withFileTypes: true });
+                return entries.filter((entry) => entry.isDirectory()).length;
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    return 0;
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            log_1.log.error(`Failed to count all subdialogs under root ${rootDialogId.selfId}:`, error);
+            return 0;
+        }
+    }
+    // === HIERARCHICAL DIALOG RESTORATION ===
+    /**
+     * Restore complete dialog tree from disk
+     */
+    static async restoreDialogTree(rootDialogId, status = 'running') {
+        try {
+            // First restore the root dialog
+            const rootState = await this.restoreDialog(rootDialogId, status);
+            if (!rootState) {
+                return null;
+            }
+            // Recursively restore subdialogs
+            const rootPath = this.getRootDialogPath(rootDialogId, status);
+            const subdialogsPath = path.join(rootPath, this.SUBDIALOGS_DIR);
+            let subdialogIds = [];
+            try {
+                const entries = await fs.promises.readdir(subdialogsPath, { withFileTypes: true });
+                subdialogIds = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+            }
+            catch (err) {
+                if (getErrorCode(err) !== 'ENOENT') {
+                    throw err;
+                }
+            }
+            for (const subdialogId of subdialogIds) {
+                await this.restoreDialogTree(new dialog_1.DialogID(subdialogId, rootDialogId.rootId), status);
+            }
+            return rootState;
+        }
+        catch (error) {
+            log_1.log.error(`Failed to restore dialog tree for ${rootDialogId.valueOf()}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Restore dialog from disk using JSONL events (optimized: only latest round loaded)
+     * For historical rounds, use loadRoundEvents() on-demand for UI navigation
+     */
+    static async restoreDialog(dialogId, status = 'running') {
+        try {
+            const metadata = await this.loadDialogMetadata(dialogId, status);
+            if (!metadata) {
+                log_1.log.debug(`No metadata found for dialog ${dialogId}`);
+                return null;
+            }
+            const reminders = await this.loadReminderState(dialogId, status);
+            // Only load latest round for dialog state restoration
+            const currentRound = await this.getCurrentRoundNumber(dialogId, status);
+            const latestEvents = await this.readRoundEvents(dialogId, currentRound, status);
+            const reconstructedState = await this.rebuildFromEvents(latestEvents, metadata, reminders, currentRound);
+            return reconstructedState;
+        }
+        catch (error) {
+            log_1.log.error(`Failed to restore dialog ${dialogId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Load specific round events for UI navigation (on-demand)
+     */
+    static async loadRoundEvents(dialogId, round, status = 'running') {
+        return await this.readRoundEvents(dialogId, round, status);
+    }
+    /**
+     * Reconstruct dialog state from JSONL events (optimized: only latest round needed)
+     */
+    static async rebuildFromEvents(events, metadata, reminders, currentRound) {
+        // Events are already in chronological order from JSONL file (append-only pattern)
+        const messages = [];
+        let contextHealth;
+        // Simple, straightforward mapping to reconstruct messages from persisted events
+        for (const event of events) {
+            switch (event.type) {
+                case 'agent_thought_record': {
+                    // Convert agent thought to ChatMessage
+                    messages.push({
+                        type: 'thinking_msg',
+                        role: 'assistant',
+                        genseq: event.genseq,
+                        content: event.content,
+                        provider_data: event.provider_data,
+                    });
+                    break;
+                }
+                case 'agent_words_record': {
+                    // Convert agent words to ChatMessage
+                    messages.push({
+                        type: 'saying_msg',
+                        role: 'assistant',
+                        genseq: event.genseq,
+                        content: event.content,
+                    });
+                    break;
+                }
+                case 'human_text_record': {
+                    // Convert human text to prompting message
+                    messages.push({
+                        type: 'prompting_msg',
+                        role: 'user',
+                        genseq: event.genseq,
+                        msgId: event.msgId,
+                        content: event.content,
+                        grammar: event.grammar ?? 'tellask',
+                    });
+                    break;
+                }
+                case 'func_call_record': {
+                    // Convert function call to ChatMessage
+                    messages.push({
+                        type: 'func_call_msg',
+                        role: 'assistant',
+                        genseq: event.genseq,
+                        id: event.id,
+                        name: event.name,
+                        arguments: event.arguments ? JSON.stringify(event.arguments) : '{}',
+                    });
+                    break;
+                }
+                case 'func_result_record': {
+                    // Convert function result to ChatMessage
+                    messages.push({
+                        type: 'func_result_msg',
+                        role: 'tool',
+                        genseq: event.genseq,
+                        id: event.id,
+                        name: event.name,
+                        content: event.content,
+                    });
+                    break;
+                }
+                case 'tool_call_result_record': {
+                    // Convert tool call result to ChatMessage
+                    messages.push({
+                        type: 'call_result_msg',
+                        role: 'tool',
+                        responderId: event.responderId,
+                        headLine: event.headLine,
+                        status: event.status,
+                        content: event.result,
+                    });
+                    break;
+                }
+                case 'teammate_response_record': {
+                    // Convert teammate response to ChatMessage (teammate - separate bubble)
+                    // Note: Teammate responses are stored as separate records but use same message type
+                    const formattedResult = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                        responderId: event.responderId,
+                        requesterId: event.originMemberId,
+                        originalCallHeadLine: event.headLine,
+                        responseBody: event.response,
+                        language: (0, runtime_language_1.getWorkLanguage)(),
+                    });
+                    messages.push({
+                        type: 'call_result_msg',
+                        role: 'tool',
+                        responderId: event.responderId,
+                        headLine: event.headLine,
+                        status: event.status,
+                        content: formattedResult,
+                    });
+                    break;
+                }
+                // gen_start_record and gen_finish_record are control events, not message content
+                // They don't need to be converted to ChatMessage objects
+                case 'gen_start_record':
+                    break;
+                case 'gen_finish_record':
+                    if (event.contextHealth) {
+                        contextHealth = event.contextHealth;
+                    }
+                    break;
+                case 'quest_for_sup_record':
+                    // These events are handled separately in dialog restoration
+                    // Skip them for message reconstruction
+                    break;
+                default:
+                    log_1.log.warn(`Unknown event type in rebuildFromEvents`, undefined, { event });
+                    break;
+            }
+        }
+        return {
+            metadata,
+            currentRound,
+            messages,
+            reminders,
+            contextHealth,
+        };
+    }
+    /**
+     * Move dialog between status directories (run/done/archive)
+     */
+    static async moveDialogStatus(dialogId, fromStatus, toStatus) {
+        try {
+            const fromPath = path.join(this.getDialogsRootDir(), fromStatus === 'running'
+                ? this.RUN_DIR
+                : fromStatus === 'completed'
+                    ? this.DONE_DIR
+                    : this.ARCHIVE_DIR, dialogId.selfId);
+            const toPath = path.join(this.getDialogsRootDir(), toStatus === 'running'
+                ? this.RUN_DIR
+                : toStatus === 'completed'
+                    ? this.DONE_DIR
+                    : this.ARCHIVE_DIR, dialogId.selfId);
+            // Ensure destination directory exists
+            await fs.promises.mkdir(toPath, { recursive: true });
+            // Move all files and directories
+            const entries = await fs.promises.readdir(fromPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const srcPath = path.join(fromPath, entry.name);
+                const destPath = path.join(toPath, entry.name);
+                await fs.promises.rename(srcPath, destPath);
+            }
+            // Remove the (now-empty) source directory so the dialog is not detected under both statuses.
+            await fs.promises.rm(fromPath, { recursive: true, force: true });
+        }
+        catch (error) {
+            log_1.log.error(`Failed to move dialog ${dialogId} from ${fromStatus} to ${toStatus}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Find the current persistence status directory for a root dialog.
+     * Root dialogs are stored under exactly one of: run/ | done/ | archive/
+     */
+    static async findRootDialogStatus(rootDialogId) {
+        if (rootDialogId.selfId !== rootDialogId.rootId) {
+            throw new Error('Expected root dialog id (selfId must equal rootId)');
+        }
+        const candidates = [
+            { status: 'running', dirName: this.RUN_DIR },
+            { status: 'completed', dirName: this.DONE_DIR },
+            { status: 'archived', dirName: this.ARCHIVE_DIR },
+        ];
+        for (const candidate of candidates) {
+            const candidatePath = path.join(this.getDialogsRootDir(), candidate.dirName, rootDialogId.selfId);
+            try {
+                // `run/` can contain stray placeholder directories (e.g. created by status-agnostic metadata updates).
+                // Treat a status as valid only if it contains the root dialog's dialog.yaml.
+                const dialogYamlPath = path.join(candidatePath, 'dialog.yaml');
+                const st = await fs.promises.stat(dialogYamlPath);
+                if (st.isFile()) {
+                    return candidate.status;
+                }
+            }
+            catch (error) {
+                if (getErrorCode(error) === 'ENOENT') {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return null;
+    }
+    /**
+     * Delete a root dialog directory (including subdialogs) from disk.
+     * Returns the status directory the dialog was deleted from, or null if not found.
+     */
+    static async deleteRootDialog(rootDialogId) {
+        const status = await this.findRootDialogStatus(rootDialogId);
+        if (!status)
+            return null;
+        // Best-effort cleanup: remove the dialog from all status directories to avoid leaving behind
+        // orphaned placeholder paths (e.g. `run/<id>/latest.yaml`) after a delete.
+        const allStatuses = [
+            'running',
+            'completed',
+            'archived',
+        ];
+        for (const candidate of allStatuses) {
+            const candidatePath = this.getRootDialogPath(rootDialogId, candidate);
+            await fs.promises.rm(candidatePath, { recursive: true, force: true });
+        }
+        return status;
+    }
+    // === REGISTRY PERSISTENCE ===
+    /**
+     * Save subdialog registry (TYPE B entries).
+     */
+    static async saveSubdialogRegistry(rootDialogId, entries, status = 'running') {
+        try {
+            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            const registryFilePath = path.join(dialogPath, 'registry.yaml');
+            await fs.promises.mkdir(dialogPath, { recursive: true });
+            const serializableEntries = entries.map((entry) => ({
+                key: entry.key,
+                subdialogId: entry.subdialogId.selfId,
+                agentId: entry.agentId,
+                tellaskSession: entry.tellaskSession,
+            }));
+            const tempFile = registryFilePath + '.tmp';
+            const yamlContent = yaml.stringify({ entries: serializableEntries });
+            await fs.promises.writeFile(tempFile, yamlContent, 'utf-8');
+            await fs.promises.rename(tempFile, registryFilePath);
+        }
+        catch (error) {
+            log_1.log.error(`Failed to save subdialog registry for dialog ${rootDialogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Load subdialog registry.
+     */
+    static async loadSubdialogRegistry(rootDialogId, status = 'running') {
+        try {
+            const dialogPath = this.getDialogResponsesPath(rootDialogId, status);
+            const registryFilePath = path.join(dialogPath, 'registry.yaml');
+            const content = await fs.promises.readFile(registryFilePath, 'utf-8');
+            const parsed = yaml.parse(content);
+            if (!isRecord(parsed) || !Array.isArray(parsed.entries)) {
+                log_1.log.warn(`Invalid registry.yaml format for dialog ${rootDialogId}`);
+                return [];
+            }
+            const entries = parsed.entries.map((entry) => {
+                if (!isRecord(entry)) {
+                    throw new Error('Invalid registry entry');
+                }
+                return {
+                    key: entry.key,
+                    subdialogId: new dialog_1.DialogID(entry.subdialogId, rootDialogId.rootId),
+                    agentId: entry.agentId,
+                    tellaskSession: entry.tellaskSession,
+                };
+            });
+            return entries;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT') {
+                return [];
+            }
+            log_1.log.error(`Failed to load subdialog registry for dialog ${rootDialogId}:`, error);
+            return [];
+        }
+    }
+}
+exports.DialogPersistence = DialogPersistence;
+DialogPersistence.DIALOGS_DIR = '.dialogs';
+DialogPersistence.RUN_DIR = 'run';
+DialogPersistence.DONE_DIR = 'done';
+DialogPersistence.ARCHIVE_DIR = 'archive';
+DialogPersistence.SUBDIALOGS_DIR = 'subdialogs';
+DialogPersistence.LATEST_WRITEBACK_WINDOW_MS = 300;
+DialogPersistence.latestWriteBackMutexes = new Map();
+DialogPersistence.latestWriteBack = new Map();