@zq-silk/yui 0.14.1 → 0.14.2

package/dist/commands/taskPublicationCommands.js

@@ -10,10 +10,21 @@ import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 const PROVIDERS = new Set(["github", "gitlab"]);
 const EXTERNAL_KINDS = new Set(["pull-request", "merge-request"]);
 const STATES = new Set(["open", "merged", "closed"]);
+const INHERITED_METADATA_FIELDS = [
+    "externalUrl",
+    "title",
+    "sourceBranch",
+    "targetBranch"
+];
+const INHERITED_EVIDENCE_FIELDS = [
+    "remoteCommit",
+    "evidence",
+    "mergedAt"
+];
 export function runPublicationCommand(args, store, options) {
     const [command, ...rest] = args;
     switch (command) {
-        case "add": return addPublication(rest, store, options);
+        case "upsert": return upsertPublication(rest, store, options);
         case "list": return listPublications(rest, store);
         case "show": return showPublication(rest, store);
         default:
@@ -22,11 +33,12 @@ export function runPublicationCommand(args, store, options) {
                 : `Unknown command: task publication ${command}`);
     }
 }
-function addPublication(args, store, options) {
-    const usage = "Task publication add usage: yui task publication add <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>] [--supersede <publication-id>] [--merged-at <iso-timestamp>].";
-    const parsed = parseAddArgs(args, usage);
+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 parsed = parseUpsertArgs(args, usage);
+    exactPositionals(parsed.positionals, 1, usage);
     const task = requireTask(store, parsed.positionals[0]);
-    const projectReference = requiredOption(parsed.options, "--project");
+    const projectReference = requiredOption(parsed.options, "--project", usage);
     const project = resolveProject(store.listProjects(), projectReference);
     if (project === null)
         throw usageError(`Project not found: ${projectReference}.`, usage);
@@ -34,98 +46,80 @@ function addPublication(args, store, options) {
         throw usageError(`Project is not bound to Task ${task.id}: ${projectReference}.`, usage);
     }
     const actor = taskActor(options.environment, task.id);
-    const state = enumOption(parsed.options, "--state", STATES, usage) ?? "open";
+    const state = enumOption(parsed.options, "--state", STATES, usage);
     const verification = parseVerification(parsed, usage);
     const input = {
         projectId: project.id,
-        provider: enumOption(parsed.options, "--provider", PROVIDERS, usage),
-        repository: requiredOption(parsed.options, "--repository"),
-        externalKind: enumOption(parsed.options, "--kind", EXTERNAL_KINDS, usage),
-        externalId: requiredOption(parsed.options, "--id"),
-        ...(parsed.options.has("--url") ? { externalUrl: requiredOption(parsed.options, "--url") } : {}),
-        ...(parsed.options.has("--title") ? { title: requiredOption(parsed.options, "--title") } : {}),
+        provider: requiredEnumOption(parsed.options, "--provider", PROVIDERS, usage),
+        repository: requiredOption(parsed.options, "--repository", usage),
+        externalKind: requiredEnumOption(parsed.options, "--kind", EXTERNAL_KINDS, usage),
+        externalId: requiredOption(parsed.options, "--id", usage),
+        ...(parsed.options.has("--url")
+            ? { externalUrl: requiredOption(parsed.options, "--url", usage) }
+            : {}),
+        ...(parsed.options.has("--title")
+            ? { title: requiredOption(parsed.options, "--title", usage) }
+            : {}),
         ...(parsed.options.has("--source-branch")
-            ? { sourceBranch: requiredOption(parsed.options, "--source-branch") }
+            ? { sourceBranch: requiredOption(parsed.options, "--source-branch", usage) }
             : {}),
         ...(parsed.options.has("--target-branch")
-            ? { targetBranch: requiredOption(parsed.options, "--target-branch") }
+            ? { targetBranch: requiredOption(parsed.options, "--target-branch", usage) }
             : {}),
         ...(parsed.options.has("--local-commit")
-            ? { localCommit: requiredOption(parsed.options, "--local-commit") }
+            ? { localCommit: requiredOption(parsed.options, "--local-commit", usage) }
             : {}),
         ...(parsed.options.has("--remote-commit")
-            ? { remoteCommit: requiredOption(parsed.options, "--remote-commit") }
+            ? { remoteCommit: requiredOption(parsed.options, "--remote-commit", usage) }
             : {}),
-        state,
-        verification,
+        ...(state === undefined ? {} : { state }),
+        ...(verification === undefined ? {} : { verification }),
         ...(parsed.options.has("--evidence")
-            ? { evidence: requiredOption(parsed.options, "--evidence") }
-            : {}),
-        ...(parsed.options.has("--supersede")
-            ? { supersedes: requiredOption(parsed.options, "--supersede") }
+            ? { evidence: requiredOption(parsed.options, "--evidence", usage) }
             : {}),
         ...(parsed.options.has("--merged-at")
-            ? { mergedAt: requiredOption(parsed.options, "--merged-at") }
-            : {}),
-        recordedBy: actor,
-        source: "manual"
+            ? { mergedAt: requiredOption(parsed.options, "--merged-at", usage) }
+            : {})
     };
