@astrosheep/keiyaku 4.5.7 → 4.5.9

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

@@ -0,0 +1,80 @@
+import { type Soul } from "./heart/index.js";
+import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type ErasedRequestCommand, type RequestCommand } from "./request-wire.js";
+import type { OwnedProcess } from "../runtime/proc/run.js";
+import { z } from "zod";
+import { type WorldRoot } from "../world.js";
+declare const akumaCallRecipeSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    allowed: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./allowed.js").AllowedActions, unknown>>;
+    provider: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+        name: string;
+        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+        executable?: string;
+        config?: Readonly<Record<string, unknown>>;
+        env?: Readonly<Record<string, string>>;
+    }>, unknown>>;
+    options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+        model?: string;
+        effort?: string;
+        readonly?: true;
+        network?: "disabled" | "enabled";
+        systemPrompt?: string;
+        systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
+    }>, unknown>>;
+    readonly: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./provider-recipe.js").ReadonlyRestraint, unknown>>>;
+}, z.core.$strict>;
+declare const akumaCallPayloadSchema: z.ZodObject<{
+    world: z.ZodString;
+    archetype: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    body: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    recipe: z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        allowed: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./allowed.js").AllowedActions, unknown>>;
+        provider: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+            name: string;
+            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+            executable?: string;
+            config?: Readonly<Record<string, unknown>>;
+            env?: Readonly<Record<string, string>>;
+        }>, unknown>>;
+        options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+            model?: string;
+            effort?: string;
+            readonly?: true;
+            network?: "disabled" | "enabled";
+            systemPrompt?: string;
+            systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
+        }>, unknown>>;
+        readonly: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./provider-recipe.js").ReadonlyRestraint, unknown>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AkumaCallRecipe = z.infer<typeof akumaCallRecipeSchema>;
+export type AkumaCallRequest = z.infer<typeof akumaCallPayloadSchema> & Readonly<{
+    action: "akuma.call";
+}>;
+export type AkumaCallRequestChildLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+    initialBody: string;
+}>;
+type CallExecutionContext = Readonly<{
+    id: string;
+    requester: string;
+    signal: AbortSignal;
+    world: WorldRoot;
+    paths: AkumaPaths;
+    parent: Soul;
+    spawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
+    admissionOpen(): boolean;
+}>;
+export declare function decodeAkumaCallRequest(value: unknown): AkumaCallRequest | null;
+export declare function akumaCallRequestCommand(): RequestCommand<AkumaCallRequest, AkuId, never, AkuId, CallExecutionContext>;
+export declare function akumaCallRequestCommands(): Readonly<Record<"akuma.call", ErasedRequestCommand>>;
+export declare function requestForwardedAkumaCall(input: Omit<AkumaCallRequest, "action"> & Readonly<{
+    directory: string;
+    id: string;
+    signal?: AbortSignal;
+}>): Promise<AkuId>;
+export {};

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

