@zq-silk/yui 0.10.0 → 0.11.0

package/dist/task/nextAction.js

@@ -2,8 +2,11 @@ import { createHash } from "node:crypto";
 import { changeSetDeliverySettled, governingChangeSets } from "../integration/deliveryObligation.js";
 import { deltaRecheckBlocksAcceptance } from "../review/reviewRound.js";
 import { classifyReviewRoundOutcome, isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
+import { actionableExecutionLaneRecoveries } from "../execution/executionHealth.js";
+import { candidateConvergenceDisagreement, candidateConvergenceEvidenceSufficient, candidateConvergenceStageResultsValid } from "../execution/candidateConvergence.js";
+import { executionStageSpendClosed, routeExecutionStage } from "../execution/resourceBroker.js";
 import { resolveRecordedTaskFinalReviewContract } from "../review/taskFinalReviewContractRebind.js";
-import { currentWorkItemCandidate, governingWorkItemCandidate } from "../workItem/workItem.js";
+import { currentWorkItemCandidate, currentWorkItemExecutionGroup, governingWorkItemCandidate } from "../workItem/workItem.js";
 const OPEN_WORK_ITEM_STATUSES = new Set(["pending", "running", "awaiting_acceptance"]);
 export function projectNextAction(facts) {
     const { task } = facts;
@@ -40,6 +43,45 @@ export function projectNextAction(facts) {
             recommendedCommand: inconsistency.recommendedCommand
         });
     }
