@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -56,15 +56,6 @@ export declare const tellRowSchema: z.ZodObject<{
         receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>;
-declare const outcomeSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"answered">;
-    historyId: z.ZodString;
-    answer: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"failed">;
-    historyId: z.ZodString;
-    diagnostic: z.ZodString;
-}, z.core.$strict>]>;
 declare const outcomeRowSchema: z.ZodObject<{
     kind: z.ZodLiteral<"outcome">;
     sequence: z.ZodNumber;
@@ -74,6 +65,7 @@ declare const outcomeRowSchema: 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;
@@ -114,6 +106,7 @@ declare const activeToolRowSchema: z.ZodObject<{
                 unspecified: "unspecified";
             }>;
             path: z.ZodString;
+            patch: z.ZodOptional<z.ZodString>;
             diffstat: z.ZodOptional<z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
@@ -128,6 +121,7 @@ declare const activeToolRowSchema: 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>;
 declare const completedToolRowSchema: z.ZodObject<{
@@ -165,6 +159,7 @@ declare const completedToolRowSchema: z.ZodObject<{
                 unspecified: "unspecified";
             }>;
             path: z.ZodString;
+            patch: z.ZodOptional<z.ZodString>;
             diffstat: z.ZodOptional<z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
@@ -184,8 +179,10 @@ declare const completedToolRowSchema: 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>;
 declare const unsettledToolRowSchema: z.ZodObject<{
@@ -222,6 +219,7 @@ declare const unsettledToolRowSchema: z.ZodObject<{
                 unspecified: "unspecified";
             }>;
             path: z.ZodString;
+            patch: z.ZodOptional<z.ZodString>;
             diffstat: z.ZodOptional<z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
@@ -236,6 +234,7 @@ declare const unsettledToolRowSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>]>;
     state: z.ZodLiteral<"unsettled">;
+    toolId: z.ZodOptional<z.ZodString>;
     truncated: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
 declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
@@ -331,6 +330,7 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
                 unspecified: "unspecified";
             }>;
             path: z.ZodString;
+            patch: z.ZodOptional<z.ZodString>;
             diffstat: z.ZodOptional<z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
@@ -345,6 +345,7 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         }, 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">;
@@ -381,6 +382,7 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
                 unspecified: "unspecified";
             }>;
             path: z.ZodString;
+            patch: z.ZodOptional<z.ZodString>;
             diffstat: z.ZodOptional<z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
@@ -400,8 +402,10 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
             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>]>;
 declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
@@ -498,6 +502,7 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
                 unspecified: "unspecified";
             }>;
             path: z.ZodString;
+            patch: z.ZodOptional<z.ZodString>;
             diffstat: z.ZodOptional<z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
