@zq-silk/yui 0.15.11 → 0.15.12

package/dist/commands/taskCommands.js

@@ -1,6 +1,9 @@
+import { controlProviderRetry, providerRetryProjection, renderProviderRetry } from "../runtime/providerRetry.js";
 import { roleLaunchEventPayload, saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
 import { createHash, randomUUID } from "node:crypto";
 import { archiveDeliveryWarnings, archiveRetainedResources, renderArchiveDiagnostics, taskArchiveDiagnostics } from "../task/archiveDiagnostics.js";
+import { archiveSettlementChecks } from "../task/archivePreflight.js";
+import { CleanupInspectionError } from "../workspace/cleanupInspection.js";
 import { isDeepStrictEqual } from "node:util";
 import { createRunInput } from "../context/runInputContract.js";
 import { buildRunContextPack, buildRunContextDelta, contextSnapshotDeltaRefIds, expandRunContextRef, freezeWorkItemExecutionAssignmentContextSnapshot, freezeReviewStageContextSnapshot, freezeRunContextSnapshot } from "../context/runContextPack.js";
@@ -70,11 +73,12 @@ import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArt
 import { runTaskNextActionCommand } from "./taskNextActionCommand.js";
 import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
 import { inspectTaskRoleRuntimeStatuses, renderTaskRoleRuntimeStatus, taskRoleActiveWorkLabel, taskRoleLastRunLabel, taskRoleNativeSessionLabel, taskRoleOpenInputLabel, taskRoleTmuxLabel, withTaskRoleHostObservation, taskRoleHostDiagnostic } from "./taskRoleRuntimeStatus.js";
-import { assertNoOpenInputRequests, openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
+import { openInputRequestCount, runTaskInputCommand } from "./taskInputCommands.js";
 import { runGrantCommand } from "./grantCommands.js";
 import { runWorkflowCommand } from "./workflowCommands.js";
 import { taskLocalActor as resolveTaskLocalActor, assertTaskDeliveryAuthority, assertTaskInputControlAuthority } from "./taskActor.js";
 import { currentManagedRuntime, resolveManagedTaskReader } from "../runtime/managedCaller.js";
+import { parseTaskCatalogOptions, readTaskCatalog, renderTaskCatalog, taskCatalogScope } from "../context/taskCatalog.js";
 import { resolveMessageRecipient, messageContinuationBlocker } from "../message/messageContinuation.js";
 import { findTaskInterrupt, reserveTaskInterrupt, taskInterruptReceipt, taskInterruptWasRejected } from "../message/taskInterrupt.js";
 import { resolveTaskInputControl } from "../message/inputControlResolution.js";
@@ -311,7 +315,7 @@ export function runTaskCommand(args, store, options = {}) {
     switch (command) {
         case "create": return createTaskCommand(rest, store, options);
         case "update": return output(updateTaskCommand(rest, store, options));
-        case "list": return listTaskCommand(rest, store);
+        case "list": return listTaskCommand(rest, store, options.environment);
         case "show": return showTaskCommand(rest, store, options.actualTaskReviewCandidate ?? null);
         case "context": return runTaskContextCommand(rest, store, options.environment);
         case "next-action": return runTaskNextActionCommand(rest, store, options.actualTaskReviewCandidate ?? null);
@@ -904,10 +908,15 @@ function createTaskAggregate(store, title, metadata, now, defaultProjectIds = []
     enqueueWork(store, taskMailbox(task.id), "task-created", now, [taskRef(task.id)]);
     return { task, leader };
 }
-function listTaskCommand(args, store) {
+function listTaskCommand(args, store, environment = {}) {
+    if (args.includes("--view")) {
+        const result = readTaskCatalog(store, parseTaskCatalogOptions(args), environment);
+        return output(renderTaskCatalog(result), result);
+    }
+    const taskId = taskCatalogScope(store, environment);
     const options = parseTaskListOptions(args);
     const snapshot = store.transaction((reader) => ({
-        result: buildTaskOverview(reader, options),
+        result: buildTaskOverview(reader, options, new Date(), taskId),
         timeZone: reader.getConfig().timeZone
     }));
     const rendered = renderTaskOverview(snapshot.result, options, snapshot.timeZone, defaultTableWidth());
@@ -1267,24 +1276,9 @@ function archiveTaskCommand(args, store, options) {
                 ? assertTaskRemoteDeliveryProof(tx, task, options.archiveRemoteDeliveryProof)
                 : undefined;
         if (!request.force) {
-            assertNoOpenInputRequests(tx, task.id, "archiving the Task");
-            const unsettledWork = tx.listWorkItems(task.id).find((item) => item.status === "open");
-            if (unsettledWork !== undefined) {
-                throw usageError(`Work Item ${unsettledWork.id} must be accepted or explicitly retired before archive.`);
-            }
-            const unresolvedIntegration = tx.listIntegrationAttempts(task.id).find((integration) => (integration.status === "running"
-                || integration.status === "blocked"
-                || integration.status === "conflicted"
-                || integration.status === "validating"));
-            if (unresolvedIntegration !== undefined) {
-                throw usageError(`Task ${task.id} has an unresolved Integration Attempt: ${unresolvedIntegration.id}.`);
-            }
-            const activeArchiveJob = tx.listDurableJobs(task.id).find((job) => (job.status === "queued"
-                || job.status === "running"
-                || (job.status === "unknown-needs-attention" && job.acknowledgedAt === undefined)));
-            if (activeArchiveJob !== undefined) {
-                throw usageError(`Task ${task.id} has an active DurableJob: ${activeArchiveJob.id}/${activeArchiveJob.status}.`);
-            }
+            const checks = archiveSettlementChecks(tx, task);
+            if (checks.length > 0)
+                throw new CleanupInspectionError(checks);
             if (task.cwd !== undefined || tx.listManagedWorkspaces(task.id).length > 0) {
                 throw usageError(`Task ${task.id} still has managed worktrees; clean them before archiving.`);
             }
@@ -1512,9 +1506,9 @@ function assertTaskRetirementProof(store, task, proof) {
         throw usageError(`Task workspaces changed after retirement preflight: ${task.id}.`);
     }
 }
-export function parseTaskArchiveArguments(args) {
+export function parseTaskArchiveArguments(args, command = "archive") {
     const usage = "Task archive usage: "
-        + "yui task archive <id> (--integrated|--abandon) [--force].";
+        + `yui task ${command} <id> (--integrated|--abandon) [--force].`;
     const taskId = args[0]?.trim();
     const flags = args.slice(1);
     if (taskId === undefined
@@ -1552,14 +1546,9 @@ export function validateTaskArchiveRequest(args, store, options = {}) {
         throw usageError(`Task ${task.id} must be completed or retired before it can be archived.`);
     }
     if (task.status !== "archived" && !request.force) {
-        assertNoOpenInputRequests(store, task.id, "archiving the Task");
-        const unresolvedIntegration = store.listIntegrationAttempts(task.id).find((integration) => (integration.status === "running"
-            || integration.status === "blocked"
-            || integration.status === "conflicted"
-            || integration.status === "validating"));
-        if (unresolvedIntegration !== undefined) {
-            throw usageError(`Task ${task.id} has an unresolved Integration Attempt: ${unresolvedIntegration.id}.`);
-        }
+        const checks = archiveSettlementChecks(store, task);
+        if (checks.length > 0)
+            throw new CleanupInspectionError(checks);
     }
     return request;
 }
@@ -2387,6 +2376,38 @@ function registerInterruptThen(store, taskId, roleName, thenMessageRef, target,
 }
 function taskRoleSessionCommand(args, store, options) {
     const [command, ...rest] = args;
+    if (command === "retry") {
+        const [taskId, roleName, action = "show", ...extra] = rest;
+        if (extra.length > 0 || !["show", "cancel", "disable", "enable"].includes(action)) {
+            throw usageError("Usage: yui task role session retry <task> <role> [show|cancel|disable|enable]");
+        }
+        return store.transaction(tx => {
+            const task = requireTask(tx, taskId);
+            const role = requireRole(tx, task.id, roleName);
+            if (action !== "show")
+                taskActor(tx, options, task.id);
+            else {
+                const reader = resolveManagedTaskReader(tx, options.environment);
+                if (reader === undefined)
+                    taskActor(tx, options, task.id);
+                else if (reader.taskId !== task.id || reader.roleName !== "leader" && reader.roleName !== role.name) {
+                    throw usageError("Provider retry read is outside the caller's Task/Role.");
+                }
+            }
+            const sessions = tx.getTaskRoleSessionSet(task.id, role.name);
+            let binding = sessions?.providerBinding ?? null;
+            if (action !== "show") {
+                if (task.status === "archived" || sessions === null || binding === null)
+                    throw usageError("No writable Provider Session.");
+                binding = controlProviderRetry(binding, action, clock(options).getTime());
+                tx.saveTaskRoleSessionSet({ ...sessions, providerBinding: binding });
+                recordTaskEvent(tx, task.id, "provider.retry-control", { roleName: role.name, action }, clock(options));
+            }
+            return output(`${renderProviderRetry(binding)}\n`, {
+                roleName: role.name, retry: providerRetryProjection(binding), disabled: binding?.retryDisabled ?? false
+            });
+        });
+    }
     if (command === "inspect") {
         exactPositionals(rest, 2, "Task Role Session inspect usage: yui task role session inspect <task> <role>.");
         const task = requireTask(store, rest[0]);
@@ -2420,6 +2441,7 @@ function taskRoleSessionCommand(args, store, options) {
                 `Native id: ${active.nativeSessionId}`,
                 `Session: ${active.status}${active.endReason === undefined ? "" : `/${active.endReason}`}`,
                 `AgentRun: ${binding?.run?.status ?? "none"}`,
+                renderProviderRetry(binding),
                 ...(host === undefined ? [] : [`Host reporting: ${taskRoleHostDiagnostic(host)}`]),
                 `Run configuration: ${agentRunConfigurationLabel(runConfiguration)}`
             ].join("\n") + "\n"
@@ -2429,6 +2451,7 @@ function taskRoleSessionCommand(args, store, options) {
             role,
             session: active,
             providerBinding: binding,
+            retry: providerRetryProjection(binding),
             ...(host === undefined ? {} : { host }),
             ...(runConfiguration === undefined ? {} : { runConfiguration })
         });
@@ -4821,6 +4844,45 @@ function settleStaleFinalReviewRun(args, store, options) {
         : `Obsolete final Review already settled: ${result.round.id}/${result.run.id}\n`, { reviewRound: result.round, reviewRun: result.run });
 }
 function retryRun(args, store, options) {
+    return store.transaction(tx => {
+        const previous = requireRun(tx, args[0], options);
+        const existing = tx.listEvents(previous.taskId).find(event => event.type === "run.retried"
+            && event.payload.previousRunId === previous.id);
+        if (existing !== undefined) {
+            return output(`Retry already recorded as ${existing.payload.runId}; retry that exact successor if needed.\n`);
+        }
+        const sessions = tx.getTaskRoleSessionSet(previous.taskId, previous.roleName);
+        const retry = sessions?.providerBinding?.retry;
+        if (options.providerRetryChainId !== undefined
+            && (retry?.chainId !== options.providerRetryChainId || retry.status !== "waiting"
+                || retry.previousRunId !== previous.id || clock(options).getTime() < Date.parse(retry.nextEligibleAt)
+                || clock(options).getTime() >= Date.parse(retry.deadline))) {
+            throw usageError("Provider recovery intent is no longer eligible.");
+        }
+        const result = retryRunOperation(args, tx, options);
+        if (retry !== undefined && retry.status !== "recovered" && retry.previousRunId === previous.id && sessions?.providerBinding != null) {
+            const successor = tx.getActiveRun(previous.taskId, previous.roleName);
+            tx.saveTaskRoleSessionSet({
+                ...sessions, providerBinding: {
+                    ...sessions.providerBinding, retry: {
+                        ...retry, status: "waiting", successorAutomatic: options.providerRetryChainId !== undefined,
+                        ...(options.providerRetryChainId === undefined ? {
+                            intentAt: clock(options).toISOString(),
+                            // An explicit manual attempt does not inherit automatic jitter,
+                            // but cannot shorten a trusted server minimum.
+                            nextEligibleAt: new Date(Math.max(clock(options).getTime(), retry.error.retryAfterMs === undefined ? 0
+                                : Date.parse(sessions.providerBinding.run.updatedAt) + retry.error.retryAfterMs + 1)).toISOString()
+                        } : {}),
+                        ...(successor === null ? {} : { successorRunId: successor.id }),
+                        ...(previous.reviewRoundId === undefined ? {} : { successorReviewRoundId: previous.reviewRoundId })
+                    }
+                }
+            });
+        }
+        return result;
+    });
+}
+function retryRunOperation(args, store, options) {
     exactPositionals(args, 1, "Task turn retry usage: yui task run retry <task>/<run>.");
     const now = clock(options);
     const previous = store.transaction((tx) => requireRun(tx, args[0], options));
@@ -5380,7 +5442,7 @@ function retryFailedReviewRun(previous, store, options, now) {
         const task = requireTask(tx, run.taskId);
         if (task.status !== "active")
             throw usageError(`Task is not active: ${task.id}.`);
-        const requestedBy = taskActor(tx, options, task.id);
+        const requestedBy = options.providerRetryChainId === undefined ? taskActor(tx, options, task.id) : "policy";
         const round = tx.getReviewRound(task.id, run.reviewRoundId);
         if (round === null) {
             throw dataError(`ReviewRound not found for run ${run.id}: ${run.reviewRoundId}.`);

package/dist/commands/taskIntegrationCommands.js

@@ -64,7 +64,9 @@ async function cleanupIntegration(args, store, home, environment) {
             + `${activeIntegrationJob.id}/${activeIntegrationJob.status}. `
             + "Cancel or acknowledge it before cleanup.");
     }
-    const result = await new GitIntegrationService(home, store).cleanup(integration);
+    const result = await new GitIntegrationService(home, store).cleanup(integration, {
+        authorize: () => taskLocalActor(store, environment, integration.taskId)
+    });
     if (result === "dirty") {
         throw usageError(`Integration worktree contains unresolved or uncommitted changes: ${integration.id}. Inspect it before cleanup.`);
     }

package/dist/commands/taskOverviewCommand.js

@@ -7,6 +7,7 @@ import { projectTaskExecutionFromFacts } from "../scheduler/taskExecutionProject
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { projectNextAction } from "../task/nextAction.js";
 import { projectTaskRemoteDeliveryFromStore } from "./taskRemoteDeliveryCommand.js";
+import { formatUsageMetric } from "../runtime/taskUsageMetrics.js";
 export function parseTaskListOptions(args) {
     const allowed = new Set(["--all", "--verbose"]);
     if (args.some((argument) => !allowed.has(argument))
@@ -18,9 +19,9 @@ export function parseTaskListOptions(args) {
         verbose: args.includes("--verbose")
     };
 }
-export function buildTaskOverview(store, options, now = new Date()) {
+export function buildTaskOverview(store, options, now = new Date(), taskId) {
     const runtimeHealthPolicy = resolveRuntimeHealth(store.getConfig().runtimeHealth);
-    const tasks = store.listTasks()
+    const tasks = (taskId === undefined ? store.listTasks() : [store.getTask(taskId)].filter((task) => task !== null))
         .filter((task) => options.all || task.status !== "archived")
         .map((task) => buildTaskOverviewEntry(task, store, now, runtimeHealthPolicy));
     return { tasks };
@@ -355,7 +356,7 @@ function renderVerboseDetails(tasks, timeZone) {
             `  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}`,
+            `  Observed usage (Task lifetime, observed sources only): tokens=${formatUsageMetric(task.execution.observability.cost.tokens)}; tools=${formatUsageMetric(task.execution.observability.cost.toolCalls)}; elapsed=${formatUsageMetric(task.execution.observability.cost.elapsedSeconds, "s")}; native execution sum=${formatUsageMetric(task.execution.observability.cost.executionSeconds, "s")}; retries=${task.execution.observability.cost.retryCount}`,
             `  Context: snapshots=${task.execution.observability.context.snapshotCount}; bytes=${task.execution.observability.context.totalBytes ?? "partial"}; compression=unavailable`,
             `  Session tokens: ${task.execution.observability.sessionTokens.length === 0
                 ? "unobserved"

package/dist/commands/taskPublicationAdoptCommand.js

@@ -0,0 +1,127 @@
+import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { contextContentDigest } from "../context/contextSnapshot.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { usageError } from "../errors/cliError.js";
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { PUBLICATION_ADOPTED_EVENT, publicationAdoption } from "../task/publicationAdoption.js";
+import { publicationExternalKey } from "../task/publicationReference.js";
+import { commitMap, completionEvent } from "../task/remoteDelivery.js";
+import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
+import { assertTaskDeliveryAuthority, taskActor } from "./taskActor.js";
+import { parseRepeatable } from "./taskIntegrationCommands.js";
+/** Local read -> explicit semantic adoption of those exact bytes. No Git writes,
+ * provider reads, completion rewrite or implicit acceptance of Integration. */
+export async function runTaskPublicationAdoptCommand(args, store, options = {}) {
+    const [command, ...rest] = args;
+    const adopt = command === "adopt";
+    if (!adopt && command !== "diff")
+        throw usageError("Expected publication diff or adopt.");
+    const usage = adopt
+        ? "yui task publication adopt <task>/<publication> --reviewed-diff <sha256> --acceptance <text> [--integration <id>]"
+        : "yui task publication diff <task>/<publication> [--integration <id>]";
+    const parsed = parseRepeatable(rest, new Set(), new Set(adopt ? ["--reviewed-diff", "--acceptance", "--integration"] : ["--integration"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const ref = resolveTaskRecordReference(parsed.positionals[0], {
+        kind: "publicationReference", label: "Publication reference"
+    });
+    const acceptance = parsed.one.get("--acceptance")?.trim();
+    const reviewedDiff = parsed.one.get("--reviewed-diff");
+    if (adopt && (!acceptance || !/^[0-9a-f]{64}$/u.test(reviewedDiff ?? ""))) {
+        throw usageError(`Adoption requires a reviewed diff digest and explicit acceptance of the full delta. ${usage}`);
+    }
+    const integrationId = parsed.one.get("--integration");
+    const read = (reader) => {
+        // The reader addresses only this Task's managed Git objects. Workers and
+        // planning Sessions do not acquire publication-adoption authority.
+        const actor = adopt
+            ? assertTaskDeliveryAuthority(reader, options.environment, ref.taskId)
+            : taskActor(options.environment, ref.taskId);
+        const task = reader.getTask(ref.taskId);
+        if (task === null || task.status !== "completed") {
+            throw usageError("Publication candidate adoption/diff requires a completed, unarchived Task.");
+        }
+        const publication = reader.getPublicationReference(task.id, ref.localId);
+        if (publication === null || publication.localCommit === undefined) {
+            throw usageError("Publication must record an exact local candidate.");
+        }
+        const current = reader.findPublicationReferenceByExternalKey(publicationExternalKey(publication));
+        if (current?.taskId !== task.id || current.id !== publication.id) {
+            throw usageError("Publication is not the current record for its external identity.");
+        }
+        const completion = task.completedAt === undefined ? undefined
+            : completionEvent(reader.listEvents(task.id), task.completedAt);
+        const acceptedCommit = commitMap(completion?.payload.projectHeads).get(publication.projectId);
+        if (completion === undefined || acceptedCommit === undefined) {
+            throw usageError("Exact completion evidence is unavailable; it cannot be inferred or repaired by adoption.");
+        }
+        const workspace = reader.getTaskWorkspace(task.id);
+        const entry = workspace?.entries.find(e => e.projectId === publication.projectId);
+        if (workspace?.owner.type !== "task" || workspace.owner.taskId !== task.id
+            || entry === undefined
+            || !task.projectBindings.some(b => b.projectId === publication.projectId)) {
+            throw usageError("The Publication Project has no Task-owned workspace for local Git evidence.");
+        }
+        const integration = integrationId === undefined ? null
+            : reader.getIntegrationAttempt(task.id, integrationId);
+        if (integrationId !== undefined && (integration === null
+            || integration.status !== "committed"
+            || integration.projectId !== publication.projectId
+            || integration.afterCommit !== publication.localCommit)) {
+            throw usageError("Integration must be this Task/Project's committed exact publication candidate.");
+        }
+        return { task, publication, completion, acceptedCommit, workspace, entry, integration, actor };
+    };
+    const facts = store.transaction(read);
+    const git = options.git ?? new NodeGitWorkspace();
+    const localCommit = facts.publication.localCommit;
+    const [acceptedTree, candidateTree, diff] = await Promise.all([
+        git.resolveTree(facts.entry.path, facts.acceptedCommit),
+        git.resolveTree(facts.entry.path, localCommit),
+        git.diffTextBetween({ repositoryPath: facts.entry.path,
+            fromCommit: facts.acceptedCommit, toCommit: localCommit, exact: true })
+    ]);
+    // Bind both endpoints even when the text diff is empty (equal trees).
+    const diffDigest = createHash("sha256").update(JSON.stringify({
+        acceptedCommit: facts.acceptedCommit, localCommit, acceptedTree, candidateTree, diff
+    })).digest("hex");
+    const evidence = {
+        projectId: facts.publication.projectId,
+        publicationId: facts.publication.id,
+        completionEventId: facts.completion.id,
+        acceptedCommit: facts.acceptedCommit,
+        localCommit, acceptedTree, candidateTree, diffDigest,
+        ...(facts.integration === null ? {} : {
+            integrationId: facts.integration.id, integrationDigest: contextContentDigest(facts.integration)
+        })
+    };
+    // No async Git/provider work under the transaction; fixed objects cannot move.
+    const event = store.transaction(tx => {
+        if (!isDeepStrictEqual(read(tx), facts)) {
+            throw usageError("Task, Publication or Integration changed while reading candidate evidence.");
+        }
+        if (!adopt)
+            return null;
+        if (reviewedDiff !== diffDigest) {
+            throw usageError(`Reviewed diff does not match this candidate. Read publication diff ${ref.taskId}/${ref.localId}.`);
+        }
+        const existing = publicationAdoption(facts.publication, facts.completion, facts.acceptedCommit, tx.listEvents(facts.task.id), tx.listPublicationReferences(facts.task.id), tx.listIntegrationAttempts(facts.task.id)).event;
+        if (existing !== null && existing.payload.diffDigest === diffDigest
+            && existing.payload.acceptance === acceptance
+            && existing.payload.integrationId === integrationId)
+            return existing;
+        const saved = createTaskEvent(tx.nextEventId(facts.task.id), facts.task.id, PUBLICATION_ADOPTED_EVENT, { ...evidence, acceptance: acceptance, by: facts.actor }, options.now?.() ?? new Date());
+        tx.saveEvent(facts.task.id, saved);
+        return saved;
+    });
+    return {
+        output: event === null
+            ? `Publication candidate: ${ref.taskId}/${ref.localId}\nAccepted: ${facts.acceptedCommit}\n`
+                + `Candidate: ${localCommit}\nReviewed diff digest: ${diffDigest}\n`
+                + "Review all removals, additions and conflict resolutions against the original acceptance before adoption.\n"
+                + `${diff}\n`
+            : `Adopted Publication candidate ${ref.taskId}/${ref.localId} (${event.id}); remote verification remains separate.\n`,
+        data: event === null ? { ...evidence, diff } : event
+    };
+}

package/dist/commands/taskPublicationCommands.js

@@ -17,6 +17,7 @@ const INHERITED_METADATA_FIELDS = [
     "targetBranch"
 ];
 const INHERITED_EVIDENCE_FIELDS = [
+    "headCommit",
     "remoteCommit",
     "evidence",
     "mergedAt"
@@ -34,7 +35,7 @@ export function runPublicationCommand(args, store, options) {
     }
 }
 function upsertPublication(args, store, options) {
-    const usage = "Task publication upsert usage: yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported|--verified] [--evidence <text>] [--merged-at <iso-timestamp>].";
+    const usage = "Task publication upsert usage: yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--head-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported|--verified] [--evidence <text>] [--merged-at <iso-timestamp>].";
     const parsed = parseUpsertArgs(args, usage);
     exactPositionals(parsed.positionals, 1, usage);
     const task = requireTask(store, parsed.positionals[0]);
@@ -72,6 +73,9 @@ function upsertPublication(args, store, options) {
         ...(parsed.options.has("--remote-commit")
             ? { remoteCommit: requiredOption(parsed.options, "--remote-commit", usage) }
             : {}),
+        ...(parsed.options.has("--head-commit")
+            ? { headCommit: requiredOption(parsed.options, "--head-commit", usage) }
+            : {}),
         ...(state === undefined ? {} : { state }),
         ...(verification === undefined ? {} : { verification }),
         ...(parsed.options.has("--evidence")
@@ -181,6 +185,7 @@ function renderPublication(reference, timeZone) {
             : [`Branches: ${reference.sourceBranch ?? "unknown"} -> ${reference.targetBranch ?? "unknown"}`]),
         `State: ${reference.state}`,
         `Verification: ${reference.verification}`,
+        ...(reference.headCommit === undefined ? [] : [`Remote head: ${reference.headCommit}`]),
         `Lineage: ${reference.localCommit ?? "unknown"} -> ${reference.externalId} -> ${reference.remoteCommit ?? "unknown"}`,
         ...(reference.mergedAt === undefined
             ? []
@@ -234,6 +239,10 @@ function inheritPublicationInput(existing, input) {
     const mergedAtChanged = input.mergedAt !== undefined
         && input.mergedAt !== existing.mergedAt;
     const evidenceContextChanged = localCommitChanged
+        || (input.headCommit !== undefined
+            && normalizeCommitForComparison(input.headCommit) !== existing.headCommit)
+        || input.projectId !== existing.projectId
+        || input.externalKind !== existing.externalKind
         || stateChanged
         || remoteCommitChanged
         || evidenceChanged
@@ -321,7 +330,7 @@ function parseUpsertArgs(args, usage) {
     const valueOptions = new Set([
         "--project", "--provider", "--repository", "--kind", "--id", "--url",
         "--title", "--source-branch", "--target-branch", "--local-commit",
-        "--remote-commit", "--state", "--evidence", "--merged-at"
+        "--remote-commit", "--head-commit", "--state", "--evidence", "--merged-at"
     ]);
     const flags = new Set(["--reported", "--verified"]);
     const positionals = [];

package/dist/commands/taskPublicationVerifyCommand.js

@@ -1,7 +1,6 @@
 import { isDeepStrictEqual } from "node:util";
 import { taskActor } from "./taskActor.js";
 import { upsertTaskPublication } from "./taskPublicationCommands.js";
-import { projectTaskRemoteDeliveryFromStore } from "./taskRemoteDeliveryCommand.js";
 import { dataError, runtimeError, taskNotFound, usageError, CliError } from "../errors/cliError.js";
 import { publicationExternalKey } from "../task/publicationReference.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
@@ -14,8 +13,7 @@ export async function runTaskPublicationVerifyCommand(args, store, options) {
         throw usageError(`Archived Task Publication cannot be verified: ${task.id}.`);
     }
     taskActor(options.environment, task.id);
-    const initialCandidate = await options.candidateForTask?.(reference.taskId) ?? null;
-    const request = preparePublicationVerification(store, reference.taskId, reference.localId, initialCandidate, options.environment);
+    const request = preparePublicationVerification(store, reference.taskId, reference.localId, options.environment);
     const verifier = options.verifiers[request.publication.provider];
     if (verifier === undefined) {
         throw usageError(`Publication verification is not supported for provider `
@@ -42,19 +40,22 @@ export async function runTaskPublicationVerifyCommand(args, store, options) {
             + `${error instanceof Error ? error.message : String(error)}`);
     }
     assertVerificationObservation(request, observation);
-    const finalCandidate = await options.candidateForTask?.(reference.taskId) ?? null;
-    const result = commitPublicationVerification(store, request, observation, finalCandidate, options.now?.() ?? new Date());
+    const result = commitPublicationVerification(store, request, observation, options.now?.() ?? new Date());
     return {
         kind: "output",
-        output: result.idempotent
-            ? `Publication ${result.reference.id} is already verified for `
-                + `${result.reference.repository}#${result.reference.externalId}.\n`
-            : `Verified publication ${result.reference.id} for `
-                + `${result.reference.repository}#${result.reference.externalId}.\n`,
+        output: result.reference.verification !== "verified"
+            ? `Recorded Publication ${result.reference.id}: remote state=${observation.state}; `
+                + `head=${observation.headCommit}; local=${request.expectedLocalCommit}. `
+                + "Not verified; prior verification is no longer current.\n"
+            : result.idempotent
+                ? `Publication ${result.reference.id} is already verified for `
+                    + `${result.reference.repository}#${result.reference.externalId}.\n`
+                : `Verified publication ${result.reference.id} for `
+                    + `${result.reference.repository}#${result.reference.externalId}.\n`,
         data: { publication: result.reference, observation }
     };
 }
-function preparePublicationVerification(store, taskId, publicationId, currentCandidate, environment) {
+function preparePublicationVerification(store, taskId, publicationId, environment) {
     return store.transaction((reader) => {
         const task = reader.getTask(taskId);
         if (task === null)
@@ -72,27 +73,19 @@ function preparePublicationVerification(store, taskId, publicationId, currentCan
             throw usageError(`Publication ${publication.id} is not the current unsuperseded record `
                 + `for ${publicationExternalKey(publication)}.`);
         }
-        const delivery = projectTaskRemoteDeliveryFromStore(reader, task, currentCandidate);
-        const project = delivery.projects.find(({ projectId }) => (projectId === publication.projectId));
+        const project = task.projectBindings.find(({ projectId }) => (projectId === publication.projectId));
         if (project === undefined) {
             throw usageError(`Publication ${publication.id} Project is not bound to Task ${task.id}: `
                 + `${publication.projectId}.`);
         }
-        if (project.expectedLocalCommit === null) {
-            throw usageError(`Task delivery head is unavailable for Publication ${publication.id}.`);
-        }
         if (publication.localCommit === undefined) {
             throw usageError(`Publication ${publication.id} must record a local commit before verification.`);
         }
-        if (publication.localCommit !== project.expectedLocalCommit) {
-            throw usageError(`Publication ${publication.id} local commit ${publication.localCommit} `
-                + `does not match Task delivery head ${project.expectedLocalCommit}.`);
-        }
         return {
             task: taskVerificationInvariant(task),
             actor,
             publication,
-            expectedLocalCommit: project.expectedLocalCommit
+            expectedLocalCommit: publication.localCommit
         };
     });
 }
@@ -104,22 +97,17 @@ function assertVerificationObservation(request, observation) {
         || observation.externalId !== publication.externalId) {
         throw usageError(`Provider returned mismatched Publication identity for ${publication.id}.`);
     }
-    if (observation.state !== "merged") {
-        throw usageError(`Remote ${publication.externalKind} ${publication.repository}#`
-            + `${publication.externalId} is ${observation.state}, not merged.`);
+    if (!/^[0-9a-f]{40}$/u.test(observation.headCommit)) {
+        throw usageError("Provider observation requires an exact remote head.");
     }
-    if (observation.headCommit !== request.expectedLocalCommit) {
-        throw usageError(`Remote ${publication.externalKind} head ${observation.headCommit} `
-            + `does not match Task delivery head ${request.expectedLocalCommit}.`);
-    }
-    if (observation.remoteCommit === undefined) {
+    if (observation.state === "merged" && observation.remoteCommit === undefined) {
         throw usageError(`Merged remote ${publication.externalKind} did not expose a remote commit.`);
     }
     if (observation.evidence.trim().length === 0) {
         throw usageError("Provider verification evidence is required.");
     }
 }
-function commitPublicationVerification(store, request, observation, currentCandidate, now) {
+function commitPublicationVerification(store, request, observation, now) {
     return store.transaction((tx) => {
         const task = tx.getTask(request.task.id);
         if (task === null)
@@ -134,12 +122,6 @@ function commitPublicationVerification(store, request, observation, currentCandi
             throw usageError(`Publication evidence changed during verification: `
                 + `${task.id}/${request.publication.id}.`);
         }
-        const delivery = projectTaskRemoteDeliveryFromStore(tx, task, currentCandidate);
-        const expectedLocalCommit = delivery.projects.find(({ projectId }) => (projectId === request.publication.projectId))?.expectedLocalCommit;
-        if (expectedLocalCommit !== request.expectedLocalCommit) {
-            throw usageError(`Task delivery head changed during Publication verification: `
-                + `${request.publication.projectId}@${expectedLocalCommit ?? "unavailable"}.`);
-        }
         return upsertTaskPublication(tx, task, {
             projectId: request.publication.projectId,
             provider: request.publication.provider,
@@ -150,9 +132,11 @@ function commitPublicationVerification(store, request, observation, currentCandi
                 ? {}
                 : { externalUrl: observation.externalUrl }),
             localCommit: request.expectedLocalCommit,
-            remoteCommit: observation.remoteCommit,
-            state: "merged",
-            verification: "verified",
+            headCommit: observation.headCommit,
+            ...(observation.remoteCommit === undefined ? {} : { remoteCommit: observation.remoteCommit }),
+            state: observation.state,
+            verification: observation.state === "merged"
+                && observation.headCommit === request.expectedLocalCommit ? "verified" : "reported",
             evidence: observation.evidence,
             ...(observation.mergedAt === undefined
                 ? {}