@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/library/repo.js

@@ -1,13 +1,12 @@
-import { currentBranchOperation, NoGitWorldError, reconcileAllOperation, scopeOperation, } from "../protocol/operations.js";
-import { settleAll } from "../settlement/settle.js";
+import { currentBranchOperation, NoGitWorldError, scopeOperation, } from "../protocol/operations.js";
 import { optionalNonblank, requireInput } from "./input.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
-import { projectContractWorktree } from "../contract-worktree.js";
+import { completeRepoReconcile, } from "./reconcile.js";
 export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
-function resolvePinnedScope(path) {
-    return scopeOperation({ coordinate: path === undefined ? process.cwd() : path });
+async function resolvePinnedScope(path) {
+    return await scopeOperation({ coordinate: path === undefined ? process.cwd() : path });
 }
 export function reconcileInput(input) {
     const values = input === undefined ? undefined : requireInput(input, "reconcile input");
@@ -25,45 +24,21 @@ export class Repo {
         this.root = scope.primaryWorktree;
         REPO_SCOPES.set(this, scope);
     }
-    static at(input) {
+    static async at(input) {
         const values = input === undefined ? undefined : requireInput(input, "Repo.at input");
-        return new Repo(resolvePinnedScope(optionalNonblank(values?.path, "repository path")));
+        return new Repo(await resolvePinnedScope(optionalNonblank(values?.path, "repository path")));
     }
     async currentBranch() {
-        return currentBranchOperation({ scope: scopeForRepo(this) });
+        return await currentBranchOperation({ scope: scopeForRepo(this) });
     }
     async reconcile(input) {
         const scope = scopeForRepo(this);
-        return withGitDecodeChannel(scope, async (channel) => {
-            const options = reconcileInput(input);
-            const retained = await reconcileAllOperation({ scope, channel, ...options, retainTerminalWorktree: true });
-            const settlements = await settleAll({
-                repository: scope,
-                channel,
-                contracts: retained.contracts.map((contract) => ({
-                    state: contract.state,
-                    effects: contract.report.effects,
-                })),
-            });
-            const deferRemoval = retained.contracts.some((contract) => contract.state !== null && contract.state.terminal !== null
-                && contract.state.coordinates.workspace === "worktree");
-            const cleanup = deferRemoval ? await reconcileAllOperation({ scope, channel, ...options }) : null;
-            const later = cleanup === null ? null : new Map(cleanup.contracts.map((contract) => [contract.contractId, contract.report]));
-            return {
-                contracts: retained.contracts.map((contract, index) => {
-                    const report = later?.get(contract.contractId);
-                    const projection = projectContractWorktree(scope, contract.state);
-                    return {
-                        contractId: contract.contractId,
-                        report: {
-                            effects: [...contract.report.effects, ...projection.effects, ...(report?.effects ?? [])],
-                            lag: [...contract.report.lag, ...projection.lag, ...(report?.lag ?? [])],
-                            settlement: settlements[index],
-                        },
-                    };
-                }),
-            };
-        });
+        const options = reconcileInput(input);
+        return await withGitDecodeChannel(scope, (channel) => completeRepoReconcile({
+            scope,
+            channel,
+            ...options,
+        }));
     }
 }
 export function scopeForRepo(value) {

package/build/src/protocol/attempt.js

@@ -77,14 +77,14 @@ function recoveredAcceptance(observation, offer, primaryContract) {
         journal: record.entries,
     };
 }
-function publicationPremiseMoved(repository, observation, offer, assertions) {
-    if (readRef(repository, GIT_REF) !== observation.admission.snapshot.commit)
+async function publicationPremiseMoved(repository, observation, offer, assertions) {
+    if (await readRef(repository, GIT_REF) !== observation.admission.snapshot.commit)
         return true;
     for (const assertion of assertions)
-        if (readRef(repository, assertion.ref) !== assertion.oid)
+        if (await readRef(repository, assertion.ref) !== assertion.oid)
             return true;
     return offer.target !== undefined
-        && readRef(repository, offer.target.target) !== offer.target.expectedOid;
+        && await readRef(repository, offer.target.target) !== offer.target.expectedOid;
 }
 /** Admit one decided offer without making another legal decision. */
 export async function admitDecidedOffer(input) {
@@ -92,7 +92,7 @@ export async function admitDecidedOffer(input) {
     const assertions = input.assertions ?? [];
     validateOffer(offer, attempt);
     const primary = primaryAppend(offer, primaryContract);
-    const admission = admit(repository, offer, decisionObservation.admission, assertions);
+    const admission = await admit(repository, offer, decisionObservation.admission, assertions);
     if (admission.kind === "accepted") {
         return {
             kind: "accepted",
@@ -102,7 +102,7 @@ export async function admitDecidedOffer(input) {
         };
     }
     if (admission.kind === "publication-failed") {
-        return publicationPremiseMoved(repository, decisionObservation, offer, assertions)
+        return await publicationPremiseMoved(repository, decisionObservation, offer, assertions)
             ? { kind: "redecide" }
             : admission;
     }

package/build/src/protocol/bind.js

@@ -10,11 +10,11 @@ function contractIdFor(title, suffix) {
     const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
     return contractIdFromSegment(suffix === undefined ? stem : `${stem}-${suffix}`);
 }
-function bindPreparation(input, target, seed) {
+async function bindPreparation(input, target, seed) {
     if (input.verification.kind === "refused") {
         return { kind: "prepared", input: { ...seed, preparation: input.verification } };
     }
-    const observed = observeBindCoordinates(input.scope, target);
+    const observed = await observeBindCoordinates(input.scope, target);
     if (observed === null)
         return { kind: "refused", refusal: { kind: "target-missing" } };
     if (input.workspace === "here" && target !== undefined && observed.branch !== target) {
@@ -44,7 +44,7 @@ function bindPreparation(input, target, seed) {
 export async function bindOperation(input) {
     let target;
     if (input.target !== undefined) {
-        const normalized = normalizeTargetBranch(input.scope, input.target);
+        const normalized = await normalizeTargetBranch(input.scope, input.target);
         if (normalized === null)
             return { kind: "refused", refusal: { kind: "invalid-target" } };
         target = normalized;
@@ -56,7 +56,7 @@ export async function bindOperation(input) {
         at,
     }, decideBind, {
         observedContracts: [id, ...input.terms.after],
-        prepareInput: (_observation, original) => bindPreparation(input, target, original),
+        prepareInput: async (_observation, original) => bindPreparation(input, target, original),
         ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
     }), { contractId: id });
     if (input.contractId !== undefined)

package/build/src/protocol/intent.d.ts

@@ -5,7 +5,7 @@ import type { GitRefAssertion } from "../git/repository.js";
 import { type WorktreeLeak } from "../git/scratch.js";
 import type { HookFailure } from "../git/hooks.js";
 import type { DecideInput, OfferDecision } from "../core/decide.js";
-import type { ActorId, ContractId, ContractState } from "../core/facts/types.js";
+import type { ActorId, ContractId, ContractState, EntryUlid, SnapshotId } from "../core/facts/types.js";
 import { type AttestationRefusal } from "../core/verbs/attestation.js";
 import { type VerificationDefinition } from "../verification/declaration.js";
 import { type CompanionDecorator, type ProtocolResult } from "./run.js";
@@ -43,6 +43,7 @@ type VerifyDeliveryInput = Readonly<{
     actor?: ActorId;
     at: string;
     state: ContractState;
+    snapshot?: SnapshotId;
     environment: NodeJS.ProcessEnv;
     signal?: AbortSignal;
     verification?: VerificationDefinition;
@@ -68,9 +69,21 @@ export type VerificationCleanupFailure = Readonly<{
 export type VerificationStep = ProtocolResult<AttestationRefusal> | VerificationRuntimeStop;
 export type VerificationResult = Readonly<{
     step: VerificationStep;
+    counts?: Readonly<{
+        passed: number;
+        total: number;
+        verdict: "satisfied" | "unsatisfied";
+        summary?: string;
+    }>;
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;
 }>;
-/** Run Verification for an observed delivery, then tender its fact. */
+export type CurrentVerifiedAttestation = Readonly<{
+    entry: EntryUlid;
+    verdict: "satisfied" | "unsatisfied";
+}>;
+/** Read the latest current verified attestation through the generic currentness judge. */
+export declare function currentVerifiedAttestation(state: ContractState): CurrentVerifiedAttestation | undefined;
+/** Run Verification against an explicit or admitted integration snapshot. */
 export declare function verifyDelivery(input: VerifyDeliveryInput): Promise<VerificationResult | null>;
 export {};

package/build/src/protocol/intent.js

@@ -1,6 +1,7 @@
 import { materializeScratchCandidate } from "../git/scratch.js";
 import { projectSettings } from "../settings.js";
 import { dependencyKeySet } from "../core/subject.js";
+import { latestCurrentAttestations } from "../core/facts/gate.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
 import { executeVerification } from "../verification/execution.js";
 import { VERIFIED } from "../verification/declaration.js";
@@ -43,19 +44,23 @@ function verificationInput(outcome, input, subject) {
         },
     };
 }
-/** Run Verification for an observed delivery, then tender its fact. */
+/** Read the latest current verified attestation through the generic currentness judge. */
+export function currentVerifiedAttestation(state) {
+    const current = latestCurrentAttestations(state, new Set([VERIFIED])).get(VERIFIED);
+    return current === undefined ? undefined : { entry: current.entry, verdict: current.data.verdict };
+}
+/** Run Verification against an explicit or admitted integration snapshot. */
 export async function verifyDelivery(input) {
-    const state = input.state;
-    if (state.delivery === null
-        || input.verification === undefined)
+    const snapshot = input.snapshot ?? input.state.delivery?.data.integration.snapshot;
+    if (snapshot === undefined || input.verification === undefined)
         return null;
     const subject = dependencyKeySet([
-        { kind: "snapshot", value: state.delivery.data.integration.snapshot },
+        { kind: "snapshot", value: snapshot },
         { kind: "segment", value: input.verification.segment },
     ]);
     const execution = await executeVerification({
         repository: input.repository,
-        candidate: state.delivery.data.integration.snapshot,
+        candidate: snapshot,
         declarations: input.verification.declarations,
         environment: input.environment,
         materializeScratchCandidate,
@@ -84,6 +89,16 @@ export async function verifyDelivery(input) {
     }
     return {
         step,
+        ...(execution.outcome.kind === "terminal"
+            ? {
+                counts: {
+                    passed: execution.outcome.passed,
+                    total: execution.outcome.total,
+                    verdict: execution.outcome.verdict,
+                    ...(execution.outcome.summary === undefined ? {} : { summary: execution.outcome.summary }),
+                },
+            }
+            : {}),
         ...(execution.cleanup === undefined ? {} : { cleanup: execution.cleanup }),
         ...(execution.leak === undefined ? {} : { leak: execution.leak }),
     };

package/build/src/protocol/operations.d.ts

@@ -1,11 +1,11 @@
-import { type IntegrationPreparationRefusal } from "../git/integration.js";
+import { type DeliveryDiffScope, type IntegrationPreparationRefusal } from "../git/integration.js";
 import { type DirtyWorkspaceRefusal, type WorkspaceDirtyDelta } from "../git/tender.js";
 import { type ReconcileResult } from "../git/reconcile.js";
 import type { WorktreeHooks } from "../git/hooks.js";
 import { NoGitWorldError, type GitRepository } from "../git/repository.js";
 import { type GitDecodeChannel, type GitTreeSelection } from "../git/read-observation.js";
 import type { WorktreeLeak } from "../git/scratch.js";
-import type { ActorId, AmendData, ArcData, AttestationData, ContractId, ContractState, ContractTerms, DeliverData, DocumentKey, SnapshotId } from "../core/facts/types.js";
+import type { ActorId, AmendData, ArcData, AttestationData, ChangeId, ContractId, ContractState, ContractTerms, DeliverData, DocumentKey, SnapshotId } from "../core/facts/types.js";
 import { type AbandonRefusal } from "../core/verbs/abandon.js";
 import { type AmendRefusal } from "../core/verbs/amend.js";
 import { type ArcRefusal } from "../core/verbs/arc.js";
@@ -13,26 +13,27 @@ import { type DeliverRefusal } from "../core/verbs/deliver.js";
 import type { PlacementRefusal } from "../core/verbs/placement.js";
 import { type AttestationRefusal } from "../core/verbs/attestation.js";
 import type { VerificationDeclarationPreparation, VerificationDeclarationRefusal } from "../verification/declaration.js";
-import { type VerificationRuntimeStop, type VerificationCleanupFailure } from "./intent.js";
-import type { TargetPlacementRefusal } from "../git/target-placement.js";
-import { type AuditReport as AuditReadReport } from "./read/audit.js";
+import { type CurrentVerifiedAttestation, type VerificationRuntimeStop, type VerificationCleanupFailure } from "./intent.js";
+import { type AuditTargetAnswer, type TargetPlacementRefusal } from "../git/target-placement.js";
 import { type ContractDocumentProjection } from "./read/documents.js";
 import { type ContractBoard, type ContractDisposition, type ContractGateCurrent, type ContractGateReport, type ContractObservation, type ContractPhase, type ContractRow } from "./read/status.js";
+import { type ManagedWorktreeAppointment } from "../workspace-place.js";
 export { bindOperation } from "./bind.js";
+export { reconcileObservationFailure } from "../git/reconcile.js";
 import type { BindRefusal, TargetInputRefusal } from "./bind.js";
 import { type IntentOutcome as ProtocolIntentOutcome } from "./outcome.js";
 import type { ProtocolTerminal } from "./run.js";
 import type { CompanionDecorator } from "./run.js";
-export type { FactKind, TimelineEntry } from "./read/audit.js";
+export type { FactKind } from "../core/facts/types.js";
 export type { ContractDocumentProjection } from "./read/documents.js";
-type DeliveryPreparationRefusal = Readonly<{
+export type DeliveryPreparationRefusal = Readonly<{
     kind: "target-missing" | "worktree-missing";
     contractId: ContractId;
 }> | DirtyWorkspaceRefusal | IntegrationPreparationRefusal | TargetPlacementRefusal;
 type ReviewPreparationRefusal = Readonly<{
-    kind: "target-missing" | "worktree-missing";
+    kind: "worktree-missing";
     contractId: ContractId;
-}> | DirtyWorkspaceRefusal | IntegrationPreparationRefusal;
+}> | DirtyWorkspaceRefusal;
 type ReviewRefusal = AttestationRefusal | ReviewPreparationRefusal;
 export type IntentRefusal = AbandonRefusal | AmendRefusal | ArcRefusal | BindRefusal | DeliverRefusal | DeliveryPreparationRefusal | PlacementRefusal | ReviewRefusal | TargetInputRefusal | VerificationDeclarationRefusal;
 export type { TargetInputRefusal } from "./bind.js";
@@ -46,11 +47,47 @@ type OperationInput = Readonly<{
 type MutationOperationInput = OperationInput & Readonly<{
     channel: GitDecodeChannel;
 }>;
-export type AuditReport = AuditReadReport & Readonly<{
-    attempt?: VerificationStop;
-    cleanup?: VerificationCleanupFailure;
-    leak?: WorktreeLeak;
+export type AuditWorkspace = Readonly<{
+    kind: "worktree" | "here";
+    path: string;
+}>;
+export type DiffScope = DeliveryDiffScope;
+export type AuditReport = Readonly<{
+    candidate: Readonly<{
+        kind: "blocked";
+        refusal: DeliveryPreparationRefusal;
+    }> | Readonly<{
+        kind: "ready";
+        workspace: AuditWorkspace;
+        identity: DeliveryIdentity;
+        scope: DiffScope;
+        diff?: string;
+    }>;
+    verification: Readonly<{
+        kind: "not-run";
+    }> | Readonly<{
+        kind: "satisfied";
+        passed: number;
+        total: number;
+        summary?: string;
+    }> | Readonly<{
+        kind: "unsatisfied";
+        passed: number;
+        total: number;
+        summary?: string;
+    }> | Readonly<{
+        kind: "stopped";
+        stop: VerificationStop;
+    }>;
+    target: Readonly<{
+        kind: "not-observed";
+    }> | AuditTargetAnswer;
+    delivery?: Readonly<{
+        changeId: ChangeId;
+        relation: "identical" | "differs";
+    }>;
 }>;
+export type VerificationReuse = CurrentVerifiedAttestation;
 export type DocumentDerivation = Readonly<{
     document: DocumentKey;
     title: string;
@@ -64,7 +101,7 @@ export type StepStop<R> = Readonly<{
     refusal?: never;
 }>;
 export type VerificationStop = StepStop<AttestationRefusal> | VerificationRuntimeStop;
-export type PlacementStop = StepStop<PlacementRefusal | TargetPlacementRefusal> | Readonly<{
+export type PlacementStop = StepStop<PlacementRefusal | TargetPlacementRefusal | IntegrationPreparationRefusal> | Readonly<{
     failure: "target-moved";
     contractId: ContractId;
     target: string;
@@ -79,10 +116,10 @@ type ScopeOperationInput = Readonly<{
 }>;
 export type RepositoryScope = GitRepository;
 export { NoGitWorldError };
-export declare function scopeOperation(input: ScopeOperationInput): RepositoryScope;
+export declare function scopeOperation(input: ScopeOperationInput): Promise<RepositoryScope>;
 export declare function currentBranchOperation(input: Readonly<{
     scope: RepositoryScope;
-}>): string | null;
+}>): Promise<string | null>;
 export declare function contractsOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
@@ -112,6 +149,7 @@ type Amendment = Readonly<{
 export declare function amendOperation(input: AmendOperationInput): Promise<IntentOutcome<Amendment, AmendRefusal | VerificationDeclarationRefusal>>;
 export type DeliverValue = DeliveryIdentity & Readonly<{
     verification?: VerificationStop;
+    verificationReuse?: VerificationReuse;
     placement?: PlacementStop;
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;
@@ -126,22 +164,25 @@ type DeliverOperationInput = MutationOperationInput & Readonly<{
 export declare function prepareDelivery(repository: GitRepository, stage: Readonly<{
     contractId: ContractId;
     coordinates: ContractState["coordinates"];
+    appointment?: Extract<ManagedWorktreeAppointment, {
+        kind: "appointed";
+    }>;
 }>, input: Readonly<{
     title: string;
     message?: string;
     requireBranchesToBeUpToDate?: boolean;
     includeDirty?: boolean;
-}>): {
+}>): Promise<{
     kind: "prepared";
     data: DeliverData;
 } | {
     kind: "refused";
     refusal: DeliveryPreparationRefusal;
-};
+}>;
 export declare function prepareReview(repository: GitRepository, stage: Readonly<{
     contractId: ContractId;
     coordinates: ContractState["coordinates"];
-}>): {
+}>): Promise<{
     kind: "prepared";
     data: Readonly<{
         changeId: DeliverData["integration"]["changeId"];
@@ -150,7 +191,7 @@ export declare function prepareReview(repository: GitRepository, stage: Readonly
 } | {
     kind: "refused";
     refusal: ReviewPreparationRefusal;
-};
+}>;
 export declare function deliverOperation(input: DeliverOperationInput): Promise<IntentOutcome<DeliverValue>>;
 export declare function abandonOperation(input: MutationOperationInput & Readonly<{
     note?: string;
@@ -169,10 +210,14 @@ export type ReviewValue = Readonly<{
     workspace?: WorkspaceDirtyDelta;
 }>;
 export declare function reviewOperation(input: ReviewOperationInput): Promise<IntentOutcome<ReviewValue, ReviewRefusal>>;
-export declare function auditOperation(input: MutationOperationInput & Readonly<{
+type AuditOperationInput = MutationOperationInput & Readonly<{
     deriveDocument?: (state: ContractState) => DocumentDerivation;
+    requireBranchesToBeUpToDate?: boolean;
+    includeDirty?: boolean;
+    showDiff?: boolean;
     signal?: AbortSignal;
-}>): Promise<IntentOutcome<AuditReport>>;
+}>;
+export declare function auditOperation(input: AuditOperationInput): Promise<IntentOutcome<AuditReport>>;
 export type ReconcileReport = ReconcileResult;
 export type ReconcileObservation = Readonly<{
     state: ContractState | null;
@@ -182,6 +227,8 @@ type ReconcileOptions = Readonly<{
     hooks: WorktreeHooks;
     retryHooks: boolean;
     retainTerminalWorktree?: boolean;
+    place?: string;
+    places?: ReadonlyMap<ContractId, string>;
 }>;
 export declare function reconcileOperation(input: MutationOperationInput & ReconcileOptions): Promise<ReconcileObservation>;
 type RepoReconcileItem = Readonly<{
@@ -192,6 +239,10 @@ type RepoReconcileItem = Readonly<{
 export type RepoReconcileReport = Readonly<{
     contracts: readonly RepoReconcileItem[];
 }>;
+export declare function worldContractStates(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+}>): Promise<readonly ContractState[]>;
 export declare function reconcileAllOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;