@astrosheep/keiyaku 4.0.4 → 4.0.5

package/build/integrations/marketplace/plugins/keiyaku/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0+codex.20260818034655",
+  "version": "0.1.0+codex.20260819092206",
   "description": "Use the Keiyaku contract, task, and Akuma CLI.",
   "author": { "name": "Keiyaku" },
   "skills": "./skills/"

package/build/integrations/marketplace/plugins/keiyaku/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0+codex.20260818034655",
+  "version": "0.1.0+codex.20260819092206",
   "description": "Use the Keiyaku contract, task, and Akuma CLI.",
   "author": {
     "name": "Keiyaku"

package/build/integrations/marketplace/plugins/keiyaku/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku-harness",
-  "version": "0.1.0+codex.20260818034655",
+  "version": "0.1.0+codex.20260819092206",
   "type": "module",
   "main": "./opencode.js",
   "keywords": ["pi-package"],

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku/SKILL.md

@@ -15,9 +15,9 @@ read `<command> --help` before using flags.
   then `keiyaku-workflow` for the remaining lifecycle.
 - An Akuma is a callable worker; see `keiyaku-akuma`.
 
-Settings owns named gate sets. Omitting `--gates` selects `gates.default`, or
-freezes an empty gate list when that entry is absent. `--gates <name>` selects
-one configured set; it does not add a literal gate word.
+Settings owns named gate bundles. Omitting `--gates` selects `gates.default`,
+or freezes `["reviewed"]` when that entry is absent. `--gates <name,...>`
+selects configured bundles in order; it does not add literal gate words.
 
 ## Quick Start
 

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-workflow/SKILL.md

@@ -94,6 +94,12 @@ frontmatter names `Contract`, then reads the listed owner documents and source
 files before acting. Do not substitute a generic repository tour for the files
 that actually govern the assignment.
 
+Contract association, available forwarded actions, and the brief are
+independent inputs. When a Reviewer should record its own verdict, include
+`--allowed contract.review` and say in the brief to record `--satisfied` on
+pass or `--unsatisfied` on failure. When a Deliverer should tender its completed
+candidate, include `--allowed contract.deliver` and say so in the brief.
+
 A `Deliverer` implements and verifies the terms in `Worktree`. Commission a
 `Reviewer` after delivery. The reviewer inspects the complete current Contract
 worktree snapshot, not a worker report or named candidate commit, and does not
@@ -182,6 +188,11 @@ substitute for them.
 
 ## Deliver
 
+When the brief assigns delivery to the Deliverer, include `--allowed
+contract.deliver`; require it to run the command below after verification and
+return the receipt. Otherwise the coordinator runs it after accepting the
+candidate.
+
 Deliver when the worktree content is the candidate you intend to land:
 
 ```bash
@@ -217,6 +228,9 @@ keiyaku review <contract> --unsatisfied --summary "<finding>"
 ```
 
 Have an independent reviewer inspect the delivered Contract worktree snapshot.
+If it should record the verdict itself, dispatch it with `--allowed
+contract.review` and state both verdicts in the brief. Otherwise its answer is
+review input for the coordinator to record.
 The `review` command records the verdict. `--satisfied` requests placement; if
 the other gates are current, the receipt shows `claimed`.
 

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

@@ -10,7 +10,6 @@ export type AkumaListRow = Readonly<{
     description?: string;
     life: AkumaLife;
     lifeAt: string | null;
-    confinement: Soul["confinement"];
     pending: readonly string[];
 }>;
 export type AkumaStatus = Readonly<{

package/build/src/akuma/akuma.js

@@ -107,7 +107,6 @@ async function bornListRow(paths, expected, snapshot) {
         ...(snapshot.soul.description === undefined ? {} : { description: snapshot.soul.description }),
         life: currentLife,
         lifeAt: lifeAt(currentLife, snapshot.latestBody, snapshot.latestKill, snapshot.soul.createdAt),
-        confinement: snapshot.soul.confinement,
         pending: snapshot.pending.map((tell) => tell.id),
     };
 }
@@ -294,7 +293,6 @@ export class AkumaHandle {
                         allowed: source.allowed,
                         cwd: source.cwd,
                         origin: { kind: "fork", parent: this.id, at: input.at },
-                        confinement: source.confinement,
                     },
                     birthSession,
                 }),
