dominds 1.25.2 → 1.25.4

package/dist/persistence.js

@@ -107,6 +107,9 @@ function summarizeLatestProjectionState(latest) {
         tellaskResultCount: latest.tellaskResults.results.length,
         latestAssignmentAnchor: latest.latestAssignmentAnchor ?? null,
         sideDialogFinalResponse: latest.sideDialogFinalResponse ?? null,
+        pendingUserInterjectionReplyMsgId: latest.pendingUserInterjectionReply?.msgId ?? null,
+        pendingUserInterjectionReplyCourse: latest.pendingUserInterjectionReply?.course ?? null,
+        pendingUserInterjectionReplyGenseq: latest.pendingUserInterjectionReply?.genseq ?? null,
         pendingRuntimePromptMsgId: latest.pendingRuntimePrompt?.msgId ?? null,
         pendingRuntimePromptOrigin: latest.pendingRuntimePrompt?.origin ?? null,
         pendingRuntimePromptGrammar: latest.pendingRuntimePrompt?.grammar ?? null,
@@ -145,6 +148,9 @@ function summarizeLatestMutationPatch(patch) {
         tellaskResultCount: patch.tellaskResults?.results.length ?? null,
         latestAssignmentAnchor: patch.latestAssignmentAnchor ?? null,
         sideDialogFinalResponse: patch.sideDialogFinalResponse ?? null,
+        pendingUserInterjectionReplyMsgId: patch.pendingUserInterjectionReply?.msgId ?? null,
+        pendingUserInterjectionReplyCourse: patch.pendingUserInterjectionReply?.course ?? null,
+        pendingUserInterjectionReplyGenseq: patch.pendingUserInterjectionReply?.genseq ?? null,
         pendingRuntimePromptMsgId: patch.pendingRuntimePrompt?.msgId ?? null,
         pendingRuntimePromptOrigin: patch.pendingRuntimePrompt?.origin ?? null,
         pendingRuntimePromptGrammar: patch.pendingRuntimePrompt?.grammar ?? null,
@@ -2090,6 +2096,32 @@ function parseDialogLatestFile(value) {
     })();
     if (sideDialogFinalResponse === null)
         return null;
+    const pendingUserInterjectionReplyRaw = value
+        .pendingUserInterjectionReply;
+    const pendingUserInterjectionReply = (() => {
+        if (pendingUserInterjectionReplyRaw === undefined)
+            return undefined;
+        if (!isRecord(pendingUserInterjectionReplyRaw))
+            return null;
+        const msgId = pendingUserInterjectionReplyRaw.msgId;
+        const course = pendingUserInterjectionReplyRaw.course;
+        const genseq = pendingUserInterjectionReplyRaw.genseq;
+        if (typeof msgId !== 'string' || msgId.trim() === '')
+            return null;
+        if (typeof course !== 'number' || !Number.isFinite(course) || Math.floor(course) <= 0) {
+            return null;
+        }
+        if (typeof genseq !== 'number' || !Number.isFinite(genseq) || Math.floor(genseq) <= 0) {
+            return null;
+        }
+        return {
+            msgId,
+            course: (0, storage_1.toDialogCourseNumber)(course),
+            genseq: (0, storage_1.toCallSiteGenseqNo)(genseq),
+        };
+    })();
+    if (pendingUserInterjectionReply === null)
+        return null;
     const latestAssignmentAnchorRaw = value.latestAssignmentAnchor;
     const latestAssignmentAnchor = (() => {
         if (latestAssignmentAnchorRaw === undefined)
@@ -2202,6 +2234,7 @@ function parseDialogLatestFile(value) {
         sideDialogFinalResponse,
         fbrState,
         deferredReplyReassertion,
+        pendingUserInterjectionReply,
         pendingRuntimePrompt,
         disableDiligencePush: value.disableDiligencePush,
         diligencePushRemainingBudget: value.diligencePushRemainingBudget,
@@ -2346,6 +2379,48 @@ function isQuestions4HumanFile(value) {
         return false;
     return value.questions.every(isHumanQuestion);
 }
+function isAnswerToHumanItem(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'string')
+        return false;
+    if (typeof value.content !== 'string')
+        return false;
+    if (typeof value.answeredAt !== 'string')
+        return false;
+    if (!isRecord(value.userInterjection))
+        return false;
+    if (typeof value.userInterjection.msgId !== 'string')
+        return false;
+    if (typeof value.userInterjection.course !== 'number')
+        return false;
+    if (!Number.isFinite(value.userInterjection.course))
+        return false;
+    if (typeof value.userInterjection.genseq !== 'number')
+        return false;
+    if (!Number.isFinite(value.userInterjection.genseq))
+        return false;
+    if (!isRecord(value.answerRef))
+        return false;
+    if (typeof value.answerRef.course !== 'number')
+        return false;
+    if (!Number.isFinite(value.answerRef.course))
+        return false;
+    if (typeof value.answerRef.genseq !== 'number')
+        return false;
+    if (!Number.isFinite(value.answerRef.genseq))
+        return false;
+    return true;
+}
+function isAnswersToHumanFile(value) {
+    if (!isRecord(value))
+        return false;
+    if (!Array.isArray(value.answers))
+        return false;
+    if (typeof value.updatedAt !== 'string')
+        return false;
+    return value.answers.every(isAnswerToHumanItem);
+}
 // Remove old type definitions - now using kernel/types/storage.ts
 const id_1 = require("./utils/id");
 function parseReplayTellaskCall(record) {
@@ -2760,7 +2835,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
      * Append event to course JSONL file (delegate to DialogPersistence)
      */
     async appendEvent(dialog, course, event) {
-        await DialogPersistence.appendEvent(this.dialogId, course, attachRootGenerationRef(dialog, event));
+        const rootedEvent = attachRootGenerationRef(dialog, event);
+        await DialogPersistence.appendEvent(this.dialogId, course, rootedEvent);
     }
     async appendEvents(dialog, course, events) {
         await DialogPersistence.appendEvents(this.dialogId, course, events.map((event) => attachRootGenerationRef(dialog, event)));
@@ -2779,6 +2855,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             ts: startedAt,
             type: 'gen_start_record',
             genseq: genseq,
+            ...(typeof msgId === 'string' && msgId.trim() !== '' ? { msgId } : {}),
         };
         await this.appendEvent(dialog, course, ev);
         // Emit generating_start_evt event
@@ -4920,6 +4997,14 @@ class DialogPersistence {
         this.q4hWriteBackMutexes.set(key, created);
         return created;
     }
+    static getA2HWriteBackMutex(key) {
+        const existing = this.a2hWriteBackMutexes.get(key);
+        if (existing)
+            return existing;
+        const created = new async_fifo_mutex_1.AsyncFifoMutex();
+        this.a2hWriteBackMutexes.set(key, created);
+        return created;
+    }
     static getCourseAppendMutex(key) {
         const existing = this.courseAppendMutexes.get(key);
         if (existing)
@@ -4969,6 +5054,10 @@ class DialogPersistence {
         // Include dialogs root dir to avoid cross-test/process.cwd collisions.
         return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}|q4h`;
     }
+    static getA2HWriteBackKey(dialogId, status) {
+        // Include dialogs root dir to avoid cross-test/process.cwd collisions.
+        return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}|a2h`;
+    }
     static getActiveCalleesKey(dialogId, status) {
         return `${this.getDialogsRootDir()}|${status}|${dialogId.valueOf()}|active-callees`;
     }
@@ -5281,6 +5370,19 @@ class DialogPersistence {
                 this.q4hWriteBackMutexes.delete(key);
             }
         }
+        for (const [key, entry] of this.a2hWriteBack.entries()) {
+            if (!matchesMainDialogKey(key))
+                continue;
+            if (entry.kind === 'scheduled') {
+                clearTimeout(entry.timer);
+            }
+            this.a2hWriteBack.delete(key);
+        }
+        for (const key of this.a2hWriteBackMutexes.keys()) {
+            if (matchesMainDialogKey(key)) {
+                this.a2hWriteBackMutexes.delete(key);
+            }
+        }
         for (const key of this.activeCalleesMutexes.keys()) {
             if (matchesMainDialogKey(key)) {
                 this.activeCalleesMutexes.delete(key);
@@ -6308,6 +6410,151 @@ class DialogPersistence {
             removedQuestion: out.removedQuestion,
         };
     }
+    static async loadAnswersToHumanState(dialogId, status = 'running') {
+        const key = this.getA2HWriteBackKey(dialogId, status);
+        const staged = this.a2hWriteBack.get(key);
+        if (staged) {
+            if (staged.state.kind === 'deleted')
+                return [];
+            return staged.state.file.answers;
+        }
+        try {
+            return await this.loadAnswersToHumanStateFromDisk(dialogId, status);
+        }
+        catch (error) {
+            await this.rethrowAfterQuarantiningDialogPersistenceProblem(dialogId, status, 'loadAnswersToHumanState', error);
+            throw new Error('unreachable after loadAnswersToHumanState persistence rethrow');
+        }
+    }
+    static async loadAnswersToHumanStateFromDisk(dialogId, status) {
+        const dialogPath = this.getDialogEventsPath(dialogId, status);
+        const answersFilePath = path.join(dialogPath, 'a2h.yaml');
+        try {
+            const content = await readPersistenceTextFile({
+                filePath: answersFilePath,
+                source: 'answers2human_state',
+                format: 'yaml',
+            });
+            const parsed = parsePersistenceYaml({
+                content,
+                filePath: answersFilePath,
+                source: 'answers2human_state',
+            });
+            if (!isAnswersToHumanFile(parsed)) {
+                throw buildInvalidPersistenceFileError({
+                    source: 'answers2human_state',
+                    format: 'yaml',
+                    filePath: answersFilePath,
+                });
+            }
+            return parsed.answers;
+        }
+        catch (error) {
+            if (getErrorCode(error) === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    static async mutateAnswersToHumanState(dialogId, mutator, status = 'running') {
+        const key = this.getA2HWriteBackKey(dialogId, status);
+        const mutex = this.getA2HWriteBackMutex(key);
+        const release = await mutex.acquire();
+        try {
+            const staged = this.a2hWriteBack.get(key);
+            const previousAnswers = staged && staged.state.kind === 'file'
+                ? staged.state.file.answers
+                : staged && staged.state.kind === 'deleted'
+                    ? []
+                    : await this.loadAnswersToHumanStateFromDisk(dialogId, status);
+            const mutation = mutator(previousAnswers);
+            let removedAnswer;
+            let nextState;
+            let nextAnswers = previousAnswers;
+            if (mutation.kind === 'noop') {
+                return { previousAnswers, answers: previousAnswers };
+            }
+            else if (mutation.kind === 'append') {
+                nextAnswers = [...previousAnswers, mutation.answer];
+            }
+            else if (mutation.kind === 'remove') {
+                const idx = previousAnswers.findIndex((answer) => answer.id === mutation.answerId);
+                if (idx === -1) {
+                    return { previousAnswers, answers: previousAnswers };
+                }
+                removedAnswer = previousAnswers[idx];
+                nextAnswers = previousAnswers.filter((answer) => answer.id !== mutation.answerId);
+            }
+            else if (mutation.kind === 'replace') {
+                nextAnswers = [...mutation.answers];
+            }
+            else if (mutation.kind === 'clear') {
+                nextAnswers = [];
+            }
+            else {
+                const _exhaustive = mutation;
+                throw new Error(`Unhandled a2h mutation: ${String(_exhaustive)}`);
+            }
+            if (nextAnswers.length === 0) {
+                nextState = { kind: 'deleted' };
+            }
+            else {
+                nextState = {
+                    kind: 'file',
+                    file: { answers: nextAnswers, updatedAt: (0, time_1.formatUnifiedTimestamp)(new Date()) },
+                };
+            }
+            const pending = this.a2hWriteBack.get(key);
+            if (!pending) {
+                const timer = setTimeout(() => {
+                    void this.flushA2HWriteBack(key);
+                }, this.A2H_WRITEBACK_WINDOW_MS);
+                this.a2hWriteBack.set(key, {
+                    kind: 'scheduled',
+                    dialogId,
+                    status,
+                    state: nextState,
+                    timer,
+                });
+                return { previousAnswers, answers: nextAnswers, removedAnswer };
+            }
+            pending.state = nextState;
+            if (pending.kind === 'flushing') {
+                pending.dirty = true;
+            }
+            return { previousAnswers, answers: nextAnswers, removedAnswer };
+        }
+        finally {
+            release();
+        }
+    }
+    static async appendAnswerToHumanState(dialogId, answer, status = 'running') {
+        const answerId = answer.id.trim();
+        if (answerId === '') {
+            throw new Error(`A2H append invariant violation: empty answer id (dialog=${dialogId.valueOf()})`);
+        }
+        if (answer.content.trim() === '') {
+            throw new Error(`A2H append invariant violation: empty answer content (dialog=${dialogId.valueOf()} answerId=${answer.id})`);
+        }
+        await this.mutateAnswersToHumanState(dialogId, (previousAnswers) => {
+            const existing = previousAnswers.find((item) => item.id === answer.id);
+            if (existing) {
+                throw new Error(`A2H duplicate answer id violation: dialog=${dialogId.valueOf()} status=${status} answerId=${answer.id} existingAnsweredAt=${existing.answeredAt} incomingAnsweredAt=${answer.answeredAt}`);
+            }
+            return { kind: 'append', answer };
+        }, status);
+        await this.flushA2HWriteBack(this.getA2HWriteBackKey(dialogId, status));
+    }
+    static async acknowledgeAnswerToHumanState(dialogId, answerId, status = 'running') {
+        const out = await this.mutateAnswersToHumanState(dialogId, () => ({ kind: 'remove', answerId }), status);
+        if (out.removedAnswer !== undefined) {
+            await this.flushA2HWriteBack(this.getA2HWriteBackKey(dialogId, status));
+        }
+        return {
+            found: typeof out.removedAnswer !== 'undefined',
+            remainingAnswers: out.answers,
+            removedAnswer: out.removedAnswer,
+        };
+    }
     static async flushQ4HWriteBack(key) {
         const mutex = this.getQ4HWriteBackMutex(key);
         let captured;
@@ -6427,6 +6674,125 @@ class DialogPersistence {
         }
         await this.renameWithRetry(tempFile, questionsFilePath, 5, cancellationToken);
     }
+    static async flushA2HWriteBack(key) {
+        const mutex = this.getA2HWriteBackMutex(key);
+        let captured;
+        {
+            const release = await mutex.acquire();
+            try {
+                const entry = this.a2hWriteBack.get(key);
+                if (!entry)
+                    return;
+                if (entry.kind === 'flushing')
+                    return;
+                if (entry.kind !== 'scheduled')
+                    return;
+                clearTimeout(entry.timer);
+                const cancellationToken = this.createMainDialogWriteBackCancellationToken(entry.dialogId, entry.status);
+                const inFlight = this.writeA2HStateToDisk(entry.dialogId, entry.state, entry.status, cancellationToken);
+                captured = {
+                    dialogId: entry.dialogId,
+                    status: entry.status,
+                    stateToWrite: entry.state,
+                    inFlight,
+                };
+                this.a2hWriteBack.set(key, {
+                    kind: 'flushing',
+                    dialogId: entry.dialogId,
+                    status: entry.status,
+                    state: entry.state,
+                    dirty: false,
+                    inFlight,
+                });
+            }
+            finally {
+                release();
+            }
+        }
+        if (!captured)
+            return;
+        try {
+            await captured.inFlight;
+        }
+        catch (error) {
+            const release = await mutex.acquire();
+            try {
+                const entry = this.a2hWriteBack.get(key);
+                if (!entry)
+                    return;
+                if (entry.kind !== 'flushing')
+                    return;
+                if (entry.inFlight !== captured.inFlight)
+                    return;
+                if (isDialogWriteBackCanceledError(error)) {
+                    this.a2hWriteBack.delete(key);
+                    return;
+                }
+                const timer = setTimeout(() => {
+                    void this.flushA2HWriteBack(key);
+                }, this.A2H_WRITEBACK_WINDOW_MS);
+                this.a2hWriteBack.set(key, {
+                    kind: 'scheduled',
+                    dialogId: entry.dialogId,
+                    status: entry.status,
+                    state: entry.state,
+                    timer,
+                });
+            }
+            finally {
+                release();
+            }
+            return;
+        }
+        const release = await mutex.acquire();
+        try {
+            const entry = this.a2hWriteBack.get(key);
+            if (!entry)
+                return;
+            if (entry.kind !== 'flushing')
+                return;
+            if (entry.inFlight !== captured.inFlight)
+                return;
+            if (!entry.dirty) {
+                this.a2hWriteBack.delete(key);
+                return;
+            }
+            const timer = setTimeout(() => {
+                void this.flushA2HWriteBack(key);
+            }, this.A2H_WRITEBACK_WINDOW_MS);
+            this.a2hWriteBack.set(key, {
+                kind: 'scheduled',
+                dialogId: entry.dialogId,
+                status: entry.status,
+                state: entry.state,
+                timer,
+            });
+        }
+        finally {
+            release();
+        }
+    }
+    static async writeA2HStateToDisk(dialogId, state, status, cancellationToken) {
+        if (cancellationToken) {
+            this.assertMainDialogWriteBackNotCanceled(cancellationToken, 'writeA2HStateToDisk:start');
+        }
+        const dialogPath = this.getDialogEventsPath(dialogId, status);
+        const answersFilePath = path.join(dialogPath, 'a2h.yaml');
+        if (state.kind === 'deleted') {
+            await fs.promises.rm(answersFilePath, { force: true });
+            return;
+        }
+        const yamlContent = yaml.stringify(state.file);
+        const tempFile = path.join(dialogPath, `.${path.basename(answersFilePath)}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+        try {
+            await fs.promises.writeFile(tempFile, yamlContent, 'utf-8');
+        }
+        catch (error) {
+            await this.rethrowWriteBackPathMissingAsCanceled(error, dialogPath, cancellationToken, 'writeA2HStateToDisk:write-temp');
+            throw error;
+        }
+        await this.renameWithRetry(tempFile, answersFilePath, 5, cancellationToken);
+    }
     /**
      * Load all Q4H questions from all running dialogs (for global Q4H display)
      * Returns array of questions with their dialog context for frontend display
@@ -6466,6 +6832,47 @@ class DialogPersistence {
             return [];
         }
     }
+    static async loadAllA2HState() {
+        try {
+            const dialogIds = await this.listAllDialogIds('running');
+            const allAnswers = [];
+            for (const dialogIdObj of dialogIds) {
+                try {
+                    const answers = await this.loadAnswersToHumanState(dialogIdObj, 'running');
+                    if (answers.length === 0) {
+                        continue;
+                    }
+                    const metadata = await this.loadDialogMetadata(dialogIdObj, 'running');
+                    if (!metadata) {
+                        continue;
+                    }
+                    for (const answer of answers) {
+                        allAnswers.push({
+                            ...answer,
+                            selfId: dialogIdObj.selfId,
+                            rootId: dialogIdObj.rootId,
+                            agentId: metadata.agentId,
+                            taskDocPath: metadata.taskDocPath,
+                        });
+                    }
+                }
+                catch (err) {
+                    log_1.log.warn(`Failed to load A2H for dialog ${dialogIdObj.valueOf()}:`, err);
+                }
+            }
+            return allAnswers.sort((a, b) => {
+                const ta = new Date(a.answeredAt).getTime();
+                const tb = new Date(b.answeredAt).getTime();
+                if (Number.isFinite(ta) && Number.isFinite(tb))
+                    return tb - ta;
+                return b.answeredAt.localeCompare(a.answeredAt);
+            });
+        }
+        catch (error) {
+            log_1.log.error('Failed to load all A2H state:', error);
+            return [];
+        }
+    }
     static async clearQuestions4HumanState(dialogId, status = 'running') {
         try {
             const { previousQuestions } = await this.mutateQuestions4HumanState(dialogId, () => ({ kind: 'clear' }), status);
@@ -7126,6 +7533,9 @@ class DialogPersistence {
             displayState: latest.displayState ?? null,
             executionMarker: latest.executionMarker ?? null,
             nextStepTriggers,
+            pendingUserInterjectionReplyMsgId: latest.pendingUserInterjectionReply?.msgId ?? null,
+            pendingUserInterjectionReplyCourse: latest.pendingUserInterjectionReply?.course ?? null,
+            pendingUserInterjectionReplyGenseq: latest.pendingUserInterjectionReply?.genseq ?? null,
             pendingRuntimePromptMsgId: latest.pendingRuntimePrompt?.msgId ?? null,
             generationRunState: latest.generationRunState ?? null,
             replyDelivery: latest.replyDelivery ?? null,
@@ -8260,7 +8670,7 @@ class DialogPersistence {
             const key = this.getLatestWriteBackKey(dialogId, status);
             const staged = this.latestWriteBack.get(key);
             if (staged) {
-                return staged.latest;
+                return await this.normalizeDialogLatestPendingUserInterjectionReply(dialogId, status, staged.latest);
             }
             const dialogPath = this.getDialogEventsPath(dialogId, status);
             const latestFilePath = path.join(dialogPath, 'latest.yaml');
@@ -8269,7 +8679,10 @@ class DialogPersistence {
                 source: 'dialog_latest',
                 format: 'yaml',
             });
-            return this.parseDialogLatestYaml(content, latestFilePath);
+            const parsed = this.parseDialogLatestYaml(content, latestFilePath);
+            return parsed === null
+                ? null
+                : await this.normalizeDialogLatestPendingUserInterjectionReply(dialogId, status, parsed);
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT') {
@@ -8393,7 +8806,10 @@ class DialogPersistence {
                 source: 'dialog_latest',
                 format: 'yaml',
             });
-            return this.parseDialogLatestYaml(content, latestFilePath);
+            const parsed = this.parseDialogLatestYaml(content, latestFilePath);
+            return parsed === null
+                ? null
+                : await this.normalizeDialogLatestPendingUserInterjectionReply(dialogId, status, parsed);
         }
         catch (error) {
             if (getErrorCode(error) === 'ENOENT') {
@@ -8735,6 +9151,132 @@ class DialogPersistence {
     static async loadCourseEvents(dialogId, course, status = 'running') {
         return await this.readCourseEvents(dialogId, course, status);
     }
+    static resolvePendingUserInterjectionReplyFromCourseEvents(events, course) {
+        let pendingUserInterjectionReply;
+        let visibleReplySettled = false;
+        for (const event of events) {
+            if (event.type === 'human_text_record') {
+                if (event.origin !== 'user')
+                    continue;
+                if (typeof event.q4hAnswerCallId === 'string' && event.q4hAnswerCallId.trim() !== '') {
+                    continue;
+                }
+                pendingUserInterjectionReply = {
+                    msgId: event.msgId,
+                    course: (0, storage_1.toDialogCourseNumber)(course),
+                    genseq: (0, storage_1.toCallSiteGenseqNo)(event.genseq),
+                };
+                visibleReplySettled = false;
+                continue;
+            }
+            if (pendingUserInterjectionReply === undefined) {
+                continue;
+            }
+            if (event.type === 'agent_words_record') {
+                visibleReplySettled = true;
+                continue;
+            }
+            if (event.type === 'func_call_record' || event.type === 'tellask_call_record') {
+                visibleReplySettled = false;
+            }
+        }
+        return visibleReplySettled ? undefined : pendingUserInterjectionReply;
+    }
+    static resolveAnsweredUserInterjectionA2HFromCourseEvents(args) {
+        let pendingUserInterjectionReply;
+        let lastVisibleAnswer;
+        let visibleReplySettled = false;
+        for (const event of args.events) {
+            if (event.type === 'human_text_record') {
+                if (event.origin !== 'user')
+                    continue;
+                if (typeof event.q4hAnswerCallId === 'string' && event.q4hAnswerCallId.trim() !== '') {
+                    continue;
+                }
+                pendingUserInterjectionReply = {
+                    msgId: event.msgId,
+                    course: (0, storage_1.toDialogCourseNumber)(args.course),
+                    genseq: (0, storage_1.toCallSiteGenseqNo)(event.genseq),
+                };
+                visibleReplySettled = false;
+                lastVisibleAnswer = undefined;
+                continue;
+            }
+            if (pendingUserInterjectionReply === undefined) {
+                continue;
+            }
+            if (event.type === 'agent_words_record') {
+                visibleReplySettled = true;
+                lastVisibleAnswer = { content: event.content, genseq: event.genseq };
+                continue;
+            }
+            if (event.type === 'func_call_record' || event.type === 'tellask_call_record') {
+                visibleReplySettled = false;
+                lastVisibleAnswer = undefined;
+            }
+        }
+        if (!visibleReplySettled || pendingUserInterjectionReply === undefined || !lastVisibleAnswer) {
+            return undefined;
+        }
+        if (pendingUserInterjectionReply.msgId !== args.pending?.msgId) {
+            return undefined;
+        }
+        const answerIdSource = [
+            args.dialogId.rootId,
+            args.dialogId.selfId,
+            `c${String(args.course)}`,
+            `g${String(lastVisibleAnswer.genseq)}`,
+            pendingUserInterjectionReply.msgId,
+        ].join('|');
+        return {
+            id: `a2h-${Buffer.from(answerIdSource).toString('base64url')}`,
+            content: lastVisibleAnswer.content,
+            answeredAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
+            userInterjection: {
+                msgId: pendingUserInterjectionReply.msgId,
+                course: pendingUserInterjectionReply.course,
+                genseq: pendingUserInterjectionReply.genseq,
+            },
+            answerRef: {
+                course: (0, storage_1.toDialogCourseNumber)(args.course),
+                genseq: (0, storage_1.toCallSiteGenseqNo)(lastVisibleAnswer.genseq),
+            },
+        };
+    }
+    static async normalizeDialogLatestPendingUserInterjectionReply(dialogId, status, latest) {
+        if (latest.pendingUserInterjectionReply === undefined) {
+            return latest;
+        }
+        const events = await this.readCourseEvents(dialogId, latest.currentCourse, status);
+        const normalizedPending = this.resolvePendingUserInterjectionReplyFromCourseEvents(events, latest.currentCourse);
+        if (normalizedPending === undefined) {
+            const recoveredAnswer = this.resolveAnsweredUserInterjectionA2HFromCourseEvents({
+                dialogId,
+                events,
+                course: latest.currentCourse,
+                pending: latest.pendingUserInterjectionReply,
+            });
+            if (recoveredAnswer !== undefined) {
+                const existingAnswers = await this.loadAnswersToHumanState(dialogId, status);
+                if (!existingAnswers.some((item) => item.id === recoveredAnswer.id)) {
+                    await this.appendAnswerToHumanState(dialogId, recoveredAnswer, status);
+                }
+                return {
+                    ...latest,
+                    pendingUserInterjectionReply: undefined,
+                };
+            }
+        }
+        if (normalizedPending?.msgId === latest.pendingUserInterjectionReply.msgId &&
+            normalizedPending?.course === latest.pendingUserInterjectionReply.course &&
+            normalizedPending?.genseq === latest.pendingUserInterjectionReply.genseq) {
+            return latest;
+        }
+        return {
+            ...latest,
+            pendingUserInterjectionReply: normalizedPending,
+        };
+    }
     /**
      * Reconstruct dialog state from JSONL events (optimized: only latest course needed).
      */
@@ -9094,10 +9636,13 @@ DialogPersistence.SIDE_DIALOGS_DIR = 'sideDialogs';
 DialogPersistence.quarantinedMainDialogScopes = new Set();
 DialogPersistence.LATEST_WRITEBACK_WINDOW_MS = 300;
 DialogPersistence.Q4H_WRITEBACK_WINDOW_MS = 300;
+DialogPersistence.A2H_WRITEBACK_WINDOW_MS = 300;
 DialogPersistence.latestWriteBackMutexes = new Map();
 DialogPersistence.latestWriteBack = new Map();
 DialogPersistence.q4hWriteBackMutexes = new Map();
 DialogPersistence.q4hWriteBack = new Map();
+DialogPersistence.a2hWriteBackMutexes = new Map();
+DialogPersistence.a2hWriteBack = new Map();
 DialogPersistence.activeCalleesMutexes = new Map();
 DialogPersistence.wakeQueueMutexes = new Map();
 DialogPersistence.backendDriveStallMutexes = new Map();

package/dist/process-title.d.ts

@@ -0,0 +1,2 @@
+export declare function setProcessTitle(title: string): void;
+export declare function setRtwsProcessTitle(rtwsRootAbs?: string): void;