@plurnk/plurnk-service 4.2.1 → 4.3.1

package/dist/schemes/Exec.js

@@ -1,11 +1,11 @@
 import { parsePath } from "@plurnk/plurnk-parser";
-import { PathSyntax } from "@plurnk/plurnk-contracts";
-import { WebMaterializationError, } from "@plurnk/plurnk-schemes";
+import { errnoCode, isExecutionOp, PathSyntax } from "@plurnk/plurnk-contracts";
+import {} from "@plurnk/plurnk-contracts";
+import { InvalidOperationResultError, MetadataOptions, } from "@plurnk/plurnk-schemes";
 import FunctionalityManager from "../server/FunctionalityManager.js";
 import EffectPolicy from "./EffectPolicy.js";
 import EntryCrud from "./_entry-crud.js";
 import EntryFind from "./_entry-find.js";
-import { MetadataOptions } from "@plurnk/plurnk-schemes";
 import ChannelWrite, {} from "../core/ChannelWrite.js";
 import LiveSubscription from "../core/LiveSubscription.js";
 import EnvFunctionality, {} from "../server/EnvFunctionality.js";
@@ -17,22 +17,13 @@ import { extname, isAbsolute, resolve } from "node:path";
 import { CoreSchemeAdapterBase } from "../core/CoreSchemeServices.js";
 import ErrorDetail from "../core/ErrorDetail.js";
 import Results, { OperationFailureError } from "../core/results.js";
-import { InvalidOperationResultError, NetworkAddress, ResourceNames, } from "@plurnk/plurnk-schemes";
-import DbProjectionCaps from "../core/caps/DbProjectionCaps.js";
-import WorkerControlAddress from "../core/WorkerControlAddress.js";
-import Turn from "../core/Turn.js";
-import AdministrativeLoop from "../core/AdministrativeLoop.js";
-import RuntimeWorker from "../core/RuntimeWorker.js";
-import LoopLifecycle from "../core/LoopLifecycle.js";
-import LogEntryProjection from "../core/LogEntryProjection.js";
-import LogBody from "../core/LogBody.js";
 import ToolResources from "../core/ToolResources.js";
 import { setTimeout as delay } from "node:timers/promises";
 import ExecScheduler, { readExecConcurrency } from "./ExecScheduler.js";
 import ExecScratch from "./ExecScratch.js";
 import ExecutionInput from "./ExecutionInput.js";
 import { execRouteOf } from "./exec-runtime.js";
-import {} from "@plurnk/plurnk-contracts";
+import ExecEntrySink, {} from "./exec-entry-sink.js";
 // Executors are discovered + probed at boot into ExecutorRegistry and reach
 // the scheme through ctx.executors ({§exec-registry-resolves}). Each runtime tag
 // resolves to its sibling executor; the scheme itself stays runtime-agnostic.
@@ -216,22 +207,90 @@ export default class Exec extends CoreSchemeAdapterBase {
     // applyResolution spawns the subprocess; output streams into the
     // coordinate-stamped <runtime>:///<pathname> entry's stdout/stderr channels
     // (e.g. sh:///1/1/2/sh, {§exec}). The model READs that entry on a subsequent turn.
+    //
+    // Admission runs in the order its refusals are owed — the executor, its tool, the fence's shape,
+    // the target's routing, the service's reserved metadata, the executor's preparation, a script
+    // target's existence — and each step returns either the refusal or what the next step needs.
     async exec(statement, ctx) {
         const core = this.coreContext(ctx);
         const body = statement.body ?? "";
-        if (core.executors === undefined)
+        const { executors } = core;
+        if (executors === undefined)
             throw new Error("exec dispatched without an executor registry");
         // {§exec-executor-slot}: the fence names the executor; the path is its program.
         const route = execRouteOf(statement);
         const runtime = route.runtime;
+        const resolved = Exec.#admitRuntime(executors, core.workspaceId, runtime);
+        if ("status" in resolved)
+            return resolved;
+        this.#prepareExecution();
+        const invocation = Exec.#admitTool(executors, core.workspaceId, resolved, runtime, route.target === null ? null : route.target.raw);
+        if ("status" in invocation)
+            return invocation;
+        const hasBody = body.length > 0;
+        const execTarget = route.target;
+        const hasTarget = execTarget !== null;
+        const shape = Exec.#checkInvocationShape(invocation, runtime, execTarget?.raw, hasBody, hasTarget);
+        if (shape !== null)
+            return shape;
+        const routed = await this.#routeTarget(core, { runtime, invocation, execTarget, hasBody });
+        if ("status" in routed)
+            return routed;
+        const { defaultCwd, resourceSource } = routed;
+        let { target } = routed;
+        let cwd = defaultCwd;
+        let inputDeclared = false;
+        const lifetime = Exec.#readReservedMetadata(statement, runtime);
+        if ("status" in lifetime)
+            return lifetime;
+        // {§executor-metadata} Options belong to the invoked executor for every source kind.
+        const prepared = await Exec.#prepareInvocation(resolved.executor, statement, { runtime, body, target: resourceSource ?? target, cwd });
+        if ("status" in prepared)
+            return prepared;
+        ({ cwd, inputDeclared } = prepared);
+        // A `script` target must be an existing file; other kinds pass through as declared.
+        if (target !== null && invocation.target?.kind === "script") {
+            const inspected = await Exec.#inspectScriptTarget(core, { runtime, target, cwd, defaultCwd, hasBody });
+            if ("status" in inspected)
+                return inspected;
+            ({ target, cwd } = inspected);
+        }
+        if (!hasBody && target === null && resourceSource === null) {
+            return Exec.#refuse(runtime, "input-required", `Executable tool '${runtime}' has no executable body or realized target.`, `Provide a ${invocation.body.role} body or a non-directory target.`);
+        }
+        // One logical target derives one effect fact before policy consumes it.
+        // A non-file resource keeps its exact authored address until materialization.
+        const effectTarget = resourceSource ?? target;
+        const effect = resolved.executor.effect(effectTarget);
+        // cwd is the workspace project_root unless target routing selected a
+        // directory override. {§exec-target-routing}, {§executor-sinks}
+        // The log writer claims the workspace output address before proposal application.
+        // {§exec-lifetime} — how long the spawn may live is the metadata's one field; the scope slot
+        // is text coordinates, which an execution has none of.
+        const attrs = {
+            runtime, cwd, body, target, pathname: "", effect,
+            ...(inputDeclared ? { input: "open" } : {}),
+            ...(resourceSource !== null ? { resourceSource } : {}),
+            ...lifetime,
+        };
+        const previewInput = body !== "" ? body : execTarget?.raw ?? "";
+        const preview = runtime !== "" ? `[${runtime}] ${previewInput}` : `$ ${previewInput}`;
+        return { status: 202, body: preview, attrs }; // host runtime proposes with 202 — {§exec-host-proposes}
+    }
+    // A refusal of the fence as written: 400, the runtime named, and the working form when there is one.
+    static #refuse(runtime, code, detail, recovery, extensions = {}) {
+        return Results.failure("scheme:exec", code, 400, detail, {}, { runtime, ...(recovery === undefined ? {} : { recovery }), retryable: false, ...extensions });
+    }
+    // The executor the fence names, or the refusal: unregistered, unavailable, or unconfigured.
+    static #admitRuntime(executors, workspaceId, runtime) {
         // {§exec-registry-resolves} — a non-empty tag selects exactly one registered executable
         // tool. Unknown tags are not reinterpreted as shell command words: that would make the
         // executed command differ from the authored body.
