@flowdesk/opencode-plugin 0.1.13 → 0.1.15

package/dist/stall-recovery.js

@@ -1,10 +1,12 @@
-import { applyFlowDeskSessionEvidenceWriteIntentsV1, prepareFlowDeskSessionEvidenceWriteIntentV1, reloadFlowDeskSessionEvidenceV1, projectFlowDeskLaneStallV1, } from "@flowdesk/core";
-import { createHmac, createHash, timingSafeEqual } from "node:crypto";
+import { applyFlowDeskSessionEvidenceWriteIntentsV1, prepareFlowDeskSessionEvidenceWriteIntentV1, reloadFlowDeskSessionEvidenceV1, projectFlowDeskLaneStallV1, validateTopTierReviewVerdictV1, } from "@flowdesk/core";
+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 } from "./agent-task-runner.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" };
@@ -252,6 +254,11 @@ export function validateAndAbortFlowDeskLaneEvidenceV1(input) {
         entry.record.state === "aborted");
     if (!persisted)
         return { status: "write_failed", reason: "abort_evidence_not_persisted" };
+    refreshFlowDeskCompletionUiCachesV1({
+        rootDir: input.rootDir,
+        workflowId: input.workflow_id,
+        observedAt: observedAt,
+    });
     return {
         status: "aborted",
         lane_id: input.lane_id,
@@ -580,6 +587,14 @@ export function backfillTerminalAgentTaskFailedLanesV1(input) {
             terminalEvidenceIds.push(evidenceId);
         }
     }
