@zq-silk/yui 0.11.3 → 0.12.0

package/dist/commands/taskCompletionGate.js

@@ -3,7 +3,7 @@ import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { publicationExternalKey } from "../task/publicationReference.js";
-import { isSemanticReviewRound } from "../review/reviewOutcomeClassifier.js";
+import { isAcceptedTaskReviewBaseline } from "../review/reviewAcceptance.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 /**
  * Verify the one supported ancestry waiver before `task complete` mutates any
@@ -29,15 +29,6 @@ export async function verifyTaskCompletionPublishedTree(taskId, publicationId, s
         throw usageError(`Publication ${publication.id} must record exact local and remote commits.`);
     }
     const workspace = requireTaskWorkspace(store, task);
-    const latestRecordedReview = latestTaskFinalReview(store, task.id);
-    const latestReview = latestRecordedReview !== undefined
-        && isSemanticReviewRound(latestRecordedReview, store)
-        && latestRecordedReview.taskCandidate !== undefined
-        ? latestRecordedReview
-        : undefined;
-    if (latestRecordedReview !== undefined && latestReview === undefined) {
-        throw usageError(`Task ${task.id} has an unsettled Task-final Review obligation before accepting a published tree.`);
-    }
     const git = options.git ?? new NodeGitWorkspace();
     const actualHeads = new Map();
     for (const taskBinding of task.projectBindings) {
@@ -46,22 +37,18 @@ export async function verifyTaskCompletionPublishedTree(taskId, publicationId, s
             throw usageError(`Task ${task.id} has no writable managed main workspace for Project ${taskBinding.projectId}.`);
         }
         const actualCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
-        if (latestReview !== undefined) {
-            const reviewedCommit = latestReview.taskCandidate.projects.find(({ projectId }) => (projectId === taskBinding.projectId))?.commit;
-            if (reviewedCommit === undefined) {
-                throw usageError(`Task-final Review ${latestReview.id} omitted Project ${taskBinding.projectId}.`);
-            }
-            if (actualCommit !== reviewedCommit) {
-                throw usageError(`Task-final Review ${latestReview.id} does not match Task head `
-                    + `${taskBinding.projectId}@${actualCommit}.`);
-            }
-        }
         actualHeads.set(taskBinding.projectId, actualCommit);
     }
