@flowdesk/opencode-plugin 0.1.11 → 0.1.12

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,10 @@ 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 { executeFlowDeskStatusLiveV1, } from "./status-live-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";
@@ -31,6 +35,8 @@ export const flowdeskStatusLiveOption = "statusLive";
 export const flowdeskQuickFallbackRunOption = "quickFallbackRun";
 export const flowdeskLaneHeartbeatWriterOption = "laneHeartbeatWriter";
 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 +46,8 @@ 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 flowdeskAgentTaskRunOption = "agentTaskRun";
+export const flowdeskAgentTaskRunToolName = "flowdesk_agent_task_run";
 const flowdeskChatSuggestionDuplicateWindowMs = 10_000;
 const disabledAuthority = {
     productionRegistrationEligible: false,
@@ -1163,6 +1171,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 +1193,47 @@ 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)
+            : { 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;
+            if (stalledAlertReady || lateAlertReady) {
+                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 +1249,42 @@ 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 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,21 +1303,84 @@ 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
+            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)
-            .map((workflow) => {
+            .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 primary = stalledEntry ?? lateEntry;
+            if (stallAlert.guardedAutoAbort !== undefined &&
+                stalledEntry !== undefined &&
+                (workflow.stalledLaneCount ?? 0) > 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,
@@ -1277,16 +1393,29 @@ async function collectStallAlertSummary(stallAlert, clock) {
                     ? {}
                     : { failureHint: primary.failureHint }),
             };
-        });
+        }));
+        if (workflowSummaries.length === 0) {
+            return { status: "none" };
+        }
         return {
-            worstClassification: result.worstLaneStallClassification ?? "unknown",
-            totalStalled: result.totalStalledLaneCount ?? 0,
-            totalLate: result.totalProgressingLateLaneCount ?? 0,
-            workflowSummaries,
+            status: "ok",
+            data: {
+                worstClassification: result.worstLaneStallClassification ?? "unknown",
+                totalStalled: result.totalStalledLaneCount ?? 0,
+                totalLate: result.totalProgressingLateLaneCount ?? 0,
+                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) {
@@ -1322,6 +1451,11 @@ function stallAlertText(summary) {
         lines.push(`- workflow ${workflow.workflowId}: ${counts} (last signal ~${minutes}m ago, ${hint}).`);
     }
     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))
+            lines.push(`- ${line}`);
+    }
     lines.push("Safe next actions:");
     for (const action of [
         "/flowdesk-status",
@@ -1686,6 +1820,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 +1854,7 @@ function redactedQuickReviewerRunToolResult(result) {
         linkedLifecycleCount: result.linkedLifecycleCount,
         acceptedPerspectives: result.acceptedPerspectives,
         redactedBlockReason: result.redactedBlockReason,
+        summaryForUser: result.summaryForUser,
         safeNextActions: result.safeNextActions,
         authority: result.authority,
     };
@@ -1727,12 +1863,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 +1894,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 +1921,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 +1951,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 +1968,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",
@@ -2057,6 +2292,10 @@ function isLaneHeartbeatWriterEnabled(options) {
     const value = options?.[flowdeskLaneHeartbeatWriterOption];
     return value === true || (isRecord(value) && value.enabled === true);
 }
+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 +2448,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 +2523,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 +2541,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) => {
@@ -2522,16 +2775,129 @@ const flowdeskServerPlugin = async (input, options) => {
         : undefined;
     if (laneHeartbeatWriterConfig !== undefined)
         Object.assign(tools, createFlowDeskLaneHeartbeatWriterOptInTools(laneHeartbeatWriterConfig));
+    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 +2933,48 @@ function chatMessageStallAlertOptionsFrom(options, statusLiveConfig) {
     if (recordRaw !== undefined &&
         typeof recordRaw.includeProgressingLate === "boolean")
         config.includeProgressingLate = recordRaw.includeProgressingLate;
+    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 = {