@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/akuma/selection-observation.d.ts

@@ -3,6 +3,30 @@ import { type AkumaStatus } from "./akuma.js";
 declare const akumaObservationSchema: z.ZodObject<{
     status: z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+        birth: 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<import("../world.js").WorldRoot, import("../world.js").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>;
         life: z.ZodEnum<{
             killed: "killed";
             hung: "hung";
@@ -12,24 +36,21 @@ declare const akumaObservationSchema: z.ZodObject<{
             stranded: "stranded";
         }>;
         cwd: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        model: 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")[]>>;
         timeline: z.ZodUnion<readonly [z.ZodObject<{
             reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 sequence: z.ZodNumber;
@@ -173,6 +194,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                                 unspecified: "unspecified";
                             }>;
                             path: z.ZodString;
+                            patch: z.ZodOptional<z.ZodString>;
                             diffstat: z.ZodOptional<z.ZodObject<{
                                 added: z.ZodNumber;
                                 removed: z.ZodNumber;
@@ -187,6 +209,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                         }, z.core.$strict>>;
                     }, z.core.$strict>]>;
                     state: z.ZodLiteral<"active">;
+                    toolId: z.ZodOptional<z.ZodString>;
                     truncated: z.ZodOptional<z.ZodLiteral<true>>;
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"tool">;
@@ -223,6 +246,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                                 unspecified: "unspecified";
                             }>;
                             path: z.ZodString;
+                            patch: z.ZodOptional<z.ZodString>;
                             diffstat: z.ZodOptional<z.ZodObject<{
                                 added: z.ZodNumber;
                                 removed: z.ZodNumber;
@@ -242,8 +266,10 @@ declare const akumaObservationSchema: z.ZodObject<{
                             ok: "ok";
                         }>;
                         message: z.ZodOptional<z.ZodString>;
+                        output: z.ZodOptional<z.ZodString>;
                         exitCode: z.ZodOptional<z.ZodNumber>;
                     }, z.core.$strict>;
+                    toolId: z.ZodOptional<z.ZodString>;
                     truncated: z.ZodOptional<z.ZodLiteral<true>>;
                 }, z.core.$strict>]>;
             }, z.core.$strict>]>>>;
@@ -276,6 +302,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                     kind: z.ZodLiteral<"answered">;
                     historyId: z.ZodString;
                     answer: z.ZodString;
+                    foldedSaidSequence: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"failed">;
                     historyId: z.ZodString;
@@ -381,6 +408,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                                 unspecified: "unspecified";
                             }>;
                             path: z.ZodString;
+                            patch: z.ZodOptional<z.ZodString>;
                             diffstat: z.ZodOptional<z.ZodObject<{
                                 added: z.ZodNumber;
                                 removed: z.ZodNumber;
@@ -400,8 +428,10 @@ declare const akumaObservationSchema: z.ZodObject<{
                             ok: "ok";
                         }>;
                         message: z.ZodOptional<z.ZodString>;
+                        output: z.ZodOptional<z.ZodString>;
                         exitCode: z.ZodOptional<z.ZodNumber>;
                     }, z.core.$strict>;
+                    toolId: z.ZodOptional<z.ZodString>;
                     truncated: z.ZodOptional<z.ZodLiteral<true>>;
                 }, z.core.$strict>]>;
             }, z.core.$strict>]>>>;
@@ -418,22 +448,18 @@ declare const akumaObservationSchema: z.ZodObject<{
         kind: z.ZodLiteral<"failed">;
         diagnostic: z.ZodString;
     }, z.core.$strict>]>;
