@flowdesk/opencode-plugin 0.1.12 → 0.1.14

package/dist/server.js

@@ -4,15 +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 { 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";
@@ -34,6 +42,10 @@ export const flowdeskProviderUsageLiveOption = "providerUsageLive";
 export const flowdeskStatusLiveOption = "statusLive";
 export const flowdeskQuickFallbackRunOption = "quickFallbackRun";
 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";
@@ -46,8 +58,14 @@ export const flowdeskProviderUsageLiveToolName = "flowdesk_provider_usage_live";
 export const flowdeskStatusLiveToolName = "flowdesk_status_live";
 export const flowdeskQuickFallbackRunToolName = "flowdesk_quick_fallback_run";
 export const flowdeskLaneHeartbeatWriterToolName = "flowdesk_lane_heartbeat_record";
+export const flowdeskWorkflowDispatchPlanToolName = "flowdesk_workflow_dispatch_plan";
+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,
@@ -1166,9 +1184,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 : "";
@@ -1183,6 +1203,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)
@@ -1194,7 +1248,9 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
                 recentStallAlerts.delete(key);
         }
         const stallResult = stallAlert
-            ? await collectStallAlertResult(stallAlert, now)
+            ? await collectStallAlertResult(stallAlert, now, {
+                currentSessionRef: partSessionID || request.session_ref,
+            })
             : { status: "none" };
         let stallTextToAppend = undefined;
         let stallDedupKey = undefined;
@@ -1215,7 +1271,10 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
             const lateAlertReady = stallAlert?.includeProgressingLate === true &&
                 summary.worstClassification === "progressing_late" &&
                 summary.totalLate > 0;
-            if (stalledAlertReady || lateAlertReady) {
+            const progressCardReady = stallAlert?.includeProgressCards === true &&
+                summary.workflowSummaries.some((workflow) => (workflow.laneCards?.length ?? 0) > 0);
+            const autoNextReady = summary.workflowSummaries.some((workflow) => workflow.autoNextReady === true);
+            if (stalledAlertReady || lateAlertReady || progressCardReady || autoNextReady) {
                 stallDedupKey = stallAlertDuplicateKey(request, summary);
                 stallTextToAppend = stallAlertText(summary);
             }
@@ -1233,6 +1292,7 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
             }
         };
         if (preview.evaluation.response.route_decision === "continue_chat") {
+            appendUsageCard();
             appendStallCard();
             return;
         }
@@ -1243,13 +1303,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();
     };
 }
@@ -1257,6 +1320,28 @@ const ALLOWED_ERROR_NAMES = new Set(["FlowDeskDiskError", "FlowDeskStateError"])
 export function assertNever(x) {
     throw new Error("Unexpected object: " + x);
 }
