@astrosheep/keiyaku 4.0.0 → 4.0.1

package/build/src/akuma/akuma.js

@@ -2,9 +2,9 @@ import { randomUUID } from "node:crypto";
 import { readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { spawnAkumaBody } from "./body.js";
-import { HeldAkumaLeash, activitySlice, life, probeLeash, readCurrentTurn, readHeart, readLastAnsweredTurn, readTurns, readForkPoint, readSeal, readSoul, recordDeath, recordTell, requestPause, requestStop, } from "./heart/index.js";
+import { HeldAkumaLeash, activitySlice, life, probeLeash, readHeart, readLastAnsweredTurn, readForkPoint, readKill, readSeal, readSoul, recordTell, requestPause, requestStop, } from "./heart/index.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, parseAkuId, pathsForAkuId, archetypeName, } from "./identity.js";
-import { projectActivityHistory, selectActivitySnapshot, } from "./activity.js";
+import { projectActivityHistory, selectActivitySnapshot, } from "./projection.js";
 import { listArchetypes as readArchetypes, loadArchetype } from "./archetype.js";
 import { publishAkuma } from "./publication.js";
 import { providerNamed } from "./providers/index.js";
@@ -35,23 +35,21 @@ async function takeLeashUntil(paths, deadline) {
         await wait(POLL_MS);
     }
 }
