@astrosheep/keiyaku 4.1.1 → 4.1.3

package/build/src/akuma/request-execution.js

@@ -0,0 +1,98 @@
+async function executeWait(input, request) {
+    return {
+        result: await input.upstream.wait({
+            targets: request.targets,
+            completion: request.completion,
+            ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+            signal: input.signal,
+        }),
+        service: { action: request.action },
+    };
+}
+async function executeTell(input, request) {
+    return {
+        result: await input.upstream.tell({
+            target: request.target,
+            body: request.body,
+            tellId: request.id,
+            recordedAt: request.admittedAt,
+            signal: input.signal,
+        }),
+        service: { action: request.action, target: request.target, tellId: request.id },
+    };
+}
+async function executeKill(input, request) {
+    const served = await input.upstream.kill({ targets: request.targets, signal: input.signal });
+    return { result: served.result, service: { action: request.action, results: served.service } };
+}
+async function executeDeliver(input, request) {
+    const served = await input.upstream.deliver({
+        repoRoot: request.repoRoot,
+        contractId: request.contractId,
+        ...(request.message === undefined ? {} : { message: request.message }),
+        includeDirty: request.includeDirty,
+        materializeConflict: request.materializeConflict,
+        requester: request.requester,
+        signal: input.signal,
+    });
+    return {
+        result: served.result,
+        ...(served.deliveryFactId === undefined
+            ? {}
+            : {
+                service: {
+                    action: request.action,
+                    repoRoot: request.repoRoot,
+                    contractId: request.contractId,
+                    deliveryFactId: served.deliveryFactId,
+                },
+            }),
+    };
+}
+async function executeReview(input, request) {
+    const served = await input.upstream.review({
+        repoRoot: request.repoRoot,
+        contractId: request.contractId,
+        verdict: request.verdict,
+        ...(request.summary === undefined ? {} : { summary: request.summary }),
+        requester: request.requester,
+        signal: input.signal,
+    });
+    return {
+        result: served.result,
+        ...(served.reviewFactId === undefined
+            ? {}
+            : {
+                service: {
+                    action: request.action,
+                    repoRoot: request.repoRoot,
+                    contractId: request.contractId,
+                    reviewFactId: served.reviewFactId,
+                },
+            }),
+    };
+}
+export async function executeRequest(input, request) {
+    if (input.upstream === undefined)
+        throw new Error("upstream execution port is unavailable");
+    if (request.action === "akuma.wait")
+        return executeWait(input, request);
+    if (request.action === "akuma.tell")
+        return executeTell(input, request);
+    if (request.action === "akuma.kill")
+        return executeKill(input, request);
+    if (request.action === "contract.deliver")
+        return executeDeliver(input, request);
+    if (request.action === "contract.review")
+        return executeReview(input, request);
+    const task = request;
+    return {
+        result: await input.upstream.task({
+            world: task.world,
+            request: task.request,
+            requester: task.requester,
+            signal: input.signal,
+        }),
+        service: { action: task.action },
+    };
+}

package/build/src/akuma/request-serve.d.ts

@@ -1,6 +1,8 @@
-import { type KillEvidence, type Soul } from "./heart/index.js";
+import { type KillEvidence, type RequestFact, type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type StructuralRequestClaim } from "./request-wire.js";
 import { type TaskMutationRequest } from "../task/mutation.js";