-        const resolved = core.executors.entry(runtime, core.workspaceId);
+        const resolved = executors.entry(runtime, workspaceId);
         if (resolved === undefined) {
             return Results.failure("scheme:exec", "executor-not-registered", 400, `No executor or MCP service named \`${runtime}\` is registered for this worker.`, {}, {
                 requestedRuntime: runtime,
-                executors: core.executors.availableRuntimes(core.workspaceId),
+                executors: executors.availableRuntimes(workspaceId),
                 retryable: false,
             });
         }
@@ -244,50 +303,60 @@ export default class Exec extends CoreSchemeAdapterBase {
                 retryable: false,
             });
         }
-        this.#prepareExecution();
-        const registry = core.executors.toolRegistry(runtime, core.workspaceId);
-        const exactTarget = route.target === null ? null : route.target.raw;
+        return resolved;
+    }
+    // The invocation contract the fence runs under: a family runtime's registered tool, named exactly, or
+    // the executor's own declaration.
+    static #admitTool(executors, workspaceId, resolved, runtime, exactTarget) {
+        const registry = executors.toolRegistry(runtime, workspaceId);
         const registeredTool = registry?.tools.find((tool) => tool.target === exactTarget);
         if (registry !== null && registeredTool === undefined) {
             const availableTargets = registry.tools.map((tool) => tool.target);
+            // {§executor-blank-invocation} No target: every enabled target's fence. An unknown one: the document listing them.
+            const recovery = availableTargets.length === 0 ? {}
+                : exactTarget === null ? { recovery: registry.tools.map((tool) => ToolResources.fence(runtime, tool.invocation, tool.target)).join("\n\n") }
+                    : { recovery: `Select a target from worker://${ToolResources.documentPath(runtime, resolved.resourcesPath)}.` };
             return Results.failure("scheme:exec", exactTarget === null ? "target-required" : "target-not-registered", exactTarget === null ? 400 : 404, exactTarget === null
                 ? `Runtime '${runtime}' requires one registered tool target.`
                 : `Runtime '${runtime}' has no registered target '${exactTarget}'.`, {}, {
                 runtime,
                 availableTargetCount: availableTargets.length,
-                ...(availableTargets.length === 0 ? {} : {
-                    recovery: `Select a target from worker://${ToolResources.documentPath(runtime, resolved.resourcesPath)}.`,
-                }),
+                ...recovery,
                 retryable: false,
             });
         }
-        const invocation = registeredTool?.invocation ?? resolved.invocation;
-        const hasBody = body.length > 0;
-        const execTarget = route.target;
-        const hasTarget = execTarget !== null;
-        const refuse = (code, detail, recovery, extensions = {}) => Results.failure("scheme:exec", code, 400, detail, {}, { runtime, ...(recovery === undefined ? {} : { recovery }), retryable: false, ...extensions });
+        return registeredTool?.invocation ?? resolved.invocation;
+    }
+    // The fence's body and target against the invocation's declaration, refused by name. {§executor-blank-invocation} An
+    // absent input is answered with the invocation's own fence.
+    static #checkInvocationShape(invocation, runtime, exactTarget, hasBody, hasTarget) {
+        const fence = () => ToolResources.fence(runtime, invocation, exactTarget);
         if (invocation.body.required && !hasBody) {
-            return refuse("body-required", `Executable tool '${runtime}' requires a ${invocation.body.role} body.`, `Provide the ${invocation.body.role} in the ${runtime} body.`);
+            return Exec.#refuse(runtime, "body-required", `Executable tool '${runtime}' requires a ${invocation.body.role} body.`, fence());
         }
         if (invocation.target === undefined && hasTarget) {
-            return refuse("target-not-supported", `Executable tool '${runtime}' does not accept a target.`, `Remove the target and provide the ${invocation.body.role} in the body.`);
+            return Exec.#refuse(runtime, "target-not-supported", `Executable tool '${runtime}' does not accept a target.`, `Remove the target and provide the ${invocation.body.role} in the body.`);
         }
         if (invocation.target?.required === true && !hasTarget) {
-            return refuse("target-required", `Executable tool '${runtime}' requires a ${invocation.target.role} target.`, `Provide the ${invocation.target.role} in (target).`);
+            return Exec.#refuse(runtime, "target-required", `Executable tool '${runtime}' requires a ${invocation.target.role} target.`, fence());
         }
         if (!hasBody && !hasTarget) {
-            return refuse("input-required", `Executable tool '${runtime}' requires a body or target.`, `Provide ${invocation.target === undefined ? "a body" : "a body or target"}.`);
+            return Exec.#refuse(runtime, "input-required", `Executable tool '${runtime}' requires a body or target.`, fence());
         }
         if (invocation.exclusive === true && hasBody && hasTarget) {
-            return refuse("input-conflict", `Executable tool '${runtime}' accepts its ${invocation.body.role} body and ${invocation.target?.role ?? "target"} target only as alternatives.`, "Provide either the body or target, not both.");
+            return Exec.#refuse(runtime, "input-conflict", `Executable tool '${runtime}' accepts its ${invocation.body.role} body and ${invocation.target?.role ?? "target"} target only as alternatives.`, "Provide either the body or target, not both.");
         }
+        return null;
+    }
+    // {§exec-target-routing} The working directory the run can always name, and the target as the executor
+    // will receive it: a literal, a local path, or a non-file resource realized at apply time.
+    async #routeTarget(core, args) {
+        const { runtime, invocation, execTarget, hasBody } = args;
         const workspaceRow = await core.db.envelope_get_workspace.get({ id: core.workspaceId });
         const projectRoot = workspaceRow?.project_root ?? null;
         // The working directory is always concrete — the project root, or the shell's own
         // cwd when the workspace has none — so every receipt can name it ({§exec-target-routing}).
         const defaultCwd = projectRoot ?? process.cwd();
-        let cwd = defaultCwd;
-        let inputDeclared = false;
         let target = null;
         let resourceSource = null;
         const targetDecl = invocation.target;
@@ -307,7 +376,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                     }
                 }
                 else {
-                    return refuse("target-kind-invalid", `Executable tool '${runtime}' accepts only a local or file:// ${targetDecl.role} target.`, `Use a local or file:// ${targetDecl.role} target.`, { target: execTarget.raw, targetKind: targetDecl.kind });
+                    return Exec.#refuse(runtime, "target-kind-invalid", `Executable tool '${runtime}' accepts only a local or file:// ${targetDecl.role} target.`, `Use a local or file:// ${targetDecl.role} target.`, { target: execTarget.raw, targetKind: targetDecl.kind });
                 }
             }
         }
