@plurnk/plurnk-service 1.17.0 → 1.19.0

package/dist/schemes/Exec.js

@@ -1,11 +1,16 @@
-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 EntryFind from "./_entry-find.js";
+import { MetadataOptions } from "@plurnk/plurnk-schemes";
 import ChannelWrite from "../core/ChannelWrite.js";
-import ExecEnv from "./exec-env.js";
+import EnvFunctionality from "../server/EnvFunctionality.js";
 import ExecAbort from "./exec-abort.js";
+import { LIFETIME_SYNTAX, formatLifetime, parseExecLifetime } from "./exec-lifetime.js";
 import { entryCoordinateOf, generatedPathname, renderAddress } from "../core/plurnk-uri.js";
 import { writeFile, unlink, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -17,6 +22,8 @@ import { InvalidOperationResultError, NetworkAddress, ResourceNames, } from "@pl
 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";
@@ -50,7 +57,15 @@ const resourceSourceOf = (target) => {
         return null;
     return target.raw;
 };
-export default class Exec extends CoreSchemeAdapterBase {
+class Exec extends CoreSchemeAdapterBase {
+    // 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 targetless invocation takes a command body.
     static sourceRecovery(source, upstream) {
@@ -105,7 +120,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 return true;
         return false;
     }
-    // {§exec-timeout} — a `<-1>` spawn ends with the daemon: nothing else ever aborts it, so the
+    // {§exec-lifetime} — a detached spawn ends with the daemon: nothing else ever aborts it, so the
     // stop sequence reaps it (bounded housekeeping) before the streaming drain barrier.
     abortDetached() {
         for (const { controller, detached } of this.#activeAborts.values())
@@ -122,7 +137,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;
         });
@@ -145,7 +160,11 @@ export default class Exec extends CoreSchemeAdapterBase {
     }
     // {§stream-control} — active KILL routes through the live controller;
     // terminal and missing outcomes resolve from the durable subscription.
-    async kill(pathname, scope, ctx, scheme = "exec") {
+    async kill(statement, ctx) {
+        if (statement.target?.kind !== "url")
+            throw new InvalidOperationResultError("Execution KILL requires a runtime URL.");
+        const { scheme } = statement.target;
+        const { pathname } = entryCoordinateOf(statement.target, "namespace");
         const core = this.coreContext(ctx);
         for (const entry of this.#activeAborts.values()) {
             if (entry.workspaceId === core.workspaceId && entry.pathname === pathname && (scheme === "exec" || entry.runtime === scheme)) {
@@ -163,19 +182,11 @@ export default class Exec extends CoreSchemeAdapterBase {
         if (terminal === null) {
             return Results.failure("scheme:exec", "stream-not-found", 404, `No stream exists at ${target}.`, {}, { target });
         }
-        if (terminal === 499) {
-            return Results.failure("scheme:exec", "stream-already-killed", 410, `Stream ${target} was already killed.`, {}, {
-                target,
-                retryable: false,
-            });
-        }
-        return Results.failure("scheme:exec", "stream-already-terminal", 409, `${target} already concluded with status ${terminal}.`, {}, {
-            target,
-            terminalStatus: terminal,
-            retryable: false,
-        });
+        // {§stream-control} — the process is already not running, which is what KILL asks for; the
+        // receipt says how it ended instead of refusing a cleanup that raced the exit (#757).
+        return { status: 200, terminalStatus: terminal };
     }
-    // EXEC op handler — the actual model-facing entry point per plurnk.md.
+    // 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}.
@@ -192,7 +203,7 @@ export default class Exec extends CoreSchemeAdapterBase {
         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.
+        // 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, `No executor or MCP service named \`${runtime}\` is registered for this worker.`, {}, {
@@ -219,7 +230,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 from worker://${ToolResources.documentPath(runtime, resolved.resourcesPath)}.`,
                 }),
                 retryable: false,
             });
@@ -248,7 +259,8 @@ export default class Exec extends CoreSchemeAdapterBase {
         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}).
-        let cwd = projectRoot ?? process.cwd();
+        const defaultCwd = projectRoot ?? process.cwd();
+        let cwd = defaultCwd;
         let target = null;
         let resourceSource = null;
         const targetDecl = invocation.target;
@@ -264,7 +276,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 {
@@ -272,6 +284,39 @@ export default class Exec extends CoreSchemeAdapterBase {
                 }
             }
         }
+        // {§exec-target-near-miss} — a target in this executor's own scheme whose path can never be a
+        // stream (`sh:///daemon-env`; streams are eight hex digits) is the writer's name for the run,
+        // not a program: with a body present, the body runs as if targetless. Never taught.
+        if (resourceSource !== null && hasBody && execTarget?.kind === "url" && execTarget.scheme === runtime
+            && !/^\/[0-9a-f]{8}(?:[/#]|$)/u.test(execTarget.pathname ?? "")) {
+            resourceSource = null;
+        }
+        // {§exec-lifetime} — the scope slot is text coordinates, and an execution has none: what a
+        // numeric scope used to mean is the metadata's one field.
+        if (statement.lineMarker !== null) {
+            return refuse("scope-unsupported", "An execution takes no scope.", `Remove the scope; how long the run may live is metadata: [{"lifetime": "30m"}], or ${LIFETIME_SYNTAX}.`);
+        }
+        // {§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;
+        }
+        // {§exec-lifetime} — the service's other reserved key, read before the executor's options so
+        // an unreadable lifetime is refused by name rather than spawning under a wrong bound. A block
+        // that is not the option-array shape carries no lifetime for the service to read: it is the
+        // invoked executor's to accept or refuse ({§executor-metadata}), exactly as `env` is.
+        const read = MetadataOptions.parse(statement.metadata, "scheme:exec", { runtime });
+        const lifetime = parseExecLifetime("failure" in read ? undefined : read.lifetime);
+        if ("invalid" in lifetime) {
+            return Results.failure("scheme:exec", "lifetime-invalid", 400, lifetime.invalid, {}, {
+                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;
         if (executor.prepare !== undefined) {
@@ -297,11 +342,17 @@ export default class Exec extends CoreSchemeAdapterBase {
             }
             catch (cause) {
                 if (cause?.code !== "ENOENT") {
-                    console.error(`EXEC target classification failed for '${inspected}':`, cause);
+                    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") {
+            // {§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.`, "Run in a directory with `[{\"cwd\": \"<directory>\"}]` and put the command in the body.", { target });
             }
             if (kind === "missing") {
@@ -328,22 +379,12 @@ export default class Exec extends CoreSchemeAdapterBase {
         // 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 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).
-        const marks = statement.lineMarker?.marks;
-        const timeoutSec = typeof marks?.[0] === "number" && marks[0] > 0 ? Math.floor(marks[0]) * 60 : undefined;
-        const turnScoped = typeof marks?.[0] === "number" && marks[0] === 0;
-        const detached = typeof marks?.[0] === "number" && marks[0] === -1;
-        const pollSec = typeof marks?.[1] === "number" && marks[1] >= 0 ? Math.floor(marks[1]) * 60 : undefined;
+        // {§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,
             ...(resourceSource !== null ? { resourceSource } : {}),
-            ...(timeoutSec !== undefined ? { timeoutSec } : {}),
-            ...(turnScoped ? { turnScoped: true } : {}),
-            ...(detached ? { detached: true } : {}),
-            ...(pollSec !== undefined ? { pollSec } : {}),
+            ...lifetime,
         };
         const previewInput = body !== "" ? body : execTarget?.raw ?? "";
         const preview = runtime !== "" ? `[${runtime}] ${previewInput}` : `$ ${previewInput}`;
@@ -422,13 +463,13 @@ 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.");
         }
         const invocation = {
-            op: "EXEC", executor: runtime, aside: null, metadata: null,
+            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 },
         };
@@ -438,7 +479,7 @@ export default class Exec extends CoreSchemeAdapterBase {
         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 source = await this.readExecSource({
                 op: "READ",
@@ -452,12 +493,12 @@ export default class Exec extends CoreSchemeAdapterBase {
             }, 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 }) });
             }
@@ -479,17 +520,17 @@ export default class Exec extends CoreSchemeAdapterBase {
             }
         }
         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.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.
@@ -519,19 +560,19 @@ export default class Exec extends CoreSchemeAdapterBase {
         const subscriptionId = await ChannelWrite.openSubscription(core.db, {
             workerId: core.workerId, entryId, scheme: runtime,
             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
+            turnScoped: attrs.turnScoped === true, // {§exec-lifetime} — "turn" is reaped at the next pre-turn
+            detached: attrs.detached === true, // {§worker-obligations} — "detached" 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 = () => { };
-        // {§exec-timeout} — `<-1>` outlives the loop: it never binds to the loop's teardown; only KILL,
-        // the worker's total reap, and daemon shutdown end it.
+        // {§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) {
             const parent = core.signal;
+            // {§worker-lifecycle-exec-epoch-bound}
             // The spawn's kill binds to its loop's cancellation epoch (ctx.signal —
             // captured here, stable for the loop). The parent only aborts on FORCEFUL loop
             // teardown — a 202-graceful loop lets its spawns outlive, never firing this — so
@@ -539,7 +580,7 @@ export default class Exec extends CoreSchemeAdapterBase {
             // then re-check `aborted`: a listener added to an already-aborted signal never
             // fires, so a check-then-attach order LOSES an abort that lands in the gap (R1's
             // TOCTOU leak). Attach-then-check closes it; controller.abort is idempotent, so a
-            // doubled fire is harmless. {§exec-timeout}
+            // doubled fire is harmless. {§exec-lifetime}
             const onParentAbort = () => controller.abort(ExecAbort.teardownReason());
             parent.addEventListener("abort", onParentAbort, { once: true });
             unlink = () => parent.removeEventListener("abort", onParentAbort);
@@ -613,7 +654,7 @@ export default class Exec extends CoreSchemeAdapterBase {
         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`)}`;
+        const contract = `worker://${generatedPathname(`${root}/${owner}/${ToolResources.targetSegment(program)}.json`)}`;
         return {
             ...result,
             problem: {
@@ -626,9 +667,12 @@ export default class Exec extends CoreSchemeAdapterBase {
         };
     }
     async #runExecutor(opts) {
-        const { executor, runtime, body, cwd, target, metadata, ctx, pathname, entryId, subscriptionId, signal, controller, timeoutSec, tempPath, input, coordinate } = 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;
-        // 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
@@ -744,13 +788,10 @@ export default class Exec extends CoreSchemeAdapterBase {
                         }
                         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;
+                    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, {
@@ -758,20 +799,15 @@ export default class Exec extends CoreSchemeAdapterBase {
                     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 });
-                    if (loop === undefined)
-                        throw new Error("entry(): loop insert returned no row");
+                    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: worker.id,
+                        workerId,
                         loopId: loop.id,
                         loopSeq: loop.sequence,
                         turnId: turn.id,
@@ -839,7 +875,13 @@ export default class Exec extends CoreSchemeAdapterBase {
         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) {
+            // A cancellation may land while the environment resolves; a listener added to an
+            // already-aborted signal never fires, so the run never receives a dead signal.
+            const composed = signal.aborted ? null
+                : await EnvFunctionality.resolve(db, ctx.workspaceId, ctx.workerId, EnvFunctionality.modifier(metadata));
+            if (composed !== null)
+                await _a.#recordEnv(db, entryId, composed.record);
+            if (composed === null || signal.aborted) {
                 result = cancelled();
             }
             else
@@ -848,13 +890,15 @@ export default class Exec extends CoreSchemeAdapterBase {
                         registerInput: (receiver) => input.register(receiver),
                         runtime, body, cwd, target, metadata, signal,
                         entry: entrySink,
-                        interact: (request) => {
+                        // {§executor-interaction-sink} — the executor's signal narrows the execution's, never replaces it.
+                        interact: (request, interactionSignal) => {
                             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, signal);
+                            return ctx.requestInteraction(request, interactionSignal === undefined ? signal
+                                : AbortSignal.any([signal, interactionSignal]));
                         },
-                        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,
@@ -900,9 +944,10 @@ export default class Exec extends CoreSchemeAdapterBase {
             // A timeout aborts the spawn → the executor reports 499; replace the
             // complete result so status and Problem remain one valid truth.
             if (timedOut) {
-                result = Results.failure("scheme:exec", "execution-timeout", 504, `Execution of '${runtime}' exceeded its ${(timeoutSec ?? 0) / 60}-minute deadline.`, exitCode === null ? {} : { exitCode }, {
+                const lifetime = formatLifetime(timeoutSec ?? 0);
+                result = Results.failure("scheme:exec", "execution-timeout", 504, `Execution of '${runtime}' outlived its ${lifetime} lifetime.`, exitCode === null ? {} : { exitCode }, {
                     runtime,
-                    timeoutMinutes: (timeoutSec ?? 0) / 60,
+                    lifetime,
                     stage: "execution",
                     retryable: false,
                 });
@@ -968,7 +1013,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();
@@ -989,32 +1034,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 find(statement, ctx) {
         const core = this.coreContext(ctx);
-        return EntryFind.findWorkspaceEntries(statement, core, Exec.manifest, {});
+        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);
+            : 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);
+            : 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);
+            : EntryCrud.deleteEntry({ authority: "", pathname }, core, _a.manifest.name);
     }
 }
+_a = Exec;
+export default Exec;
 //# sourceMappingURL=Exec.js.map