@@ -416,10 +414,7 @@ export class Akuma {
         const cwd = input.cwd !== undefined && context?.cwdCanonical === true
             ? input.cwd
             : await canonicalBirthCwd(selectedCwd);
-        const recipe = Object.freeze({
-            ...requestRecipe,
-            confinement: archetype.adapter.confinement({ cwd, options: archetype.options }),
-        });
+        const recipe = requestRecipe;
         const published = await publishAkuma({
             worldPath: this.path,
             archetype: archetype.name,

package/build/src/akuma/allowed.d.ts

@@ -1,4 +1,4 @@
-export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.deliver", "task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
+export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.deliver", "contract.review", "task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
 export type AllowedAction = (typeof ALLOWED_ACTIONS)[number];
 export type AllowedActions = readonly AllowedAction[];
 export declare function isAllowedAction(value: unknown): value is AllowedAction;

package/build/src/akuma/allowed.js

@@ -1,18 +1,11 @@
+import { TASK_MUTATION_ACTIONS } from "../task/mutation.js";
 export const ALLOWED_ACTIONS = Object.freeze([
     "akuma.call",
     "akuma.kill",
     "akuma.tell",
     "contract.deliver",
-    "task.add",
-    "task.addDocument",
-    "task.compose",
-    "task.done",
-    "task.drop",
-    "task.hold",
-    "task.resume",
-    "task.start",
-    "task.stop",
-    "task.update",
+    "contract.review",
+    ...TASK_MUTATION_ACTIONS,
 ]);
 const ALLOWED_ACTION_SET = new Set(ALLOWED_ACTIONS);
 export function isAllowedAction(value) {

package/build/src/akuma/body.d.ts

@@ -1,7 +1,7 @@
 import { type SessionFact, type Soul } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter } from "./provider.js";
-import { type UpstreamExecutionPort, type RequestChildLaunch } from "./requests.js";
+import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
 export declare const CONTROL_RESPONSE_MS = 1000;
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
@@ -16,5 +16,8 @@ type BodyRuntime = Readonly<{
 }>;
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<void>;
 export declare function spawnAkumaBody(launch: BodyLaunch): Promise<void>;
-export declare function runAkumaBody(upstreamFor: (launch: BodyLaunch) => UpstreamExecutionPort): Promise<void>;
+export declare function runAkumaBody(upstreamFor: (launch: BodyLaunch, configuration: Readonly<{
+    home?: string;
+    gitPath?: string;
+}>) => UpstreamExecutionPort): Promise<void>;
 export {};

package/build/src/akuma/body.js

@@ -3,7 +3,7 @@ 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 { resolveProviderExecution } from "./providers/index.js";
-import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./requests.js";
+import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 25;
 const BODY_CONTROL_OBSERVATION_MS = 100;
@@ -178,24 +178,22 @@ async function startTurnDrive(input) {
         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 requests = 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,
+    });
     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 } }),
+        requests: { dir: requests.directory },
     };
     const setup = session === undefined
         ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
@@ -204,7 +202,7 @@ async function startTurnDrive(input) {
         const selected = await setup;
         if (input.supervisor.signal.aborted) {
             await retireProviderCustody(input, turn.sequence, selected);
-            await requests?.close();
+            await requests.close();
             return { kind: "stopped" };
         }
         if (input.launchTells.length > 0) {
@@ -216,13 +214,12 @@ async function startTurnDrive(input) {
                 deliveredAt: input.now(),
             })));
         }
