@plurnk/plurnk-service 1.16.4 → 1.17.0

package/dist/core/Dispatcher.js

@@ -1,10 +1,11 @@
 var _a;
-import { foldAuthorityIntoPath, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
+import { PlurnkParser, TurnDisposition, parsePath } from "@plurnk/plurnk-contracts";
+import { foldAuthorityIntoPath, promptLoopPrefix, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
 import { PathSyntax } from "@plurnk/plurnk-contracts";
 import Namespace from "./namespace.js";
 import CapabilityResolver from "./CapabilityResolver.js";
+import LoopPolicyReader from "./LoopPolicyReader.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
-import LoopLifecycle from "./LoopLifecycle.js";
 import Results from "./results.js";
 import { OperationFailureError } from "./results.js";
 import EffectPolicy from "../schemes/EffectPolicy.js";
@@ -14,11 +15,15 @@ import ResourceMutations from "./ResourceMutations.js";
 import { primaryTargetOf } from "./statement-primary.js";
 import LogBody from "./LogBody.js";
 import LogVisibility from "./LogVisibility.js";
+import EntryAddressBinding from "./EntryAddressBinding.js";
 import WorkerControlHandler from "./WorkerControlHandler.js";
+import WorkerControlAddress from "./WorkerControlAddress.js";
 import KillHandler from "./KillHandler.js";
-import SendBroadcastHandler from "./SendBroadcastHandler.js";
+import TurnDispositionHandler from "./TurnDispositionHandler.js";
 import LogWriter from "./LogWriter.js";
+import LogEntryProjection from "./LogEntryProjection.js";
 import DataStatementRunner from "./DataStatementRunner.js";
+import ResourceBindings from "./ResourceBindings.js";
 // SPEC {§scheme-surface}: writer must be in target scheme's manifest.writableBy.
 // READ/FIND are not gated — they read, never mutating an entry.
 const MUTATING_OPS = new Set(["EDIT", "SEND", "COPY", "MOVE", "EXEC", "KILL", "FORK", "WORK"]);
@@ -47,17 +52,12 @@ class Dispatcher {
     // {§relation-indexed-dialects} — the engine's derivation pump, awaited by a scheme whose
     // indexed dialect met a still-deriving index.
     #settleDerivations;
-    #settleVectors;
     #streamEventNotify;
     #wakeWorkerNotify;
     #injectWorker;
     #cancelWorker;
     #cancelDescendants;
-    // {§send-premature-terminate}/SEND signal 202 with scope — the engine-owned park-deadline registry (loopId → seconds;
-    // -1 = indefinite). The dispatcher WRITES at park; the daemon's drain park-exit consumes.
-    #parkDeadlines;
     // Per-turn running-worker READ obligations. {§join-blocking-collect}
-    #joinTargets;
     #liveSubscriptions;
     #lifecycle;
     #resourceMutations;
@@ -65,10 +65,10 @@ class Dispatcher {
     #capabilities;
     #workerControl;
     #kill;
-    #sendBroadcast;
+    #disposition;
     #logWriter;
     #dataRun;
-    constructor({ db, schemes, mimetypes, weigh, notices, proposals, interactions, executors, loopSignal, settleDerivations, settleVectors, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, cancelDescendants, parkDeadlines, joinTargets, liveSubscriptions, entryAddresses }) {
+    constructor({ db, lifecycle, schemes, mimetypes, weigh, notices, proposals, interactions, executors, loopSignal, settleDerivations, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, cancelDescendants, liveSubscriptions, entryAddresses }) {
         this.#db = db;
         this.#schemes = schemes;
         this.#mimetypes = mimetypes;
@@ -79,24 +79,21 @@ class Dispatcher {
         this.#executors = executors;
         this.#loopSignal = loopSignal;
         this.#settleDerivations = settleDerivations;
-        this.#settleVectors = settleVectors;
         this.#streamEventNotify = streamEventNotify;
         this.#wakeWorkerNotify = wakeWorkerNotify;
         this.#injectWorker = injectWorker;
         this.#cancelWorker = cancelWorker;
         this.#cancelDescendants = cancelDescendants;
-        this.#parkDeadlines = parkDeadlines ?? new Map();
-        this.#joinTargets = joinTargets ?? new Set();
         this.#liveSubscriptions = liveSubscriptions;
         this.#entryAddresses = entryAddresses;
         this.#capabilities = new CapabilityResolver(db, schemes, executors);
-        this.#lifecycle = new LoopLifecycle(db);
+        this.#lifecycle = lifecycle;
         this.#resourceMutations = new ResourceMutations({
             schemes,
             liveSubscriptions,
             run: (schemeName, statement, ctx) => this.#dataRun.run(schemeName, statement, ctx),
-            checkWritable: (statement, origin, workerId) => this.#checkWritable(statement, origin, workerId),
-            checkCapabilities: (statement, workspaceId, loopId, workerId) => this.#checkCapabilities(statement, workspaceId, loopId, workerId),
+            checkWritable: (statement, origin, workspaceId) => this.#checkWritable(statement, origin, workspaceId),
+            checkCapabilities: (statement, ctx) => this.#checkCapabilities(statement, ctx),
             editTargetIdentity: (statement, workspaceId, workerId) => this.#editTargetIdentity(statement, workspaceId, workerId),
             canonicalFilePath: (pathname, workspaceId) => this.#canonicalFilePath(pathname, workspaceId),
             prepareDataRepresentation: (args) => this.#prepareDataRepresentation({
@@ -109,11 +106,11 @@ class Dispatcher {
             deleteChannel: (scheme, address, channel, ctx) => this.#deleteChannel(scheme, address, channel, ctx),
             applyProposal: (statement, result, resolution, ids) => this.#proposals.workerApply(statement, result, resolution, ids),
         });
-        this.#workerControl = new WorkerControlHandler({ db: this.#db, schemes: this.#schemes, failure: _a.#failure });
+        this.#workerControl = new WorkerControlHandler({ db: this.#db, failure: _a.#failure });
         this.#kill = new KillHandler({ db: this.#db, schemes: this.#schemes, liveSubscriptions: this.#liveSubscriptions, cancelWorker: this.#cancelWorker, resolveDataEntryAddress: this.#resolveDataEntryAddress.bind(this), boundEntryContext: this.#boundEntryContext.bind(this), handlerContext: this.#handlerContext.bind(this), deleteEntry: this.#deleteEntry.bind(this), failure: _a.#failure });
-        this.#sendBroadcast = new SendBroadcastHandler({ db: this.#db, cancelDescendants: this.#cancelDescendants, parkDeadlines: this.#parkDeadlines, joinTargets: this.#joinTargets, lifecycle: this.#lifecycle, nextPacketBoundaries: this.#nextPacketBoundaries.bind(this), unobservedFailureCount: this.#unobservedFailureCount.bind(this), pendingSet: this.#pendingSet.bind(this), hasLiveWork: this.hasLiveWork.bind(this), failure: _a.#failure, statusResult: _a.#statusResult, unobservedFailures: _a.#unobservedFailures });
+        this.#disposition = new TurnDispositionHandler({ db: this.#db, cancelDescendants: this.#cancelDescendants, lifecycle: this.#lifecycle, nextPacketBoundaries: this.#nextPacketBoundaries.bind(this), unobservedFailureCount: this.#unobservedFailureCount.bind(this), pendingSet: this.#pendingSet.bind(this), hasLiveWork: this.hasLiveWork.bind(this), failure: _a.#failure, statusResult: _a.#statusResult, unobservedFailures: _a.#unobservedFailures });
         this.#logWriter = new LogWriter({ db: this.#db, weighContent: this.#weighContent, extractTarget: this.#extractTarget.bind(this), canonColumns: this.#canonColumns.bind(this), signalToJson: this.#signalToJson.bind(this), isProposal: _a.#isProposal });
-        this.#dataRun = new DataStatementRunner({ schemes: this.#schemes, liveSubscriptions: this.#liveSubscriptions, resolveDataEntryAddress: this.#resolveDataEntryAddress.bind(this), fixedEntryOwnerId: this.#fixedEntryOwnerId.bind(this), prepareDataRepresentation: this.#prepareDataRepresentation.bind(this), failure: _a.#failure });
+        this.#dataRun = new DataStatementRunner({ schemes: this.#schemes, liveSubscriptions: this.#liveSubscriptions, resolveDataEntryAddress: this.#resolveDataEntryAddress.bind(this), prepareDataRepresentation: this.#prepareDataRepresentation.bind(this), failure: _a.#failure });
     }
     // workspace → project_root, memoized: {§fs-namespace} fixes the root immutably at
     // workspace creation, so a process-lifetime cache can never go stale.
@@ -121,36 +118,31 @@ class Dispatcher {
     evictWorkspaceCache(workspaceId) {
         this.#rootCache.delete(workspaceId);
     }
-    async #fixedEntryOwnerId(manifest, ctx) {
-        return this.#entryAddresses.fixedOwnerId(manifest, ctx);
-    }
     async #handlerContext(scheme, ctx, authority = "") {
-        const manifest = this.#schemes.manifestFor(scheme, ctx.functionalityWorkerId);
+        const manifest = this.#schemes.manifestFor(scheme, ctx.workspaceId);
         return manifest === undefined
             ? null
             : new SchemeCtxImpl(ctx, scheme, manifest, this.#liveSubscriptions, {
                 authority,
-                ownerId: await this.#fixedEntryOwnerId(manifest, ctx),
             });
     }
     #boundEntryContext(routedScheme, address, ctx) {
-        const manifest = this.#schemes.manifestFor(routedScheme, ctx.functionalityWorkerId);
+        const manifest = this.#schemes.manifestFor(routedScheme, ctx.workspaceId);
         return manifest?.category === "data"
             ? new SchemeCtxImpl(ctx, address.scheme, manifest, this.#liveSubscriptions, {
                 authority: address.authority,
-                ownerId: address.ownerId,
             })
             : null;
     }
-    #coreCrud(scheme, workerId) {
-        const handler = this.#schemes.get(scheme, workerId);
+    #coreCrud(scheme, workspaceId) {
+        const handler = this.#schemes.get(scheme, workspaceId);
         return handler instanceof CoreSchemeAdapterBase
             ? handler
             : undefined;
     }
     async #readEntry(scheme, address, ctx) {
         const { pathname } = address;