+    if ((input.refreshCompletionUiCaches ?? true) &&
+        (terminalEvidenceIds.length > 0 || latestFailure.size > 0)) {
+        refreshFlowDeskCompletionUiCachesV1({
+            rootDir: input.rootDir,
+            workflowId: input.workflowId,
+            observedAt,
+        });
+    }
     return {
         status: "backfill_completed",
         workflowId: input.workflowId,
@@ -900,6 +915,8 @@ export async function evaluateGuardedAutoRetryHookV1(input) {
             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}`;
@@ -1169,6 +1186,18 @@ 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,
@@ -1218,6 +1247,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++;
@@ -1254,4 +1285,650 @@ 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, looksLikeRefusalOrError: observed.looksLikeRefusalOrError };
+        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, looksLikeRefusalOrError: observed.looksLikeRefusalOrError };
+        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 extractJsonBlocksFromText(raw) {
+    const trimmed = raw.trim();
+    const results = [];
+    if (trimmed.startsWith("{") && trimmed.endsWith("}"))
+        return [trimmed];
+    const fencePattern = /```(?:json)?\s*\n?(\{[\s\S]*?\})\s*\n?```/g;
+    for (const match of trimmed.matchAll(fencePattern)) {
+        if (match[1])
+            results.push(match[1].trim());
+    }
+    if (results.length > 0)
+        return results;
+    let depth = 0;
+    let start = -1;
+    let lastBlock;
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                lastBlock = trimmed.slice(start, i + 1).trim();
+                start = -1;
+            }
+        }
+    }
+    return lastBlock === undefined ? [] : [lastBlock];
+}
+function observedTopTierReviewerVerdictFromText(input) {
+    for (const block of extractJsonBlocksFromText(input.text)) {
+        try {
+            const candidate = JSON.parse(block);
+            const validation = validateTopTierReviewVerdictV1(candidate);
+            if (!validation.ok)
+                continue;
+            const verdict = candidate;
+            if (verdict.workflow_id === input.workflowId)
+                return verdict;
+        }
+        catch {
+            // Keep scanning candidates.
+        }
+    }
+    return undefined;
+}
+function persistObservedReviewerVerdict(input) {
+    const evidenceId = input.verdict.verdict_id;
+    if (!writeChildSessionEvidence(input.rootDir, input.workflowId, evidenceId, input.verdict))
+        return false;
+    const reloaded = reloadFlowDeskSessionEvidenceV1({ rootDir: input.rootDir, workflowId: input.workflowId });
+    return reloaded.ok && reloaded.blocked.length === 0 && reloaded.entries.some((entry) => entry.evidenceClass === "reviewer_verdict" &&
+        entry.evidenceId === evidenceId &&
+        entry.record.verdict_id === input.verdict.verdict_id);
+}
+function writeAgentTaskCompleteLifecycleForVerdict(input) {
+    return writeChildSessionEvidence(input.rootDir, input.workflowId, `lifecycle-agent-task-complete-${input.laneId}-${input.verdictId}`, {
+        schema_version: "flowdesk.lane_lifecycle_record.v1",
+        lane_id: input.laneId,
+        workflow_id: input.workflowId,
+        attempt_id: input.attemptId,
+        parent_session_ref: input.parentSessionRef,
+        child_session_ref: input.childSessionId.startsWith("ses-") ? input.childSessionId : `ses-${input.childSessionId}`,
+        message_ref: `msg-${input.laneId}`,
+        agent_ref: input.agentRef,
+        provider_qualified_model_id: input.providerQualifiedModelId,
+        state: "complete",
+        verdict_ref: input.verdictId,
+        output_ref: `output-${input.taskResultEvidenceId}`,
+        runtime_echo_ref: `runtime-echo-${input.laneId}`,
+        telemetry_ref: `telemetry-${input.laneId}`,
+        timeout_ms: 0,
+        orphan_max_age_ms: 0,
+        retry_count: 0,
+        created_at: input.observedAt,
+        updated_at: input.observedAt,
+        dispatch_authority_enabled: false,
+        providerCall: false,
+        actualLaneLaunch: false,
+        runtimeExecution: false,
+    });
+}
+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 terminalEvidenceObservedAtMs(record) {
+    const value = typeof record.updated_at === "string"
+        ? record.updated_at
+        : typeof record.created_at === "string"
+            ? record.created_at
+            : typeof record.observed_at === "string"
+                ? record.observed_at
+                : undefined;
+    const parsed = value === undefined ? Number.NaN : Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function chooseLaterTerminalEndState(existing, candidate) {
+    if (existing === undefined)
+        return candidate;
+    if (candidate.observedAtMs > existing.observedAtMs)
+        return candidate;
+    if (candidate.observedAtMs < existing.observedAtMs)
+        return existing;
+    // Prefer task_result for equal timestamps; otherwise keep the existing entry so
+    // duplicate event-session-error / failed-child evidence is idempotent.
+    return candidate.hasTaskResult && !existing.hasTaskResult ? candidate : existing;
+}
+function collectTerminalLaneEndStatesV1(entries) {
+    const terminalByLane = new Map();
+    for (const entry of entries) {
+        const rec = entry.record;
+        const laneId = typeof rec.lane_id === "string" ? rec.lane_id : undefined;
+        if (laneId === undefined)
+            continue;
+        let state;
+        let hasTaskResult = false;
+        if (entry.evidenceClass === "lane_lifecycle") {
+            state = typeof rec.state === "string" && TERMINAL_LANE_STATES.has(rec.state) ? rec.state : undefined;
+        }
+        else if (entry.evidenceClass === "task_result") {
+            state = "complete";
+            hasTaskResult = true;
+        }
+        else if (entry.evidenceClass === "task_failed") {
+            state = rec.failure_category === "no_response" ? "no_output" : "invocation_failed";
+        }
+        if (state === undefined)
+            continue;
+        terminalByLane.set(laneId, chooseLaterTerminalEndState(terminalByLane.get(laneId), {
+            laneId,
+            state,
+            observedAtMs: terminalEvidenceObservedAtMs(rec),
+            hasTaskResult,
+        }));
+    }
+    return terminalByLane;
+}
+function latestTerminalObservedAtIso(endStates, fallbackMs) {
+    let latest = 0;
+    for (const state of endStates)
+        latest = Math.max(latest, state.observedAtMs);
+    return new Date(latest > 0 ? latest : fallbackMs).toISOString();
+}
+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 10s silence: nudge with noReply: true
+ *   - At 20s: second nudge
+ *   - At 30s+: session.abort + task_failed + terminal lifecycle
+ */
+export async function monitorChildSessionsV1(input) {
+    const nowMs = (input.now ?? new Date()).getTime();
+    const nudgeQuietPeriodMs = input.nudgeQuietPeriodMs ?? 10_000;
+    const maxNudges = input.maxNudges ?? 2;
+    const abortThresholdMs = input.abortThresholdMs ?? 30_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. Terminal evidence can come from
+    // task_result, task_failed (including event-session-error records), or a
+    // lifecycle terminal state. The map keeps the extracted end-state timestamp so
+    // cache refreshes are monotonic/idempotent even when no task_result exists.
+    const terminalEndStates = collectTerminalLaneEndStatesV1(reloaded.entries);
+    const terminalLaneIds = new Set(terminalEndStates.keys());
+    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 });
+            }
+        }
+    }
+    const terminalRefreshObservedAt = latestTerminalObservedAtIso(terminalEndStates.values(), nowMs);
+    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);
+    }
+    let uiCacheRefreshed = false;
+    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)) {
+            // Refresh the completion UI cache for terminal lanes so stale "running"
+            // rows are promoted to terminal. This must run for any terminal lane,
+            // including lanes that only have lane_lifecycle/task_failed evidence and
+            // no task_result (e.g. reviewer execution bridge writing only
+            // lane_lifecycle=invocation_failed). Without this, the sidebar row stays
+            // stuck at progressing_normal/running until a task_result appears.
+            if (!uiCacheRefreshed) {
+                refreshFlowDeskCompletionUiCachesV1({
+                    rootDir: input.rootDir,
+                    workflowId: input.workflowId,
+                    observedAt: terminalRefreshObservedAt,
+                });
+                uiCacheRefreshed = true;
+            }
+            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,
+                    finalization_reason: "terminal_marker",
+                    looks_like_refusal_or_error: resultObservation.looksLikeRefusalOrError,
+                    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,
+                });
+                refreshFlowDeskCompletionUiCachesV1({
+                    rootDir: input.rootDir,
+                    workflowId: input.workflowId,
+                    observedAt: completedAt,
+                });
+                continue;
+            }
+            const observedReviewerVerdict = observedTopTierReviewerVerdictFromText({
+                text: resultObservation.text,
+                workflowId: input.workflowId,
+            });
+            const reviewerVerdictPersisted = observedReviewerVerdict === undefined
+                ? false
+                : persistObservedReviewerVerdict({
+                    rootDir: input.rootDir,
+                    workflowId: input.workflowId,
+                    verdict: observedReviewerVerdict,
+                });
+            const runningLifecycle = reloaded.entries.find((entry) => {
+                const lifecycle = entry.record;
+                return entry.evidenceClass === "lane_lifecycle" && lifecycle.lane_id === laneId && typeof lifecycle.attempt_id === "string";
+            })?.record;
+            if (reviewerVerdictPersisted && observedReviewerVerdict !== undefined) {
+                writeAgentTaskCompleteLifecycleForVerdict({
+                    rootDir: input.rootDir,
+                    workflowId: input.workflowId,
+                    laneId,
+                    attemptId: typeof runningLifecycle?.attempt_id === "string" ? runningLifecycle.attempt_id : `attempt-${laneId}`,
+                    parentSessionRef: typeof record.parent_session_ref === "string" ? record.parent_session_ref : "ses-agent-task-parent",
+                    childSessionId,
+                    taskResultEvidenceId,
+                    agentRef,
+                    providerQualifiedModelId: modelId,
+                    verdictId: observedReviewerVerdict.verdict_id,
+                    observedAt: completedAt,
+                });
+            }
+            writeAgentTaskProgressEvidence({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                laneId,
+                taskId,
+                agentRef,
+                providerQualifiedModelId: modelId,
+                phase: "finalizing",
+                progressSeq: 10 + nudgeCount,
+                progressLabel: reviewerVerdictPersisted
+                    ? "async agent task result captured with reviewer verdict evidence"
+                    : "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,
+                    // Captured partial text is still a usable result, not a contract
+                    // failure. The coordinator judges substance from the advisory fields.
+                    missing_contract: false,
+                    finalization_reason: "timeout_partial",
+                    looks_like_refusal_or_error: partialObservation.looksLikeRefusalOrError,
+                    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,
+            });
+            refreshFlowDeskCompletionUiCachesV1({
+                rootDir: input.rootDir,
+                workflowId: input.workflowId,
+                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(),
+            });
+        }
+    }
+    // Invariant: terminal/failure lanes observed during this cycle MUST cause a
+    // completion UI cache refresh, even when the failed lane has no paired
+    // `agent_task_child_session` record (e.g. reviewer execution bridge wrote
+    // only `lane_lifecycle=invocation_failed`, or `task_failed`/`no_output`
+    // arrived via the event hook without a task_result). Without this defensive
+    // refresh, the `subtask-activity-sidebar` and `auto-next-ready` caches stay
+    // stuck at `progressing_normal/running` until the next backfill pass.
+    if (!uiCacheRefreshed && terminalLaneIds.size > 0) {
+        refreshFlowDeskCompletionUiCachesV1({
+            rootDir: input.rootDir,
+            workflowId: input.workflowId,
+            observedAt: terminalRefreshObservedAt,
+        });
+    }
+    return result;
+}
 //# sourceMappingURL=stall-recovery.js.map