@flowdesk/opencode-plugin 0.1.13 → 0.1.15

package/dist/server.js

@@ -4,18 +4,23 @@ import { join, resolve, sep } from "node:path";
 import { applyFlowDeskSessionEvidenceWriteIntentsV1, createFlowDeskChatHookAuthorityProbeV1, evaluateFlowDeskChatIntakeV1, getFlowDeskPortableCommandToolName, getRelease1SchemaArtifact, materializeFlowDeskExactModelCacheEvidenceFromProviderAcquisitionEvidenceV1, materializeFlowDeskRuntimeLaneLaunchPlansFromReviewerFanoutEvidenceV1, planFlowDeskReviewerFanoutFromReloadedCacheEvidenceV1, prepareFlowDeskSessionEvidenceWriteIntentV1, reloadFlowDeskSessionEvidenceV1, validateFlowDeskDefaultManagedDispatchAuthorizationV1, validateProjectConfigV1, validateRunRequestV1, } from "@flowdesk/core";
 import { tool, } from "@opencode-ai/plugin";
 import { flowdeskPluginId, flowdeskPluginScaffold, hasProductionOpenCodeRegistration, } from "./index.js";
+import { observeFlowDeskOpenCodeEventV1 } from "./event-hook-observer.js";
 import { recordFlowDeskLaneHeartbeatV1, } from "./lane-heartbeat-writer.js";
 import { createFlowDeskLocalNonDispatchAdapterSession, flowdeskLocalNonDispatchAdapterProfile, hasFlowDeskLocalPlanningEvidenceV1, } from "./local-adapter.js";
-import { createFlowDeskManagedDispatchBetaDurableReservationStoreV1, createFlowDeskOpenCodeMetadataProviderAcquisitionClientV1, createFlowDeskOpenCodePromptBackedProviderAcquisitionClientV1, dispatchManagedDispatchBetaPromptV1, materializeFlowDeskManagedFallbackRegatePlanEvidenceV1, orchestrateFlowDeskManagedFallbackRegateV1, runFlowDeskExactModelProviderAcquisitionLiveTestV1, } from "./managed-dispatch-adapter.js";
+import { createFlowDeskManagedDispatchBetaDurableReservationStoreV1, createFlowDeskOpenCodeMetadataProviderAcquisitionClientV1, createFlowDeskOpenCodePromptBackedProviderAcquisitionClientV1, dispatchManagedDispatchBetaPromptV1, observeAndFinalizeManagedDispatchLaneV1, materializeFlowDeskManagedFallbackRegatePlanEvidenceV1, orchestrateFlowDeskManagedFallbackRegateV1, runFlowDeskExactModelProviderAcquisitionLiveTestV1, } from "./managed-dispatch-adapter.js";
 import { executeFlowDeskProviderUsageLiveV1, } from "./provider-usage-live-tool.js";
+import { formatFlowDeskTuiUsageSnapshotCompactText, loadFlowDeskTuiUsageSnapshotViewV1, } from "./tui-usage-snapshot.js";
 import { executeFlowDeskQuickFallbackRunV1, } from "./quick-fallback-run.js";
 import { executeFlowDeskQuickReviewerRunV1, } from "./quick-reviewer-run.js";
 import { executeFlowDeskRuntimeReviewerExecutionBridgeV1, redactedRuntimeReviewerExecutionBlocked, runtimeReviewerExecutionExpectationsFromValue, } from "./runtime-reviewer-execution-bridge.js";
 import { executeFlowDeskAgentTaskV1 } from "./agent-task-runner.js";
+import { executeFlowDeskAutoContinuePreviewToolV1, } from "./auto-continue-preview-tool.js";
 import { executeFlowDeskControlledWriteApplyToolV1, } from "./controlled-write-tool.js";
 import { executeFlowDeskStatusLiveV1, } from "./status-live-tool.js";
 import { executeFlowDeskWorkflowDispatchPlanToolV1, } from "./workflow-dispatch-plan-tool.js";
 import { executeFlowDeskWorkflowDispatchToolV1, } from "./workflow-dispatch-tool.js";
+import { executeFlowDeskWorkflowOrchestratorV1 } from "./workflow-orchestrator.js";
+import { executeFlowDeskWorkflowSynthesisPreviewV1 } from "./workflow-synthesis-tool.js";
 import { evaluateGuardedAutoAbortHookV1, evaluateGuardedAutoRetryHookV1, reconcileStalePendingRetryPlansV1, checkSdkSessionApiHealthV1, runFlowDeskWatchdogCycleV1, } from "./stall-recovery.js";
 import { withTimeout, FlowDeskTimeoutError } from "./shared/with-timeout.js";
 import { FLOWDESK_PRE_SPIKE_PLUGIN_TOOL_STUBS, getFlowDeskRelease1HandlerReadinessSummary, getFlowDeskRelease1ProductionReadinessSummary, hasPassingFds1SchemaConversionSpike, runFlowDeskPreSpikePluginToolStub, } from "./tool-stubs.js";
@@ -40,10 +45,12 @@ export const flowdeskLaneHeartbeatWriterOption = "laneHeartbeatWriter";
 export const flowdeskWorkflowDispatchPlanToolOption = "workflowDispatchPlanTool";
 export const flowdeskWorkflowDispatchOption = "workflowDispatch";
 export const flowdeskControlledWriteApplyOption = "controlledWriteApply";
+export const flowdeskUiProbeOption = "uiProbe";
 export const flowdeskDefaultManagedDispatchAuthorizationOption = "defaultManagedDispatchAuthorization";
 export const flowdeskWatchdogOption = "watchdog";
 export const flowdeskWatchdogTriggerToolName = "flowdesk_watchdog_trigger";
 export const flowdeskManagedDispatchBetaToolName = "flowdesk_managed_dispatch_beta";
+export const flowdeskManagedDispatchLaneFinalizeToolName = "flowdesk_managed_dispatch_lane_finalize";
 export const flowdeskExactModelProviderAcquisitionLiveTestToolName = "flowdesk_exact_model_provider_acquisition_live_test";
 export const flowdeskRuntimeReviewerExecutionToolName = "flowdesk_runtime_reviewer_execution";
 export const flowdeskManagedFallbackRegateToolName = "flowdesk_managed_fallback_regate";
