@zq-silk/yui 0.14.0 → 0.14.2

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 { isAcceptedTaskReviewBaseline } from "../review/reviewAcceptance.js";
+import { isCompletedTaskReviewEvidence } from "../review/reviewAcceptance.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 /**
  * Verify the one supported ancestry waiver before `task complete` mutates any
@@ -113,7 +113,7 @@ export function assertTaskCompletionPublishedTreeProof(store, task, publicationI
     if (proof.reviewRoundId !== undefined) {
         const review = store.getReviewRound(task.id, proof.reviewRoundId);
         if (review === null
-            || !isAcceptedTaskReviewBaseline(store, review)
+            || !isCompletedTaskReviewEvidence(store, review)
             || review.taskCandidate === undefined
             || !sameTaskCandidate(review.taskCandidate, actualCandidate)) {
             throw usageError(`Task-final Review evidence changed before published-tree completion: ${task.id}.`);
@@ -142,7 +142,7 @@ function requireCurrentVerifiedPublication(store, taskId, publicationId) {
 }
 function acceptedTaskFinalReviews(store, taskId) {
     return store.listReviewRounds(taskId)
-        .filter((round) => isAcceptedTaskReviewBaseline(store, round))
+        .filter((round) => isCompletedTaskReviewEvidence(store, round))
         .sort((left, right) => (right.id.localeCompare(left.id, undefined, { numeric: true })));
 }
 function sameTaskCandidate(left, right) {
@@ -154,35 +154,22 @@ function sameTaskCandidate(left, right) {
  * Reconcile configured remote baselines before a Task completion attempt.
  *
  * Remote resolution and fetches happen from the Task's managed worktree.  A
- * moved remote is represented by a new Integration Attempt that reuses the
- * already integrated ChangeSets, runs the existing Project checks, and lets
- * the normal target CAS advance the Task branch.  Stable Project checkouts
- * are never refreshed or otherwise mutated here.
+ * moved remote is represented by a normal upstream Integration Attempt. The
+ * normal check and CAS path advances only the Task clone; stable Project
+ * checkouts are never refreshed or otherwise mutated here.
  */
 export async function reconcileTaskRemoteBaselines(taskId, store, home, options = {}) {
     const task = store.getTask(taskId);
     if (task === null)
         throw usageError(`Task not found: ${taskId}.`);
-    // The delivery contract opts Project-backed Tasks into committed
-    // Integration evidence.  Metadata-only Tasks retain their existing local
-    // completion semantics and have no remote baseline to reconcile here.
-    if (task.projectBindings.length === 0
-        || !store.listIntegrationAttempts(task.id).some(({ status }) => status === "committed")) {
+    if (task.projectBindings.length === 0) {
         return [];
     }
     const workspace = requireTaskWorkspace(store, task);
     const git = options.git ?? new NodeGitWorkspace();
-    if (git.fetchRemoteHeadIntoWorktree === undefined
-        || git.mergeRemoteIntoWorktree === undefined) {
+    if (git.fetchRemoteHeadIntoWorktree === undefined) {
         throw usageError(`Task ${task.id} cannot verify remote baselines: managed Git workspace support is unavailable.`);
     }
-    // A completed Task-final Review that exactly covers the current frozen heads
-    // is the final review evidence.  Do not reconcile the remote after a clean
-    // review, as merging a moved remote would change the reviewed head and
-    // invalidate the review.
-    if (await hasCompletedTaskFinalReviewForCurrentCandidate(store, task, workspace, git)) {
-        return [];
-    }
     const plans = [];
     for (const binding of task.projectBindings) {
         const project = store.getProject(binding.projectId);
@@ -196,69 +183,47 @@ export async function reconcileTaskRemoteBaselines(taskId, store, home, options
             throw usageError(`Task ${task.id} has no writable managed main workspace for remote Project ${project.id}.`);
         }
         const currentCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
-        const previousIntegration = latestCommittedIntegration(store, task.id, project.id);
-        // A completed Task-final Review for the exact current head freezes the
-        // Task baseline: the delivery has been reviewed and approved, so the
-        // completion gate must not merge remote changes that would invalidate
-        // the review evidence.
-        if (hasFrozenTaskBaseline(store, task.id, project.id, currentCommit)) {
-            continue;
-        }
-        // Let the existing exact-head Task-final gate report local post-
-        // Integration drift before attempting any network operation.  This keeps
-        // completion read-only for an already-invalid candidate and preserves its
-        // precise recovery guidance.
-        if (previousIntegration !== undefined
-            && previousIntegration.candidateCommit !== currentCommit) {
-            continue;
+        if (binding.currentCommit !== currentCommit || binding.baseCommit === undefined) {
+            throw usageError(`Project ${project.id} Task commit record does not match its authoritative main clone.`);
         }
         const remote = await fetchRemote(git, entry, project);
         if (remote.commit === currentCommit)
             continue;
         if (await git.isAncestor(entry.path, remote.commit, currentCommit))
             continue;
-        if (previousIntegration === undefined) {
-            throw usageError(`Project ${project.id} remote target moved to ${remote.commit}, but no committed `
-                + "Integration can establish a safe Task baseline.");
-        }
-        if (previousIntegration.candidateCommit !== currentCommit) {
-            throw usageError(`Project ${project.id} Task head ${currentCommit} does not match its latest committed `
-                + `Integration ${previousIntegration.id}; settle that drift before remote reconciliation.`);
-        }
         if (!await git.isClean(entry.path)) {
             throw usageError(`Project ${project.id} managed Task workspace is dirty; commit or clean it before remote reconciliation.`);
         }
-        plans.push({ project, entry, remote, currentCommit, previousIntegration });
+        plans.push({
+            project,
+            entry,
+            remote,
+            currentCommit,
+            taskBaseCommit: binding.baseCommit
+        });
     }
     const reconciled = [];
     for (const plan of plans) {
         const attempt = store.transaction((tx) => {
-            // Re-check the frozen baseline inside the transaction: a Task-final
-            // Review may have completed during the async remote fetch, freezing
-            // the head after the initial check.  Creating a new Integration here
-            // would move the reviewed head and invalidate the review evidence.
-            if (hasFrozenTaskBaseline(tx, task.id, plan.project.id, plan.currentCommit)) {
-                return null;
-            }
             const created = createIntegrationAttempt({
                 id: tx.nextIntegrationAttemptId(task.id),
                 taskId: task.id,
                 projectId: plan.project.id,
                 targetRef: plan.entry.branch,
-                expectedHead: plan.currentCommit,
-                changeSetIds: plan.previousIntegration.changeSetIds,
-                checkCommands: plan.previousIntegration.checkCommands
+                beforeCommit: plan.currentCommit,
+                source: {
+                    kind: "upstream",
+                    branch: plan.remote.branch,
+                    remoteCommit: plan.remote.commit,
+                    taskBaseCommit: plan.taskBaseCommit,
+                    strategy: "rebase"
+                },
+                checkCommands: []
             }, options.now?.() ?? new Date());
             tx.saveIntegrationAttempt(task.id, created);
             return created;
         });
-        if (attempt === null)
-            continue;
-        const baseline = {
-            remoteUrl: plan.project.remoteUrl,
-            branch: plan.remote.branch
-        };
-        const result = await new GitIntegrationService(home, store, git, options.now ?? (() => new Date()), options.environment, undefined, options.jobPort).integrate(task.id, attempt.id, { remoteBaseline: baseline });
+        const result = await new GitIntegrationService(home, store, git, options.now ?? (() => new Date()), options.environment, undefined, options.jobPort).integrate(task.id, attempt.id);
         // rr6/f3: A moved remote with non-empty checks spawns a DurableJob. This
         // is a pending completion outcome, not a failure: name the exact
         // Integration and Job and the exact continuation command (mirroring the
@@ -307,44 +272,3 @@ function requireTaskWorkspace(store, task) {
     }
     return workspace;
 }
-/**
- * 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 actualProjects = [];
-    for (const binding of task.projectBindings) {
-        const entry = workspaceProjectEntry(workspace, binding.projectId);
-        if (entry === undefined || entry.access !== "write")
-            return false;
-        const actualHead = (await git.inspect(entry.path, "HEAD")).baseCommit;
-        actualProjects.push({ projectId: binding.projectId, commit: actualHead });
-    }
-    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)
-        .filter((attempt) => attempt.projectId === projectId && attempt.status === "committed")
-        .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }))
-        .at(-1);
-}
-/**
- * A Task baseline is frozen when a completed (clean) Task-final ReviewRound
- * reviewed the exact current head for the given Project.  Once frozen, the
- * completion gate skips remote baseline reconciliation to prevent merging
- * unreviewed remote changes into the approved delivery.
- */
-function hasFrozenTaskBaseline(store, taskId, projectId, currentCommit) {
-    return store.listReviewRounds(taskId)
-        .some((round) => ((round.scope ?? "work-item") === "task"
-        && isAcceptedTaskReviewBaseline(store, round)
-        && round.taskCandidate !== undefined
-        && round.taskCandidate.projects.some((entry) => (entry.projectId === projectId && entry.commit === currentCommit))));
-}

package/dist/commands/taskContextCommand.js

@@ -4,10 +4,10 @@ import { formatTimestamp } from "../output/timePresentation.js";
 import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectNextAction } from "../task/nextAction.js";
-import { summarizeExecutionGroup } from "../execution/executionGroup.js";
-import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
+import { projectWorkItemExecution } from "../execution/workItemExecutionProjection.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { projectReviewDecision } from "../review/reviewDecision.js";
+import { projectTaskRemoteDeliveryFromStore, renderTaskRemoteDelivery } from "./taskRemoteDeliveryCommand.js";
 const RECENT_RECORD_LIMIT = 5;
 const RELATED_RECORD_LIMIT = 5;
 const SUMMARY_TEXT_LIMIT = 400;
@@ -49,6 +49,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         const changeSets = chronological(reader.listChangeSets(task.id));
         const integrations = chronological(reader.listIntegrationAttempts(task.id));
         const publications = chronological(reader.listPublicationReferences(task.id));
+        const remoteDelivery = projectTaskRemoteDeliveryFromStore(reader, task, currentTaskReviewCandidate);
         const nextActionFacts = reader.readNextActionFacts(task.id);
         if (nextActionFacts === null) {
             throw new Error(`Task next-action facts disappeared: ${task.id}.`);
@@ -80,6 +81,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             changeSets,
             integrations,
             publications,
+            remoteDelivery,
             messages: operationalTaskRecords(reader.listMessages(task.id), events, "message"),
             openInputRequests: inputRequests.filter((request) => request.status === "open"),
             resolvedInputRequests: inputRequests.filter((request) => request.status !== "open"),
@@ -91,10 +93,11 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             })
         };
     });
-    const { task, execution, reviewConfig, reviewDecision, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, workItems, turns, reviewRounds, changeSets, integrations, publications, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
+    const { task, execution, reviewConfig, reviewDecision, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, coordinationMailboxes, workItems, turns, reviewRounds, changeSets, integrations, publications, remoteDelivery, messages, openInputRequests, resolvedInputRequests, events, nextAction } = data;
     const timeZone = store.getConfig().timeZone;
     const displayedActiveDecisions = activeDecisions.slice(-RECENT_RECORD_LIMIT);
     const displayedWorkItems = currentAndRecentWorkItems(workItems);
+    const currentWorkItems = workItems.filter(({ status }) => status !== "retired");
     const displayedOpenInputRequests = openInputRequests.slice(-RECENT_RECORD_LIMIT);
     const displayedResolvedInputRequests = resolvedInputRequests.slice(-RECENT_RECORD_LIMIT);
     const displayedActiveTurns = execution.activeTurns;
@@ -132,6 +135,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         ...(task.retirementSummary === undefined ? [] : [`Retirement summary: ${task.retirementSummary}`]),
         ...(task.replacementTaskId === undefined ? [] : [`Replacement Task: ${task.replacementTaskId}`]),
         ...(task.archiveSummary === undefined ? [] : [`Archive summary: ${task.archiveSummary}`]),
+        renderTaskRemoteDelivery(remoteDelivery).trimEnd(),
         "Execution:",
         `  Status: ${execution.status}`,
         `  Owner/action: ${execution.owner}/${execution.action}`,
@@ -173,12 +177,12 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
             ? ["  None."]
             : managedWorkspaces.map((workspace) => (`  ${managedWorkspaceLabel(workspace)}: ${workspace.root} (${workspace.entries.filter(({ access }) => access === "write").length} writable / ${workspace.entries.length} Projects)`))),
         `Type: ${task.type ?? "unspecified"}`,
-        `Execution topology: ${workItems.length === 0
+        `Execution topology: ${currentWorkItems.length === 0
             ? "Leader-owned Task main"
-            : `${workItems.length} independently owned WorkItem(s), integrated on Task main`}`,
+            : `${currentWorkItems.length} independently owned WorkItem(s), integrated on Task main`}`,
         `Completion evidence: ${task.projectBindings.length === 0
             ? "no Project evidence required"
-            : workItems.length === 0
+            : currentWorkItems.length === 0
                 ? "clean committed Task main required"
                 : "each delivered WorkItem requires a ChangeSet and committed Integration"}`,
         `Global review: ${reviewConfig === null
@@ -285,9 +289,7 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
                     ...(observability.workItems.find(({ workItemId }) => workItemId === item.id) === undefined
                         ? []
                         : [renderWorkItemObservability(observability.workItems.find(({ workItemId }) => workItemId === item.id))]),
-                    ...(currentWorkItemExecutionGroup(item) === undefined
-                        ? []
-                        : renderExecutionGroup(currentWorkItemExecutionGroup(item), executionGroupsById.get(currentWorkItemExecutionGroup(item).id))),
+                    ...renderWorkItemExecution(projectWorkItemExecution(item, turns, roleSessionSets)),
                     ...(item.acceptance.length === 0
                         ? []
                         : [`    Acceptance: ${item.acceptance.map(compactText).join("; ")}`]),
@@ -309,9 +311,12 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
                         : [
                             `    Turns: ${itemRuns.length}; latest ${latestTurn.id} [${latestTurn.status}] ${latestTurn.effective.agentId}/${latestTurn.effective.adapterId} · effective r${latestTurn.effective.sourceDesiredRevision}/${latestTurn.effective.profileAccess}/${latestTurn.effective.permission.strategy}`,
                             `      Assignment: ${latestTurn.inputs[0].input.source.channel}${latestTurn.inputs[0].input.directive === undefined ? "" : ` · ${compactText(latestTurn.inputs[0].input.directive)}`}`,
-                            ...(latestTurn.result === undefined
+                            ...(latestTurn.result?.output === undefined
+                                ? []
+                                : [`      Result: ${compactText(latestTurn.result.output)}`]),
+                            ...(latestTurn.result?.diagnostic === undefined
                                 ? []
-                                : [`      Summary: ${compactText(latestTurn.result.output)}`])
+                                : [`      Failure: ${compactText(latestTurn.result.diagnostic)}`])
                         ]),
                     ...renderReviewRounds(reviewRounds.filter((round) => round.workItemId === item.id), executionGroupsById)
                 ];
@@ -323,7 +328,10 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         ...recentSection("Turns", turns, (run) => [
             `  ${run.id} [${run.status}/${run.purpose}] ${run.roleName} via ${run.effective.agentId}/${run.effective.adapterId}`,
             `    Effective: r${run.effective.sourceDesiredRevision}; Profile intent: ${run.effective.profileAccess}; permission: ${run.effective.permission.strategy}; model: ${run.effective.model ?? "default"}; effort: ${run.effective.effort ?? "default"}`,
-            ...(run.result === undefined ? [] : [`    Result: ${compactText(run.result.output)}`])
+            ...(run.result?.output === undefined ? [] : [`    Result: ${compactText(run.result.output)}`]),
+            ...(run.result?.diagnostic === undefined
+                ? []
+                : [`    Failure: ${compactText(run.result.diagnostic)}`])
         ]),
         "",
         "Runtime health:",
@@ -347,7 +355,11 @@ export function runTaskContextCommand(args, store, currentTaskReviewCandidate =
         `Integration Attempts (${integrations.length}):`,
         ...(integrations.length === 0
             ? ["  None."]
-            : integrations.slice(-RECENT_RECORD_LIMIT).map((integration) => (`  ${integration.id} [${integration.status}/${integration.projectId}] — ${integration.targetRef}; ${integration.changeSetIds.join(", ")}`))),
+            : integrations.slice(-RECENT_RECORD_LIMIT).map((integration) => (`  ${integration.id} [${integration.status}/${integration.projectId}] — ${integration.targetRef}; ${integration.source.kind === "work-item"
+                ? `WorkItem ${integration.source.workItemId}@${integration.source.resultCommit.slice(0, 12)}`
+                : integration.source.kind === "upstream"
+                    ? `upstream ${integration.source.branch}@${integration.source.remoteCommit.slice(0, 12)}`
+                    : `historical ChangeSets ${integration.source.changeSetIds.join(", ")}`}`))),
         "",
         `Publication references (${publications.length}):`,
         ...(publications.length === 0
@@ -435,15 +447,7 @@ function renderReviewRounds(rounds, executionGroupsById = new Map()) {
                     ? [`      Review mode: full`]
                     : [
                         `      Review mode: delta-recheck (rechecks ${latest.deltaRecheck.previousReviewRoundId}@${latest.deltaRecheck.previousBaseCommit.slice(0, 12)})`,
-                        `      Delta: ${latest.deltaRecheck.changedFiles.length} file(s), +${latest.deltaRecheck.addedLines}/-${latest.deltaRecheck.deletedLines}, digest ${latest.deltaRecheck.diffDigest.slice(0, 12)}`,
-                        ...(latest.deltaRecheck.disposition === undefined
-                            ? []
-                            : [
-                                `      Delta disposition: ${latest.deltaRecheck.disposition}`,
-                                ...(latest.deltaRecheck.escalatedToReviewRoundId === undefined
-                                    ? []
-                                    : [`      Escalated to: ${latest.deltaRecheck.escalatedToReviewRoundId}`])
-                            ])
+                        `      Delta: ${latest.deltaRecheck.changedFiles.length} file(s), +${latest.deltaRecheck.addedLines}/-${latest.deltaRecheck.deletedLines}, digest ${latest.deltaRecheck.diffDigest.slice(0, 12)}`
                     ])
             ]
             : []),
@@ -451,16 +455,18 @@ function renderReviewRounds(rounds, executionGroupsById = new Map()) {
             ? "not prepared"
             : `${latest.workspace.root} (${latest.workspace.entries.length} writable Projects)`}`,
         `      Workspace disposition: ${latest.workspaceDisposition?.kind ?? "pending"}`,
-        `      Diagnostic evidence: ${latest.evidenceCommit ?? "none"}`,
-        `      Checks: ${latest.checks === undefined || latest.checks.length === 0
-            ? "none"
-            : latest.checks.map(({ name, outcome }) => `${name}=${outcome}`).join(", ")}`,
-        ...(latest.summary === undefined
+        `      Main Reviewer Turn: ${latest.reviewerTurnId ?? "not dispatched"}`,
+        ...(latest.failure === undefined
             ? []
-            : [`      Review summary: ${compactText(latest.summary)}`]),
+            : [`      Core failure: ${latest.failure.kind} · ${compactText(latest.failure.message)}`]),
         ...(latest.executionGroup === undefined
             ? []
-            : renderExecutionGroup(latest.executionGroup, executionGroupsById.get(latest.executionGroup.id)).map((line) => `    ${line.trimStart()}`))
+            : [
+                `      Execution shape: replicated`,
+                `      Execution Group: ${latest.executionGroup.id}`,
+                ...latest.executionGroup.lanes.map((lane) => (`      Producer ${lane.id} (#${lane.ordinal}, ${lane.roleName}): `
+                    + `${lane.disposition}; turn=${lane.currentTurnId ?? "not dispatched"}`))
+            ])
     ];
 }
 function renderResolvedInputRequest(request, timeZone) {
@@ -553,57 +559,19 @@ function managedWorkspaceLabel(workspace) {
             return `execution-lane ${workspace.owner.executionGroupId}/${workspace.owner.executionLaneId}`;
     }
 }
-function renderExecutionGroup(group, projected) {
-    const summary = projected
-        ?? summarizeExecutionGroup(group);
-    const health = projected?.health;
-    const resources = projected?.resources;
+function renderWorkItemExecution(projection) {
     return [
-        `    Execution Group ${summary.groupId} [${summary.purpose}/${summary.strategy.mode}]: ${summary.activeLaneCount} active / ${summary.terminalLaneCount} terminal; ${summary.failedLaneCount} failed; ${summary.skippedLaneCount} skipped`,
-        ...(health === undefined
-            ? []
-            : [
-                `      Health: active=${health.activeLaneCount}, silent=${health.silentLaneCount}, suspected-stalled=${health.suspectedStalledLaneCount}, confirmed-dead=${health.confirmedDeadLaneCount}`,
-                `      Recovery: reusable=${health.reusableLaneIds.length}, retryable=${health.retryableLaneIds.length}`
-            ]),
-        ...(resources === undefined
-            ? []
-            : [
-                `      Resources: tokens=${resourceUsageLabel(resources.tokens, resources.tokensRemaining, resources.tokensObservable)}; tools=${resourceUsageLabel(resources.toolCalls, resources.toolCallsRemaining, resources.toolCallsObservable)}; wall=${resources.wallClockSeconds}s${resources.wallClockSecondsRemaining === undefined ? "" : `, remaining=${resources.wallClockSecondsRemaining}s`}`,
-                `      Completion: usable=${resources.usableLaneCount}/${group.stage?.resources?.quorum ?? "legacy"}; quorum=${resources.quorumMet ? "met" : "open"}; deadline=${resources.deadlineReached ? "reached" : "open"}; budgets=${resources.exhaustedBudgets.join(",") || "open"}; queued=${resources.pendingLaneIds.length}; stragglers=${resources.stragglerLaneIds.length}`
-            ]),
-        ...summary.laneSummaries.flatMap((lane) => {
-            const laneHealth = projected?.laneSummaries.find(({ laneId }) => laneId === lane.laneId);
-            return [
-                `      Lane ${lane.laneId} (#${lane.ordinal}, ${lane.roleName}${lane.turnId === undefined ? "" : `, run ${lane.turnId}`}) [${lane.status}${laneHealth?.runtimeHealth === undefined ? "" : `/${laneHealth.runtimeHealth}`}]${lane.summary === undefined ? "" : `: ${compactText(lane.summary)}`}`,
-                ...(lane.effective === undefined
-                    ? []
-                    : [`        Config: ${lane.effective.adapterId}/${lane.effective.model ?? "default"}/${lane.effective.effort ?? "default"}; profile=${lane.effective.profileAccess}`]),
-                ...(laneHealth !== undefined && laneHealth.recovery !== "none"
-                    ? [`        Recovery: ${laneHealth.recovery}; ${compactText(laneHealth.reason)}`]
-                    : []),
-                ...(lane.report === undefined ? [] : [`        Report: ${compactText(lane.report)}`]),
-                ...(lane.checks === undefined || lane.checks.length === 0
-                    ? []
-                    : [`        Checks: ${lane.checks.map(({ name, outcome }) => `${name}:${outcome}`).join(", ")}`]),
-                ...(lane.findings === undefined || lane.findings.length === 0
-                    ? []
-                    : [`        Findings: ${lane.findings.map(({ id, severity, status }) => `${id}:${severity}/${status}`).join(", ")}`]),
-                ...(lane.evidence === undefined || lane.evidence.length === 0
-                    ? []
-                    : [`        Evidence: ${lane.evidence.length} item(s)`]),
-                ...(lane.evidenceCommit === undefined
-                    ? []
-                    : [`        Evidence commit: ${lane.evidenceCommit}`]),
-                ...(lane.decision === undefined ? [] : [`        Decision: ${lane.decision}`])
-            ];
-        }),
-        ...(summary.openHighPriorityFindingIds.length === 0
-            ? []
-            : [`      Open high findings: ${summary.openHighPriorityFindingIds.join(", ")}`]),
-        ...(summary.resolution === undefined
+        `    WorkItem execution [${projection.shape}]${projection.groupId === undefined ? "" : `: ${projection.groupId}`}`,
+        ...projection.lanes.map((lane) => (`      Lane ${lane.laneId} (#${lane.ordinal}, ${lane.roleName}) [${lane.status}]: `
+            + `turn=${lane.currentTurnId ?? "unknown"}; session=${lane.session}; `
+            + `retry=${lane.retryTurnId ?? "none"}; settle=${lane.settleTurnId ?? "none"}`)),
+        `      Synthesis: ${projection.synthesis.status} (${projection.synthesis.successfulLaneCount}/${projection.synthesis.requiredSuccessfulLaneCount} successful)`,
+        `      Main Turn: ${projection.mainTurn.turnId ?? "unobserved"} [${projection.mainTurn.status}]; session=${projection.mainTurn.session}`,
+        `      Candidate source: ${projection.candidate.candidateId ?? "none"} [${projection.candidate.status}]; main=${projection.candidate.mainTurnId ?? "unobserved"}`,
+        ...(projection.candidate.sourceExecutionGroupId === undefined
             ? []
-            : [`      Resolution: ${summary.resolution.decision} — ${compactText(summary.resolution.summary)}`])
+            : [`      Provenance: ${projection.candidate.mainTurnId ?? "unobserved"} -> ${projection.candidate.sourceExecutionGroupId} -> ${projection.candidate.successfulLaneTurns.map(({ laneId, successfulTurnId }) => `${laneId} -> ${successfulTurnId}`).join(", ") || "unobserved"}`]),
+        `      Next: ${projection.nextAction.kind}; owner=${projection.nextAction.owners.join(", ") || "none"}; target=${projection.nextAction.targetIds.join(", ") || "none"}`
     ];
 }
 function resourceUsageLabel(used, remaining, observable) {
@@ -612,6 +580,5 @@ function resourceUsageLabel(used, remaining, observable) {
     return `${used}${remaining === undefined ? "" : `, remaining=${remaining}`}`;
 }
 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}; evidence=${item.evidenceCount}; open-findings=${item.openFindingCount}; compression=${item.context.compressionStatus}`;
+    return `    Observability (read-only): tokens=${item.cost.tokensObservable ? item.cost.tokens : "unobserved"}; tools=${item.cost.toolCallsObservable ? item.cost.toolCalls : "unobserved"}; wall=${item.cost.wallClockSeconds}s; retries=${item.cost.retryCount}; snapshots=${item.context.snapshotCount}; agent-results=${item.resultCount ?? "unobserved"}; compression=${item.context.compressionStatus}`;
 }

package/dist/commands/taskExecutionCommands.js

@@ -1,12 +1,11 @@
 import { createTaskEvent } from "../event/taskEvent.js";
-import { recordExecutionLaneResult } from "../execution/executionGroup.js";
+import { updateExecutionLane } from "../execution/workItemExecution.js";
 import { usageError } from "../errors/cliError.js";
 import { requestDurableJobCancel } from "../job/durableJob.js";
 import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewRound.js";
 import { failTurn } from "../turn/turn.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { startTaskExecution, stopTaskExecution } from "../task/task.js";
-import { updateWorkItemExecutionGroup, workItemExecutionGroupById } from "../workItem/workItem.js";
 import { taskActor } from "./taskActor.js";
 export function parseTaskExecutionStopRequest(args) {
     const taskId = args[0];
@@ -183,44 +182,27 @@ function taskRuntimeRoleNames(store, taskId, turns) {
 }
 function failExecutionAttempts(store, taskId, turns, reason, now) {
     const summary = `Task execution stopped: ${reason}`;
-    const workItems = new Map(store.listWorkItems(taskId).map((item) => [item.id, item]));
     const reviewRounds = new Map(store.listReviewRounds(taskId).map((round) => [round.id, round]));
     const affectedReviewRoundIds = new Set();
     for (const turn of turns) {
-        if (turn.executionGroupId === undefined || turn.executionLaneId === undefined)
-            continue;
-        if (turn.workItemId !== undefined) {
-            const item = workItems.get(turn.workItemId);
-            const group = item === undefined
-                ? undefined
-                : workItemExecutionGroupById(item, turn.executionGroupId);
-            const lane = group?.lanes.find(({ id }) => id === turn.executionLaneId);
-            if (item !== undefined && group !== undefined && lane !== undefined
-                && item.currentExecutionGroupId === group.id
-                && !["completed", "failed", "skipped"].includes(lane.status)) {
-                const updated = updateWorkItemExecutionGroup(item, recordExecutionLaneResult(group, lane.id, { summary }, "failed", now), now);
-                workItems.set(item.id, updated);
-            }
-        }
         if (turn.reviewRoundId !== undefined) {
             affectedReviewRoundIds.add(turn.reviewRoundId);
+            if (turn.executionGroupId === undefined || turn.executionLaneId === undefined)
+                continue;
             const round = reviewRounds.get(turn.reviewRoundId);
             const group = round?.executionGroup?.id === turn.executionGroupId
                 ? round.executionGroup
                 : undefined;
             const lane = group?.lanes.find(({ id }) => id === turn.executionLaneId);
             if (round !== undefined && group !== undefined && lane !== undefined
-                && !["completed", "failed", "skipped"].includes(lane.status)) {
-                reviewRounds.set(round.id, updateReviewExecutionGroup(round, recordExecutionLaneResult(group, lane.id, { summary }, "failed", now)));
+                && lane.disposition === "open") {
+                reviewRounds.set(round.id, updateReviewExecutionGroup(round, updateExecutionLane(group, lane.id, {
+                    currentTurnId: turn.id,
+                    disposition: "failed"
+                }, now)));
             }
         }
     }
-    for (const item of workItems.values()) {
-        const original = store.getWorkItem(item.taskId, item.id);
-        if (original !== null && original.revision !== item.revision) {
-            store.saveWorkItem(item.taskId, item);
-        }
-    }
     for (const reviewRoundId of affectedReviewRoundIds) {
         const round = reviewRounds.get(reviewRoundId);
         const original = store.getReviewRound(round.taskId, round.id);
@@ -228,7 +210,7 @@ function failExecutionAttempts(store, taskId, turns, reason, now) {
             continue;
         const changed = JSON.stringify(original.executionGroup) !== JSON.stringify(round.executionGroup);
         const terminal = round.status === "pending" || round.status === "running"
-            ? finishReviewRound(round, "failed", summary, now)
+            ? finishReviewRound(round, "failed", now, { kind: "execution", message: summary })
             : round;
         if (changed || terminal !== round)
             store.saveReviewRound(round.taskId, terminal);

package/dist/commands/taskInputCommands.js

@@ -255,12 +255,12 @@ export function isCurrentGlobalOperator(store, environment) {
         return false;
     const agentId = exactIdentity(environment.YUI_AGENT_ID);
     const adapterId = exactIdentity(environment.YUI_ADAPTER_ID);
-    const launchId = exactIdentity(environment.YUI_LAUNCH_ID);
+    const runtimeGenerationId = exactIdentity(environment.YUI_RUNTIME_GENERATION_ID);
     const nativeSessionId = exactIdentity(environment.YUI_NATIVE_SESSION_ID);
     const binding = role.agentBindings[role.activeAgentId];
     if (agentId === undefined
         || adapterId === undefined
-        || launchId === undefined
+        || runtimeGenerationId === undefined
         || binding === undefined
         || binding.agentId !== agentId
         || binding.adapterId !== adapterId)
@@ -277,7 +277,7 @@ export function isCurrentGlobalOperator(store, environment) {
                 roleName: role.name,
                 agentId,
                 adapterId,
-                launchId
+                runtimeGenerationId
             });
     }
     // A fresh Codex launch discovers its native Session asynchronously. Its
@@ -290,14 +290,14 @@ export function isCurrentGlobalOperator(store, environment) {
         || (nativeSessionId === undefined
             && binding.adapterId === "codex"
             && session.adapterId === "codex"
-            && session.launchId !== undefined
-            && session.launchId === launchId));
+            && session.runtimeGenerationId !== undefined
+            && session.runtimeGenerationId === runtimeGenerationId));
     return binding.agentId === session.agentId
         && binding.adapterId === session.adapterId
         && session.agentId === agentId
         && session.adapterId === adapterId
-        && session.launchId !== undefined
-        && session.launchId === launchId
+        && session.runtimeGenerationId !== undefined
+        && session.runtimeGenerationId === runtimeGenerationId
         && nativeSessionMatches;
 }
 function currentProcessBelongsToReservedGlobalLaunch(store, input) {
@@ -307,16 +307,16 @@ function currentProcessBelongsToReservedGlobalLaunch(store, input) {
         scope: "global",
         roleName: input.roleName
     }));
-    if (!isRuntimeLaunchReservation(mailbox?.processing, input.launchId)
+    if (!isRuntimeLaunchReservation(mailbox?.processing, input.runtimeGenerationId)
         || hasRuntimeCleanupObligation(mailbox))
         return false;
-    const owner = store.getSessionOwner(input.launchId);
+    const owner = store.getSessionOwner(input.runtimeGenerationId);
     if (owner === null
         || owner.owner.scope !== "global"
         || owner.owner.roleName !== input.roleName
         || owner.agentId !== input.agentId
         || owner.adapterId !== input.adapterId
-        || owner.launchId !== input.launchId
+        || owner.runtimeGenerationId !== input.runtimeGenerationId
         || owner.providerRoot.attribution !== "launch-env"
         || !isLinuxProcessLive(owner.providerRoot.pid, owner.providerRoot.startIdentity)) {
         return false;