@astrosheep/keiyaku 4.0.0 → 4.0.2

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,29 +1,18 @@
 import type { AkuId } from "../identity.js";
+import type { ResumeCoordinate } from "../coordinate.js";
+import type { ProviderExecution, ProviderOptions, ReadonlyRestraint } from "../provider-recipe.js";
+export type { ResumeCoordinate } from "../coordinate.js";
 export type Confinement = Readonly<{
     kind: "unconfined";
 }> | Readonly<{
     kind: "declared";
     writableRoots: readonly string[];
 }>;
-export type ProviderOptions = Readonly<{
-    model?: string;
-    effort?: string;
-    access?: "read" | "write" | "auto";
-    network?: "disabled" | "enabled";
-    systemPrompt?: string;
-}>;
-export type ProviderExecution = Readonly<{
-    name: string;
-    kind: "claude-agent-sdk" | "codex-app-server";
-    executable?: string;
-    config?: Readonly<Record<string, unknown>>;
-    env?: Readonly<Record<string, string>>;
-}>;
 export type AkumaOrigin = Readonly<{
     kind: "direct";
 }> | Readonly<{
     kind: "request";
-    parentId: AkuId;
+    parent: AkuId;
     requestId: string;
 }> | Readonly<{
     kind: "fork";
@@ -36,28 +25,24 @@ export type Soul = Readonly<{
     description?: string;
     provider: ProviderExecution;
     options: ProviderOptions;
+    readonly?: ReadonlyRestraint;
     cwd: string;
     origin: AkumaOrigin;
     confinement: Confinement;
     createdAt: string;
 }>;
-export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "confinement">;
-export type Collar = Readonly<{
-    pid: number;
-    processGroup: number;
-    spawnedAt: string;
-}>;
+export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "confinement">;
 export type BodyEnd = "exited" | "broke-off" | "put-down";
 export type BodyFact = Readonly<{
     sequence: number;
-    collar: Collar;
     leashTakenAt: string;
+    hung?: Readonly<{
+        diagnostic: string;
+        at: string;
+    }>;
     end?: BodyEnd;
     endedAt?: string;
 }>;
-export type ResumeCoordinate = Readonly<{
-    sessionId: string;
-}>;
 export type SessionFact = Readonly<{
     sequence: number;
     provider: string;
@@ -75,26 +60,73 @@ export type ForkPoint = Readonly<{
 }>;
 export type TurnOutcome = Readonly<{
     kind: "answered";
-    historyId: string;
+    historyId?: string;
     session: ResumeCoordinate;
     answer: string;
 }> | 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,31 +152,42 @@ 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" | "already-stopped" | "hung" | "untidy" | "unavailable";
+export type KillFact = Readonly<{
+    sequence: number;
+    bodySequence: number;
+    evidence: "killed";
     at: string;
 }>;
+export type StopFact = Readonly<{
+    bodySequence: number;
+    requestedAt: string;
+}>;
+export type PauseFact = Readonly<{
+    bodySequence: number;
+    requestedAt: string;
+}>;
 export type SealFact = Readonly<{
     evidence: string;
     at: string;
 }>;
 export type LeashProbe = "held" | "free";
-export type CollarProbe = Readonly<{
-    kind: "gone";
-    end: BodyEnd | null;
-}> | Readonly<{
-    kind: "alive";
-}> | Readonly<{
-    kind: "unverifiable";
-    diagnostic: string;
-}>;
-export type AkumaLife = "running" | "asleep" | "stranded" | "headless" | "dead";
+export type AkumaLife = "running" | "asleep" | "stranded" | "hung" | "untidy" | "killed";
 export type HeartSnapshot = Readonly<{
     soul: Soul | null;
     latestBody: BodyFact | null;
     latestSession: SessionFact | null;
     pending: readonly TellFact[];
-    death: DeathFact | null;
+    latestKill: KillFact | null;
+    stop: StopFact | null;
+    pause: PauseFact | null;
+}>;
+export declare function life(input: Readonly<{
+    leash: LeashProbe;
+    body: BodyFact | null;
+    kill: KillFact | null;
+}>): AkumaLife;
+export declare function lifeAt(current: AkumaLife, body: BodyFact | null, kill: KillFact | null, createdAt: string): string | null;
+export type SoulRow = Readonly<{
+    soul_json: string;
 }>;
-export declare function life(leashProbe: LeashProbe, collarProbe: CollarProbe, deathRow: DeathFact | null): AkumaLife;

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

@@ -1,9 +1,20 @@
-export function life(leashProbe, collarProbe, deathRow) {
-    if (deathRow !== null)
-        return "dead";
-    if (leashProbe === "held")
-        return "running";
-    if (collarProbe.kind !== "gone")
-        return "headless";
-    return collarProbe.end === "exited" ? "asleep" : "stranded";
+export function life(input) {
+    if (input.leash === "held")
+        return input.body?.hung === undefined ? "running" : "hung";
+    if (input.body === null || input.body.end === undefined)
+        return "untidy";
+    if (input.kill?.bodySequence === input.body.sequence)
+        return "killed";
+    return input.body.end === "exited" ? "asleep" : "stranded";
+}
+export function lifeAt(current, body, kill, createdAt) {
+    if (current === "running")
+        return body?.leashTakenAt ?? null;
+    if (current === "hung")
+        return body?.hung?.at ?? null;
+    if (current === "killed")
+        return kill?.at ?? null;
+    if (current === "asleep")
+        return body?.endedAt ?? createdAt;
+    return current === "stranded" ? body?.endedAt ?? null : null;
 }

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

@@ -1,36 +1,21 @@
 import type { AkuId, AkumaPaths } from "../identity.js";
-import type { BodyEnd, BodyFact, Collar, DeathFact, ForkPoint, HeartSnapshot, LeashProbe, RequestFact, RequestInput, SealFact, SessionFact, Soul, TellFact, TellState, TurnFact } from "./facts.js";
-import type { ActivityFact, ActivityFactSlice } from "./rows.js";
-export { life } from "./facts.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Collar, CollarProbe, Confinement, DeathFact, HeartSnapshot, ForkPoint, KillEvidence, LeashProbe, ProviderOptions, ProviderExecution, RequestFact, RequestInput, RequestRecipe, ResumeCoordinate, SealFact, SessionFact, Soul, TellFact, TellState, TurnFact, TurnOutcome, } from "./facts.js";
-export declare function initializeHeart(paths: AkumaPaths): void;
-export declare class HeldAkumaLeash {
-    private readonly database;
-    private closed;
-    private constructor();
-    static try(paths: AkumaPaths): HeldAkumaLeash | null;
-    birth(paths: AkumaPaths, soul: Soul, session?: Omit<SessionFact, "sequence">): "born" | "already-born" | "sealed";
-    sealIfUnborn(paths: AkumaPaths, input: Readonly<{
-        evidence: string;
-        at: string;
-    }>): "born" | "sealed";
-    clearPause(paths: AkumaPaths): void;
-    release(): void;
-}
-export declare function probeLeash(paths: AkumaPaths): LeashProbe;
-export declare function readSoul(paths: AkumaPaths): Soul | null;
-export declare function heartExists(paths: AkumaPaths): boolean;
-export declare function readSeal(paths: AkumaPaths): SealFact | null;
-export declare function recordBody(paths: AkumaPaths, input: Readonly<{
-    collar: Collar;
-    leashTakenAt: string;
-}>): BodyFact;
-export declare function recordSession(paths: AkumaPaths, input: Omit<SessionFact, "sequence">): SessionFact;
+import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, 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 { 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 { ResumeCoordinate } from "../coordinate.js";
+export declare function readSoul(paths: AkumaPaths): Promise<Soul | null>;
+export declare function heartExists(paths: AkumaPaths): Promise<boolean>;
+export declare function readSeal(paths: AkumaPaths): Promise<SealFact | null>;
+export declare function recordSession(paths: AkumaPaths, input: Omit<SessionFact, "sequence">): Promise<SessionFact>;
 export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
-    bodySequence: number;
+    turnSequence: number;
     event: unknown;
     at: string;
-}>): number;
+}>): Promise<number>;
 export type ActivitySliceInput = Readonly<{
     before?: number;
     since?: number;
@@ -38,41 +23,65 @@ export type ActivitySliceInput = Readonly<{
 }>;
 export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
-export declare function activitySlice(paths: AkumaPaths, input?: ActivitySliceInput): ActivitySlice;
-export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "state">): "recorded" | "dead";
-export declare function advanceTell(paths: AkumaPaths, id: string, state: Exclude<TellState, "recorded" | "voided-by-death">): void;
+export type { TimelineFact } from "./timeline.js";
+export declare function activitySlice(paths: AkumaPaths, input?: ActivitySliceInput): Promise<ActivitySlice>;
+export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Promise<Readonly<{
+    kind: "not-born";
+} | {
+    kind: "recorded";
+    tell: TellFact;
+}>>;
+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;
-}>): RequestFact;
-export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
-export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
-export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): RequestFact;
-export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): RequestFact;
-export declare function readRequest(paths: AkumaPaths, id: string): RequestFact | null;
-export declare function readNonterminalRequests(paths: AkumaPaths): readonly RequestFact[];
-export declare function requestStop(paths: AkumaPaths, at: string): "requested" | "dead";
-export declare function requestPause(paths: AkumaPaths, at: string): "requested" | "dead";
-export declare function stopRequested(paths: AkumaPaths): boolean;
-export declare function pauseRequested(paths: AkumaPaths): boolean;
-export declare function clearAbandonedControl(paths: AkumaPaths): void;
-export declare function recordDeath(paths: AkumaPaths, death: DeathFact): "recorded" | "already-dead";
+}>): 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";
+    body: BodyFact;
+}> | Readonly<{
+    kind: "already-killed" | "already-stopped";
+    body: BodyFact;
+}>>;
+export declare function requestPause(paths: AkumaPaths, at: string): Promise<Readonly<{
+    kind: "not-born";
+} | {
+    kind: "requested";
+    body: BodyFact;
+}>>;
+export declare function stopRequested(paths: AkumaPaths, bodySequence?: number): Promise<boolean>;
+export declare function pauseRequested(paths: AkumaPaths, bodySequence?: number): Promise<boolean>;
 export declare function breakBody(paths: AkumaPaths, input: Readonly<{
     sequence: number;
     end: Exclude<BodyEnd, "exited">;
     at: string;
-}>): void;
-export declare function recordTurn(paths: AkumaPaths, input: Omit<TurnFact, "sequence">): TurnFact;
+}>): Promise<void>;
+export declare function beginTurn(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    startedAt: string;
+    call?: string;
+}>): Promise<TurnStartFact>;
+export declare function endTurn(paths: AkumaPaths, input: Readonly<{
+    turnSequence: number;
+    outcome: TurnOutcome;
+    completedAt: string;
+}>): Promise<TurnEndFact>;
 export declare function finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
     sequence: number;
     at: string;
-}>): Readonly<{
-    kind: "finished";
+}>): Promise<Readonly<{
+    kind: "controlled" | "finished";
 } | {
     kind: "pending";
     tells: readonly string[];
-}>;
-export declare function readHeart(paths: AkumaPaths): HeartSnapshot;
-export declare function readTurns(paths: AkumaPaths): readonly TurnFact[];
-export declare function readLastAnsweredTurn(paths: AkumaPaths): TurnFact | null;
-export declare function readCurrentTurn(paths: AkumaPaths): TurnFact | null;
-export declare function readForkPoint(paths: AkumaPaths, historyId: string): ForkPoint | null;
+}>>;
+export declare function readHeart(paths: AkumaPaths): Promise<HeartSnapshot>;
+export declare function readLastAnsweredTurn(paths: AkumaPaths): Promise<TurnFact | null>;
+export declare function readForkPoint(paths: AkumaPaths, historyId: string): Promise<ForkPoint | null>;