@plurnk/plurnk-service 1.4.0 → 1.6.0

package/dist/core/Dispatcher.js

@@ -5,27 +5,40 @@ import WorkerControlAddress from "./WorkerControlAddress.js";
 import { entryPathnameOf, foldAuthorityIntoPath, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
 import Fork from "./fork.js";
 import WorkerCap from "./worker-cap.js";
-import { parsePath, PathSyntax } from "@plurnk/plurnk-contracts";
+import { PathSyntax, TagSignal } from "@plurnk/plurnk-contracts";
 import Namespace from "./namespace.js";
 import LoopFlagsReader from "./LoopFlagsReader.js";
 import ChannelWrite from "./ChannelWrite.js";
-import { assertEditBatchReceipt, assertEditReceipt, assertResourceEffects, editReceipt, LineMarkerOps, MimetypeBinary, PathMimetype, projectEditReceipt, } from "../content/index.js";
+import { assertEditBatchReceipt, assertEditReceipt, assertResourceEffects, EditCollision, editReceipt, LineAnchors, LineMarkerOps, MimetypeBinary, PathMimetype, ReadProjector, projectEditReceipt, } from "../content/index.js";
+import DbProjectionCaps from "./caps/DbProjectionCaps.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
 import EntryCrud from "../schemes/_entry-crud.js";
 import EntryOps from "../schemes/_entry-ops.js";
+import EntryFind from "../schemes/_entry-find.js";
 import WorkspaceSettings from "./workspace-settings.js";
 import LoopLifecycle from "./LoopLifecycle.js";
+import TerminalResult from "./TerminalResult.js";
 import Results from "./results.js";
 import { OperationFailureError } from "./results.js";
 import EffectPolicy from "../schemes/EffectPolicy.js";
-import { CoreSchemeAdapterBase } from "./CoreSchemeServices.js";
+import { CoreSchemeAdapterBase, } from "./CoreSchemeServices.js";
 import { InvalidOperationResultError, NetworkAddress, } from "@plurnk/plurnk-schemes";
 import DurableStatement from "./DurableStatement.js";
 // SPEC {§scheme-surface}: writer must be in target scheme's manifest.writableBy.
 // OPEN/FOLD/READ/FIND are not gated — they curate the log or read, never mutating an entry.
 const MUTATING_OPS = new Set(["EDIT", "SEND", "COPY", "MOVE", "EXEC", "KILL", "FORK", "WORK"]);
+const assertClassifyingSignal = (statement) => {
+    if (statement.op === "FIND"
+        || statement.op === "READ"
+        || statement.op === "EDIT"
+        || statement.op === "COPY"
+        || statement.op === "MOVE"
+        || statement.op === "BARE") {
+        TagSignal.applied(statement.signal);
+    }
+};
 // Op dispatch ({§op-methods-op-dispatch}): gates (writableBy, loop flags), the
-// engine-owned op orchestrations (COPY/MOVE/KILL/SEND/READ-fanout), scheme
+// engine-owned op orchestrations (COPY/MOVE/KILL/SEND), scheme
 // routing, the durable log write, and the proposal pause.
 class Dispatcher {
     static #failure(code, status, detail, fields = {}, extensions = {}) {
@@ -53,7 +66,7 @@ class Dispatcher {
     #branchCompletionGate;
     #cancelWorker;
     #cancelDescendants;
-    // {§send-premature-terminate}/SEND[202]<T> — the engine-owned park-deadline registry (loopId → seconds;
+    // {§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;
     #searchGate;
@@ -95,8 +108,14 @@ class Dispatcher {
         const handlerCtx = this.#handlerContext(scheme, ctx);
         return this.#schemes.manifestFor(scheme)?.category === "data" ? handlerCtx : null;
     }
-    async #readEntry(scheme, pathname, ctx) {
+    #coreCrud(scheme) {
         const handler = this.#schemes.get(scheme);
+        return handler instanceof CoreSchemeAdapterBase
+            ? handler
+            : undefined;
+    }
+    async #readEntry(scheme, pathname, ctx) {
+        const handler = this.#coreCrud(scheme);
         const handlerCtx = this.#entryContext(scheme, ctx);
         if (typeof handler?.readEntry === "function" && handlerCtx !== null) {
             return Results.assert(await handler.readEntry(pathname, handlerCtx));
@@ -116,11 +135,16 @@ class Dispatcher {
             status: result.status,
             entry: result.entry === null
                 ? null
-                : { channels: { ...result.entry.channels }, tags: [...result.entry.tags] },
+                : {
+                    channels: { ...result.entry.channels },
+                    ...(result.entry.attributes === undefined
+                        ? {}
+                        : { attributes: { ...result.entry.attributes } }),
+                },
         });
     }
     async #writeEntry(scheme, pathname, entry, ctx) {
-        const handler = this.#schemes.get(scheme);
+        const handler = this.#coreCrud(scheme);
         const handlerCtx = this.#entryContext(scheme, ctx);
         if (typeof handler?.writeEntry === "function" && handlerCtx !== null) {
             return Results.assert(await handler.writeEntry(pathname, entry, handlerCtx));
@@ -137,7 +161,7 @@ class Dispatcher {
         return Results.assert(await caps.write(pathname, entry, scheme === "prompt" ? "worker" : "commons"));
     }
     async #deleteEntry(scheme, pathname, ctx) {
-        const handler = this.#schemes.get(scheme);
+        const handler = this.#coreCrud(scheme);
         const handlerCtx = this.#entryContext(scheme, ctx);
         if (typeof handler?.deleteEntry === "function" && handlerCtx !== null) {
             return Results.assert(await handler.deleteEntry(pathname, handlerCtx));
@@ -154,7 +178,7 @@ class Dispatcher {
         return Results.assert(await caps.delete(pathname, scheme === "prompt" ? "worker" : "commons"));
     }
     async #deleteChannel(scheme, pathname, channel, ctx) {
-        const handler = this.#schemes.get(scheme);
+        const handler = this.#coreCrud(scheme);
         const handlerCtx = this.#entryContext(scheme, ctx);
         if (typeof handler?.deleteChannel === "function" && handlerCtx !== null) {
             return Results.assert(await handler.deleteChannel(pathname, channel, handlerCtx));
@@ -189,11 +213,114 @@ class Dispatcher {
         if (key !== null)
             target.pathname = key;
     }
+    async #resolveEditAnchors(statements, identity, schemeName, manifest, ctx) {
+        const anchored = statements.filter(({ lineMarker }) => LineAnchors.hasAnchor(lineMarker));
+        if (anchored.length === 0) {
+            return { statements: statements, precondition: null };
+        }
+        if (manifest.textEditScopes !== true || !manifest.writableBy.includes("model")) {
+            return {
+                result: _a.#failure("line-anchor-unsupported", 400, `Scheme '${schemeName}' does not support textual EDIT scopes.`, {}, {
+                    scheme: schemeName,
+                    operation: "EDIT",
+                    recovery: "Remove the scope and submit the scheme's complete editable unit.",
+                    retryable: false,
+                }),
+            };
+        }
+        if (identity === null) {
+            return {
+                result: _a.#failure("edit-target-required", 400, "A line-anchored EDIT requires a target resource.", {}, { recovery: "Provide the target that rendered the line anchor.", retryable: false }),
+            };
+        }
+        const first = statements[0];
+        if (first === undefined)
+            return { statements: [], precondition: null };
+        const current = await this.#run(schemeName, {
+            op: "READ",
+            suffix: first.suffix,
+            signal: null,
+            target: first.target,
+            lineMarker: { marks: [1, -1] },
+            body: null,
+            position: first.position,
+        }, ctx);
+        if (current.status === 204 || current.status === 404) {
+            return { result: EditCollision.result(identity) };
+        }
+        if (current.status >= 300) {
+            return {
+                result: _a.#failure("line-anchor-validation-failed", current.status, `EDIT could not validate its line anchor at ${identity}: ${current.problem?.detail ?? `READ returned ${current.status}`}`, {}, {
+                    target: identity,
+                    upstreamStatus: current.status,
+                    stage: "mutation-precondition",
+                    retryable: false,
+                }),
+            };
+        }
+        if (current.status !== 200) {
+            return { result: EditCollision.result(identity) };
+        }
+        const content = current.content;
+        if (typeof content !== "string") {
+            throw new InvalidOperationResultError(`Scheme '${schemeName}' returned READ ${current.status} without textual content while validating an EDIT anchor.`);
+        }
+        const lineAnchors = current.lineAnchors;
+        const lineAnchorIdentity = current.lineAnchorIdentity;
+        try {
+            LineAnchors.assertProjection(content, lineAnchors);
+            if (typeof lineAnchorIdentity !== "string" || lineAnchorIdentity.length === 0) {
+                throw new TypeError("READ line anchors require their canonical derivation identity.");
+            }
+        }
+        catch (cause) {
+            throw new InvalidOperationResultError(`Scheme '${schemeName}' returned READ 200 without its core-owned line-anchor projection.`, { cause });
+        }
+        const resolved = [];
+        const checks = [];
+        for (const statement of statements) {
+            if (statement.lineMarker === null || !LineAnchors.hasAnchor(statement.lineMarker)) {
+                resolved.push(statement);
+                continue;
+            }
+            const resolution = LineAnchors.resolve(lineAnchors, statement.lineMarker);
+            if (!resolution.ok) {
+                const { anchor, kind } = resolution.failure;
+                const invalid = kind === "invalid";
+                if (!invalid)
+                    return { result: EditCollision.result(lineAnchorIdentity) };
+                return {
+                    result: _a.#failure("line-anchor-invalid", 400, `${anchor} is not valid in that EDIT line-coordinate position.`, {}, {
+                        anchor,
+                        target: identity,
+                        recovery: "Use anchors only where the EDIT scope denotes a line.",
+                        retryable: false,
+                    }),
+                };
+            }
+            for (const [index, anchor] of statement.lineMarker.marks.entries()) {
+                if (typeof anchor !== "string")
+                    continue;
+                const line = resolution.marker.marks[index];
+                if (typeof line !== "number") {
+                    throw new InvalidOperationResultError("An EDIT line anchor did not lower to a numeric line.");
+                }
+                checks.push({ anchor, line });
+            }
+            resolved.push({ ...statement, lineMarker: resolution.marker });
+        }
+        const uniqueChecks = [...new Map(checks.map((check) => [`${check.anchor}:${check.line}`, check])).values()];
+        return {
+            statements: resolved,
+            precondition: { identity: lineAnchorIdentity, checks: uniqueChecks },
+        };
+    }
     async prepareEditBatches(statements, context) {
         const { workspaceId, workerId, loopId, turnId, origin } = context;
         const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId, turnId, origin });
         const groups = new Map();
         for (const statement of statements) {
+            assertClassifyingSignal(statement); // {§log-tag-signal}
             const target = this.#extractTarget(statement.target);
             await this.#canonColumns(target, workspaceId);
             const key = JSON.stringify([
@@ -205,11 +332,15 @@ class Dispatcher {
             ]);
             const group = groups.get(key);
             if (group === undefined)
-                groups.set(key, [statement]);
+                groups.set(key, {
+                    identity: renderTarget(target),
+                    statements: [statement],
+                });
             else
-                group.push(statement);
+                group.statements.push(statement);
         }
-        for (const group of groups.values()) {
+        for (const preparedGroup of groups.values()) {
+            const group = preparedGroup.statements;
             const first = group[0];
             const schemeName = schemeNameOf(first.target);
             let initial;
@@ -240,8 +371,20 @@ class Dispatcher {
                 }
                 else {
                     try {
-                        const addressedScheme = first.target?.kind === "url" ? first.target.scheme : schemeName;
-                        initial = Results.assert(await method.call(handler, group, new SchemeCtxImpl(schemeCtx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions)));
+                        const resolved = await this.#resolveEditAnchors(group, preparedGroup.identity, schemeName, manifest, schemeCtx);
+                        if ("result" in resolved) {
+                            initial = resolved.result;
+                        }
+                        else {
+                            const addressedScheme = first.target?.kind === "url" ? first.target.scheme : schemeName;
+                            const publishedChannel = first.target?.kind === "url"
+                                ? first.target.fragment ?? manifest.defaultChannel
+                                : manifest.defaultChannel;
+                            initial = Results.assert(await method.call(handler, resolved.statements, new SchemeCtxImpl(schemeCtx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions, {
+                                publishedChannel,
+                                editPrecondition: resolved.precondition,
+                            })));
+                        }
                     }
                     catch (err) {
                         if (err instanceof InvalidOperationResultError)
@@ -284,6 +427,7 @@ class Dispatcher {
         }
     }
     async dispatch(context) {
+        assertClassifyingSignal(context.statement); // {§log-tag-signal}
         const result = await this.#dispatchOne(context);
         if (context.statement.op === "EDIT") {
             const prepared = this.#preparedEdits.get(context.statement);
@@ -297,31 +441,16 @@ class Dispatcher {
         return result;
     }
     async #dispatchOne(context) {
-        const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, operationConstraint, } = context;
+        const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, } = context;
         const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId, turnId, origin });
         let result;
-        let denial = operationConstraint !== undefined
-            && !operationConstraint.allowedOperations.includes(statement.op)
-            ? _a.#failure("operation-not-allowed", 409, `${statement.op} was not executed because ${operationConstraint.detail}.`, {}, {
-                constraint: operationConstraint.code,
-                allowedOperations: [...operationConstraint.allowedOperations],
-                retryable: false,
-            })
-            : null;
-        if (denial === null)
-            denial = this.#checkWritable(statement, origin);
+        let curationPlan = null;
+        let denial = this.#checkWritable(statement, origin);
         if (denial === null)
             denial = await this.#checkFlagsGate(statement, loopId);
         if (denial !== null) {
             result = denial;
         }