@@ -0,0 +1,211 @@
+import { isAbsolute, resolve } from "node:path";
+import { clipAllowedActions, decodeAllowedActions } from "./allowed.js";
+import { refuseRequest, reserveRequest } from "./heart/index.js";
+import { archetypeName, parseAkuId } from "./identity.js";
+import { publishAkuma } from "./publication.js";
+import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
+import { decodeProviderExecution } from "./providers/index.js";
+import { requestBodyCommand } from "./request-rendezvous.js";
+import { eraseRequestCommand } from "./request-wire.js";
+import { z } from "zod";
+import { World } from "../world.js";
+function schemaDecode(decode, message) {
+    return z.unknown().transform((value, context) => {
+        try {
+            return decode(value);
+        }
+        catch {
+            context.addIssue({ code: "custom", message });
+            return z.NEVER;
+        }
+    });
+}
+const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
+const akuIdSchema = z.string().transform((value, context) => {
+    try {
+        const id = parseAkuId(value).id;
+        if (id !== value) {
+            context.addIssue({ code: "custom", message: "expected canonical AkuId" });
+            return z.NEVER;
+        }
+        return id;
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected canonical AkuId" });
+        return z.NEVER;
+    }
+});
+const archetypeSchema = z.string().transform((value, context) => {
+    try {
+        return archetypeName(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected Akuma name" });
+        return z.NEVER;
+    }
+});
+const allowedActionsSchema = schemaDecode(decodeAllowedActions, "expected allowed actions");
+const providerExecutionSchema = schemaDecode(decodeProviderExecution, "expected provider execution");
+const providerOptionsSchema = schemaDecode(decodeProviderOptions, "expected provider options");
+const readonlyRestraintSchema = schemaDecode(decodeReadonlyRestraint, "expected readonly restraint");
+const akumaCallRecipeSchema = z
+    .object({
+    description: z.string().trim().min(1).optional(),
+    allowed: allowedActionsSchema,
+    provider: providerExecutionSchema,
+    options: providerOptionsSchema,
+    readonly: readonlyRestraintSchema.optional(),
+})
+    .strict()
+    .superRefine((recipe, context) => {
+    if ((recipe.options.readonly === true) !== (recipe.readonly !== undefined)) {
+        context.addIssue({ code: "custom", message: "readonly recipe fields disagree" });
+    }
+});
+const akumaCallPayloadSchema = z
+    .object({
+    world: absolutePathSchema,
+    archetype: archetypeSchema,
+    body: z.string(),
+    cwd: absolutePathSchema.optional(),
+    recipe: akumaCallRecipeSchema,
+})
+    .strict();
+function carriesLaunchWorld(value) {
+    const upstream = object(value);
+    return upstream !== null && typeof upstream.launchWorld === "function";
+}
+function decodeCallExecutionContext(value) {
+    const context = object(value);
+    const paths = object(context?.paths);
+    const parent = object(context?.parent);
+    const parentId = akuIdSchema.safeParse(parent?.id);
+    if (context === null ||
+        typeof context.id !== "string" ||
+        context.id.trim() === "" ||
+        typeof context.requester !== "string" ||
+        typeof context.signal !== "object" ||
+        context.signal === null ||
+        typeof context.signal.throwIfAborted !== "function" ||
+        paths === null ||
+        !["directory", "heart", "leash", "log", "requests"].every((key) => typeof paths[key] === "string") ||
+        parent === null ||
+        !parentId.success ||
+        typeof parent.cwd !== "string" ||
+        !Array.isArray(parent.allowed) ||
+        typeof context.spawn !== "function" ||
+        typeof context.admissionOpen !== "function")
+        throw new Error("invalid Akuma call execution context");
+    if (!carriesLaunchWorld(context.upstream))
+        throw new Error("Akuma call requires a minted launch World");
+    return {
+        id: context.id,
+        requester: context.requester,
+        signal: context.signal,
+        world: context.upstream.launchWorld(),
+        paths: context.paths,
+        parent: context.parent,
+        spawn: context.spawn,
+        admissionOpen: context.admissionOpen,
+    };
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function decodeAkumaCallRequest(value) {
+    const parsed = akumaCallPayloadSchema.safeParse(value);
+    return parsed.success ? { ...parsed.data, action: "akuma.call" } : null;
+}
+function callPayload(request) {
+    const { action: _action, ...payload } = request;
+    return payload;
+}
+async function executeAkumaCall(request, context) {
+    const world = context.world;
+    const requestWorld = await World.prove(request.world);
+    if (requestWorld !== world) {
+        await refuseRequest(context.paths, context.id, `request world ${requestWorld} does not match ${world}`);
+        throw new Error(`request world ${requestWorld} does not match ${world}`);
+    }
+    const recipe = {
+        ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
+        allowed: clipAllowedActions(request.recipe.allowed, context.parent.allowed),
+        provider: request.recipe.provider,
+        options: request.recipe.options,
+        ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
+    };
+    const published = await publishAkuma({
+        worldPath: world,
+        archetype: request.archetype,
+        signal: context.signal,
+        launch: async (allocated) => {
+            if (!context.admissionOpen())
+                throw new Error("body closed request admission");
+            await reserveRequest(context.paths, context.id, allocated.id);
+            return await context.spawn({
+                paths: allocated.paths,
+                seed: {
+                    id: allocated.id,
+                    archetype: allocated.archetype,
+                    ...recipe,
+                    cwd: request.cwd ?? context.parent.cwd,
+                    origin: { kind: "request", parent: context.parent.id, requestId: context.id },
+                },
+                initialBody: request.body,
+            });
+        },
+    });
+    return { result: published.id, child: published.id };
+}
+export function akumaCallRequestCommand() {
+    return {
+        action: "akuma.call",
+        encodeRequest: callPayload,
+        decodeRequest: decodeAkumaCallRequest,
+        encodeResult: (result) => result,
+        decodeResult: (result) => {
+            const child = akuIdSchema.safeParse(result);
+            if (!child.success)
+                throw new Error("Akuma call returned an invalid child");
+            return child.data;
+        },
+        encodeService: (service) => service,
+        decodeService: (_service) => {
+            throw new Error("Akuma call has no service evidence");
+        },
+        projectService: (_service) => {
+            throw new Error("Akuma call has no service evidence");
+        },
+        projectChild: (child) => {
+            const id = akuIdSchema.safeParse(child);
+            if (!id.success)
+                throw new Error("Akuma call stored an invalid child reference");
+            return id.data;
+        },
+        decodeReference: (reference) => {
+            const child = akuIdSchema.safeParse(reference);
+            if (!child.success)
+                throw new Error("Akuma call stored an invalid child reference");
+            return child.data;
+        },
+        isPermitted: (allowed) => allowed.includes("akuma.call"),
+        decodeExecutionContext: decodeCallExecutionContext,
+        execute: executeAkumaCall,
+    };
+}
+export function akumaCallRequestCommands() {
+    return { "akuma.call": eraseRequestCommand(akumaCallRequestCommand()) };
+}
+export async function requestForwardedAkumaCall(input) {
+    const { directory, id, signal, ...request } = input;
+    const response = await requestBodyCommand({
+        directory,
+        id,
+        command: akumaCallRequestCommand(),
+        value: { ...request, action: "akuma.call" },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    return response.kind === "returned" ? response.result : response.reference;
+}

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

@@ -2,7 +2,6 @@ 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 AkumaOrigin = Readonly<{
     kind: "direct";
@@ -101,6 +100,16 @@ export type TellFact = Readonly<{
     state: "pending" | "told";
     deliveries: readonly TellDelivery[];
 }>;
+export type TellRow = Readonly<{
+    kind: "tell";
+    sequence: number;
+    at: string;
+    tellId: string;
+    text: string;
+    state: "pending" | "told";
+    deliveries: readonly TellDelivery[];
+}>;
+export declare function projectTell(fact: TellFact): TellRow;
 export type TellDeliveryInput = Readonly<{
     tellId: string;
     turnSequence: number;
@@ -123,75 +132,10 @@ 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";
-    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[];
-}> | Readonly<{
-    id: string;
-    action: "contract.deliver";
-    repoRoot: string;
-    contractId: string;
-    message?: string;
-    includeDirty: boolean;
-    materializeConflict: boolean;
-}> | Readonly<{
-    id: string;
-    action: "contract.review";
-    repoRoot: string;
-    contractId: string;
-    verdict: "satisfied" | "unsatisfied";
-    summary?: string;
-}> | TaskRequestInput;
-export type UpstreamRequestService = Readonly<{
-    action: "akuma.wait";
-}> | Readonly<{
-    action: "akuma.tell";
-    target: AkuId;
-    tellId: string;
-}> | Readonly<{
-    action: "akuma.kill";
-    results: readonly 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"];
+    action: string;
+    payloadJson: string;
 }>;
 type AdmittedRequest = RequestInput & Readonly<{
     requester: AkuId;
@@ -199,21 +143,15 @@ type AdmittedRequest = RequestInput & Readonly<{
 }>;
 export type RequestFact = (AdmittedRequest & Readonly<{
     state: "admitted";
-}>) | (Extract<AdmittedRequest, {
-    action: "akuma.call";
-}> & Readonly<{
+}>) | (AdmittedRequest & Readonly<{
     state: "reserved";
     child: AkuId;
-}>) | (Extract<AdmittedRequest, {
-    action: "akuma.call";
-}> & Readonly<{
+}>) | (AdmittedRequest & Readonly<{
     state: "served";
     child: AkuId;
-}>) | (Exclude<AdmittedRequest, {
-    action: "akuma.call";
-}> & Readonly<{
+}>) | (AdmittedRequest & Readonly<{
     state: "served";
-    service: UpstreamRequestService;
+    serviceJson: string;
 }>) | (AdmittedRequest & Readonly<{
     state: "refused";
     diagnostic: string;

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

@@ -1,3 +1,14 @@
+export function projectTell(fact) {
+    return {
+        kind: "tell",
+        sequence: fact.sequence,
+        at: fact.recordedAt,
+        tellId: fact.id,
+        text: fact.body,
+        state: fact.state,
+        deliveries: fact.deliveries,
+    };
+}
 export function life(input) {
     if (input.body?.hung !== undefined)
         return "hung";

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

@@ -5,8 +5,8 @@ import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
-export { life, lifeAt } 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 { life, lifeAt, projectTell } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellRow, 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>;
@@ -27,6 +27,7 @@ export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequ
     kind: "recorded";
     tell: TellFact;
 }>>;
+export declare function readTell(paths: AkumaPaths, id: string): Promise<TellFact | null>;
 export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): Promise<void>;
 export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): Promise<void>;
 export declare function readKill(paths: AkumaPaths, bodySequence: number): Promise<KillFact | null>;

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

@@ -6,7 +6,7 @@ import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHea
 import { soulFact } from "./soul.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
-export { life, lifeAt } from "./facts.js";
+export { life, lifeAt, projectTell } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;
 export async function readSoul(paths) {
     try {
@@ -67,6 +67,9 @@ export async function recordTell(paths, tell) {
         return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
     }));
 }
+export async function readTell(paths, id) {
+    return await withHeart(paths, (heart) => readTransaction(heart, () => tellFact(heart, id)));
+}
 export async function recordTellDeliveries(paths, inputs) {
     await withHeart(paths, (heart) => transaction(heart, () => {
         for (const input of inputs) {

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

@@ -1,12 +1,13 @@
-import type { AkuId, AkumaPaths } from "../identity.js";
-import type { RequestFact, RequestInput, UpstreamRequestService } from "./facts.js";
+import { type AkuId, type AkumaPaths } from "../identity.js";
+import type { RequestFact, RequestInput } from "./facts.js";
 export declare function isRequestInputConflict(error: unknown): error is Error;
 export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
     admittedAt: string;
+    permitted: boolean;
 }>): 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 serveRequest(paths: AkumaPaths, id: string, child: string): Promise<RequestFact>;
+export declare function serveUpstreamRequest(paths: AkumaPaths, id: string, serviceJson: string): 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/request-authority.js

@@ -1,7 +1,7 @@
+import { parseAkuId } from "../identity.js";
 import { insertRequestFact, nonterminalRequestFacts, requestFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, updateUpstreamRequestServed, } from "./request-rows.js";
 import { transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-import { clipAllowedActions } from "../allowed.js";
 import { requestPayloadJson } from "./request-rows.js";
 // This stays out of the public Heart index: only transport service projects it as a refusal.
 class RequestInputConflictError extends Error {
@@ -18,31 +18,19 @@ export async function admitRequest(paths, 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;
+        const { permitted, ...request } = input;
         insertRequestFact(heart, {
-            ...normalized,
+            ...request,
             requester: soul.id,
-            admittedAt: input.admittedAt,
-            ...(permitted ? {} : { refusal: `not-allowed: ${action}` }),
+            ...(permitted ? {} : { refusal: `not-allowed: ${input.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 ||
-            fact.id !== normalized.id ||
-            fact.action !== normalized.action ||
-            requestPayloadJson(fact) !== requestPayloadJson(normalized)) {
+            fact.id !== input.id ||
+            fact.action !== input.action ||
+            requestPayloadJson(fact) !== requestPayloadJson(input)) {
             throw new RequestInputConflictError(input.id);
         }
         return fact;
@@ -53,43 +41,41 @@ 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) {
+        else if ((before.state !== "reserved" && before.state !== "served") ||
+            !("child" in before) ||
+            before.child !== child) {
             throw new Error(`Akuma request ${id} cannot reserve ${child}`);
         }
         return requestFact(heart, id);
     }));
 }
 export async function serveRequest(paths, id, child) {
+    const parsed = parseAkuId(child);
+    if (parsed.id !== child)
+        throw new Error(`Akuma request ${id} has a noncanonical 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) {
+        if (before.state === "reserved" && before.child === parsed.id)
+            updateRequestServed(heart, id, parsed.id);
+        else if (before.state !== "served" || !("child" in before) || before.child !== parsed.id) {
             throw new Error(`Akuma request ${id} cannot serve ${child}`);
         }
         return requestFact(heart, id);
     }));
 }
-export async function serveUpstreamRequest(paths, id, service) {
+export async function serveUpstreamRequest(paths, id, serviceJson) {
     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") {
-            throw new Error(`Akuma request ${id} cannot be served as ${service.action}`);
+            updateUpstreamRequestServed(heart, id, serviceJson);
+        else if (before.state !== "served" || !("serviceJson" in before) || before.serviceJson !== serviceJson) {
+            throw new Error(`Akuma request ${id} cannot be served with this service reference`);
         }
         return requestFact(heart, id);
     }));

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

@@ -1,45 +1,34 @@
-import { isTaskMutationAction } from "../../task/mutation.js";
-function json(value) {
-    return JSON.stringify(value);
-}
-function parsed(value) {
+function assertJsonText(value) {
     if (typeof value !== "string")
         throw new Error("Akuma authority contains non-text JSON");
-    return JSON.parse(value);
+    JSON.parse(value);
+    return value;
 }
 export function requestPayloadJson(input) {
-    const { id: _id, action: _action, requester: _requester, admittedAt: _admittedAt, state: _state, child: _child, service: _service, diagnostic: _diagnostic, evidence: _evidence, refusal: _refusal, ...payload } = input;
-    return json(payload);
+    return assertJsonText(input.payloadJson);
 }
 function decodeRequestRow(row) {
-    const knownAction = ["akuma.call", "akuma.wait", "akuma.tell", "akuma.kill", "contract.deliver", "contract.review"].includes(row.action) || isTaskMutationAction(row.action);
-    if (!knownAction)
-        throw new Error(`Akuma authority contains an unknown request action: ${row.action}`);
-    const payload = parsed(row.payload_json);
     const input = {
         id: row.id,
         requester: row.requester,
         action: row.action,
-        ...payload,
+        payloadJson: assertJsonText(row.payload_json),
         admittedAt: row.admitted_at,
     };
     if (row.state === "reserved") {
-        if (input.action !== "akuma.call" || row.child === null) {
+        if (row.child === null || row.service_json !== 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");
+        if (row.child !== null && row.service_json === null) {
             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");
+        if (row.child === null && row.service_json !== null) {
+            return { ...input, state: row.state, serviceJson: assertJsonText(row.service_json) };
         }
-        const service = parsed(row.service_json);
-        return { ...input, state: row.state, service };
+        throw new Error("Akuma authority contains an invalid served request");
     }
     if (row.state === "refused")
         return { ...input, state: row.state, diagnostic: row.diagnostic };
@@ -82,8 +71,8 @@ export function updateRequestServed(database, id, child) {
 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);
+    WHERE id = ? AND state = 'admitted'`)
+        .run(assertJsonText(service), id);
 }
 export function updateRequestRefused(database, id, diagnostic) {
     database