@flowdesk/opencode-plugin 0.1.12 → 0.1.13

package/dist/server.js

@@ -12,7 +12,10 @@ 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";
@@ -34,6 +37,9 @@ 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";
@@ -46,6 +52,9 @@ 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;
@@ -1194,7 +1203,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 +1226,9 @@ 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);
+            if (stalledAlertReady || lateAlertReady || progressCardReady) {
                 stallDedupKey = stallAlertDuplicateKey(request, summary);
                 stallTextToAppend = stallAlertText(summary);
             }
@@ -1257,6 +1270,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 +1345,34 @@ 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 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 &&
-                (workflow.stalledLaneCount ?? 0) > 0) {
+                scopedStalledCount > 0) {
                 // Reconcile stale pending retry plans on each stall check
                 try {
                     reconcileStalePendingRetryPlansV1({
@@ -1383,8 +1434,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 +1443,43 @@ export async function collectStallAlertResult(stallAlert, clock, deps = {}) {
                 ...(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 {
             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 +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}`;
@@ -1432,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.`);
     }
@@ -1449,8 +1538,17 @@ 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}`);
+        }
     }
-    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 +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) {
@@ -2157,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)
@@ -2292,6 +2424,166 @@ 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);
@@ -2603,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 = {
@@ -2622,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']"
@@ -2665,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]) &&
@@ -2775,6 +3088,17 @@ 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;
@@ -2933,6 +3257,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 = {