-    if (latestReview !== undefined
-        && actualHeads.size !== latestReview.taskCandidate.projects.length) {
-        throw usageError(`Task-final Review ${latestReview.id} Project set does not match Task ${task.id}.`);
-    }
+    const actualCandidate = {
+        schemaVersion: 1,
+        projects: task.projectBindings.map(({ projectId }) => ({
+            projectId,
+            commit: actualHeads.get(projectId)
+        }))
+    };
+    const latestReview = acceptedTaskFinalReviews(store, task.id)
+        .find((round) => (round.taskCandidate !== undefined
+        && sameTaskCandidate(round.taskCandidate, actualCandidate)));
     const entry = workspaceProjectEntry(workspace, publication.projectId);
     const localCommit = actualHeads.get(publication.projectId);
     if (publication.localCommit !== localCommit) {
@@ -124,18 +111,14 @@ export function assertTaskCompletionPublishedTreeProof(store, task, publicationI
         throw usageError(`Publication evidence changed before Task completion: ${publication.id}.`);
     }
     if (proof.reviewRoundId !== undefined) {
-        const latestReview = latestTaskFinalReview(store, task.id);
-        if (latestReview === undefined
-            || latestReview.id !== proof.reviewRoundId
-            || !isSemanticReviewRound(latestReview, store)
-            || latestReview.taskCandidate === undefined
-            || !sameTaskCandidate(latestReview.taskCandidate, actualCandidate)) {
+        const review = store.getReviewRound(task.id, proof.reviewRoundId);
+        if (review === null
+            || !isAcceptedTaskReviewBaseline(store, review)
+            || review.taskCandidate === undefined
+            || !sameTaskCandidate(review.taskCandidate, actualCandidate)) {
             throw usageError(`Task-final Review evidence changed before published-tree completion: ${task.id}.`);
         }
     }
-    else if (latestTaskFinalReview(store, task.id) !== undefined) {
-        throw usageError(`Published-tree proof omitted the Task-final Review: ${task.id}.`);
-    }
     const actualCommit = actualCandidate.projects.find(({ projectId }) => (projectId === proof.projectId))?.commit;
     if (actualCommit !== proof.localCommit) {
         throw usageError(`Task head changed before published-tree completion: `
@@ -157,11 +140,10 @@ function requireCurrentVerifiedPublication(store, taskId, publicationId) {
     }
     return publication;
 }
-function latestTaskFinalReview(store, taskId) {
+function acceptedTaskFinalReviews(store, taskId) {
     return store.listReviewRounds(taskId)
-        .filter((round) => (round.scope ?? "work-item") === "task")
-        .sort((left, right) => (left.id.localeCompare(right.id, undefined, { numeric: true })))
-        .at(-1);
+        .filter((round) => isAcceptedTaskReviewBaseline(store, round))
+        .sort((left, right) => (right.id.localeCompare(left.id, undefined, { numeric: true })));
 }
 function sameTaskCandidate(left, right) {
     return left.projects.length === right.projects.length
@@ -326,33 +308,26 @@ function requireTaskWorkspace(store, task) {
     return workspace;
 }
 /**
- * Check whether the latest Task-final ReviewRound is completed and its
+ * Check whether an accepted Task-final ReviewRound is completed and its
  * immutable candidate exactly matches the current actual heads for every
  * Project in the Task.  When this holds, the reviewed head is the final
  * head and remote reconciliation must not change it.
  */
 async function hasCompletedTaskFinalReviewForCurrentCandidate(store, task, workspace, git) {
-    const rounds = store.listReviewRounds(task.id)
-        .filter((round) => (round.scope ?? "work-item") === "task")
-        .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }));
-    const latest = rounds.at(-1);
-    if (latest === undefined || !isSemanticReviewRound(latest, store))
-        return false;
-    if (latest.taskCandidate === undefined)
-        return false;
-    const candidateProjects = new Map(latest.taskCandidate.projects.map((entry) => [entry.projectId, entry.commit]));
+    const actualProjects = [];
     for (const binding of task.projectBindings) {
-        const reviewedCommit = candidateProjects.get(binding.projectId);
-        if (reviewedCommit === undefined)
-            return false;
         const entry = workspaceProjectEntry(workspace, binding.projectId);
         if (entry === undefined || entry.access !== "write")
             return false;
         const actualHead = (await git.inspect(entry.path, "HEAD")).baseCommit;
-        if (actualHead !== reviewedCommit)
-            return false;
+        actualProjects.push({ projectId: binding.projectId, commit: actualHead });
     }
-    return true;
+    const actualCandidate = {
+        schemaVersion: 1,
+        projects: actualProjects
+    };
+    return acceptedTaskFinalReviews(store, task.id).some((round) => (round.taskCandidate !== undefined
+        && sameTaskCandidate(round.taskCandidate, actualCandidate)));
 }
 function latestCommittedIntegration(store, taskId, projectId) {
     return store.listIntegrationAttempts(taskId)
@@ -369,7 +344,7 @@ function latestCommittedIntegration(store, taskId, projectId) {
 function hasFrozenTaskBaseline(store, taskId, projectId, currentCommit) {
     return store.listReviewRounds(taskId)
         .some((round) => ((round.scope ?? "work-item") === "task"
-        && isSemanticReviewRound(round, store)
+        && isAcceptedTaskReviewBaseline(store, round)
         && round.taskCandidate !== undefined
         && round.taskCandidate.projects.some((entry) => (entry.projectId === projectId && entry.commit === currentCommit))));
 }

package/dist/commands/taskContextCommand.js

@@ -9,6 +9,7 @@ import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { projectExecutionLaneRunRecoveries } from "../run/recoveryProjection.js";
+import { projectReviewDecision } from "../review/reviewDecision.js";
 const RECENT_RECORD_LIMIT = 5;
 const RELATED_RECORD_LIMIT = 5;
 const SUMMARY_TEXT_LIMIT = 400;
@@ -17,7 +18,7 @@ const TERMINAL_WORK_ITEM_STATUSES = new Set([
     "failed",
     "retired"
 ]);
-export function runTaskContextCommand(args, store) {
+export function runTaskContextCommand(args, store, currentTaskReviewCandidate = null) {
     if (args.length !== 1 || args[0]?.trim().length === 0) {
         throw usageError("Task context usage: yui task context <task>.");
     }
@@ -46,6 +47,7 @@ export function runTaskContextCommand(args, store) {
         const events = reader.listEvents(task.id);
         const agentRuns = chronological(operationalTaskRecords(reader.listAgentRuns(task.id), events, "agent-run"));
         const reviewRounds = chronological(reader.listReviewRounds(task.id));
+        const reviewConfig = reader.getReviewConfig();
         const changeSets = chronological(reader.listChangeSets(task.id));
         const integrations = chronological(reader.listIntegrationAttempts(task.id));
         const publications = chronological(reader.listPublicationReferences(task.id));
@@ -56,7 +58,16 @@ export function runTaskContextCommand(args, store) {
         return {
             task,
             execution,
-            reviewConfig: reader.getReviewConfig(),
+            reviewConfig,
+            reviewDecision: projectReviewDecision({
+                store: reader,
+                task,
+                roles,
+                runs: agentRuns,
+                rounds: reviewRounds,
+                reviewConfig,
+                currentCandidate: currentTaskReviewCandidate
+            }),
             brief: reader.getTaskBrief(task.id),
             activeDecisions: reader.listDecisions(task.id)
                 .filter((decision) => decision.status === "active"),
@@ -78,20 +89,19 @@ export function runTaskContextCommand(args, store) {
             events,
             nextAction: projectNextAction({
                 ...nextActionFacts,
+                currentTaskReviewCandidate,
                 executionGroups: execution.executionGroups,
                 runRecoveries: projectExecutionLaneRunRecoveries(reader, task.id, execution.executionGroups)
             })
         };
     });
-    const { task, execution, reviewConfig, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
+    const { task, execution, reviewConfig, reviewDecision, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
     const timeZone = store.getConfig().timeZone;
     const displayedActiveDecisions = activeDecisions.slice(-RECENT_RECORD_LIMIT);
     const displayedWorkItems = currentAndRecentWorkItems(workItems);
     const displayedOpenInputRequests = openInputRequests.slice(-RECENT_RECORD_LIMIT);
     const displayedResolvedInputRequests = resolvedInputRequests.slice(-RECENT_RECORD_LIMIT);
-    const displayedExecutionCarriers = execution.monitoring === "active"
-        ? execution.activeRuns
-        : [];
+    const displayedActiveRuns = execution.activeRuns;
     const executionGroupsById = new Map(execution.executionGroups.map((group) => [
         group.groupId,
         group
@@ -135,14 +145,26 @@ export function runTaskContextCommand(args, store) {
         `  Attention: ${execution.attention.length === 0
             ? "none"
             : execution.attention.map(({ kind, owner }) => `${kind}/${owner}`).join(", ")}`,
-        `  Active execution carriers (${displayedExecutionCarriers.length}):`,
-        ...(displayedExecutionCarriers.length === 0
+        `  Active AgentRuns (${displayedActiveRuns.length}):`,
+        ...(displayedActiveRuns.length === 0
             ? ["    None."]
-            : displayedExecutionCarriers.map((run) => (`    ${run.roleName}: ${run.id} [${run.status}; ${run.delivered ? "accepted" : "delivery-pending"}]`))),
+            : displayedActiveRuns.map((run) => (`    ${run.roleName}: ${run.id} [${run.status}/${run.purpose}; ${run.delivered ? "accepted" : "delivery-pending"}${run.workItemId === undefined ? "" : `; work-item=${run.workItemId}`}${run.reviewRoundId === undefined ? "" : `; review-round=${run.reviewRoundId}`}${run.executionGroupId === undefined ? "" : `; group=${run.executionGroupId}`}${run.executionLaneId === undefined ? "" : `; lane=${run.executionLaneId}`}]`))),
         "Observability:",
         `  DAG: ${observability.dag.nodes.length} node(s), ${observability.dag.edges.length} edge(s); ready=${observability.dag.readyIds.join(", ") || "none"}; blocked=${observability.dag.blockedIds.join(", ") || "none"}`,
         `  Cost: tokens=${resourceUsageLabel(observability.cost.tokens, undefined, observability.cost.tokensObservable)}; tools=${resourceUsageLabel(observability.cost.toolCalls, undefined, observability.cost.toolCallsObservable)}; wall=${observability.cost.wallClockSeconds}s; lanes=${observability.cost.laneCount}; groups=${observability.cost.groupCount}; retries=${observability.cost.retryCount}; marginal-value=unavailable`,
-        `  Context: snapshots=${observability.context.snapshotCount}; bytes=${observability.context.totalBytes === null ? "partial" : observability.context.totalBytes}; peak-input=${observability.context.observedInputPeakTokens}; compression=unavailable`,
+        `  Context: snapshots=${observability.context.snapshotCount}; bytes=${observability.context.totalBytes === null ? "partial" : observability.context.totalBytes}; compression=unavailable`,
+        "  Session tokens:",
+        ...(observability.sessionTokens.length === 0
+            ? ["    unobserved"]
+            : observability.sessionTokens.map(({ roleName, agentId, metrics }) => {
+                const total = metrics.cumulativeTotal.status === "observed"
+                    ? metrics.cumulativeTotal.totalTokens
+                    : "unobserved";
+                const maximum = metrics.maximumRequestInput.status === "observed"
+                    ? metrics.maximumRequestInput.inputTokens
+                    : "unobserved";
+                return `    ${roleName}/${agentId}: total=${total}; max-request-input=${maximum}`;
+            })),
         ...(task.projectBindings.length === 0
             ? []
             : [
@@ -166,6 +188,28 @@ export function runTaskContextCommand(args, store) {
         `Global review: ${reviewConfig === null
             ? "disabled"
             : `${reviewConfig.roleName} (${reviewConfig.trigger})`}`,
+        "Review decision support:",
+        `  Current durable heads: ${reviewDecision.currentCandidate?.projects
+            .map(({ projectId, commit }) => `${projectId}@${commit.slice(0, 12)}`).join(", ")
+            ?? "unavailable"}`,
+        "  Active Reviews:",
+        ...(reviewDecision.activeReviews.length === 0
+            ? ["    - none"]
+            : reviewDecision.activeReviews.map((review) => (`    - ${review.reviewRoundId}/${review.reviewerRoleName}/${review.mode}`
+                + ` [${review.status}; current=${review.candidateRelation}]`
+                + ` heads=${review.frozenCandidate?.projects.map(({ projectId, commit }) => (`${projectId}@${commit.slice(0, 12)}`)).join(", ") ?? "unavailable"}`
+                + `${review.workspaceRoot === undefined
+                    ? ""
+                    : ` workspace=${review.workspaceRoot}`}`))),
+        `  Reviewer slots: ${reviewDecision.reviewers.length === 0
+            ? "none configured"
+            : reviewDecision.reviewers.map((reviewer) => (`${reviewer.reviewerRoleName}=${reviewer.status}`
+                + `${reviewer.activeRunId === undefined ? "" : `(${reviewer.activeRunId})`}`)).join(", ")}`,
+        `  Accepted baseline: ${reviewDecision.latestAcceptedBaseline === null
+            ? "none"
+            : `${reviewDecision.latestAcceptedBaseline.reviewRoundId}`
+                + ` [${reviewDecision.latestAcceptedBaseline.relationToCurrent}]`}`,
+        `  Delta: ${reviewDecision.delta.technicalAvailability}; ${reviewDecision.delta.reason}`,
         "",
         "Brief:",
         ...(brief === null
@@ -577,5 +621,5 @@ function resourceUsageLabel(used, remaining, observable) {
 }
 function renderWorkItemObservability(item) {
     const stages = item.stages.map((stage) => (`${stage.stage ?? "single"}${stage.round === undefined ? "" : `#${stage.round}`}${stage.stageAttempt === undefined ? "" : `/a${stage.stageAttempt}`}`)).join(", ");
-    return `    Observability: stages=${stages || "none"}; tokens=${item.cost.tokens}; tools=${item.cost.toolCalls}; wall=${item.cost.wallClockSeconds}s; retries=${item.cost.retryCount}; snapshots=${item.context.snapshotCount}; peak-input=${item.context.observedInputPeakTokens}; evidence=${item.evidenceCount}; open-findings=${item.openFindingCount}; compression=${item.context.compressionStatus}`;
+    return `    Observability: stages=${stages || "none"}; tokens=${item.cost.tokens}; tools=${item.cost.toolCalls}; wall=${item.cost.wallClockSeconds}s; retries=${item.cost.retryCount}; snapshots=${item.context.snapshotCount}; evidence=${item.evidenceCount}; open-findings=${item.openFindingCount}; compression=${item.context.compressionStatus}`;
 }

package/dist/commands/taskInputCommands.js

@@ -6,7 +6,7 @@ import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatTimestamp } from "../output/timePresentation.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
-import { clearMatchingLeaderStallAttention, isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
+import { isRoleRunStalled, RUN_RECOVERED_EVENT } from "../scheduler/roleRunStall.js";
 import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
 import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { isLinuxProcessLive, listOwnedProcessTree } from "../runtime/sessionOwnerIdentity.js";
@@ -66,9 +66,13 @@ function createRequest(args, store, options) {
         const wasStalled = isRoleRunStalled(tx.listEvents(task.id), origin.run.id);
         tx.saveInputRequest(task.id, created);
         enqueueWork(tx, { kind: "operator" }, "input-requested", now, [
-            { type: "input", taskId: task.id, id: created.id },
-            { type: "run", taskId: task.id, id: origin.run.id }
-        ]);
+            { type: "input", taskId: task.id, id: created.id }
+        ], {
+            source: "input-request",
+            dedupeKey: `operator-input:${task.id}:${created.id}`,
+            deliveryMode: "followup",
+            lane: "normal"
+        });
         const terminal = terminalizeExactTaskRun(tx, {
             taskId: task.id,
             roleName: LEADER_ROLE,
@@ -94,7 +98,6 @@ function createRequest(args, store, options) {
                 kind: "input-request"
             }, now);
         }
-        clearMatchingLeaderStallAttention(tx, task.id, origin.run.id);
         recordTaskEvent(tx, task.id, "input.requested", {
             requestId: created.id,
             requesterRunId: created.requester.runId,

package/dist/commands/taskNextActionCommand.js

@@ -6,6 +6,7 @@ import { projectTaskOrchestration } from "../observability/orchestrationMetrics.
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectExecutionLaneRunRecoveries } from "../run/recoveryProjection.js";
+import { projectReviewDecision } from "../review/reviewDecision.js";
 /**
  * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
  * Folds the existing durable records into exactly one protocol-level next
@@ -18,7 +19,7 @@ import { projectExecutionLaneRunRecoveries } from "../run/recoveryProjection.js"
  * carries the full `completionReadiness` blocker list so the Leader sees every
  * terminalization precondition before attempting `yui task complete`.
  */
-export function runTaskNextActionCommand(args, store) {
+export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate = null) {
     const usage = "Task next-action usage: yui task next-action <task> [--json].";
     const positionals = args.filter((arg) => arg !== "--json");
     const asJson = args.includes("--json");
@@ -40,6 +41,7 @@ export function runTaskNextActionCommand(args, store) {
             throw taskNotFound(taskId);
         const actionFacts = {
             ...facts,
+            currentTaskReviewCandidate,
             executionGroups: execution.executionGroups,
             runRecoveries: projectExecutionLaneRunRecoveries(reader, taskId, execution.executionGroups)
         };
@@ -69,13 +71,25 @@ export function runTaskNextActionCommand(args, store) {
             completionReadiness = projectCompletionReadiness(readinessFacts);
         }
         const events = reader.listEvents(taskId);
+        const task = reader.getTask(taskId);
+        const operationalRuns = operationalTaskRecords(reader.listAgentRuns(taskId), events, "agent-run");
+        const reviewRounds = reader.listReviewRounds(taskId);
+        const reviewDecision = projectReviewDecision({
+            store: reader,
+            task,
+            roles: reader.listRoles(taskId),
+            runs: operationalRuns,
+            rounds: reviewRounds,
+            reviewConfig: reader.getReviewConfig(),
+            currentCandidate: currentTaskReviewCandidate
+        });
         const orchestration = projectTaskOrchestration({
-            task: reader.getTask(taskId),
-            runs: operationalTaskRecords(reader.listAgentRuns(taskId), events, "agent-run"),
+            task,
+            runs: operationalRuns,
             roleSessionSets: reader.listRoleSessionSets(taskId),
             workItems: reader.listWorkItems(taskId),
             changeSets: reader.listChangeSets(taskId),
-            reviewRounds: reader.listReviewRounds(taskId),
+            reviewRounds,
             reviewFindings: reader.listReviewFindings(taskId),
             integrations: reader.listIntegrationAttempts(taskId),
             durableJobs: reader.listDurableJobs(taskId),
@@ -90,6 +104,8 @@ export function runTaskNextActionCommand(args, store) {
             repairWave,
             completionReadiness,
             knowledgeProposals,
+            reviewDecision,
+            execution: nextActionExecutionView(execution),
             orchestration
         };
     });
@@ -102,7 +118,7 @@ export function runTaskNextActionCommand(args, store) {
     }
     return {
         kind: "output",
-        output: renderNextAction(data.action, data.taskType, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.orchestration.advisories),
+        output: renderNextAction(data.action, data.taskType, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.reviewDecision, data.execution, data.orchestration.advisories),
         data
     };
 }
@@ -120,12 +136,17 @@ function repairWaveFor(action, facts) {
         return null;
     return planRepairWave(round.id, findings);
 }
-function renderNextAction(action, taskType, repairWave, completionReadiness, knowledgeProposals, orchestrationAdvisories) {
+function renderNextAction(action, taskType, repairWave, completionReadiness, knowledgeProposals, reviewDecision, execution, orchestrationAdvisories) {
     const lines = [
         `Task: ${action.taskId}`,
         `Type: ${taskType ?? "unspecified"}`,
         `Next action: ${action.kind}`,
         `Reason: ${action.reason}`,
+        `Execution view: ${execution.status}; owner/action=${execution.owner}/${execution.action}; reason=${execution.reason}; ${execution.summary}`,
+        `Active AgentRuns (${execution.activeRuns.length}):`,
+        ...(execution.activeRuns.length === 0
+            ? ["  none"]
+            : execution.activeRuns.map((run) => `  ${renderActiveRun(run)}`)),
         ...(action.refs.length === 0
             ? ["Refs: none"]
             : ["Refs:", ...action.refs.map((ref) => `  ${ref.kind}: ${ref.id}`)]),
@@ -142,6 +163,16 @@ function renderNextAction(action, taskType, repairWave, completionReadiness, kno
         ...(action.judgmentRequired === undefined
             ? []
             : [`Judgment: ${action.judgmentRequired}`]),
+        `Review state: active=${reviewDecision.activeReviews.length}; reviewers=${reviewDecision.reviewers
+            .map(({ reviewerRoleName, status }) => `${reviewerRoleName}:${status}`).join(", ") || "none"}`,
+        ...(reviewDecision.activeReviews.length === 0
+            ? []
+            : [
+                "Frozen Reviews: " + reviewDecision.activeReviews.map((review) => (`${review.reviewRoundId}/${review.reviewerRoleName}`
+                    + `[${review.status}; current=${review.candidateRelation}; `
+                    + `${review.frozenCandidate?.projects.map(({ projectId, commit }) => (`${projectId}@${commit.slice(0, 12)}`)).join(", ") ?? "heads-unavailable"}]`)).join("; ")
+            ]),
+        `Delta support: ${reviewDecision.delta.technicalAvailability}; ${reviewDecision.delta.reason}`,
         ...(action.alternatives === undefined || action.alternatives.length === 0
             ? []
             : [
@@ -188,3 +219,22 @@ function renderNextAction(action, taskType, repairWave, completionReadiness, kno
     }
     return `${lines.join("\n")}\n`;
 }
+function renderActiveRun(run) {
+    const subject = run.reviewRoundId === undefined
+        ? run.workItemId === undefined ? "task" : `work-item=${run.workItemId}`
+        : `review-round=${run.reviewRoundId}`;
+    const lane = run.executionGroupId === undefined
+        ? ""
+        : `; group=${run.executionGroupId}${run.executionLaneId === undefined ? "" : `; lane=${run.executionLaneId}`}`;
+    return `${run.id} [${run.purpose}/${run.status}; role=${run.roleName}; ${run.delivered ? "accepted" : "delivery-pending"}; ${subject}${lane}]`;
+}
+function nextActionExecutionView(execution) {
+    return {
+        status: execution.status,
+        owner: execution.owner,
+        action: execution.action,
+        reason: execution.reason,
+        summary: execution.summary,
+        activeRuns: execution.activeRuns
+    };
+}

package/dist/commands/taskOverviewCommand.js

@@ -64,7 +64,6 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
     const agentRuns = store.listAgentRuns(task.id);
     const events = store.listEvents(task.id);
     const leaderFailure = store.getLeaderFailure(task.id);
-    const operatorNotification = store.getOperatorNotification(task.id);
     const leaderMailbox = store.getWorkMailbox({ kind: "role", taskId: task.id, roleName: "leader" });
     const pendingWakeup = pendingWakeupProjection(leaderMailbox);
     const reviewRounds = store.listReviewRounds(task.id);
@@ -74,7 +73,7 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         const session = store.getRoleSession(task.id, role.name);
         return session === null ? [] : [{ roleName: role.name, ...session }];
     });
-    const attention = collectAttention(task, agentRuns, events, leaderFailure, operatorNotification);
+    const attention = collectAttention(task, agentRuns, events, leaderFailure);
     const blockers = collectBlockers(workItems, openInputRequests, attention);
     const legacyNext = deriveNextAction(task, brief, workItems, openInputRequests, blockers, pendingWakeup);
     const leader = {
@@ -119,7 +118,6 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         pendingWakeup,
         leaderMailbox,
         leaderFailure,
-        operatorNotification,
         roleSessions,
         contextSnapshots: store.listContextSnapshots(task.id),
         now,
@@ -154,37 +152,16 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         execution
     };
 }
-function collectAttention(task, runs, events, failure, notification) {
+function collectAttention(task, runs, events, failure) {
     const items = [];
-    if (failure !== null || notification?.type === "leader-recovery-failed") {
+    if (failure !== null) {
         items.push({
             kind: "leader-recovery",
             id: `leader-recovery:${task.id}`,
             status: "failed",
             owner: "operator",
-            summary: failure?.message
-                ?? (notification?.type === "leader-recovery-failed"
-                    ? notification.message
-                    : "Leader recovery failed."),
-            updatedAt: failure?.lastFailedAt
-                ?? (notification?.type === "leader-recovery-failed"
-                    ? notification.updatedAt
-                    : task.updatedAt)
-        });
-    }
-    const notificationStall = notification?.type === "leader-stalled"
-        ? notification
-        : null;
-    if (notificationStall !== null) {
-        items.push({
-            kind: "leader-stalled",
-            id: `leader-stall:${notificationStall.runId}:${notificationStall.progressAt}`,
-            status: "needs-attention",
-            owner: "operator",
-            summary: notificationStall.message,
-            updatedAt: notificationStall.updatedAt,
-            runId: notificationStall.runId,
-            roleName: "leader"
+            summary: failure.message,
+            updatedAt: failure.lastFailedAt
         });
     }
     for (const run of runs) {
@@ -192,8 +169,6 @@ function collectAttention(task, runs, events, failure, notification) {
             || run.status !== "active"
             || !isRoleRunStalled(events, run.id))
             continue;
-        if (notificationStall?.runId === run.id)
-            continue;
         const progressAt = latestStallProgressAt(events, run.id) ?? run.updatedAt;
         items.push({
             kind: "leader-stalled",
@@ -399,7 +374,18 @@ function renderVerboseDetails(tasks, timeZone) {
             `  Monitoring: ${task.execution.monitoring}; attention: ${task.execution.attention.length}`,
             `  DAG: ${task.execution.observability.dag.nodes.length} nodes, ${task.execution.observability.dag.edges.length} edges; ready=${task.execution.observability.dag.readyIds.join(", ") || "none"}; blocked=${task.execution.observability.dag.blockedIds.join(", ") || "none"}`,
             `  Cost: tokens=${task.execution.observability.cost.tokens}${task.execution.observability.cost.tokensObservable ? "" : " (partial)"}; tools=${task.execution.observability.cost.toolCalls}${task.execution.observability.cost.toolCallsObservable ? "" : " (partial)"}; wall=${task.execution.observability.cost.wallClockSeconds}s; retries=${task.execution.observability.cost.retryCount}`,
-            `  Context: snapshots=${task.execution.observability.context.snapshotCount}; bytes=${task.execution.observability.context.totalBytes ?? "partial"}; peak-input=${task.execution.observability.context.observedInputPeakTokens}; compression=unavailable`,
+            `  Context: snapshots=${task.execution.observability.context.snapshotCount}; bytes=${task.execution.observability.context.totalBytes ?? "partial"}; compression=unavailable`,
+            `  Session tokens: ${task.execution.observability.sessionTokens.length === 0
+                ? "unobserved"
+                : task.execution.observability.sessionTokens.map(({ roleName, metrics }) => {
+                    const total = metrics.cumulativeTotal.status === "observed"
+                        ? metrics.cumulativeTotal.totalTokens
+                        : "unobserved";
+                    const maximum = metrics.maximumRequestInput.status === "observed"
+                        ? metrics.maximumRequestInput.inputTokens
+                        : "unobserved";
+                    return `${roleName}: total=${total}, max-request-input=${maximum}`;
+                }).join("; ")}`,
             `  Projects: ${task.projectBindings.length === 0
                 ? "none"
                 : task.projectBindings.map(({ directory, projectId, baseRef }) => (`${directory} (${projectId} @ ${baseRef})`)).join(", ")}`

package/dist/commands/taskRoleRuntimeStatus.js

@@ -8,6 +8,7 @@ import { latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
@@ -65,6 +66,12 @@ export function renderTaskRoleRuntimeStatus(status) {
                     ? ""
                     : ` (${status.runtime.observerDetail})`}`
         ].filter((value) => value !== undefined).join("; ");
+    const sessionTokens = [
+        `total=${sessionCumulativeTokenLabel(status.sessionTokens)}`,
+        `max-request-input=${status.sessionTokens.maximumRequestInput.status === "observed"
+            ? status.sessionTokens.maximumRequestInput.inputTokens
+            : "unobserved"}`
+    ].join("; ");
     return [
         `Task Role status: ${status.taskId}/${status.roleName}`,
         "",
@@ -87,6 +94,7 @@ export function renderTaskRoleRuntimeStatus(status) {
             : "none"}`,
         `  Native session   ${nativeSession}`,
         `  Agent runtime    ${runtime}`,
+        `  Session tokens   ${sessionTokens}`,
         `  Runtime cleanup  ${status.runtimeCleanupPending ? "pending" : "none"}`,
         `  Fresh launch     ${status.freshLaunchAllowed ? "allowed" : "blocked"}`,
         `  tmux pane        ${tmux}`,
@@ -178,6 +186,9 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         ? { managed: false, path: role.workspace }
         : { ...managedWorkspace, managed: true };
     const events = store.listEvents(taskId);
+    const sessionTokens = projectSessionTokenMetrics(events, resolveSessionTokenIdentity(nativeSession === null
+        ? null
+        : { taskId, roleName: role.name, ...nativeSession }));
     const runtime = projectTaskRoleRuntime(activeRun, nativeSession, tmux, events, store.getWorkMailbox({ kind: "role", taskId, roleName: role.name }), store, taskId, role.name, now);
     const stalled = activeRun !== null && isRoleRunStalled(events, activeRun.id);
     const stallProgressAt = activeRun === null
@@ -213,10 +224,23 @@ function inspectTaskRoleRuntimeStatus(taskId, role, store, pane, openInputReques
         nativeSession,
         tmux,
         workspace,
+        sessionTokens,
         runtime,
         stall
     };
 }
+function sessionCumulativeTokenLabel(metrics) {
+    const total = metrics.cumulativeTotal;
+    if (total.status === "unobserved")
+        return "unobserved";
+    const breakdown = [
+        `input=${total.inputTokens}`,
+        `output=${total.outputTokens}`,
+        ...(total.cachedInputTokens === undefined ? [] : [`cached-input=${total.cachedInputTokens}`]),
+        ...(total.reasoningTokens === undefined ? [] : [`reasoning=${total.reasoningTokens}`])
+    ];
+    return `${total.totalTokens} (${breakdown.join(", ")})`;
+}
 function latestStallKind(events, runId) {
     const event = [...events]
         .filter((candidate) => candidate.type === "run.stalled" && candidate.payload.runId === runId)

package/dist/commands/taskWorkspaceCommands.js

@@ -99,8 +99,11 @@ function replaceTaskCommand(args, store, options) {
     const old = store.getTask(oldId);
     if (old === null)
         throw usageError(`Task not found: ${oldId}.`);
-    if (old.status === "draft" || old.status === "active") {
-        throw usageError(`Task is open and can be rebuilt instead of replaced: ${old.id}.`);
+    if (old.status === "draft") {
+        throw usageError(`Draft Task ${old.id} owns no workspace to replace or rebuild; activate it or retire it and create a new Draft.`);
+    }
+    if (old.status === "active") {
+        throw usageError(`Active Task can be rebuilt instead of replaced: ${old.id}.`);
     }
     let title = `Replaces ${old.id}: ${old.title}`;
     for (let index = 1; index < args.length; index += 1) {

package/dist/config/configCatalog.js

@@ -22,8 +22,8 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "provider-retry-max-window-seconds", domain: "runtime", property: "providerRetryMaxWindowSeconds", label: "Provider retry max window", summary: "Positive-integer total retry budget per Run lineage in seconds (default: 600).", takesEffect: "The next retry episode; an active episode keeps its existing deadline." },
     { key: "leader-next-action", domain: "workflow", property: "leaderNextActionMode", label: "Leader next-action mode", summary: "Leader next-action mode: display, warn, or enforce (default: display).", takesEffect: "The next Leader next-action projection or gate." },
     { key: "leader-semantic-budget-turns", domain: "workflow", property: "leaderSemanticBudgetTurns", label: "Leader semantic budget", summary: "Consecutive yielded Leader turns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
-    { key: "context-budget", domain: "workflow", property: "contextBudget", label: "Context budget", summary: `Per-Session context token budget; soft and hard are ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}, with soft below hard (defaults: 100000/120000).`, takesEffect: "The next context-budget evaluation; retained conversation content is unchanged." },
-    { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger; optional finding-ledger and delta-recheck controls. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
+    { key: "context-budget", domain: "workflow", property: "contextBudget", label: "Legacy context budget (inactive)", summary: `Compatibility-only soft and hard values in ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}; they are parsed but never control Session or workflow behavior.`, takesEffect: "No runtime effect; Session Token metrics are read-only observations." },
+    { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger and optional finding-ledger behavior. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
     { key: "resources-gc-mode", domain: "resources", property: "resourcesGcMode", label: "Resources GC mode", summary: "Resource GC mode: report or quarantine (default: report).", takesEffect: "The next resource GC operation." },
     { key: "resources-gc-auto-quarantine", domain: "resources", property: "resourcesGcAutoQuarantine", label: "Resources GC auto-quarantine", summary: "Automatically quarantine eligible terminal Task resources (default: false).", takesEffect: "The next eligible automatic resource GC operation." },
     { key: "resources-quarantine-ttl-hours", domain: "resources", property: "resourcesQuarantineTtlHours", label: "Resource quarantine TTL", summary: "Default observation window before purge, 1-720 hours (default: 24).", takesEffect: "The next resource GC command without an explicit TTL override." },