@astrosheep/keiyaku 4.5.0 → 4.5.2

package/build/src/akuma/identity.js

@@ -4,6 +4,13 @@ import { dirname, join } from "node:path";
 import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
 import { normalizeIdentityStem } from "../identity/normalize.js";
 const HEX8 = /^[0-9a-f]{8}$/u;
+export function parsePublicHistoryId(value) {
+    const match = /^turn\/([1-9][0-9]*)$/u.exec(value);
+    if (match === null)
+        return null;
+    const sequence = Number(match[1]);
+    return Number.isSafeInteger(sequence) ? sequence : null;
+}
 export function archetypeName(value) {
     if (value.length === 0 || normalizeIdentityStem({ source: value }) !== value) {
         throw new TypeError("Akuma name must be one normalized human identity segment");

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

@@ -9,7 +9,7 @@ export declare function probeBornAkuma(worldPath: WorldRoot, id: AkuId): Promise
 export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
 export type { ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBodyRequestError } from "./requests.js";
-export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, TellWake, UnbornAkumaListRow, } from "./akuma.js";
+export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ExactHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, TellWake, UnbornAkumaListRow, } from "./akuma.js";
 export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, ReportedFileChange, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
 export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
 export type { AkuId } from "./identity.js";

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

@@ -1,6 +1,14 @@
 import { type ToolCall, type ToolResult } from "./provider.js";