-        else if (this.#readFansOut(statement)) {
-            // Multi-resource scopes, relation matchers, and acquisition-scheme
-            // matchers use FIND for selection and write their own rows. An exact
-            // stored-resource content matcher remains a direct READ, preserving
-            // content-level outcomes such as 203.
-            return await this.#handleReadFanout(statement, schemeCtx, { workerId, loopId, turnId, sequence, origin, onDispatch });
-        }
         else {
             // {§scheme-surface-exception-500} Scheme-handler
             // exceptions become the action-entry's outcome (status 500), not a
@@ -363,7 +492,9 @@ class Dispatcher {
                     result = await this.#handleSendBroadcast(statement, { workspaceId, workerId, loopId, turnId, sequence });
                 }
                 else if (statement.op === "OPEN" || statement.op === "FOLD") {
-                    result = await this.#runLogCuration(statement, schemeCtx);
+                    const curation = await this.#runLogCuration(statement, schemeCtx);
+                    result = curation.result;
+                    curationPlan = curation.plan;
                 }
                 else if (statement.op === "FORK" || statement.op === "WORK") {
                     result = await this.#handleWorkerControl(statement, schemeCtx);
@@ -381,10 +512,8 @@ class Dispatcher {
                     result = this.#handlePlan(statement);
                 }
                 else if (statement.op === "EXEC") {
-                    // EXEC's target slot is `cwd`, not a scheme address.
-                    // Per plurnk.md the op routes unconditionally to the
-                    // exec scheme; the scheme handler reads runtime
-                    // (signal), cwd (target), and command (body).
+                    // EXEC routes unconditionally to its operation owner. The
+                    // resolved runtime declaration owns body/target semantics.
                     result = await this.#gatedExec(statement, schemeCtx, loopId, turnId);
                 }
                 else {
@@ -411,19 +540,30 @@ class Dispatcher {
         // {§join-blocking-collect}
         if (typeof result.awaitWorker === "string")
             this.#joinTargets.add(loopId);
-        const logEntryId = await this.#writeLog({ statement, result, workspaceId, workerId, loopId, turnId, sequence, origin });
+        const logEntryId = await this.#writeLog({
+            statement,
+            result,
+            workspaceId,
+            workerId,
+            loopId,
+            turnId,
+            sequence,
+            origin,
+            curationPlan,
+            modelCallId: null,
+        });
         // {§search-gate} — register successful searches AFTER #writeLog stamps the runtime
         // entry's coordinate onto result.attrs.pathname (the gate's dedup serves from it).
         if (statement.op === "EXEC" && result.status < 400) {
             const rt = ("signal" in statement && typeof statement.signal === "string" && statement.signal.length > 0) ? statement.signal : "sh";
-            const cmd = ("body" in statement && typeof statement.body === "string") ? statement.body : "";
+            const body = ("body" in statement && typeof statement.body === "string") ? statement.body : "";
             const attrPath = result.attrs?.pathname;
             if (typeof attrPath === "string")
-                this.#searchGate?.registerPending(loopId, turnId, rt, cmd, attrPath);
+                this.#searchGate?.registerPending(loopId, turnId, rt, body, attrPath);
         }
         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[202] park is model
+        // side-effecting op returns status 202 (a broadcast SEND signal 202 park is model
         // speech, not a proposal — #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,
@@ -531,11 +671,49 @@ class Dispatcher {
             origin: "client",
         });
         const schemeCtx = new SchemeCtxImpl(coreCtx, addressedScheme, manifest, this.#liveSubscriptions);
+        const resolved = await this.#resolveDataEntryAddress({
+            target,
+            routedScheme,
+            handler,
+            manifest,
+            ctx: coreCtx,
+            schemeCtx,
+        });
+        if (resolved.address === null)
+            return null;
+        const rendered = target.kind === "url"
+            ? renderTarget({ ...target, fragment: null })
+            : renderTarget({ scheme: null, pathname: target.raw, fragment: null });
+        if (rendered === null)
+            throw new TypeError("Resolved entry target did not render.");
+        return {
+            ownerId: resolved.address.ownerId,
+            scheme: resolved.address.scheme,
+            pathname: resolved.address.pathname,
+            target: rendered,
+        };
+    }
+    async #resolveDataEntryAddress({ target, routedScheme, handler, manifest, ctx, schemeCtx, }) {
+        const addressedScheme = target.kind === "url" ? target.scheme : routedScheme;
+        const identityTarget = target.kind === "url"
+            ? {
+                ...target,
+                pathname: PathSyntax.decodeParens(target.pathname),
+                fragment: null,
+            }
+            : { ...target, raw: PathSyntax.decodeParens(target.raw) };
         const resolved = handler.resolveEntryAddress === undefined
