@plurnk/plurnk-service 1.4.0 → 1.6.0

package/dist/schemes/Exec.js

@@ -1,9 +1,8 @@
-import { parsePath } from "@plurnk/plurnk-contracts";
+import { parsePath, TagSignal } from "@plurnk/plurnk-contracts";
 import { Policy } from "@plurnk/plurnk-execs";
 import { WebFetcher, WebMaterializationError, } from "@plurnk/plurnk-schemes-http";
 import WorkspaceSettings from "../core/workspace-settings.js";
 import EffectPolicy from "./EffectPolicy.js";
-import EntryOps from "./_entry-ops.js";
 import EntryCrud from "./_entry-crud.js";
 import Owner from "../core/Owner.js";
 import EntryFind from "./_entry-find.js";
@@ -13,7 +12,7 @@ import ExecAbort from "./exec-abort.js";
 import { entryPathnameOf, renderAddress } from "../core/plurnk-uri.js";
 import { writeFile, unlink, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { 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";
@@ -21,11 +20,13 @@ import { InvalidOperationResultError, NetworkAddress } from "@plurnk/plurnk-sche
 import DbProjectionCaps from "../core/caps/DbProjectionCaps.js";
 import WorkerControlAddress from "../core/WorkerControlAddress.js";
 import JournalTurn from "../core/JournalTurn.js";
+import LogEntryProjection from "../core/LogEntryProjection.js";
+import { setTimeout as delay } from "node:timers/promises";
 // Executors are discovered + probed at boot into ExecutorRegistry and reach
 // the scheme through ctx.executors ({§exec-registry-resolves}). Each runtime tag
 // resolves to its sibling executor; the scheme itself stays runtime-agnostic.
 // Extract the local arm of {§exec-target-routing}; non-file schemes are
-// classified separately by schemeSourceOf.
+// classified separately by resourceSourceOf.
 const localPathFromTarget = (target) => {
     if (target === null)
         return null;
@@ -39,21 +40,13 @@ const localPathFromTarget = (target) => {
 // A non-file scheme target is distinct from the local path handled above. The
 // consumer resolves its content at apply time; executors stay scheme-blind
 // ({§executor-role}).
-const schemeSourceOf = (target) => {
+const resourceSourceOf = (target) => {
     if (target === null || target.kind !== "url")
         return null;
     if (target.scheme === null || target.scheme === "file")
         return null;
     return target.raw;
 };
-// {§exec-target-routing} — effect classifies the invocation core is admitting,
-// before a scheme-backed source can be materialized. A scheme target with no
-// body becomes the command, so the executor has no target. With a body, the
-// scheme content becomes a target at run time; its authored address is the
-// stable, opaque target-present identity used only for the one effect call.
-const effectTargetOf = (authoredTarget, routedTarget, schemeSource, command) => schemeSource !== null && command.length > 0
-    ? authoredTarget?.raw ?? null
-    : routedTarget;
 // 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
@@ -96,27 +89,22 @@ export default class Exec extends CoreSchemeAdapterBase {
         writableBy: ["model", "client"],
         volatile: true,
         modelVisible: true,
-        example: "<<EXEC[sqlite]:SELECT 22.0 / 7.0:EXEC",
-        documentation: "Runs a command in a runtime — `<<EXEC[runtime](target):command:EXEC` — output streams into the worker's `<runtime>:///<loop>/<turn>/<seq>` entry on the runtime's own channels (a subprocess → stdout/stderr; a computational runtime like sqlite/jq → a JSON `results` channel). A host-effecting command proposes for review before it runs; a read-only/pure one runs ungated. Either way you never fetch the output: the engine surfaces each turn's new stream bytes to you automatically — folded while the command runs, opened when it finishes.",
+        documentation: "Runs a registered executable tool — `## EXEC0 [executor] (target) <timeout,poll>\nbody` — using the tool's table-declared target and body 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. Either way you never fetch the output: the engine surfaces each turn's new stream bytes automatically — folded while it runs, opened when it finishes.",
         flags: {
             excludedInAsk: true,
         },
     };
-    // The web-fetch the entry sink calls on content:null ({§exec-entry-sink}). Default = schemes-http's
-    // checked WebFetcher over one warm-Chromium pool shared across this handler's
-    // fallback renders; injectable so tests substitute the network.
+    // The web-fetch the entry sink calls on content:null ({§exec-entry-sink}).
+    // Default = schemes-http's checked WebFetcher; injectable for tests.
     #fetchWeb;
-    #closeWebFetcher;
     constructor(fetchWeb) {
         super();
-        const webFetcher = new WebFetcher();
         if (fetchWeb === undefined) {
+            const webFetcher = new WebFetcher();
             this.#fetchWeb = (url, opts) => webFetcher.fetch(url, opts);
-            this.#closeWebFetcher = () => webFetcher.close();
         }
         else {
             this.#fetchWeb = fetchWeb;
-            this.#closeWebFetcher = async () => { };
         }
     }
     #activeAborts = new Map();
@@ -124,11 +112,9 @@ export default class Exec extends CoreSchemeAdapterBase {
     async idle() {
         await Promise.allSettled([...this.#activeSpawns.values()]);
     }
-    // {§handler-lifecycle} — idle is the streaming drain barrier; the handler
-    // hook owns release of its separate checked-fetch browser pool.
+    // {§handler-lifecycle} — idle is the streaming drain barrier.
     async close() {
         await this.idle();
-        await this.#closeWebFetcher();
     }
     // Whether the worker has an in-flight spawn (a background exec). The daemon
     // reads this only for loop.cancel's cancelled=true/false answer — the
@@ -140,6 +126,29 @@ export default class Exec extends CoreSchemeAdapterBase {
                 return true;
         return false;
     }
+    // {§worker-optimistic-settlement} — wait on exactly the spawns initiated by
+    // this turn, ending immediately when all settle and never extending the
+    // opportunity to streams inherited from an earlier turn.
+    async settleTurnSpawns(workerId, turnId, timeoutMs, signal) {
+        signal?.throwIfAborted();
+        const pending = [...this.#activeAborts.entries()]
+            .filter(([, active]) => active.workerId === workerId && active.turnId === turnId)
+            .map(([subscriptionId]) => {
+            const spawn = this.#activeSpawns.get(subscriptionId);
+            if (spawn === undefined) {
+                throw new Error(`Active EXEC subscription ${subscriptionId} has no spawn settlement promise.`);
+            }
+            return spawn;
+        });
+        if (pending.length === 0)
+            return true;
+        if (timeoutMs === 0)
+            return false;
+        return await Promise.race([
+            Promise.allSettled(pending).then(() => true),
+            delay(timeoutMs, false, { signal, ref: false }),
+        ]);
+    }
     // {§exec-hold-until-concluded} — match active spawns against the
     // operator's runtime or runtime:effect hold selectors.
     hasActiveHoldSpawns(workerId, holdSet) {
@@ -185,51 +194,15 @@ export default class Exec extends CoreSchemeAdapterBase {
         });
     }
     // EXEC op handler — the actual model-facing entry point per plurnk.md.
-    // `<<EXEC[runtime](target):command:EXEC` →
-    //   signal=runtime, target=optional source/program/cwd, body=command.
+    // `## EXEC0 [runtime] (target)\nbody` → runtime-owned invocation buckets.
     //
-    // Proposes (status=202) with attrs={runtime, cwd, command, pathname}.
+    // 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}). The model READs that entry on a subsequent turn.
     async exec(statement, ctx) {
         const core = this.coreContext(ctx);
-        let command = statement.body ?? "";
-        // Non-file data sources resolve after acceptance. {§exec-target-routing}
-        const schemeSource = schemeSourceOf(statement.target);
-        // A local directory overrides cwd; every other local path remains the
-        // executor target. {§exec-target-routing}
-        const workspaceRow = await core.db.envelope_get_workspace.get({ id: core.workspaceId });
-        const projectRoot = workspaceRow?.project_root ?? null;
-        const localTarget = localPathFromTarget(statement.target);
-        let routedTarget = localTarget;
-        let cwd = projectRoot;
-        if (localTarget !== null) {
-            const abs = projectRoot !== null ? resolve(projectRoot, localTarget) : localTarget;
-            try {
-                if ((await stat(abs)).isDirectory()) {
-                    cwd = abs;
-                    routedTarget = null;
-                }
-            }
-            catch (cause) {
-                if (cause?.code !== "ENOENT") {
-                    console.error(`EXEC target classification failed for '${abs}':`, cause);
-                    return Results.failure("scheme:exec", "target-classification-failed", 500, `EXEC target '${localTarget}' could not be inspected: ${ErrorDetail.preview(cause)}`, {}, {
-                        target: localTarget,
-                        stage: "target-classification",
-                    });
-                }
-            }
-        }
-        // An empty body requires a file/program or scheme command source.
-        // {§exec-target-routing}
-        if (command.length === 0 && schemeSource === null && routedTarget === null) {
-            return Results.failure("scheme:exec", "command-required", 400, "EXEC requires a command body or an executable target.", {}, {
-                recovery: "Provide a command body or executable target.",
-                retryable: false,
-            });
-        }
+        const body = statement.body ?? "";
         const requested = typeof statement.signal === "string" ? statement.signal : "";
         const runtime = requested === "" ? "sh" : requested; // empty signal = default shell
         if (core.executors === undefined)
@@ -276,14 +249,76 @@ export default class Exec extends CoreSchemeAdapterBase {
                 retryable: false,
             });
         }
-        // The local (target) realization the executor receives — its data source
-        // or program. A directory routes to cwd and a scheme source is resolved
-        // only after acceptance, so either is null here.
-        const target = routedTarget;
-        // Derive one effect from the canonical logical target before any policy
-        // consumes it, then preserve that fact with the invocation (#107,
-        // {§executor-effect}). Leaves never receive authored command text.
-        const effectTarget = effectTargetOf(statement.target, target, schemeSource, command);
+        const invocation = resolved.invocation;
+        const hasBody = body.length > 0;
+        const hasTarget = statement.target !== 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.`);
+        }
+        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.`);
+        }
+        if (invocation.target?.required === true && !hasTarget) {
+            return refuse("target-required", `Executable tool '${runtime}' requires a ${invocation.target.role} target.`, `Provide the ${invocation.target.role} in (target).`);
+        }
+        if (!hasBody && !hasTarget) {
+            return refuse("input-required", `Executable tool '${runtime}' requires a body or target.`, `Provide ${invocation.target === undefined ? "a body" : "a body or target"}.`);
+        }
+        if (invocation.exclusive === true && hasBody && hasTarget) {
+            return refuse("input-conflict", `Executable tool '${runtime}' accepts its ${invocation.body.role} body and ${invocation.target?.role ?? "target"} target only as alternatives.`, "Provide either the body or target, not both.");
+        }
+        const workspaceRow = await core.db.envelope_get_workspace.get({ id: core.workspaceId });
+        const projectRoot = workspaceRow?.project_root ?? null;
+        let cwd = projectRoot;
+        let target = null;
+        let resourceSource = null;
+        const targetDecl = invocation.target;
+        if (statement.target !== null && targetDecl !== undefined) {
+            if (targetDecl.kind === "literal") {
+                target = statement.target.raw;
+            }
+            else {
+                const localTarget = localPathFromTarget(statement.target);
+                if (localTarget !== null) {
+                    target = localTarget;
+                }
+                else if (targetDecl.kind === "resource") {
+                    resourceSource = resourceSourceOf(statement.target);
+                    if (resourceSource === null) {
+                        throw new Error(`EXEC '${runtime}' resource target could not be classified`);
+                    }
+                }
+                else {
+                    return refuse("target-kind-invalid", `Executable tool '${runtime}' accepts only a local or file:// ${targetDecl.role} target.`, `Use a local or file:// ${targetDecl.role} target.`, { target: statement.target.raw, targetKind: targetDecl.kind });
+                }
+            }
+        }
+        if (target !== null && targetDecl?.directory === "cwd") {
+            const inspected = isAbsolute(target)
+                ? target
+                : projectRoot === null ? null : resolve(projectRoot, target);
+            if (inspected !== null) {
+                try {
+                    if ((await stat(inspected)).isDirectory()) {
+                        cwd = inspected;
+                        target = null;
+                    }
+                }
+                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" });
+                    }
+                }
+            }
+        }
+        if (!hasBody && target === null && resourceSource === null) {
+            return refuse("input-required", `Executable tool '${runtime}' has no executable body or realized target.`, `Provide a ${invocation.body.role} body or a non-directory target.`);
+        }
+        // One logical target derives one effect fact before policy consumes it.
+        // A non-file resource keeps its exact authored address until materialization.
+        const effectTarget = resourceSource ?? target;
         const effect = resolved.executor.effect(effectTarget);
         // cwd is the workspace project_root unless target routing selected a
         // directory override. {§exec-target-routing}, {§executor-sinks}
@@ -300,21 +335,20 @@ export default class Exec extends CoreSchemeAdapterBase {
         const turnScoped = typeof marks?.[0] === "number" && marks[0] === 0;
         const pollSec = typeof marks?.[1] === "number" && marks[1] >= 0 ? Math.floor(marks[1]) : undefined;
         const attrs = {
-            runtime, cwd, command, target, pathname: "", effect,
-            ...(schemeSource !== null ? { schemeSource } : {}),
+            runtime, cwd, body, target, pathname: "", effect,
+            ...(resourceSource !== null ? { resourceSource } : {}),
             ...(timeoutSec !== undefined ? { timeoutSec } : {}),
             ...(turnScoped ? { turnScoped: true } : {}),
             ...(pollSec !== undefined ? { pollSec } : {}),
         };
-        // Body shown to client during proposal review — `$ command` is the
-        // most-readable summary regardless of runtime.
-        const preview = runtime !== "" ? `[${runtime}] ${command}` : `$ ${command}`;
+        const previewInput = body !== "" ? body : statement.target?.raw ?? "";
+        const preview = runtime !== "" ? `[${runtime}] ${previewInput}` : `$ ${previewInput}`;
         return { status: 202, body: preview, attrs }; // host runtime proposes with 202 — {§exec-host-proposes}
     }
     async applyResolution(args, ctx) {
         const core = this.coreContext(ctx);
         const attrs = args.attrs;
-        let command = typeof attrs.command === "string" ? attrs.command : "";
+        const body = typeof attrs.body === "string" ? attrs.body : "";
         const pathname = attrs.pathname;
         const runtime = (typeof attrs.runtime === "string" && attrs.runtime !== "") ? attrs.runtime : "sh";
         const cwd = (typeof attrs.cwd === "string" && attrs.cwd.length > 0) ? attrs.cwd : null;
@@ -326,12 +360,11 @@ export default class Exec extends CoreSchemeAdapterBase {
         if (!EffectPolicy.isEffect(effect)) {
             throw new InvalidOperationResultError("The accepted EXEC proposal is missing its canonical effect fact.");
         }
-        // Resolve a scheme target after acceptance: empty body uses the content
-        // as the command; otherwise a temporary file becomes the data target.
-        // {§exec-target-routing}
+        // Every non-file resource becomes a temporary executor target after
+        // acceptance; body presence never changes the target's role.
         let tempPath = null;
-        if (attrs.schemeSource !== undefined) {
-            const sourceTarget = parsePath(attrs.schemeSource);
+        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.");
             }
@@ -340,7 +373,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 suffix: "",
                 signal: null,
                 target: sourceTarget,
-                lineMarker: null,
+                lineMarker: { marks: [1, -1] },
                 body: null,
                 position: { line: 0, column: 0 },
             }, core);
@@ -355,22 +388,12 @@ export default class Exec extends CoreSchemeAdapterBase {
                     retryable: false,
                 });
             }
-            if (command.length === 0) {
-                command = content;
-            }
-            else {
-                tempPath = join(tmpdir(), `plurnk-exec-${core.workspaceId}-${pathname.replace(/[^a-zA-Z0-9]/g, "-")}`);
-                await writeFile(tempPath, content, "utf8");
-                target = tempPath;
-            }
+            tempPath = join(tmpdir(), `plurnk-exec-${core.workspaceId}-${pathname.replace(/[^a-zA-Z0-9]/g, "-")}`);
+            await writeFile(tempPath, content, "utf8");
+            target = tempPath;
         }
