@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/akuma/allowed.js

@@ -0,0 +1,33 @@
+import { TASK_MUTATION_ACTIONS } from "../task/mutation.js";
+export const ALLOWED_ACTIONS = Object.freeze([
+    "akuma.call",
+    "akuma.kill",
+    "akuma.tell",
+    "contract.deliver",
+    "contract.review",
+    ...TASK_MUTATION_ACTIONS,
+]);
+const ALLOWED_ACTION_SET = new Set(ALLOWED_ACTIONS);
+export function isAllowedAction(value) {
+    return typeof value === "string" && ALLOWED_ACTION_SET.has(value);
+}
+export function decodeAllowedActions(value, label = "allowed") {
+    if (!Array.isArray(value))
+        throw new TypeError(`${label} must be an array`);
+    const seen = new Set();
+    for (const action of value) {
+        if (!isAllowedAction(action))
+            throw new TypeError(`${label} contains an unknown action: ${String(action)}`);
+        if (seen.has(action))
+            throw new TypeError(`${label} contains a duplicate action: ${action}`);
+        seen.add(action);
+    }
+    return Object.freeze([...seen].sort());
+}
+export function effectiveAllowedActions(value) {
+    return value === undefined ? ALLOWED_ACTIONS : decodeAllowedActions(value);
+}
+export function clipAllowedActions(requested, parent) {
+    const ceiling = new Set(parent);
+    return Object.freeze(requested.filter((action) => ceiling.has(action)));
+}

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

@@ -1,12 +1,14 @@
 import type { Settings } from "../settings.js";
 import type { ProviderAdapter } from "./provider.js";
 import { type ProviderExecution, type ProviderOptions, type ReadonlyRestraint } from "./provider-recipe.js";
+import { type AllowedActions } from "./allowed.js";
 type DecodedArchetype = Readonly<{
     name: string;
     path: string;
     provider: string;
     description?: string;
     options: ProviderOptions;
+    allowed: AllowedActions;
 }>;
 export type ArchetypeCatalogRow = Readonly<{
     name: string;
@@ -27,14 +29,15 @@ export declare class AkumaArchetypeError extends Error {
     readonly kind = "akuma-archetype";
     constructor(archetype: string, searched: readonly string[], reason: string, guidance?: string);
 }
-export declare function listArchetypes(input: Readonly<{
-    settings: Settings;
+export declare function listArchetypes(input?: Readonly<{
+    home?: string;
 }>): Promise<readonly string[]>;
-export declare function listArchetypeDefinitions(input: Readonly<{
-    settings: Settings;
+export declare function listArchetypeDefinitions(input?: Readonly<{
+    home?: string;
 }>): Promise<readonly ArchetypeCatalogRow[]>;
 export declare function loadArchetype(input: Readonly<{
     name: string;
+    home?: string;
     settings: Settings;
 }>): Promise<AdmittedArchetype>;
 export {};

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 "./request-serve.js";
 export declare const CONTROL_RESPONSE_MS = 1000;
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
@@ -12,7 +12,12 @@ 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, configuration: Readonly<{
+    home?: string;
+    gitPath?: string;
+}>) => UpstreamExecutionPort): Promise<void>;
 export {};

package/build/src/akuma/body.js

@@ -3,7 +3,7 @@ import { abortableDelay } from "./abort.js";
 import { HeldAkumaLeash, appendActivity, beginTurn, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
 import { encodeAgentEvent, } from "./provider.js";
 import { resolveProviderExecution } from "./providers/index.js";
-import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./requests.js";
+import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 25;
 const BODY_CONTROL_OBSERVATION_MS = 100;
@@ -178,23 +178,22 @@ async function startTurnDrive(input) {
         startedAt: input.now(),
         ...(input.call === undefined ? {} : { call: input.call }),
     });
-    const requests = input.soul.confinement.kind === "declared"
-        ? await BodyRequestPump.open({
-            paths: input.paths,
-            parent: input.soul,
-            bodySequence: input.bodySequence,
-            now: input.now,
-            spawn: input.runtimeSpawn,
-            signal: input.supervisor.signal,
-        })
-        : null;
+    const requests = await BodyRequestPump.open({
+        paths: input.paths,
+        parent: input.soul,
+        bodySequence: input.bodySequence,
+        now: input.now,
+        spawn: input.runtimeSpawn,
+        ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
+        signal: input.supervisor.signal,
+    });
     const driveInput = {
         body: input.body,
         launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
         cwd,
         options,
         signal: input.supervisor.signal,
-        ...(requests === null ? {} : { requests: { dir: requests.directory } }),
+        requests: { dir: requests.directory },
     };
     const setup = session === undefined
         ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
@@ -203,7 +202,7 @@ async function startTurnDrive(input) {
         const selected = await setup;
         if (input.supervisor.signal.aborted) {
             await retireProviderCustody(input, turn.sequence, selected);
-            await requests?.close();
+            await requests.close();
             return { kind: "stopped" };
         }
         if (input.launchTells.length > 0) {
@@ -215,13 +214,12 @@ async function startTurnDrive(input) {
                 deliveredAt: input.now(),
             })));
         }
-        if (requests !== null)
-            void selected.completion.then(() => requests.stopAdmission());
+        void selected.completion.then(() => requests.stopAdmission());
         return { turnSequence: turn.sequence, drive: selected, requests, cwd, options,
             ...(session === undefined ? {} : { resume: session }) };
     }
     catch (error) {
-        await requests?.close();
+        await requests.close();
         if (input.supervisor.signal.aborted) {
             if (input.supervisor.reason === "heart-gone")
                 throw error;
@@ -310,7 +308,7 @@ async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
 }
 async function stopActiveDrive(input, active) {
     await retireProviderCustody(input, active.turnSequence, active.drive);
-    await active.requests?.close();
+    await active.requests.close();
 }
 function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
     return liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id));
