@astrosheep/keiyaku 4.6.8 → 4.6.9

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

@@ -36,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;
@@ -197,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;
@@ -211,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">;
@@ -247,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;
@@ -266,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>]>>>;
@@ -300,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;
@@ -405,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;
@@ -424,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>]>>>;
@@ -442,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";
@@ -524,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;
@@ -685,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;
@@ -699,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">;
@@ -735,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;
@@ -754,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>]>>>;
@@ -788,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;
@@ -893,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;
@@ -912,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>]>>>;
@@ -930,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";
@@ -1258,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;
@@ -1419,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;
@@ -1433,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">;
@@ -1469,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;
@@ -1488,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>]>>>;
@@ -1522,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;
@@ -1627,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;
@@ -1646,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>]>>>;
@@ -1664,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,7 +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 };
+    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({
@@ -354,6 +374,7 @@ async function consumeTurnDrive(input, active) {
     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));
@@ -398,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());

package/build/src/akuma-body.js

@@ -11,8 +11,8 @@ import { contractRequestCommands } from "./library/contract-operations.js";
 import { createKeiyakuHandle } from "./library/keiyaku.js";
 import { Repo } from "./library/repo.js";
 import { settings } from "./settings.js";
-import { Tasks } from "./task/index.js";
-import { taskMutationRequestCommands } from "./task/mutation.js";
+import { Debts } from "./debt/index.js";
+import { debtMutationRequestCommands } from "./debt/mutation.js";
 import { World } from "./world.js";
 async function contractDependencies(repoRoot, processConfiguration) {
     const repo = await Repo.at({
@@ -68,35 +68,25 @@ function contractUpstream(processConfiguration) {
         },
     };
 }
-const TASK_LIFECYCLE = {
-    start: async (handle, input) => await handle.start(input),
-    stop: async (handle, input) => await handle.stop(input),
-    hold: async (handle, input) => await handle.hold(input),
-    resume: async (handle, input) => await handle.resume(input),
+const DEBT_LIFECYCLE = {
     done: async (handle, input) => await handle.done(input),
     drop: async (handle, input) => await handle.drop(input),
 };
 /**
- * The upper Body edge composes the forced-local Tasks SDK the descriptor
+ * The upper Body edge composes the forced-local Debts SDK the descriptor
  * execution entries consume. Each ability is one ordinary local product
- * operation; no generic task(request) dispatcher is introduced here.
+ * operation; no generic debt(request) dispatcher is introduced here.
  */
-function taskMutationRequestPort() {
+function debtMutationRequestPort() {
     return {
-        add: async ({ world, options }) => await Tasks.of(world).add(options),
-        addDocument: async ({ world, document }) => await Tasks.of(world).addDocument(document),
-        compose: async ({ world, markdown, defaultNamespace, actor, signal }) => await Tasks.of(world).compose({
-            markdown,
-            namespace: defaultNamespace,
-            actor,
-            ...(signal === undefined ? {} : { signal }),
-        }),
-        update: async ({ world, id, options }) => await Tasks.of(world).task({ id }).update(options),
-        lifecycle: async ({ world, verb, id, note, signal }) => await TASK_LIFECYCLE[verb](Tasks.of(world).task({ id }), {
+        add: async ({ world, options }) => await Debts.of(world).add(options),
+        addDocument: async ({ world, document }) => await Debts.of(world).addDocument(document),
+        update: async ({ world, id, options }) => await Debts.of(world).debt({ id }).update(options),
+        lifecycle: async ({ world, verb, id, note, signal }) => await DEBT_LIFECYCLE[verb](Debts.of(world).debt({ id }), {
             ...(note === undefined ? {} : { note }),
             ...(signal === undefined ? {} : { signal }),
         }),
-        batch: async ({ world, verb, ids, note, signal }) => await Tasks.of(world).batch({
+        batch: async ({ world, verb, ids, note, signal }) => await Debts.of(world).batch({
             verb,
             ids,
             ...(note === undefined ? {} : { note }),
@@ -110,7 +100,7 @@ export async function externalRequestCommandsFor(launch, processConfiguration) {
         world,
         commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world, (message) => {
             void recordPluginDiagnostic(launch.paths, "outcome observation", message);
-        })), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
+        })), contractRequestCommands(contractUpstream(processConfiguration)), debtMutationRequestCommands(debtMutationRequestPort())),
     };
 }
 function bodyProcessConfiguration() {

package/build/src/cli/akuma-caller.js

@@ -11,6 +11,16 @@ export async function akumaCallerFromEnvironment(environment) {
         const resolved = await World.resolve({ cwd: world, repositoryRoot: world });
         return decodeAkumaCaller({ kind: "akuma", akuId: id, world: resolved.candidate });
     }
+    const hosts = [
+        { integration: "codex", id: environment.CODEX_THREAD_ID },
+        { integration: "pi", id: environment.PI_SESSION_ID },
+        { integration: "claude", id: environment.CLAUDE_CODE_SESSION_ID },
+    ].filter(({ id }) => id !== undefined && id !== "");
+    if (hosts.length > 1) {
+        throw new TypeError(`Ambiguous native host caller: ${hosts.map(({ integration }) => integration).join(", ")}`);
+    }
+    if (hosts[0])
+        return decodeAkumaCaller({ kind: "external", ...hosts[0] });
     const external = environment.KEIYAKU_EXTERNAL_CALLER;
     if (external === undefined)
         return undefined;

package/build/src/cli/commands/akuma-grammar.js

@@ -48,10 +48,9 @@ const AKUMA_COMMAND_SPECS = {
         details: [
             "The default mode is any; --all waits until every selected Akuma completes.",
             "An already completed member counts immediately, so repeating a selection can return at once.",
-            "Akuma names, completed activity, and the final result stream on stderr.",
-            "A streamed plural wait leaves stdout empty, and so does a single wait with no answer.",
-            "Only a single selected Akuma that answered writes to stdout, exactly its answer.",
-            "With --json nothing streams and stdout carries the result document.",
+            "Text prints each selected Akuma's status snapshot, then one failure fact for any Akuma it could not read.",
+            "An answer is part of that snapshot; wait writes no separate copy of it to stdout.",
+            "With --json stdout carries the result document.",
         ].join("\n"),
     },
     tell: {