@astrosheep/keiyaku 4.0.2 → 4.0.4

package/build/src/akuma/archetype.js

@@ -1,9 +1,11 @@
 import { readFile, readdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { parseDocument } from "yaml";
 import { archetypeName } from "./identity.js";
 import { decodeProviderOptions, decodeProviderRecipe, } from "./provider-recipe.js";
 import { resolveProviderExecution } from "./providers/index.js";
+import { effectiveAllowedActions } from "./allowed.js";
 export class AkumaArchetypeError extends Error {
     archetype;
     searched;
@@ -17,14 +19,11 @@ export class AkumaArchetypeError extends Error {
         this.name = "AkumaArchetypeError";
     }
 }
-function archetypeDirectory(settings) {
-    const userPath = settings.scopes.user.path;
-    return userPath === undefined ? null : join(dirname(userPath), "akuma");
+function archetypeDirectory(home) {
+    return join(home ?? join(homedir(), ".keiyaku"), "akuma");
 }
-async function archetypePaths(settings) {
-    const directory = archetypeDirectory(settings);
-    if (directory === null)
-        return [];
+async function archetypePaths(home) {
+    const directory = archetypeDirectory(home);
     try {
         return (await readdir(directory, { withFileTypes: true }))
             .flatMap((entry) => {
@@ -46,8 +45,8 @@ async function archetypePaths(settings) {
         throw error;
     }
 }
-export async function listArchetypes(input) {
-    return (await archetypePaths(input.settings)).map(({ name }) => name);
+export async function listArchetypes(input = {}) {
+    return (await archetypePaths(input.home)).map(({ name }) => name);
 }
 function archetypeField(values, key, required = false) {
     const value = values[key];
@@ -96,6 +95,7 @@ function decodeArchetype(name, path, markdown) {
     const readonly = archetypeReadonly(values);
     const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
     const description = archetypeField(values, "description");
+    const allowed = effectiveAllowedActions(values.allowed);
     const systemPrompt = lines.slice(closing + 1).join("\n");
     return Object.freeze({
         name,
@@ -109,12 +109,13 @@ function decodeArchetype(name, path, markdown) {
             ...(network === undefined ? {} : { network }),
             ...(systemPrompt.length === 0 ? {} : { systemPrompt }),
         }),
+        allowed,
     });
 }
-export async function listArchetypeDefinitions(input) {
+export async function listArchetypeDefinitions(input = {}) {
     // Reads still run concurrently, but the reported failure is the first invalid
     // definition in catalog byte order, not whichever read happened to finish first.
-    const settled = await Promise.allSettled((await archetypePaths(input.settings)).map(async ({ name, path }) => {
+    const settled = await Promise.allSettled((await archetypePaths(input.home)).map(async ({ name, path }) => {
         try {
             const definition = decodeArchetype(name, path, await readFile(path, "utf8"));
             return Object.freeze({
@@ -209,11 +210,9 @@ function admitArchetype(archetype, settings) {
 }
 export async function loadArchetype(input) {
     const name = archetypeName(input.name);
-    const directory = archetypeDirectory(input.settings);
-    const missing = () => new AkumaArchetypeError(name, directory === null ? [] : [join(directory, `${name}.md`)], "was not found", "use `keiyaku ls aku/` to list available Akuma");
-    if (directory === null)
-        throw missing();
+    const directory = archetypeDirectory(input.home);
     const path = join(directory, `${name}.md`);
+    const missing = () => new AkumaArchetypeError(name, [path], "was not found", "use `keiyaku ls aku/` to list available Akuma");
     let markdown;
     try {
         markdown = await readFile(path, "utf8");

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 RequestChildLaunch } from "./requests.js";
+import { type UpstreamExecutionPort, type RequestChildLaunch } from "./requests.js";
 export declare const CONTROL_RESPONSE_MS = 1000;
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
@@ -12,7 +12,9 @@ export type BodyLaunch = Readonly<{
 type BodyRuntime = Readonly<{
     now(): string;
     spawnChild?(launch: RequestChildLaunch): Promise<void>;
+    upstream?: UpstreamExecutionPort;
 }>;
 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 {};

package/build/src/akuma/body.js

@@ -185,6 +185,7 @@ async function startTurnDrive(input) {
             bodySequence: input.bodySequence,
             now: input.now,
             spawn: input.runtimeSpawn,
+            ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
             signal: input.supervisor.signal,
         })
         : null;
@@ -538,6 +539,7 @@ async function runBodyTurns(input) {
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
             launchTells,
+            ...(runtime.upstream === undefined ? {} : { upstream: runtime.upstream }),
             now: runtime.now,
         });
         if (result.kind === "stopped") {
@@ -580,8 +582,16 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
         }
     }
     catch (error) {
-        if (await heartExists(launch.paths))
-            throw error;
+        if (!await heartExists(launch.paths))
+            return;
+        try {
+            await leash.sealIfUnborn(launch.paths, {
+                evidence: error instanceof Error ? error.message : String(error),
+                at: runtime.now(),
+            });
+        }
+        catch { /* the original Body failure remains authoritative */ }
+        throw error;
     }
     finally {
         leash.release();
@@ -593,20 +603,21 @@ export async function spawnAkumaBody(launch) {
     if (actorId === undefined)
         throw new Error("Akuma wake has no born soul");
     const owned = await spawnDetachedProcess({
-        argv: [process.execPath, ...process.execArgv, fileURLToPath(import.meta.url), encoded],
+        argv: [process.execPath, ...process.execArgv, fileURLToPath(new URL("../akuma-body.js", import.meta.url)), encoded],
         cwd: await launchCwd(launch),
         env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
         log: launch.paths.log,
     });
     owned.release();
 }
-async function main() {
+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"));
-    await driveAkumaBody(launch);
-}
-if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
-    await main();
+    await driveAkumaBody(launch, undefined, {
+        now: () => new Date().toISOString(),
+        spawnChild: spawnAkumaBody,
+        upstream: upstreamFor(launch),
+    });
 }

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

@@ -1,6 +1,7 @@
 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";
 export type { ResumeCoordinate } from "../coordinate.js";
 export type Confinement = Readonly<{
     kind: "unconfined";
@@ -29,9 +30,10 @@ export type Soul = Readonly<{
     cwd: string;
     origin: AkumaOrigin;
     confinement: Confinement;
+    allowed: AllowedActions;
     createdAt: string;
 }>;
-export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "confinement">;
+export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "confinement" | "allowed">;
 export type BodyEnd = "exited" | "broke-off" | "put-down";
 export type BodyFact = Readonly<{
     sequence: number;
@@ -129,26 +131,66 @@ export type TellReceiptInput = Readonly<{
 }>);
 export type RequestInput = Readonly<{
     id: string;
+    action: "akuma.call";
     archetype: string;
     body: string;
     cwd?: string;
     world: string;
     recipe: RequestRecipe;
+}> | Readonly<{
+    id: string;
+    action: "akuma.wait";
+    targets: readonly AkuId[];
+    completion: "any" | "all";
+    timeoutMs?: number;
+}> | Readonly<{
+    id: string;
+    action: "akuma.tell";
+    target: AkuId;
+    body: string;
+}> | Readonly<{
+    id: string;
+    action: "akuma.kill";
+    targets: readonly AkuId[];
 }>;
-export type RequestFact = RequestInput & Readonly<{
+export type UpstreamRequestService = Readonly<{
+    action: "akuma.wait";
+}> | Readonly<{
+    action: "akuma.tell";
+    target: AkuId;
+    tellId: string;
+}> | Readonly<{
+    action: "akuma.kill";
+    results: readonly Readonly<{
+        id: AkuId;
+        evidence: KillEvidence;
+    }>[];
+}>;
+type AdmittedRequest = RequestInput & Readonly<{
+    requester: AkuId;
     admittedAt: string;
-}> & (Readonly<{
+}>;
+export type RequestFact = (AdmittedRequest & Readonly<{
     state: "admitted";
-}> | Readonly<{
+}>) | (Extract<AdmittedRequest, {
+    action: "akuma.call";
+}> & Readonly<{
     state: "reserved";
     child: AkuId;
-}> | Readonly<{
+}>) | (Extract<AdmittedRequest, {
+    action: "akuma.call";
+}> & Readonly<{
     state: "served";
     child: AkuId;
-}> | Readonly<{
+}>) | (Exclude<AdmittedRequest, {
+    action: "akuma.call";
+}> & Readonly<{
+    state: "served";
+    service: UpstreamRequestService;
+}>) | (AdmittedRequest & Readonly<{
     state: "refused";
     diagnostic: string;
-}> | Readonly<{
+}>) | (AdmittedRequest & Readonly<{
     state: "voided";
     evidence: string;
 }>);

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

@@ -1,11 +1,11 @@
 import type { AkuId, AkumaPaths } from "../identity.js";
-import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
+import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, UpstreamRequestService, 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 { life, lifeAt } from "./facts.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Confinement, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } 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 { ResumeCoordinate } from "../coordinate.js";
 export declare function readSoul(paths: AkumaPaths): Promise<Soul | null>;
 export declare function heartExists(paths: AkumaPaths): Promise<boolean>;
@@ -16,15 +16,10 @@ export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
     event: unknown;
     at: string;
 }>): Promise<number>;
-export type ActivitySliceInput = Readonly<{
-    before?: number;
-    since?: number;
-    limit?: number;
-}>;
 export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
 export type { TimelineFact } from "./timeline.js";
-export declare function activitySlice(paths: AkumaPaths, input?: ActivitySliceInput): Promise<ActivitySlice>;
+export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
 export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Promise<Readonly<{
     kind: "not-born";
 } | {
@@ -38,6 +33,7 @@ export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Re
 }>): 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>;

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

@@ -1,8 +1,9 @@
-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, } from "./rows.js";
+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 { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
 import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
-import { isHeartAbsent, readSealFromLeash, transaction, withHeart } from "./storage.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 { life, lifeAt } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;
@@ -46,14 +47,20 @@ export async function appendActivity(paths, input) {
         return sequence;
     }));
 }
-export async function activitySlice(paths, input = {}) {
-    const limit = input.limit ?? ACTIVITY_LIMIT;
-    return await withHeart(paths, (heart) => activityFactSlice(heart, { ...input, limit }));
+export async function activitySlice(paths) {
+    return await withHeart(paths, (heart) => readTransaction(heart, () => activityFactSlice(heart)));
 }
 export async function recordTell(paths, tell) {
     return await withHeart(paths, (heart) => transaction(heart, () => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
+        const existing = tellFact(heart, tell.id);
+        if (existing !== null) {
+            if (existing.body !== tell.body || existing.recordedAt !== tell.recordedAt) {
+                throw new Error(`tell ${tell.id} reused different input`);
+            }
+            return { kind: "recorded", tell: existing };
+        }
         const sequence = insertTellFact(heart, tell);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
@@ -83,21 +90,55 @@ export async function recordTellReceipt(paths, input) {
     }));
 }
 function sameRequestInput(fact, input) {
-    return fact.id === input.id
-        && 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.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, () => {
-        insertRequestFact(heart, input);
+        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 (!sameRequestInput(fact, input))
+        if (fact.requester !== soul.id || !sameRequestInput(fact, normalized)) {
             throw new Error(`Akuma request ${input.id} reused different input`);
+        }
         return fact;
     }));
 }
@@ -106,6 +147,8 @@ export async function reserveRequest(paths, id, child) {
         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) {
@@ -119,6 +162,8 @@ export async function serveRequest(paths, id, child) {
         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) {
@@ -127,6 +172,22 @@ export async function serveRequest(paths, id, 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);
@@ -234,7 +295,7 @@ export async function finishBodyIfIdle(paths, input) {
 }
 export async function readHeart(paths) {
     try {
-        return await withHeart(paths, (heart) => ({
+        return await withHeart(paths, (heart) => readTransaction(heart, () => ({
             soul: soulFact(heart),
             latestBody: latestBodyFact(heart),
             latestSession: latestSessionFact(heart),
@@ -242,7 +303,7 @@ export async function readHeart(paths) {
             latestKill: latestKillFact(heart),
             stop: stopFact(heart),
             pause: pauseFact(heart),
-        }));
+        })));
     }
     catch (error) {
         if (isHeartAbsent(error)) {

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

@@ -42,14 +42,13 @@ export type CallRow = Readonly<{
 export type RequestRow = Readonly<{
     sequence: number;
     id: string;
-    archetype: string;
-    body: string;
-    cwd: string | null;
-    world: string;
-    recipe_json: string;
+    requester: string;
+    action: string;
+    payload_json: string;
     admitted_at: string;
     state: RequestFact["state"];
     child: string | null;
+    service_json: string | null;
     diagnostic: string | null;
     evidence: string | null;
 }>;
@@ -102,12 +101,15 @@ export declare function insertActivityFact(database: DatabaseSync, input: Readon
     at: string;
 }>): number;
 export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
+    requester: AkuId;
     admittedAt: string;
+    refusal?: string;
 }>): void;
 export declare function requestFact(database: DatabaseSync, id: string): RequestFact | null;
 export declare function nonterminalRequestFacts(database: DatabaseSync): readonly RequestFact[];
 export declare function updateRequestReserved(database: DatabaseSync, id: string, child: AkuId): void;
 export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function updateUpstreamRequestServed(database: DatabaseSync, id: string, service: unknown): void;
 export declare function updateRequestRefused(database: DatabaseSync, id: string, diagnostic: string): void;
 export declare function updateRequestVoided(database: DatabaseSync, id: string, evidence: string): void;
 export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;

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

@@ -7,6 +7,66 @@ function parsed(value) {
         throw new Error("Akuma authority contains non-text JSON");
     return JSON.parse(value);
 }
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function exactKeys(value, expected) {
+    const actual = Object.keys(value).sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+const KILL_EVIDENCE = [
+    "already-killed",
+    "already-stopped",
+    "hung",
+    "killed",
+    "untidy",
+    "unavailable",
+];
+function decodeRequestService(value, input) {
+    const service = object(value);
+    if (service === null || service.action !== input.action) {
+        throw new Error("Akuma authority contains a mismatched request service reference");
+    }
+    if (input.action === "akuma.wait") {
+        if (!exactKeys(service, ["action"])) {
+            throw new Error("Akuma authority contains an invalid wait service reference");
+        }
+        return { action: input.action };
+    }
+    if (input.action === "akuma.tell") {
+        if (!exactKeys(service, ["action", "target", "tellId"])
+            || service.target !== input.target
+            || service.tellId !== input.id) {
+            throw new Error("Akuma authority contains an invalid tell service reference");
+        }
+        return { action: input.action, target: input.target, tellId: input.id };
+    }
+    if (!exactKeys(service, ["action", "results"]) || !Array.isArray(service.results)) {
+        throw new Error("Akuma authority contains an invalid kill service reference");
+    }
+    let targetIndex = -1;
+    const results = service.results.map((value) => {
+        const result = object(value);
+        if (result === null
+            || !exactKeys(result, ["evidence", "id"])
+            || typeof result.id !== "string"
+            || !KILL_EVIDENCE.includes(result.evidence)) {
+            throw new Error("Akuma authority contains an invalid kill service reference");
+        }
+        const index = input.targets.indexOf(result.id);
+        if (index <= targetIndex) {
+            throw new Error("Akuma authority contains an invalid kill service reference");
+        }
+        targetIndex = index;
+        return {
+            id: result.id,
+            evidence: result.evidence,
+        };
+    });
+    return { action: input.action, results };
+}
 function resumeCoordinate(value) {
     const coordinate = decodeResumeCoordinate(value);
     if (coordinate === null)
@@ -67,18 +127,39 @@ export function decodeCallRow(row) {
     return { kind: "call", sequence: row.sequence, turnSequence: row.turn_sequence, body: row.body, at: row.at };
 }
 export function decodeRequestRow(row) {
+    if (!["akuma.call", "akuma.wait", "akuma.tell", "akuma.kill"].includes(row.action)) {
+        throw new Error(`Akuma authority contains an unknown request action: ${row.action}`);
+    }
+    const payload = parsed(row.payload_json);
     const input = {
         id: row.id,
-        archetype: row.archetype,
-        body: row.body,
-        ...(row.cwd === null ? {} : { cwd: row.cwd }),
-        world: row.world,
-        recipe: parsed(row.recipe_json),
+        requester: row.requester,
+        action: row.action,
+        ...payload,
         admittedAt: row.admitted_at,
     };
-    if (row.state === "reserved" || row.state === "served") {
+    if (row.state === "reserved") {
+        if (input.action !== "akuma.call" || row.child === null) {
+            throw new Error("Akuma authority contains an invalid reserved request");
+        }
         return { ...input, state: row.state, child: row.child };
     }
+    if (row.state === "served") {
+        if (input.action === "akuma.call") {
+            if (row.child === null)
+                throw new Error("Akuma authority contains a served call without a child");
+            return { ...input, state: row.state, child: row.child };
+        }
+        if (row.service_json === null) {
+            throw new Error("Akuma authority contains a served request without a service reference");
+        }
+        const service = decodeRequestService(parsed(row.service_json), input);
+        return {
+            ...input,
+            state: row.state,
+            service,
+        };
+    }
     if (row.state === "refused")
         return { ...input, state: row.state, diagnostic: row.diagnostic };
     if (row.state === "voided")
@@ -129,11 +210,13 @@ export function insertActivityFact(database, input) {
         .run(sequence, input.turnSequence, encodeActivityEvent(input.event), input.at);
     return sequence;
 }
-const REQUEST_COLUMNS = `sequence, id, archetype, body, cwd, world, recipe_json, admitted_at,
-  state, child, diagnostic, evidence`;
+const REQUEST_COLUMNS = `sequence, id, requester, action, payload_json, admitted_at,
+  state, child, service_json, diagnostic, evidence`;
 export function insertRequestFact(database, input) {
-    database.prepare(`INSERT OR IGNORE INTO requests(id, archetype, body, cwd, world, recipe_json, admitted_at, state)
-    VALUES (?, ?, ?, ?, ?, ?, ?, 'admitted')`).run(input.id, input.archetype, input.body, input.cwd ?? null, input.world, json(input.recipe), input.admittedAt);
+    const { id, action, requester, admittedAt, refusal, ...payload } = input;
+    database.prepare(`INSERT OR IGNORE INTO requests(
+    id, requester, action, payload_json, admitted_at, state, diagnostic
+  ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, requester, action, json(payload), admittedAt, refusal === undefined ? "admitted" : "refused", refusal ?? null);
 }
 export function requestFact(database, id) {
     const row = database.prepare(`SELECT ${REQUEST_COLUMNS} FROM requests WHERE id = ?`).get(id);
@@ -152,12 +235,16 @@ export function updateRequestServed(database, id, child) {
     database.prepare(`UPDATE requests SET state = 'served', child = ?
     WHERE id = ? AND state = 'reserved'`).run(child, id);
 }
+export function updateUpstreamRequestServed(database, id, service) {
+    database.prepare(`UPDATE requests SET state = 'served', service_json = ?
+    WHERE id = ? AND state = 'admitted' AND action != 'akuma.call'`).run(json(service), id);
+}
 export function updateRequestRefused(database, id, diagnostic) {
     database.prepare(`UPDATE requests SET state = 'refused', diagnostic = ?
     WHERE id = ? AND state = 'admitted'`).run(diagnostic, id);
 }
 export function updateRequestVoided(database, id, evidence) {
-    database.prepare(`UPDATE requests SET state = 'voided', child = NULL, evidence = ?
+    database.prepare(`UPDATE requests SET state = 'voided', child = NULL, service_json = NULL, evidence = ?
     WHERE id = ? AND state IN ('admitted', 'reserved')`).run(evidence, id);
 }
 export function insertStopControl(database, bodySequence, at) {