-        // {§exec-target-routing} — a local file target is itself the program, so
-        // its body may be empty; no target and no command remains invalid.
-        if (command.length === 0 && target === null) {
-            if (attrs.schemeSource !== undefined) {
-                return Results.failure("scheme:exec", "source-command-empty", 422, "The EXEC source resolved to an empty command.", { outcome: "scheme_source_command_empty" }, { retryable: false });
-            }
-            throw new InvalidOperationResultError("The accepted EXEC proposal has neither a command nor a target.");
+        if (body.length === 0 && target === null) {
+            throw new InvalidOperationResultError("The accepted EXEC 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
@@ -392,7 +415,7 @@ export default class Exec extends CoreSchemeAdapterBase {
                 state: decl.defaultState ?? "active",
             };
         }
-        const seed = { channels: seedChannels, tags: [] };
+        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(pathname, seed, core, runtime, core.workerId);
@@ -407,7 +430,7 @@ export default class Exec extends CoreSchemeAdapterBase {
         }
         const subscriptionId = await ChannelWrite.openSubscription(core.db, {
             workerId: core.workerId, entryId, scheme: runtime,
-            handle: runtime !== "" ? `${runtime}: ${command}` : command,
+            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
         });
@@ -429,13 +452,13 @@ export default class Exec extends CoreSchemeAdapterBase {
             if (parent.aborted)
                 controller.abort(ExecAbort.teardownReason());
         }
-        this.#activeAborts.set(subscriptionId, { workerId: core.workerId, pathname, runtime, effect, controller, unlink });
+        this.#activeAborts.set(subscriptionId, { workerId: core.workerId, turnId: core.turnId, pathname, runtime, effect, controller, unlink });
         this.liveSubscriptions().register(subscriptionId, {
             cancel: () => controller.abort(ExecAbort.teardownReason()),
         });
         const tail = this.#runExecutor({
             executor: resolved.executor,
-            runtime, command, cwd, target, ctx: core, pathname,
+            runtime, body, cwd, target, ctx: core, pathname,
             entryId, subscriptionId, signal: controller.signal, controller, tempPath,
             timeoutSec: typeof attrs.timeoutSec === "number" ? attrs.timeoutSec : null,
         });
