@zq-silk/yui 0.15.9 → 0.15.12

package/dist/commands/taskIntegrationCommands.js

@@ -3,7 +3,7 @@ import { assertProjectActive, resolveProject } from "../repository/project.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
 import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
-import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration, updateIntegrationAttempt } from "../integration/integrationAttempt.js";
+import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration } from "../integration/integrationAttempt.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { runTaskIntegrationQueueCommand } from "./taskIntegrationQueueCommands.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.`);
     }
@@ -171,6 +173,7 @@ async function continueIntegration(args, store, home, now, options) {
     taskLocalActor(store, options.environment, integration.taskId);
     if (integration.status !== "validating"
         && integration.status !== "running"
+        && integration.status !== "conflicted"
         && (integration.status !== "blocked"
             || integration.resolution?.action !== "manual-resolution")) {
         throw usageError(`Integration is not ready to continue: ${integration.id}/${integration.status}.`);
@@ -181,11 +184,13 @@ 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 ${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"
-                ? `Integration ${result.attempt.id} checks are running as DurableJob ${result.job.id}; run 'yui task integration continue ${result.attempt.taskId}/${result.attempt.id}' when the job finishes\n`
-                : `Integration ${result.attempt.id} failed; target ref was not advanced\n`;
+        : result.status === "conflicted"
+            ? `Integration ${result.attempt.id} is conflicted in ${result.workspace.path}; resolve files, then run 'yui task integration continue ${result.attempt.taskId}/${result.attempt.id}' (no prior resolve required)\n`
+            : result.status === "blocked"
+                ? `Integration ${result.attempt.id} needs Leader attention in ${result.workspace.path}: ${result.attempt.summary ?? result.attempt.conflict?.summary ?? "Inspect the current attempt"}\n`
+                : result.status === "checks-running"
+                    ? `Integration ${result.attempt.id} checks are running as DurableJob ${result.job.id}; run 'yui task integration continue ${result.attempt.taskId}/${result.attempt.id}' when the job finishes\n`
+                    : `Integration ${result.attempt.id} failed; inspect its target and preserved evidence\n`;
     return { output, data: result };
 }
 function resolveDecision(args, store, now, environment, home) {
@@ -223,41 +228,16 @@ async function abortIntegration(args, store, now, options, home) {
     const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
     taskLocalActor(store, options.environment, integration.taskId);
-    if (integration.status !== "running" && integration.status !== "blocked") {
-        throw usageError(`Integration cannot be aborted from ${integration.status}: ${integration.id}.`);
-    }
     const reason = parsed.one.get("--reason");
     if (reason === undefined)
         throw usageError(usage);
-    if (integration.jobId !== undefined && options.jobPort !== undefined) {
-        await options.jobPort.cancelJob(integration.taskId, integration.jobId);
-    }
-    return store.transaction((tx) => {
-        // Re-read inside the transaction: a concurrent `continue` can advance the
-        // Attempt to validating (and then commit the target) after the initial
-        // read.  Aborting a validating or committed Attempt would leave the
-        // target advanced while the Attempt is failed.
-        const current = tx.getIntegrationAttempt(integration.taskId, integration.id);
-        if (current === null) {
-            throw usageError(`Integration Attempt not found: ${integration.taskId}/${integration.id}.`);
-        }
-        if (current.status !== "running" && current.status !== "blocked") {
-            throw usageError(`Integration cannot be aborted from ${current.status}: ${current.id}.`);
-        }
-        taskLocalActor(tx, options.environment, current.taskId);
-        const aborted = updateIntegrationAttempt(current, {
-            status: "failed",
-            checks: [
-                ...(current.checks ?? []),
-                { name: "aborted", outcome: "failed", details: reason }
-            ]
-        }, now);
-        tx.saveIntegrationAttempt(aborted.taskId, aborted);
-        return {
-            output: `Aborted Integration ${aborted.id}; start a new Integration Attempt to retry\n`,
-            data: { integration: aborted }
-        };
-    });
+    const settled = await new GitIntegrationService(home, store, undefined, () => now, options.environment, undefined, options.jobPort).abort(integration.taskId, integration.id, reason, (tx, taskId) => taskLocalActor(tx, options.environment, taskId));
+    return {
+        output: settled.status === "committed"
+            ? `Integration ${settled.id} had already advanced its target; recorded committed, not aborted.\n`
+            : `Aborted Integration ${settled.id}; candidate, workspace and history are preserved. This is not Git abort or proof of Job quiescence. Choose an authorized replacement delivery path.\n`,
+        data: { integration: settled }
+    };
 }
 function supersedeIntegrationCommand(args, store, now, environment, home) {
     const usage = "Task Integration supersede usage: yui task integration supersede <task>/<integration> --reason <text>.";

package/dist/commands/taskIntegrationQueueCommands.js

@@ -138,7 +138,7 @@ async function process(args, store, home, options) {
         if (result.status === "committed") {
             return `${entry.id} committed ${entry.changeSetId} -> ${entry.targetAfter ?? "-"}`;
         }
-        if (result.status === "blocked") {
+        if (result.status === "blocked" || result.status === "conflicted") {
             return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "blocked"}`;
         }
         return `${entry.id} conflicted ${entry.changeSetId}: ${entry.conflictSummary ?? "gate failure"}`;

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
                 ? {}

