dominds 1.15.4 → 1.15.5

package/dist/apps/assigned-port.d.ts

@@ -1,4 +1,4 @@
-import type { DomindsAppInstallJsonV1 } from '@longrun-ai/kernel/app-json';
+import type { DomindsAppInstallJson } from '@longrun-ai/kernel/app-json';
 import type { AppsResolutionEntry } from './resolution-file';
 export type AssignedPortResolutionReason = 'no_frontend' | 'kept_existing' | 'selected_default' | 'allocated_stable_range' | 'reassigned_from_existing_conflict' | 'reassigned_from_existing_unbindable';
 export type AssignedPortResolution = Readonly<{
@@ -16,13 +16,13 @@ export type AssignedPortResolution = Readonly<{
  */
 export declare function resolveStableAssignedPort(params: {
     appId: string;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
     existingApps: ReadonlyArray<AppsResolutionEntry>;
     existingAssignedPort: number | null;
 }): Promise<number | null>;
 export declare function resolveStableAssignedPortWithReason(params: {
     appId: string;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
     existingApps: ReadonlyArray<AppsResolutionEntry>;
     existingAssignedPort: number | null;
 }): Promise<AssignedPortResolution>;

package/dist/apps/resolution-file.d.ts

@@ -1,4 +1,4 @@
-import { type DomindsAppInstallJsonV1 } from '@longrun-ai/kernel/app-json';
+import { type DomindsAppInstallJson } from '@longrun-ai/kernel/app-json';
 export type AppsResolutionSchemaVersion = 1;
 export type AppsResolutionSource = Readonly<{
     kind: 'npx';
@@ -12,7 +12,7 @@ export type AppsResolutionEntry = Readonly<{
     enabled: boolean;
     source: AppsResolutionSource;
     assignedPort: number | null;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
 }>;
 export type AppsResolutionFile = Readonly<{
     schemaVersion: AppsResolutionSchemaVersion;

package/dist/apps/run-app-json.d.ts

@@ -1,8 +1,8 @@
-import { type DomindsAppInstallJsonV1 } from '@longrun-ai/kernel/app-json';
+import { type DomindsAppInstallJson } from '@longrun-ai/kernel/app-json';
 export declare function runDomindsAppJsonViaNpx(params: {
     spec: string;
     cwdAbs: string;
-}): Promise<DomindsAppInstallJsonV1>;
+}): Promise<DomindsAppInstallJson>;
 export declare function runDomindsAppJsonViaLocalPackage(params: {
     packageRootAbs: string;
-}): Promise<DomindsAppInstallJsonV1>;
+}): Promise<DomindsAppInstallJson>;

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

@@ -1,12 +1,12 @@
 import type { DomindsAppDynamicToolsetsContext, DomindsAppReminderOwnerApplyContext, DomindsAppReminderOwnerRenderContext, DomindsAppReminderOwnerUpdateContext, DomindsAppRunControlContext, DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
-import type { DomindsAppHostReminderUpdateResult, DomindsAppHostToolResult, DomindsAppInstallJsonV1, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult } from '@longrun-ai/kernel/app-json';
+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<{
     appId: string;
     runtimePort: number | null;
-    installJson: DomindsAppInstallJsonV1;
+    installJson: DomindsAppInstallJson;
     hostSourceVersion: string | null;
 }>;
 export type AppsHostClient = Readonly<{

package/dist/apps-host/host.js

@@ -33,12 +33,14 @@ function isStringArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === 'string');
 }
 function isToolCallOutput(value) {
-    if (typeof value === 'string')
-        return true;
     if (!isRecord(value))
         return false;
     if (typeof value['content'] !== 'string')
         return false;
+    const outcome = value['outcome'];
+    if (outcome !== 'success' && outcome !== 'failure' && outcome !== 'partial_failure') {
+        return false;
+    }
     const contentItems = value['contentItems'];
     return contentItems === undefined || Array.isArray(contentItems);
 }
