@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/core/settlement/petition-preview.js

@@ -1,8 +1,9 @@
 import { createOathGate } from "./petition-claim-gates.js";
-import { assertFoldedPetitionable, } from "./petition.js";
+import { assertFoldedPetitionable, precedingRenewSealResult, } from "./petition.js";
 import { captureFoldedSeal } from "../seal.js";
 import { withContractCarrierSession } from "../contract-carrier.js";
 import { FlowError } from "../../flow-error.js";
+import { normalizeScopePattern } from "../scope.js";
 export const PETITION_PREVIEW_GATE_NAMES = [
     "contract",
     "freshness",
@@ -44,6 +45,7 @@ export async function previewPetition(input) {
         const base = session.lifecycle.pins.base;
         const target = { ref: session.lifecycle.pins.target.ref, branch: session.lifecycle.pins.target.ref.slice("refs/heads/".length) };
         const context = { lifecycle: session.lifecycle, deliveryCwd: session.target.root, base, target };
+        const appendScope = (input.appendScope ?? []).map(normalizeScopePattern);
         const gates = [{ name: "contract", result: "pass" }];
         const freshness = await gate("freshness", async () => {
             if (!session.pins.target.head || context.base !== session.pins.target.head) {
@@ -58,15 +60,28 @@ export async function previewPetition(input) {
             })
             : notEvaluated("arc");
         gates.push(arc);
-        const state = await gate("state", () => {
-            assertFoldedPetitionable(input.contractId, context.lifecycle);
+        const state = await gate("state", async () => {
+            await assertFoldedPetitionable(input.contractId, context.lifecycle, session.repository, session.stableRoot);
         });
         gates.push(state);
         let seal;
+        let scopeWarning = null;
         if (freshness.result === "pass" && arc.result === "pass" && state.result === "pass") {
             try {
-                const capture = await captureFoldedSeal(context.deliveryCwd, context.lifecycle, "HEAD");
-                seal = { name: "seal", result: "pass", detail: sealFileDetail(capture?.diffstat.files ?? 0) };
+                const precedingRenewSeal = appendScope.length === 0
+                    ? await precedingRenewSealResult(context.deliveryCwd, context.lifecycle)
+                    : null;
+                const capture = precedingRenewSeal
+                    ? null
+                    : await captureFoldedSeal(context.deliveryCwd, context.lifecycle, "HEAD", appendScope, "warn");
+                const scope = precedingRenewSeal ?? capture;
+                if (scope?.scopeAudit.violations.length) {
+                    scopeWarning = {
+                        violations: [...scope.scopeAudit.violations],
+                        evidence: [...scope.scopeViolationEvidence],
+                    };
+                }
+                seal = { name: "seal", result: "pass", detail: sealFileDetail(scope?.diffstat.files ?? 0) };
             }
             catch (error) {
                 seal = { name: "seal", result: "failed", detail: failureDetail(error) };
@@ -102,6 +117,7 @@ export async function previewPetition(input) {
             contract: input.contractId,
             target: context.target.ref,
             arc: { source: { arc: context.lifecycle.phase === "active" ? context.lifecycle.intent.arc : null, fence: context.lifecycle.pins.delivery } },
+            scopeWarning,
             gates,
             verdict: gates.some((item) => item.result === "failed") ? "would_fail" : "would_succeed",
         };

package/build/core/settlement/petition.js

@@ -3,14 +3,44 @@ import { parseCommandMarkdown } from "../command-markdown.js";
 import { runLifecycle } from "../lifecycle-runner.js";
 import { queueMembership, readQueueReadModel } from "./queue.js";
 import { captureFoldedSeal } from "../seal.js";
-import { currentLifecycleState } from "../repository-ledger/read-model.js";
+import { currentLifecycleState, lookupCurrentContract } from "../repository-ledger/read-model.js";
 import { assertCleanTrackedWorkingTree } from "../../git/worktree.js";
-import { normalizeScopePattern } from "../scope.js";
-export function assertFoldedPetitionable(contractId, model) {
+import { normalizeScopePattern, scopePathEvidence } from "../scope.js";
+import { readRemainingTaskNeedsForSettlement } from "../task/settlement-policy.js";
+export async function assertFoldedPetitionable(contractId, model, repository, stableRoot) {
     const state = currentLifecycleState(model);
     if (state.state !== "active" && state.state !== "bound") {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition from state ${state.state}`);
     }
+    const unavailable = model.causal.after.filter((dependency) => {
+        const prerequisite = lookupCurrentContract(repository, dependency);
+        return prerequisite.status !== "healthy" ||
+            (prerequisite.model.phase !== "claimed" && prerequisite.model.phase !== "forfeited");
+    });
+    if (unavailable.length > 0) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition before after dependencies settle: ${unavailable.join(", ")}`);
+    }
+    const pendingNeeds = (await readRemainingTaskNeedsForSettlement(stableRoot, model.causal.needs))
+        .filter((need) => !need.satisfied);
+    if (pendingNeeds.length > 0) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot petition before task needs settle: ${pendingNeeds.map((need) => need.id).join(", ")}`);
+    }
+}
+/** Rehydrate the seal consumed by an immediately preceding renew without auditing a new segment. */
+export async function precedingRenewSealResult(cwd, lifecycle, renewIndex = lifecycle.history.length - 1) {
+    const renew = lifecycle.history[renewIndex]?.entry;
+    const seal = lifecycle.history[renewIndex - 1];
+    if (renew?.kind !== "renew" || seal?.entry.kind !== "seal" || seal.entry.data.sealedBy !== "renew")
+        return null;
+    return {
+        ...seal.entry.data,
+        receipts: [...seal.entry.data.receipts],
+        diffstat: { ...seal.entry.data.diffstat },
+        scopeAudit: { violations: [...seal.entry.data.scopeAudit.violations] },
+        scopeViolationEvidence: await scopePathEvidence(cwd, lifecycle.effectiveScope, seal.entry.data.scopeAudit.violations),
+        sealedBy: "renew",
+        ledgerHead: seal.objectId,
+    };
 }
 function nextSettlementSeat(read, target) {
     let floor = 0;
@@ -68,7 +98,7 @@ export async function petitionContract(input) {
                 const branch = target.slice("refs/heads/".length);
                 throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} must renew onto ${branch} before petition`, { facts: { kind: "needs_renew", contractId: input.contractId } });
             }
-            assertFoldedPetitionable(input.contractId, session.lifecycle);
+            await assertFoldedPetitionable(input.contractId, session.lifecycle, session.repository, session.stableRoot);
             return { lifecycle: session.lifecycle, deliveryCwd };
         },
         prepare: async (admission) => {
@@ -88,7 +118,7 @@ export async function petitionContract(input) {
                         receipts: [...acceptedSeal.data.receipts],
                         diffstat: { ...acceptedSeal.data.diffstat },
                         scopeAudit: { violations: [...acceptedSeal.data.scopeAudit.violations] },
-                        scopeViolationEvidence: [],
+                        scopeViolationEvidence: await scopePathEvidence(input.cwd, admission.business.lifecycle.effectiveScope, acceptedSeal.data.scopeAudit.violations),
                     };
                     prefixIndex -= 1;
                 }
@@ -101,13 +131,14 @@ export async function petitionContract(input) {
                 return {
                     additions: [],
                     capture,
+                    precedingRenewSeal: await precedingRenewSealResult(input.cwd, admission.business.lifecycle, admission.business.lifecycle.history.findIndex(({ objectId }) => objectId === transaction.entryObjectIds.at(-1)) - 1),
                     seat: accepted.data.seat,
                     targetHead: accepted.data.intent === "claim" ? accepted.data.targetHead : admission.pins.target.head ?? "",
                     existing: { transactionObjectId: transaction.transactionObjectId },
                 };
             }
             const scopeEntry = patterns.length === 0 ? null : {
-                v: 1,
+                v: 2,
                 kind: "amend",
                 contract: input.contractId,
                 at,
@@ -118,12 +149,12 @@ export async function petitionContract(input) {
             if (!deliveryCwd)
                 throw new FlowError("INTERNAL_STATE", `petition ${input.contractId} is missing its delivery worktree`);
             const lifecycle = admission.business.lifecycle;
-            const followsRenewWithoutInterveningFact = lifecycle.phase === "active"
-                && lifecycle.seal === null
-                && lifecycle.history.at(-1)?.entry.kind === "renew";
-            const capture = followsRenewWithoutInterveningFact
+            const precedingRenewSeal = patterns.length === 0
+                ? await precedingRenewSealResult(input.cwd, lifecycle)
+                : null;
+            const capture = precedingRenewSeal
                 ? null
-                : await captureFoldedSeal(deliveryCwd, lifecycle, "HEAD", patterns);
+                : await captureFoldedSeal(deliveryCwd, lifecycle, "HEAD", patterns, "warn");
             let sealEntry = null;
             if (capture) {
                 const { scopeViolationEvidence: _evidence, ...durableCapture } = capture;
@@ -145,6 +176,7 @@ export async function petitionContract(input) {
             return {
                 additions,
                 capture,
+                precedingRenewSeal,
                 seat: nextSettlementSeat(admission.repository, admission.pins.target.ref),
                 targetHead,
             };
@@ -169,7 +201,7 @@ export async function petitionContract(input) {
             const base = session.lifecycle.pins.base;
             if (base !== session.pins.target.head)
                 return { code: "PETITION_TARGET_CHANGED", message: "petition target/base facts changed during preparation" };
-            assertFoldedPetitionable(input.contractId, session.lifecycle);
+            await assertFoldedPetitionable(input.contractId, session.lifecycle, session.repository, session.stableRoot);
             return undefined;
         },
         effect: async ({ context, prepared }) => {
@@ -208,15 +240,15 @@ export async function petitionContract(input) {
                 ? await context.replayCommitted({ transactionObjectId: prepared.existing.transactionObjectId })
                 : await context.publishAuthoritative({
                     verb: "petition",
-                    admittedLedgerHead: context.session.lifecycle.observedLedgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    admittedLedgerHead: context.session.pins.repositoryLedgerHead,
+                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
                     entries: additions,
                 });
             if (result.status === "indeterminate") {
-                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.lifecycle.observedLedgerHead };
+                return { kind: "precommit-effects-only", authoritativeHead: result.currentHead ?? context.session.pins.repositoryLedgerHead };
             }
             if (result.status !== "committed") {
-                const authoritativeHead = result.currentHead ?? context.session.lifecycle.observedLedgerHead;
+                const authoritativeHead = result.currentHead ?? context.session.pins.repositoryLedgerHead;
                 return { kind: "refused-before-effects", authoritativeHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during petition` } };
             }
             if (input.reviewPersistence) {
@@ -254,7 +286,9 @@ export async function petitionContract(input) {
                     position,
                     seat: prepared.seat,
                     reviewHistoryPath,
-                    sealed: prepared.capture ? { ...prepared.capture, sealedBy: "petition", ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((entry) => entry.kind === "seal")] } : undefined,
+                    sealed: prepared.capture
+                        ? { ...prepared.capture, sealedBy: "petition", ledgerHead: result.transaction.entryObjectIds[result.transaction.entries.findIndex((entry) => entry.kind === "seal")] }
+                        : prepared.precedingRenewSeal ?? undefined,
                 },
             };
         },

package/build/core/settlement/settlement.js

@@ -1,9 +1,8 @@
 import { FlowError } from "../../flow-error.js";
 import { readCurrentContractContext } from "../context.js";
 import { convergeContractCarrier, withContractCarrierSession } from "../contract-carrier.js";
-import { createGit } from "../../git/core.js";
+import { requireCommitCoordinate } from "../../git/commits.js";
 import { getCurrentBranch, requireGitRepository } from "../../git/branches.js";
-import { getLatestCommitHash } from "../../git/staging.js";
 import { readContractLog } from "../log.js";
 import { scopePathEvidence } from "../scope.js";
 import { nextReviewResponseNumber } from "../transcripts.js";
@@ -45,15 +44,17 @@ async function pinnedCloseCandidate(cwd, contractId, signal) {
         if (session.target.status !== "available" || !session.pins.delivery.head) {
             throw new FlowError("INTERNAL_STATE", session.target.status === "available" ? `contract ${contractId} delivery ref does not resolve` : session.target.reason);
         }
-        const git = createGit(session.target.root);
-        const [head, tree] = await Promise.all([
-            git.raw(["rev-parse", "--verify", "HEAD^{commit}"]),
-            git.raw(["rev-parse", "--verify", "HEAD^{tree}"]),
-        ]);
-        if (head.trim() !== session.pins.delivery.head) {
+        const coordinate = await requireCommitCoordinate(session.target.root, "HEAD");
+        if (coordinate.commit !== session.pins.delivery.head) {
             throw new FlowError("INTERNAL_STATE", `contract ${contractId} delivery head changed while petition was being prepared`);
         }
-        return { deliveryCwd: session.target.root, candidate: { head: head.trim(), tree: tree.trim() }, contractVerification: contractVerificationDeclarations(session.lifecycle) };
+        const bind = session.lifecycle.history.find(({ entry }) => entry.kind === "bind")?.entry;
+        return {
+            deliveryCwd: session.target.root,
+            candidate: { head: coordinate.commit, tree: coordinate.tree },
+            contractVerification: contractVerificationDeclarations(session.lifecycle),
+            preparation: bind?.kind === "bind" && bind.data.workspace === "worktree" ? bind.data.bootstrap ?? null : null,
+        };
     });
 }
 async function loadCloseContext(cwd, requestedContractId, signal) {
@@ -66,6 +67,7 @@ async function loadCloseContext(cwd, requestedContractId, signal) {
             deliveryCwd: pinned.deliveryCwd,
             verificationCandidate: pinned.candidate,
             contractVerification: pinned.contractVerification,
+            verificationPreparation: pinned.preparation,
             keiyakuBranch: `keiyaku/${requestedContractId}`,
             baseBranch: lifecycle.pins.target.ref.slice("refs/heads/".length),
             contractId: requestedContractId,
@@ -88,6 +90,7 @@ async function loadCloseContext(cwd, requestedContractId, signal) {
         deliveryCwd: pinned.deliveryCwd,
         verificationCandidate: pinned.candidate,
         contractVerification: pinned.contractVerification,
+        verificationPreparation: pinned.preparation,
         keiyakuBranch,
         baseBranch: contractContext.baseBranch,
         contractId: contractContext.contractId,
@@ -107,14 +110,15 @@ async function throwClaimGateFailure(failure, _input, context, _dependencies) {
 }
 async function runClaimGatePipelineOrThrow(input, context, dependencies) {
     const deliveryCwd = context.deliveryCwd ?? context.cwd;
-    const verificationCandidate = context.verificationCandidate ?? {
-        head: await getLatestCommitHash(deliveryCwd),
-        tree: (await createGit(deliveryCwd).raw(["rev-parse", "--verify", "HEAD^{tree}"])).trim(),
-    };
+    const verificationCandidate = context.verificationCandidate ?? await (async () => {
+        const coordinate = await requireCommitCoordinate(deliveryCwd, "HEAD");
+        return { head: coordinate.commit, tree: coordinate.tree };
+    })();
+    const verificationPreparation = context.verificationPreparation ?? null;
     const gateConfig = await dependencies.resolveClaimGateConfig(context.cwd);
     const repositoryGates = gateConfig.repositoryGates ?? gateConfig.verificationCommands ?? [];
     const verificationPlan = composeVerificationPlan({ contract: context.contractVerification ?? [], repositoryGates, timeoutMs: gateConfig.verificationTimeoutMs });
-    const coordinationRoot = await stableRepoRoot(context.cwd);
+    const repositoryRoot = await stableRepoRoot(context.cwd);
     let review;
     let reviewHeadBeforeWrite;
     let reviewerActor;
@@ -123,11 +127,12 @@ async function runClaimGatePipelineOrThrow(input, context, dependencies) {
     for (const gate of buildClaimGatePipeline()) {
         const result = await gate.evaluate({
             cwd: deliveryCwd,
-            coordinationRoot,
+            repositoryRoot,
             contractId: context.contractId,
             input,
             verificationPlan,
             verificationCandidate,
+            verificationPreparation,
             baseBranch: dependencies.baseBranch,
             reviewNumber: dependencies.reviewNumber,
         });

package/build/core/settlement/verdict.js

@@ -103,12 +103,12 @@ export async function verdictContract(input) {
                     value: { result: admission.business.existing.result, summary: admission.business.existing.summary },
                 };
             }
-            const committed = await context.publishAuthoritative({ verb: "verdict", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId, entries: [prepared.entry] });
+            const committed = await context.publishAuthoritative({ verb: "verdict", admittedLedgerHead: admission.ledgerHead, acceptedLifecycleTail: context.session.lifecycle.contractHead, entries: [prepared.entry] });
             if (committed.status === "indeterminate") {
                 return { kind: "precommit-effects-only", authoritativeHead: committed.currentHead ?? admission.ledgerHead };
             }
             if (committed.status !== "committed") {
-                return { kind: "refused-before-effects", authoritativeHead: committed.currentHead ?? context.session.lifecycle.observedLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during verdict` } };
+                return { kind: "refused-before-effects", authoritativeHead: committed.currentHead ?? context.session.pins.repositoryLedgerHead, refusal: { code: "LEDGER_CAS_CONFLICT", message: `contract ${input.contractId} changed during verdict` } };
             }
             return {
                 kind: "committed",