@astrosheep/keiyaku 4.5.19 → 4.5.21

package/build/src/akuma/providers/execution-environment.js

@@ -0,0 +1,24 @@
+export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
+const PARENT_HARNESS_IDENTITY_KEYS = [
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_CHILD_SESSION",
+    "CLAUDECODE",
+    "CODEX_THREAD_ID",
+    "OPENCODE_SESSION_ID",
+    "PI_SESSION_ID",
+    "PI_SESSION_FILE",
+    "PASEO_AGENT_ID",
+    "SQUARE_PARTICIPANT_NAME",
+];
+/** Construct the environment for one isolated Akuma execution or native child. */
+export function akumaExecutionEnvironment(inherited, overrides = {}, requests, nativeIdentity = []) {
+    const preserved = Object.fromEntries(nativeIdentity.flatMap((key) => (inherited[key] === undefined ? [] : [[key, inherited[key]]])));
+    const environment = Object.fromEntries(Object.entries({ ...inherited, ...overrides }).flatMap(([key, value]) => value === undefined ? [] : [[key, value]]));
+    for (const key of PARENT_HARNESS_IDENTITY_KEYS)
+        delete environment[key];
+    Object.assign(environment, preserved);
+    delete environment[AKUMA_REQUESTS_ENV];
+    if (requests !== undefined)
+        environment[AKUMA_REQUESTS_ENV] = requests;
+    return environment;
+}

package/build/src/akuma/providers/grok-build/index.js

