@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/akuma/call-request.d.ts

@@ -8,23 +8,18 @@ import type { WorldRoot } from "../world.js";
 declare const akumaCallRecipeSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
-        "task.add": "task.add";
-        "task.addDocument": "task.addDocument";
-        "task.compose": "task.compose";
-        "task.done": "task.done";
-        "task.drop": "task.drop";
-        "task.hold": "task.hold";
-        "task.resume": "task.resume";
-        "task.start": "task.start";
-        "task.stop": "task.stop";
-        "task.update": "task.update";
+        "debt.add": "debt.add";
+        "debt.addDocument": "debt.addDocument";
+        "debt.done": "debt.done";
+        "debt.drop": "debt.drop";
+        "debt.update": "debt.update";
         "akuma.call": "akuma.call";
         "akuma.kill": "akuma.kill";
         "akuma.tell": "akuma.tell";
         "contract.audit": "contract.audit";
         "contract.deliver": "contract.deliver";
         "contract.review": "contract.review";
-    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
     provider: z.ZodPipe<z.ZodObject<{
         name: z.ZodString;
         kind: z.ZodEnum<{
@@ -33,6 +28,7 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
             "codex-app-server": "codex-app-server";
             "grok-build": "grok-build";
             "opencode-sdk": "opencode-sdk";
+            paseo: "paseo";
             pi: "pi";
         }>;
         executable: z.ZodOptional<z.ZodString>;
@@ -43,10 +39,10 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         config?: Readonly<Record<string, unknown>>;
         executable?: string;
         name: string;
-        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
     }>, {
         name: string;
-        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
         executable?: string | undefined;
         config?: Record<string, unknown> | undefined;
         env?: Record<string, string> | undefined;
@@ -60,11 +56,11 @@ declare const akumaCallRecipeSchema: 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;
@@ -74,7 +70,7 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         effort?: string | undefined;
         network?: "disabled" | "enabled" | undefined;
         systemPrompt?: string | undefined;
-        systemPromptMode?: "append" | "replace" | undefined;
+        systemPromptMode?: "replace" | "append" | undefined;
     }>>;
 }, z.core.$strict>;
 declare const akumaCallPayloadSchema: z.ZodObject<{
@@ -86,27 +82,24 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
         schemaJson: z.ZodOptional<z.ZodString>;
         initiator: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    birthInitiator: z.ZodOptional<z.ZodString>;
+    contractId: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
-            "task.add": "task.add";
-            "task.addDocument": "task.addDocument";
-            "task.compose": "task.compose";
-            "task.done": "task.done";
-            "task.drop": "task.drop";
-            "task.hold": "task.hold";
-            "task.resume": "task.resume";
-            "task.start": "task.start";
-            "task.stop": "task.stop";
-            "task.update": "task.update";
+            "debt.add": "debt.add";
+            "debt.addDocument": "debt.addDocument";
+            "debt.done": "debt.done";
+            "debt.drop": "debt.drop";
+            "debt.update": "debt.update";
             "akuma.call": "akuma.call";
             "akuma.kill": "akuma.kill";
             "akuma.tell": "akuma.tell";
             "contract.audit": "contract.audit";
             "contract.deliver": "contract.deliver";
             "contract.review": "contract.review";
-        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
         provider: z.ZodPipe<z.ZodObject<{
             name: z.ZodString;
             kind: z.ZodEnum<{
@@ -115,6 +108,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
                 "codex-app-server": "codex-app-server";
                 "grok-build": "grok-build";
                 "opencode-sdk": "opencode-sdk";
+                paseo: "paseo";
                 pi: "pi";
             }>;
             executable: z.ZodOptional<z.ZodString>;
@@ -125,10 +119,10 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             config?: Readonly<Record<string, unknown>>;
             executable?: string;
             name: string;
-            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
         }>, {
             name: string;
-            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
             executable?: string | undefined;
             config?: Record<string, unknown> | undefined;
             env?: Record<string, string> | undefined;
@@ -142,11 +136,11 @@ declare const akumaCallPayloadSchema: 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;
@@ -156,7 +150,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             effort?: string | undefined;
             network?: "disabled" | "enabled" | undefined;
             systemPrompt?: string | undefined;
-            systemPromptMode?: "append" | "replace" | undefined;
+            systemPromptMode?: "replace" | "append" | undefined;
         }>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -167,6 +161,10 @@ export type AkumaCallRequest = z.infer<typeof akumaCallPayloadSchema> & Readonly
 export type AkumaCallRequestChildLaunch = Readonly<{
     paths: AkumaPaths;
     seed: Omit<Soul, "createdAt">;
+    birthInitiator?: string;
+    completion?: Readonly<{
+        contractId?: string;
+    }>;
 }>;
 export type InitialTellAdmissionRequest = Readonly<{
     id: AkuId;

package/build/src/akuma/call-request.js

@@ -1,7 +1,8 @@
 import { isAbsolute, resolve } from "node:path";
 import { allowedActionsSchema } from "./allowed.js";
 import { refuseRequest, reserveRequest } from "./heart/index.js";
-import { archetypeName, akumaIdSchema } from "./identity.js";
+import { validateAkumaName } from "../identity/normalize.js";
+import { akumaIdSchema } from "./identity.js";
 import { callDiagnostic, executePreparedCall } from "./publication.js";
 import { tellResultSchema } from "./call-initial-tell.js";
 import { providerOptionsSchema, providerRecipeSchema } from "./provider-recipe.js";
@@ -11,7 +12,7 @@ import { z } from "zod";
 const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
 const archetypeSchema = z.string().transform((value, context) => {
     try {
-        return archetypeName(value);
+        return validateAkumaName(value);
     }
     catch {
         context.addIssue({ code: "custom", message: "expected Akuma name" });
@@ -39,6 +40,8 @@ const akumaCallPayloadSchema = z
     world: absolutePathSchema,
     archetype: archetypeSchema,
     initialTell: initialTellSchema.optional(),
+    birthInitiator: z.string().optional(),
+    contractId: z.string().optional(),
     cwd: absolutePathSchema.optional(),
     recipe: akumaCallRecipeSchema,
 })
@@ -95,7 +98,11 @@ async function executeAkumaCall(request, facts, capabilities) {
             refuse: async (diagnostic) => {
                 await refuseRequest(paths, facts.id, diagnostic);
             },
-            spawn,
+            spawn: async (launch) => await spawn({
+                ...launch,
+                ...(request.birthInitiator === undefined ? {} : { birthInitiator: request.birthInitiator }),
+                ...(request.contractId === undefined ? {} : { completion: { contractId: request.contractId } }),
+            }),
             admitInitialTell,
         },
     });

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import type { WorldRoot } from "../world.js";
+import { type Soul } from "./heart/facts.js";
+export declare const akumaCallerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"akuma">;
+    world: z.ZodCustom<WorldRoot, WorldRoot>;
+    akuId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    integration: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type AkumaCaller = z.infer<typeof akumaCallerSchema>;
+export declare const akumaBirthSchema: z.ZodObject<{
+    origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"direct">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"request">;
+        parent: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fork">;
+        parent: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+        at: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    caller: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"akuma">;
+        world: z.ZodCustom<WorldRoot, WorldRoot>;
+        akuId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        integration: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>], "kind">, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export declare function projectAkumaBirth(soul: Soul): z.infer<typeof akumaBirthSchema>;
+export declare function decodeAkumaCaller(value: unknown): AkumaCaller | undefined;

package/build/src/akuma/caller.js

@@ -0,0 +1,36 @@
+import { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+import { akumaIdSchema } from "./identity.js";
+import { akumaOriginSchema } from "./heart/facts.js";
+// Stored attribution is a coordinate, not a live World capability or lookup.
+const callerWorldSchema = z.custom((value) => typeof value === "string" && isAbsolute(value) && resolve(value) === value, "caller world must be an absolute normalized path");
+export const akumaCallerSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("akuma"), world: callerWorldSchema, akuId: akumaIdSchema }).strict(),
+    z
+        .object({
+        kind: z.literal("external"),
+        integration: z.string().regex(/^[a-z][a-z0-9._-]{0,63}$/u),
+        id: z
+            .string()
+            .max(512)
+            .refine((value) => value.trim().length > 0 && !/[\u0000-\u001f\u007f-\u009f]/u.test(value), "external caller id must be nonblank and contain no control characters"),
+    })
+        .strict(),
+]);
+export const akumaBirthSchema = z
+    .object({
+    origin: akumaOriginSchema,
+    caller: z.union([akumaCallerSchema, z.object({ kind: z.literal("unknown") }).strict()]),
+})
+    .strict();
+export function projectAkumaBirth(soul) {
+    return { origin: soul.origin, caller: soul.caller ?? { kind: "unknown" } };
+}
+export function decodeAkumaCaller(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = akumaCallerSchema.safeParse(value);
+    if (!parsed.success)
+        throw new TypeError(`Invalid Akuma caller: ${parsed.error.message}`);
+    return parsed.data;
+}

