@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/library/akuma-creation.js

@@ -1,6 +1,6 @@
 import { realpath, stat } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
-import { Akuma, } from "../akuma/akuma.js";
+import { Akuma, akumaCallExecution, callAkumaWithContext, } from "../akuma/akuma.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch, } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
@@ -28,6 +28,17 @@ function settingsOption(value) {
     }
     return value;
 }
+function homeOption(value) {
+    if (value === undefined)
+        return undefined;
+    return nonblank(value, "home");
+}
+function akumaWorld(path, home, settings) {
+    return Akuma.of(path, {
+        ...(home === undefined ? {} : { home }),
+        ...(settings === undefined ? {} : { settings }),
+    });
+}
 function onlyKeys(values, allowed, label) {
     const accepted = new Set(allowed);
     for (const key of Object.keys(values)) {
@@ -132,31 +143,33 @@ async function resolveCallExecution(input) {
             source: "input",
         };
     }
-    if (input.contract === undefined)
-        return { cwd: input.path, source: "world" };
-    const seat = seatForKeiyaku(input.contract);
-    const state = await currentManagedContract(input.contract, seat.id);
-    const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
-    if (appointment.kind === "unappointed") {
-        throw unavailableWorkspace(state.id, "is unappointed; use reconcile");
-    }
-    if (appointment.kind === "failed") {
-        throw new Error(`${appointment.diagnostic}; use reconcile`);
+    if (input.contract !== undefined) {
+        const seat = seatForKeiyaku(input.contract);
+        const state = await currentManagedContract(input.contract, seat.id);
+        const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
+        if (appointment.kind === "unappointed") {
+            throw unavailableWorkspace(state.id, "is unappointed; use reconcile");
+        }
+        if (appointment.kind === "failed") {
+            throw new Error(`${appointment.diagnostic}; use reconcile`);
+        }
+        return {
+            cwd: await canonicalizeExistingDirectory(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
+            source: "contract-worktree",
+        };
     }
-    return {
-        cwd: await canonicalizeExistingDirectory(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
-        source: "contract-worktree",
-    };
+    return undefined;
 }
 export async function callKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.call input");
-    onlyKeys(values, ["path", "archetype", "body", "cwd", "mode", "timeoutMs", "settings", "contract", "alias"], "Keiyaku.call input");
+    onlyKeys(values, ["path", "archetype", "body", "cwd", "mode", "timeoutMs", "home", "settings", "contract", "alias", "allowed"], "Keiyaku.call input");
     const path = nonblank(values.path, "path");
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
     const cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
     const mode = callMode(values.mode);
     const timeoutMs = callTimeout(values.timeoutMs, mode);
+    const home = homeOption(values.home);
     const settings = settingsOption(values.settings);
     const alias = values.alias === undefined
         ? undefined
@@ -167,11 +180,19 @@ export async function callKeiyaku(input) {
         ...(cwd === undefined ? {} : { cwd }),
         ...(seat === undefined ? {} : { contract: values.contract }),
     });
-    const handle = await Akuma.of(path, settings).call({
+    const world = akumaWorld(path, home, settings);
+    const call = {
         archetype,
         body,
-        cwd: execution.cwd,
-    });
+        ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
+        ...(execution === undefined ? {} : { cwd: execution.cwd }),
+    };
+    const handle = execution === undefined
+        ? await world.call(call)
+        : await callAkumaWithContext(world, call, { cwdCanonical: true });
+    const completedExecution = execution ?? akumaCallExecution(handle);
+    if (completedExecution === undefined)
+        throw new Error("Akuma call is missing its birth execution");
     const readonly = (await handle.status()).readonly;
     const dispatch = seat === undefined
         ? { kind: "none" }
@@ -195,7 +216,7 @@ export async function callKeiyaku(input) {
         kind: "called",
         akuma: handle.id,
         ...(readonly === undefined ? {} : { readonly }),
-        execution,
+        execution: completedExecution,
         dispatch,
         alias: aliasStage,
         observation,
@@ -203,19 +224,15 @@ export async function callKeiyaku(input) {
 }
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
-    onlyKeys(values, ["path", "akuma", "at", "settings", "repo"], "Keiyaku.fork input");
+    onlyKeys(values, ["path", "akuma", "at", "repo"], "Keiyaku.fork input");
     const path = nonblank(values.path, "path");
     const at = nonblank(values.at, "at");
-    const settings = settingsOption(values.settings);
     const akuma = (await addressAkuma({
         path,
         akuma: nonblank(values.akuma, "akuma"),
-        ...(settings === undefined ? {} : { settings }),
     })).id;
     const repository = values.repo === undefined ? undefined : scopeForRepo(values.repo);
-    const receipt = await Akuma.of(path, settings)
-        .of({ id: akuma })
-        .fork({ at });
+    const receipt = await Akuma.of(path).of({ id: akuma }).fork({ at });
     if (receipt.kind !== "forked")
         return { ...receipt, parent: akuma };
     const dispatch = repository === undefined

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

@@ -1,5 +1,6 @@
 import type { ContractId } from "../core/facts/types.js";
-import { type AuditReport, type RepositoryScope } from "../protocol/operations.js";
+import { type AuditReport } from "../protocol/audit.js";
+import type { RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
 import { type MutationResult } from "./mutation.js";
 export type AuditInput = Readonly<{

package/build/src/library/audit.js

@@ -1,6 +1,6 @@
 import { decodeContractDocument } from "../body/decode.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
-import { auditOperation, } from "../protocol/operations.js";
+import { auditOperation } from "../protocol/audit.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput, } from "./input.js";
 import { completeMutation } from "./mutation.js";

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

@@ -1,6 +1,7 @@
 import { type ActorId, type ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { bindOperation, type IntentOutcome, type RepositoryScope } from "../protocol/operations.js";
+import { bindOperation } from "../protocol/bind.js";
+import type { IntentOutcome, RepositoryScope } from "../protocol/operations.js";
 import type { TaskId } from "../task/identity.js";
 import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
 import type { KeiyakuRefusal } from "./refusal.js";

package/build/src/library/bind.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { releaseContractWorktree, reserveContractWorktree, withContractWorktreeAppointment, } from "../contract-worktree.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
 import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
-import { bindOperation } from "../protocol/operations.js";
+import { bindOperation } from "../protocol/bind.js";
 import { claimTaskHolder } from "../settlement/holder.js";
 function candidateId(title, collision) {
     const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
@@ -13,7 +13,6 @@ async function attempt(input, id) {
     return bindOperation({
         scope: input.scope,
         channel: input.channel,
-        title: input.title,
         terms: input.terms,
         verification: input.verification,
         workspace: input.workspace,
@@ -26,6 +25,7 @@ async function attempt(input, id) {
     });
 }
 async function attemptCandidates(input) {
+    let result;
     for (let collision = 0; collision <= 3; collision += 1) {
         const id = candidateId(input.title, collision);
         let reserved = false;
@@ -40,7 +40,7 @@ async function attemptCandidates(input) {
             }
             reserved = true;
         }
-        const result = await attempt(input, id);
+        result = await attempt(input, id);
         if (result.kind === "accepted")
             return result;
         if (reserved)
@@ -48,7 +48,7 @@ async function attemptCandidates(input) {
         if (result.kind !== "refused" || result.refusal.kind !== "contract-exists")
             return result;
     }
-    throw new Error("contract identity collision attempts exhausted");
+    return result;
 }
 export async function admitBindWithAppointment(input) {
     const action = () => attemptCandidates(input);

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

@@ -1,6 +1,5 @@
 import { type AkumaList } from "../akuma/akuma.js";
 import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
-import type { Settings } from "../settings.js";
 import type { TaskRow } from "../task/index.js";
 import { type ContractBoard } from "./contract.js";
 import { Repo } from "./repo.js";
@@ -29,7 +28,7 @@ export type CatalogInput = Readonly<{
     query: Extract<CatalogQuery, {
         kind: "archetypes";
     }>;
-    settings: Settings;
+    home?: string;
 }> | Readonly<{
     query: Extract<CatalogQuery, {
         kind: "akuma";

package/build/src/library/catalog.js

@@ -4,10 +4,11 @@ import { observeTaskCatalogRows } from "../task/operations.js";
 import { listKeiyaku } from "./contract.js";
 import { requireInput } from "./input.js";
 import { Repo } from "./repo.js";
-function settingsValue(value) {
-    if (typeof value !== "object" || value === null
-        || typeof value.namespace !== "function") {
-        throw new TypeError("settings must be a Settings");
+function optionalHome(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError("home must be a nonblank string");
     }
     return value;
 }
@@ -40,7 +41,7 @@ export async function listCatalog(input) {
     const values = requireInput(input, "Keiyaku.ls input");
     const query = queryValue(values.query);
     const allowed = query.kind === "contracts" ? ["query", "repo"]
-        : query.kind === "archetypes" ? ["query", "settings"] : ["query", "path"];
+        : query.kind === "archetypes" ? ["query", "home"] : ["query", "path"];
     for (const key of Object.keys(values)) {
         if (!allowed.includes(key))
             throw new TypeError(`Keiyaku.ls input has unknown field: ${key}`);
@@ -52,7 +53,11 @@ export async function listCatalog(input) {
         return { kind: "contracts", root: board.root, state: board.state, rows: board.rows };
     }
     if (query.kind === "archetypes") {
-        return { kind: "archetypes", rows: await listArchetypeDefinitions({ settings: settingsValue(values.settings) }) };
+        const home = optionalHome(values.home);
+        return {
+            kind: "archetypes",
+            rows: await listArchetypeDefinitions(home === undefined ? {} : { home }),
+        };
     }
     const path = worldRoot(values.path);
     if (query.kind === "tasks") {

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

@@ -4,14 +4,18 @@ export type { HookCommand, WorktreeHooks } from "../git/hooks.js";
 export type Gate = string;
 export type GatesFromInput = Readonly<{
     settings: Settings;
-    name?: string;
+    names?: readonly string[];
 }>;
 export type RequireBranchesToBeUpToDateFromInput = Readonly<{
     settings: Settings;
 }>;
+export type WorktreeHooksFromInput = Readonly<{
+    settings: Settings;
+}>;
 export { SettingsError };
 export declare function gatesFrom(input: GatesFromInput): readonly Gate[];
 export declare function requireBranchesToBeUpToDateFrom(input: RequireBranchesToBeUpToDateFromInput): boolean;
+export declare function worktreeHooksFrom(input: WorktreeHooksFromInput): WorktreeHooks;
 export declare function normalizedWorktreeHooks(value: unknown): WorktreeHooks;
 export declare const EMPTY_WORKTREE_HOOKS: WorktreeHooks;
 export declare function worktreeHooksOption(value: unknown): WorktreeHooks;

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))
@@ -76,6 +110,25 @@ export function requireBranchesToBeUpToDateFrom(input) {
     }
     return selected.value;
 }
+export function worktreeHooksFrom(input) {
+    if (!record(input))
+        throw new TypeError("worktreeHooksFrom input must be an object");
+    const view = input.settings.namespace("worktree");
+    if (view.kind === "failed")
+        namespaceFailure(view);
+    for (const entry of view.entries) {
+        if (entry.name !== "create" && entry.name !== "destroy") {
+            throw new SettingsError(`worktree has unknown entry: ${entry.name}`);
+        }
+    }
+    const selected = (phase) => {
+        const entry = view.entries.find((item) => item.name === phase);
+        if (entry === undefined)
+            return Object.freeze([]);
+        return commands(entry.value, `worktree.${phase}`, SettingsError);
+    };
+    return Object.freeze({ create: selected("create"), destroy: selected("destroy") });
+}
 export function normalizedWorktreeHooks(value) {
     if (!record(value))
         throw new TypeError("hooks must be an object");

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

@@ -3,20 +3,42 @@ 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 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";
 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, };
 export type { TaskId };
 export type { RegionOverlap };
 export type Fact = JournalEntry;
+export type ContractHistoryEvent = Readonly<{
+    source: "journal";
+    fact: Fact;
+}> | Readonly<{
+    source: "dispatch";
+    dispatch: Dispatch;
+}>;
+export type ContractHistory = Readonly<{
+    id: ContractId;
+    state: SnapshotId;
+    events: readonly ContractHistoryEvent[];
+}>;
 export type ActorId = string;
 export type AttestationVerdict = "satisfied" | "unsatisfied";
 export type Review = ReviewValue;
@@ -49,7 +71,7 @@ export type BindInput = Readonly<{
     hooks?: WorktreeHooks;
 }>;
 export type AmendInput = Readonly<{
-    markdown: string;
+    markdown?: string;
     actor?: ActorId;
     after?: readonly ContractId[];
     gates?: readonly Gate[];
@@ -90,12 +112,57 @@ export type DeliverInput = ActorOptions & Readonly<{
     includeDirty?: boolean;
     signal?: AbortSignal;
 }>;
+type ForwardedDeliveryReceipt = Readonly<{
+    kind: "accepted";
+    result: MutationResult<DeliverValue>;
+}> | Readonly<{
+    kind: "refused";
+    refusal: KeiyakuRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: KeiyakuRetryReason;
+}>;
+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;
+    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;
     constructor(id: ContractId, scope: RepositoryScope);
     state(): Promise<ContractState>;
+    history(): Promise<ContractHistory>;
     guidance(): Promise<string>;
     delivery(): Promise<Delivery | null>;
     amend(input: AmendInput): Promise<AmendResult>;