-    createdTasks: z.ZodUnion<readonly [z.ZodObject<{
+    createdDebts: z.ZodUnion<readonly [z.ZodObject<{
         kind: z.ZodLiteral<"present">;
         rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+            id: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
             title: z.ZodString;
             state: z.ZodEnum<{
                 open: "open";
-                in_progress: "in_progress";
-                on_hold: "on_hold";
                 done: "done";
                 drop: "drop";
             }>;
             priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
             disposition: z.ZodEnum<{
-                in_progress: "in_progress";
-                on_hold: "on_hold";
                 done: "done";
                 drop: "drop";
                 ready: "ready";
@@ -467,6 +493,30 @@ declare const akumaWaitResultSchema: z.ZodObject<{
     observations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         status: z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+            birth: 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<import("../world.js").WorldRoot, import("../world.js").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>;
             life: z.ZodEnum<{
                 killed: "killed";
                 hung: "hung";
@@ -476,24 +526,21 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                 stranded: "stranded";
             }>;
             cwd: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+            model: 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")[]>>;
             timeline: z.ZodUnion<readonly [z.ZodObject<{
                 reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                     sequence: z.ZodNumber;
@@ -637,6 +684,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                                     unspecified: "unspecified";
                                 }>;
                                 path: z.ZodString;
+                                patch: z.ZodOptional<z.ZodString>;
                                 diffstat: z.ZodOptional<z.ZodObject<{
                                     added: z.ZodNumber;
                                     removed: z.ZodNumber;
@@ -651,6 +699,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                             }, z.core.$strict>>;
                         }, z.core.$strict>]>;
                         state: z.ZodLiteral<"active">;
+                        toolId: z.ZodOptional<z.ZodString>;
                         truncated: z.ZodOptional<z.ZodLiteral<true>>;
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"tool">;
@@ -687,6 +736,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                                     unspecified: "unspecified";
                                 }>;
                                 path: z.ZodString;
+                                patch: z.ZodOptional<z.ZodString>;
                                 diffstat: z.ZodOptional<z.ZodObject<{
                                     added: z.ZodNumber;
                                     removed: z.ZodNumber;
@@ -706,8 +756,10 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                                 ok: "ok";
                             }>;
                             message: z.ZodOptional<z.ZodString>;
+                            output: z.ZodOptional<z.ZodString>;
                             exitCode: z.ZodOptional<z.ZodNumber>;
                         }, z.core.$strict>;
+                        toolId: z.ZodOptional<z.ZodString>;
                         truncated: z.ZodOptional<z.ZodLiteral<true>>;
                     }, z.core.$strict>]>;
                 }, z.core.$strict>]>>>;
@@ -740,6 +792,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                         kind: z.ZodLiteral<"answered">;
                         historyId: z.ZodString;
                         answer: z.ZodString;
+                        foldedSaidSequence: z.ZodOptional<z.ZodNumber>;
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"failed">;
                         historyId: z.ZodString;
@@ -845,6 +898,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                                     unspecified: "unspecified";
                                 }>;
                                 path: z.ZodString;
+                                patch: z.ZodOptional<z.ZodString>;
                                 diffstat: z.ZodOptional<z.ZodObject<{
                                     added: z.ZodNumber;
                                     removed: z.ZodNumber;
@@ -864,8 +918,10 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                                 ok: "ok";
                             }>;
                             message: z.ZodOptional<z.ZodString>;
+                            output: z.ZodOptional<z.ZodString>;
                             exitCode: z.ZodOptional<z.ZodNumber>;
                         }, z.core.$strict>;
+                        toolId: z.ZodOptional<z.ZodString>;
                         truncated: z.ZodOptional<z.ZodLiteral<true>>;
                     }, z.core.$strict>]>;
                 }, z.core.$strict>]>>>;
@@ -882,22 +938,18 @@ declare const akumaWaitResultSchema: z.ZodObject<{
             kind: z.ZodLiteral<"failed">;
             diagnostic: z.ZodString;
         }, z.core.$strict>]>;