+import type { OwnedProcess } from "../runtime/proc/run.js";
 export type RequestChildLaunch = Readonly<{
     paths: AkumaPaths;
     seed: Omit<Soul, "createdAt">;
@@ -63,10 +65,20 @@ type PumpInput = Readonly<{
     parent: Soul;
     bodySequence: number;
     now(): string;
-    spawn(launch: RequestChildLaunch): Promise<void>;
+    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
     upstream?: UpstreamExecutionPort;
     signal: AbortSignal;
 }>;
+export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
+    directory: string;
+    claim: StructuralRequestClaim;
+    admissionOpen(): boolean;
+}>;
+export type UpstreamFact = Exclude<Extract<RequestFact, {
+    state: "admitted";
+}>, Extract<RequestFact, {
+    action: "akuma.call";
+}>>;
 export declare class BodyRequestPump {
     private readonly input;
     readonly directory: string;

package/build/src/akuma/request-serve.js

@@ -6,6 +6,7 @@ import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { BIRTH_TIMEOUT_MS, publishAkuma } from "./publication.js";
 import { atomicJson, canonicalAkuId, decodeClaim, decodeRecipe, receiptPath, } from "./request-wire.js";
 import { isTaskMutationAction } from "../task/mutation.js";
+import { executeRequest } from "./request-execution.js";
 const POLL_MS = 100;
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -118,7 +119,7 @@ async function serveCall(input) {
             launch: async (allocated) => {
                 if (!input.admissionOpen())
                     throw new Error("body closed request admission");
-                await input.spawn({
+                return await input.spawn({
                     paths: allocated.paths,
                     seed: {
                         id: allocated.id,
@@ -161,107 +162,6 @@ function failure(error) {
     }
     return { kind: "failed", diagnostic: diagnostic(error) };
 }
-async function execute(input, request) {
-    if (input.upstream === undefined)
-        throw new Error("upstream execution port is unavailable");
-    if (request.action === "akuma.wait") {
-        const result = await input.upstream.wait({
-            targets: request.targets,
-            completion: request.completion,
-            ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
-            signal: input.signal,
-        });
-        return { result, service: { action: request.action } };
-    }
-    if (request.action === "akuma.tell") {
-        const result = await input.upstream.tell({
-            target: request.target,
-            body: request.body,
-            tellId: request.id,
-            recordedAt: request.admittedAt,
-            signal: input.signal,
-        });
-        return {
-            result,
-            service: { action: request.action, target: request.target, tellId: request.id },
-        };
-    }
-    if (request.action === "akuma.kill") {
-        const served = await input.upstream.kill({
-            targets: request.targets,
-            signal: input.signal,
-        });
-        return {
-            result: served.result,
-            service: { action: request.action, results: served.service },
-        };
-    }
-    if (request.action === "contract.deliver") {
-        return await executeDeliver(input, request);
-    }
-    if (request.action === "contract.review") {
-        return await executeReview(input, request);
-    }
-    const task = request;
-    const result = await input.upstream.task({
-        world: task.world,
-        request: task.request,
-        requester: task.requester,
-        signal: input.signal,
-    });
-    return { result, service: { action: task.action } };
-}
-async function executeDeliver(input, request) {
-    if (input.upstream === undefined)
-        throw new Error("upstream execution port is unavailable");
-    const served = await input.upstream.deliver({
-        repoRoot: request.repoRoot,
-        contractId: request.contractId,
-        ...(request.message === undefined ? {} : { message: request.message }),
-        includeDirty: request.includeDirty,
-        materializeConflict: request.materializeConflict,
-        requester: request.requester,
-        signal: input.signal,
-    });
-    return {
-        result: served.result,
-        ...(served.deliveryFactId === undefined
-            ? {}
-            : {
-                service: {
-                    action: request.action,
-                    repoRoot: request.repoRoot,
-                    contractId: request.contractId,
-                    deliveryFactId: served.deliveryFactId,
-                },
-            }),
-    };
-}
-async function executeReview(input, request) {
-    if (input.upstream === undefined)
-        throw new Error("upstream execution port is unavailable");
-    const served = await input.upstream.review({
-        repoRoot: request.repoRoot,
-        contractId: request.contractId,
-        verdict: request.verdict,
-        ...(request.summary === undefined ? {} : { summary: request.summary }),
-        requester: request.requester,
-        signal: input.signal,
-    });
-    return {
-        result: served.result,
-        ...(served.reviewFactId === undefined
-            ? {}
-            : {
-                service: {
-                    action: request.action,
-                    repoRoot: request.repoRoot,
-                    contractId: request.contractId,
-                    reviewFactId: served.reviewFactId,
-                },
-            }),
-    };
-}
 function pendingService(request) {
     if (request.action === "akuma.wait")
         return { action: request.action };
@@ -303,7 +203,7 @@ async function serveUpstream(input) {
     let outcome;
     let service = pendingService(request);
     try {
-        const served = await execute(input, request);
+        const served = await executeRequest(input, request);
         outcome = { kind: "returned", result: served.result };
         if (served.service !== undefined)
             service = served.service;

package/build/src/akuma/{body-turn.d.ts → turn-drive.d.ts}

@@ -1,31 +1,9 @@
-import { type HeartSnapshot, type HeldAkumaLeash, type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
+import { type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
 import { type RequestChildLaunch, type UpstreamExecutionPort } from "./request-serve.js";
-export declare const CONTROL_RESPONSE_MS = 1000;
-export declare class BodySupervisor {
-    private readonly paths;
-    private readonly bodySequence;
-    private readonly leash;
-    readonly signal: AbortSignal;
-    private readonly controller;
-    private readonly finished;
-    private readonly observer;
-    private waiter;
-    private observation;
-    private stopping?;
-    private constructor();
-    static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash): Promise<BodySupervisor>;
-    get reason(): "control" | "heart-gone" | undefined;
-    current(): HeartSnapshot;
-    recordHung(diagnostic: string, at: string): Promise<void>;
-    refresh(): Promise<HeartSnapshot>;
-    next(after: HeartSnapshot): Promise<HeartSnapshot>;
-    cancel(reason: "control" | "heart-gone"): void;
-    close(): Promise<void>;
-    private publish;
-    private observe;
-}
+import { BodySupervisor } from "./body-supervisor.js";
+import type { OwnedProcess } from "../runtime/proc/run.js";
 export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
     cwd: string;
     options: Soul["options"];
@@ -47,7 +25,7 @@ export type DriveTurnInput = Readonly<{
     call?: string;
     launchTells: readonly TellFact[];
     supervisor: BodySupervisor;
-    runtimeSpawn(launch: RequestChildLaunch): Promise<void>;
+    runtimeSpawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
     upstream?: UpstreamExecutionPort;
     now(): string;
 }>;

package/build/src/akuma/{body-turn.js → turn-drive.js}

@@ -2,93 +2,7 @@ import { abortableDelay } from "./abort.js";
 import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
 import { encodeAgentEvent } from "./provider.js";
 import { BodyRequestPump } from "./request-serve.js";
-const BODY_CONTROL_OBSERVATION_MS = 100;
-export const CONTROL_RESPONSE_MS = 1_000;
-export class BodySupervisor {
-    paths;
-    bodySequence;
-    leash;
-    signal;
-    controller = new AbortController();
-    finished = new AbortController();
-    observer;
-    waiter;
-    observation;
-    stopping;
-    constructor(paths, bodySequence, leash, observation) {
-        this.paths = paths;
-        this.bodySequence = bodySequence;
-        this.leash = leash;
-        this.signal = this.controller.signal;
-        this.observation = observation;
-        this.observer = this.observe();
-    }
-    static async open(paths, bodySequence, leash) {
-        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
-    }
-    get reason() {
-        return this.stopping;
-    }
-    current() {
-        return this.observation;
-    }
-    async recordHung(diagnostic, at) {
-        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
-    }
-    async refresh() {
-        this.publish(await readHeart(this.paths));
-        return this.observation;
-    }
-    next(after) {
-        if (this.observation !== after)
-            return Promise.resolve(this.observation);
-        return new Promise((resolve) => {
-            this.waiter = resolve;
-        });
-    }
-    cancel(reason) {
-        if (this.stopping !== undefined)
-            return;
-        this.stopping = reason;
-        this.controller.abort(new Error(reason === "control" ? "Akuma Body interrupted by durable control" : "Akuma Heart disappeared"));
-        this.waiter?.(this.observation);
-        this.waiter = undefined;
-    }
-    async close() {
-        this.finished.abort();
-        await this.observer;
-        this.waiter = undefined;
-    }
-    publish(snapshot) {
-        this.observation = snapshot;
-        this.waiter?.(snapshot);
-        this.waiter = undefined;
-    }
-    async observe() {
-        for (;;) {
-            const snapshot = this.observation;
-            if (!(await heartExists(this.paths)))
-                return this.cancel("heart-gone");
-            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
-                return this.cancel("control");
-            }
-            try {
-                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
-            }
-            catch {
-                return;
-            }
-            try {
-                await this.refresh();
-            }
-            catch (error) {
-                if (await heartExists(this.paths))
-                    throw error;
-                return this.cancel("heart-gone");
-            }
-        }
-    }
-}
+import { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function serializeEffects() {
     let tail = Promise.resolve();
     let failed = false;
@@ -132,11 +46,7 @@ async function failedTurnSetup(input, turnSequence, requests, cancelDrive, error
             throw error;
         return { kind: "stopped" };
     }
-    return {
-        kind: "failed",
-        turnSequence,
-        diagnostic: error instanceof Error ? error.message : String(error),
-    };
+    return { kind: "failed", turnSequence, diagnostic: error instanceof Error ? error.message : String(error) };
 }
 async function writeProviderEvent(input, active, event) {
     if (input.supervisor.signal.aborted)
@@ -151,11 +61,7 @@ async function writeProviderEvent(input, active, event) {
             admittedAt: at,
         });
     }
-    await appendActivity(input.paths, {
-        turnSequence: active.turnSequence,
-        event: encodeAgentEvent(event),
-        at,
-    });
+    await appendActivity(input.paths, { turnSequence: active.turnSequence, event: encodeAgentEvent(event), at });
 }
 async function startTurnDrive(input) {
     const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
@@ -212,7 +118,7 @@ async function startTurnDrive(input) {
             }
             return { kind: "stopped" };
         }
-        if (input.launchTells.length > 0) {
+        if (input.launchTells.length > 0)
             await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
                 tellId: tell.id,
                 route: "launch",
@@ -220,8 +126,7 @@ async function startTurnDrive(input) {
                 fence: selected.admission.fence,
                 deliveredAt: input.now(),
             })));
-        }
-        void selected.completion.then(() => requests.stopAdmission());
+        void selected.completion.then(() => requests.stopAdmission(), () => undefined);
         return {
             turnSequence: turn.sequence,
             drive: selected,
@@ -289,6 +194,9 @@ function pumpReceipts(writers) {
 function observeReceiptFailure(receiptPump) {
     return receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
 }
+function observeCompletionFailure(drive) {
+    return drive.completion.then(() => new Promise(() => { }), (error) => ({ kind: "completion-failed", error }));
+}
 async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
     const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
     for (const tell of pending) {
@@ -348,6 +256,7 @@ async function consumeTurnDrive(input, active) {
     const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;
     const writers = { input, turnSequence, drive, writeWitness, mayWrite };
     const receiptFailure = observeReceiptFailure(pumpReceipts(writers));
+    const completionFailure = observeCompletionFailure(drive);
     const iterator = drive.events[Symbol.asyncIterator]();
     let pending = iterator.next();
     let liveTells = true;
@@ -375,7 +284,12 @@ async function consumeTurnDrive(input, active) {
                 ...(tellObservation === null ? [] : [tellObservation]),
                 receiptFailure,
                 requests.failure,
+                completionFailure,
             ]);
+            if (next.kind === "completion-failed") {
+                requests.stopAdmission();
+                throw next.error;
+            }
             if (next.kind === "heart") {
                 heart = next.observation;
                 continue;

package/build/src/cli/commands/akuma.d.ts

@@ -60,11 +60,5 @@ export declare function isParsedAkumaCommand(command: Readonly<{
 export declare function renderAkumaRootRows(): readonly string[];
 export declare function renderAkumaHelp(action: AkumaAction): string;
 export declare function renderAkumaUsage(action: AkumaAction): string;
-export declare function parseAkumaCatalogPath(value: string): Readonly<{
-    kind: "archetypes";
-} | {
-    kind: "akuma";
-    archetype?: string;
-}> | null;
 export declare function parseAkumaCommand(argv: readonly string[]): ParsedAkumaCommand;
 export {};

package/build/src/cli/commands/akuma.js

@@ -1,5 +1,5 @@
 import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
-import { archetypeName, parseAkuId } from "../../akuma/identity.js";
+import { parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
 import { decodeAllowedActions } from "../../akuma/allowed.js";
@@ -84,16 +84,6 @@ export function renderAkumaHelp(action) {
 export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
 }
-export function parseAkumaCatalogPath(value) {
-    if (value === "aku" || value === "aku/")
-        return { kind: "archetypes" };
-    if (value === "aku/*/*")
-        return { kind: "akuma" };
-    const match = /^aku\/([^/]+)\/?$/u.exec(value);
-    if (match === null)
-        return null;
-    return { kind: "akuma", archetype: archetypeName(match[1]) };
-}
 function stringFlag(value, diagnostic, fail) {
     if (typeof value !== "string")
         fail(diagnostic);

package/build/src/cli/commands/contract-invoke.d.ts

@@ -0,0 +1,25 @@
+import type { InvocationResult } from "../result.js";
+import type { ParsedCommand } from "../parse.js";
+import type { WorktreeHooks } from "../../library/configuration.js";
+import type { Repo } from "../../library/repo.js";
+import type { Settings } from "../../settings.js";
+import type { WorldRoot } from "../../world.js";
+type ContractMutation = Extract<ParsedCommand, {
+    command: "bind" | "amend" | "deliver" | "review" | "arc" | "abandon" | "audit";
+}>;
+type InvocationEdge = Readonly<{
+    environment: NodeJS.ProcessEnv;
+    readStdin: () => Promise<string>;
+}>;
+export type ContractMutationInput = Readonly<{
+    parsed: ContractMutation;
+    repo: Repo;
+    edge: InvocationEdge;
+    scope: string;
+    configuration?: Settings;
+    hooks: WorktreeHooks;
+    establishWorld: () => Promise<WorldRoot>;
+    forwarded?: true;
+}>;
+export declare function invokeContractMutation(input: ContractMutationInput): Promise<InvocationResult>;
+export {};