-    const externalKey = `${input.provider}/${input.repository}/${input.externalId}`;
     const now = clock(options);
-    const result = store.transaction((tx) => {
-        const existing = tx.findPublicationReferenceByExternalKey(externalKey);
-        if (existing !== null) {
-            if (existing.taskId !== task.id) {
-                throw dataError(`Publication external identity already belongs to Task ${existing.taskId}: ${externalKey}.`);
-            }
-            const semantic = createPublicationReference(existing.id, task.id, input.supersedes === existing.id
-                ? {
-                    projectId: input.projectId,
-                    provider: input.provider,
-                    repository: input.repository,
-                    externalKind: input.externalKind,
-                    externalId: input.externalId,
-                    ...(input.externalUrl === undefined ? {} : { externalUrl: input.externalUrl }),
-                    ...(input.title === undefined ? {} : { title: input.title }),
-                    ...(input.sourceBranch === undefined ? {} : { sourceBranch: input.sourceBranch }),
-                    ...(input.targetBranch === undefined ? {} : { targetBranch: input.targetBranch }),
-                    ...(input.localCommit === undefined ? {} : { localCommit: input.localCommit }),
-                    ...(input.remoteCommit === undefined ? {} : { remoteCommit: input.remoteCommit }),
-                    state: input.state,
-                    verification: input.verification,
-                    ...(input.evidence === undefined ? {} : { evidence: input.evidence }),
-                    ...(input.mergedAt === undefined ? {} : { mergedAt: input.mergedAt }),
-                    recordedBy: input.recordedBy,
-                    source: input.source
-                }
-                : input, new Date(existing.createdAt));
-            if (isDeepStrictEqual(semantic, existing)) {
-                return { reference: existing, idempotent: true };
-            }
-            if (input.supersedes === undefined || input.supersedes !== existing.id) {
-                throw usageError(`Publication ${externalKey} conflicts with current record ${existing.id}; `
-                    + "use --supersede with that id to append corrected evidence.", usage);
-            }
-        }
-        else if (input.supersedes !== undefined) {
-            throw usageError(`Publication supersede target has a different external identity: ${input.supersedes}.`, usage);
-        }
-        const reference = createPublicationReference(tx.nextPublicationReferenceId(task.id), task.id, input, now);
-        tx.savePublicationReference(task.id, reference);
-        recordTaskEvent(tx, task.id, "publication.recorded", {
-            publicationId: reference.id,
-            provider: reference.provider,
-            repository: reference.repository,
-            externalKind: reference.externalKind,
-            externalId: reference.externalId,
-            state: reference.state,
-            verification: reference.verification
-        }, now);
-        return { reference, idempotent: false };
-    });
+    const result = store.transaction((tx) => upsertTaskPublication(tx, task, input, actor, now));
     return output(result.idempotent
-        ? `Publication reference already recorded: ${result.reference.id}.\n`
-        : `Recorded publication ${result.reference.id} (${result.reference.provider}/${result.reference.repository}/${result.reference.externalKind}/${result.reference.externalId}) for ${result.reference.taskId}.\n`, result.reference);
+        ? `Publication reference already current: ${result.reference.id}.\n`
+        : `Upserted publication ${result.reference.id} (${result.reference.provider}/${result.reference.repository}/${result.reference.externalKind}/${result.reference.externalId}) for ${result.reference.taskId}.\n`, result.reference);
+}
+/**
+ * One immutable Publication upsert against the caller's current transaction.
+ * External verification uses the same lineage and idempotency path as manual
+ * evidence instead of maintaining a second mutation protocol.
+ */
+export function upsertTaskPublication(store, task, input, actor, now) {
+    const externalKey = `${input.provider}/${input.repository}/${input.externalId}`;
+    const existing = store.findPublicationReferenceByExternalKey(externalKey);
+    if (existing !== null && existing.taskId !== task.id) {
+        throw dataError(`Publication external identity already belongs to Task ${existing.taskId}: ${externalKey}.`);
+    }
+    const effective = existing === null
+        ? input
+        : inheritPublicationInput(existing, input);
+    if (existing !== null) {
+        const semantic = createPublicationReference(existing.id, task.id, {
+            ...effective,
+            recordedBy: existing.recordedBy,
+            source: existing.source
+        }, new Date(existing.createdAt));
+        if (isDeepStrictEqual(publicationSemantics(semantic), publicationSemantics(existing))) {
+            return { reference: existing, idempotent: true };
+        }
+    }
+    const reference = createPublicationReference(store.nextPublicationReferenceId(task.id), task.id, {
+        ...effective,
+        ...(existing === null ? {} : { supersedes: existing.id }),
+        recordedBy: actor,
+        source: "manual"
+    }, now);
+    store.savePublicationReference(task.id, reference);
+    recordPublicationEvent(store, reference, now);
+    return { reference, idempotent: false };
 }
 function listPublications(args, store) {
     const usage = "Task publication list usage: yui task publication list <task>.";
@@ -207,7 +201,11 @@ function parseVerification(parsed, usage) {
     if (parsed.flags.has("--reported") && parsed.flags.has("--verified")) {
         throw usageError("--reported and --verified are mutually exclusive.", usage);
     }
-    return parsed.flags.has("--verified") ? "verified" : "reported";
+    if (parsed.flags.has("--verified"))
+        return "verified";
+    if (parsed.flags.has("--reported"))
+        return "reported";
+    return undefined;
 }
 function enumOption(options, name, allowed, usage) {
     if (!options.has(name))
@@ -218,6 +216,59 @@ function enumOption(options, name, allowed, usage) {
     }
     return value;
 }
+function requiredEnumOption(options, name, allowed, usage) {
+    const value = enumOption(options, name, allowed, usage);
+    if (value === undefined) {
+        throw usageError(`${name} is required.`, usage);
+    }
+    return value;
+}
+function inheritPublicationInput(existing, input) {
+    const localCommitChanged = input.localCommit !== undefined
+        && normalizeCommitForComparison(input.localCommit) !== existing.localCommit;
+    const stateChanged = input.state !== undefined && input.state !== existing.state;
+    const remoteCommitChanged = input.remoteCommit !== undefined
+        && normalizeCommitForComparison(input.remoteCommit) !== existing.remoteCommit;
+    const evidenceChanged = input.evidence !== undefined
+        && input.evidence.trim() !== existing.evidence;
+    const mergedAtChanged = input.mergedAt !== undefined
+        && input.mergedAt !== existing.mergedAt;
+    const evidenceContextChanged = localCommitChanged
+        || stateChanged
+        || remoteCommitChanged
+        || evidenceChanged
+        || mergedAtChanged;
+    const inherited = {
+        projectId: input.projectId,
+        provider: input.provider,
+        repository: input.repository,
+        externalKind: input.externalKind,
+        externalId: input.externalId,
+        state: input.state ?? (localCommitChanged ? "open" : existing.state),
+        verification: input.verification ?? (evidenceContextChanged ? "reported" : existing.verification),
+        ...(input.localCommit === undefined
+            ? (existing.localCommit === undefined ? {} : { localCommit: existing.localCommit })
+            : { localCommit: input.localCommit })
+    };
+    for (const field of INHERITED_METADATA_FIELDS) {
+        const value = input[field] ?? existing[field];
+        if (value !== undefined)
+            Object.assign(inherited, { [field]: value });
+    }
+    for (const field of INHERITED_EVIDENCE_FIELDS) {
+        const value = input[field] ?? (evidenceContextChanged ? undefined : existing[field]);
+        if (value !== undefined)
+            Object.assign(inherited, { [field]: value });
+    }
+    return inherited;
+}
+function normalizeCommitForComparison(value) {
+    return value.trim().toLowerCase();
+}
+function publicationSemantics(reference) {
+    const { schemaVersion: _schemaVersion, id: _id, taskId: _taskId, supersedes: _supersedes, recordedBy: _recordedBy, source: _source, createdAt: _createdAt, ...semantics } = reference;
+    return semantics;
+}
 function requireTask(store, taskId) {
     const id = requiredText(taskId, "Task id");
     const task = store.getTask(id);
@@ -225,11 +276,26 @@ function requireTask(store, taskId) {
         throw taskNotFound(id);
     return task;
 }
+function recordPublicationEvent(store, reference, now) {
+    recordTaskEvent(store, reference.taskId, "publication.recorded", {
+        publicationId: reference.id,
+        provider: reference.provider,
+        repository: reference.repository,
+        externalKind: reference.externalKind,
+        externalId: reference.externalId,
+        state: reference.state,
+        verification: reference.verification
+    }, now);
+}
 function recordTaskEvent(store, taskId, type, payload, now) {
     store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, type, payload, now));
 }