-import type { TellDelivery, TellFact, TimelineFact, TurnEndFact } from "./heart/index.js";
-export type TurnOutcome = TurnEndFact["outcome"];
+import type { TellDelivery, TellFact, TimelineFact } from "./heart/index.js";
+export type TurnOutcome = Readonly<{
+    kind: "answered";
+    historyId: string;
+    answer: string;
+}> | Readonly<{
+    kind: "failed";
+    historyId: string;
+    diagnostic: string;
+}>;
 export type TurnStartRow = Readonly<{
     kind: "turn";
     sequence: number;
@@ -153,7 +161,15 @@ export type ActivityHistory = Readonly<{
     lowestRetained: number | null;
     highest: number | null;
 }>;
+export type ExactHistory = Readonly<{
+    kind: "exact";
+    outcome: OutcomeRow;
+}> | Readonly<{
+    kind: "unknown-history";
+    id: string;
+}>;
 export type HistoryPage = ActivityHistory;
+export declare function selectExactHistory(rows: readonly ActivityRow[], id: string): ExactHistory;
 export type HistoryCursor = Readonly<{
     before?: number;
     since?: number;

package/build/src/akuma/projection.js

@@ -1,4 +1,14 @@
 import { decodeAgentEvent } from "./provider.js";
+function publicOutcome(turnSequence, outcome) {
+    const historyId = `turn/${turnSequence}`;
+    return outcome.kind === "answered"
+        ? { kind: "answered", historyId, answer: outcome.answer }
+        : { kind: "failed", historyId, diagnostic: outcome.diagnostic };
+}
+export function selectExactHistory(rows, id) {
+    const outcome = rows.find((row) => row.kind === "outcome" && row.outcome.historyId === id);
+    return outcome === undefined ? { kind: "unknown-history", id } : { kind: "exact", outcome };
+}
 function duration(startedAt, completedAt) {
     const start = Date.parse(startedAt);
     const end = Date.parse(completedAt);
@@ -171,7 +181,7 @@ export function projectTurns(facts, retained = {
                 sequence: fact.sequence,
                 turnSequence: fact.turnSequence,
                 at: fact.completedAt,
-                outcome: fact.outcome,
+                outcome: publicOutcome(fact.turnSequence, fact.outcome),
             };
             const turn = state.turnsBySequence.get(fact.turnSequence);
             if (turn === undefined)

package/build/src/akuma/providers/claude/index.js

@@ -118,53 +118,64 @@ function finishClaudeInput(input, terminal) {
     else
         input.close();
 }
+function consumeClaudeMessage(context, state, message) {
+    const { input, events, observation, progress, admit, rejectAdmission, settle, controls } = context;
+    if (state.terminal !== null)
+        return;
+    if (!state.admitted && "session_id" in message && typeof message.session_id === "string" && admit()) {
+        state.admitted = true;
+        events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
+    }
+    emitClaudeMessage(message, events, observation);
+    if (message.type === "assistant" &&
+        message.parent_tool_use_id === null &&
+        typeof message.uuid === "string" &&
+        message.uuid.length > 0)
+        state.historyId = message.uuid;
+    if (message.type !== "result")
+        return;
+    if (message.subtype === "success") {
+        state.terminal = successfulResult(message, state.historyId);
+        progress.checkpoint += 1;
+        controls.flushReceipts();
+        queueMicrotask(controls.closeWhenIdle);
+    }
+    else {
+        state.terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
+        input.close();
+    }
+    progress.ended = true;
+    if (!state.admitted)
+        rejectAdmission(new Error(state.terminal.kind === "failed" ? state.terminal.diagnostic : "Claude query ended before session admission"));
+    finishClaudeInput(input, state.terminal);
+    events.end();
+    settle(state.terminal);
+    controls.settleReceipts();
+}
 async function consumeClaudeQuery(context) {
-    const { query, input, events, observation, progress, admit, rejectAdmission, settle, controls } = context;
-    let admitted = false;
-    let terminal = null;
-    let historyId;
+    const { query, input, events, progress, rejectAdmission, settle, controls } = context;
+    const state = { admitted: false, terminal: null };
     try {
-        for await (const message of query) {
-            if (!admitted && "session_id" in message && typeof message.session_id === "string") {
-                admitted = true;
-                events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
-                admit();
-            }
-            emitClaudeMessage(message, events, observation);
-            if (message.type === "assistant" &&
-                message.parent_tool_use_id === null &&
-                typeof message.uuid === "string" &&
-                message.uuid.length > 0)
-                historyId = message.uuid;
-            if (message.type !== "result")
-                continue;
-            if (message.subtype === "success") {
-                terminal = successfulResult(message, historyId);
-                progress.checkpoint += 1;
-                controls.flushReceipts();
-                queueMicrotask(controls.closeWhenIdle);
-            }
-            else {
-                terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
-                input.close();
-            }
-        }
+        for await (const message of query)
+            consumeClaudeMessage(context, state, message);
         progress.ended = true;
-        const result = terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
-        if (!admitted)
+        const result = state.terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
+        if (!state.admitted)
             rejectAdmission(new Error(result.kind === "failed" ? result.diagnostic : "Claude query ended before session admission"));
         settle(result);
     }
     catch (error) {
         progress.ended = true;
+        if (state.terminal !== null)
+            return;
         input.fail(error);
         const failure = error instanceof Error ? error : new Error(String(error));
-        if (!admitted)
+        if (!state.admitted)
             rejectAdmission(failure);
         settle({ kind: "failed", diagnostic: failure.message });
     }
     finally {
-        finishClaudeInput(input, terminal);
+        finishClaudeInput(input, state.terminal);
         events.end();
         controls.settleReceipts();
     }
@@ -206,9 +217,21 @@ function observeClaudeQuery(context) {
     const observation = { tools: new Map() };
     let admit;
     let rejectAdmission;
+    let admissionOpen = true;
     const admission = new Promise((resolve, reject) => {
-        admit = resolve;
-        rejectAdmission = reject;
+        admit = () => {
+            if (!admissionOpen)
+                return false;
+            admissionOpen = false;
+            resolve();
+            return true;
+        };
+        rejectAdmission = (error) => {
+            if (!admissionOpen)
+                return;
+            admissionOpen = false;
+            reject(error);
+        };
     });
     let settle;
     const completion = new Promise((resolve) => {
@@ -247,6 +270,7 @@ function observeClaudeQuery(context) {
     });
     return {
         admission,
+        rejectAdmission,
         completion,
         get ended() {
             return progress.ended;
@@ -282,9 +306,13 @@ async function driveClaude(load, execution, drive) {
         input.fail(error);
         query.close();
     };
-    const abortSetup = () => shutDown(signal.reason);
+    let observed;
+    const abortSetup = () => {
+        shutDown(signal.reason);
+        observed?.rejectAdmission(signal.reason);
+    };
     signal.addEventListener("abort", abortSetup, { once: true });
-    const observed = observeClaudeQuery({
+    observed = observeClaudeQuery({
         query,
         input,
         events,
@@ -296,8 +324,11 @@ async function driveClaude(load, execution, drive) {
             },
         },
     });
+    if (signal.aborted)
+        abortSetup();
     try {
         await Promise.all([launchAcknowledged, observed.admission]);
+        signal.throwIfAborted();
     }
     finally {
         signal.removeEventListener("abort", abortSetup);

package/build/src/akuma/publication.js

@@ -93,6 +93,9 @@ async function awaitBirth(paths, owned, signal) {
             const settled = await settleTimedOutBirth(paths);
             if (settled !== null)
                 return settled;
+            if (owned !== undefined)
+                await owned.terminate(true);
+            throw new Error("Akuma birth timed out before Soul admission");
         }
         if (owned === undefined) {
             await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);

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

@@ -0,0 +1,45 @@
+import { type Soul } from "./heart/index.js";
+import { type AkumaPaths } from "./identity.js";
+import { type StructuralRequestClaim } from "./request-wire.js";
+import type { OwnedProcess } from "../runtime/proc/run.js";
+export type RequestChildLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+    initialBody: string;
+}>;
+export type PumpInput = Readonly<{
+    paths: AkumaPaths;
+    parent: Soul;
+    bodySequence: number;
+    now(): string;
+    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
+    upstream?: unknown;
+    signal: AbortSignal;
+}>;
+type ServeClaim = (input: PumpInput & Readonly<{
+    directory: string;
+    transportId: string;
+    claim: StructuralRequestClaim;
+    signal: AbortSignal;
+    admissionOpen(): boolean;
+}>) => Promise<void>;
+export declare class BodyRequestPump {
+    private readonly input;
+    private readonly serveClaim;
+    readonly directory: string;
+    readonly failure: Promise<never>;
+    private readonly closeSignal;
+    private readonly executionSignal;
+    private readonly handled;
+    private readonly running;
+    private readonly cancelBody;
+    private admissionClosed;
+    protected constructor(input: PumpInput, serveClaim: ServeClaim);
+    static openWithService(input: PumpInput, serveClaim: ServeClaim): Promise<BodyRequestPump>;
+    private run;
+    close(): Promise<void>;
+    stopAdmission(): void;
+}
+export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
+export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
+export {};

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

@@ -0,0 +1,171 @@
+import { access, mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { abortableDelay } from "./abort.js";
+import { HeldAkumaLeash, readNonterminalRequests, readSoul, serveRequest, voidRequest, } from "./heart/index.js";
+import { pathsForAkuId } from "./identity.js";
+import { BIRTH_TIMEOUT_MS } from "./publication.js";
+import { atomicJson, decodeClaim, receiptPath } from "./request-wire.js";
+const POLL_MS = 100;
+export class BodyRequestPump {
+    input;
+    serveClaim;
+    directory;
+    failure;
+    closeSignal = new AbortController();
+    executionSignal = new AbortController();
+    handled = new Set();
+    running;
+    cancelBody;
+    admissionClosed = false;
+    constructor(input, serveClaim) {
+        this.input = input;
+        this.serveClaim = serveClaim;
+        this.directory = join(input.paths.directory, "requests", String(input.bodySequence));
+        this.cancelBody = () => {
+            this.stopAdmission();
+            if (!this.executionSignal.signal.aborted)
+                this.executionSignal.abort(input.signal.reason);
+        };
+        input.signal.addEventListener("abort", this.cancelBody, { once: true });
+        if (input.signal.aborted)
+            this.cancelBody();
+        this.running = this.run();
+        this.failure = this.running.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+    }
+    static async openWithService(input, serveClaim) {
+        await mkdir(join(input.paths.directory, "requests", String(input.bodySequence)), { recursive: true });
+        return new BodyRequestPump(input, serveClaim);
+    }
+    async run() {
+        while (!this.closeSignal.signal.aborted) {
+            for (const name of await requestFiles(this.directory)) {
+                if (this.closeSignal.signal.aborted)
+                    return;
+                const transportId = name.slice(0, -".request.json".length);
+                if (this.handled.has(transportId))
+                    continue;
+                const path = join(this.directory, name);
+                const claim = decodeClaim(await readFile(path, "utf8"), transportId);
+                if (claim === null) {
+                    await rm(path, { force: true });
+                    this.handled.add(transportId);
+                    continue;
+                }
+                if (!this.admissionClosed) {
+                    try {
+                        await this.serveClaim({
+                            directory: this.directory,
+                            transportId,
+                            claim,
+                            ...this.input,
+                            signal: this.executionSignal.signal,
+                            admissionOpen: () => !this.admissionClosed,
+                        });
+                    }
+                    catch (error) {
+                        await projectTransportFailure(this.directory, transportId, claim, error);
+                    }
+                }
+                this.handled.add(transportId);
+            }
+            try {
+                await abortableDelay(POLL_MS, this.closeSignal.signal);
+            }
+            catch (error) {
+                if (this.closeSignal.signal.aborted)
+                    return;
+                throw error;
+            }
+        }
+    }
+    async close() {
+        this.stopAdmission();
+        try {
+            await this.running;
+        }
+        finally {
+            this.input.signal.removeEventListener("abort", this.cancelBody);
+            await rm(this.directory, { recursive: true, force: true });
+        }
+    }
+    stopAdmission() {
+        this.admissionClosed = true;
+        if (!this.closeSignal.signal.aborted)
+            this.closeSignal.abort(new Error("Body request pump closed"));
+    }
+}
+export async function clearBodyRequestTransport(paths) {
+    await rm(join(paths.directory, "requests"), { recursive: true, force: true });
+}
+async function requestFiles(directory) {
+    try {
+        return (await readdir(directory)).filter((name) => name.endsWith(".request.json")).sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+async function projectTransportFailure(directory, transportId, claim, error) {
+    await atomicJson(receiptPath(directory, transportId), {
+        id: claim.id,
+        action: claim.action,
+        state: "refused",
+        diagnostic: error instanceof Error ? error.message : String(error),
+    });
+}
+function matchingRequestOrigin(soul, parent, id) {
+    return soul.origin.kind === "request" && soul.origin.parent === parent && soul.origin.requestId === id;
+}
+async function settleReservedSoul(paths, parent, request, soul) {
+    await (matchingRequestOrigin(soul, parent.id, request.id)
+        ? serveRequest(paths, request.id, request.child)
+        : voidRequest(paths, request.id, "reserved child origin does not match the request"));
+}
+async function settleReserved(paths, parent, request, now, signal) {
+    const childPaths = pathsForAkuId(request.world, request.child);
+    const deadline = performance.now() + BIRTH_TIMEOUT_MS;
+    for (;;) {
+        signal?.throwIfAborted();
+        if (!(await access(childPaths.directory).then(() => true, () => false))) {
+            await voidRequest(paths, request.id, "reserved child directory is absent");
+            return true;
+        }
+        const soul = await readSoul(childPaths);
+        if (soul !== null) {
+            await settleReservedSoul(paths, parent, request, soul);
+            return true;
+        }
+        const leash = await HeldAkumaLeash.try(childPaths);
+        if (leash !== null) {
+            try {
+                const settled = await readSoul(childPaths);
+                if (settled !== null)
+                    await settleReservedSoul(paths, parent, request, settled);
+                else {
+                    await leash.sealIfUnborn(childPaths, { evidence: "request settlement", at: now() });
+                    await voidRequest(paths, request.id, "reserved child was sealed unborn");
+                }
+            }
+            finally {
+                leash.release();
+            }
+            return true;
+        }
+        if (performance.now() >= deadline)
+            return false;
+        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
+    }
+}
+export async function settleBodyRequests(paths, parent, now, signal) {
+    let pending = false;
+    for (const request of await readNonterminalRequests(paths)) {
+        signal?.throwIfAborted();
+        if (request.state === "admitted")
+            await voidRequest(paths, request.id, "body died before serving the request");
+        else if (request.state === "reserved" && !(await settleReserved(paths, parent, request, now, signal)))
+            pending = true;
+    }
+    return pending ? "pending" : "settled";
+}

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

@@ -1,13 +1,10 @@
-import { type KillEvidence, type RequestFact, type Soul } from "./heart/index.js";
-import { type AkuId, type AkumaPaths } from "./identity.js";
+import { type KillEvidence, type RequestFact } from "./heart/index.js";
+import { type AkuId } from "./identity.js";
 import { type StructuralRequestClaim } from "./request-wire.js";
 import { type TaskMutationRequest } from "../task/mutation.js";
-import type { OwnedProcess } from "../runtime/proc/run.js";
-export type RequestChildLaunch = Readonly<{
-    paths: AkumaPaths;
-    seed: Omit<Soul, "createdAt">;
-    initialBody: string;
-}>;
+import { BodyRequestPump as LifecycleBodyRequestPump, type RequestChildLaunch as LifecycleRequestChildLaunch, type PumpInput as LifecyclePumpInput } from "./request-lifecycle.js";
+export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
+export type RequestChildLaunch = LifecycleRequestChildLaunch;
 type UpstreamCall = Readonly<{
     signal: AbortSignal;
 }>;
@@ -60,17 +57,12 @@ export type UpstreamExecutionPort = Readonly<{
         request: TaskMutationRequest;
     }>): Promise<unknown>;
 }>;
-type PumpInput = Readonly<{
-    paths: AkumaPaths;
-    parent: Soul;
-    bodySequence: number;
-    now(): string;
-    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
+type PumpInput = Omit<LifecyclePumpInput, "upstream"> & Readonly<{
     upstream?: UpstreamExecutionPort;
-    signal: AbortSignal;
 }>;
 export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
     directory: string;
+    transportId: string;
     claim: StructuralRequestClaim;
     admissionOpen(): boolean;
 }>;
@@ -79,22 +71,7 @@ export type UpstreamFact = Exclude<Extract<RequestFact, {
 }>, Extract<RequestFact, {
     action: "akuma.call";
 }>>;
-export declare class BodyRequestPump {
-    private readonly input;
-    readonly directory: string;
-    readonly failure: Promise<never>;
-    private readonly closeSignal;
-    private readonly executionSignal;
-    private readonly handled;
-    private readonly running;
-    private readonly cancelBody;
-    private admissionClosed;
-    private constructor();
+export declare function serveRequest(input: ServeInput): Promise<void>;
+export declare class BodyRequestPump extends LifecycleBodyRequestPump {
     static open(input: PumpInput): Promise<BodyRequestPump>;
-    private run;
-    close(): Promise<void>;
-    stopAdmission(): void;
 }
-export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
-export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
-export {};