-            ? { pathname: entryPathnameOf(target), owner: "commons" }
-            : await handler.resolveEntryAddress(target, schemeCtx);
+            ? { pathname: entryPathnameOf(identityTarget), owner: "commons" }
+            : await handler.resolveEntryAddress(identityTarget, schemeCtx);
         if (resolved === null)
-            return null;
+            return { address: null, result: null };
+        if ("status" in resolved) {
+            const result = Results.assert(resolved);
+            if (result.status < 300) {
+                throw new InvalidOperationResultError(`Scheme '${routedScheme}' returned a successful operation result instead of an entry address.`);
+            }
+            return { address: null, result };
+        }
         if (typeof resolved.pathname !== "string") {
             throw new TypeError(`Scheme '${routedScheme}' returned an invalid entry pathname.`);
         }
@@ -547,10 +725,10 @@ class Dispatcher {
             ownerId = resolved.ownerId;
         }
         else if (resolved.owner === "worker") {
-            ownerId = workerId;
+            ownerId = ctx.workerId;
         }
         else if (resolved.owner === "commons") {
-            ownerId = await Owner.commonsId(this.#db, workspaceId);
+            ownerId = await Owner.commonsId(this.#db, ctx.workspaceId);
         }
         else {
             throw new TypeError(`Scheme '${routedScheme}' returned an invalid entry owner.`);
@@ -558,16 +736,48 @@ class Dispatcher {
         if (!Number.isSafeInteger(ownerId) || ownerId < 1) {
             throw new TypeError(`Scheme '${routedScheme}' returned an invalid entry owner id.`);
         }
-        const rendered = target.kind === "url"
-            ? renderTarget({ ...target, fragment: null })
-            : renderTarget({ scheme: null, pathname: target.raw, fragment: null });
-        if (rendered === null)
-            throw new TypeError("Resolved entry target did not render.");
         return {
-            ownerId,
-            scheme: manifest.storedScheme ?? addressedScheme,
-            pathname: resolved.pathname,
-            target: rendered,
+            address: {
+                ownerId,
+                scheme: manifest.storedScheme ?? addressedScheme,
+                pathname: resolved.pathname,
+            },
+            result: null,
+        };
+    }
+    async #prepareDataRepresentation({ target, routedScheme, handler, manifest, ctx, schemeCtx, publishedChannel, }) {
+        const resolved = await this.#resolveDataEntryAddress({
+            target,
+            routedScheme,
+            handler,
+            manifest,
+            ctx,
+            schemeCtx,
+        });
+        if (resolved.address === null
+            || resolved.result !== null
+            || typeof handler.prepareRepresentation !== "function") {
+            return resolved;
+        }
+        const address = resolved.address;
+        const selectionNeutralTarget = target.kind === "url"
+            ? {
+                ...target,
+                raw: renderTarget({ ...target, fragment: null }) ?? target.raw,
+                fragment: null,
+            }
+            : target;
+        const preparationCtx = new SchemeCtxImpl(ctx, target.kind === "url" ? target.scheme : routedScheme, manifest, this.#liveSubscriptions, {
+            ownerId: address.ownerId,
+            publishedChannel,
+        });
+        const prepared = Results.assertRepresentationPreparation(await handler.prepareRepresentation({
+            target: selectionNeutralTarget,
+            pathname: address.pathname,
+        }, preparationCtx));
+        return {
+            address,
+            result: prepared.status === 200 ? null : prepared,
         };
     }
     // An accepted EXEC reads a non-file source through the same registered
@@ -611,8 +821,8 @@ class Dispatcher {
             return null;
         if (statement.op === "SEND" && statement.target === null)
             return null;
-        // EXEC's target slot is `cwd`, not a scheme address. The op's
-        // authority always belongs to the exec scheme regardless of cwd.
+        // 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);
         }
