@astrosheep/keiyaku 4.0.0 → 4.0.1

package/build/src/akuma/body.js

@@ -1,13 +1,28 @@
 import { fileURLToPath } from "node:url";
-import { HeldAkumaLeash, advanceTell, appendActivity, breakBody, clearAbandonedControl, finishBodyIfIdle, heartExists, pauseRequested, readHeart, recordBody, recordSession, recordTurn, stopRequested, } from "./heart/index.js";
+import { HeldAkumaLeash, appendActivity, beginTurn, breakBody, endTurn, finishBodyIfIdle, heartExists, pauseRequested, readHeart, recordBody, recordSession, recordTellDeliveries, recordTellReceipt, stopRequested, } from "./heart/index.js";
 import { encodeAgentEvent } from "./provider.js";
 import { providerNamed } from "./providers/index.js";
-import { BodyRequestPump, settleBodyRequests, } from "./requests.js";
+import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./requests.js";
 import { currentProcessCollar, probeProcessTree, putDownProcessTree, spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 25;
 function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
+function serializeEffects() {
+    let tail = Promise.resolve();
+    return async (effect) => {
+        const before = tail;
+        let release;
+        tail = new Promise((resolve) => { release = resolve; });
+        await before;
+        try {
+            return await effect();
+        }
+        finally {
+            release();
+        }
+    };
+}
 function missing(error) {
     return error.code === "ENOENT";
 }
@@ -50,6 +65,13 @@ async function settlePredecessor(paths) {
 }
 async function startTurnDrive(input) {
     const { cwd, options, session } = turnRecipe(input.paths, input.soul);
+    if (session !== undefined && input.adapter.resume === undefined)
+        return { kind: "resume-unsupported" };
+    const turn = beginTurn(input.paths, {
+        bodySequence: input.bodySequence,
+        startedAt: input.now(),
+        ...(input.call === undefined ? {} : { call: input.call }),
+    });
     const requests = input.soul.confinement.kind === "declared"
         ? new BodyRequestPump({
             paths: input.paths,
@@ -60,94 +82,181 @@ async function startTurnDrive(input) {
         })
         : null;
     try {
-        const drive = await input.adapter.start({
-            prompt: input.prompt,
+        const driveInput = {
+            body: input.body,
+            launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
             cwd,
             options,
-            ...(session === undefined ? {} : { session }),
             ...(requests === null ? {} : { requests: { dir: requests.directory } }),
-        });
+        };
+        const selected = session === undefined
+            ? await input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
+            : await input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
+        if (input.launchTells.length > 0) {
+            recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
+                tellId: tell.id,
+                route: "launch",
+                turnSequence: turn.sequence,
+                fence: selected.admission.fence,
+                deliveredAt: input.now(),
+            })));
+        }
         if (requests !== null)
-            void drive.completion.then(() => requests.stopAdmission());
-        return { drive, requests, cwd, options, ...(session === undefined ? {} : { session }) };
+            void selected.completion.then(() => requests.stopAdmission());
+        return { turnSequence: turn.sequence, drive: selected, requests, cwd, options,
+            ...(session === undefined ? {} : { resume: session }) };
     }
     catch (error) {
         if (requests !== null)
             await requests.close();
-        throw error;
+        const diagnostic = error instanceof Error ? error.message : String(error);
+        endTurn(input.paths, {
+            turnSequence: turn.sequence,
+            outcome: { kind: "failed", diagnostic },
+            completedAt: input.now(),
+        });
+        return { kind: "start-failed", turnSequence: turn.sequence, diagnostic };
     }
 }