@@ -323,7 +392,7 @@ export default class Exec extends CoreSchemeAdapterBase {
         // cannot see the host's temporary directory, and runs markdown where it can.
         if (resourceSource !== null && execTarget?.kind === "url" && execTarget.scheme === "worker"
             && isGeneratedPathname(PathSyntax.decodeParens(execTarget.pathname ?? ""))) {
-            return refuse("target-is-documentation", `\`${execTarget.raw}\` is reference documentation the harness generated, not a program; ${runtime} cannot run it.`, undefined, { target: execTarget.raw });
+            return Exec.#refuse(runtime, "target-is-documentation", `\`${execTarget.raw}\` is reference documentation the harness generated, not a program; ${runtime} cannot run it.`, undefined, { target: execTarget.raw });
         }
         // {§exec-scratch-directory} — a standalone source is realized under the scratch directory,
         // where its executor must be able to read it; a directory the daemon cannot create or
@@ -332,12 +401,16 @@ export default class Exec extends CoreSchemeAdapterBase {
             const scratch = this.#sourceScratch();
             const unavailable = await scratch.unavailable();
             if (unavailable !== null) {
-                return refuse("scratch-unavailable", `The execution scratch directory \`${scratch.directory}\` named by ${ExecScratch.KNOB} cannot be created or written (${unavailable}), so the ${runtime} source \`${execTarget.raw}\` cannot be realized.`, `The operator points ${ExecScratch.KNOB} at a writable absolute directory the ${runtime} executor can also read; meanwhile, target a program file the executor can reach, or put the command beneath a ${runtime} heading with no target.`, { target: execTarget.raw, scratch: scratch.directory, configuration: ExecScratch.KNOB });
+                return Exec.#refuse(runtime, "scratch-unavailable", `The execution scratch directory \`${scratch.directory}\` named by ${ExecScratch.KNOB} cannot be created or written (${unavailable}), so the ${runtime} source \`${execTarget.raw}\` cannot be realized.`, `The operator points ${ExecScratch.KNOB} at a writable absolute directory the ${runtime} executor can also read; meanwhile, target a program file the executor can reach, or put the command beneath a ${runtime} heading with no target.`, { target: execTarget.raw, scratch: scratch.directory, configuration: ExecScratch.KNOB });
             }
         }
+        return { defaultCwd, target, resourceSource };
+    }
+    // {§exec-lifetime} {§env-option} The service's reserved keys, read before the executor sees its options.
+    static #readReservedMetadata(statement, runtime) {
         // {§exec-lifetime} — the scope slot is text coordinates, and an execution has none.
         if (statement.lineMarker !== null)
-            return refuse("scope-unsupported", "An execution takes no scope.", undefined);
+            return Exec.#refuse(runtime, "scope-unsupported", "An execution takes no scope.", undefined);
         // {§env-option} — the fence's own environment is the service's key: refused here by name,
         // so the model learns why, never dropped at the spawn. The executor never sees it.
         try {
@@ -359,84 +432,70 @@ export default class Exec extends CoreSchemeAdapterBase {
                 runtime, recovery: `State one lifetime: ${LIFETIME_SYNTAX}.`, retryable: false,
             });
         }
-        // {§executor-metadata} Options belong to the invoked executor for every source kind.
-        const executor = resolved.executor;
+        return lifetime;
+    }
+    // {§executor-metadata} The executor's preparation of its own options: the working directory it chose
+    // and whether the invocation registers an input receiver; metadata without a preparer is refused.
+    static async #prepareInvocation(executor, statement, args) {
+        const { runtime, body, target, cwd } = args;
         if (executor.prepare !== undefined) {
-            const prepared = Results.assert(await executor.prepare({
-                runtime, body, target: resourceSource ?? target, cwd, metadata: statement.metadata,
-            }));
+            const prepared = Results.assert(await executor.prepare({ runtime, body, target, cwd, metadata: statement.metadata }));
             if (prepared.status >= 400)
                 return prepared;
             if (prepared.status !== 200 || (prepared.cwd !== null && (typeof prepared.cwd !== "string" || !isAbsolute(prepared.cwd)))) {
                 throw new InvalidOperationResultError(`Executable tool '${runtime}' returned invalid invocation preparation.`);
             }
-            cwd = prepared.cwd;
-            inputDeclared = prepared.input === "open";
+            return { cwd: prepared.cwd, inputDeclared: prepared.input === "open" };
         }