@@ -644,8 +854,8 @@ class Dispatcher {
     // the prior durable digest and the per-turn cap refuses without execution.
     async #gatedExec(statement, ctx, loopId, turnId) {
         const runtime = ("signal" in statement && typeof statement.signal === "string" && statement.signal.length > 0) ? statement.signal : "sh";
-        const command = ("body" in statement && typeof statement.body === "string") ? statement.body : "";
-        const verdict = this.#searchGate?.check(loopId, turnId, runtime, command) ?? { verdict: "pass" };
+        const body = ("body" in statement && typeof statement.body === "string") ? statement.body : "";
+        const verdict = this.#searchGate?.check(loopId, turnId, runtime, body) ?? { verdict: "pass" };
         if (verdict.verdict === "capped") {
             return _a.#failure("search-limit-reached", 429, `This turn already used its ${verdict.cap} permitted searches.`, {}, {
                 searchLimit: verdict.cap,
@@ -752,12 +962,17 @@ class Dispatcher {
         if (statement.op === "COPY" || statement.op === "MOVE") {
             return check(statement.target) ?? check(statement.body?.target ?? null);
         }
-        // {§exec-target-routing} — the operation owner and a non-file source
-        // are independent authorities; local/file targets stay executor-local.
+        // {§exec-target-routing} — only a runtime-declared resource target adds
+        // source authority. Literal identifiers and path targets stay executor-local.
         if (statement.op === "EXEC") {
             const operationDenial = checkScheme("exec");
             if (operationDenial !== null)
                 return operationDenial;
+            const requested = typeof statement.signal === "string" ? statement.signal : "";
+            const runtime = requested === "" ? "sh" : requested;
+            const targetKind = this.#executors()?.entry(runtime)?.invocation.target?.kind;
+            if (targetKind !== "resource")
+                return null;
             const sourceScheme = schemeNameOf(statement.target);
             return sourceScheme === null || sourceScheme === "file" ? null : checkScheme(sourceScheme);
         }
@@ -829,7 +1044,7 @@ class Dispatcher {
         if (statement.op === "FORK") {
             // Branch the current worker's log into a named sister.
             const branchWorkerId = await Fork.fork(this.#db, ctx.workerId, name);
-            await ctx.injectWorker({ workspaceId: ctx.workspaceId, workerId: branchWorkerId, prompt, flags });
+            await ctx.injectWorker({ workspaceId: ctx.workspaceId, workerId: branchWorkerId, prompt, flags, parentLoopId: ctx.loopId });
             return { status: 200, body: name };
         }
         // WORK — a fresh worker sister named <name>.
@@ -838,7 +1053,7 @@ class Dispatcher {
         });
         if (row === undefined)
             throw new Error("worker spawn: worker insert returned no row");
-        await ctx.injectWorker({ workspaceId: ctx.workspaceId, workerId: row.id, prompt, flags });
+        await ctx.injectWorker({ workspaceId: ctx.workspaceId, workerId: row.id, prompt, flags, parentLoopId: ctx.loopId });
         return { status: 200, body: name };
     }
     async #handleCopy(statement, ctx) {
@@ -870,11 +1085,19 @@ class Dispatcher {
                 retryable: false,
             });
         }
+        const sourceMarks = statement.lineMarker?.marks;
+        const sourceLineMarker = sourceMarks?.length === 2
+            && sourceMarks[0] === 1
+            && sourceMarks[1] === -1
+            ? null
+            : statement.lineMarker;
         return this.#moveOrchestration({
             statement,
             source: {
                 target: statement.target,
-                lineMarker: statement.lineMarker,
+                // Canonicalize only the execution selection. #writeLog retains
+                // the authored marker as operation evidence. {§move-canonical-whole-source}
+                lineMarker: sourceLineMarker,
             },
             destination: statement.body,
             ctx,
@@ -949,185 +1172,48 @@ class Dispatcher {
         // carries the delete target to review (#isProposal fires on 202). Plurnk-internal deletes execute inline.
         return this.#deleteEntry(schemeName, entryPathnameOf(path), ctx);
     }
-    // A multi-resource READ uses FIND as its resource selector, then writes one
-    // READ row per selected resource. Match coordinates remain metadata on that
-    // resource; they never create extra rows or replace its content.
-    #readFansOut(statement) {
-        if (statement.op !== "READ")
-            return false;
-        const body = statement.body;
-        if (body?.dialect === "semantic" || body?.dialect === "graph")
-            return true;
-        const schemeName = schemeNameOf(statement.target);
-        const handler = schemeName === null
-            ? undefined
-            : this.#schemes.get(schemeName);
-        if (body !== null && typeof handler?.prepareFind === "function")
-            return true;
-        const t = statement.target;
-        const p = t === null ? "" : (t.kind === "url" ? t.pathname : t.raw);
-        if (PathSyntax.hasGlob(p))
-            return true;
-        return p.endsWith("/") && schemeName !== null && this.#schemes.manifestFor(schemeName)?.folderScopes === true;
-    }
-    static #retargetRead(statement, pathname, lineMarker, body) {
-        const t = statement.target;
-        const target = t !== null && t.kind === "url"
-            ? { ...t, pathname, raw: `${t.scheme}://${pathname}` }
-            : { ...t, raw: pathname };
-        return { ...statement, target: target, lineMarker, body };
-    }
-    // READ scope always projects text. Semantic READ reserves a leading decimal
-    // for similarity selection; any remaining integers are the text projection.
-    // FIND retains its own public result-range interpretation.
-    static #readMarkers(statement) {
-        const marker = statement.lineMarker;
-        if (statement.body?.dialect !== "semantic") {
-            return { selection: null, projection: marker };
-        }
-        if (marker === null)
-            return { selection: null, projection: null };
-        const [first, ...rest] = marker.marks;
-        if (Number.isInteger(first)) {
-            return { selection: null, projection: marker };
-        }
-        return {
-            selection: { marks: [first] },
-            projection: rest.length === 0 ? null : { marks: rest },
-        };
-    }
-    #standardEntryManifest(schemeName, statement) {
-        const handler = this.#schemes.get(schemeName);
-        if (typeof handler?.find === "function")
-            return null;
-        const target = statement.target;
-        if (target === null || target.kind !== "url" || target.scheme === null)
-            return null;
-        const manifest = this.#schemes.manifestFor(schemeName);
-        return manifest === undefined ? null : { ...manifest, name: target.scheme };
-    }
-    static #storedEntryRead(statement, pathname, lineMarker, body, storage) {
-        const target = statement.target;
-        if (target === null || target.kind !== "url")
-            return _a.#retargetRead(statement, pathname, lineMarker, body);
-        if (NetworkAddress.supports(target.scheme)) {
-            const parsed = parsePath(renderAddress(target.scheme, pathname));
-            if (parsed === null || parsed.kind !== "url") {
-                throw new Error(`failed to reconstruct network entry target for ${target.scheme}:${pathname}`);
-            }
-            const reconstructed = { ...parsed, fragment: target.fragment };
-            const raw = renderTarget(reconstructed);
-            if (raw === null)
-                throw new Error(`failed to render network entry target for ${target.scheme}:${pathname}`);
-            return {
-                ...statement,
-                target: { ...reconstructed, raw },
-                lineMarker,
-                body,
-            };
-        }
-        const hostPrefix = target.hostname === null ? null : `/${target.hostname}`;
-        const displayPath = hostPrefix !== null && pathname.startsWith(`${hostPrefix}/`)
-            ? pathname.slice(hostPrefix.length)
-            : pathname;
-        return {
-            ...statement,
-            target: storage
-                ? { ...target, hostname: null, pathname, raw: `${target.scheme}://${pathname}` }
-                : { ...target, pathname: displayPath, raw: `${target.scheme}://${target.hostname ?? ""}${displayPath}` },
-            lineMarker,
-            body,
-        };
-    }
-    async #handleReadFanout(statement, ctx, ids) {
-        const { workerId, loopId, turnId, sequence, origin, onDispatch } = ids;
-        const schemeName = schemeNameOf(statement.target);
-        const read = statement;
-        const markers = _a.#readMarkers(read);
-        const findStatement = {
-            ...statement,
-            op: "FIND",
-            lineMarker: markers.selection,
-        };
-        const standardEntryManifest = schemeName === null ? null : this.#standardEntryManifest(schemeName, statement);
-        const found = await this.#run(schemeName, findStatement, ctx);
-        const matches = found.matches ?? [];
-        const omittedItems = typeof found.omittedItems === "number" ? found.omittedItems : null;
-        if (omittedItems !== null) {
-            const maximumItems = typeof found.maximumItems === "number" ? found.maximumItems : null;
-            const result = _a.#failure("read-materialization-too-large", 413, `READ selected ${omittedItems} resources, exceeding the materialization limit${maximumItems === null ? "" : ` of ${maximumItems}`}.`, {}, {
-                resources: omittedItems,
-                ...(maximumItems === null ? {} : { maximumResources: maximumItems }),
-                stage: "materialization",
-                recovery: "Narrow the target or matcher.",
-                retryable: false,
-            });
-            const readRowId = await this.#writeLog({ statement, result, workspaceId: ctx.workspaceId, workerId, loopId, turnId, sequence, origin });
-            onDispatch?.(readRowId);
-            return { ...result, rowsWritten: 1 };
-        }
-        // Find-less scheme, a matcher/scope error, or zero matches → a single row carrying the
-        // status, exactly like a non-fanned READ. The model sees the empty/failed result, not silence.
-        if (found.status !== 200 || matches.length === 0) {
-            const result = found.status === 200
-                ? { status: 204, ...(read.body === null ? {} : { matches: [] }) }
-                : found;
-            const id = await this.#writeLog({ statement, result, workspaceId: ctx.workspaceId, workerId, loopId, turnId, sequence, origin });
-            onDispatch?.(id);
-            return { ...result, rowsWritten: 1 };
-        }
-        const fannedStatuses = [];
-        const scopeNormalizations = [];
-        let written = 0;
-        for (const match of matches) {
-            ctx.signal?.throwIfAborted();
-            const executionStatement = standardEntryManifest === null
-                ? _a.#retargetRead(statement, match.pathname, markers.projection, null)
-                : _a.#storedEntryRead(statement, match.pathname, markers.projection, null, true);
-            const readResult = standardEntryManifest === null
-                ? await this.#run(schemeName, executionStatement, ctx)
-                : await EntryOps.readWorkspaceEntry(executionStatement, ctx, standardEntryManifest);
-            const result = read.body === null
-                ? readResult
-                : { ...readResult, matches: match.matches };
-            const loggedStatement = standardEntryManifest === null
-                ? _a.#retargetRead(statement, match.pathname, statement.lineMarker, read.body)
-                : _a.#storedEntryRead(statement, match.pathname, statement.lineMarker, read.body, false);
-            const id = await this.#writeLog({ statement: loggedStatement, result, workspaceId: ctx.workspaceId, workerId, loopId, turnId, sequence: sequence + written, origin });
-            onDispatch?.(id);
-            fannedStatuses.push(result.status);
-            scopeNormalizations.push(...(result.scopeNormalizations ?? []));
-            written++;
-        }
-        return {
-            status: 200,
-            rowsWritten: written,
-            fannedStatuses,
-            ...(scopeNormalizations.length === 0 ? {} : { scopeNormalizations }),
-        };
-    }
-    // {§model-entry} — mirror an admitted model emission back as an actionless `model` log row, so
-    // the model can inspect and curate its own prior behavior.
-    // Born FOLDED by default (budget-neutral until OPENed); the turn-0 exemplar passes folded:false
-    // (born open — the one worked example the model orients on, thinning the grammar). text/vnd.plurnk.
-    async writeModelEntry({ verbatim, workerId, loopId, turnId, sequence, folded, origin = "model", reasoningItems }) {
+    async #writeActionlessEntry({ verbatim, workerId, loopId, turnId, sequence, origin, kind, folded, modelCallId = null, attrs = {} }) {
         const row = await this.#db.engine_insert_log_entry.get({
             worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence,
-            origin, source: null, op: "model", suffix: "", signal: null,
+            origin, source: null, model_call_id: modelCallId,
+            op: null, suffix: "", 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",
             rx: JSON.stringify({ content: verbatim, mimetype: "text/vnd.plurnk" }),
             mimetype_rx: "application/json",
             status_rx: 200, tokens: this.#tokenize(verbatim), state: "resolved", outcome: null,
-            attrs: reasoningItems !== undefined && reasoningItems.length > 0 ? JSON.stringify({ reasoning: reasoningItems }) : "{}",
+            attrs: JSON.stringify({ ...attrs, kind }),
         });
         if (row === undefined)
-            throw new Error("Dispatcher.writeModelEntry: insert returned no row");
+            throw new Error("Dispatcher.#writeActionlessEntry: insert returned no row");
         if (folded)
             await this.#db.engine_fold_log_entry.run({ id: row.id });
         return row.id;
     }
+    // {§worker-initialization-entry} — the kernel-authored, born-open worked
+    // turn that initializes a worker's log without impersonating model output.
+    async writeInitializationEntry({ verbatim, workerId, loopId, turnId, sequence }) {
+        return this.#writeActionlessEntry({
+            verbatim, workerId, loopId, turnId, sequence,
+            origin: "plurnk", kind: "initialization", folded: false,
+        });
+    }
+    // {§model-entry} — mirror a model emission back as an actionless log row, so
+    // the model can inspect and curate its own prior behavior. Ordinary admitted
+    // emissions are folded; the bounded invalid-emission lifeline is the one
+    // born-open rejected item under {§invalid-emission-attempts} and labels
+    // that admission fact structurally.
+    async writeModelEntry({ verbatim, workerId, loopId, turnId, sequence, folded, modelCallId, admission = "accepted", reasoningItems }) {
+        return this.#writeActionlessEntry({
+            verbatim, workerId, loopId, turnId, sequence,
+            origin: "model", kind: "model_emission", folded, modelCallId,
+            attrs: {
+                ...(admission === "rejected" ? { admission } : {}),
+                ...(reasoningItems !== undefined && reasoningItems.length > 0 ? { reasoning: reasoningItems } : {}),
+            },
+        });
+    }
     // PLAN — the model's intended-goals op. 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.