@@ -67,6 +67,9 @@ export const interpretGrokTool = (update) => {
         fileChangeCall(name, input));
 };
 function optionAdmission(options) {
+    if (options.sandbox !== undefined) {
+        return { kind: "refused", diagnostic: "Grok Build does not support the sandbox option" };
+    }
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "Grok Build does not support the network option" };
     }

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
@@ -22,6 +22,8 @@ function opencodeSessionId(coordinateValue) {
     return coordinateValue.sessionId;
 }
 function admit(options) {
+    if (options.sandbox !== undefined)
+        throw new Error("OpenCode does not support the sandbox option");
     if (options.network !== undefined)
         throw new Error("OpenCode does not support explicit network");
     if (options.systemPromptMode === "replace") {
@@ -202,12 +204,13 @@ async function forceDisposeOpencode(abortController, close, finish) {
 }
 async function loadDriveRuntime(execution, input, signal, loader, onRuntime) {
     const runtime = await loadOpencode({
-        ...execution,
-        env: {
-            ...execution.env,
-            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
-        },
-    }, input.cwd, signal, loader, onRuntime);
+        execution,
+        cwd: input.cwd,
+        signal,
+        ...(loader === undefined ? {} : { loader }),
+        ...(onRuntime === undefined ? {} : { onRuntime }),
+        ...(input.requests === undefined ? {} : { requests: input.requests.dir }),
+    });
     if (signal.aborted) {
         await runtime.close();
         signal.throwIfAborted();
@@ -341,22 +344,28 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
         fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => {
             const sessionId = opencodeSessionId(input.session);
             let close;
-            const runtime = await loadOpencode(execution, input.cwd, custody.signal, loader, (ready) => {
-                let closing;
-                let settleRuntimeClosed;
-                let rejectRuntimeClosed;
-                const runtimeClosed = new Promise((resolve, reject) => {
-                    settleRuntimeClosed = resolve;
-                    rejectRuntimeClosed = reject;
-                });
-                close = () => {
-                    if (closing === undefined) {
-                        closing = ready.close();
-                        void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
-                    }
-                    return closing;
-                };
-                custody.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+            const runtime = await loadOpencode({
+                execution,
+                cwd: input.cwd,
+                signal: custody.signal,
+                ...(loader === undefined ? {} : { loader }),
+                onRuntime: (ready) => {
+                    let closing;
+                    let settleRuntimeClosed;
+                    let rejectRuntimeClosed;
+                    const runtimeClosed = new Promise((resolve, reject) => {
+                        settleRuntimeClosed = resolve;
+                        rejectRuntimeClosed = reject;
+                    });
+                    close = () => {
+                        if (closing === undefined) {
+                            closing = ready.close();
+                            void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
+                        }
+                        return closing;
+                    };
+                    custody.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+                },
             });
             try {
                 const result = await runtime.client.session.fork({

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -23,5 +23,12 @@ export type OpencodeRuntime = Readonly<{
     };
     close: () => Promise<void>;
 }>;
-export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader, onRuntime?: (runtime: OpencodeRuntime) => void): Promise<OpencodeRuntime>;
+export declare function loadOpencode(input: Readonly<{
+    execution: ProviderExecution;
+    cwd: string;
+    signal: AbortSignal;
+    loader?: OpencodeSdkLoader;
+    onRuntime?: (runtime: OpencodeRuntime) => void;
+    requests?: string;
+}>): Promise<OpencodeRuntime>;
 export declare function coordinate(sessionId: string): ResumeCoordinate;

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -1,5 +1,6 @@
 import net from "node:net";
 import { abortable } from "../../abort.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
 export function parseModel(model) {
@@ -37,9 +38,10 @@ async function availablePort() {
         });
     });
 }
-export async function loadOpencode(execution, cwd, signal, loader, onRuntime) {
+export async function loadOpencode(input) {
+    const { execution, cwd, signal, loader, onRuntime, requests } = input;
     if (loader) {
-        const loaded = await abortable(loader(cwd, execution, signal), signal);
+        const loaded = await abortable(loader(cwd, { ...execution, env: akumaExecutionEnvironment(process.env, execution.env, requests) }, signal), signal);
         let closing;
         const runtime = {
             client: loaded.client,
@@ -64,11 +66,10 @@ export async function loadOpencode(execution, cwd, signal, loader, onRuntime) {
     const owned = await spawnDetachedProcess({
         argv: [execution.executable ?? "opencode", "serve", "--hostname", "127.0.0.1", "--port", String(port)],
         cwd,
-        env: {
-            ...process.env,
+        env: akumaExecutionEnvironment(process.env, {
             ...(execution.config === undefined ? {} : { OPENCODE_CONFIG_CONTENT: JSON.stringify(execution.config) }),
             ...execution.env,
-        },
+        }, requests),
         log: `${cwd}/.opencode.log`,
     });
     const { createOpencodeClient } = await import("@opencode-ai/sdk");

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

@@ -89,7 +89,9 @@ function searchCall(name, value) {
     };
 }
 function fileChangeCall(name, value) {
-    if (name !== "edit" || typeof value.path !== "string")
+    // Native write cannot prove creation versus overwrite and reports no patch, so
+    // it joins the conservative update operation with unknown diffstat.
+    if ((name !== "edit" && name !== "write") || typeof value.path !== "string")
         return undefined;
     return { kind: "fileChange", changes: [{ op: "update", path: value.path }] };
 }
@@ -158,7 +160,10 @@ function translateMessage(event, state) {
     }
     const text = textContent(message.content);
     state.answer = text;
-    if (hasTextContent(message.content)) {
+    // Gemini emits an empty text block alongside every tool-use message. It is
+    // transport scaffolding, not narration; an ordinary terminal empty answer
+    // remains public evidence.
+    if (hasTextContent(message.content) && !(message.stopReason === "toolUse" && text.length === 0)) {
         translated.push({ type: "assistant", text });
     }
     return translated;

package/build/src/akuma/providers/pi/index.js

@@ -1,5 +1,6 @@
 import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
+import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
 const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
@@ -7,6 +8,8 @@ function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function admitPiOptions(options) {
+    if (options.sandbox !== undefined)
+        return { kind: "refused", diagnostic: "Pi provider does not support the sandbox option" };
     if (options.network !== undefined)
         return { kind: "refused", diagnostic: "Pi provider does not support the network option" };
     if (options.model !== undefined && !MODEL_PATTERN.test(options.model)) {
@@ -54,7 +57,7 @@ async function piCreateOptions(sdk, input) {
             (await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
                 spawnHook: (context) => ({
                     ...context,
-                    env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
+                    env: akumaExecutionEnvironment(context.env, {}, input.requests.dir, ["PI_SESSION_ID", "PI_SESSION_FILE"]),
                 }),
             }),
         ];

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

@@ -0,0 +1,45 @@
+export declare const REQUEST_PROGRESS_WINDOW = 64;
+export type RequestProgressSnapshot = Readonly<{
+    nextSequence: number;
+    events: readonly Readonly<{
+        sequence: number;
+        value: unknown;
+    }>[];
+}>;
+export declare function progressPath(directory: string, transportId: string): string;
+export declare function cancellationPath(directory: string, transportId: string): string;
+/**
+ * The snapshot is a bounded, replaceable observation window. It is deliberately
+ * not a progress log: a slow observer receives an explicit sequence gap.
+ */
+export declare function publishRequestProgress(input: Readonly<{
+    directory: string;
+    transportId: string;
+    id: string;
+    action: string;
+}>): Readonly<{
+    progress(value: unknown): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}>;
+export declare function readRequestProgress(input: Readonly<{
+    directory: string;
+    transportId: string;
+    id: string;
+    action: string;
+}>): Promise<RequestProgressSnapshot | undefined>;
+export declare function publishRequestCancellation(input: Readonly<{
+    directory: string;
+    transportId: string;
+    id: string;
+    action: string;
+}>): Promise<void>;
+export declare function observeRequestCancellation(input: Readonly<{
+    directory: string;
+    transportId: string;
+    id: string;
+    action: string;
+}>): Readonly<{
+    signal: AbortSignal;
+    close(): Promise<void>;
+}>;

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

@@ -0,0 +1,162 @@
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+import { abortableDelay } from "./abort.js";
+import { atomicJson } from "./request-wire.js";
+export const REQUEST_PROGRESS_WINDOW = 64;
+const OBSERVATION_POLL_MS = 25;
+const sequenceSchema = z.number().int().nonnegative();
+const nextSequenceSchema = z.number().int().positive();
+const progressSnapshotSchema = z
+    .object({
+    id: z.string(),
+    action: z.string(),
+    nextSequence: nextSequenceSchema,
+    events: z.array(z.object({ sequence: sequenceSchema, value: z.unknown() }).strict()).max(REQUEST_PROGRESS_WINDOW),
+})
+    .strict()
+    .superRefine((snapshot, context) => {
+    for (let index = 1; index < snapshot.events.length; index += 1) {
+        if (snapshot.events[index].sequence !== snapshot.events[index - 1].sequence + 1) {
+            context.addIssue({ code: "custom", message: "progress sequences must be contiguous" });
+            return;
+        }
+    }
+    if (snapshot.events.at(-1)?.sequence !== undefined && snapshot.events.at(-1).sequence >= snapshot.nextSequence) {
+        context.addIssue({ code: "custom", message: "progress sequence exceeds its snapshot" });
+    }
+});
+const cancellationSchema = z.object({ id: z.string(), action: z.string() }).strict();
+export function progressPath(directory, transportId) {
+    return `${directory}/${transportId}.progress.json`;
+}
+export function cancellationPath(directory, transportId) {
+    return `${directory}/${transportId}.cancel.json`;
+}
+/**
+ * The snapshot is a bounded, replaceable observation window. It is deliberately
+ * not a progress log: a slow observer receives an explicit sequence gap.
+ */
+export function publishRequestProgress(input) {
+    let nextSequence = 1;
+    let events = [];
+    let dirty = false;
+    let closed = false;
+    let writer;
+    const snapshot = () => ({ nextSequence, events });
+    const write = async () => {
+        while (dirty && !closed) {
+            dirty = false;
+            try {
+                await atomicJson(progressPath(input.directory, input.transportId), {
+                    id: input.id,
+                    action: input.action,
+                    ...snapshot(),
+                });
+            }
+            catch {
+                // Observation is never allowed to impede service or its durable outcome.
+            }
+        }
+    };
+    const startWriter = () => {
+        if (writer !== undefined)
+            return;
+        writer = write().finally(() => {
+            writer = undefined;
+            if (dirty && !closed)
+                startWriter();
+        });
+    };
+    const flush = async () => {
+        while (writer !== undefined)
+            await writer;
+    };
+    return {
+        progress(value) {
+            if (closed)
+                return;
+            const sequence = nextSequence++;
+            try {
+                const encoded = JSON.stringify({ value });
+                if (encoded === undefined || !Object.hasOwn(JSON.parse(encoded), "value"))
+                    throw new Error("not JSON transport data");
+            }
+            catch {
+                dirty = true;
+                startWriter();
+                return;
+            }
+            if (events.length === REQUEST_PROGRESS_WINDOW) {
+                events = events.slice(1);
+            }
+            events = [...events, { sequence, value }];
+            dirty = true;
+            startWriter();
+        },
+        flush,
+        async close() {
+            await flush();
+            closed = true;
+        },
+    };
+}
+export async function readRequestProgress(input) {
+    let bytes;
+    try {
+        bytes = await readFile(progressPath(input.directory, input.transportId), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        return undefined;
+    }
+    try {
+        const parsed = progressSnapshotSchema.safeParse(JSON.parse(bytes));
+        if (!parsed.success || parsed.data.id !== input.id || parsed.data.action !== input.action)
+            return undefined;
+        return { nextSequence: parsed.data.nextSequence, events: parsed.data.events };
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function publishRequestCancellation(input) {
+    try {
+        await atomicJson(cancellationPath(input.directory, input.transportId), { id: input.id, action: input.action });
+    }
+    catch {
+        // The channel may have disappeared; rendezvous will report the truthful unknown outcome.
+    }
+}
+export function observeRequestCancellation(input) {
+    const local = new AbortController();
+    const stop = new AbortController();
+    const run = (async () => {
+        while (!stop.signal.aborted && !local.signal.aborted) {
+            try {
+                const parsed = cancellationSchema.safeParse(JSON.parse(await readFile(cancellationPath(input.directory, input.transportId), "utf8")));
+                if (parsed.success && parsed.data.id === input.id && parsed.data.action === input.action) {
+                    local.abort(new Error("request cancelled by caller"));
+                    return;
+                }
+            }
+            catch {
+                // An absent or malformed cancellation notice has no authority.
+            }
+            try {
+                await abortableDelay(OBSERVATION_POLL_MS, stop.signal);
+            }
+            catch {
+                return;
+            }
+        }
+    })();
+    return {
+        signal: local.signal,
+        async close() {
+            if (!stop.signal.aborted)
+                stop.abort();
+            await run;
+        },
+    };
+}

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

@@ -18,12 +18,15 @@ type RequestResponse<Output, Reference> = Readonly<{
     requestId: string;
     action: string;
 }>;
-/** Generic rendezvous only: operation owners supply their own request and result codecs. */
-export declare function requestBodyCommand<Input, Output, Reference>(input: Readonly<{
+type RequestCommandInput<Input, Output, Reference> = Readonly<{
     directory: string;
     id?: string;
     command: RequestProtocol<Input, Output, Reference>;
     value: Input;
     signal?: AbortSignal;
-}>): Promise<RequestResponse<Output, Reference>>;
+    onProgress?(value: unknown): void;
+    onProgressGap?(dropped: number): void;
+}>;
+/** Generic rendezvous only: operation owners supply their own request and result codecs. */
+export declare function requestBodyCommand<Input, Output, Reference>(input: RequestCommandInput<Input, Output, Reference>): Promise<RequestResponse<Output, Reference>>;
 export {};

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

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { access, readFile } from "node:fs/promises";
 import { abortableDelay } from "./abort.js";
+import { publishRequestCancellation, readRequestProgress, } from "./request-observation.js";
 import { atomicJson, decodeReceiptEnvelope, receiptPath, requestPath } from "./request-wire.js";
 const POLL_MS = 100;
 export class AkumaBodyRequestError extends Error {
@@ -110,21 +111,86 @@ export async function requestBodyCommand(input) {
         throw new AkumaBodyRequestError(input.command.action, "unknown", "parent request channel closed before request publication", id);
     }
     const path = receiptPath(input.directory, transportId);
-    for (;;) {
-        const response = await readRequestReceipt(input, path, id);
-        if (response !== undefined)
-            return response;
-        if (!(await access(input.directory).then(() => true, () => false))) {
-            throw new AkumaBodyRequestError(input.command.action, "unknown", "parent request channel closed before a receipt", id);
-        }
-        try {
-            await abortableDelay(POLL_MS, input.signal);
-        }
-        catch (error) {
-            if (input.signal?.aborted) {
-                throw new AkumaBodyRequestError(input.command.action, "unknown", "request was cancelled after publication and before a receipt", id);
+    return await observePublishedRequest(input, id, transportId, path);
+}
+async function observePublishedRequest(input, id, transportId, path) {
+    let observedSequence = 0;
+    const consumeProgress = async () => {
+        const snapshot = await readRequestProgress({
+            directory: input.directory,
+            transportId,
+            id,
+            action: input.command.action,
+        });
+        observedSequence = consumeSnapshot(snapshot, observedSequence, input.onProgress, input.onProgressGap);
+    };
+    const publishCancellation = () => {
+        void publishRequestCancellation({ directory: input.directory, transportId, id, action: input.command.action });
+    };
+    const cancellable = input.command.supportsCancellation === true;
+    if (cancellable && input.signal !== undefined) {
+        input.signal.addEventListener("abort", publishCancellation, { once: true });
+        if (input.signal.aborted)
+            publishCancellation();
+    }
+    try {
+        for (;;) {
+            let response;
+            try {
+                response = await readRequestReceipt(input, path, id);
+            }
+            finally {
+                // A visible receipt guarantees its final progress was already published, even on failure.
+                await consumeProgress();
+            }
+            if (response !== undefined)
+                return response;
+            if (!(await access(input.directory).then(() => true, () => false))) {
+                throw new AkumaBodyRequestError(input.command.action, "unknown", "parent request channel closed before a receipt", id);
+            }
+            try {
+                await abortableDelay(POLL_MS, cancellable ? undefined : input.signal);
+            }
+            catch (error) {
+                if (input.signal?.aborted) {
+                    throw new AkumaBodyRequestError(input.command.action, "unknown", "request was cancelled after publication and before a receipt", id);
+                }
+                throw error;
             }
-            throw error;
         }
     }
+    finally {
+        if (cancellable && input.signal !== undefined)
+            input.signal.removeEventListener("abort", publishCancellation);
+    }
+}
+function consumeSnapshot(snapshot, observedSequence, onProgress, onProgressGap) {
+    if (snapshot === undefined)
+        return observedSequence;
+    const events = snapshot.events.filter((event) => event.sequence > observedSequence);
+    const latestSequence = snapshot.nextSequence - 1;
+    const firstAvailable = events[0]?.sequence ?? latestSequence + 1;
+    const gap = firstAvailable - observedSequence - 1;
+    if (gap > 0) {
+        notifyObserver(onProgressGap, gap);
+    }
+    if (events.length === 0)
+        return Math.max(observedSequence, latestSequence);
+    for (const event of events) {
+        observedSequence = event.sequence;
+        notifyObserver(onProgress, event.value);
+    }
+    return observedSequence;
+}
+function notifyObserver(observer, value) {
+    if (observer === undefined)
+        return;
+    try {
+        void Promise.resolve(observer(value)).catch(() => {
+            // A caller observation failure cannot affect its in-flight request.
+        });
+    }
+    catch {
+        // A caller observation failure cannot affect its in-flight request.
+    }
 }

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

@@ -1,5 +1,6 @@
 import { admitRequest, beginRequest, isRequestInputConflict, readHeart, readRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, unproveRequest, } from "./heart/index.js";
 import { atomicJson, receiptPath, } from "./request-wire.js";
+import { observeRequestCancellation, publishRequestProgress } from "./request-observation.js";
 import { BodyRequestPump as LifecycleBodyRequestPump, settleReserved, } from "./request-lifecycle.js";
 export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
 function replayReference(fact, command) {
@@ -72,16 +73,38 @@ async function serveResolvedCommand(input, command, request, execute) {
         return true;
     }
     try {
+        const progress = publishRequestProgress({
+            directory: input.directory,
+            transportId: input.transportId,
+            id: fact.id,
+            action: fact.action,
+        });
+        const cancellation = command.completion === "service" && request.supportsCancellation
+            ? observeRequestCancellation({
+                directory: input.directory,
+                transportId: input.transportId,
+                id: fact.id,
+                action: fact.action,
+            })
+            : undefined;
         const facts = {
             id: fact.id,
             admittedAt: fact.admittedAt,
             requester: fact.requester,
-            signal: input.signal,
+            signal: cancellation === undefined ? input.signal : AbortSignal.any([input.signal, cancellation.signal]),
             admissionOpen: input.admissionOpen,
+            progress: progress.progress,
         };
-        const served = await execute(fact, facts);
-        fact = served.fact;
-        await projectCommandReceipt(input, fact, command, served.outcome);
+        try {
+            const served = await execute(fact, facts);
+            fact = served.fact;
+            await progress.flush();
+            await projectCommandReceipt(input, fact, command, served.outcome);
+        }
+        finally {
+            await progress.close();
+            await cancellation?.close();
+        }
     }
     catch (error) {
         const failure = encodedFailure(request, error);

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

@@ -71,6 +71,8 @@ export type RequestEnvelope = z.infer<typeof requestEnvelopeSchema>;
  */
 export type RequestProtocol<Input, Output, Reference> = Readonly<{
     action: string;
+    /** An opted-in service request accepts cancellation after publication. */
+    supportsCancellation?: boolean;
     encodeRequest(input: Input): unknown;
     decodeRequest(payload: unknown): Input | null;
     encodeResult(result: Output): unknown;
@@ -86,6 +88,8 @@ export type ExecutionFacts = Readonly<{
     requester: string;
     signal: AbortSignal;
     admissionOpen(): boolean;
+    /** Best-effort, ephemeral progress for this one live request. */
+    progress?(value: unknown): void;
 }>;
 export type ChildRequestCommand<Input, Output, Reference> = Readonly<{
     completion: "child";
@@ -109,6 +113,7 @@ export type ServiceRequestCommand<Input, Output, Service, Reference> = Readonly<
 }>;
 type ErasedRequest = Readonly<{
     payloadJson: string;
+    supportsCancellation: boolean;
     isPermitted(allowed: readonly string[]): boolean;
     encodeFailure(error: unknown): unknown | null;
 }>;

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

@@ -53,6 +53,7 @@ export function eraseRequestCommand(command) {
                         return null;
                     return {
                         payloadJson: JSON.stringify(protocol.encodeRequest(input)),
+                        supportsCancellation: protocol.supportsCancellation === true,
                         isPermitted: (allowed) => protocol.isPermitted(allowed),
                         execute: async (facts) => {
                             const served = await command.execute(input, facts);
@@ -73,6 +74,7 @@ export function eraseRequestCommand(command) {
                         return null;
                     return {
                         payloadJson: JSON.stringify(protocol.encodeRequest(input)),
+                        supportsCancellation: protocol.supportsCancellation === true,
                         isPermitted: (allowed) => protocol.isPermitted(allowed),
                         execute: async (facts) => {
                             const served = await command.execute(input, facts);

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

@@ -25,6 +25,7 @@ export type DriveTurnInput = Readonly<{
     body: string;
     call?: string;
     launchTells: readonly TellFact[];
+    initiator?: string;
     schemaJson?: string;
     supervisor: BodySupervisor;
     runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;