-        createdTasks: z.ZodUnion<readonly [z.ZodObject<{
+        createdDebts: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodLiteral<"present">;
             rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+                id: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
                 title: z.ZodString;
                 state: z.ZodEnum<{
                     open: "open";
-                    in_progress: "in_progress";
-                    on_hold: "on_hold";
                     done: "done";
                     drop: "drop";
                 }>;
                 priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
                 disposition: z.ZodEnum<{
-                    in_progress: "in_progress";
-                    on_hold: "on_hold";
                     done: "done";
                     drop: "drop";
                     ready: "ready";
@@ -1164,8 +1216,6 @@ export type AkumaAskResult<T = unknown> = Omit<z.infer<typeof akumaAskResultSche
 }>;
 /** Compose one native status into the canonical observation its crossing transports. */
 export declare function akumaObservationOf(status: AkumaStatus): AkumaObservation;
-export declare function isTellResult(value: unknown): value is AkumaTellResult;
-export declare function isAskResult(value: unknown): value is AkumaAskResult;
 export declare const selectionResultSchemas: {
     wait: z.ZodObject<{
         mode: z.ZodEnum<{
@@ -1179,6 +1229,30 @@ export declare const selectionResultSchemas: {
         observations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             status: z.ZodObject<{
                 id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+                birth: 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<import("../world.js").WorldRoot, import("../world.js").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>;
                 life: z.ZodEnum<{
                     killed: "killed";
                     hung: "hung";
@@ -1188,24 +1262,21 @@ export declare const selectionResultSchemas: {
                     stranded: "stranded";
                 }>;
                 cwd: z.ZodOptional<z.ZodString>;
+                provider: z.ZodOptional<z.ZodString>;
+                model: 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")[]>>;
                 timeline: z.ZodUnion<readonly [z.ZodObject<{
                     reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                         sequence: z.ZodNumber;
@@ -1349,6 +1420,7 @@ export declare const selectionResultSchemas: {
                                         unspecified: "unspecified";
                                     }>;
                                     path: z.ZodString;
+                                    patch: z.ZodOptional<z.ZodString>;
                                     diffstat: z.ZodOptional<z.ZodObject<{
                                         added: z.ZodNumber;
                                         removed: z.ZodNumber;
@@ -1363,6 +1435,7 @@ export declare const selectionResultSchemas: {
                                 }, z.core.$strict>>;
                             }, z.core.$strict>]>;
                             state: z.ZodLiteral<"active">;
+                            toolId: z.ZodOptional<z.ZodString>;
                             truncated: z.ZodOptional<z.ZodLiteral<true>>;
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"tool">;
@@ -1399,6 +1472,7 @@ export declare const selectionResultSchemas: {
                                         unspecified: "unspecified";
                                     }>;
                                     path: z.ZodString;
+                                    patch: z.ZodOptional<z.ZodString>;
                                     diffstat: z.ZodOptional<z.ZodObject<{
                                         added: z.ZodNumber;
                                         removed: z.ZodNumber;
@@ -1418,8 +1492,10 @@ export declare const selectionResultSchemas: {
                                     ok: "ok";
                                 }>;
                                 message: z.ZodOptional<z.ZodString>;
+                                output: z.ZodOptional<z.ZodString>;
                                 exitCode: z.ZodOptional<z.ZodNumber>;
                             }, z.core.$strict>;
+                            toolId: z.ZodOptional<z.ZodString>;
                             truncated: z.ZodOptional<z.ZodLiteral<true>>;
                         }, z.core.$strict>]>;
                     }, z.core.$strict>]>>>;
@@ -1452,6 +1528,7 @@ export declare const selectionResultSchemas: {
                             kind: z.ZodLiteral<"answered">;
                             historyId: z.ZodString;
                             answer: z.ZodString;
+                            foldedSaidSequence: z.ZodOptional<z.ZodNumber>;
                         }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"failed">;
                             historyId: z.ZodString;
@@ -1557,6 +1634,7 @@ export declare const selectionResultSchemas: {
                                         unspecified: "unspecified";
                                     }>;
                                     path: z.ZodString;
+                                    patch: z.ZodOptional<z.ZodString>;
                                     diffstat: z.ZodOptional<z.ZodObject<{
                                         added: z.ZodNumber;
                                         removed: z.ZodNumber;
@@ -1576,8 +1654,10 @@ export declare const selectionResultSchemas: {
                                     ok: "ok";
                                 }>;
                                 message: z.ZodOptional<z.ZodString>;
+                                output: z.ZodOptional<z.ZodString>;
                                 exitCode: z.ZodOptional<z.ZodNumber>;
                             }, z.core.$strict>;
+                            toolId: z.ZodOptional<z.ZodString>;
                             truncated: z.ZodOptional<z.ZodLiteral<true>>;
                         }, z.core.$strict>]>;
                     }, z.core.$strict>]>>>;
@@ -1594,22 +1674,18 @@ export declare const selectionResultSchemas: {
                 kind: z.ZodLiteral<"failed">;
                 diagnostic: z.ZodString;
             }, z.core.$strict>]>;