@@ -1136,6 +1222,20 @@ class Dispatcher {
             throw new Error("unreachable");
         return { status: 200 };
     }
+    // {§bare-inference} Provider work is prepared concurrently by Engine; the
+    // dispatcher owns only the ordinary operation-result commit and notification.
+    async recordBareResult(context, result, modelCallId) {
+        assertClassifyingSignal(context.statement);
+        Results.assert(result);
+        const logEntryId = await this.#writeLog({
+            ...context,
+            result,
+            curationPlan: null,
+            modelCallId,
+        });
+        context.onDispatch?.(logEntryId);
+        return result;
+    }
     static #isDispatchResult(value) {
         return "status" in value;
     }
@@ -1201,8 +1301,81 @@ class Dispatcher {
             manifest,
         };
     }
-    async #selectSource(selection, ctx) {
-        const read = await this.#readEntry(selection.scheme, selection.pathname, ctx);
+    #resolveResourceLineMarker(selection, content, operation) {
+        if (!LineAnchors.hasAnchor(selection.lineMarker)) {
+            return {
+                selection: {
+                    ...selection,
+                    lineMarker: selection.lineMarker,
+                },
+                precondition: null,
+            };
+        }
+        const target = this.#resourceAddress(selection);
+        if (selection.manifest.textEditScopes !== true || !selection.manifest.writableBy.includes("model")) {
+            return {
+                result: _a.#failure("line-anchor-unsupported", 400, `The representation at ${target} does not publish line anchors.`, {}, {
+                    operation,
+                    target,
+                    recovery: "Use numeric text coordinates.",
+                    retryable: false,
+                }),
+            };
+        }
+        const resolution = LineAnchors.resolve(LineAnchors.tokens(target, content), selection.lineMarker);
+        if (!resolution.ok) {
+            if (resolution.failure.kind === "invalid") {
+                return {
+                    result: _a.#failure("line-anchor-invalid", 400, "A line anchor appeared outside a line-coordinate position.", {}, {
+                        operation,
+                        target,
+                        recovery: "Use anchors only for L, SL, or EL; columns remain numeric.",
+                        retryable: false,
+                    }),
+                };
+            }
+            return {
+                result: _a.#failure("line-anchor-collision", 409, `${operation} coordinates collided with current content at ${target}.`, {}, {
+                    operation,
+                    target,
+                    recovery: `READ ${target} again and retry against its current coordinates.`,
+                    retryable: true,
+                }),
+            };
+        }
+        return {
+            selection: { ...selection, lineMarker: resolution.marker },
+            precondition: {
+                identity: target,
+                checks: LineAnchors.checks(selection.lineMarker, resolution.marker),
+            },
+        };
+    }
+    async #selectSource(selection, ctx, operation) {
+        const handler = this.#schemes.get(selection.scheme);
+        if (handler === undefined) {
+            throw new InvalidOperationResultError(`Resolved COPY/MOVE source scheme '${selection.scheme}' is no longer registered.`);
+        }
+        const addressedScheme = selection.target.kind === "url"
+            ? selection.target.scheme
+            : selection.scheme;
+        const schemeCtx = new SchemeCtxImpl(ctx, addressedScheme, selection.manifest, this.#liveSubscriptions, { publishedChannel: selection.channel });
+        const prepared = await this.#prepareDataRepresentation({
+            target: selection.target,
+            routedScheme: selection.scheme,
+            handler,
+            manifest: selection.manifest,
+            ctx,
+            schemeCtx,
+            publishedChannel: selection.channel,
+        });
+        if (prepared.result !== null)
+            return prepared.result;
+        if (prepared.address === null) {
+            return _a.#failure("entry-not-found", 404, `No entry exists at ${this.#resourceAddress(selection)}.`, {}, { target: this.#resourceAddress(selection) });
+        }
+        const storageAddress = prepared.address;
+        const read = await EntryCrud.readEntry(storageAddress.pathname, ctx, storageAddress.scheme, storageAddress.ownerId);
         if (read.status >= 400)
             return read;
         if (read.status !== 200 || read.entry === null) {
@@ -1210,13 +1383,16 @@ class Dispatcher {
         }
         const selected = read.entry.channels[selection.channel];
         if (selected === undefined) {
-            return _a.#failure("channel-not-found", 404, `No channel named #${selection.channel} exists at ${renderAddress(selection.scheme, selection.identityPathname)}.`, {}, {
-                target: renderAddress(selection.scheme, selection.identityPathname),
+            return _a.#failure("channel-not-found", 404, `No channel named #${selection.channel} exists at ${renderAddress(storageAddress.scheme, storageAddress.pathname)}.`, {}, {
+                target: renderAddress(storageAddress.scheme, storageAddress.pathname),
                 requestedChannel: selection.channel,
                 availableChannels: Object.keys(read.entry.channels),
                 retryable: false,
             });
         }
+        const resolvedMarker = this.#resolveResourceLineMarker(selection, selected.content, operation);
+        if ("result" in resolvedMarker)
+            return resolvedMarker.result;
         let content = selected.content;
         let scopeNormalizations;
         if (await MimetypeBinary.isBinaryMimetype(selected.mimetype, ctx.mimetypes)) {
@@ -1227,17 +1403,23 @@ class Dispatcher {
                 retryable: false,
             });
         }
-        if (selection.lineMarker !== null) {
-            const sliced = LineMarkerOps.sliceLinesRaw(content, selection.lineMarker);
+        if (resolvedMarker.selection.lineMarker !== null) {
+            const sliced = LineMarkerOps.sliceLinesRaw(content, resolvedMarker.selection.lineMarker);
             if (sliced.status !== 200)
                 return Results.assert(sliced);
             content = sliced.text ?? "";
             scopeNormalizations = sliced.scopeNormalizations;
         }
+        if (selected.producerResult !== undefined && selected.producerResult.status >= 400) {
+            return Results.assert(selected.producerResult);
+        }
         return {
-            ...selection,
+            ...resolvedMarker.selection,
+            storageAddress,
             content,
+            completeContent: selected.content,
             mimetype: selected.mimetype,
+            lineAnchorPrecondition: resolvedMarker.precondition,
             ...(scopeNormalizations === undefined ? {} : { scopeNormalizations }),
         };
     }
@@ -1252,6 +1434,18 @@ class Dispatcher {
             ],
         });
     }
+    static #mergeLineAnchorPreconditions(...values) {
+        const present = values.filter((value) => value !== null);
+        if (present.length === 0)
+            return null;
+        const identity = present[0].identity;
+        if (present.some((value) => value.identity !== identity)) {
+            throw new TypeError("Line-anchor preconditions for one edit batch must share a resource identity.");
+        }
+        const checks = [...new Map(present.flatMap(({ checks: valueChecks }) => valueChecks)
+                .map((check) => [`${check.anchor}:${check.line}`, check])).values()];
+        return { identity, checks };
+    }
     #resourceAddress(selection) {
         const address = renderTarget({
             scheme: selection.scheme === "file" ? null : selection.scheme,
@@ -1471,7 +1665,7 @@ class Dispatcher {
             },
         };
     }
-    async #invokeEditBatch(selection, edits, ctx) {
+    async #invokeEditBatch(selection, edits, ctx, precondition = null) {
         const handler = this.#schemes.get(selection.scheme);
         if (typeof handler?.editBatch !== "function") {
             return _a.#failure("operation-not-implemented", 501, `Scheme '${selection.scheme}' does not implement EDIT batches.`, {}, {
@@ -1480,10 +1674,10 @@ class Dispatcher {
                 retryable: false,
             });
         }
-        const statements = edits.map(({ marker, body, tags, position }) => ({
+        const statements = edits.map(({ marker, body, position }) => ({
             op: "EDIT",
             suffix: "",
-            signal: tags,
+            signal: null,
             target: selection.target,
             lineMarker: marker,
             body,
@@ -1493,7 +1687,10 @@ class Dispatcher {
             ? selection.target.scheme
             : selection.scheme;
         try {
-            const result = Results.assert(await handler.editBatch(statements, new SchemeCtxImpl(ctx, addressedScheme, selection.manifest, this.#liveSubscriptions)));
+            const result = Results.assert(await handler.editBatch(statements, new SchemeCtxImpl(ctx, addressedScheme, selection.manifest, this.#liveSubscriptions, {
+                publishedChannel: selection.channel,
+                editPrecondition: precondition,
+            })));
             return this.#withProposalRoute(result, selection);
         }
         catch (err) {
@@ -1529,7 +1726,6 @@ class Dispatcher {
                 retryable: false,
             });
         }
-        const tags = Array.isArray(statement.signal) ? statement.signal : [];
         const destinationEffect = this.#pendingEffect(destination, destinationChannel === undefined ? "create" : "update");
         if (destination.lineMarker !== null) {
             if (destinationChannel === undefined) {
@@ -1545,13 +1741,15 @@ class Dispatcher {
                     retryable: false,
                 });
             }
-            const edited = await this.#invokeEditBatch(destination, [{
-                    marker: destination.lineMarker,
+            const resolvedMarker = this.#resolveResourceLineMarker(destination, destinationChannel.content, statement.op);
+            if ("result" in resolvedMarker)
+                return resolvedMarker.result;
+            const edited = await this.#invokeEditBatch(resolvedMarker.selection, [{
+                    marker: resolvedMarker.selection.lineMarker,
                     body: source.content,
-                    tags,
                     position: statement.position,
-                }], ctx);
-            return this.#finalizeEffects(edited, destination, [destinationEffect]);
+                }], ctx, resolvedMarker.precondition);
+            return this.#finalizeEffects(edited, resolvedMarker.selection, [destinationEffect]);
         }
         if (destinationChannel !== undefined
             && destinationChannel.content !== source.content) {
@@ -1560,10 +1758,7 @@ class Dispatcher {
                 retryable: false,
             });
         }
