@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/heart/activity-schema.d.ts

@@ -0,0 +1,325 @@
+import { z } from "zod";
+declare const searchScopeSchema: z.ZodEnum<{
+    content: "content";
+    files: "files";
+    web: "web";
+}>;
+export declare const toolInputSchema: z.ZodObject<{
+    json: z.ZodString;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const diffstatSchema: z.ZodObject<{
+    added: z.ZodNumber;
+    removed: z.ZodNumber;
+}, z.core.$strip>;
+export declare const fileChangeSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        add: "add";
+        update: "update";
+        delete: "delete";
+        unspecified: "unspecified";
+    }>;
+    path: z.ZodString;
+    diffstat: z.ZodOptional<z.ZodObject<{
+        added: z.ZodNumber;
+        removed: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const toolCallSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"run">;
+    command: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"read">;
+    path: z.ZodString;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"search">;
+    query: z.ZodString;
+    scope: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        files: "files";
+        web: "web";
+    }>>;
+    path: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fileChange">;
+    changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            add: "add";
+            update: "update";
+            delete: "delete";
+            unspecified: "unspecified";
+        }>;
+        path: z.ZodString;
+        diffstat: z.ZodOptional<z.ZodObject<{
+            added: z.ZodNumber;
+            removed: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"other">;
+    display: z.ZodString;
+    input: z.ZodOptional<z.ZodObject<{
+        json: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
+export declare const toolResultSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        error: "error";
+        ok: "ok";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
+    phase: z.ZodLiteral<"started">;
+    result: z.ZodOptional<z.ZodNever>;
+    type: z.ZodLiteral<"tool">;
+    id: z.ZodString;
+    name: z.ZodString;
+    call: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+        command: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"read">;
+        path: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        scope: z.ZodOptional<z.ZodEnum<{
+            content: "content";
+            files: "files";
+            web: "web";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fileChange">;
+        changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<{
+                add: "add";
+                update: "update";
+                delete: "delete";
+                unspecified: "unspecified";
+            }>;
+            path: z.ZodString;
+            diffstat: z.ZodOptional<z.ZodObject<{
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"other">;
+        display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodObject<{
+    phase: z.ZodLiteral<"completed">;
+    result: z.ZodObject<{
+        status: z.ZodEnum<{
+            error: "error";
+            ok: "ok";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"tool">;
+    id: z.ZodString;
+    name: z.ZodString;
+    call: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+        command: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"read">;
+        path: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        scope: z.ZodOptional<z.ZodEnum<{
+            content: "content";
+            files: "files";
+            web: "web";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fileChange">;
+        changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<{
+                add: "add";
+                update: "update";
+                delete: "delete";
+                unspecified: "unspecified";
+            }>;
+            path: z.ZodString;
+            diffstat: z.ZodOptional<z.ZodObject<{
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"other">;
+        display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>]>;
+export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"session">;
+    coordinate: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+        sessionFile: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodTransform<{
+        sessionFile: string;
+        sessionId?: never;
+    } | {
+        sessionFile: string;
+        sessionId: string;
+    }, {
+        sessionFile: string;
+        sessionId?: string | undefined;
+    }>>, z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"assistant">;
+    text: z.ZodString;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"thought">;
+    text: z.ZodString;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+    phase: z.ZodLiteral<"started">;
+    result: z.ZodOptional<z.ZodNever>;
+    type: z.ZodLiteral<"tool">;
+    id: z.ZodString;
+    name: z.ZodString;
+    call: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+        command: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"read">;
+        path: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        scope: z.ZodOptional<z.ZodEnum<{
+            content: "content";
+            files: "files";
+            web: "web";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fileChange">;
+        changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<{
+                add: "add";
+                update: "update";
+                delete: "delete";
+                unspecified: "unspecified";
+            }>;
+            path: z.ZodString;
+            diffstat: z.ZodOptional<z.ZodObject<{
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"other">;
+        display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodObject<{
+    phase: z.ZodLiteral<"completed">;
+    result: z.ZodObject<{
+        status: z.ZodEnum<{
+            error: "error";
+            ok: "ok";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"tool">;
+    id: z.ZodString;
+    name: z.ZodString;
+    call: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+        command: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"read">;
+        path: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"search">;
+        query: z.ZodString;
+        scope: z.ZodOptional<z.ZodEnum<{
+            content: "content";
+            files: "files";
+            web: "web";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fileChange">;
+        changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<{
+                add: "add";
+                update: "update";
+                delete: "delete";
+                unspecified: "unspecified";
+            }>;
+            path: z.ZodString;
+            diffstat: z.ZodOptional<z.ZodObject<{
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"other">;
+        display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>]>, z.ZodObject<{
+    type: z.ZodLiteral<"note">;
+    text: z.ZodString;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"unknown">;
+    kind: z.ZodString;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>]>;
+export type SearchScope = z.infer<typeof searchScopeSchema>;
+export type ToolInput = z.infer<typeof toolInputSchema>;
+export type ToolCall = z.infer<typeof toolCallSchema>;
+export type ToolResult = z.infer<typeof toolResultSchema>;
+export type ToolEvent = z.infer<typeof toolEventSchema>;
+export type AgentEvent = z.infer<typeof agentEventSchema>;
+export declare function decodeAgentEvent(value: unknown): AgentEvent;
+export {};

package/build/src/akuma/heart/activity-schema.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { resumeCoordinateSchema } from "../coordinate.js";
+const nonnegativeInteger = z.number().int().safe().nonnegative();
+const positiveInteger = z.number().int().safe().positive();
+const text = z.string();
+const truncated = z.literal(true).optional();
+const searchScopeSchema = z.enum(["content", "files", "web"]);
+export const toolInputSchema = z.object({ json: text, truncated: z.boolean() });
+export const diffstatSchema = z.object({ added: nonnegativeInteger, removed: nonnegativeInteger });
+export const fileChangeSchema = z.object({
+    op: z.enum(["add", "update", "delete", "unspecified"]),
+    path: text,
+    diffstat: diffstatSchema.optional(),
+});
+export const toolCallSchema = z.union([
+    z.object({ kind: z.literal("run"), command: text }),
+    z.object({
+        kind: z.literal("read"),
+        path: text,
+        offset: positiveInteger.optional(),
+        limit: positiveInteger.optional(),
+    }),
+    z.object({
+        kind: z.literal("search"),
+        query: text,
+        scope: searchScopeSchema.optional(),
+        path: text.optional(),
+        glob: text.optional(),
+    }),
+    z.object({ kind: z.literal("fileChange"), changes: z.array(fileChangeSchema).readonly() }),
+    z.object({ kind: z.literal("other"), display: text, input: toolInputSchema.optional() }),
+]);
+export const toolResultSchema = z.object({
+    status: z.enum(["ok", "error"]),
+    message: text.optional(),
+    exitCode: z.number().int().safe().optional(),
+});
+const toolFields = { type: z.literal("tool"), id: text, name: text, call: toolCallSchema, truncated };
+const toolEventSchema = z.union([
+    z.object({ ...toolFields, phase: z.literal("started"), result: z.never().optional() }),
+    z.object({ ...toolFields, phase: z.literal("completed"), result: toolResultSchema }),
+]);
+export const agentEventSchema = z.union([
+    z.object({ type: z.literal("session"), coordinate: resumeCoordinateSchema }),
+    z.object({ type: z.literal("assistant"), text, truncated }),
+    z.object({ type: z.literal("thought"), text, truncated }),
+    toolEventSchema,
+    z.object({ type: z.literal("note"), text, truncated }),
+    z.object({ type: z.literal("unknown"), kind: text, truncated }),
+]);
+export function decodeAgentEvent(value) {
+    return agentEventSchema.parse(value);
+}

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

@@ -40,13 +40,8 @@ export type BodyFact = Readonly<{
     end?: BodyEnd;
     endedAt?: string;
 }>;
-export type SessionFact = Readonly<{
+export type SessionFact = import("zod").infer<typeof import("./rows.js").sessionAdmissionSchema> & Readonly<{
     sequence: number;
-    provider: string;
-    coordinate: ResumeCoordinate;
-    cwd: string;
-    options: ProviderOptions;
-    admittedAt: string;
 }>;
 export type ForkPoint = Readonly<{
     historyId: string;

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

@@ -2,6 +2,7 @@ import type { AkumaPaths } from "../identity.js";
 import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, 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 { AgentEvent } from "./activity-schema.js";
 import { type StatusFactInput, type ActivityFactSlice } from "./timeline.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";
@@ -15,7 +16,7 @@ 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<{
     turnSequence: number;
-    event: unknown;
+    event: AgentEvent;
     at: string;
 }>): Promise<number>;
 export type ActivitySlice = ActivityFactSlice;
@@ -94,6 +95,7 @@ export declare function failOpenBoundTurns(paths: AkumaPaths, input: Readonly<{
     completedAt: string;
 }>): Promise<readonly number[]>;
 export declare function readTurn(paths: AkumaPaths, sequence: number): Promise<TurnFact | null>;
+export declare function readTurnParticipants(paths: AkumaPaths, sequence: number): Promise<readonly string[]>;
 export declare function readLatestTurnForBody(paths: AkumaPaths, bodySequence: number): Promise<TurnFact | null>;
 export declare function endTurn(paths: AkumaPaths, input: Readonly<{
     turnSequence: number;

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

@@ -1,6 +1,6 @@
 import { parsePublicHistoryId } from "../identity.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, } from "./tells.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, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
@@ -264,6 +264,9 @@ export async function failOpenBoundTurns(paths, input) {
 export async function readTurn(paths, sequence) {
     return await withReadOnlyHeart(paths, (heart) => turnFact(heart, sequence));
 }
+export async function readTurnParticipants(paths, sequence) {
+    return await withReadOnlyHeart(paths, (heart) => turnParticipants(heart, sequence));
+}
 export async function readLatestTurnForBody(paths, bodySequence) {
     return await withReadOnlyHeart(paths, (heart) => latestTurnFactForBody(heart, bodySequence));
 }

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

@@ -1,5 +1,7 @@
+import { z } from "zod";
 import type { DatabaseSync } from "node:sqlite";
 import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
+import { type AgentEvent } from "./activity-schema.js";
 export type SealRow = Readonly<{
     evidence: string;
     at: string;
@@ -12,6 +14,51 @@ export type BodyRow = Readonly<{
     end: BodyEnd | null;
     ended_at: string | null;
 }>;
+export declare const sessionAdmissionSchema: z.ZodObject<{
+    provider: z.ZodString;
+    coordinate: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+        sessionFile: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodTransform<{
+        sessionFile: string;
+        sessionId?: never;
+    } | {
+        sessionFile: string;
+        sessionId: string;
+    }, {
+        sessionFile: string;
+        sessionId?: string | undefined;
+    }>>, z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strict>]>;
+    cwd: z.ZodString;
+    options: z.ZodPipe<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodString>;
+        network: z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            enabled: "enabled";
+        }>>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        systemPromptMode: z.ZodOptional<z.ZodEnum<{
+            append: "append";
+            replace: "replace";
+        }>>;
+    }, z.core.$strip>, z.ZodTransform<Readonly<{
+        systemPromptMode?: "append" | "replace";
+        systemPrompt?: string;
+        network?: "disabled" | "enabled";
+        effort?: string;
+        model?: string;
+    }>, {
+        model?: string | undefined;
+        effort?: string | undefined;
+        network?: "disabled" | "enabled" | undefined;
+        systemPrompt?: string | undefined;
+        systemPromptMode?: "append" | "replace" | undefined;
+    }>>;
+    admittedAt: z.ZodString;
+}, z.core.$strict>;
 export type SessionRow = Readonly<{
     sequence: number;
     provider: string;
@@ -51,7 +98,7 @@ export type ActivityFact = Readonly<{
     kind: "activity";
     sequence: number;
     turnSequence: number;
-    event: unknown;
+    event: AgentEvent;
     at: string;
 }>;
 export type KillRow = Readonly<{
@@ -85,7 +132,7 @@ export declare function insertBodyFact(database: DatabaseSync, input: Readonly<{
 export declare function insertSessionFact(database: DatabaseSync, input: Omit<SessionFact, "sequence">): number;
 export declare function insertActivityFact(database: DatabaseSync, input: Readonly<{
     turnSequence: number;
-    event: unknown;
+    event: AgentEvent;
     at: string;
 }>): number;
 export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;

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

@@ -1,4 +1,18 @@
+import { z } from "zod";
+import { providerOptionsSchema } from "../provider-recipe.js";
+import { resumeCoordinateSchema } from "../coordinate.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate as encodeCoordinate } from "../coordinate.js";
+import { agentEventSchema } from "./activity-schema.js";
+const sessionText = z.string().refine((value) => value.trim() !== "");
+export const sessionAdmissionSchema = z
+    .object({
+    provider: sessionText,
+    coordinate: resumeCoordinateSchema,
+    cwd: sessionText,
+    options: providerOptionsSchema,
+    admittedAt: sessionText,
+})
+    .strict();
 function json(value) {
     return JSON.stringify(value);
 }
@@ -89,14 +103,14 @@ export function decodeCallRow(row) {
     return { kind: "call", sequence: row.sequence, turnSequence: row.turn_sequence, body: row.body, at: row.at };
 }
 export function encodeActivityEvent(event) {
-    return json(event);
+    return json(agentEventSchema.parse(event));
 }
 export function decodeActivityRow(row) {
     return {
         kind: "activity",
         sequence: row.sequence,
         turnSequence: row.turn_sequence,
-        event: parsed(row.event_json),
+        event: agentEventSchema.parse(parsed(row.event_json)),
         at: row.at,
     };
 }

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

@@ -1,5 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 import type { Soul, 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;
 export declare function encodeSoulRow(soul: Soul): readonly [string];

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

@@ -43,7 +43,7 @@ function decodeOrigin(value) {
     }
     throw new Error("Akuma soul origin must be direct, request, or fork");
 }
-function validateSoul(value) {
+export function decodeSoulSeed(value) {
     const soul = record(value);
     if (soul === null)
         throw new Error("Akuma soul must be an object");
@@ -64,7 +64,6 @@ function validateSoul(value) {
         cwd: nonblank(soul.cwd, "cwd"),
         origin: decodeOrigin(soul.origin),
         allowed: historicalAllowedActions(soul.allowed),
-        createdAt: nonblank(soul.createdAt, "createdAt"),
     };
 }
 function deepFreeze(value) {
@@ -77,10 +76,13 @@ function deepFreeze(value) {
     return value;
 }
 export function decodeSoul(value) {
-    return deepFreeze(validateSoul(value));
+    const soul = record(value);
+    if (soul === null)
+        throw new Error("Akuma soul must be an object");
+    return deepFreeze({ ...decodeSoulSeed(soul), createdAt: nonblank(soul.createdAt, "createdAt") });
 }
 export function encodeSoul(soul) {
-    return JSON.stringify(validateSoul(soul));
+    return JSON.stringify(decodeSoul(soul));
 }
 export function encodeSoulRow(soul) {
     return [encodeSoul(soul)];

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

@@ -27,5 +27,6 @@ export declare function insertTellBindingFact(database: DatabaseSync, input: Rea
     turnSequence: number;
     boundAt: string;
 }>): void;
+export declare function turnParticipants(database: DatabaseSync, turnSequence: number): readonly string[];
 export declare function drainPendingTells(pending: readonly TellFact[], activeTurnSequences?: readonly number[]): readonly TellFact[];
 export declare function openBoundTurns(database: DatabaseSync, bodySequence: number): readonly number[];

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

@@ -204,6 +204,24 @@ export function insertTellBindingFact(database, input) {
             throw new Error(`tell ${input.tellId} binding was not retained`);
     }
 }
+export function turnParticipants(database, turnSequence) {
+    const rows = database
+        .prepare(`SELECT turns.initiator AS owner, tells.initiator AS teller
+       FROM turns
+       LEFT JOIN tell_bindings ON tell_bindings.turn_sequence = turns.sequence
+       LEFT JOIN tells ON tells.id = tell_bindings.tell_id
+       WHERE turns.sequence = ?
+       ORDER BY tell_bindings.sequence`)
+        .all(turnSequence);
+    const participants = new Set();
+    for (const row of rows) {
+        if (row.owner)
+            participants.add(row.owner);
+        if (row.teller)
+            participants.add(row.teller);
+    }
+    return [...participants];
+}
 export function drainPendingTells(pending, activeTurnSequences = []) {
     const eligible = pending.filter((tell) => tell.binding === undefined || !activeTurnSequences.includes(tell.binding.turnSequence));
     if (eligible.length === 0)

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

@@ -1,15 +1,17 @@
+import { z } from "zod";
 declare const AKU_ID: unique symbol;
 export type AkuId = string & {
     readonly [AKU_ID]: true;
 };
 export declare function parsePublicHistoryId(value: string): number | null;
-export type AkumaPaths = Readonly<{
-    directory: string;
-    heart: string;
-    leash: string;
-    log: string;
-    requests: string;
-}>;
+export declare const akumaPathsSchema: z.ZodObject<{
+    directory: z.ZodString;
+    heart: z.ZodString;
+    leash: z.ZodString;
+    log: z.ZodString;
+    requests: z.ZodString;
+}, z.core.$strict>;
+export type AkumaPaths = z.infer<typeof akumaPathsSchema>;
 export type AllocatedAkuma = Readonly<{
     id: AkuId;
     archetype: string;
@@ -26,6 +28,7 @@ export declare function parseAkuId(value: string): Readonly<{
     archetype: string;
     suffix: string;
 }>;
+export declare const akumaIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
 export declare function akumaRunRoot(worldRoot: string): string;
 export declare function akumaPaths(input: Readonly<{
     runRoot: string;