+function sessionRefVariants(value) {
+    const variants = new Set();
+    if (value === undefined || value.trim().length === 0)
+        return variants;
+    const token = safeToken(value, "session");
+    variants.add(token);
+    if (token.startsWith("ses_"))
+        variants.add(`ses-${token.slice(4)}`);
+    if (token.startsWith("ses-"))
+        variants.add(`ses_${token.slice(4)}`);
+    return variants;
+}
+function sessionRefsMatch(left, right) {
+    const leftVariants = sessionRefVariants(left);
+    if (leftVariants.size === 0)
+        return false;
+    for (const candidate of sessionRefVariants(right)) {
+        if (leftVariants.has(candidate))
+            return true;
+    }
+    return false;
+}
 function latestParentSessionRefForLane(rootDir, workflowId, laneId) {
     const reload = reloadFlowDeskSessionEvidenceV1({ rootDir, workflowId });
     if (!reload.ok)
@@ -1310,18 +1395,36 @@ export async function collectStallAlertResult(stallAlert, clock, deps = {}) {
         if (result.status !== "status_live_collected")
             return { status: "none" };
         const autoAbortSummaries = [];
-        const workflowSummaries = await Promise.all(result.workflows
-            .filter((workflow) => (workflow.stalledLaneCount ?? 0) > 0 ||
-            (stallAlert.includeProgressingLate === true &&
-                (workflow.progressingLateLaneCount ?? 0) > 0))
-            .slice(0, 3)
+        const currentSessionRef = deps.currentSessionRef;
+        const workflowSummariesWithEmpty = await Promise.all(result.workflows
             .map(async (workflow) => {
-            const stalledEntry = workflow.laneStallProjection?.entries.find((entry) => entry.classification === "stalled");
-            const lateEntry = workflow.laneStallProjection?.entries.find((entry) => entry.classification === "progressing_late");
+            const parentRefCache = new Map();
+            const latestParentRef = (laneId) => {
+                if (!parentRefCache.has(laneId)) {
+                    parentRefCache.set(laneId, latestParentSessionRefForLane(stallAlert.rootDir, workflow.workflowId, laneId));
+                }
+                return parentRefCache.get(laneId);
+            };
+            const laneInCurrentSession = (laneId) => currentSessionRef === undefined ||
+                sessionRefsMatch(latestParentRef(laneId), currentSessionRef);
+            const scopedEntries = (workflow.laneStallProjection?.entries ?? []).filter((entry) => laneInCurrentSession(entry.laneId));
+            const stalledEntry = scopedEntries.find((entry) => entry.classification === "stalled");
+            const lateEntry = scopedEntries.find((entry) => entry.classification === "progressing_late");
             const primary = stalledEntry ?? lateEntry;
+            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;
             if (stallAlert.guardedAutoAbort !== undefined &&
                 stalledEntry !== undefined &&
-                (workflow.stalledLaneCount ?? 0) > 0) {
+                scopedStalledCount > 0) {
                 // Reconcile stale pending retry plans on each stall check
                 try {
                     reconcileStalePendingRetryPlansV1({
@@ -1383,8 +1486,8 @@ export async function collectStallAlertResult(stallAlert, clock, deps = {}) {
             }
             return {
                 workflowId: workflow.workflowId,
-                stalledLaneCount: workflow.stalledLaneCount ?? 0,
-                lateLaneCount: workflow.progressingLateLaneCount ?? 0,
+                stalledLaneCount: scopedStalledCount,
+                lateLaneCount: scopedLateCount,
                 ...(primary?.secondsSinceLastSignal === undefined
                     ? {}
                     : { secondsSinceLastSignal: primary.secondsSinceLastSignal }),
@@ -1392,17 +1495,61 @@ 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,
+                        })),
+                    }
+                    : {}),
             };
         }));
+        const workflowSummaries = workflowSummariesWithEmpty
+            .filter((summary) => summary !== undefined)
+            .slice(0, 3);
         if (workflowSummaries.length === 0) {
             return { status: "none" };
         }
+        const scopedTotalStalled = workflowSummaries.reduce((sum, workflow) => sum + workflow.stalledLaneCount, 0);
+        const scopedTotalLate = workflowSummaries.reduce((sum, workflow) => sum + workflow.lateLaneCount, 0);
+        const scopedWorstClassification = scopedTotalStalled > 0
+            ? "stalled"
+            : scopedTotalLate > 0
+                ? "progressing_late"
+                : (result.worstLaneStallClassification ?? "unknown");
         return {
             status: "ok",
             data: {
-                worstClassification: result.worstLaneStallClassification ?? "unknown",
-                totalStalled: result.totalStalledLaneCount ?? 0,
-                totalLate: result.totalProgressingLateLaneCount ?? 0,
+                worstClassification: scopedWorstClassification,
+                totalStalled: scopedTotalStalled,
+                totalLate: scopedTotalLate,
                 workflowSummaries,
                 ...(autoAbortSummaries.length === 0 ? {} : { autoAbortSummaries }),
             }
@@ -1424,7 +1571,15 @@ function stallAlertDuplicateKey(request, summary) {
         const ageMinutes = typeof entry.secondsSinceLastSignal === "number"
             ? Math.floor(entry.secondsSinceLastSignal / 60)
             : -1;
-        return `${entry.workflowId}:${entry.stalledLaneCount}:${ageMinutes}`;
+        const lanes = (entry.laneCards ?? [])
+            .map((lane) => {
+            const laneAge = typeof lane.secondsSinceLastSignal === "number"
+                ? Math.floor(lane.secondsSinceLastSignal / 60)
+                : -1;
+            return `${lane.laneId}:${lane.state ?? "unknown"}:${lane.classification}:${laneAge}`;
+        })
+            .join(",");
+        return `${entry.workflowId}:${entry.stalledLaneCount}:${ageMinutes}:${lanes}`;
     })
         .join("|");
     return `${safeToken(request.session_ref, "session")}|stall|${wf}|worst:${summary.worstClassification}`;
@@ -1432,12 +1587,19 @@ function stallAlertDuplicateKey(request, summary) {
 function stallAlertText(summary) {
     const lines = [];
     lines.push("FlowDesk");
+    const progressCardCount = summary.workflowSummaries.reduce((sum, workflow) => sum + (workflow.laneCards?.length ?? 0), 0);
     if (summary.worstClassification === "stalled") {
         lines.push(`Stalled lanes detected: ${summary.totalStalled} stalled, ${summary.totalLate} progressing-late.`);
     }
     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.`);
+    }
     else {
         lines.push(`Lane progress check: ${summary.totalStalled} stalled, ${summary.totalLate} progressing-late.`);
     }
@@ -1445,12 +1607,58 @@ 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}`);
+            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}`);
+        }
     }
-    lines.push("FlowDesk does not auto-retry, auto-abort, or auto-fallback on stall.");
     if (summary.autoAbortSummaries !== undefined && summary.autoAbortSummaries.length > 0) {
         lines.push("Guarded auto-abort diagnostics (evidence-only, opt-in):");
         for (const line of summary.autoAbortSummaries.slice(0, 3))
@@ -1466,6 +1674,9 @@ function stallAlertText(summary) {
         "/flowdesk-export-debug",
     ])
         lines.push(`- ${action}`);
+    if (progressCardCount > 0) {
+        lines.push("Lane log refs are command-based in this MVP; native clickable task UI is not claimed.");
+    }
     return lines.join("\n");
 }
 function isFds1SchemaConversionProbeEnabled(options) {
@@ -1973,6 +2184,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: [
@@ -1980,7 +2217,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: {
@@ -1991,6 +2228,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 20000ms (20s). Recommended: always pass 20000. At 20s silence → nudge 1, 40s → nudge 2, 60s+ → 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 20s/40s, and aborts at 60s+. Coordinator uses flowdesk_status_live to detect completion. Recommended for all orchestration calls."),
             },
             async execute(args, ctx) {
                 const record = isRecord(args) ? args : {};
@@ -2010,6 +2249,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({
@@ -2022,19 +2264,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 }),
+                    }),
                 });
             },
         }),
@@ -2157,6 +2417,37 @@ function isProviderUsageLiveEnabled(options) {
     const value = options?.[flowdeskProviderUsageLiveOption];
     return value === true || (isRecord(value) && value.enabled === true);
 }
+/**
+ * Returns true when OpenCode auth store has a google/gemini OAuth record that
+ * FlowDesk's Gemini usage collector can auto-detect (via opencode-gemini-auth login),
+ * without requiring explicit geminiOAuthClientId/Secret config.
+ */
+function geminiOAuthAutoDetectAvailable(homeDir) {
+    try {
+        const home = homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? "";
+        if (!home)
+            return false;
+        const xdgData = process.env.XDG_DATA_HOME
+            ? join(process.env.XDG_DATA_HOME, "opencode")
+            : join(home, ".local", "share", "opencode");
+        const authPath = join(xdgData, "auth.json");
+        const raw = readFileSync(authPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return false;
+        const db = parsed;
+        const entry = db.google ?? db.gemini;
+        if (typeof entry !== "object" || entry === null)
+            return false;
+        const rec = entry;
+        return rec.type === "oauth" &&
+            (typeof rec.access === "string" && rec.access.length > 0 ||
+                typeof rec.refresh === "string" && rec.refresh.length > 0);
+    }
+    catch {
+        return false;
+    }
+}
 function providerUsageLiveConfigFromOptions(options) {
     const value = options?.[flowdeskProviderUsageLiveOption];
     if (!isRecord(value) || value.enabled !== true)
@@ -2185,6 +2476,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
@@ -2292,6 +2585,254 @@ function isLaneHeartbeatWriterEnabled(options) {
     const value = options?.[flowdeskLaneHeartbeatWriterOption];
     return value === true || (isRecord(value) && value.enabled === true);
 }
+function isWorkflowDispatchPlanToolEnabled(options) {
+    const value = options?.[flowdeskWorkflowDispatchPlanToolOption];
+    return value === true || (isRecord(value) && value.enabled === true);
+}
+function workflowDispatchPlanToolConfigFromOptions(options) {
+    const value = options?.[flowdeskWorkflowDispatchPlanToolOption];
+    const enabledFromBool = value === true;
+    const enabledFromRecord = isRecord(value) && value.enabled === true;
+    if (!enabledFromBool && !enabledFromRecord)
+        return undefined;
+    const explicitRoot = isRecord(value) &&
+        typeof value.rootDir === "string" &&
+        value.rootDir.trim().length > 0
+        ? value.rootDir
+        : undefined;
+    const rootDir = explicitRoot ?? durableStateRootFromOptions(options);
+    return rootDir === undefined ? undefined : { rootDir };
+}
+function workflowDispatchToolConfigFromOptions(input, options) {
+    const value = options?.[flowdeskWorkflowDispatchOption];
+    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 controlledWriteApplyConfigFromOptions(input, options) {
+    const value = options?.[flowdeskControlledWriteApplyOption];
+    if (!isRecord(value) || value.enabled !== true || value.devBetaControlledWriteApply !== true)
+        return undefined;
+    const explicitRoot = typeof value.rootDir === "string" && value.rootDir.trim().length > 0
+        ? value.rootDir
+        : undefined;
+    const durableStateRoot = explicitRoot ?? durableStateRootFromOptions(options);
+    if (durableStateRoot === undefined)
+        return undefined;
+    const optionWorkspaceRoot = typeof value.workspaceRoot === "string" && value.workspaceRoot.trim().length > 0
+        ? value.workspaceRoot
+        : undefined;
+    const inputWorkspaceRoot = isRecord(input) && typeof input.workspace === "string" && input.workspace.trim().length > 0
+        ? input.workspace
+        : isRecord(input) && typeof input.directory === "string" && input.directory.trim().length > 0
+            ? input.directory
+            : undefined;
+    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({
+            description: [
+                "Build and persist a FlowDesk planning-only workflow dispatch plan using flowdesk.workflow_dispatch_plan.v1 evidence. This optional tool never opens dispatch authority, never calls providers, never executes runtime work, never launches lanes, and never performs fallback or reselection.",
+                "WHEN TO USE: the user explicitly asks to plan a multi-role or multi-task FlowDesk workflow and durable planning evidence is useful before any later guarded command-backed step.",
+                "WHEN NOT TO USE: ordinary chat, provider usage questions, status checks, code review fan-out, fallback/retry requests, or any request to actually dispatch, run, launch, execute, switch providers, or call a model.",
+                "INVOKE WITH: optional workflowId, goalSummary, optional selectedAgentRoles, and tasks[] with agentRole plus summary/title labels. The configured server durable state root is used; do not pass user filesystem paths.",
+                "AFTER CALLING: surface summaryForUser and safeNextActions. On blocked_before_workflow_dispatch_plan, report redactedBlockReason. Never claim dispatch/provider/runtime/lane/fallback authority.",
+            ].join(" "),
+            args: {
+                workflowId: tool.schema
+                    .string()
+                    .optional()
+                    .describe("Optional workflow id to bind the durable planning evidence to. Auto-generated when omitted."),
+                goalSummary: tool.schema
+                    .string()
+                    .describe("Bounded redacted summary of the workflow planning goal."),
+                selectedAgentRoles: tool.schema
+                    .array(tool.schema.string())
+                    .optional()
+                    .describe("Optional FlowDesk role categories to include in the planning evidence."),
+                tasks: tool.schema
+                    .array(tool.schema.object({
+                    agentRole: tool.schema.string(),
+                    title: tool.schema.string().optional(),
+                    summary: tool.schema.string(),
+                    agentRoleRef: tool.schema.string().optional(),
+                    dependsOnTaskIds: tool.schema.array(tool.schema.string()).optional(),
+                }))
+                    .describe("One or more planning-only task labels with agentRole and summary. No raw prompts or provider payloads."),
+            },
+            async execute(input) {
+                const result = executeFlowDeskWorkflowDispatchPlanToolV1({
+                    config,
+                    rawInput: input,
+                });
+                return JSON.stringify(result);
+            },
+        }),
+    };
+}
+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({
+            description: [
+                "Run one explicit dev-mode FlowDesk workflow task through the injected OpenCode SDK client. This optional beta tool is disabled by default and requires workflowDispatch.enabled=true plus workflowDispatch.devBetaActualLaneLaunch=true, durableStateRoot, developerModeAcknowledged=true, allowProviderCall=true, and allowActualLaneLaunch=true. It persists non-authorizing workflow_dispatch_plan evidence, launches exactly one lane through executeFlowDeskAgentTaskV1, and verifies terminal task evidence.",
+                "WHEN TO USE: only when the user explicitly asks for dev-mode actual one-task workflow dispatch and understands this makes a provider/runtime call.",
+                "WHEN NOT TO USE: default Release 1 workflows, planning-only requests, fallback/reselection, provider switching, controlled write/apply, ordinary chat, status, usage, or review fan-out.",
+                "INVOKE WITH: optional workflowId, goalSummary, parentSessionId, one task with agentRole, summary, promptText, agentName, providerQualifiedModelId, optional outputContractRef=contract-task-result-v1, and the three explicit allow flags. Do not pass raw transcripts, provider payloads, write/apply instructions, fallback wording, or filesystem paths.",
+                "AFTER CALLING: surface summaryForUser, ids, safeNextActions, and authority. Never claim default dispatch authority, write authority, fallback authority, hard chat cancellation, or default Release 1 dispatch enablement.",
+            ].join(" "),
+            args: {
+                workflowId: tool.schema.string().optional().describe("Optional workflow id. Auto-generated when omitted."),
+                goalSummary: tool.schema.string().describe("Bounded redacted summary of the one-task dev-mode workflow goal."),
+                parentSessionId: tool.schema.string().describe("Existing OpenCode parent session id. Required; no unrelated silent parent session is created."),
+                task: tool.schema.object({
+                    agentRole: tool.schema.string().describe("FlowDesk role category for the single task."),
+                    summary: tool.schema.string().describe("Bounded task summary label for evidence."),
+                    promptText: tool.schema.string().describe("Bounded prompt text for the one launched lane."),
+                    agentName: tool.schema.string().describe("OpenCode agent name or agent-* ref for the lane."),
+                    providerQualifiedModelId: tool.schema.string().describe("Concrete provider/model id such as openai/gpt-5.5."),
+                    outputContractRef: tool.schema.string().optional().describe("Optional; only contract-task-result-v1 is supported in this pass."),
+                }),
+                developerModeAcknowledged: tool.schema.boolean().describe("Must be true to acknowledge dev-mode beta lane launch."),
+                allowProviderCall: tool.schema.boolean().describe("Must be true to allow the provider call for this one lane."),
+                allowActualLaneLaunch: tool.schema.boolean().describe("Must be true to allow actual one-lane runtime launch."),
+            },
+            async execute(input) {
+                const result = await executeFlowDeskWorkflowDispatchToolV1({
+                    config,
+                    rawInput: input,
+                });
+                return JSON.stringify(result);
+            },
+        }),
+    };
+}
+export function createFlowDeskControlledWriteApplyOptInTools(config) {
+    return {
+        [flowdeskControlledWriteApplyToolName]: tool({
+            description: [
+                "Apply one complete-file replacement through the FlowDesk dev/beta controlled write path. This optional tool is disabled by default and requires controlledWriteApply.enabled=true plus controlledWriteApply.devBetaControlledWriteApply=true, durableStateRoot, developerModeAcknowledged=true, userApprovalRef, allowControlledWrite=true, and a workspace-relative target path.",
+                "WHEN TO USE: only when the user explicitly approves a bounded local workspace file replacement in dev mode and the current file hash is known or the caller explicitly sets allowMissingExpectedHashForDevMode=true.",
+                "WHEN NOT TO USE: default Release 1 workflows, model-generated automatic apply, provider/runtime dispatch, fallback/reselection, remote writes, shell execution, absolute paths, path traversal, symlink targets, binary content, or hidden injection.",
+                "INVOKE WITH: workflowId, targetFilePath relative to the workspace root, expectedSha256 or expectedContentSha256 when available, replacementText, reasonSummary, developerModeAcknowledged=true, bounded userApprovalRef, and allowControlledWrite=true. Never pass raw transcripts, prompts, provider payloads, secrets, absolute paths, or shell output.",
+                "AFTER CALLING: surface summaryForUser, targetFilePath, ledgerEntryId, hashes, safeNextActions, and authority. Never claim default Release 1 write authority, dispatch authority, provider calls, runtime execution, fallback authority, or hard chat cancellation.",
+            ].join(" "),
+            args: {
+                workflowId: tool.schema.string().describe("Stable FlowDesk workflow id for durable ledger evidence."),
+                targetFilePath: tool.schema.string().describe("Workspace-relative target file path only. Absolute paths and traversal are rejected."),
+                expectedSha256: tool.schema.string().optional().describe("Optional sha256-<hex> hash of the current target file content."),
+                expectedContentSha256: tool.schema.string().optional().describe("Optional sha256-<hex> hash alias for the current target file content."),
+                allowMissingExpectedHashForDevMode: tool.schema.boolean().optional().describe("Must be true to proceed without an expected current-content hash."),
+                replacementText: tool.schema.string().describe("Complete replacement file text, bounded and non-binary."),
+                reasonSummary: tool.schema.string().describe("Bounded redacted reason for the controlled write."),
+                developerModeAcknowledged: tool.schema.boolean().describe("Must be true to acknowledge dev/beta controlled write authority."),
+                userApprovalRef: tool.schema.string().describe("Bounded opaque user approval reference for this write."),
+                allowControlledWrite: tool.schema.boolean().describe("Must be true to permit this one controlled local write."),
+            },
+            async execute(input) {
+                const result = executeFlowDeskControlledWriteApplyToolV1({
+                    config,
+                    rawInput: input,
+                });
+                return JSON.stringify(result);
+            },
+        }),
+    };
+}
 function isAgentTaskRunEnabled(options) {
     const value = options?.[flowdeskAgentTaskRunOption];
     return value === true || (isRecord(value) && value.enabled === true);
@@ -2477,6 +3018,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({
@@ -2486,7 +3155,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
@@ -2603,6 +3272,9 @@ const flowdeskServerPlugin = async (input, options) => {
                 const laneHeartbeatWriterConfigForDoctor = isLaneHeartbeatWriterEnabled(options)
                     ? laneHeartbeatWriterConfigFromOptions(options)
                     : undefined;
+                const workflowDispatchPlanConfigForDoctor = isWorkflowDispatchPlanToolEnabled(options)
+                    ? workflowDispatchPlanToolConfigFromOptions(options)
+                    : undefined;
                 const quickReviewerRunRegistered = isQuickReviewerRunEnabled(options) &&
                     quickReviewerRunClientFrom(input, options) !== undefined;
                 const naturalLanguageTools = {
@@ -2622,14 +3294,15 @@ const flowdeskServerPlugin = async (input, options) => {
                                 "string",
                         persistWorkflowId: providerUsageLiveConfigForDoctor?.persistWorkflowId,
                         geminiOAuthConfigured: providerUsageLiveConfigForDoctor !== undefined &&
-                            ((providerUsageLiveConfigForDoctor.geminiOAuthClientId !==
-                                undefined &&
-                                providerUsageLiveConfigForDoctor.geminiOAuthClientSecret !==
-                                    undefined) ||
-                                typeof process.env.FLOWDESK_GEMINI_OAUTH_CLIENT_ID ===
-                                    "string" ||
-                                typeof process.env.FLOWDESK_GEMINI_OAUTH_CLIENT_SECRET ===
-                                    "string"),
+                            (
+                            // Explicit inline config
+                            (providerUsageLiveConfigForDoctor.geminiOAuthClientId !== undefined &&
+                                providerUsageLiveConfigForDoctor.geminiOAuthClientSecret !== undefined) ||
+                                // Explicit env vars
+                                typeof process.env.FLOWDESK_GEMINI_OAUTH_CLIENT_ID === "string" ||
+                                typeof process.env.FLOWDESK_GEMINI_OAUTH_CLIENT_SECRET === "string" ||
+                                // Auto-detect: OpenCode auth store (opencode-gemini-auth login)
+                                geminiOAuthAutoDetectAvailable(providerUsageLiveConfigForDoctor.homeDir)),
                         hint: isProviderUsageLiveEnabled(options) &&
                             providerUsageLiveConfigForDoctor === undefined
                             ? "providerUsageLive.enabled=true but no provider family configured; set providers=['claude','openai','gemini']"
@@ -2665,6 +3338,23 @@ const flowdeskServerPlugin = async (input, options) => {
                             ? "laneHeartbeatWriter.enabled=true but no durable state root resolved; set laneHeartbeatWriter.rootDir or top-level durableStateRoot"
                             : undefined,
                     },
+                    workflowDispatchPlanTool: {
+                        enabled: isWorkflowDispatchPlanToolEnabled(options),
+                        registered: workflowDispatchPlanConfigForDoctor !== undefined,
+                        rootDir: workflowDispatchPlanConfigForDoctor?.rootDir,
+                        persistsWorkflowDispatchPlanEvidence: workflowDispatchPlanConfigForDoctor !== undefined,
+                        authority: {
+                            realOpenCodeDispatch: false,
+                            providerCall: false,
+                            runtimeExecution: false,
+                            actualLaneLaunch: false,
+                            fallbackAuthority: false,
+                        },
+                        hint: isWorkflowDispatchPlanToolEnabled(options) &&
+                            workflowDispatchPlanConfigForDoctor === undefined
+                            ? "workflowDispatchPlanTool.enabled=true but no durable state root resolved; set workflowDispatchPlanTool.rootDir or top-level durableStateRoot"
+                            : undefined,
+                    },
                     chatMessageStallAlert: {
                         enabled: options?.[flowdeskChatMessageStallAlertOption] === true ||
                             (isRecord(options?.[flowdeskChatMessageStallAlertOption]) &&
@@ -2763,8 +3453,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;
@@ -2775,6 +3467,19 @@ const flowdeskServerPlugin = async (input, options) => {
         : undefined;
     if (laneHeartbeatWriterConfig !== undefined)
         Object.assign(tools, createFlowDeskLaneHeartbeatWriterOptInTools(laneHeartbeatWriterConfig));
+    const workflowDispatchPlanConfig = isWorkflowDispatchPlanToolEnabled(options)
+        ? workflowDispatchPlanToolConfigFromOptions(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));
+    const controlledWriteApplyConfig = controlledWriteApplyConfigFromOptions(input, options);
+    if (controlledWriteApplyConfig !== undefined)
+        Object.assign(tools, createFlowDeskControlledWriteApplyOptInTools(controlledWriteApplyConfig));
     const agentTaskRunEnabled = isAgentTaskRunEnabled(options);
     if (agentTaskRunEnabled) {
         const agentTaskRunClient = isRecord(input) && isManagedDispatchBetaClient(input.client) ? input.client : undefined;
@@ -2786,6 +3491,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];
@@ -2886,14 +3598,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";
@@ -2933,6 +3685,13 @@ function chatMessageStallAlertOptionsFrom(options, statusLiveConfig, sdkClient)
     if (recordRaw !== undefined &&
         typeof recordRaw.includeProgressingLate === "boolean")
         config.includeProgressingLate = recordRaw.includeProgressingLate;
+    if (recordRaw !== undefined &&
+        typeof recordRaw.includeProgressCards === "boolean")
+        config.includeProgressCards = recordRaw.includeProgressCards;
+    if (recordRaw !== undefined &&
+        typeof recordRaw.maxProgressCards === "number" &&
+        recordRaw.maxProgressCards > 0)
+        config.maxProgressCards = Math.min(6, Math.max(1, Math.floor(recordRaw.maxProgressCards)));
     if (recordRaw !== undefined && isRecord(recordRaw.guardedAutoAbort)) {
         const rawGuard = recordRaw.guardedAutoAbort;
         const guardedAutoAbort = {