+function pumpReceipts(input, turnSequence, drive, writeWitness) {
+    return (async () => {
+        if (drive.receipts === undefined)
+            return;
+        for await (const receipt of drive.receipts) {
+            await writeWitness(() => recordTellReceipt(input.paths, receipt.evidence === "exact"
+                ? { ...receipt, receivedAt: input.now() }
+                : { ...receipt, turnSequence, receivedAt: input.now() }));
+        }
+    })();
+}
+async function submitPendingLiveTells(input, turnSequence, drive, attempted, writeWitness) {
+    if (drive.tell === undefined)
+        return "live";
+    for (const tell of readHeart(input.paths).pending) {
+        if (attempted.has(tell.id))
+            continue;
+        attempted.add(tell.id);
+        const outcome = await writeWitness(async () => {
+            const submission = await drive.tell({ id: tell.id, text: tell.body });
+            if (submission.kind === "turn-ended")
+                return "turn-ended";
+            recordTellDeliveries(input.paths, [{
+                    tellId: tell.id,
+                    route: "live",
+                    turnSequence,
+                    fence: submission.fence,
+                    receipt: drive.receipts === undefined ? "unavailable" : "required",
+                    deliveredAt: input.now(),
+                }]);
+            return "accepted";
+        });
+        if (outcome === "turn-ended")
+            return "turn-ended";
+    }
+    return "live";
+}
 async function consumeTurnDrive(input, active) {
-    const { drive, requests, cwd, options, session } = active;
-    let turnSession = session;
-    let entered = false;
+    const { turnSequence, drive, requests, cwd, options, resume } = active;
+    let turnSession = resume;
+    const attempted = new Set(input.launchTells.map((tell) => tell.id));
+    const writeWitness = serializeEffects();
+    const receiptPump = pumpReceipts(input, turnSequence, drive, writeWitness);
+    const receiptFailure = receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
     const iterator = drive.events[Symbol.asyncIterator]();
     let pending = iterator.next();
-    for (;;) {
-        if (stopRequested(input.paths) || pauseRequested(input.paths)) {
-            const draining = requests?.close();
-            try {
-                await drive.abort();
+    let liveTells = true;
+    try {
+        for (;;) {
+            if (stopRequested(input.paths, input.bodySequence) || pauseRequested(input.paths)) {
+                const draining = requests?.close();
+                try {
+                    await drive.abort();
+                }
+                finally {
+                    await draining;
+                    await receiptPump;
+                }
+                return { kind: "stopped" };
             }
-            finally {
-                await draining;
+            if (liveTells) {
+                liveTells = await submitPendingLiveTells(input, turnSequence, drive, attempted, writeWitness) === "live";
             }
-            return { kind: "stopped" };
-        }
-        const next = await Promise.race([
-            pending,
-            wait(LEASH_RETRY_MS).then(() => null),
-            ...(requests === null ? [] : [requests.failure]),
-        ]);
-        if (next === null)
-            continue;
-        if (next.done)
-            break;
-        const event = next.value;
-        const at = input.now();
-        if (event.type === "session") {
-            turnSession = event.coordinate;
-            recordSession(input.paths, {
-                provider: input.soul.provider.name,
-                coordinate: event.coordinate,
-                cwd,
-                options,
-                admittedAt: at,
+            const next = await Promise.race([
+                pending,
+                wait(LEASH_RETRY_MS).then(() => null),
+                receiptFailure,
+                ...(requests === null ? [] : [requests.failure]),
+            ]);
+            if (next === null)
+                continue;
+            if (next.done)
+                break;
+            const event = next.value;
+            const at = input.now();
+            if (event.type === "session") {
+                turnSession = event.coordinate;
+                recordSession(input.paths, {
+                    provider: input.soul.provider.name,
+                    coordinate: event.coordinate,
+                    cwd,
+                    options,
+                    admittedAt: at,
+                });
+            }
+            appendActivity(input.paths, {
+                turnSequence,
+                event: encodeAgentEvent(event),
+                at,
             });
+            pending = iterator.next();
         }
-        appendActivity(input.paths, {
-            bodySequence: input.bodySequence,
-            event: encodeAgentEvent(event),
-            at,
-        });
-        if (!entered && input.tellId !== undefined) {
-            entered = true;
-            advanceTell(input.paths, input.tellId, "seen");
-            advanceTell(input.paths, input.tellId, "consumed");
-        }
-        pending = iterator.next();
+        const result = await drive.completion;
+        await receiptPump;
+        if (requests !== null)
+            await requests.close();
+        return result.kind === "answered"
+            ? { ...result, ...(turnSession === undefined ? {} : { session: turnSession }) }
+            : result;
     }
-    const result = await drive.completion;
-    if (requests !== null)
-        await requests.close();
-    if (!entered && result.kind === "answered" && input.tellId !== undefined) {
-        advanceTell(input.paths, input.tellId, "seen");
-        advanceTell(input.paths, input.tellId, "consumed");
+    catch (error) {
+        const draining = requests?.close();
+        try {
+            await drive.abort();
+        }
+        catch { /* the pump failure owns the turn result */ }
+        try {
+            await receiptPump;
+        }
+        catch { /* preserve the first pump failure */ }
+        try {
+            await draining;
+        }
+        catch { /* preserve the first pump failure */ }
+        return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
     }
-    return result.kind === "answered"
-        ? { ...result, ...(turnSession === undefined ? {} : { session: turnSession }) }
-        : result;
 }
 async function driveTurn(input) {
-    const active = await startTurnDrive(input);
+    let active;
+    try {
+        const started = await startTurnDrive(input);
+        if ("kind" in started)
+            return started;
+        active = started;
+    }
+    catch (error) {
+        if (!heartExists(input.paths))
+            return { kind: "heart-gone" };
+        throw error;
+    }
     try {
-        return await consumeTurnDrive(input, active);
+        return { ...await consumeTurnDrive(input, active), turnSequence: active.turnSequence };
     }
     catch (error) {
         const draining = active.requests?.close();
         if (heartExists(input.paths)) {
             await draining;
-            throw error;
+            return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error),
+                turnSequence: active.turnSequence };
         }
         try {
             await active.drive.abort();
@@ -162,10 +271,8 @@ async function driveTurn(input) {
 }
 function bornSoul(launch, leash, now) {
     const before = readHeart(launch.paths);
-    if (before.death !== null)
-        return null;
     if (before.soul !== null) {
-        clearAbandonedControl(launch.paths);
+        leash.clearPause(launch.paths);
         return before.soul;
     }
     if (launch.seed === undefined)
@@ -190,9 +297,9 @@ function launchCwd(launch) {
         ? snapshot.latestSession.cwd
         : soul.cwd;
 }
-function persistTurn(paths, bodySequence, result, completedAt) {
-    recordTurn(paths, {
-        bodySequence,
+function persistTurn(paths, turnSequence, result, completedAt) {
+    endTurn(paths, {
+        turnSequence,
         outcome: result.kind === "answered" && result.session !== undefined
             ? { kind: "answered", historyId: result.historyId, session: result.session, answer: result.answer }
             : result.kind === "answered"
@@ -213,11 +320,14 @@ function defaultRuntime() {
 function childSpawner(runtime) {
     return runtime.spawnChild ?? spawnAkumaBody;
 }
-async function beginBody(paths, soul, runtime) {
+async function beginBody(paths, soul, leash, runtime) {
     if (!await settlePredecessor(paths))
         return null;
+    leash.settleStop(paths);
     const body = recordBody(paths, { collar: runtime.collar, leashTakenAt: runtime.now() });
-    if (await settleBodyRequests(paths, soul, runtime.now) === "settled")
+    const requests = await settleBodyRequests(paths, soul, runtime.now);
+    clearBodyRequestTransport(paths);
+    if (requests === "settled")
         return body;
     breakBody(paths, { sequence: body.sequence, end: "broke-off", at: runtime.now() });
     return null;
@@ -231,34 +341,28 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
         if (soul === null)
             return;
         const selected = adapter ?? providerNamed(soul.provider);
-        const body = await beginBody(launch.paths, soul, runtime);
+        const body = await beginBody(launch.paths, soul, leash, runtime);
         if (body === null)
             return;
         let initial = launch.initialBody;
         for (;;) {
             const snapshot = readHeart(launch.paths);
-            if (snapshot.death !== null) {
-                breakBody(launch.paths, { sequence: body.sequence, end: "put-down", at: runtime.now() });
-                return;
-            }
-            const tell = initial === undefined ? snapshot.pending[0] : undefined;
-            const prompt = initial ?? tell?.body;
-            if (prompt === undefined) {
+            const launchTells = snapshot.pending;
+            if (initial === undefined && launchTells.length === 0) {
                 const finished = finishBodyIfIdle(launch.paths, { sequence: body.sequence, at: runtime.now() });
                 if (finished.kind === "finished")
                     return;
                 continue;
             }
-            if (tell !== undefined)
-                advanceTell(launch.paths, tell.id, "delivered");
             const result = await driveTurn({
                 paths: launch.paths,
                 soul,
                 adapter: selected,
                 bodySequence: body.sequence,
                 runtimeSpawn: childSpawner(runtime),
-                prompt,
-                ...(tell === undefined ? {} : { tellId: tell.id }),
+                body: initial ?? "",
+                ...(initial === undefined ? {} : { call: initial }),
+                launchTells,
                 now: runtime.now,
             });
             if (result.kind === "heart-gone") {
@@ -269,7 +373,15 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
                 breakBody(launch.paths, { sequence: body.sequence, end: "put-down", at: runtime.now() });
                 return;
             }
-            if (persistTurn(launch.paths, body.sequence, result, runtime.now()) === "failed") {
+            if (result.kind === "resume-unsupported") {
+                breakBody(launch.paths, { sequence: body.sequence, end: "broke-off", at: runtime.now() });
+                return;
+            }
+            if (result.kind === "start-failed") {
+                breakBody(launch.paths, { sequence: body.sequence, end: "broke-off", at: runtime.now() });
+                return;
+            }
+            if (persistTurn(launch.paths, result.turnSequence, result, runtime.now()) === "failed") {
                 breakBody(launch.paths, { sequence: body.sequence, end: "broke-off", at: runtime.now() });
                 return;
             }

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

@@ -0,0 +1,9 @@
+export type ResumeCoordinate = Readonly<{
+    sessionId: string;
+    sessionFile?: never;
+}> | Readonly<{
+    sessionFile: string;
+    sessionId?: string;
+}>;
+export declare function decodeResumeCoordinate(value: unknown): ResumeCoordinate | null;
+export declare function encodeResumeCoordinate(coordinate: ResumeCoordinate): unknown;

package/build/src/akuma/coordinate.js

@@ -0,0 +1,22 @@
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : null;
+}
+export function decodeResumeCoordinate(value) {
+    const coordinate = record(value);
+    if (coordinate === null)
+        return null;
+    const keys = Object.keys(coordinate);
+    if (typeof coordinate.sessionFile === "string" && coordinate.sessionFile.trim().length > 0
+        && (coordinate.sessionId === undefined || (typeof coordinate.sessionId === "string" && coordinate.sessionId.trim().length > 0))
+        && keys.every((key) => key === "sessionFile" || key === "sessionId")) {
+        return { sessionFile: coordinate.sessionFile, ...(coordinate.sessionId === undefined ? {} : { sessionId: coordinate.sessionId }) };
+    }
+    return typeof coordinate.sessionId === "string" && coordinate.sessionId.trim().length > 0 && keys.length === 1
+        ? { sessionId: coordinate.sessionId } : null;
+}
+export function encodeResumeCoordinate(coordinate) {
+    return "sessionFile" in coordinate
+        ? { sessionFile: coordinate.sessionFile, ...(coordinate.sessionId === undefined ? {} : { sessionId: coordinate.sessionId }) }
+        : { sessionId: coordinate.sessionId };
+}

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

@@ -1,4 +1,6 @@
 import type { AkuId } from "../identity.js";
+import type { ResumeCoordinate } from "../coordinate.js";
+export type { ResumeCoordinate } from "../coordinate.js";
 export type Confinement = Readonly<{
     kind: "unconfined";
 }> | Readonly<{
@@ -14,7 +16,7 @@ export type ProviderOptions = Readonly<{
 }>;
 export type ProviderExecution = Readonly<{
     name: string;
-    kind: "claude-agent-sdk" | "codex-app-server";
+    kind: "claude-agent-sdk" | "codex-app-server" | "opencode-sdk" | "pi";
     executable?: string;
     config?: Readonly<Record<string, unknown>>;
     env?: Readonly<Record<string, string>>;
@@ -23,7 +25,7 @@ export type AkumaOrigin = Readonly<{
     kind: "direct";
 }> | Readonly<{
     kind: "request";
-    parentId: AkuId;
+    parent: AkuId;
     requestId: string;
 }> | Readonly<{
     kind: "fork";
@@ -55,9 +57,6 @@ export type BodyFact = Readonly<{
     end?: BodyEnd;
     endedAt?: string;
 }>;
-export type ResumeCoordinate = Readonly<{
-    sessionId: string;
-}>;
 export type SessionFact = Readonly<{
     sequence: number;
     provider: string;
@@ -82,19 +81,66 @@ export type TurnOutcome = Readonly<{
     kind: "failed";
     diagnostic: string;
 }>;
-export type TurnFact = Readonly<{
+export type TurnStartFact = Readonly<{
+    kind: "turn-start";
     sequence: number;
     bodySequence: number;
+    startedAt: string;
+}>;
+export type TurnEndFact = Readonly<{
+    kind: "turn-end";
+    sequence: number;
+    turnSequence: number;
     outcome: TurnOutcome;
     completedAt: string;
 }>;
-export type TellState = "recorded" | "delivered" | "seen" | "consumed" | "voided-by-death";
+export type TurnFact = TurnStartFact & Readonly<{
+    end?: TurnEndFact;
+}>;
+export type CallFact = Readonly<{
+    kind: "call";
+    sequence: number;
+    turnSequence: number;
+    body: string;
+    at: string;
+}>;
+export type TellDelivery = Readonly<{
+    turnSequence: number;
+    route: "launch" | "live";
+    receipt?: "unavailable" | "required";
+    deliveredAt: string;
+}>;
 export type TellFact = Readonly<{
+    kind: "tell";
+    sequence: number;
     id: string;
     body: string;
-    state: TellState;
     recordedAt: string;
-}>;
+    state: "pending" | "told";
+    deliveries: readonly TellDelivery[];
+}>;
+export type TellDeliveryInput = Readonly<{
+    tellId: string;
+    turnSequence: number;
+    fence: string;
+    deliveredAt: string;
+}> & (Readonly<{
+    route: "launch";
+}> | Readonly<{
+    route: "live";
+    receipt: "unavailable" | "required";
+}>);
+export type TellReceiptInput = Readonly<{
+    kind: string;
+    receivedAt: string;
+}> & (Readonly<{
+    evidence: "exact";
+    tellId: string;
+}> | Readonly<{
+    evidence: "fence";
+    turnSequence: number;
+    fence: string;
+}>);
 export type RequestInput = Readonly<{
     id: string;
     archetype: string;
@@ -120,11 +166,17 @@ export type RequestFact = RequestInput & Readonly<{
     state: "voided";
     evidence: string;
 }>);
-export type KillEvidence = "killed" | "already-dead" | "alive-after-sigkill" | "unavailable";
-export type DeathFact = Readonly<{
-    evidence: KillEvidence;
+export type KillEvidence = "killed" | "already-killed" | "alive-after-sigkill" | "unavailable";
+export type KillFact = Readonly<{
+    sequence: number;
+    bodySequence: number;
+    evidence: "killed";
     at: string;
 }>;
+export type StopFact = Readonly<{
+    bodySequence: number;
+    requestedAt: string;
+}>;
 export type SealFact = Readonly<{
     evidence: string;
     at: string;
@@ -139,12 +191,12 @@ export type CollarProbe = Readonly<{
     kind: "unverifiable";
     diagnostic: string;
 }>;
-export type AkumaLife = "running" | "asleep" | "stranded" | "headless" | "dead";
+export type AkumaLife = "running" | "asleep" | "stranded" | "headless" | "killed";
 export type HeartSnapshot = Readonly<{
     soul: Soul | null;
     latestBody: BodyFact | null;
     latestSession: SessionFact | null;
     pending: readonly TellFact[];
-    death: DeathFact | null;
+    latestKill: KillFact | null;
 }>;
-export declare function life(leashProbe: LeashProbe, collarProbe: CollarProbe, deathRow: DeathFact | null): AkumaLife;
+export declare function life(leashProbe: LeashProbe, collarProbe: CollarProbe, latestBody: BodyFact | null, latestKill: KillFact | null): AkumaLife;

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

@@ -1,9 +1,9 @@
-export function life(leashProbe, collarProbe, deathRow) {
-    if (deathRow !== null)
-        return "dead";
+export function life(leashProbe, collarProbe, latestBody, latestKill) {
     if (leashProbe === "held")
         return "running";
     if (collarProbe.kind !== "gone")
         return "headless";
+    if (latestBody !== null && latestKill?.bodySequence === latestBody.sequence)
+        return "killed";
     return collarProbe.end === "exited" ? "asleep" : "stranded";
 }