@@ -459,7 +482,7 @@ export default class Exec extends CoreSchemeAdapterBase {
     // notify's reported state to "closed" before the chunk event fires
     // as "active." Chain through a single promise queue to serialize.
     async #runExecutor(opts) {
-        const { executor, runtime, command, cwd, target, ctx, pathname, entryId, subscriptionId, signal, controller, timeoutSec, tempPath } = opts;
+        const { executor, runtime, body, cwd, target, ctx, pathname, entryId, subscriptionId, signal, controller, timeoutSec, tempPath } = opts;
         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
@@ -520,7 +543,12 @@ export default class Exec extends CoreSchemeAdapterBase {
                 materialized = this.#fetchWeb(fetchAddress.url, { signal });
             }
             else {
-                materialized = Promise.resolve({ body: content, mimetype: opts.mimetype });
+                materialized = Promise.resolve({
+                    url: fetchAddress?.url ?? "http://localhost",
+                    body: content,
+                    mimetype: opts.mimetype,
+                    allowTavily: false,
+                });
             }
             const op = async () => {
                 const fetched = await materialized;
@@ -538,19 +566,21 @@ export default class Exec extends CoreSchemeAdapterBase {
                 }
                 if (web === null)
                     throw new Error(`entry(): '${path.slice(0, 80)}' has no readable projection`);
-                const prior = await EntryCrud.readEntry(pathname, ctx, scheme);
-                const tags = [...new Set([...(prior.entry?.tags ?? []), ...opts.tags])];
+                if (web.body === undefined) {
+                    throw new Error(web.bodyOutcome.failure?.detail
+                        ?? `entry(): '${path.slice(0, 80)}' produced no readable body`);
+                }
+                const tags = TagSignal.applied(opts.tags.map((tag) => `+${tag}`)).add;
+                const tagSignal = tags.map((tag) => `+${tag}`);
                 // {§exec-entry-sink}/{§html-materialization} The shared
                 // materializer owns the decisive projection and its provenance.
-                const channels = {
-                    body: web.body,
-                    ...(web.html === undefined ? {} : { html: web.html }),
-                    ...(web.header === undefined ? {} : { header: { content: web.header, mimetype: "text/plain" } }),
-                };
+                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(pathname, { channels, tags }, ctx, scheme));
+                const written = Results.assert(await EntryCrud.writeEntry(pathname, { channels }, ctx, scheme));
                 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" });
@@ -570,21 +600,23 @@ export default class Exec extends CoreSchemeAdapterBase {
                     };
                 }
                 const sequence = narration.seq++;
