@zq-silk/yui 0.2.0 → 0.4.2

package/dist/commands/taskCompletionGate.js

@@ -0,0 +1,131 @@
+import { usageError } from "../errors/cliError.js";
+import { GitIntegrationService } from "../integration/gitIntegrationService.js";
+import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
+/**
+ * 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.
+ */
+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 || task.requireIntegration !== true)
+        return [];
+    const workspace = requireTaskWorkspace(store, task);
+    const git = options.git ?? new NodeGitWorkspace();
+    if (git.fetchRemoteHeadIntoWorktree === undefined
+        || git.mergeRemoteIntoWorktree === undefined) {
+        throw usageError(`Task ${task.id} cannot verify remote baselines: managed Git workspace support is unavailable.`);
+    }
+    const plans = [];
+    for (const binding of task.projectBindings) {
+        const project = store.getProject(binding.projectId);
+        if (project === null) {
+            throw usageError(`Project not found for Task ${task.id}: ${binding.projectId}.`);
+        }
+        if (project.remoteUrl === undefined)
+            continue;
+        const entry = workspaceProjectEntry(workspace, project.id);
+        if (entry === undefined || entry.access !== "write") {
+            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);
+        // 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;
+        }
+        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 });
+    }
+    const reconciled = [];
+    for (const plan of plans) {
+        const attempt = store.transaction((tx) => {
+            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
+            }, options.now?.() ?? new Date());
+            tx.saveIntegrationAttempt(task.id, created);
+            return created;
+        });
+        const baseline = {
+            remoteUrl: plan.project.remoteUrl,
+            branch: plan.remote.branch
+        };
+        const result = await new GitIntegrationService(home, store, git, options.now ?? (() => new Date()), options.environment).integrate(task.id, attempt.id, { remoteBaseline: baseline });
+        if (result.status !== "committed" || result.attempt.candidateCommit === undefined) {
+            const detail = result.attempt.checks?.find(({ outcome }) => outcome === "failed")?.details
+                ?? result.attempt.conflict?.summary
+                ?? result.attempt.status;
+            throw usageError(`Remote baseline reconciliation failed for ${task.id}/${plan.project.id}: ${detail}`);
+        }
+        reconciled.push({
+            projectId: plan.project.id,
+            remote: plan.remote,
+            fromCommit: plan.currentCommit,
+            toCommit: result.attempt.candidateCommit,
+            integrationId: attempt.id
+        });
+    }
+    return reconciled;
+}
+async function fetchRemote(git, entry, project) {
+    try {
+        return await git.fetchRemoteHeadIntoWorktree({
+            repositoryPath: entry.path,
+            remoteUrl: project.remoteUrl,
+            branch: project.developmentBranch
+        });
+    }
+    catch (error) {
+        throw usageError(`Project ${project.id} remote target could not be resolved; completion is fail-closed: `
+            + `${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function requireTaskWorkspace(store, task) {
+    const workspace = store.getTaskWorkspace(task.id);
+    if (workspace === null || workspace.owner.type !== "task") {
+        throw usageError(`Task ${task.id} has no authoritative managed main workspace.`);
+    }
+    return workspace;
+}
+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);
+}

package/dist/commands/taskContextCommand.js

@@ -1,13 +1,18 @@
 import { taskNotFound, usageError } from "../errors/cliError.js";
 import { taskMessageAuthorLabel } from "../message/message.js";
+import { formatTimestamp } from "../output/timePresentation.js";
+import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
+import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
+import { inspectTaskRoleSessionRecovery } from "./taskRoleRuntimeStatus.js";
+import { summarizeExecutionGroup } from "../execution/executionGroup.js";
+import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
 const RECENT_RECORD_LIMIT = 5;
 const RELATED_RECORD_LIMIT = 5;
 const SUMMARY_TEXT_LIMIT = 400;
 const TERMINAL_WORK_ITEM_STATUSES = new Set([
     "completed",
     "failed",
-    "cancelled",
-    "superseded"
+    "retired"
 ]);
 export function runTaskContextCommand(args, store) {
     if (args.length !== 1 || args[0]?.trim().length === 0) {
@@ -19,29 +24,45 @@ export function runTaskContextCommand(args, store) {
         if (task === null)
             throw taskNotFound(taskId);
         const workItems = reader.listWorkItems(task.id);
-        const workItemIds = new Set(workItems.map((item) => item.id));
         const inputRequests = reader.listInputRequests(task.id);
+        const roles = reader.listRoles(task.id);
+        const execution = buildTaskExecutionProjection(reader, task.id, task);
+        if (execution === null) {
+            throw new Error(`Task execution projection disappeared: ${task.id}.`);
+        }
+        const roleSessionSets = reader.listRoleSessionSets(task.id);
         return {
             task,
+            execution,
+            reviewConfig: reader.getReviewConfig(),
             brief: reader.getTaskBrief(task.id),
             activeDecisions: reader.listDecisions(task.id)
                 .filter((decision) => decision.status === "active"),
             milestones: reader.listMilestones(task.id),
-            roles: reader.listRoles(task.id),
+            roles,
+            managedWorkspaces: reader.listManagedWorkspaces(task.id),
+            roleSessionSets,
+            roleSessionRecoveries: roles.map((role) => (inspectTaskRoleSessionRecovery(task.id, role.name, reader))),
             workItems,
-            runs: reader.listAgentRuns(task.id)
-                .filter((run) => run.workItemId !== undefined && workItemIds.has(run.workItemId)),
+            agentRuns: chronological(reader.listAgentRuns(task.id)),
+            reviewRounds: chronological(reader.listReviewRounds(task.id)),
+            changeSets: chronological(reader.listChangeSets(task.id)),
+            integrations: chronological(reader.listIntegrationAttempts(task.id)),
             messages: reader.listMessages(task.id),
             openInputRequests: inputRequests.filter((request) => request.status === "open"),
             resolvedInputRequests: inputRequests.filter((request) => request.status !== "open"),
             events: reader.listEvents(task.id)
         };
     });
-    const { task, brief, activeDecisions, milestones, roles, workItems, runs, messages, openInputRequests, resolvedInputRequests, events } = data;
+    const { task, execution, reviewConfig, brief, activeDecisions, milestones, roles, managedWorkspaces, roleSessionSets, roleSessionRecoveries, workItems, agentRuns, reviewRounds, changeSets, integrations, messages, openInputRequests, resolvedInputRequests, events } = 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 lines = [
         `Task context: ${task.id}`,
         `Title: ${compactText(task.title)}`,
@@ -49,12 +70,41 @@ export function runTaskContextCommand(args, store) {
         ...(task.description === undefined ? [] : [`Description: ${compactText(task.description)}`]),
         ...(task.priority === undefined ? [] : [`Priority: ${task.priority}`]),
         ...(task.tags === undefined ? [] : [`Tags: ${task.tags.join(", ")}`]),
-        ...(task.dueAt === undefined ? [] : [`Due: ${task.dueAt}`]),
+        ...(task.dueAt === undefined ? [] : [`Due: ${formatTimestamp(task.dueAt, timeZone)}`]),
         ...(task.completionSummary === undefined ? [] : [`Completion summary: ${task.completionSummary}`]),
+        ...(task.retirementSummary === undefined ? [] : [`Retirement summary: ${task.retirementSummary}`]),
+        ...(task.replacementTaskId === undefined ? [] : [`Replacement Task: ${task.replacementTaskId}`]),
         ...(task.archiveSummary === undefined ? [] : [`Archive summary: ${task.archiveSummary}`]),
-        ...(task.repositoryId === undefined ? [] : [`Repository: ${task.repositoryId}`]),
-        ...(task.baseRef === undefined ? [] : [`Base: ${task.baseRef}`]),
+        "Execution:",
+        `  Status: ${execution.status}`,
+        `  Owner/action: ${execution.owner}/${execution.action}`,
+        `  Monitoring: ${execution.monitoring}`,
+        `  Fail-closed: ${execution.failClosed ? "yes" : "no"}`,
+        `  Reason: ${execution.reason}`,
+        `  Attention: ${execution.attention.length === 0
+            ? "none"
+            : execution.attention.map(({ kind, owner }) => `${kind}/${owner}`).join(", ")}`,
+        `  Active execution carriers (${displayedExecutionCarriers.length}):`,
+        ...(displayedExecutionCarriers.length === 0
+            ? ["    None."]
+            : displayedExecutionCarriers.map((run) => (`    ${run.roleName}: ${run.id} [${run.status}; ${run.delivered ? "accepted" : "delivery-pending"}]`))),
+        ...(task.projectBindings.length === 0
+            ? []
+            : [
+                "Projects:",
+                ...task.projectBindings.map((binding) => (`- ${binding.directory}: ${binding.projectId} @ ${binding.baseRef}`))
+            ]),
         ...(task.cwd === undefined ? [] : [`Workspace: ${task.cwd}`]),
+        `Managed Workspaces (${managedWorkspaces.length}):`,
+        ...(managedWorkspaces.length === 0
+            ? ["  None."]
+            : managedWorkspaces.map((workspace) => (`  ${managedWorkspaceLabel(workspace)}: ${workspace.root} (${workspace.entries.filter(({ access }) => access === "write").length} writable / ${workspace.entries.length} Projects)`))),
+        `Completion evidence: ${task.requireIntegration
+            ? "WorkItem, ChangeSet, and committed Integration required"
+            : "delivery integration not required"}`,
+        `Global review: ${reviewConfig === null
+            ? "disabled"
+            : `${reviewConfig.roleName} (${reviewConfig.trigger})`}`,
         "",
         "Brief:",
         ...(brief === null
@@ -65,9 +115,12 @@ export function runTaskContextCommand(args, store) {
                 ...(brief.boundaries.length === 0
                     ? ["    None."]
                     : brief.boundaries.map((boundary) => `    - ${compactText(boundary)}`)),
+                `  Technical approach: ${brief.technicalApproach.length === 0
+                    ? "Not defined."
+                    : compactText(brief.technicalApproach)}`,
                 `  Current focus: ${compactText(brief.currentFocus)}`,
                 `  Leader summary: ${compactText(brief.leaderSummary)}`,
-                `  Updated by ${brief.updatedBy} at ${brief.updatedAt}`
+                `  Updated by ${brief.updatedBy} at ${formatTimestamp(brief.updatedAt, timeZone)}`
             ]),
         "",
         `Active decisions (${displayedActiveDecisions.length}${activeDecisions.length > displayedActiveDecisions.length ? ` of ${activeDecisions.length}` : ""}):`,
@@ -79,55 +132,133 @@ export function runTaskContextCommand(args, store) {
             ])),
         "",
         ...recentSection("milestones", milestones, (milestone) => [
-            `  ${milestone.id}: ${compactText(milestone.title)} (${milestone.createdAt})`,
+            `  ${milestone.id}: ${compactText(milestone.title)} (${formatTimestamp(milestone.createdAt, timeZone)})`,
             `    ${compactText(milestone.summary)}`
         ]),
         "",
-        `Roles (${roles.length}):`,
+        `Task Roles (${roles.length}):`,
         ...(roles.length === 0
             ? ["  None."]
-            : roles.map((role) => (`  ${role.name} [${role.status}] — Agent: ${role.activeAgentId}`))),
+            : roles.flatMap((role) => {
+                const binding = role.agentBindings[role.activeAgentId];
+                const activeRun = agentRuns.find((run) => (run.roleName === role.name && run.status === "active"));
+                const sessions = roleSessionSets.find((set) => set.owner.roleName === role.name);
+                const activeSession = sessions?.sessions[sessions.activeAgentId];
+                const effective = activeRun?.effective ?? activeSession?.effective;
+                const effectiveSource = activeRun === undefined ? "Session" : "Run";
+                const recovery = roleSessionRecoveries.find((entry) => entry.roleName === role.name);
+                const creation = [...events].reverse().find((event) => (event.type === "role.added" && event.payload.role === role.name));
+                return [
+                    `  ${role.name} [${role.status}]: ${role.activeAgentId}/${binding.adapterId}`,
+                    `    Desired: r${role.launchRevision}; Profile intent: ${role.defaultAccess}; Model: ${binding.config.model ?? "default"}; effort: ${binding.config.effort ?? "default"}; permission: ${binding.config.permission.strategy}`,
+                    `    Effective: ${effective === undefined
+                        ? "not started"
+                        : `${effectiveSource} ${effective.agentId}/${effective.adapterId}; r${effective.sourceDesiredRevision}; Profile intent: ${effective.profileAccess}; permission: ${effective.permission.strategy}`}`,
+                    `    Desired drift: ${effective === undefined
+                        ? "-"
+                        : effective.sourceDesiredRevision === role.launchRevision
+                            ? "none"
+                            : "pending next launch"}`,
+                    ...(creation?.payload.runtimeSource === undefined
+                        ? []
+                        : [`    Runtime source at creation: ${creation.payload.runtimeSource}`]),
+                    ...(recovery === undefined ? [] : [
+                        `    Runtime cleanup: ${recovery.runtimeCleanupPending ? "pending" : "none"}`,
+                        `    Fresh launch: ${recovery.freshLaunchAllowed ? "allowed" : "blocked"}`
+                    ])
+                ];
+            })),
         "",
         `Current and recent work items (${displayedWorkItems.length}${workItems.length > displayedWorkItems.length ? ` of ${workItems.length}` : ""}):`,
         ...(displayedWorkItems.length === 0
             ? ["  None."]
             : displayedWorkItems.flatMap((item) => {
-                const itemRuns = runs.filter((run) => run.workItemId === item.id);
+                const itemRuns = agentRuns.filter((run) => run.workItemId === item.id);
                 const latestRun = itemRuns.at(-1);
                 return [
-                    `  ${item.id} [${item.status}] ${item.assignee}: ${compactText(item.title)}`,
-                    ...(item.outcome === undefined
+                    `  ${item.id} [${item.status}]: ${compactText(item.title)}`,
+                    `    Objective: ${compactText(item.objective)}`,
+                    `    Writable Projects: ${item.writeProjectIds.length === 0
+                        ? "none"
+                        : item.writeProjectIds.join(", ")}`,
+                    ...(currentWorkItemExecutionGroup(item) === undefined
+                        ? []
+                        : renderExecutionGroup(currentWorkItemExecutionGroup(item))),
+                    ...(item.acceptance.length === 0
+                        ? []
+                        : [`    Acceptance: ${item.acceptance.map(compactText).join("; ")}`]),
+                    ...(item.candidates.length === 0
                         ? []
-                        : [`    Outcome: ${compactText(item.outcome)}`]),
+                        : item.candidates.flatMap((candidate) => [
+                            `    Candidate ${candidate.sequence}: ${candidate.id}${item.status === "awaiting_acceptance" && candidate === item.candidates.at(-1) ? " [current]" : ""} (${candidate.source.type === "run" ? candidate.source.runId : "direct"})`,
+                            `      Review policy: ${candidate.reviewPolicy === undefined ? "none" : `${candidate.reviewPolicy.roleName} (${candidate.reviewPolicy.trigger})`}`,
+                            `      Task-final contract: ${candidate.taskFinalReviewContract === undefined
+                                ? "none"
+                                : `${candidate.taskFinalReviewContract.digest} via control ${candidate.taskFinalReviewContract.controlPlaneDigest}`}`,
+                            `      Frozen Git: ${candidate.gitSnapshot === undefined
+                                ? "unavailable"
+                                : `${candidate.gitSnapshot.reviewBaseCommit} (${candidate.gitSnapshot.projects.length} Projects)`}`,
+                            `      Summary: ${compactText(candidate.summary)}`
+                        ])),
                     ...(latestRun === undefined
-                        ? ["    Runs: none."]
+                        ? ["    AgentRuns: none."]
                         : [
-                            `    Runs: ${itemRuns.length}; latest ${latestRun.id} [${latestRun.status}] ${latestRun.roleName}`,
+                            `    AgentRuns: ${itemRuns.length}; latest ${latestRun.id} [${latestRun.status}] ${latestRun.effective.agentId}/${latestRun.effective.adapterId} · effective r${latestRun.effective.sourceDesiredRevision}/${latestRun.effective.profileAccess}/${latestRun.effective.permission.strategy}`,
                             `      Input: ${compactText(latestRun.input)}`,
                             ...(latestRun.summary === undefined
                                 ? []
                                 : [`      Summary: ${compactText(latestRun.summary)}`])
-                        ])
+                        ]),
+                    ...renderWorkItemReviews(reviewRounds.filter((round) => round.workItemId === item.id))
                 ];
             })),
         "",
+        ...recentSection("AgentRuns", agentRuns, (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.summary === undefined ? [] : [`    Result: ${compactText(run.summary)}`])
+        ]),
+        "",
+        "Runtime health:",
+        ...(() => {
+            const stalled = agentRuns.filter((run) => (run.status === "active" && isRoleRunStalled(events, run.id)));
+            return stalled.length === 0
+                ? ["  No needs-attention Runs."]
+                : stalled.flatMap((run) => [
+                    `  ${run.id} [needs-attention] ${run.roleName}`,
+                    `    Durable progress: ${formatTimestamp(latestStallProgressAt(events, run.id) ?? run.updatedAt, timeZone)}`,
+                    `    Cause: ${latestStallKind(events, run.id)} with no new semantic Run evidence in the stall window`,
+                    "    Next: inspect Task context/Role status; no automatic retry or Session replacement was performed."
+                ]);
+        })(),
+        "",
+        `ChangeSets (${changeSets.length}):`,
+        ...(changeSets.length === 0
+            ? ["  None."]
+            : changeSets.slice(-RECENT_RECORD_LIMIT).map((changeSet) => (`  ${changeSet.id} [${changeSet.projectId}]: ${changeSet.baseCommit.slice(0, 12)}..${changeSet.headCommit.slice(0, 12)} (${changeSet.changedPaths.length} paths; WorkItem ${changeSet.workItemId})`))),
+        "",
+        `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(", ")}`))),
+        "",
         ...recentSection("messages", messages, (message) => [
-            `  ${message.id} [${taskMessageAuthorLabel(message.author)}] ${message.createdAt}`,
+            `  ${message.id} [${taskMessageAuthorLabel(message.author)}] ${formatTimestamp(message.createdAt, timeZone)}`,
             `    ${compactText(message.body)}`
         ]),
         "",
         `Open input requests (${displayedOpenInputRequests.length}${openInputRequests.length > displayedOpenInputRequests.length ? ` of ${openInputRequests.length}` : ""}):`,
         ...(displayedOpenInputRequests.length === 0
             ? ["  None."]
-            : displayedOpenInputRequests.flatMap(renderOpenInputRequest)),
+            : displayedOpenInputRequests.flatMap((request) => renderOpenInputRequest(request, timeZone))),
         "",
         `Recent resolved input requests (${displayedResolvedInputRequests.length}${resolvedInputRequests.length > displayedResolvedInputRequests.length ? ` of ${resolvedInputRequests.length}` : ""}):`,
         ...(displayedResolvedInputRequests.length === 0
             ? ["  None."]
-            : displayedResolvedInputRequests.flatMap(renderResolvedInputRequest)),
+            : displayedResolvedInputRequests.flatMap((request) => renderResolvedInputRequest(request, timeZone))),
         "",
         ...recentSection("events", events, (event) => [
-            `  ${event.id} ${event.type} (${event.createdAt})`,
+            `  ${event.id} ${event.type} (${formatTimestamp(event.createdAt, timeZone)})`,
             ...(Object.keys(event.payload).length === 0
                 ? []
                 : [`    ${Object.entries(event.payload)
@@ -141,7 +272,43 @@ export function runTaskContextCommand(args, store) {
         data
     };
 }
-function renderResolvedInputRequest(request) {
+function latestStallKind(events, runId) {
+    const event = [...events]
+        .filter((candidate) => candidate.type === "run.stalled" && candidate.payload.runId === runId)
+        .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
+    return event?.payload.kind ?? "execution-stalled";
+}
+function renderWorkItemReviews(rounds) {
+    const latest = rounds.at(-1);
+    if (latest === undefined)
+        return ["    ReviewRounds: none."];
+    return [
+        `    ReviewRounds: ${rounds.length}; latest ${latest.id} [${latest.status}] ${latest.scope === "task" ? "Task-final" : "WorkItem"} for ${latest.candidateId} via ${latest.reviewerRoleName} (${latest.requestedBy})`,
+        `      Review base: ${latest.reviewBaseCommit}`,
+        ...(latest.scope === "task"
+            ? [
+                `      Frozen integrated Task heads: ${latest.taskCandidate?.projects
+                    .map(({ projectId, commit }) => `${projectId}@${commit}`).join(", ") ?? "unavailable"}`,
+                `      Task-final contract: ${latest.taskFinalReviewContract?.digest ?? "global policy"}`
+            ]
+            : []),
+        `      Review workspace: ${latest.workspace === undefined
+            ? "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
+            ? []
+            : [`      Review summary: ${compactText(latest.summary)}`]),
+        ...(latest.executionGroup === undefined
+            ? []
+            : renderExecutionGroup(latest.executionGroup).map((line) => `    ${line.trimStart()}`))
+    ];
+}
+function renderResolvedInputRequest(request, timeZone) {
     if (request.status === "open")
         return [];
     return [
@@ -150,15 +317,15 @@ function renderResolvedInputRequest(request) {
         ...(request.status === "answered"
             ? [
                 `    Answer: ${compactText(request.resolution.answer.text)}`,
-                `    Answered by ${request.resolution.answeredBy} at ${request.resolution.answeredAt}`
+                `    Answered by ${request.resolution.answeredBy} at ${formatTimestamp(request.resolution.answeredAt, timeZone)}`
             ]
             : [
                 `    Cancelled: ${compactText(request.cancellation.reason)}`,
-                `    Cancelled at: ${request.cancellation.cancelledAt}`
+                `    Cancelled at: ${formatTimestamp(request.cancellation.cancelledAt, timeZone)}`
             ])
     ];
 }
-function renderOpenInputRequest(request) {
+function renderOpenInputRequest(request, timeZone) {
     const choices = request.choices.slice(0, RELATED_RECORD_LIMIT);
     const blockedRefs = request.blockedRefs.slice(0, RELATED_RECORD_LIMIT);
     const recommendedChoiceKey = request.policy.kind === "recommended"
@@ -179,7 +346,7 @@ function renderOpenInputRequest(request) {
         ...(request.policy.kind === "recommended"
             ? [
                 `    Recommended choice: ${request.policy.recommendedChoiceKey}: ${compactText(recommendedChoice?.label ?? request.policy.recommendedChoiceKey)}`,
-                `    Timeout at: ${request.policy.timeoutAt}`
+                `    Timeout at: ${formatTimestamp(request.policy.timeoutAt, timeZone)}`
             ]
             : []),
         ...(request.blockedRefs.length === 0
@@ -207,9 +374,56 @@ function currentAndRecentWorkItems(records) {
     const selected = new Set([...current, ...recentTerminal]);
     return records.filter((record) => selected.has(record));
 }
+function chronological(records) {
+    return [...records].sort((left, right) => (Date.parse(left.createdAt) - Date.parse(right.createdAt)
+        || left.id.localeCompare(right.id)));
+}
 function compactText(value) {
     const oneLine = value.replace(/\s+/g, " ").trim();
     return oneLine.length <= SUMMARY_TEXT_LIMIT
         ? oneLine
         : `${oneLine.slice(0, SUMMARY_TEXT_LIMIT - 3)}...`;
 }
+function managedWorkspaceLabel(workspace) {
+    switch (workspace.owner.type) {
+        case "task":
+            return "task";
+        case "work-item":
+            return `work-item ${workspace.owner.workItemId}`;
+        case "review-round":
+            return `review-round ${workspace.owner.reviewRoundId}`;
+        case "integration-attempt":
+            return `integration-attempt ${workspace.owner.integrationAttemptId}`;
+        case "execution-lane":
+            return `execution-lane ${workspace.owner.executionGroupId}/${workspace.owner.executionLaneId}`;
+    }
+}
+function renderExecutionGroup(group) {
+    const summary = summarizeExecutionGroup(group);
+    return [
+        `    Execution Group ${summary.groupId} [${summary.purpose}/${summary.strategy.mode}]: ${summary.activeLaneCount} active / ${summary.terminalLaneCount} terminal; ${summary.failedLaneCount} failed`,
+        ...summary.laneSummaries.flatMap((lane) => [
+            `      Lane ${lane.laneId} (#${lane.ordinal}, ${lane.roleName}) [${lane.status}]${lane.summary === undefined ? "" : `: ${compactText(lane.summary)}`}`,
+            ...(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
+            ? []
+            : [`      Resolution: ${summary.resolution.decision} — ${compactText(summary.resolution.summary)}`])
+    ];
+}