@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/contract-operations.js

@@ -1,40 +1,17 @@
-import { executionReceipt } from "./execution-result.js";
-import { decodeExecutionEvent, observeExecution } from "../protocol/execution-observation.js";
-import { contractId, snapshotId } from "../core/facts/types.js";
-import { AkumaBodyRequestError, requestBodyCommand } from "../akuma/request-rendezvous.js";
-import { eraseRequestCommand, } from "../akuma/request-wire.js";
-import { auditReportSchema, auditResultSchema, deliveryResultSchema, reviewResultSchema, } from "./mutation.js";
-import { decodeContractLiveFailure, encodeContractLiveFailure } from "./refusal.js";
 import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
+import { AkumaBodyRequestError, requestBodyCommand } from "../akuma/request-rendezvous.js";
+import { eraseRequestCommand, } from "../akuma/request-wire.js";
+import { auditReportSchema } from "../protocol/audit.js";
+import { materializedConflictSchema } from "../protocol/deliver.js";
+import { decodeExecutionObservation, observeExecution, } from "../protocol/execution-observation.js";
+import { contractIdSchema } from "../protocol/operations.js";
+import { deliveryValueSchema } from "./delivery.js";
+import { InvocationAccumulator } from "./invocation.js";
+import { decodeFailureWire, encodeFailureWire, KeiyakuError, outcomeSchema, project, reviewSchema } from "./outcome.js";
 const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
 const nonblankStringSchema = z.string().refine((value) => value.trim() !== "");
-const contractIdSchema = z.string().transform((value, context) => {
-    try {
-        return contractId(value);
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected ContractId" });
-        return z.NEVER;
-    }
-});
-const snapshotIdSchema = z.string().transform((value, context) => {
-    try {
-        return snapshotId(value);
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected SnapshotId" });
-        return z.NEVER;
-    }
-});
 const contractRequestBaseSchema = z.object({ repoRoot: absolutePathSchema, contractId: contractIdSchema }).strict();
-const conflictRecoverySchema = z
-    .object({
-    materialize: z.literal("deliver --materialize-conflict --include-dirty"),
-    deliver: z.literal("deliver --include-dirty"),
-    staging: z.literal("not-required"),
-})
-    .strict();
 const auditRequestSchema = contractRequestBaseSchema
     .extend({
     includeDirty: z.boolean(),
@@ -76,26 +53,12 @@ const reviewReferenceSchema = z
     reviewFactId: nonblankStringSchema,
 })
     .strict();