@@ -57,6 +64,9 @@ export const flowdeskWorkflowDispatchToolName = "flowdesk_workflow_dispatch";
 export const flowdeskControlledWriteApplyToolName = "flowdesk_controlled_write_apply";
 export const flowdeskAgentTaskRunOption = "agentTaskRun";
 export const flowdeskAgentTaskRunToolName = "flowdesk_agent_task_run";
+export const flowdeskWorkflowSynthesisPreviewToolName = "flowdesk_workflow_synthesis_preview";
+export const flowdeskAutoContinuePreviewToolName = "flowdesk_auto_continue_preview";
+export const flowdeskUiProbeToolName = "flowdesk_ui_probe";
 const flowdeskChatSuggestionDuplicateWindowMs = 10_000;
 const disabledAuthority = {
     productionRegistrationEligible: false,
@@ -537,6 +547,15 @@ function redactedManagedDispatchBetaToolResult(result) {
                 sessionId: result.sessionId,
                 agent: result.agent,
                 model: result.model,
+                ...(!("laneId" in result) || result.laneId === undefined
+                    ? {}
+                    : { laneId: result.laneId }),
+                ...(!("childSessionRef" in result) || result.childSessionRef === undefined
+                    ? {}
+                    : { childSessionRef: result.childSessionRef }),
+                ...(!("messageRef" in result) || result.messageRef === undefined
+                    ? {}
+                    : { messageRef: result.messageRef }),
                 ...("redactedErrorCategory" in result
                     ? { redactedErrorCategory: result.redactedErrorCategory }
                     : {}),
@@ -886,6 +905,9 @@ async function evaluateFlowDeskManagedDispatchRunRoute(request, options = {}) {
         ...(options.reservationStore === undefined
             ? {}
             : { reservationStore: options.reservationStore }),
+        ...(options.durableStateRootDir === undefined
+            ? {}
+            : { durableStateRootDir: options.durableStateRootDir }),
     });
     return {
         runRouteProfile: "flowdesk_run_default_managed_dispatch_route",
@@ -944,10 +966,46 @@ export function createFlowDeskManagedDispatchBetaOptInTools(client, reservationS
                     dispatchManifest: record.dispatchManifest,
                     ...(reloadedEvidence === undefined ? {} : { reloadedEvidence }),
                     ...(reservationStore === undefined ? {} : { reservationStore }),
+                    ...(durableStateRootDir === undefined ? {} : { durableStateRootDir }),
                 });
                 return JSON.stringify(redactedManagedDispatchBetaToolResult(result));
             },
         }),
+        [flowdeskManagedDispatchLaneFinalizeToolName]: tool({
+            description: "FlowDesk managed-dispatch lane finalize observer; reads a launched managed-dispatch lane's child session once and records terminal task_result + lane_lifecycle evidence. Observation-only: never nudges, aborts, or enables dispatch/provider/runtime/fallback authority.",
+            args: {
+                workflowId: tool.schema.string().describe("Workflow id that owns the managed-dispatch lane."),
+                laneId: tool.schema.string().describe("Lane id of the launched managed-dispatch lane."),
+                attemptId: tool.schema.string().describe("Attempt id bound to the lane."),
+                childSessionId: tool.schema.string().describe("Child session id to observe (raw OpenCode id)."),
+                agentRef: tool.schema.string().describe("Agent ref bound to the lane."),
+                providerQualifiedModelId: tool.schema.string().describe("Concrete provider-qualified model id for the lane."),
+                parentSessionRef: tool.schema.string().optional().describe("Optional parent ses- ref for lifecycle evidence."),
+            },
+            async execute(input) {
+                const record = isRecord(input) ? input : {};
+                if (durableStateRootDir === undefined) {
+                    return JSON.stringify({
+                        adapterProfile: "managed_dispatch_lane_finalize_observer",
+                        status: "blocked_before_finalize",
+                        redactedBlockReason: "managed-dispatch lane finalize requires a configured durable state root.",
+                        authority: { ...disabledAuthority, toolAuthority: false },
+                    });
+                }
+                const result = await observeAndFinalizeManagedDispatchLaneV1({
+                    client,
+                    rootDir: durableStateRootDir,
+                    workflowId: String(record.workflowId ?? ""),
+                    laneId: String(record.laneId ?? ""),
+                    attemptId: String(record.attemptId ?? ""),
+                    childSessionId: String(record.childSessionId ?? ""),
+                    agentRef: String(record.agentRef ?? "agent-managed-dispatch"),
+                    providerQualifiedModelId: String(record.providerQualifiedModelId ?? "unknown/unknown"),
+                    ...(typeof record.parentSessionRef === "string" ? { parentSessionRef: record.parentSessionRef } : {}),
+                });
+                return JSON.stringify(result);
+            },
+        }),
     };
 }
 export function createFlowDeskExactModelProviderAcquisitionLiveTestOptInTools(client, rootDir, cacheMaterialization, runtimeReviewerExecutionClient) {
@@ -1175,9 +1233,11 @@ export function createFlowDeskExactModelProviderAcquisitionLiveTestOptInTools(cl
         }),
     };
 }
