@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/akuma/body.js

@@ -1,159 +1,20 @@
 import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
-import { HeldAkumaLeash, appendActivity, beginTurn, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
-import { encodeAgentEvent, } from "./provider.js";
+import { BodySupervisor, driveTurn, turnRecipe } from "./body-turn.js";
+import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, } from "./heart/index.js";
 import { resolveProviderExecution } from "./providers/index.js";
-import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./requests.js";
+import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 25;
-const BODY_CONTROL_OBSERVATION_MS = 100;
-export const CONTROL_RESPONSE_MS = 1_000;
-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)) {
-                this.cancel("heart-gone");
-                return;
-            }
-            if (bodyControlRequested(snapshot, this.bodySequence)) {
-                this.cancel("control");
-                return;
-            }
-            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;
-                this.cancel("heart-gone");
-                return;
-            }
-        }
-    }
-}
-function serializeEffects() {
-    let tail = Promise.resolve();
-    let failed = false;
-    let failure;
-    const serialize = async (effect) => {
-        const result = tail.then(effect);
-        tail = result.then(() => undefined, (error) => {
-            if (!failed)
-                failure = error;
-            failed = true;
-        });
-        return await result;
-    };
-    serialize.drain = async () => {
-        await tail;
-        if (failed)
-            throw failure;
-    };
-    return serialize;
-}
+export { CONTROL_RESPONSE_MS } from "./body-turn.js";
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
-async function writeProviderEvent(input, active, event) {
-    if (input.supervisor.signal.aborted)
-        return;
-    const at = input.now();
-    if (event.type === "session") {
-        await recordSession(input.paths, {
-            provider: input.soul.provider.name,
-            coordinate: event.coordinate,
-            cwd: active.cwd,
-            options: active.options,
-            admittedAt: at,
-        });
-    }
-    await appendActivity(input.paths, {
-        turnSequence: active.turnSequence,
-        event: encodeAgentEvent(event),
-        at,
-    });
-}
-function bodyControlRequested(snapshot, bodySequence) {
-    return snapshot.stop?.bodySequence === bodySequence
-        || snapshot.pause?.bodySequence === bodySequence;
-}
 async function putDownIfControlled(paths, supervisor, bodySequence, now) {
     if (supervisor.reason === "control" && await heartExists(paths)) {
         await breakBody(paths, { sequence: bodySequence, end: "put-down", at: now() });
     }
 }