-        else if ((statement.metadata?.length ?? 0) > 0) {
+        if ((statement.metadata?.length ?? 0) > 0) {
             return Results.failure("scheme:exec", "metadata-unsupported", 400, `Executable tool '${runtime}' does not accept metadata.`, {}, { runtime, retryable: false });
         }
-        // A `script` target must be an existing file; other kinds pass through as declared.
-        if (target !== null && targetDecl?.kind === "script") {
-            const inspected = isAbsolute(target) ? target : resolve(cwd ?? process.cwd(), target);
-            let kind = "missing";
-            try {
-                kind = (await stat(inspected)).isDirectory() ? "directory" : "file";
-            }
-            catch (cause) {
-                if (cause?.code !== "ENOENT") {
-                    console.error(`Execution target classification failed for '${inspected}':`, cause);
-                    return Results.failure("scheme:exec", "target-classification-failed", 500, `${runtime} target '${target}' could not be inspected: ${ErrorDetail.preview(cause)}`, {}, { target, stage: "target-classification" });
-                }
-            }
-            // {§exec-target-near-miss} — a directory is never a program: with a body and no explicit
-            // cwd, it is where the body runs. Never taught.
-            if (kind === "directory" && hasBody && cwd === defaultCwd) {
-                cwd = inspected;
-                target = null;
-            }
-            else if (kind === "directory") {
-                return refuse("target-not-a-program", `${runtime} target '${target}' is a directory, not a program.`, undefined, { target });
-            }
-            if (kind === "missing") {
-                // The target is not a script here, but it may be a registered tool of another executor or an
-                // executor itself: that is what exists, said as found (#388, {§diagnostic-observation}).
-                const executors = core.executors;
-                const ownerRuntimes = executors === undefined
-                    ? []
-                    : executors.availableRuntimes(core.workspaceId)
-                        .filter((tag) => executors.toolRegistry(tag, core.workspaceId)?.tools.some((tool) => tool.target === target) === true);
-                const runtimeTarget = executors !== undefined && target !== null && target !== runtime
-                    && executors.availableRuntimes(core.workspaceId).includes(target);
-                const recovery = ownerRuntimes.length > 0
-                    ? `The tool \`${target}\` is registered under executor \`${ownerRuntimes[0]}\`.`
-                    : runtimeTarget
-                        ? `\`${target}\` is its own executor.`
-                        : "The target must name an existing program resource.";
-                return refuse("target-not-found", `The ${runtime} program does not resolve as a script or a registered tool for this executor.`, recovery, { target, ...(ownerRuntimes.length === 0 ? {} : { toolRuntimes: ownerRuntimes }) });
+        return { cwd, inputDeclared: false };
+    }
+    // A script target as it exists: a file runs, a directory with a body is where the body runs
+    // ({§exec-target-near-miss}), and a missing one is refused as what it is ({§diagnostic-observation}).
+    static async #inspectScriptTarget(core, args) {
+        const { runtime, defaultCwd, hasBody } = args;
+        let { cwd } = args;
+        let target = args.target;
+        const inspected = isAbsolute(target) ? target : resolve(cwd ?? process.cwd(), target);
+        let kind = "missing";
+        try {
+            kind = (await stat(inspected)).isDirectory() ? "directory" : "file";
+        }
+        catch (cause) {
+            if (errnoCode(cause) !== "ENOENT") {
+                console.error(`Execution target classification failed for '${inspected}':`, cause);
+                return Results.failure("scheme:exec", "target-classification-failed", 500, `${runtime} target '${target}' could not be inspected: ${ErrorDetail.preview(cause)}`, {}, { target, stage: "target-classification" });
             }
         }
-        if (!hasBody && target === null && resourceSource === null) {
-            return refuse("input-required", `Executable tool '${runtime}' has no executable body or realized target.`, `Provide a ${invocation.body.role} body or a non-directory target.`);
+        // {§exec-target-near-miss} — a directory is never a program: with a body and no explicit
+        // cwd, it is where the body runs. Never taught.
+        if (kind === "directory" && hasBody && cwd === defaultCwd) {
+            cwd = inspected;
+            target = null;
         }
-        // One logical target derives one effect fact before policy consumes it.
-        // A non-file resource keeps its exact authored address until materialization.
-        const effectTarget = resourceSource ?? target;
-        const effect = resolved.executor.effect(effectTarget);
-        // cwd is the workspace project_root unless target routing selected a
-        // directory override. {§exec-target-routing}, {§executor-sinks}
-        // The log writer claims the workspace output address before proposal application.
-        // {§exec-lifetime} — how long the spawn may live is the metadata's one field; the scope slot
-        // is text coordinates, which an execution has none of.
-        const attrs = {
-            runtime, cwd, body, target, pathname: "", effect,
-            ...(inputDeclared ? { input: "open" } : {}),
-            ...(resourceSource !== null ? { resourceSource } : {}),
-            ...lifetime,
-        };
-        const previewInput = body !== "" ? body : execTarget?.raw ?? "";
-        const preview = runtime !== "" ? `[${runtime}] ${previewInput}` : `$ ${previewInput}`;
-        return { status: 202, body: preview, attrs }; // host runtime proposes with 202 — {§exec-host-proposes}
+        else if (kind === "directory") {
+            return Exec.#refuse(runtime, "target-not-a-program", `${runtime} target '${target}' is a directory, not a program.`, undefined, { target });
+        }
+        if (kind === "missing") {
+            // The target is not a script here, but it may be a registered tool of another executor or an
+            // executor itself: that is what exists, said as found (#388, {§diagnostic-observation}).
+            const executors = core.executors;
+            const ownerRuntimes = executors === undefined
+                ? []
+                : executors.availableRuntimes(core.workspaceId)
+                    .filter((tag) => executors.toolRegistry(tag, core.workspaceId)?.tools.some((tool) => tool.target === target) === true);
+            const runtimeTarget = executors !== undefined && target !== null && target !== runtime
+                && executors.availableRuntimes(core.workspaceId).includes(target);
+            const recovery = ownerRuntimes.length > 0
+                ? `The tool \`${target}\` is registered under executor \`${ownerRuntimes[0]}\`.`
+                : runtimeTarget
+                    ? `\`${target}\` is its own executor.`
+                    : "The target must name an existing program resource.";
+            return Exec.#refuse(runtime, "target-not-found", `The ${runtime} program does not resolve as a script or a registered tool for this executor.`, recovery, { target, ...(ownerRuntimes.length === 0 ? {} : { toolRuntimes: ownerRuntimes }) });
+        }
+        return { target, cwd };
     }
     async #inputRecipient(statement, ctx, runtime) {
         const core = this.coreContext(ctx);
@@ -521,8 +580,11 @@ export default class Exec extends CoreSchemeAdapterBase {
         if (!EffectPolicy.isEffect(effect)) {
             throw new InvalidOperationResultError("The accepted execution proposal is missing its canonical effect fact.");
         }
+        if (!isExecutionOp(runtime)) {
+            throw new InvalidOperationResultError(`The accepted execution proposal names runtime '${runtime}', which is not a runtime tag.`);
+        }
         const invocation = {
-            runtime: runtime, aside: null, metadata: null,
+            runtime, aside: null, metadata: null,
             target: attrs.resourceSource ? parsePath(attrs.resourceSource) : target === null ? null : parsePath(target),
             lineMarker: null, body, position: { line: 1, column: 1 },
         };
@@ -530,54 +592,112 @@ export default class Exec extends CoreSchemeAdapterBase {
         // files retain their environment; only standalone sources need a copy.
         let tempPath = null;
         if (attrs.resourceSource !== undefined) {
-            const sourceTarget = parsePath(attrs.resourceSource);
-            if (sourceTarget?.kind !== "url" || sourceTarget.scheme === null || sourceTarget.scheme === "file") {
-                throw new InvalidOperationResultError("The accepted execution proposal has an invalid scheme source address.");
-            }
-            const source = await this.readExecSource({
-                op: "READ",
-                aside: null,
-                target: sourceTarget,
-                metadata: null,
-                lineMarker: { marks: [1, -1] },
-                matcher: null,
-                body: null,
-                position: { line: 0, column: 0 },
-            }, core);
-            const read = source.result;
-            if (read.status >= 400) {
-                // {§exec-target-routing} — the failure stays the owning READ's (#163); the execution
-                // contract rides its recovery, because a stream address in the target slot is
-                // almost always a command that belonged beneath a targetless heading (#425 F4).
-                const problem = read.problem === undefined ? undefined : {
-                    ...read.problem,
-                    recovery: Exec.sourceRecovery(attrs.resourceSource, read.problem.recovery),
-                };
-                return Results.assert({ ...read, outcome: "scheme_source_read_failed", ...(problem === undefined ? {} : { problem }) });
-            }
-            const content = read.content;
-            if (typeof content !== "string") {
-                return Results.failure("scheme:exec", "source-content-unavailable", 422, `Scheme '${sourceTarget.scheme}' did not supply content for the ${runtime} source.`, { outcome: "scheme_source_content_unavailable" }, {
-                    scheme: sourceTarget.scheme,
-                    sourceStatus: read.status,
-                    retryable: false,
-                });
+            const realized = await this.#realizeSource(attrs.resourceSource, runtime, core);
+            if ("status" in realized)
+                return realized;
+            ({ target, tempPath } = realized);
+        }
+        if (body.length === 0 && target === null) {
+            throw new InvalidOperationResultError("The accepted execution proposal has neither a body nor a realized target.");
+        }
+        const stream = await Exec.#openStreamEntry(core, runtime, pathname);
+        if ("status" in stream)
+            return stream;
+        const { resolved, entryId } = stream;
+        const { subscriptionId, controller, input, lifecycle } = await this.#bindSpawnLifecycle({
+            core, attrs, resolved, runtime, body, target, pathname, entryId, effect, invocation,
+            inputTimeoutMs: execution.inputTimeoutMs,
+        });
+        const run = async () => {
+            input.started();
+            return this.#runExecutor({
+                executor: resolved.executor,
+                runtime, body, cwd, target, metadata: args.metadata, ctx: core, pathname, coordinate: attrs.coordinate,
+                entryId, lifecycle, signal: controller.signal, controller, tempPath, input,
+                timeoutSec: typeof attrs.timeoutSec === "number" ? attrs.timeoutSec : null,
+            });
+        };
+        // {§functionality-model-mutation} Configuration is an ordered core operation,
+        // not a background job competing for an external-execution slot.
+        if (resolved.executor instanceof FunctionalityManager) {
+            const tail = run();
+            this.#activeSpawns.set(subscriptionId, tail);
+            return await tail;
+        }
+        const admission = execution.scheduler.admit(core.workspaceId, controller.signal);
+        const tail = admission.ready.then(async (release) => {
+            try {
+                return await run();
             }
-            if (source.nativePath !== null) {
-                target = source.nativePath;
+            finally {
+                release();
             }
-            else {
-                tempPath = this.#sourceScratch().path(extname(sourceTarget.pathname)); // {§exec-scratch-directory}
-                await writeFile(tempPath, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
-                target = tempPath;
+        });
+        // External executions background + stream ({§exec-stream}): the output
+        // surfaces as the environment-observation injector's terminal delta (nothing while it runs,
+        // one visible READ when it finishes). Pure/read commands still auto-accept
+        // from the preserved effect fact; they resolve a turn later, uniformly
+        // with host streams.
+        this.#activeSpawns.set(subscriptionId, tail);
+        void tail.catch((cause) => { console.error(`Execution '${runtime}' failed to settle:`, cause); });
+        return admission.queued
+            ? {
+                status: 202,
+                outcome: "queued",
+                result: {
+                    executionsAhead: admission.executionsAhead,
+                    concurrency: admission.concurrency,
+                },
             }
+            : { status: 200, outcome: "started" };
+    }
+    // {§exec-source-temporary} A standalone source read through its own scheme and realized where the executor can
+    // run it: a native file is its own path; anything else is written once under the scratch directory
+    // ({§exec-scratch-directory}). A failed read stays the owning READ's failure.
+    async #realizeSource(resourceSource, runtime, core) {
+        const sourceTarget = parsePath(resourceSource);
+        if (sourceTarget?.kind !== "url" || sourceTarget.scheme === null || sourceTarget.scheme === "file") {
+            throw new InvalidOperationResultError("The accepted execution proposal has an invalid scheme source address.");
         }
-        if (body.length === 0 && target === null) {
-            throw new InvalidOperationResultError("The accepted execution proposal has neither a body nor a realized target.");
+        const source = await this.readExecSource({
+            op: "READ",
+            aside: null,
+            target: sourceTarget,
+            metadata: null,
+            lineMarker: { marks: [1, -1] },
+            matcher: null,
+            body: null,
+            position: { line: 0, column: 0 },
+        }, core);
+        const read = source.result;
+        if (read.status >= 400) {
+            // {§exec-target-routing} — the failure stays the owning READ's (#163); the execution
+            // contract rides its recovery, because a stream address in the target slot is
+            // almost always a command that belonged beneath a targetless heading (#425 F4).
+            const problem = read.problem === undefined ? undefined : {
+                ...read.problem,
+                recovery: Exec.sourceRecovery(resourceSource, read.problem.recovery),
+            };
+            return Results.assert({ ...read, outcome: "scheme_source_read_failed", ...(problem === undefined ? {} : { problem }) });
+        }
+        const { content } = read;
+        if (typeof content !== "string") {
+            return Results.failure("scheme:exec", "source-content-unavailable", 422, `Scheme '${sourceTarget.scheme}' did not supply content for the ${runtime} source.`, { outcome: "scheme_source_content_unavailable" }, {
+                scheme: sourceTarget.scheme,
+                sourceStatus: read.status,
+                retryable: false,
+            });
         }
-        // Resolve the runtime's executor from the boot registry, then seed
-        // channels from its declared topology ({§executor-channels}). Each executor declares its own
-        // shape (subprocess → stdout/stderr; search → results; etc.).
+        if (source.nativePath !== null)
+            return { target: source.nativePath, tempPath: null };
+        const tempPath = this.#sourceScratch().path(extname(sourceTarget.pathname)); // {§exec-scratch-directory}
+        await writeFile(tempPath, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
+        return { target: tempPath, tempPath };
+    }
+    // Resolve the runtime's executor from the boot registry, then seed the stream entry's channels from its
+    // declared topology ({§executor-channels}): each executor declares its own shape (subprocess → stdout/stderr;
+    // search → results; etc.).
+    static async #openStreamEntry(core, runtime, pathname) {
         if (core.executors === undefined) {
             throw new InvalidOperationResultError("An accepted execution proposal has no executor registry.");
         }
@@ -610,6 +730,13 @@ export default class Exec extends CoreSchemeAdapterBase {
                 retryable: false,
             });
         }
+        return { resolved, entryId };
+    }
+    // The spawn's live subscription and cancellation scope: the stream subscription opened, the controller bound
+    // to the loop's teardown unless detached ({§exec-lifetime}), the input receiver, the abort registry entry, and
+    // the LiveSubscription whose release unbinds them all.
+    async #bindSpawnLifecycle(args) {
+        const { core, attrs, resolved, runtime, body, target, pathname, entryId, effect, invocation, inputTimeoutMs } = args;
         const subscriptionId = await ChannelWrite.openSubscription(core.db, {
             workerId: core.workerId, entryId, scheme: runtime,
             handle: runtime !== "" ? `${runtime}: ${body !== "" ? body : target ?? ""}` : body,
@@ -620,7 +747,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 : `log:///${attrs.coordinate.loop_seq}/${attrs.coordinate.turn_seq}/${attrs.coordinate.sequence}/${runtime}`,
         });
         const controller = new AbortController();
-        let unlink = () => { };
+        let detachParent = () => { };
         // {§exec-lifetime} — a detached spawn outlives the loop: it never binds to the loop's teardown;
         // only KILL, the worker's total reap, and daemon shutdown end it.
         if (core.signal !== undefined && attrs.detached !== true) {
@@ -636,11 +763,11 @@ export default class Exec extends CoreSchemeAdapterBase {
             // doubled fire is harmless. {§exec-lifetime}
             const onParentAbort = () => controller.abort(ExecAbort.teardownReason());
             parent.addEventListener("abort", onParentAbort, { once: true });
-            unlink = () => parent.removeEventListener("abort", onParentAbort);
+            detachParent = () => parent.removeEventListener("abort", onParentAbort);
             if (parent.aborted)
                 controller.abort(ExecAbort.teardownReason());
         }
-        const input = new ExecutionInput(controller.signal, execution.inputTimeoutMs, attrs.input === "open");
+        const input = new ExecutionInput(controller.signal, inputTimeoutMs, attrs.input === "open");
         this.#activeAborts.set(subscriptionId, { workspaceId: core.workspaceId, workerId: core.workerId, turnId: core.turnId, pathname, runtime, effect, controller, detached: attrs.detached === true, input, invocation, executor: resolved.executor });
         const lifecycle = new LiveSubscription({
             db: core.db, registry: this.liveSubscriptions(),
@@ -649,55 +776,15 @@ export default class Exec extends CoreSchemeAdapterBase {
                 target: `${runtime}://${pathname}`, subscriptionId, scheme: runtime, ...attrs.coordinate,
             },
             handle: { cancel: () => controller.abort(ExecAbort.teardownReason()) },
+            reaperLoopId: core.signal !== undefined && attrs.detached !== true ? core.loopId : null,
             release: () => {
-                unlink();
+                detachParent();
                 this.#activeAborts.delete(subscriptionId);
                 this.#activeSpawns.delete(subscriptionId);
             },
             notify: core.streamEventNotify, wake: core.wakeWorkerNotify,
         });
-        const run = async () => {
-            input.started();
-            return this.#runExecutor({
-                executor: resolved.executor,
-                runtime, body, cwd, target, metadata: args.metadata, ctx: core, pathname, coordinate: attrs.coordinate,
-                entryId, lifecycle, signal: controller.signal, controller, tempPath, input,
-                timeoutSec: typeof attrs.timeoutSec === "number" ? attrs.timeoutSec : null,
-            });
-        };
-        // {§functionality-model-mutation} Configuration is an ordered core operation,
-        // not a background job competing for an external-execution slot.
-        if (resolved.executor instanceof FunctionalityManager) {
-            const tail = run();
-            this.#activeSpawns.set(subscriptionId, tail);
-            return await tail;
-        }
-        const admission = execution.scheduler.admit(core.workspaceId, controller.signal);
-        const tail = admission.ready.then(async (release) => {
-            try {
-                return await run();
-            }
-            finally {
-                release();
-            }
-        });
-        // External executions background + stream ({§exec-stream}): the output
-        // surfaces as the environment-observation injector's terminal delta (nothing while it runs,
-        // one visible READ when it finishes). Pure/read commands still auto-accept
-        // from the preserved effect fact; they resolve a turn later, uniformly
-        // with host streams.
-        this.#activeSpawns.set(subscriptionId, tail);
-        void tail.catch((cause) => { console.error(`Execution '${runtime}' failed to settle:`, cause); });
-        return admission.queued
-            ? {
-                status: 202,
-                outcome: "queued",
-                result: {
-                    executionsAhead: admission.executionsAhead,
-                    concurrency: admission.concurrency,
-                },
-            }
-            : { status: 200, outcome: "started" };
+        return { subscriptionId, controller, input, lifecycle };
     }
     // Bridge the executor's sink-style contract (write/setState/emit)
     // onto plurnk-service's storage primitives (appendToChannel,