-export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Date(), session = createFlowDeskLocalNonDispatchAdapterSession(now), stallAlert, durableSuggestionRoot) {
+export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Date(), session = createFlowDeskLocalNonDispatchAdapterSession(now), stallAlert, durableSuggestionRoot, providerUsageLiveConfig) {
     const recentSuggestionCards = new Map();
     const recentStallAlerts = new Map();
+    const usageAutoRefreshMaxAgeMs = 3 * 60_000;
+    let lastUsageRefreshAttemptAtMs = 0;
     return async function message(input, output) {
         const inputRecord = isRecord(input) ? input : {};
         const partSessionID = typeof inputRecord.sessionID === "string" ? inputRecord.sessionID : "";
@@ -1192,6 +1252,40 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
         const request = intakeRequestFromChatMessage({ ...inputRecord, ...output });
         const preview = previewNaturalLanguageRouting(request, session);
         const nowMs = clockMs(now);
+        if (providerUsageLiveConfig?.durableStateRootDir && nowMs - lastUsageRefreshAttemptAtMs > 30_000) {
+            lastUsageRefreshAttemptAtMs = nowMs;
+            let isStale = false;
+            try {
+                const cachePath = join(providerUsageLiveConfig.durableStateRootDir, ".flowdesk", "ui", "provider-usage-sidebar.json");
+                const cacheContent = JSON.parse(readFileSync(cachePath, "utf8"));
+                if (typeof cacheContent.observed_at === "string" && nowMs - Date.parse(cacheContent.observed_at) > usageAutoRefreshMaxAgeMs)
+                    isStale = true;
+            }
+            catch {
+                isStale = true;
+            }
+            if (isStale) {
+                try {
+                    await executeFlowDeskProviderUsageLiveV1({ config: { ...providerUsageLiveConfig, persistSidebarCache: true }, request: { providerFamily: "all" } });
+                }
+                catch { }
+            }
+        }
+        const usageTextToAppend = providerUsageLiveConfig?.durableStateRootDir &&
+            providerUsageLiveConfig.appendToChat === true
+            ? formatFlowDeskTuiUsageSnapshotCompactText(loadFlowDeskTuiUsageSnapshotViewV1({
+                rootDir: providerUsageLiveConfig.durableStateRootDir,
+                workflowId: providerUsageLiveConfig.persistWorkflowId,
+                now: () => (typeof now === "function" ? now() : now),
+            }))
+            : undefined;
+        const appendUsageCard = () => {
+            if (usageTextToAppend === undefined)
+                return;
+            if (!Array.isArray(output.parts))
+                output.parts = [];
+            output.parts.push(buildTextPart(usageTextToAppend));
+        };
         for (const [key, recordedAtMs] of recentSuggestionCards) {
             if (nowMs - recordedAtMs > flowdeskChatSuggestionDuplicateWindowMs ||
                 nowMs < recordedAtMs)
@@ -1228,7 +1322,8 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
                 summary.totalLate > 0;
             const progressCardReady = stallAlert?.includeProgressCards === true &&
                 summary.workflowSummaries.some((workflow) => (workflow.laneCards?.length ?? 0) > 0);
-            if (stalledAlertReady || lateAlertReady || progressCardReady) {
+            const autoNextReady = summary.workflowSummaries.some((workflow) => workflow.autoNextReady === true);
+            if (stalledAlertReady || lateAlertReady || progressCardReady || autoNextReady) {
                 stallDedupKey = stallAlertDuplicateKey(request, summary);
                 stallTextToAppend = stallAlertText(summary);
             }
@@ -1246,6 +1341,7 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
             }
         };
         if (preview.evaluation.response.route_decision === "continue_chat") {
+            appendUsageCard();
             appendStallCard();
             return;
         }
@@ -1256,13 +1352,16 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
             recentSuggestionCards.set(duplicateKey, nowMs);
             writeDurableSuggestionPreference(durableSuggestionRoot, duplicateKey, request, preview.evaluation.response, nowMs);
             if (previousAtMs !== undefined &&
-                nowMs - previousAtMs <= flowdeskChatSuggestionDuplicateWindowMs)
+                nowMs - previousAtMs <= flowdeskChatSuggestionDuplicateWindowMs) {
+                appendUsageCard();
                 return;
+            }
         }
         const result = evaluateNaturalLanguageRouting(request, session);
         if (!Array.isArray(output.parts))
             output.parts = [];
         output.parts.push(buildTextPart(steeringText(result)));
+        appendUsageCard();
         appendStallCard();
     };
 }