-function requiredOption(options, name) {
-    return requiredText(options.get(name), name);
+function requiredOption(options, name, usage) {
+    const value = options.get(name)?.trim();
+    if (value === undefined || value.length === 0) {
+        throw usageError(`${name} is required.`, usage);
+    }
+    return value;
 }
 function requiredText(value, label) {
     const normalized = value?.trim();
@@ -251,11 +317,11 @@ function exactPositionals(values, count, usage) {
         throw usageError(usage);
     }
 }
-function parseAddArgs(args, usage) {
+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", "--supersede", "--merged-at"
+        "--remote-commit", "--state", "--evidence", "--merged-at"
     ]);
     const flags = new Set(["--reported", "--verified"]);
     const positionals = [];

package/dist/commands/taskPublicationVerifyCommand.js

@@ -0,0 +1,181 @@
+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";
+export async function runTaskPublicationVerifyCommand(args, store, options) {
+    const reference = parsePublicationVerificationReference(args);
+    const task = store.getTask(reference.taskId);
+    if (task === null)
+        throw taskNotFound(reference.taskId);
+    if (task.status === "archived") {
+        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 verifier = options.verifiers[request.publication.provider];
+    if (verifier === undefined) {
+        throw usageError(`Publication verification is not supported for provider `
+            + `${request.publication.provider}.`);
+    }
+    let observation;
+    try {
+        observation = await verifier.inspect({
+            provider: request.publication.provider,
+            repository: request.publication.repository,
+            externalKind: request.publication.externalKind,
+            externalId: request.publication.externalId,
+            ...(request.publication.externalUrl === undefined
+                ? {}
+                : { externalUrl: request.publication.externalUrl }),
+            expectedLocalCommit: request.expectedLocalCommit
+        });
+    }
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
+        throw runtimeError(`Publication verification failed for ${request.publication.provider}/`
+            + `${request.publication.repository}/${request.publication.externalId}: `
+            + `${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());
+    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`,
+        data: { publication: result.reference, observation }
+    };
+}
+function preparePublicationVerification(store, taskId, publicationId, currentCandidate, environment) {
+    return store.transaction((reader) => {
+        const task = reader.getTask(taskId);
+        if (task === null)
+            throw taskNotFound(taskId);
+        if (task.status === "archived") {
+            throw usageError(`Archived Task Publication cannot be verified: ${task.id}.`);
+        }
+        const actor = taskActor(environment, task.id);
+        const publication = reader.getPublicationReference(task.id, publicationId);
+        if (publication === null) {
+            throw dataError(`Publication reference not found: ${task.id}/${publicationId}.`);
+        }
+        const current = reader.findPublicationReferenceByExternalKey(publicationExternalKey(publication));
+        if (current === null || current.taskId !== task.id || current.id !== publication.id) {
+            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));
+        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
+        };
+    });
+}
+function assertVerificationObservation(request, observation) {
+    const publication = request.publication;
+    if (observation.provider !== publication.provider
+        || observation.repository !== publication.repository
+        || observation.externalKind !== publication.externalKind
+        || 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 (observation.headCommit !== request.expectedLocalCommit) {
+        throw usageError(`Remote ${publication.externalKind} head ${observation.headCommit} `
+            + `does not match Task delivery head ${request.expectedLocalCommit}.`);
+    }
+    if (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) {
+    return store.transaction((tx) => {
+        const task = tx.getTask(request.task.id);
+        if (task === null)
+            throw taskNotFound(request.task.id);
+        if (!isDeepStrictEqual(taskVerificationInvariant(task), request.task)) {
+            throw usageError(`Task changed during Publication verification: ${request.task.id}.`);
+        }
+        const current = tx.findPublicationReferenceByExternalKey(publicationExternalKey(request.publication));
+        if (current === null
+            || current.taskId !== task.id
+            || !isDeepStrictEqual(current, request.publication)) {
+            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,
+            repository: request.publication.repository,
+            externalKind: request.publication.externalKind,
+            externalId: request.publication.externalId,
+            ...(observation.externalUrl === undefined
+                ? {}
+                : { externalUrl: observation.externalUrl }),
+            localCommit: request.expectedLocalCommit,
+            remoteCommit: observation.remoteCommit,
+            state: "merged",
+            verification: "verified",
+            evidence: observation.evidence,
+            ...(observation.mergedAt === undefined
+                ? {}
+                : { mergedAt: observation.mergedAt })
+        }, request.actor, now);
+    });
+}
+function parsePublicationVerificationReference(args) {
+    const usage = "Task publication verify usage: "
+        + "yui task publication verify (<task>/<publication-id> | <task> <publication-id>).";
+    if (args.length !== 1 && args.length !== 2)
+        throw usageError(usage);
+    return resolveTaskRecordReference(args.length === 1 ? args[0] : `${args[0]}/${args[1]}`, { kind: "publicationReference", label: "Publication reference" });
+}
+function taskVerificationInvariant(task) {
+    return {
+        id: task.id,
+        status: task.status,
+        projectBindings: task.projectBindings,
+        ...(task.workspaceIdentity === undefined
+            ? {}
+            : { workspaceIdentity: task.workspaceIdentity }),
+        ...(task.completedAt === undefined ? {} : { completedAt: task.completedAt }),
+        ...(task.retiredAt === undefined ? {} : { retiredAt: task.retiredAt })
+    };
+}

package/dist/commands/taskRemoteDeliveryCommand.js

@@ -0,0 +1,134 @@
+import { isDeepStrictEqual } from "node:util";
+import { taskNotFound, usageError } from "../errors/cliError.js";
+import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
+export function runTaskRemoteDeliveryCommand(args, store, currentCandidate = null) {
+    const usage = "Task remote-delivery usage: yui task remote-delivery <task> [--json].";
+    const asJson = args.includes("--json");
+    const positionals = args.filter((arg) => arg !== "--json");
+    if (positionals.length !== 1 || positionals[0]?.trim().length === 0) {
+        throw usageError(usage);
+    }
+    const taskId = positionals[0].trim();
+    const data = store.transaction((reader) => {
+        const task = reader.getTask(taskId);
+        if (task === null)
+            throw taskNotFound(taskId);
+        return projectTaskRemoteDeliveryFromStore(reader, task, currentCandidate);
+    });
+    return {
+        kind: "output",
+        output: asJson
+            ? `${JSON.stringify(data, null, 2)}\n`
+            : renderTaskRemoteDelivery(data),
+        data
+    };
+}
+export function projectTaskRemoteDeliveryFromStore(store, task, currentCandidate = null) {
+    return projectTaskRemoteDelivery({
+        task,
+        events: store.listEvents(task.id),
+        publications: store.listPublicationReferences(task.id),
+        managedWorkspaces: store.listManagedWorkspaces(task.id),
+        turns: store.listTurns(task.id),
+        currentCandidate
+    });
+}
+export function createTaskRemoteDeliveryProof(store, task, currentCandidate = null) {
+    const publications = store.listPublicationReferences(task.id);
+    const delivery = projectTaskRemoteDelivery({
+        task,
+        events: store.listEvents(task.id),
+        publications,
+        managedWorkspaces: store.listManagedWorkspaces(task.id),
+        turns: store.listTurns(task.id),
+        currentCandidate
+    });
+    return {
+        schemaVersion: 1,
+        task: taskRemoteDeliveryProofTask(task),
+        publications,
+        delivery
+    };
+}
+export function assertTaskRemoteDeliveryProof(store, task, proof, options = {}) {
+    if (proof === undefined || proof.schemaVersion !== 1) {
+        throw usageError(`Task remote-delivery preflight proof is required: ${task.id}.`);
+    }
+    if (!isDeepStrictEqual(proof.task, taskRemoteDeliveryProofTask(task))) {
+        throw usageError(`Task changed after remote-delivery preflight: ${task.id}.`);
+    }
+    if (!isDeepStrictEqual(proof.publications, store.listPublicationReferences(task.id))) {
+        throw usageError(`Task Publication evidence changed after remote-delivery preflight: ${task.id}.`);
+    }
+    assertTaskRemoteDeliveryIntegrated(proof.delivery, options);
+    return proof.delivery;
+}
+export function assertTaskRemoteDeliveryIntegrated(delivery, options = {}) {
+    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.");
+        }
+        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.");
+    }
+    if (delivery.allVerified || options.forceUnverified === true)
+        return;
+    const unverified = delivery.projects
+        .filter((project) => (project.codeDelivery !== "none"
+        && project.merged
+        && !project.verified))
+        .map((project) => (`${project.projectId}/${project.coverage}`
+        + (project.publication === null ? "" : `/${project.publication.id}`)))
+        .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.");
+}
+export function renderTaskRemoteDelivery(delivery, indent = "") {
+    const source = `${delivery.source}${delivery.provisional ? " (provisional)" : ""}`;
+    const lines = [
+        `${indent}Remote delivery: ${delivery.status}`,
+        `${indent}Expected heads: ${source}`,
+        `${indent}All merged: ${delivery.allMerged ? "yes" : "no"}`,
+        `${indent}All verified: ${delivery.allVerified ? "yes" : "no"}`,
+        `${indent}Code Projects: ${delivery.mergedProjectCount}/${delivery.codeProjectCount} merged; ${delivery.verifiedProjectCount}/${delivery.codeProjectCount} verified`,
+        `${indent}Archive --integrated coverage: ${delivery.integratedCoverageSatisfied ? "satisfied" : "blocked"}`,
+        ...(delivery.archiveDisposition === null
+            ? []
+            : [`${indent}Archive disposition: ${delivery.archiveDisposition}`]),
+        `${indent}Projects:${delivery.projects.length === 0 ? " none" : ""}`,
+        ...delivery.projects.map((project) => (`${indent}- ${project.directory} (${project.projectId}): `
+            + `expected=${shortCommit(project.expectedLocalCommit)}; `
+            + `base=${shortCommit(project.baseCommit)}; `
+            + `publication=${project.publication?.id ?? "none"}; `
+            + `state=${project.state ?? "none"}; `
+            + `verification=${project.verification ?? "none"}; `
+            + `remote=${shortCommit(project.remoteCommit)}; `
+            + `coverage=${project.coverage}`))
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function shortCommit(commit) {
+    return commit === null ? "unknown" : commit.slice(0, 12);
+}
+function taskRemoteDeliveryProofTask(task) {
+    return {
+        id: task.id,
+        status: task.status,
+        projectBindings: task.projectBindings,
+        ...(task.workspaceIdentity === undefined
+            ? {}
+            : { workspaceIdentity: task.workspaceIdentity }),
+        ...(task.completedAt === undefined ? {} : { completedAt: task.completedAt }),
+        ...(task.retiredAt === undefined ? {} : { retiredAt: task.retiredAt })
+    };
+}