dominds 0.1.0

package/dist/dialog.js

@@ -0,0 +1,1024 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogStore = exports.RootDialog = exports.SubDialog = exports.Dialog = exports.DialogID = void 0;
+/**
+ * Module: dialog
+ *
+ * Provides the `Dialog` object for orchestrating conversations:
+ * - Tracks messages, agent identity, optional supdialog/subdialog relationships
+ * - Receivers for streaming LLM output and tool results
+ * - Helpers for spawning subdialogs and prompting human input
+ * - Persistence support for dialog state and message history
+ *
+ * Architecture (Phase 2):
+ * - `Dialog` - Abstract base class for all dialogs
+ * - `RootDialog` - Root dialog with subdialog registry
+ * - `SubDialog` - Subdialog with root dialog reference and dynamic supdialog resolution
+ */
+const util_1 = require("util");
+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 id_1 = require("./shared/utils/id");
+const inter_dialog_format_1 = require("./shared/utils/inter-dialog-format");
+const time_1 = require("./shared/utils/time");
+const id_2 = require("./utils/id");
+class DialogID {
+    constructor(selfId, rootId) {
+        this.selfId = selfId;
+        this.rootId = rootId || selfId;
+        if (typeof selfId !== 'string')
+            throw new Error(`Wrong type [${typeof selfId}] passed as dlg id: ${(0, util_1.inspect)(selfId)}`);
+        if (rootId && typeof rootId !== 'string')
+            throw new Error(`Wrong type [${typeof rootId}] passed as dlg id: ${(0, util_1.inspect)(rootId)}`);
+    }
+    key() {
+        return this.valueOf();
+    }
+    valueOf() {
+        if (!this.rootId || this.rootId === this.selfId) {
+            return this.selfId;
+        }
+        return this.rootId + '#' + this.selfId;
+    }
+    /**
+     * Pretty print representation for debugging and display
+     */
+    toString() {
+        return this.valueOf();
+    }
+    /**
+     * Check equality with another DialogID
+     */
+    equals(other) {
+        if (other === null || other === undefined) {
+            return false;
+        }
+        return this.selfId === other.selfId && this.rootId === other.rootId;
+    }
+    /**
+     * Generate hash code for Map/Set usage
+     */
+    hashCode() {
+        return this.valueOf();
+    }
+}
+exports.DialogID = DialogID;
+const globalDialogMutexes = new Map();
+function getGlobalDialogMutex(dialogId) {
+    const key = dialogId.key();
+    const existing = globalDialogMutexes.get(key);
+    if (existing)
+        return existing;
+    const created = new async_fifo_mutex_1.AsyncFifoMutex();
+    globalDialogMutexes.set(key, created);
+    return created;
+}
+/**
+ * Abstract base class for all dialog types.
+ * Contains common properties and methods shared between RootDialog and SubDialog.
+ */
+class Dialog {
+    constructor(dlgStore, taskDocPath, id, agentId, initialState) {
+        // Persistence state
+        this._currentRound = 1;
+        this._remindersVer = 0;
+        // Track whether the current round's initial events (user_text, generating_start)
+        // have been fully processed. Used to ensure subdialog_final_response_evt arrives
+        // only after parent events are emitted.
+        this._generationStarted = false;
+        // Track the generation sequence when _generationStarted was set
+        // Used to ensure proper ordering when multiple generations occur
+        this._generationStartedGenseq = 0;
+        // Pending subdialog IDs (for auto-revive tracking)
+        this._pendingSubdialogIds = [];
+        // Phase 11: Suspension state for Type A subdialog mechanism
+        // Tracks whether this dialog is in normal state, suspended, or resuming from suspension
+        this._suspensionState = 'active';
+        // Keep-going (diligence auto-continue) budget counter (runtime-only).
+        // Intentionally not persisted: this is a per-process safety valve, not dialog state.
+        this.diligenceAutoContinueCount = 0;
+        // Keep-going disable switch (persisted via latest.yaml; default = false).
+        this.disableDiligencePush = false;
+        // Current callId for tellask tool-call correlation
+        // - Set during tool_call_finish_evt (from TellaskStreamParser)
+        // - Retrieved during tool response (for receiveToolResponse callId parameter)
+        // - Enables frontend to attach result INLINE to the calling section
+        // - NOT used for teammate tellasks (which use calleeDialogId instead)
+        this._currentCallId = null;
+        // Validate required parameters
+        if (!taskDocPath || taskDocPath.trim() === '') {
+            throw new Error('Taskdoc path is required for creating a dialog');
+        }
+        this.dlgStore = dlgStore;
+        this.taskDocPath = taskDocPath.trim();
+        if (id === undefined) {
+            const generatedId = (0, id_2.generateDialogID)();
+            id = new DialogID(generatedId);
+        }
+        this.id = id;
+        this._mutex = getGlobalDialogMutex(this.id);
+        this.agentId = agentId;
+        this.reminders = initialState?.reminders || [];
+        this.msgs = initialState?.messages || [];
+        // Initialize persistence state
+        const now = (0, time_1.formatUnifiedTimestamp)(new Date());
+        this._createdAt = initialState?.createdAt || now;
+        this._updatedAt = initialState?.updatedAt || now;
+        this._currentRound = initialState?.currentRound || 1;
+        this._uiLanguage = (0, runtime_language_1.getWorkLanguage)();
+        this._lastUserLanguageCode = (0, runtime_language_1.getWorkLanguage)();
+        this._lastContextHealth = initialState?.contextHealth;
+        this._lastContextHealthGenseq = undefined;
+    }
+    setLastContextHealth(snapshot) {
+        this._lastContextHealth = snapshot;
+        // Track the generation sequence that produced this snapshot, so reminder owners
+        // can distinguish pre-generation updates (previous snapshot) from post-generation
+        // updates (current snapshot) without relying on heuristics.
+        this._lastContextHealthGenseq = this._activeGenSeq;
+    }
+    getLastContextHealth() {
+        return this._lastContextHealth;
+    }
+    getLastContextHealthGenseq() {
+        return this._lastContextHealthGenseq;
+    }
+    get remindersVer() {
+        return this._remindersVer;
+    }
+    get supdialog() {
+        return undefined;
+    }
+    getUiLanguage() {
+        return this._uiLanguage;
+    }
+    setUiLanguage(language) {
+        this._uiLanguage = language;
+    }
+    getLastUserLanguageCode() {
+        return this._lastUserLanguageCode;
+    }
+    setLastUserLanguageCode(language) {
+        this._lastUserLanguageCode = language;
+    }
+    /**
+     * Get the current callId for tool-call correlation
+     *
+     * Call Types:
+     * - Tool Call (`!?@tool_name`): callId is set during tool_call_start_evt, used for inline result
+     * - Teammate Tellask (@agentName): Uses calleeDialogId, not callId
+     *
+     * @returns The current callId for tool correlation, or null if no active tool call
+     */
+    getCurrentCallId() {
+        return this._currentCallId;
+    }
+    /**
+     * Set the current callId (called during tool_call_finish_evt for tool calls)
+     *
+     * @param callId - The correlation ID from TellaskEventsReceiver.callFinish()
+     */
+    setCurrentCallId(callId) {
+        this._currentCallId = callId;
+    }
+    /**
+     * Clear the current callId (called after tool response is sent)
+     */
+    clearCurrentCallId() {
+        this._currentCallId = null;
+    }
+    /**
+     * Acquire the dialog mutex. Returns a release callback.
+     * FIFO queue ensures fairness when multiple callers wait.
+     */
+    async acquire() {
+        return await this._mutex.acquire();
+    }
+    /**
+     * Check if the dialog mutex is currently locked.
+     */
+    isLocked() {
+        return this._mutex.isLocked();
+    }
+    /**
+     * Check if dialog has pending Q4H questions.
+     * Queries persistence for current questions4Human state.
+     */
+    async hasPendingQ4H() {
+        try {
+            const questions = await this.dlgStore.loadQuestions4Human(this.id, this.status);
+            return questions.length > 0;
+        }
+        catch (err) {
+            log_1.log.warn('Failed to load Q4H state for pending check', {
+                dialogId: this.id.selfId,
+                error: err,
+            });
+            return true;
+        }
+    }
+    /**
+     * Check if dialog has pending subdialogs.
+     */
+    async hasPendingSubdialogs() {
+        try {
+            const pending = await this.dlgStore.loadPendingSubdialogs(this.id, this.status);
+            return pending.length > 0;
+        }
+        catch (err) {
+            log_1.log.warn('Failed to load pending subdialogs for pending check', {
+                dialogId: this.id.selfId,
+                error: err,
+            });
+            return true;
+        }
+    }
+    /**
+     * Check if dialog can be driven (not suspended for Q4H or subdialogs).
+     */
+    async canDrive() {
+        const hasQ4H = await this.hasPendingQ4H();
+        const hasSubdialogs = await this.hasPendingSubdialogs();
+        return !hasQ4H && !hasSubdialogs;
+    }
+    /**
+     * Get suspension status for logging/debugging.
+     */
+    async getSuspensionStatus() {
+        const hasQ4H = await this.hasPendingQ4H();
+        const hasSubdialogs = await this.hasPendingSubdialogs();
+        return {
+            q4h: hasQ4H,
+            subdialogs: hasSubdialogs,
+            canDrive: !hasQ4H && !hasSubdialogs,
+        };
+    }
+    get pendingSubdialogIds() {
+        return this._pendingSubdialogIds;
+    }
+    addPendingSubdialogs(ids) {
+        this._pendingSubdialogIds.push(...ids);
+    }
+    removePendingSubdialog(id) {
+        this._pendingSubdialogIds = this._pendingSubdialogIds.filter((pending) => pending.selfId !== id.selfId);
+    }
+    clearPendingSubdialogs() {
+        this._pendingSubdialogIds = [];
+    }
+    /**
+     * Load pending subdialogs from persistence into memory.
+     * Used during crash recovery to restore suspension state.
+     */
+    async loadPendingSubdialogsFromPersistence() {
+        try {
+            const pending = await this.dlgStore.loadPendingSubdialogs(this.id, this.status);
+            this.clearPendingSubdialogs();
+            this.addPendingSubdialogs(pending.map((record) => record.subdialogId));
+        }
+        catch (err) {
+            log_1.log.warn('Failed to load pending subdialogs from persistence', {
+                dialogId: this.id.selfId,
+                error: err,
+            });
+        }
+    }
+    /**
+     * Post a dialog event using the standard event registry.
+     */
+    postEvent(event) {
+        (0, evt_registry_1.postDialogEvent)(this, event);
+    }
+    // - return true if human response has been collected and incorporated into the msgs, thus
+    // should continue generating next llm messages immediately;
+    //
+    // Reminder management methods
+    addReminder(content, owner, meta, position) {
+        const reminder = { content, owner, meta };
+        const insertIndex = position !== undefined ? position : this.reminders.length;
+        if (insertIndex < 0 || insertIndex > this.reminders.length) {
+            throw new Error(`Invalid reminder position ${insertIndex}. Valid range: 0-${this.reminders.length}`);
+        }
+        this.reminders.splice(insertIndex, 0, reminder);
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        // Increment version for conditional event emission in driver
+        this._remindersVer++;
+    }
+    deleteReminder(index) {
+        if (index < 0 || index >= this.reminders.length) {
+            throw new Error(`Reminder index ${index} does not exist. Available reminders: 0-${this.reminders.length - 1}`);
+        }
+        const deleted = this.reminders.splice(index, 1)[0];
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        // Increment version for conditional event emission in driver
+        this._remindersVer++;
+        return deleted;
+    }
+    updateReminder(index, content, meta) {
+        if (index < 0 || index >= this.reminders.length) {
+            throw new Error(`Reminder index ${index} does not exist. Available reminders: 0-${this.reminders.length - 1}`);
+        }
+        const oldReminder = this.reminders[index];
+        const updatedReminder = {
+            content,
+            owner: oldReminder.owner,
+            meta: meta !== undefined ? meta : oldReminder.meta,
+        };
+        this.reminders[index] = updatedReminder;
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        // Increment version for conditional event emission in driver
+        this._remindersVer++;
+        return oldReminder;
+    }
+    clearReminders() {
+        this.reminders.length = 0;
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        // Increment version for conditional event emission in driver
+        this._remindersVer++;
+    }
+    /**
+     * Process reminder updates before LLM generation.
+     * Calls updateReminder on each tool that owns reminders to allow them to update/drop/keep their reminders.
+     * Returns reminder contents with metadata for the frontend.
+     */
+    async processReminderUpdates() {
+        const indicesToRemove = [];
+        for (let i = 0; i < this.reminders.length; i++) {
+            const reminder = this.reminders[i];
+            // Skip if the reminder has no owner or the owner doesn't have an updateReminder method
+            if (!reminder.owner || !reminder.owner.updateReminder) {
+                continue;
+            }
+            try {
+                const result = await reminder.owner.updateReminder(this, reminder);
+                switch (result.treatment) {
+                    case 'drop':
+                        indicesToRemove.push(i);
+                        break;
+                    case 'update':
+                        if (result.updatedContent !== undefined) {
+                            const updatedReminder = {
+                                content: result.updatedContent,
+                                owner: reminder.owner,
+                                meta: result.updatedMeta !== undefined ? result.updatedMeta : reminder.meta,
+                            };
+                            this.reminders[i] = updatedReminder;
+                        }
+                        break;
+                    case 'keep':
+                        // No action needed
+                        break;
+                }
+            }
+            catch (error) {
+                log_1.log.error(`Error updating reminder from tool ${reminder.owner}:`, error);
+                // Continue processing other reminders even if one fails
+            }
+        }
+        // Remove reminders marked for deletion (in reverse order to maintain indices)
+        for (let i = indicesToRemove.length - 1; i >= 0; i--) {
+            this.reminders.splice(indicesToRemove[i], 1);
+        }
+        if (indicesToRemove.length > 0) {
+            this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        }
+        // Centralized persistence - called when emitting event.
+        // Must be awaited to avoid overlapping writes (reminders.json.tmp rename races).
+        try {
+            await this.dlgStore.persistReminders(this, this.reminders);
+        }
+        catch (err) {
+            log_1.log.warn('Failed to persist reminders', err, { dialogId: this.id.valueOf() });
+        }
+        const reminders = this.reminders.map((r) => ({
+            content: r.content,
+            meta: r.meta,
+        }));
+        // Emit full_reminders_update event with complete reminder list including metadata
+        const fullRemindersEvt = {
+            type: 'full_reminders_update',
+            reminders,
+        };
+        (0, evt_registry_1.postDialogEvent)(this, fullRemindersEvt);
+        return reminders;
+    }
+    // only to be used by the driver
+    async addChatMessages(...msgs) {
+        this.msgs.push(...msgs);
+    }
+    /**
+     * Get current round number
+     */
+    get currentRound() {
+        return this._currentRound;
+    }
+    /**
+     * Get current generation sequence number
+     */
+    get activeGenSeq() {
+        if (!this._activeGenSeq) {
+            throw new Error(`No active genseq, this is bug!!`);
+        }
+        return this._activeGenSeq;
+    }
+    get activeGenSeqOrUndefined() {
+        return this._activeGenSeq;
+    }
+    get activeGenRoundOrUndefined() {
+        return this._activeGenRound;
+    }
+    /**
+     * Check if generation has started for the current round.
+     * Used to ensure subdialog_final_response_evt arrives after parent events.
+     */
+    get generationStarted() {
+        return this._generationStarted;
+    }
+    /**
+     * Mark generation as started (after user_text event has been emitted).
+     * This ensures subdialog_final_response_evt waits for this signal.
+     * @param genseq The generation sequence number when this flag is set
+     */
+    markGenerationStarted(genseq) {
+        this._generationStarted = true;
+        this._generationStartedGenseq = genseq ?? this._activeGenSeq ?? 0;
+    }
+    /**
+     * Get the genseq when generation was marked as started
+     */
+    get generationStartedGenseq() {
+        return this._generationStartedGenseq;
+    }
+    /**
+     * Phase 11: Get current suspension state
+     * @returns 'active' | 'suspended' | 'resumed'
+     */
+    getSuspensionState() {
+        return this._suspensionState;
+    }
+    /**
+     * Phase 11: Set suspension state
+     * @param state The new suspension state
+     */
+    setSuspensionState(state) {
+        this._suspensionState = state;
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    get updatedAt() {
+        return this._updatedAt;
+    }
+    setUpNextPrompt(prompt) {
+        const trimmed = prompt.trim();
+        if (!trimmed) {
+            throw new Error('newRoundPrompt is required to start a new round');
+        }
+        this._upNext = {
+            prompt: trimmed,
+            msgId: (0, id_1.generateShortId)(),
+            userLanguageCode: this._lastUserLanguageCode,
+        };
+    }
+    hasUpNext() {
+        return this._upNext !== undefined;
+    }
+    takeUpNext() {
+        const next = this._upNext;
+        this._upNext = undefined;
+        return next;
+    }
+    /**
+     * Start a new round - clears conversational noise, Q4H, and increments round counter.
+     * Queues a new-round prompt for the driver to consume on the next drive cycle.
+     * This is the single entry point for mental clarity operations (clear_mind, change_mind).
+     */
+    async startNewRound(newRoundPrompt) {
+        const trimmedPrompt = newRoundPrompt.trim();
+        if (!trimmedPrompt) {
+            throw new Error('newRoundPrompt is required to start a new round');
+        }
+        // Clear all messages and Q4H questions for mental clarity
+        this.msgs.length = 0;
+        await this.dlgStore.clearQuestions4Human(this);
+        // Delegate to DialogStore for round start persistence
+        if (this.dlgStore) {
+            await this.dlgStore.startNewRound(this, trimmedPrompt);
+        }
+        const storeRound = this.dlgStore
+            ? await this.dlgStore.loadCurrentRound(this.id)
+            : this._currentRound + 1;
+        this._currentRound = storeRound;
+        this._updatedAt = (0, time_1.formatUnifiedTimestamp)(new Date());
+        // Principle: user should see what the model sees.
+        // For subdialogs, include the original supdialog assignment together with the new-round prompt
+        // as the first user message in the new round (persisted by the driver).
+        const combinedPrompt = this instanceof SubDialog
+            ? `${(0, inter_dialog_format_1.formatAssignmentFromSupdialog)({
+                fromAgentId: this.assignmentFromSup.originMemberId,
+                toAgentId: this.agentId,
+                headLine: this.assignmentFromSup.headLine,
+                callBody: this.assignmentFromSup.callBody,
+                language: (0, runtime_language_1.getWorkLanguage)(),
+                collectiveTargets: this.assignmentFromSup.collectiveTargets ?? [this.agentId],
+            })}\n---\n${trimmedPrompt}`
+            : trimmedPrompt;
+        this.setUpNextPrompt(combinedPrompt);
+    }
+    // Proxy methods for DialogStore - route calls through dialog object instead of direct dlgStore access
+    async receiveFuncResult(result) {
+        return await this.dlgStore.receiveFuncResult(this, result);
+    }
+    async notifyGeneratingStart() {
+        // Capture the generation's starting round so any events emitted during this generation
+        // remain attributed to the correct round even if a tool mutates dialog.currentRound
+        // mid-generation (e.g., clear_mind).
+        this._activeGenRound = this.currentRound;
+        if (typeof this._activeGenSeq === 'number') {
+            this._activeGenSeq++;
+        }
+        else {
+            // Get next sequence number from store
+            const genseq = await this.dlgStore.getNextSeq(this.id, this.currentRound);
+            this._activeGenSeq = genseq;
+        }
+        // Mark generation as started with the actual genseq
+        // This ensures subdialog_final_response_evt waits for both user_text and generating_start_evt
+        this.markGenerationStarted();
+        await this.dlgStore.notifyGeneratingStart(this);
+    }
+    async notifyGeneratingFinish(contextHealth, llmGenModel) {
+        if (contextHealth) {
+            this.setLastContextHealth(contextHealth);
+        }
+        try {
+            await this.dlgStore.notifyGeneratingFinish(this, contextHealth, llmGenModel);
+        }
+        catch (err) {
+            log_1.log.warn('notifyGeneratingFinish failed', undefined, {
+                genseq: this._activeGenSeq,
+                error: err,
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Reset generation tracking for the next round
+        this._generationStarted = false;
+        this._generationStartedGenseq = 0;
+        this._activeGenRound = undefined;
+    }
+    async streamError(error) {
+        if (this.dlgStore) {
+            await this.dlgStore.streamError(this, error);
+        }
+    }
+    async thinkingStart() {
+        await this.dlgStore.thinkingStart(this);
+    }
+    async thinkingChunk(chunk) {
+        await this.dlgStore.thinkingChunk(this, chunk);
+    }
+    async markdownStart() {
+        await this.dlgStore.markdownStart(this);
+    }
+    async markdownChunk(chunk) {
+        await this.dlgStore.markdownChunk(this, chunk);
+    }
+    async thinkingFinish() {
+        await this.dlgStore.thinkingFinish(this);
+    }
+    async markdownFinish() {
+        await this.dlgStore.markdownFinish(this);
+    }
+    async sayingStart() {
+        await this.dlgStore.sayingStart(this);
+    }
+    async sayingChunk(chunk) {
+        await this.dlgStore.sayingChunk(this, chunk);
+        // No frontend event needed - frontend gets content through streaming parser
+    }
+    async sayingFinish() {
+        await this.dlgStore.sayingFinish(this);
+    }
+    // Function call events (non-streaming mode - single event captures entire call)
+    async funcCallRequested(funcId, funcName, argumentsStr) {
+        await this.dlgStore.funcCallRequested(this, funcId, funcName, argumentsStr);
+    }
+    // Tellask call events (streaming mode - `!?@...` blocks)
+    async callingStart(validation) {
+        await this.dlgStore.callingStart(this, validation);
+    }
+    async callingHeadlineChunk(chunk) {
+        await this.dlgStore.callingHeadlineChunk(this, chunk);
+    }
+    async callingHeadlineFinish() {
+        await this.dlgStore.callingHeadlineFinish(this);
+    }
+    async callingBodyStart() {
+        await this.dlgStore.callingBodyStart(this);
+    }
+    async callingBodyChunk(chunk) {
+        await this.dlgStore.callingBodyChunk(this, chunk);
+    }
+    async callingBodyFinish() {
+        await this.dlgStore.callingBodyFinish(this);
+    }
+    async callingFinish(callId) {
+        // Store callId for tool call correlation
+        this.setCurrentCallId(callId);
+        await this.dlgStore.callingFinish(this, callId);
+    }
+    /**
+     * Receive tool response with callId for inline correlation
+     */
+    async receiveToolResponse(responderId, headLine, result, status, callId) {
+        return await this.dlgStore.receiveToolResponse(this, responderId, headLine, result, status, callId);
+    }
+    /**
+     * Receive teammate response (separate bubble for @teammate tellasks)
+     */
+    async receiveTeammateResponse(responderId, headLine, status, subdialogId, options) {
+        return await this.dlgStore.receiveTeammateResponse(this, responderId, headLine, status, subdialogId, options);
+    }
+    async updateQuestions4Human(questions) {
+        return await this.dlgStore.updateQuestions4Human(this, questions);
+    }
+    async persistUserMessage(content, msgId, grammar, userLanguageCode) {
+        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, userLanguageCode);
+    }
+    async persistAgentMessage(content, genseq, type, provider_data) {
+        return await this.dlgStore.persistAgentMessage(this, content, genseq, type, provider_data);
+    }
+    async persistFunctionCall(id, name, arguments_, genseq) {
+        return await this.dlgStore.persistFunctionCall(this, id, name, arguments_, genseq);
+    }
+    /**
+     * Post subdialog completion response to this dialog.
+     * Phase 14: No wait - emit immediately with virtual gen markers for Type C subdialogs
+     */
+    async postSubdialogResponse(subdialogId, response) {
+        try {
+            let responderId = subdialogId.rootId;
+            let responderAgentId;
+            let headLine = response;
+            let originMemberId = responderId;
+            let callId = '';
+            try {
+                const metadata = await this.dlgStore.loadDialogMetadata(subdialogId, 'running');
+                if (metadata) {
+                    if (metadata.agentId) {
+                        responderId = metadata.agentId;
+                        responderAgentId = metadata.agentId;
+                        originMemberId = metadata.agentId;
+                    }
+                    if (metadata.assignmentFromSup) {
+                        headLine = metadata.assignmentFromSup.headLine;
+                        originMemberId = metadata.assignmentFromSup.originMemberId;
+                        callId = metadata.assignmentFromSup.callId;
+                    }
+                }
+            }
+            catch (err) {
+                log_1.log.warn('Failed to load subdialog metadata for response labeling', {
+                    dialogId: this.id.selfId,
+                    subdialogId: subdialogId.selfId,
+                    error: err,
+                });
+            }
+            if (callId.trim() === '') {
+                log_1.log.warn('Missing callId for subdialog response', undefined, {
+                    dialogId: this.id.selfId,
+                    subdialogId: subdialogId.selfId,
+                });
+            }
+            if (headLine.trim() === '') {
+                headLine = response;
+            }
+            // NO WAIT - emit immediately with virtual gen markers
+            // Emit virtual generating_start_evt for subdialog response bubble
+            await this.notifyGeneratingStart();
+            const formattedResult = (0, inter_dialog_format_1.formatTeammateResponseContent)({
+                responderId,
+                requesterId: originMemberId,
+                originalCallHeadLine: headLine,
+                responseBody: response,
+                language: (0, runtime_language_1.getWorkLanguage)(),
+            });
+            // Emit TeammateResponseEvent
+            const evt = {
+                type: 'teammate_response_evt',
+                responderId,
+                calleeDialogId: subdialogId.selfId,
+                headLine,
+                status: 'completed',
+                result: formattedResult,
+                round: this.currentRound,
+                response,
+                agentId: responderAgentId ?? responderId,
+                callId,
+                originMemberId,
+            };
+            (0, evt_registry_1.postDialogEvent)(this, evt);
+            // Emit virtual generating_finish_evt
+            await this.notifyGeneratingFinish();
+        }
+        catch (err) {
+            log_1.log.warn('Failed to post teammate_response_evt event', undefined, {
+                error: err,
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+exports.Dialog = Dialog;
+/**
+ * SubDialog - A subdialog created by a RootDialog for autonomous teammate tellasks.
+ * Stores the root dialog for registry and lookup, and resolves its effective supdialog dynamically.
+ */
+class SubDialog extends Dialog {
+    constructor(dlgStore, rootDialog, taskDocPath, id, agentId, assignmentFromSup, tellaskSession, initialState) {
+        super(dlgStore, taskDocPath, id, agentId, initialState);
+        this.rootDialog = rootDialog;
+        this.tellaskSession = tellaskSession;
+        this.assignmentFromSup = assignmentFromSup;
+        const resolvedSupdialog = rootDialog.lookupDialog(assignmentFromSup.callerDialogId);
+        if (resolvedSupdialog && resolvedSupdialog.id.selfId === this.id.selfId) {
+            log_1.log.warn('SubDialog assignmentFromSup.callerDialogId resolved to self; falling back to root', {
+                dialogId: this.id.selfId,
+                callerDialogId: assignmentFromSup.callerDialogId,
+            });
+            this._supdialog = rootDialog;
+        }
+        else if (resolvedSupdialog) {
+            this._supdialog = resolvedSupdialog;
+        }
+        else {
+            // If we can't resolve the caller dialog in the in-memory registry, fall back to root.
+            // This can happen when restoring a dialog tree without restoring the full parent chain.
+            log_1.log.warn('SubDialog failed to resolve callerDialogId in root registry; falling back to root', {
+                dialogId: this.id.selfId,
+                callerDialogId: assignmentFromSup.callerDialogId,
+                rootId: rootDialog.id.rootId,
+            });
+            this._supdialog = rootDialog;
+        }
+        this.rootDialog.registerDialog(this);
+    }
+    get supdialog() {
+        return this._supdialog;
+    }
+    get status() {
+        return this.rootDialog.status;
+    }
+    /**
+     * Create a subdialog under the same root dialog tree.
+     * The new subdialog's effective supdialog is resolved via AssignmentFromSup.callerDialogId.
+     */
+    async createSubDialog(targetAgentId, headLine, callBody, options) {
+        return await this.rootDialog.createSubDialog(targetAgentId, headLine, callBody, options);
+    }
+}
+exports.SubDialog = SubDialog;
+/**
+ * RootDialog - The main/root dialog that can create and manage subdialogs.
+ * Uses in-memory registries for O(1) dialog and Type B lookup.
+ */
+class RootDialog extends Dialog {
+    constructor(dlgStore, taskDocPath, id, agentId, initialState) {
+        super(dlgStore, taskDocPath, id, agentId, initialState);
+        this._status = 'running';
+        // Tracks all dialogs in this dialog tree for O(1) lookup
+        this._localRegistry = new Map();
+        // Tracks TYPE B registered subdialogs by agentId!tellaskSession
+        this._subdialogRegistry = new Map();
+        this.registerDialog(this);
+    }
+    get status() {
+        return this._status;
+    }
+    setPersistenceStatus(status) {
+        this._status = status;
+    }
+    /**
+     * Register a dialog (self or subdialog) in the local registry.
+     */
+    registerDialog(dialog) {
+        this._localRegistry.set(dialog.id.selfId, dialog);
+    }
+    /**
+     * Lookup a dialog by selfId in the local registry.
+     */
+    lookupDialog(selfId) {
+        return this._localRegistry.get(selfId);
+    }
+    /**
+     * Get all registered dialogs in this dialog tree.
+     */
+    getAllDialogs() {
+        return Array.from(this._localRegistry.values());
+    }
+    /**
+     * Remove a dialog from the local registry.
+     */
+    unregisterDialog(selfId) {
+        this._localRegistry.delete(selfId);
+    }
+    /**
+     * Generate a registry key from agentId and tellaskSession.
+     */
+    static makeSubdialogKey(agentId, tellaskSession) {
+        return `${agentId}!${tellaskSession}`;
+    }
+    /**
+     * Register a TYPE B subdialog for resumption.
+     */
+    registerSubdialog(subdialog) {
+        if (!subdialog.tellaskSession) {
+            return;
+        }
+        const key = RootDialog.makeSubdialogKey(subdialog.agentId, subdialog.tellaskSession);
+        this._subdialogRegistry.set(key, subdialog);
+        this.registerDialog(subdialog);
+    }
+    /**
+     * Lookup a TYPE B subdialog by agentId and tellaskSession.
+     */
+    lookupSubdialog(agentId, tellaskSession) {
+        const key = RootDialog.makeSubdialogKey(agentId, tellaskSession);
+        return this._subdialogRegistry.get(key);
+    }
+    /**
+     * Remove a TYPE B subdialog from registry.
+     */
+    unregisterSubdialog(agentId, tellaskSession) {
+        const key = RootDialog.makeSubdialogKey(agentId, tellaskSession);
+        const subdialog = this._subdialogRegistry.get(key);
+        if (subdialog) {
+            this._localRegistry.delete(subdialog.id.selfId);
+            return this._subdialogRegistry.delete(key);
+        }
+        return false;
+    }
+    /**
+     * Get all registered subdialogs.
+     */
+    getRegisteredSubdialogs() {
+        return Array.from(this._subdialogRegistry.values());
+    }
+    /**
+     * Create a new subdialog for autonomous teammate tellasks.
+     */
+    async createSubDialog(targetAgentId, headLine, callBody, options) {
+        return await this.dlgStore.createSubDialog(this, targetAgentId, headLine, callBody, options);
+    }
+    /**
+     * Save subdialog registry to disk (registry.yaml).
+     */
+    async saveSubdialogRegistry() {
+        const entries = Array.from(this._subdialogRegistry.entries()).map(([key, subdialog]) => ({
+            key,
+            subdialogId: subdialog.id,
+            agentId: subdialog.agentId,
+            tellaskSession: subdialog.tellaskSession,
+        }));
+        await this.dlgStore.saveSubdialogRegistry(this.id, entries, this.status);
+    }
+    /**
+     * Load subdialog registry from disk (registry.yaml).
+     */
+    async loadSubdialogRegistry() {
+        await this.dlgStore.loadSubdialogRegistry(this, this.status);
+    }
+}
+exports.RootDialog = RootDialog;
+/**
+ * The UI showing a dialog in realtime
+ */
+class DialogStore {
+    /**
+     * almost certainly, the subclass should override this method to be (sub)dialog structure aware
+     *
+     * impl here serves for demo purpose only
+     *
+     * @param supdialog
+     * @param targetAgentId
+     * @param headLine
+     * @param callBody
+     * @returns
+     */
+    async createSubDialog(supdialog, targetAgentId, headLine, callBody, options) {
+        const generatedId = (0, id_2.generateDialogID)();
+        // For subdialogs, use the supdialog's root dialog ID as the root
+        const subdialogId = new DialogID(generatedId, supdialog.id.rootId);
+        return new SubDialog(this, supdialog, supdialog.taskDocPath, subdialogId, targetAgentId, {
+            headLine,
+            callBody,
+            originMemberId: options.originMemberId,
+            callerDialogId: options.callerDialogId,
+            callId: options.callId,
+            collectiveTargets: options.collectiveTargets,
+        }, options.tellaskSession);
+    }
+    /**
+     * Receive and handle LLM generation streams (Markdown stream + tellask call stream)
+     */
+    /**
+     * Notify start of LLM generation lifecycle (generating_start_evt)
+     */
+    async notifyGeneratingStart(_dialog) { }
+    /**
+     * Notify end of LLM generation lifecycle (generating_finish_evt)
+     */
+    async notifyGeneratingFinish(_dialog, _contextHealth, _llmGenModel) { }
+    // Explicit phase notifications (driver-driven)
+    thinkingStart(_dialog) { }
+    thinkingChunk(_dialog, _chunk) { }
+    thinkingFinish(_dialog) { }
+    markdownStart(_dialog) { }
+    markdownChunk(_dialog, _chunk) { }
+    markdownFinish(_dialog) { }
+    // Saying streaming methods (different from markdown)
+    sayingStart(_dialog) { }
+    sayingChunk(_dialog, _chunk) { }
+    sayingFinish(_dialog) { }
+    async receiveFuncResult(_dialog, _funcResult) { }
+    /**
+     * Receive tool response with callId for inline correlation
+     */
+    async receiveToolResponse(_dialog, _responderId, _headLine, _result, _status, _callId) { }
+    /**
+     * Receive teammate response (separate bubble for @teammate tellasks)
+     */
+    async receiveTeammateResponse(_dialog, _responderId, _headLine, _status, _subdialogId, _options) { }
+    async updateQuestions4Human(_dialog, _questions) { }
+    /**
+     * Load Questions for Human state from storage
+     */
+    async loadQuestions4Human(_dialogId, _status) {
+        return [];
+    }
+    async loadDialogMetadata(_dialogId, _status) {
+        return null;
+    }
+    async loadPendingSubdialogs(_dialogId, _status) {
+        return [];
+    }
+    async saveSubdialogRegistry(_rootDialogId, _entries, _status) { }
+    async loadSubdialogRegistry(_rootDialog, _status) { }
+    /**
+     * Clear Questions for Human state in storage
+     */
+    async clearQuestions4Human(_dialog) { }
+    // Tellask call streaming methods
+    async callingStart(_dialog, _validation) { }
+    async callingHeadlineChunk(_dialog, _chunk) { }
+    async callingHeadlineFinish(_dialog) { }
+    async callingBodyStart(_dialog) { }
+    async callingBodyChunk(_dialog, _chunk) { }
+    async callingBodyFinish(_dialog) { }
+    async callingFinish(_dialog, _callId) { }
+    // Function call event (non-streaming mode - single event)
+    async funcCallRequested(_dialog, _funcId, _funcName, _argumentsStr) { }
+    /**
+     * Load current round number from persisted metadata
+     * This method should be implemented by subclasses to read from storage
+     */
+    async loadCurrentRound(_dialogId) {
+        // Default implementation returns 1
+        return 1;
+    }
+    /**
+     * Get next sequence number for generation
+     * This method should be implemented by subclasses for sequence allocation
+     */
+    async getNextSeq(_dialogId, _round) {
+        // Default implementation returns 1
+        return 1;
+    }
+    /**
+     * Persist reminders to storage (event emission handled by processReminderUpdates)
+     */
+    async persistReminders(_dialog, _reminders) { }
+    /**
+     * Persist a user message to storage
+     */
+    async persistUserMessage(_dialog, _content, _msgId, _grammar, _userLanguageCode) { }
+    /**
+     * Persist an assistant message to storage
+     */
+    async persistAgentMessage(_dialog, _content, _genseq, _type, _provider_data) { }
+    /**
+     * Persist a function call to storage
+     */
+    async persistFunctionCall(_dialog, _id, _name, _arguments, _genseq) { }
+    /**
+     * Start a new round in storage
+     */
+    async startNewRound(_dialog, _newRoundPrompt) { }
+    /**
+     * Handle stream error
+     */
+    async streamError(_dialog, _error) { }
+}
+exports.DialogStore = DialogStore;