-        const handler = this.#coreCrud(scheme, ctx.functionalityWorkerId);
+        const handler = this.#coreCrud(scheme, ctx.workspaceId);
         const handlerCtx = this.#boundEntryContext(scheme, address, ctx);
         if (typeof handler?.readEntry === "function" && handlerCtx !== null) {
             return Results.assert(await handler.readEntry(pathname, handlerCtx));
@@ -180,7 +172,7 @@ class Dispatcher {
     }
     async #writeEntry(scheme, address, entry, ctx) {
         const { pathname } = address;
-        const handler = this.#coreCrud(scheme, ctx.functionalityWorkerId);
+        const handler = this.#coreCrud(scheme, ctx.workspaceId);
         const handlerCtx = this.#boundEntryContext(scheme, address, ctx);
         if (typeof handler?.writeEntry === "function" && handlerCtx !== null) {
             return Results.assert(await handler.writeEntry(pathname, entry, handlerCtx));
@@ -198,7 +190,7 @@ class Dispatcher {
     }
     async #deleteEntry(scheme, address, ctx) {
         const { pathname } = address;
-        const handler = this.#coreCrud(scheme, ctx.functionalityWorkerId);
+        const handler = this.#coreCrud(scheme, ctx.workspaceId);
         const handlerCtx = this.#boundEntryContext(scheme, address, ctx);
         if (typeof handler?.deleteEntry === "function" && handlerCtx !== null) {
             return Results.assert(await handler.deleteEntry(pathname, handlerCtx));
@@ -216,7 +208,7 @@ class Dispatcher {
     }
     async #deleteChannel(scheme, address, channel, ctx) {
         const { pathname } = address;
-        const handler = this.#coreCrud(scheme, ctx.functionalityWorkerId);
+        const handler = this.#coreCrud(scheme, ctx.workspaceId);
         const handlerCtx = this.#boundEntryContext(scheme, address, ctx);
         if (typeof handler?.deleteChannel === "function" && handlerCtx !== null) {
             return Results.assert(await handler.deleteChannel(pathname, channel, handlerCtx));
@@ -254,31 +246,23 @@ class Dispatcher {
     async #canonicalFilePath(pathname, workspaceId) {
         return Namespace.canonicalizeSpelling(pathname, await this.#workspaceRoot(workspaceId));
     }
-    async #editTargetIdentity(statement, workspaceId, workerId) {
-        const target = this.#extractTarget(statement.target, workerId);
+    async #editTargetIdentity(statement, workspaceId, _workerId) {
+        const target = this.#extractTarget(statement.target, workspaceId);
         await this.#canonColumns(target, workspaceId);
-        return {
-            key: JSON.stringify([
-                schemeNameOf(statement.target),
-                target.scheme,
-                target.hostname,
-                target.pathname,
-                target.fragment,
-            ]),
-            identity: renderTarget(target),
-        };
+        return renderTarget(target);
     }
     // {§kill-scope-entry} — a scoped KILL on an entry-bearing scheme is one EDIT with an empty
     // body over the same marker: prepared, gated, and merged as an EDIT while its log row
     // records the model's KILL. Schemes that implement kill() (streams) take the scope themselves;
     // the log's scoped KILL is curation.
     #scopedEntryEdits = new WeakMap();
-    #scopedEntryEdit(statement, functionalityWorkerId) {
+    #scopedEntryEdit(statement, workspaceId) {
         if (statement.op === "EDIT")
             return statement;
-        // A body pattern is a log selector; a scoped KILL carrying one is not an EDIT — the KILL
-        // handler refuses it ({§kill-scope-entry}).
-        if (statement.op !== "KILL" || statement.lineMarker === null || statement.body !== null)
+        // {§kill-scope-entry} a scoped KILL of an entry empties the span; {§kill-pattern} a KILL with
+        // a matcher removes every whole line the pattern selects, inside its scope when one is given.
+        // Both are emptying EDITs; the log and every scheme with its own kill() keep their own path.
+        if (statement.op !== "KILL" || (statement.lineMarker === null && statement.matcher === null))
             return null;
         const cached = this.#scopedEntryEdits.get(statement);
         if (cached !== undefined)
@@ -286,33 +270,29 @@ class Dispatcher {
         const schemeName = schemeNameOf(statement.target);
         if (schemeName === null || schemeName === "log")
             return null;
-        const handler = this.#schemes.get(schemeName, functionalityWorkerId);
+        const handler = this.#schemes.get(schemeName, workspaceId);
         if (handler === undefined || typeof handler.kill === "function")
             return null;
         const edit = {
             op: "EDIT",
-            delimiter: statement.delimiter,
-            annotation: statement.annotation,
+            aside: statement.aside,
             metadata: statement.metadata,
             target: statement.target,
             lineMarker: statement.lineMarker,
+            matcher: statement.matcher,
             body: "",
             position: statement.position,
         };
         this.#scopedEntryEdits.set(statement, edit);
+        if (statement.matcher !== null)
+            this.#resourceMutations.markLineDeletion(edit);
         return edit;
     }
-    async prepareEditBatches(statements, context) {
-        const { workspaceId, workerId, functionalityWorkerId, loopId, turnId, origin } = context;
-        const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, functionalityWorkerId, loopId, turnId, origin });
-        const edits = statements.flatMap((statement) => {
-            const edit = this.#scopedEntryEdit(statement, schemeCtx.functionalityWorkerId);
-            return edit === null ? [] : [edit];
-        });
-        await this.#resourceMutations.prepareEditBatches(edits, context, schemeCtx);
-    }
     async dispatch(context) {
-        let result = await this.#dispatchOne(context);
+        if (context.statement.op === "READ" && _a.#globTarget(context.statement.target)) {
+            return this.#fanOutRead(context, context.statement);
+        }
+        let result = await ResourceBindings.using(this.#schemes, this.#buildSchemeCtx(context), (ctx) => this.#dispatchOne(context, ctx));
         const edit = context.statement.op === "EDIT" ? context.statement : this.#scopedEntryEdits.get(context.statement);
         if (edit !== undefined) {
             // {§edit-batch-merges} — a proposal's apply result replaces the projected one; the
@@ -322,15 +302,65 @@ class Dispatcher {
         }
         return result;
     }
-    async #dispatchOne(context) {
+    static #globTarget(target) {
+        return target !== null && PathSyntax.hasGlob(target.kind === "url" ? target.pathname : target.raw);
+    }
+    // {§read-fan-out} — a READ over a glob reads every matching path: the paths come from the
+    // ordinary FIND over the same target (unlogged; a matcher FIND when there is one, the catalog
+    // otherwise; its resource page bounds the fan-out), and each is read as an ordinary exact READ
+    // with the authored scope and matcher and its own receipt row, so every rendered line keeps its
+    // path, ordinal and anchor. No path: one 204 receipt on the authored glob. A resource dialect
+    // (`~`, `&`) selects resources, not lines, so that READ is the FIND survey.
+    async #fanOutRead(context, statement) {
+        const survey = {
+            op: "FIND", aside: statement.aside, target: statement.target, metadata: statement.metadata,
+            matcher: statement.matcher, lineMarker: null, body: null, position: statement.position,
+        };
+        if (statement.matcher?.dialect === "fts" || statement.matcher?.dialect === "graph") {
+            return this.dispatch({ ...context, statement: survey });
+        }
+        const found = await ResourceBindings.using(this.#schemes, this.#buildSchemeCtx(context), (ctx) => this.#dataRun.run(schemeNameOf(statement.target), survey, ctx));
+        const paths = found.status < 300
+            ? (found.results ?? []).flatMap((item) => Array.isArray(item) && !("items" in item[0]) ? [item[0].path] : [])
+            : [];
+        if (paths.length === 0) {
+            const result = found.status >= 400 ? found : Results.assert(statement.matcher === null
+                ? { status: 204, detail: `No path matched ${statement.target.raw}.` }
+                : { status: 204, matched: 0, matcher: statement.matcher.raw, detail: `No line under ${statement.target.raw} matched the pattern.` });
+            const logEntryId = await this.#logWriter.writeLog({
+                statement, result, workspaceId: context.workspaceId, workerId: context.workerId, loopId: context.loopId,
+                turnId: context.turnId, sequence: context.sequence, origin: context.origin, curationPlan: null, modelCallId: null,
+            });
+            context.onDispatch?.(logEntryId);
+            return result;
+        }
+        const results = [];
+        for (const [index, path] of paths.entries()) {
+            const target = parsePath(path);
+            if (target === null)
+                throw new InvalidOperationResultError(`FIND named an unparseable path: ${path}`);
+            results.push(await this.dispatch({ ...context, statement: { ...statement, target }, sequence: context.sequence + index }));
+        }
+        const matchingPathCount = typeof found.matchingPathCount === "number" ? found.matchingPathCount : paths.length;
+        if (matchingPathCount > paths.length) {
+            this.#notices.push(context.workspaceId, context.workerId, context.loopId, {
+                source: "engine:dispatcher",
+                kind: "read_fanout_bounded",
+                level: "warn",
+                message: `READ ${statement.target.raw} matched ${matchingPathCount} paths; the first ${paths.length} were read. Narrow the glob, or FIND first.`,
+            });
+        }
+        return Results.assert({ ...(results.find(({ status }) => status >= 400) ?? results[results.length - 1]), rowsWritten: results.length });
+    }
+    async #dispatchOne(context, schemeCtx) {
         const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, onSettled, } = context;