package/build/src/akuma/dispatch-association.d.ts

@@ -10,4 +10,3 @@ export declare const dispatchAssociationSchema: z.ZodUnion<readonly [z.ZodObject
 }, z.core.$strict>]>;
 export type DispatchAssociation = z.infer<typeof dispatchAssociationSchema>;
 export declare const NO_DISPATCH_ASSOCIATION: DispatchAssociation;
-export declare function parseDispatchAssociation(value: unknown): DispatchAssociation;

package/build/src/akuma/dispatch-association.js

@@ -6,6 +6,3 @@ export const dispatchAssociationSchema = z.union([
     z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
 ]);
 export const NO_DISPATCH_ASSOCIATION = { kind: "none" };
-export function parseDispatchAssociation(value) {
-    return dispatchAssociationSchema.parse(value);
-}

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

@@ -24,6 +24,7 @@ export declare const fileChangeSchema: z.ZodObject<{
         added: z.ZodNumber;
         removed: z.ZodNumber;
     }, z.core.$strip>>;
+    patch: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const toolCallSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"run">;
@@ -57,6 +58,7 @@ export declare const toolCallSchema: z.ZodUnion<readonly [z.ZodObject<{
             added: z.ZodNumber;
             removed: z.ZodNumber;
         }, z.core.$strip>>;
+        patch: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"other">;
@@ -72,6 +74,7 @@ export declare const toolResultSchema: z.ZodObject<{
         ok: "ok";
     }>;
     message: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodString>;
     exitCode: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
@@ -112,6 +115,7 @@ declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
@@ -130,6 +134,7 @@ declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             ok: "ok";
         }>;
         message: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
         exitCode: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"tool">;