-        if (requests !== null)
-            void selected.completion.then(() => requests.stopAdmission());
+        void selected.completion.then(() => requests.stopAdmission());
         return { turnSequence: turn.sequence, drive: selected, requests, cwd, options,
             ...(session === undefined ? {} : { resume: session }) };
     }
     catch (error) {
-        await requests?.close();
+        await requests.close();
         if (input.supervisor.signal.aborted) {
             if (input.supervisor.reason === "heart-gone")
                 throw error;
@@ -311,7 +308,7 @@ async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
 }
 async function stopActiveDrive(input, active) {
     await retireProviderCustody(input, active.turnSequence, active.drive);
-    await active.requests?.close();
+    await active.requests.close();
 }
 function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
     return liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id));
@@ -320,7 +317,7 @@ function persistProviderEvent(_input, _active, event) {
     return event.type === "session" ? event.coordinate : undefined;
 }
 async function settleCompletion(result, session, requests) {
-    await requests?.close();
+    await requests.close();
     return result.kind === "answered" ? { ...result, ...(session === undefined ? {} : { session }) } : result;
 }
 async function consumeTurnDrive(input, active) {
@@ -360,7 +357,7 @@ async function consumeTurnDrive(input, active) {
                 input.supervisor.next(heart).then((observation) => ({ kind: "heart", observation })),
                 ...(tellObservation === null ? [] : [tellObservation]),
                 receiptFailure,
-                ...(requests === null ? [] : [requests.failure]),
+                requests.failure,
             ]);
             if (next.kind === "event" && !next.event.done) {
                 await writeProviderEvent(input, active, next.event.value);
@@ -395,7 +392,7 @@ async function consumeTurnDrive(input, active) {
         }
         await retireProviderCustody(input, turnSequence, drive);
         try {
-            await requests?.close();
+            await requests.close();
         }
         catch { /* preserve the first pump failure */ }
         return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
@@ -424,7 +421,7 @@ async function driveTurn(input) {
     }
     catch (error) {
         if (await heartExists(input.paths)) {
-            await active.requests?.close();
+            await active.requests.close();
             return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error),
                 turnSequence: active.turnSequence };
         }
@@ -615,9 +612,18 @@ export async function runAkumaBody(upstreamFor) {
     if (encoded === undefined)
         throw new TypeError("Akuma body launch payload is missing");
     const launch = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    const mappedHome = process.env.KEIYAKU_HOME?.trim();
+    const mappedGitPath = process.env.KEIYAKU_GIT_PATH;
+    if (mappedGitPath !== undefined && mappedGitPath.trim().length === 0) {
+        throw new TypeError("KEIYAKU_GIT_PATH requires a nonblank value");
+    }
+    const configuration = {
+        ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
+        ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
+    };
     await driveAkumaBody(launch, undefined, {
         now: () => new Date().toISOString(),
         spawnChild: spawnAkumaBody,
-        upstream: upstreamFor(launch),
+        upstream: upstreamFor(launch, configuration),
     });
 }

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,21 @@ 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;
+}> | 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 +179,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;

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";

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

@@ -1,10 +1,10 @@
-import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseFact, requestFact, sessionFactForCoordinate, stopFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, updateUpstreamRequestServed, } from "./rows.js";
+import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, } from "./rows.js";
 import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
 import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-import { clipAllowedActions } from "../allowed.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";
 const ACTIVITY_LIMIT = 5_000;
 export async function readSoul(paths) {
@@ -89,137 +89,6 @@ export async function recordTellReceipt(paths, input) {
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
     }));
 }