-const materializedHandoffServiceSchema = z
-    .object({
+const materializedHandoffReferenceSchema = materializedConflictSchema;
+const materializedHandoffServiceSchema = materializedConflictSchema
+    .extend({
     kind: z.literal("materialized-handoff"),
     repoRoot: absolutePathSchema,
     contractId: contractIdSchema,
-    targetHead: snapshotIdSchema,
-    handoffBase: snapshotIdSchema,
-    recovery: conflictRecoverySchema,
-    conflictPaths: z.array(nonblankStringSchema).transform((paths) => Object.freeze(paths)),
-    workspace: z.object({ kind: z.literal("worktree"), path: nonblankStringSchema }).strict(),
-})
-    .strict();
-const materializedHandoffReferenceSchema = z
-    .object({
-    kind: z.literal("integration-conflict-materialized"),
-    targetHead: snapshotIdSchema,
-    handoffBase: snapshotIdSchema,
-    recovery: conflictRecoverySchema,
-    conflictPaths: z.array(nonblankStringSchema).transform((paths) => Object.freeze(paths)),
-    workspace: z.object({ kind: z.literal("worktree"), path: nonblankStringSchema }).strict(),
 })
     .strict();
 const contractServiceSchema = z.union([
@@ -144,86 +107,102 @@ function executionObservation(facts) {
         return {};
     return { observe: (event) => facts.progress?.(event) };
 }
+function acceptedDeliveryEvidence(result) {
+    const leading = result.value.leading;
+    if (leading === undefined)
+        throw new Error("accepted delivery is missing its leading admission evidence");
+    return leading.fact;
+}
+function acceptedReviewEvidence(result, contractId) {
+    const review = result.facts.findLast((fact) => fact.contract === contractId && fact.kind === "attestation" && fact.data.gate === "reviewed");
+    if (review === undefined)
+        throw new Error("accepted review is missing its addressed journal fact");
+    return review.entry;
+}
 async function executeContractRequest(request, facts, port) {
     const observation = executionObservation(facts);
     if (request.action === "contract.audit") {
-        const served = await port.audit({
+        const result = await port.audit({
             ...request,
             ...observation,
             requester: facts.requester,
             signal: facts.signal,
         });
-        if (served.auditReport === undefined)
-            throw new Error(`Contract ${request.action} completed without durable service evidence`);
+        if (result.kind !== "accepted")
+            return { kind: "voided", outcome: result };
         return {
-            result: served.result,
+            kind: "served",
+            result,
             service: {
                 kind: "audit-report",
                 repoRoot: request.repoRoot,
                 contractId: request.contractId,
-                report: served.auditReport,
+                report: result.value,
             },
         };
     }
     if (request.action === "contract.deliver") {
-        const served = await port.deliver({
+        const result = await port.deliver({
             ...request,
             ...observation,
             overwrite: request.overwrite ?? false,
             requester: facts.requester,
             signal: facts.signal,
         });
-        if ("kind" in served.result && served.result.kind === "integration-conflict-materialized") {
+        if (result.kind === "refused" || result.kind === "retry")
+            return { kind: "voided", outcome: result };
+        if (result.kind === "handoff") {
             return {
-                result: served.result,
+                kind: "served",
+                result,
                 service: {
                     kind: "materialized-handoff",
                     repoRoot: request.repoRoot,
                     contractId: request.contractId,
-                    targetHead: served.result.targetHead,
-                    handoffBase: served.result.handoffBase,
-                    recovery: served.result.recovery,
-                    conflictPaths: served.result.conflictPaths,
-                    workspace: served.result.workspace,
+                    targetHead: result.value.targetHead,
+                    handoffBase: result.value.handoffBase,
+                    recovery: result.value.recovery,
+                    conflictPaths: result.value.conflictPaths,
+                    workspace: result.value.workspace,
                 },
             };
         }
-        if (served.deliveryFactId === undefined)
-            throw new Error(`Contract ${request.action} completed without durable service evidence`);
         return {
-            result: served.result,
+            kind: "served",
+            result,
             service: {
                 kind: "accepted-reference",
                 repoRoot: request.repoRoot,
                 contractId: request.contractId,
-                deliveryFactId: served.deliveryFactId,
+                deliveryFactId: acceptedDeliveryEvidence(result),
             },
         };
     }
-    const served = await port.review({
+    const result = await port.review({
         ...request,
         ...observation,
         requester: facts.requester,
         signal: facts.signal,
     });
-    if (served.reviewFactId === undefined)
-        throw new Error(`Contract ${request.action} completed without durable service evidence`);
+    if (result.kind !== "accepted")
+        return { kind: "voided", outcome: result };
     return {
-        result: served.result,
+        kind: "served",
+        result,
         service: {
             kind: "accepted-reference",
             repoRoot: request.repoRoot,
             contractId: request.contractId,
-            reviewFactId: served.reviewFactId,
+            reviewFactId: acceptedReviewEvidence(result, request.contractId),
         },
     };
 }
 function decodedContractResult(action, value) {
     const schema = action === "contract.audit"
-        ? auditResultSchema
+        ? outcomeSchema("audit", auditReportSchema)
         : action === "contract.deliver"
-            ? deliveryResultSchema
-            : reviewResultSchema;
+            ? outcomeSchema("deliver", deliveryValueSchema, materializedHandoffReferenceSchema)
+            : outcomeSchema("review", reviewSchema);
     const parsed = schema.safeParse(value);
     if (!parsed.success)
         throw new Error(`transport integrity: Contract ${action} returned an invalid live result`);
@@ -240,8 +219,8 @@ export function contractRequestProtocol(action) {
         decodeRequest: (value) => decodeContractRequest(action, value),
         encodeResult: (value) => value,
         decodeResult: (value) => decodedContractResult(action, value),
-        encodeFailure: encodeContractLiveFailure,
-        decodeFailure: decodeContractLiveFailure,
+        encodeFailure: encodeFailureWire,
+        decodeFailure: (value) => decodeFailureWire(value),
         decodeReference: (reference) => decodeContractReference(action, reference),
         isPermitted: (allowed) => allowed.includes(action),
     };
@@ -271,7 +250,7 @@ export async function requestForwardedContractLive(input) {
         value: input.request,
         onProgress: (value) => {
             try {
-                observeExecution(input.observe, decodeExecutionEvent(value));
+                observeExecution(input.observe, decodeExecutionObservation(value));
             }
             catch {
                 observeExecution(input.observe, { kind: "progress-dropped", count: 1 });
@@ -279,23 +258,35 @@ export async function requestForwardedContractLive(input) {
         },
         onProgressGap: (count) => observeExecution(input.observe, { kind: "progress-dropped", count }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
-    }).catch((error) => {
-        if (error instanceof AkumaBodyRequestError &&
-            error.outcome === "unproven" &&
-            error.cause instanceof Error &&
-            executionReceipt(error.cause) !== undefined) {
-            Object.defineProperties(error.cause, {
-                requestId: { value: error.requestId, enumerable: false },
-                action: { value: error.action, enumerable: false },
-                requestOutcome: { value: error.outcome, enumerable: false },
-            });
-            throw error.cause;
-        }
-        throw error;
-    });
+    }).catch((error) => mapForwardedContractFailure(error, input.request));
     if (response.kind === "reference") {
         throw new Error(`transport integrity: request ${response.requestId} action ${response.action} returned a durable reference without a live result`);
     }
     return response.result;
 }
-export { executeLocalDelivery, executeLocalReview, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./contract-forwarding.js";
+/** Map durable request disposition without reconstructing an expired owner answer. */
+export function mapForwardedContractFailure(error, request) {
+    if (error instanceof AkumaBodyRequestError && error.outcome === "voided") {
+        const operation = request.action === "contract.audit" ? "audit" : request.action === "contract.review" ? "review" : "deliver";
+        const projected = project(operation, new InvocationAccumulator().snapshot(), {
+            kind: "retry",
+            contract: request.contractId,
+            reason: { kind: "owner-reason-unavailable", diagnostic: error.diagnostic },
+        });
+        if (projected.kind === "failed")
+            throw projected.error;
+        return { kind: "returned", result: projected.outcome };
+    }
+    if (error instanceof AkumaBodyRequestError &&
+        error.outcome === "unproven" &&
+        error.cause instanceof Error &&
+        error.cause instanceof KeiyakuError) {
+        Object.defineProperties(error.cause, {
+            requestId: { value: error.requestId, enumerable: false },
+            action: { value: error.action, enumerable: false },
+            requestOutcome: { value: error.outcome, enumerable: false },
+        });
+        throw error.cause;
+    }
+    throw error;
+}

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

@@ -0,0 +1,71 @@
+/** @architectureCompositionRoot */
+import type { ContractId, Gate } from "../core/facts/types.js";
+import type { AuditReport } from "../protocol/audit.js";
+import type { ExecutionObserver } from "../protocol/execution-observation.js";
+import type { IntentOutcome, IntentRetry } from "../protocol/operations.js";
+import type { ContractWorkspaceLocation } from "../workspace-place.js";
+import type { Delivery, DeliveryValue } from "./delivery.js";
+import type { InvocationAccumulator } from "./invocation.js";
+import type { Keiyaku } from "./keiyaku.js";
+import type { ContractVerb, HandoffOutcome, OperationOutcome, OutcomeProjection, Review } from "./outcome.js";
+import type { OperationRefusals } from "./refusal.js";
+import type { AmendRegionObservation, RegionObservation } from "./region.js";
+export type BindValue = Readonly<{
+    keiyaku: Keiyaku;
+    workspace?: ContractWorkspaceLocation;
+    warnings?: readonly string[];
+}> & RegionObservation;
+export type AmendValue = Readonly<{
+    documentDiff: string;
+    changes: Readonly<{
+        gates?: readonly Gate[];
+        after?: readonly ContractId[];
+    }>;
+}> & AmendRegionObservation;
+export type BindOutcome = OperationOutcome<"bind", BindValue, OperationRefusals["bind"]>;
+export type AmendOutcome = OperationOutcome<"amend", AmendValue, OperationRefusals["amend"]>;
+export type DeliverOutcome = OperationOutcome<"deliver", Delivery & DeliveryValue, OperationRefusals["deliver"]> | HandoffOutcome;
+export type ReviewOutcome = OperationOutcome<"review", Review, OperationRefusals["review"]>;
+export type AuditOutcome = OperationOutcome<"audit", AuditReport, OperationRefusals["audit"]>;
+export type ArcOutcome = OperationOutcome<"arc", void, OperationRefusals["arc"]>;
+export type AbandonOutcome = OperationOutcome<"abandon", void, OperationRefusals["abandon"]>;
+export type MutationObservation = Readonly<{
+    observe?: ExecutionObserver;
+}>;
+export type AuditInput = Readonly<{
+    includeDirty?: boolean;
+    showDiff?: boolean;
+    signal?: AbortSignal;
+}>;
+export type BindResult = BindOutcome;
+type AcceptedIntent<Value> = Extract<IntentOutcome<Value>, {
+    kind: "accepted";
+}>;
+type Admission<Value, Refusal> = Readonly<{
+    kind: "accepted";
+    accepted: AcceptedIntent<Value>;
+}> | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: IntentRetry;
+}>;
+export declare function admissionOf<Value, Refusal>(outcome: IntentOutcome<Value, Refusal>): Admission<Value, Refusal>;
+/** The refused/retry arms are value-agnostic, so every operation can return them unchanged. */
+type ExpectedProjection<Refusal> = Readonly<{
+    kind: "refused";
+    contract?: ContractId;
+    refusal: Refusal;
+}> | Readonly<{
+    kind: "retry";
+    contract?: ContractId;
+    reason: IntentRetry;
+}>;
+export declare function expected<Refusal>(contract: ContractId | undefined, admission: Exclude<Admission<unknown, Refusal>, {
+    kind: "accepted";
+}>): ExpectedProjection<Refusal>;
+export declare function acceptedOutcome<Operation extends ContractVerb, Value>(operation: Operation, contract: ContractId, accumulator: InvocationAccumulator, value: Value): OutcomeProjection<Operation, Value, never>;
+export declare function conclusions(value: object): Readonly<Record<string, unknown>>;
+export declare function retainAdmission<Value>(accumulator: InvocationAccumulator, contract: ContractId, leading: AcceptedIntent<Value>, verificationResidueRecorded: boolean): void;
+export {};

package/build/src/library/contract-outcomes.js

@@ -0,0 +1,32 @@
+export function admissionOf(outcome) {
+    if (outcome.kind === "accepted")
+        return { kind: "accepted", accepted: outcome };
+    return outcome.kind === "refused"
+        ? { kind: "refused", refusal: outcome.refusal }
+        : { kind: "retry", reason: outcome.reason };
+}
+export function expected(contract, admission) {
+    return admission.kind === "refused"
+        ? {
+            kind: "refused",
+            ...(contract === undefined ? {} : { contract }),
+            refusal: admission.refusal,
+        }
+        : { kind: "retry", ...(contract === undefined ? {} : { contract }), reason: admission.reason };
+}
+export function acceptedOutcome(operation, contract, accumulator, value) {
+    void operation;
+    const head = accumulator.head(contract);
+    if (head === undefined)
+        throw new Error("missing leading admission receipt");
+    return { kind: "accepted", contract, head, value };
+}
+export function conclusions(value) {
+    return value;
+}
+export function retainAdmission(accumulator, contract, leading, verificationResidueRecorded) {
+    accumulator.recordPublication(contract, leading.head, leading.facts);
+    accumulator.recordResidue(contract, leading);
+    if (!verificationResidueRecorded)
+        accumulator.recordVerification(contract, undefined, leading);
+}

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

@@ -0,0 +1,25 @@
+/** @architectureCompositionRoot */
+import { type ActorId, type Gate } from "../core/facts/types.js";
+import { type WorktreeHooks } from "../git/hooks.js";
+import { type Settings } from "../settings.js";
+import type { LocalContractComposition } from "./contract-types.js";
+/** The one immutable Contract-local composition captured at construction. */
+export type LocalContractCompositionCapture = Readonly<{
+    settings?: Settings;
+    actor?: ActorId;
+}>;
+/**
+ * Hooks, freshness, and gate bundles are read from the captured Settings only at the operation
+ * that consumes them. Bare core (omitted Settings) keeps empty hooks, false freshness, and
+ * literal gate words; a broken selected namespace fails before any admission.
+ */
+export declare function derivedHooks(composition: LocalContractCompositionCapture): WorktreeHooks;
+/** The two Settings-derived Contract policies one mutating operation may consume. */
+export declare function derivedContractPolicy(composition: LocalContractCompositionCapture): Readonly<{
+    hooks: WorktreeHooks;
+    requireBranchesToBeUpToDate: boolean;
+}>;
+export declare function gateNames(value: unknown): readonly string[] | undefined;
+/** Bare words and configured bundles share validation, first-seen accumulation, and freezing. */
+export declare function derivedGates(composition: LocalContractCompositionCapture, names: readonly string[] | undefined): readonly Gate[];
+export declare function captureLocalContractComposition(input?: LocalContractComposition): LocalContractCompositionCapture;

package/build/src/library/contract-settings.js

@@ -0,0 +1,135 @@
+/** @architectureCompositionRoot */
+import { gate, gateWord } from "../core/facts/types.js";
+import { EMPTY_WORKTREE_HOOKS, worktreeHooksFrom } from "../git/hooks.js";
+import { SettingsError } from "../settings.js";
+import { actorOption, requireInput } from "./input.js";
+import { KeiyakuError } from "./outcome.js";
+/** One scoped Settings lookup: its native failure stays the cause of caller-invalid input. */
+function settingsScopedFailure(error) {
+    if (error instanceof SettingsError)
+        throw new KeiyakuError("invalid-input", error.message, { cause: error });
+    throw error;
+}
+/**
+ * Hooks, freshness, and gate bundles are read from the captured Settings only at the operation
+ * that consumes them. Bare core (omitted Settings) keeps empty hooks, false freshness, and
+ * literal gate words; a broken selected namespace fails before any admission.
+ */
+export function derivedHooks(composition) {
+    if (composition.settings === undefined)
+        return EMPTY_WORKTREE_HOOKS;
+    try {
+        return worktreeHooksFrom({ settings: composition.settings });
+    }
+    catch (error) {
+        return settingsScopedFailure(error);
+    }
+}
+function derivedFreshness(composition) {
+    if (composition.settings === undefined)
+        return false;
+    try {
+        const view = composition.settings.namespace("git");
+        if (view.kind === "failed")
+            namespaceFailure(view);
+        for (const entry of view.entries) {
+            if (entry.name !== "requireBranchesToBeUpToDate") {
+                throw new SettingsError(`git has unknown entry: ${entry.name}`);
+            }
+        }
+        const selected = view.entries.find((entry) => entry.name === "requireBranchesToBeUpToDate");
+        if (selected === undefined)
+            return false;
+        if (typeof selected.value !== "boolean") {
+            throw new SettingsError("git.requireBranchesToBeUpToDate must be a boolean");
+        }
+        return selected.value;
+    }
+    catch (error) {
+        return settingsScopedFailure(error);
+    }
+}
+/** The two Settings-derived Contract policies one mutating operation may consume. */
+export function derivedContractPolicy(composition) {
+    return { hooks: derivedHooks(composition), requireBranchesToBeUpToDate: derivedFreshness(composition) };
+}
+export function gateNames(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new TypeError("gates must be an array");
+    return value.map((item, index) => {
+        if (typeof item !== "string")
+            throw new TypeError(`gates[${index}] must be a string`);
+        return item;
+    });
+}
+function namespaceFailure(view) {
+    throw new SettingsError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
+}
+function gateValue(value, message, configured) {
+    if (!gateWord(value)) {
+        if (configured)
+            throw new SettingsError(message);
+        throw new KeiyakuError("invalid-input", message, { cause: new TypeError(message) });
+    }
+    return gate(value);
+}
+function bundleGates(name, value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new SettingsError(`gate bundle '${name}' must be an object`);
+    }
+    const bundle = value;
+    if (bundle.kind !== "bundle") {
+        throw new SettingsError(`gate bundle '${name}' has unsupported kind: ${String(bundle.kind)}`);
+    }
+    for (const field of Object.keys(bundle)) {
+        if (field !== "kind" && field !== "gates") {
+            throw new SettingsError(`gate bundle '${name}' has unknown field: ${field}`);
+        }
+    }
+    if (!Array.isArray(bundle.gates))
+        throw new SettingsError(`gate bundle '${name}'.gates must be an array`);
+    return bundle.gates.map((value) => gateValue(value, `gate bundle '${name}' contains an invalid gate word`, true));
+}
+/** Bare words and configured bundles share validation, first-seen accumulation, and freezing. */
+export function derivedGates(composition, names) {
+    const settings = composition.settings;
+    const configured = settings !== undefined;
+    try {
+        const selected = (names ?? (configured ? ["default"] : [])).map((name, index) => gateValue(name, configured
+            ? "gate or bundle name must match ^[a-z][a-z0-9-]{0,63}$"
+            : `gates[${index}] must match ^[a-z][a-z0-9-]{0,63}$`, configured));
+        // Explicit empty selection never looks up a namespace.
+        if (selected.length === 0)
+            return Object.freeze([]);
+        const view = settings?.namespace("gates");
+        if (view?.kind === "failed")
+            namespaceFailure(view);
+        const expanded = new Set();
+        for (const name of selected) {
+            const entry = view?.entries.find((entry) => entry.name === name);
+            const gates = entry === undefined
+                ? [configured && names === undefined ? gate("reviewed") : name]
+                : bundleGates(name, entry.value);
+            for (const value of gates)
+                expanded.add(value);
+        }
+        return Object.freeze([...expanded]);
+    }
+    catch (error) {
+        return settingsScopedFailure(error);
+    }
+}
+export function captureLocalContractComposition(input) {
+    const values = requireInput(input === undefined ? {} : input, "Keiyaku.with input", ["settings", "actor"]);
+    const actor = actorOption(values.actor).actor;
+    const settings = values.settings;
+    if (settings !== undefined && (settings === null || typeof settings !== "object")) {
+        throw new TypeError("Keiyaku.with settings must be a Settings value");
+    }
+    return Object.freeze({
+        ...(actor === undefined ? {} : { actor }),
+        ...(settings === undefined ? {} : { settings: settings }),
+    });
+}

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

@@ -1,26 +1,14 @@
-import type { ContractId, JournalEntry, SnapshotId } from "../core/facts/types.js";
-import type { ContractFileEffect, ContractFileLag } from "../contract-worktree.js";
-import type { ReconcileReport as ProtocolReconcileReport } from "../protocol/reconcile.js";
+import type { AttestationData, ContractId, JournalEntry, SnapshotId } from "../core/facts/types.js";
 import type { Dispatch } from "../dispatch/index.js";
-import type { Gate, WorktreeHooks } from "./configuration.js";
-import type { AmendRegionObservation, RegionObservation } from "./region.js";
-import type { Repo } from "./repo.js";
-import type { MutationResult } from "./mutation.js";
-import type { SettlementReport } from "../settlement/settle.js";
-import type { AttestationVerdict } from "./contract.js";
-import type { Keiyaku } from "./contract-handle.js";
 import type { ContractBoard, ContractRow } from "../protocol/read/status.js";
+import type { Settings } from "../settings.js";
 import type { TaskId } from "../task/identity.js";
-import type { ContractWorkspaceLocation } from "../workspace-place.js";
-export type BindResult = Readonly<Omit<MutationResult<Keiyaku>, "value"> & {
-    keiyaku: Keiyaku;
-    workspace?: ContractWorkspaceLocation;
-    warnings?: readonly string[];
-} & RegionObservation>;
-export type Fact = JournalEntry;
+import type { Repo } from "./repo.js";
+/** Public gate words remain ordinary strings; private policy interprets them. */
+export type Gate = string;
 export type ContractHistoryEvent = Readonly<{
     source: "journal";
-    fact: Fact;
+    fact: JournalEntry;
 }> | Readonly<{
     source: "dispatch";
     dispatch: Dispatch;
@@ -28,19 +16,13 @@ export type ContractHistoryEvent = Readonly<{
 export type ContractHistory = Readonly<{
     id: ContractId;
     state: SnapshotId;
+    workspace?: Readonly<{
+        kind: "worktree";
+        path: string;
+    }>;
     events: readonly ContractHistoryEvent[];
 }>;
-export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
-export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
-export type AmendResult = Readonly<MutationResult<void> & {
-    documentDiff: string;
-}> & AmendRegionObservation;
-export type ReconcileReport = Readonly<{
-    effects: readonly (ProtocolReconcileReport["effects"][number] | ContractFileEffect)[];
-    lag: readonly (ProtocolReconcileReport["lag"][number] | ContractFileLag)[];
-    settlement: SettlementReport;
-}>;
-export type MarkdownBindInput = Readonly<{
+type MarkdownBindInput = Readonly<{
     repo: Repo;
     markdown: string;
     task?: TaskId;
@@ -48,31 +30,28 @@ export type MarkdownBindInput = Readonly<{
     workspace?: "worktree";
     actor?: string;
     after?: readonly ContractId[];
-    gates?: readonly Gate[];
-    hooks?: WorktreeHooks;
+    gates?: readonly string[];
 }>;
-export type ForkBindInput = Readonly<{
+type ForkBindInput = Readonly<{
     repo: Repo;
     forkOf: ContractId;
     target?: string;
     workspace?: "worktree";
     actor?: string;
-    hooks?: WorktreeHooks;
 }>;
 export type BindInput = MarkdownBindInput | ForkBindInput;
 type ActorOptions = Readonly<{
     actor?: string;
-    hooks?: WorktreeHooks;
 }>;
+/** Contract-local composition: one captured Settings selection and the operation actor. */
 export type LocalContractComposition = Readonly<{
+    settings?: Settings;
     actor?: string;
-    hooks?: WorktreeHooks;
-    requireBranchesToBeUpToDate?: boolean;
 }>;
 export type AmendInput = ActorOptions & Readonly<{
     markdown?: string;
     after?: readonly ContractId[];
-    gates?: readonly Gate[];
+    gates?: readonly string[];
 }>;
 export type ArcInput = ActorOptions & Readonly<{
     markdown: string;
@@ -94,7 +73,7 @@ export type KeiyakuSelectInput = Readonly<{
     id: ContractId;
 }>;
 export type ReviewInput = Readonly<{
-    verdict: AttestationVerdict;
+    verdict: AttestationData["verdict"];
     summary?: string;
     signal?: AbortSignal;
 }>;