-        const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, functionalityWorkerId: context.functionalityWorkerId, loopId, turnId, origin });
-        const { functionalityWorkerId } = schemeCtx;
         let result;
         let curationPlan = null;
-        let denial = this.#checkWritable(statement, origin, functionalityWorkerId);
-        if (denial === null)
-            denial = await this.#checkCapabilities(statement, workspaceId, loopId, functionalityWorkerId);
+        // {§send-prompt-acceptance} — a model SEND addressed to one of this loop's own prompts
+        // means what an untargeted SEND means; the address the packet showed it is accepted.
+        const ownPrompt = statement.op === "SEND" && origin === "model" && await this.#isOwnPromptAddress(statement.target, workerId, loopId);
+        const denial = ownPrompt ? null : (this.#checkWritable(statement, origin, workspaceId)
+            ?? await this.#checkCapabilities(statement, schemeCtx));
         if (denial !== null) {
             result = denial;
         }
@@ -342,16 +372,20 @@ class Dispatcher {
             // those are system failures.
             try {
                 if (statement.op === "EDIT") {
-                    result = await this.#resourceMutations.preparedEditResult(statement);
+                    result = await this.#resourceMutations.edit(statement, schemeCtx, context.editSequence);
+                }
+                else if (statement.op === "SEND" && (statement.target === null || ownPrompt)) {
+                    result = await this.#respond(statement, schemeCtx, origin, workerId, loopId);
                 }
-                else if (statement.op === "SEND" && statement.target === null) {
-                    result = await this.#sendBroadcast.handleSendBroadcast(statement, {
+                else if (TurnDisposition.is(statement)) {
+                    result = await this.#disposition.handle(statement, {
                         workspaceId,
                         workerId,
                         loopId,
                         turnId,
                         sequence,
                         origin,
+                        allowUnobservedRetrievalCompletion: context.allowUnobservedRetrievalCompletion,
                     });
                 }
                 else if (statement.op === "KILL" && schemeNameOf(statement.target) === "log") {
@@ -360,7 +394,9 @@ class Dispatcher {
                     curationPlan = curation.plan;
                 }
                 else if (statement.op === "FORK" || statement.op === "WORK") {
-                    result = await this.#workerControl.handleWorkerControl(statement, schemeCtx);
+                    // {§worker-spawn-prompt-resource} — a non-address path is the child's prompt resource.
+                    const seeded = await this.#seedSpawnPrompt(statement, schemeCtx);
+                    result = "result" in seeded ? seeded.result : await this.#workerControl.handleWorkerControl(seeded.statement, schemeCtx);
                 }
                 else if (statement.op === "COPY") {
                     result = await this.#resourceMutations.handleCopy(statement, schemeCtx);
@@ -368,15 +404,12 @@ class Dispatcher {
                 else if (statement.op === "MOVE") {
                     result = await this.#resourceMutations.handleMove(statement, schemeCtx);
                 }
-                else if (statement.op === "KILL" && this.#scopedEntryEdits.has(statement)) {
-                    result = await this.#resourceMutations.preparedEditResult(this.#scopedEntryEdits.get(statement));
+                else if (statement.op === "KILL" && this.#scopedEntryEdit(statement, workspaceId) !== null) {
+                    result = await this.#resourceMutations.edit(this.#scopedEntryEdits.get(statement), schemeCtx, context.editSequence);
                 }
                 else if (statement.op === "KILL") {
                     result = await this.#kill.handleKill(statement, schemeCtx);
                 }
-                else if (statement.op === "PLAN") {
-                    result = this.#handlePlan(statement);
-                }
                 else if (statement.op === "EXEC") {
                     // EXEC routes unconditionally to its operation owner after
                     // the shared capability resolver admits its runtime/tool.
@@ -395,7 +428,7 @@ class Dispatcher {
                 else {
                     const scheme = schemeNameOf(primaryTargetOf(statement));
                     console.error(`Scheme '${scheme ?? "unknown"}' ${statement.op} threw outside its operation result contract:`, err);
-                    result = _a.#failure("scheme-handler-threw", 500, `The '${scheme ?? "unknown"}' scheme did not produce a ${statement.op} result.`, {}, {
+                    result = _a.#failure("scheme-handler-threw", 500, `The '${scheme ?? "unknown"}' scheme did not produce a result for ${statement.op}.`, {}, {
                         stage: "scheme-dispatch",
                         scheme,
                         operation: statement.op,
@@ -407,12 +440,9 @@ class Dispatcher {
         // successful receipts while the exact state effects remain durable.
         // A running-worker READ arms this turn's blocking collect.
         // {§join-blocking-collect}
-        if (typeof result.awaitWorker === "string")
-            this.#joinTargets.add(loopId);
         const logEntryId = await this.#logWriter.writeLog({
             statement,
             result,
-            functionalityWorkerId,
             workspaceId,
             workerId,
             loopId,
@@ -424,8 +454,8 @@ class Dispatcher {
         });
         onDispatch?.(logEntryId);
         // Proposal lifecycle (SPEC.md {§engine-rails} + {§methods-proposal-resolve}; {§proposal-202-pauses}). When a
-        // side-effecting op returns status 202 (a broadcast SEND signal 202 park is model
-        // speech, not a proposal — #isProposal), the entry is written
+        // side-effecting op returns status 202 (a waiting TASK parks rather
+        // than proposing — #isProposal), the entry is written
         // state='proposed'; dispatch then PAUSES on a per-entry waiter until
         // resolution arrives via Engine.resolveProposal (from a client-interface resume,
         // core-owned disposition, or timeout). The post-resolution status replaces 202 in the
@@ -436,20 +466,21 @@ class Dispatcher {
             // that exact fact here; no human gate or loop/proposal notification.
             const effect = result.attrs?.effect;
             let autoAccept = false;
-            if (statement.op === "EXEC") {
+            if (statement.op === "EXEC" || (statement.op === "SEND"
+                && this.#schemes.isRuntimeScheme(schemeNameOf(statement.target) ?? "", workspaceId))) {
                 if (!EffectPolicy.isEffect(effect)) {
-                    throw new InvalidOperationResultError("EXEC proposal omitted its canonical effect fact.");
+                    throw new InvalidOperationResultError("Execution proposal omitted its canonical effect fact.");
                 }
                 autoAccept = EffectPolicy.decide(effect) === "auto";
             }
             if (autoAccept) {
-                const initialSettlement = await this.#proposals.workerApply(statement, result, { decision: "accept" }, { workspaceId, workerId, functionalityWorkerId, loopId, turnId });
+                const initialSettlement = await this.#proposals.workerApply(statement, result, { decision: "accept" }, { workspaceId, workerId, loopId, turnId });
                 const effective = await this.#resourceMutations.settleProposal({
                     statement,
                     result,
                     settlement: initialSettlement,
                     ctx: schemeCtx,
-                    ids: { workspaceId, workerId, functionalityWorkerId, loopId, turnId },
+                    ids: { workspaceId, workerId, loopId, turnId },
                 });
                 const post = await this.#proposals.applyResolution(logEntryId, effective);
                 await onSettled?.(logEntryId);
@@ -481,13 +512,13 @@ class Dispatcher {
             // file, spawns the process, etc.). Its operation result is
             // preserved: an apply failure keeps its original status and
             // Problem Details instead of masquerading as a client rejection.
-            const initialSettlement = await this.#proposals.workerApply(statement, result, resolution, { workspaceId, workerId, functionalityWorkerId, loopId, turnId });
+            const initialSettlement = await this.#proposals.workerApply(statement, result, resolution, { workspaceId, workerId, loopId, turnId });
             const effective = await this.#resourceMutations.settleProposal({
                 statement,
                 result,
                 settlement: initialSettlement,
                 ctx: schemeCtx,
-                ids: { workspaceId, workerId, functionalityWorkerId, loopId, turnId },
+                ids: { workspaceId, workerId, loopId, turnId },
             });
             const post = await this.#proposals.applyResolution(logEntryId, effective);
             await onSettled?.(logEntryId);
@@ -506,14 +537,21 @@ class Dispatcher {
         if (statement.op !== "READ")
             throw new Error(`look resolves READ only; got ${statement.op}`);
         // turnId is a write-time FK only — a look writes no row, so 0 (no turn) is inert.
-        const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, functionalityWorkerId: context.functionalityWorkerId, loopId, turnId: 0, origin });
-        const denial = await this.#checkCapabilities(statement, schemeCtx.workspaceId, loopId, schemeCtx.functionalityWorkerId);
-        if (denial !== null)
-            return denial;
-        return this.#dataRun.run(schemeNameOf(statement.target), statement, schemeCtx);
+        const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId, turnId: 0, origin });
+        return ResourceBindings.using(this.#schemes, schemeCtx, async (ctx) => {
+            try {
+                const denial = await this.#checkCapabilities(statement, ctx);
+                return denial ?? await this.#dataRun.run(schemeNameOf(statement.target), statement, ctx);
+            }
+            catch (error) {
+                if (error instanceof OperationFailureError)
+                    return error.result;
+                throw error;
+            }
+        });
     }
-    capabilityProjection(workspaceId, workerId) {
-        return this.#capabilities.projection(workspaceId, workerId);
+    capabilityProjection(workspaceId) {
+        return this.#capabilities.projection(workspaceId);
     }
     // Resolve the client selector through the owning scheme before persistence
     // is consulted. Public schemes choose a semantic owner; core-owned authority
@@ -523,7 +561,6 @@ class Dispatcher {
         const coreCtx = this.#buildSchemeCtx({
             workspaceId,
             workerId,
-            functionalityWorkerId: context.functionalityWorkerId,
             loopId: 0,
             turnId: 0,
             origin: "client",
@@ -539,7 +576,6 @@ class Dispatcher {
         if (rendered === null)
             throw new TypeError("Resolved entry target did not render.");
         return {
-            ownerId: resolved.address.ownerId,
             scheme: resolved.address.scheme,
             authority: resolved.address.authority,
             pathname: resolved.address.pathname,
@@ -550,23 +586,32 @@ class Dispatcher {
         const routedScheme = schemeNameOf(target);
         if (routedScheme === null)
             return null;
-        const handler = this.#schemes.get(routedScheme, ctx.functionalityWorkerId);
-        const manifest = this.#schemes.manifestFor(routedScheme, ctx.functionalityWorkerId);
-        if (handler === undefined || manifest?.category !== "data")
-            return null;
-        return this.#resolveDataEntryAddress({ target, routedScheme, handler, manifest, ctx });
+        return ResourceBindings.using(this.#schemes, ctx, async (boundCtx) => {
+            try {
+                const binding = await ResourceBindings.resolve(target, boundCtx);
+                if (binding?.manifest.category !== "data")
+                    return null;
+                return this.#resolveDataEntryAddress({ target, routedScheme,
+                    handler: binding.handler, manifest: binding.manifest, ctx: boundCtx });
+            }
+            catch (error) {
+                if (error instanceof OperationFailureError)
+                    return { address: null, result: error.result };
+                throw error;
+            }
+        });
     }
-    async #resolveDataEntryAddress({ target, routedScheme, handler, manifest, ctx, }) {
+    async #resolveDataEntryAddress({ target, routedScheme, handler, manifest, ctx, access = "read", }) {
         if (manifest.category !== "data") {
             throw new TypeError(`Scheme '${routedScheme}' is not entry-bearing.`);
         }
-        return this.#entryAddresses.resolve({ target, routedScheme, handler, manifest, ctx });
+        return this.#entryAddresses.resolve({ target, routedScheme, handler, manifest, ctx, access });
     }
     async #prepareDataRepresentation({ target, metadata, routedScheme, handler, manifest, ctx, publishedChannel, resolved: priorResolution, }) {
         if (metadata !== null && manifest.metadataModifier !== true) {
             return {
                 address: null,
-                result: _a.#failure("scheme-metadata-unsupported", 400, `Scheme '${routedScheme}' does not accept the {metadata} modifier.`, {}, { scheme: routedScheme, retryable: false }),
+                result: _a.#failure("scheme-metadata-unsupported", 400, `Scheme '${routedScheme}' does not accept the [metadata] modifier.`, {}, { scheme: routedScheme, retryable: false }),
             };
         }
         const resolved = priorResolution ?? await this.#resolveDataEntryAddress({
@@ -587,7 +632,6 @@ class Dispatcher {
             : target;
         const preparationCtx = new SchemeCtxImpl(ctx, target.kind === "url" ? target.scheme : routedScheme, manifest, this.#liveSubscriptions, {
             authority: address.authority,
-            ownerId: address.ownerId,
             publishedChannel,
         });
         const prepared = Results.assertRepresentationPreparation(await handler.prepareRepresentation({
@@ -604,16 +648,37 @@ class Dispatcher {
     // An accepted EXEC reads a non-file source through the same registered
     // handler and addressed context as an authored READ. {§exec-target-routing}
     async readExecSource(statement, ctx) {
+        return ResourceBindings.using(this.#schemes, ctx, (boundCtx) => this.#readExecSource(statement, boundCtx));
+    }
+    async #readExecSource(statement, ctx) {
         const schemeName = schemeNameOf(statement.target);
-        const manifest = schemeName === null ? undefined : this.#schemes.manifestFor(schemeName, ctx.functionalityWorkerId);
+        const binding = await ResourceBindings.resolve(statement.target, ctx);
+        const manifest = binding?.manifest;
         if (manifest !== undefined && manifest.category !== "data") {
-            return _a.#failure("exec-source-not-data", 501, `Scheme '${schemeName}' is not a data source for EXEC.`, {}, {
-                scheme: schemeName,
-                category: manifest.category,
-                retryable: false,
-            });
+            return { nativePath: null, result: _a.#failure("exec-source-not-data", 501, `Scheme '${schemeName}' is not a data source for EXEC.`, {}, {
+                    scheme: schemeName,
+                    category: manifest.category,
+                    retryable: false,
+                }) };
         }
-        return Results.assertReadResult(await this.#dataRun.run(schemeName, statement, ctx));
+        const result = Results.assertReadResult(await this.#dataRun.run(schemeName, statement, ctx));
+        const target = statement.target;
+        const handler = binding?.handler;
+        const selectedChannel = target?.fragment ?? null;
+        if (result.status !== 200 || target === null || handler === undefined || manifest?.category !== "data"
+            || (selectedChannel !== null && selectedChannel !== manifest.defaultChannel)) {
+            return { result, nativePath: null };
+        }
+        const resolved = await this.#resolveDataEntryAddress({ target, routedScheme: schemeName, handler, manifest, ctx });
+        if (resolved.result !== null)
+            return { result: resolved.result, nativePath: null };
+        const source = resolved.address === null ? undefined : handler.byteSource?.(resolved.address, EntryAddressBinding.addressContext(ctx));
+        if (source?.nativePath === undefined)
+            return { result, nativePath: null };
+        const nativePath = await source.nativePath();
+        if (nativePath === null)
+            return { nativePath: null, result: _a.#failure("entry-not-found", 404, "The EXEC source file no longer exists.", {}, { target: target.raw }) };
+        return { result, nativePath };
     }
     // The one place per-dispatch coordinates are built; a caller that carries no
     // explicit Functionality coordinate acts in its own Worker's
@@ -621,10 +686,9 @@ class Dispatcher {
     // PlurnkSchemeContext and never re-derive.
     #buildSchemeCtx(ids) {
         const { workspaceId, workerId, loopId, turnId, origin } = ids;
-        const functionalityWorkerId = ids.functionalityWorkerId ?? workerId;
         const context = {
             db: this.#db,
-            workspaceId, workerId, functionalityWorkerId, loopId, turnId,
+            workspaceId, workerId, loopId, turnId,
             writer: origin,
             signal: this.#loopSignal(loopId),
             streamEventNotify: this.#streamEventNotify,
@@ -634,11 +698,10 @@ class Dispatcher {
             weigh: this.#weighContent,
             // {§exec-stream} — a runtime scheme's default channel is its own (stdout), never the
             // catalog fallback `body`; resolved through the same registry the writable gate reads.
-            defaultChannelFor: (scheme) => this.#schemes.defaultChannelFor(scheme, functionalityWorkerId),
+            defaultChannelFor: (scheme) => this.#schemes.defaultChannelFor(scheme, context.workspaceId),
             settleDerivations: () => this.#settleDerivations(context),
-            settleVectors: (hashes) => this.#settleVectors(context, hashes),
             pushNotice: (notice) => this.#notices.push(workspaceId, workerId, loopId, notice),
-            requestInteraction: (request) => this.#interactions.request(request, { workspaceId, workerId, loopId, turnId }, this.#loopSignal(loopId)),
+            requestInteraction: (request, signal = this.#loopSignal(loopId)) => this.#interactions.request(request, { workspaceId, workerId, loopId, turnId }, signal),
             executors: this.#executors(),
         };
         return context;
@@ -649,40 +712,38 @@ class Dispatcher {
     // - SEND broadcast (path=null) has no target scheme; not gated.
     // - COPY: dst scheme writableBy applies.
     // - MOVE: both src (delete) and dst (write) schemes' writableBy apply.
-    #checkWritable(statement, origin, functionalityWorkerId) {
-        const workerId = functionalityWorkerId;
+    #checkWritable(statement, origin, workspaceId) {
         if (!MUTATING_OPS.has(statement.op))
             return null;
-        if (statement.op === "SEND" && statement.target === null)
+        if (TurnDisposition.is(statement) || statement.op === "SEND" && statement.target === null)
             return null;
         // EXEC's operation authority always belongs to the exec scheme;
         // runtime-specific resource authority is gated separately below.
         if (statement.op === "EXEC") {
-            return this.#denyIfDisallowed("exec", origin, workerId);
+            return this.#denyIfDisallowed("exec", origin, workspaceId);
         }
-        // {§stream-control} — a KILL of a runtime stream terminates the caller's own process; it
-        // writes nothing into that read-only output scheme (writableBy plugin), so the writer rule
-        // does not speak. Exec.kill scopes the stream to the caller ({§stream-owner-scoped}).
-        if (statement.op === "KILL") {
+        // {§stream-control}, {§exec-input}: process control is not a write to
+        // stored output. The workspace execution binding owns KILL and SEND.
+        if (statement.op === "KILL" || statement.op === "SEND") {
             const target = schemeNameOf(statement.target);
-            if (target !== null && this.#schemes.isRuntimeScheme(target, workerId))
+            if (target !== null && this.#schemes.isRuntimeScheme(target, workspaceId))
                 return null;
         }
         // Worker control (FORK/WORK → worker://<name>, spawn or fork) is gated by worker://'s writableBy — its
         // body is a seed prompt, not a dst path, so the entry-COPY dst-parse below doesn't apply.
         // {§machine-processes}
         if (this.#isWorkerControl(statement))
-            return this.#denyIfDisallowed("worker", origin, workerId);
+            return this.#denyIfDisallowed("worker", origin, workspaceId);
         if (statement.op === "COPY" || statement.op === "MOVE") {
             const dst = statement.destination.target;
             const dstScheme = schemeNameOf(dst);
-            const dstDenial = this.#denyIfDisallowed(dstScheme, origin, workerId);
+            const dstDenial = this.#denyIfDisallowed(dstScheme, origin, workspaceId);
             if (dstDenial !== null)
                 return dstDenial;
             if (statement.op === "MOVE") {
                 const srcScheme = schemeNameOf(statement.source.target);
                 if (srcScheme !== dstScheme) {
-                    const srcDenial = this.#denyIfDisallowed(srcScheme, origin, workerId);
+                    const srcDenial = this.#denyIfDisallowed(srcScheme, origin, workspaceId);
                     if (srcDenial !== null)
                         return srcDenial;
                 }
@@ -690,7 +751,7 @@ class Dispatcher {
             return null;
         }
         const target = schemeNameOf(statement.target);
-        const denial = this.#denyIfDisallowed(target, origin, workerId);
+        const denial = this.#denyIfDisallowed(target, origin, workspaceId);
         // {§send-target-recipient} — SEND addresses recipients, not otherwise
         // read-only resources. State that boundary without guessing whether the
         // model intended a reply, deletion, or directed message.
@@ -704,13 +765,13 @@ class Dispatcher {
         }
         return denial;
     }
-    #denyIfDisallowed(schemeName, origin, workerId) {
+    #denyIfDisallowed(schemeName, origin, workspaceId) {
         if (schemeName === null)
             return null;
-        const handler = this.#schemes.get(schemeName, workerId);
+        const handler = this.#schemes.get(schemeName, workspaceId);
         if (handler === undefined)
             return null;
-        const manifest = this.#schemes.manifestFor(schemeName, workerId);
+        const manifest = this.#schemes.manifestFor(schemeName, workspaceId);
         if (manifest === undefined)
             throw new Error(`registered scheme '${schemeName}' has no manifest`);
         if (manifest.writableBy.includes(origin))
@@ -725,8 +786,9 @@ class Dispatcher {
     // {§capability-admission} — one resolver gates every operation route before
     // execution or proposal handling. Unknown routes continue to their ordinary
     // owner; a known policy denial is one factual, non-presumptuous 403.
-    async #checkCapabilities(statement, workspaceId, loopId, functionalityWorkerId) {
-        const denied = await this.#capabilities.denial(statement, workspaceId, functionalityWorkerId, loopId);
+    async #checkCapabilities(statement, ctx) {
+        await LoopPolicyReader.read(this.#db, ctx.loopId);
+        const denied = await this.#capabilities.denial(statement, ctx.workspaceId, ctx.writer, async (target) => (await ResourceBindings.resolve(target, ctx))?.manifest);
         if (denied === null)
             return null;
         const { descriptor, scope } = denied;
@@ -742,19 +804,23 @@ class Dispatcher {
             retryable: false,
         });
     }
+    capabilityDenial(statement, ctx) {
+        return ResourceBindings.using(this.#schemes, ctx, (boundCtx) => this.#checkCapabilities(statement, boundCtx));
+    }
     // Worker control is FORK/WORK (grammar 0.74.55), not COPY — its body
     // is the new worker's seed prompt, not a destination path. The COPY gates and ResourceMutations.handleCopy
     // branch on this so they never parse the prompt as a dst path.
     #isWorkerControl(statement) {
         return statement.op === "FORK" || statement.op === "WORK"; // worker control targets worker://<name> (grammar 0.74.55)
     }
-    async #writeActionlessEntry({ verbatim, workerId, loopId, turnId, sequence, origin, kind, folded, modelCallId = null, attrs = {} }) {
-        const durableAttrs = { ...attrs, kind };
+    // {§rejected-emission-entry} — rejected provider bytes, never an admitted program.
+    async writeEmissionAttempt({ verbatim, workerId, loopId, turnId, sequence, modelCallId }) {
+        const durableAttrs = { kind: "emissionAttempt" };
         const rx = JSON.stringify({ content: verbatim, mimetype: "text/vnd.plurnk" });
         const row = await this.#db.engine_insert_log_entry.get({
             worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence,
-            origin, source: null, model_call_id: modelCallId,
-            op: null, delimiter: "", signal: null,
+            origin: "model", source: null, model_call_id: modelCallId,
+            op: null, signal: null,
             scheme: null, username: null, password: null, hostname: null, port: null,
             pathname: null, query: null, fragment: null, lineMarker: null,
             tx: "", mimetype_tx: "text/vnd.plurnk",
@@ -771,49 +837,82 @@ class Dispatcher {
             }, this.#weighContent),
             state: "resolved", outcome: null,
             attrs: JSON.stringify(durableAttrs),
-            initial_folded: LogVisibility.serialize(folded ? LogVisibility.FOLDED : LogVisibility.OPEN),
+            initial_folded: LogVisibility.serialize(LogVisibility.FOLDED),
         });
         if (row === undefined)
-            throw new Error("Dispatcher.#writeActionlessEntry: insert returned no row");
+            throw new Error("Dispatcher.writeEmissionAttempt: insert returned no row");
         return row.id;
     }
-    // {§turn-ops-entry} — preserve exact admitted source beside, never instead
-    // of, the ordinary operation-result rows produced by dispatch.
-    async writeTurnOps({ verbatim, workerId, loopId, turnId, sequence, origin, folded, modelCallId = null, reasoningItems }) {
-        return this.#writeActionlessEntry({
-            verbatim, workerId, loopId, turnId, sequence,
-            origin, kind: "turnOps", folded, modelCallId,
-            attrs: {
-                ...(reasoningItems !== undefined && reasoningItems.length > 0 ? { reasoning: reasoningItems } : {}),
-            },
-        });
+    // {§worker-spawn-prompt-resource} WORK and FORK overload their slot by scheme: a `worker://`
+    // path is always the child's address (and keeps the address rules); a path of any other scheme
+    // is read whole and becomes the child's prompt, composed with the body as BARE's combined form.
+    // The durable row keeps the authored statement; only the handler sees the composed one, with no
+    // target, so the child is auto-named exactly as when the slot is empty.
+    async #seedSpawnPrompt(statement, ctx) {
+        if (statement.target === null || WorkerControlAddress.isWorkerScheme(statement.target))
+            return { statement };
+        const read = { ...statement, op: "READ", matcher: null, body: null, lineMarker: { marks: [1, -1] } };
+        const denial = await this.#checkCapabilities(read, ctx);
+        if (denial !== null)
+            return { result: denial };
+        const result = Results.assertReadResult(await this.#dataRun.run(schemeNameOf(read.target), read, ctx));
+        if (result.status !== 200 && result.status !== 204)
+            return { result };
+        if (result.content !== null && typeof result.content !== "string") {
+            throw new InvalidOperationResultError(`${statement.op} prompt resource READ returned non-text content.`);
+        }
+        const prompt = [result.content ?? "", statement.body ?? ""].filter((part) => part !== "").join("\n\n");
+        if (prompt.trim() === "") {
+            return { result: _a.#failure("spawn-prompt-empty", 422, `${statement.op} has no prompt text: the resource is empty and there is no body.`, {}, { retryable: false }) };
+        }
+        return { statement: { ...statement, target: null, body: prompt } };
     }
-    // {§rejected-emission-entry} — provider bytes that fail admission are an
-    // attempt artifact, never a turn program.
-    async writeEmissionAttempt({ verbatim, workerId, loopId, turnId, sequence, modelCallId, reasoningItems }) {
-        return this.#writeActionlessEntry({
-            verbatim, workerId, loopId, turnId, sequence,
-            origin: "model", kind: "emissionAttempt", folded: true, modelCallId,
-            attrs: {
-                ...(reasoningItems !== undefined && reasoningItems.length > 0 ? { reasoning: reasoningItems } : {}),
-            },
+    // {§bare-inference} Reuse exact READ projection without its log/presentation layer.
+    async prepareBarePrompt(context) {
+        return ResourceBindings.using(this.#schemes, this.#buildSchemeCtx(context), async (ctx) => {
+            try {
+                return await this.#prepareBarePrompt(context.statement, ctx);
+            }
+            catch (error) {
+                if (error instanceof OperationFailureError)
+                    return { result: error.result };
+                throw error;
+            }
         });
     }
-    // PLAN — one installment of the model's running work journal. An ordinary op: dispatched like any
-    // other, logged, and broadcast to the client as a log entry — but a pure no-op for
-    // state (PLAN ∉ MUTATING_OPS); its body serializes into the log row's tx, no effect.
-    #handlePlan(statement) {
-        if (statement.op !== "PLAN")
-            throw new Error("unreachable");
-        return { status: 200 };
+    async #prepareBarePrompt(statement, ctx) {
+        const denial = await this.#checkCapabilities(statement, ctx);
+        if (denial !== null)
+            return { result: denial };
+        let resource = "";
+        if (statement.target !== null) {
+            const read = {
+                ...statement,
+                op: "READ",
+                matcher: null,
+                body: null,
+                lineMarker: { marks: [1, -1] },
+            };
+            const result = Results.assertReadResult(await this.#dataRun.run(schemeNameOf(read.target), read, ctx));
+            if (result.status !== 200 && result.status !== 204)
+                return { result };
+            if (typeof result.content === "string")
+                resource = result.content;
+            else if (result.content !== null) {
+                throw new InvalidOperationResultError("BARE source READ returned non-text content.");
+            }
+        }
+        const prompt = [resource, statement.body].filter((part) => part !== "").join("\n\n");
+        if (prompt.trim() === "") {
+            return { result: _a.#failure("bare-prompt-empty", 422, "BARE has no prompt text.", {}, { retryable: false }) };
+        }
+        return { prompt };
     }
-    // {§bare-inference} Provider work is prepared concurrently by Engine; the
-    // dispatcher owns only the ordinary operation-result commit and notification.
+    // {§bare-inference} Provider work runs concurrently; receipts commit in authored order.
     async recordBareResult(context, result, modelCallId) {
         Results.assert(result);
         const logEntryId = await this.#logWriter.writeLog({
             ...context,
-            functionalityWorkerId: context.functionalityWorkerId ?? context.workerId,
             result,
             curationPlan: null,
             modelCallId,
@@ -822,41 +921,103 @@ class Dispatcher {
         await context.onSettled?.(logEntryId);
         return result;
     }
-    // {§send-premature-terminate} — the unified PENDING SET, judged at the terminal's OWN dispatch
-    // (post-batch: the emission's earlier ops already executed, so a same-turn KILL+[200] repairs in
-    // ONE turn, and a same-turn WORK+[200] is caught — the spawn is live by the time the SEND lands).
-    // pending = open streams ∪ live children ∪ THIS turn's retrievals (READ/FIND/BARE, results unseen
-    // until next packet). Failed operations are the separate next-packet leg shared by explicit
-    // completion and empty-join completion. Nothing pending may be silently discarded; 499 discards
-    // BY STATED INTENT and is never gated.
+    // {§send-prompt-acceptance} `prompt://<this worker>/<this loop>/<id>` names a prompt the loop
+    // contains; a SEND to it is the response, exactly as if untargeted. Another worker's or
+    // another loop's prompt is not a recipient and keeps the ordinary refusal.
+    // {§send-response-receipt} — a response names the prompts it answers, so the receipt
+    // says where the text went. {§send-looks-like-operation} — a model response whose first
+    // line is an operation heading is a mis-fenced operation, not a reply: the 2026-09-11
+    // dogfood put four operations on the line after their fences, delivered all four to the
+    // user as 200 replies, then waited fifteen minutes for receipts that could never come.
+    async #respond(statement, schemeCtx, origin, workerId, loopId) {
+        if (origin === "model") {
+            const heading = this.#operationHeading(statement.body?.raw ?? "", schemeCtx);
+            if (heading !== null) {
+                return _a.#failure("send-looks-like-operation", 400, `The response begins with the operation heading \`${heading}\`; nothing ran and nothing was delivered.`, {}, {
+                    heading,
+                    stage: "dispatch",
+                    recovery: `An operation goes on the fence line (\`\`\`\`${heading}); a quoted example goes inside a SEND body.`,
+                    retryable: false,
+                });
+            }
+        }
+        return { status: 200, recipients: await this.#activePrompts(workerId, loopId) };
+    }
+    // The first non-blank line, when it parses alone as one clean heading naming an operation
+    // this worker could perform: a Plurnk operation, or a registered executor or MCP service.
+    #operationHeading(body, schemeCtx) {
+        const line = body.split("\n").find((candidate) => candidate.trim().length > 0)?.trim();
+        if (line === undefined || line.startsWith("`"))
+            return null;
+        const parsed = PlurnkParser.parseStatements(PlurnkParser.frame(line, null), {
+            executors: schemeCtx.executors?.availableRuntimes(schemeCtx.workspaceId) ?? [],
+        });
+        if (parsed.unparsedTail !== undefined || parsed.items.length !== 1 || parsed.items[0].kind !== "statement")
+            return null;
+        const { statement } = parsed.items[0];
+        // {§naked-pattern} lifts prose after the path on FIND, READ and KILL as a literal matcher;
+        // on a reply's first line a multi-word literal is prose, not a mis-fenced operation.
+        if ("matcher" in statement && statement.matcher?.dialect === "glob" && /\s/u.test(statement.matcher.raw))
+            return null;
+        if (statement.op !== "EXEC")
+            return line;
+        const executor = statement.executor;
+        if (executor === null || schemeCtx.executors?.entry(executor, schemeCtx.workspaceId) === undefined)
+            return null;
+        return line;
+    }
+    // The loop's Active Prompts, oldest first, exactly as the packet lists them.
+    async #activePrompts(workerId, loopId) {
+        const worker = await this.#db.worker_get.get({ id: workerId });
+        if (worker === undefined)
+            throw new Error(`worker ${workerId} does not exist`);
+        const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
+        const prefix = promptLoopPrefix(loopSeq);
+        const rows = await this.#db.drain_get_all_prompt_bodies_for_loop.all({
+            worker_id: workerId,
+            pattern: `${prefix}%`,
+            prefix_len: prefix.length,
+        });
+        return rows.map((row) => `prompt://${worker.name}${row.pathname}`);
+    }
+    async #isOwnPromptAddress(target, workerId, loopId) {
+        if (target === null || target.kind !== "url" || target.scheme !== "prompt")
+            return false;
+        const worker = await this.#db.worker_get.get({ id: workerId });
+        if (worker === undefined || target.hostname !== worker.name)
+            return false;
+        const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
+        return target.pathname.startsWith(promptLoopPrefix(loopSeq));
+    }
+    // {§send-premature-terminate} The pending set is judged at TASK's dispatch point,
+    // after earlier operations have executed. Every non-SEND/TASK/KILL model operation
+    // requires a new packet, independently of its result or log visibility.
     async #pendingSet(workerId, turnId) {
         const pending = [];
-        const execHandler = this.#schemes.get("exec");
-        // {§exec-timeout} — a `<-1>` spawn outlives the loop and is nobody's obligation.
-        const openSubs = (await this.#db.find_open_subscriptions_for_worker.all({ worker_id: workerId }))
-            .filter(({ id }) => execHandler?.isDetachedSpawn?.(id) !== true);
-        if (openSubs.length > 0 || execHandler?.hasActiveSpawns?.(workerId) === true)
+        // {§worker-obligations} — the stream and child legs are one durable row.
+        const held = await this.#db.worker_live_obligations.get({ worker_id: workerId });
+        if (held === undefined)
+            throw new Error(`worker ${workerId} does not exist`);
+        if (held.streams === 1)
             pending.push("streams");
-        const liveChild = await this.#db.engine_worker_has_live_child.get({ worker_id: workerId });
-        if (liveChild !== undefined)
+        if (held.workers === 1)
             pending.push("workers");
         const boundaries = await this.#nextPacketBoundaries(workerId, turnId);
-        if (boundaries.retrievals)
+        const receipts = [...new Set(boundaries.operations
+                .filter(({ op }) => op !== "KILL")
+                .map((row) => LogEntryProjection.leaf(row)))];
+        if (boundaries.streamTerminations.length > 0)
+            receipts.push("stream completion");
+        if (receipts.length > 0)
             pending.push("receipts");
-        // A stream that closed successfully is banked, not pending: concluding on its own
-        // success is legitimate and its output stays in the Log. A failed close is an unseen
-        // failure — named exactly (bench#5 requiem #9) so the model reads it, not guesses.
+        // The final-strike escape hatch cannot discard an unobserved failure.
         if (boundaries.streamTerminations.some(({ closeStatus }) => closeStatus >= 400))
             pending.push("failed-stream-results");
         if (boundaries.childTerminations)
             pending.push("worker-results");
-        return pending;
+        return { pending, receipts };
     }
-    // Results cross an observation boundary only when they have appeared in a packet;
-    // successful log-curation effects likewise become useful through the curated next packet.
-    // Keep every next-packet boundary in one classifier while letting the callers apply
-    // their distinct contracts: retrievals block explicit completion, whereas log curation only
-    // prevents an empty wait from being inferred as completion.
+    // {§wait-obligation-matrix}: completion and an empty wait use the same execution evidence.
     async #nextPacketBoundaries(workerId, turnId) {
         const [turnBoundaries, streamTerminations, childTermination] = await Promise.all([
             this.#db.engine_turn_packet_boundaries.all({ turn_id: turnId }),
@@ -866,10 +1027,7 @@ class Dispatcher {
                 .get({ worker_id: workerId }),
         ]);
         return {
-            // {§log-kill-scope} — a log KILL is housekeeping: it continues an empty (WAIT) but never
-            // blocks an explicit (TERM); every other boundary row is a retrieval receipt.
-            retrievals: turnBoundaries.some(({ op }) => op !== "KILL"),
-            curations: turnBoundaries.some(({ op }) => op === "KILL"),
+            operations: turnBoundaries,
             streamTerminations,
             childTerminations: childTermination !== undefined,
         };
@@ -883,25 +1041,18 @@ class Dispatcher {
         return failedRows.length;
     }
     static #unobservedFailures(failCount) {
-        return _a.#failure("unobserved-failures", 409, `This turn produced ${failCount} failed operation result(s) that have not yet entered a packet.`, {}, {
+        return _a.#failure("unobserved-failures", 409, `Completion deferred: ${failCount} operation${failCount === 1 ? "" : "s"} failed in the same turn. The failure${failCount === 1 ? " is" : "s are"} in this packet; address ${failCount === 1 ? "it" : "them"} or complete with a TASK now.`, {}, {
             failures: failCount,
             stage: "completion",
-            retryable: false,
+            retryable: true,
         });
     }
-    // J — a live obligation to WAIT on: a spawned child or an open stream (NOT retrievals, which land
+    // A live obligation to wait on: a spawned child or an open stream (not retrievals, which land
     // next turn regardless). The wait-side twin of #pendingSet's stream+child legs ({§wait-obligation-matrix}).
     async hasLiveWork(workerId) {
-        const execHandler = this.#schemes.get("exec");
-        // {§exec-timeout} — a `<-1>` spawn outlives the loop and is nobody's obligation.
-        const openSubs = (await this.#db.find_open_subscriptions_for_worker.all({ worker_id: workerId }))
-            .filter(({ id }) => execHandler?.isDetachedSpawn?.(id) !== true);
-        if (openSubs.length > 0)
-            return true;
-        if (execHandler?.hasActiveSpawns?.(workerId) === true)
-            return true;
-        const liveChild = await this.#db.engine_worker_has_live_child.get({ worker_id: workerId });
-        return liveChild !== undefined;
+        // {§worker-obligations} — one durable row answers both legs.
+        const held = await this.#db.worker_live_obligations.get({ worker_id: workerId });
+        return held !== undefined && (held.streams === 1 || held.workers === 1);
     }
     async #runLogCuration(statement, ctx, admittedMaxId) {
         const addressedScheme = schemeNameOf(statement.target);
@@ -926,27 +1077,26 @@ class Dispatcher {
         if (maxId === undefined) {
             throw new Error(`log selection boundary could not be resolved for worker ${ctx.workerId}`);
         }
-        const schemeCtx = new SchemeCtxImpl(ctx, "log", manifest, this.#liveSubscriptions, { ownerId: null });
+        const schemeCtx = new SchemeCtxImpl(ctx, "log", manifest, this.#liveSubscriptions, {});
         const outcome = await handler.curate(statement, schemeCtx, maxId);
         return { result: Results.assert(outcome.result), plan: outcome.plan };
     }
-    // {§proposal}/{§send} — status 202 is a proposal except for broadcast
-    // SEND signal 202, which parks the loop. The operation disambiguates the status.
+    // {§proposal}/{§send} — native dispositions park; other 202 results propose.
     static #isProposal(statement, result) {
         if (result.status !== 202)
             return false;
-        return !(statement.op === "SEND" && statement.target === null);
+        return !TurnDisposition.is(statement);
     }
     // Normalize a parsed target for log storage. Bare paths and `file:///...`
     // inputs collapse to scheme=null in log target metadata because both render
     // as bare paths. Addressable file entries separately persist under the
     // reserved `file` identity scheme ({§entry-identity-no-null}).
-    #extractTarget(path, workerId) {
+    #extractTarget(path, workspaceId) {
         if (path === null)
             return { scheme: null, username: null, password: null, hostname: null, port: null, pathname: null, query: null, fragment: null };
         // `local` (bare path) carries no URL parts — store the raw text as the pathname for the log record, scheme=null.
         if (path.kind === "local")
-            return { scheme: null, username: null, password: null, hostname: null, port: null, pathname: PathSyntax.decodeParens(path.raw), query: null, fragment: null }; // {§path-parentheses}
+            return { scheme: null, username: null, password: null, hostname: null, port: null, pathname: PathSyntax.decodeParens(path.raw), query: null, fragment: path.fragment ?? null }; // {§path-parentheses} {§local-path-fragment}
         const scheme = path.scheme === "file" ? null : path.scheme;
         // The registered scheme owns authority disposition. Namespace authority
         // is path syntax; resource and owner authorities remain explicit in the
@@ -954,7 +1104,7 @@ class Dispatcher {
         const routedScheme = schemeNameOf(path);
         const manifest = routedScheme === null
             ? undefined
-            : this.#schemes.manifestFor(routedScheme, workerId);
+            : this.#schemes.manifestFor(routedScheme, workspaceId);
         const foldNs = scheme !== null
             && manifest !== undefined
             && (manifest.authority ?? "namespace") === "namespace";