@astrosheep/keiyaku 4.0.5 → 4.0.6

package/build/src/akuma/nuke.js

@@ -0,0 +1,152 @@
+import { lstat, readdir, rm } from "node:fs/promises";
+import { nukeAliases } from "../alias/index.js";
+import { CONTROL_RESPONSE_MS } from "./body.js";
+import { HeldAkumaLeash, readHeart, readKill, requestStop, } from "./heart/index.js";
+import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, } from "./identity.js";
+const POLL_MS = 25;
+async function hasAkumaCustody(paths) {
+    try {
+        const value = await lstat(paths.heart);
+        return value.isFile() && !value.isSymbolicLink();
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return false;
+    }
+}
+function wait(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function takeLeashUntil(paths, deadline) {
+    for (;;) {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        if (performance.now() >= deadline)
+            return null;
+        await wait(POLL_MS);
+    }
+}
+async function stopRunningAkuma(entry) {
+    const request = await requestStop(entry.paths, new Date().toISOString());
+    const leash = await takeLeashUntil(entry.paths, performance.now() + CONTROL_RESPONSE_MS);
+    if (leash === null)
+        throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+    try {
+        if (request.kind === "already-killed" || request.kind === "already-stopped")
+            return leash;
+        if (await readKill(entry.paths, request.body.sequence) !== null)
+            return leash;
+        const current = await readHeart(entry.paths);
+        if (current.latestBody?.sequence !== request.body.sequence) {
+            if (await readKill(entry.paths, request.body.sequence) !== null)
+                return leash;
+            throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+        }
+        if (current.latestBody.end !== "put-down") {
+            await leash.clearStop(entry.paths);
+            throw new Error(`Akuma ${entry.id} could not be stopped: untidy`);
+        }
+        if (await leash.settleStop(entry.paths, request.body.sequence) === null) {
+            throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+        }
+        return leash;
+    }
+    catch (error) {
+        leash.release();
+        throw error;
+    }
+}
+async function removeRegularFile(path) {
+    try {
+        const value = await lstat(path);
+        if (value.isFile() && !value.isSymbolicLink())
+            await rm(path, { force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function removeAkumaEntry(entry) {
+    for (const path of [entry.paths.heart, entry.paths.log,
+        `${entry.paths.heart}-wal`, `${entry.paths.heart}-shm`]) {
+        await removeRegularFile(path);
+    }
+}
+async function nukeAkumaEntries(world) {
+    const runRoot = akumaRunRoot(world);
+    let names;
+    try {
+        names = (await readdir(runRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            names = [];
+        else
+            throw error;
+    }
+    const entries = [];
+    for (const name of names) {
+        let physical;
+        try {
+            physical = akuIdFromDirectoryName(name);
+        }
+        catch {
+            // The run root can contain bytes not produced by Keiyaku. Preserve them.
+            continue;
+        }
+        const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
+        if (!(await hasAkumaCustody(paths)))
+            continue;
+        entries.push({ id: physical.id, paths });
+    }
+    return entries;
+}
+export async function stopAkuma(world) {
+    const entries = await nukeAkumaEntries(world);
+    const held = [];
+    try {
+        for (const entry of entries) {
+            const snapshot = await readHeart(entry.paths);
+            const leash = snapshot.soul !== null && snapshot.latestBody?.end === undefined
+                ? await stopRunningAkuma(entry)
+                : await takeLeashUntil(entry.paths, performance.now() + CONTROL_RESPONSE_MS);
+            if (leash === null)
+                throw new Error(`Akuma ${entry.id} could not be verified stopped`);
+            try {
+                const after = await readHeart(entry.paths);
+                if (after.soul === null || after.latestBody?.end !== undefined) {
+                    held.push(leash);
+                    continue;
+                }
+                throw new Error(`Akuma ${entry.id} stopped without a durable end`);
+            }
+            catch (error) {
+                leash.release();
+                throw error;
+            }
+        }
+        return async () => {
+            try {
+                await nukeAliases(world);
+                for (const entry of entries)
+                    await removeAkumaEntry(entry);
+            }
+            finally {
+                for (const leash of held.reverse())
+                    leash.release();
+            }
+        };
+    }
+    finally {
+        if (held.length !== entries.length) {
+            for (const leash of held.reverse())
+                leash.release();
+        }
+    }
+}

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

@@ -121,8 +121,10 @@ export type Session = Readonly<{
     events: AsyncIterable<AgentEvent>;
     receipts?: AsyncIterable<TellReceipt>;
     completion: Promise<TurnResult>;
-    /** Fulfills after every adapter-owned OS child or native session is disposed. */
+    /** Requests graceful adapter-owned cancellation. */
     abort(): Promise<void>;
+    /** Fulfills only after forced adapter-owned disposal is proved. */
+    forceDispose(): Promise<void>;
     tell?(tell: Readonly<{
         id: string;
         text: string;

package/build/src/akuma/providers/acp/config.d.ts

@@ -0,0 +1,8 @@
+export type AcpExecutionConfig = Readonly<{
+    argvBefore: readonly string[];
+    argvAfter: readonly string[];
+    modelArg?: string;
+    effortArg?: string;
+    systemPromptArg?: string;
+}>;
+export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;

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

@@ -0,0 +1,37 @@
+function argumentName(value, key) {
+    const selected = value[key];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
+    }
+    return selected;
+}
+export function decodeAcpConfig(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("ACP provider config must be an object");
+    }
+    const config = value;
+    const unknown = Object.keys(config)
+        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg"].includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
+    if (!Array.isArray(config.argvBefore)
+        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
+    }
+    if (!Array.isArray(config.argvAfter)
+        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
+    }
+    const modelArg = argumentName(config, "modelArg");
+    const effortArg = argumentName(config, "effortArg");
+    const systemPromptArg = argumentName(config, "systemPromptArg");
+    return Object.freeze({
+        argvBefore: Object.freeze([...config.argvBefore]),
+        argvAfter: Object.freeze([...config.argvAfter]),
+        ...(modelArg === undefined ? {} : { modelArg }),
+        ...(effortArg === undefined ? {} : { effortArg }),
+        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
+    });
+}

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

@@ -122,6 +122,12 @@ function beginAcpPrompt(agent, child, turn, sessionId, input) {
             else
                 await turn.finish(result, () => child.close(true));
         },
+        forceDispose: async () => {
+            if (!turn.open())
+                await child.close(true);
+            else
+                await turn.finish({ kind: "failed", diagnostic: "ACP turn force-disposed" }, () => child.close(true));
+        },
     };
 }
 export async function startAcpSession(launch, input, dependencies = {}) {

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

@@ -1,12 +1,5 @@
 import type { ProviderAdapter } from "../../provider.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type AcpDependencies } from "./core.js";
-export type AcpExecutionConfig = Readonly<{
-    argvBefore: readonly string[];
-    argvAfter: readonly string[];
-    modelArg?: string;
-    effortArg?: string;
-    systemPromptArg?: string;
-}>;
-export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;
+export { decodeAcpConfig, type AcpExecutionConfig } from "./config.js";
 export declare function createAcpProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

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

@@ -1,41 +1,6 @@
+import { decodeAcpConfig } from "./config.js";
 import { startAcpSession } from "./core.js";
-function argumentName(value, key) {
-    const selected = value[key];
-    if (selected === undefined)
-        return undefined;
-    if (typeof selected !== "string" || selected.trim().length === 0) {
-        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
-    }
-    return selected;
-}
-export function decodeAcpConfig(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new TypeError("ACP provider config must be an object");
-    }
-    const config = value;
-    const unknown = Object.keys(config)
-        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg"].includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
-    if (!Array.isArray(config.argvBefore)
-        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
-        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
-    }
-    if (!Array.isArray(config.argvAfter)
-        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
-        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
-    }
-    const modelArg = argumentName(config, "modelArg");
-    const effortArg = argumentName(config, "effortArg");
-    const systemPromptArg = argumentName(config, "systemPromptArg");
-    return Object.freeze({
-        argvBefore: Object.freeze([...config.argvBefore]),
-        argvAfter: Object.freeze([...config.argvAfter]),
-        ...(modelArg === undefined ? {} : { modelArg }),
-        ...(effortArg === undefined ? {} : { effortArg }),
-        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
-    });
-}
+export { decodeAcpConfig } from "./config.js";
 function optionAdmission(options, config) {
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "ACP provider does not support the network option" };

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

@@ -269,6 +269,11 @@ async function driveClaude(load, execution, drive) {
         },
         async abort() {
             shutDown(new Error("Claude query aborted"));
+            await observed.completion;
+        },
+        async forceDispose() {
+            shutDown(new Error("Claude query force-disposed"));
+            await observed.completion;
         },
     };
 }

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

@@ -182,6 +182,11 @@ async function startCodex(execution, input) {
         events,
         completion,
         abort: () => abortTurn(server, state, finish),
+        forceDispose: async () => {
+            if (!state.settled)
+                settle({ kind: "failed", diagnostic: "codex app-server force-disposed" });
+            await server.close(true);
+        },
         tell: (tell) => steerTurn(server, state, tell),
     };
 }

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

@@ -10,7 +10,7 @@ function object(value) {
 }
 function nativeName(update) {
     const wire = update;
-    return nonblank(update.name) ?? nonblank(wire.toolName);
+    return nonblank(update.name) ?? nonblank(update.title) ?? nonblank(wire.toolName);
 }
 function readCall(name, input) {
     if (name !== "read_file" && name !== "hashline_read")

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

@@ -1,6 +1,7 @@
 import type { ProviderAdapter } from "../provider.js";
 import { type ProviderExecution } from "../provider-recipe.js";
-export declare function resolveProviderExecution(input: unknown): Readonly<{
+export declare function decodeProviderExecution(input: unknown): ProviderExecution;
+export declare function resolveProviderExecution(input: unknown): Promise<Readonly<{
     execution: ProviderExecution;
     adapter: ProviderAdapter;
-}>;
+}>>;

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

@@ -1,50 +1,50 @@
 import { decodeProviderRecipe } from "../provider-recipe.js";
-import { createAcpProvider, decodeAcpConfig } from "./acp/index.js";
-import { claudeProvider, createClaudeProvider } from "./claude/index.js";
-import { createCodexAppServerProvider } from "./codex-app-server/index.js";
-import { createGrokBuildProvider } from "./grok-build/index.js";
-import { createOpencodeProvider } from "./opencode-sdk/index.js";
-import { createPiProvider } from "./pi/index.js";
-const PROVIDERS = {
-    claude: claudeProvider,
-};
-function providerConfig(execution) {
-    const { config, kind } = execution;
-    if (kind === "claude-agent-sdk" && config !== undefined)
-        throw new TypeError("provider execution config is unsupported by claude-agent-sdk");
-    if (kind === "opencode-sdk" && config !== undefined)
-        throw new TypeError("provider execution config is unsupported by opencode-sdk");
-    if (kind === "acp")
-        return decodeAcpConfig(config);
-    return config;
+import { decodeAcpConfig } from "./acp/config.js";
+export function decodeProviderExecution(input) {
+    const decoded = decodeProviderRecipe(input);
+    if ((decoded.kind === "claude-agent-sdk" || decoded.kind === "opencode-sdk") && decoded.config !== undefined) {
+        throw new TypeError(`provider execution config is unsupported by ${decoded.kind}`);
+    }
+    if (decoded.kind === "pi") {
+        if (decoded.executable !== undefined || decoded.config !== undefined) {
+            throw new TypeError("Pi provider does not support executable or config");
+        }
+        if (decoded.env !== undefined && Object.keys(decoded.env).length > 0) {
+            throw new TypeError("env injection not supported for provider pi");
+        }
+    }
+    if (decoded.kind === "grok-build" && decoded.config !== undefined) {
+        throw new TypeError("Grok Build does not support execution config");
+    }
+    const config = decoded.kind === "acp" ? decodeAcpConfig(decoded.config) : decoded.config;
+    return Object.freeze({
+        name: decoded.name,
+        kind: decoded.kind,
+        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
+        ...(config === undefined ? {} : { config }),
+        ...(decoded.env === undefined ? {} : { env: decoded.env }),
+    });
 }
-function adapterFor(execution) {
+async function adapterFor(execution) {
     if (execution.kind === "acp")
-        return createAcpProvider(execution);
+        return (await import("./acp/index.js")).createAcpProvider(execution);
     if (execution.kind === "claude-agent-sdk") {
+        const { claudeProvider, createClaudeProvider } = await import("./claude/index.js");
         return execution.executable === undefined && execution.env === undefined
-            ? PROVIDERS.claude
+            ? claudeProvider
             : createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"), execution);
     }
     if (execution.kind === "codex-app-server")
-        return createCodexAppServerProvider(execution);
+        return (await import("./codex-app-server/index.js")).createCodexAppServerProvider(execution);
     if (execution.kind === "grok-build")
-        return createGrokBuildProvider(execution);
+        return (await import("./grok-build/index.js")).createGrokBuildProvider(execution);
     if (execution.kind === "opencode-sdk")
-        return createOpencodeProvider(execution);
+        return (await import("./opencode-sdk/index.js")).createOpencodeProvider(execution);
     if (execution.kind === "pi")
-        return createPiProvider(execution);
+        return (await import("./pi/index.js")).createPiProvider(execution);
     throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);
 }
-export function resolveProviderExecution(input) {
-    const decoded = decodeProviderRecipe(input);
-    const config = providerConfig(decoded);
-    const execution = Object.freeze({
-        name: decoded.name,
-        kind: decoded.kind,
-        ...(decoded.executable === undefined ? {} : { executable: decoded.executable }),
-        ...(config === undefined ? {} : { config }),
-        ...(decoded.env === undefined ? {} : { env: decoded.env }),
-    });
-    return Object.freeze({ execution, adapter: adapterFor(execution) });
+export async function resolveProviderExecution(input) {
+    const execution = decodeProviderExecution(input);
+    return Object.freeze({ execution, adapter: await adapterFor(execution) });
 }

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

@@ -195,6 +195,11 @@ function terminalSettlement(events, close) {
     });
     return { completion, finish };
 }
+async function forceDisposeOpencode(abortController, close, finish) {
+    abortController.abort();
+    await close();
+    await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
+}
 async function drive(execution, input, loader) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
@@ -256,6 +261,7 @@ async function drive(execution, input, loader) {
                 void session.abort({ path: { id: sessionId }, query: { directory: input.cwd }, throwOnError: true }).catch(() => undefined);
                 await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
             },
+            forceDispose: () => forceDisposeOpencode(abortController, closeOnce, finish),
         };
     }
     catch (error) {

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

@@ -1,4 +1,4 @@
-import { type OpencodeClient } from "@opencode-ai/sdk";
+import type { OpencodeClient } from "@opencode-ai/sdk";
 import type { ResumeCoordinate } from "../../heart/index.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 export type OpencodeSdkSession = Pick<OpencodeClient["session"], "create" | "get" | "fork" | "abort" | "promptAsync" | "messages">;

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

@@ -1,7 +1,6 @@
 import net from "node:net";
 import { abortable } from "../../abort.js";
 import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
-import { createOpencodeClient } from "@opencode-ai/sdk";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
 export function parseModel(model) {
     const slash = model.indexOf("/");
@@ -50,6 +49,7 @@ export async function loadOpencode(execution, cwd, signal, loader) {
         env: { ...process.env, ...execution.env },
         log: `${cwd}/.opencode.log`,
     });
+    const { createOpencodeClient } = await import("@opencode-ai/sdk");
     const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
     try {
         await waitReady(client, cwd, signal);

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

@@ -1,4 +1,4 @@
-import { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, type CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
+import type { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, CreateAgentSessionOptions } from "@earendil-works/pi-coding-agent";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type ProviderAdapter } from "../../provider.js";
 export type PiSdk = Readonly<{

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

@@ -1,4 +1,3 @@
-import { createAgentSession, createBashToolDefinition, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { abortable } from "../../abort.js";
 import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
@@ -41,6 +40,14 @@ async function piCreateOptions(sdk, input) {
         : "sessionFile" in input.session.coordinate
             ? sdk.SessionManager.open(input.session.coordinate.sessionFile)
             : (() => { throw new Error("Pi resume requires sessionFile"); })();
+    const customTools = input.requests === undefined || input.options.readonly === true
+        ? undefined
+        : [(await import("@earendil-works/pi-coding-agent")).createBashToolDefinition(input.cwd, {
+                spawnHook: (context) => ({
+                    ...context,
+                    env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
+                }),
+            })];
     return {
         cwd: input.cwd,
         sessionManager,
@@ -48,20 +55,19 @@ async function piCreateOptions(sdk, input) {
         ...(resourceLoader === undefined ? {} : { resourceLoader }),
         ...(input.options.effort === undefined ? {} : { thinkingLevel: input.options.effort }),
         ...(input.options.readonly === undefined ? {} : { tools: ["read", "grep", "find", "ls"] }),
-        ...(input.requests === undefined || input.options.readonly === true
-            ? {}
-            : { customTools: [createBashToolDefinition(input.cwd, {
-                        spawnHook: (context) => ({
-                            ...context,
-                            env: { ...context.env, [AKUMA_REQUESTS_ENV]: input.requests.dir },
-                        }),
-                    })] }),
+        ...(customTools === undefined ? {} : { customTools }),
     };
 }
 async function createPiSession(sdk, input, signal) {
     const setup = piCreateOptions(sdk, input).then(async (options) => await sdk.createAgentSession(options));
     return await abortable(setup, signal, (created) => created.session.dispose());
 }
+function forceDisposePi(dispose, settle, setAborting) {
+    setAborting();
+    dispose();
+    settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
+    return Promise.resolve();
+}
 async function drivePi(sdk, input, signal) {
     const created = await createPiSession(sdk, input, signal);
     const native = created.session;
@@ -155,6 +161,7 @@ async function drivePi(sdk, input, signal) {
             })();
             return abortRequest;
         },
+        forceDispose: () => forceDisposePi(dispose, settle, () => { aborting = true; }),
     };
 }
 function piSessionFile(coordinate) {
@@ -170,8 +177,17 @@ async function forkPi(sdk, input) {
         throw new Error("Pi fork did not create a distinct child session file");
     return { session: { sessionFile: child } };
 }
-const defaultSdk = { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager };
-export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = async () => defaultSdk) {
+async function loadPiSdk() {
+    const sdk = await import("@earendil-works/pi-coding-agent");
+    return {
+        createAgentSession: sdk.createAgentSession,
+        DefaultResourceLoader: sdk.DefaultResourceLoader,
+        getAgentDir: sdk.getAgentDir,
+        ModelRuntime: sdk.ModelRuntime,
+        SessionManager: sdk.SessionManager,
+    };
+}
+export function createPiProvider(execution = { name: "pi", kind: "pi" }, load = loadPiSdk) {
     if (execution.executable !== undefined || execution.config !== undefined) {
         throw new TypeError("Pi provider does not support executable or config");
     }

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

@@ -41,6 +41,7 @@ export type UpstreamExecutionPort = Readonly<{
     deliver(input: ContractCall & Readonly<{
         message?: string;
         includeDirty: boolean;
+        materializeConflict: boolean;
     }>): Promise<Readonly<{
         result: unknown;
         deliveryFactId?: string;

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

@@ -222,6 +222,7 @@ async function executeDeliver(input, request) {
         contractId: request.contractId,
         ...(request.message === undefined ? {} : { message: request.message }),
         includeDirty: request.includeDirty,
+        materializeConflict: request.materializeConflict,
         requester: request.requester,
         signal: input.signal,
     });
@@ -303,12 +304,8 @@ async function serveUpstream(input) {
     try {
         const served = await execute(input, request);
         outcome = { kind: "returned", result: served.result };
-        if (served.service === undefined) {
-            fact = await voidRequest(input.paths, request.id, "body completed without a durable Contract fact reference");
-            await projectReceipt(input.directory, fact);
-            return;
-        }
-        service = served.service;
+        if (served.service !== undefined)
+            service = served.service;
     }
     catch (error) {
         outcome = { kind: "failed", failure: failure(error) };
@@ -368,37 +365,40 @@ export class BodyRequestPump {
         return new BodyRequestPump(input);
     }
     async run() {
-        try {
-            while (!this.closeSignal.signal.aborted) {
-                for (const name of await requestFiles(this.directory)) {
-                    if (this.closeSignal.signal.aborted)
-                        return;
-                    const id = name.slice(0, -".request.json".length);
-                    if (this.handled.has(id))
-                        continue;
-                    const claim = decodeClaim(await readFile(join(this.directory, name), "utf8"), id);
-                    if (claim !== null && !this.admissionClosed) {
-                        await serve({
-                            directory: this.directory,
-                            claim,
-                            ...this.input,
-                            signal: this.executionSignal.signal,
-                            admissionOpen: () => !this.admissionClosed,
-                        });
-                    }
+        while (!this.closeSignal.signal.aborted) {
+            for (const name of await requestFiles(this.directory)) {
+                if (this.closeSignal.signal.aborted)
+                    return;
+                const id = name.slice(0, -".request.json".length);
+                if (this.handled.has(id))
+                    continue;
+                const path = join(this.directory, name);
+                const claim = decodeClaim(await readFile(path, "utf8"), id);
+                if (claim === null) {
+                    await rm(path, { force: true });
                     this.handled.add(id);
+                    continue;
                 }
-                try {
-                    await abortableDelay(POLL_MS, this.closeSignal.signal);
+                if (!this.admissionClosed) {
+                    await serve({
+                        directory: this.directory,
+                        claim,
+                        ...this.input,
+                        signal: this.executionSignal.signal,
+                        admissionOpen: () => !this.admissionClosed,
+                    });
                 }
-                catch {
+                this.handled.add(id);
+            }
+            try {
+                await abortableDelay(POLL_MS, this.closeSignal.signal);
+            }
+            catch (error) {
+                if (this.closeSignal.signal.aborted)
                     return;
-                }
+                throw error;
             }
         }
-        catch {
-            // Request transport loss is recovered from Heart on the next Body.
-        }
     }
     async close() {
         this.stopAdmission();