@plurnk/plurnk-service 1.16.5 → 1.18.0

package/dist/schemes/Exec.js

@@ -1,28 +1,34 @@
-import { parsePath, PathSyntax } from "@plurnk/plurnk-contracts";
+var _a;
+import { parsePath } from "@plurnk/plurnk-parser";
+import { PathSyntax } from "@plurnk/plurnk-contracts";
 import { WebFetcher, WebMaterializationError, } from "@plurnk/plurnk-schemes-http";
+import { isWorkerBound } from "../core/ExecutorRegistry.js";
 import EffectPolicy from "./EffectPolicy.js";
 import EntryCrud from "./_entry-crud.js";
-import Owner from "../core/Owner.js";
 import EntryFind from "./_entry-find.js";
 import ChannelWrite from "../core/ChannelWrite.js";
 import ExecEnv from "./exec-env.js";
+import EnvFunctionality, { ENV_OWNER } from "../server/EnvFunctionality.js";
 import ExecAbort from "./exec-abort.js";
-import { renderAddress } from "../core/plurnk-uri.js";
+import { entryCoordinateOf, generatedPathname, renderAddress } from "../core/plurnk-uri.js";
 import { writeFile, unlink, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
+import { extname, isAbsolute, join, 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, } from "@plurnk/plurnk-schemes";
+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 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 from "./ExecScheduler.js";
+import ExecutionInput from "./ExecutionInput.js";
 import { execRouteOf } from "./exec-runtime.js";
 // Executors are discovered + probed at boot into ExecutorRegistry and reach
 // the scheme through ctx.executors ({§exec-registry-resolves}). Each runtime tag
@@ -49,68 +55,50 @@ const resourceSourceOf = (target) => {
         return null;
     return target.raw;
 };
-// EXEC's pathname is <runtime>/<loop_seq>/<turn_seq>/<sequence> (stamped by
-// Dispatcher.#writeLog). Exec owns this convention, so it — not the client — turns
-// the pathname into the entry's coordinate, mirrored onto stream payloads so
-// clients read fields instead of parsing the URI. The
-// coordinate is the numeric triple before the `/EXEC` op segment ({§log-coordinate-hierarchy}:
-// every item address is loop/turn/item/OP); any other pathname yields undefined (no
-// coordinate on the wire).
-// {§notifications-stream-event-on-channel-change}, {§notifications-stream-concluded}
-const coordinateFromPathname = (pathname) => {
-    const seg = pathname.split("/").filter(Boolean);
-    if (seg.length < 4 || seg.at(-1) !== "EXEC")
-        return undefined;
-    const [loop_seq, turn_seq, sequence] = seg.slice(-4, -1).map(Number);
-    if (![loop_seq, turn_seq, sequence].every(Number.isInteger))
-        return undefined;
-    return { loop_seq, turn_seq, sequence };
-};
-// {§stream-owner-scoped} — resolve a stream statement's authority to the owning worker and hand
-// back the statement authority-stripped (the storage path is the bare loop coordinate; the owner
-// rides the owner_id column, never the pathname). Empty authority = the CALLING worker — your own
-// streams need no qualifier, so a fan-out sibling's identical coordinate can never be yours
-// ({§stream-owner-scoped}).
-// A named authority = that worker's streams, any worker of the workspace (#394); an unknown
-// name resolves null → the face 404s.
-export const resolveStreamStatement = async (statement, ctx) => {
-    const t = statement.target;
-    const hostname = t !== null && t.kind === "url" ? t.hostname : null;
-    const ownerId = await Owner.resolveStreamOwner(hostname, ctx);
-    if (ownerId === null)
-        return null;
-    if (hostname === null || t === null || t.kind !== "url")
-        return { statement, ownerId };
-    return { statement: { ...statement, target: { ...t, hostname: null } }, ownerId };
-};
-export default class Exec extends CoreSchemeAdapterBase {
+class Exec extends CoreSchemeAdapterBase {
+    // {§exec-env-scoped} — the environment one spawn receives: the ambient ceiling, then the Worker's
+    // own `env` state over it ({§env-functionality}), read here rather than held anywhere. No row is
+    // the ordinary case: a Worker that never set anything.
+    static async #composedEnv(db, workerId, modifier) {
+        const ambient = ExecEnv.scoped();
+        const row = await db.worker_module_state_get.get({ worker_id: workerId, namespace_owner: ENV_OWNER });
+        return EnvFunctionality.compose(ambient, row === undefined ? { version: 1, definitions: {} } : JSON.parse(row.state), modifier);
+    }
+    // The record goes on the output the spawn produces ({§execution-output-identity}) — the log row
+    // is the model's proposal and stays immutable. An output that is not there is a defect in the
+    // provenance chain, never a spawn that quietly runs unrecorded.
+    static async #recordEnv(db, entryId, record) {
+        const { changes } = await db.execution_record_env.run({ entry_id: entryId, env: JSON.stringify(record) });
+        if (changes !== 1)
+            throw new Error(`spawn output entry ${entryId} is not there to record the environment on`);
+    }
     // The slot contract, stated when a resource source cannot be read: the resource IS the
-    // program and the body its stdin; a command belongs beneath a targetless heading.
+    // program and the body its stdin; a targetless invocation takes a command body.
     static sourceRecovery(source, upstream) {
-        const contract = `\`### EXEC0 (${source})\` runs that resource as the program (its content is the program; the body is its stdin). To run a command in the workspace, write it beneath a targetless \`### EXEC0\`.`;
+        const contract = `The target \`${source}\` names the program resource; the body is its stdin. Without a target, the body is the command.`;
         return typeof upstream === "string" && upstream.length > 0 ? `${contract} ${upstream}` : contract;
     }
     static manifest = {
         name: "exec",
-        authority: "owner",
+        authority: "namespace",
         channels: { stdout: "text/stream", stderr: "text/stream" },
         defaultChannel: "stdout",
         category: "data",
-        entryOwner: "worker",
-        inherit: "none",
         writableBy: ["model", "client"],
         volatile: true,
         modelVisible: true,
         metadataModifier: true,
-        documentation: "Runs a registered executable tool — `### EXEC0 [executor] (program) <timeout minutes,poll minutes>\nbody` — using its `worker://~/_plurnk/tools/` invocation contract. Output streams into the worker's `<executor>:///<loop>/<turn>/<seq>` entry on that tool's own channels. A host-effecting invocation proposes for review before it runs; a read-only or pure one runs ungated. While it runs, Child Streams reports channel size and growth and READ can inspect any range; when it finishes, one terminal READ becomes visible automatically.",
+        documentation: "The opening fence names a registered executor or MCP service; its target, body, metadata, and timing follow that tool's invocation contract. Output streams into the workspace's `<executor>:///<id>` entry on that tool's own channels. A host-effecting invocation proposes for review before it runs; a read-only or pure one runs ungated. While it runs, the packet's `## Delegation` streams list reports channel size and growth and READ can inspect any range; when it finishes, one terminal READ becomes visible automatically.",
     };
     // The web-fetch the entry sink calls on content:null ({§exec-entry-sink}).
     // Default = schemes-http's checked WebFetcher; injectable for tests.
     #fetchWeb;
     #scheduler;
+    #inputTimeoutMs;
     constructor(fetchWeb) {
         super();
         this.#scheduler = new ExecScheduler();
+        this.#inputTimeoutMs = ExecutionInput.configuredTimeout();
         if (fetchWeb === undefined) {
             const webFetcher = new WebFetcher();
             this.#fetchWeb = (url, opts) => webFetcher.fetch(url, opts);
@@ -138,11 +126,6 @@ export default class Exec extends CoreSchemeAdapterBase {
                 return true;
         return false;
     }
-    // {§exec-timeout} — a `<-1>` spawn is nobody's obligation: terminals, joins, and optimistic
-    // settlement look past it.
-    isDetachedSpawn(subscriptionId) {
-        return this.#activeAborts.get(subscriptionId)?.detached === true;
-    }
     // {§exec-timeout} — a `<-1>` spawn ends with the daemon: nothing else ever aborts it, so the
     // stop sequence reaps it (bounded housekeeping) before the streaming drain barrier.
     abortDetached() {
@@ -160,7 +143,7 @@ export default class Exec extends CoreSchemeAdapterBase {
             .map(([subscriptionId]) => {
             const spawn = this.#activeSpawns.get(subscriptionId);
             if (spawn === undefined) {
-                throw new Error(`Active EXEC subscription ${subscriptionId} has no spawn settlement promise.`);
+                throw new Error(`Active execution subscription ${subscriptionId} has no spawn settlement promise.`);
             }
             return spawn;
         });
@@ -186,18 +169,13 @@ export default class Exec extends CoreSchemeAdapterBase {
     async kill(pathname, scope, ctx, scheme = "exec") {
         const core = this.coreContext(ctx);
         for (const entry of this.#activeAborts.values()) {
-            if (entry.workerId === core.workerId && entry.pathname === pathname) {
+            if (entry.workspaceId === core.workspaceId && entry.pathname === pathname && (scheme === "exec" || entry.runtime === scheme)) {
                 entry.controller.abort(ExecAbort.killReason(null));
                 return { status: 200 };
             }
         }
-        // Not running — settle the outcome from the closed subscription's status, scoped to the
-        // caller's own subscription (coordinates duplicate across workers, {§stream-owner-scoped}).
-        // The error answers in the model's OWN runtime-tag address (sh:///…), never the retired
-        // internal `exec` machinery ({§fs-answer-in-canon}) — the model KILLs what it addressed.
         const terminal = await ChannelWrite.execTerminalStatus(core.db, {
             workspaceId: core.workspaceId,
-            workerId: core.workerId,
             scheme,
             authority: "",
             pathname,
@@ -218,29 +196,29 @@ export default class Exec extends CoreSchemeAdapterBase {
             retryable: false,
         });
     }
-    // EXEC op handler — the actual model-facing entry point per plurnk.md.
-    // `### EXEC0 [runtime] (target)\nbody` → runtime-owned invocation buckets.
+    // Execution handler — the model-facing entry point per plurnk.md.
+    // Named executable fences lower to runtime-owned invocation buckets.
     //
     // Proposes (status=202) with attrs={runtime, cwd, body, pathname}.
     // applyResolution spawns the subprocess; output streams into the
     // coordinate-stamped <runtime>:///<pathname> entry's stdout/stderr channels
-    // (e.g. sh:///1/1/2/EXEC, {§exec}). The model READs that entry on a subsequent turn.
+    // (e.g. sh:///1/1/2/sh, {§exec}). The model READs that entry on a subsequent turn.
     async exec(statement, ctx) {
         const core = this.coreContext(ctx);
         const body = statement.body ?? "";
         if (core.executors === undefined)
             throw new Error("exec dispatched without an executor registry");
-        // {§exec-executor-slot}: the bracket names the executor; the path is its program.
+        // {§exec-executor-slot}: the fence names the executor; the path is its program.
         const route = execRouteOf(statement);
         const runtime = route.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. Bare EXEC remains the default-shell form.
-        const resolved = core.executors.entry(runtime, core.functionalityWorkerId);
+        // executed command differ from the authored body.
+        const resolved = core.executors.entry(runtime, core.workspaceId);
         if (resolved === undefined) {
-            return Results.failure("scheme:exec", "executor-not-registered", 400, `\`[${runtime}]\` names no registered executor for this worker. Executors are taught under \`worker://~/_plurnk/tools/\`; a bare \`### EXEC0\` is the shell.`, {}, {
+            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.functionalityWorkerId),
+                executors: core.executors.availableRuntimes(core.workspaceId),
                 retryable: false,
             });
         }
@@ -251,7 +229,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 retryable: false,
             });
         }
-        const registry = core.executors.toolRegistry(runtime, core.functionalityWorkerId);
+        const registry = core.executors.toolRegistry(runtime, core.workspaceId);
         const exactTarget = route.target === null ? null : route.target.raw;
         const registeredTool = registry?.tools.find((tool) => tool.target === exactTarget);
         if (registry !== null && registeredTool === undefined) {
@@ -262,7 +240,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 runtime,
                 availableTargetCount: availableTargets.length,
                 ...(availableTargets.length === 0 ? {} : {
-                    recovery: `Select a target documented under worker://~/_plurnk/tools/${runtime}/.`,
+                    recovery: `Select a target documented under worker:///_plurnk/tools/${runtime}/.`,
                 }),
                 retryable: false,
             });
@@ -273,7 +251,7 @@ export default class Exec extends CoreSchemeAdapterBase {
         const hasTarget = execTarget !== null;
         const refuse = (code, detail, recovery, extensions = {}) => Results.failure("scheme:exec", code, 400, detail, {}, { runtime, recovery, retryable: false, ...extensions });
         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 EXEC body.`);
+            return refuse("body-required", `Executable tool '${runtime}' requires a ${invocation.body.role} body.`, `Provide the ${invocation.body.role} in the ${runtime} body.`);
         }
         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.`);
@@ -307,7 +285,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 else if (targetDecl.kind === "resource" || targetDecl.kind === "script") {
                     resourceSource = resourceSourceOf(execTarget);
                     if (resourceSource === null) {
-                        throw new Error(`EXEC '${runtime}' resource target could not be classified`);
+                        throw new Error(`'${runtime}' resource target could not be classified`);
                     }
                 }
                 else {
@@ -315,46 +293,47 @@ export default class Exec extends CoreSchemeAdapterBase {
                 }
             }
         }
-        // {§exec-executor-slot} — the path names the program; `{cwd=<directory>}` names where it
-        // runs. A relative directory resolves against the project root, or the shell's own cwd
-        // when the workspace has none.
-        const runRoot = projectRoot ?? process.cwd();
-        // Metadata on a resource-address target belongs to the source scheme ({§exec-target-routing});
-        // on a local program it names the working directory and nothing else.
-        for (const block of resourceSource === null ? statement.metadata ?? [] : []) {
-            const named = /^cwd=(.+)$/.exec(block.trim());
-            if (named === null) {
-                return refuse("metadata-unsupported", `EXEC accepts only \`{cwd=<directory>}\` metadata; got \`{${block}}\`.`, "Name the working directory as `{cwd=sub}`; everything else belongs in the body.", { metadata: block });
-            }
-            const inspected = isAbsolute(named[1]) ? named[1] : resolve(runRoot, named[1]);
-            let isDirectory = false;
-            try {
-                isDirectory = (await stat(inspected)).isDirectory();
-            }
-            catch (cause) {
-                if (cause?.code !== "ENOENT")
-                    throw cause;
-            }
-            if (!isDirectory) {
-                return refuse("cwd-not-found", `EXEC working directory '${named[1]}' is not an existing directory.`, "Name an existing directory in `{cwd=…}`.", { cwd: named[1] });
+        // {§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 {
+            EnvFunctionality.modifier(statement.metadata);
+        }
+        catch (cause) {
+            if (!(cause instanceof OperationFailureError))
+                throw cause;
+            return cause.result;
+        }
+        // {§executor-metadata} Options belong to the invoked executor for every source kind.
+        const executor = resolved.executor;
+        if (executor.prepare !== undefined) {
+            const prepared = Results.assert(await executor.prepare({
+                runtime, body, target: resourceSource ?? 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 = inspected;
+            cwd = prepared.cwd;
+        }
+        else 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, 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 (cause?.code !== "ENOENT") {
-                    console.error(`EXEC target classification failed for '${inspected}':`, cause);
-                    return Results.failure("scheme:exec", "target-classification-failed", 500, `EXEC target '${target}' could not be inspected: ${ErrorDetail.preview(cause)}`, {}, { target, stage: "target-classification" });
+                    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 (kind === "directory") {
-                return refuse("target-not-a-program", `EXEC target '${target}' is a directory, not a program.`, "Run in a directory with `{cwd=<directory>}` and put the command in the body.", { target });
+                return refuse("target-not-a-program", `${runtime} target '${target}' is a directory, not a program.`, "Run in a directory with `[{\"cwd\": \"<directory>\"}]` and put the command in the body.", { target });
             }
             if (kind === "missing") {
                 // The target is not a script here, but it may be a registered tool of another
@@ -362,12 +341,12 @@ export default class Exec extends CoreSchemeAdapterBase {
                 const executors = core.executors;
                 const ownerRuntimes = executors === undefined
                     ? []
-                    : executors.availableRuntimes(core.functionalityWorkerId)
-                        .filter((tag) => executors.toolRegistry(tag, core.functionalityWorkerId)?.tools.some((tool) => tool.target === target) === true);
+                    : executors.availableRuntimes(core.workspaceId)
+                        .filter((tag) => executors.toolRegistry(tag, core.workspaceId)?.tools.some((tool) => tool.target === target) === true);
                 const recovery = ownerRuntimes.length === 0
-                    ? "Name an existing script as the program, or place a shell command beneath a bare `### EXEC0`."
-                    : `Run the registered tool with \`### EXEC0 [${ownerRuntimes[0]}] (${target})\`.`;
-                return refuse("target-not-found", "The EXEC program does not resolve as a script or a registered tool for this executor.", recovery, { target, ...(ownerRuntimes.length === 0 ? {} : { toolRuntimes: ownerRuntimes }) });
+                    ? `The target must name an existing program resource. A targetless ${runtime} takes the command in its body.`
+                    : `The tool \`${target}\` is registered under executor \`${ownerRuntimes[0]}\`; use that name on the opening fence.`;
+                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 }) });
             }
         }
         if (!hasBody && target === null && resourceSource === null) {
@@ -379,11 +358,8 @@ export default class Exec extends CoreSchemeAdapterBase {
         const effect = resolved.executor.effect(effectTarget);
         // cwd is the workspace project_root unless target routing selected a
         // directory override. {§exec-target-routing}, {§executor-sinks}
-        // Pathname is assigned by Dispatcher.#writeLog as <runtime>/<loop_seq>/
-        // <turn_seq>/<sequence> (executor-domain + coordinate, e.g. sh/1/1/2).
-        // `pathname` is stamped into attrs at log-write time; applyResolution
-        // reads it back here.
-        // EXEC repurposes the `<L>` slot as `<timeout, poll>` (MINUTES, held in seconds): mark[0] caps the spawn's
+        // The log writer claims the workspace output address before proposal application.
+        // An execution repurposes the `<L>` slot as `<timeout, poll>` (MINUTES, held in seconds): mark[0] caps the spawn's
         // lifetime, mark[1] sets the hibernation poll-wake cadence ({§exec-poll}). N>0 → deadline (504);
         // -1 / absent → unbounded (loop-life bounded); 0 → turn-scoped (reaped at the next pre-turn,
         // never surviving into the subsequent turn).
@@ -404,6 +380,69 @@ export default class Exec extends CoreSchemeAdapterBase {
         const preview = runtime !== "" ? `[${runtime}] ${previewInput}` : `$ ${previewInput}`;
         return { status: 202, body: preview, attrs }; // host runtime proposes with 202 — {§exec-host-proposes}
     }
+    async #inputRecipient(statement, ctx, runtime) {
+        const core = this.coreContext(ctx);
+        const target = statement.target;
+        const failure = (code, status, detail) => ({
+            failure: Results.failure("scheme:exec", code, status, detail, {}, { retryable: false }),
+        });
+        if (target?.kind !== "url" || target.scheme !== runtime || target.fragment !== null
+            || target.query !== null || statement.lineMarker !== null) {
+            return failure("invalid-input-target", 400, "SEND input addresses an execution, without a channel or scope.");
+        }
+        const coordinate = entryCoordinateOf(target, "namespace");
+        const found = [...this.#activeAborts.entries()].find(([, entry]) => entry.workspaceId === core.workspaceId && entry.runtime === runtime && entry.pathname === coordinate.pathname);
+        if (found !== undefined) {
+            if (core.executors?.entry(runtime, core.workspaceId)?.executor !== found[1].executor) {
+                return failure("input-unavailable", 409, "This execution's input receiver is no longer enabled.");
+            }
+            return { found };
+        }
+        const terminal = await ChannelWrite.execTerminalStatus(core.db, {
+            workspaceId: core.workspaceId, scheme: runtime, ...coordinate,
+        });
+        return terminal === null
+            ? failure("stream-not-found", 404, "No execution exists at the requested address.")
+            : failure("input-closed", 410, "Execution input is closed.");
+    }
+    async sendInput(statement, ctx, runtime) {
+        const recipient = await this.#inputRecipient(statement, ctx, runtime);
+        if ("failure" in recipient)
+            return recipient.failure;
+        const [subscriptionId, entry] = recipient.found;
+        const unavailable = entry.input.unavailable();
+        if (unavailable !== null)
+            return unavailable;
+        const denied = await this.capabilityDenial(entry.invocation, ctx);
+        if (denied !== null)
+            return denied;
+        return {
+            status: 202,
+            attrs: { inputSubscription: subscriptionId, inputBody: statement.body?.raw ?? "", inputTarget: statement.target.raw, effect: entry.effect },
+        };
+    }
+    async applyInput(args, ctx, runtime) {
+        const attrs = args.attrs;
+        if (typeof attrs.inputSubscription !== "number" || typeof attrs.inputBody !== "string" || typeof attrs.inputTarget !== "string") {
+            throw new InvalidOperationResultError("Execution input proposal is missing its invocation or body.");
+        }
+        const body = args.body ?? attrs.inputBody;
+        const statement = {
+            op: "SEND", aside: null, metadata: args.metadata === null ? null : [...args.metadata],
+            target: parsePath(attrs.inputTarget), lineMarker: null, body: { raw: body, json: null }, position: { line: 1, column: 1 },
+        };
+        const recipient = await this.#inputRecipient(statement, ctx, runtime);
+        if ("failure" in recipient)
+            return recipient.failure;
+        const [subscriptionId, entry] = recipient.found;
+        if (subscriptionId !== attrs.inputSubscription) {
+            return Results.failure("scheme:exec", "input-closed", 410, "The proposed execution input is no longer live.", {}, { retryable: false });
+        }
+        const denied = await this.capabilityDenial(statement, ctx) ?? await this.capabilityDenial(entry.invocation, ctx);
+        if (denied !== null)
+            return denied;
+        return entry.input.deliver(body, args.metadata, ctx.signal);
+    }
     async applyResolution(args, ctx) {
         const core = this.coreContext(ctx);
         const attrs = args.attrs;
@@ -414,63 +453,74 @@ export default class Exec extends CoreSchemeAdapterBase {
         let target = (typeof attrs.target === "string" && attrs.target.length > 0) ? attrs.target : null;
         const effect = attrs.effect;
         if (typeof pathname !== "string" || pathname.length === 0) {
-            throw new InvalidOperationResultError("The accepted EXEC proposal is missing its stream pathname.");
+            throw new InvalidOperationResultError("The accepted execution proposal is missing its stream pathname.");
         }
         if (!EffectPolicy.isEffect(effect)) {
-            throw new InvalidOperationResultError("The accepted EXEC proposal is missing its canonical effect fact.");
+            throw new InvalidOperationResultError("The accepted execution proposal is missing its canonical effect fact.");
         }
-        // Every non-file resource becomes a temporary executor target after
-        // acceptance; body presence never changes the target's role.
+        const invocation = {
+            runtime: runtime, aside: null, metadata: null,
+            target: attrs.resourceSource ? parsePath(attrs.resourceSource) : target === null ? null : parsePath(target),
+            lineMarker: null, body, position: { line: 1, column: 1 },
+        };
+        // {§exec-source-temporary} Admission precedes source realization. Native
+        // 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 EXEC proposal has an invalid scheme source address.");
+                throw new InvalidOperationResultError("The accepted execution proposal has an invalid scheme source address.");
             }
-            const read = await this.readExecSource({
+            const source = await this.readExecSource({
                 op: "READ",
-                delimiter: "",
-                annotation: null,
+                aside: null,
                 target: sourceTarget,
-                metadata: args.metadata === null ? null : [...args.metadata],
+                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 EXEC
+                // {§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),
+                    recovery: _a.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 EXEC source.`, { outcome: "scheme_source_content_unavailable" }, {
+                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,
                 });
             }
-            tempPath = join(tmpdir(), `plurnk-exec-${crypto.randomUUID()}`);
-            await writeFile(tempPath, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
-            target = tempPath;
+            if (source.nativePath !== null) {
+                target = source.nativePath;
+            }
+            else {
+                tempPath = join(tmpdir(), `plurnk-exec-${crypto.randomUUID()}${extname(sourceTarget.pathname)}`);
+                await writeFile(tempPath, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
+                target = tempPath;
+            }
         }
         if (body.length === 0 && target === null) {
-            throw new InvalidOperationResultError("The accepted EXEC proposal has neither a body nor a realized target.");
+            throw new InvalidOperationResultError("The accepted execution proposal has neither a body nor a realized target.");
         }
         // 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 (core.executors === undefined) {
-            throw new InvalidOperationResultError("An accepted EXEC proposal has no executor registry.");
+            throw new InvalidOperationResultError("An accepted execution proposal has no executor registry.");
         }
-        const resolved = core.executors.entry(runtime, core.functionalityWorkerId);
+        const resolved = core.executors.entry(runtime, core.workspaceId);
         if (resolved === undefined) {
-            throw new InvalidOperationResultError(`The '${runtime}' executor disappeared after its EXEC proposal.`);
+            throw new InvalidOperationResultError(`The '${runtime}' executor disappeared after its proposal.`);
         }
         // {§executor-effect}, {§exec-hold-until-concluded}, #107: the admitted
         // effect fact rides the hold predicate unchanged through application.
@@ -485,7 +535,9 @@ export default class Exec extends CoreSchemeAdapterBase {
         const seed = { channels: seedChannels };
         // {§exec} — the stream entry's scheme IS the runtime tag (sh/node), so it addresses by
         // tag authority (sh:///l/t/s). The engine registers each runtime tag → this handler.
-        const { entryId } = await EntryCrud.writeEntry({ authority: "", pathname }, seed, core, runtime, core.workerId);
+        const { entryId } = await EntryCrud.writeEntry({ authority: "", pathname }, seed, core, runtime, {
+            defaultChannel: resolved.executor.defaultChannel, output: true,
+        });
         if (entryId === null) {
             return Results.failure("scheme:exec", "stream-entry-write-failed", 500, `The ${runtime} stream entry could not be created.`, {
                 outcome: "entry_write_failed",
@@ -500,6 +552,10 @@ export default class Exec extends CoreSchemeAdapterBase {
             handle: runtime !== "" ? `${runtime}: ${body !== "" ? body : target ?? ""}` : body,
             pollSeconds: typeof attrs.pollSec === "number" ? attrs.pollSec : null, // {§exec-poll} — hibernation wake cadence
             turnScoped: attrs.turnScoped === true, // {§exec-poll} — `<0>` reaped at the next pre-turn
+            detached: attrs.detached === true, // {§worker-obligations} — `<-1>` is nobody's obligation
+            publishedChannel: resolved.executor.publishedChannel,
+            source: attrs.coordinate === undefined ? undefined
+                : `log:///${attrs.coordinate.loop_seq}/${attrs.coordinate.turn_seq}/${attrs.coordinate.sequence}/${runtime}`,
         });
         const controller = new AbortController();
         let unlink = () => { };
@@ -521,7 +577,8 @@ export default class Exec extends CoreSchemeAdapterBase {
             if (parent.aborted)
                 controller.abort(ExecAbort.teardownReason());
         }
-        this.#activeAborts.set(subscriptionId, { workerId: core.workerId, turnId: core.turnId, pathname, runtime, effect, controller, unlink, detached: attrs.detached === true });
+        const input = new ExecutionInput(controller.signal, this.#inputTimeoutMs);
+        this.#activeAborts.set(subscriptionId, { workspaceId: core.workspaceId, workerId: core.workerId, turnId: core.turnId, pathname, runtime, effect, controller, unlink, detached: attrs.detached === true, input, invocation, executor: resolved.executor });
         this.liveSubscriptions().register(subscriptionId, {
             cancel: () => controller.abort(ExecAbort.teardownReason()),
         });
@@ -530,8 +587,8 @@ export default class Exec extends CoreSchemeAdapterBase {
             try {
                 return await this.#runExecutor({
                     executor: resolved.executor,
-                    runtime, body, cwd, target, ctx: core, pathname,
-                    entryId, subscriptionId, signal: controller.signal, controller, tempPath,
+                    runtime, body, cwd, target, metadata: args.metadata, ctx: core, pathname, coordinate: attrs.coordinate,
+                    entryId, subscriptionId, signal: controller.signal, controller, tempPath, input,
                     timeoutSec: typeof attrs.timeoutSec === "number" ? attrs.timeoutSec : null,
                 });
             }
@@ -567,11 +624,45 @@ export default class Exec extends CoreSchemeAdapterBase {
     // a setState("closed") that races a prior write() can flip the
     // notify's reported state to "closed" before the chunk event fires
     // as "active." Chain through a single promise queue to serialize.
+    // {§exec-tool-fall-through} — a bare shell command whose program is really the name of a tool
+    // of an enabled runtime (`brave_web_search {…}` under the default shell) dies with the shell's
+    // exit 127. The failure receipt states that fact at the failure site, with the invocation the
+    // registry actually publishes, so the model recovers in one turn instead of by rereading docs.
+    #namedToolFallThrough(result, runtime, body, ctx) {
+        const core = this.coreContext(ctx);
+        const executors = core.executors;
+        if (executors === undefined || result.problem === undefined)
+            return result;
+        const program = body.trim().split(/\s+/u, 1)[0] ?? "";
+        if (program.length === 0)
+            return result;
+        const owners = executors.availableRuntimes(core.workspaceId)
+            .filter((tag) => tag !== runtime
+            && executors.toolRegistry(tag, core.workspaceId)?.tools.some((tool) => tool.target === program) === true);
+        if (owners.length === 0)
+            return result;
+        const owner = owners[0];
+        // The tool's own document, where its family publishes it ({§tools-resource-materialization}).
+        const root = executors.entry(owner, core.workspaceId)?.resourcesPath ?? "/plurnk";
+        const contract = `worker://${generatedPathname(`${root}/${owner}/${ToolResources.targetSegment(program)}.md`)}`;
+        return {
+            ...result,
+            problem: {
+                ...result.problem,
+                detail: `'${runtime}' exited with code 127; \`${program}\` is a registered tool of \`${owner}\`.`,
+                recovery: `Use the \`${owner}\` fence with target \`(${program})\` and JSON input in the body; contract: ${contract}.`,
+                toolRuntimes: owners,
+                tool: program,
+            },
+        };
+    }
     async #runExecutor(opts) {
-        const { executor, runtime, body, cwd, target, ctx, pathname, entryId, subscriptionId, signal, controller, timeoutSec, tempPath } = opts;
+        const { runtime, body, cwd, target, metadata, ctx, pathname, entryId, subscriptionId, signal, controller, timeoutSec, tempPath, input, coordinate } = opts;
+        // {§functionality-model-projection} — a Core-owned manager acts for the invoking Worker. The
+        // framework's ExecArgs carries no Worker identity, so Core binds it here, at the operation.
+        const executor = isWorkerBound(opts.executor) ? opts.executor.forWorker(ctx.workerId) : opts.executor;
         const db = ctx.db;
-        const coordinate = coordinateFromPathname(pathname);
-        // grammar 0.74.20 EXEC `<T>` — kill the spawn after T seconds. unref'd so a pending timer never
+        // an execution's `<T>` — kill the spawn after T seconds. unref'd so a pending timer never
         // holds the process open; cleared in finally so a spawn that finishes first leaves no timer.
         let timedOut = false;
         const timeoutTimer = timeoutSec !== null
@@ -607,7 +698,14 @@ export default class Exec extends CoreSchemeAdapterBase {
             callerSource = WorkerControlAddress.render(caller.name);
             return callerSource;
         };
-        const entrySink = (path, content, opts) => {
+        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`));
@@ -619,7 +717,9 @@ export default class Exec extends CoreSchemeAdapterBase {
             const fetchAddress = address !== null && (address.scheme === "http" || address.scheme === "https")
                 ? address
                 : null;
-            const binding = this.bindEntryAddress(parsed, ctx);
+            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.
@@ -629,12 +729,12 @@ export default class Exec extends CoreSchemeAdapterBase {
                     return Promise.reject(new Error("entry(): content:null requires an http(s):// URL"));
                 materialized = this.#fetchWeb(fetchAddress.url, { signal });
             }
-            else {
+            else if (typeof content === "string" && requestedPath !== null) {
                 materialized = Promise.resolve({
                     url: fetchAddress?.url ?? "http://localhost",
                     body: content,
                     mimetype: opts.mimetype,
-                    allowTavily: false,
+                    allowConfiguredMaterializer: false,
                 });
             }
             const op = async () => {
@@ -647,42 +747,53 @@ export default class Exec extends CoreSchemeAdapterBase {
                 if (resolved.address === null) {
                     throw new Error(`entry(): '${path.slice(0, 80)}' did not resolve to an entry address`);
                 }
-                const { authority, pathname, scheme, ownerId } = resolved.address;
+                const { authority, pathname, scheme } = resolved.address;
                 const coordinate = { authority, pathname };
-                const fetched = await materialized;
-                if (fetched === null)
-                    throw new Error(`entry(): '${path.slice(0, 80)}' is dead`);
-                let web;
-                try {
-                    web = await WebFetcher.materialize(fetched, new DbProjectionCaps(ctx));
+                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;
                 }
-                catch (error) {
-                    if (!signal.aborted && error instanceof WebMaterializationError) {
-                        console.error("entry() web materialization failed", { path, error });
+                else {
+                    const fetched = await materialized;
+                    if (fetched === null)
+                        throw new Error(`entry(): '${path.slice(0, 80)}' is dead`);
+                    let web;
+                    try {
+                        web = await WebFetcher.materialize(fetched, new DbProjectionCaps(ctx));
                     }
-                    throw error;
-                }
-                if (web === null)
-                    throw new Error(`entry(): '${path.slice(0, 80)}' has no readable projection`);
-                if (web.body === undefined) {
-                    throw new Error(web.bodyOutcome.failure?.detail
-                        ?? `entry(): '${path.slice(0, 80)}' produced no readable body`);
+                    catch (error) {
+                        if (!signal.aborted && error instanceof WebMaterializationError) {
+                            console.error("entry() web materialization failed", { path, error });
+                        }
+                        throw error;
+                    }
+                    if (web === null)
+                        throw new Error(`entry(): '${path.slice(0, 80)}' has no readable projection`);
+                    if (web.body === undefined)
+                        throw new Error(web.bodyOutcome.failure?.detail ?? `entry(): '${path.slice(0, 80)}' produced no readable body`);
+                    channels = WebFetcher.materializedChannels(web, content === null && fetchAddress !== null ? { url: fetchAddress.url, method: "GET" } : undefined);
+                    decisive = web.body.content;
+                    source = web.html?.content ?? decisive;
                 }
-                // {§exec-entry-sink}/{§html-materialization} The shared
-                // materializer owns the decisive projection and its provenance.
-                const channels = WebFetcher.materializedChannels(web, content === null && fetchAddress !== null
-                    ? { url: fetchAddress.url, method: "GET" }
-                    : undefined);
-                const decisive = web.body.content;
-                const source = web.html?.content ?? decisive;
                 const causalSource = await resolveCallerSource();
-                const written = Results.assert(await EntryCrud.writeEntry(coordinate, { channels }, ctx, scheme, ownerId));
+                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 worker = await db.envelope_get_worker_by_name.get({ workspace_id: ctx.workspaceId, name: "plurnk" })
-                        ?? await db.envelope_insert_worker.get({ workspace_id: ctx.workspaceId, name: "plurnk", origin: "_plurnk" });
-                    if (worker === undefined)
-                        throw new Error("entry(): plurnk worker resolution returned no row");
-                    const loop = await db.envelope_insert_client_loop.get({ worker_id: worker.id });
+                    const workerId = await RuntimeWorker.ensure(db, ctx.workspaceId);
+                    const loop = await db.envelope_insert_client_loop.get({ worker_id: workerId });
                     if (loop === undefined)
                         throw new Error("entry(): loop insert returned no row");
                     const turn = await Turn.open(db, {
@@ -691,7 +802,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                         kind: "operation",
                     });
                     narration = {
-                        workerId: worker.id,
+                        workerId,
                         loopId: loop.id,
                         loopSeq: loop.sequence,
                         turnId: turn.id,
@@ -721,7 +832,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 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", delimiter: "", signal: null,
+                    op: "EDIT", signal: null,
                     scheme, username: null, password: null,
                     hostname: address === null ? null : parsed.hostname,
                     port: address === null ? null : parsed.port,
@@ -757,34 +868,37 @@ export default class Exec extends CoreSchemeAdapterBase {
             return run;
         };
         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 {
             if (signal.aborted) {
-                result = Results.failure("scheme:exec", "execution-cancelled", 499, `Execution of '${runtime}' was cancelled by the service.`, {}, {
-                    runtime,
-                    stage: "execution",
-                    retryable: false,
-                });
+                result = cancelled();
             }
             else
                 try {
+                    const composed = await _a.#composedEnv(db, ctx.workerId, EnvFunctionality.modifier(metadata));
+                    await _a.#recordEnv(db, entryId, composed.record);
                     const reported = await executor.run({
-                        runtime, body, cwd, target, signal,
+                        registerInput: (receiver) => input.register(receiver),
+                        runtime, body, cwd, target, metadata, signal,
                         entry: entrySink,
                         interact: (request) => {
                             if (ctx.requestInteraction === undefined) {
-                                throw new Error("EXEC client interaction capability is unavailable.");
+                                throw new Error("The execution's client interaction capability is unavailable.");
                             }
-                            return ctx.requestInteraction(request);
+                            return ctx.requestInteraction(request, signal);
                         },
-                        env: ExecEnv.scoped(), // SPEC {§exec} {§exec-env-scoped} — never plurnk's own secrets
+                        env: composed.env, // SPEC {§exec} {§exec-env-scoped}
                         write: (channel, chunk, mimetype) => enqueue(() => ChannelWrite.appendToChannel(db, {
+                            producerWorkerId: ctx.workerId,
                             entryId, channel, chunk, mimetype, notify: ctx.streamEventNotify, coordinate,
                         })),
                         setState: (channel, state) => enqueue(() => ChannelWrite.setChannelState(db, {
+                            producerWorkerId: ctx.workerId,
                             entryId, channel, state, notify: ctx.streamEventNotify, coordinate,
                         })),
                         emit: (event) => ctx.pushNotice?.(event),
                     });
+                    input.close();
                     // Drain the queue so the subscription doesn't close before
                     // final chunk events / state transitions have committed.
                     await queue;
@@ -801,14 +915,19 @@ export default class Exec extends CoreSchemeAdapterBase {
                     }
                 }
                 catch (cause) {
-                    // A rejecting driver must still CONCLUDE its stream — uncaught, the subscription sat
-                    // open forever and the floating spawn promise was an unhandled rejection.
-                    console.error(`Executor '${runtime}' threw outside its operation result contract:`, cause);
-                    result = Results.failure("scheme:exec", "executor-threw", 500, `The '${runtime}' executor failed outside its operation result contract.`, {}, {
-                        runtime,
-                        stage: "execution",
-                        retryable: false,
-                    });
+                    input.close();
+                    // {§executor-results} — an abort rejection is not an executor crash.
+                    if (signal.aborted && (cause === signal.reason || (cause instanceof Error && cause.name === "AbortError"))) {
+                        result = cancelled();
+                    }
+                    else {
+                        console.error(`Executor '${runtime}' threw outside its operation result contract:`, cause);
+                        result = Results.failure("scheme:exec", "executor-threw", 500, `The '${runtime}' executor failed outside its operation result contract.`, {}, {
+                            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
@@ -824,11 +943,10 @@ export default class Exec extends CoreSchemeAdapterBase {
                 // spawn we reaped did not succeed, whatever it resolved under abort.
             }
             else if (signal.aborted && result.status < 400) {
-                result = Results.failure("scheme:exec", "execution-cancelled", 499, `Execution of '${runtime}' was cancelled by the service.`, exitCode === null ? {} : { exitCode }, {
-                    runtime,
-                    stage: "execution",
-                    retryable: false,
-                });
+                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`
@@ -883,7 +1001,7 @@ export default class Exec extends CoreSchemeAdapterBase {
             // executor result, but an exceptional failure remains observable.
             if (tempPath !== null) {
                 await unlink(tempPath).catch((cause) => {
-                    console.error(`EXEC source temporary cleanup failed for '${tempPath}':`, cause);
+                    console.error(`Execution source temporary cleanup failed for '${tempPath}':`, cause);
                 });
             }
             this.#activeAborts.get(subscriptionId)?.unlink();
@@ -895,7 +1013,7 @@ export default class Exec extends CoreSchemeAdapterBase {
             if (ctx.wakeWorkerNotify !== undefined) {
                 ctx.wakeWorkerNotify({
                     workspaceId: ctx.workspaceId, workerId: ctx.workerId,
-                    entryOwnerId: ctx.workerId, entryId, target: `${runtime}://${pathname}`, subscriptionId, result,
+                    entryId, target: `${runtime}://${pathname}`, subscriptionId, result,
                     scheme: runtime,
                     summary: `${runtime}://${pathname} completed (${exitLabel}); stdout=${stdoutLength} bytes, stderr=${stderrLength} bytes`,
                     ...coordinate,
@@ -904,49 +1022,34 @@ export default class Exec extends CoreSchemeAdapterBase {
             if (finalizationErrors.length === 1)
                 throw finalizationErrors[0];
             if (finalizationErrors.length > 1) {
-                throw new AggregateError(finalizationErrors, `EXEC narration ${completedNarration?.turnId ?? "unknown"} failed to settle`);
+                throw new AggregateError(finalizationErrors, `Execution narration ${completedNarration?.turnId ?? "unknown"} failed to settle`);
             }
         }
         return result;
     }
-    async resolveEntryAddress(target, ctx) {
-        if (target.kind !== "url")
-            return null;
-        const ownerId = await Owner.resolveStreamOwner(target.hostname, this.coreContext(ctx));
-        return ownerId === null
-            ? Results.failure("scheme:exec", "stream-not-found", 404, "No visible stream exists at the requested address.")
-            : ownerId === ctx.workerId
-                ? { authority: "", pathname: target.pathname }
-                : Results.failure("scheme:exec", "stream-not-found", 404, "The internal exec surface does not address another Worker's stream; use its runtime scheme.");
-    }
     async find(statement, ctx) {
         const core = this.coreContext(ctx);
-        const owner = await resolveStreamStatement(statement, core);
-        if (owner === null) {
-            return Results.failure("scheme:exec", "stream-not-found", 404, "No visible stream exists at the requested address.", {
-                content: null, mimetype: null, results: [], itemsWeightTotal: 0, returnedItemsWeightTotal: 0,
-                matchingPathCount: 0, matchLocationCount: 0,
-            });
-        }
-        return EntryFind.findWorkspaceEntries(owner.statement, core, Exec.manifest, { ownerId: owner.ownerId });
+        return EntryFind.findWorkspaceEntries(statement, core, _a.manifest, {});
     }
     async readEntry(pathname, ctx) {
         const core = this.coreContext(ctx);
         return "entries" in ctx
             ? ctx.entries.read(pathname)
-            : EntryCrud.readEntry({ authority: "", pathname }, core, Exec.manifest.name, core.workerId);
+            : EntryCrud.readEntry({ authority: "", pathname }, core, _a.manifest.name);
     }
     async writeEntry(pathname, entry, ctx) {
         const core = this.coreContext(ctx);
         return "entries" in ctx
             ? ctx.entries.write(pathname, entry)
-            : EntryCrud.writeEntry({ authority: "", pathname }, entry, core, Exec.manifest.name, core.workerId);
+            : EntryCrud.writeEntry({ authority: "", pathname }, entry, core, _a.manifest.name);
     }
     async deleteEntry(pathname, ctx) {
         const core = this.coreContext(ctx);
         return "entries" in ctx
             ? ctx.entries.delete(pathname)
-            : EntryCrud.deleteEntry({ authority: "", pathname }, core, Exec.manifest.name, core.workerId);
+            : EntryCrud.deleteEntry({ authority: "", pathname }, core, _a.manifest.name);
     }
 }
+_a = Exec;
+export default Exec;
 //# sourceMappingURL=Exec.js.map