@zq-silk/yui 0.14.0 → 0.14.2

package/dist/commands/taskIntegrationCommands.js

@@ -5,10 +5,10 @@ import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration, updateIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
+import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { runTaskIntegrationQueueCommand } from "./taskIntegrationQueueCommands.js";
 import { taskLocalActor } from "./taskActor.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
-import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
 export async function runTaskIntegrationCommand(args, store, home, options = {}) {
     const now = options.now ?? (() => new Date());
     const [command, ...rest] = args;
@@ -44,7 +44,7 @@ async function cleanupIntegration(args, store, home, environment) {
         throw usageError("Task Integration cleanup usage: yui task integration cleanup <task>/<integration>.");
     }
     const integration = requireIntegration(store, args[0], environment);
-    taskLocalActor(store, environment, integration.taskId, home);
+    taskLocalActor(store, environment, integration.taskId);
     if (integration.status !== "committed"
         && integration.status !== "superseded"
         && integration.status !== "failed") {
@@ -75,51 +75,51 @@ async function cleanupIntegration(args, store, home, environment) {
     };
 }
 async function start(args, store, home, now, options) {
-    const usage = "Task Integration start usage: yui task integration start <task> [--project <project>] --change-set <id> [--change-set <id> ...] [--target <ref>] [--check <command> ...].";
-    const parsed = parseRepeatable(args, new Set(["--change-set", "--check"]), new Set(["--project", "--target"]), usage);
+    const usage = "Task Integration start usage: yui task integration start <task> --work-item <id> --strategy <ff|cherry-pick|merge|manual> [--project <project>] [--target <ref>] [--check <command> ...].";
+    const parsed = parseRepeatable(args, new Set(["--check"]), new Set(["--work-item", "--strategy", "--project", "--target"]), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
-    const task = store.getTask(parsed.positionals[0]);
+    let task = store.getTask(parsed.positionals[0]);
     if (task === null)
         throw usageError(`Task not found: ${parsed.positionals[0]}.`);
     if (task.status !== "active") {
         throw usageError(`Task is not active: ${task.id}/${task.status}.`);
     }
-    taskLocalActor(store, options.environment, task.id, home);
-    const changeSetIds = parsed.many.get("--change-set") ?? [];
-    if (changeSetIds.length === 0)
-        throw usageError("--change-set is required.", usage);
-    const changeSets = changeSetIds.map((id) => {
-        const changeSet = store.getChangeSet(task.id, id);
-        if (changeSet === null)
-            throw usageError(`ChangeSet not found: ${id}.`);
-        return changeSet;
-    });
-    // Only diagnostic evidence commits (a reviewer's own commit on top of the
-    // frozen base) are barred from becoming an Integration source.  A clean
-    // review attests the frozen base itself (evidenceCommit === reviewBaseCommit),
-    // which is the candidate's own head and a legitimate source.
-    const diagnosticEvidence = new Set(store.listReviewRounds(task.id)
-        .flatMap(({ evidenceCommit, reviewBaseCommit }) => evidenceCommit !== undefined && evidenceCommit !== reviewBaseCommit
-        ? [evidenceCommit]
-        : []));
-    const reviewSource = changeSets.find(({ headCommit }) => diagnosticEvidence.has(headCommit));
-    if (reviewSource !== undefined) {
-        throw usageError(`ReviewRound evidence commit cannot become an Integration source: ${reviewSource.id}.`);
+    taskLocalActor(store, options.environment, task.id);
+    await new FileTaskWorkspacePreparer(home, store, undefined, now)
+        .prepareTaskWorkspace(task.id);
+    task = store.getTask(task.id);
+    if (task === null || task.status !== "active") {
+        throw usageError(`Task is no longer active: ${parsed.positionals[0]}.`);
+    }
+    const workItemId = parsed.one.get("--work-item");
+    const strategy = parsed.one.get("--strategy");
+    if (workItemId === undefined || strategy === undefined
+        || !["ff", "cherry-pick", "merge", "manual"].includes(strategy)) {
+        throw usageError(usage);
     }
-    const projectIds = [...new Set(changeSets.map(({ projectId }) => projectId))];
-    if (projectIds.length !== 1) {
-        throw usageError("An Integration may only contain ChangeSets from one Project.");
+    const workItem = store.getWorkItem(task.id, workItemId);
+    if (workItem === null)
+        throw usageError(`WorkItem not found: ${workItemId}.`);
+    const candidate = workItem.candidates.at(-1);
+    if (candidate?.gitSnapshot === undefined || candidate.workspace === undefined) {
+        throw usageError(`WorkItem has no committed result snapshot: ${workItem.id}.`);
     }
+    const projectIds = candidate.workspace.entries
+        .filter(({ access }) => access === "write")
+        .map(({ projectId }) => projectId);
     const requestedProject = parsed.one.get("--project");
+    if (requestedProject === undefined && projectIds.length !== 1) {
+        throw usageError("Select --project when a WorkItem result contains multiple Projects.");
+    }
     const project = requestedProject === undefined
         ? store.getProject(projectIds[0])
         : resolveProject(store.listProjects(), requestedProject);
     if (project === null)
         throw usageError(`Project not found: ${requestedProject ?? projectIds[0]}.`);
     assertProjectActive(project, "start an Integration");
-    if (project.id !== projectIds[0]) {
-        throw usageError(`ChangeSets belong to another Project: ${projectIds[0]}.`);
+    if (!projectIds.includes(project.id)) {
+        throw usageError(`WorkItem result does not contain Project: ${project.id}.`);
     }
     if (!task.projectBindings.some(({ projectId }) => projectId === project.id)) {
         throw usageError(`Project does not belong to Task: ${project.id}.`);
@@ -132,35 +132,33 @@ async function start(args, store, home, now, options) {
     if (targetRef === undefined) {
         throw usageError(`Task main worktree is not ready; reconcile the Task first: ${task.id}.`);
     }
-    const expectedHead = (await new NodeGitWorkspace().inspect(project.path, targetRef)).baseCommit;
-    // The duplicate/budget preflight runs inside the same transaction as the
-    // attempt insert: on the single-writer SQLite backend the check and the
-    // record creation are atomic, so a concurrent Leader cannot sneak a
-    // duplicate Integration between the guard and the write.
+    const expectedHead = (await new NodeGitWorkspace().inspect(mainEntry.path, targetRef)).baseCommit;
+    const snapshotEntry = candidate.workspace.entries.find(({ projectId }) => projectId === project.id);
+    const resultCommit = candidate.gitSnapshot.projects.find(({ projectId }) => projectId === project.id)?.commit;
+    if (snapshotEntry === undefined || resultCommit === undefined) {
+        throw usageError(`WorkItem result Project snapshot is incomplete: ${workItem.id}/${project.id}.`);
+    }
     const integration = store.transaction((tx) => {
-        taskLocalActor(tx, options.environment, task.id, home);
-        const guard = runDeliveryGuardPreflight(tx, task.id, {
-            kind: "integration-start",
-            projectId: project.id,
-            changeSetIds
-        }, { environment: options.environment, budget: true });
+        taskLocalActor(tx, options.environment, task.id);
         const created = createIntegrationAttempt({
             id: tx.nextIntegrationAttemptId(task.id),
             taskId: task.id,
             projectId: project.id,
             targetRef,
-            expectedHead,
-            changeSetIds,
+            beforeCommit: expectedHead,
+            source: {
+                kind: "work-item",
+                workItemId: workItem.id,
+                startCommit: snapshotEntry.baseCommit,
+                resultCommit,
+                strategy
+            },
             checkCommands: parsed.many.get("--check") ?? []
         }, now());
         tx.saveIntegrationAttempt(task.id, created);
-        return { attempt: created, guard };
+        return created;
     });
-    const result = await runIntegration(store, home, integration.attempt, now, options);
-    return {
-        ...result,
-        output: withGuardWarnings(integration.guard, result.output)
-    };
+    return runIntegration(store, home, integration, now, options);
 }
 async function continueIntegration(args, store, home, now, options) {
     const usage = "Task Integration continue usage: yui task integration continue <task>/<integration>.";
@@ -169,7 +167,7 @@ async function continueIntegration(args, store, home, now, options) {
         throw usageError(usage);
     const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
-    taskLocalActor(store, options.environment, integration.taskId, home);
+    taskLocalActor(store, options.environment, integration.taskId);
     if (integration.status !== "validating"
         && integration.status !== "running"
         && (integration.status !== "blocked"
@@ -181,7 +179,7 @@ async function continueIntegration(args, store, home, now, options) {
 async function runIntegration(store, home, integration, now, options) {
     const result = await new GitIntegrationService(home, store, undefined, now, options.environment, undefined, options.jobPort).integrate(integration.taskId, integration.id);
     const output = result.status === "committed"
-        ? `Integrated ${result.attempt.changeSetIds.join(", ")} into ${result.attempt.targetRef} with CAS (${result.attempt.id})\n`
+        ? `Integrated ${integrationSourceLabel(result.attempt)} into ${result.attempt.targetRef} with CAS (${result.attempt.id})\n`
         : result.status === "blocked"
             ? `Integration ${result.attempt.id} requires a Task Agent resolution decision in ${result.workspace.path}\n`
             : result.status === "checks-running"
@@ -201,7 +199,7 @@ function resolveDecision(args, store, now, environment, home) {
     const resolved = store.transaction((tx) => {
         const integration = requireIntegration(tx, parsed.positionals[0], environment);
         const task = requireActiveIntegrationTask(tx, integration);
-        const actor = taskLocalActor(tx, environment, task.id, home);
+        const actor = taskLocalActor(tx, environment, task.id);
         const updated = recordResolutionDecision(integration, {
             action: selectedOption,
             rationale
@@ -223,7 +221,7 @@ async function abortIntegration(args, store, now, options, home) {
         throw usageError(usage);
     const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
-    taskLocalActor(store, options.environment, integration.taskId, home);
+    taskLocalActor(store, options.environment, integration.taskId);
     if (integration.status !== "running" && integration.status !== "blocked") {
         throw usageError(`Integration cannot be aborted from ${integration.status}: ${integration.id}.`);
     }
@@ -245,7 +243,7 @@ async function abortIntegration(args, store, now, options, home) {
         if (current.status !== "running" && current.status !== "blocked") {
             throw usageError(`Integration cannot be aborted from ${current.status}: ${current.id}.`);
         }
-        taskLocalActor(tx, options.environment, current.taskId, home);
+        taskLocalActor(tx, options.environment, current.taskId);
         const aborted = updateIntegrationAttempt(current, {
             status: "failed",
             checks: [
@@ -275,7 +273,7 @@ function supersedeIntegrationCommand(args, store, now, environment, home) {
         throw usageError(usage);
     // Superseding a committed Integration rewrites delivery-baseline evidence
     // and audit history, so it remains an explicit Task-control decision.
-    taskLocalActor(store, environment, integration.taskId, home);
+    taskLocalActor(store, environment, integration.taskId);
     // A queue-backed committed Attempt cannot be superseded: the queue entry
     // would remain in its current status while its Attempt becomes "superseded",
     // leaving contradictory terminal records that never converge. This covers
@@ -295,7 +293,7 @@ function supersedeIntegrationCommand(args, store, now, environment, home) {
         if (current.status !== "committed") {
             throw usageError(`Integration cannot be superseded from ${current.status}: ${current.id}.`);
         }
-        taskLocalActor(tx, environment, current.taskId, home);
+        taskLocalActor(tx, environment, current.taskId);
         const superseded = supersedeIntegration(current, reason, now);
         tx.saveIntegrationAttempt(superseded.taskId, superseded);
         return {
@@ -326,13 +324,13 @@ function list(args, store) {
             { header: "Integration", minWidth: 11, maxWidth: 24 },
             { header: "Project", minWidth: 8, maxWidth: 20 },
             { header: "Target", minWidth: 8, maxWidth: 30 },
-            { header: "Changes", minWidth: 7, maxWidth: 10 },
+            { header: "Source", minWidth: 10, maxWidth: 28 },
             { header: "Status", minWidth: 7, maxWidth: 20 }
         ], integrations.map((entry) => [
             entry.id,
             entry.projectId,
             entry.targetRef,
-            String(entry.changeSetIds.length),
+            integrationSourceLabel(entry),
             entry.status
         ]), defaultTableWidth())}\n`;
     return { output, data: { integrations } };
@@ -347,11 +345,13 @@ function show(args, store, environment) {
             `Task: ${integration.taskId}`,
             `Project: ${integration.projectId}`,
             `Target: ${integration.targetRef}`,
-            `Expected head: ${integration.expectedHead}`,
+            `Before commit: ${integration.beforeCommit}`,
             `Candidate: ${integration.candidateCommit ?? "-"}`,
+            `After commit: ${integration.afterCommit ?? "-"}`,
             `Job: ${integration.jobId ?? "-"}`,
-            `ChangeSets: ${integration.changeSetIds.join(", ")}`,
+            `Source: ${integrationSourceLabel(integration)}`,
             `Status: ${integration.status}`,
+            `Summary: ${integration.summary ?? "-"}`,
             `Conflict: ${integration.conflict?.summary ?? "-"}`,
             `Resolution: ${integration.resolution?.action ?? "-"}`,
             ...(integration.checks === undefined
@@ -368,6 +368,14 @@ function show(args, store, environment) {
         data: { integration }
     };
 }
+function integrationSourceLabel(integration) {
+    if (integration.source.kind === "work-item") {
+        return `work-item:${integration.source.workItemId}@${integration.source.resultCommit.slice(0, 12)}`;
+    }
+    return integration.source.kind === "upstream"
+        ? `upstream:${integration.source.branch}@${integration.source.remoteCommit.slice(0, 12)}`
+        : `historical:${integration.source.changeSetIds.join(",")}`;
+}
 function requireIntegration(store, value, environment) {
     let reference;
     try {

package/dist/commands/taskIntegrationQueueCommands.js

@@ -222,5 +222,5 @@ function requireQueueEntry(store, value, environment) {
     return entry;
 }
 function requireTaskControlActor(store, environment, taskId, home) {
-    return taskLocalActor(store, environment, taskId, home);
+    return taskLocalActor(store, environment, taskId);
 }

package/dist/commands/taskNextActionCommand.js

@@ -1,18 +1,17 @@
 import { taskNotFound, usageError } from "../errors/cliError.js";
 import { projectNextAction } from "../task/nextAction.js";
 import { projectCompletionReadiness } from "../task/completionReadiness.js";
-import { extractReviewFindings, planRepairWave } from "../task/repairWave.js";
 import { projectTaskOrchestration } from "../observability/orchestrationMetrics.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectReviewDecision } from "../review/reviewDecision.js";
+import { projectTaskRemoteDeliveryFromStore, renderTaskRemoteDelivery } from "./taskRemoteDeliveryCommand.js";
 /**
  * Issue 07 (Leader convergence): read-only `yui task next-action <task>`.
  * Folds the existing durable records into exactly one protocol-level next
  * action with exact refs, preconditions, recommended command, alternatives, and
  * the judgment that remains owned by the Leader.
- * The command never mutates state; when the action is `route-review-findings`
- * it also prints the minimal repair wave for the failing Review.
+ * The command never mutates state and never interprets Agent result text.
  *
  * Issue 06: when the recommended action is `complete-task`, the output also
  * carries the full `completionReadiness` blocker list so the Leader sees every
@@ -44,7 +43,6 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
             executionGroups: execution.executionGroups
         };
         const action = projectNextAction(actionFacts);
-        const repairWave = repairWaveFor(action, actionFacts);
         // Issue 12: surface pending Knowledge promotion proposals for the Task's
         // bound Projects as a non-blocking advisory. The proposals are workflow
         // state, not completion blockers: an Operator reviews them separately.
@@ -70,6 +68,7 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
         }
         const events = reader.listEvents(taskId);
         const task = reader.getTask(taskId);
+        const remoteDelivery = projectTaskRemoteDeliveryFromStore(reader, task, currentTaskReviewCandidate);
         const operationalTurns = operationalTaskRecords(reader.listTurns(taskId), events, "turn");
         const reviewRounds = reader.listReviewRounds(taskId);
         const reviewDecision = projectReviewDecision({
@@ -88,23 +87,21 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
             workItems: reader.listWorkItems(taskId),
             changeSets: reader.listChangeSets(taskId),
             reviewRounds,
-            reviewFindings: reader.listReviewFindings(taskId),
             integrations: reader.listIntegrationAttempts(taskId),
             durableJobs: reader.listDurableJobs(taskId),
             publications: reader.listPublicationReferences(taskId),
-            decisions: reader.listDecisions(taskId),
             events,
             managedWorkspaces: reader.listManagedWorkspaces(taskId)
         });
         return {
             taskType: facts.task.type ?? null,
             action,
-            repairWave,
             completionReadiness,
             knowledgeProposals,
             reviewDecision,
             execution: nextActionExecutionView(execution),
-            orchestration
+            orchestration,
+            remoteDelivery
         };
     });
     if (asJson) {
@@ -116,28 +113,15 @@ export function runTaskNextActionCommand(args, store, currentTaskReviewCandidate
     }
     return {
         kind: "output",
-        output: renderNextAction(data.action, data.taskType, data.repairWave, data.completionReadiness, data.knowledgeProposals, data.reviewDecision, data.execution, data.orchestration.advisories),
+        output: renderNextAction(data.action, data.taskType, data.completionReadiness, data.knowledgeProposals, data.reviewDecision, data.execution, data.orchestration.advisories, data.remoteDelivery),
         data
     };
 }
-function repairWaveFor(action, facts) {
-    if (action.kind !== "route-review-findings")
-        return null;
-    const reviewRef = action.refs.find((ref) => ref.kind === "review-round");
-    if (reviewRef === undefined)
-        return null;
-    const round = facts.reviewRounds.find((candidate) => candidate.id === reviewRef.id);
-    if (round === undefined)
-        return null;
-    const findings = extractReviewFindings(round);
-    if (findings.length === 0)
-        return null;
-    return planRepairWave(round.id, findings);
-}
-function renderNextAction(action, taskType, repairWave, completionReadiness, knowledgeProposals, reviewDecision, execution, orchestrationAdvisories) {
+function renderNextAction(action, taskType, completionReadiness, knowledgeProposals, reviewDecision, execution, orchestrationAdvisories, remoteDelivery) {
     const lines = [
         `Task: ${action.taskId}`,
         `Type: ${taskType ?? "unspecified"}`,
+        renderTaskRemoteDelivery(remoteDelivery).trimEnd(),
         `Next action: ${action.kind}`,
         `Reason: ${action.reason}`,
         `Execution view: ${execution.status}; owner/action=${execution.owner}/${execution.action}; reason=${execution.reason}; ${execution.summary}`,
@@ -202,11 +186,6 @@ function renderNextAction(action, taskType, repairWave, completionReadiness, kno
                 + ` — fix before archive: ${advisory.fix}`));
         }
     }
-    if (repairWave !== null) {
-        lines.push(`Repair wave (${repairWave.openFindingCount} open finding(s), ${repairWave.groups.length} group(s)):`, ...repairWave.groups.map((group) => `  ${group.id}: findings ${group.findingIds.join(", ")}`
-            + ` — paths ${group.paths.length === 0 ? "none" : group.paths.join(", ")}`
-            + ` — ${group.reason}`));
-    }
     if (knowledgeProposals.length > 0) {
         lines.push(`Knowledge proposals (non-blocking): ${knowledgeProposals.length} pending`, ...knowledgeProposals.map((proposal) => `  ${proposal.projectId}/${proposal.proposalId}: ${proposal.title}`
             + ` — review: yui project knowledge proposals list ${proposal.projectId}`));

package/dist/commands/taskOverviewCommand.js

@@ -6,6 +6,7 @@ import { defaultTableWidth, renderTable } from "../output/table.js";
 import { projectTaskExecutionFromFacts } from "../scheduler/taskExecutionProjection.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { projectNextAction } from "../task/nextAction.js";
+import { projectTaskRemoteDeliveryFromStore } from "./taskRemoteDeliveryCommand.js";
 export function parseTaskListOptions(args) {
     const allowed = new Set(["--all", "--verbose"]);
     if (args.some((argument) => !allowed.has(argument))
@@ -37,6 +38,7 @@ export function renderTaskOverview(result, options, timeZone, width = defaultTab
         { header: "Work", minWidth: 8, maxWidth: 38 },
         { header: "Blockers", minWidth: 9, maxWidth: 42 },
         { header: "Execution", minWidth: 14, maxWidth: 34 },
+        { header: "Delivery", minWidth: 12, maxWidth: 28 },
         { header: "Next action / owner", minWidth: 16, maxWidth: 42 }
     ], result.tasks.map((task) => [
         task.id,
@@ -49,6 +51,7 @@ export function renderTaskOverview(result, options, timeZone, width = defaultTab
         workCell(task.work.counts),
         blockersCell(task.blockers),
         `${task.execution.status} / ${task.execution.owner}`,
+        deliveryCell(task.remoteDelivery),
         nextCell(task.next)
     ]), width);
     if (!options.verbose)
@@ -137,6 +140,10 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         currentTaskReviewCandidate: null,
         executionGroups: execution.executionGroups
     }));
+    const persistedCandidate = task.status === "active" || task.status === "retired"
+        ? taskRemoteDeliveryCandidate(task)
+        : null;
+    const remoteDelivery = projectTaskRemoteDeliveryFromStore(store, task, persistedCandidate);
     return {
         ...task,
         brief,
@@ -155,7 +162,8 @@ function buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy) {
         nextAction: next?.action ?? null,
         nextOwner: next?.owner ?? null,
         runtime,
-        execution
+        execution,
+        remoteDelivery
     };
 }
 function collectAttention(task, turns, events, failure) {
@@ -220,8 +228,7 @@ function collectBlockers(workItems, openInputRequests, attention) {
         }
         if (item.status !== "pending")
             continue;
-        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "completed"
-            && workById.get(dependency)?.status !== "retired"));
+        const dependencies = item.dependsOn.filter((dependency) => (workById.get(dependency)?.status !== "completed"));
         if (dependencies.length === 0)
             continue;
         blockers.push({
@@ -326,6 +333,20 @@ function blockersCell(blockers) {
 function nextCell(next) {
     return next === null ? "—" : `${next.action} / ${next.owner}`;
 }
+function deliveryCell(delivery) {
+    if (delivery.status === "none")
+        return "none";
+    return `${delivery.status} · ${delivery.mergedProjectCount}/${delivery.codeProjectCount} merged`
+        + (delivery.allMerged
+            ? ` · ${delivery.verifiedProjectCount}/${delivery.codeProjectCount} verified`
+            : "");
+}
+function taskRemoteDeliveryCandidate(task) {
+    const projects = task.projectBindings.flatMap(({ projectId, currentCommit }) => (currentCommit === undefined ? [] : [{ projectId, commit: currentCommit }]));
+    return projects.length === task.projectBindings.length
+        ? { projects }
+        : null;
+}
 function compactText(value) {
     const oneLine = value.replace(/\s+/g, " ").trim();
     return oneLine.length <= 240 ? oneLine : `${oneLine.slice(0, 237)}...`;
@@ -343,6 +364,7 @@ function renderVerboseDetails(tasks, timeZone) {
                 ? "missing"
                 : formatTimestamp(task.summaryUpdatedAt, timeZone)}`,
             `  Execution: ${task.execution.status} (${task.execution.owner}); ${task.execution.summary}`,
+            `  Remote delivery: ${deliveryCell(task.remoteDelivery)}; source=${task.remoteDelivery.source}${task.remoteDelivery.provisional ? " (provisional)" : ""}`,
             `  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}`,