@@ -517,8 +522,10 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
             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>]>;
 declare const snapshotEntrySchema: <Row extends z.ZodType>(row: Row) => z.ZodUnion<readonly [z.ZodObject<{
@@ -686,6 +693,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                         unspecified: "unspecified";
                     }>;
                     path: z.ZodString;
+                    patch: z.ZodOptional<z.ZodString>;
                     diffstat: z.ZodOptional<z.ZodObject<{
                         added: z.ZodNumber;
                         removed: z.ZodNumber;
@@ -700,6 +708,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [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">;
@@ -736,6 +745,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                         unspecified: "unspecified";
                     }>;
                     path: z.ZodString;
+                    patch: z.ZodOptional<z.ZodString>;
                     diffstat: z.ZodOptional<z.ZodObject<{
                         added: z.ZodNumber;
                         removed: z.ZodNumber;
@@ -755,8 +765,10 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [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>]>>>;
@@ -789,6 +801,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [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;
@@ -894,6 +907,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                         unspecified: "unspecified";
                     }>;
                     path: z.ZodString;
+                    patch: z.ZodOptional<z.ZodString>;
                     diffstat: z.ZodOptional<z.ZodObject<{
                         added: z.ZodNumber;
                         removed: z.ZodNumber;
@@ -913,14 +927,15 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [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>]>>>;
     omitted: z.ZodNumber;
 }, z.core.$strict>]>;
-export type TurnOutcome = z.infer<typeof outcomeSchema>;
 export type TurnStartRow = z.infer<typeof turnRowSchema>;
 type CallRow = z.infer<typeof callRowSchema>;
 type SaidRow = z.infer<ReturnType<typeof textRowSchema>>;
@@ -952,7 +967,6 @@ export type IdleSnapshotRow = z.infer<typeof idleSnapshotRowSchema>;
 export type SnapshotRow = OpenSnapshotRow | IdleSnapshotRow;
 export type ActivitySnapshotEntry<Row extends SnapshotRow = SnapshotRow> = z.infer<ReturnType<typeof snapshotEntrySchema<z.ZodType<Row>>>>;
 export type ReportedFileChange = z.infer<typeof reportedFileChangeSchema>;
-export type Snapshot = z.infer<typeof activitySnapshotSchema>;
 export type ActivitySnapshot = z.infer<typeof activitySnapshotSchema>;
 export type ActivityHistory = Readonly<{
     rows: readonly ActivityRow[];

package/build/src/akuma/projection.js

@@ -69,7 +69,14 @@ export const tellRowSchema = z
 })
     .strict();
 const outcomeSchema = z.union([
-    z.object({ kind: z.literal("answered"), historyId: nonblankTextSchema, answer: z.string() }).strict(),
+    z
+        .object({
+        kind: z.literal("answered"),
+        historyId: nonblankTextSchema,
+        answer: z.string(),
+        foldedSaidSequence: countSchema.optional(),
+    })
+        .strict(),
     z.object({ kind: z.literal("failed"), historyId: nonblankTextSchema, diagnostic: z.string() }).strict(),
 ]);
 const outcomeRowSchema = z
@@ -90,6 +97,7 @@ const activeToolRowSchema = z
     name: nonblankTextSchema,
     call: publicToolCallSchema,
     state: z.literal("active"),
+    toolId: z.string().optional(),
     truncated: z.literal(true).optional(),
 })
     .strict();
@@ -103,6 +111,7 @@ const completedToolRowSchema = z
     name: nonblankTextSchema,
     call: publicToolCallSchema,
     state: publicToolResultSchema,
+    toolId: z.string().optional(),
     truncated: z.literal(true).optional(),
 })
     .strict();
@@ -115,6 +124,7 @@ const unsettledToolRowSchema = z
     name: nonblankTextSchema,
     call: publicToolCallSchema,
     state: z.literal("unsettled"),
+    toolId: z.string().optional(),
     truncated: z.literal(true).optional(),
 })
     .strict();