@@ -183,15 +185,12 @@ function isChatMessage(value) {
     return true;
 }
 function normalizeToolResult(value) {
-    if (isToolCallOutput(value)) {
-        return { output: value };
-    }
     if (!isRecord(value)) {
-        throw new Error('Invalid app tool result: expected ToolCallOutput or structured object');
+        throw new Error('Invalid app tool result: expected { output: { content, outcome, contentItems? }, ... }');
     }
     const output = value['output'];
     if (!isToolCallOutput(output)) {
-        throw new Error('Invalid app tool result: output must be ToolCallOutput');
+        throw new Error('Invalid app tool result: output must be { content, outcome, contentItems? }');
     }
     const reminderRequestsRaw = value['reminderRequests'];
     if (reminderRequestsRaw !== undefined && !Array.isArray(reminderRequestsRaw)) {

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

@@ -1,5 +1,5 @@
 import type { DomindsAppRunControlResult } from '@longrun-ai/kernel/app-host-contract';
-import type { DomindsAppDialogReminderRequestBatch, DomindsAppHostReminderUpdateResult, DomindsAppInstallJsonV1, DomindsAppReminderApplyRequest, DomindsAppReminderApplyResult, DomindsAppReminderState } from '@longrun-ai/kernel/app-json';
+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';
@@ -13,7 +13,7 @@ export type AppsHostKernelInitMessage = Readonly<{
     apps: ReadonlyArray<Readonly<{
         appId: string;
         runtimePort: number | null;
-        installJson: DomindsAppInstallJsonV1;
+        installJson: DomindsAppInstallJson;
     }>>;
 }>;
 export type AppsHostKernelToolCallMessage = Readonly<{

package/dist/docs/app-constitution.md

@@ -222,7 +222,7 @@ Recommended user mental model:
 
 (Current: implemented) existing anchors:
 
-- JSON schema: `dominds/main/apps/app-json.ts` (`DomindsAppInstallJsonV1`).
+- JSON schema: `dominds/main/apps/app-json.ts` (`DomindsAppInstallJson`).
 - Apps configuration file: `dominds/main/apps/configuration-file.ts`.
 - Apps resolution file: `dominds/main/apps/resolution-file.ts`.
 

package/dist/docs/app-constitution.zh.md

@@ -221,7 +221,7 @@ Install JSON 是 app 与 Kernel/CLI 之间的**安装/运行握手载荷**。它
 
 （现状：已实现）install json schema 与 apps 配置/解析锚点仍可参考：
 
-- JSON schema：`dominds/main/apps/app-json.ts`（`DomindsAppInstallJsonV1`）。
+- JSON schema：`dominds/main/apps/app-json.ts`（`DomindsAppInstallJson`）。
 - `.apps/configuration.yaml`：`dominds/main/apps/configuration-file.ts`。
 - `.apps/resolution.yaml`：`dominds/main/apps/resolution-file.ts`。
 

package/dist/docs/tellask-result-unification.md

@@ -0,0 +1,280 @@
+# Tellask Result Unification
+
+## Purpose
+
+This document captures the agreed direction for the current tellask refactor so the
+implementation can stay aligned while multiple storage, runtime, provider, and frontend
+paths are being simplified at the same time.
+
+The goal is not to preserve old technical symmetry for its own sake. The goal is to make
+tellask behave as one coherent business feature with fewer special cases.
+
+## Agreed Direction
+
+- Keep `tellask_call_record` as the tellask-family call record.
+- Keep one unified tellask business result type:
+  - `tellask_result_record`
+  - `tellask_result_msg`
+  - `tellask_result_evt`
+- Keep carryover special and separate:
+  - rename `tellask_carryover_result_record` to `tellask_carryover_record`
+  - rename `tellask_carryover_result_msg` to `tellask_carryover_msg`
+  - rename `tellask_call_carryover_evt` / `tellask_carryover_result_evt` style names into a single
+    `tellask_carryover_evt`
+- Inline tellask result rendering is no longer the target model.
+- Tellask results should render as separate bubbles.
+- Call-site UI may still exist for pending / settled state, but result body should not depend on
+  inline rendering.
+- `replyTellask*` is not a separate business result family to unify on its own.
+  `replyTellask*` is a mechanism that produces a tellask result.
+- `askHuman` should move into the tellask result flow instead of being represented as a normal
+  user bubble.
+- Q4H answers should not be persisted as `human_text_record` for askHuman result rendering.
+
+## Current Problem
+
+Tellask business semantics are currently split across too many layers:
+
+- `tellask_call_record`
+  - call start
+- `tellask_call_result_record`
+  - local inline tellask business result
+- `tellask_response_record`
+  - sideline / subdialog response bubble
+- `tellask_result_record`
+  - thin technical pair record added later for call/result parity
+- `tellask_carryover_result_record`
+  - special cross-course carryover
+
+This produces several kinds of debt:
+
+- one business feature has multiple result record types
+- one business result message name has mixed semantics
+- frontend uses different event families for inline vs separate-bubble tellask results
+- `askHuman` answer flow still re-enters the generic user-message path
+- provider/runtime logic has had to invent technical projection types that are not the real
+  business model
+
+## Business Model After Refactor
+
+### Tellask Call
+
+`tellask_call_record` remains the start record for tellask-family tool invocation.
+
+It still covers:
+
+- `tellask`
+- `tellaskSessionless`
+- `tellaskBack`
+- `askHuman`
+- `freshBootsReasoning`
+- `replyTellask`
+- `replyTellaskSessionless`
+- `replyTellaskBack`
+
+### Tellask Result
+
+`tellask_result_record` becomes the single business result record for tellask outcomes.
+
+It should absorb the business payload currently split across:
+
+- `tellask_call_result_record`
+- `tellask_response_record`
+
+It should be rich enough to carry the actual tellask business context, not just a thin tool pair.
+
+### Tellask Carryover
+
+Carryover stays separate because it is not a normal call/result pair outcome.
+
+Its essence is:
+
+- cross-course continuation
+- special context anchor semantics
+- intentionally not part of standard call/result unification
+
+So it should remain independent under shorter names:
+
+- `tellask_carryover_record`
+- `tellask_carryover_msg`
+- `tellask_carryover_evt`
+
+## Message And Event Model
+
+### Result Bubble Direction
+
+Tellask business results should render as separate bubbles.
+
+That means the frontend event model should converge toward:
+
+- `tellask_call_start_evt`
+  - call-site lifecycle start
+- `tellask_result_evt`
+  - business result bubble creation / replay
+  - status updates for the related call site
+- `tellask_carryover_evt`
+  - special carryover bubble
+
+The old split:
+
+- `tellask_call_result_evt`
+- `tellask_response_evt`
+
+should be collapsed into `tellask_result_evt`.
+
+### Frontend Behavior
+
+Frontend call-site handling should become simpler:
+
+- call site shows pending / settled / carried-over state
+- tellask result body is shown in a separate bubble
+- no dependency on inline result body rendering
+
+This applies to:
+
+- local tellask failures
+- sideline/subdialog responses
+- askHuman pending/final result display
+
+## AskHuman Direction
+
+`askHuman` should behave as part of the tellask family, not as a detour into the generic user
+message path.
+
+### Desired Flow
+
+1. `askHuman` call starts as a tellask-family call.
+2. A temporary tellask-style result is shown while waiting.
+3. When the human answers, the final askHuman result is represented as a tellask result.
+4. The answer should not be kept as a normal user bubble for this purpose.
+
+### Important Clarification
+
+The runtime may still need the answer content to continue the next generation round.
+
+But that technical need must not force the product model to keep askHuman answers as
+`human_text_record` or ordinary user-style UI bubbles.
+
+The tellask business model is the source of truth.
+
+## ReplyTellask Direction
+
+`replyTellask*` should not be treated as a separate business result family.
+
+The correct business interpretation is:
+
+- `replyTellask*` is an action that produces a tellask result
+- the tellask result is the business object
+- `replyTellask*` itself does not need another parallel business-unification effort
+
+In practice this means the refactor should avoid introducing extra local-only reply result models
+just to satisfy old technical pairing assumptions.
+
+## Tellask Result Record Shape
+
+The unified `tellask_result_record` should be rich and business-oriented.
+
+It should not flatten every field at top level.
+
+Preferred shape:
+
+- keep truly global result fields at top level
+- move stable field groups into optional nested structures
+- inside a nested structure, fields should be required whenever that structure is present
+
+Suggested top-level concerns:
+
+- record identity / timestamp / course refs
+- `callId`
+- `callName`
+- `status`
+- `content`
+
+Suggested nested groups:
+
+- `call`
+  - original tellask call context
+  - example fields:
+    - `tellaskContent`
+    - `mentionList`
+    - `sessionSlug`
+- `responder`
+  - who produced the business result
+  - example fields:
+    - `responderId`
+    - `agentId`
+    - `originMemberId`
+- `route`
+  - navigation / callee metadata when applicable
+  - example fields:
+    - `calleeDialogId`
+    - `calleeCourse`
+    - `calleeGenseq`
+
+The exact final union can be refined during implementation, but the important rule is:
+
+- business grouping first
+- technical pairing concerns do not get to dictate the field model
+
+## Provider / Runtime Interpretation
+
+The unified tellask result model is the business truth.
+
+Provider/runtime projection must adapt to it, not the other way around.
+
+This means:
+
+- do not invent thin technical result types as the canonical tellask model
+- if the provider layer needs a particular call/result projection, derive it from the business
+  message
+- do not let tool-pair convenience decide what fields are allowed to exist
+
+## Files Expected To Change
+
+The refactor will likely touch at least these areas:
+
+- `packages/kernel/src/types/storage.ts`
+- `packages/kernel/src/types/chat-message.ts`
+- `packages/kernel/src/types/dialog.ts`
+- `main/persistence.ts`
+- `main/dialog.ts`
+- `main/priming.ts`
+- `main/dialog-fork.ts`
+- `main/llm/kernel-driver/tellask-special.ts`
+- `main/llm/kernel-driver/drive.ts`
+- `main/server/websocket-handler.ts`
+- `main/llm/gen/openai.ts`
+- `main/llm/gen/openai-compatible.ts`
+- `main/llm/gen/codex.ts`
+- `main/llm/gen/anthropic.ts`
+- `main/llm/gen/mock.ts`
+- `webapp/src/components/dominds-dialog-container.ts`
+- `webapp/src/components/dominds-app.tsx`
+
+Tests will also need a broad update wherever old tellask inline/result/carryover names are asserted.
+
+## Implementation Checklist
+
+- Redefine `tellask_result_record` as the single business result record.
+- Remove `tellask_call_result_record`.
+- Remove `tellask_response_record`.
+- Rename carryover record/msg/evt to shorter names.
+- Replace old tellask result event split with unified `tellask_result_evt`.
+- Update replay and restore to rebuild unified tellask result messages.
+- Update frontend to render tellask results as separate bubbles.
+- Keep call-site lifecycle status, but stop depending on inline result body.
+- Route askHuman answer flow through tellask result rendering instead of normal user-bubble
+  persistence.
+- Revisit provider projection after the business model is in place, not before.
+
+## Review Standard For This Refactor
+
+Behavior review should focus on current product semantics, not historical storage compatibility.
+
+Primary questions:
+
+- Does the user now see one coherent tellask result model?
+- Are local tellask failures and sideline tellask responses rendered the same way?
+- Does askHuman now behave like tellask instead of like an unrelated user-message path?
+- Does carryover remain special without polluting the unified tellask result model?
+- Did we remove result-path branching instead of just moving it around?

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

@@ -787,6 +787,18 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingChunk(content);
     await dlg.sayingFinish();
 }
+function resolveFuncToolFollowupMode(tool) {
+    return tool?.followupMode ?? 'immediate';
+}
+function shouldImmediatelyFollowUpSuccessfulToolResult(tool) {
+    return resolveFuncToolFollowupMode(tool) === 'immediate';
+}
+function shouldImmediatelyFollowUpToolOutcome(tool, outcome) {
+    if (outcome === 'failure' || outcome === 'partial_failure') {
+        return true;
+    }
+    return shouldImmediatelyFollowUpSuccessfulToolResult(tool);
+}
 async function executeFunctionCalls(args) {
     const functionPromises = args.funcCalls.map(async (func) => {
         throwIfAborted(args.abortSignal, args.dlg);
@@ -796,19 +808,23 @@ async function executeFunctionCalls(args) {
         const preparedInvocationArgs = tool !== undefined ? (0, tool_1.resolveFuncToolInvocationArguments)(tool, argsStr) : null;
         await args.dlg.funcCallRequested(func.id, func.name, argsStr);
         let result;
+        let outcome = 'success';
         let rethrowError;
         if (!tool) {
+            outcome = 'failure';
+            const output = (0, tool_1.toolFailure)(`Tool '${func.name}' not found`);
             result = {
                 type: 'func_result_msg',
                 id: func.id,
                 name: func.name,
-                content: `Tool '${func.name}' not found`,
+                content: output.content,
                 role: 'tool',
                 genseq: callGenseq,
             };
         }
         else {
             if (!preparedInvocationArgs || !preparedInvocationArgs.ok) {
+                outcome = 'failure';
                 const errorText = preparedInvocationArgs?.error ?? 'Arguments could not be prepared for tool invocation';
                 log_1.log.warn('kernel-driver rejected function call arguments before execution', undefined, {
                     funcName: func.name,
@@ -819,7 +835,7 @@ async function executeFunctionCalls(args) {
                     type: 'func_result_msg',
                     id: func.id,
                     name: func.name,
-                    content: `Invalid arguments: ${errorText}`,
+                    content: (0, tool_1.toolFailure)(`Invalid arguments: ${errorText}`).content,
                     role: 'tool',
                     genseq: callGenseq,
                 };
@@ -829,40 +845,36 @@ async function executeFunctionCalls(args) {
                     throwIfAborted(args.abortSignal, args.dlg);
                     const output = await tool.call(args.dlg, args.agent, preparedInvocationArgs.args);
                     throwIfAborted(args.abortSignal, args.dlg);
-                    const normalized = typeof output === 'string'
-                        ? { content: output, contentItems: undefined }
-                        : {
-                            content: typeof output.content === 'string' ? output.content : String(output),
-                            contentItems: Array.isArray(output.contentItems)
-                                ? output.contentItems
-                                : undefined,
-                        };
+                    outcome = output.outcome;
                     result = {
                         type: 'func_result_msg',
                         id: func.id,
                         name: func.name,
-                        content: String(normalized.content),
-                        contentItems: normalized.contentItems,
+                        content: output.content,
+                        contentItems: Array.isArray(output.contentItems) ? [...output.contentItems] : undefined,
                         role: 'tool',
                         genseq: callGenseq,
                     };
                 }
                 catch (err) {
+                    outcome = 'failure';
                     const errText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+                    const failureOutput = (0, tool_1.toolFailure)(`Function '${func.name}' execution failed: ${errText}`);
                     result = {
                         type: 'func_result_msg',
                         id: func.id,
                         name: func.name,
-                        content: `Function '${func.name}' execution failed: ${errText}`,
+                        content: failureOutput.content,
                         role: 'tool',
                         genseq: callGenseq,
                     };
                     if (args.abortSignal?.aborted || err instanceof KernelDriverInterruptedError) {
+                        const interruptedOutput = (0, tool_1.toolFailure)(`Function '${func.name}' interrupted before completion: ${errText}`);
                         result = {
                             type: 'func_result_msg',
                             id: func.id,
                             name: func.name,
-                            content: `Function '${func.name}' interrupted before completion: ${errText}`,
+                            content: interruptedOutput.content,
                             role: 'tool',
                             genseq: callGenseq,
                         };
@@ -875,14 +887,14 @@ async function executeFunctionCalls(args) {
         if (rethrowError !== undefined) {
             throw rethrowError;
         }
-        return result;
+        return { outcome, result };
     });
     return await Promise.all(functionPromises);
 }
 async function executeFunctionRound(args) {
     if (args.funcCalls.length === 0) {
         return {
-            hadNormalToolCalls: false,
+            hasImmediateFollowupToolCalls: false,
             shouldStopAfterReplyTool: false,
             pairedMessages: [],
             tellaskToolOutputs: [],
@@ -910,13 +922,25 @@ async function executeFunctionRound(args) {
         callbacks: args.callbacks,
     });
     throwIfAborted(args.abortSignal, args.dlg);
-    const genericResults = await executeFunctionCalls({
+    const genericExecutions = await executeFunctionCalls({
         dlg: args.dlg,
         agent: args.agent,
         agentTools: args.agentTools,
         funcCalls: tellaskRound.normalCalls,
         abortSignal: args.abortSignal,
     });
+    const funcToolByName = new Map(args.agentTools
+        .filter((tool) => tool.type === 'func')
+        .map((tool) => [tool.name, tool]));
+    const genericOutcomeByCallId = new Map(genericExecutions.map((execution) => [execution.result.id, execution.outcome]));
+    const hasImmediateFollowupToolCalls = tellaskRound.normalCalls.some((call) => {
+        const tool = funcToolByName.get(call.name);
+        const outcome = genericOutcomeByCallId.get(call.id);
+        if (outcome === undefined) {
+            throw new Error(`kernel-driver function outcome invariant violation: missing outcome for call id '${call.id}' (${call.name})`);
+        }
+        return shouldImmediatelyFollowUpToolOutcome(tool, outcome);
+    });
     const resultByCallId = new Map();
     const register = (result) => {
         const existing = resultByCallId.get(result.id);
@@ -928,8 +952,8 @@ async function executeFunctionRound(args) {
     for (const result of tellaskRound.tellaskResults) {
         register(result);
     }
-    for (const result of genericResults) {
-        register(result);
+    for (const execution of genericExecutions) {
+        register(execution.result);
     }
     const pairedMessages = [];
     const tellaskCallMsgById = new Map(tellaskRound.tellaskCallMessages.map((msg) => [msg.id, msg]));
@@ -961,7 +985,7 @@ async function executeFunctionRound(args) {
         throw new Error(`kernel-driver function result invariant violation: missing result for call id '${call.id}' (${call.name})`);
     }
     return {
-        hadNormalToolCalls: tellaskRound.normalCalls.length > 0,
+        hasImmediateFollowupToolCalls,
         shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         pairedMessages,
         tellaskToolOutputs: [...tellaskRound.toolOutputs],
@@ -1900,19 +1924,18 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 // Tool execution may have created pending Q4H/subdialogs mid-round. Respect the
                 // dialog's actual suspension state here so auto-continue is decided in one place.
                 const suspensionAfterToolRound = await dlg.getSuspensionStatus({
-                    allowPendingSubdialogs: routed.hadNormalToolCalls,
+                    allowPendingSubdialogs: routed.hasImmediateFollowupToolCalls,
                 });
                 if (!suspensionAfterToolRound.canDrive) {
                     await resetDiligenceBudgetAfterQ4H(dlg, team);
                     break;
                 }
-                // Continue only when this round produced new context that must be fed back into the next
-                // LLM turn. Provider-native side-channel UI events are meaningful output, but they are not
-                // transcript/context inputs and therefore must not trigger another generation round.
-                const shouldContinue = streamedFuncCalls.length > 0 ||
-                    routed.pairedMessages.length > 0 ||
-                    routed.tellaskToolOutputs.length > 0;
-                if (!shouldContinue) {
+                // Start an immediate post-tool generation only when this round produced tool outputs that
+                // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
+                // meaningful output, but they are not transcript/context inputs and therefore must not
+                // trigger another immediate generation round by themselves.
+                const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls || routed.tellaskToolOutputs.length > 0;
+                if (!shouldStartImmediatePostToolGeneration) {
                     const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
                         dlg,
                         providerCfg,
@@ -1939,7 +1962,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     }
                     break;
                 }
-                if (shouldContinue) {
+                if (shouldStartImmediatePostToolGeneration) {
                     continue;
                 }
             }

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

@@ -1,6 +1,6 @@
 import type { LanguageCode } from '@longrun-ai/kernel/types/language';
 import type { DialogFbrState } from '@longrun-ai/kernel/types/storage';
-import type { FuncTool } from '../../tool';
+import { type FuncTool } from '../../tool';
 import type { ChatMessage } from '../client';
 export declare const FBR_LOW_NOISE_CONCLUSION_TOOL_NAME = "presentLowNoiseHighlyInformativeConclusion";
 export declare const FBR_UNREASONABLE_SITUATION_TOOL_NAME = "presentUnreasonableSituation";

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

@@ -16,6 +16,7 @@ exports.advanceFbrState = advanceFbrState;
 exports.buildFbrPromptForState = buildFbrPromptForState;
 const fbr_body_1 = require("../../runtime/fbr-body");
 const inter_dialog_format_1 = require("../../runtime/inter-dialog-format");
+const tool_1 = require("../../tool");
 exports.FBR_LOW_NOISE_CONCLUSION_TOOL_NAME = 'presentLowNoiseHighlyInformativeConclusion';
 exports.FBR_UNREASONABLE_SITUATION_TOOL_NAME = 'presentUnreasonableSituation';
 function buildFbrConclusionToolDescription(args) {
@@ -40,7 +41,7 @@ function extractFbrConclusionToolArgs(rawArgs) {
     return { content: normalized };
 }
 async function callFbrConclusionTool(_dlg, _caller, rawArgs) {
-    return extractFbrConclusionToolArgs(rawArgs).content;
+    return (0, tool_1.toolSuccess)(extractFbrConclusionToolArgs(rawArgs).content);
 }
 function buildFbrConclusionTools(language) {
     return [