@@ -319,7 +317,7 @@ function persistProviderEvent(_input, _active, event) {
     return event.type === "session" ? event.coordinate : undefined;
 }
 async function settleCompletion(result, session, requests) {
-    await requests?.close();
+    await requests.close();
     return result.kind === "answered" ? { ...result, ...(session === undefined ? {} : { session }) } : result;
 }
 async function consumeTurnDrive(input, active) {
@@ -359,7 +357,7 @@ async function consumeTurnDrive(input, active) {
                 input.supervisor.next(heart).then((observation) => ({ kind: "heart", observation })),
                 ...(tellObservation === null ? [] : [tellObservation]),
                 receiptFailure,
-                ...(requests === null ? [] : [requests.failure]),
+                requests.failure,
             ]);
             if (next.kind === "event" && !next.event.done) {
                 await writeProviderEvent(input, active, next.event.value);
@@ -394,7 +392,7 @@ async function consumeTurnDrive(input, active) {
         }
         await retireProviderCustody(input, turnSequence, drive);
         try {
-            await requests?.close();
+            await requests.close();
         }
         catch { /* preserve the first pump failure */ }
         return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
@@ -423,7 +421,7 @@ async function driveTurn(input) {
     }
     catch (error) {
         if (await heartExists(input.paths)) {
-            await active.requests?.close();
+            await active.requests.close();
             return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error),
                 turnSequence: active.turnSequence };
         }
@@ -538,6 +536,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 +600,30 @@ 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();
+    const mappedHome = process.env.KEIYAKU_HOME?.trim();
+    const mappedGitPath = process.env.KEIYAKU_GIT_PATH;
+    if (mappedGitPath !== undefined && mappedGitPath.trim().length === 0) {
+        throw new TypeError("KEIYAKU_GIT_PATH requires a nonblank value");
+    }
+    const configuration = {
+        ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
+        ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
+    };
+    await driveAkumaBody(launch, undefined, {
+        now: () => new Date().toISOString(),
+        spawnChild: spawnAkumaBody,
+        upstream: upstreamFor(launch, configuration),
+    });
 }

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

@@ -1,13 +1,9 @@
 import type { AkuId } from "../identity.js";
 import type { ResumeCoordinate } from "../coordinate.js";
 import type { ProviderExecution, ProviderOptions, ReadonlyRestraint } from "../provider-recipe.js";
+import type { AllowedActions } from "../allowed.js";
+import type { TaskMutationAction, TaskMutationRequest } from "../../task/mutation.js";
 export type { ResumeCoordinate } from "../coordinate.js";
-export type Confinement = Readonly<{
-    kind: "unconfined";
-}> | Readonly<{
-    kind: "declared";
-    writableRoots: readonly string[];
-}>;
 export type AkumaOrigin = Readonly<{
     kind: "direct";
 }> | Readonly<{
@@ -28,10 +24,10 @@ export type Soul = Readonly<{
     readonly?: ReadonlyRestraint;
     cwd: string;
     origin: AkumaOrigin;
-    confinement: Confinement;
+    allowed: AllowedActions;
     createdAt: string;
 }>;
-export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "confinement">;
+export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "allowed">;
 export type BodyEnd = "exited" | "broke-off" | "put-down";
 export type BodyFact = Readonly<{
     sequence: number;
@@ -127,28 +123,100 @@ 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;
+}> | 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"];
 }>;
