@astrosheep/keiyaku 4.0.2 → 4.0.4

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

@@ -9,9 +9,13 @@ export type GatesFromInput = Readonly<{
 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

@@ -76,6 +76,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

@@ -4,6 +4,7 @@ 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 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";
@@ -17,6 +18,18 @@ export type { AuditReport, DeliveryPreparationRefusal, ChangeId, ContractId, Con
 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 +62,7 @@ export type BindInput = Readonly<{
     hooks?: WorktreeHooks;
 }>;
 export type AmendInput = Readonly<{
-    markdown: string;
+    markdown?: string;
     actor?: ActorId;
     after?: readonly ContractId[];
     gates?: readonly Gate[];
@@ -96,6 +109,7 @@ export declare class KeiyakuHandle {
     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>;

package/build/src/library/contract.js

@@ -9,7 +9,10 @@ import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { abandonOperation, amendOperation, arcOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
-import { withGitDecodeChannel } from "../git/read-observation.js";
+import { readDispatchesAt } from "../dispatch/index.js";
+import { mintSnapshotId } from "../git/identity.js";
+import { observeContractsForAdmissionInObservationAt } from "../git/observe.js";
+import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
 import { claimTaskHolderWithFence, releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection, } from "../settlement/holder.js";
 import { parseTaskId } from "../task/identity.js";
 import { reconcileInput, scopeForRepo } from "./repo.js";
@@ -53,6 +56,38 @@ export class KeiyakuHandle {
             contractId: this.id,
         }));
     }
+    async history() {
+        return withGitDecodeChannel(this.scope, (channel) => withGitReadObservation(this.scope, channel, async (observation) => {
+            const [journals, dispatches] = await Promise.all([
+                observeContractsForAdmissionInObservationAt(observation, [this.id]),
+                readDispatchesAt(observation),
+            ]);
+            const record = journals.journals.get(this.id);
+            if (record === undefined)
+                throw new Error(`missing requested contract observation: ${this.id}`);
+            if (record.state === null)
+                throw new KeiyakuRefused({ kind: "contract-missing", contractId: this.id });
+            const commit = observation.snapshot.commit;
+            if (commit === null)
+                throw new Error("contract history requires a keiyaku-state snapshot");
+            const recordedAt = (event) => (event.source === "journal" ? event.fact.at : event.dispatch.dispatchedAt);
+            const events = [
+                ...record.entries.map((fact) => ({ source: "journal", fact })),
+                ...dispatches
+                    .filter((dispatch) => dispatch.contractId === this.id)
+                    .map((dispatch) => ({ source: "dispatch", dispatch })),
+            ].sort((left, right) => {
+                const leftAt = recordedAt(left);
+                const rightAt = recordedAt(right);
+                if (leftAt !== rightAt)
+                    return leftAt < rightAt ? -1 : 1;
+                if (left.source !== right.source)
+                    return left.source === "journal" ? -1 : 1;
+                return 0;
+            });
+            return { id: this.id, state: mintSnapshotId(commit), events };
+        }));
+    }
     async guidance() {
         return withGitDecodeChannel(this.scope, async (channel) => {
             const observed = await contractObservationOperation({ scope: this.scope, channel, contractId: this.id });
@@ -74,12 +109,15 @@ export class KeiyakuHandle {
     async amend(input) {
         const values = requireInput(input, "amend input");
         const hooks = worktreeHooksOption(values.hooks);
-        const markdown = requireMarkdown(values.markdown);
+        const markdown = values.markdown === undefined ? undefined : requireMarkdown(values.markdown);
         const actor = actorOption(values.actor);
         const gates = values.gates === undefined ? undefined : normalizedGates(values.gates);
         const prerequisites = values.after === undefined
             ? undefined
             : normalizedList(values.after, "after", contractId);
+        if (markdown === undefined && gates === undefined && prerequisites === undefined) {
+            throw new TypeError("amend requires markdown, after, or gates");
+        }
         return withGitDecodeChannel(this.scope, async (channel) => {
             const accepted = requireAccepted(await amendOperation({
                 scope: this.scope,
@@ -87,8 +125,17 @@ export class KeiyakuHandle {
                 contractId: this.id,
                 ...actor,
                 deriveAmendment: (source) => {
-                    const document = decodeContractDocument(applyAmendDocument(markdown, decodeContractDocument(source.document.bytes)));
-                    const terms = contractTerms(document, gates ?? source.gates, prerequisites ?? source.after);
+                    const document = markdown === undefined
+                        ? decodeContractDocument(source.document.bytes)
+                        : decodeContractDocument(applyAmendDocument(markdown, decodeContractDocument(source.document.bytes)));
+                    const terms = markdown === undefined
+                        ? {
+                            document: source.document,
+                            segments: source.segments,
+                            gates: gates ?? source.gates,
+                            after: prerequisites ?? source.after,
+                        }
+                        : contractTerms(document, gates ?? source.gates, prerequisites ?? source.after);
                     return {
                         terms,
                         verification: documentDerivation(document, terms.gates, this.id).verification,

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

@@ -1,23 +1,34 @@
 import { type ActivityHistory, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
 import type { ContractId } from "../core/facts/types.js";
+import type { TaskRow } from "../task/index.js";
+import type { WorldRoot } from "../world.js";
 import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
+import { type Repo } from "./repo.js";
+export type CreatedTaskObservation = Readonly<{
+    kind: "present";
+    rows: readonly TaskRow[];
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+export type AkumaObservation = Readonly<{
+    status: AkumaStatus;
+    contractId?: ContractId;
+    createdTasks: CreatedTaskObservation;
+}>;
 export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
 }>;
 export type AkumaWaitResult = Readonly<{
     completion: "any" | "all";
-    statuses: readonly AkumaStatusView[];
-}>;
-export type AkumaStatusView = Readonly<{
-    status: AkumaStatus;
-    contractId?: ContractId;
+    observations: readonly AkumaObservation[];
 }>;
 export type AkumaKillResult = Readonly<{
     results: readonly Readonly<{
         id: AkumaStatus["id"];
         evidence: KillEvidence;
-        observation: AkumaStatusView;
+        observation: AkumaObservation;
     }>[];
 }>;
 export type AkumaTellInput = AkumaAddressInput & Readonly<{
@@ -26,7 +37,7 @@ export type AkumaTellInput = AkumaAddressInput & Readonly<{
 export type AkumaTellResult = Readonly<{
     akuma: AkumaStatus["id"];
     tell: TellResult;
-    observation: AkumaStatusView;
+    observation: AkumaObservation;
 }>;
 export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
     body: string;
@@ -34,7 +45,7 @@ export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
 export type AkumaInterruptResult = Readonly<{
     id: AkumaStatus["id"];
     receipt: InterruptReceipt;
-    observation: AkumaStatusView;
+    observation: AkumaObservation;
 }>;
 export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
     before?: number;
@@ -57,9 +68,36 @@ export type AkumaHistoryResult = Readonly<{
     id: AkumaStatus["id"];
     contractId?: ContractId;
 }>;
-export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaStatusView>;
+type WaitExecutionInput = Readonly<{
+    path: WorldRoot;
+    ids: readonly AkumaStatus["id"][];
+    completion: "any" | "all";
+    timeoutMs?: number;
+    repo?: Repo;
+    signal?: AbortSignal;
+}>;
+export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<AkumaWaitResult>;
+type TellExecutionInput = Readonly<{
+    path: WorldRoot;
+    id: AkumaStatus["id"];
+    body: string;
+    tellId?: string;
+    recordedAt?: string;
+    repo?: Repo;
+    signal?: AbortSignal;
+}>;
+export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
+type KillExecutionInput = Readonly<{
+    path: WorldRoot;
+    ids: readonly AkumaStatus["id"][];
+    repo?: Repo;
+    signal?: AbortSignal;
+}>;
+export declare function executeKillAkuma(input: KillExecutionInput): Promise<AkumaKillResult>;
+export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaObservation>;
 export declare function waitAkuma(input: AkumaWaitInput): Promise<AkumaWaitResult>;
 export declare function killAkuma(input: AkumaSetAddressInput): Promise<AkumaKillResult>;
 export declare function tellAkuma(input: AkumaTellInput): Promise<AkumaTellResult>;
 export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
 export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;
+export {};

package/build/src/library/fleet.js

@@ -1,19 +1,45 @@
-import { Akuma, } from "../akuma/index.js";
-import { readActionFeedbackStatus, readBudgetedStatus } from "../akuma/akuma.js";
+import { Akuma, AkumaNotBornError, } from "../akuma/index.js";
+import { readBudgetedStatus, tellAkumaWithId } from "../akuma/akuma.js";
+import { injectedBodyRequests, requestBodyKill, requestBodyTell, requestBodyWait, } from "../akuma/requests.js";
 import { readDispatch } from "../dispatch/index.js";
+import { observeTaskBoard } from "../task/operations.js";
 import { addressAkuma, addressAkumaSet } from "./address.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
-function source(path, settings) {
-    return Akuma.of(path, settings);
+function source(path) {
+    return Akuma.of(path);
 }
 async function contractFor(repo, id) {
     const dispatch = repo === undefined ? null : await readDispatch(scopeForRepo(repo), id);
     return dispatch?.contractId;
 }
-async function statusView(status, repo) {
-    const contractId = await contractFor(repo, status.id);
-    return contractId === undefined ? { status } : { status, contractId };
+function createdTaskDiagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function createdTasksFor(path, statuses) {
+    let board;
+    try {
+        board = await observeTaskBoard(path);
+    }
+    catch (error) {
+        const failed = { kind: "failed", diagnostic: createdTaskDiagnostic(error) };
+        return statuses.map(() => failed);
+    }
+    return statuses.map((status) => ({ kind: "present", rows: board.selectCreatedBy(status.id) }));
+}
+async function observeAkuma(status, path, repo) {
+    return (await observeAkumaSet([status], path, repo))[0];
+}
+async function observeAkumaSet(statuses, path, repo) {
+    const created = await createdTasksFor(path, statuses);
+    return await Promise.all(statuses.map(async (status, index) => {
+        const contractId = await contractFor(repo, status.id);
+        return {
+            status,
+            createdTasks: created[index],
+            ...(contractId === undefined ? {} : { contractId }),
+        };
+    }));
 }
 function timeout(value) {
     if (value === undefined)
@@ -23,28 +49,119 @@ function timeout(value) {
     }
     return value;
 }
-function delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+function delay(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        let timer;
+        const done = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            reject(signal?.reason ?? new Error("upstream request aborted"));
+        };
+        timer = setTimeout(done, milliseconds);
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener("abort", abort, { once: true });
+    });
 }
 const SHARED_ORDINARY_BUDGET = 30;
-async function observeWaitStatuses(path, ids, settings) {
+async function observeWaitStatuses(path, ids, signal) {
+    signal?.throwIfAborted();
     if (ids.length <= 1) {
-        return await Promise.all(ids.map(async (id) => await source(path, settings).of({ id }).status()));
+        return await Promise.all(ids.map(async (id) => await source(path).of({ id }).status()));
     }
     let remaining = SHARED_ORDINARY_BUDGET;
     const statuses = [];
     for (const id of ids) {
+        signal?.throwIfAborted();
         const observed = await readBudgetedStatus(path, id, { ordinaryBudget: remaining });
         statuses.push(observed.status);
         remaining -= observed.ordinarySelected;
     }
     return statuses;
 }
+export async function executeWaitAkuma(input) {
+    const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
+    for (;;) {
+        const statuses = await observeWaitStatuses(input.path, input.ids, input.signal);
+        const settled = statuses.map((status) => status.life !== "running");
+        if ((input.completion === "any" ? settled.some(Boolean) : settled.every(Boolean))
+            || (deadline !== undefined && performance.now() >= deadline)) {
+            return {
+                completion: input.completion,
+                observations: await observeAkumaSet(statuses, input.path, input.repo),
+            };
+        }
+        await delay(deadline === undefined ? 25 : Math.min(25, Math.max(0, deadline - performance.now())), input.signal);
+    }
+}
+export async function executeTellAkuma(input) {
+    input.signal?.throwIfAborted();
+    const handle = source(input.path).of({ id: input.id });
+    const tell = input.tellId === undefined
+        ? await handle.tell(input.body)
+        : await tellAkumaWithId(input.path, input.id, input.body, input.tellId, input.recordedAt);
+    input.signal?.throwIfAborted();
+    return {
+        akuma: input.id,
+        tell,
+        observation: await observeAkuma(await handle.status(), input.path, input.repo),
+    };
+}
+export async function executeKillAkuma(input) {
+    input.signal?.throwIfAborted();
+    const handles = input.ids.map((id) => source(input.path).of({ id }));
+    const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
+    input.signal?.throwIfAborted();
+    const statuses = await Promise.all(input.ids.map(async (id) => await source(input.path).of({ id }).status()));
+    const observations = await observeAkumaSet(statuses, input.path, input.repo);
+    return {
+        results: input.ids.map((id, index) => ({ id, evidence: evidence[index], observation: observations[index] })),
+    };
+}
+function upstreamResult(outcome) {
+    if (outcome.kind === "returned")
+        return outcome.result;
+    if (outcome.failure.kind === "akuma-not-born")
+        throw new AkumaNotBornError(outcome.failure.id);
+    throw new Error(outcome.failure.diagnostic);
+}
+async function attachContract(repo, observation) {
+    if (repo === undefined || observation.contractId !== undefined)
+        return observation;
+    const contractId = await contractFor(repo, observation.status.id);
+    return contractId === undefined ? observation : { ...observation, contractId };
+}
+async function attachWaitContracts(repo, result) {
+    return repo === undefined
+        ? result
+        : {
+            ...result,
+            observations: await Promise.all(result.observations.map((observation) => attachContract(repo, observation))),
+        };
+}
+async function attachTellContract(repo, result) {
+    return repo === undefined ? result : { ...result, observation: await attachContract(repo, result.observation) };
+}
+async function attachKillContracts(repo, result) {
+    return repo === undefined
+        ? result
+        : {
+            ...result,
+            results: await Promise.all(result.results.map(async (entry) => ({
+                ...entry,
+                observation: await attachContract(repo, entry.observation),
+            }))),
+        };
+}
 function directAddress(values) {
     return {
         path: values.path,
         akuma: values.akuma,
-        ...(values.settings === undefined ? {} : { settings: values.settings }),
         ...(values.repo === undefined ? {} : { repo: values.repo }),
     };
 }
@@ -52,18 +169,17 @@ function setAddress(values) {
     return {
         path: values.path,
         akuma: values.akuma,
-        ...(values.settings === undefined ? {} : { settings: values.settings }),
         ...(values.repo === undefined ? {} : { repo: values.repo }),
     };
 }
 export async function statusAkuma(input) {
     const addressed = await addressAkuma(input);
-    return await statusView(await source(addressed.path, addressed.settings).of({ id: addressed.id }).status(), input.repo);
+    return await observeAkuma(await source(addressed.path).of({ id: addressed.id }).status(), addressed.path, input.repo);
 }
 export async function waitAkuma(input) {
     const values = requireInput(input, "Keiyaku.wait input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "repo", "completion", "timeoutMs"].includes(key)) {
+        if (!["path", "akuma", "repo", "completion", "timeoutMs"].includes(key)) {
             throw new TypeError(`Keiyaku.wait input has unknown field: ${key}`);
         }
     }
@@ -72,70 +188,94 @@ export async function waitAkuma(input) {
     if (addressed.ids.length > 1 && completion !== "any" && completion !== "all") {
         throw new TypeError("completion must be any or all when waiting for multiple Akuma");
     }
-    if (completion !== undefined && completion !== "any" && completion !== "all")
+    if (completion !== undefined && completion !== "any" && completion !== "all") {
         throw new TypeError("completion must be any or all");
+    }
     const selected = completion ?? "all";
     const timeoutMs = timeout(values.timeoutMs);
-    const deadline = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
-    for (;;) {
-        const statuses = await observeWaitStatuses(addressed.path, addressed.ids, addressed.settings);
-        const settled = statuses.map((status) => status.life !== "running");
-        if ((selected === "any" ? settled.some(Boolean) : settled.every(Boolean))
-            || (deadline !== undefined && performance.now() >= deadline)) {
-            return { completion: selected, statuses: await Promise.all(statuses.map(async (status) => await statusView(status, values.repo))) };
-        }
-        await delay(deadline === undefined ? 25 : Math.min(25, Math.max(0, deadline - performance.now())));
+    const requests = injectedBodyRequests();
+    if (requests !== null) {
+        const outcome = await requestBodyWait({
+            directory: requests,
+            targets: addressed.ids,
+            completion: selected,
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        });
+        return await attachWaitContracts(values.repo, upstreamResult(outcome));
     }
+    return await executeWaitAkuma({
+        path: addressed.path,
+        ids: addressed.ids,
+        completion: selected,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(values.repo === undefined ? {} : { repo: values.repo }),
+    });
 }
 export async function killAkuma(input) {
     const addressed = await addressAkumaSet(input);
-    const handles = addressed.ids.map((id) => source(addressed.path, addressed.settings).of({ id }));
-    const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
-    const observations = await Promise.all(addressed.ids.map(async (id) => await statusView(await readActionFeedbackStatus(addressed.path, id), input.repo)));
-    return {
-        results: addressed.ids.map((id, index) => ({
-            id,
-            evidence: evidence[index],
-            observation: observations[index],
-        })),
-    };
+    const requests = injectedBodyRequests();
+    if (requests !== null) {
+        const outcome = await requestBodyKill({ directory: requests, targets: addressed.ids });
+        return await attachKillContracts(input.repo, upstreamResult(outcome));
+    }
+    return await executeKillAkuma({
+        path: addressed.path,
+        ids: addressed.ids,
+        ...(input.repo === undefined ? {} : { repo: input.repo }),
+    });
 }
 export async function tellAkuma(input) {
     const values = requireInput(input, "Keiyaku.tell input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "body", "repo"].includes(key))
+        if (!["path", "akuma", "body", "repo"].includes(key)) {
             throw new TypeError(`Keiyaku.tell input has unknown field: ${key}`);
+        }
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
     const addressed = await addressAkuma(directAddress(values));
-    const handle = source(addressed.path, addressed.settings).of({ id: addressed.id });
-    const tell = await handle.tell(values.body);
-    return { akuma: addressed.id, tell, observation: await statusView(await readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+    const requests = injectedBodyRequests();
+    if (requests !== null) {
+        const outcome = await requestBodyTell({
+            directory: requests,
+            target: addressed.id,
+            body: values.body,
+        });
+        return await attachTellContract(values.repo, upstreamResult(outcome));
+    }
+    return await executeTellAkuma({
+        path: addressed.path,
+        id: addressed.id,
+        body: values.body,
+        ...(values.repo === undefined ? {} : { repo: values.repo }),
+    });
 }
 export async function interruptAkuma(input) {
     const values = requireInput(input, "Keiyaku.interrupt input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "body", "repo"].includes(key))
+        if (!["path", "akuma", "body", "repo"].includes(key)) {
             throw new TypeError(`Keiyaku.interrupt input has unknown field: ${key}`);
+        }
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
     const addressed = await addressAkuma(directAddress(values));
-    const receipt = await source(addressed.path, addressed.settings).of({ id: addressed.id }).interrupt(values.body);
-    return { id: addressed.id, receipt, observation: await statusView(await readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+    const handle = source(addressed.path).of({ id: addressed.id });
+    const receipt = await handle.interrupt(values.body);
+    const observation = await observeAkuma(await handle.status(), addressed.path, values.repo);
+    return { id: addressed.id, receipt, observation };
 }
 export async function historyAkuma(input) {
     const values = requireInput(input, "Keiyaku.history input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "settings", "before", "since", "limit", "last", "repo"].includes(key)) {
+        if (!["path", "akuma", "before", "since", "limit", "last", "repo"].includes(key)) {
             throw new TypeError(`Keiyaku.history input has unknown field: ${key}`);
         }
     }
     if (values.last !== undefined && typeof values.last !== "boolean")
         throw new TypeError("last must be a boolean");
     const addressed = await addressAkuma(directAddress(values));
-    const handle = source(addressed.path, addressed.settings).of({ id: addressed.id });
+    const handle = source(addressed.path).of({ id: addressed.id });
     if (values.last === true) {
         const answer = await handle.lastAnswer();
         const contractId = await contractFor(values.repo, addressed.id);

package/build/src/library/input.js

@@ -91,6 +91,7 @@ export function contractTerms(document, gates, after) {
 export function documentDerivation(document, gates, contractId) {
     return {
         document: document.document.key,
+        bytes: document.document.bytes,
         title: document.title,
         verification: prepareVerificationDeclaration({
             gates,

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

@@ -5,10 +5,9 @@ import { listCatalog } from "./catalog.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
-export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, } from "./configuration.js";
-export { worktreeHooksFrom } from "../git/hooks.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
-export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
+export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
 export type { ContractId, ContractState, ChangeId, SnapshotId, } from "../core/facts/types.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
 export type { RegionOverlap } from "./region.js";
@@ -20,9 +19,10 @@ export type { Dispatch, DispatchFailure } from "../dispatch/index.js";
 export type { AkumaAlias } from "../identity/selector.js";
 export type { AkumaGlob } from "../identity/selector.js";
 export type { AkuId } from "../akuma/identity.js";
+export type { AllowedAction, AllowedActions } from "../akuma/allowed.js";
 export type { Catalog, CatalogInput, CatalogQuery } from "./catalog.js";
 export type { AkumaAddressInput, AkumaSetAddressInput, AkumaWorldScopeRefusal, DirectAkumaSelector, SetAkumaSelector, } from "./address.js";
-export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaStatusView, AkumaTellInput, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";
+export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaTellInput, CreatedTaskObservation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";
 export type Keiyaku = KeiyakuType;
 export declare const Keiyaku: Readonly<{
     prototype: KeiyakuHandle;

package/build/src/library/keiyaku.js

@@ -5,8 +5,7 @@ import { listCatalog } from "./catalog.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
-export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, } from "./configuration.js";
-export { worktreeHooksFrom } from "../git/hooks.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
 export const Keiyaku = Object.freeze({
     prototype: KeiyakuHandle.prototype,

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

@@ -18,14 +18,13 @@ export type TargetInputRefusal = Readonly<{
 type BindOperationInput = Readonly<{
     scope: GitRepository;
     channel: GitDecodeChannel;
-    title: string;
     terms: BindData["terms"];
     verification: VerificationDeclarationPreparation;
     target?: string;
     workspace: "worktree" | "here";
     actor?: ActorId;
     decorateOffer?: CompanionDecorator;
-    contractId?: ContractId;
+    contractId: ContractId;
 }>;
 export declare function bindOperation(input: BindOperationInput): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;