@astrosheep/keiyaku 4.6.8 → 4.6.9

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

@@ -37,4 +37,11 @@ export declare function readStatusBatch(database: DatabaseSync, input: StatusFac
 };
 export declare function statusFacts(database: DatabaseSync, input: StatusFactInput): readonly TimelineFact[];
 export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;
+/**
+ * SQLite's cross-connection change counter, sampled inside the read
+ * transaction. It identifies exactly the snapshot that transaction decodes: a
+ * commit from another connection during the read cannot be mistaken for this
+ * one and skipped, because the next transaction reports a new counter.
+ */
+export declare function timelineDataVersion(database: DatabaseSync): number;
 export {};

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

@@ -124,3 +124,13 @@ export function activityFactSlice(database) {
         highest: bounds.highest,
     };
 }
+/**
+ * SQLite's cross-connection change counter, sampled inside the read
+ * transaction. It identifies exactly the snapshot that transaction decodes: a
+ * commit from another connection during the read cannot be mistaken for this
+ * one and skipped, because the next transaction reports a new counter.
+ */
+export function timelineDataVersion(database) {
+    const row = database.prepare("PRAGMA data_version").get();
+    return row?.data_version ?? 0;
+}

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

@@ -5,6 +5,7 @@ export type { ArchetypeCatalog, ArchetypeCatalogInput, ArchetypeCatalogRow } fro
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
 export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaHostOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
+export type { AkumaStreamSnapshot } from "./akuma-stream.js";
 export type { InterruptReceipt } from "./akuma-owner.js";
 export type { AkumaStatus } from "./akuma.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";

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

@@ -65,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;
@@ -105,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;
@@ -119,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<{
@@ -156,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;
@@ -175,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<{
@@ -213,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;
@@ -227,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<{
@@ -322,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;
@@ -336,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">;
@@ -372,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;
@@ -391,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<{
@@ -489,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;
@@ -508,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<{
@@ -677,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;
@@ -691,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">;
@@ -727,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;
@@ -746,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>]>>>;
@@ -780,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;
@@ -885,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;
@@ -904,8 +927,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>]>>>;

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

@@ -58,6 +58,17 @@ export declare const providerRecipeSchema: z.ZodPipe<z.ZodObject<{
     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

@@ -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

@@ -16,6 +16,14 @@ export declare function boundedToolInput(input: unknown): ToolInput | undefined;
 export declare function otherToolCall(display: string, input?: unknown): Extract<ToolCall, {
     kind: "other";
 }>;
+/**
+ * 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";
 }>;
@@ -56,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;

package/build/src/akuma/provider.js

@@ -1,6 +1,7 @@
 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 { decodeAgentEvent } from "./heart/activity-schema.js";
 function boundedToolCall(call) {
@@ -33,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);
@@ -62,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) {
@@ -82,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":
@@ -158,9 +175,37 @@ function boundedToolInputJson(value) {
 function boundedEventText(value) {
     return value.slice(0, AGENT_EVENT_TEXT_LIMIT);
 }
+/**
+ * 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() };
 }
@@ -250,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

package/build/src/akuma/providers/acp/events.js

@@ -1,5 +1,5 @@
 import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
-import { nonblank, object, positiveLine } from "../decode.js";
+import { nonblank, object, positiveLine, stringValue } from "../decode.js";
 export const EMPTY_ACP_EVENT_STATE = Object.freeze({
     answer: "",
     assistantMessageId: null,
@@ -40,6 +40,25 @@ function locationFact(locations) {
     }
     return {};
 }
+/**
+ * The observed result text of one ACP tool update: its text content blocks in
+ * native order, otherwise a raw output that is itself a string. A raw output of
+ * any other shape is left absent rather than stringified.
+ */
+function verifiedToolOutput(update) {
+    if (Array.isArray(update.content)) {
+        const blocks = update.content.flatMap((entry) => {
+            const value = object(entry);
+            if (value?.type !== "content")
+                return [];
+            const content = object(value.content);
+            return content?.type === "text" && typeof content.text === "string" ? [content.text] : [];
+        });
+        if (blocks.length > 0)
+            return blocks.join("");
+    }
+    return stringValue(update.rawOutput);
+}
 function standardCall(update, name) {
     const location = locationFact(update.locations);
     if (update.kind === "read") {
@@ -109,6 +128,7 @@ export function mapAcpUpdate(update, previous, interpret) {
             const observed = observeTool(update, previous.tools.get(update.toolCallId), interpret);
             const tools = new Map(previous.tools);
             if (update.status === "completed" || update.status === "failed") {
+                const output = verifiedToolOutput(update);
                 tools.delete(update.toolCallId);
                 return flushAcpEvents({ ...previous, tools }, [
                     {
@@ -116,7 +136,10 @@ export function mapAcpUpdate(update, previous, interpret) {
                         phase: "completed",
                         id: update.toolCallId,
                         ...observed,
-                        result: { status: update.status === "completed" ? "ok" : "error" },
+                        result: {
+                            status: update.status === "completed" ? "ok" : "error",
+                            ...(output === undefined ? {} : { output }),
+                        },
                     },
                 ]);
             }