-async function turnRecipe(paths, soul) {
-    const latest = (await readHeart(paths)).latestSession;
-    const admitted = latest?.provider === soul.provider.name ? latest : undefined;
-    const session = admitted?.coordinate;
-    return {
-        cwd: admitted?.cwd ?? soul.cwd,
-        options: admitted?.options ?? soul.options,
-        ...(session === undefined ? {} : { session }),
-    };
-}
 async function takeLeash(paths) {
     for (;;) {
         try {
@@ -169,270 +30,6 @@ async function takeLeash(paths) {
         await abortableDelay(LEASH_RETRY_MS);
     }
 }
-async function startTurnDrive(input) {
-    const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
-    if (session !== undefined && input.adapter.resume === undefined)
-        return { kind: "resume-unsupported" };
-    const turn = await beginTurn(input.paths, {
-        bodySequence: input.bodySequence,
-        startedAt: input.now(),
-        ...(input.call === undefined ? {} : { call: input.call }),
-    });
-    const requests = input.soul.confinement.kind === "declared"
-        ? await BodyRequestPump.open({
-            paths: input.paths,
-            parent: input.soul,
-            bodySequence: input.bodySequence,
-            now: input.now,
-            spawn: input.runtimeSpawn,
-            ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
-            signal: input.supervisor.signal,
-        })
-        : null;
-    const driveInput = {
-        body: input.body,
-        launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
-        cwd,
-        options,
-        signal: input.supervisor.signal,
-        ...(requests === null ? {} : { requests: { dir: requests.directory } }),
-    };
-    const setup = session === undefined
-        ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
-        : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
-    try {
-        const selected = await setup;
-        if (input.supervisor.signal.aborted) {
-            await retireProviderCustody(input, turn.sequence, selected);
-            await requests?.close();
-            return { kind: "stopped" };
-        }
-        if (input.launchTells.length > 0) {
-            await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
-                tellId: tell.id,
-                route: "launch",
-                turnSequence: turn.sequence,
-                fence: selected.admission.fence,
-                deliveredAt: input.now(),
-            })));
-        }
-        if (requests !== null)
-            void selected.completion.then(() => requests.stopAdmission());
-        return { turnSequence: turn.sequence, drive: selected, requests, cwd, options,
-            ...(session === undefined ? {} : { resume: session }) };
-    }
-    catch (error) {
-        await requests?.close();
-        if (input.supervisor.signal.aborted) {
-            if (input.supervisor.reason === "heart-gone")
-                throw error;
-            return { kind: "stopped" };
-        }
-        return {
-            kind: "failed",
-            turnSequence: turn.sequence,
-            diagnostic: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-async function retireProviderCustody(input, turnSequence, drive) {
-    const outcome = await Promise.race([
-        drive.abort().then(() => ({ kind: "retired" }), (error) => ({ kind: "held", error })),
-        abortableDelay(CONTROL_RESPONSE_MS).then(() => ({
-            kind: "held",
-            error: new Error(`provider custody remained live after ${CONTROL_RESPONSE_MS}ms`),
-        })),
-    ]);
-    if (outcome.kind === "retired")
-        return;
-    if (await heartExists(input.paths)) {
-        const diagnostic = outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
-        const at = input.now();
-        try {
-            await input.supervisor.recordHung(diagnostic, at);
-            await appendActivity(input.paths, {
-                turnSequence,
-                event: encodeAgentEvent({ type: "note", text: `Provider custody was not retired: ${diagnostic}` }),
-                at,
-            });
-        }
-        catch { /* undisposed provider custody still owns the leash */ }
-    }
-    for (;;)
-        await abortableDelay(60_000);
-}
-function pumpReceipts(writers) {
-    const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
-    return (async () => {
-        if (drive.receipts === undefined)
-            return;
-        for await (const receipt of drive.receipts) {
-            if (!mayWrite())
-                return;
-            await writeWitness(async () => {
-                if (!mayWrite())
-                    return;
-                await recordTellReceipt(input.paths, receipt.evidence === "exact"
-                    ? { ...receipt, receivedAt: input.now() }
-                    : { ...receipt, turnSequence, receivedAt: input.now() });
-            });
-        }
-    })();
-}
-function observeReceiptFailure(receiptPump) {
-    return receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
-}
-async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
-    const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
-    for (const tell of pending) {
-        if (attempted.has(tell.id))
-            continue;
-        attempted.add(tell.id);
-        const outcome = await writeWitness(async () => {
-            const submission = await tellLive({ id: tell.id, text: tell.body });
-            if (!mayWrite())
-                return "turn-ended";
-            if (submission.kind === "turn-ended")
-                return "turn-ended";
-            await recordTellDeliveries(input.paths, [{
-                    tellId: tell.id,
-                    route: "live",
-                    turnSequence,
-                    fence: submission.fence,
-                    receipt: drive.receipts === undefined ? "unavailable" : "required",
-                    deliveredAt: input.now(),
-                }]);
-            return "accepted";
-        });
-        if (outcome === "turn-ended")
-            return "turn-ended";
-    }
-    return "live";
-}
-async function stopActiveDrive(input, active) {
-    await retireProviderCustody(input, active.turnSequence, active.drive);
-    await active.requests?.close();
-}
-function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
-    return liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id));
-}
-function persistProviderEvent(_input, _active, event) {
-    return event.type === "session" ? event.coordinate : undefined;
-}
-async function settleCompletion(result, session, requests) {
-    await requests?.close();
-    return result.kind === "answered" ? { ...result, ...(session === undefined ? {} : { session }) } : result;
-}
-async function consumeTurnDrive(input, active) {
-    const { turnSequence, drive, requests, resume } = active;
-    let heart = input.supervisor.current();
-    let turnSession = resume;
-    const attempted = new Set(input.launchTells.map((tell) => tell.id));
-    const writeWitness = serializeEffects();
-    let writesOpen = true;
-    const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;
-    const writers = { input, turnSequence, drive, writeWitness, mayWrite };
-    const receiptPump = pumpReceipts(writers);
-    const receiptFailure = observeReceiptFailure(receiptPump);
-    const iterator = drive.events[Symbol.asyncIterator]();
-    let pending = iterator.next();
-    let liveTells = true;
-    let tellPump = null;
-    let tellObservation = null;
-    try {
-        for (;;) {
-            if (input.supervisor.signal.aborted) {
-                writesOpen = false;
-                await stopActiveDrive(input, active);
-                return { kind: "stopped" };
-            }
-            if (hasUnattemptedTell(liveTells, tellPump, heart.pending, attempted)) {
-                if (drive.tell === undefined) {
-                    writesOpen = false;
-                    await stopActiveDrive(input, active);
-                    return { kind: "handoff" };
-                }
-                tellPump = submitPendingLiveTells(writers, heart.pending, attempted, drive.tell);
-                tellObservation = tellPump.then((result) => ({ kind: "tell", result }));
-            }
-            const next = await Promise.race([
-                pending.then((event) => ({ kind: "event", event })),
-                input.supervisor.next(heart).then((observation) => ({ kind: "heart", observation })),
-                ...(tellObservation === null ? [] : [tellObservation]),
-                receiptFailure,
-                ...(requests === null ? [] : [requests.failure]),
-            ]);
-            if (next.kind === "event" && !next.event.done) {
-                await writeProviderEvent(input, active, next.event.value);
-            }
-            if (next.kind === "heart") {
-                heart = next.observation;
-                continue;
-            }
-            if (next.kind === "tell") {
-                tellPump = null;
-                tellObservation = null;
-                liveTells = next.result === "live";
-                continue;
-            }
-            if (next.event.done)
-                break;
-            turnSession = persistProviderEvent(input, active, next.event.value) ?? turnSession;
-            pending = iterator.next();
-        }
-        const result = await drive.completion;
-        if (tellPump !== null)
-            await tellPump;
-        await writeWitness.drain();
-        writesOpen = false;
-        return await settleCompletion(result, turnSession, requests);
-    }
-    catch (error) {
-        writesOpen = false;
-        if (input.supervisor.signal.aborted) {
-            await stopActiveDrive(input, active);
-            return { kind: "stopped" };
-        }
-        await retireProviderCustody(input, turnSequence, drive);
-        try {
-            await requests?.close();
-        }
-        catch { /* preserve the first pump failure */ }
-        return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
-    }
-}
-async function driveTurn(input) {
-    let active;
-    try {
-        const started = await startTurnDrive(input);
-        if ("kind" in started)
-            return started;
-        active = started;
-    }
-    catch (error) {
-        if (!await heartExists(input.paths)) {
-            input.supervisor.cancel("heart-gone");
-            return { kind: "stopped" };
-        }
-        throw error;
-    }
-    try {
-        const result = await consumeTurnDrive(input, active);
-        return result.kind === "stopped" || result.kind === "handoff"
-            ? result
-            : { ...result, turnSequence: active.turnSequence };
-    }
-    catch (error) {
-        if (await heartExists(input.paths)) {
-            await active.requests?.close();
-            return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error),
-                turnSequence: active.turnSequence };
-        }
-        input.supervisor.cancel("heart-gone");
-        await stopActiveDrive(input, active);
-        return { kind: "stopped" };
-    }
-}
 async function bornSoul(launch, leash, now) {
     const before = await readHeart(launch.paths);
     if (before.soul !== null)
@@ -542,6 +139,8 @@ async function runBodyTurns(input) {
             ...(runtime.upstream === undefined ? {} : { upstream: runtime.upstream }),
             now: runtime.now,
         });