package/dist/commands/taskRemoteDeliveryCommand.js

@@ -30,6 +30,7 @@ export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate
         publications: store.listPublicationReferences(task.id),
         managedWorkspaces: store.listManagedWorkspaces(task.id),
         runs: store.listRuns(task.id),
+        integrations: store.listIntegrationAttempts(task.id),
         currentCandidate
     });
 }
@@ -41,6 +42,7 @@ export function createTaskRemoteDeliveryProof(store, task, currentCandidate = nu
         publications,
         managedWorkspaces: store.listManagedWorkspaces(task.id),
         runs: store.listRuns(task.id),
+        integrations: store.listIntegrationAttempts(task.id),
         currentCandidate
     });
     return {
@@ -50,7 +52,7 @@ export function createTaskRemoteDeliveryProof(store, task, currentCandidate = nu
         delivery
     };
 }
-export function assertTaskRemoteDeliveryProof(store, task, proof, options = {}) {
+export function assertTaskRemoteDeliveryProof(store, task, proof) {
     if (proof === undefined || proof.schemaVersion !== 1) {
         throw usageError(`Task remote-delivery preflight proof is required: ${task.id}.`);
     }
@@ -60,26 +62,34 @@ export function assertTaskRemoteDeliveryProof(store, task, proof, options = {})
     if (!isDeepStrictEqual(proof.publications, store.listPublicationReferences(task.id))) {
         throw usageError(`Task Publication evidence changed after remote-delivery preflight: ${task.id}.`);
     }
-    assertTaskRemoteDeliveryIntegrated(proof.delivery, options);
+    // Recheck semantic adoption/Integration facts as well as Publication versions.
+    // For provisional cancelled Tasks retain the frozen candidate used at preflight.
+    const current = projectTaskRemoteDeliveryFromStore(store, task, {
+        projects: proof.delivery.projects.flatMap(p => p.expectedLocalCommit === null
+            ? [] : [{ projectId: p.projectId, commit: p.expectedLocalCommit }])
+    });
+    if (!isDeepStrictEqual(current, proof.delivery)) {
+        throw usageError(`Task delivery evidence changed after remote-delivery preflight: ${task.id}.`);
+    }
+    assertTaskRemoteDeliveryIntegrated(proof.delivery);
     return proof.delivery;
 }
-export function assertTaskRemoteDeliveryIntegrated(delivery, options = {}) {
+export function assertTaskRemoteDeliveryIntegrated(delivery) {
     if (!delivery.allMerged) {
         const headUnavailable = delivery.projects.filter((project) => (project.codeDelivery !== "none"
             && project.coverage === "head-unavailable"));
         if (headUnavailable.length > 0 && delivery.source === "task-completed") {
-            throw usageError(`Task ${delivery.taskId} has no frozen completion heads for: ${headUnavailable.map(({ projectId }) => projectId).join(", ")}. Reopen and complete it again to record exact heads before archiving; `
-                + "--force cannot override missing head evidence.");
+            throw usageError(`Task ${delivery.taskId} has no frozen completion heads for: ${headUnavailable.map(({ projectId }) => projectId).join(", ")}. Historical acceptance cannot be inferred from a merge or archive.`);
         }
         const uncovered = delivery.projects
             .filter((project) => project.codeDelivery !== "none" && !project.merged)
             .map((project) => (`${project.projectId}/${project.coverage}`
             + (project.publication === null ? "" : `/${project.publication.id}`)))
             .join(", ");
-        throw usageError(`Task ${delivery.taskId} is not fully merged into remote delivery: ${uncovered || "expected Project heads are unavailable"}. Record confirmed current-head evidence with task publication upsert, `
-            + "or use task archive --abandon for an intentional non-merge.");
+        throw usageError(`Task ${delivery.taskId} is not fully merged into remote delivery: ${uncovered || "expected Project heads are unavailable"}. Inspect each Project reason with task remote-delivery. Record confirmed Publication facts; `
+            + "for a changed post-completion candidate, review publication diff and explicitly adopt its acceptance.");
     }
-    if (delivery.allVerified || options.forceUnverified === true)
+    if (delivery.allVerified)
         return;
     const unverified = delivery.projects
         .filter((project) => (project.codeDelivery !== "none"
@@ -90,8 +100,7 @@ export function assertTaskRemoteDeliveryIntegrated(delivery, options = {}) {
         .join(", ");
     throw usageError(`Task ${delivery.taskId} has merged Publication evidence that is not verified: `
         + `${unverified || "verification evidence is unavailable"}. Run task publication verify `
-        + "for each Publication, or repeat task archive --integrated --force to explicitly "
-        + "override verification. --force never overrides missing, stale, open, or closed merge evidence.");
+        + "for each Publication only when the provider read is authorized.");
 }
 export function renderTaskRemoteDelivery(delivery, indent = "") {
     const source = `${delivery.source}${delivery.provisional ? " (provisional)" : ""}`;
@@ -108,12 +117,14 @@ export function renderTaskRemoteDelivery(delivery, indent = "") {
         `${indent}Projects:${delivery.projects.length === 0 ? " none" : ""}`,
         ...delivery.projects.map((project) => (`${indent}- ${project.directory} (${project.projectId}): `
             + `expected=${shortCommit(project.expectedLocalCommit)}; `
+            + `candidate=${shortCommit(project.deliveryLocalCommit)}; `
+            + `adoption=${project.adoption?.id ?? "none"}; `
             + `base=${shortCommit(project.baseCommit)}; `
             + `publication=${project.publication?.id ?? "none"}; `
             + `state=${project.state ?? "none"}; `
             + `verification=${project.verification ?? "none"}; `
             + `remote=${shortCommit(project.remoteCommit)}; `
-            + `coverage=${project.coverage}`))
+            + `coverage=${project.coverage}\n${indent}  ${project.reason}`))
     ];
     return `${lines.join("\n")}\n`;
 }

package/dist/commands/taskRoleRuntimeStatus.js

@@ -11,6 +11,40 @@ import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
 import { formatRunReceiptId } from "../task/taskRecordReference.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
+export function taskRoleHostDiagnostic(host) {
+    const snapshot = host.snapshot;
+    if (snapshot === undefined)
+        return `unavailable: ${host.detail ?? "Host could not be read"}`;
+    const delivery = snapshot.eventDelivery;
+    return [
+        `Provider Host=${snapshot.state}`,
+        delivery === undefined ? "event delivery=unreported (legacy Host)" :
+            `pending facts=${delivery.pending}; native terminals awaiting acknowledgement=${delivery.pendingTerminals}`,
+        delivery?.failure === undefined ? undefined :
+            `reporting failure (${delivery.failure.stage}, ${delivery.failure.observedAt}): ${delivery.failure.detail}`,
+        snapshot.detail
+    ].filter(Boolean).join("; ");
+}
+/** Overlay live reporting evidence without rewriting Run/Provider/business truth. */
+export function withTaskRoleHostObservation(status, host) {
+    if (host === undefined)
+        return status;
+    const snapshot = host.snapshot;
+    if (snapshot !== undefined && (snapshot.nativeSessionId !== status.nativeSession?.nativeSessionId
+        || snapshot.adapterId !== status.nativeSession?.adapterId)) {
+        return { ...status, host: { detail: "Host does not match the recorded native Session." } };
+    }
+    const reportingNeedsAttention = snapshot !== undefined && (snapshot.state === "failed" || snapshot.state === "exited"
+        || snapshot.eventDelivery?.failure !== undefined
+        || (snapshot.eventDelivery?.pendingTerminals ?? 0) > 0);
+    return {
+        ...status, host,
+        ...(reportingNeedsAttention ? {
+            health: "needs-attention",
+            healthReason: `${taskRoleHostDiagnostic(host)}. Formal Run status and business acceptance are unchanged.`
+        } : {})
+    };
+}
 export function inspectTaskRoleRuntimeStatuses(taskId, roles, store, panes, now = new Date()) {
     const taskOpenInputRequestCount = store.listInputRequests(taskId)
         .filter((request) => request.status === "open").length;
@@ -99,6 +133,7 @@ export function renderTaskRoleRuntimeStatus(status) {
             : "none"}`,
         `  Native session   ${nativeSession}`,
         `  AgentRuntime    ${runtime}`,
+        ...(status.host === undefined ? [] : [`  Host reporting   ${taskRoleHostDiagnostic(status.host)}`]),
         `  Session tokens   ${sessionTokens}`,
         `  Runtime cleanup  ${status.runtimeCleanupPending ? "pending" : "none"}`,
         `  tmux pane        ${tmux}`,

package/dist/context/runContextPack.js

@@ -1,3 +1,4 @@
+import { providerRetryProjection } from "../runtime/providerRetry.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_INPUT_MAX_DELTAS } from "./runInputContract.js";
@@ -295,6 +296,8 @@ function readLiveTaskState(store, taskId) {
         status: round.status
     }));
     return Object.freeze({
+        providerRetries: Object.freeze(store.listRoleSessionSets(taskId).flatMap(set => set.providerBinding?.retry === undefined
+            ? [] : [{ roleName: set.owner.roleName, retry: providerRetryProjection(set.providerBinding) }])),
         activeRuns: Object.freeze(activeRuns),
         activeTaskReviews: Object.freeze(activeTaskReviews)
     });