@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/library/configuration.js

@@ -9,31 +9,65 @@ function namespaceFailure(view) {
         throw new Error("settings namespace failure expected");
     throw new SettingsError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
 }
+function bundleGates(name, value) {
+    if (!record(value))
+        throw new SettingsError(`gate bundle '${name}' must be an object`);
+    if (value.kind !== "bundle") {
+        throw new SettingsError(`gate bundle '${name}' has unsupported kind: ${String(value.kind)}`);
+    }
+    for (const field of Object.keys(value)) {
+        if (field !== "kind" && field !== "gates") {
+            throw new SettingsError(`gate bundle '${name}' has unknown field: ${field}`);
+        }
+    }
+    if (!Array.isArray(value.gates)) {
+        throw new SettingsError(`gate bundle '${name}'.gates must be an array`);
+    }
+    return value.gates.map((gate) => {
+        if (!gateWord(gate)) {
+            throw new SettingsError(`gate bundle '${name}' contains an invalid gate word`);
+        }
+        if (gate !== "reviewed" && gate !== "verified") {
+            throw new SettingsError(`gate bundle '${name}' contains a gate without a producer: ${gate}`);
+        }
+        return gate;
+    });
+}
 export function gatesFrom(input) {
     if (!record(input))
         throw new TypeError("gatesFrom input must be an object");
-    const name = input.name ?? "default";
-    if (!gateWord(name))
-        throw new SettingsError("gate set name must match ^[a-z][a-z0-9-]{0,63}$");
+    if (input.names !== undefined && !Array.isArray(input.names)) {
+        throw new TypeError("gatesFrom names must be an array");
+    }
+    const names = input.names ?? ["default"];
+    for (const name of names) {
+        if (!gateWord(name))
+            throw new SettingsError("gate bundle name must match ^[a-z][a-z0-9-]{0,63}$");
+    }
     const view = input.settings.namespace("gates");
     if (view.kind === "failed")
         namespaceFailure(view);
-    const selected = view.entries.find((entry) => entry.name === name);
-    if (selected === undefined) {
-        if (input.name === undefined)
-            return Object.freeze([]);
-        throw new SettingsError(`unknown gate set: ${name}`);
+    const expanded = [];
+    const seen = new Set();
+    for (const name of names) {
+        const selected = view.entries.find((entry) => entry.name === name);
+        if (selected === undefined) {
+            if (input.names === undefined) {
+                if (!seen.has("reviewed"))
+                    expanded.push("reviewed");
+                seen.add("reviewed");
+                continue;
+            }
+            throw new SettingsError(`unknown gate bundle: ${name}`);
+        }
+        for (const gate of bundleGates(name, selected.value)) {
+            if (seen.has(gate))
+                continue;
+            seen.add(gate);
+            expanded.push(gate);
+        }
     }
-    if (!Array.isArray(selected.value))
-        throw new SettingsError(`gate set '${name}' must be an array`);
-    const values = selected.value.map((value) => {
-        if (!gateWord(value))
-            throw new SettingsError(`gate set '${name}' contains an invalid gate word`);
-        return value;
-    });
-    if (new Set(values).size !== values.length)
-        throw new SettingsError(`gate set '${name}' contains duplicate gates`);
-    return Object.freeze(values);
+    return Object.freeze(expanded);
 }
 function command(value, coordinate, ErrorType) {
     if (!record(value))

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

@@ -3,7 +3,13 @@ import { type RegionObservation, type RegionOverlap } from "./region.js";
 import { type Gate, type WorktreeHooks } from "./configuration.js";
 import { type ChangeId, type ContractId, type ContractState, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { type AuditReport, type ContractBoard, type ContractDisposition, type ContractGateCurrent, type ContractGateReport, type ContractObservation, type ContractPhase, type ContractRow, type FactKind, type PlacementStop, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope, type ReviewValue, type VerificationReuse, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
+import { type PlacementStop, type RepositoryScope, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
+import type { ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow } from "../protocol/read/status.js";
+import type { AuditReport } from "../protocol/audit.js";
+import { type DeliverValue, type IntegrationConflictMaterialized, type VerificationReuse } from "../protocol/deliver.js";
+import type { ReconcileReport as ProtocolReconcileReport } from "../protocol/reconcile.js";
+import { type ReviewValue } from "../protocol/review.js";
+import type { FactKind } from "../core/facts/types.js";
 import { type Dispatch } from "../dispatch/index.js";
 import { type SettlementReport } from "../settlement/settle.js";
 import { type TaskId } from "../task/identity.js";
@@ -11,7 +17,10 @@ import { Repo, type ReconcileInput } from "./repo.js";
 import { type AuditInput } from "./audit.js";
 import { Delivery } from "./delivery.js";
 import { type MutationResult } from "./mutation.js";
-export { KeiyakuRefused, KeiyakuRetry, type ContractAppointmentRefusal, type KeiyakuRefusal, type KeiyakuRetryReason, } from "./refusal.js";
+import { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
+export { KeiyakuRefused, type ContractAppointmentRefusal, } from "./refusal.js";
+export { KeiyakuRetry };
+export type { KeiyakuRefusal, KeiyakuRetryReason };
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks } from "./configuration.js";
 export type { AuditReport, DeliveryPreparationRefusal, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, FactKind, SnapshotId, };
@@ -33,7 +42,7 @@ export type ContractHistory = Readonly<{
 export type ActorId = string;
 export type AttestationVerdict = "satisfied" | "unsatisfied";
 export type Review = ReviewValue;
-export type { PlacementStop, VerificationReuse, VerificationStop };
+export type { PlacementStop, VerificationReuse, VerificationStop, IntegrationConflictMaterialized };
 export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
 export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
 export type { MutationResult };
@@ -101,9 +110,55 @@ export type DeliverInput = ActorOptions & Readonly<{
     message?: string;
     requireBranchesToBeUpToDate?: boolean;
     includeDirty?: boolean;
+    materializeConflict?: boolean;
     signal?: AbortSignal;
 }>;
+type ForwardedDeliveryReceipt = Readonly<{
+    kind: "accepted";
+    result: MutationResult<DeliverValue>;
+}> | Readonly<{
+    kind: "refused";
+    refusal: KeiyakuRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: KeiyakuRetryReason;
+}> | IntegrationConflictMaterialized;
+type ForwardedReviewReceipt = Readonly<{
+    kind: "accepted";
+    result: MutationResult<ReviewValue>;
+}> | Readonly<{
+    kind: "refused";
+    refusal: KeiyakuRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: KeiyakuRetryReason;
+}>;
 export type { AuditInput };
+export declare function executeForwardedDeliver(input: Readonly<{
+    repo: Repo;
+    contractId: string;
+    requester: string;
+    message?: string;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+    requireBranchesToBeUpToDate: boolean;
+    hooks: WorktreeHooks;
+    signal?: AbortSignal;
+}>): Promise<Readonly<{
+    result: ForwardedDeliveryReceipt;
+    deliveryFactId?: string;
+}>>;
+export declare function executeForwardedReview(input: Readonly<{
+    repo: Repo;
+    contractId: string;
+    requester: string;
+    verdict: AttestationVerdict;
+    summary?: string;
+    hooks: WorktreeHooks;
+}>): Promise<Readonly<{
+    result: ForwardedReviewReceipt;
+    reviewFactId?: string;
+}>>;
 export declare class KeiyakuHandle {
     private readonly id;
     private readonly scope;
@@ -113,7 +168,7 @@ export declare class KeiyakuHandle {
     guidance(): Promise<string>;
     delivery(): Promise<Delivery | null>;
     amend(input: AmendInput): Promise<AmendResult>;
-    deliver(input?: DeliverInput): Promise<MutationResult<Delivery>>;
+    deliver(input?: DeliverInput): Promise<MutationResult<Delivery> | IntegrationConflictMaterialized>;
     review(input: ReviewInput): Promise<MutationResult<Review>>;
     abandon(input?: AbandonInput): Promise<MutationResult<void>>;
     arc(input: ArcInput): Promise<MutationResult<void>>;

package/build/src/library/contract.js

@@ -2,13 +2,19 @@ import { documentDiff } from "../markdown/diff.js";
 import { applyAmendDocument } from "../body/amend.js";
 import { decodeArcDocument } from "../body/arc.js";
 import { decodeContractDocument } from "../body/decode.js";
-import { renderContractGuidance, } from "../contract-worktree.js";
+import { renderContractGuidance, resolveHereContractWorkspace, } from "../contract-worktree.js";
 import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
 import { observeRegion } from "./region.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { abandonOperation, amendOperation, arcOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
+import { contractObservationOperation, contractsOperation, deliveryDiffOperation, deliveryOperation, stateOperation, } from "../protocol/operations.js";
+import { abandonOperation } from "../protocol/abandon.js";
+import { amendOperation } from "../protocol/amend.js";
+import { arcOperation } from "../protocol/arc.js";
+import { deliverOperation, } from "../protocol/deliver.js";
+import { reviewOperation } from "../protocol/review.js";
 import { readDispatchesAt } from "../dispatch/index.js";
 import { mintSnapshotId } from "../git/identity.js";
 import { observeContractsForAdmissionInObservationAt } from "../git/observe.js";
@@ -16,13 +22,15 @@ import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observ
 import { claimTaskHolderWithFence, releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection, } from "../settlement/holder.js";
 import { parseTaskId } from "../task/identity.js";
 import { reconcileInput, scopeForRepo } from "./repo.js";
+import { injectedBodyRequests, requestBodyDeliver, requestBodyReview, } from "../akuma/requests.js";
 import { auditContract } from "./audit.js";
 import { Delivery, deliveryHandle } from "./delivery.js";
-import { completeHolderMutation, completeMutation, } from "./mutation.js";
+import { completionInput, completeHolderMutation, completeMutation, } from "./mutation.js";
 import { completeReconcile } from "./reconcile.js";
 import { admitBindWithAppointment } from "./bind.js";
-import { KeiyakuRefused, requireAccepted } from "./refusal.js";
-export { KeiyakuRefused, KeiyakuRetry, } from "./refusal.js";
+import { KeiyakuRefused, KeiyakuRetry, requireAccepted, } from "./refusal.js";
+export { KeiyakuRefused, } from "./refusal.js";
+export { KeiyakuRetry };
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export { Delivery };
 function taskOption(value) {
@@ -38,8 +46,140 @@ function taskOption(value) {
     }
     return value;
 }
-function completion(scope, channel, id, value, hooks) {
-    return { scope, channel, contractId: id, value, hooks };
+async function resolveHereWorkspace(scope, id) {
+    const appointment = await resolveHereContractWorkspace(scope, id);
+    if (appointment.kind === "failed") {
+        if (appointment.cause === "duplicate")
+            throw new AuthorityCorruptionError(appointment.diagnostic);
+        throw new Error(appointment.diagnostic);
+    }
+    return appointment.kind === "appointed" ? appointment.path : undefined;
+}
+function derivedDocument(state) {
+    return documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
+}
+async function executeLocalDelivery(input) {
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const outcome = await deliverOperation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            deriveDocument: derivedDocument,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(input.message === undefined ? {} : { message: input.message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
+            materializeConflict: input.materializeConflict,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
+        });
+        if (outcome.kind === "integration-conflict-materialized")
+            return outcome;
+        return completeMutation({
+            ...completionInput(input.scope, channel, input.contractId, (delivery) => delivery, input.hooks),
+            accepted: requireAccepted(outcome),
+        });
+    });
+}
+async function executeLocalReview(input) {
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const accepted = requireAccepted(await reviewOperation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            deriveDocument: derivedDocument,
+            verdict: input.verdict,
+            ...(input.summary === undefined ? {} : { summary: input.summary }),
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
+        }));
+        return completeMutation({
+            ...completionInput(input.scope, channel, input.contractId, (review) => review, input.hooks),
+            accepted,
+        });
+    });
+}
+function forwardedReceipt(outcome, action) {
+    if (outcome.kind === "failed") {
+        throw new Error(outcome.failure.kind === "failed"
+            ? outcome.failure.diagnostic
+            : `Unexpected Akuma target failure for ${action}: ${outcome.failure.id}`);
+    }
+    return outcome.result;
+}
+function requireForwardedDelivery(receipt) {
+    if (receipt.kind === "refused")
+        throw new KeiyakuRefused(receipt.refusal);
+    if (receipt.kind === "retry")
+        throw new KeiyakuRetry(receipt.reason);
+    return receipt.kind === "accepted" ? receipt.result : receipt;
+}
+function requireForwardedReview(receipt) {
+    if (receipt.kind === "refused")
+        throw new KeiyakuRefused(receipt.refusal);
+    if (receipt.kind === "retry")
+        throw new KeiyakuRetry(receipt.reason);
+    return receipt.result;
+}
+export async function executeForwardedDeliver(input) {
+    const id = contractId(input.contractId);
+    const actor = actorOption(input.requester).actor;
+    const message = optionalNonblank(input.message, "deliver message");
+    try {
+        const result = await executeLocalDelivery({
+            scope: scopeForRepo(input.repo),
+            contractId: id,
+            ...(actor === undefined ? {} : { actor }),
+            ...(message === undefined ? {} : { message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
+            materializeConflict: input.materializeConflict,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            hooks: input.hooks,
+        });
+        if (!("facts" in result))
+            return { result };
+        const delivery = result.facts.find((fact) => fact.kind === "deliver");
+        if (delivery === undefined)
+            throw new Error("accepted delivery is missing its journal fact");
+        return { result: { kind: "accepted", result }, deliveryFactId: delivery.entry };
+    }
+    catch (error) {
+        if (error instanceof KeiyakuRefused)
+            return { result: { kind: "refused", refusal: error.refusal } };
+        if (error instanceof KeiyakuRetry)
+            return { result: { kind: "retry", reason: error.reason } };
+        throw error;
+    }
+}
+export async function executeForwardedReview(input) {
+    const id = contractId(input.contractId);
+    const actor = actorOption(input.requester).actor;
+    if (input.verdict !== "satisfied" && input.verdict !== "unsatisfied") {
+        throw new TypeError("verdict must be satisfied or unsatisfied");
+    }
+    const summary = optionalNonblank(input.summary, "review summary");
+    try {
+        const result = await executeLocalReview({
+            scope: scopeForRepo(input.repo),
+            contractId: id,
+            ...(actor === undefined ? {} : { actor }),
+            verdict: input.verdict,
+            ...(summary === undefined ? {} : { summary }),
+            hooks: input.hooks,
+        });
+        const review = result.facts.find((fact) => fact.kind === "attestation");
+        if (review === undefined)
+            throw new Error("accepted review is missing its journal fact");
+        return { result: { kind: "accepted", result }, reviewFactId: review.entry };
+    }
+    catch (error) {
+        if (error instanceof KeiyakuRefused)
+            return { result: { kind: "refused", refusal: error.refusal } };
+        if (error instanceof KeiyakuRetry)
+            return { result: { kind: "retry", reason: error.reason } };
+        throw error;
+    }
 }
 export class KeiyakuHandle {
     id;
@@ -145,7 +285,7 @@ export class KeiyakuHandle {
             const document = decodeContractDocument(accepted.value.terms.document.bytes);
             return {
                 ...await completeMutation({
-                    ...completion(this.scope, channel, this.id, () => undefined, hooks),
+                    ...completionInput(this.scope, channel, this.id, () => undefined, hooks),
                     accepted,
                 }),
                 documentDiff: documentDiff("before", "after", accepted.value.source.document.bytes, accepted.value.terms.document.bytes),
@@ -159,25 +299,32 @@ export class KeiyakuHandle {
         const message = optionalNonblank(values?.message, "deliver message");
         const requireBranchesToBeUpToDate = optionalBoolean(values?.requireBranchesToBeUpToDate, "requireBranchesToBeUpToDate") ?? false;
         const includeDirty = optionalBoolean(values?.includeDirty, "includeDirty") ?? false;
+        const materializeConflict = optionalBoolean(values?.materializeConflict, "materializeConflict") ?? false;
         const actor = actorOption(values?.actor);
         const signal = optionalSignal(values?.signal);
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const accepted = requireAccepted(await deliverOperation({
+        const requests = injectedBodyRequests();
+        const result = requests === null
+            ? await executeLocalDelivery({
                 scope: this.scope,
-                channel,
                 contractId: this.id,
-                deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
                 ...actor,
                 ...(message === undefined ? {} : { message }),
                 requireBranchesToBeUpToDate,
                 includeDirty,
+                materializeConflict,
                 ...(signal === undefined ? {} : { signal }),
-            }));
-            return completeMutation({
-                ...completion(this.scope, channel, this.id, (delivery) => this.deliveryHandle(delivery), hooks),
-                accepted,
-            });
-        });
+                hooks,
+            })
+            : requireForwardedDelivery(forwardedReceipt(await requestBodyDeliver({
+                directory: requests,
+                repoRoot: this.scope.primaryWorktree,
+                contractId: this.id,
+                ...(message === undefined ? {} : { message }),
+                includeDirty,
+                materializeConflict,
+                ...(signal === undefined ? {} : { signal }),
+            }), "deliver"));
+        return "facts" in result ? { ...result, value: this.deliveryHandle(result.value) } : result;
     }
     async review(input) {
         const values = requireInput(input, "review input");
@@ -187,19 +334,24 @@ export class KeiyakuHandle {
             throw new TypeError("verdict must be satisfied or unsatisfied");
         }
         const summary = optionalNonblank(values.summary, "review summary");
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const accepted = requireAccepted(await reviewOperation({
-                scope: this.scope,
-                channel,
+        const actor = actorOption(values.actor);
+        const requests = injectedBodyRequests();
+        if (requests !== null) {
+            return requireForwardedReview(forwardedReceipt(await requestBodyReview({
+                directory: requests,
+                repoRoot: this.scope.primaryWorktree,
                 contractId: this.id,
                 verdict,
                 ...(summary === undefined ? {} : { summary }),
-                ...actorOption(values.actor),
-            }));
-            return completeMutation({
-                ...completion(this.scope, channel, this.id, (value) => value, hooks),
-                accepted,
-            });
+            }), "review"));
+        }
+        return await executeLocalReview({
+            scope: this.scope,
+            contractId: this.id,
+            ...actor,
+            verdict,
+            ...(summary === undefined ? {} : { summary }),
+            hooks,
         });
     }
     async abandon(input) {
@@ -220,7 +372,7 @@ export class KeiyakuHandle {
                 },
             }));
             return completeHolderMutation({
-                completion: completion(this.scope, channel, this.id, () => undefined, hooks),
+                completion: completionInput(this.scope, channel, this.id, () => undefined, hooks),
                 admission,
                 requireAccepted,
             });
@@ -239,7 +391,7 @@ export class KeiyakuHandle {
                 chapter,
             }));
             return completeMutation({
-                ...completion(this.scope, channel, this.id, () => undefined, hooks),
+                ...completionInput(this.scope, channel, this.id, () => undefined, hooks),
                 accepted,
             });
         });
