@flowdesk/opencode-plugin 0.1.12 → 0.1.14

package/dist/stall-recovery.js

@@ -1,9 +1,12 @@
 import { applyFlowDeskSessionEvidenceWriteIntentsV1, prepareFlowDeskSessionEvidenceWriteIntentV1, reloadFlowDeskSessionEvidenceV1, projectFlowDeskLaneStallV1, } from "@flowdesk/core";
-import { createHmac, createHash, timingSafeEqual } from "node:crypto";
+import { createHmac, createHash, timingSafeEqual, randomBytes } from "node:crypto";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { launchFlowDeskInjectedSdkRuntimeLaneFromPlanV1, } from "./managed-dispatch-adapter.js";
 import { FLOWDESK_TIMEOUT_DEFAULTS, FlowDeskTimeoutError, withTimeout, } from "./shared/with-timeout.js";
+import { executeFlowDeskAgentTaskV1, AGENT_TASK_CHILD_SESSION_SCHEMA_VERSION, sanitizeFlowDeskTaskResultTextV1 } from "./agent-task-runner.js";
+import { observeFlowDeskAgentTaskOutputV1 } from "./agent-task-output.js";
+import { refreshFlowDeskCompletionUiCachesV1 } from "./completion-ui-cache.js";
 export async function checkSdkSessionApiHealthV1(client, sessionId, timeouts = {}) {
     if (typeof client.session.messages !== "function") {
         return { status: "unknown", reason: "sdk_messages_not_available" };
@@ -423,6 +426,15 @@ export function evaluateGuardedAutoAbortHookV1(input) {
 function isReviewerLaneContext(value) {
     return isRecord(value) && value.schema_version === "flowdesk.reviewer_lane_context.v1";
 }
+function isAgentTaskContext(value) {
+    return isRecord(value) && value.schema_version === "flowdesk.agent_task_context.v1";
+}
+function isTaskFailed(value) {
+    return isRecord(value) && value.schema_version === "flowdesk.task_failed.v1";
+}
+function isTaskResult(value) {
+    return isRecord(value) && value.schema_version === "flowdesk.task_result.v1";
+}
 function isPendingRetryPlan(value) {
     return isRecord(value) && value.schema_version === "flowdesk.pending_retry_plan.v1";
 }
@@ -432,6 +444,152 @@ function isRetryExecuted(value) {
 function isRetryFailed(value) {
     return isRecord(value) && value.schema_version === "flowdesk.retry_failed.v1";
 }
+function latestLifecycleByLane(records) {
+    const byLane = new Map();
+    for (const record of records) {
+        const existing = byLane.get(record.lane_id);
+        if (existing === undefined ||
+            Date.parse(record.updated_at) > Date.parse(existing.updated_at) ||
+            (Date.parse(record.updated_at) === Date.parse(existing.updated_at) && record.state > existing.state)) {
+            byLane.set(record.lane_id, record);
+        }
+    }
+    return byLane;
+}
+function latestTaskFailedByLane(records) {
+    const byLane = new Map();
+    for (const record of records) {
+        const existing = byLane.get(record.lane_id);
+        if (existing === undefined || Date.parse(record.created_at) >= Date.parse(existing.created_at)) {
+            byLane.set(record.lane_id, record);
+        }
+    }
+    return byLane;
+}
+function latestTaskResultByLane(records) {
+    const byLane = new Map();
+    for (const record of records) {
+        const existing = byLane.get(record.lane_id);
+        if (existing === undefined || Date.parse(record.created_at) >= Date.parse(existing.created_at)) {
+            byLane.set(record.lane_id, record);
+        }
+    }
+    return byLane;
+}
+function agentTaskContextByLane(records) {
+    const byLane = new Map();
+    for (const record of records)
+        byLane.set(record.lane_id, record);
+    return byLane;
+}
+/**
+ * Safe local cleanup/backfill for legacy `flowdesk_agent_task_run` lanes.
+ *
+ * Older agent-task results/failures could persist `task_result.v1` or
+ * `task_failed.v1` while the latest `lane_lifecycle` remained
+ * `created`/`running`, which made status cards keep reporting stale active
+ * lanes. This helper only writes terminal lifecycle evidence when existing
+ * durable evidence already proves the agent-task ended.
+ * It never launches, aborts, retries, enables dispatch authority, or rewrites
+ * existing evidence.
+ */
+export function backfillTerminalAgentTaskFailedLanesV1(input) {
+    const reloaded = reloadFlowDeskSessionEvidenceV1({ rootDir: input.rootDir, workflowId: input.workflowId });
+    if (!reloaded.ok)
+        return { status: "backfill_skipped", workflowId: input.workflowId, reason: "session_evidence_reload_failed" };
+    const lifecycles = [];
+    const taskResults = [];
+    const taskFailures = [];
+    const contexts = [];
+    for (const entry of reloaded.entries) {
+        if (isLaneLifecycleRecord(entry.record))
+            lifecycles.push(entry.record);
+        else if (isTaskResult(entry.record))
+            taskResults.push(entry.record);
+        else if (isTaskFailed(entry.record))
+            taskFailures.push(entry.record);
+        else if (isAgentTaskContext(entry.record))
+            contexts.push(entry.record);
+    }
+    const latestLifecycle = latestLifecycleByLane(lifecycles);
+    const latestResult = latestTaskResultByLane(taskResults);
+    const latestFailure = latestTaskFailedByLane(taskFailures);
+    const contextByLane = agentTaskContextByLane(contexts);
+    const observedAt = (input.now ?? new Date()).toISOString();
+    const token = timestampToken(input.now ?? new Date());
+    const terminalEvidenceIds = [];
+    let lanesScanned = 0;
+    for (const [laneId, result] of latestResult) {
+        const latest = latestLifecycle.get(laneId);
+        if (latest === undefined)
+            continue;
+        lanesScanned++;
+        if (!ABORT_ELIGIBLE_LANE_STATES.has(latest.state))
+            continue;
+        const context = contextByLane.get(laneId);
+        const evidenceId = `lifecycle-agent-task-terminal-backfill-${safeToken(laneId)}-${token}`;
+        const terminalRecord = {
+            ...latest,
+            workflow_id: result.workflow_id,
+            lane_id: laneId,
+            agent_ref: context?.agent_ref ?? result.agent_ref ?? latest.agent_ref,
+            provider_qualified_model_id: context?.provider_qualified_model_id ?? result.provider_qualified_model_id ?? latest.provider_qualified_model_id,
+            parent_session_ref: context?.parent_session_ref ?? latest.parent_session_ref,
+            state: "incomplete",
+            verdict_ref: undefined,
+            output_ref: `output-${safeToken(result.task_id)}`,
+            updated_at: observedAt,
+            spawned_by: latest.spawned_by ?? "flowdesk",
+            dispatch_authority_enabled: false,
+            providerCall: false,
+            actualLaneLaunch: false,
+            runtimeExecution: false,
+        };
+        if (writeEvidence({ rootDir: input.rootDir, workflowId: input.workflowId, evidenceId, record: terminalRecord })) {
+            terminalEvidenceIds.push(evidenceId);
+        }
+    }
+    for (const [laneId, failed] of latestFailure) {
+        if (latestResult.has(laneId))
+            continue;
+        const latest = latestLifecycle.get(laneId);
+        if (latest === undefined)
+            continue;
+        lanesScanned++;
+        if (!ABORT_ELIGIBLE_LANE_STATES.has(latest.state))
+            continue;
+        const context = contextByLane.get(laneId);
+        const state = failed.failure_category === "no_response" ? "no_output" : "invocation_failed";
+        const evidenceId = `lifecycle-agent-task-terminal-backfill-${safeToken(laneId)}-${token}`;
+        const terminalRecord = {
+            ...latest,
+            workflow_id: failed.workflow_id,
+            lane_id: laneId,
+            agent_ref: context?.agent_ref ?? failed.agent_ref ?? latest.agent_ref,
+            provider_qualified_model_id: context?.provider_qualified_model_id ?? failed.provider_qualified_model_id ?? latest.provider_qualified_model_id,
+            parent_session_ref: context?.parent_session_ref ?? latest.parent_session_ref,
+            state,
+            verdict_ref: undefined,
+            output_ref: undefined,
+            updated_at: observedAt,
+            spawned_by: latest.spawned_by ?? "flowdesk",
+            dispatch_authority_enabled: false,
+            providerCall: false,
+            actualLaneLaunch: false,
+            runtimeExecution: false,
+        };
+        if (writeEvidence({ rootDir: input.rootDir, workflowId: input.workflowId, evidenceId, record: terminalRecord })) {
+            terminalEvidenceIds.push(evidenceId);
+        }
+    }
+    return {
+        status: "backfill_completed",
+        workflowId: input.workflowId,
+        lanesScanned,
+        lanesTerminalized: terminalEvidenceIds.length,
+        terminalLifecycleEvidenceIds: terminalEvidenceIds,
+    };
+}
 /**
  * On startup/reload: any `pending_retry_plan` in `launched` state with no matching
  * `retry_executed` or `retry_failed` within 10 minutes of `created_at` is reconciled
@@ -522,6 +680,19 @@ function buildRetryLaunchPlanFromContextV1(context, newLaneId, parentSessionId)
         runtimeExecution: false,
     };
 }
+function parentSessionIdFromRef(parentSessionRef) {
+    return parentSessionRef.startsWith("ses-") && parentSessionRef.length > "ses-".length
+        ? parentSessionRef.slice("ses-".length)
+        : undefined;
+}
+function writeRetryFailedV1(input) {
+    writeEvidence({
+        rootDir: input.rootDir,
+        workflowId: input.workflowId,
+        evidenceId: input.evidenceId,
+        record: input.record,
+    });
+}
 /**
  * Evaluate guarded auto-retry hook following the execution order from the design doc exactly.
  * Called after `evaluateGuardedAutoAbortHookV1` returns `auto_abort_executed`.
@@ -572,7 +743,8 @@ export async function evaluateGuardedAutoRetryHookV1(input) {
             redactedReason: "sdk_client_missing_or_session_create_unavailable",
         };
     }
-    // Step 4: Load reviewer_lane_context.v1 for laneId
+    // Step 4: Load retry context for laneId. Reviewer context remains the
+    // preferred P7 path; generic agent tasks fall back to agent_task_context.v1.
     const reloaded = reloadFlowDeskSessionEvidenceV1({
         rootDir: input.rootDir,
         workflowId: input.workflowId,
@@ -580,18 +752,31 @@ export async function evaluateGuardedAutoRetryHookV1(input) {
     if (!reloaded.ok) {
         return { status: "auto_retry_disabled", reason: "context_missing" };
     }
-    const contextEntry = reloaded.entries.find((e) => isReviewerLaneContext(e.record) && e.record.lane_id === input.laneId);
+    const reviewerContextEntry = reloaded.entries.find((e) => isReviewerLaneContext(e.record) && e.record.lane_id === input.laneId);
+    const agentTaskContextEntry = reviewerContextEntry === undefined
+        ? reloaded.entries.find((e) => isAgentTaskContext(e.record) && e.record.lane_id === input.laneId)
+        : undefined;
+    const contextEntry = reviewerContextEntry ?? agentTaskContextEntry;
     if (contextEntry === undefined) {
         return { status: "auto_retry_disabled", reason: "context_missing" };
     }
-    const context = contextEntry.record;
+    const isAgentTaskRetry = reviewerContextEntry === undefined;
+    const reviewerContext = isAgentTaskRetry ? undefined : contextEntry.record;
+    const agentTaskContext = isAgentTaskRetry ? contextEntry.record : undefined;
+    const context = reviewerContext ?? agentTaskContext;
     // Step 5: Verify context.redaction_version present
     if (!context.redaction_version || typeof context.redaction_version !== "string" || context.redaction_version.trim().length === 0) {
         return { status: "auto_retry_disabled", reason: "context_redaction_invalid" };
     }
-    // Step 6: Verify context.workflow_id === workflowId && context.perspective valid
+    // Step 6: Verify context.workflow_id === workflowId and context-specific invariants.
     const VALID_PERSPECTIVES = new Set(["policy_security", "architecture", "verification_implementation"]);
-    if (context.workflow_id !== input.workflowId || !VALID_PERSPECTIVES.has(context.perspective)) {
+    if (context.workflow_id !== input.workflowId) {
+        return { status: "auto_retry_disabled", reason: "invariant_violated" };
+    }
+    if (reviewerContext !== undefined && !VALID_PERSPECTIVES.has(reviewerContext.perspective)) {
+        return { status: "auto_retry_disabled", reason: "invariant_violated" };
+    }
+    if (agentTaskContext !== undefined && agentTaskContext.prompt_text_truncated === true) {
         return { status: "auto_retry_disabled", reason: "invariant_violated" };
     }
     // Step 7: Count cap — retry_executed + retry_failed + pending_retry_plan(pending|launched) for laneId
@@ -674,8 +859,116 @@ export async function evaluateGuardedAutoRetryHookV1(input) {
             redactedReason: "pending_retry_plan_write_failed",
         };
     }
+    if (agentTaskContext !== undefined) {
+        const retryParentSessionId = parentSessionIdFromRef(agentTaskContext.parent_session_ref);
+        if (retryParentSessionId === undefined) {
+            const failedId = `retry-failed-agent-task-parent-${safeToken(newLaneId)}-${retryToken}`;
+            writeRetryFailedV1({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                evidenceId: failedId,
+                record: {
+                    schema_version: "flowdesk.retry_failed.v1",
+                    workflow_id: input.workflowId,
+                    original_lane_id: input.laneId,
+                    new_lane_id: newLaneId,
+                    retry_attempt: retryAttempt,
+                    failure_category: "invariant_violated",
+                    redacted_reason: "agent_task_context_parent_session_ref_invalid",
+                    created_at: now.toISOString(),
+                    dispatch_authority_enabled: false,
+                },
+            });
+            writeEvidence({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                evidenceId: `${pendingRetryEvidenceId}-failed`,
+                record: { ...pendingRecord, status: "failed" },
+            });
+            return {
+                status: "retry_failed",
+                failureCategory: "invariant_violated",
+                redactedReason: "agent_task_context_parent_session_ref_invalid",
+            };
+        }
+        const taskResult = await executeFlowDeskAgentTaskV1({
+            workflowId: input.workflowId,
+            taskId: agentTaskContext.task_id,
+            laneId: newLaneId,
+            agentRef: agentTaskContext.agent_ref,
+            providerQualifiedModelId: agentTaskContext.provider_qualified_model_id,
+            promptText: agentTaskContext.prompt_text,
+            parentSessionId: retryParentSessionId,
+            rootDir: input.rootDir,
+            client: input.client,
+            timeoutMs: timeoutMs,
+            _nudgeQuietPeriodMs: input._nudgeQuietPeriodMs,
+            _messagesTimeoutMs: input._messagesTimeoutMs,
+        });
+        if (taskResult.status === "task_failed") {
+            const failedId = `retry-failed-agent-task-${safeToken(newLaneId)}-${retryToken}`;
+            writeRetryFailedV1({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                evidenceId: failedId,
+                record: {
+                    schema_version: "flowdesk.retry_failed.v1",
+                    workflow_id: input.workflowId,
+                    original_lane_id: input.laneId,
+                    new_lane_id: newLaneId,
+                    retry_attempt: retryAttempt,
+                    failure_category: taskResult.failureCategory === "no_response" ? "indeterminate_launch" : "sdk_create_failed",
+                    redacted_reason: `agent_task_retry_${taskResult.failureCategory}`,
+                    created_at: now.toISOString(),
+                    dispatch_authority_enabled: false,
+                },
+            });
+            writeEvidence({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                evidenceId: `${pendingRetryEvidenceId}-failed`,
+                record: { ...pendingRecord, status: "failed" },
+            });
+            return {
+                status: "retry_failed",
+                failureCategory: taskResult.failureCategory,
+                redactedReason: taskResult.redactedReason,
+            };
+        }
+        const executedId = `retry-executed-${safeToken(newLaneId)}-${retryToken}`;
+        const executedRecord = {
+            schema_version: "flowdesk.retry_executed.v1",
+            workflow_id: input.workflowId,
+            original_lane_id: input.laneId,
+            new_lane_id: newLaneId,
+            retry_attempt: retryAttempt,
+            retry_kind: "agent_task",
+            task_id: agentTaskContext.task_id,
+            provider_qualified_model_id: agentTaskContext.provider_qualified_model_id,
+            new_parent_session_ref: agentTaskContext.parent_session_ref,
+            created_at: now.toISOString(),
+            dispatch_authority_enabled: false,
+        };
+        writeEvidence({
+            rootDir: input.rootDir,
+            workflowId: input.workflowId,
+            evidenceId: executedId,
+            record: executedRecord,
+        });
+        writeEvidence({
+            rootDir: input.rootDir,
+            workflowId: input.workflowId,
+            evidenceId: `${pendingRetryEvidenceId}-launched`,
+            record: { ...pendingRecord, status: "launched" },
+        });
+        return {
+            status: "retry_launched",
+            newLaneId,
+            pendingRetryEvidenceId,
+        };
+    }
     // Step 12: Call launchFlowDeskInjectedSdkRuntimeLaneFromPlanV1
-    const launchPlan = buildRetryLaunchPlanFromContextV1(context, newLaneId, input.parentSessionId);
+    const launchPlan = buildRetryLaunchPlanFromContextV1(reviewerContext, newLaneId, input.parentSessionId);
     let launchResult;
     try {
         const launchPromise = launchFlowDeskInjectedSdkRuntimeLaneFromPlanV1({
@@ -684,7 +977,7 @@ export async function evaluateGuardedAutoRetryHookV1(input) {
             request: {
                 allowActualLaneLaunch: true,
                 parentSessionId: input.parentSessionId,
-                promptText: context.prompt_text,
+                promptText: reviewerContext.prompt_text,
                 dispatchMethod: "prompt",
             },
         });
@@ -771,10 +1064,11 @@ export async function evaluateGuardedAutoRetryHookV1(input) {
         original_lane_id: input.laneId,
         new_lane_id: newLaneId,
         retry_attempt: retryAttempt,
-        perspective: context.perspective,
-        provider_qualified_model_id: context.provider_qualified_model_id,
+        retry_kind: "reviewer_lane",
+        perspective: reviewerContext.perspective,
+        provider_qualified_model_id: reviewerContext.provider_qualified_model_id,
         new_parent_session_ref: newParentSessionRef,
-        original_attempt_id: context.original_attempt_id,
+        original_attempt_id: reviewerContext.original_attempt_id,
         created_at: now.toISOString(),
         dispatch_authority_enabled: false,
     };
@@ -879,6 +1173,23 @@ export async function runFlowDeskWatchdogCycleV1(input) {
         const workflowIds = listWatchdogWorkflowIds(input.rootDir);
         const now = input.now ?? new Date();
         for (const workflowId of workflowIds) {
+            // Monitor async-mode child sessions (nudge + abort + result collection)
+            if (input.client !== undefined) {
+                try {
+                    await monitorChildSessionsV1({
+                        rootDir: input.rootDir,
+                        workflowId,
+                        client: input.client,
+                        now,
+                    });
+                }
+                catch { /* best-effort, must not crash watchdog */ }
+            }
+            backfillTerminalAgentTaskFailedLanesV1({
+                rootDir: input.rootDir,
+                workflowId,
+                now,
+            });
             // Reload evidence for this workflow
             const reloaded = reloadFlowDeskSessionEvidenceV1({
                 rootDir: input.rootDir,
@@ -923,6 +1234,8 @@ export async function runFlowDeskWatchdogCycleV1(input) {
                                     client: input.client,
                                     parentSessionId: input.parentSessionId,
                                     now,
+                                    _nudgeQuietPeriodMs: input._nudgeQuietPeriodMs,
+                                    _messagesTimeoutMs: input._messagesTimeoutMs,
                                 });
                                 if (retryResult.status === "retry_launched") {
                                     lanesRetried++;
@@ -959,4 +1272,443 @@ export async function runFlowDeskWatchdogCycleV1(input) {
         lanesFailed,
     };
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Child session monitor (async-mode lanes)
+// ─────────────────────────────────────────────────────────────────────────────
+const AGENT_TASK_NUDGE_TEXT_WATCHDOG = "Please provide your final answer now. If you have completed your analysis, output your complete response.";
+/** Poll result from one session.messages call */
+function monitorRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function monitorResponseData(value) {
+    const record = monitorRecord(value);
+    return record !== undefined && "data" in record ? record.data : value;
+}
+function monitorSdkErrorResponse(value) {
+    const record = monitorRecord(value);
+    const data = monitorRecord(monitorResponseData(value));
+    return record?.error !== undefined || data?.error !== undefined;
+}
+async function pollChildSessionOutput(client, childSessionId, messagesTimeoutMs = 3_000) {
+    const messages = client.session.messages;
+    if (typeof messages !== "function")
+        return null;
+    try {
+        const readMessages = async () => {
+            const current = await messages.call(client.session, {
+                sessionID: childSessionId,
+            });
+            if (!monitorSdkErrorResponse(current))
+                return current;
+            return messages.call(client.session, {
+                path: { id: childSessionId },
+            });
+        };
+        const raw = await Promise.race([
+            readMessages(),
+            new Promise(resolve => setTimeout(() => resolve(null), messagesTimeoutMs)),
+        ]);
+        if (raw === null)
+            return null;
+        const observed = observeFlowDeskAgentTaskOutputV1(raw);
+        if (observed.terminalObserved && observed.latestText !== undefined && observed.latestText.trim().length > 0)
+            return { text: observed.latestText, completionStatus: "final", outputKind: observed.outputKind, usableForSynthesis: observed.usableForSynthesis };
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function pollChildSessionCandidate(client, childSessionId, messagesTimeoutMs = 3_000) {
+    const messages = client.session.messages;
+    if (typeof messages !== "function")
+        return null;
+    try {
+        const readMessages = async () => {
+            const current = await messages.call(client.session, { sessionID: childSessionId });
+            if (!monitorSdkErrorResponse(current))
+                return current;
+            return messages.call(client.session, { path: { id: childSessionId } });
+        };
+        const raw = await Promise.race([
+            readMessages(),
+            new Promise(resolve => setTimeout(() => resolve(null), messagesTimeoutMs)),
+        ]);
+        if (raw === null)
+            return null;
+        const observed = observeFlowDeskAgentTaskOutputV1(raw);
+        if (observed.latestText !== undefined && observed.latestText.trim().length > 0)
+            return { text: observed.latestText, completionStatus: observed.terminalObserved ? "final" : "partial", outputKind: observed.outputKind, usableForSynthesis: observed.usableForSynthesis };
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Send a noReply nudge to a child session — best effort with hard timeout */
+async function sendWatchdogNudge(client, childSessionId, timeoutMs = 5_000) {
+    const promptFn = client.session.promptAsync ?? client.session.prompt;
+    if (promptFn === undefined)
+        return "skipped";
+    try {
+        await Promise.race([
+            promptFn.call(client.session, {
+                sessionID: childSessionId,
+                noReply: true,
+                parts: [{ type: "text", text: AGENT_TASK_NUDGE_TEXT_WATCHDOG }],
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("nudge timeout")), timeoutMs)),
+        ]);
+        return "sent";
+    }
+    catch {
+        return "timeout";
+    }
+}
+/** Abort a child session via the injected SDK client */
+async function abortChildSession(client, childSessionId) {
+    const abort = client.session.abort;
+    if (typeof abort !== "function")
+        return;
+    try {
+        await abort.call(client.session, {
+            path: { id: childSessionId },
+        });
+    }
+    catch { /* best-effort */ }
+}
+function writeChildSessionEvidence(rootDir, workflowId, evidenceId, record) {
+    const prepared = prepareFlowDeskSessionEvidenceWriteIntentV1({ workflowId, evidenceId, record });
+    if (!prepared.ok || prepared.writeIntent === undefined)
+        return false;
+    const applied = applyFlowDeskSessionEvidenceWriteIntentsV1(rootDir, [prepared.writeIntent]);
+    return applied.ok && applied.writtenPaths.length > 0;
+}
+function laneAlreadyHasTerminalTaskEvidence(input) {
+    const reloaded = reloadFlowDeskSessionEvidenceV1({
+        rootDir: input.rootDir,
+        workflowId: input.workflowId,
+    });
+    if (!reloaded.ok)
+        return false;
+    return reloaded.entries.some((entry) => {
+        if (entry.evidenceClass !== "task_result" && entry.evidenceClass !== "task_failed")
+            return false;
+        const record = entry.record;
+        return record.lane_id === input.laneId;
+    });
+}
+function childProgressLabel(value) {
+    const compact = value.replace(/\s+/g, " ").trim();
+    return compact.length > 120 ? `${compact.slice(0, 119)}…` : compact;
+}
+function writeAgentTaskProgressEvidence(input) {
+    const record = {
+        schema_version: "flowdesk.agent_task_progress.v1",
+        workflow_id: input.workflowId,
+        lane_id: input.laneId,
+        task_id: input.taskId,
+        agent_ref: input.agentRef,
+        provider_qualified_model_id: input.providerQualifiedModelId,
+        progress_seq: input.progressSeq,
+        observed_at: input.observedAt,
+        phase: input.phase,
+        progress_label: childProgressLabel(input.progressLabel),
+        progress_ref: `progress-${input.laneId}-${input.progressSeq}`,
+        redaction_version: "v1",
+        dispatch_authority_enabled: false,
+    };
+    writeChildSessionEvidence(input.rootDir, input.workflowId, `agent-task-progress-${input.laneId}-${input.progressSeq}`, record);
+}
+/**
+ * Monitor all async-mode agent task lanes in the given workflow.
+ * Called from the watchdog cycle once per interval:
+ *   - Poll session.messages for each running child session
+ *   - On result: write task_result evidence + terminal lifecycle
+ *   - At 20s silence: nudge with noReply: true
+ *   - At 40s: second nudge
+ *   - At 60s+: session.abort + task_failed + terminal lifecycle
+ */
+export async function monitorChildSessionsV1(input) {
+    const nowMs = (input.now ?? new Date()).getTime();
+    const nudgeQuietPeriodMs = input.nudgeQuietPeriodMs ?? 20_000;
+    const maxNudges = input.maxNudges ?? 2;
+    const abortThresholdMs = input.abortThresholdMs ?? 60_000;
+    const result = { lanesPolled: 0, lanesCompleted: 0, lanesNudged: 0, lanesAborted: 0 };
+    const reloaded = reloadFlowDeskSessionEvidenceV1({ rootDir: input.rootDir, workflowId: input.workflowId });
+    if (!reloaded.ok)
+        return result;
+    // Find all child session records for running lanes
+    const childRecords = reloaded.entries
+        .filter(e => e.evidenceClass === "agent_task_child_session")
+        .map(e => e.record)
+        .filter(r => r.schema_version === AGENT_TASK_CHILD_SESSION_SCHEMA_VERSION);
+    // Find lanes that are NOT yet terminal (by lifecycle state or by task_result/task_failed evidence)
+    const terminalLaneIds = new Set();
+    const terminalTaskResultLaneIds = new Set();
+    const awaitingPermissionLaneIds = new Set();
+    const latestProgressByLane = new Map();
+    for (const entry of reloaded.entries) {
+        const rec = entry.record;
+        const laneIdVal = typeof rec.lane_id === "string" ? rec.lane_id : undefined;
+        if (!laneIdVal)
+            continue;
+        if (entry.evidenceClass === "agent_task_progress") {
+            const observedAtMs = typeof rec.observed_at === "string" ? Date.parse(rec.observed_at) : NaN;
+            const phase = typeof rec.phase === "string" ? rec.phase : undefined;
+            const current = latestProgressByLane.get(laneIdVal);
+            if (phase !== undefined && Number.isFinite(observedAtMs) && (current === undefined || current.observedAtMs <= observedAtMs)) {
+                latestProgressByLane.set(laneIdVal, { observedAtMs, phase });
+            }
+        }
+        if (entry.evidenceClass === "lane_lifecycle") {
+            const s = rec.state;
+            if (s === "complete" || s === "invocation_failed" || s === "no_output" || s === "incomplete")
+                terminalLaneIds.add(laneIdVal);
+        }
+        else if (entry.evidenceClass === "task_result" || entry.evidenceClass === "task_failed") {
+            terminalLaneIds.add(laneIdVal);
+            if (entry.evidenceClass === "task_result")
+                terminalTaskResultLaneIds.add(laneIdVal);
+        }
+    }
+    for (const [laneId, progress] of latestProgressByLane) {
+        if (progress.phase === "awaiting_permission")
+            awaitingPermissionLaneIds.add(laneId);
+    }
+    // Defensive fallback for older/event-written progress records: if any explicit
+    // awaiting_permission marker is present and no later permission response has
+    // been observed, suspend watchdog nudge/abort for the lane.
+    for (const entry of reloaded.entries) {
+        if (entry.evidenceClass !== "agent_task_progress")
+            continue;
+        const rec = entry.record;
+        if (rec.phase === "awaiting_permission" && typeof rec.lane_id === "string")
+            awaitingPermissionLaneIds.add(rec.lane_id);
+        if (rec.phase === "waiting" && typeof rec.progress_label === "string" && rec.progress_label.includes("permission response") && typeof rec.lane_id === "string")
+            awaitingPermissionLaneIds.delete(rec.lane_id);
+    }
+    for (const record of childRecords) {
+        const laneId = typeof record.lane_id === "string" ? record.lane_id : "";
+        const childSessionId = typeof record.child_session_id === "string" ? record.child_session_id : "";
+        if (!laneId || !childSessionId)
+            continue;
+        if (terminalLaneIds.has(laneId)) {
+            if (terminalTaskResultLaneIds.has(laneId)) {
+                refreshFlowDeskCompletionUiCachesV1({
+                    rootDir: input.rootDir,
+                    workflowId: input.workflowId,
+                    observedAt: new Date(nowMs).toISOString(),
+                });
+            }
+            continue; // already done
+        }
+        if (awaitingPermissionLaneIds.has(laneId))
+            continue; // user permission is outstanding; do not nudge or abort
+        result.lanesPolled++;
+        const createdAtMs = typeof record.created_at === "string" ? Date.parse(record.created_at) : nowMs;
+        const nudgeCount = typeof record.nudge_count === "number" ? record.nudge_count : 0;
+        const lastNudgeAtMs = typeof record.last_nudge_at === "string" ? Date.parse(record.last_nudge_at) : createdAtMs;
+        const silenceMs = nowMs - lastNudgeAtMs;
+        const totalAgeMs = nowMs - createdAtMs;
+        // 1. Try to collect terminal result text. Candidate text without terminal is kept for abort-time partial capture.
+        const resultObservation = await pollChildSessionOutput(input.client, childSessionId);
+        if (resultObservation !== null && resultObservation.text.trim().length > 0) {
+            const taskId = typeof record.task_id === "string" ? record.task_id : laneId;
+            const agentRef = typeof record.agent_ref === "string" ? record.agent_ref : "agent-unknown";
+            const modelId = typeof record.provider_qualified_model_id === "string" ? record.provider_qualified_model_id : "unknown/unknown";
+            if (laneAlreadyHasTerminalTaskEvidence({ rootDir: input.rootDir, workflowId: input.workflowId, laneId })) {
+                continue;
+            }
+            const token = randomBytes(4).toString("hex");
+            const completedAt = new Date(nowMs).toISOString();
+            const sanitizedResult = sanitizeFlowDeskTaskResultTextV1(resultObservation.text);
+            const finalText = sanitizedResult.text;
+            const taskResultEvidenceId = `task-result-${taskId}-watchdog-${token}`;
+            const taskResultWritten = input._forceTaskResultWriteFailureForTest === true
+                ? false
+                : writeChildSessionEvidence(input.rootDir, input.workflowId, taskResultEvidenceId, {
+                    schema_version: "flowdesk.task_result.v1",
+                    workflow_id: input.workflowId,
+                    lane_id: laneId,
+                    task_id: taskId,
+                    agent_ref: agentRef,
+                    provider_qualified_model_id: modelId,
+                    task_prompt_sha256: createHash("sha256").update("watchdog-collected").digest("hex"),
+                    result_text: finalText,
+                    result_text_truncated: sanitizedResult.truncated,
+                    result_text_sha256: createHash("sha256").update(resultObservation.text).digest("hex"),
+                    completion_status: resultObservation.completionStatus,
+                    output_kind: resultObservation.outputKind,
+                    usable_for_synthesis: resultObservation.usableForSynthesis,
+                    missing_contract: false,
+                    created_at: completedAt,
+                    dispatch_authority_enabled: false,
+                });
+            if (!taskResultWritten) {
+                writeChildSessionEvidence(input.rootDir, input.workflowId, `task-failed-${taskId}-watchdog-result-write-${token}`, {
+                    schema_version: "flowdesk.task_failed.v1",
+                    workflow_id: input.workflowId,
+                    lane_id: laneId,
+                    task_id: taskId,
+                    agent_ref: agentRef,
+                    provider_qualified_model_id: modelId,
+                    failure_category: "unknown",
+                    redacted_reason: "watchdog could not persist task_result evidence",
+                    created_at: completedAt,
+                    dispatch_authority_enabled: false,
+                });
+                writeAgentTaskProgressEvidence({
+                    rootDir: input.rootDir,
+                    workflowId: input.workflowId,
+                    laneId,
+                    taskId,
+                    agentRef,
+                    providerQualifiedModelId: modelId,
+                    phase: "failed",
+                    progressSeq: 20 + nudgeCount,
+                    progressLabel: "async agent task result persistence failed",
+                    observedAt: completedAt,
+                });
+                continue;
+            }
+            writeAgentTaskProgressEvidence({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                laneId,
+                taskId,
+                agentRef,
+                providerQualifiedModelId: modelId,
+                phase: "finalizing",
+                progressSeq: 10 + nudgeCount,
+                progressLabel: "async agent task result captured by watchdog",
+                observedAt: completedAt,
+            });
+            refreshFlowDeskCompletionUiCachesV1({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                observedAt: completedAt,
+            });
+            result.lanesCompleted++;
+            continue;
+        }
+        // 2. Abort threshold exceeded
+        if (totalAgeMs >= abortThresholdMs && nudgeCount >= maxNudges) {
+            await abortChildSession(input.client, childSessionId);
+            const taskId = typeof record.task_id === "string" ? record.task_id : laneId;
+            const agentRef = typeof record.agent_ref === "string" ? record.agent_ref : "agent-unknown";
+            const modelId = typeof record.provider_qualified_model_id === "string" ? record.provider_qualified_model_id : "unknown/unknown";
+            if (laneAlreadyHasTerminalTaskEvidence({ rootDir: input.rootDir, workflowId: input.workflowId, laneId })) {
+                continue;
+            }
+            const token = randomBytes(4).toString("hex");
+            const abortedAt = new Date(nowMs).toISOString();
+            const partialObservation = await pollChildSessionCandidate(input.client, childSessionId);
+            if (partialObservation !== null && partialObservation.text.trim().length > 0) {
+                const sanitizedResult = sanitizeFlowDeskTaskResultTextV1(partialObservation.text);
+                const taskResultWritten = writeChildSessionEvidence(input.rootDir, input.workflowId, `task-result-${taskId}-watchdog-partial-${token}`, {
+                    schema_version: "flowdesk.task_result.v1",
+                    workflow_id: input.workflowId,
+                    lane_id: laneId,
+                    task_id: taskId,
+                    agent_ref: agentRef,
+                    provider_qualified_model_id: modelId,
+                    task_prompt_sha256: createHash("sha256").update("watchdog-collected").digest("hex"),
+                    result_text: sanitizedResult.text,
+                    result_text_truncated: sanitizedResult.truncated,
+                    result_text_sha256: createHash("sha256").update(partialObservation.text).digest("hex"),
+                    completion_status: "partial",
+                    output_kind: partialObservation.outputKind,
+                    usable_for_synthesis: partialObservation.usableForSynthesis,
+                    missing_contract: true,
+                    created_at: abortedAt,
+                    dispatch_authority_enabled: false,
+                });
+                if (taskResultWritten) {
+                    writeAgentTaskProgressEvidence({
+                        rootDir: input.rootDir,
+                        workflowId: input.workflowId,
+                        laneId,
+                        taskId,
+                        agentRef,
+                        providerQualifiedModelId: modelId,
+                        phase: "finalizing",
+                        progressSeq: 20 + nudgeCount,
+                        progressLabel: "async agent task partial result captured before abort",
+                        observedAt: abortedAt,
+                    });
+                    refreshFlowDeskCompletionUiCachesV1({
+                        rootDir: input.rootDir,
+                        workflowId: input.workflowId,
+                        observedAt: abortedAt,
+                    });
+                    result.lanesCompleted++;
+                    continue;
+                }
+            }
+            const failureCategory = totalAgeMs > abortThresholdMs * 2
+                ? "network_interrupted"
+                : "sdk_prompt_timeout";
+            writeChildSessionEvidence(input.rootDir, input.workflowId, `task-failed-${taskId}-watchdog-abort-${token}`, {
+                schema_version: "flowdesk.task_failed.v1",
+                workflow_id: input.workflowId,
+                lane_id: laneId,
+                task_id: taskId,
+                agent_ref: agentRef,
+                provider_qualified_model_id: modelId,
+                failure_category: failureCategory,
+                redacted_reason: `watchdog aborted child session after ${Math.round(totalAgeMs / 1000)}s with no response`,
+                created_at: abortedAt,
+                dispatch_authority_enabled: false,
+            });
+            writeAgentTaskProgressEvidence({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                laneId,
+                taskId,
+                agentRef,
+                providerQualifiedModelId: modelId,
+                phase: "failed",
+                progressSeq: 20 + nudgeCount,
+                progressLabel: "async agent task aborted after no response",
+                observedAt: abortedAt,
+            });
+            result.lanesAborted++;
+            continue;
+        }
+        // 3. Nudge if silence threshold exceeded
+        if (silenceMs >= nudgeQuietPeriodMs && nudgeCount < maxNudges) {
+            await sendWatchdogNudge(input.client, childSessionId);
+            result.lanesNudged++;
+            const taskId = typeof record.task_id === "string" ? record.task_id : laneId;
+            const agentRef = typeof record.agent_ref === "string" ? record.agent_ref : "agent-unknown";
+            const modelId = typeof record.provider_qualified_model_id === "string" ? record.provider_qualified_model_id : "unknown/unknown";
+            const nudgedAt = new Date(nowMs).toISOString();
+            writeAgentTaskProgressEvidence({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                laneId,
+                taskId,
+                agentRef,
+                providerQualifiedModelId: modelId,
+                phase: "nudged",
+                progressSeq: 2 + nudgeCount,
+                progressLabel: "async agent task nudged after quiet period",
+                observedAt: nudgedAt,
+            });
+            // Update nudge_count in evidence (overwrite record)
+            const evidenceId = reloaded.entries
+                .find(e => e.evidenceClass === "agent_task_child_session" && e.record.lane_id === laneId)
+                ?.evidenceId ?? `agent-task-child-session-${laneId}-watchdog`;
+            writeChildSessionEvidence(input.rootDir, input.workflowId, evidenceId, {
+                ...record,
+                nudge_count: nudgeCount + 1,
+                last_nudge_at: new Date(nowMs).toISOString(),
+            });
+        }
+    }
+    return result;
+}
 //# sourceMappingURL=stall-recovery.js.map