@astrosheep/keiyaku 4.0.3 → 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") {
@@ -601,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) {

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

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
-export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 14)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 14);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    archetype TEXT NOT NULL,\n    body TEXT NOT NULL,\n    cwd TEXT,\n    world TEXT NOT NULL,\n    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
+export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 16)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 16);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    requester TEXT NOT NULL,\n    action TEXT NOT NULL CHECK (action IN ('akuma.call', 'akuma.wait', 'akuma.tell', 'akuma.kill')),\n    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'reserved' AND action = 'akuma.call'\n        AND child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((action = 'akuma.call' AND child IS NOT NULL AND service_json IS NULL)\n          OR (action != 'akuma.call' AND child IS NULL AND service_json IS NOT NULL))\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
 export declare const LEASH_SCHEMA = "\n  PRAGMA journal_mode=DELETE;\n  CREATE TABLE IF NOT EXISTS leash_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 4)\n  ) STRICT;\n  INSERT OR IGNORE INTO leash_schema(singleton, version) VALUES (1, 4);\n  CREATE TABLE IF NOT EXISTS seal (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    evidence TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n";