-        const priorTags = existing?.tags ?? [];
-        const mergedTags = [...new Set([...priorTags, ...tags])];
-        const addsTags = mergedTags.length !== priorTags.length;
-        if (destinationChannel !== undefined && !addsTags)
+        if (destinationChannel !== undefined)
             return { status: 304 };
         const channels = {
             ...(existing?.channels ?? {}),
@@ -1572,15 +1767,18 @@ class Dispatcher {
                 mimetype: source.mimetype,
             },
         };
-        const written = await this.#writeEntry(destination.scheme, destination.pathname, { channels, tags: mergedTags }, ctx);
+        const written = await this.#writeEntry(destination.scheme, destination.pathname, { channels }, ctx);
         const exactWritten = Results.assert(written);
+        const parseIssues = exactWritten.status === 200 || exactWritten.status === 201
+            ? await new DbProjectionCaps(ctx).parseIssues(source.content, source.mimetype)
+            : undefined;
         const materialized = source.lineMarker === null
             || (exactWritten.status !== 200 && exactWritten.status !== 201 && exactWritten.status !== 202)
             ? exactWritten
-            : _a.#withEditMaterialization(exactWritten, editReceipt(destinationChannel?.content ?? "", source.content, [{
+            : _a.#withEditMaterialization(exactWritten, editReceipt("", source.content, [{
                     marker: { marks: [1, -1] },
                     body: source.content,
-                }]));
+                }], parseIssues));
         return this.#finalizeEffects(materialized, destination, [destinationEffect]);
     }
     async #copyOrchestration({ statement, source, destination, ctx, }) {
@@ -1590,13 +1788,13 @@ class Dispatcher {
         const resolvedDestination = await this.#resolveResourceSelection(destination, ctx);
         if (_a.#isDispatchResult(resolvedDestination))
             return resolvedDestination;
-        const selected = await this.#selectSource(resolvedSource, ctx);
+        const selected = await this.#selectSource(resolvedSource, ctx, "COPY");
         if (_a.#isDispatchResult(selected))
             return selected;
         const result = await this.#writeDestination(statement, selected, resolvedDestination, ctx);
         return _a.#prependScopeNormalizations(result, selected.scopeNormalizations);
     }
-    #deferredMoveSource(source, destination) {
+    #deferredMoveSource(source, destination, lineAnchorPrecondition) {
         return {
             target: source.target,
             lineMarker: source.lineMarker,
@@ -1604,6 +1802,7 @@ class Dispatcher {
             pathname: source.pathname,
             channel: source.channel,
             destination: this.#resourceAddress(destination),
+            lineAnchorPrecondition,
         };
     }
     #moveFailureAfterDestination(result, destination, destinationEffects) {
@@ -1625,7 +1824,7 @@ class Dispatcher {
         });
         return _a.#withCombinedEffects(failed, destinationEffects);
     }
-    async #removeMoveSource(statement, source, ctx) {
+    async #removeMoveSource(statement, source, ctx, lineAnchorPrecondition = null) {
         const effect = this.#pendingEffect(source, source.lineMarker === null ? "delete" : "update");
         if (source.lineMarker === null) {
             const deleted = await this.#deleteChannel(source.scheme, source.pathname, source.channel, ctx);
@@ -1634,9 +1833,8 @@ class Dispatcher {
         const edited = await this.#invokeEditBatch(source, [{
                 marker: source.lineMarker,
                 body: "",
-                tags: null,
                 position: statement.position,
-            }], ctx);
+            }], ctx, lineAnchorPrecondition);
         return this.#finalizeEffects(edited, source, [effect]);
     }
     async #moveWithinChannel(statement, source, destination, ctx) {
@@ -1653,22 +1851,24 @@ class Dispatcher {
         if (destination.lineMarker === null) {
             return this.#writeDestination(statement, source, destination, ctx);
         }
-        const moved = await this.#invokeEditBatch(destination, [
+        const resolvedDestination = this.#resolveResourceLineMarker(destination, source.completeContent, "MOVE");
+        if ("result" in resolvedDestination)
+            return resolvedDestination.result;
+        const precondition = _a.#mergeLineAnchorPreconditions(source.lineAnchorPrecondition, resolvedDestination.precondition);
+        const moved = await this.#invokeEditBatch(resolvedDestination.selection, [
             {
-                marker: destination.lineMarker,
+                marker: resolvedDestination.selection.lineMarker,
                 body: source.content,
-                tags: Array.isArray(statement.signal) ? statement.signal : [],
                 position: statement.position,
             },
             {
                 marker: source.lineMarker,
                 body: "",
-                tags: null,
                 position: statement.position,
             },
-        ], ctx);
-        const effect = this.#pendingEffect(destination, "update");
-        return this.#finalizeEffects(moved, destination, [effect, effect]);
+        ], ctx, precondition);
+        const effect = this.#pendingEffect(resolvedDestination.selection, "update");
+        return this.#finalizeEffects(moved, resolvedDestination.selection, [effect, effect]);
     }
     async #moveOrchestration({ statement, source, destination, ctx, }) {
         const resolvedSource = await this.#resolveResourceSelection(source, ctx);