@@ -239,6 +249,7 @@ function projectToolEvent(rows, running, fact, event, phase) {
             turnSequence: fact.turnSequence,
             at: fact.at,
             name: event.name,
+            toolId: event.id,
             call: event.call,
             state: phase === "open" ? "active" : "unsettled",
             ...(event.truncated === true ? { truncated: true } : {}),
@@ -254,6 +265,7 @@ function projectToolEvent(rows, running, fact, event, phase) {
             turnSequence: fact.turnSequence,
             at: fact.at,
             name: event.name,
+            toolId: event.id,
             call: event.call,
             state: event.result,
             ...(event.truncated === true ? { truncated: true } : {}),
@@ -268,6 +280,7 @@ function projectToolEvent(rows, running, fact, event, phase) {
         at: fact.at,
         ...(durationMs === undefined ? {} : { durationMs }),
         name: event.name,
+        toolId: event.id,
         call: event.call,
         state: event.result,
         ...(started.truncated === true || event.truncated === true ? { truncated: true } : {}),
@@ -300,16 +313,20 @@ function demoteActive(row) {
 }
 function foldOutcomeVoice(rows, outcome) {
     if (outcome?.outcome.kind !== "answered")
-        return rows;
+        return { rows, outcome };
     const finalVoice = rows.findLast((row) => row.kind === "said");
     return finalVoice?.text === outcome.outcome.answer && finalVoice.truncated !== true
-        ? rows.filter((row) => row !== finalVoice)
-        : rows;
+        ? {
+            rows: rows.filter((row) => row !== finalVoice),
+            outcome: { ...outcome, outcome: { ...outcome.outcome, foldedSaidSequence: finalVoice.sequence } },
+        }
+        : { rows, outcome };
 }
 function finishTurn(turn) {
-    const rows = [...foldOutcomeVoice(turn.rows, turn.outcome)].sort((left, right) => left.sequence - right.sequence);
-    if (turn.phase === "closed" && turn.outcome !== undefined) {
-        return { kind: "closed", turn: turn.turn, rows: rows.map(demoteActive), outcome: turn.outcome };
+    const folded = foldOutcomeVoice(turn.rows, turn.outcome);
+    const rows = [...folded.rows].sort((left, right) => left.sequence - right.sequence);
+    if (turn.phase === "closed" && folded.outcome !== undefined) {
+        return { kind: "closed", turn: turn.turn, rows: rows.map(demoteActive), outcome: folded.outcome };
     }
     if (rows.some((row) => row.kind === "tool" && row.state === "unsettled")) {
         throw new Error(`open Turn ${turn.turn.turnSequence} contains an unsettled tool`);

package/build/src/akuma/provider-recipe.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 declare const systemPromptModeSchema: z.ZodEnum<{
-    append: "append";
     replace: "replace";
+    append: "append";
 }>;
 export type SystemPromptMode = z.infer<typeof systemPromptModeSchema>;
 export declare const providerOptionsSchema: z.ZodPipe<z.ZodObject<{
@@ -13,11 +13,11 @@ export declare const providerOptionsSchema: z.ZodPipe<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;
@@ -27,7 +27,7 @@ export declare const providerOptionsSchema: z.ZodPipe<z.ZodObject<{
     effort?: string | undefined;
     network?: "disabled" | "enabled" | undefined;
     systemPrompt?: string | undefined;
-    systemPromptMode?: "append" | "replace" | undefined;
+    systemPromptMode?: "replace" | "append" | undefined;
 }>>;
 export type ProviderOptions = z.infer<typeof providerOptionsSchema>;
 export declare const providerRecipeSchema: z.ZodPipe<z.ZodObject<{
@@ -38,6 +38,7 @@ export declare const providerRecipeSchema: z.ZodPipe<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>;
@@ -48,15 +49,26 @@ export declare const providerRecipeSchema: z.ZodPipe<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;
 }>>;
 export type ProviderExecution = z.infer<typeof providerRecipeSchema>;
+/**
+ * One observed runtime model, admitted under the same identity rules a birth
+ * selection obeys: a nonblank native identifier, or an explicit unknown whose
+ * replacement the native surface did not name.
+ */
+export declare function decodeRuntimeModel(value: unknown): string | undefined;
+/**
+ * Recipe members without the current-model member, which an otherwise frozen
+ * recipe does not own: it lives once, as the Soul's mutable current selection.
+ */
+export declare function withoutModel(options: ProviderOptions): ProviderOptions;
 export declare function decodeProviderOptions(value: unknown): ProviderOptions;
 export declare function decodeProviderRecipe(value: unknown): ProviderExecution;
 export {};

package/build/src/akuma/provider-recipe.js

@@ -35,7 +35,7 @@ function snapshot(value) {
 export const providerRecipeSchema = z
     .object({
     name: z.string().refine((value) => value.trim() !== "", "provider execution name must be a nonblank string"),
-    kind: z.enum(["acp", "claude-agent-sdk", "codex-app-server", "grok-build", "opencode-sdk", "pi"], {
+    kind: z.enum(["acp", "claude-agent-sdk", "codex-app-server", "grok-build", "opencode-sdk", "paseo", "pi"], {
         error: "provider execution has unknown kind",
     }),
     executable: z
@@ -52,6 +52,29 @@ export const providerRecipeSchema = z
     ...(config === undefined ? {} : { config: snapshot(config) }),
     ...(env === undefined ? {} : { env: Object.freeze(env) }),
 }));
+/**
+ * One observed runtime model, admitted under the same identity rules a birth
+ * selection obeys: a nonblank native identifier, or an explicit unknown whose
+ * replacement the native surface did not name.
+ */
+export function decodeRuntimeModel(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = modelText.safeParse(value);
+    if (!parsed.success)
+        throw new TypeError(parsed.error.issues[0]?.message ?? "provider option model must be a nonblank string", {
+            cause: parsed.error,
+        });
+    return parsed.data;
+}
+/**
+ * Recipe members without the current-model member, which an otherwise frozen
+ * recipe does not own: it lives once, as the Soul's mutable current selection.
+ */
+export function withoutModel(options) {
+    const { model: _current, ...rest } = options;
+    return rest;
+}
 export function decodeProviderOptions(value) {
     const parsed = providerOptionsSchema.safeParse(value);
     if (!parsed.success)

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

@@ -1,13 +1,10 @@
 import { type ResumeCoordinate } from "./coordinate.js";
 import type { ProviderOptions } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
-export { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
-export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
-export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
-export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
+export { AKUMA_REQUESTS_ENV, AKUMA_REQUESTS_ENTRY_ENV } from "./providers/execution-environment.js";
 export declare const AGENT_EVENT_QUEUE_LIMIT = 256;
-export { agentEventSchema, decodeAgentEvent } from "./heart/activity-schema.js";
-export type { AgentEvent, SearchScope, ToolCall, ToolEvent, ToolInput, ToolResult } from "./heart/activity-schema.js";
+export { decodeAgentEvent } from "./heart/activity-schema.js";
+export type { AgentEvent, SearchScope, ToolCall, ToolResult } from "./heart/activity-schema.js";
 import type { AgentEvent, ToolCall, ToolInput } from "./heart/activity-schema.js";
 export declare function encodeAgentEvent(event: AgentEvent): AgentEvent;
 /**
@@ -19,8 +16,14 @@ export declare function boundedToolInput(input: unknown): ToolInput | undefined;
 export declare function otherToolCall(display: string, input?: unknown): Extract<ToolCall, {
     kind: "other";
 }>;
-export declare function boundedEventText(value: string): string;
-export declare function boundedThoughtText(value: string): string;
+/**
+ * One provider-neutral runtime-model observation. Adapters emit it only from
+ * native evidence that names an actual model; `undefined` reports a known
+ * model change whose replacement the native surface did not identify.
+ */
+export declare function modelEvent(model?: string): Extract<AgentEvent, {
+    type: "model";
+}>;
 export declare function noteEvent(note: string): Extract<AgentEvent, {
     type: "note";
 }>;
@@ -45,7 +48,7 @@ export type TurnResult = Readonly<{
     kind: "failed";
     diagnostic: string;
 }>;
-export type ProviderFence = string;
+type ProviderFence = string;
 export type TellReceipt = Readonly<{
     evidence: "exact";
     tellId: string;
@@ -61,6 +64,23 @@ export type TellSubmission = Readonly<{
 }> | Readonly<{
     kind: "turn-ended";
 }>;
+export type TellRegistry<Key> = Readonly<{
+    register(key: Key, id: string): Promise<TellSubmission>;
+    /** Native evidence naming the booked tell resolves its wait; false when none was booked. */
+    accept(key: Key): boolean;
+    fail(key: Key, error: unknown): void;
+    end(): void;
+}>;
+/**
+ * One live-tell receipt book, keyed by whatever evidence proves acceptance: a
+ * native message identity or the tell id itself, with `fenceOf` naming the
+ * receipt. Register before the text reaches the native surface. Ending the
+ * turn ends every remaining wait, and every later registration too.
+ */
+export declare function tellRegistry<Key>(fenceOf?: (id: string) => string): TellRegistry<Key>;
+export declare function launchPrompt(body: string, tells: readonly Readonly<{
+    text: string;
+}>[], schema?: string): string;
 export type Session = Readonly<{
     admission: Readonly<{
         fence: ProviderFence;
@@ -87,7 +107,7 @@ export type ProviderAttempt<Result> = Readonly<{
     abort(): Promise<void>;
     forceDispose(): Promise<void>;
 }>;
-export type AttemptResource = Readonly<{
+type AttemptResource = Readonly<{
     /** Resolves only when this physical resource has retired. */
     closed: Promise<void>;
     abort?(): Promise<void>;
@@ -115,6 +135,7 @@ export type DriveInput = Readonly<{
     signal: AbortSignal;
     requests: Readonly<{
         dir: string;
+        entry?: string;
     }>;
     schemaJson?: string;
 }>;

package/build/src/akuma/provider.js

@@ -1,9 +1,9 @@
-export { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
-export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
-export const AGENT_EVENT_TEXT_LIMIT = 16_384;
-export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
+export { AKUMA_REQUESTS_ENV, AKUMA_REQUESTS_ENTRY_ENV } from "./providers/execution-environment.js";
+const AGENT_EVENT_TEXT_LIMIT = 16_384;
+const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
+const OBSERVED_TEXT_TRUNCATION_MARKER = "\n…[truncated]";
 export const AGENT_EVENT_QUEUE_LIMIT = 256;
-export { agentEventSchema, decodeAgentEvent } from "./heart/activity-schema.js";
+export { decodeAgentEvent } from "./heart/activity-schema.js";
 function boundedToolCall(call) {
     switch (call.kind) {
         case "run":
@@ -34,14 +34,24 @@ function boundedToolCall(call) {
                     (call.path !== undefined && call.path.length > AGENT_EVENT_TEXT_LIMIT) ||
                     (call.glob !== undefined && call.glob.length > AGENT_EVENT_TEXT_LIMIT),
             };
-        case "fileChange":
+        case "fileChange": {
+            const bounded = call.changes.map((change) => {
+                const patch = change.patch === undefined ? undefined : boundedObservedText(change.patch);
+                return {
+                    value: {
+                        ...change,
+                        path: boundedEventText(change.path),
+                        ...(patch === undefined ? {} : { patch: patch.value }),
+                    },
+                    truncated: patch?.truncated === true,
+                };
+            });
             return {
-                value: {
-                    kind: call.kind,
-                    changes: call.changes.map((change) => ({ ...change, path: boundedEventText(change.path) })),
-                },
-                truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
+                value: { kind: call.kind, changes: bounded.map((change) => change.value) },
+                truncated: bounded.some((change) => change.truncated) ||
+                    call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
             };
+        }
         case "other": {
             const input = call.input;
             const display = boundedEventText(call.display);
@@ -63,13 +73,15 @@ function boundedToolCall(call) {
     }
 }
 function boundedToolResult(result) {
+    const output = result.output === undefined ? undefined : boundedObservedText(result.output);
     return {
         value: {
             status: result.status,
             ...(result.message === undefined ? {} : { message: boundedEventText(result.message) }),
+            ...(output === undefined ? {} : { output: output.value }),
             ...(result.exitCode === undefined ? {} : { exitCode: result.exitCode }),
         },
-        truncated: result.message !== undefined && result.message.length > AGENT_EVENT_TEXT_LIMIT,
+        truncated: (result.message !== undefined && result.message.length > AGENT_EVENT_TEXT_LIMIT) || output?.truncated === true,
     };
 }
 export function encodeAgentEvent(event) {
@@ -83,6 +95,10 @@ export function encodeAgentEvent(event) {
                 : { sessionId: event.coordinate.sessionId };
             return { type: event.type, coordinate };
         }
+        case "model":
+            return event.model === undefined
+                ? { type: event.type }
+                : { type: event.type, model: boundedEventText(event.model) };
         case "assistant":
             return marked({ type: event.type, text: boundedEventText(event.text) }, event.text.length > AGENT_EVENT_TEXT_LIMIT);
         case "thought":
@@ -156,12 +172,40 @@ function boundedToolInputJson(value) {
     }
     return { value: prefix, truncated: true };
 }
-export function boundedEventText(value) {
+function boundedEventText(value) {
     return value.slice(0, AGENT_EVENT_TEXT_LIMIT);
 }
-export function boundedThoughtText(value) {
+/**
+ * Bound one observed result text or patch. Observed content carries its own
+ * visible truncation marker inside the same budget: a cut diff that still looks
+ * complete is worse than a marked one, and the marker is part of that bound so
+ * re-encoding an already bounded value changes nothing. The cut lands on a
+ * complete code point, never a UTF-16 surrogate half.
+ */
+function boundedObservedText(value) {
+    if (value.length <= AGENT_EVENT_TEXT_LIMIT)
+        return { value, truncated: false };
+    const budget = AGENT_EVENT_TEXT_LIMIT - OBSERVED_TEXT_TRUNCATION_MARKER.length;
+    return {
+        value: `${value.slice(0, cutBeforeSurrogate(value, budget))}${OBSERVED_TEXT_TRUNCATION_MARKER}`,
+        truncated: true,
+    };
+}
+function cutBeforeSurrogate(value, budget) {
+    const lastKept = value.charCodeAt(budget - 1);
+    return lastKept >= 0xd800 && lastKept <= 0xdbff ? budget - 1 : budget;
+}
+function boundedThoughtText(value) {
     return value.slice(0, AGENT_THOUGHT_TEXT_LIMIT);
 }
+/**
+ * One provider-neutral runtime-model observation. Adapters emit it only from
+ * native evidence that names an actual model; `undefined` reports a known
+ * model change whose replacement the native surface did not identify.
+ */
+export function modelEvent(model) {
+    return model === undefined ? { type: "model" } : { type: "model", model: boundedEventText(model) };
+}
 export function noteEvent(note) {
     return { type: "note", text: note.replace(/\s+/g, " ").trim() };
 }
@@ -251,6 +295,53 @@ export class AgentEventChannel {
         };
     }
 }
+/**
+ * One live-tell receipt book, keyed by whatever evidence proves acceptance: a
+ * native message identity or the tell id itself, with `fenceOf` naming the
+ * receipt. Register before the text reaches the native surface. Ending the
+ * turn ends every remaining wait, and every later registration too.
+ */
+export function tellRegistry(fenceOf = (id) => id) {
+    const waiting = new Map();
+    let ended = false;
+    const take = (key) => {
+        const waiter = waiting.get(key);
+        if (waiter !== undefined)
+            waiting.delete(key);
+        return waiter;
+    };
+    return {
+        register(key, id) {
+            if (ended)
+                return Promise.resolve({ kind: "turn-ended" });
+            if (waiting.has(key))
+                throw new Error("duplicate live tell");
+            return new Promise((resolve, reject) => waiting.set(key, { id, resolve, reject }));
+        },
+        accept(key) {
+            const waiter = take(key);
+            waiter?.resolve({ kind: "accepted", fence: fenceOf(waiter.id) });
+            return waiter !== undefined;
+        },
+        fail(key, error) {
+            take(key)?.reject(error);
+        },
+        end() {
+            ended = true;
+            for (const waiter of waiting.values())
+                waiter.resolve({ kind: "turn-ended" });
+            waiting.clear();
+        },
+    };
+}
+/** The one launch text: the body, every launch tell, then any schema, blank-line separated. */
+const JSON_SCHEMA_PROMPT = "Respond with JSON matching this JSON Schema and no other text:";
+export function launchPrompt(body, tells, schema) {
+    const parts = [body, ...tells.map((tell) => tell.text)];
+    if (schema !== undefined)
+        parts.push(JSON_SCHEMA_PROMPT, schema);
+    return parts.filter((part) => part.length > 0).join("\n\n");
+}
 /**
  * Starts provider work after its caller has received custody.  The input signal
  * remains a cancellation notification; this attempt owns its own controller