+    const laneRecovery = actionableExecutionLaneRecoveries(facts.executionGroups ?? [])
+        .find(hasExactRun);
+    if (laneRecovery !== undefined) {
+        return buildExecutionLaneRecoveryAction(facts, laneRecovery);
+    }
+    // Quick Win (EXE-03): a resume Run that failed before durable Provider
+    // acceptance must not be retried against the same native Session.  The
+    // authoritative next action is to replace the Session, not to retry the
+    // same delivery.  The guard only applies while the failed resume Run is the
+    // *latest* Leader Run: once a newer Run exists (the fresh-Session launch),
+    // the historical failure is stale and must not keep recommending a Session
+    // replacement.
+    const latestLeaderRun = facts.leaderRuns.at(-1);
+    const failedResumeWithoutAcceptance = latestLeaderRun !== undefined
+        && latestLeaderRun.mode === "resume"
+        && latestLeaderRun.status === "failed"
+        && latestLeaderRun.deliveredAt === undefined
+        ? latestLeaderRun
+        : undefined;
+    if (failedResumeWithoutAcceptance !== undefined) {
+        return buildAction(facts, {
+            kind: "replace-leader-session",
+            reason: `Leader resume Run ${failedResumeWithoutAcceptance.id} failed before Provider acceptance; `
+                + "the native Session is proven unusable for this delivery. Replace it with a fresh Session "
+                + "after exact cleanup/reset.",
+            refs: [ref("agent-run", failedResumeWithoutAcceptance.id)],
+            preconditions: [
+                { fact: "Resume Run failed without durable acceptance", satisfied: true, ref: ref("agent-run", failedResumeWithoutAcceptance.id) },
+                { fact: "Old Session is cleaned up or reset before fresh launch", satisfied: false }
+            ],
+            // The failed resume Run is already terminal, so `task run recover
+            // --action replace-session` (which requires an active Run) cannot act
+            // on it.  The working recovery is to reset the Role's Session
+            // generation, then clear the Leader failure so the next wake launches
+            // a fresh Session (the failed-resume guard in the wakeup processor
+            // forces mode=new for the next launch).
+            recommendedCommand: `yui task role reset ${task.id} leader --reason "resume failed before acceptance" && yui jobs retry leader-recovery:${task.id}`
+        });
+    }
     const activeLeader = facts.activeRuns.find((run) => run.roleName === "leader");
     if (activeLeader !== undefined) {
         return buildAction(facts, {
@@ -99,6 +141,18 @@ export function projectNextAction(facts) {
                 }
                 const reviewRun = activeReviewRoundRun(activeReview, facts.activeRuns);
                 if (reviewRun === undefined) {
+                    if (reviewGroupHasResourceQueue(activeReview)) {
+                        return buildAction(facts, {
+                            kind: "resume-review",
+                            reason: `ReviewRound ${activeReview.id} has Reviewer Lanes waiting for Resource Broker capacity.`,
+                            refs: [reviewRef],
+                            preconditions: [
+                                { fact: "A Reviewer Lane is durably queued", satisfied: true, ref: reviewRef },
+                                { fact: "Resource capacity is available", satisfied: false }
+                            ],
+                            recommendedCommand: `yui task work review ${task.id}/${candidateReady.id}`
+                        });
+                    }
                     const runRef = ref("agent-run", activeReview.reviewerRunId);
                     return buildAction(facts, {
                         kind: "repair-protocol-inconsistency",
@@ -202,6 +256,18 @@ export function projectNextAction(facts) {
                 recommendedCommand: `yui task review finding repair-wave ${task.id} --create`
             });
         }
+        const explorationStop = exhaustedExplorationReason(failedWork, facts.executionGroups);
+        if (explorationStop !== undefined) {
+            return buildAction(facts, {
+                kind: "implement-current-work-item",
+                reason: explorationStop,
+                refs: [ref("work-item", failedWork.id)],
+                preconditions: [
+                    { fact: "Work Item exploration cannot continue", satisfied: true, ref: ref("work-item", failedWork.id) }
+                ],
+                recommendedCommand: `yui task work retire ${task.id}/${failedWork.id} --summary \"<reason>\"`
+            });
+        }
         return buildAction(facts, {
             kind: "implement-current-work-item",
             reason: `Work Item ${failedWork.id} failed without a Review verdict; retry implementation.`,
@@ -209,7 +275,9 @@ export function projectNextAction(facts) {
             preconditions: [
                 { fact: "Work Item is failed", satisfied: true, ref: ref("work-item", failedWork.id) }
             ],
-            recommendedCommand: `yui task work update ${task.id}/${failedWork.id} running`
+            recommendedCommand: failedWork.assignee === undefined
+                ? `yui task work update ${task.id}/${failedWork.id} running`
+                : `yui task work dispatch ${task.id}/${failedWork.id}`
         });
     }
     const openWork = selectOpenWorkItem(facts.workItems);
@@ -230,6 +298,9 @@ export function projectNextAction(facts) {
     }
     if (openWork?.kind === "ready") {
         const item = openWork.item;
+        const stageAction = buildExecutionStageAction(facts, item);
+        if (stageAction !== null)
+            return stageAction;
         const refs = [ref("work-item", item.id)];
         return buildAction(facts, {
             kind: "implement-current-work-item",
@@ -379,6 +450,18 @@ export function projectNextAction(facts) {
             }
             const reviewRun = activeReviewRoundRun(activeFinal, facts.activeRuns);
             if (reviewRun === undefined) {
+                if (reviewGroupHasResourceQueue(activeFinal)) {
+                    return buildAction(facts, {
+                        kind: "resume-review",
+                        reason: `Task-final ReviewRound ${activeFinal.id} has Reviewer Lanes waiting for Resource Broker capacity.`,
+                        refs: [reviewRef],
+                        preconditions: [
+                            { fact: "A Reviewer Lane is durably queued", satisfied: true, ref: reviewRef },
+                            { fact: "Resource capacity is available", satisfied: false }
+                        ],
+                        recommendedCommand: `yui task review request ${task.id} --role ${activeFinal.reviewerRoleName}`
+                    });
+                }
                 const runRef = ref("agent-run", activeFinal.reviewerRunId);
                 return buildAction(facts, {
                     kind: "repair-protocol-inconsistency",
@@ -486,6 +569,77 @@ export function projectNextAction(facts) {
         recommendedCommand: `yui task complete ${task.id} --summary-file -`
     });
 }
+function hasExactRun(lane) {
+    return lane.runId !== undefined;
+}
+function buildExecutionLaneRecoveryAction(facts, lane) {
+    const refs = [
+        ref("execution-group", lane.groupId),
+        ref("execution-lane", lane.laneId),
+        ref("agent-run", lane.runId)
+    ];
+    if (lane.recovery === "retry-new-agent-run") {
+        return buildAction(facts, {
+            kind: "recover-execution-lane",
+            reason: `Execution Lane ${lane.laneId} is durably failed; retry only exact Run ${lane.runId} and retain sibling results.`,
+            refs,
+            preconditions: [
+                { fact: "Execution Lane is failed and unresolved", satisfied: true, ref: refs[1] },
+                { fact: "Exact failed AgentRun is retained", satisfied: true, ref: refs[2] }
+            ],
+            recommendedCommand: `yui task run retry ${facts.task.id}/${lane.runId}`
+        });
+    }
+    const action = lane.recovery === "diagnose" ? "diagnose" : "terminate";
+    const recovery = facts.runRecoveries?.find(({ runId }) => runId === lane.runId);
+    const plan = recovery?.actions.find((candidate) => candidate.action === action);
+    return buildAction(facts, {
+        kind: "recover-execution-lane",
+        reason: lane.recovery === "diagnose"
+            ? `Execution Lane ${lane.laneId} needs bounded diagnostics for exact Run ${lane.runId}.`
+            : `Execution Lane ${lane.laneId} has confirmed death evidence; terminate exact Run ${lane.runId}.`,
+        refs,
+        preconditions: [
+            { fact: `Lane recovery is ${lane.recovery}`, satisfied: true, ref: refs[1] },
+            {
+                fact: `Exact Run exposes a current ${action} recovery plan`,
+                satisfied: plan !== undefined,
+                ref: refs[2]
+            }
+        ],
+        ...(plan === undefined ? {} : { recommendedCommand: plan.command }),
+        ...(plan !== undefined && recovery?.judgmentRequired === undefined
+            ? {}
+            : {
+                judgmentRequired: recovery?.judgmentRequired
+                    ?? `Inspect yui task run show ${facts.task.id}/${lane.runId}; its exact recovery fence is unavailable.`
+            })
+    });
+}
+function exhaustedExplorationReason(item, executionGroups) {
+    const group = currentWorkItemExecutionGroup(item);
+    if (group?.stage === undefined || group.resolution === undefined)
+        return undefined;
+    if (group.resolution.decision === "reject") {
+        return `Work Item ${item.id} exploration was rejected and has no legal continuation; retire it explicitly.`;
+    }
+    if (group.resolution.decision === "retry"
+        && group.stage.stage === "resolve"
+        && group.stage.round >= group.stage.maxRounds) {
+        return `Work Item ${item.id} exhausted its exploration round budget; retire it explicitly.`;
+    }
+    const resources = executionGroups?.find(({ groupId }) => groupId === group.id)?.resources;
+    if ((group.resolution.decision === "retry" || group.resolution.decision === "blocked")
+        && resources !== undefined
+        && executionStageSpendClosed(resources)) {
+        return `Work Item ${item.id} cannot retry its frozen exploration resource budget; retire it explicitly or replace it with a newly authorized delivery boundary.`;
+    }
+    if ((group.resolution.decision === "retry" || group.resolution.decision === "blocked")
+        && group.stage.stageAttempt >= group.stage.budget.maxAttempts) {
+        return `Work Item ${item.id} exhausted its ${group.stage.stage} stage attempt budget; retire it explicitly.`;
+    }
+    return undefined;
+}
 /**
  * Stable fingerprint of the durable delivery position. It changes exactly
  * when a delivery record changes, so the semantic-progress budget can compare
@@ -527,6 +681,156 @@ function buildAction(facts, input) {
         fingerprint: createHash("sha256").update(fingerprintSource).digest("hex")
     };
 }
+function buildExecutionStageAction(facts, item) {
+    const group = currentWorkItemExecutionGroup(item);
+    if (group?.stage?.resources === undefined || group.resolution !== undefined)
+        return null;
+    const projected = facts.executionGroups?.find(({ groupId }) => groupId === group.id);
+    const resources = projected?.resources;
+    if (resources === undefined)
+        return null;
+    const usableLaneIds = group.lanes.filter(({ status }) => (status === "yielded" || status === "completed")).map(({ id }) => id);
+    const stageResultsValid = candidateConvergenceStageResultsValid(group);
+    const disagreement = candidateConvergenceDisagreement(group);
+    const routing = routeExecutionStage({
+        group,
+        resources,
+        evidenceSufficient: candidateConvergenceEvidenceSufficient(item, group, usableLaneIds),
+        disagreement
+    });
+    const refs = [ref("work-item", item.id), ref("execution-group", group.id)];
+    const resolveCommand = (decision, suffix = "") => (`yui task work group resolve ${facts.task.id}/${item.id}`
+        + ` --decision ${decision} --summary \"<stage decision>\"${suffix}`);
+    if (routing.action === "blocked") {
+        return buildAction(facts, {
+            kind: "resolve-execution-stage",
+            reason: `${routing.reason}; dispatch would preserve the same pending Lanes without starting them.`,
+            refs,
+            preconditions: [
+                { fact: "Execution stage is unresolved", satisfied: true, ref: refs[1] },
+                {
+                    fact: "Stage deadline or hard budget is exhausted",
+                    satisfied: executionStageSpendClosed(resources),
+                    ref: refs[1]
+                },
+                { fact: "Acceptance-level evidence is sufficient", satisfied: false, ref: refs[1] }
+            ],
+            recommendedCommand: resolveCommand("blocked"),
+            judgmentRequired: "Leader must record the resource-blocked stage, then retire or replace the delivery boundary; the frozen budget cannot be reopened by redispatch."
+        });
+    }
+    if (routing.action === "expand-parallel") {
+        return buildAction(facts, {
+            kind: "resolve-execution-stage",
+            reason: routing.reason,
+            refs,
+            preconditions: [
+                {
+                    fact: "Stage quorum is open or structured results show material disagreement",
+                    satisfied: !resources.quorumMet || disagreement === "high",
+                    ref: refs[1]
+                },
+                {
+                    fact: "Adaptive Lane capacity remains",
+                    satisfied: group.strategy.mode === "adaptive"
+                        && group.lanes.length < group.strategy.max,
+                    ref: refs[1]
+                }
+            ],
+            recommendedCommand: `yui task work dispatch ${facts.task.id}/${item.id} --lane-role <independent-role>`,
+            ...(resources.quorumMet
+                ? {
+                    alternatives: [{
+                            kind: "deepen-sequential",
+                            reason: "Resolve the current evidence and deepen sequentially when another independent Lane has lower value.",
+                            recommendedCommand: resolveCommand("accept"),
+                            refs
+                        }]
+                }
+                : {}),
+            judgmentRequired: resources.quorumMet
+                ? "Leader must choose an unused compatible Task Role for expansion or deliberately select the sequential alternative."
+                : "Leader must choose an unused compatible Task Role so the frozen stage can satisfy quorum."
+        });
+    }
+    if (routing.action === "deepen-sequential") {
+        const resolveRequestsNextRound = group.stage.stage === "resolve";
+        const decision = usableLaneIds.length === 0
+            || !stageResultsValid
+            || !resources.quorumMet
+            || resolveRequestsNextRound
+            ? "retry"
+            : "accept";
+        return buildAction(facts, {
+            kind: "resolve-execution-stage",
+            reason: resolveRequestsNextRound
+                ? "Resolve evidence does not establish a Candidate; begin another bounded exploration round."
+                : !resources.quorumMet
+                    ? "The stage exhausted its Lane capacity before quorum; resolve it as a bounded retry."
+                    : decision === "retry"
+                        ? "The stage has no structurally usable output; resolve it as a bounded retry before redispatch."
+                        : routing.reason,
+            refs,
+            preconditions: [
+                { fact: "No stage Lane remains active or queued", satisfied: true, ref: refs[1] },
+                { fact: "Current stage has structurally usable output", satisfied: stageResultsValid, ref: refs[1] },
+                { fact: "Stage quorum is met", satisfied: resources.quorumMet, ref: refs[1] }
+            ],
+            recommendedCommand: resolveCommand(decision),
+            judgmentRequired: resolveRequestsNextRound
+                ? "Leader must judge whether the frozen round budget permits another exploration round or the WorkItem should be retired."
+                : decision === "retry"
+                    ? "Leader must judge whether the frozen attempt budget permits one retry or the WorkItem should be retired."
+                    : "Leader must select the usable stage evidence before advancing to the next bounded stage."
+        });
+    }
+    if (routing.action === "resolve") {
+        const earlyStop = routing.cancelPendingLaneIds.length === 0
+            ? ""
+            : " --early-stop <observed-marginal-value>";
+        return buildAction(facts, {
+            kind: "resolve-execution-stage",
+            reason: routing.reason,
+            refs,
+            preconditions: [
+                { fact: "Stage quorum is met", satisfied: resources.quorumMet, ref: refs[1] },
+                { fact: "Acceptance-level evidence is sufficient", satisfied: true, ref: refs[1] }
+            ],
+            recommendedCommand: resolveCommand("accept", earlyStop),
+            judgmentRequired: routing.cancelPendingLaneIds.length === 0
+                ? "Leader must select and accept the evidence that satisfies the stage contract."
+                : "Leader must record the observed marginal value before skipping never-started pending Lanes."
+        });
+    }
+    if (resources.pendingLaneIds.length > 0 && resources.activeLaneIds.length === 0) {
+        return buildAction(facts, {
+            kind: "implement-current-work-item",
+            reason: `ExecutionGroup ${group.id} has queued Lanes and an open resource budget; retry Broker admission after the capacity wake.`,
+            refs,
+            preconditions: [
+                { fact: "At least one Lane is durably queued", satisfied: true, ref: refs[1] },
+                {
+                    fact: "Stage deadline and hard budgets remain open",
+                    satisfied: !executionStageSpendClosed(resources),
+                    ref: refs[1]
+                }
+            ],
+            recommendedCommand: `yui task work dispatch ${facts.task.id}/${item.id}`
+        });
+    }
+    if (resources.activeLaneIds.length > 0) {
+        return buildAction(facts, {
+            kind: "repair-protocol-inconsistency",
+            reason: `ExecutionGroup ${group.id} retains active Lanes but no delegated AgentRun is active.`,
+            refs,
+            conflicts: refs,
+            preconditions: [
+                { fact: "Every active Lane has an active exact AgentRun", satisfied: false, ref: refs[1] }
+            ]
+        });
+    }
+    return null;
+}
 function latestActiveWorkItemReview(rounds, item, candidate) {
     if (candidate === undefined)
         return undefined;
@@ -567,6 +871,12 @@ function reviewGroupAwaitingResolution(round) {
         && isPanelReviewRound(round)
         && round.executionGroup.lanes.every((lane) => TERMINAL_REVIEW_LANE_STATUSES.has(lane.status));
 }
+function reviewGroupHasResourceQueue(round) {
+    return round.executionGroup !== undefined
+        && round.executionGroup.resolution === undefined
+        && round.executionGroup.lanes.some((lane) => (lane.status === "pending"
+            && lane.runId === undefined));
+}
 function buildResolveReviewGroupAction(facts, round) {
     const group = round.executionGroup;
     const refs = [
@@ -621,6 +931,8 @@ function reviewRoundConflict(round, activeRuns) {
             };
         }
         if (activeReviewRoundRun(round, activeRuns) === undefined) {
+            if (reviewGroupHasResourceQueue(round))
+                return null;
             const runRef = ref("agent-run", round.reviewerRunId);
             return {
                 reason: `ReviewRound ${round.id} references Reviewer Run ${round.reviewerRunId}, but that Run is not active.`,

package/dist/web/assets/client/components.js

@@ -175,12 +175,37 @@ export function executionGroupCard(summary, t, locale) {
   head.append(pills);
   card.append(head);
 
+  if (summary.stage) {
+    const stage = node("div", "record-meta execution-stage-meta");
+    stage.append(node("span", "mono", t("detail.stage") + " · " + (summary.stage.stage || "—")));
+    stage.append(node("span", "", t("detail.round") + " · " + String(summary.stage.round)));
+    stage.append(node("span", "", t("detail.stageAttempt") + " · " + String(summary.stage.stageAttempt)));
+    stage.append(chip(t("mode." + summary.stage.mode)));
+    card.append(stage);
+  }
+  if (summary.resources) {
+    const resources = summary.resources;
+    const budget = node("div", "record-meta execution-resource-meta");
+    budget.append(node("span", "", t("detail.cost") + " · "
+      + formatResource(resources.tokens, resources.tokensRemaining, resources.tokensObservable) + " tokens"));
+    budget.append(node("span", "", formatResource(resources.toolCalls, resources.toolCallsRemaining, resources.toolCallsObservable) + " tools"));
+    budget.append(node("span", "", resources.wallClockSeconds + "s"));
+    budget.append(node("span", "", t("detail.quorum") + " · "
+      + resources.usableLaneCount + "/" + (summary.stage.resources?.quorum || "—")));
+    card.append(budget);
+  }
+
   const lanes = node("div", "lane-list");
   summary.laneSummaries.forEach(function (lane) {
     const row = node("div", "lane-row");
     row.append(statusDot(lane.status));
     row.append(node("span", "lane-role", lane.roleName));
     row.append(node("span", "lane-status", t("lane." + lane.status)));
+    if (lane.effective) {
+      const config = [lane.effective.adapterId, lane.effective.model, lane.effective.effort]
+        .filter(function (value) { return value; }).join(" · ");
+      if (config) row.append(chip(config));
+    }
     if (lane.summary) {
       row.append(node("span", "lane-summary", lane.summary));
     }
@@ -202,6 +227,63 @@ export function executionGroupCard(summary, t, locale) {
   return card;
 }
 
+function formatResource(used, remaining, observable) {
+  const value = String(used) + (remaining === undefined ? "" : "/" + String(used + remaining));
+  return observable === false ? value + "*" : value;
+}
+
+export function observabilityMetricCard(observability, t) {
+  if (!observability) return null;
+  const card = node("div", "observability-metrics");
+  const cost = observability.cost || {};
+  const context = observability.context || {};
+  card.append(metricTile(t("detail.tokens"), cost.tokens + (cost.tokensObservable === false ? "*" : "")));
+  card.append(metricTile(t("detail.toolCalls"), cost.toolCalls + (cost.toolCallsObservable === false ? "*" : "")));
+  card.append(metricTile(t("detail.wallClock"), cost.wallClockSeconds + "s"));
+  card.append(metricTile(t("detail.ready"), (observability.dag?.readyIds || []).length, { hot: true }));
+  card.append(metricTile(t("detail.contextSnapshots"), context.snapshotCount));
+  card.append(metricTile(t("detail.contextPeak"), context.observedInputPeakTokens));
+  const contextMeta = node("div", "record-meta observability-context-meta");
+  contextMeta.append(node("span", "", t("detail.contextBytes") + " · "
+    + (context.totalBytes === null ? t("detail.partial") : context.totalBytes + " B")));
+  contextMeta.append(node("span", "", t("detail.compression") + " · " + t("detail.unavailable")));
+  contextMeta.append(node("span", "", t("detail.marginalValue") + " · " + t("detail.unavailable")));
+  card.append(contextMeta);
+  return card;
+}
+
+export function dagGraph(dag, t) {
+  if (!dag || !dag.nodes || !dag.nodes.length) return emptyRow(t);
+  const graph = node("div", "dag-graph");
+  const edgeByTarget = {};
+  (dag.edges || []).forEach(function (edge) {
+    if (!edgeByTarget[edge.to]) edgeByTarget[edge.to] = [];
+    edgeByTarget[edge.to].push(edge);
+  });
+  dag.nodes.forEach(function (item) {
+    const row = node("div", "dag-node is-" + item.projectedStatus);
+    const top = node("div", "dag-node-head");
+    top.append(statusDot(item.projectedStatus), node("strong", "dag-node-title", item.title));
+    top.append(pill(t, "dag", item.projectedStatus));
+    if ((dag.readyIds || []).indexOf(item.id) >= 0) top.append(chip(t("dag.ready"), "is-active"));
+    row.append(top);
+    const edges = edgeByTarget[item.id] || [];
+    if (edges.length) {
+      const deps = node("div", "dag-node-deps");
+      deps.append(node("small", "", t("dag.dependsOn")));
+      edges.forEach(function (edge) {
+        deps.append(chip(edge.from + " · " + t("dag.edge." + edge.status), "is-" + edge.status));
+      });
+      row.append(deps);
+    }
+    if (item.rootCauseIds && item.rootCauseIds.length) {
+      row.append(node("small", "dag-root-cause", t("dag.rootCause") + " · " + item.rootCauseIds.join(" ← ")));
+    }
+    graph.append(row);
+  });
+  return graph;
+}
+
 // --- WorkItem Candidates -----------------------------------------------------
 export function candidateList(candidates, t, locale) {
   if (!candidates || !candidates.length) return null;
@@ -473,6 +555,40 @@ export function workItemCard(item, titles, t, locale, actions, taskId) {
     body.append(executionGroupCard(item.currentExecution, t, locale));
   }
 
+  if (item.observability) {
+    const observability = item.observability;
+    if (observability.executionGroups && observability.executionGroups.length) {
+      observability.executionGroups.forEach(function (group) {
+        if (!item.currentExecution || group.groupId !== item.currentExecution.groupId) {
+          body.append(executionGroupCard(group, t, locale));
+        }
+      });
+    }
+    const metrics = node("div", "record-meta work-item-observability");
+    metrics.append(node("span", "", t("detail.cost") + " · "
+      + observability.cost.tokens + " tokens"));
+    metrics.append(node("span", "", observability.cost.toolCalls + " tools"));
+    metrics.append(node("span", "", observability.cost.wallClockSeconds + "s"));
+    metrics.append(node("span", "", t("detail.contextSnapshots") + " · "
+      + observability.context.snapshotCount));
+    metrics.append(node("span", "", t("detail.evidence") + " · "
+      + observability.evidenceCount));
+    if (observability.openFindingCount > 0) {
+      metrics.append(chip(t("detail.openFindings") + " · " + observability.openFindingCount, "is-danger"));
+    }
+    body.append(metrics);
+    if (observability.stages && observability.stages.length) {
+      const stages = node("div", "chip-row work-item-stages");
+      observability.stages.forEach(function (stage) {
+        const label = (stage.stage || "single")
+          + (stage.round === undefined ? "" : " #" + stage.round)
+          + (stage.resolution ? " · " + stage.resolution : "");
+        stages.append(chip(label, stage.groupId === observability.currentGroupId ? "is-active" : ""));
+      });
+      body.append(stages);
+    }
+  }
+
   // Review candidates submitted for this WorkItem, newest first.
   const candidates = candidateList(item.candidates, t, locale);
   if (candidates) body.append(candidates);

package/dist/web/assets/client/i18n.js

@@ -55,6 +55,24 @@ const messages = {
     "detail.constraints": "Constraints",
     "detail.decisions": "Decisions",
     "detail.dependsOn": "Depends on",
+    "detail.dag": "Task DAG",
+    "detail.stage": "Stage",
+    "detail.round": "Round",
+    "detail.stageAttempt": "Attempt",
+    "detail.cost": "Cost",
+    "detail.tokens": "Tokens",
+    "detail.toolCalls": "Tool calls",
+    "detail.wallClock": "Wall clock",
+    "detail.ready": "Ready",
+    "detail.quorum": "Quorum",
+    "detail.contextSnapshots": "Context snapshots",
+    "detail.contextPeak": "Context peak",
+    "detail.contextBytes": "Context bytes",
+    "detail.compression": "Compression",
+    "detail.marginalValue": "Marginal value",
+    "detail.partial": "partial",
+    "detail.unavailable": "unavailable",
+    "detail.openFindings": "Open findings",
     "detail.desired": "Desired launch",
     "detail.desiredAgent": "Desired Agent",
     "detail.due": "Due",
@@ -241,6 +259,7 @@ const messages = {
     "exec.owner.none": "—",
     "exec.action.advance-task": "Advance task",
     "exec.action.wait-for-agents": "Wait for agents",
+    "exec.action.recover-execution": "Recover execution",
     "exec.action.answer-input": "Answer input",
     "exec.action.inspect-attention": "Inspect attention",
     "exec.action.recover-leader": "Recover leader",
@@ -270,6 +289,20 @@ const messages = {
     "lane.yielded": "Yielded",
     "lane.completed": "Completed",
     "lane.failed": "Failed",
+    "lane.skipped": "Skipped",
+    "dag.ready": "Ready",
+    "dag.dependsOn": "Dependencies",
+    "dag.rootCause": "Root cause",
+    "dag.blocked": "Blocked",
+    "dag.running": "Running",
+    "dag.awaiting_acceptance": "Awaiting acceptance",
+    "dag.completed": "Completed",
+    "dag.failed": "Failed",
+    "dag.retired": "Retired",
+    "dag.edge.satisfied": "satisfied",
+    "dag.edge.active": "active",
+    "dag.edge.failed-open": "failed",
+    "dag.edge.dead": "missing",
     "resolution.accept": "Accepted",
     "resolution.reject": "Rejected",
     "resolution.retry": "Retry",
@@ -358,6 +391,24 @@ const messages = {
     "detail.constraints": "约束",
     "detail.decisions": "决策",
     "detail.dependsOn": "依赖",
+    "detail.dag": "任务 DAG",
+    "detail.stage": "阶段",
+    "detail.round": "轮次",
+    "detail.stageAttempt": "阶段尝试",
+    "detail.cost": "成本",
+    "detail.tokens": "Token",
+    "detail.toolCalls": "工具调用",
+    "detail.wallClock": "墙钟时间",
+    "detail.ready": "可就绪",
+    "detail.quorum": "法定数量",
+    "detail.contextSnapshots": "上下文快照",
+    "detail.contextPeak": "上下文峰值",
+    "detail.contextBytes": "上下文字节",
+    "detail.compression": "压缩",
+    "detail.marginalValue": "边际价值",
+    "detail.partial": "部分可见",
+    "detail.unavailable": "不可用",
+    "detail.openFindings": "未解决发现",
     "detail.desired": "期望启动配置",
     "detail.desiredAgent": "期望 Agent",
     "detail.due": "截止时间",
@@ -544,6 +595,7 @@ const messages = {
     "exec.owner.none": "—",
     "exec.action.advance-task": "推进任务",
     "exec.action.wait-for-agents": "等待智能体",
+    "exec.action.recover-execution": "恢复执行",
     "exec.action.answer-input": "回答输入",
     "exec.action.inspect-attention": "检查注意项",
     "exec.action.recover-leader": "恢复负责人",
@@ -573,6 +625,20 @@ const messages = {
     "lane.yielded": "已交付",
     "lane.completed": "已完成",
     "lane.failed": "失败",
+    "lane.skipped": "已跳过",
+    "dag.ready": "可就绪",
+    "dag.dependsOn": "依赖",
+    "dag.rootCause": "根因",
+    "dag.blocked": "阻塞",
+    "dag.running": "运行中",
+    "dag.awaiting_acceptance": "等待接受",
+    "dag.completed": "已完成",
+    "dag.failed": "失败",
+    "dag.retired": "已退役",
+    "dag.edge.satisfied": "已满足",
+    "dag.edge.active": "进行中",
+    "dag.edge.failed-open": "失败传播",
+    "dag.edge.dead": "缺失",
     "resolution.accept": "已接受",
     "resolution.reject": "已拒绝",
     "resolution.retry": "已重试",