@@ -1677,7 +1877,7 @@ class Dispatcher {
         const resolvedDestination = await this.#resolveResourceSelection(destination, ctx);
         if (_a.#isDispatchResult(resolvedDestination))
             return resolvedDestination;
-        const selected = await this.#selectSource(resolvedSource, ctx);
+        const selected = await this.#selectSource(resolvedSource, ctx, "MOVE");
         if (_a.#isDispatchResult(selected))
             return selected;
         if (this.#sameChannel(resolvedSource, resolvedDestination)) {
@@ -1696,11 +1896,11 @@ class Dispatcher {
                 ...destinationResult,
                 attrs: {
                     ...destinationResult.attrs,
-                    moveSource: this.#deferredMoveSource(resolvedSource, resolvedDestination),
+                    moveSource: this.#deferredMoveSource(selected, resolvedDestination, selected.lineAnchorPrecondition),
                 },
             };
         }
-        const sourceResult = await this.#removeMoveSource(statement, resolvedSource, ctx);
+        const sourceResult = await this.#removeMoveSource(statement, selected, ctx, selected.lineAnchorPrecondition);
         if (sourceResult.status === 202) {
             return {
                 ...sourceResult,
@@ -1796,7 +1996,10 @@ class Dispatcher {
             || resolvedSource.channel !== deferred.channel) {
             throw new InvalidOperationResultError("A deferred MOVE source no longer resolves to its recorded identity.");
         }
-        const removed = await this.#removeMoveSource(statement, resolvedSource, ctx);
+        const removed = await this.#removeMoveSource(statement, {
+            ...resolvedSource,
+            lineMarker: resolvedSource.lineMarker,
+        }, ctx, deferred.lineAnchorPrecondition);
         if (removed.status >= 400) {
             return {
                 resolution: settlement.resolution,
@@ -1834,7 +2037,7 @@ class Dispatcher {
     // {§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/OPEN, results unseen
+    // pending = open streams ∪ live children ∪ THIS turn's retrievals (READ/FIND/OPEN/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.
@@ -1847,30 +2050,32 @@ class Dispatcher {
         const liveChild = await this.#db.engine_worker_has_live_child.get({ worker_id: workerId });
         if (liveChild !== undefined)
             pending.push("surviving workers");
-        const observations = await this.#pendingObservations(workerId, turnId);
-        if (observations.retrievals)
+        const boundaries = await this.#nextPacketBoundaries(workerId, turnId);
+        if (boundaries.retrievals)
             pending.push("this turn's retrieval results (they land in the NEXT packet's Log)");
-        if (observations.streamTerminations) {
+        if (boundaries.streamTerminations) {
             pending.push("completed stream results that land in the NEXT packet's Log");
         }
-        if (observations.childTerminations)
+        if (boundaries.childTerminations)
             pending.push("worker results that arrived during this turn (they land NEXT turn)");
         return pending;
     }
-    // Results cross an observation boundary only when they have appeared in a
-    // packet. Completion alone is not delivery. Keep the three next-packet
-    // producers in one classifier so SEND[200]'s discard gate and SEND[202]'s
-    // empty-join decision cannot disagree about what remains unseen.
-    async #pendingObservations(workerId, turnId) {
-        const [retrievals, streamTermination, childTermination] = await Promise.all([
-            this.#db.engine_turn_retrievals.all({ turn_id: turnId }),
+    // Results cross an observation boundary only when they have appeared in a packet;
+    // successful FOLD 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 FOLD only
+    // prevents an empty wait from being inferred as completion.
+    async #nextPacketBoundaries(workerId, turnId) {
+        const [turnBoundaries, streamTermination, childTermination] = await Promise.all([
+            this.#db.engine_turn_packet_boundaries.all({ turn_id: turnId }),
             this.#db.engine_worker_has_undelivered_stream_term
                 .get({ worker_id: workerId }),
             this.#db.engine_worker_has_undelivered_child_term
                 .get({ worker_id: workerId }),
         ]);
         return {
-            retrievals: retrievals.length > 0,
+            retrievals: turnBoundaries.some(({ op }) => op !== "FOLD"),
+            folds: turnBoundaries.some(({ op }) => op === "FOLD"),
             streamTerminations: streamTermination !== undefined,
             childTerminations: childTermination !== undefined,
         };
@@ -1911,15 +2116,15 @@ class Dispatcher {
         if (status === null) {
             return _a.#failure("send-status-required", 400, "SEND requires a numeric status.", {}, { retryable: false });
         }
-        const raw = statement.body === null ? "" : typeof statement.body === "string" ? statement.body : statement.body.raw;
-        // The park rides SEND[202] only ({§park-202-only}). A scoped SEND[102] is neither
+        const raw = statement.body === null ? "" : statement.body.raw;
+        // The park rides SEND signal 202 only ({§park-202-only}). A scoped signal 102 is neither
         // a wait nor a meaningful continuation, so reject it instead of preserving the
         // retired dual spelling.
         if (status === 102 && statement.lineMarker !== null) {
-            return _a.#failure("send-scope-invalid", 400, "SEND[102] does not accept a scope.", {}, {
+            return _a.#failure("send-scope-invalid", 400, "`## SEND0 [102]` does not accept a scope.", {}, {
                 requestedStatus: 102,
                 scope: statement.lineMarker,
-                recovery: "Use SEND[202] with a scope to wait, or remove the scope to continue.",
+                recovery: "Use `## SEND0 [202] <scope>` to wait, or remove the scope to continue.",
                 retryable: false,
             });
         }
@@ -1927,13 +2132,13 @@ class Dispatcher {
         // indefinite park. {§join-blocking-collect}
         const joinArmed = this.#joinTargets.delete(loopId);
         if (status === 102 && statement.lineMarker === null && joinArmed) {
-            if (!await this.#lifecycle.park(loopId, raw.length > 0 ? raw : "parked — awaiting a worker's result (blocking collect)")) {
+            if (!await this.#lifecycle.park(loopId)) {
                 return _a.#statusResult(await this.#lifecycle.status(loopId), "loop-already-terminal", "The loop was already terminal when SEND attempted to park it.");
             }
             this.#parkDeadlines.set(loopId, -1); // indefinite: the bounded child's terminal is the wake edge
             return { status: 102, attrs: { parked: -1, join: true } };
         }
-        // {§wait-obligation-matrix} — SEND[202] is the obligation-checked join. A live
+        // {§wait-obligation-matrix} — SEND signal 202 is the obligation-checked join. A live
         // obligation (a spawned child or open stream, J) BLOCKS the loop until it concludes and
         // reawakens it ({§worker-lifecycle-child-wake}); a wait on nothing (∅) is already satisfied and
         // resolves like 200, so <-1>+∅ self-resolves rather than hang the agent; a pending own
@@ -1942,7 +2147,7 @@ class Dispatcher {
             const marks = statement.lineMarker?.marks[0];
             const seconds = typeof marks === "number" ? marks : -1; // bare 202 / absent T = indefinite, bounded by the join
             if (await this.#hasLiveWork(workerId)) {
-                if (!await this.#lifecycle.park(loopId, raw.length > 0 ? raw : "waiting on live work")) {
+                if (!await this.#lifecycle.park(loopId)) {
                     return _a.#statusResult(await this.#lifecycle.status(loopId), "loop-already-terminal", "The loop was already terminal when SEND attempted to wait.");
                 }
                 this.#parkDeadlines.set(loopId, seconds);
@@ -1952,8 +2157,8 @@ class Dispatcher {
             // all complete-but-unobserved. Their wake edge may already have
             // fired, so do not park; continue directly to the packet that
             // materializes them.
-            const observations = await this.#pendingObservations(workerId, turnId);
-            if (observations.retrievals || observations.streamTerminations || observations.childTerminations) {
+            const boundaries = await this.#nextPacketBoundaries(workerId, turnId);
+            if (boundaries.retrievals || boundaries.folds || boundaries.streamTerminations || boundaries.childTerminations) {
                 return { status: 102 };
             }
             const failCount = await this.#unobservedFailureCount(turnId);
@@ -1964,7 +2169,7 @@ class Dispatcher {
                 return branchDenial;
             // The joined set is already drained. Awaiting an empty task group completes
             // immediately; it never parks and needs no corrective model turn.
-            const finished = await this.#lifecycle.finish(loopId, { status: 200 }, { message: raw === "" ? null : raw });
+            const finished = await this.#lifecycle.finish(loopId, TerminalResult.success(raw));
             return {
                 status: finished !== null ? 200 : await this.#lifecycle.status(loopId),
                 attrs: { joined: true, pending: 0 },
@@ -2008,7 +2213,7 @@ class Dispatcher {
                     return _a.#failure("retrieval-results-unobserved", 409, "Last turn both performed retrieval operations and attempted to terminate. Retrieval operations force an additional turn so their results can be reviewed.", {}, {
                         pending: [...pending],
                         stage: "completion",
-                        recovery: "Review the results, then use only PLAN and SEND[200] to conclude.",
+                        recovery: "Review the results, then use only `# PLAN0` and `## SEND0 [200]` to conclude.",
                         retryable: false,
                     });
                 }
@@ -2022,7 +2227,7 @@ class Dispatcher {
             const branchDenial = await this.#branchCompletionGate?.(workerId) ?? null;
             if (branchDenial !== null)
                 return branchDenial;
-            const finished = await this.#lifecycle.finish(loopId, { status: 200 }, { message: raw === "" ? null : raw });
+            const finished = await this.#lifecycle.finish(loopId, TerminalResult.success(raw));
             return _a.#statusResult(finished !== null ? 200 : await this.#lifecycle.status(loopId), "loop-already-terminal", "The loop was already terminal when SEND attempted to conclude it.");
         }
         if (status === 499) {
@@ -2035,7 +2240,7 @@ class Dispatcher {
                 turn_id: turnId,
             });
             if (seqs === undefined) {
-                throw new Error(`SEND[499]: no coordinate for loop=${loopId} turn=${turnId}`);
+                throw new Error(`SEND signal 499: no coordinate for loop=${loopId} turn=${turnId}`);
             }
             Results.attachInstance(failure, `log:///${seqs.loop_seq}/${seqs.turn_seq}/${ctx.sequence}/SEND`);
             const finished = await this.#lifecycle.finish(loopId, failure);
@@ -2050,7 +2255,20 @@ class Dispatcher {
     }
     async #run(schemeName, statement, ctx) {
         if (schemeName === null) {
-            return _a.#failure("target-scheme-required", 400, `${statement.op} requires a target scheme.`, {}, { operation: statement.op, retryable: false });
+            const fields = statement.op === "READ"
+                ? { content: null, mimetype: null, channel: null }
+                : statement.op === "FIND"
+                    ? {
+                        content: null,
+                        mimetype: null,
+                        results: [],
+                        itemsTokenTotal: 0,
+                        returnedItemsTokenTotal: 0,
+                        matchingPathCount: 0,
+                        matchLocationCount: 0,
+                    }
+                    : {};
+            return _a.#failure("target-scheme-required", 400, `${statement.op} requires a target scheme.`, fields, { operation: statement.op, retryable: false });
         }
         if (statement.op === "SEND" && statement.signal === 499 && statement.target?.kind === "url") {
             const addressedScheme = statement.target.scheme;
@@ -2084,16 +2302,128 @@ class Dispatcher {
         const manifest = this.#schemes.manifestFor(schemeName);
         if (manifest === undefined)
             throw new Error(`scheme '${schemeName}' has no manifest`);
-        const schemeCtx = new SchemeCtxImpl(ctx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions);
-        if (typeof method === "function")
-            return Results.assert(await method.call(handler, statement, schemeCtx));
+        const publishedChannel = statement.target?.kind === "url"
+            ? statement.target.fragment ?? manifest.defaultChannel
+            : manifest.defaultChannel;
+        const schemeCtx = new SchemeCtxImpl(ctx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions, { publishedChannel });
+        if (statement.op === "READ"
+            && handler instanceof CoreSchemeAdapterBase
+            && typeof handler.resolveCoreRepresentation === "function") {
+            const selectionNeutralTarget = statement.target?.kind === "url"
+                ? {
+                    ...statement.target,
+                    raw: renderTarget({ ...statement.target, fragment: null }) ?? statement.target.raw,
+                    fragment: null,
+                }
+                : statement.target;
+            const resolved = await handler
+                .resolveCoreRepresentation(selectionNeutralTarget, schemeCtx);
+            if ("result" in resolved)
+                return Results.assertReadResult(resolved.result);
+            if (selectionNeutralTarget === null) {
+                throw new InvalidOperationResultError(`Core scheme '${schemeName}' resolved a targetless READ representation.`);
+            }
+            const target = renderTarget(selectionNeutralTarget.kind === "url"
+                ? selectionNeutralTarget
+                : { scheme: null, pathname: selectionNeutralTarget.raw });
+            if (target === null) {
+                throw new TypeError(`Core scheme '${schemeName}' resolved an unrenderable READ target.`);
+            }
+            return Results.assertReadResult(await ReadProjector.project({
+                statement,
+                manifest,
+                target,
+                identity: target,
+                representation: resolved.representation,
+                mimetypes: ctx.mimetypes,
+            }));
+        }
+        if (statement.op === "READ" && manifest.category === "data") {
+            const prepared = statement.target === null
+                ? { address: null, result: null }
+                : await this.#prepareDataRepresentation({
+                    target: statement.target,
+                    routedScheme: schemeName,
+                    handler: handler,
+                    manifest,
+                    ctx,
+                    schemeCtx,
+                    publishedChannel,
+                });
+            if (prepared.result !== null)
+                return prepared.result;
+            const resolved = prepared.address;
+            if (statement.target !== null && resolved === null) {
+                const target = renderTarget(statement.target.kind === "url"
+                    ? statement.target
+                    : { scheme: null, pathname: statement.target.raw });
+                return Results.failure(`scheme:${schemeName}`, "entry-not-found", 404, `No entry exists at ${target ?? "the requested address"}.`, { content: null, mimetype: null, channel: null }, { target });
+            }
+            const storageScheme = resolved?.scheme ?? manifest.storedScheme ?? addressedScheme ?? schemeName;
+            const projected = Results.assertReadResult(await EntryOps.readWorkspaceEntry(statement, ctx, { ...manifest, name: storageScheme, storedScheme: storageScheme }, resolved === null
+                ? {}
+                : {
+                    ownerId: resolved.ownerId,
+                    pathname: resolved.pathname,
+                }));
+            return projected;
+        }
         if (statement.op !== "FIND" || manifest.category !== "data") {
+            if (typeof method === "function") {
+                return Results.assert(await method.call(handler, statement, schemeCtx));
+            }
             return _a.#failure("operation-not-implemented", 501, `Scheme '${schemeName}' does not implement ${statement.op}.`, {}, {
                 scheme: schemeName,
                 operation: statement.op,
                 retryable: false,
             });
         }
+        const targetPathname = statement.target?.kind === "url"
+            ? statement.target.pathname
+            : statement.target?.raw ?? "";
+        const collectionTarget = manifest.folderScopes === true
+            && (targetPathname === "" || targetPathname.endsWith("/"));
+        const exactTarget = statement.target !== null
+            && !collectionTarget
+            && !PathSyntax.hasGlob(entryPathnameOf(statement.target));
+        if (exactTarget && statement.target !== null) {
+            const prepared = await this.#prepareDataRepresentation({
+                target: statement.target,
+                routedScheme: schemeName,
+                handler: handler,
+                manifest,
+                ctx,
+                schemeCtx,
+                publishedChannel,
+            });
+            if (prepared.result !== null)
+                return prepared.result;
+            if (prepared.address === null) {
+                const target = renderTarget(statement.target.kind === "url"
+                    ? statement.target
+                    : { scheme: null, pathname: statement.target.raw });
+                return Results.failure(`scheme:${schemeName}`, "entry-not-found", 404, `No entry exists at ${target ?? "the requested address"}.`, {
+                    content: null,
+                    mimetype: null,
+                    results: [],
+                    itemsTokenTotal: 0,
+                    returnedItemsTokenTotal: 0,
+                    matchingPathCount: 0,
+                    matchLocationCount: 0,
+                }, { target });
+            }
+            const storageScheme = prepared.address.scheme
+                ?? manifest.storedScheme
+                ?? addressedScheme
+                ?? schemeName;
+            return Results.assert(await EntryFind.findWorkspaceEntries(statement, ctx, { ...manifest, name: storageScheme, storedScheme: storageScheme }, {
+                ownerId: prepared.address.ownerId,
+                pathname: prepared.address.pathname,
+            }));
+        }
+        if (typeof method === "function") {
+            return Results.assert(await method.call(handler, statement, schemeCtx));
+        }
         const prepareFind = handler.prepareFind;
         if (typeof prepareFind === "function") {
             const prepared = await prepareFind.call(handler, statement, schemeCtx);
@@ -2105,11 +2435,14 @@ class Dispatcher {
     async #runLogCuration(statement, ctx) {
         const addressedScheme = schemeNameOf(statement.target);
         if (addressedScheme !== null && addressedScheme !== "log") {
-            return _a.#failure("operation-not-implemented", 501, `Scheme '${addressedScheme}' does not implement ${statement.op}.`, {}, {
-                scheme: addressedScheme,
-                operation: statement.op,
-                retryable: false,
-            });
+            return {
+                result: _a.#failure("operation-not-implemented", 501, `Scheme '${addressedScheme}' does not implement ${statement.op}.`, {}, {
+                    scheme: addressedScheme,
+                    operation: statement.op,
+                    retryable: false,
+                }),
+                plan: null,
+            };
         }
         const handler = this.#schemes.get("log");
         const manifest = this.#schemes.manifestFor("log");
@@ -2117,21 +2450,20 @@ class Dispatcher {
             throw new Error("the core log curation owner is not registered");
         }
         const schemeCtx = new SchemeCtxImpl(ctx, "log", manifest, this.#liveSubscriptions);
-        return statement.op === "OPEN"
-            ? Results.assert(await handler.open(statement, schemeCtx))
-            : Results.assert(await handler.fold(statement, schemeCtx));
+        const outcome = await handler.curate(statement, schemeCtx);
+        return { result: Results.assert(outcome.result), plan: outcome.plan };
     }
     // {§proposal}/{§send} — status 202 is a proposal except for broadcast
-    // SEND[202], which parks the loop. The operation disambiguates the status.
+    // SEND signal 202, which parks the loop. The operation disambiguates the status.
     static #isProposal(statement, result) {
-        // {§send-300-choices} — SEND[300] is the proposal exception.
+        // {§send-300-choices} — SEND signal 300 is the proposal exception.
         if (result.status !== 202)
             return false;
         if (statement.op === "SEND" && statement.signal === 300)
             return true;
         return !(statement.op === "SEND" && statement.target === null);
     }
-    async #writeLog({ statement, result, workspaceId, workerId, loopId, turnId, sequence, origin, }) {
+    async #writeLog({ statement, result, workspaceId, workerId, loopId, turnId, sequence, origin, curationPlan, modelCallId, }) {
         const durableStatement = DurableStatement.project(statement);
         const target = this.#extractTarget(durableStatement.target);
         await this.#canonColumns(target, workspaceId); // {§fs-answer-in-canon}
@@ -2141,12 +2473,23 @@ class Dispatcher {
         // A proposal (status 202 from a side-effecting op) is written to the log in
         // state='proposed' until the proposal lifecycle resolves it; attrs holds the
         // scheme-supplied payload (file diff, exec command, etc.) the client renders
-        // for review and the scheme consumes on accept. A broadcast SEND[202] is a
+        // for review and the scheme consumes on accept. A broadcast SEND signal 202 is a
         // parked-terminal, not a proposal (#isProposal) → state='resolved'.
         const isProposed = _a.#isProposal(statement, result);
         let attrsObj = (result.attrs !== undefined && result.attrs !== null)
             ? { ...result.attrs }
             : {};
+        if (curationPlan !== null) {
+            if (Object.hasOwn(attrsObj, "__plurnk_curation")) {
+                throw new Error("Dispatcher.#writeLog: result attrs collide with private log curation state");
+            }
+            attrsObj.__plurnk_curation = {
+                ids: curationPlan.targetLogEntryIds,
+                expanded: curationPlan.expanded,
+                add: curationPlan.add,
+                remove: curationPlan.remove,
+            };
+        }
         const seqs = statement.op === "EXEC" || result.problem !== undefined
             ? await this.#db.engine_loop_turn_seqs.get({
                 loop_id: loopId,
@@ -2197,6 +2540,7 @@ class Dispatcher {
             sequence: sequence,
             origin,
             source: null, // dispatch entries are self-authored; {§env-delta} deltas set this
+            model_call_id: modelCallId,
             op: durableStatement.op,
             suffix: durableStatement.suffix,
             signal: this.#signalToJson(durableStatement.signal),