-function recordTellBody(paths, body) {
+function recordTellBody(paths, akuma, body) {
     const id = randomUUID();
-    const admitted = recordTell(paths, { id, body, recordedAt: new Date().toISOString() });
-    return admitted === "dead" ? { kind: "dead" } : { kind: "recorded", id };
+    const admitted = recordTell(paths, { kind: "tell", id, body, recordedAt: new Date().toISOString() });
+    if (admitted.kind === "not-born")
+        throw new AkumaNotBornError(akuma);
+    return { kind: "recorded", tellId: admitted.tell.id };
 }
-async function wakeTell(paths, akuma, id) {
-    const soul = readSoul(paths);
-    if (soul === null)
-        throw new Error(`Akuma ${akuma} has no soul`);
+async function wakeTell(paths, tellId) {
     try {
         await spawnAkumaBody({ paths });
-        return { id, state: "recorded", wake: "spawned" };
+        return { admission: { tellId, fact: "recorded" }, wake: "spawned" };
     }
     catch (error) {
         return {
-            id,
-            state: "recorded",
+            admission: { tellId, fact: "recorded" },
             wake: { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) },
         };
     }
@@ -74,35 +72,39 @@ function bornListRow(paths, expected, snapshot = readHeart(paths)) {
         id: snapshot.soul.id,
         archetype: snapshot.soul.archetype,
         ...(snapshot.soul.description === undefined ? {} : { description: snapshot.soul.description }),
-        life: life(probeLeash(paths), collar, snapshot.death),
+        life: life(probeLeash(paths), collar, snapshot.latestBody, snapshot.latestKill),
         collar,
         confinement: snapshot.soul.confinement,
         pending: snapshot.pending.map((tell) => tell.id),
     };
 }
-function bornStatus(paths, expected) {
+function bornStatus(paths, expected, profile = "status") {
     const snapshot = readHeart(paths);
     if (snapshot.soul === null)
         throw new AkumaNotBornError(expected);
     const current = bornListRow(paths, expected, snapshot);
-    const latest = readCurrentTurn(paths);
+    const resumeUnsupported = current.life === "stranded"
+        && snapshot.latestSession?.provider === snapshot.soul.provider.name
+        && providerNamed(snapshot.soul.provider).resume === undefined;
     return {
-        ...current,
-        ...(latest === null ? {} : { outcomeAt: latest.completedAt }),
-        ...(latest?.outcome.kind === "answered"
-            ? { answer: latest.outcome.answer, answerHistoryId: latest.outcome.historyId }
-            : {}),
-        ...(latest?.outcome.kind === "failed" ? { failure: latest.outcome.diagnostic } : {}),
-        activity: (() => {
-            const slice = activitySlice(paths, { limit: 5_000 });
+        id: current.id,
+        life: current.life,
+        collar: current.collar,
+        ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
+        timeline: (() => {
+            const slice = activitySlice(paths, { limit: Number.MAX_SAFE_INTEGER });
             return selectActivitySnapshot(slice.rows, {
-                pending: snapshot.pending,
                 lowestRetained: slice.lowestRetained,
                 highest: slice.highest,
+                profile,
             });
         })(),
     };
 }
+/** Package-internal compact observation for action feedback. */
+export function readActionFeedbackStatus(worldPath, id) {
+    return bornStatus(pathsForAkuId(worldPath, id), id, "feedback");
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -137,8 +139,9 @@ export class AkumaHandle {
             ...(input.since === undefined ? {} : { since: input.since }),
             limit: 5_000,
         });
-        return projectActivityHistory(slice, readTurns(this.paths), {
-            since: input.since !== undefined,
+        return projectActivityHistory(slice, {
+            ...(input.before === undefined ? {} : { before: input.before }),
+            ...(input.since === undefined ? {} : { since: input.since }),
             limit,
         });
     }
@@ -156,14 +159,13 @@ export class AkumaHandle {
         }
     }
     async tell(body) {
-        const recorded = recordTellBody(this.paths, body);
-        if (recorded.kind === "dead")
-            throw new Error(`Akuma ${this.id} is dead`);
-        return await wakeTell(this.paths, this.id, recorded.id);
+        const recorded = recordTellBody(this.paths, this.id, body);
+        return await wakeTell(this.paths, recorded.tellId);
     }
     async interrupt(body) {
-        if (requestPause(this.paths, new Date().toISOString()) === "dead")
-            return { kind: "dead" };
+        if (requestPause(this.paths, new Date().toISOString()).kind === "not-born") {
+            throw new AkumaNotBornError(this.id);
+        }
         let putDown = "was-idle";
         let leash = HeldAkumaLeash.try(this.paths);
         if (leash === null) {
@@ -188,16 +190,21 @@ export class AkumaHandle {
         }
         let recorded;
         try {
-            leash.clearPause(this.paths);
-            recorded = recordTellBody(this.paths, body);
+            const id = randomUUID();
+            const admitted = leash.recordInterruptTell(this.paths, {
+                kind: "tell",
+                id,
+                body,
+                recordedAt: new Date().toISOString(),
+            });
+            if (admitted.kind === "not-born")
+                throw new AkumaNotBornError(this.id);
+            recorded = { kind: "recorded", tellId: admitted.tell.id };
         }
         finally {
             leash.release();
         }
-        if (recorded.kind === "dead") {
-            return { kind: "interrupted", putDown, tell: { kind: "refused-dead" } };
-        }
-        return { kind: "interrupted", putDown, tell: await wakeTell(this.paths, this.id, recorded.id) };
+        return { kind: "interrupted", putDown, tell: await wakeTell(this.paths, recorded.tellId) };
     }
     async fork(input) {
         const source = readSoul(this.paths);
@@ -256,51 +263,67 @@ export class AkumaHandle {
     }
     async kill() {
         const at = new Date().toISOString();
-        if (requestStop(this.paths, at) === "dead")
-            return "already-dead";
+        const request = requestStop(this.paths, at);
+        if (request.kind === "already-killed")
+            return "already-killed";
+        const target = request.body;
         const graceDeadline = performance.now() + KILL_GRACE_MS;
         while (probeLeash(this.paths) === "held" && performance.now() < graceDeadline)
             await wait(POLL_MS);
-        if (probeLeash(this.paths) === "held") {
-            const current = readHeart(this.paths).latestBody;
-            if (current === null)
-                return "unavailable";
-            const evidence = await putDownProcessTree(current.collar);
+        if (readKill(this.paths, target.sequence) !== null)
+            return "killed";
+        const targetProbe = probeProcessTree(target.collar);
+        if (targetProbe.kind === "unverifiable")
+            return "unavailable";
+        if (targetProbe.kind === "alive") {
+            const evidence = await putDownProcessTree(target.collar);
             if (evidence === "unavailable" || evidence === "alive-after-sigkill")
                 return evidence;
         }
-        const releaseDeadline = performance.now() + KILL_GRACE_MS;
-        while (probeLeash(this.paths) === "held" && performance.now() < releaseDeadline)
-            await wait(POLL_MS);
-        if (probeLeash(this.paths) === "held")
-            return "unavailable";
-        return recordDeath(this.paths, { evidence: "killed", at }) === "already-dead" ? "already-dead" : "killed";
+        const leash = await takeLeashUntil(this.paths, performance.now() + KILL_GRACE_MS);
+        if (leash === null)
+            return readKill(this.paths, target.sequence) === null ? "unavailable" : "killed";
+        try {
+            const settled = leash.settleStop(this.paths, target.sequence);
+            if (settled === null)
+                return "unavailable";
+            return "killed";
+        }
+        finally {
+            leash.release();
+        }
     }
     lastAnswer() {
         const turn = readLastAnsweredTurn(this.paths);
-        return turn?.outcome.kind === "answered" ? turn.outcome.answer : "";
+        return turn?.end?.outcome.kind === "answered"
+            ? { kind: "answer", answer: turn.end.outcome.answer }
+            : { kind: "no-answer" };
     }
 }
 export class Akuma {
     path;
-    settings;
-    constructor(path, settings) {
+    configuredSettings;
+    constructor(path, configuredSettings) {
         this.path = path;
-        this.settings = settings;
+        this.configuredSettings = configuredSettings;
     }
-    static at(input) {
-        const path = resolve(input.path);
-        return new Akuma(path, input.settings ?? readSettings({ root: path }));
+    static of(root, settings) {
+        if (typeof root !== "string")
+            throw new TypeError("Akuma.of root must be a WorldRoot");
+        return new Akuma(root, settings);
+    }
+    settings() {
+        return this.configuredSettings ?? readSettings({ root: this.path });
     }
     of(input) {
         return new AkumaHandle(parseAkuId(input.id).id, this.path);
     }
     listArchetypes() {
-        return readArchetypes({ settings: this.settings });
+        return readArchetypes({ settings: this.settings() });
     }
     async call(input) {
         const name = archetypeName(input.archetype);
-        const archetype = loadArchetype({ name, settings: this.settings });
+        const archetype = loadArchetype({ name, settings: this.settings() });
         const provider = archetype.adapter;
         const cwd = resolve(input.cwd ?? this.path);
         const recipe = Object.freeze({
@@ -342,7 +365,14 @@ export class Akuma {
         });
         return new AkumaHandle(published.id, this.path);
     }
-    list() {
+    list(input = {}) {
+        if (typeof input !== "object" || input === null || Array.isArray(input)) {
+            throw new TypeError("Akuma list input must be an object");
+        }
+        const unknown = Object.keys(input).find((key) => key !== "archetype");
+        if (unknown !== undefined)
+            throw new TypeError(`Akuma list input has unknown field: ${unknown}`);
+        const selected = input.archetype === undefined ? undefined : archetypeName(input.archetype);
         const runRoot = akumaRunRoot(this.path);
         let names;
         try {
@@ -359,6 +389,8 @@ export class Akuma {
         const rows = names.flatMap((name) => {
             try {
                 const physical = akuIdFromDirectoryName(name);
+                if (selected !== undefined && physical.archetype !== selected)
+                    return [];
                 const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
                 const snapshot = readHeart(paths);
                 if (snapshot.soul !== null)

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

@@ -8,6 +8,11 @@ type DecodedArchetype = Readonly<{
     description?: string;
     options: ProviderOptions;
 }>;
+export type ArchetypeCatalogRow = Readonly<{
+    name: string;
+    model?: string;
+    description?: string;
+}>;
 type ArchetypeDefinition = DecodedArchetype & Readonly<{
     adapter: ProviderAdapter;
 }>;
@@ -24,6 +29,9 @@ export declare class AkumaArchetypeError extends Error {
 export declare function listArchetypes(input: Readonly<{
     settings: Settings;
 }>): readonly string[];
+export declare function listArchetypeDefinitions(input: Readonly<{
+    settings: Settings;
+}>): readonly ArchetypeCatalogRow[];
 export declare function loadArchetype(input: Readonly<{
     name: string;
     settings: Settings;

package/build/src/akuma/archetype.js

@@ -21,27 +21,24 @@ function archetypeDirectory(settings) {
     const userPath = settings.scopes.user.path;
     return userPath === undefined ? null : join(dirname(userPath), "akuma");
 }
-export function listArchetypes(input) {
-    const directory = archetypeDirectory(input.settings);
+function archetypePaths(settings) {
+    const directory = archetypeDirectory(settings);
     if (directory === null)
         return [];
     try {
         return readdirSync(directory, { withFileTypes: true })
             .flatMap((entry) => {
-            if (!entry.isFile())
-                return [];
-            const filename = entry.name;
-            if (!filename.endsWith(".md"))
+            if (!entry.isFile() || !entry.name.endsWith(".md"))
                 return [];
-            const name = filename.slice(0, -3);
+            const name = entry.name.slice(0, -3);
             try {
-                return [archetypeName(name)];
+                return [{ name: archetypeName(name), path: join(directory, entry.name) }];
             }
             catch {
                 return [];
             }
         })
-            .sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
+            .sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -49,6 +46,9 @@ export function listArchetypes(input) {
         throw error;
     }
 }
+export function listArchetypes(input) {
+    return archetypePaths(input.settings).map(({ name }) => name);
+}
 function archetypeField(values, key, required = false) {
     const value = values[key];
     if (value === undefined && !required)
@@ -102,6 +102,21 @@ function decodeArchetype(name, path, markdown) {
         }),
     });
 }
+export function listArchetypeDefinitions(input) {
+    return archetypePaths(input.settings).map(({ name, path }) => {
+        try {
+            const definition = decodeArchetype(name, path, readFileSync(path, "utf8"));
+            return Object.freeze({
+                name: definition.name,
+                ...(definition.options.model === undefined ? {} : { model: definition.options.model }),
+                ...(definition.description === undefined ? {} : { description: definition.description }),
+            });
+        }
+        catch (error) {
+            throw new AkumaArchetypeError(name, [path], `is invalid: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value : null;
@@ -142,6 +157,10 @@ function providerExecution(settings, name) {
         return Object.freeze({ name, kind: "claude-agent-sdk" });
     if (name === "codex-app-server")
         return Object.freeze({ name, kind: "codex-app-server" });
+    if (name === "opencode-sdk")
+        return Object.freeze({ name, kind: "opencode-sdk" });
+    if (name === "pi")
+        return Object.freeze({ name, kind: "pi" });
     throw new TypeError(`unknown provider ${name}`);
 }
 function admitArchetype(archetype, settings) {