+        if (result.kind === "hung")
+            return;
         if (result.kind === "stopped") {
             await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
             return;
@@ -567,7 +166,7 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
         const soul = await bornSoul(launch, leash, runtime.now());
         if (soul === null)
             return;
-        const selected = adapter ?? resolveProviderExecution(soul.provider).adapter;
+        const selected = adapter ?? (await resolveProviderExecution(soul.provider)).adapter;
         if (!await prepareBodyStart(launch.paths, leash))
             return;
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
@@ -610,14 +209,10 @@ export async function spawnAkumaBody(launch) {
     });
     owned.release();
 }
-export async function runAkumaBody(upstreamFor) {
-    const encoded = process.argv[2];
-    if (encoded === undefined)
-        throw new TypeError("Akuma body launch payload is missing");
-    const launch = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+export async function runAkumaBody(launch, upstream) {
     await driveAkumaBody(launch, undefined, {
         now: () => new Date().toISOString(),
         spawnChild: spawnAkumaBody,
-        upstream: upstreamFor(launch),
+        upstream,
     });
 }

package/build/src/akuma/heart/facts.d.ts

@@ -2,13 +2,8 @@ import type { AkuId } from "../identity.js";
 import type { ResumeCoordinate } from "../coordinate.js";
 import type { ProviderExecution, ProviderOptions, ReadonlyRestraint } from "../provider-recipe.js";
 import type { AllowedActions } from "../allowed.js";
+import type { TaskMutationAction, TaskMutationRequest } from "../../task/mutation.js";
 export type { ResumeCoordinate } from "../coordinate.js";
-export type Confinement = Readonly<{
-    kind: "unconfined";
-}> | Readonly<{
-    kind: "declared";
-    writableRoots: readonly string[];
-}>;
 export type AkumaOrigin = Readonly<{
     kind: "direct";
 }> | Readonly<{
@@ -29,11 +24,10 @@ export type Soul = Readonly<{
     readonly?: ReadonlyRestraint;
     cwd: string;
     origin: AkumaOrigin;
-    confinement: Confinement;
     allowed: AllowedActions;
     createdAt: string;
 }>;
-export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "confinement" | "allowed">;
+export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "allowed">;
 export type BodyEnd = "exited" | "broke-off" | "put-down";
 export type BodyFact = Readonly<{
     sequence: number;
@@ -129,6 +123,12 @@ export type TellReceiptInput = Readonly<{
     turnSequence: number;
     fence: string;
 }>);
+export type TaskRequestInput = Readonly<{
+    id: string;
+    action: TaskMutationAction;
+    world: string;
+    request: TaskMutationRequest;
+}>;
 export type RequestInput = Readonly<{
     id: string;
     action: "akuma.call";
@@ -152,7 +152,22 @@ export type RequestInput = Readonly<{
     id: string;
     action: "akuma.kill";
     targets: readonly AkuId[];
-}>;
+}> | Readonly<{
+    id: string;
+    action: "contract.deliver";
+    repoRoot: string;
+    contractId: string;
+    message?: string;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+}> | Readonly<{
+    id: string;
+    action: "contract.review";
+    repoRoot: string;
+    contractId: string;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string;
+}> | TaskRequestInput;
 export type UpstreamRequestService = Readonly<{
     action: "akuma.wait";
 }> | Readonly<{
@@ -165,6 +180,18 @@ export type UpstreamRequestService = Readonly<{
         id: AkuId;
         evidence: KillEvidence;
     }>[];
+}> | Readonly<{
+    action: "contract.deliver";
+    repoRoot: string;
+    contractId: string;
+    deliveryFactId: string;
+}> | Readonly<{
+    action: "contract.review";
+    repoRoot: string;
+    contractId: string;
+    reviewFactId: string;
+}> | Readonly<{
+    action: TaskMutationRequest["action"];
 }>;
 type AdmittedRequest = RequestInput & Readonly<{
     requester: AkuId;
@@ -223,6 +250,7 @@ export type HeartSnapshot = Readonly<{
     latestKill: KillFact | null;
     stop: StopFact | null;
     pause: PauseFact | null;
+    lastActivityAt: string | null;
 }>;
 export declare function life(input: Readonly<{
     leash: LeashProbe;

package/build/src/akuma/heart/facts.js

@@ -1,6 +1,8 @@
 export function life(input) {
+    if (input.body?.hung !== undefined)
+        return "hung";
     if (input.leash === "held")
-        return input.body?.hung === undefined ? "running" : "hung";
+        return "running";
     if (input.body === null || input.body.end === undefined)
         return "untidy";
     if (input.kill?.bodySequence === input.body.sequence)

package/build/src/akuma/heart/index.d.ts

@@ -1,11 +1,12 @@
-import type { AkuId, AkumaPaths } from "../identity.js";
-import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, UpstreamRequestService, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
+import type { AkumaPaths } from "../identity.js";
+import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Confinement, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, UpstreamRequestService, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, UpstreamRequestService, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
 export type { ResumeCoordinate } from "../coordinate.js";
 export declare function readSoul(paths: AkumaPaths): Promise<Soul | null>;
 export declare function heartExists(paths: AkumaPaths): Promise<boolean>;
@@ -28,16 +29,6 @@ export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequ
 }>>;
 export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): Promise<void>;
 export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): Promise<void>;
-export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
-    admittedAt: string;
-}>): Promise<RequestFact>;
-export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
-export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
-export declare function serveUpstreamRequest(paths: AkumaPaths, id: string, service: UpstreamRequestService): Promise<RequestFact>;
-export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): Promise<RequestFact>;
-export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): Promise<RequestFact>;
-export declare function readRequest(paths: AkumaPaths, id: string): Promise<RequestFact | null>;
-export declare function readNonterminalRequests(paths: AkumaPaths): Promise<readonly RequestFact[]>;
 export declare function readKill(paths: AkumaPaths, bodySequence: number): Promise<KillFact | null>;
 export declare function requestStop(paths: AkumaPaths, at: string): Promise<Readonly<{
     kind: "requested";