@@ -1361,12 +1460,14 @@ export async function collectStallAlertResult(stallAlert, clock, deps = {}) {
             const stalledEntry = scopedEntries.find((entry) => entry.classification === "stalled");
             const lateEntry = scopedEntries.find((entry) => entry.classification === "progressing_late");
             const primary = stalledEntry ?? lateEntry;
-            const scopedLaneCards = (workflow.laneProgressCards ?? []).filter((lane) => lane.classification !== "terminal" &&
+            const autoNextReady = workflow.laneProgressAggregate?.autoNextStepEligible === true;
+            const scopedLaneCards = (workflow.laneProgressCards ?? []).filter((lane) => (autoNextReady || lane.classification !== "terminal") &&
                 laneInCurrentSession(lane.laneId));
             const scopedStalledCount = scopedEntries.filter((entry) => entry.classification === "stalled").length;
             const scopedLateCount = scopedEntries.filter((entry) => entry.classification === "progressing_late").length;
             const shouldShowWorkflow = scopedStalledCount > 0 ||
                 (stallAlert.includeProgressingLate === true && scopedLateCount > 0) ||
+                (autoNextReady && scopedLaneCards.length > 0) ||
                 (stallAlert.includeProgressCards === true && scopedLaneCards.length > 0);
             if (!shouldShowWorkflow)
                 return undefined;
@@ -1443,18 +1544,36 @@ export async function collectStallAlertResult(stallAlert, clock, deps = {}) {
                 ...(primary?.failureHint === undefined
                     ? {}
                     : { failureHint: primary.failureHint }),
+                ...(workflow.laneProgressAggregate === undefined
+                    ? {}
+                    : { laneProgressAggregate: workflow.laneProgressAggregate }),
+                ...(autoNextReady ? { autoNextReady: true } : {}),
+                ...(workflow.latestWorkflowSynthesisTasksSummarized === undefined
+                    ? {}
+                    : { synthesisTasksSummarized: workflow.latestWorkflowSynthesisTasksSummarized }),
+                ...(workflow.latestWorkflowSynthesisConflictDetected === undefined
+                    ? {}
+                    : { synthesisConflictDetected: workflow.latestWorkflowSynthesisConflictDetected }),
                 ...(stallAlert.includeProgressCards === true
                     ? {
                         laneCards: scopedLaneCards
                             .slice(0, stallAlert.maxProgressCards ?? 3)
                             .map((lane) => ({
                             laneId: lane.laneId,
+                            taskId: lane.taskId,
                             state: lane.state,
                             classification: lane.classification,
                             secondsSinceLastSignal: lane.secondsSinceLastSignal,
                             agentRef: lane.agentRef,
                             providerQualifiedModelId: lane.providerQualifiedModelId,
+                            promptPreview: lane.promptPreview,
+                            nudgeCount: lane.nudgeCount,
+                            progressPhase: lane.progressPhase,
+                            progressLabel: lane.progressLabel,
                             verdictLabel: lane.verdictLabel,
+                            completionStatus: lane.completionStatus,
+                            outputKind: lane.outputKind,
+                            usableForSynthesis: lane.usableForSynthesis,
                             failureHint: lane.failureHint,
                         })),
                     }
@@ -1524,6 +1643,9 @@ function stallAlertText(summary) {
     else if (summary.worstClassification === "progressing_late") {
         lines.push(`Late-progressing lanes detected: ${summary.totalLate} late, ${summary.totalStalled} stalled.`);
     }
+    else if (summary.workflowSummaries.some((workflow) => workflow.autoNextReady === true)) {
+        lines.push("All FlowDesk subtasks completed normally. Auto-next synthesis is ready.");
+    }
     else if (progressCardCount > 0) {
         lines.push(`Lane progress: ${progressCardCount} lane(s) visible on the main screen.`);
     }
@@ -1534,19 +1656,56 @@ function stallAlertText(summary) {
         const secs = workflow.secondsSinceLastSignal ?? 0;
         const minutes = Math.floor(secs / 60);
         const hint = workflow.failureHint ?? "no recent heartbeat";
-        const counts = workflow.stalledLaneCount > 0
-            ? `${workflow.stalledLaneCount} stalled`
-            : `${workflow.lateLaneCount} progressing-late`;
-        lines.push(`- workflow ${workflow.workflowId}: ${counts} (last signal ~${minutes}m ago, ${hint}).`);
+        if (workflow.autoNextReady === true) {
+            const synthesis = workflow.synthesisTasksSummarized === undefined
+                ? "synthesis not yet recorded"
+                : `synthesis recorded for ${workflow.synthesisTasksSummarized} task(s)`;
+            const conflict = workflow.synthesisConflictDetected === undefined
+                ? " conflict=unknown"
+                : workflow.synthesisConflictDetected === true ? " conflict=true" : " conflict=false";
+            const nextAction = workflow.laneProgressAggregate?.nextActionAvailable === true
+                ? ` next_action=${workflow.laneProgressAggregate.nextActionKind ?? "available"}_ready`
+                : "";
+            lines.push(`- workflow ${workflow.workflowId}: auto-next ready (${synthesis},${conflict}${nextAction}).`);
+        }
+        else {
+            const counts = workflow.stalledLaneCount > 0
+                ? `${workflow.stalledLaneCount} stalled`
+                : `${workflow.lateLaneCount} progressing-late`;
+            lines.push(`- workflow ${workflow.workflowId}: ${counts} (last signal ~${minutes}m ago, ${hint}).`);
+        }
+        if (workflow.laneProgressAggregate !== undefined) {
+            const aggregate = workflow.laneProgressAggregate;
+            const nextAction = aggregate.nextActionAvailable === true
+                ? `, next_action=${aggregate.nextActionKind ?? "available"}_ready`
+                : "";
+            lines.push(`  tasks: expected=${aggregate.expected}, terminal=${aggregate.terminal}, completed=${aggregate.normalCompleted}, failed=${aggregate.failed}, awaiting_permission=${aggregate.awaitingPermission}, auto_next=${aggregate.autoNextStepEligible}${nextAction}`);
+        }
         for (const lane of workflow.laneCards?.slice(0, 3) ?? []) {
             const age = lane.secondsSinceLastSignal === undefined
                 ? "unknown"
                 : `~${Math.floor(lane.secondsSinceLastSignal / 60)}m ago`;
             const model = lane.providerQualifiedModelId ?? "(unknown)";
             const agent = lane.agentRef ?? "(unknown)";
+            const task = lane.taskId ?? lane.laneId;
+            const prompt = lane.promptPreview ?? "(hidden)";
+            const nudge = lane.nudgeCount === undefined ? "?" : String(lane.nudgeCount);
+            const progress = lane.progressLabel === undefined
+                ? "(none)"
+                : `${lane.progressPhase ?? "progress"}: ${lane.progressLabel}`;
             const verdict = lane.verdictLabel ?? "(none)";
+            const resultQuality = lane.completionStatus === undefined && lane.outputKind === undefined && lane.usableForSynthesis === undefined
+                ? "(none)"
+                : `${lane.completionStatus ?? "unknown"}/${lane.outputKind ?? "unknown"}/synthesis=${lane.usableForSynthesis === undefined ? "unknown" : String(lane.usableForSynthesis)}`;
             const issue = lane.failureHint === undefined ? "" : ` issue=${lane.failureHint}`;
-            lines.push(`  - lane ${lane.laneId}: ${lane.state ?? "unknown"}/${lane.classification}, last signal ${age}, agent=${agent}, model=${model}, verdict=${verdict}${issue}`);
+            lines.push(`  - lane ${lane.laneId}: ${lane.state ?? "unknown"}/${lane.classification}`);
+            lines.push(`    task: ${task}`);
+            lines.push(`    prompt: ${prompt}`);
+            lines.push(`    agent: ${agent}`);
+            lines.push(`    model: ${model}`);
+            lines.push(`    progress: ${progress}`);
+            lines.push(`    result: ${resultQuality}`);
+            lines.push(`    last signal: ${age}; nudges=${nudge}; verdict=${verdict}${issue}`);
         }
     }
     if (summary.autoAbortSummaries !== undefined && summary.autoAbortSummaries.length > 0) {
@@ -2074,6 +2233,32 @@ export function createFlowDeskAgentTaskRunOptInTools(input) {
         return undefined;
     const client = input.client;
     const rootDir = input.durableStateRoot;
+    const promptPreview = (text, max = 120) => {
+        const compact = text.replace(/\s+/g, " ").trim();
+        return compact.length > max ? `${compact.slice(0, max - 1)}…` : compact;
+    };
+    const taskSummaryForUser = (input) => {
+        const lines = [
+            input.status === "task_completed"
+                ? "FlowDesk task completed."
+                : input.status === "task_launched"
+                    ? "FlowDesk task launched."
+                    : "FlowDesk task failed.",
+            `workflow: ${input.workflowId}`,
+            `lane: ${input.laneId}`,
+            `task: ${input.taskId}`,
+            `prompt: ${promptPreview(input.promptText)}`,
+            `agent: ${input.agentName}`,
+            `model: ${input.providerQualifiedModelId}`,
+        ];
+        if (input.asyncMode === true)
+            lines.push("progress: use /flowdesk-status or flowdesk_status_live to follow durable lane evidence");
+        if (input.resultText !== undefined)
+            lines.push(`result: ${promptPreview(input.resultText, 200)}`);
+        if (input.failureCategory !== undefined)
+            lines.push(`failure: ${input.failureCategory}${input.redactedReason === undefined ? "" : ` (${input.redactedReason})`}`);
+        return lines.join("\n");
+    };
     return {
         [flowdeskAgentTaskRunToolName]: tool({
             description: [
@@ -2081,7 +2266,7 @@ export function createFlowDeskAgentTaskRunOptInTools(input) {
                 "Use this to delegate a well-defined subtask to a specific model (e.g. Claude Opus for security analysis, GPT for architecture review).",
                 "Requires developerModeAcknowledged=true and allowProviderCall=true per call.",
                 "WHEN TO USE: user asks to delegate a specific task to a specific model/agent.",
-                "WHEN NOT TO USE: multi-step workflows (use flowdesk_workflow_dispatch), code review (use flowdesk_quick_reviewer_run).",
+                "WHEN NOT TO USE: multi-step workflows (use flowdesk_workflow_dispatch).",
                 "After calling, use flowdesk_status_live to check the lane status.",
             ].join(" "),
             args: {
@@ -2092,6 +2277,8 @@ export function createFlowDeskAgentTaskRunOptInTools(input) {
                 parentSessionId: tool.schema.string().optional().describe("Parent session id"),
                 developerModeAcknowledged: tool.schema.boolean(),
                 allowProviderCall: tool.schema.boolean(),
+                nudgeQuietPeriodMs: tool.schema.number().optional().describe("Milliseconds of silence before sending a nudge prompt. Default 10000ms (10s). Recommended: always pass 10000. At 10s silence → nudge 1, 20s → nudge 2, 30s+ → lane fails and watchdog retries."),
+                asyncMode: tool.schema.boolean().optional().describe("When true, return laneId immediately after launch. Watchdog polls child session, sends noReply nudges at 10s/20s, and aborts at 30s+. Coordinator uses flowdesk_status_live to detect completion. Recommended for all orchestration calls."),
             },
             async execute(args, ctx) {
                 const record = isRecord(args) ? args : {};
@@ -2111,6 +2298,9 @@ export function createFlowDeskAgentTaskRunOptInTools(input) {
                     : typeof ctxRecord.sessionID === "string" && ctxRecord.sessionID.length > 0
                         ? ctxRecord.sessionID
                         : "";
+                const nudgeQuietPeriodMs = typeof record.nudgeQuietPeriodMs === "number" && record.nudgeQuietPeriodMs > 0
+                    ? Math.floor(record.nudgeQuietPeriodMs) : undefined;
+                const asyncMode = record.asyncMode === true;
                 const taskId = `task-${Date.now().toString(36)}`;
                 const laneId = `lane-task-${Date.now().toString(36)}`;
                 const result = await executeFlowDeskAgentTaskV1({
@@ -2123,19 +2313,37 @@ export function createFlowDeskAgentTaskRunOptInTools(input) {
                     parentSessionId,
                     rootDir,
                     client,
+                    asyncMode,
+                    _nudgeQuietPeriodMs: nudgeQuietPeriodMs,
                 });
+                const failureCategory = result.status === "task_failed" ? result.failureCategory : undefined;
+                const redactedReason = result.status === "task_failed" ? result.redactedReason : undefined;
                 return JSON.stringify({
                     workflowId,
                     laneId,
                     taskId,
                     status: result.status,
+                    taskPreview: promptPreview(taskDescription),
+                    agentName,
+                    providerQualifiedModelId,
+                    ...(result.status === "task_launched" ? { childSessionId: result.childSessionId, asyncMode: true, safeNextActions: ["/flowdesk-status"] } : {}),
                     resultText: result.status === "task_completed" ? result.resultText.slice(0, 4_096) : undefined,
                     resultTruncated: result.status === "task_completed" && result.resultText.length > 4_096,
-                    failureCategory: result.status === "task_failed" ? result.failureCategory : undefined,
-                    redactedReason: result.status === "task_failed" ? result.redactedReason : undefined,
-                    summaryForUser: result.status === "task_completed"
-                        ? `Task completed on ${agentName} (${providerQualifiedModelId}). Result: ${result.resultText.slice(0, 200)}${result.resultText.length > 200 ? "..." : ""}`
-                        : `Task failed on ${agentName}: ${result.failureCategory}`,
+                    failureCategory,
+                    redactedReason,
+                    summaryForUser: taskSummaryForUser({
+                        status: result.status,
+                        workflowId,
+                        laneId,
+                        taskId,
+                        agentName,
+                        providerQualifiedModelId,
+                        promptText: taskDescription,
+                        ...(result.status === "task_completed" ? { resultText: result.resultText } : {}),
+                        ...(result.status === "task_launched" ? { asyncMode: true } : {}),
+                        ...(failureCategory === undefined ? {} : { failureCategory }),
+                        ...(redactedReason === undefined ? {} : { redactedReason }),
+                    }),
                 });
             },
         }),
@@ -2317,6 +2525,8 @@ function providerUsageLiveConfigFromOptions(options) {
         config.geminiProjectId = value.geminiProjectId;
     if (value.persistSnapshots === true)
         config.persistSnapshots = true;
+    if (value.appendToChat === true)
+        config.appendToChat = true;
     const explicitRoot = typeof value.durableStateRootDir === "string" &&
         value.durableStateRootDir.trim().length > 0
         ? value.durableStateRootDir
@@ -2474,6 +2684,67 @@ function controlledWriteApplyConfigFromOptions(input, options) {
     const workspaceRoot = optionWorkspaceRoot ?? inputWorkspaceRoot ?? process.cwd();
     return { durableStateRoot, workspaceRoot };
 }
+export const flowdeskOrchestrateToolName = "flowdesk_orchestrate";
+export const flowdeskOrchestrateOption = "workflowOrchestrate";
+function orchestrateToolConfigFromOptions(input, options) {
+    const value = options?.[flowdeskOrchestrateOption];
+    if (!isRecord(value) || value.enabled !== true || value.devBetaActualLaneLaunch !== true)
+        return undefined;
+    const explicitRoot = typeof value.rootDir === "string" && value.rootDir.trim().length > 0 ? value.rootDir : undefined;
+    const rootDir = explicitRoot ?? durableStateRootFromOptions(options);
+    if (rootDir === undefined)
+        return undefined;
+    const client = isRecord(input) && isManagedDispatchBetaClient(input.client) ? input.client : undefined;
+    return client === undefined ? undefined : { rootDir, client };
+}
+function createFlowDeskOrchestrateOptInTools(config) {
+    return {
+        [flowdeskOrchestrateToolName]: tool({
+            description: [
+                "Run a full FlowDesk multi-task orchestration: Author → Assign → Schedule → Synthesize.",
+                "WHEN TO USE: the user gives a natural-language goal that requires decomposing into multiple tasks, assigning agents/models based on provider usage, executing them in dependency order, and aggregating results.",
+                "INVOKE WITH: goalSummary (clear bounded goal text), parentSessionId, and optional workflowId.",
+                "AFTER CALLING: surface summaryForUser and report synthesisId, taskCount, conflictDetected. All authority flags remain false.",
+                "WHEN NOT TO USE: simple single-task requests, status checks, usage queries, or review fan-out.",
+            ].join(" "),
+            args: {
+                goalSummary: tool.schema.string().describe("Bounded natural-language goal for the workflow. Max 500 chars."),
+                parentSessionId: tool.schema.string().describe("Current OpenCode session id (ses-...)."),
+                workflowId: tool.schema.string().optional().describe("Optional stable workflow id. Auto-generated when omitted."),
+                providerQualifiedModelId: tool.schema.string().optional().describe("Concrete provider/model id for author and synthesis calls. Defaults to openai/gpt-5.5."),
+                agentName: tool.schema.string().optional().describe("Agent name for author and synthesis calls. Defaults to reviewer-gpt-frontier."),
+                developerModeAcknowledged: tool.schema.boolean().describe("Must be true to allow provider calls."),
+                allowProviderCall: tool.schema.boolean().describe("Must be true to allow provider calls."),
+                allowActualLaneLaunch: tool.schema.boolean().describe("Must be true to allow actual lane launch."),
+            },
+            async execute(input) {
+                if (!isRecord(input))
+                    return JSON.stringify({ status: "blocked_before_orchestration", summaryForUser: "invalid input", safeNextActions: ["/flowdesk-doctor"] });
+                if (input.developerModeAcknowledged !== true || input.allowProviderCall !== true || input.allowActualLaneLaunch !== true)
+                    return JSON.stringify({ status: "blocked_before_orchestration", summaryForUser: "developerModeAcknowledged, allowProviderCall, and allowActualLaneLaunch must all be true", safeNextActions: ["/flowdesk-doctor"] });
+                const goalSummary = typeof input.goalSummary === "string" ? input.goalSummary.slice(0, 500) : "";
+                if (!goalSummary.trim())
+                    return JSON.stringify({ status: "blocked_before_orchestration", summaryForUser: "goalSummary is required", safeNextActions: ["/flowdesk-doctor"] });
+                const parentSessionId = typeof input.parentSessionId === "string" ? input.parentSessionId : "";
+                if (!parentSessionId.trim())
+                    return JSON.stringify({ status: "blocked_before_orchestration", summaryForUser: "parentSessionId is required", safeNextActions: ["/flowdesk-doctor"] });
+                const providerQualifiedModelId = typeof input.providerQualifiedModelId === "string" ? input.providerQualifiedModelId : "openai/gpt-5.5";
+                const agentName = typeof input.agentName === "string" ? input.agentName : "reviewer-gpt-frontier";
+                const workflowId = typeof input.workflowId === "string" ? input.workflowId : undefined;
+                const result = await executeFlowDeskWorkflowOrchestratorV1({
+                    workflowId,
+                    goalSummary,
+                    parentSessionId,
+                    rootDir: config.rootDir,
+                    client: config.client,
+                    providerQualifiedModelId,
+                    agentName,
+                });
+                return JSON.stringify(result);
+            },
+        }),
+    };
+}
 export function createFlowDeskWorkflowDispatchPlanOptInTools(config) {
     return {
         [flowdeskWorkflowDispatchPlanToolName]: tool({
@@ -2516,6 +2787,33 @@ export function createFlowDeskWorkflowDispatchPlanOptInTools(config) {
         }),
     };
 }
+export function createFlowDeskAutoContinuePreviewOptInTools(config) {
+    return {
+        [flowdeskAutoContinuePreviewToolName]: tool({
+            description: [
+                "Preview the next pending task from durable FlowDesk workflow_dispatch_plan evidence without executing it.",
+                "WHEN TO USE: the user asks whether FlowDesk can continue remaining planned work or asks what would run next from a durable plan.",
+                "WHEN NOT TO USE: requests to actually dispatch, call a provider, launch a lane, fallback/reselect, mutate TUI/chat, or write files. This tool is preview-only and never performs continuation.",
+                "INVOKE WITH: workflowId and optional maxSteps. The configured durable state root is used. Todo source is durable workflow_dispatch_plan evidence only, not transient chat/todowrite state.",
+                "AFTER CALLING: surface summaryForUser, nextTaskId/title/summary, pendingTaskCount, and authority. Never claim automatic execution, dispatch, provider call, fallback, hard chat, or TUI action authority.",
+            ].join(" "),
+            args: {
+                workflowId: tool.schema.string().describe("Workflow id with durable workflow_dispatch_plan evidence."),
+                maxSteps: tool.schema.number().optional().describe("Bounded preview cap. Clamped to 1..5; no steps are executed."),
+            },
+            async execute(input) {
+                const result = executeFlowDeskAutoContinuePreviewToolV1({
+                    config,
+                    request: {
+                        workflowId: typeof input.workflowId === "string" ? input.workflowId : undefined,
+                        maxSteps: typeof input.maxSteps === "number" ? input.maxSteps : undefined,
+                    },
+                });
+                return JSON.stringify(result);
+            },
+        }),
+    };
+}
 export function createFlowDeskWorkflowDispatchOptInTools(config) {
     return {
         [flowdeskWorkflowDispatchToolName]: tool({
@@ -2769,6 +3067,134 @@ export function createFlowDeskStatusLiveOptInTools(config) {
         }),
     };
 }
+export function createFlowDeskWorkflowSynthesisPreviewTools(config) {
+    return {
+        [flowdeskWorkflowSynthesisPreviewToolName]: tool({
+            description: [
+                "Build and persist a provider-free FlowDesk synthesis preview from existing task_result evidence. This local tool never calls providers, launches lanes, dispatches runtime work, performs fallback/reselection, writes workspace files, or grants execution authority.",
+                "WHEN TO USE: a workflow reports next_action=synthesis_ready and the user asks to summarize, synthesize, continue with the next synthesis step, or see the completed task results without making a model/provider call.",
+                "WHEN NOT TO USE: requests for model-authored synthesis, real dispatch, provider calls, write/apply, fallback/retry, or replacing raw task results.",
+                "INVOKE WITH: workflowId for a workflow that already has task_result evidence under the configured durable root.",
+                "AFTER CALLING: surface summaryForUser, synthesisId, tasksSummarized, conflictDetected, safeNextActions, and authority. State that this is a provider-free preview derived from durable task_result evidence.",
+            ].join(" "),
+            args: {
+                workflowId: tool.schema.string().describe("Workflow id with existing task_result evidence to synthesize locally."),
+            },
+            async execute(input) {
+                const workflowId = isRecord(input) && typeof input.workflowId === "string" ? input.workflowId : "";
+                const result = executeFlowDeskWorkflowSynthesisPreviewV1({ workflowId, rootDir: config.rootDir });
+                return JSON.stringify(result);
+            },
+        }),
+    };
+}
+function isFlowDeskUiProbeEnabled(options) {
+    const raw = options?.[flowdeskUiProbeOption];
+    return process.env.FLOWDESK_UI_PROBE === "1" || raw === true || (isRecord(raw) && raw.enabled === true);
+}
+function boundedUiProbeString(value, maxLength = 160) {
+    if (typeof value !== "string" || value.length === 0)
+        return undefined;
+    return value.length > maxLength ? `${value.slice(0, maxLength - 1)}…` : value;
+}
+function summarizeFlowDeskUiProbeEventV1(event, observedAt) {
+    const rec = isRecord(event) ? event : {};
+    const properties = Object.keys(rec).sort().slice(0, 20);
+    const nested = (name) => {
+        const value = rec[name];
+        return isRecord(value) ? value : undefined;
+    };
+    const session = nested("session") ?? nested("sessionID") ?? nested("sessionId");
+    const message = nested("message");
+    const part = nested("part");
+    const sessionId = boundedUiProbeString(rec.sessionID) ??
+        boundedUiProbeString(rec.sessionId) ??
+        boundedUiProbeString(session?.id);
+    return {
+        observedAt,
+        eventType: boundedUiProbeString(rec.type, 120) ?? boundedUiProbeString(rec.event, 120) ?? "unknown",
+        ...(sessionId === undefined ? {} : { sessionId }),
+        ...(boundedUiProbeString(message?.id) === undefined ? {} : { messageId: boundedUiProbeString(message?.id) }),
+        ...(boundedUiProbeString(part?.id) === undefined ? {} : { partId: boundedUiProbeString(part?.id) }),
+        keys: properties,
+    };
+}
+function createFlowDeskUiProbeTools(observations) {
+    return {
+        [flowdeskUiProbeToolName]: tool({
+            description: [
+                "Developer-only FlowDesk UI renderer/event probe. Enabled only when FLOWDESK_UI_PROBE=1.",
+                "It emits bounded markdown/details/link/code-fence/long-log samples and reports redacted OpenCode event observations captured by the plugin event hook.",
+                "No dispatch, provider call, write authority, fallback authority, or hard chat control is granted.",
+            ].join(" "),
+            args: {
+                mode: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Probe mode: render, events, or all. Defaults to all."),
+                limit: tool.schema
+                    .number()
+                    .optional()
+                    .describe("Maximum recent event observations to return; clamped to 1..50."),
+            },
+            async execute(input) {
+                const mode = isRecord(input) && typeof input.mode === "string" ? input.mode : "all";
+                const requestedLimit = isRecord(input) && typeof input.limit === "number" ? Math.floor(input.limit) : 20;
+                const limit = Math.max(1, Math.min(50, requestedLimit));
+                const includeRender = mode === "all" || mode === "render";
+                const includeEvents = mode === "all" || mode === "events";
+                const longLog = Array.from({ length: 40 }, (_, index) => {
+                    const n = String(index + 1).padStart(2, "0");
+                    return `${n}. ui-probe timeline event ${n}: message/status/log renderer sample`;
+                });
+                return JSON.stringify({
+                    schema_version: "flowdesk.ui_probe_result.v1",
+                    status: "ui_probe_collected",
+                    probeEnabled: true,
+                    mode,
+                    authority: {
+                        realOpenCodeDispatch: false,
+                        providerCall: false,
+                        runtimeExecution: false,
+                        actualLaneLaunch: false,
+                        fallbackAuthority: false,
+                        hardCancelOrNoReplyAuthority: false,
+                    },
+                    ...(includeRender
+                        ? {
+                            renderSamples: {
+                                markdownDetails: [
+                                    "<details>",
+                                    "<summary>FlowDesk UI probe: details summary</summary>",
+                                    "",
+                                    "[FlowDesk markdown link probe](https://example.com/flowdesk-ui-probe)",
+                                    "",
+                                    "```text",
+                                    ...longLog.slice(0, 8),
+                                    "```",
+                                    "</details>",
+                                ].join("\n"),
+                                longLogText: ["FlowDesk UI probe long log", ...longLog].join("\n"),
+                                observationInstructions: [
+                                    "1. Check whether markdownDetails renders as collapsible UI or plain text.",
+                                    "2. Click the markdown link and re-run mode=events to see whether any click/navigation event reached Hooks.event.",
+                                    "3. Check whether longLogText is folded, scrollable, or fully expanded by OpenCode's tool-output renderer.",
+                                ].join("\n"),
+                            },
+                        }
+                        : {}),
+                    ...(includeEvents
+                        ? {
+                            recentEventObservations: observations.slice(-limit),
+                            recentEventObservationCount: Math.min(observations.length, limit),
+                            totalBufferedEventObservationCount: observations.length,
+                        }
+                        : {}),
+                });
+            },
+        }),
+    };
+}
 export function createFlowDeskProviderUsageLiveOptInTools(config) {
     return {
         [flowdeskProviderUsageLiveToolName]: tool({
@@ -2778,7 +3204,7 @@ export function createFlowDeskProviderUsageLiveOptInTools(config) {
                 "ALSO PROACTIVELY USE: before starting a large multi-step task that depends on a specific provider (e.g. extensive refactor, long agentic loop, multi-perspective review), call this tool first to check whether the chosen provider has enough headroom; if worstAlertLevel is critical or exhausted, warn the user and suggest switching providers or waiting for reset.",
                 "WHEN NOT TO USE: general chat, status of an in-progress workflow (use status instead), or any non-usage question.",
                 "INVOKE WITH: optional providerFamily ('claude', 'openai', 'gemini', or 'all'; default 'all'). The plugin user has already opted in to provider-native usage collection at configuration time, so this tool can be called automatically without per-call confirmation.",
-                "AFTER CALLING: summarize per-provider availability for the user in plain language. For each provider include the bucket label (claude-5h, claude-weekly, openai-gpt-5h, gemini-pro-5h, gemini-pro-weekly, gemini-flash-daily, gemini-flash-lite-daily), remainingPercent, reset time, alertLevel, and recommendation. If any provider returned non_dispatchable, exhausted, critical, stale, or unknown, note it explicitly and surface the overallRecommendation. Never echo raw tokens or raw payloads.",
+                "AFTER CALLING: summarize per-provider availability for the user in plain language. For each provider include the bucket label (claude-5h, claude-weekly, openai-gpt-5h, gemini-pro-daily, gemini-pro-weekly, gemini-flash-daily, gemini-flash-lite-daily), remainingPercent, reset time, alertLevel, and recommendation. If any provider returned non_dispatchable, exhausted, critical, stale, or unknown, note it explicitly and surface the overallRecommendation. Never echo raw tokens or raw payloads.",
             ].join(" "),
             args: {
                 providerFamily: tool.schema
@@ -3076,8 +3502,10 @@ const flowdeskServerPlugin = async (input, options) => {
     const statusLiveConfig = isStatusLiveEnabled(options)
         ? statusLiveConfigFromOptions(options)
         : undefined;
-    if (statusLiveConfig !== undefined)
+    if (statusLiveConfig !== undefined) {
         Object.assign(tools, createFlowDeskStatusLiveOptInTools(statusLiveConfig));
+        Object.assign(tools, createFlowDeskWorkflowSynthesisPreviewTools({ rootDir: statusLiveConfig.rootDir }));
+    }
     const quickFallbackRunConfig = isQuickFallbackRunEnabled(options)
         ? quickFallbackRunConfigFromOptions(options)
         : undefined;
@@ -3093,6 +3521,8 @@ const flowdeskServerPlugin = async (input, options) => {
         : undefined;
     if (workflowDispatchPlanConfig !== undefined)
         Object.assign(tools, createFlowDeskWorkflowDispatchPlanOptInTools(workflowDispatchPlanConfig));
+    if (workflowDispatchPlanConfig !== undefined)
+        Object.assign(tools, createFlowDeskAutoContinuePreviewOptInTools(workflowDispatchPlanConfig));
     const workflowDispatchConfig = workflowDispatchToolConfigFromOptions(input, options);
     if (workflowDispatchConfig !== undefined)
         Object.assign(tools, createFlowDeskWorkflowDispatchOptInTools(workflowDispatchConfig));
@@ -3110,6 +3540,13 @@ const flowdeskServerPlugin = async (input, options) => {
         if (agentTaskRunTools !== undefined)
             Object.assign(tools, agentTaskRunTools);
     }
+    const orchestrateConfig = orchestrateToolConfigFromOptions(input, options);
+    if (orchestrateConfig !== undefined)
+        Object.assign(tools, createFlowDeskOrchestrateOptInTools(orchestrateConfig));
+    const uiProbeEnabled = isFlowDeskUiProbeEnabled(options);
+    const uiProbeEventObservations = [];
+    if (uiProbeEnabled)
+        Object.assign(tools, createFlowDeskUiProbeTools(uiProbeEventObservations));
     // P8 Background Watchdog
     const watchdogConfig = watchdogConfigFromOptions(options);
     const chatStallAlertRaw = options?.[flowdeskChatMessageStallAlertOption];
@@ -3210,14 +3647,54 @@ const flowdeskServerPlugin = async (input, options) => {
             },
         });
     }
+    const eventRootDir = durableStateRootFromOptions(options);
+    const eventHook = eventRootDir === undefined && !uiProbeEnabled
+        ? undefined
+        : async (input) => {
+            if (uiProbeEnabled) {
+                uiProbeEventObservations.push(summarizeFlowDeskUiProbeEventV1(input.event, new Date().toISOString()));
+                if (uiProbeEventObservations.length > 200)
+                    uiProbeEventObservations.splice(0, uiProbeEventObservations.length - 200);
+            }
+            if (eventRootDir !== undefined) {
+                await observeFlowDeskOpenCodeEventV1({ rootDir: eventRootDir, event: input.event });
+            }
+        };
     if (!naturalLanguageRoutingEnabled)
-        return { tool: tools };
+        return eventHook === undefined ? { tool: tools } : { tool: tools, event: eventHook };
     const stallAlertOption = chatMessageStallAlertOptionsFrom(options, statusLiveConfig, isRecord(input) && isManagedDispatchBetaClient(input.client)
         ? input.client
         : undefined);
+    // Background sidebar cache refresh interval — runs every 3 minutes regardless of chat activity
+    if (providerUsageLiveConfig?.durableStateRootDir) {
+        const capturedUsageConfig = providerUsageLiveConfig;
+        const sidebarRefreshIntervalMs = 3 * 60_000;
+        const sidebarRefreshInterval = setInterval(() => {
+            const cachePath = join(capturedUsageConfig.durableStateRootDir, ".flowdesk", "ui", "provider-usage-sidebar.json");
+            let isStale = false;
+            try {
+                const cache = JSON.parse(readFileSync(cachePath, "utf8"));
+                if (typeof cache.observed_at === "string" && Date.now() - Date.parse(cache.observed_at) > sidebarRefreshIntervalMs)
+                    isStale = true;
+            }
+            catch {
+                isStale = true;
+            }
+            if (isStale) {
+                executeFlowDeskProviderUsageLiveV1({
+                    config: { ...capturedUsageConfig, persistSidebarCache: true },
+                    request: { providerFamily: "all" },
+                }).catch(() => { });
+            }
+        }, sidebarRefreshIntervalMs);
+        sidebarRefreshInterval.unref();
+        process.once("exit", () => clearInterval(sidebarRefreshInterval));
+        process.once("SIGTERM", () => clearInterval(sidebarRefreshInterval));
+    }
     return {
         tool: tools,
-        "chat.message": createFlowDeskNaturalLanguageChatMessageHook(() => new Date(), localSession, stallAlertOption, durableStateRootFromOptions(options)),
+        ...(eventHook === undefined ? {} : { event: eventHook }),
+        "chat.message": createFlowDeskNaturalLanguageChatMessageHook(() => new Date(), localSession, stallAlertOption, durableStateRootFromOptions(options), providerUsageLiveConfig),
     };
 };
 export const flowdeskChatMessageStallAlertOption = "chatMessageStallAlert";