@flowdesk/opencode-plugin 0.1.12 → 0.1.14

package/dist/status-live-tool.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { FLOWDESK_SESSION_EVIDENCE_CLASSES, projectFlowDeskLaneStallV1, reloadFlowDeskSessionEvidenceV1, } from "@flowdesk/core";
+import { applyFlowDeskSessionEvidenceWriteIntentsV1, FLOWDESK_SESSION_EVIDENCE_CLASSES, prepareFlowDeskSessionEvidenceWriteIntentV1, projectFlowDeskLaneStallV1, reloadFlowDeskSessionEvidenceV1, } from "@flowdesk/core";
+import { backfillTerminalAgentTaskFailedLanesV1 } from "./stall-recovery.js";
 const FLOWDESK_LANE_STALL_TERMINAL_STATES = new Set([
     "complete",
     "incomplete",
@@ -89,6 +90,27 @@ function pruneNonTerminalLifecycleSnapshotsNoLongerValid(reload) {
         return reload;
     return { ...reload, entries };
 }
+function pruneInconsistencySnapshotsNoLongerValid(reload) {
+    const terminalLaneIds = new Set();
+    for (const entry of reload.entries) {
+        if (entry.evidenceClass === "task_result" || entry.evidenceClass === "task_failed") {
+            const laneId = getLaneLifecycleRecordField(entry.record, "lane_id");
+            if (laneId !== undefined)
+                terminalLaneIds.add(laneId);
+        }
+    }
+    if (terminalLaneIds.size === 0)
+        return reload;
+    const entries = reload.entries.filter((entry) => {
+        if (entry.evidenceClass !== "agent_task_inconsistency")
+            return true;
+        const laneId = getLaneLifecycleRecordField(entry.record, "lane_id");
+        return laneId === undefined || !terminalLaneIds.has(laneId);
+    });
+    if (entries.length === reload.entries.length)
+        return reload;
+    return { ...reload, entries };
+}
 const FLOWDESK_SESSION_RECORD_ROOT = ".flowdesk/sessions";
 function blockedAuthority() {
     return {
@@ -105,6 +127,14 @@ function blockedAuthority() {
 function safeNextActions() {
     return ["/flowdesk-status", "/flowdesk-doctor", "/flowdesk-export-debug"];
 }
+function authorityCapabilitySummary() {
+    return {
+        availableNow: ["display_only", "local_preview", "command_backed_guarded"],
+        explicitDevBeta: ["provider_task_lane", "controlled_workspace_write"],
+        laterGated: ["managed_dispatch", "managed_fallback", "tui_actions", "hard_chat_control"],
+        unsupportedByDefault: ["auto_provider_execution", "automatic_reselection"],
+    };
+}
 function listSessionWorkflowIds(rootDir, max) {
     const sessionsDir = join(rootDir, FLOWDESK_SESSION_RECORD_ROOT);
     if (!existsSync(sessionsDir))
@@ -137,6 +167,165 @@ function getStringField(record, key) {
     const value = record[key];
     return typeof value === "string" ? value : undefined;
 }
+function getPositiveIntegerField(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isInteger(value) && value > 0
+        ? value
+        : undefined;
+}
+const FORBIDDEN_SYNTHESIS_SUMMARY_MARKERS = /system prompt|provider payload|raw token|hidden injection|opencode\srun|dispatch|fallback|reselect/i;
+function synthesisSummaryPreview(value) {
+    if (value === undefined)
+        return undefined;
+    const compact = value.replace(/\s+/g, " ").trim();
+    if (compact.length === 0 || FORBIDDEN_SYNTHESIS_SUMMARY_MARKERS.test(compact))
+        return undefined;
+    return compact.length > 160 ? `${compact.slice(0, 159)}…` : compact;
+}
+const DEFAULT_AGENT_TASK_FINALIZING_INCONSISTENCY_GRACE_MS = 90_000;
+const MIN_AGENT_TASK_FINALIZING_INCONSISTENCY_GRACE_MS = 30_000;
+const MAX_AGENT_TASK_FINALIZING_INCONSISTENCY_GRACE_MS = 600_000;
+function clampFinalizingInconsistencyGraceMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return DEFAULT_AGENT_TASK_FINALIZING_INCONSISTENCY_GRACE_MS;
+    return Math.min(MAX_AGENT_TASK_FINALIZING_INCONSISTENCY_GRACE_MS, Math.max(MIN_AGENT_TASK_FINALIZING_INCONSISTENCY_GRACE_MS, Math.floor(value)));
+}
+function finalizingInconsistencyEvidenceId(laneId) {
+    return `agent-task-inconsistency-${laneId}-finalizing-without-terminal`;
+}
+function materializeFinalizingWithoutTerminalInconsistencies(input) {
+    const observedAtMs = Date.parse(input.observedAt);
+    if (!Number.isFinite(observedAtMs))
+        return false;
+    const terminalLaneIds = new Set();
+    const existingInconsistencyIds = new Set();
+    const attemptIdByLane = new Map();
+    const taskIdByLane = new Map();
+    const latestActiveSignalByLane = new Map();
+    const latestFinalizingByLane = new Map();
+    for (const entry of input.reload.entries) {
+        const laneId = getStringField(entry.record, "lane_id");
+        if (laneId !== undefined) {
+            if (entry.evidenceClass === "lane_lifecycle" || entry.evidenceClass === "lane_heartbeat") {
+                const attemptId = getStringField(entry.record, "attempt_id");
+                if (attemptId !== undefined)
+                    attemptIdByLane.set(laneId, attemptId);
+                const state = getStringField(entry.record, "state");
+                const observedAt = getStringField(entry.record, "updated_at") ??
+                    getStringField(entry.record, "observed_at") ??
+                    getStringField(entry.record, "created_at");
+                const observedAtMs = observedAt === undefined ? NaN : Date.parse(observedAt);
+                if ((state === "created" ||
+                    state === "running" ||
+                    state === "awaiting_dependency" ||
+                    state === "cooldown") &&
+                    Number.isFinite(observedAtMs)) {
+                    const current = latestActiveSignalByLane.get(laneId);
+                    if (current === undefined || observedAtMs > current)
+                        latestActiveSignalByLane.set(laneId, observedAtMs);
+                }
+            }
+            if (entry.evidenceClass === "agent_task_context") {
+                const taskId = getStringField(entry.record, "task_id");
+                if (taskId !== undefined)
+                    taskIdByLane.set(laneId, taskId);
+            }
+        }
+        if (entry.evidenceClass === "task_result" || entry.evidenceClass === "task_failed") {
+            if (laneId !== undefined)
+                terminalLaneIds.add(laneId);
+            continue;
+        }
+        if (entry.evidenceClass === "agent_task_inconsistency") {
+            existingInconsistencyIds.add(entry.evidenceId);
+            continue;
+        }
+        if (entry.evidenceClass !== "agent_task_progress")
+            continue;
+        if (laneId === undefined)
+            continue;
+        if (getStringField(entry.record, "phase") !== "finalizing")
+            continue;
+        const progressObservedAt = getStringField(entry.record, "observed_at");
+        if (progressObservedAt === undefined)
+            continue;
+        const progressObservedAtMs = Date.parse(progressObservedAt);
+        if (!Number.isFinite(progressObservedAtMs))
+            continue;
+        const current = latestFinalizingByLane.get(laneId);
+        if (current !== undefined && current.observedAtMs > progressObservedAtMs)
+            continue;
+        latestFinalizingByLane.set(laneId, {
+            laneId,
+            attemptId: attemptIdByLane.get(laneId),
+            taskId: getStringField(entry.record, "task_id"),
+            progressSeq: getPositiveIntegerField(entry.record, "progress_seq"),
+            observedAt: progressObservedAt,
+            observedAtMs: progressObservedAtMs,
+        });
+    }
+    const intents = [];
+    for (const progress of latestFinalizingByLane.values()) {
+        if (terminalLaneIds.has(progress.laneId))
+            continue;
+        const activeSignalMs = latestActiveSignalByLane.get(progress.laneId);
+        const finalizingAgeMs = observedAtMs - progress.observedAtMs;
+        const activeSignalAgeMs = activeSignalMs === undefined ? 0 : observedAtMs - activeSignalMs;
+        if (finalizingAgeMs < input.graceMs && activeSignalAgeMs < input.graceMs)
+            continue;
+        const attemptId = progress.attemptId ?? attemptIdByLane.get(progress.laneId);
+        const taskId = progress.taskId ?? taskIdByLane.get(progress.laneId);
+        const progressSeq = progress.progressSeq;
+        if (attemptId === undefined || taskId === undefined || progressSeq === undefined)
+            continue;
+        const evidenceId = finalizingInconsistencyEvidenceId(progress.laneId);
+        if (existingInconsistencyIds.has(evidenceId))
+            continue;
+        const record = {
+            schema_version: "flowdesk.agent_task_inconsistency.v1",
+            workflow_id: input.workflowId,
+            attempt_id: attemptId,
+            lane_id: progress.laneId,
+            task_id: taskId,
+            last_progress_seq: progressSeq,
+            last_progress_observed_at: progress.observedAt,
+            inconsistency_kind: "finalizing_without_terminal",
+            grace_window_ms: input.graceMs,
+            grace_source_label: input.graceMs === DEFAULT_AGENT_TASK_FINALIZING_INCONSISTENCY_GRACE_MS
+                ? "default_status_live_finalizing_inconsistency_grace"
+                : "configured_status_live_finalizing_inconsistency_grace",
+            observed_at: input.observedAt,
+            safe_next_actions: [
+                "/flowdesk-status",
+                "/flowdesk-abort",
+                "/flowdesk-retry",
+                "/flowdesk-doctor",
+                "/flowdesk-export-debug",
+            ],
+            redaction_version: "v1",
+            dispatch_authority_enabled: false,
+        };
+        const prepared = prepareFlowDeskSessionEvidenceWriteIntentV1({
+            workflowId: input.workflowId,
+            evidenceId,
+            record,
+        });
+        if (prepared.ok && prepared.writeIntent !== undefined)
+            intents.push(prepared.writeIntent);
+    }
+    if (intents.length === 0)
+        return false;
+    const applied = applyFlowDeskSessionEvidenceWriteIntentsV1(input.rootDir, intents);
+    return applied.ok && applied.writtenPaths.length > 0;
+}
+function compactPromptPreview(value, max = 96) {
+    if (value === undefined)
+        return undefined;
+    const compact = value.replace(/\s+/g, " ").trim();
+    if (compact.length === 0)
+        return undefined;
+    return compact.length > max ? `${compact.slice(0, Math.max(0, max - 1))}…` : compact;
+}
 function summarizeWorkflow(workflowId, reload, maxRecent) {
     const counts = {};
     const recent = {};
@@ -144,6 +333,19 @@ function summarizeWorkflow(workflowId, reload, maxRecent) {
     const laneLifecycleStates = [];
     let regatePlanState;
     let providerAcquisitionStatus;
+    let workflowAuthoringStatus;
+    let workflowAuthoringGoalSummary;
+    let taskGraphTaskCount;
+    let taskGraphEdgeCount;
+    let taskAgentAssignmentCount;
+    let taskModelSelectionStatus;
+    let taskModelSelectionBlockedLabels;
+    let workflowSynthesisId;
+    let workflowSynthesisTasksSummarized;
+    let workflowSynthesisConflictDetected;
+    let workflowSynthesisSummaryPreview;
+    let workflowDispatchPlanRevisionId;
+    let workflowDispatchPlanTaskCount;
     for (const evidenceClass of FLOWDESK_SESSION_EVIDENCE_CLASSES) {
         const classEntries = reload.entries.filter((entry) => entry.evidenceClass === evidenceClass);
         if (classEntries.length === 0)
@@ -187,6 +389,57 @@ function summarizeWorkflow(workflowId, reload, maxRecent) {
                     providerAcquisitionStatus = acquisitionStatus;
             }
         }
+        if (evidenceClass === "workflow_authoring_result") {
+            const last = classEntries[classEntries.length - 1];
+            if (last !== undefined) {
+                workflowAuthoringStatus = getStringField(last.record, "status");
+                workflowAuthoringGoalSummary = getStringField(last.record, "goal_summary");
+            }
+        }
+        if (evidenceClass === "task_graph") {
+            const last = classEntries[classEntries.length - 1];
+            if (last !== undefined) {
+                const nodes = last.record.nodes;
+                const edges = last.record.edges;
+                if (Array.isArray(nodes))
+                    taskGraphTaskCount = nodes.length;
+                if (Array.isArray(edges))
+                    taskGraphEdgeCount = edges.length;
+            }
+        }
+        if (evidenceClass === "task_agent_assignment") {
+            taskAgentAssignmentCount = classEntries.length;
+        }
+        if (evidenceClass === "task_model_selection") {
+            const last = classEntries[classEntries.length - 1];
+            if (last !== undefined) {
+                taskModelSelectionStatus = getStringField(last.record, "selection_status");
+                const blockedLabels = last.record.blocked_labels;
+                if (Array.isArray(blockedLabels)) {
+                    taskModelSelectionBlockedLabels = blockedLabels.filter((label) => typeof label === "string");
+                }
+            }
+        }
+        if (evidenceClass === "workflow_synthesis_result") {
+            const last = classEntries[classEntries.length - 1];
+            if (last !== undefined) {
+                workflowSynthesisId = getStringField(last.record, "synthesis_id") ?? last.evidenceId;
+                const tasks = last.record.tasks_summarized;
+                if (typeof tasks === "number")
+                    workflowSynthesisTasksSummarized = tasks;
+                workflowSynthesisConflictDetected = last.record.conflict_detected === true;
+                workflowSynthesisSummaryPreview = synthesisSummaryPreview(getStringField(last.record, "synthesis_summary"));
+            }
+        }
+        if (evidenceClass === "workflow_dispatch_plan") {
+            const last = classEntries[classEntries.length - 1];
+            if (last !== undefined) {
+                workflowDispatchPlanRevisionId = getStringField(last.record, "plan_revision_id");
+                const tasks = last.record.tasks;
+                if (Array.isArray(tasks))
+                    workflowDispatchPlanTaskCount = tasks.length;
+            }
+        }
     }
     const providerUsageSummary = summarizeLatestProviderUsageSnapshot(reload.entries);
     return {
@@ -217,8 +470,248 @@ function summarizeWorkflow(workflowId, reload, maxRecent) {
         ...(providerUsageSummary.count > 0
             ? { providerUsageSnapshotCount: providerUsageSummary.count }
             : {}),
+        ...(workflowAuthoringStatus !== undefined
+            ? { latestWorkflowAuthoringStatus: workflowAuthoringStatus }
+            : {}),
+        ...(workflowAuthoringGoalSummary !== undefined
+            ? { latestWorkflowAuthoringGoalSummary: workflowAuthoringGoalSummary }
+            : {}),
+        ...(taskGraphTaskCount !== undefined
+            ? { latestTaskGraphTaskCount: taskGraphTaskCount }
+            : {}),
+        ...(taskGraphEdgeCount !== undefined
+            ? { latestTaskGraphEdgeCount: taskGraphEdgeCount }
+            : {}),
+        ...(taskAgentAssignmentCount !== undefined
+            ? { latestTaskAgentAssignmentCount: taskAgentAssignmentCount }
+            : {}),
+        ...(taskModelSelectionStatus !== undefined
+            ? { latestTaskModelSelectionStatus: taskModelSelectionStatus }
+            : {}),
+        ...(taskModelSelectionBlockedLabels !== undefined
+            ? { latestTaskModelSelectionBlockedLabels: taskModelSelectionBlockedLabels }
+            : {}),
+        ...(workflowSynthesisId !== undefined
+            ? { latestWorkflowSynthesisId: workflowSynthesisId }
+            : {}),
+        ...(workflowSynthesisTasksSummarized !== undefined
+            ? { latestWorkflowSynthesisTasksSummarized: workflowSynthesisTasksSummarized }
+            : {}),
+        ...(workflowSynthesisConflictDetected !== undefined
+            ? { latestWorkflowSynthesisConflictDetected: workflowSynthesisConflictDetected }
+            : {}),
+        ...(workflowSynthesisSummaryPreview !== undefined
+            ? { latestWorkflowSynthesisSummaryPreview: workflowSynthesisSummaryPreview }
+            : {}),
+        ...(workflowDispatchPlanRevisionId !== undefined
+            ? {
+                latestWorkflowDispatchPlanRevisionId: workflowDispatchPlanRevisionId,
+            }
+            : {}),
+        ...(workflowDispatchPlanTaskCount !== undefined
+            ? { latestWorkflowDispatchPlanTaskCount: workflowDispatchPlanTaskCount }
+            : {}),
     };
 }
+function buildLaneProgressCards(workflowId, reload, projection) {
+    const lifecycleMeta = new Map();
+    const verdictLabels = new Map();
+    const taskResultLaneIds = new Set();
+    const taskResultByLane = new Map();
+    const agentTaskContextByLane = new Map();
+    const childSessionByLane = new Map();
+    const agentTaskProgressByLane = new Map();
+    for (const entry of reload.entries) {
+        if (entry.evidenceClass === "agent_task_progress") {
+            const laneId = getStringField(entry.record, "lane_id");
+            if (laneId !== undefined) {
+                const observedAt = getStringField(entry.record, "observed_at");
+                const observedAtMs = observedAt === undefined ? 0 : Date.parse(observedAt);
+                const current = agentTaskProgressByLane.get(laneId);
+                if (current === undefined || current.observedAtMs <= observedAtMs) {
+                    agentTaskProgressByLane.set(laneId, {
+                        observedAtMs: Number.isFinite(observedAtMs) ? observedAtMs : 0,
+                        phase: getStringField(entry.record, "phase"),
+                        label: getStringField(entry.record, "progress_label"),
+                        observedAt,
+                    });
+                }
+            }
+            continue;
+        }
+        if (entry.evidenceClass === "agent_task_context") {
+            const laneId = getStringField(entry.record, "lane_id");
+            if (laneId !== undefined) {
+                agentTaskContextByLane.set(laneId, {
+                    taskId: getStringField(entry.record, "task_id"),
+                    promptPreview: compactPromptPreview(getStringField(entry.record, "prompt_text")),
+                    promptTextTruncated: entry.record.prompt_text_truncated === true,
+                });
+            }
+            continue;
+        }
+        if (entry.evidenceClass === "agent_task_child_session") {
+            const laneId = getStringField(entry.record, "lane_id");
+            const nudgeCount = entry.record.nudge_count;
+            if (laneId !== undefined) {
+                childSessionByLane.set(laneId, {
+                    ...(typeof nudgeCount === "number" && Number.isFinite(nudgeCount)
+                        ? { nudgeCount }
+                        : {}),
+                });
+            }
+            continue;
+        }
+        if (entry.evidenceClass === "task_result") {
+            const laneId = getStringField(entry.record, "lane_id");
+            if (laneId !== undefined) {
+                taskResultLaneIds.add(laneId);
+                taskResultByLane.set(laneId, {
+                    taskId: getStringField(entry.record, "task_id"),
+                    completionStatus: getStringField(entry.record, "completion_status"),
+                    outputKind: getStringField(entry.record, "output_kind"),
+                    ...(typeof entry.record.usable_for_synthesis === "boolean"
+                        ? { usableForSynthesis: entry.record.usable_for_synthesis }
+                        : {}),
+                });
+            }
+            continue;
+        }
+        if (entry.evidenceClass === "reviewer_verdict") {
+            const label = getStringField(entry.record, "verdict_label");
+            if (label === "pass" ||
+                label === "changes_required" ||
+                label === "blocked" ||
+                label === "inconclusive")
+                verdictLabels.set(entry.evidenceId, label);
+        }
+        if (entry.evidenceClass !== "lane_lifecycle")
+            continue;
+        const laneId = getStringField(entry.record, "lane_id");
+        if (laneId === undefined)
+            continue;
+        const updatedAtRaw = getStringField(entry.record, "updated_at") ??
+            getStringField(entry.record, "created_at");
+        const updatedAtMs = updatedAtRaw === undefined ? 0 : Date.parse(updatedAtRaw);
+        const current = lifecycleMeta.get(laneId);
+        if (current !== undefined && current.updatedAtMs > updatedAtMs)
+            continue;
+        lifecycleMeta.set(laneId, {
+            updatedAtMs: Number.isFinite(updatedAtMs) ? updatedAtMs : 0,
+            state: getStringField(entry.record, "state"),
+            agentRef: getStringField(entry.record, "agent_ref"),
+            providerQualifiedModelId: getStringField(entry.record, "provider_qualified_model_id"),
+            verdictRef: getStringField(entry.record, "verdict_ref"),
+        });
+    }
+    return projection.entries.slice(0, 6).map((entry) => {
+        const meta = lifecycleMeta.get(entry.laneId);
+        const context = agentTaskContextByLane.get(entry.laneId);
+        const childSession = childSessionByLane.get(entry.laneId);
+        const progress = agentTaskProgressByLane.get(entry.laneId);
+        const taskResult = taskResultByLane.get(entry.laneId);
+        const projectedState = meta?.state === "incomplete" && taskResultLaneIds.has(entry.laneId)
+            ? "task_result"
+            : (meta?.state ?? entry.lifecycleState);
+        const taskId = context?.taskId ?? taskResult?.taskId;
+        const verdictLabel = meta?.verdictRef === undefined
+            ? undefined
+            : verdictLabels.get(meta.verdictRef);
+        return {
+            workflowId,
+            laneId: entry.laneId,
+            ...(taskId === undefined ? {} : { taskId }),
+            attemptId: entry.attemptId,
+            state: projectedState,
+            classification: entry.classification,
+            ...(entry.secondsSinceLastSignal === undefined
+                ? {}
+                : { secondsSinceLastSignal: entry.secondsSinceLastSignal }),
+            ...(entry.lastSignalSource === undefined
+                ? {}
+                : { lastSignalSource: entry.lastSignalSource }),
+            ...(meta?.agentRef === undefined ? {} : { agentRef: meta.agentRef }),
+            ...(meta?.providerQualifiedModelId === undefined
+                ? {}
+                : { providerQualifiedModelId: meta.providerQualifiedModelId }),
+            ...(context?.promptPreview === undefined ? {} : { promptPreview: context.promptPreview }),
+            ...(context?.promptTextTruncated === undefined ? {} : { promptTextTruncated: context.promptTextTruncated }),
+            ...(childSession?.nudgeCount === undefined ? {} : { nudgeCount: childSession.nudgeCount }),
+            ...(progress?.phase === undefined ? {} : { progressPhase: progress.phase }),
+            ...(progress?.label === undefined ? {} : { progressLabel: progress.label }),
+            ...(progress?.observedAt === undefined ? {} : { progressObservedAt: progress.observedAt }),
+            ...(verdictLabel === undefined ? {} : { verdictLabel }),
+            ...(taskResult?.completionStatus === undefined
+                ? {}
+                : { completionStatus: taskResult.completionStatus }),
+            ...(taskResult?.outputKind === undefined
+                ? {}
+                : { outputKind: taskResult.outputKind }),
+            ...(taskResult?.usableForSynthesis === undefined
+                ? {}
+                : { usableForSynthesis: taskResult.usableForSynthesis }),
+            ...(entry.failureHint === undefined
+                ? {}
+                : { failureHint: entry.failureHint }),
+            statusCommandRef: "/flowdesk-status",
+            debugCommandRef: "/flowdesk-export-debug",
+        };
+    });
+}
+function buildLaneProgressAggregate(cards, synthesisAlreadyRecorded = false) {
+    const expected = cards.length;
+    const terminal = cards.filter(card => card.classification === "terminal").length;
+    const taskResult = cards.filter(card => card.state === "task_result").length;
+    const failed = cards.filter(card => card.failureHint !== undefined || card.state === "invocation_failed" || card.state === "task_failed").length;
+    const awaitingPermission = cards.filter(card => card.progressPhase === "awaiting_permission").length;
+    const normalCompleted = cards.filter(card => card.state === "task_result" &&
+        card.classification === "terminal" &&
+        card.completionStatus !== "partial" &&
+        card.usableForSynthesis !== false &&
+        card.failureHint === undefined).length;
+    const nextActionReady = expected > 0 && normalCompleted === expected && !synthesisAlreadyRecorded;
+    return {
+        expected,
+        terminal,
+        taskResult,
+        failed,
+        awaitingPermission,
+        normalCompleted,
+        autoNextStepEligible: nextActionReady,
+        nextActionAvailable: nextActionReady,
+        ...(nextActionReady ? { nextActionKind: "synthesis" } : {}),
+        nextActionRefs: ["/flowdesk-status", "/flowdesk-export-debug"],
+    };
+}
+function buildSubtaskActivityRows(cards) {
+    return cards.map((card) => {
+        const recoveryActionRefs = card.failureHint !== undefined ||
+            card.classification === "stalled" ||
+            card.classification === "progressing_late"
+            ? ["/flowdesk-status", "/flowdesk-retry", "/flowdesk-resume", "/flowdesk-abort", "/flowdesk-export-debug"]
+            : ["/flowdesk-status", "/flowdesk-export-debug"];
+        return {
+            workflowId: card.workflowId,
+            laneId: card.laneId,
+            ...(card.taskId === undefined ? {} : { taskId: card.taskId }),
+            ...(card.attemptId === undefined ? {} : { attemptId: card.attemptId }),
+            ...(card.state === undefined ? {} : { state: card.state }),
+            classification: card.classification,
+            ...(card.progressPhase === undefined ? {} : { progressPhase: card.progressPhase }),
+            ...(card.progressLabel === undefined ? {} : { progressLabel: card.progressLabel }),
+            ...(card.progressObservedAt === undefined ? {} : { lastObservedAt: card.progressObservedAt }),
+            ...(card.nudgeCount === undefined ? {} : { nudgeCount: card.nudgeCount }),
+            ...(card.completionStatus === undefined ? {} : { completionStatus: card.completionStatus }),
+            ...(card.outputKind === undefined ? {} : { outputKind: card.outputKind }),
+            ...(card.usableForSynthesis === undefined ? {} : { usableForSynthesis: card.usableForSynthesis }),
+            ...(card.verdictLabel === undefined ? {} : { verdictLabel: card.verdictLabel }),
+            ...(card.failureHint === undefined ? {} : { failureHint: card.failureHint }),
+            recoveryActionRefs,
+            statusCommandRef: "/flowdesk-status",
+            debugCommandRef: "/flowdesk-export-debug",
+        };
+    });
+}
 function summarizeLatestProviderUsageSnapshot(entries) {
     const snapshots = entries.filter((entry) => entry.evidenceClass === "provider_usage_snapshot");
     if (snapshots.length === 0)
@@ -249,6 +742,7 @@ export async function executeFlowDeskStatusLiveV1(input) {
             workflows: [],
             redactedBlockReason: "status live tool requires a durable state root directory",
             safeNextActions: safeNextActions(),
+            authorityCapabilitySummary: authorityCapabilitySummary(),
             authority: blockedAuthority(),
         };
     }
@@ -267,51 +761,93 @@ export async function executeFlowDeskStatusLiveV1(input) {
                 ? `no durable session evidence for workflow ${requestedWorkflowId}`
                 : "no durable session workflows found under the configured durable state root",
             safeNextActions: safeNextActions(),
+            authorityCapabilitySummary: authorityCapabilitySummary(),
             authority: blockedAuthority(),
         };
     }
     const workflows = [];
     for (const workflowId of workflowIds) {
-        const reload = reloadFlowDeskSessionEvidenceV1({
+        backfillTerminalAgentTaskFailedLanesV1({
+            workflowId,
+            rootDir,
+            now: new Date(observedAt),
+        });
+        let reload = reloadFlowDeskSessionEvidenceV1({
             workflowId,
             rootDir,
         });
-        const summary = summarizeWorkflow(workflowId, reload, maxRecentEvidencePerClass);
-        const projectionReload = pruneNonTerminalLifecycleSnapshotsNoLongerValid(reload);
-        const projection = projectFlowDeskLaneStallV1({
+        let summary;
+        let projectionReload;
+        let projection;
+        const buildWorkflowSummary = () => {
+            summary = summarizeWorkflow(workflowId, reload, maxRecentEvidencePerClass);
+            projectionReload = pruneInconsistencySnapshotsNoLongerValid(pruneNonTerminalLifecycleSnapshotsNoLongerValid(reload));
+            projection = projectFlowDeskLaneStallV1({
+                workflowId,
+                reload: projectionReload,
+                observedAt,
+                ...(input.config.laneHeartbeatLateThresholdMs === undefined
+                    ? {}
+                    : { lateThresholdMs: input.config.laneHeartbeatLateThresholdMs }),
+                ...(input.config.laneHeartbeatStallThresholdMs === undefined
+                    ? {}
+                    : { stallThresholdMs: input.config.laneHeartbeatStallThresholdMs }),
+            });
+            summary.laneStallProjection = projection;
+            const projectedLifecycleStates = projection.entries
+                .map((entry) => entry.lifecycleState)
+                .filter((state) => typeof state === "string" && state.length > 0);
+            if (projectedLifecycleStates.length > 0) {
+                summary.latestLaneLifecycleStates = projectedLifecycleStates;
+            }
+            summary.worstLaneStallClassification = projection.worstClassification;
+            summary.stalledLaneCount = projection.totalStalledLanes;
+            summary.progressingLateLaneCount = projection.totalLateLanes;
+            summary.inconsistentFinalizingWithoutTerminalLaneCount =
+                projection.totalInconsistentLanes;
+            summary.laneProgressCards = buildLaneProgressCards(workflowId, projectionReload, projection);
+            summary.subtaskActivityRows = buildSubtaskActivityRows(summary.laneProgressCards);
+            summary.laneProgressAggregate = buildLaneProgressAggregate(summary.laneProgressCards, summary.latestWorkflowSynthesisTasksSummarized !== undefined);
+        };
+        const graceMs = clampFinalizingInconsistencyGraceMs(input.config.agentTaskFinalizingInconsistencyGraceMs);
+        const wroteInconsistency = materializeFinalizingWithoutTerminalInconsistencies({
             workflowId,
-            reload: projectionReload,
+            rootDir,
+            reload,
             observedAt,
-            ...(input.config.laneHeartbeatLateThresholdMs === undefined
-                ? {}
-                : { lateThresholdMs: input.config.laneHeartbeatLateThresholdMs }),
-            ...(input.config.laneHeartbeatStallThresholdMs === undefined
-                ? {}
-                : { stallThresholdMs: input.config.laneHeartbeatStallThresholdMs }),
+            graceMs,
         });
-        summary.laneStallProjection = projection;
-        summary.worstLaneStallClassification = projection.worstClassification;
-        summary.stalledLaneCount = projection.totalStalledLanes;
-        summary.progressingLateLaneCount = projection.totalLateLanes;
+        if (wroteInconsistency) {
+            reload = reloadFlowDeskSessionEvidenceV1({
+                workflowId,
+                rootDir,
+            });
+        }
+        buildWorkflowSummary();
         workflows.push(summary);
     }
     const observed = workflows.some((summary) => Object.values(summary.evidenceCounts).some((count) => typeof count === "number" && count > 0));
     const totalStalled = workflows.reduce((sum, summary) => sum + (summary.stalledLaneCount ?? 0), 0);
     const totalLate = workflows.reduce((sum, summary) => sum + (summary.progressingLateLaneCount ?? 0), 0);
-    const worstLaneStallClassification = workflows.some((summary) => summary.worstLaneStallClassification === "stalled")
-        ? "stalled"
-        : workflows.some((summary) => summary.worstLaneStallClassification === "progressing_late")
-            ? "progressing_late"
-            : workflows.some((summary) => summary.worstLaneStallClassification === "progressing_normal")
-                ? "progressing_normal"
-                : workflows.some((summary) => summary.worstLaneStallClassification === "terminal")
-                    ? "terminal"
-                    : "unknown";
+    const totalInconsistent = workflows.reduce((sum, summary) => sum + (summary.inconsistentFinalizingWithoutTerminalLaneCount ?? 0), 0);
+    const worstLaneStallClassification = workflows.some((summary) => summary.worstLaneStallClassification ===
+        "inconsistent_finalizing_without_terminal")
+        ? "inconsistent_finalizing_without_terminal"
+        : workflows.some((summary) => summary.worstLaneStallClassification === "stalled")
+            ? "stalled"
+            : workflows.some((summary) => summary.worstLaneStallClassification === "progressing_late")
+                ? "progressing_late"
+                : workflows.some((summary) => summary.worstLaneStallClassification === "progressing_normal")
+                    ? "progressing_normal"
+                    : workflows.some((summary) => summary.worstLaneStallClassification === "terminal")
+                        ? "terminal"
+                        : "unknown";
     const summaryForUser = buildStatusLiveSummaryForUser({
         workflows,
         worstLaneStallClassification,
         totalStalled,
         totalLate,
+        totalInconsistent,
         requestedWorkflowId,
     });
     return {
@@ -324,8 +860,10 @@ export async function executeFlowDeskStatusLiveV1(input) {
         worstLaneStallClassification,
         totalStalledLaneCount: totalStalled,
         totalProgressingLateLaneCount: totalLate,
+        totalInconsistentFinalizingWithoutTerminalLaneCount: totalInconsistent,
         summaryForUser,
         safeNextActions: safeNextActions(),
+        authorityCapabilitySummary: authorityCapabilitySummary(),
         authority: {
             realOpenCodeDispatch: false,
             providerCall: false,
@@ -345,26 +883,70 @@ function buildStatusLiveSummaryForUser(input) {
             ? `FlowDesk status: no durable evidence for workflow ${input.requestedWorkflowId}.`
             : "FlowDesk status: no durable workflows found.";
     }
-    const headline = input.totalStalled > 0
-        ? `FlowDesk status: ${workflowsCount} workflow(s); worst classification stalled (${input.totalStalled} stalled, ${input.totalLate} progressing-late).`
-        : input.totalLate > 0
-            ? `FlowDesk status: ${workflowsCount} workflow(s); ${input.totalLate} progressing-late, no stalled lanes.`
-            : input.worstLaneStallClassification === "terminal"
-                ? `FlowDesk status: ${workflowsCount} workflow(s); all observed lanes terminal/complete.`
-                : input.worstLaneStallClassification === "progressing_normal"
-                    ? `FlowDesk status: ${workflowsCount} workflow(s); active lanes progressing_normal.`
-                    : `FlowDesk status: ${workflowsCount} workflow(s); worst classification ${input.worstLaneStallClassification}.`;
+    const headline = input.totalInconsistent > 0
+        ? `FlowDesk status: ${workflowsCount} workflow(s); ${input.totalInconsistent} finalizing-without-terminal inconsistent lane(s) require manual recovery.`
+        : input.totalStalled > 0
+            ? `FlowDesk status: ${workflowsCount} workflow(s); worst classification stalled (${input.totalStalled} stalled, ${input.totalLate} progressing-late).`
+            : input.totalLate > 0
+                ? `FlowDesk status: ${workflowsCount} workflow(s); ${input.totalLate} progressing-late, no stalled lanes.`
+                : input.worstLaneStallClassification === "terminal"
+                    ? `FlowDesk status: ${workflowsCount} workflow(s); all observed lanes terminal/complete.`
+                    : input.worstLaneStallClassification === "progressing_normal"
+                        ? `FlowDesk status: ${workflowsCount} workflow(s); active lanes progressing_normal.`
+                        : `FlowDesk status: ${workflowsCount} workflow(s); worst classification ${input.worstLaneStallClassification}.`;
     const perWorkflow = input.workflows.slice(0, 3).map((workflow) => {
         const verdictLabels = workflow.latestReviewerVerdictLabels;
         const verdictText = verdictLabels.length > 0
             ? `verdicts=${verdictLabels.join("/")}`
             : "verdicts=(none)";
-        const lifecycleStates = workflow.latestLaneLifecycleStates;
+        const projectedLaneStates = (workflow.laneProgressCards ?? [])
+            .slice(0, 3)
+            .map((lane) => `${lane.state ?? "unknown"}/${lane.classification}`);
+        const lifecycleStates = projectedLaneStates.length > 0 ? projectedLaneStates : workflow.latestLaneLifecycleStates;
         const lifecycleText = lifecycleStates.length > 0
-            ? `lifecycle=${lifecycleStates.slice(0, 3).join("/")}`
-            : "lifecycle=(none)";
+            ? `${projectedLaneStates.length > 0 ? "lane_state" : "lifecycle"}=${lifecycleStates.slice(0, 3).join("/")}`
+            : "lane_state=(none)";
+        const synthesisPreview = workflow.latestWorkflowSynthesisSummaryPreview === undefined
+            ? ""
+            : ` preview="${workflow.latestWorkflowSynthesisSummaryPreview.replace(/"/g, "'").slice(0, 96)}"`;
+        const synthesisText = workflow.latestWorkflowSynthesisTasksSummarized !== undefined
+            ? ` synthesis=${workflow.latestWorkflowSynthesisTasksSummarized} tasks${workflow.latestWorkflowSynthesisConflictDetected ? " conflict=detected" : ""}${synthesisPreview}`
+            : "";
+        const autoNextText = workflow.laneProgressAggregate?.autoNextStepEligible === true ? " auto_next=ready" : "";
+        const nextActionText = workflow.laneProgressAggregate?.nextActionAvailable === true
+            ? ` next_action=${workflow.laneProgressAggregate.nextActionKind ?? "available"}_ready`
+            : "";
+        const planText = workflow.latestWorkflowDispatchPlanRevisionId !== undefined
+            ? `workflow_plan=${workflow.latestWorkflowDispatchPlanRevisionId} tasks=${workflow.latestWorkflowDispatchPlanTaskCount ?? "unknown"}${synthesisText}${autoNextText}${nextActionText}`
+            : workflow.latestTaskGraphTaskCount !== undefined
+                ? `planning_slice=${workflow.latestWorkflowAuthoringStatus ?? "unknown"} tasks=${workflow.latestTaskGraphTaskCount} assignments=${workflow.latestTaskAgentAssignmentCount ?? 0} model=${workflow.latestTaskModelSelectionStatus ?? "unknown"}${synthesisText}${autoNextText}${nextActionText}`
+                : synthesisText.length > 0
+                    ? `${synthesisText.trim()}${autoNextText}${nextActionText}`
+                    : `workflow_plan=(none)${autoNextText}${nextActionText}`;
         const classification = workflow.worstLaneStallClassification ?? "unknown";
-        return `- ${workflow.workflowId}: ${classification}, ${verdictText}, ${lifecycleText}`;
+        const lanePreview = (workflow.laneProgressCards ?? [])
+            .slice(0, 2)
+            .map((lane) => {
+            const age = lane.secondsSinceLastSignal === undefined
+                ? "unknown"
+                : `~${Math.floor(lane.secondsSinceLastSignal / 60)}m`;
+            return `${lane.laneId}:${lane.state ?? "unknown"}/${lane.classification}/last=${age}`;
+        })
+            .join(", ");
+        const subtaskPreview = (workflow.subtaskActivityRows ?? [])
+            .slice(0, 3)
+            .map((row) => {
+            const actions = (row.recoveryActionRefs ?? [])
+                .slice(0, 5)
+                .map((action) => action.replace("/flowdesk-", ""))
+                .join("|");
+            const compact = `${row.laneId}:${row.state ?? "unknown"}/${row.classification}${actions.length > 0 ? `[${actions}]` : ""}`;
+            return compact.length > 96 ? `${compact.slice(0, 95)}…` : compact;
+        })
+            .join("; ");
+        const laneText = lanePreview.length > 0 && subtaskPreview.length === 0 ? `, lanes=${lanePreview}` : "";
+        const subtaskText = subtaskPreview.length > 0 ? `, subtasks=${subtaskPreview}` : "";
+        return `- ${workflow.workflowId}: ${classification}, ${verdictText}, ${lifecycleText}, ${planText}${laneText}${subtaskText}`;
     });
     return [headline, ...perWorkflow].join("\n");
 }