@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/library/outcome.js

@@ -1,7 +1,7 @@
 /** @architectureCompositionRoot */
 import { z } from "zod";
 import { contractFileEffectSchema } from "../contract-worktree.js";
-import { decodeJournalEntry } from "../core/facts/codec.js";
+import { validateEntry } from "../core/facts/codec.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractHeadSchema } from "../git/identity.js";
 import { reconcileEffectSchema } from "../git/reconcile.js";
@@ -100,7 +100,7 @@ function phasePending(operation, value) {
     if (concluded === undefined)
         return [];
     const pending = [];
-    if (concluded.verification !== undefined)
+    if (concluded.verification?.kind === "stopped")
         pending.push(surface("verification", true));
     if (concluded.placement !== undefined)
         pending.push(surface("placement", true));
@@ -306,7 +306,7 @@ const amendEvidenceSchema = z
     .strict()
     .refine((value) => value.overlaps === undefined || value.overlapFailure === undefined);
 const partialDeliverySchema = deliveryValueSchema.partial().superRefine((value, context) => {
-    const fields = deliverDataSchema.keyof().options;
+    const fields = deliverDataSchema.omit({ note: true }).keyof().options;
     const present = fields.filter((field) => value[field] !== undefined);
     if (present.length !== 0 && present.length !== fields.length)
         context.addIssue({ code: "custom", message: "delivery identity must be complete when present" });
@@ -322,7 +322,7 @@ const partialValueSchemas = {
 };
 const journalEntrySchema = z.unknown().transform((value, context) => {
     try {
-        return decodeJournalEntry(value);
+        return validateEntry(value);
     }
     catch {
         context.addIssue({ code: "custom", message: "invalid journal fact" });

package/build/src/library/reconcile.d.ts

@@ -8,6 +8,7 @@ import type { ReconcileResult } from "../git/reconcile.js";
 import { type RepositoryScope } from "../protocol/operations.js";
 import { type ProtocolProgress } from "../protocol/progress.js";
 import { type SettlementReport } from "../settlement/settle.js";
+import type { InvocationAccumulator } from "./invocation.js";
 export type ReconcileReport = Readonly<{
     effects: readonly (ReconcileResult["effects"][number] | ContractFileEffect)[];
     lag: readonly (ReconcileResult["lag"][number] | ContractFileLag)[];
@@ -128,5 +129,10 @@ type ReconcileOptions = Readonly<{
 export declare function completeReconcile(input: ReconcileOptions & Readonly<{
     contractId: ContractId;
 }>): Promise<ReconcileCompletion>;
+/**
+ * The one post-admission reconciliation walk: every affected Contract is observed afresh, and an
+ * operational stop is recorded rather than thrown.
+ */
+export declare function reconcileAffectedContracts(accumulator: InvocationAccumulator, contractId: ContractId, scope: RepositoryScope, channel: GitDecodeChannel, hooks: WorktreeHooks): Promise<void>;
 export declare function completeRepoReconcile(input: ReconcileOptions): Promise<RepoReconcileReport>;
 export {};

package/build/src/library/reconcile.js

@@ -4,7 +4,7 @@ import { contractFileLagSchema, projectContractWorktree, } from "../contract-wor
 import { gitReconcileLagSchema, reconcileObservationFailure } from "../git/reconcile.js";
 import { worktreePath } from "../git/workspace.js";
 import { stateOperation } from "../protocol/operations.js";
-import { isOperationalFailure } from "../protocol/progress.js";
+import { isOperationalFailure, isOperationalStop, executionStop } from "../protocol/progress.js";
 import { reconcileAllOperation, reconcileOperation, worldContractStates } from "../protocol/reconcile.js";
 import { settle, settleAll } from "../settlement/settle.js";
 import { appointManagedWorktrees, placeRegisterPath, releaseManagedWorktrees, } from "../workspace-place.js";
@@ -205,6 +205,36 @@ export async function completeReconcile(input) {
     const terminal = await finishTerminalReconcile(input, retained, appointed);
     return assembleReconcile(retained.report, projection, settlement, terminal);
 }
+/**
+ * The one post-admission reconciliation walk: every affected Contract is observed afresh, and an
+ * operational stop is recorded rather than thrown.
+ */
+export async function reconcileAffectedContracts(accumulator, contractId, scope, channel, hooks) {
+    for (const contract of [...new Set([contractId, ...accumulator.snapshot().affected])]) {
+        try {
+            scope.signal?.throwIfAborted();
+            accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
+            try {
+                await completeReconcile({
+                    scope,
+                    channel,
+                    contractId: contract,
+                    hooks,
+                    retryHooks: false,
+                    progress: accumulator,
+                });
+            }
+            finally {
+                accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
+            }
+        }
+        catch (error) {
+            if (!isOperationalStop(error, scope.signal))
+                throw error;
+            accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
+        }
+    }
+}
 function attachReleaseLag(contracts, released, lag) {
     const affected = new Set(released);
     return {

package/build/src/library/repo.d.ts

@@ -1,7 +1,6 @@
 import { type RepositoryScope } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 export { NoGitWorldError };
-export type { RepoContractReconcileReport, RepoReconcileReport } from "./reconcile.js";
 export type RepoAtInput = Readonly<{
     path?: string;
     gitPath?: string;

package/build/src/library/selection.d.ts

@@ -56,10 +56,7 @@ export type AkumaAskInput<T = string> = AkumaAddressInput & Readonly<{
     signal?: AbortSignal;
     observe?: AskObserver;
 }>;
-export type { TellResult, TellWake } from "../akuma/body.js";
-export type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaUnobserved, AkumaWaitResult, } from "../akuma/selection-observation.js";
-export type { DispatchAssociation } from "../dispatch/association.js";
-export type { CreatedTaskObservation } from "../task/created-observation.js";
+export type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaWaitResult, } from "../akuma/selection-observation.js";
 export type AkumaKillInput = AkumaSetAddressInput & Readonly<{
     signal?: AbortSignal;
 }>;
@@ -98,18 +95,12 @@ export type AkumaHistoryResult = Readonly<{
 export declare function statusAkuma(input: AkumaAddressInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaObservation>;
-export declare function waitAkuma(input: AkumaWaitInput & Readonly<{
-    path: WorldRoot;
-}>, execution?: ExecutionContext): Promise<AkumaWaitResult>;
 export declare function waitAkumaOn(seam: SelectionSeam, input: AkumaWaitInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaWaitResult>;
 export declare function killAkumaOn(seam: SelectionSeam, input: AkumaKillInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaKillResult>;
-export declare function tellAkuma(input: AkumaTellInput & Readonly<{
-    path: WorldRoot;
-}>, execution?: ExecutionContext): Promise<AkumaTellResult>;
 export declare function tellAkumaOn(seam: SelectionSeam, input: AkumaTellInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaTellResult>;

package/build/src/library/selection.js

@@ -5,11 +5,11 @@ import { AkumaOwner } from "../akuma/akuma-owner.js";
 import { decodeAskObservation, executeAskAkuma, executeKillAkuma, executeTellAkuma, } from "../akuma/akuma-selection-execution.js";
 import { executeWaitAkuma, } from "../akuma/akuma-wait.js";
 import { parsePublicHistoryId } from "../akuma/identity.js";
-import { executionChannel, localExecutionContext } from "../akuma/requests.js";
+import { executionChannel } from "../akuma/requests.js";
 import { schemaJsonText } from "../akuma/schema.js";
 import { requestForwardedSelectionAsk, requestForwardedSelectionKill, requestForwardedSelectionTell, requestForwardedSelectionWait, } from "../akuma/selection-request.js";
 import { readAliases } from "../alias/index.js";
-import { observeDispatchAssociation } from "../dispatch/index.js";
+import { observeDispatchAssociations } from "../dispatch/index.js";
 import { observeContractAt } from "../git/observe.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { observeCreatedTaskObservations } from "../task/created-observation.js";
@@ -99,8 +99,8 @@ function observationError(id, error) {
         return error;
     return new AkumaObservationError(id, observationDiagnostic(error));
 }
-async function dispatchAssociation(repo, id) {
-    return await observeDispatchAssociation(repo === undefined ? undefined : scopeForRepo(repo), id);
+async function dispatchAssociations(repo, ids) {
+    return await observeDispatchAssociations(repo === undefined ? undefined : scopeForRepo(repo), ids);
 }
 /**
  * Read-time placement discharge. Reported changes describe a candidate that a
@@ -141,9 +141,12 @@ async function createdTasksFor(path, statuses) {
  * One wait's identity-fact resolver: the alias bound to an Akuma in its world and
  * its Dispatch association. The alias index is read once, on the first observed
  * Akuma, and each Akuma's alias is the first binding the canonical order offers.
+ * Alias bindings and selected Dispatch associations are read once for this live
+ * stage. Final result composition owns a separate, fresh Dispatch observation.
  */
-function waitIdentityFacts(path, repo) {
+function waitIdentityFacts(path, repo, selected) {
     let aliases;
+    let contracts;
     return async (id) => {
         if (aliases === undefined) {
             const bound = new Map();
@@ -153,8 +156,9 @@ function waitIdentityFacts(path, repo) {
             }
             aliases = bound;
         }
+        contracts ??= await dispatchAssociations(repo, selected);
         const alias = aliases.get(id);
-        return { ...(alias === undefined ? {} : { alias }), contract: await dispatchAssociation(repo, id) };
+        return { ...(alias === undefined ? {} : { alias }), contract: contracts.get(id) };
     };
 }
 async function observeAkuma(status, path, repo) {
@@ -168,8 +172,9 @@ async function observeAkuma(status, path, repo) {
 async function composeAkumaAssociations(statuses, path, repo) {
     const created = await createdTasksFor(path, statuses);
     const discharged = placementDischarged(repo);
+    const contracts = await dispatchAssociations(repo, statuses.map((status) => status.id));
     return await Promise.all(statuses.map(async (status, index) => {
-        const contract = await dispatchAssociation(repo, status.id);
+        const contract = contracts.get(status.id);
         return {
             status: await composeObservation(status, contract, discharged),
             contract,
@@ -265,7 +270,7 @@ async function localWait(addressed, input) {
             completion: input.completion,
             ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
-            identity: waitIdentityFacts(addressed.path, input.repo),
+            identity: waitIdentityFacts(addressed.path, input.repo, addressed.orderedIds),
             selectionOrder: addressed.orderedIds,
             ...(input.observer?.selected === undefined ? {} : { onSelected: input.observer.selected }),
             ...(input.observer?.observe === undefined ? {} : { observe: input.observer.observe }),
@@ -277,9 +282,6 @@ async function localWait(addressed, input) {
         throw observationError(addressed.orderedIds[0], error);
     }
 }
-export async function waitAkuma(input, execution = localExecutionContext()) {
-    return await waitAkumaOn(selectionSeam(execution), input);
-}
 function waitObserver(value) {
     if (value === undefined)
         return undefined;
@@ -330,9 +332,6 @@ export async function killAkumaOn(seam, input) {
     }
     return await seam.kill(await seam.addressSet(setAddress(values)), signal(values.signal));
 }
-export async function tellAkuma(input, execution = localExecutionContext()) {
-    return await tellAkumaOn(selectionSeam(execution), input);
-}
 export async function tellAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.tell input");
     for (const key of Object.keys(values)) {
@@ -392,7 +391,7 @@ export async function historyAkuma(input) {
     const addressed = await addressAkuma(directAddress(values));
     try {
         const handle = new AkumaOwner(addressed.id, addressed.path);
-        const contract = await dispatchAssociation(values.repo, addressed.id);
+        const contract = (await dispatchAssociations(values.repo, [addressed.id])).get(addressed.id);
         if (values.last === true) {
             const answer = await handle.lastAnswer();
             return answer.kind === "answer"

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

@@ -1,7 +1,7 @@
 import type { ActiveContractRefusal } from "../core/facts/observation.js";
 import type { GitTreeSelection } from "../git/read-observation.js";
 import type { CompanionDecorator } from "./run.js";
-import type { IntentOutcome, MutationOperationInput } from "./operations.js";
+import { type IntentOutcome, type MutationOperationInput } from "./operations.js";
 export declare function abandonOperation(input: MutationOperationInput & Readonly<{
     note?: string;
     decorateOffer?: CompanionDecorator;

package/build/src/protocol/abandon.js

@@ -1,16 +1,9 @@
 import { decideAbandon } from "../core/verbs/abandon.js";
-import { admitIntent } from "./intent.js";
-import { complete } from "./outcome.js";
-import { timestamp } from "./operations.js";
+import { admitVoidIntent } from "./operations.js";
 export async function abandonOperation(input) {
-    return complete(await admitIntent(input.channel, input.scope, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        ...(input.note === undefined ? {} : { note: input.note }),
-    }, decideAbandon, {
+    return admitVoidIntent(input, { ...(input.note === undefined ? {} : { note: input.note }) }, decideAbandon, {
         ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
         ...(input.observationSelection === undefined ? {} : { observationSelection: input.observationSelection }),
         ...(input.progress === undefined ? {} : { progress: input.progress }),
-    }), undefined);
+    });
 }

package/build/src/protocol/amend.js

@@ -63,14 +63,11 @@ export async function amendOperation(input) {
             if (decision.kind === "refused")
                 return decision;
             const admission = await admitDecidedOffer({
-                channel: input.channel,
-                repository: input.scope,
+                ...input,
                 seat,
-                decisionObservation: observation,
+                observation,
                 attempt: attempts[index],
                 offer: decision.offer,
-                primaryContract: input.contractId,
-                ...(input.progress === undefined ? {} : { progress: input.progress }),
             });
             if (admission.kind === "accepted") {
                 if (amendment === undefined)

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

@@ -1,5 +1,5 @@
 import type { ActiveContractRefusal } from "../core/facts/observation.js";
-import type { IntentOutcome, MutationOperationInput } from "./operations.js";
+import { type IntentOutcome, type MutationOperationInput } from "./operations.js";
 export declare function arcOperation(input: MutationOperationInput & Readonly<{
     chapter: Readonly<{
         title: string;

package/build/src/protocol/arc.js

@@ -1,12 +1,5 @@
 import { decideArc } from "../core/verbs/arc.js";
-import { admitIntent } from "./intent.js";
-import { complete } from "./outcome.js";
-import { timestamp } from "./operations.js";
+import { admitVoidIntent } from "./operations.js";
 export async function arcOperation(input) {
-    return complete(await admitIntent(input.channel, input.scope, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        data: input.chapter,
-    }, decideArc), undefined);
+    return admitVoidIntent(input, { data: input.chapter }, decideArc);
 }

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

@@ -10,22 +10,9 @@ import type { AttemptContext } from "../core/decide.js";
 import type { Offer } from "../core/facts/offer.js";
 import { type ContractId, type ContractState, type EntryUlid, type JournalEntry } from "../core/facts/types.js";
 export declare const entryUlidSchema: z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>;
-export declare function mintEntryUlids(count: number): readonly EntryUlid[];
 export declare function mintAttempts(input: Readonly<{
     entryCount: number;
 }>): readonly AttemptContext[];
-export type UnknownAttemptClassification = Readonly<{
-    kind: "accepted";
-}> | Readonly<{
-    kind: "redecide";
-}> | Readonly<{
-    kind: "collision";
-    contractId: ContractId;
-    planned: JournalEntry;
-    observed: JournalEntry;
-    plannedBytes: string;
-    observedBytes: string;
-}>;
 export type AcceptedAdmission = Readonly<{
     kind: "accepted";
     facts: readonly JournalEntry[];
@@ -46,18 +33,14 @@ export type DecidedOfferResult<Refusal = never> = AcceptedAdmission | AttemptTer
 }>;
 /** Admit one decided offer without making another legal decision. */
 export declare function admitDecidedOffer<Refusal = never>(input: Readonly<{
+    scope: GitRepository;
     channel: GitDecodeChannel;
-    repository: GitRepository;
+    contractId: ContractId;
     seat: PrivateStatePublicationSeat;
-    decisionObservation: GitDecisionObservation;
+    observation: GitDecisionObservation;
     attempt: AttemptContext;
     offer: Offer;
-    primaryContract: ContractId;
     assertions?: readonly GitRefAssertion[];
     validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     progress?: ProtocolProgress;
 }>): Promise<DecidedOfferResult<Refusal>>;
-/** Classify an unknown atomic-publication outcome using only a captured Git observation. */
-export declare function classifyUnknownAttempt(observation: Readonly<{
-    contracts: GitDecisionObservation["journals"];
-}>, offer: Offer): UnknownAttemptClassification;

package/build/src/protocol/attempt.js

@@ -34,7 +34,7 @@ function nextEntryUlid() {
     }
     return entryUlid(value);
 }
-export function mintEntryUlids(count) {
+function mintEntryUlids(count) {
     return Array.from({ length: count }, nextEntryUlid);
 }
 export function mintAttempts(input) {
@@ -104,7 +104,8 @@ async function publicationPremiseMoved(repository, observation, offer, assertion
 }
 /** Admit one decided offer without making another legal decision. */
 export async function admitDecidedOffer(input) {
-    const { repository, decisionObservation, attempt, offer, primaryContract } = input;
+    const { seat, observation: decisionObservation, attempt, offer, contractId: primaryContract } = input;
+    const repository = input.scope;
     const assertions = input.assertions ?? [];
     validateOffer(offer, attempt);
     const primary = primaryAppend(offer, primaryContract);
@@ -115,7 +116,7 @@ export async function admitDecidedOffer(input) {
     }
     const admission = await admit(repository, offer, decisionObservation.admission, assertions);
     if (admission.kind === "accepted") {
-        confirmPrivateStatePublication(input.seat);
+        confirmPrivateStatePublication(seat);
         input.progress?.recordPublication(primaryContract, admission.heads[primary.contractId], offerEntries(offer));
         const accepted = {
             kind: "accepted",
@@ -135,7 +136,7 @@ export async function admitDecidedOffer(input) {
     const recovered = await withGitDecodeChannel(recoveryRepository, async (recoveryChannel) => observeContractsForAdmissionAt(recoveryRepository, recoveryChannel, offer.facts.map((append) => append.contractId)));
     const classification = classifyUnknownAttempt({ contracts: recovered.journals }, offer);
     if (classification.kind === "accepted") {
-        const accepted = confirmRecoveredAcceptance(input.seat, { contracts: recovered.journals }, offer, primaryContract);
+        const accepted = confirmRecoveredAcceptance(seat, { contracts: recovered.journals }, offer, primaryContract);
         input.progress?.recordAdmission(accepted);
         return accepted;
     }
@@ -147,7 +148,7 @@ function confirmRecoveredAcceptance(seat, observation, offer, primaryContract) {
     return recovered;
 }
 /** Classify an unknown atomic-publication outcome using only a captured Git observation. */
-export function classifyUnknownAttempt(observation, offer) {
+function classifyUnknownAttempt(observation, offer) {
     let exact = 0;
     let missing = 0;
     for (const append of offer.facts) {

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

@@ -75,6 +75,7 @@ export declare const auditReportSchema: z.ZodObject<{
             path: z.ZodString;
         }, z.core.$strict>;
         identity: z.ZodObject<{
+            note: z.ZodOptional<z.ZodString>;
             tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
             integration: z.ZodObject<{
                 predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;

package/build/src/protocol/audit.js

@@ -11,7 +11,7 @@ import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { currentVerifiedAttestation, verifyDelivery } from "./intent.js";
 import { accepted, admitted } from "./outcome.js";
 import { prepareDelivery } from "./deliver.js";
-import { timestamp, unpackVerificationOutcome } from "./operations.js";
+import { recordedIntegrationSnapshots, timestamp, unpackVerificationOutcome } from "./operations.js";
 export const auditReportSchema = z
     .object({
     candidate: z.union([
@@ -63,15 +63,15 @@ async function auditWorkspace(repository, state) {
         return appointed;
     return { kind: "ready", answer: { kind: "worktree", path: appointed.path }, appointment: appointed };
 }
-function auditDeliveryRelation(state, candidate, verificationDeclared) {
+function auditDeliveryRelation(state, candidate, declaration) {
     const recorded = state.delivery?.data.integration.changeId;
     if (recorded === undefined)
         return undefined;
-    const verification = currentVerifiedAttestation(state);
+    const verification = declaration == null ? undefined : currentVerifiedAttestation(state);
     return {
         changeId: recorded,
         relation: recorded === candidate.integration.changeId ? "identical" : "differs",
-        verification: !verificationDeclared
+        verification: declaration == null
             ? { kind: "undeclared" }
             : verification === undefined
                 ? { kind: "unrecorded" }
@@ -95,15 +95,13 @@ async function auditCandidateVerification(input, state, snapshot, definition) {
         throw new Error("audit verification preparation unexpectedly produced no attempt");
     return unpackVerificationOutcome(verification);
 }
-function auditVerificationAnswer(verified, declared) {
-    if (!declared)
+function auditVerificationAnswer(verified, declaration) {
+    if (declaration === null)
         return { kind: "undeclared" };
     if (verified === undefined)
-        return { kind: "not-run" };
+        throw new Error("declared audit Verification produced no attempt");
     if (verified.stop !== undefined)
         return { kind: "stopped", stop: verified.stop };
-    if (verified.reuse !== undefined)
-        return { kind: "reused", ...verified.reuse };
     if (verified.counts === undefined)
         throw new Error("terminal Verification is missing producer counts");
     return {
@@ -172,6 +170,7 @@ export async function auditOperation(input) {
     const prepared = await prepareDelivery(input.scope, {
         contractId: state.id,
         coordinates: state.coordinates,
+        recordedIntegrations: recordedIntegrationSnapshots(observed.journals.get(state.id)?.entries ?? []),
         ...(workspace.appointment === undefined ? {} : { appointment: workspace.appointment }),
     }, {
         title: derivation.title,
@@ -187,8 +186,8 @@ export async function auditOperation(input) {
     const verified = derivation.verification.data === null
         ? undefined
         : await auditCandidateVerification(input, state, prepared.data.integration.snapshot, derivation.verification.data);
-    const verification = auditVerificationAnswer(verified, derivation.verification.data !== null);
-    const delivery = auditDeliveryRelation(verified?.admission?.state ?? state, prepared.data, derivation.verification.data !== null);
+    const verification = auditVerificationAnswer(verified, derivation.verification.data);
+    const delivery = auditDeliveryRelation(verified?.admission?.state ?? state, prepared.data, derivation.verification.data);
     input.progress?.recordAudit(state.id, { verification, ...(delivery === undefined ? {} : { delivery }) });
     const target = await auditTargetAnswer(input.scope, state, prepared.data);
     input.progress?.recordAudit(state.id, { target });