@astrosheep/keiyaku 4.5.28 → 4.5.29

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

@@ -39,24 +39,14 @@ class ReceiptChannel {
     }
 }
 function admitClaudeOptions(options) {
-    if (options.sandbox === "full-access" && options.readonly === true) {
-        return { kind: "refused", diagnostic: "Claude full-access sandbox cannot combine with readonly" };
-    }
-    if (options.sandbox === "full-access" && options.network === "disabled") {
-        return { kind: "refused", diagnostic: "Claude full-access sandbox cannot combine with disabled network" };
-    }
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "Claude provider does not support the network option" };
     }
     return {
         kind: "admitted",
         options: Object.freeze({ ...options }),
-        ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
     };
 }
-function permissionMode(readonly) {
-    return readonly === true ? "plan" : "bypassPermissions";
-}
 function claudeSessionId(coordinate) {
     if (!("sessionId" in coordinate) || coordinate.sessionId === undefined) {
         throw new Error("Claude resume requires sessionId");
@@ -64,7 +54,6 @@ function claudeSessionId(coordinate) {
     return coordinate.sessionId;
 }
 function claudeQueryOptions(input, execution, abortController) {
-    const mode = permissionMode(input.options.readonly);
     return {
         ...(execution.config ?? {}),
         cwd: input.cwd,
@@ -72,10 +61,9 @@ function claudeQueryOptions(input, execution, abortController) {
         ...(input.requests === undefined ? {} : { additionalDirectories: [input.requests.dir] }),
         ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
         env: akumaExecutionEnvironment(process.env, execution.env, input.requests?.dir),
-        permissionMode: mode,
-        ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
         settingSources: ["user", "project", "local"],
-        ...(input.options.sandbox === "full-access" ? { sandbox: { enabled: false } } : {}),
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0

package/build/src/akuma/providers/codex-app-server/index.js

@@ -48,20 +48,6 @@ async function steerTurn(server, state, tell) {
         throw new Error("codex app-server steer acknowledged a different turn");
     return { kind: "accepted", fence: `${accepted}:${tell.id}` };
 }
-function sandbox(cwd, options, requests) {
-    if (options.sandbox === "full-access")
-        return { type: "dangerFullAccess" };
-    if (options.readonly === true) {
-        return { type: "readOnly", networkAccess: options.network === "enabled" };
-    }
-    return {
-        type: "workspaceWrite",
-        writableRoots: [cwd, ...(requests === undefined ? [] : [requests.dir])],
-        networkAccess: options.network === "enabled",
-        excludeTmpdirEnvVar: false,
-        excludeSlashTmp: false,
-    };
-}
 async function admitTurn(server, input, state, events, config) {
     await initialize(server);
     const threadParams = {
@@ -97,7 +83,6 @@ async function admitTurn(server, input, state, events, config) {
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         approvalPolicy: "never",
-        sandboxPolicy: sandbox(input.cwd, input.options, input.requests),
         ...(input.schemaJson === undefined ? {} : { outputSchema: JSON.parse(input.schemaJson) }),
     }));
 }
@@ -223,16 +208,9 @@ export function createCodexAppServerProvider(input = "codex") {
     const execution = typeof input === "string" ? { name: "codex-app-server", kind: "codex-app-server", executable: input } : input;
     return {
         admitOptions(options) {
-            if (options.sandbox === "full-access" && options.readonly === true) {
-                return { kind: "refused", diagnostic: "Codex full-access sandbox cannot combine with readonly" };
-            }
-            if (options.sandbox === "full-access" && options.network === "disabled") {
-                return { kind: "refused", diagnostic: "Codex full-access sandbox cannot combine with disabled network" };
-            }
             return {
                 kind: "admitted",
                 options: Object.freeze({ ...options }),
-                ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
             };
         },
         fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => await forkCodex(execution, input, custody)),

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

@@ -67,9 +67,6 @@ 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" };
     }
@@ -79,14 +76,6 @@ function optionAdmission(options) {
     return {
         kind: "admitted",
         options,
-        ...(options.readonly === undefined
-            ? {}
-            : {
-                readonly: {
-                    enforcement: "none",
-                    diagnostic: "Grok Build cannot remove task-surface mutation capabilities",
-                },
-            }),
     };
 }
 function grokSessionMeta(config, options) {

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

@@ -22,8 +22,6 @@ 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") {
@@ -329,14 +327,6 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
             return {
                 kind: "admitted",
                 options: Object.freeze({ ...options }),
-                ...(options.readonly === undefined
-                    ? {}
-                    : {
-                        readonly: {
-                            enforcement: "none",
-                            diagnostic: "OpenCode V1 cannot remove task-surface mutation capabilities",
-                        },
-                    }),
             };
         },
         start: (input) => createProviderAttempt(input.signal, async (custody) => await drive(execution, { ...input, signal: custody.signal }, loader, custody)),

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

@@ -8,8 +8,6 @@ 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)) {
@@ -21,7 +19,6 @@ function admitPiOptions(options) {
     return {
         kind: "admitted",
         options: Object.freeze({ ...options }),
-        ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
     };
 }
 async function piCreateOptions(sdk, input) {
@@ -51,7 +48,7 @@ async function piCreateOptions(sdk, input) {
             : (() => {
                 throw new Error("Pi resume requires sessionFile");
             })();
-    const customTools = input.requests === undefined || input.options.readonly === true
+    const customTools = input.requests === undefined
         ? undefined
         : [
             sdk.createBashToolDefinition(input.cwd, {
@@ -67,7 +64,6 @@ async function piCreateOptions(sdk, input) {
         ...(model === undefined || modelRuntime === undefined ? {} : { model, modelRuntime }),
         ...(resourceLoader === undefined ? {} : { resourceLoader }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
-        ...(input.options.readonly === undefined ? {} : { tools: ["read", "grep", "find", "ls"] }),
         ...(customTools === undefined ? {} : { customTools }),
     };
 }

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

@@ -17,5 +17,4 @@ export declare function bodyRequestExecution(input: Readonly<{
 }>): LibraryExecution;
 /** Normalizes the public carrier before a composition captures its immutable channel. */
 export declare function libraryExecution(value: unknown): LibraryExecution;
-export declare function libraryExecutionInput(input: unknown): LibraryExecution;
 export declare function executionChannel(context?: ExecutionContext): ExecutionChannel;

package/build/src/akuma/requests.js

@@ -52,13 +52,6 @@ export function libraryExecution(value) {
     }
     throw new TypeError("execution channel must be local or body-request");
 }
-export function libraryExecutionInput(input) {
-    const value = valueRecord(input, "Keiyaku.withExecution input");
-    closed(value, ["execution"], "Keiyaku.withExecution input");
-    if (value.execution === undefined)
-        throw new TypeError("Keiyaku.withExecution input requires execution");
-    return libraryExecution(value.execution);
-}
 export function executionChannel(context) {
     return context?.channel ?? LOCAL_CHANNEL;
 }

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

@@ -1,5 +1,7 @@
 import { type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
+import type { CallInitialTellAdmission } from "./call-initial-tell.js";
+import type { InitialTellAdmissionRequest } from "./call-request.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
 import { type AkumaCallRequestChildLaunch } from "./call-request.js";
 import { type ErasedRequestCommand } from "./request-wire.js";
@@ -29,6 +31,7 @@ export type DriveTurnInput = Readonly<{
     schemaJson?: string;
     supervisor: BodySupervisor;
     runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
+    admitInitialTell(input: InitialTellAdmissionRequest): Promise<CallInitialTellAdmission>;
     world: import("../world.js").WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
     now(): string;

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

@@ -87,8 +87,8 @@ async function startTurnDrive(input) {
             boundAt: input.now(),
         });
     }
-    const { world, paths, soul: parent, runtimeSpawn: spawn, externalCommands } = input;
-    const commands = composeRequestCommands(akumaCallRequestCommands({ world, paths, parent, spawn }), externalCommands);
+    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({
         paths: input.paths,
         allowed: input.soul.allowed,

package/build/src/{library → cli}/catalog.d.ts

@@ -1,10 +1,8 @@
-/** @architectureCompositionRoot */
-import { type AkumaList } from "../akuma/akuma.js";
-import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
+import type { AkumaList } from "../akuma/akuma.js";
+import type { ArchetypeCatalogRow } from "../akuma/archetype.js";
 import type { TaskRow } from "../task/index.js";
-import { type ContractCatalogue } from "./contract.js";
-import { Repo } from "./repo.js";
-import { type WorldRoot } from "../world.js";
+import type { ContractRow } from "../library/contract.js";
+import type { WorldRoot } from "../world.js";
 export type CatalogQuery = Readonly<{
     kind: "tasks";
     namespace?: readonly string[];
@@ -14,33 +12,12 @@ export type CatalogQuery = Readonly<{
     limit?: number;
 }> | Readonly<{
     kind: "archetypes";
+    limit?: number;
 }> | Readonly<{
     kind: "akuma";
     archetype?: string;
     limit?: number;
 }>;
-export type CatalogInput = Readonly<{
-    query: Extract<CatalogQuery, {
-        kind: "tasks";
-    }>;
-    path: WorldRoot;
-}> | Readonly<{
-    query: Extract<CatalogQuery, {
-        kind: "contracts";
-    }>;
-    repo: Repo;
-}> | Readonly<{
-    query: Extract<CatalogQuery, {
-        kind: "archetypes";
-    }>;
-    path?: WorldRoot;
-    home?: string;
-}> | Readonly<{
-    query: Extract<CatalogQuery, {
-        kind: "akuma";
-    }>;
-    path: WorldRoot;
-}>;
 export type Catalog = Readonly<{
     kind: "tasks";
     root: WorldRoot;
@@ -51,11 +28,12 @@ export type Catalog = Readonly<{
     root: string;
     state: string | null;
     observedAt: string;
-    rows: ContractCatalogue["rows"];
+    rows: readonly ContractRow[];
     hasMore: boolean;
 }> | Readonly<{
     kind: "archetypes";
     rows: readonly ArchetypeCatalogRow[];
+    hasMore: boolean;
 }> | Readonly<{
     kind: "akuma";
     root: WorldRoot;
@@ -65,4 +43,3 @@ export type Catalog = Readonly<{
     searched: readonly string[];
     hasMore: boolean;
 }>;
-export declare function listCatalog(input: CatalogInput): Promise<Catalog>;

package/build/src/cli/catalog.js

@@ -0,0 +1 @@
+export {};

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -1,6 +1,6 @@
 import { type AkuId } from "../../akuma/identity.js";
 import { type ActivityHistory } from "../../akuma/akuma.js";
-import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
+import { type AkumaInterruptResult, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import { type WaitSelectedIdentity } from "../render/akuma-activity.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
@@ -12,7 +12,6 @@ export type AkumaInvocationResult = Readonly<{
     action: "call";
     result: CallResult;
     world: WorldRoot;
-    schemaAnswer?: unknown;
     streamed?: boolean;
 }> | Readonly<{
     kind: "akuma";
@@ -50,11 +49,12 @@ export type AkumaInvocationResult = Readonly<{
     result: AkumaTellWaitResult;
     body: string;
     alias?: string;
+    structured?: true;
 }> | Readonly<{
     kind: "akuma";
     action: "tell";
     mode: "interrupt";
-    result: Awaited<ReturnType<typeof Keiyaku.interrupt>>;
+    result: AkumaInterruptResult;
     body: string;
     alias?: string;
 }> | Readonly<{

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

@@ -1,72 +1,36 @@
 import { readFile } from "node:fs/promises";
 import { squareAssignedParticipantName } from "@astrosheep/square";
 import { emitInitiatingPluginSignal } from "../../plugin/akuma-signals.js";
-import { observeAkumaStatus } from "../../akuma/akuma-observe.js";
-import { AuthorityCorruptionError, Keiyaku, } from "../../index.js";
-import { callObservationStream, waitObservationStream } from "../render/akuma-activity.js";
-import { callObservationHead, tellWaitProgressStream } from "../render/akuma.js";
-import { killAkuma, tellAkuma, tellWaitAkuma, waitAkuma } from "../../library/fleet.js";
+import { decodeTellWaitObservation } from "../../akuma/fleet-execution.js";
+import { Akumas, } from "../../index.js";
+import { callObservationStream, inputWaitStream, waitObservationStream, } from "../render/akuma-activity.js";
+import { callObservationHead, tellWaitProgressStream, waitedTellProgress } from "../render/akuma.js";
+import { DEFAULT_CLI_COLUMNS } from "../render/terminal.js";
+import { tellWaitAkuma, waitAkuma } from "../../library/fleet.js";
 import { localExecutionContext } from "../../akuma/requests.js";
 import { Akuma, Schema } from "../../akuma/index.js";
 import { addressAkuma, resolveAkuma } from "../../library/address.js";
 import { executionChannel } from "../../akuma/requests.js";
-import { AkumaDecodeError } from "../../akuma/akuma-errors.js";
 import { requestForwardedFleetTellAnswer } from "../../akuma/fleet-request.js";
-/** The window a call observes for when the caller gives no `--wait` duration. */
-const CALL_TIMEOUT_MS = 300_000;
+function akumas(input) {
+    return Akumas.of(input.path, { execution: input.execution ?? localExecutionContext() });
+}
 function callSignalOption(signal) {
     return signal === undefined ? {} : { signal };
 }
-function integrationFailure(error) {
-    return {
-        kind: error instanceof AuthorityCorruptionError ? "authority-corruption" : "infrastructure",
-        diagnostic: error instanceof Error ? error.message : String(error),
-    };
-}
 /** The display context the command result renders with, so live progress rows match the result. */
 function resultContext() {
     const tty = process.stderr.isTTY === true;
     return {
-        columns: tty && Number.isInteger(process.stderr.columns) ? process.stderr.columns : 80,
+        columns: tty && Number.isInteger(process.stderr.columns) ? process.stderr.columns : DEFAULT_CLI_COLUMNS,
         color: tty && process.env.NO_COLOR === undefined,
     };
 }
 function writeProgress(body) {
+    if (body.length === 0)
+        return;
     process.stderr.write(body.endsWith("\n") ? body : `${body}\n`);
 }
-/**
- * The live half of an observe-mode call: the resolved birth opens one identity
- * frame (never the detached receipt's cwd row), each later observation prints
- * the settled rows that arrived since the previous one, and the return appends
- * one conclusion. The stream is append-only, so no final snapshot replays.
- */
-async function observeCallUntilComplete(command, input, born) {
-    const stream = callObservationStream(resultContext(), callObservationHead(born));
-    try {
-        const observed = await observeAkumaStatus(input.path, born.akuma, {
-            timeoutMs: command.timeoutMs ?? CALL_TIMEOUT_MS,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-            observe: (observed) => {
-                const lines = stream.observe(observed);
-                if (lines.length > 0)
-                    writeProgress(lines.join("\n"));
-            },
-        });
-        const conclusion = stream.conclude({ kind: "observed", reason: observed.reason, status: observed.status });
-        if (conclusion.length > 0)
-            writeProgress(conclusion);
-        return { kind: "observed", reason: observed.reason, status: observed.status };
-    }
-    catch (error) {
-        if (input.signal?.aborted)
-            throw error;
-        const failure = integrationFailure(error);
-        const conclusion = stream.conclude({ kind: "failed", failure });
-        if (conclusion.length > 0)
-            writeProgress(conclusion);
-        return { kind: "failed", failure };
-    }
-}
 async function schemaFromFile(path) {
     try {
         const parsed = JSON.parse(await readFile(path, "utf8"));
@@ -166,30 +130,13 @@ async function inputInitiator(input) {
     }
     return { initiator };
 }
-function decodeWaitedTellSchema(result, schema) {
-    if (result.observation.reason !== "answered")
-        return result;
-    if (typeof result.observation.answer !== "string") {
-        throw new AkumaDecodeError("Answer is not valid JSON", String(result.observation.answer));
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(result.observation.answer);
-    }
-    catch (error) {
-        throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer is not valid JSON", result.observation.answer);
-    }
-    try {
-        return { ...result, observation: { reason: "answered", answer: schema.decode(parsed) } };
-    }
-    catch (error) {
-        throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer failed schema decode", result.observation.answer);
-    }
-}
 async function invokeWaitedTell(command, input, body) {
     const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
     const alias = inputAlias(command.akuma);
-    const progress = command.output === "text" ? tellWaitProgressStream(undefined, alias, resultContext()) : undefined;
+    const channel = executionChannel(input.execution);
+    const progress = command.output === "text" && channel.kind === "local"
+        ? tellWaitProgressStream(undefined, alias, resultContext())
+        : undefined;
     const result = await tellWaitAkuma({
         ...(await inputInitiator(input)),
         path: input.path,
@@ -209,9 +156,11 @@ async function invokeWaitedTell(command, input, body) {
                 },
             }),
     }, input.execution ?? localExecutionContext());
-    const rendered = schema === undefined ? result : decodeWaitedTellSchema(result, schema);
+    const rendered = schema === undefined ? result : { ...result, observation: decodeTellWaitObservation(result.observation, schema) };
     if (progress !== undefined)
         writeProgress(progress.conclude(rendered).join("\n"));
+    else if (command.output === "text" && channel.kind === "body-request")
+        writeProgress(waitedTellProgress(rendered, alias, resultContext()));
     return {
         kind: "akuma",
         action: "tell",
@@ -219,6 +168,7 @@ async function invokeWaitedTell(command, input, body) {
         result: rendered,
         body,
         ...(alias === undefined ? {} : { alias }),
+        ...(schema === undefined ? {} : { structured: true }),
     };
 }
 async function invokeTell(command, input) {
@@ -265,9 +215,8 @@ async function invokeTell(command, input) {
     }
     const initiator = await inputInitiator(input);
     if (command.interrupt) {
-        const result = await Keiyaku.interrupt({
+        const result = await akumas(input).interrupt({
             ...initiator,
-            path: input.path,
             akuma: command.akuma,
             body,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
@@ -283,20 +232,18 @@ async function invokeTell(command, input) {
             ...(alias === undefined ? {} : { alias }),
         };
     }
-    const result = await tellAkuma({
+    const result = await akumas(input).tell({
         ...initiator,
-        path: input.path,
         akuma: command.akuma,
         body,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
-    }, input.execution ?? localExecutionContext());
+    });
     const alias = inputAlias(command.akuma);
     return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
 }
 async function invokeHistory(command, input) {
-    const result = await Keiyaku.history({
-        path: input.path,
+    const result = await akumas(input).history({
         akuma: command.akuma,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(command.before === undefined ? {} : { before: command.before }),
@@ -324,8 +271,7 @@ async function invokeFork(command, input) {
     return {
         kind: "akuma",
         action: "fork",
-        receipt: await Keiyaku.fork({
-            path: input.path,
+        receipt: await akumas(input).fork({
             akuma: command.akuma,
             at: command.at,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
@@ -337,12 +283,11 @@ async function invokeKill(command, input) {
     return {
         kind: "akuma",
         action: "kill",
-        result: await killAkuma({
-            path: input.path,
+        result: await akumas(input).kill({
             akuma: command.akuma,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
-        }, input.execution ?? localExecutionContext()),
+        }),
         ...(alias === undefined ? {} : { alias }),
     };
 }
@@ -351,10 +296,9 @@ export async function invokeAkuma(command, input) {
         case "call": {
             const body = await promptBody(command, input);
             const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
-            const caller = input.execution === undefined ? Keiyaku : Keiyaku.withExecution({ execution: input.execution });
+            const caller = akumas(input);
             const request = {
                 ...(await inputInitiator(input)),
-                path: input.path,
                 archetype: command.archetype,
                 body,
                 ...(input.home === undefined ? {} : { home: input.home }),
@@ -366,19 +310,48 @@ export async function invokeAkuma(command, input) {
                 ...(schema === undefined ? {} : { schema }),
                 ...callSignalOption(input.signal),
             };
-            const observing = schema === undefined && command.mode === "wait" && command.output === "text";
-            const born = await caller.call(observing
-                ? { ...request, mode: "detach" }
-                : {
-                    ...request,
-                    mode: command.mode,
-                    ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-                });
-            const result = observing ? { ...born, observation: await observeCallUntilComplete(command, input, born) } : born;
-            if (schema !== undefined && command.mode === "wait" && result.schemaAnswer !== undefined) {
-                return { kind: "akuma", action: "call", result, world: input.path, schemaAnswer: result.schemaAnswer };
+            let stream;
+            const observing = command.mode === "wait" && command.output === "text";
+            const observe = observing
+                ? {
+                    admitted: (tell, id, head) => {
+                        stream = callObservationStream(resultContext(), callObservationHead({ akuma: id, ...head }), {
+                            admittedAt: tell.row.at,
+                        });
+                    },
+                    observe: (observation) => {
+                        const lines = stream?.observe(observation) ?? [];
+                        if (lines.length > 0)
+                            writeProgress(lines.join("\n"));
+                    },
+                }
+                : undefined;
+            const result = await caller.call({
+                ...request,
+                mode: command.mode,
+                ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
+                ...(observe === undefined ? {} : { observe }),
+            });
+            let streamed = stream !== undefined;
+            if (stream !== undefined) {
+                writeProgress(stream.conclude(result.observation));
             }
-            return { kind: "akuma", action: "call", result, world: input.path, ...(observing ? { streamed: true } : {}) };
+            else if (observing && result.observation.kind === "failed") {
+                const fallback = inputWaitStream(resultContext(), () => callObservationHead({
+                    akuma: result.akuma,
+                    dispatch: result.dispatch,
+                    alias: result.alias,
+                }), { cursor: "empty", answerSeparator: true });
+                writeProgress(fallback.conclude({ kind: "failed", diagnostic: result.observation.failure.diagnostic }));
+                streamed = true;
+            }
+            return {
+                kind: "akuma",
+                action: "call",
+                result,
+                world: input.path,
+                ...(streamed ? { streamed: true } : {}),
+            };
         }
         case "wait":
             return await invokeWait(command, input);
@@ -396,7 +369,7 @@ export async function invokeAkumaStatus(path, akuma, alias, repo) {
     return {
         kind: "akuma",
         action: "status",
-        status: await Keiyaku.status({ path, akuma, ...(repo === undefined ? {} : { repo }) }),
+        status: await Akumas.of(path).status({ akuma, ...(repo === undefined ? {} : { repo }) }),
         ...(alias === undefined ? {} : { alias }),
     };
 }