dominds 1.23.7 → 1.23.9

package/dist/apps-host/client.d.ts

@@ -1,6 +1,5 @@
-import type { DomindsAppDynamicToolsetsContext, DomindsAppReminderOwnerApplyContext, DomindsAppReminderOwnerRenderContext, DomindsAppReminderOwnerUpdateContext, DomindsAppRunControlContext, DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
+import type { DomindsAppDynamicToolsetsContext, DomindsAppReminderOwnerApplyContext, DomindsAppReminderOwnerRenderContext, DomindsAppReminderOwnerUpdateContext, DomindsAppReminderRenderedMessage, DomindsAppRunControlContext, DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
 import type { DomindsAppHostReminderUpdateResult, DomindsAppHostToolResult, DomindsAppInstallJson, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult } from '@longrun-ai/kernel/app-json';
-import type { ChatMessage } from '../llm/client';
 import type { ToolArguments } from '../tool';
 import type { AppsHostMessageToKernel } from './ipc-types';
 export type EnabledAppForHost = Readonly<{
@@ -22,7 +21,7 @@ export type AppsHostClient = Readonly<{
     applyRunControl: (controlId: string, payload: DomindsAppRunControlContext) => Promise<DomindsAppRunControlResult>;
     applyReminder: (appId: string, ownerRef: string, request: DomindsAppReminderApplyRequest, ctx: DomindsAppReminderOwnerApplyContext) => Promise<DomindsAppReminderApplyResult>;
     updateReminder: (appId: string, ownerRef: string, ctx: DomindsAppReminderOwnerUpdateContext) => Promise<DomindsAppHostReminderUpdateResult>;
-    renderReminder: (appId: string, ownerRef: string, ctx: DomindsAppReminderOwnerRenderContext) => Promise<ChatMessage>;
+    renderReminder: (appId: string, ownerRef: string, ctx: DomindsAppReminderOwnerRenderContext) => Promise<DomindsAppReminderRenderedMessage>;
     shutdown: () => Promise<void>;
 }>;
 export type AppsHostReadyMessage = Extract<AppsHostMessageToKernel, {

package/dist/apps-host/host.js

@@ -6,8 +6,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const url_1 = require("url");
-const log_1 = require("../log");
 const app_id_1 = require("../apps/app-id");
+const log_1 = require("../log");
 const ipc_types_1 = require("./ipc-types");
 const log = (0, log_1.createLogger)('apps-host');
 const dynamicImport = new Function('specifier', 'return import(specifier)');
@@ -186,12 +186,10 @@ function isReminderUpdateResult(value) {
     const updatedMeta = value['updatedMeta'];
     return updatedMeta === undefined || isJsonValue(updatedMeta);
 }
-function isChatMessage(value) {
+function isReminderRenderedMessage(value) {
     if (!isRecord(value))
         return false;
-    if (typeof value['type'] !== 'string')
-        return false;
-    if (typeof value['role'] !== 'string')
+    if (typeof value['content'] !== 'string')
         return false;
     return true;
 }
@@ -697,12 +695,12 @@ process.on('message', (raw) => {
                 }
                 try {
                     const message = await found.fn.renderReminder(msg.ctx);
-                    if (!isChatMessage(message)) {
+                    if (!isReminderRenderedMessage(message)) {
                         send({
                             type: 'reminder_render_result',
                             callId: msg.callId,
                             ok: false,
-                            errorText: `Invalid reminder render result shape: ${msg.appId}/${msg.ownerRef}`,
+                            errorText: `Invalid reminder render result shape: ${msg.appId}/${msg.ownerRef}; expected { content: string }`,
                         });
                         return;
                     }

package/dist/apps-host/ipc-types.d.ts

@@ -1,7 +1,6 @@
-import type { DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
+import type { DomindsAppReminderRenderedMessage, DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
 import type { DomindsAppDialogReminderRequestBatch, DomindsAppHostReminderUpdateResult, DomindsAppInstallJson, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult, DomindsAppReminderState } from '@longrun-ai/kernel/app-json';
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
-import type { ChatMessage } from '../llm/client';
 import type { ToolArguments, ToolCallOutput } from '../tool';
 export type AppsHostKernelInitMessage = Readonly<{
     type: 'init';
@@ -171,7 +170,7 @@ export type AppsHostReminderRenderResultMessage = Readonly<{
     callId: string;
 } & (Readonly<{
     ok: true;
-    message: ChatMessage;
+    message: DomindsAppReminderRenderedMessage;
 }> | Readonly<{
     ok: false;
     errorText: string;

package/dist/docs/dialog-system.md

@@ -241,6 +241,9 @@ flowchart TD
 
 - If a Side Dialog has completed all assigned goals and can deliver the final result, it MUST reply directly with the response body; do not use `tellaskBack` to send final delivery.
 - Runtime treats that direct reply as the completion delivery to the tellasker and injects the work-language marker automatically (`【Completed】` in English work language, `【最终完成】` in Chinese work language).
+- There is no separate technical state for keeping Side Dialogs active. A Side Dialog continues because normal business state still requires work: a tool result needs reaction, Q4H is pending, a downstream Side Dialog is pending, or an explicit runtime/user prompt is queued. Do not add a side path whose only purpose is to keep a dialog active.
+- Reply-obligation tail handling is one small state machine: after runtime reaches a non-suspended tail, it inspects the newest non-empty assistant generation candidate produced by the current drive, preferring public saying over thinking when both exist on the same generation. If a Side Dialog still owes `replyTellask*` and has produced that candidate content without using the exact reply tool, runtime queues one reply-tool reminder. If the next answer to that reminder is still only thinking/saying, runtime intentionally delivers that content through direct-reply fallback and marks it as fallback.
+- Runtime must not infer this tail state by scanning historical message text. Historical context is for the model and the UI; scheduling state must be carried explicitly by the current drive result, active reply obligation, pending blocker indexes, or queued prompts.
 - If the work is unfinished, do not default to `tellaskBack`; first use team SOP / role ownership to judge whether a responsible owner is already clear, and if yes for execution work, directly use `tellask` / `tellaskSessionless` for that owner.
 - Use `tellaskBack({ tellaskContent: "..." })` only when the tellasker must clarify the request, decide a tradeoff, confirm acceptance criteria, provide missing input, or current SOP cannot determine ownership.
 - **FBR exception**: FBR Side Dialogs forbid all tellask calls (including `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`); they must list missing context and return.

package/dist/docs/dialog-system.zh.md

@@ -239,6 +239,9 @@ flowchart TD
 **支线交付规则（规范）**：
 
 - 只有当所有目标完成时，支线对话才可直接正常回复诉请者。
+- 支线对话没有独立的活性维持状态。支线继续推进，是因为正常业务状态仍未完成：工具结果需要处理、Q4H 待答、下游支线待回贴，或已有显式 runtime/user prompt 排队。不要新增只为维持活跃而存在的旁路。
+- 回复义务的尾部处理是一条很小的状态机：运行时到达未挂起的尾部后，只检查本次 drive 产出的最新非空 assistant generation 候选；同一 generation 同时存在 saying/thinking 时优先取公开 saying。若支线仍欠 `replyTellask*`，并且已经产出候选内容但没有调用精确 reply 工具，运行时只排队一次 reply-tool reminder；如果模型在 reminder 后仍只产出 thinking/saying，运行时会有意通过 direct-reply fallback 投递该内容，并显式标注 fallback。
+- 运行时不得通过回扫历史消息文本来推断这个尾部状态。历史上下文属于模型和 UI；调度状态必须由当前 drive result、active reply obligation、pending blocker 索引或 queued prompt 等显式状态携带。
 - 若目标尚未完成，不要默认直接 `tellaskBack`；应先按团队规程 / SOP / 职责卡判断能否明确负责人，若能明确且属于执行性处理，直接 `tellask` / `tellaskSessionless` 对应负责人。
 - 只有当必须由诉请者补充需求、澄清目标、做业务裁决、确认验收口径、提供缺失输入，或现有规程无法明确判责时，才使用 `tellaskBack({ tellaskContent: "..." })` 回问诉请者再继续。
 - **FBR 例外**：FBR 支线对话禁止一切 tellask（包括 `tellaskBack` / `tellask` / `tellaskSessionless` / `askHuman`），只能列出缺口与阻塞原因并直接回复。

package/dist/docs/diligence-push.md

@@ -77,13 +77,15 @@ idle" path. In that recovery-only case, pending sideDialogs do not veto the sing
 injection, because the deadlock may happen in a function-result-driven generation round right after
 the main dialog has already registered an in-flight tellask/sideDialog.
 
-Side Dialogs may also use this recovery path, but only when an active reply obligation still exists.
-If no active reply obligation exists, runtime does not inject a push and leaves the retry-stopped
-state for a human to handle. The Side Dialog recovery template does not read rtws diligence files;
-it uses a built-in bilingual template containing the current time, the current Tellask goal, and the
-single runtime-confirmed `replyTellask*` tool (for example
-`replyTellaskSessionless({ replyContent })`). The LLM must not guess the reply variant. Q4H remains
-a hard blocker.
+Side Dialogs may also use this recovery path, but only for provider/API retry-stopped deadlock
+recovery while an active reply obligation still exists. This is not a general mechanism for keeping
+Side Dialogs active. Normal Side Dialog continuation must come from ordinary business state: tool
+results, Q4H, downstream Side Dialog blockers, or queued runtime/user prompts. If no active reply
+obligation exists, runtime does not inject a push and leaves the retry-stopped state for a human to
+handle. The Side Dialog recovery template does not read rtws diligence files; it uses a built-in
+bilingual template containing the current time, the current Tellask goal, and the single
+runtime-confirmed `replyTellask*` tool (for example `replyTellaskSessionless({ replyContent })`).
+The LLM must not guess the reply variant. Q4H remains a hard blocker.
 
 ### Action
 

package/dist/llm/gen/codex.js

@@ -263,8 +263,23 @@ function extractReasoningPayload(item) {
         reasoning.content = content;
     if (encrypted)
         reasoning.encrypted_content = encrypted;
+    const hasReasoningData = summary.length > 0 || (content?.length ?? 0) > 0 || encrypted !== undefined;
+    if (hasReasoningData) {
+        reasoning.metadata = {
+            itemType: item.type,
+        };
+        if (typeof item.id === 'string' && item.id.length > 0) {
+            reasoning.metadata.itemId = item.id;
+        }
+    }
     return reasoning;
 }
+function hasReasoningPayloadSignals(payload) {
+    return (payload.summary.length > 0 ||
+        (payload.content?.length ?? 0) > 0 ||
+        (payload.encrypted_content?.length ?? 0) > 0 ||
+        payload.metadata !== undefined);
+}
 function buildReasoningPayloadFromText(text) {
     if (text.trim().length === 0)
         return undefined;
@@ -932,7 +947,7 @@ class CodexGen {
                                     : sawReasoningDeltaWithoutItemId;
                                 if (!sawReasoningDelta) {
                                     const text = extractReasoningText(event.item);
-                                    if (text.length > 0) {
+                                    if (text.length > 0 || hasReasoningPayloadSignals(payloadFromItem)) {
                                         if (activeStream === 'saying') {
                                             const detail = 'CODEX stream overlap violation: received reasoning while saying stream still active';
                                             log.error(detail, new Error('codex_stream_overlap_violation'));
@@ -951,9 +966,11 @@ class CodexGen {
                                             await receiver.thinkingStart();
                                             activeStream = 'thinking';
                                         }
-                                        currentThinkingContent += text;
-                                        await receiver.thinkingChunk(text);
-                                        await receiver.thinkingFinish(payloadFromItem ?? buildReasoningPayloadFromText(currentThinkingContent));
+                                        if (text.length > 0) {
+                                            currentThinkingContent += text;
+                                            await receiver.thinkingChunk(text);
+                                        }
+                                        await receiver.thinkingFinish(payloadFromItem);
                                         thinkingStarted = false;
                                         currentThinkingContent = '';
                                         if (activeStream === 'thinking')
@@ -961,12 +978,16 @@ class CodexGen {
                                     }
                                 }
                                 else if (thinkingStarted) {
-                                    await receiver.thinkingFinish(payloadFromItem ?? buildReasoningPayloadFromText(currentThinkingContent));
+                                    await receiver.thinkingFinish(payloadFromItem);
                                     thinkingStarted = false;
                                     currentThinkingContent = '';
                                     if (activeStream === 'thinking')
                                         activeStream = 'idle';
                                 }
+                                else if (hasReasoningPayloadSignals(payloadFromItem)) {
+                                    await receiver.thinkingStart();
+                                    await receiver.thinkingFinish(payloadFromItem);
+                                }
                                 return;
                             }
                             case 'local_shell_call':

package/dist/llm/gen/openai.js

@@ -1135,8 +1135,28 @@ function extractReasoningPayload(item) {
         out.content = content;
     if (encrypted)
         out.encrypted_content = encrypted;
+    const hasReasoningData = summary.length > 0 || content.length > 0 || encrypted !== undefined;
+    if (hasReasoningData) {
+        const metadata = { itemType: item.type };
+        if (typeof item.id === 'string' && item.id.length > 0) {
+            metadata.itemId = item.id;
+        }
+        if (item.status === 'in_progress' ||
+            item.status === 'completed' ||
+            item.status === 'incomplete') {
+            metadata.status = item.status;
+        }
+        out.metadata = metadata;
+    }
     return out;
 }
+function hasReasoningPayloadSignals(payload) {
+    return (payload !== null &&
+        (payload.summary.length > 0 ||
+            (payload.content?.length ?? 0) > 0 ||
+            (payload.encrypted_content?.length ?? 0) > 0 ||
+            payload.metadata !== undefined));
+}
 function openAiResponseToBatchOutputs(response, genseq) {
     const outputs = [];
     const output = response.output;
@@ -1149,7 +1169,7 @@ function openAiResponseToBatchOutputs(response, genseq) {
         if (item.type === 'reasoning') {
             const reasoning = extractReasoningPayload(item);
             const content = extractReasoningText(item);
-            if (content.length > 0 || reasoning !== null) {
+            if (content.length > 0 || hasReasoningPayloadSignals(reasoning)) {
                 outputs.push({
                     kind: 'message',
                     message: {
@@ -1157,7 +1177,7 @@ function openAiResponseToBatchOutputs(response, genseq) {
                         role: 'assistant',
                         genseq,
                         content,
-                        reasoning: reasoning ?? undefined,
+                        ...(reasoning !== null ? { reasoning } : {}),
                     },
                 });
             }
@@ -1655,6 +1675,7 @@ class OpenAiGen {
                             const sawReasoningDelta = itemId !== null
                                 ? streamedReasoningItemIds.has(itemId)
                                 : sawReasoningDeltaWithoutItemId;
+                            const payload = extractReasoningPayload(item);
                             if (sawReasoningDelta) {
                                 if (itemId !== null) {
                                     streamedReasoningItemIds.delete(itemId);
@@ -1662,9 +1683,20 @@ class OpenAiGen {
                                 else {
                                     sawReasoningDeltaWithoutItemId = false;
                                 }
+                                if (thinkingStarted) {
+                                    await receiver.thinkingFinish(payload ?? buildReasoningPayloadFromText(currentThinkingContent));
+                                    thinkingStarted = false;
+                                    currentThinkingContent = '';
+                                    if (activeStream === 'thinking')
+                                        activeStream = 'idle';
+                                    break;
+                                }
+                                if (hasReasoningPayloadSignals(payload)) {
+                                    await receiver.thinkingStart();
+                                    await receiver.thinkingFinish(payload);
+                                }
                                 break;
                             }
-                            const payload = extractReasoningPayload(item);
                             const text = extractReasoningText(item);
                             if (thinkingStarted) {
                                 if (currentThinkingContent.length === 0 && text.length > 0) {
@@ -1678,7 +1710,7 @@ class OpenAiGen {
                                     activeStream = 'idle';
                                 break;
                             }
-                            if (text.length > 0 || payload !== null) {
+                            if (text.length > 0 || hasReasoningPayloadSignals(payload)) {
                                 if (activeStream === 'saying') {
                                     if (sayingStarted) {
                                         await receiver.sayingFinish();

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

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitThinkingEvents = emitThinkingEvents;
 exports.emitSayingEvents = emitSayingEvents;
 async function emitThinkingEvents(dlg, content, reasoning) {
-    if (!content.trim())
-        return undefined;
+    const hasContent = content.trim().length > 0;
+    if (!hasContent && reasoning === undefined)
+        return;
     await dlg.thinkingStart();
-    await dlg.thinkingChunk(content);
+    if (hasContent) {
+        await dlg.thinkingChunk(content);
+    }
     await dlg.thinkingFinish(reasoning);
 }
 async function emitSayingEvents(dlg, content) {

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

@@ -81,6 +81,7 @@ function isNonIdleDisplayProjection(state) {
     return state !== undefined && state.kind !== 'idle_waiting_user';
 }
 function resolveDirectFallbackResponse(args) {
+    let saying;
     if (args.driveResult.lastAssistantSayingContent !== null &&
         args.driveResult.lastAssistantSayingContent.trim() !== '') {
         if (typeof args.driveResult.lastAssistantSayingGenseq !== 'number' ||
@@ -88,16 +89,22 @@ function resolveDirectFallbackResponse(args) {
             args.driveResult.lastAssistantSayingGenseq <= 0) {
             throw new Error(`Direct reply fallback invariant violation: missing lastAssistantSayingGenseq for dialog=${args.dialog.id.valueOf()}`);
         }
-        return {
+        saying = {
             responseText: args.driveResult.lastAssistantSayingContent,
             responseGenseq: Math.floor(args.driveResult.lastAssistantSayingGenseq),
             source: 'saying',
         };
     }
-    // Thinking-only output is intentionally a fallback candidate: some providers/models can finish a
-    // Side Dialog with useful content in thinking and no public saying. This helper only extracts the
-    // candidate; callers below must still reject it when a same-round function/tellask call needs
-    // auto-continuation, when the dialog is suspended, or when another follow-up prompt is queued.
+    // Thinking output is intentionally a fallback candidate: some providers/models can finish a
+    // Side Dialog with useful content in thinking and no public saying. Pick the newest non-empty
+    // assistant generation candidate across the whole drive, preferring public saying over thinking
+    // on the same generation. A post-tool thinking segment must not be shadowed by an older pre-tool
+    // saying segment from an earlier generation iteration.
+    //
+    // This helper only extracts the candidate; callers below must still reject it when a same-round
+    // function/tellask call needs auto-continuation, when the dialog is suspended, or when another
+    // follow-up prompt is queued.
+    let thinking;
     if (args.driveResult.lastAssistantThinkingContent !== null &&
         args.driveResult.lastAssistantThinkingContent.trim() !== '') {
         if (typeof args.driveResult.lastAssistantThinkingGenseq !== 'number' ||
@@ -105,13 +112,16 @@ function resolveDirectFallbackResponse(args) {
             args.driveResult.lastAssistantThinkingGenseq <= 0) {
             throw new Error(`Direct reply fallback invariant violation: missing lastAssistantThinkingGenseq for dialog=${args.dialog.id.valueOf()}`);
         }
-        return {
+        thinking = {
             responseText: args.driveResult.lastAssistantThinkingContent,
             responseGenseq: Math.floor(args.driveResult.lastAssistantThinkingGenseq),
             source: 'thinking_only',
         };
     }
-    return undefined;
+    if (saying !== undefined && thinking !== undefined) {
+        return saying.responseGenseq >= thinking.responseGenseq ? saying : thinking;
+    }
+    return saying ?? thinking;
 }
 async function buildReplyToolReminderPrompt(args) {
     return (0, reply_prompt_copy_1.buildReplyToolReminderText)({
@@ -209,79 +219,6 @@ async function loadPendingDiagnosticsSnapshot(args) {
         };
     }
 }
-async function hasAssistantOutputAfterAssignmentAnchor(args) {
-    const events = await persistence_1.DialogPersistence.loadCourseEvents(args.dialog.id, args.dialog.currentCourse, args.dialog.status);
-    let assignmentGenseq;
-    for (const event of events) {
-        if (event.type === 'tellask_anchor_record' &&
-            event.anchorRole === 'assignment' &&
-            event.callId === args.callId) {
-            assignmentGenseq = event.genseq;
-            continue;
-        }
-        if (assignmentGenseq !== undefined &&
-            (event.type === 'agent_thought_record' || event.type === 'agent_words_record') &&
-            event.genseq >= assignmentGenseq &&
-            event.content.trim() !== '') {
-            return true;
-        }
-    }
-    return false;
-}
-async function resolveStrandedSideDialogReplyReminderFollowUp(args) {
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.dialog.id, args.dialog.status);
-    const displayState = latest?.displayState;
-    const isRecoverableProjection = displayState?.kind === 'idle_waiting_user' ||
-        (displayState?.kind === 'stopped' && displayState.reason.kind === 'pending_reply_obligation');
-    if (!latest ||
-        !isRecoverableProjection ||
-        latest.pendingCourseStartPrompt !== undefined ||
-        latest.executionMarker?.kind === 'dead') {
-        return undefined;
-    }
-    const directive = await (0, tellask_special_1.loadActiveTellaskReplyDirective)(args.dialog);
-    if (!directive) {
-        return undefined;
-    }
-    const ownerDialogId = directive.targetDialogId.trim();
-    if (ownerDialogId === '') {
-        throw new Error(`stranded sideDialog reply recovery invariant violation: empty targetDialogId ` +
-            `(dialogId=${args.dialog.id.valueOf()}, targetCallId=${directive.targetCallId})`);
-    }
-    const pending = await persistence_1.DialogPersistence.loadPendingSideDialogs(new dialog_1.DialogID(ownerDialogId, args.dialog.id.rootId), args.dialog.status);
-    const pendingRecord = pending.find((record) => record.sideDialogId === args.dialog.id.selfId && record.callId === directive.targetCallId);
-    if (!pendingRecord) {
-        return undefined;
-    }
-    if (!(await hasAssistantOutputAfterAssignmentAnchor({
-        dialog: args.dialog,
-        callId: pendingRecord.callId,
-    }))) {
-        return undefined;
-    }
-    const language = (0, work_language_1.getWorkLanguage)();
-    const sideDialogReplyTarget = {
-        ownerDialogId,
-        callType: pendingRecord.callType,
-        callId: pendingRecord.callId,
-        callSiteCourse: pendingRecord.callSiteCourse,
-        callSiteGenseq: pendingRecord.callSiteGenseq,
-    };
-    return {
-        kind: 'runtime_sideDialog_reply_reminder',
-        prompt: await buildReplyToolReminderPrompt({
-            dlg: args.dialog,
-            directive,
-            language,
-        }),
-        msgId: (0, id_1.generateShortId)(),
-        grammar: 'markdown',
-        origin: 'runtime',
-        userLanguageCode: language,
-        tellaskReplyDirective: directive,
-        sideDialogReplyTarget,
-    };
-}
 async function clearConsumedDeferredRootQueueIfIdle(dialog) {
     if (dialog.id.selfId !== dialog.id.rootId) {
         return;
@@ -741,29 +678,6 @@ async function executeDriveRound(args) {
         // suspended by pending Q4H or sideDialogs. This prevents duplicate generations when
         // multiple wake-ups race around the same sideDialog completion boundary.
         if (!humanPrompt) {
-            if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
-                const strandedReplyReminder = await resolveStrandedSideDialogReplyReminderFollowUp({
-                    dialog,
-                });
-                if (strandedReplyReminder !== undefined) {
-                    await queueReplyReminderFollowUp({ dialog, followUp: strandedReplyReminder });
-                    args.scheduleDrive(dialog, {
-                        waitInQue: true,
-                        driveOptions: {
-                            source: 'kernel_driver_follow_up',
-                            reason: 'follow_up_prompt',
-                        },
-                    });
-                    log_1.log.warn('kernel-driver recovered stranded sideDialog reply obligation by queueing reply reminder', undefined, {
-                        dialogId: dialog.id.valueOf(),
-                        rootId: dialog.id.rootId,
-                        selfId: dialog.id.selfId,
-                        targetCallId: strandedReplyReminder.tellaskReplyDirective.targetCallId,
-                        targetOwnerDialogId: strandedReplyReminder.sideDialogReplyTarget.ownerDialogId,
-                    });
-                    return;
-                }
-            }
             if (dialog instanceof dialog_1.SideDialog && !dialog.hasUpNext()) {
                 try {
                     const inspection = await inspectNoPromptSideDialogDrive({ dialog, driveOptions });

package/dist/persistence.d.ts

@@ -97,6 +97,7 @@ export declare class DiskFileDialogStore extends DialogStore {
     private sayingContent;
     private thinkingContent;
     private thinkingReasoning;
+    private thinkingStarted;
     sayingStart(dialog: Dialog): Promise<void>;
     sayingChunk(dialog: Dialog, chunk: string): Promise<void>;
     sayingFinish(dialog: Dialog): Promise<void>;

package/dist/persistence.js

@@ -1816,6 +1816,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         this.sayingContent = '';
         this.thinkingContent = '';
         this.thinkingReasoning = undefined;
+        this.thinkingStarted = false;
         this.dialogId = dialogId;
     }
     // === DialogStore interface methods ===
@@ -2261,6 +2262,7 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         // Reset thinking content tracker
         this.thinkingContent = '';
         this.thinkingReasoning = undefined;
+        this.thinkingStarted = true;
         const thinkingStartEvt = {
             type: 'thinking_start_evt',
             course,
@@ -2286,13 +2288,13 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
         if (reasoning)
             this.thinkingReasoning = reasoning;
         const thinkingContent = this.thinkingContent;
-        if (thinkingContent || this.thinkingReasoning) {
+        if (this.thinkingStarted || thinkingContent || this.thinkingReasoning) {
             const thinkingMessageEvent = {
                 ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 type: 'agent_thought_record',
                 genseq: dialog.activeGenSeq,
                 content: thinkingContent,
-                reasoning: this.thinkingReasoning,
+                ...(this.thinkingReasoning !== undefined ? { reasoning: this.thinkingReasoning } : {}),
             };
             await this.appendEvent(dialog, course, thinkingMessageEvent);
         }
@@ -2300,8 +2302,10 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             type: 'thinking_finish_evt',
             course,
             genseq: dialog.activeGenSeq,
+            ...(this.thinkingReasoning !== undefined ? { reasoning: this.thinkingReasoning } : {}),
         };
         (0, evt_registry_1.postDialogEvent)(dialog, thinkingFinishEvt);
+        this.thinkingStarted = false;
     }
     async markdownStart(dialog) {
         const course = dialog.activeGenCourseOrUndefined ?? dialog.currentCourse;
@@ -2805,8 +2809,8 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 type: 'agent_thought_record',
                 genseq,
                 content: content || '',
-                reasoning,
-                provider_data,
+                ...(reasoning !== undefined ? { reasoning } : {}),
+                ...(provider_data !== undefined ? { provider_data } : {}),
             }
             : {
                 ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
@@ -3319,43 +3323,26 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                 break;
             }
             case 'agent_thought_record': {
-                // Replay thinking content as thinking events
+                // Replay persisted thinking records as substream boundaries, with chunks when content exists.
                 const content = event.content || '';
-                if (content) {
-                    // Start thinking phase
-                    const thinkingStartEvent = {
-                        type: 'thinking_start_evt',
-                        course,
-                        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,
-                            course,
-                            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',
+                const thinkingStartEvent = {
+                    type: 'thinking_start_evt',
+                    course,
+                    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,
                         course,
                         genseq: event.genseq,
                         dialog: {
@@ -3365,9 +3352,23 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
                         timestamp: event.ts,
                     };
                     if (ws.readyState === 1) {
-                        ws.send(JSON.stringify(thinkingFinishEvent));
+                        ws.send(JSON.stringify(thinkingChunkEvent));
                     }
                 }
+                const thinkingFinishEvent = {
+                    type: 'thinking_finish_evt',
+                    course,
+                    genseq: event.genseq,
+                    ...(event.reasoning !== undefined ? { reasoning: event.reasoning } : {}),
+                    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': {
@@ -6933,8 +6934,8 @@ class DialogPersistence {
                         role: 'assistant',
                         genseq: event.genseq,
                         content: event.content,
-                        reasoning: event.reasoning,
-                        provider_data: event.provider_data,
+                        ...(event.reasoning !== undefined ? { reasoning: event.reasoning } : {}),
+                        ...(event.provider_data !== undefined ? { provider_data: event.provider_data } : {}),
                     });
                     break;
                 }