@@ -167,6 +172,7 @@ declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
@@ -195,6 +201,9 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>>, z.ZodObject<{
         sessionId: z.ZodString;
     }, z.core.$strict>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"model">;
+    model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"assistant">;
     text: z.ZodString;
@@ -241,6 +250,7 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
@@ -259,6 +269,7 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             ok: "ok";
         }>;
         message: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
         exitCode: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"tool">;
@@ -296,6 +307,7 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;

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

@@ -11,6 +11,7 @@ export const fileChangeSchema = z.object({
     op: z.enum(["add", "update", "delete", "unspecified"]),
     path: text,
     diffstat: diffstatSchema.optional(),
+    patch: text.optional(),
 });
 export const toolCallSchema = z.union([
     z.object({ kind: z.literal("run"), command: text }),
@@ -33,6 +34,7 @@ export const toolCallSchema = z.union([
 export const toolResultSchema = z.object({
     status: z.enum(["ok", "error"]),
     message: text.optional(),
+    output: text.optional(),
     exitCode: z.number().int().safe().optional(),
 });
 const toolFields = { type: z.literal("tool"), id: text, name: text, call: toolCallSchema, truncated };
@@ -42,6 +44,10 @@ const toolEventSchema = z.union([
 ]);
 export const agentEventSchema = z.union([
     z.object({ type: z.literal("session"), coordinate: resumeCoordinateSchema }),
+    // One provider-neutral runtime-model observation in the shared agent-event
+    // vocabulary. Body admits it into the Soul's single current model; it is
+    // never appended to activity, so compaction cannot lose or resurrect it.
+    z.object({ type: z.literal("model"), model: text.optional() }),
     z.object({ type: z.literal("assistant"), text, truncated }),
     z.object({ type: z.literal("thought"), text, truncated }),
     toolEventSchema,

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

@@ -1,4 +1,6 @@
-import type { AkuId } from "../identity.js";
+import type { AkumaCaller } from "../caller.js";
+import { z } from "zod";
+import { type AkuId } from "../identity.js";
 import type { ResumeCoordinate } from "../coordinate.js";
 import type { ProviderExecution, ProviderOptions } from "../provider-recipe.js";
 import type { AllowedActions } from "../allowed.js";
@@ -6,17 +8,18 @@ export type { ResumeCoordinate } from "../coordinate.js";
 export declare class HeartAuthorityCorruptionError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
-export type AkumaOrigin = Readonly<{
-    kind: "direct";
-}> | Readonly<{
-    kind: "request";
-    parent: AkuId;
-    requestId: string;
-}> | Readonly<{
-    kind: "fork";
-    parent: AkuId;
-    at: string;
-}>;
+export declare const akumaOriginSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"direct">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"request">;
+    parent: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    requestId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork">;
+    parent: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    at: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type AkumaOrigin = z.infer<typeof akumaOriginSchema>;
 export type Soul = Readonly<{
     id: AkuId;
     archetype: string;
@@ -25,6 +28,7 @@ export type Soul = Readonly<{
     options: ProviderOptions;
     cwd: string;
     origin: AkumaOrigin;
+    caller?: AkumaCaller;
     allowed: AllowedActions;
     createdAt: string;
 }>;

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

@@ -1,9 +1,17 @@
+import { z } from "zod";
+import { akumaIdSchema } from "../identity.js";
 export class HeartAuthorityCorruptionError extends Error {
     constructor(message, options) {
         super(message, options);
         this.name = "HeartAuthorityCorruptionError";
     }
 }
+const originText = z.string().refine((value) => value.trim().length > 0);
+export const akumaOriginSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("direct") }),
+    z.object({ kind: z.literal("request"), parent: akumaIdSchema, requestId: originText }),
+    z.object({ kind: z.literal("fork"), parent: akumaIdSchema, at: originText }),
+]);
 export function projectTell(fact) {
     return {
         kind: "tell",

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

@@ -1,14 +1,13 @@
 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";
+import { type HeartRead } from "./storage.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";
 export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
 export { drainPendingTells } from "./tells.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellBinding, TellFact, TellRow, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, HeartSnapshot, KillEvidence, RequestFact, SessionFact, Soul, TellFact, TurnEndFact, TurnOutcome, } 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>;
@@ -19,13 +18,63 @@ export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
     event: AgentEvent;
     at: string;
 }>): Promise<number>;
-export type ActivitySlice = ActivityFactSlice;
-export type { ActivityFact };
+type ActivitySlice = ActivityFactSlice;
 export type { TimelineFact } from "./timeline.js";
+export type CurrentModelUpdate = "recorded" | "unchanged" | "not-current-body";
+/**
+ * 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 declare function recordCurrentModel(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    model: string | undefined;
+}>): Promise<CurrentModelUpdate>;
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
 export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
-/** One live observation's successful raw input and decoded frontier, never a connection. */
+/** One live observation's current retained timeline, or a no-change witness. */
+export type TimelineRead = Readonly<{
+    changed: false;
+}> | Readonly<{
+    changed: true;
+    born: boolean;
+    slice: ActivityFactSlice;
+}>;
+/**
+ * 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 declare function createTimelineReader(paths: AkumaPaths): Readonly<{
+    read(signal?: AbortSignal): Promise<TimelineRead>;
+    clear(): void;
+}>;
+/** One observer owns its connection and successful decoded frontier. */
 export declare function createStatusFactReader(paths: AkumaPaths): {
+    life: (signal?: AbortSignal) => Promise<LifeSnapshot>;
+    tellOutcome: (id: string, signal?: AbortSignal) => Promise<{
+        tell: Readonly<{
+            kind: "tell";
+            sequence: number;
+            id: string;
+            body: string;
+            initiator?: string;
+            schemaJson?: string;
+            recordedAt: string;
+            state: "pending" | "told";
+            deliveries: readonly import("./facts.js").TellDelivery[];
+            binding?: import("./facts.js").TellBinding;
+        }> | null;
+        end: Readonly<{
+            kind: "turn-end";
+            sequence: number;
+            turnSequence: number;
+            outcome: TurnOutcome;
+            completedAt: string;
+        }> | undefined;
+    }>;
     clear(): void;
     read(input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
 };
@@ -33,7 +82,7 @@ type LifeSnapshot = Pick<HeartSnapshot, "soul" | "latestBody" | "latestSession"
     hasPendingTell: boolean;
 }>;
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export declare function readLifeSnapshot(paths: AkumaPaths, signal?: AbortSignal): Promise<LifeSnapshot>;
+export declare function readLifeSnapshot(paths: AkumaPaths, signal?: AbortSignal, read?: HeartRead): Promise<LifeSnapshot>;
 export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">, options?: Readonly<{
     interrupt?: boolean;
 }>): Promise<Readonly<{
@@ -74,8 +123,6 @@ export declare function requestPause(paths: AkumaPaths, at: string, signal?: Abo
     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">;
@@ -116,6 +163,11 @@ export declare function finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
     kind: "pending";
     tells: readonly string[];
 }>>;
+export type BodyControlSnapshot = Pick<HeartSnapshot, "soul" | "pending" | "stop" | "pause">;
+export declare function createBodyHeartReader(paths: AkumaPaths): {
+    clear: () => void;
+    read(): Promise<BodyControlSnapshot>;
+};
 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>;