+                const narrationAttrs = { kind: "entry_materialized" };
                 if (written.problem !== undefined) {
-                    Results.attachInstance(written, `log:///${narration.loopSeq}/${narration.turnSeq}/${sequence}/EDIT`);
+                    const coordinate = LogEntryProjection.coordinate(`${narration.loopSeq}/${narration.turnSeq}/${sequence}`, { origin: "plurnk", op: "EDIT", attrs: narrationAttrs });
+                    Results.attachInstance(written, `log:///${coordinate}`);
                 }
-                await db.engine_insert_log_entry.get({
+                const logRow = await db.engine_insert_log_entry.get({
                     worker_id: narration.workerId, loop_id: narration.loopId, turn_id: narration.turnId, sequence,
-                    // signal carries the tags — the SAME slot a model's EDIT[tags] uses, so the
+                    // signal carries additive tag terms through the same slot a model's EDIT uses, so the
                     // ambient row renders its tags natively everywhere (packet meta line, digest).
-                    origin: "plurnk", source: causalSource, op: "EDIT", suffix: "", signal: JSON.stringify(tags),
+                    origin: "plurnk", source: causalSource, model_call_id: null,
+                    op: "EDIT", suffix: "", signal: JSON.stringify(tagSignal),
                     scheme, username: null, password: null, hostname: null, port: null,
                     pathname, query: null, fragment: null, lineMarker: null,
                     tx: JSON.stringify({ op: "EDIT", body: source }), mimetype_tx: "application/json",
                     rx: JSON.stringify(written.problem === undefined
                         ? {
                             ...written,
-                            tags,
                             span: decisive.split("\n").map((l, n) => `${n + 1}:${l}`).join("\n"),
                         }
                         : written),
@@ -592,8 +624,10 @@ export default class Exec extends CoreSchemeAdapterBase {
                     status_rx: written.status, tokens: ctx.tokenize?.(decisive) ?? 0, state: "resolved", outcome: null,
                     // Durable provenance for clients/forensics. This is machine
                     // ambience, not a human/model action waterfall item.
-                    attrs: JSON.stringify({ tags, kind: "entry_materialized" }),
+                    attrs: JSON.stringify(narrationAttrs),
                 });
+                if (logRow === undefined)
+                    throw new Error("entry(): log insert returned no row");
                 if (written.problem !== undefined)
                     throw new OperationFailureError(written);
                 return renderAddress(scheme, pathname);
@@ -605,11 +639,11 @@ export default class Exec extends CoreSchemeAdapterBase {
         try {
             try {
                 const reported = await executor.run({
-                    runtime, command, cwd, target, signal,
+                    runtime, body, cwd, target, signal,
                     entry: entrySink,
                     env: ExecEnv.scoped(), // SPEC {§exec} {§exec-env-scoped} — never plurnk's own secrets
-                    write: (channel, chunk) => enqueue(() => ChannelWrite.appendToChannel(db, {
-                        entryId, channel, chunk, notify: ctx.streamEventNotify, coordinate,
+                    write: (channel, chunk, mimetype) => enqueue(() => ChannelWrite.appendToChannel(db, {
+                        entryId, channel, chunk, mimetype, notify: ctx.streamEventNotify, coordinate,
                     })),
                     setState: (channel, state) => enqueue(() => ChannelWrite.setChannelState(db, {
                         entryId, channel, state, notify: ctx.streamEventNotify, coordinate,
@@ -695,7 +729,7 @@ export default class Exec extends CoreSchemeAdapterBase {
             if (ctx.wakeWorkerNotify !== undefined) {
                 ctx.wakeWorkerNotify({
                     workspaceId: ctx.workspaceId, workerId: ctx.workerId,
-                    entryId, target: `${runtime}://${pathname}`, subscriptionId, result,
+                    entryOwnerId: ctx.workerId, entryId, target: `${runtime}://${pathname}`, subscriptionId, result,
                     scheme: runtime,
                     summary: `${runtime}://${pathname} completed (${exitLabel}); stdout=${stdoutLength} bytes, stderr=${stderrLength} bytes`,
                     ...coordinate,
@@ -704,25 +738,24 @@ export default class Exec extends CoreSchemeAdapterBase {
         }
         return result;
     }
-    async read(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, channel: null,
-            });
-        }
-        return EntryOps.readWorkspaceEntry(owner.statement, core, Exec.manifest, owner.ownerId);
+    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.")
+            : { pathname: target.pathname, ownerId };
     }
     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: [], itemsTokenTotal: 0, pathnames: [], matches: [],
+                content: null, mimetype: null, results: [], itemsTokenTotal: 0, returnedItemsTokenTotal: 0,
+                matchingPathCount: 0, matchLocationCount: 0,
             });
         }
-        return EntryFind.findWorkspaceEntries(owner.statement, core, Exec.manifest, owner.ownerId);
+        return EntryFind.findWorkspaceEntries(owner.statement, core, Exec.manifest, { ownerId: owner.ownerId });
     }
     async readEntry(pathname, ctx) {
         const core = this.coreContext(ctx);