@@ -288,7 +440,11 @@ export async function listKeiyaku(input) {
         if (key !== "repo")
             throw new TypeError(`Keiyaku.list input has unknown field: ${key}`);
     const scope = scopeForRepo(values.repo);
-    return withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
+    return withGitDecodeChannel(scope, (channel) => contractsOperation({
+        scope,
+        channel,
+        hereWorkspace: async (id) => await resolveHereContractWorkspace(scope, id),
+    }));
 }
 export async function observeKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.observe input");
@@ -305,7 +461,12 @@ export async function observeKeiyaku(input) {
     catch (error) {
         throw new TypeError(error instanceof Error ? error.message : "contract ID is invalid");
     }
-    return withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id }));
+    return withGitDecodeChannel(scope, (channel) => contractObservationOperation({
+        scope,
+        channel,
+        contractId: id,
+        hereWorkspace: async (contract) => await resolveHereContractWorkspace(scope, contract),
+    }));
 }
 export async function bindKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.bind input");
@@ -339,9 +500,9 @@ export async function bindKeiyaku(input) {
         const id = accepted.value.contractId;
         const toHandle = ({ contractId: contract }) => new KeiyakuHandle(contract, scope);
         const result = admission === null
-            ? await completeMutation({ ...completion(scope, channel, id, toHandle, hooks), accepted })
+            ? await completeMutation({ ...completionInput(scope, channel, id, toHandle, hooks), accepted })
             : await completeHolderMutation({
-                completion: completion(scope, channel, id, toHandle, hooks),
+                completion: completionInput(scope, channel, id, toHandle, hooks),
                 admission,
                 requireAccepted,
             });

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

@@ -1,9 +1,11 @@
 import type { SnapshotId } from "../core/facts/types.js";
-import type { DeliverValue } from "../protocol/operations.js";
+import type { DeliverValue } from "../protocol/deliver.js";
 declare class DeliveryHandle {
     private readonly readDiff;
+    readonly completion?: DeliverValue["completion"];
     readonly verification?: DeliverValue["verification"];
     readonly verificationReuse?: DeliverValue["verificationReuse"];
+    readonly verificationSummary?: DeliverValue["verificationSummary"];
     readonly placement?: DeliverValue["placement"];
     readonly cleanup?: DeliverValue["cleanup"];
     readonly leak?: DeliverValue["leak"];
@@ -11,7 +13,7 @@ declare class DeliveryHandle {
     readonly integration: DeliverValue["integration"];
     readonly method: DeliverValue["method"];
     readonly policy: DeliverValue["policy"];
-    constructor(identity: Pick<DeliverValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliverValue, "verification" | "verificationReuse" | "placement" | "cleanup" | "leak">>);
+    constructor(identity: Pick<DeliverValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliverValue, "completion" | "verification" | "verificationReuse" | "verificationSummary" | "placement" | "cleanup" | "leak">>);
     diff(): Promise<string | null>;
 }
 export type Delivery = DeliveryHandle;

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

@@ -11,11 +11,30 @@ export type CreatedTaskObservation = Readonly<{
     kind: "failed";
     diagnostic: string;
 }>;
+export type DispatchAssociation = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "associated";
+    contractId: ContractId;
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
 export type AkumaObservation = Readonly<{
     status: AkumaStatus;
-    contractId?: ContractId;
+    contract: DispatchAssociation;
     createdTasks: CreatedTaskObservation;
 }>;
+export type AkumaObservationStage = (Readonly<{
+    kind: "observed";
+}> & AkumaObservation) | Readonly<{
+    kind: "unobserved";
+    diagnostic: string;
+}>;
+export type AkumaUnobserved = Readonly<{
+    id: AkumaStatus["id"];
+    diagnostic: string;
+}>;
 export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
@@ -23,12 +42,13 @@ export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
 export type AkumaWaitResult = Readonly<{
     completion: "any" | "all";
     observations: readonly AkumaObservation[];
+    unobserved: readonly AkumaUnobserved[];
 }>;
 export type AkumaKillResult = Readonly<{
     results: readonly Readonly<{
         id: AkumaStatus["id"];
         evidence: KillEvidence;
-        observation: AkumaObservation;
+        observation: AkumaObservationStage;
     }>[];
 }>;
 export type AkumaTellInput = AkumaAddressInput & Readonly<{
@@ -37,7 +57,7 @@ export type AkumaTellInput = AkumaAddressInput & Readonly<{
 export type AkumaTellResult = Readonly<{
     akuma: AkumaStatus["id"];
     tell: TellResult;
-    observation: AkumaObservation;
+    observation: AkumaObservationStage;
 }>;
 export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
     body: string;
@@ -45,7 +65,7 @@ export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
 export type AkumaInterruptResult = Readonly<{
     id: AkumaStatus["id"];
     receipt: InterruptReceipt;
-    observation: AkumaObservation;
+    observation: AkumaObservationStage;
 }>;
 export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
     before?: number;
@@ -57,16 +77,16 @@ export type AkumaHistoryResult = Readonly<{
     kind: "history";
     id: AkumaStatus["id"];
     history: ActivityHistory;
-    contractId?: ContractId;
+    contract: DispatchAssociation;
 }> | Readonly<{
     kind: "last";
     id: AkumaStatus["id"];
     answer: string;
-    contractId?: ContractId;
+    contract: DispatchAssociation;
 }> | Readonly<{
     kind: "no-answer";
     id: AkumaStatus["id"];
-    contractId?: ContractId;
+    contract: DispatchAssociation;
 }>;
 type WaitExecutionInput = Readonly<{
     path: WorldRoot;