@zq-silk/yui 0.8.1 → 0.8.3

package/dist/commands/taskCompletionGate.js

@@ -2,7 +2,159 @@ import { usageError } from "../errors/cliError.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { publicationExternalKey } from "../task/publicationReference.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
+/**
+ * Verify the one supported ancestry waiver before `task complete` mutates any
+ * durable state. The explicit Publication must be the current verified merged
+ * record, bind the exact reviewed physical Task head, and name an
+ * ancestry-divergent commit with the exact same Git tree.
+ */
+export async function verifyTaskCompletionPublishedTree(taskId, publicationId, store, options = {}) {
+    const task = store.getTask(taskId);
+    if (task === null)
+        throw usageError(`Task not found: ${taskId}.`);
+    if (task.status !== "active") {
+        throw usageError(`Task is not active: ${task.id}.`);
+    }
+    const publication = requireCurrentVerifiedPublication(store, task.id, publicationId);
+    const binding = task.projectBindings.find(({ projectId }) => (projectId === publication.projectId));
+    if (binding === undefined) {
+        throw usageError(`Publication ${publication.id} Project is not bound to Task ${task.id}: `
+            + `${publication.projectId}.`);
+    }
+    if (publication.localCommit === undefined || publication.remoteCommit === undefined) {
+        throw usageError(`Publication ${publication.id} must record exact local and remote commits.`);
+    }
+    const workspace = requireTaskWorkspace(store, task);
+    const latestReview = latestTaskFinalReview(store, task.id);
+    if (latestReview === undefined
+        || latestReview.status !== "completed"
+        || latestReview.taskCandidate === undefined) {
+        throw usageError(`Task ${task.id} requires a latest completed Task-final Review before accepting a published tree.`);
+    }
+    const git = options.git ?? new NodeGitWorkspace();
+    const actualHeads = new Map();
+    for (const taskBinding of task.projectBindings) {
+        const entry = workspaceProjectEntry(workspace, taskBinding.projectId);
+        if (entry === undefined || entry.access !== "write") {
+            throw usageError(`Task ${task.id} has no writable managed main workspace for Project ${taskBinding.projectId}.`);
+        }
+        const reviewedCommit = latestReview.taskCandidate.projects.find(({ projectId }) => (projectId === taskBinding.projectId))?.commit;
+        if (reviewedCommit === undefined) {
+            throw usageError(`Task-final Review ${latestReview.id} omitted Project ${taskBinding.projectId}.`);
+        }
+        const actualCommit = (await git.inspect(entry.path, "HEAD")).baseCommit;
+        if (actualCommit !== reviewedCommit) {
+            throw usageError(`Task-final Review ${latestReview.id} does not match Task head `
+                + `${taskBinding.projectId}@${actualCommit}.`);
+        }
+        actualHeads.set(taskBinding.projectId, actualCommit);
+    }
+    if (actualHeads.size !== latestReview.taskCandidate.projects.length) {
+        throw usageError(`Task-final Review ${latestReview.id} Project set does not match Task ${task.id}.`);
+    }
+    const entry = workspaceProjectEntry(workspace, publication.projectId);
+    const localCommit = actualHeads.get(publication.projectId);
+    if (publication.localCommit !== localCommit) {
+        throw usageError(`Publication ${publication.id} local commit ${publication.localCommit} `
+            + `does not match Task head ${localCommit}.`);
+    }
+    let remoteCommit;
+    let localTree;
+    let remoteTree;
+    try {
+        remoteCommit = (await git.inspect(entry.path, publication.remoteCommit)).baseCommit;
+        [localTree, remoteTree] = await Promise.all([
+            git.resolveTree(entry.path, localCommit),
+            git.resolveTree(entry.path, remoteCommit)
+        ]);
+    }
+    catch (error) {
+        throw usageError(`Publication ${publication.id} commit/tree evidence is unavailable: `
+            + `${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (remoteCommit !== publication.remoteCommit) {
+        throw usageError(`Publication ${publication.id} remote commit changed: expected `
+            + `${publication.remoteCommit}, found ${remoteCommit}.`);
+    }
+    const [localContainsRemote, remoteContainsLocal] = await Promise.all([
+        git.isAncestor(entry.path, remoteCommit, localCommit),
+        git.isAncestor(entry.path, localCommit, remoteCommit)
+    ]);
+    if (localContainsRemote || remoteContainsLocal) {
+        throw usageError(`Publication ${publication.id} is not ancestry-divergent from Task head ${localCommit}; `
+            + "use normal Task completion.");
+    }
+    if (localTree !== remoteTree) {
+        throw usageError(`Publication ${publication.id} Git trees differ: `
+            + `${localCommit}^{tree}=${localTree}, ${remoteCommit}^{tree}=${remoteTree}.`);
+    }
+    return {
+        taskId: task.id,
+        projectId: publication.projectId,
+        publicationId: publication.id,
+        reviewRoundId: latestReview.id,
+        localCommit,
+        remoteCommit,
+        tree: localTree
+    };
+}
+/** Re-derive every durable half of the asynchronous Git proof under the Task
+ * completion transaction. The physical heads are the CLI snapshot captured
+ * immediately before mutation; any record or head drift fails closed. */
+export function assertTaskCompletionPublishedTreeProof(store, task, publicationId, proof, actualCandidate) {
+    if (proof === undefined
+        || proof.taskId !== task.id
+        || proof.publicationId !== publicationId) {
+        throw usageError(`Published-tree completion proof is missing or mismatched for ${task.id}/${publicationId}.`);
+    }
+    const publication = requireCurrentVerifiedPublication(store, task.id, publicationId);
+    if (publication.projectId !== proof.projectId
+        || publication.localCommit !== proof.localCommit
+        || publication.remoteCommit !== proof.remoteCommit) {
+        throw usageError(`Publication evidence changed before Task completion: ${publication.id}.`);
+    }
+    const latestReview = latestTaskFinalReview(store, task.id);
+    if (latestReview === undefined
+        || latestReview.id !== proof.reviewRoundId
+        || latestReview.status !== "completed"
+        || latestReview.taskCandidate === undefined
+        || !sameTaskCandidate(latestReview.taskCandidate, actualCandidate)) {
+        throw usageError(`Task-final Review evidence changed before published-tree completion: ${task.id}.`);
+    }
+    const actualCommit = actualCandidate.projects.find(({ projectId }) => (projectId === proof.projectId))?.commit;
+    if (actualCommit !== proof.localCommit) {
+        throw usageError(`Task head changed before published-tree completion: `
+            + `${proof.projectId}@${actualCommit ?? "missing"}.`);
+    }
+    return proof;
+}
+function requireCurrentVerifiedPublication(store, taskId, publicationId) {
+    const publication = store.getPublicationReference(taskId, publicationId);
+    if (publication === null) {
+        throw usageError(`Publication reference not found: ${taskId}/${publicationId}.`);
+    }
+    const current = store.findPublicationReferenceByExternalKey(publicationExternalKey(publication));
+    if (current === null || current.taskId !== taskId || current.id !== publication.id) {
+        throw usageError(`Publication ${publication.id} is not the current unsuperseded record for its external identity.`);
+    }
+    if (publication.state !== "merged" || publication.verification !== "verified") {
+        throw usageError(`Publication ${publication.id} must be merged and verified before Task completion.`);
+    }
+    return publication;
+}
+function latestTaskFinalReview(store, taskId) {
+    return store.listReviewRounds(taskId)
+        .filter((round) => (round.scope ?? "work-item") === "task")
+        .sort((left, right) => (left.id.localeCompare(right.id, undefined, { numeric: true })))
+        .at(-1);
+}
+function sameTaskCandidate(left, right) {
+    return left.projects.length === right.projects.length
+        && left.projects.every((project, index) => (project.projectId === right.projects[index]?.projectId
+            && project.commit === right.projects[index]?.commit));
+}
 /**
  * Reconcile configured remote baselines before a Task completion attempt.
  *

package/dist/context/runContextPack.js

@@ -1,3 +1,4 @@
+import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_BOOTSTRAP_MAX_DELTAS } from "./runContextContract.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot, validateContextSnapshot } from "./contextSnapshot.js";
 export const RUN_CONTEXT_PACK_SCHEMA_VERSION = 1;
@@ -123,11 +124,12 @@ export function buildRunContextPack(store, taskId, runId) {
     });
     return pack;
 }
-export function expandRunContextRef(store, taskId, runId, refId) {
+export function expandRunContextRef(store, taskId, runId, refId, refStore) {
     const pack = buildRunContextPack(store, taskId, runId);
-    const authorized = pack.pointers.filter((ref) => ref.refId === refId);
+    const authorized = pack.pointers.filter((ref) => (ref.refId === refId && (refStore === undefined || ref.store === refStore)));
+    const selector = refStore === undefined ? refId : `${refStore}/${refId}`;
     if (authorized.length !== 1) {
-        throw new Error(`Run Context ref is not uniquely authorized: ${refId}.`);
+        throw new Error(`Run Context ref is not uniquely authorized: ${selector}.`);
     }
     const run = requireExactRun(store, taskId, runId);
     const snapshotRef = run.assignment.contextSnapshotRef;
@@ -135,7 +137,7 @@ export function expandRunContextRef(store, taskId, runId, refId) {
         ? collectAuthorizedContext(store, run).find(({ ref }) => (contextRefIdentity(ref) === contextRefIdentity(authorized[0])))
         : store.getContextSnapshot(taskId, snapshotRef.id)?.resources.find(({ ref }) => (contextRefIdentity(ref) === contextRefIdentity(authorized[0])));
     if (materialized === undefined || materialized.ref.digest !== authorized[0].digest) {
-        throw new Error(`Run Context ref is unavailable or drifted: ${refId}.`);
+        throw new Error(`Run Context ref is unavailable or drifted: ${selector}.`);
     }
     const bytes = Buffer.byteLength(JSON.stringify(materialized.value), "utf8");
     if (bytes > RUN_CONTEXT_EXPAND_MAX_BYTES) {
@@ -261,6 +263,19 @@ function collectAuthorizedContext(store, run) {
         for (const message of store.listMessages(task.id).slice(-16)) {
             result.push(materialize("L4", "task-message", message.id, message));
         }
+        const publishedTreeAuthorizations = [];
+        const events = store.listEvents(task.id);
+        for (let index = events.length - 1; index >= 0; index -= 1) {
+            const event = events[index];
+            if (event.type === "task.completed" || event.type === "task.reopened")
+                break;
+            if (event.type === TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT) {
+                publishedTreeAuthorizations.push(event);
+            }
+        }
+        for (const event of publishedTreeAuthorizations.reverse().slice(-16)) {
+            result.push(materialize("L4", "task-event", event.id, event));
+        }
         for (const request of store.listOpenInputRequests([task.id])) {
             result.push(materialize("L4", "input-request", request.id, request));
         }

package/dist/context/sessionBootstrapManifest.js

@@ -57,7 +57,7 @@ export function materializeSessionBootstrap(input) {
             }
             : {
                 loadCommand: `\"${sessionCliPath}\" task run context \"$YUI_TASK_ID/<run-id>\" --json`,
-                expandCommand: `\"${sessionCliPath}\" task run context expand \"$YUI_TASK_ID/<run-id>\" <ref-id> --mode full --json`
+                expandCommand: `\"${sessionCliPath}\" task run context expand \"$YUI_TASK_ID/<run-id>\" <ref-id> --store <store> --mode full --json`
             }
     };
     const manifest = Object.freeze({ ...body, digest: digest(body) });