@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/audit/candidate.js

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import { FlowError, asMessage } from "../../flow-error.js";
 import { createGit, wrapGitError } from "../../git/core.js";
 import { readStructuredDiff } from "../../git/diff/structured.js";
-import { rewriteRenewBranch } from "../renew.js";
+import { abortDetachedRenewChain, buildDetachedRenewChain, renewScratchName } from "../renew-rewrite.js";
+import { isBootstrapSuccess, runWorktreeBootstrap } from "../worktree-bootstrap.js";
 async function resolveObject(cwd, revision, kind) {
     try {
         return (await createGit(cwd).raw(["rev-parse", "--verify", `${revision}^{${kind}}`])).trim();
@@ -24,14 +25,25 @@ export async function createAuditCandidate(input) {
         await candidateGit.raw(["checkout", "--quiet", "-B", `keiyaku/${input.contractId}`, input.frozen.coordinates.delivery.head]);
         if (input.frozen.base === input.frozen.coordinates.target.head)
             return { cwd, rehearsal: { status: "fresh" }, candidate: { base: input.frozen.coordinates.target.head, head: input.frozen.coordinates.delivery.head, tree: input.frozen.coordinates.delivery.tree, rewritten: false } };
-        try {
-            await rewriteRenewBranch({ cwd, contractId: input.contractId, oldHead: input.frozen.coordinates.delivery.head, recoveryRef: "refs/keiyaku/audit/disposable", newBase: input.frozen.coordinates.target.head, oldBase: input.frozen.base });
-        }
-        catch (error) {
-            if (error instanceof FlowError && error.code === "CLOSE_MERGE_CONFLICT" && error.facts?.kind === "renew_conflict")
-                return { cwd, rehearsal: { status: "conflict", paths: [...error.facts.conflictPaths], pathCapture: error.facts.conflictPathCapture.status === "captured" ? "captured" : "failed", ...(error.facts.conflictPathCapture.status === "failed" ? { diagnostic: error.facts.conflictPathCapture.diagnostic } : {}) }, candidate: null };
-            return { cwd, rehearsal: { status: "unknown", cause: { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) } }, candidate: null };
+        const scratchName = renewScratchName(`audit-${input.contractId}-${input.frozen.coordinates.delivery.head}`);
+        const deliveryCommits = (await candidateGit.raw(["rev-list", "--reverse", "--ancestry-path", `${input.frozen.base}..${input.frozen.coordinates.delivery.head}`])).split(/\r?\n/).filter(Boolean);
+        const rewrite = await buildDetachedRenewChain({
+            cwd,
+            scratchName,
+            observedLedgerHead: input.frozen.coordinates.ledger.head,
+            deliveryRef: input.frozen.coordinates.delivery.ref,
+            targetRef: input.frozen.coordinates.target.ref,
+            effectiveScope: input.frozen.scope,
+            oldBase: input.frozen.base,
+            oldHead: input.frozen.coordinates.delivery.head,
+            newBase: input.frozen.coordinates.target.head,
+            deliveryCommits,
+        });
+        if (rewrite.status === "conflict") {
+            await abortDetachedRenewChain({ cwd, scratchName });
+            return { cwd, rehearsal: { status: "conflict", paths: [...rewrite.conflictPaths], pathCapture: "captured" }, candidate: null };
         }
+        await candidateGit.raw(["reset", "--hard", rewrite.newHead]);
         const [head, tree] = await Promise.all([resolveObject(cwd, "HEAD", "commit"), resolveObject(cwd, "HEAD", "tree")]);
         return { cwd, rehearsal: { status: "clean", oldBase: input.frozen.base, newBase: input.frozen.coordinates.target.head, oldHead: input.frozen.coordinates.delivery.head }, candidate: { base: input.frozen.coordinates.target.head, head, tree, rewritten: true } };
     }
@@ -44,5 +56,94 @@ export async function readAuditCandidateDiff(candidateResult) {
     const candidate = candidateResult.candidate;
     if (!candidate)
         return null;
-    return readStructuredDiff(candidateResult.cwd, candidate.base, candidate.head, { excludePaths: [".keiyaku/KEIYAKU.md"] });
+    return readStructuredDiff(candidateResult.cwd, candidate.base, candidate.head);
+}
+async function readCandidateIntegrity(cwd) {
+    const git = createGit(cwd);
+    const [head, tree, status] = await Promise.all([
+        resolveObject(cwd, "HEAD", "commit"),
+        resolveObject(cwd, "HEAD", "tree"),
+        git.raw(["status", "--porcelain=v1", "-z", "--untracked-files=no"]),
+    ]);
+    return { head, tree, trackedChanges: status.split("\0").filter(Boolean) };
+}
+function preparationPlan(plan) {
+    return { command: [...plan.command], timeoutMs: plan.timeoutMs };
+}
+function preparationOutput(observation) {
+    return {
+        ...(observation.stdoutTail !== undefined ? { stdoutTail: observation.stdoutTail } : {}),
+        ...(observation.stdoutTruncated ? { stdoutTruncated: true } : {}),
+        ...(observation.stderrTail !== undefined ? { stderrTail: observation.stderrTail } : {}),
+        ...(observation.stderrTruncated ? { stderrTruncated: true } : {}),
+    };
+}
+function bootstrapResultDescription(result) {
+    if (result.kind === "exit")
+        return `exit ${result.code}`;
+    if (result.kind === "signal")
+        return `signal ${result.signal}`;
+    if (result.kind === "timeout")
+        return "timeout";
+    return `spawn: ${result.message}`;
+}
+function observationFailure(plan, candidate, observation) {
+    return {
+        status: "failed",
+        plan: preparationPlan(plan),
+        candidate: { head: candidate.head, tree: candidate.tree },
+        result: observation.result,
+        durationMs: observation.durationMs,
+        ...preparationOutput(observation),
+        cause: { code: "CANDIDATE_BOOTSTRAP_FAILED", message: `candidate bootstrap failed with ${bootstrapResultDescription(observation.result)}` },
+    };
+}
+export async function prepareAuditCandidate(input, dependencies = {}) {
+    const candidate = input.candidateResult.candidate;
+    if (!candidate)
+        return { status: "not-required", reason: "candidate_unavailable" };
+    if (!input.verificationRequired)
+        return { status: "not-required", reason: "verification_not_configured" };
+    if (!input.plan)
+        return { status: "not-configured", candidate: { head: candidate.head, tree: candidate.tree } };
+    const runBootstrap = dependencies.runBootstrap ?? runWorktreeBootstrap;
+    const observation = await runBootstrap({ cwd: input.candidateResult.cwd, plan: input.plan, captureOutput: true });
+    if (!isBootstrapSuccess(observation))
+        return observationFailure(input.plan, candidate, observation);
+    let integrity;
+    try {
+        integrity = await (dependencies.readIntegrity ?? readCandidateIntegrity)(input.candidateResult.cwd);
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            plan: preparationPlan(input.plan),
+            candidate: { head: candidate.head, tree: candidate.tree },
+            result: observation.result,
+            durationMs: observation.durationMs,
+            ...preparationOutput(observation),
+            cause: { code: "CANDIDATE_INTEGRITY_UNKNOWN", message: asMessage(error) },
+        };
+    }
+    if (integrity.head !== candidate.head || integrity.tree !== candidate.tree || integrity.trackedChanges.length > 0) {
+        return {
+            status: "failed",
+            plan: preparationPlan(input.plan),
+            candidate: { head: candidate.head, tree: candidate.tree },
+            result: observation.result,
+            durationMs: observation.durationMs,
+            ...preparationOutput(observation),
+            cause: { code: "CANDIDATE_INTEGRITY_CHANGED", message: "candidate HEAD, tree, or tracked worktree changed during preparation" },
+            integrity,
+        };
+    }
+    return {
+        status: "succeeded",
+        plan: preparationPlan(input.plan),
+        candidate: { head: candidate.head, tree: candidate.tree },
+        result: { kind: "exit", code: 0 },
+        durationMs: observation.durationMs,
+        ...preparationOutput(observation),
+        integrity,
+    };
 }

package/build/core/audit/coordinates.js

@@ -3,17 +3,12 @@ import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { FlowError, asMessage } from "../../flow-error.js";
 import { createGit, wrapGitError } from "../../git/core.js";
-import { readLedger } from "../ledger.js";
+import { effectiveCriteria } from "../amendment-criteria.js";
 import { hasStrandableProjectionGeneration } from "../projection/index.js";
-import { readRenewRecoverySession } from "../renew-session.js";
-import { effectiveScope, findOpenArc, getFence, getMaxArc, receiptsAfterFence } from "../seal.js";
-import { queueMembership, readQueueReadModel } from "../settlement/queue.js";
-import { markdownSourceSections } from "../scope.js";
-import { normalizeSectionTitle } from "../markdown/titles.js";
-import { commissionTarget, latestBase } from "../status/drift.js";
-import { deriveContractState, isTerminalState } from "../status/lifecycle.js";
-import { resolveContractDeliveryCwd } from "../worktree-path.js";
-import { KEIYAKU_FILE } from "../../keiyaku.js";
+import { admitRepositoryLifecycleContract, } from "../repository-ledger/admission.js";
+import { lookupCurrentContract, readRepositoryLifecycle, } from "../repository-ledger/read-model.js";
+import { deriveQueueReadModel, queueMembership } from "../settlement/queue.js";
+import { findRegisteredContractWorktreePathFromModel } from "../worktree-path.js";
 async function resolveObject(cwd, revision, kind) {
     const git = createGit(cwd);
     try {
@@ -23,45 +18,62 @@ async function resolveObject(cwd, revision, kind) {
         throw wrapGitError(`rev-parse ${revision}^{${kind}}`, error, cwd);
     }
 }
-export function appendedScopeTerms(entries) {
-    return entries.flatMap((entry) => entry.kind === "amend" && entry.data.scopeDelta ? entry.data.scopeDelta.add : []);
+export function appendedScopeTerms(model) {
+    return model.history.flatMap(({ entry }) => entry.kind === "amend" && entry.data.scopeDelta ? entry.data.scopeDelta.add : []);
 }
-export function effectiveCriteria(entries) {
-    const bind = entries.find((entry) => entry.kind === "bind");
-    if (!bind)
-        return [];
-    const criteria = [...bind.data.checks];
-    for (const entry of entries) {
-        if (entry.kind !== "amend")
-            continue;
-        for (const section of markdownSourceSections(entry.data.amendment)) {
-            if (section.level !== 2 || normalizeSectionTitle(section.title) !== "checks")
-                continue;
-            for (const line of entry.data.amendment.slice(section.contentStart, section.end).split(/\r?\n/)) {
-                const match = line.match(/^\s*-\s+(.+)$/);
-                if (match)
-                    criteria.push(match[1].trim());
-            }
-        }
-    }
-    return criteria;
+function auditCriteria(model) {
+    const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
+    if (!bind || bind.kind !== "bind")
+        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} is missing folded bind terms`);
+    const amendments = model.history.flatMap(({ entry }) => entry.kind === "amend" ? [entry.data.amendment] : []);
+    return effectiveCriteria(bind.data.criteria, amendments);
+}
+function repositoryLifecycleDiseaseError(outcome) {
+    return new FlowError("INTERNAL_STATE", `contract ${outcome.contract} is unavailable because repository lifecycle evidence is ${outcome.status}`, {
+        facts: {
+            kind: "repository_lifecycle_disease",
+            contractId: outcome.contract,
+            status: outcome.status,
+            diagnostics: outcome.diagnostics.map((diagnostic) => ({
+                objectId: diagnostic.objectId,
+                code: diagnostic.code,
+                detail: diagnostic.detail,
+                ...(diagnostic.contract === undefined ? {} : { contract: diagnostic.contract }),
+            })),
+        },
+    });
 }
 async function pinLedgerCoordinates(input) {
-    const ledger = await readLedger(input.root, input.contractId);
-    if (!ledger)
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
-    const bind = ledger.entries.find((entry) => entry.kind === "bind");
-    const target = commissionTarget(ledger.entries);
-    const base = latestBase(ledger.entries);
-    if (!bind || !target || !base)
-        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} is missing pinned audit coordinates`);
+    const repository = await readRepositoryLifecycle(input.root);
+    const admission = admitRepositoryLifecycleContract(repository, input.contractId);
+    let model;
+    switch (admission.status) {
+        case "healthy":
+            model = admission.model;
+            break;
+        case "diseased":
+        case "isolated":
+        case "indeterminate":
+            throw repositoryLifecycleDiseaseError(admission);
+        case "absent":
+            throw new FlowError("CONTRACT_NOT_FOUND", `contract ${admission.contract} not found`);
+    }
+    if (repository.observedLedgerHead === null)
+        throw new FlowError("INTERNAL_STATE", "repository lifecycle ledger is absent");
+    const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
+    if (!bind || bind.kind !== "bind")
+        throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} is missing folded bind terms`);
     const [deliveryHead, deliveryTree, targetHead, targetTree] = await Promise.all([
-        resolveObject(input.root, input.deliveryRef, "commit"), resolveObject(input.root, input.deliveryRef, "tree"),
-        resolveObject(input.root, target.ref, "commit"), resolveObject(input.root, target.ref, "tree"),
+        resolveObject(input.root, model.resources.deliveryRef, "commit"), resolveObject(input.root, model.resources.deliveryRef, "tree"),
+        resolveObject(input.root, model.pins.target.ref, "commit"), resolveObject(input.root, model.pins.target.ref, "tree"),
     ]);
+    if (model.pins.target.approvedHead !== null && model.petition.state === "approved" && model.pins.target.approvedHead !== targetHead) {
+        throw new FlowError("INTERNAL_STATE", `target ref ${model.pins.target.ref} moved from approved petition pin`);
+    }
     return {
-        criteria: effectiveCriteria(ledger.entries), scope: effectiveScope(ledger.entries), appendScope: appendedScopeTerms(ledger.entries), base, entries: ledger.entries,
-        coordinates: { ledger: { head: ledger.head }, delivery: { ref: input.deliveryRef, head: deliveryHead, tree: deliveryTree }, target: { ref: target.ref, head: targetHead, tree: targetTree } },
+        criteria: auditCriteria(model), scope: [...model.effectiveScope], appendScope: appendedScopeTerms(model), base: model.pins.base,
+        lifecycle: model, repository,
+        coordinates: { ledger: { head: repository.observedLedgerHead }, delivery: { ref: model.resources.deliveryRef, head: deliveryHead, tree: deliveryTree }, target: { ref: model.pins.target.ref, head: targetHead, tree: targetTree } },
     };
 }
 async function deliveryResidue(cwd) {
@@ -75,11 +87,6 @@ async function deliveryResidue(cwd) {
             continue;
         const xy = field.slice(0, 2);
         const filePath = field.slice(3);
-        if (filePath === KEIYAKU_FILE || filePath.startsWith(".keiyaku/recovery/")) {
-            if (xy[0] === "R" || xy[0] === "C")
-                index += 1;
-            continue;
-        }
         if (xy === "??")
             untracked.add(filePath);
         else {
@@ -119,44 +126,88 @@ async function deliveryCoordinate(cwd) {
     const [head, tree, residue] = await Promise.all([resolveObject(cwd, "HEAD", "commit"), resolveObject(cwd, "HEAD", "tree"), deliveryResidue(cwd)]);
     return { head, tree, residue, residueFingerprint: await residueFingerprint(cwd, residue) };
 }
+async function checkedOutRef(cwd) {
+    try {
+        return (await createGit(cwd).raw(["symbolic-ref", "--quiet", "HEAD"])).trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function receiptsAfterPinnedFence(input) {
+    const fence = input.model.pins.delivery;
+    try {
+        return (await createGit(input.root).raw(["rev-list", "--reverse", `${fence}..${input.deliveryHead}`]))
+            .split(/\r?\n/).filter(Boolean);
+    }
+    catch (error) {
+        throw wrapGitError(`rev-list ${fence}..${input.deliveryHead}`, error, input.root);
+    }
+}
 async function readReadiness(input) {
-    const bind = input.frozen.entries.find((entry) => entry.kind === "bind");
-    const lifecycle = deriveContractState(input.frozen.entries);
-    const [residue, looseCommits, session, queue, liveProjection, dependencies] = await Promise.all([
-        deliveryResidue(input.deliveryCwd), receiptsAfterFence(input.root, input.frozen.entries, input.frozen.coordinates.delivery.head), readRenewRecoverySession(input.root, input.contractId), readQueueReadModel(input.root),
+    const model = input.frozen.lifecycle;
+    const [residue, looseCommits, queue, liveProjection, dependencies] = await Promise.all([
+        deliveryResidue(input.deliveryCwd), receiptsAfterPinnedFence({ root: input.root, model, deliveryHead: input.frozen.coordinates.delivery.head }), Promise.resolve(deriveQueueReadModel(input.frozen.repository)),
         hasStrandableProjectionGeneration({ cwd: input.root, commissionId: input.contractId, deliveryWorktree: input.deliveryCwd, nowMs: Date.now() }),
-        Promise.all((bind.data.after ?? []).map(async (id) => { const ledger = await readLedger(input.root, id); const state = ledger ? deriveContractState(ledger.entries) : { state: "missing" }; return { id, satisfied: ledger !== null && isTerminalState(state), state: state.state }; })),
+        Promise.resolve(model.causal.after.map((id) => {
+            const outcome = lookupCurrentContract(input.frozen.repository, id);
+            const state = outcome.status === "healthy" ? outcome.model.phase : outcome.status;
+            return { id, satisfied: outcome.status === "healthy" && (state === "claimed" || state === "forfeited"), state };
+        })),
     ]);
     const membership = queueMembership(queue, input.contractId);
-    return { deliveryResidue: residue, arc: { open: findOpenArc(input.frozen.entries)?.data.arc ?? (getMaxArc(input.frozen.entries) === 0 ? 0 : null), max: getMaxArc(input.frozen.entries), fence: getFence(input.frozen.entries), looseCommits }, renewSession: { open: session !== null }, rewriteGuard: { liveProjection }, dependencies, petition: { state: lifecycle.state, queue: membership ? { position: membership.position, length: membership.queueLength, head: membership.queueHead, diagnostics: membership.diagnostics.map((item) => item.kind) } : null } };
+    return { deliveryResidue: residue, arc: { open: model.phase === "active" ? model.intent.arc : null, max: model.intent.arc, fence: model.pins.delivery, looseCommits }, rewriteGuard: { liveProjection }, dependencies, petition: { state: model.phase, queue: membership ? { position: membership.position, length: membership.queueLength, head: membership.queueHead, diagnostics: membership.diagnostics.map((item) => item.kind) } : null } };
 }
 export async function pinAuditSnapshot(input) {
     const contractId = input.address.binding.commissionId;
     const root = input.address.repo.stableRoot;
-    const deliveryRef = `refs/heads/keiyaku/${contractId}`;
-    return pinLedgerCoordinates({ root, contractId, deliveryRef });
+    return pinLedgerCoordinates({ root, contractId });
 }
 export function initialCoordinateRace(input) {
     return { which: "delivery-worktree", pinned: input.frozen.coordinates.delivery, observed: input.observed };
 }
+async function authoritativeDeliveryCwd(root, model) {
+    const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
+    if (!bind || bind.kind !== "bind")
+        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} is missing folded bind terms`);
+    if (bind.data.workspace === "here")
+        return fs.realpath(root);
+    const worktree = model.resources.worktree;
+    if (!worktree || worktree.state !== "held" || worktree.place !== bind.data.place) {
+        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} has no held worktree matching folded bind place ${bind.data.place}`);
+    }
+    const registered = await findRegisteredContractWorktreePathFromModel(root, model);
+    if (!registered) {
+        throw new FlowError("INTERNAL_STATE", `contract ${model.contract} has no Git-registered delivery worktree at folded bind place ${bind.data.place}`);
+    }
+    return registered;
+}
 export async function pinAuditCoordinates(input) {
+    const frozen = await pinAuditSnapshot({ address: input.address });
+    return completeAuditCoordinates({ address: input.address, frozen, deliveryCwd: input.deliveryCwd });
+}
+/** Expensive worktree/readiness capture performed after repository admission is released. */
+export async function completeAuditCoordinates(input) {
     const contractId = input.address.binding.commissionId;
     const root = input.address.repo.stableRoot;
-    const frozen = await pinAuditSnapshot({ address: input.address });
-    const deliveryCwd = await resolveContractDeliveryCwd(input.cwd, contractId);
+    const frozen = input.frozen;
+    const deliveryCwd = await authoritativeDeliveryCwd(root, frozen.lifecycle);
+    if (input.deliveryCwd && path.resolve(input.deliveryCwd) !== path.resolve(deliveryCwd)) {
+        throw new Error(`observed delivery worktree ${deliveryCwd} does not match expected worktree ${input.deliveryCwd}`);
+    }
     const coordinate = await deliveryCoordinate(deliveryCwd);
-    if (coordinate.head !== frozen.coordinates.delivery.head || coordinate.tree !== frozen.coordinates.delivery.tree)
-        throw new Error(`registered delivery worktree ${coordinate.head}/${coordinate.tree} does not match pinned delivery ref ${frozen.coordinates.delivery.head}/${frozen.coordinates.delivery.tree}`);
+    const branchRef = await checkedOutRef(deliveryCwd);
+    if (branchRef !== frozen.coordinates.delivery.ref || coordinate.head !== frozen.coordinates.delivery.head || coordinate.tree !== frozen.coordinates.delivery.tree)
+        throw new Error(`registered delivery worktree ${branchRef ?? "detached"} ${coordinate.head}/${coordinate.tree} does not match pinned delivery ref ${frozen.coordinates.delivery.ref} ${frozen.coordinates.delivery.head}/${frozen.coordinates.delivery.tree}`);
     const readiness = await readReadiness({ root, deliveryCwd, contractId, frozen });
     return { ...frozen, deliveryCwd, deliveryCoordinate: coordinate, readiness };
 }
 export async function rereadCoordinateRace(input) {
     const contractId = input.address.binding.commissionId;
     const root = input.address.repo.stableRoot;
-    const deliveryRef = `refs/heads/keiyaku/${contractId}`;
     let after;
     try {
-        after = await pinLedgerCoordinates({ root, contractId, deliveryRef });
+        after = await pinLedgerCoordinates({ root, contractId });
     }
     catch (error) {
         return { which: "ledger", pinned: input.frozen.coordinates.ledger, observed: asMessage(error) };
@@ -168,10 +219,14 @@ export async function rereadCoordinateRace(input) {
     if (after.coordinates.target.head !== input.frozen.coordinates.target.head || after.coordinates.target.tree !== input.frozen.coordinates.target.tree)
         return { which: "target", pinned: input.frozen.coordinates.target, observed: after.coordinates.target };
     try {
-        const deliveryCwd = await resolveContractDeliveryCwd(input.cwd, contractId);
+        const deliveryCwd = await authoritativeDeliveryCwd(root, after.lifecycle);
+        if (input.deliveryCwd && path.resolve(input.deliveryCwd) !== path.resolve(deliveryCwd)) {
+            return { which: "delivery-worktree", pinned: { cwd: input.frozen.deliveryCwd, ...input.frozen.deliveryCoordinate }, observed: { cwd: deliveryCwd, expected: input.deliveryCwd } };
+        }
         const observed = await deliveryCoordinate(deliveryCwd);
-        if (path.resolve(deliveryCwd) !== path.resolve(input.frozen.deliveryCwd) || observed.head !== input.frozen.deliveryCoordinate.head || observed.tree !== input.frozen.deliveryCoordinate.tree || observed.residueFingerprint !== input.frozen.deliveryCoordinate.residueFingerprint)
-            return { which: "delivery-worktree", pinned: { cwd: input.frozen.deliveryCwd, ...input.frozen.deliveryCoordinate }, observed: { cwd: deliveryCwd, ...observed } };
+        const branchRef = await checkedOutRef(deliveryCwd);
+        if (branchRef !== input.frozen.coordinates.delivery.ref || path.resolve(deliveryCwd) !== path.resolve(input.frozen.deliveryCwd) || observed.head !== input.frozen.deliveryCoordinate.head || observed.tree !== input.frozen.deliveryCoordinate.tree || observed.residueFingerprint !== input.frozen.deliveryCoordinate.residueFingerprint)
+            return { which: "delivery-worktree", pinned: { cwd: input.frozen.deliveryCwd, ref: input.frozen.coordinates.delivery.ref, ...input.frozen.deliveryCoordinate }, observed: { cwd: deliveryCwd, ref: branchRef, ...observed } };
     }
     catch (error) {
         return { which: "delivery-worktree", pinned: { cwd: input.frozen.deliveryCwd, ...input.frozen.deliveryCoordinate }, observed: asMessage(error) };

package/build/core/audit/evidence.js

@@ -1,6 +1,6 @@
 import { FlowError, asMessage } from "../../flow-error.js";
 import { scopePathEvidence } from "../scope.js";
-import { verificationExecutor, resolveVerificationCommands, runVerificationCommand } from "../settlement/verification.js";
+import { composeVerificationPlan, runVerificationPlan, resolveVerificationPolicy } from "../settlement/verification.js";
 function importLine(line) {
     return /^(?:import\b|export\s+(?:\*|\{)|(?:const|let|var)\s+[^=]+\s*=\s*require\s*\(|[^=]+\brequire\s*\(|[^=]+\bimport\s*\()/.test(line.content.trim());
 }
@@ -118,32 +118,28 @@ export function presentDiff(input) {
     return { budget: { limit: budget, used }, selected: selected.sort((left, right) => left.path.localeCompare(right.path) || (left.hunk ?? -1) - (right.hunk ?? -1)), omissions };
 }
 function fileFacts(diff, scope) { return diff.files.map((file, index) => { const row = scope[index]; return { path: file.path, ...(file.oldPath ? { oldPath: file.oldPath } : {}), status: file.status, stats: { insertions: file.insertions, deletions: file.deletions, binary: file.binary }, matcher: row.matcher, explanations: row.explanations, residue: row.residue, class: row.class }; }); }
-export async function evaluateVerification(cwd, head) {
-    let commands;
+export async function resolveAuditVerificationPlan(input) {
+    let policy;
     try {
-        commands = await resolveVerificationCommands(cwd);
+        policy = await resolveVerificationPolicy(input.cwd);
     }
     catch (error) {
-        return { status: "unknown", cause: { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) }, results: [] };
+        return { status: "unknown", cause: { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) } };
     }
-    if (commands.length === 0)
+    const plan = composeVerificationPlan({ contract: input.contract, repositoryGates: policy.commands, timeoutMs: policy.timeoutMs });
+    return { status: "resolved", plan };
+}
+export async function evaluateVerification(input) {
+    const plan = input.plan;
+    if (plan.length === 0)
         return { status: "not_configured", results: [] };
-    const results = [];
-    for (const command of commands) {
-        const argv = [command.command, ...command.args];
-        const known = verificationExecutor(command);
-        if ("cause" in known) {
-            results.push({ status: "unverifiable", label: command.label, command: command.command, argv, head, cause: known.cause });
-            continue;
-        }
-        try {
-            const execution = await runVerificationCommand(cwd, command);
-            results.push({ status: "executed", label: command.label, executor: known.executor, body: known.body, command: command.command, argv, head, exitCode: execution.code, durationMs: execution.durationMs, stdout: execution.stdout, stderr: execution.stderr });
-        }
-        catch (error) {
-            return { status: "unknown", cause: { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) }, results: [] };
-        }
-    }
+    const executed = await runVerificationPlan({ cwd: input.cwd, candidate: { head: input.candidate.head, tree: input.candidate.tree }, plan, signal: input.signal, coordinationKey: input.coordinationKey, coordinationRoot: input.coordinationRoot });
+    const results = executed.map((result) => {
+        const common = { source: result.source, declaration: result.declaration, label: result.label, executor: result.executor, command: result.command, argv: [result.command, ...result.args], candidate: result.candidate };
+        if (result.execution.status === "runner_failed")
+            return { ...common, ...result.execution };
+        return { status: "executed", ...common, body: result.shell ? result.command : result.args.at(-1) ?? "", exitCode: result.execution.code, durationMs: result.execution.durationMs, stdout: result.execution.stdout, stderr: result.execution.stderr };
+    });
     return { status: "evaluated", results };
 }
 export async function collectEvidence(input) {
@@ -154,5 +150,5 @@ export async function collectEvidence(input) {
         return null;
     const diff = input.diff;
     const scope = await evaluateScope({ cwd: input.candidateResult.cwd, frozen: input.frozen, diff });
-    return { diff, scope, presentation: presentDiff({ diff, scope, budget: input.diffBudgetBytes, retrievalCoordinates: { from: input.frozen.base, to: input.frozen.coordinates.delivery.head } }), files: fileFacts(diff, scope), verification: await evaluateVerification(input.candidateResult.cwd, candidate.head), candidate };
+    return { diff, scope, presentation: presentDiff({ diff, scope, budget: input.diffBudgetBytes, retrievalCoordinates: { from: input.frozen.base, to: input.frozen.coordinates.delivery.head } }), files: fileFacts(diff, scope), verification: input.verificationOverride ?? await evaluateVerification({ cwd: input.candidateResult.cwd, candidate, plan: input.verificationPlan, signal: input.signal, coordinationKey: input.coordinationKey, coordinationRoot: input.coordinationRoot }), candidate };
 }

package/build/core/audit/facade.js

@@ -1,27 +1,50 @@
-import { createAuditCandidate, disposeAuditCandidate, readAuditCandidateDiff } from "./candidate.js";
-import { initialCoordinateRace, pinAuditCoordinates, pinAuditSnapshot, rereadCoordinateRace } from "./coordinates.js";
-import { collectEvidence } from "./evidence.js";
+import { createAuditCandidate, disposeAuditCandidate, prepareAuditCandidate, readAuditCandidateDiff } from "./candidate.js";
+import { completeAuditCoordinates, initialCoordinateRace, pinAuditSnapshot, rereadCoordinateRace } from "./coordinates.js";
+import { collectEvidence, resolveAuditVerificationPlan } from "./evidence.js";
 import { collectFindings, emptyRaceReport } from "./report.js";
 import { readinessFromFacts } from "./readiness.js";
 export async function auditContract(input) {
     const contractId = input.address.binding.commissionId;
+    const frozenSnapshot = await pinAuditSnapshot({ address: input.address });
+    const bind = frozenSnapshot.lifecycle.history.find(({ entry }) => entry.kind === "bind")?.entry;
+    const contractVerification = bind?.kind === "bind" ? bind.data.verification : [];
+    const admission = {
+        frozen: frozenSnapshot,
+        contractVerification,
+    };
     let frozen;
     try {
-        frozen = await pinAuditCoordinates({ cwd: input.cwd, address: input.address });
+        frozen = await completeAuditCoordinates({ address: input.address, frozen: admission.frozen });
     }
     catch (error) {
-        const fallback = await pinAuditSnapshot({ address: input.address }).catch(() => null);
-        if (!fallback)
-            throw error;
+        const fallback = admission.frozen;
         return emptyRaceReport({ contractId, coordinates: fallback.coordinates, terms: { criteria: fallback.criteria, scope: fallback.scope, appendScope: fallback.appendScope }, detail: error instanceof Error ? error.message : String(error), race: initialCoordinateRace({ frozen: fallback, observed: error instanceof Error ? error.message : String(error) }) });
     }
     const candidateResult = await createAuditCandidate({ root: input.address.repo.stableRoot, contractId, frozen });
     let evidence = null;
     let verification;
+    let candidatePreparation = { status: "not-required", reason: "candidate_unavailable" };
     try {
+        let verificationPlan = [];
+        let verificationOverride;
+        if (candidateResult.candidate) {
+            const planResolution = await resolveAuditVerificationPlan({ cwd: candidateResult.cwd, contract: admission.contractVerification });
+            if (planResolution.status === "unknown") {
+                candidatePreparation = { status: "not-required", reason: "verification_plan_unavailable" };
+                verificationOverride = { status: "unknown", cause: planResolution.cause, results: [] };
+            }
+            else {
+                verificationPlan = planResolution.plan;
+                const lifecycleBind = frozen.lifecycle.history.find(({ entry }) => entry.kind === "bind")?.entry;
+                candidatePreparation = await prepareAuditCandidate({ candidateResult, verificationRequired: verificationPlan.length > 0, plan: lifecycleBind?.kind === "bind" && lifecycleBind.data.workspace === "worktree" ? lifecycleBind.data.bootstrap : undefined });
+                if (candidatePreparation.status === "failed") {
+                    verificationOverride = { status: "not_evaluated", reason: "candidate_preparation_failed", results: [] };
+                }
+            }
+        }
         const diff = await readAuditCandidateDiff(candidateResult);
-        evidence = await collectEvidence({ candidateResult, frozen, diff, diffBudgetBytes: input.diffBudgetBytes ?? 32_000 });
-        verification = evidence?.verification ?? { status: "not_evaluated", reason: candidateResult.rehearsal.status === "conflict" ? "renew_conflict" : "renew_unknown", results: [] };
+        evidence = await collectEvidence({ candidateResult, frozen, diff, diffBudgetBytes: input.diffBudgetBytes ?? 32_000, verificationPlan, signal: input.signal, coordinationKey: JSON.stringify({ repository: input.address.repo.stableRoot, candidate: candidateResult.candidate, preparation: bind?.kind === "bind" && bind.data.workspace === "worktree" ? bind.data.bootstrap : null, plan: verificationPlan }), coordinationRoot: input.address.repo.stableRoot, ...(verificationOverride ? { verificationOverride } : {}) });
+        verification = evidence?.verification ?? verificationOverride ?? { status: "not_evaluated", reason: candidateResult.rehearsal.status === "conflict" ? "renew_conflict" : "renew_unknown", results: [] };
         await input.afterEvidence?.();
     }
     finally {
@@ -37,6 +60,6 @@ export async function auditContract(input) {
         return emptyRaceReport({ contractId, coordinates: frozen.coordinates, terms: { criteria: frozen.criteria, scope: frozen.scope, appendScope: frozen.appendScope }, detail, race });
     }
     const readiness = readinessFromFacts(frozen.readiness);
-    const findings = collectFindings({ contractId, deliveryCwd: frozen.deliveryCwd, rehearsal: candidateResult.rehearsal, scope: evidence?.scope ?? null, verification, readiness });
-    return { contract: contractId, coordinates: frozen.coordinates, terms: { criteria: frozen.criteria, scope: frozen.scope, appendScope: frozen.appendScope }, rehearsal: candidateResult.rehearsal, candidate: evidence ? (evidence.candidate.rewritten ? { kind: "renew-rehearsal", base: evidence.candidate.base, head: evidence.candidate.head, tree: evidence.candidate.tree, deliveryHead: frozen.coordinates.delivery.head, targetHead: frozen.coordinates.target.head } : { kind: "delivery", base: evidence.candidate.base, head: evidence.candidate.head, tree: evidence.candidate.tree }) : null, diff: evidence?.diff ?? null, presentation: evidence?.presentation ?? null, files: evidence?.files ?? null, scope: evidence?.scope ?? null, verification, readiness, findings, counts: { files: evidence?.files.length ?? 0, selected: evidence?.presentation.selected.length ?? 0, omitted: evidence?.presentation.omissions.length ?? 0, inScope: evidence?.scope.filter((row) => row.class === "in-scope").length ?? 0, downgraded: evidence?.scope.filter((row) => row.class === "downgraded").length ?? 0, violated: evidence?.scope.filter((row) => row.class === "violated").length ?? 0, findings: findings.length } };
+    const findings = collectFindings({ contractId, deliveryCwd: frozen.deliveryCwd, rehearsal: candidateResult.rehearsal, scope: evidence?.scope ?? null, candidatePreparation, verification, readiness });
+    return { contract: contractId, coordinates: frozen.coordinates, terms: { criteria: frozen.criteria, scope: frozen.scope, appendScope: frozen.appendScope }, rehearsal: candidateResult.rehearsal, candidate: evidence ? (evidence.candidate.rewritten ? { kind: "renew-rehearsal", base: evidence.candidate.base, head: evidence.candidate.head, tree: evidence.candidate.tree, deliveryHead: frozen.coordinates.delivery.head, targetHead: frozen.coordinates.target.head } : { kind: "delivery", base: evidence.candidate.base, head: evidence.candidate.head, tree: evidence.candidate.tree }) : null, diff: evidence?.diff ?? null, presentation: evidence?.presentation ?? null, files: evidence?.files ?? null, scope: evidence?.scope ?? null, candidatePreparation, verification, readiness, findings, counts: { files: evidence?.files.length ?? 0, selected: evidence?.presentation.selected.length ?? 0, omitted: evidence?.presentation.omissions.length ?? 0, inScope: evidence?.scope.filter((row) => row.class === "in-scope").length ?? 0, downgraded: evidence?.scope.filter((row) => row.class === "downgraded").length ?? 0, violated: evidence?.scope.filter((row) => row.class === "violated").length ?? 0, findings: findings.length } };
 }

package/build/core/audit/report.js

@@ -9,12 +9,14 @@ export function collectFindings(input) {
         findings.push({ code: "RENEW_UNKNOWN", detail: `${input.rehearsal.cause.code}: ${input.rehearsal.cause.message}`, nextCommand: `${selector} audit` });
     for (const row of input.scope?.filter((item) => item.class === "violated") ?? [])
         findings.push({ code: "SCOPE_RESIDUE", detail: `${row.path}: ${row.residue.length} unexplained changes`, nextCommand: `${selector} amend --scope-add ${JSON.stringify(row.path)}` });
+    if (input.candidatePreparation.status === "failed")
+        findings.push({ code: "CANDIDATE_PREPARATION_FAILED", detail: `${input.candidatePreparation.cause.code}: ${input.candidatePreparation.cause.message}`, nextCommand: `${selector} audit` });
     if (input.verification.status === "evaluated") {
         for (const result of input.verification.results) {
             if (result.status === "executed" && result.exitCode !== 0)
                 findings.push({ code: "VERIFICATION_FAILED", detail: `${result.label} exited ${result.exitCode}`, nextCommand: result.command });
-            if (result.status === "unverifiable")
-                findings.push({ code: "VERIFICATION_UNVERIFIABLE", detail: `${result.label}: ${result.cause}`, nextCommand: result.command });
+            if (result.status === "runner_failed")
+                findings.push({ code: "VERIFICATION_UNKNOWN", detail: `${result.source} ${result.label}: ${result.cause.code}: ${result.cause.message}`, nextCommand: result.command });
         }
     }
     const residue = input.readiness.deliveryResidue;
@@ -22,8 +24,6 @@ export function collectFindings(input) {
         findings.push({ code: "DELIVERY_RESIDUE", detail: `registered delivery worktree has uncommitted residue at ${input.deliveryCwd}`, nextCommand: `git -C ${JSON.stringify(input.deliveryCwd)} status --short` });
     if (input.readiness.arc.max > 0 && input.readiness.arc.open === null && input.readiness.arc.looseCommits.length > 0)
         findings.push({ code: "LOOSE_COMMITS", detail: `${input.readiness.arc.looseCommits.length} loose commits after fence`, nextCommand: `printf '# Continue\\n\\n## Objective\\nReceipt loose commits.\\n\\n## Brief\\nContinue delivery.\\n' | ${selector} arc` });
-    if (input.readiness.renewSession.open)
-        findings.push({ code: "RENEW_SESSION_OPEN", detail: "renew recovery session is open", nextCommand: `${selector} renew --continue` });
     if (input.readiness.rewriteGuard.liveProjection)
         findings.push({ code: "LIVE_REWRITE_GUARD", detail: "a live projection owns the delivery worktree", nextCommand: "keiyaku status" });
     for (const dependency of input.readiness.dependencies.filter((item) => !item.satisfied))
@@ -34,5 +34,5 @@ export function collectFindings(input) {
 }
 export function emptyRaceReport(input) {
     const findings = [{ code: "COORDINATE_RACE", detail: input.detail, nextCommand: `keiyaku @${input.contractId} audit`, race: input.race }];
-    return { contract: input.contractId, coordinates: input.coordinates, terms: input.terms, rehearsal: { status: "unknown", cause: { code: "COORDINATE_RACE", message: input.detail } }, candidate: null, diff: null, presentation: null, files: null, scope: null, verification: { status: "not_evaluated", reason: "coordinate_race", results: [] }, readiness: null, findings, counts: { files: 0, selected: 0, omitted: 0, inScope: 0, downgraded: 0, violated: 0, findings: 1 } };
+    return { contract: input.contractId, coordinates: input.coordinates, terms: input.terms, rehearsal: { status: "unknown", cause: { code: "COORDINATE_RACE", message: input.detail } }, candidate: null, diff: null, presentation: null, files: null, scope: null, candidatePreparation: { status: "not-required", reason: "coordinate_race" }, verification: { status: "not_evaluated", reason: "coordinate_race", results: [] }, readiness: null, findings, counts: { files: 0, selected: 0, omitted: 0, inScope: 0, downgraded: 0, violated: 0, findings: 1 } };
 }