-export type RequestFact = RequestInput & Readonly<{
+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,12 @@
-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 { AkumaPaths } from "../identity.js";
+import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Confinement, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, UpstreamRequestService, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
 export type { ResumeCoordinate } from "../coordinate.js";
 export declare function readSoul(paths: AkumaPaths): Promise<Soul | null>;
 export declare function heartExists(paths: AkumaPaths): Promise<boolean>;
@@ -16,15 +17,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";
 } | {
@@ -33,15 +29,6 @@ export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequ
 }>>;
 export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): Promise<void>;
 export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): Promise<void>;
-export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
-    admittedAt: string;
-}>): Promise<RequestFact>;
-export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
-export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
-export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): Promise<RequestFact>;
-export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): Promise<RequestFact>;
-export declare function readRequest(paths: AkumaPaths, id: string): Promise<RequestFact | null>;
-export declare function readNonterminalRequests(paths: AkumaPaths): Promise<readonly RequestFact[]>;
 export declare function readKill(paths: AkumaPaths, bodySequence: number): Promise<KillFact | null>;
 export declare function requestStop(paths: AkumaPaths, at: string): Promise<Readonly<{
     kind: "requested";

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

@@ -1,9 +1,10 @@
-import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseFact, requestFact, sessionFactForCoordinate, stopFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, } from "./rows.js";
+import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, } from "./rows.js";
 import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
 import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
-import { isHeartAbsent, readSealFromLeash, transaction, withHeart } from "./storage.js";
+import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
 export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;
 export async function readSoul(paths) {
@@ -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: [] } };
@@ -82,83 +89,6 @@ export async function recordTellReceipt(paths, input) {
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
     }));
 }
-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);
-}
-export async function admitRequest(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        insertRequestFact(heart, input);
-        const fact = requestFact(heart, input.id);
-        if (fact === null)
-            throw new Error(`Akuma request ${input.id} was not admitted`);
-        if (!sameRequestInput(fact, input))
-            throw new Error(`Akuma request ${input.id} reused different input`);
-        return fact;
-    }));
-}
-export async function reserveRequest(paths, id, child) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted")
-            updateRequestReserved(heart, id, child);
-        else if ((before.state !== "reserved" && before.state !== "served") || before.child !== child) {
-            throw new Error(`Akuma request ${id} cannot reserve ${child}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function serveRequest(paths, id, child) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "reserved" && before.child === child)
-            updateRequestServed(heart, id, child);
-        else if (before.state !== "served" || before.child !== child) {
-            throw new Error(`Akuma request ${id} cannot serve ${child}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function refuseRequest(paths, id, diagnostic) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted")
-            updateRequestRefused(heart, id, diagnostic);
-        else if (before.state !== "refused" || before.diagnostic !== diagnostic) {
-            throw new Error(`Akuma request ${id} cannot be refused`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function voidRequest(paths, id, evidence) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted" || before.state === "reserved")
-            updateRequestVoided(heart, id, evidence);
-        else if (before.state !== "voided" || before.evidence !== evidence) {
-            throw new Error(`Akuma request ${id} cannot be voided`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function readRequest(paths, id) {
-    return await withHeart(paths, (heart) => requestFact(heart, id));
-}
-export async function readNonterminalRequests(paths) {
-    return await withHeart(paths, nonterminalRequestFacts);
-}
 export async function readKill(paths, bodySequence) {
     return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
 }
@@ -234,7 +164,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 +172,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/request-authority.d.ts

@@ -0,0 +1,12 @@
+import type { AkuId, AkumaPaths } from "../identity.js";
+import type { RequestFact, RequestInput, UpstreamRequestService } from "./facts.js";
+export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
+    admittedAt: string;
+}>): Promise<RequestFact>;
+export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
+export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
+export declare function serveUpstreamRequest(paths: AkumaPaths, id: string, service: UpstreamRequestService): Promise<RequestFact>;
+export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): Promise<RequestFact>;
+export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): Promise<RequestFact>;
+export declare function readRequest(paths: AkumaPaths, id: string): Promise<RequestFact | null>;
+export declare function readNonterminalRequests(paths: AkumaPaths): Promise<readonly RequestFact[]>;