@flowdesk/opencode-plugin 0.1.11 → 0.1.13

package/dist/server.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import { applyFlowDeskSessionEvidenceWriteIntentsV1, createFlowDeskChatHookAuthorityProbeV1, evaluateFlowDeskChatIntakeV1, getFlowDeskPortableCommandToolName, getRelease1SchemaArtifact, materializeFlowDeskExactModelCacheEvidenceFromProviderAcquisitionEvidenceV1, materializeFlowDeskRuntimeLaneLaunchPlansFromReviewerFanoutEvidenceV1, planFlowDeskReviewerFanoutFromReloadedCacheEvidenceV1, prepareFlowDeskSessionEvidenceWriteIntentV1, reloadFlowDeskSessionEvidenceV1, validateFlowDeskDefaultManagedDispatchAuthorizationV1, validateProjectConfigV1, validateRunRequestV1, } from "@flowdesk/core";
@@ -10,7 +11,13 @@ import { executeFlowDeskProviderUsageLiveV1, } from "./provider-usage-live-tool.
 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 { 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 { 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";
 export const flowdeskPreSpikeDoctorToolName = "flowdesk_pre_spike_doctor";
 export const flowdeskChatIntakeToolName = "flowdesk_chat_intake";
@@ -30,7 +37,12 @@ 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 flowdeskDefaultManagedDispatchAuthorizationOption = "defaultManagedDispatchAuthorization";
+export const flowdeskWatchdogOption = "watchdog";
+export const flowdeskWatchdogTriggerToolName = "flowdesk_watchdog_trigger";
 export const flowdeskManagedDispatchBetaToolName = "flowdesk_managed_dispatch_beta";
 export const flowdeskExactModelProviderAcquisitionLiveTestToolName = "flowdesk_exact_model_provider_acquisition_live_test";
 export const flowdeskRuntimeReviewerExecutionToolName = "flowdesk_runtime_reviewer_execution";
@@ -40,6 +52,11 @@ 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";
 const flowdeskChatSuggestionDuplicateWindowMs = 10_000;
 const disabledAuthority = {
     productionRegistrationEligible: false,
@@ -1163,6 +1180,15 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
     const recentStallAlerts = new Map();
     return async function message(input, output) {
         const inputRecord = isRecord(input) ? input : {};
+        const partSessionID = typeof inputRecord.sessionID === "string" ? inputRecord.sessionID : "";
+        const partMessageID = typeof inputRecord.messageID === "string" ? inputRecord.messageID : "";
+        const buildTextPart = (text) => ({
+            id: `prt_${randomUUID().replaceAll("-", "")}`,
+            sessionID: partSessionID,
+            messageID: partMessageID,
+            type: "text",
+            text,
+        });
         const request = intakeRequestFromChatMessage({ ...inputRecord, ...output });
         const preview = previewNaturalLanguageRouting(request, session);
         const nowMs = clockMs(now);
@@ -1176,32 +1202,51 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
                 nowMs < recordedAtMs)
                 recentStallAlerts.delete(key);
         }
-        const stallSummary = stallAlert
-            ? await collectStallAlertSummary(stallAlert, now)
-            : undefined;
-        const stalledAlertReady = stallSummary !== undefined &&
-            stallSummary.worstClassification === "stalled" &&
-            stallSummary.totalStalled > 0;
-        const lateAlertReady = stallSummary !== undefined &&
-            stallAlert?.includeProgressingLate === true &&
-            stallSummary.worstClassification === "progressing_late" &&
-            stallSummary.totalLate > 0;
-        const shouldAppendStallCard = stalledAlertReady || lateAlertReady;
-        if (preview.evaluation.response.route_decision === "continue_chat") {
-            if (shouldAppendStallCard && stallSummary !== undefined) {
-                const key = stallAlertDuplicateKey(request, stallSummary);
-                const previous = recentStallAlerts.get(key);
-                recentStallAlerts.set(key, nowMs);
+        const stallResult = stallAlert
+            ? await collectStallAlertResult(stallAlert, now, {
+                currentSessionRef: partSessionID || request.session_ref,
+            })
+            : { status: "none" };
+        let stallTextToAppend = undefined;
+        let stallDedupKey = undefined;
+        if (stallResult.status === "unavailable") {
+            stallDedupKey = `${safeToken(request.session_ref, "session")}|stall-unavailable`;
+            stallTextToAppend =
+                "FlowDesk\nStall detection temporarily unavailable (status check timed out).\nSafe next actions:\n- /flowdesk-status\n- /flowdesk-doctor";
+        }
+        else if (stallResult.status === "error") {
+            stallDedupKey = `${safeToken(request.session_ref, "session")}|stall-error`;
+            stallTextToAppend =
+                "FlowDesk\nStall detection encountered an error.\nRun /flowdesk-doctor to diagnose.";
+        }
+        else if (stallResult.status === "ok") {
+            const summary = stallResult.data;
+            const stalledAlertReady = summary.worstClassification === "stalled" &&
+                summary.totalStalled > 0;
+            const lateAlertReady = stallAlert?.includeProgressingLate === true &&
+                summary.worstClassification === "progressing_late" &&
+                summary.totalLate > 0;
+            const progressCardReady = stallAlert?.includeProgressCards === true &&
+                summary.workflowSummaries.some((workflow) => (workflow.laneCards?.length ?? 0) > 0);
+            if (stalledAlertReady || lateAlertReady || progressCardReady) {
+                stallDedupKey = stallAlertDuplicateKey(request, summary);
+                stallTextToAppend = stallAlertText(summary);
+            }
+        }
+        const appendStallCard = () => {
+            if (stallDedupKey && stallTextToAppend) {
+                const previous = recentStallAlerts.get(stallDedupKey);
+                recentStallAlerts.set(stallDedupKey, nowMs);
                 if (previous === undefined ||
                     nowMs - previous > flowdeskChatSuggestionDuplicateWindowMs) {
                     if (!Array.isArray(output.parts))
                         output.parts = [];
-                    output.parts.push({
-                        type: "text",
-                        text: stallAlertText(stallSummary),
-                    });
+                    output.parts.push(buildTextPart(stallTextToAppend));
                 }
             }
+        };
+        if (preview.evaluation.response.route_decision === "continue_chat") {
+            appendStallCard();
             return;
         }
         if (!mayCreatePendingConfirmation(preview)) {
@@ -1217,21 +1262,64 @@ export function createFlowDeskNaturalLanguageChatMessageHook(now = () => new Dat
         const result = evaluateNaturalLanguageRouting(request, session);
         if (!Array.isArray(output.parts))
             output.parts = [];
-        output.parts.push({ type: "text", text: steeringText(result) });
-        if (shouldAppendStallCard && stallSummary !== undefined) {
-            const key = stallAlertDuplicateKey(request, stallSummary);
-            const previous = recentStallAlerts.get(key);
-            recentStallAlerts.set(key, nowMs);
-            if (previous === undefined ||
-                nowMs - previous > flowdeskChatSuggestionDuplicateWindowMs)
-                output.parts.push({
-                    type: "text",
-                    text: stallAlertText(stallSummary),
-                });
-        }
+        output.parts.push(buildTextPart(steeringText(result)));
+        appendStallCard();
     };
 }
-async function collectStallAlertSummary(stallAlert, clock) {
+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)
+        return undefined;
+    let latest;
+    for (const entry of reload.entries) {
+        if (entry.evidenceClass !== "lane_lifecycle")
+            continue;
+        const record = entry.record;
+        if (!isRecord(record))
+            continue;
+        if (record.lane_id !== laneId)
+            continue;
+        if (typeof record.parent_session_ref !== "string")
+            continue;
+        const updatedAt = typeof record.updated_at === "string"
+            ? Date.parse(record.updated_at)
+            : Number.NaN;
+        if (!Number.isFinite(updatedAt))
+            continue;
+        if (latest === undefined || updatedAt > latest.updatedAtMs) {
+            latest = { parentSessionRef: record.parent_session_ref, updatedAtMs: updatedAt };
+        }
+    }
+    return latest?.parentSessionRef;
+}
+export async function collectStallAlertResult(stallAlert, clock, deps = {}) {
+    const statusLiveImpl = deps.statusLiveImpl ?? executeFlowDeskStatusLiveV1;
     try {
         const observedAt = (typeof clock === "function" ? clock() : clock).toISOString();
         const config = {
@@ -1250,25 +1338,104 @@ async function collectStallAlertSummary(stallAlert, clock) {
                     laneHeartbeatStallThresholdMs: stallAlert.laneHeartbeatStallThresholdMs,
                 }),
         };
-        const result = await executeFlowDeskStatusLiveV1({
+        const result = await withTimeout(statusLiveImpl({
             config,
             now: () => new Date(observedAt),
-        });
+        }), stallAlert.statusLiveTimeoutMs ?? 8_000, "executeFlowDeskStatusLiveV1");
         if (result.status !== "status_live_collected")
-            return undefined;
-        const workflowSummaries = result.workflows
-            .filter((workflow) => (workflow.stalledLaneCount ?? 0) > 0 ||
-            (stallAlert.includeProgressingLate === true &&
-                (workflow.progressingLateLaneCount ?? 0) > 0))
-            .slice(0, 3)
-            .map((workflow) => {
-            const stalledEntry = workflow.laneStallProjection?.entries.find((entry) => entry.classification === "stalled");
-            const lateEntry = workflow.laneStallProjection?.entries.find((entry) => entry.classification === "progressing_late");
+            return { status: "none" };
+        const autoAbortSummaries = [];
+        const currentSessionRef = deps.currentSessionRef;
+        const workflowSummariesWithEmpty = await Promise.all(result.workflows
+            .map(async (workflow) => {
+            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 scopedLaneCards = (workflow.laneProgressCards ?? []).filter((lane) => 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) ||
+                (stallAlert.includeProgressCards === true && scopedLaneCards.length > 0);
+            if (!shouldShowWorkflow)
+                return undefined;
+            if (stallAlert.guardedAutoAbort !== undefined &&
+                stalledEntry !== undefined &&
+                scopedStalledCount > 0) {
+                // Reconcile stale pending retry plans on each stall check
+                try {
+                    reconcileStalePendingRetryPlansV1({
+                        rootDir: stallAlert.rootDir,
+                        workflowId: workflow.workflowId,
+                        now: new Date(observedAt),
+                    });
+                }
+                catch {
+                    // Reconciliation is best-effort
+                }
+                let sdkSessionHealth = stallAlert.guardedAutoAbort.sdkSessionHealth;
+                if (sdkSessionHealth === undefined &&
+                    stallAlert.guardedAutoAbort.useLiveSdkSessionHealth === true &&
+                    stallAlert.guardedAutoAbort.sdkClient !== undefined) {
+                    const parentSessionRef = latestParentSessionRefForLane(stallAlert.rootDir, workflow.workflowId, stalledEntry.laneId);
+                    sdkSessionHealth = parentSessionRef === undefined
+                        ? { status: "unknown", reason: "parent_session_ref_missing" }
+                        : await checkSdkSessionApiHealthV1(stallAlert.guardedAutoAbort.sdkClient, parentSessionRef);
+                }
+                const autoAbort = evaluateGuardedAutoAbortHookV1({
+                    rootDir: stallAlert.rootDir,
+                    workflow_id: workflow.workflowId,
+                    lane_id: stalledEntry.laneId,
+                    config: stallAlert.guardedAutoAbort,
+                    stallConfirmed: true,
+                    sdkSessionHealth: sdkSessionHealth ?? {
+                        status: "unknown",
+                        reason: "sdk_session_health_not_supplied_to_chat_hook",
+                    },
+                    now: () => new Date(observedAt),
+                });
+                autoAbortSummaries.push(`workflow ${workflow.workflowId} lane ${stalledEntry.laneId}: guarded auto-abort ${autoAbort.status}`);
+                // After auto-abort, evaluate guarded auto-retry if configured
+                if (autoAbort.status === "auto_abort_executed" &&
+                    stallAlert.guardedAutoAbort.autoRetryAfterAbort === true &&
+                    stallAlert.guardedAutoAbort.sdkClient !== undefined) {
+                    let retryResult;
+                    try {
+                        retryResult = await evaluateGuardedAutoRetryHookV1({
+                            config: stallAlert.guardedAutoAbort,
+                            rootDir: stallAlert.rootDir,
+                            workflowId: workflow.workflowId,
+                            laneId: stalledEntry.laneId,
+                            abortEvidenceId: autoAbort.lifecycle_evidence_id,
+                            client: stallAlert.guardedAutoAbort.sdkClient,
+                            parentSessionId: stalledEntry.laneId,
+                            timeoutMs: 30_000,
+                            now: new Date(observedAt),
+                        });
+                    }
+                    catch {
+                        // Retry evaluation is best-effort
+                    }
+                    if (retryResult !== undefined) {
+                        autoAbortSummaries.push(`workflow ${workflow.workflowId} lane ${stalledEntry.laneId}: guarded auto-retry ${retryResult.status}`);
+                    }
+                }
+            }
             return {
                 workflowId: workflow.workflowId,
-                stalledLaneCount: workflow.stalledLaneCount ?? 0,
-                lateLaneCount: workflow.progressingLateLaneCount ?? 0,
+                stalledLaneCount: scopedStalledCount,
+                lateLaneCount: scopedLateCount,
                 ...(primary?.secondsSinceLastSignal === undefined
                     ? {}
                     : { secondsSinceLastSignal: primary.secondsSinceLastSignal }),
@@ -1276,17 +1443,56 @@ async function collectStallAlertSummary(stallAlert, clock) {
                 ...(primary?.failureHint === undefined
                     ? {}
                     : { failureHint: primary.failureHint }),
+                ...(stallAlert.includeProgressCards === true
+                    ? {
+                        laneCards: scopedLaneCards
+                            .slice(0, stallAlert.maxProgressCards ?? 3)
+                            .map((lane) => ({
+                            laneId: lane.laneId,
+                            state: lane.state,
+                            classification: lane.classification,
+                            secondsSinceLastSignal: lane.secondsSinceLastSignal,
+                            agentRef: lane.agentRef,
+                            providerQualifiedModelId: lane.providerQualifiedModelId,
+                            verdictLabel: lane.verdictLabel,
+                            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 {
-            worstClassification: result.worstLaneStallClassification ?? "unknown",
-            totalStalled: result.totalStalledLaneCount ?? 0,
-            totalLate: result.totalProgressingLateLaneCount ?? 0,
-            workflowSummaries,
+            status: "ok",
+            data: {
+                worstClassification: scopedWorstClassification,
+                totalStalled: scopedTotalStalled,
+                totalLate: scopedTotalLate,
+                workflowSummaries,
+                ...(autoAbortSummaries.length === 0 ? {} : { autoAbortSummaries }),
+            }
         };
     }
-    catch {
-        return undefined;
+    catch (error) {
+        if (error instanceof FlowDeskTimeoutError) {
+            return { status: "unavailable" };
+        }
+        const errorName = error instanceof Error ? error.name : "UnknownError";
+        const safeName = ALLOWED_ERROR_NAMES.has(errorName) ? errorName : "UnknownError";
+        process.stderr.write(`[flowdesk] collectStallAlertResult error: ${safeName}\n`);
+        return { status: "error" };
     }
 }
 function stallAlertDuplicateKey(request, summary) {
@@ -1295,7 +1501,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}`;
@@ -1303,12 +1517,16 @@ 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 (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.`);
     }
@@ -1320,8 +1538,22 @@ function stallAlertText(summary) {
             ? `${workflow.stalledLaneCount} stalled`
             : `${workflow.lateLaneCount} progressing-late`;
         lines.push(`- workflow ${workflow.workflowId}: ${counts} (last signal ~${minutes}m ago, ${hint}).`);
+        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 verdict = lane.verdictLabel ?? "(none)";
+            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}`);
+        }
+    }
+    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))
+            lines.push(`- ${line}`);
     }
-    lines.push("FlowDesk does not auto-retry, auto-abort, or auto-fallback on stall.");
     lines.push("Safe next actions:");
     for (const action of [
         "/flowdesk-status",
@@ -1332,6 +1564,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) {
@@ -1686,6 +1921,7 @@ function redactedQuickReviewerRunBlocked(reason) {
         laneCount: 0,
         lanes: [],
         redactedBlockReason: reason,
+        summaryForUser: `FlowDesk quick reviewer blocked before launch: ${reason}. Safe next actions: /flowdesk-status.`,
         safeNextActions: ["/flowdesk-status"],
         authority: {
             realOpenCodeDispatch: false,
@@ -1719,6 +1955,7 @@ function redactedQuickReviewerRunToolResult(result) {
         linkedLifecycleCount: result.linkedLifecycleCount,
         acceptedPerspectives: result.acceptedPerspectives,
         redactedBlockReason: result.redactedBlockReason,
+        summaryForUser: result.summaryForUser,
         safeNextActions: result.safeNextActions,
         authority: result.authority,
     };
@@ -1727,12 +1964,13 @@ export function createFlowDeskQuickReviewerRunOptInTools(client, defaults) {
     return {
         [flowdeskQuickReviewerRunToolName]: tool({
             description: [
-                "Run a 3-perspective FlowDesk reviewer fan-out (policy_security, architecture, verification_implementation) on a user-supplied prompt, pasted content, or the current conversation context, returning typed reviewer verdicts.",
+                "Run a 3-perspective FlowDesk reviewer fan-out (policy_security, architecture, verification_implementation) on a user-supplied prompt, pasted code/content, or the current conversation context, returning typed reviewer verdicts plus a concise summaryForUser string. Supports optional per-perspective bindings[] for multi-model fan-out when exact provider/model ids and reviewer agents are configured.",
                 "WHEN TO USE: the user explicitly asks for a code review, security audit, multi-perspective check, critical review, design review, or quality review. Trigger on English phrases such as 'multi-perspective review', 'multi-angle review', 'critical review', 'review from multiple perspectives', 'audit', 'critique', 'assess', or 'evaluate'. Trigger on Korean phrases such as '다관점 리뷰', '다관점리뷰', '다관점 비판적리뷰', '다관점 비판적 리뷰', '다각도 리뷰', '다각도 검토', '여러 관점 리뷰', '여러 관점에서 검토', '복수 관점 리뷰', '비판적 리뷰', '비판적 검토', '심층 리뷰', '아키텍처 리뷰', '보안 리뷰', '품질 리뷰', '검토', or '점검'.",
+                "ALSO PROACTIVELY USE: when the user supplies a code snippet, file reference, or design idea and asks for opinion/critique without explicitly typing 'review' (English: 'what do you think', 'how does this look', 'spot issues', 'find problems'; Korean: '어때', '괜찮아', '문제 있어 보여', '이슈 찾아줘', '봐줘'). When the user gives no snippet, derive a concise review target from the immediate prior turn and call this tool instead of asking for one more clarification.",
                 "CONTENT SELECTION: code is not required. If the user provides no explicit snippet after the trigger phrase, pass a concise prompt that includes the user's request plus the relevant current conversation context or target they are asking to review.",
-                "WHEN NOT TO USE: general questions, plain chat, or any request that does not explicitly ask for a review, critique, audit, assessment, evaluation, 검토, 리뷰, 점검, or 비판.",
+                "WHEN NOT TO USE: general questions, plain chat, status/usage/recovery questions (use the other FlowDesk natural-language tools), or any request that does not explicitly ask for a review-style judgement.",
                 "INVOKE WITH: developerModeAcknowledged=true and allowProviderCall=true. The plugin user has already opted into this tool at configuration time, so these flags must be set on every call. Do not ask the user for extra confirmation before calling; just call.",
-                "AFTER CALLING: summarize the lane verdicts back to the user. acceptanceStatus=verdicts_accepted and durableLinkageStatus=durable_verdicts_accepted mean all three perspectives passed. Any lane with a redactedBlockReason indicates that perspective did not return a matching typed verdict.",
+                "AFTER CALLING: read the result.summaryForUser string and surface it verbatim or compressed in your reply to the user. acceptanceStatus=verdicts_accepted and durableLinkageStatus=durable_verdicts_accepted mean all requested perspectives passed. status=quick_reviewer_run_incomplete means at least one lane did not produce a matching typed verdict; lanes[].redactedObservationErrors and lanes[].observationStatus indicate why. status=blocked_before_quick_reviewer_run means the helper refused before launching providers; report result.redactedBlockReason as-is. After surfacing summaryForUser, recommend the safeNextActions in result.safeNextActions for follow-up.",
                 "LANE HEARTBEAT: each reviewer lane automatically records one durable flowdesk.lane_heartbeat.v1 evidence record on launch through the runtime reviewer execution bridge; status_live and the chat.message stall card consume that heartbeat as the latest progress signal so the lane shows as progressing_normal while it is still working.",
             ].join(" "),
             args: {
@@ -1757,6 +1995,15 @@ export function createFlowDeskQuickReviewerRunOptInTools(client, defaults) {
                     .array(tool.schema.string())
                     .optional()
                     .describe("Optional subset of reviewer perspectives (policy_security, architecture, verification_implementation). Defaults to all three."),
+                bindings: tool.schema
+                    .array(tool.schema.object({
+                    perspective: tool.schema.string(),
+                    providerQualifiedModelId: tool.schema.string(),
+                    runtimeAgent: tool.schema.string(),
+                    sourceLabel: tool.schema.string().optional(),
+                }))
+                    .optional()
+                    .describe("Optional per-perspective reviewer bindings for multi-model fan-out. Each entry must include perspective, concrete providerQualifiedModelId, and runtimeAgent. When omitted, all perspectives use providerQualifiedModelId/runtimeAgent."),
                 parentSessionId: tool.schema
                     .string()
                     .optional()
@@ -1775,12 +2022,28 @@ export function createFlowDeskQuickReviewerRunOptInTools(client, defaults) {
                     record.runtimeAgent.trim().length > 0
                     ? record.runtimeAgent
                     : defaults.runtimeAgent;
-                if (typeof providerQualifiedModelId !== "string" ||
-                    typeof runtimeAgent !== "string")
-                    return JSON.stringify(redactedQuickReviewerRunBlocked("Quick reviewer run requires providerQualifiedModelId and runtimeAgent (either as args or plugin defaults)."));
                 const perspectives = Array.isArray(record.perspectives)
                     ? record.perspectives.filter((value) => typeof value === "string")
                     : undefined;
+                const bindings = Array.isArray(record.bindings)
+                    ? record.bindings
+                        .filter((value) => isRecord(value))
+                        .map((value) => ({
+                        perspective: value.perspective,
+                        providerQualifiedModelId: value.providerQualifiedModelId,
+                        runtimeAgent: value.runtimeAgent,
+                        ...(typeof value.sourceLabel === "string"
+                            ? { sourceLabel: value.sourceLabel }
+                            : {}),
+                    }))
+                        .filter((value) => typeof value.perspective === "string" &&
+                        typeof value.providerQualifiedModelId === "string" &&
+                        typeof value.runtimeAgent === "string")
+                    : undefined;
+                if (bindings === undefined &&
+                    (typeof providerQualifiedModelId !== "string" ||
+                        typeof runtimeAgent !== "string"))
+                    return JSON.stringify(redactedQuickReviewerRunBlocked("Quick reviewer run requires providerQualifiedModelId and runtimeAgent (either as args or plugin defaults) unless per-perspective bindings are supplied."));
                 const result = await executeFlowDeskQuickReviewerRunV1({
                     client,
                     prompt,
@@ -1789,6 +2052,7 @@ export function createFlowDeskQuickReviewerRunOptInTools(client, defaults) {
                     allowProviderCall: record.allowProviderCall === true,
                     developerModeAcknowledged: record.developerModeAcknowledged === true,
                     ...(perspectives === undefined ? {} : { perspectives }),
+                    ...(bindings === undefined ? {} : { bindings }),
                     ...(typeof record.parentSessionId === "string" &&
                         record.parentSessionId.length > 0
                         ? { parentSessionId: record.parentSessionId }
@@ -1805,6 +2069,78 @@ export function createFlowDeskQuickReviewerRunOptInTools(client, defaults) {
         }),
     };
 }
+export function createFlowDeskAgentTaskRunOptInTools(input) {
+    if (!input.client || !input.durableStateRoot)
+        return undefined;
+    const client = input.client;
+    const rootDir = input.durableStateRoot;
+    return {
+        [flowdeskAgentTaskRunToolName]: tool({
+            description: [
+                "Run a single task on a specific agent and model, returning the result text.",
+                "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).",
+                "After calling, use flowdesk_status_live to check the lane status.",
+            ].join(" "),
+            args: {
+                workflowId: tool.schema.string().describe("Workflow id (e.g. workflow-xxx)"),
+                taskDescription: tool.schema.string().max(20_000).describe("The task prompt to send to the agent"),
+                agentName: tool.schema.string().describe("Agent name (e.g. reviewer-claude-opus, reviewer-gpt-frontier)"),
+                providerQualifiedModelId: tool.schema.string().describe("Concrete model id (e.g. anthropic/claude-opus-4-7)"),
+                parentSessionId: tool.schema.string().optional().describe("Parent session id"),
+                developerModeAcknowledged: tool.schema.boolean(),
+                allowProviderCall: tool.schema.boolean(),
+            },
+            async execute(args, ctx) {
+                const record = isRecord(args) ? args : {};
+                if (record.developerModeAcknowledged !== true)
+                    return JSON.stringify({ status: "blocked", reason: "developerModeAcknowledged must be true" });
+                if (record.allowProviderCall !== true)
+                    return JSON.stringify({ status: "blocked", reason: "allowProviderCall must be true" });
+                const workflowId = typeof record.workflowId === "string" ? record.workflowId : undefined;
+                const taskDescription = typeof record.taskDescription === "string" ? record.taskDescription : undefined;
+                const agentName = typeof record.agentName === "string" ? record.agentName : undefined;
+                const providerQualifiedModelId = typeof record.providerQualifiedModelId === "string" ? record.providerQualifiedModelId : undefined;
+                if (!workflowId || !taskDescription || !agentName || !providerQualifiedModelId)
+                    return JSON.stringify({ status: "blocked", reason: "workflowId, taskDescription, agentName, and providerQualifiedModelId are required" });
+                const ctxRecord = isRecord(ctx) ? ctx : {};
+                const parentSessionId = typeof record.parentSessionId === "string" && record.parentSessionId.length > 0
+                    ? record.parentSessionId
+                    : typeof ctxRecord.sessionID === "string" && ctxRecord.sessionID.length > 0
+                        ? ctxRecord.sessionID
+                        : "";
+                const taskId = `task-${Date.now().toString(36)}`;
+                const laneId = `lane-task-${Date.now().toString(36)}`;
+                const result = await executeFlowDeskAgentTaskV1({
+                    workflowId,
+                    taskId,
+                    laneId,
+                    agentRef: `agent-${agentName}`,
+                    providerQualifiedModelId,
+                    promptText: taskDescription,
+                    parentSessionId,
+                    rootDir,
+                    client,
+                });
+                return JSON.stringify({
+                    workflowId,
+                    laneId,
+                    taskId,
+                    status: result.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}`,
+                });
+            },
+        }),
+    };
+}
 function redactedManagedFallbackRegateBlocked(reason) {
     return {
         adapterProfile: "managed_fallback_regate_orchestrator",
@@ -1922,6 +2258,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)
@@ -2057,6 +2424,170 @@ 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 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 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);
+}
 function laneHeartbeatWriterConfigFromOptions(options) {
     const value = options?.[flowdeskLaneHeartbeatWriterOption];
     const enabledFromBool = value === true;
@@ -2209,10 +2740,11 @@ export function createFlowDeskStatusLiveOptInTools(config) {
         [flowdeskStatusLiveToolName]: tool({
             description: [
                 "Return a live FlowDesk status summary by reloading durable session evidence under the configured FlowDesk state root, including reviewer verdict counts, reviewer fan-out plans, runtime lane lifecycle records, fallback regate plans, exact-model availability cache entries, provider acquisition results, and a lane heartbeat stall projection that classifies each FlowDesk-owned lane as progressing_normal, progressing_late, stalled, terminal, or unknown based on the most recent lifecycle update.",
-                "WHEN TO USE: the user asks about recent FlowDesk activity, current workflow progress, recent reviewer results, ongoing or stalled runs, lanes that have stopped logging, lanes that look stuck, or what has been recorded so far. Trigger on English phrases such as 'status', 'what happened', 'recent activity', 'progress', 'where are we', 'how is it going', 'recent reviews', 'recent runs', 'is it stuck', 'stalled', 'no log', 'no update', 'is anything frozen', and Korean phrases such as '상태', '어디까지', '진행 상황', '진행됐', '오늘 작업', '오늘 뭐했', '최근 활동', '최근 리뷰', '지금 어디', '상태 요약', '워크플로우 상태', '멈춘 것 같아', '멈췄어', '응답이 없어', '아무 로그도 없', '오래 걸리는', '진행이 안돼'.",
+                "WHEN TO USE: the user asks about recent FlowDesk activity, current workflow progress, recent reviewer results, ongoing or stalled runs, lanes that have stopped logging, lanes that look stuck, or what has been recorded so far. Trigger on English phrases such as 'status', 'what happened', 'recent activity', 'progress', 'where are we', 'how is it going', 'recent reviews', 'recent runs', 'is it stuck', 'stalled', 'no log', 'no update', 'is anything frozen', 'last review', 'just now', 'earlier result', and Korean phrases such as '상태', '어디까지', '진행 상황', '진행됐', '오늘 작업', '오늘 뭐했', '최근 활동', '최근 리뷰', '지금 어디', '상태 요약', '워크플로우 상태', '멈춘 것 같아', '멈췄어', '응답이 없어', '아무 로그도 없', '오래 걸리는', '진행이 안돼', '방금', '직전', '조금 전', '이전', '최근에 한 거', '아까 한 거', '결과 보여줘'.",
+                "ALSO PROACTIVELY USE: as a follow-up after invoking a real-work FlowDesk tool (quick_reviewer_run, quick_fallback_run, managed_dispatch). If the user asks a vague follow-up about the just-completed work ('잘 됐어?', 'how did it go?', '결과는?'), call this tool with the just-created workflowId to pull durable evidence instead of guessing from memory.",
                 "WHEN NOT TO USE: provider usage/quota questions (use flowdesk_provider_usage_live), multi-perspective code reviews (use flowdesk_quick_reviewer_run), or unrelated general chat.",
                 "INVOKE WITH: optional workflowId. When omitted, the tool lists the most recently modified durable workflows (default up to 5). The plugin user already opted in to durable status evidence reload at configuration time, so this tool can be called automatically without per-call confirmation.",
-                "AFTER CALLING: summarize per-workflow durable evidence counts in plain language for the user. Mention reviewer verdict labels (pass / changes_required / blocked / inconclusive), lane lifecycle states (running, complete, invocation_failed), the most recent fallback_regate_plan state, the most recent provider acquisition status, and any stalled or progressing_late lanes reported in worstLaneStallClassification with totalStalledLaneCount and totalProgressingLateLaneCount. Per-lane entries inside laneStallProjection.entries can also carry expectedNextHeartbeatOverdue=true plus secondsPastExpectedNextHeartbeat to indicate that the heartbeat's own expected_next_heartbeat_at has passed, which is a diagnostic hint independent of the configurable stall threshold. If stalled lanes are present, surface the laneStallProjection safe next actions (/flowdesk-status, /flowdesk-retry, /flowdesk-resume, /flowdesk-abort, /flowdesk-doctor, /flowdesk-export-debug) without auto-retrying, auto-aborting, or auto-fallbacking on the user's behalf. If no workflow returned evidence, say so plainly. Never echo raw provider/auth/token payloads.",
+                "AFTER CALLING: read result.summaryForUser and surface that as the headline reply. If the user needs more detail, mention reviewer verdict labels (pass / changes_required / blocked / inconclusive), lane lifecycle states (running, complete, invocation_failed), the most recent fallback_regate_plan state, the most recent provider acquisition status, and any stalled or progressing_late lanes reported in worstLaneStallClassification with totalStalledLaneCount and totalProgressingLateLaneCount. Per-lane entries inside laneStallProjection.entries can also carry expectedNextHeartbeatOverdue=true plus secondsPastExpectedNextHeartbeat to indicate that the heartbeat's own expected_next_heartbeat_at has passed, which is a diagnostic hint independent of the configurable stall threshold. If stalled lanes are present, surface the laneStallProjection safe next actions (/flowdesk-status, /flowdesk-retry, /flowdesk-resume, /flowdesk-abort, /flowdesk-doctor, /flowdesk-export-debug) without auto-retrying, auto-aborting, or auto-fallbacking on the user's behalf. If no workflow returned evidence, say so plainly. Never echo raw provider/auth/token payloads.",
             ].join(" "),
             args: {
                 workflowId: tool.schema
@@ -2283,6 +2815,11 @@ function quickReviewerRunDefaultsFromOptions(options) {
     const option = options?.[flowdeskQuickReviewerRunOption];
     if (!isRecord(option))
         return {};
+    const optionRoot = typeof option.durableStateRoot === "string" &&
+        option.durableStateRoot.trim().length > 0
+        ? option.durableStateRoot
+        : undefined;
+    const rootDir = optionRoot ?? durableStateRootFromOptions(options);
     return {
         ...(typeof option.providerQualifiedModelId === "string" &&
             option.providerQualifiedModelId.trim().length > 0
@@ -2296,10 +2833,18 @@ function quickReviewerRunDefaultsFromOptions(options) {
             option.sourceLabel.trim().length > 0
             ? { sourceLabel: option.sourceLabel }
             : {}),
-        ...(typeof option.durableStateRoot === "string" &&
-            option.durableStateRoot.trim().length > 0
-            ? { rootDir: option.durableStateRoot }
-            : {}),
+        ...(rootDir === undefined ? {} : { rootDir }),
+    };
+}
+function watchdogConfigFromOptions(options) {
+    const w = options?.[flowdeskWatchdogOption];
+    if (!isRecord(w) || w.enabled !== true)
+        return undefined;
+    return {
+        enabled: true,
+        intervalMs: Math.max(10_000, typeof w.intervalMs === "number" ? w.intervalMs : 30_000),
+        stallThresholdMs: typeof w.stallThresholdMs === "number" ? w.stallThresholdMs : 3 * 60_000,
+        mcpTriggerEnabled: w.mcpTriggerEnabled === true,
     };
 }
 const flowdeskServerPlugin = async (input, options) => {
@@ -2350,6 +2895,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 = {
@@ -2369,14 +2917,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']"
@@ -2412,6 +2961,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]) &&
@@ -2522,16 +3088,140 @@ 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));
+    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;
+        const agentTaskRunRoot = durableStateRootFromOptions(options);
+        const agentTaskRunTools = createFlowDeskAgentTaskRunOptInTools({
+            client: agentTaskRunClient,
+            durableStateRoot: agentTaskRunRoot,
+        });
+        if (agentTaskRunTools !== undefined)
+            Object.assign(tools, agentTaskRunTools);
+    }
+    // P8 Background Watchdog
+    const watchdogConfig = watchdogConfigFromOptions(options);
+    const chatStallAlertRaw = options?.[flowdeskChatMessageStallAlertOption];
+    const guardedAutoAbortForWatchdog = isRecord(chatStallAlertRaw) && isRecord(chatStallAlertRaw.guardedAutoAbort)
+        ? (() => {
+            const raw = chatStallAlertRaw.guardedAutoAbort;
+            const cfg = {
+                autoAbortOnStall: raw.autoAbortOnStall === true,
+            };
+            if (typeof raw.preAbortWarningMs === "number")
+                cfg.preAbortWarningMs = Math.floor(raw.preAbortWarningMs);
+            if (typeof raw.guardSignOffPath === "string")
+                cfg.guardSignOffPath = raw.guardSignOffPath;
+            if (typeof raw.guardHmacKey === "string")
+                cfg.guardHmacKey = raw.guardHmacKey;
+            if (typeof raw.productionMode === "boolean")
+                cfg.productionMode = raw.productionMode;
+            if (raw.autoRetryAfterAbort === true)
+                cfg.autoRetryAfterAbort = true;
+            if (typeof raw.maxAutoRetries === "number")
+                cfg.maxAutoRetries = Math.min(2, Math.max(1, Math.floor(raw.maxAutoRetries)));
+            return cfg;
+        })()
+        : undefined;
+    const durableStateRoot = durableStateRootFromOptions(options);
+    if (watchdogConfig?.enabled === true && guardedAutoAbortForWatchdog !== undefined && durableStateRoot !== undefined) {
+        const capturedClient = isRecord(input) && isManagedDispatchBetaClient(input.client) ? input.client : undefined;
+        const capturedParentSessionId = "";
+        const capturedRootDir = durableStateRoot;
+        const capturedConfig = guardedAutoAbortForWatchdog;
+        const watchdogInterval = setInterval(() => {
+            runFlowDeskWatchdogCycleV1({
+                config: capturedConfig,
+                rootDir: capturedRootDir,
+                client: capturedClient,
+                parentSessionId: capturedParentSessionId,
+                now: new Date(),
+            }).catch(() => {
+                // errors are swallowed — watchdog must not crash the plugin
+            });
+        }, watchdogConfig.intervalMs ?? 30_000);
+        // Allow the process to exit even if the interval is still active
+        watchdogInterval.unref();
+        process.once("exit", () => clearInterval(watchdogInterval));
+        process.once("SIGTERM", () => clearInterval(watchdogInterval));
+        if (watchdogConfig.mcpTriggerEnabled === true) {
+            tools[flowdeskWatchdogTriggerToolName] = tool({
+                description: "Trigger one watchdog cycle manually. Called by external flowdesk-watchdog process (Option A). Requires guardedAutoAbort config.",
+                args: { parentSessionId: tool.schema.string().optional() },
+                async execute(args) {
+                    const psi = isRecord(args) && typeof args.parentSessionId === "string" ? args.parentSessionId : "";
+                    const result = await runFlowDeskWatchdogCycleV1({
+                        config: capturedConfig,
+                        rootDir: capturedRootDir,
+                        client: capturedClient,
+                        parentSessionId: psi,
+                        now: new Date(),
+                    });
+                    return JSON.stringify({
+                        cycleAt: result.cycleAt,
+                        guardValid: result.guardValid,
+                        lanesChecked: result.lanesChecked,
+                        lanesAborted: result.lanesAborted,
+                        lanesRetried: result.lanesRetried,
+                        lanesFailed: result.lanesFailed,
+                        skippedReason: result.skippedReason,
+                    });
+                },
+            });
+        }
+    }
+    else if (watchdogConfig?.mcpTriggerEnabled === true && guardedAutoAbortForWatchdog !== undefined && durableStateRoot !== undefined) {
+        // mcpTriggerEnabled without setInterval (Option A standalone)
+        const capturedClient = isRecord(input) && isManagedDispatchBetaClient(input.client) ? input.client : undefined;
+        const capturedRootDir = durableStateRoot;
+        const capturedConfig = guardedAutoAbortForWatchdog;
+        tools[flowdeskWatchdogTriggerToolName] = tool({
+            description: "Trigger one watchdog cycle manually. Called by external flowdesk-watchdog process (Option A). Requires guardedAutoAbort config.",
+            args: { parentSessionId: tool.schema.string().optional() },
+            async execute(args) {
+                const psi = isRecord(args) && typeof args.parentSessionId === "string" ? args.parentSessionId : "";
+                const result = await runFlowDeskWatchdogCycleV1({
+                    config: capturedConfig,
+                    rootDir: capturedRootDir,
+                    client: capturedClient,
+                    parentSessionId: psi,
+                    now: new Date(),
+                });
+                return JSON.stringify({
+                    cycleAt: result.cycleAt,
+                    guardValid: result.guardValid,
+                    lanesChecked: result.lanesChecked,
+                    lanesAborted: result.lanesAborted,
+                    lanesRetried: result.lanesRetried,
+                    lanesFailed: result.lanesFailed,
+                    skippedReason: result.skippedReason,
+                });
+            },
+        });
+    }
     if (!naturalLanguageRoutingEnabled)
         return { tool: tools };
-    const stallAlertOption = chatMessageStallAlertOptionsFrom(options, statusLiveConfig);
+    const stallAlertOption = chatMessageStallAlertOptionsFrom(options, statusLiveConfig, isRecord(input) && isManagedDispatchBetaClient(input.client)
+        ? input.client
+        : undefined);
     return {
         tool: tools,
         "chat.message": createFlowDeskNaturalLanguageChatMessageHook(() => new Date(), localSession, stallAlertOption, durableStateRootFromOptions(options)),
     };
 };
 export const flowdeskChatMessageStallAlertOption = "chatMessageStallAlert";
-function chatMessageStallAlertOptionsFrom(options, statusLiveConfig) {
+function chatMessageStallAlertOptionsFrom(options, statusLiveConfig, sdkClient) {
     const raw = options?.[flowdeskChatMessageStallAlertOption];
     if (raw === false)
         return undefined;
@@ -2567,6 +3257,55 @@ function chatMessageStallAlertOptionsFrom(options, statusLiveConfig) {
     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 = {
+            autoAbortOnStall: rawGuard.autoAbortOnStall === true,
+        };
+        if (typeof rawGuard.preAbortWarningMs === "number" && rawGuard.preAbortWarningMs > 0)
+            guardedAutoAbort.preAbortWarningMs = Math.floor(rawGuard.preAbortWarningMs);
+        if (typeof rawGuard.guardSignOffPath === "string" && rawGuard.guardSignOffPath.trim().length > 0)
+            guardedAutoAbort.guardSignOffPath = rawGuard.guardSignOffPath;
+        if (typeof rawGuard.guardHmacKey === "string" && rawGuard.guardHmacKey.length > 0)
+            guardedAutoAbort.guardHmacKey = rawGuard.guardHmacKey;
+        if (typeof rawGuard.productionMode === "boolean")
+            guardedAutoAbort.productionMode = rawGuard.productionMode;
+        if (rawGuard.autoRetryAfterAbort === true)
+            guardedAutoAbort.autoRetryAfterAbort = true;
+        if (typeof rawGuard.maxAutoRetries === "number")
+            guardedAutoAbort.maxAutoRetries = Math.min(2, Math.max(1, Math.floor(rawGuard.maxAutoRetries)));
+        if (typeof rawGuard.useLiveSdkSessionHealth === "boolean")
+            guardedAutoAbort.useLiveSdkSessionHealth = rawGuard.useLiveSdkSessionHealth;
+        if (guardedAutoAbort.useLiveSdkSessionHealth === true && sdkClient !== undefined)
+            guardedAutoAbort.sdkClient = sdkClient;
+        if (isRecord(rawGuard.sdkSessionHealth)) {
+            const status = rawGuard.sdkSessionHealth.status;
+            if (status === "api_responsive")
+                guardedAutoAbort.sdkSessionHealth = { status };
+            if (status === "api_timeout")
+                guardedAutoAbort.sdkSessionHealth = {
+                    status,
+                    reason: typeof rawGuard.sdkSessionHealth.reason === "string"
+                        ? rawGuard.sdkSessionHealth.reason
+                        : "configured_api_timeout",
+                };
+            if (status === "unknown")
+                guardedAutoAbort.sdkSessionHealth = {
+                    status,
+                    reason: typeof rawGuard.sdkSessionHealth.reason === "string"
+                        ? rawGuard.sdkSessionHealth.reason
+                        : "configured_unknown",
+                };
+        }
+        config.guardedAutoAbort = guardedAutoAbort;
+    }
     return config;
 }
 export const flowdeskOpenCodeServerPlugin = {