@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -1,9 +1,10 @@
 import { parsePublicHistoryId } from "../identity.js";
+import { decodeRuntimeModel, withoutModel } from "../provider-recipe.js";
 import { answeredTurnFact, endBodyFact, finishBodyFact, deleteStopControl, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, latestTurnFactForBody, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
-import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, turnParticipants, } from "./tells.js";
-import { activityFactSlice, statusFacts, readStatusBatch, decodeTimelineBatch, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
-import { isHeartAbsent, readSealFromLeash, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
-import { soulFact } from "./soul.js";
+import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, turnParticipants, } from "./tells.js";
+import { activityFactSlice, statusFacts, readStatusBatch, decodeTimelineBatch, timelineDataVersion, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
+import { createHeartReader, isHeartAbsent, readSealFromLeash, recordPendingTell, withHeartTransaction, withReadOnlyHeart, } from "./storage.js";
+import { setSoulModel, soulFact } from "./soul.js";
 import { AkumaBusyError, HeartAuthorityCorruptionError } from "./facts.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
@@ -50,12 +51,57 @@ export async function appendActivity(paths, input) {
         return sequence;
     });
 }
+/**
+ * Admit one runtime-model observation from the Body that is actually running.
+ * The model is the one mutable member of an otherwise frozen recipe, so only
+ * the exact latest Running Body may move it: evidence that arrives after that
+ * Body settled, or from a superseded Body, is refused rather than applied.
+ */
+export async function recordCurrentModel(paths, input) {
+    const model = decodeRuntimeModel(input.model);
+    return await withHeartTransaction(paths, (heart) => {
+        const body = latestBodyFact(heart);
+        if (body === null || body.sequence !== input.bodySequence || body.end !== undefined || body.hung !== undefined) {
+            return "not-current-body";
+        }
+        return setSoulModel(heart, model) ? "recorded" : "unchanged";
+    });
+}
 export async function activitySlice(paths) {
     return await withReadOnlyHeart(paths, (heart) => activityFactSlice(heart));
 }
 export async function readStatusFacts(paths, input, signal) {
     return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input), signal);
 }
+/**
+ * One operation-owned reader of the retained timeline. It keeps its read
+ * custody between observations, skips decoding when the same connection's
+ * change counter still names the observed snapshot, and renews that gate
+ * whenever a replaced Heart gives it a new connection.
+ */
+export function createTimelineReader(paths) {
+    const reader = createHeartReader(paths);
+    let generation = -1;
+    let version;
+    return {
+        clear: reader.clear,
+        async read(signal) {
+            // Publication follows COMMIT, so a failed read never leaves a memo behind.
+            return await reader.read((heart) => {
+                const current = reader.generation();
+                if (current !== generation) {
+                    generation = current;
+                    version = undefined;
+                }
+                const observed = timelineDataVersion(heart);
+                if (version !== undefined && observed === version)
+                    return { changed: false };
+                version = observed;
+                return { changed: true, born: soulFact(heart) !== null, slice: activityFactSlice(heart) };
+            }, signal);
+        },
+    };
+}
 // Each query returns a fixed set of scalar columns; compare JSON columns as text.
 function sameRawRows(left, right) {
     if (left.length !== right.length)
@@ -75,16 +121,24 @@ function sameStatusBatch(left, right) {
         sameRawRows(left.tells.deliveries, right.tells.deliveries) &&
         sameRawRows(left.tells.bindings, right.tells.bindings));
 }