@@ -762,190 +849,15 @@ export default class Exec extends CoreSchemeAdapterBase {
             stage: "execution",
             retryable: false,
         });
-        let exitLabel = "did not conclude";
-        let stdoutLength = 0;
-        let stderrLength = 0;
-        // {§exec-entry-sink} {§env-delta-entry-materialization} — serialize
-        // executor entry() materializations and narrate them through the one
-        // reserved-worker turn owned by this spawn.
-        let entryChain = Promise.resolve();
-        let narration = null;
-        let narrationResult = { status: 200 };
-        let entryChainFailed = false;
-        let callerSource;
-        const resolveCallerSource = async () => {
-            if (callerSource !== undefined)
-                return callerSource;
-            const caller = await db.worker_name_by_id.get({ worker_id: ctx.workerId });
-            if (caller === undefined)
-                throw new Error(`entry(): calling worker ${ctx.workerId} does not exist`);
-            callerSource = WorkerControlAddress.render(caller.name);
-            return callerSource;
-        };
-        const publishedNames = new ResourceNames();
-        const entrySink = (requestedPath, content, opts) => {
-            let path = requestedPath;
-            if (path === null) {
-                if (content === null)
-                    return Promise.reject(new Error("entry(): an invocation resource requires supplied content"));
-                path = renderAddress({ scheme: runtime, authority: "", pathname: `${pathname}/resources/${publishedNames.allocate(opts.name)}` });
-            }
-            const parsed = parsePath(path);
-            if (parsed === null || parsed.kind !== "url")
-                return Promise.reject(new Error(`entry(): '${path.slice(0, 80)}' is not a URL`));
-            if (content !== null && opts.mimetype === undefined)
-                return Promise.reject(new Error("entry(): mimetype is required when content is provided"));
-            const address = NetworkAddress.supports(parsed.scheme) ? NetworkAddress.from(parsed) : null;
-            if (address?.hasCredentials === true)
-                return Promise.reject(new Error("entry(): network URL userinfo is not allowed"));
-            const fetchAddress = address !== null && (address.scheme === "http" || address.scheme === "https")
-                ? address
-                : null;
-            const binding = requestedPath === null
-                ? Promise.resolve({ address: { scheme: runtime, authority: "", pathname: parsed.pathname }, result: null })
-                : this.bindEntryAddress(parsed, ctx);
-            // {§exec-entry-sink}/{§web-search-retrieval} — start content:null
-            // acquisition before the write chain so fetches run in parallel;
-            // only durable entry writes serialize. A null result rejects the sink.
-            let materialized;
-            if (content === null) {
-                if (fetchAddress === null)
-                    return Promise.reject(new Error("entry(): content:null requires an http(s):// URL"));
-                materialized = this.#fetchWeb(fetchAddress.url, { signal });
-            }
-            else if (typeof content === "string" && requestedPath !== null) {
-                materialized = Promise.resolve({
-                    url: fetchAddress?.url ?? "http://localhost",
-                    body: content,
-                    mimetype: opts.mimetype,
-                    allowConfiguredMaterializer: false,
-                });
-            }
-            const op = async () => {
-                const resolved = await binding;
-                if (resolved === null) {
-                    throw new Error(`entry(): no entry-bearing scheme is registered for '${path.slice(0, 80)}'`);
-                }
-                if (resolved.result !== null)
-                    throw new OperationFailureError(resolved.result);
-                if (resolved.address === null) {
-                    throw new Error(`entry(): '${path.slice(0, 80)}' did not resolve to an entry address`);
-                }
-                const { authority, pathname, scheme } = resolved.address;
-                const coordinate = { authority, pathname };
-                let channels;
-                let decisive;
-                let source;
-                if (materialized === undefined) {
-                    if (content === null)
-                        throw new Error("entry(): missing supplied content");
-                    const body = typeof content === "string" ? { content, mimetype: opts.mimetype }
-                        : { content: "", bytes: content, mimetype: opts.mimetype };
-                    const channel = requestedPath === null ? executor.defaultChannel : ctx.defaultChannelFor?.(scheme);
-                    if (channel === undefined)
-                        throw new Error(`entry(): no default channel for '${scheme}'`);
-                    channels = { [channel]: body };
-                    decisive = typeof content === "string" ? content : `${opts.mimetype}; ${content.byteLength} bytes`;
-                    source = decisive;
-                }
-                else {
-                    const fetched = await materialized;
-                    if (fetched === null)
-                        throw new Error(`entry(): '${path.slice(0, 80)}' is dead`);
-                    let web;
-                    try {
-                        web = await this.#materializer().materialize(fetched, new DbProjectionCaps(ctx));
-                    }
-                    catch (error) {
-                        if (!signal.aborted && error instanceof WebMaterializationError) {
-                            console.error("entry() web materialization failed", { path, error });
-                        }
-                        throw error;
-                    }
-                    channels = this.#materializer().materializedChannels(web, content === null && fetchAddress !== null ? { url: fetchAddress.url, method: "GET" } : undefined);
-                    decisive = web.readable?.content ?? (web.body.bytes === undefined
-                        ? web.body.content : `${web.body.mimetype}; ${web.body.bytes.byteLength} bytes`);
-                    source = web.body.bytes === undefined ? web.body.content : decisive;
-                }
-                const causalSource = await resolveCallerSource();
-                const written = Results.assert(await EntryCrud.writeEntry(coordinate, { channels }, ctx, scheme, {
-                    defaultChannel: requestedPath === null ? executor.defaultChannel : ctx.defaultChannelFor?.(scheme),
-                    output: requestedPath === null,
-                }));
-                if (narration === null) {
-                    const workerId = await RuntimeWorker.ensure(db, ctx.workspaceId);
-                    const loop = await AdministrativeLoop.open(db, workerId);
-                    const turn = await Turn.open(db, {
-                        loopId: loop.id,
-                        producer: "_plurnk",
-                        kind: "operation",
-                    });
-                    narration = {
-                        workerId,
-                        loopId: loop.id,
-                        loopSeq: loop.sequence,
-                        turnId: turn.id,
-                        turnSeq: turn.sequence,
-                        seq: 1,
-                    };
-                }
-                if (narrationResult.status < 400 || written.status >= 400)
-                    narrationResult = written;
-                const sequence = narration.seq++;
-                const narrationAttrs = { kind: "entry_materialized" };
-                if (written.problem !== undefined) {
-                    const coordinate = LogEntryProjection.coordinate(`${narration.loopSeq}/${narration.turnSeq}/${sequence}`, { origin: "_plurnk", op: "EDIT", attrs: narrationAttrs });
-                    Results.attachInstance(written, `log:///${coordinate}`);
-                }
-                const tx = JSON.stringify({ op: "EDIT", body: source });
-                const rx = JSON.stringify(written.problem === undefined
-                    ? {
-                        ...written,
-                        span: decisive.split("\n").map((l, n) => `${n + 1}:${l}`).join("\n"),
-                    }
-                    : written);
-                const attrs = JSON.stringify(narrationAttrs);
-                if (ctx.weigh === undefined) {
-                    throw new Error("entry(): ctx.weigh is required for curation-weight accounting");
-                }
-                const logRow = await db.engine_insert_log_entry.get({
-                    worker_id: narration.workerId, loop_id: narration.loopId, turn_id: narration.turnId, sequence,
-                    origin: "_plurnk", source: causalSource, model_call_id: null,
-                    op: "EDIT", signal: null,
-                    scheme, username: null, password: null,
-                    hostname: address === null ? null : parsed.hostname,
-                    port: address === null ? null : parsed.port,
-                    pathname: address === null ? pathname : PathSyntax.decodeParens(parsed.pathname),
-                    query: address === null ? null : parsed.query,
-                    fragment: null, lineMarker: null,
-                    tx, mimetype_tx: "application/json",
-                    rx,
-                    mimetype_rx: "application/json",
-                    status_rx: written.status,
-                    weight: LogBody.weight({
-                        op: "EDIT",
-                        attrs,
-                        tx,
-                        rx,
-                        mimetypeTx: "application/json",
-                        mimetypeRx: "application/json",
-                    }, ctx.weigh),
-                    state: "resolved", outcome: null,
-                    // Durable provenance for clients/forensics. This is machine
-                    // ambience, not a human/model action waterfall item.
-                    attrs,
-                    initial_folded: "[]",
-                });
-                if (logRow === undefined)
-                    throw new Error("entry(): log insert returned no row");
-                if (written.problem !== undefined)
-                    throw new OperationFailureError(written);
-                return renderAddress({ scheme, authority, pathname });
-            };
-            const run = entryChain.then(op, op);
-            entryChain = run.then(() => undefined, () => { entryChainFailed = true; });
-            return run;
-        };
+        let channelSizes = [];
+        // {§exec-entry-sink} — the executor's entry() sink and the narration turn it owns live in their own owner;
+        // this spawn's tail settles them.
+        const sink = new ExecEntrySink({
+            ctx, runtime, pathname, signal, executor,
+            bindEntryAddress: (parsed, context) => this.bindEntryAddress(parsed, context),
+            fetchWeb: this.#fetchWeb,
+            materializer: this.#materializer,
+        });
         const executionFailures = [];
         const cancelled = (exitCode) => Results.failure("scheme:exec", "execution-cancelled", 499, `Execution of '${runtime}' was cancelled by the service.`, exitCode === undefined ? {} : { exitCode }, { runtime, stage: "execution", retryable: false });
         try {
@@ -963,7 +875,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                     const reported = await executor.run({
                         registerInput: (receiver) => input.register(receiver),
                         runtime, body, cwd, target, metadata, signal,
-                        entry: entrySink,
+                        entry: sink.entry,
                         // {§executor-interaction-sink} — the executor's signal narrows the execution's, never replaces it.
                         interact: (request, interactionSignal) => {
                             if (ctx.requestInteraction === undefined) {
@@ -1014,67 +926,19 @@ export default class Exec extends CoreSchemeAdapterBase {
                         });
                     }
                 }
-            const exitCode = typeof result.exitCode === "number" ? result.exitCode : null;
-            // A timeout aborts the spawn → the executor reports 499; replace the
-            // complete result so status and Problem remain one valid truth.
-            if (timedOut) {
-                const lifetime = formatLifetime(timeoutSec ?? 0);
-                result = Results.failure("scheme:exec", "execution-timeout", 504, `Execution of '${runtime}' outlived its ${lifetime} lifetime.`, exitCode === null ? {} : { exitCode }, {
-                    runtime,
-                    lifetime,
-                    stage: "execution",
-                    retryable: false,
-                });
-                // The service's own abort knowledge outranks a driver's claim: a
-                // spawn we reaped did not succeed, whatever it resolved under abort.
-            }
-            else if (signal.aborted && result.status < 400) {
-                result = cancelled(exitCode ?? undefined);
-            }
-            else if (result.status < 400 && exitCode === 127 && target === null) {
-                result = this.#namedToolFallThrough(result, runtime, body, ctx);
-            }
-            exitLabel = timedOut
-                ? `timed out after ${(timeoutSec ?? 0) / 60}m`
-                : result.status === 499
-                    ? "aborted"
-                    : exitCode !== null
-                        ? `exit ${exitCode}`
-                        : result.problem?.title.toLowerCase() ?? "completed";
-            const stdoutMeta = await db.channel_meta.get({ entry_id: entryId, channel: "stdout" });
-            const stderrMeta = await db.channel_meta.get({ entry_id: entryId, channel: "stderr" });
-            stdoutLength = stdoutMeta?.contentLength ?? 0;
-            stderrLength = stderrMeta?.contentLength ?? 0;
+            result = this.#settleExecutionResult({ result, timedOut, timeoutSec, signal, target, runtime, body, ctx });
+            // {§exec-conclusion-summary} — the summary sizes the channels this executor declares, in its order.
+            channelSizes = await Promise.all(Object.keys(executor.channels).map(async (channel) => [
+                channel,
+                (await db.channel_meta.get({ entry_id: entryId, channel }))?.contentLength ?? 0,
+            ]));
         }
         catch (cause) {
             executionFailures.push(cause);
         }
         {
-            // {§exec-entry-sink} — the spawn tail owns every serialized entry/narration write.
-            const finalizationErrors = [...executionFailures];
-            if (entryChainFailed && narrationResult.status < 400) {
-                narrationResult = Results.failure("scheme:exec", "entry-narration-failed", 500, "An executor entry could not be materialized or narrated.", {}, { stage: "entry-materialization", retryable: false });
-            }
-            try {
-                await entryChain;
-            }
-            catch (cause) {
-                narrationResult = Results.failure("scheme:exec", "entry-narration-failed", 500, "An executor entry could not be materialized or narrated.", {}, { stage: "entry-materialization", retryable: false });
-                finalizationErrors.push(cause);
-            }
-            const completedNarration = narration;
-            if (completedNarration !== null) {
-                try {
-                    await Turn.complete(db, completedNarration.turnId, narrationResult.status);
-                    const closed = await new LoopLifecycle(db).finish(completedNarration.loopId, narrationResult);
-                    if (closed === null) {
-                        throw new Error(`entry(): narration loop ${completedNarration.loopId} was not open at completion`);
-                    }
-                }
-                catch (cause) {
-                    finalizationErrors.push(cause);
-                }
-            }
+            // {§exec-entry-sink} — the spawn tail settles the entry chain and its narration turn before anything else.
+            const finalizationErrors = [...executionFailures, ...await sink.settle()];
             if (timeoutTimer !== null)
                 clearTimeout(timeoutTimer); // a finished spawn leaves no pending timer
             // {§exec-source-temporary} — cleanup cannot rewrite the settled
@@ -1085,7 +949,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 });
             }
             try {
-                await lifecycle.close(result, `${runtime}://${pathname} completed (${exitLabel}); stdout=${stdoutLength} bytes, stderr=${stderrLength} bytes`);
+                await lifecycle.close(result, Exec.#closeSummary(`${runtime}://${pathname}`, result, channelSizes));
             }
             catch (cause) {
                 finalizationErrors.push(cause);
@@ -1093,11 +957,47 @@ export default class Exec extends CoreSchemeAdapterBase {
             if (finalizationErrors.length === 1)
                 throw finalizationErrors[0];
             if (finalizationErrors.length > 1) {
-                throw new AggregateError(finalizationErrors, `Execution narration ${completedNarration?.turnId ?? "unknown"} failed to settle`);
+                throw new AggregateError(finalizationErrors, `Execution narration ${sink.narrationTurnId ?? "unknown"} failed to settle`);
             }
         }
         return result;
     }
+    // One valid truth for the settled execution: a timeout outranks the executor's report, the service's own abort
+    // knowledge outranks a driver's claim, and a shell's 127 on a tool's name is that tool's refusal
+    // ({§exec-tool-fall-through}).
+    #settleExecutionResult(args) {
+        const { timedOut, timeoutSec, signal, target, runtime, body, ctx } = args;
+        let { result } = args;
+        const cancelled = (exitCode) => Results.failure("scheme:exec", "execution-cancelled", 499, `Execution of '${runtime}' was cancelled by the service.`, exitCode === undefined ? {} : { exitCode }, { runtime, stage: "execution", retryable: false });
+        const exitCode = typeof result.exitCode === "number" ? result.exitCode : null;
+        // A timeout aborts the spawn → the executor reports 499; replace the
+        // complete result so status and Problem remain one valid truth.
+        if (timedOut) {
+            const lifetime = formatLifetime(timeoutSec ?? 0);
+            result = Results.failure("scheme:exec", "execution-timeout", 504, `Execution of '${runtime}' outlived its ${lifetime} lifetime.`, exitCode === null ? {} : { exitCode }, {
+                runtime,
+                lifetime,
+                stage: "execution",
+                retryable: false,
+            });
+            // The service's own abort knowledge outranks a driver's claim: a
+            // spawn we reaped did not succeed, whatever it resolved under abort.
+        }
+        else if (signal.aborted && result.status < 400) {
+            result = cancelled(exitCode ?? undefined);
+        }
+        else if (result.status < 400 && exitCode === 127 && target === null) {
+            result = this.#namedToolFallThrough(result, runtime, body, ctx);
+        }
+        return result;
+    }
+    // {§exec-conclusion-summary} — the stream's address, how its settled result ended, and each declared channel's size.
+    static #closeSummary(address, result, channels) {
+        const ended = Results.isFailed(result) ? result.problem.title.toLowerCase()
+            : typeof result.exitCode === "number" ? `completed (exit ${result.exitCode})` : "completed";
+        const sizes = channels.map(([channel, size]) => `${channel}=${size} bytes`).join(", ");
+        return `${address} ${ended}${sizes === "" ? "" : `; ${sizes}`}`;
+    }
     async find(statement, ctx) {
         const core = this.coreContext(ctx);
         return EntryFind.findWorkspaceEntries(statement, core, Exec.manifest, {});