-            createdTasks: z.ZodUnion<readonly [z.ZodObject<{
+            createdDebts: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"present">;
                 rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                    id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+                    id: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
                     title: z.ZodString;
                     state: z.ZodEnum<{
                         open: "open";
-                        in_progress: "in_progress";
-                        on_hold: "on_hold";
                         done: "done";
                         drop: "drop";
                     }>;
                     priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
                     disposition: z.ZodEnum<{
-                        in_progress: "in_progress";
-                        on_hold: "on_hold";
                         done: "done";
                         drop: "drop";
                         ready: "ready";

package/build/src/akuma/selection-observation.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { EMPTY_CREATED_TASK_OBSERVATION, createdTaskObservationSchema } from "../task/created-observation.js";
+import { EMPTY_CREATED_DEBT_OBSERVATION, createdDebtObservationSchema } from "../debt/created-observation.js";
 import { akumaStatusSchema } from "./akuma.js";
 import { tellResultSchema } from "./call-initial-tell.js";
 import { NO_DISPATCH_ASSOCIATION, dispatchAssociationSchema } from "./dispatch-association.js";
@@ -16,7 +16,7 @@ const akumaObservationSchema = z
     .object({
     status: akumaStatusSchema,
     contract: dispatchAssociationSchema,
-    createdTasks: createdTaskObservationSchema,
+    createdDebts: createdDebtObservationSchema,
 })
     .strict();
 const akumaUnobservedSchema = z.object({ id: akumaIdSchema, diagnostic: z.string() }).strict();
@@ -48,13 +48,7 @@ const akumaAskResultSchema = z
     .strict();
 /** Compose one native status into the canonical observation its crossing transports. */
 export function akumaObservationOf(status) {
-    return { status, contract: NO_DISPATCH_ASSOCIATION, createdTasks: EMPTY_CREATED_TASK_OBSERVATION };
-}
-export function isTellResult(value) {
-    return akumaTellResultSchema.safeParse(value).success;
-}
-export function isAskResult(value) {
-    return akumaAskResultSchema.safeParse(value).success;
+    return { status, contract: NO_DISPATCH_ASSOCIATION, createdDebts: EMPTY_CREATED_DEBT_OBSERVATION };
 }
 export const selectionResultSchemas = {
     wait: akumaWaitResultSchema,

package/build/src/akuma/turn-drive.d.ts

@@ -34,6 +34,9 @@ export type DriveTurnInput = Readonly<{
     admitInitialTell(input: InitialTellAdmissionRequest): Promise<CallInitialTellAdmission>;
     world: import("../world.js").WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
+    turnStarted: Readonly<{
+        emit(turnSequence: number): Promise<void>;
+    }>;
     now(): string;
 }>;
 export declare function driveTurn(input: DriveTurnInput): Promise<(DrivenTurn & Readonly<{

package/build/src/akuma/turn-drive.js

@@ -1,6 +1,7 @@
 import { abortableDelay } from "./abort.js";
 /* eslint-disable max-lines-per-function -- Turn setup and consumption each preserve one ordered lifecycle transaction. */
-import { appendActivity, beginTurn, bindTellsToTurn, breakBody, drainPendingTells, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { appendActivity, beginTurn, bindTellsToTurn, breakBody, drainPendingTells, heartExists, readHeart, recordCurrentModel, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { withoutModel } from "./provider-recipe.js";
 import { encodeAgentEvent, } from "./provider.js";
 import { akumaCallRequestCommands } from "./call-request.js";
 import { BodyRequestPump } from "./request-serve.js";
@@ -27,12 +28,20 @@ function serializeEffects() {
     return serialize;
 }
 export async function turnRecipe(paths, soul) {
-    const latest = (await readHeart(paths)).latestSession;
+    const heart = await readHeart(paths);
+    const latest = heart.latestSession;
     const admitted = latest?.provider === soul.provider.name ? latest : undefined;
     const session = admitted?.coordinate;
+    // The current model is the one mutable member of the recipe and lives only
+    // in the Soul, so every Turn reads it freshly and no session copy, cached
+    // birth Soul, or stale option can re-admit a model that already moved.
+    const current = heart.soul?.options.model;
     return {
         cwd: soul.cwd,
-        options: admitted?.options ?? soul.options,
+        options: {
+            ...withoutModel(admitted?.options ?? soul.options),
+            ...(current === undefined ? {} : { model: current }),
+        },
         ...(session === undefined ? {} : { session }),
     };
 }
@@ -51,7 +60,7 @@ async function failedTurnSetup(input, turnSequence, requests, cancelDrive, error
     }
     return { kind: "failed", turnSequence, diagnostic: error instanceof Error ? error.message : String(error) };
 }
-async function writeProviderEvent(input, active, event) {
+async function writeProviderEvent(input, active, event, witness) {
     if (input.supervisor.signal.aborted)
         return;
     const at = input.now();
@@ -64,6 +73,16 @@ async function writeProviderEvent(input, active, event) {
             admittedAt: at,
         });
     }
+    if (event.type === "model") {
+        // Native model evidence is authoritative current state, not narration: it
+        // moves the Soul's one model and is never appended to activity.
+        if (witness.written && witness.model === event.model)
+            return;
+        witness.written = true;
+        witness.model = event.model;
+        await recordCurrentModel(input.paths, { bodySequence: input.bodySequence, model: event.model });
+        return;
+    }
     await appendActivity(input.paths, { turnSequence: active.turnSequence, event: encodeAgentEvent(event), at });
 }
 async function startTurnDrive(input) {
@@ -87,6 +106,7 @@ async function startTurnDrive(input) {
             boundAt: input.now(),
         });
     }
+    await input.turnStarted.emit(turn.sequence);
     const { world, paths, soul: parent, runtimeSpawn: spawn, externalCommands, admitInitialTell } = input;
     const commands = composeRequestCommands(akumaCallRequestCommands({ world, paths, parent, spawn, admitInitialTell }), externalCommands);
     const requests = await BodyRequestPump.open({
@@ -115,7 +135,7 @@ async function startTurnDrive(input) {
         cwd,
         options,
         signal: driveController.signal,
-        requests: { dir: requests.directory },
+        requests: { dir: requests.directory, entry: requests.entry },
         ...(schemaJson === undefined ? {} : { schemaJson }),
     };
     const attempt = session === undefined
@@ -232,9 +252,6 @@ function pumpReceipts(writers) {
 function observeFailure(settlement) {
     return settlement.then(() => new Promise(() => { }), (error) => Promise.reject(error));
 }
-function observeReceiptFailure(receiptPump) {
-    return observeFailure(receiptPump);
-}
 function observeCompletionFailure(drive) {
     return drive.completion.then(() => new Promise(() => { }), (error) => ({ kind: "completion-failed", error }));
 }
@@ -354,9 +371,10 @@ async function consumeTurnDrive(input, active) {
     let writesOpen = true;
     const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;
     const writers = { input, turnSequence, drive, writeWitness, mayWrite };
-    const receiptFailure = observeReceiptFailure(pumpReceipts(writers));
+    const receiptFailure = observeFailure(pumpReceipts(writers));
     const completionFailure = observeCompletionFailure(drive);
     const iterator = drive.events[Symbol.asyncIterator]();
+    const witness = { written: false, model: undefined };
     let liveTells = true;
     let tellPump = null;
     const wakeups = createTurnWakeups((after) => input.supervisor.next(after));
@@ -401,7 +419,7 @@ async function consumeTurnDrive(input, active) {
             }
             if (next.event.done)
                 break;
-            await writeProviderEvent(input, active, next.event.value);
+            await writeProviderEvent(input, active, next.event.value, witness);
             if (next.event.value.type === "session")
                 turnSession = next.event.value.coordinate;
             wakeups.event(iterator.next());