-function sameRequestInput(fact, input) {
-    if (fact.id !== input.id || fact.action !== input.action)
-        return false;
-    if (fact.action === "akuma.call" && input.action === "akuma.call") {
-        return fact.archetype === input.archetype
-            && fact.body === input.body
-            && fact.cwd === input.cwd
-            && fact.world === input.world
-            && JSON.stringify(fact.recipe) === JSON.stringify(input.recipe);
-    }
-    if (fact.action === "akuma.wait" && input.action === "akuma.wait") {
-        return fact.completion === input.completion
-            && fact.timeoutMs === input.timeoutMs
-            && JSON.stringify(fact.targets) === JSON.stringify(input.targets);
-    }
-    if (fact.action === "akuma.tell" && input.action === "akuma.tell") {
-        return fact.target === input.target && fact.body === input.body;
-    }
-    return fact.action === "akuma.kill" && input.action === "akuma.kill"
-        && JSON.stringify(fact.targets) === JSON.stringify(input.targets);
-}
-export async function admitRequest(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const soul = soulFact(heart);
-        if (soul === null)
-            throw new Error("Akuma request admission requires a born Soul");
-        const action = input.action;
-        const parentAllowed = soul.allowed;
-        const permitted = action === "akuma.wait" || parentAllowed.includes(action);
-        const normalized = input.action === "akuma.call"
-            ? {
-                ...input,
-                recipe: {
-                    ...input.recipe,
-                    allowed: permitted ? clipAllowedActions(input.recipe.allowed, parentAllowed) : input.recipe.allowed,
-                },
-            }
-            : input;
-        insertRequestFact(heart, {
-            ...normalized,
-            requester: soul.id,
-            admittedAt: input.admittedAt,
-            ...(permitted ? {} : { refusal: `not-allowed: ${action}` }),
-        });
-        const fact = requestFact(heart, input.id);
-        if (fact === null)
-            throw new Error(`Akuma request ${input.id} was not admitted`);
-        if (fact.requester !== soul.id || !sameRequestInput(fact, normalized)) {
-            throw new Error(`Akuma request ${input.id} reused different input`);
-        }
-        return fact;
-    }));
-}
-export async function reserveRequest(paths, id, child) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.action !== "akuma.call")
-            throw new Error(`Akuma request ${id} cannot reserve a child`);
-        if (before.state === "admitted")
-            updateRequestReserved(heart, id, child);
-        else if ((before.state !== "reserved" && before.state !== "served") || before.child !== child) {
-            throw new Error(`Akuma request ${id} cannot reserve ${child}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function serveRequest(paths, id, child) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.action !== "akuma.call")
-            throw new Error(`Akuma request ${id} cannot serve a child`);
-        if (before.state === "reserved" && before.child === child)
-            updateRequestServed(heart, id, child);
-        else if (before.state !== "served" || before.child !== child) {
-            throw new Error(`Akuma request ${id} cannot serve ${child}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function serveUpstreamRequest(paths, id, service) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.action === "akuma.call" || service.action !== before.action) {
-            throw new Error(`Akuma request ${id} has a mismatched service reference`);
-        }
-        if (before.state === "admitted")
-            updateUpstreamRequestServed(heart, id, service);
-        else if (before.state !== "served" || JSON.stringify(before.service) !== JSON.stringify(service)) {
-            throw new Error(`Akuma request ${id} cannot be served as ${service.action}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function refuseRequest(paths, id, diagnostic) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted")
-            updateRequestRefused(heart, id, diagnostic);
-        else if (before.state !== "refused" || before.diagnostic !== diagnostic) {
-            throw new Error(`Akuma request ${id} cannot be refused`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function voidRequest(paths, id, evidence) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted" || before.state === "reserved")
-            updateRequestVoided(heart, id, evidence);
-        else if (before.state !== "voided" || before.evidence !== evidence) {
-            throw new Error(`Akuma request ${id} cannot be voided`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function readRequest(paths, id) {
-    return await withHeart(paths, (heart) => requestFact(heart, id));
-}
-export async function readNonterminalRequests(paths) {
-    return await withHeart(paths, nonterminalRequestFacts);
-}
 export async function readKill(paths, bodySequence) {
     return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
 }

package/build/src/akuma/heart/request-authority.d.ts

@@ -0,0 +1,12 @@
+import type { AkuId, AkumaPaths } from "../identity.js";
+import type { RequestFact, RequestInput, UpstreamRequestService } from "./facts.js";
+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[]>;