-/** One live observation's successful raw input and decoded frontier, never a connection. */
+/** One observer owns its connection and successful decoded frontier. */
 export function createStatusFactReader(paths) {
+    const reader = createHeartReader(paths);
     let memo;
     return {
+        life: (signal) => readLifeSnapshot(paths, signal, reader.read),
+        tellOutcome: (id, signal) => reader.read((heart) => {
+            const tell = tellFact(heart, id);
+            const end = tell?.binding === undefined ? undefined : turnFact(heart, tell.binding.turnSequence)?.end;
+            return { tell, end };
+        }, signal),
         clear() {
+            reader.clear();
             memo = undefined;
         },
         async read(input, signal) {
             try {
-                const next = await withReadOnlyHeart(paths, (heart) => {
+                const next = await reader.read((heart) => {
                     const batch = readStatusBatch(heart, input);
                     if (memo !== undefined && sameStatusBatch(batch, memo.batch))
                         return memo;
@@ -95,6 +149,7 @@ export function createStatusFactReader(paths) {
                 return next.facts;
             }
             catch (error) {
+                reader.clear();
                 memo = undefined;
                 throw error;
             }
@@ -102,9 +157,9 @@ export function createStatusFactReader(paths) {
     };
 }
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export async function readLifeSnapshot(paths, signal) {
+export async function readLifeSnapshot(paths, signal, read = (body, signal) => withReadOnlyHeart(paths, body, signal)) {
     try {
-        return await withReadOnlyHeart(paths, (heart) => ({
+        return await read((heart) => ({
             soul: soulFact(heart),
             latestBody: latestBodyFact(heart),
             latestSession: latestSessionFact(heart),
@@ -138,9 +193,7 @@ export async function recordTell(paths, tell, options = {}) {
         const running = body !== null && body.end === undefined && body.hung === undefined;
         if (tell.schemaJson !== undefined && running && options.interrupt !== true)
             throw new AkumaBusyError();
-        const sequence = insertTellFact(heart, tell);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-        return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+        return recordPendingTell(heart, tell);
     });
 }
 export async function readTell(paths, id) {
@@ -256,18 +309,6 @@ export async function requestPause(paths, at, signal) {
         return { kind: "requested", body };
     }, signal);
 }
-export async function stopRequested(paths, bodySequence) {
-    return await withReadOnlyHeart(paths, (heart) => {
-        const target = stopFact(heart);
-        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
-    });
-}
-export async function pauseRequested(paths, bodySequence) {
-    return await withReadOnlyHeart(paths, (heart) => {
-        const target = pauseFact(heart);
-        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
-    });
-}
 export async function breakBody(paths, input) {
     await withHeartTransaction(paths, (heart) => endBodyFact(heart, input));
 }
@@ -335,6 +376,27 @@ export async function finishBodyIfIdle(paths, input) {
         return { kind: "finished" };
     });
 }
+export function createBodyHeartReader(paths) {
+    const reader = createHeartReader(paths);
+    return {
+        clear: reader.clear,
+        async read() {
+            try {
+                return await reader.read((heart) => ({
+                    soul: soulFact(heart),
+                    pending: pendingTellFacts(heart),
+                    stop: stopFact(heart),
+                    pause: pauseFact(heart),
+                }));
+            }
+            catch (error) {
+                if (isHeartAbsent(error))
+                    return { soul: null, pending: [], stop: null, pause: null };
+                throw error;
+            }
+        },
+    };
+}
 export async function readHeart(paths) {
     try {
         return await withReadOnlyHeart(paths, (heart) => ({
@@ -380,12 +442,15 @@ export async function readForkPoint(paths, historyId) {
             const recipe = sessionFactForCoordinate(heart, outcome.session);
             if (recipe === null)
                 throw new Error(`Akuma fork point ${historyId} has no session recipe`);
+            // The source's current model is the admitted child selection. The session
+            // row's obsolete copy is dropped, and an absent current model stays absent.
+            const current = soulFact(heart)?.options.model;
             return {
                 historyId: outcome.historyId,
                 session: outcome.session,
                 provider: recipe.provider,
                 cwd: recipe.cwd,
-                options: recipe.options,
+                options: { ...withoutModel(recipe.options), ...(current === undefined ? {} : { model: current }) },
             };
         });
     }

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

@@ -41,11 +41,11 @@ export declare const sessionAdmissionSchema: z.ZodObject<{
         }>>;
         systemPrompt: z.ZodOptional<z.ZodString>;
         systemPromptMode: z.ZodOptional<z.ZodEnum<{
-            append: "append";
             replace: "replace";
+            append: "append";
         }>>;
     }, z.core.$strip>, z.ZodTransform<Readonly<{
-        systemPromptMode?: "append" | "replace";
+        systemPromptMode?: "replace" | "append";
         systemPrompt?: string;
         network?: "disabled" | "enabled";
         effort?: string;
@@ -55,7 +55,7 @@ export declare const sessionAdmissionSchema: z.ZodObject<{
         effort?: string | undefined;
         network?: "disabled" | "enabled" | undefined;
         systemPrompt?: string | undefined;
-        systemPromptMode?: "append" | "replace" | undefined;
+        systemPromptMode?: "replace" | "append" | undefined;
     }>>;
     admittedAt: z.ZodString;
 }, z.core.$strict>;

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { providerOptionsSchema } from "../provider-recipe.js";
+import { providerOptionsSchema, withoutModel } from "../provider-recipe.js";
 import { resumeCoordinateSchema } from "../coordinate.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate as encodeCoordinate } from "../coordinate.js";
 import { agentEventSchema } from "./activity-schema.js";
@@ -32,7 +32,7 @@ export function encodeSessionRow(session) {
         session.provider,
         encodeResumeCoordinate(session.coordinate),
         session.cwd,
-        json(session.options),
+        json(withoutModel(session.options)),
         session.admittedAt,
     ];
 }
@@ -45,7 +45,9 @@ export function decodeSessionRow(row) {
         provider: row.provider,
         coordinate: resumeCoordinate(parsed(row.coordinate_json)),
         cwd: row.cwd,
-        options: parsed(row.options_json),
+        // A session's own model copy is obsolete: the Soul owns the one current
+        // model, so an old row never re-admits the model it happened to start with.
+        options: withoutModel(parsed(row.options_json)),
         admittedAt: row.admitted_at,
     };
 }

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

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { Soul, SoulRow } from "./facts.js";
+import { type Soul, type SoulRow } from "./facts.js";
 export declare function decodeSoulSeed(value: unknown): Omit<Soul, "createdAt">;
 export declare function decodeSoul(value: unknown): Soul;
 export declare function encodeSoul(soul: Soul): string;
@@ -7,3 +7,12 @@ export declare function encodeSoulRow(soul: Soul): readonly [string];
 export declare function decodeSoulRow(row: SoulRow): Soul;
 export declare function soulFact(database: DatabaseSync): Soul | null;
 export declare function insertSoulFact(database: DatabaseSync, soul: Soul): void;
+/**
+ * Replace only the current-model member of the singleton Soul and report
+ * whether the stored value actually moved. Every other raw member is carried
+ * through byte-identically: the codec normalizes recipe options, origin and
+ * allowed, so decoding and re-encoding a whole Soul here would silently
+ * rewrite fields this update never touched. A Soul this build cannot read is
+ * refused rather than mutated.
+ */
+export declare function setSoulModel(database: DatabaseSync, model: string | undefined): boolean;

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

@@ -1,5 +1,7 @@
+import { decodeAkumaCaller } from "../caller.js";
 import { parseAkuId } from "../identity.js";
 import { decodeProviderOptions, decodeProviderRecipe } from "../provider-recipe.js";
+import { akumaOriginSchema } from "./facts.js";
 import { historicalAllowedActions } from "../allowed.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -20,29 +22,6 @@ function soulAkuIdentity(value, what) {
         throw new Error(`Akuma soul ${what} is not an Akuma identity coordinate`, { cause: error });
     }
 }
-function decodeOrigin(value) {
-    const origin = record(value);
-    if (origin === null)
-        throw new Error("Akuma soul origin must be an object");
-    if (origin.kind === "direct") {
-        return { kind: "direct" };
-    }
-    if (origin.kind === "request") {
-        return {
-            kind: "request",
-            parent: soulAkuIdentity(origin.parent, "request parent").id,
-            requestId: nonblank(origin.requestId, "request requestId"),
-        };
-    }
-    if (origin.kind === "fork") {
-        return {
-            kind: "fork",
-            parent: soulAkuIdentity(origin.parent, "fork parent").id,
-            at: nonblank(origin.at, "fork at"),
-        };
-    }
-    throw new Error("Akuma soul origin must be direct, request, or fork");
-}
 export function decodeSoulSeed(value) {
     const soul = record(value);
     if (soul === null)
@@ -55,6 +34,7 @@ export function decodeSoulSeed(value) {
     const description = soul.description === undefined ? undefined : nonblank(soul.description, "description");
     const provider = decodeProviderRecipe(soul.provider);
     const options = decodeProviderOptions(soul.options);
+    const caller = decodeAkumaCaller(soul.caller);
     return {
         id,
         archetype,
@@ -62,7 +42,8 @@ export function decodeSoulSeed(value) {
         provider,
         options,
         cwd: nonblank(soul.cwd, "cwd"),
-        origin: decodeOrigin(soul.origin),
+        origin: akumaOriginSchema.parse(soul.origin),
+        ...(caller === undefined ? {} : { caller }),
         allowed: historicalAllowedActions(soul.allowed),
     };
 }
@@ -97,3 +78,32 @@ export function soulFact(database) {
 export function insertSoulFact(database, soul) {
     database.prepare("INSERT INTO soul(singleton, soul_json) VALUES (1, ?)").run(...encodeSoulRow(soul));
 }
+/**
+ * Replace only the current-model member of the singleton Soul and report
+ * whether the stored value actually moved. Every other raw member is carried
+ * through byte-identically: the codec normalizes recipe options, origin and
+ * allowed, so decoding and re-encoding a whole Soul here would silently
+ * rewrite fields this update never touched. A Soul this build cannot read is
+ * refused rather than mutated.
+ */
+export function setSoulModel(database, model) {
+    const row = database.prepare("SELECT soul_json FROM soul WHERE singleton = 1").get();
+    if (row === undefined)
+        throw new Error("Akuma soul is absent");
+    const raw = JSON.parse(row.soul_json);
+    decodeSoul(raw);
+    const soul = record(raw);
+    const options = record(soul.options);
+    if (options === null)
+        throw new Error("Akuma soul options must be an object");
+    const current = options.model;
+    if (model === undefined ? current === undefined : current === model)
+        return false;
+    const next = { ...options };
+    if (model === undefined)
+        delete next.model;
+    else
+        next.model = model;
+    database.prepare("UPDATE soul SET soul_json = ? WHERE singleton = 1").run(JSON.stringify({ ...soul, options: next }));
+    return true;
+}

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

@@ -9,7 +9,27 @@ export declare class HeartAbsentError extends Error {
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
 export declare function classifyHeartSchema(paths: AkumaPaths): Promise<"current" | "unsupported">;
 export declare function withReadOnlyHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
+export type HeartRead = <T>(body: (database: DatabaseSync) => T, signal?: AbortSignal) => Promise<T>;
+export type HeartReader = Readonly<{
+    read: HeartRead;
+    clear(): void;
+    /** Counts opened connections, so a caller's own reuse cannot survive a replaced Heart. */
+    generation(): number;
+}>;
+/**
+ * A bounded observer owns its connection between observations, never a
+ * transaction: each read settles the transaction it began, and a removed or
+ * replaced Heart invalidates the retained custody through file identity.
+ * Release never interrupts an executing read; it settles after the current
+ * observation, so a caller may release while a pull is still in flight.
+ */
+export declare function createHeartReader(paths: AkumaPaths): HeartReader;
 export declare function withHeartTransaction<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
+/** Insert one already-admitted pending Tell into an already-open Heart transaction. */
+export declare function recordPendingTell(heart: DatabaseSync, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">): Readonly<{
+    kind: "recorded";
+    tell: TellFact;
+}>;
 export declare function initializeHeart(paths: AkumaPaths): Promise<void>;
 export declare class HeldAkumaLeash {
     private readonly database;

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

@@ -112,6 +112,61 @@ export async function withReadOnlyHeart(paths, body, signal) {
         database.close();
     }
 }
+/**
+ * A bounded observer owns its connection between observations, never a
+ * transaction: each read settles the transaction it began, and a removed or
+ * replaced Heart invalidates the retained custody through file identity.
+ * Release never interrupts an executing read; it settles after the current
+ * observation, so a caller may release while a pull is still in flight.
+ */
+export function createHeartReader(paths) {
+    let database;
+    let identity;
+    let tail = Promise.resolve();
+    let opened = 0;
+    const release = () => {
+        const retained = database;
+        database = undefined;
+        identity = undefined;
+        try {
+            retained?.close();
+        }
+        catch {
+            // A connection already released by its own failed read stays released.
+        }
+    };
+    const clear = () => {
+        tail = tail.then(release, release);
+    };
+    const read = (body, signal) => {
+        const pending = tail.then(async () => {
+            try {
+                signal?.throwIfAborted();
+                const current = await lstat(paths.heart).catch((error) => {
+                    if (error.code === "ENOENT")
+                        throw new HeartAbsentError(paths.heart, { cause: error });
+                    throw error;
+                });
+                if (identity?.dev !== current.dev || identity?.ino !== current.ino)
+                    release();
+                if (database === undefined) {
+                    database = await openHeart(paths.heart, "ro");
+                    identity = current;
+                    opened += 1;
+                }
+                await beginTransaction(database, "read", signal);
+                return finishTransaction(database, body);
+            }
+            catch (error) {
+                release();
+                throw error;
+            }
+        });
+        tail = pending.catch(() => undefined);
+        return pending;
+    };
+    return { read, clear, generation: () => opened };
+}
 export async function withHeartTransaction(paths, body, signal) {
     signal?.throwIfAborted();
     const database = await openHeart(paths.heart, "rw");
@@ -142,6 +197,12 @@ function finishTransaction(database, body) {
         throw error;
     }
 }
+/** Insert one already-admitted pending Tell into an already-open Heart transaction. */
+export function recordPendingTell(heart, tell) {
+    const sequence = insertTellFact(heart, tell);
+    pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+}
 export async function initializeHeart(paths) {
     const heart = new DatabaseSync(paths.heart);
     try {
@@ -258,9 +319,7 @@ export class HeldAkumaLeash {
             deletePauseControl(heart);
             if (soulFact(heart) === null)
                 return { kind: "not-born" };
-            const sequence = insertTellFact(heart, tell);
-            pruneActivityFacts(heart, ACTIVITY_LIMIT);
-            return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+            return recordPendingTell(heart, tell);
         });
     }
     release() {

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

@@ -37,4 +37,11 @@ export declare function readStatusBatch(database: DatabaseSync, input: StatusFac
 };
 export declare function statusFacts(database: DatabaseSync, input: StatusFactInput): readonly TimelineFact[];
 export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;
+/**
+ * SQLite's cross-connection change counter, sampled inside the read
+ * transaction. It identifies exactly the snapshot that transaction decodes: a
+ * commit from another connection during the read cannot be mistaken for this
+ * one and skipped, because the next transaction reports a new counter.
+ */
+export declare function timelineDataVersion(database: DatabaseSync): number;
 export {};

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

@@ -124,3 +124,13 @@ export function activityFactSlice(database) {
         highest: bounds.highest,
     };
 }
+/**
+ * SQLite's cross-connection change counter, sampled inside the read
+ * transaction. It identifies exactly the snapshot that transaction decodes: a
+ * commit from another connection during the read cannot be mistaken for this
+ * one and skipped, because the next transaction reports a new counter.
+ */
+export function timelineDataVersion(database) {
+    const row = database.prepare("PRAGMA data_version").get();
+    return row?.data_version ?? 0;
+}

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

@@ -18,7 +18,6 @@ export type AllocatedAkuma = Readonly<{
     suffix: string;
     paths: AkumaPaths;
 }>;
-export declare function archetypeName(value: string): string;
 export declare function akuId(input: Readonly<{
     archetype: string;
     suffix: string;

package/build/src/akuma/identity.js

@@ -22,9 +22,6 @@ export const akumaPathsSchema = z
     requests: pathText,
 })
     .strict();
-export function archetypeName(value) {
-    return validateAkumaName(value);
-}
 function suffixSegment(value) {
     if (!HEX8.test(value))
         throw new TypeError("Akuma suffix must be lower hex8");
@@ -33,7 +30,7 @@ function suffixSegment(value) {
 export function akuId(input) {
     return identityCoordinate({
         family: "aku",
-        segments: [archetypeName(input.archetype), suffixSegment(input.suffix)],
+        segments: [validateAkumaName(input.archetype), suffixSegment(input.suffix)],
     });
 }
 export function parseAkuId(value) {
@@ -94,7 +91,7 @@ export async function ensureAkumaRunRoot(worldRoot) {
     return runRoot;
 }
 export async function allocateAkumaDirectory(input) {
-    const archetype = archetypeName(input.archetype);
+    const archetype = validateAkumaName(input.archetype);
     const runRoot = await ensureAkumaRunRoot(input.worldRoot);
     for (;;) {
         const suffix = suffixSegment(input.draw?.() ?? randomBytes(4).toString("hex"));

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

@@ -1,7 +1,11 @@
-export type { WorldRoot } from "../world.js";
+export type { AkumaCaller } from "./caller.js";
+export type { AkumaOrigin } from "./heart/index.js";
+export { AkumaArchetypeError, listArchetypeDefinitions } from "./archetype.js";
+export type { ArchetypeCatalog, ArchetypeCatalogInput, ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
-export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
+export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaHostOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
+export type { AkumaStreamSnapshot } from "./akuma-stream.js";
 export type { InterruptReceipt } from "./akuma-owner.js";
 export type { AkumaStatus } from "./akuma.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";

package/build/src/akuma/index.js

@@ -1,3 +1,4 @@
+export { AkumaArchetypeError, listArchetypeDefinitions } from "./archetype.js";
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";

package/build/src/akuma/nuke.js

@@ -1,10 +1,11 @@
 import { lstat, readdir, rm, rmdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { nukeAliases } from "../alias/index.js";
+import { knownAkuma } from "./akuma.js";
 import { settleAkumaKill } from "./akuma-owner.js";
 import { acquireLeash } from "./control.js";
 import { classifyHeartSchema, readHeart } from "./heart/index.js";
-import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot } from "./identity.js";
+import { akumaRunRoot } from "./identity.js";
 export class AkumaResetStopError extends Error {
     constructor(message) {
         super(message);
@@ -105,6 +106,7 @@ async function removeKnownRequestChannel(path) {
 async function removeAkumaEntry(entry) {
     await removeKnownRequestChannel(entry.paths.requests);
     for (const path of [
+        join(entry.paths.directory, "request-entry.json"),
         entry.paths.log,
         `${entry.paths.heart}-wal`,
         `${entry.paths.heart}-shm`,
@@ -136,34 +138,10 @@ async function removeEmptyAkumaRunRoot(world) {
     await removeEmptyDirectory(dirname(runRoot));
 }
 async function nukeAkumaEntries(world) {
-    const runRoot = akumaRunRoot(world);
-    let names;
-    try {
-        names = (await readdir(runRoot, { withFileTypes: true }))
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            names = [];
-        else
-            throw error;
-    }
     const entries = [];
-    for (const name of names) {
-        let physical;
-        try {
-            physical = akuIdFromDirectoryName(name);
-        }
-        catch {
-            // The run root can contain bytes not produced by Keiyaku. Preserve them.
-            continue;
-        }
-        const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
-        if (!(await hasAkumaCustody(paths)))
-            continue;
-        entries.push({ id: physical.id, paths });
+    for (const entry of (await knownAkuma(world)).rows) {
+        if (await hasAkumaCustody(entry.paths))
+            entries.push(entry);
     }
     return entries;
 }