@plurnk/plurnk-service 1.5.0 → 1.6.1

package/dist/core/Dispatcher.js

@@ -5,11 +5,11 @@ 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 { 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, ReadProjector, projectEditReceipt, } from "../content/index.js";
+import { ReadProjector } from "../content/index.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
 import EntryCrud from "../schemes/_entry-crud.js";
 import EntryOps from "../schemes/_entry-ops.js";
@@ -23,12 +23,23 @@ import EffectPolicy from "../schemes/EffectPolicy.js";
 import { CoreSchemeAdapterBase, } from "./CoreSchemeServices.js";
 import { InvalidOperationResultError, NetworkAddress, } from "@plurnk/plurnk-schemes";
 import DurableStatement from "./DurableStatement.js";
+import ResourceMutations from "./ResourceMutations.js";
+import LogBody from "./LogBody.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"]);
-// Op dispatch ({§op-methods-op-dispatch}): gates (writableBy, loop flags), the
-// engine-owned op orchestrations (COPY/MOVE/KILL/SEND), scheme
-// routing, the durable log write, and the proposal pause.
+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}): admission, operation-owner routing,
+// durable log writing, and proposal lifecycle.
 class Dispatcher {
     static #failure(code, status, detail, fields = {}, extensions = {}) {
         return Results.failure("engine:dispatcher", code, status, detail, fields, extensions);
@@ -41,7 +52,7 @@ class Dispatcher {
     #db;
     #schemes;
     #mimetypes;
-    #tokenize;
+    #weighContent;
     #notices;
     #proposals;
     // Boot-discovered runtime executors, late-injected on Engine — thunked.
@@ -55,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;
@@ -63,12 +74,12 @@ class Dispatcher {
     #joinTargets;
     #liveSubscriptions;
     #lifecycle;
-    #preparedEdits = new WeakMap();
-    constructor({ db, schemes, mimetypes, tokenize, notices, proposals, executors, loopSignal, streamEventNotify, wakeWorkerNotify, injectWorker, branchWorker, branchCompletionGate, cancelWorker, cancelDescendants, searchGate, parkDeadlines, joinTargets, liveSubscriptions }) {
+    #resourceMutations;
+    constructor({ db, schemes, mimetypes, weigh, notices, proposals, executors, loopSignal, streamEventNotify, wakeWorkerNotify, injectWorker, branchWorker, branchCompletionGate, cancelWorker, cancelDescendants, searchGate, parkDeadlines, joinTargets, liveSubscriptions }) {
         this.#db = db;
         this.#schemes = schemes;
         this.#mimetypes = mimetypes;
-        this.#tokenize = tokenize;
+        this.#weighContent = weigh;
         this.#notices = notices;
         this.#proposals = proposals;
         this.#executors = executors;
@@ -85,6 +96,23 @@ class Dispatcher {
         this.#joinTargets = joinTargets ?? new Set();
         this.#liveSubscriptions = liveSubscriptions;
         this.#lifecycle = new LoopLifecycle(db);
+        this.#resourceMutations = new ResourceMutations({
+            schemes,
+            liveSubscriptions,
+            run: (schemeName, statement, ctx) => this.#run(schemeName, statement, ctx),
+            checkWritable: (statement, origin) => this.#checkWritable(statement, origin),
+            checkFlagsGate: (statement, loopId) => this.#checkFlagsGate(statement, loopId),
+            editTargetIdentity: (statement, workspaceId) => this.#editTargetIdentity(statement, workspaceId),
+            canonicalFilePath: (pathname, workspaceId) => this.#canonicalFilePath(pathname, workspaceId),
+            prepareDataRepresentation: (args) => this.#prepareDataRepresentation({
+                ...args,
+                handler: args.handler,
+            }),
+            readEntry: (scheme, pathname, ctx) => this.#readEntry(scheme, pathname, ctx),
+            writeEntry: (scheme, pathname, entry, ctx) => this.#writeEntry(scheme, pathname, entry, ctx),
+            deleteChannel: (scheme, pathname, channel, ctx) => this.#deleteChannel(scheme, pathname, channel, ctx),
+            applyProposal: (statement, result, resolution, ids) => this.#proposals.workerApply(statement, result, resolution, ids),
+        });
     }
     // workspace → project_root, memoized: {§fs-namespace} fixes the root immutably at
     // workspace creation, so a process-lifetime cache can never go stale.
@@ -124,7 +152,12 @@ 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) {
@@ -197,113 +230,35 @@ class Dispatcher {
         if (key !== null)
             target.pathname = key;
     }
-    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) {
-            const target = this.#extractTarget(statement.target);
-            await this.#canonColumns(target, workspaceId);
-            const key = JSON.stringify([
+    async #canonicalFilePath(pathname, workspaceId) {
+        return Namespace.canonicalizeSpelling(pathname, await this.#workspaceRoot(workspaceId));
+    }
+    async #editTargetIdentity(statement, workspaceId) {
+        const target = this.#extractTarget(statement.target);
+        await this.#canonColumns(target, workspaceId);
+        return {
+            key: JSON.stringify([
                 schemeNameOf(statement.target),
                 target.scheme,
                 target.hostname,
                 target.pathname,
                 target.fragment,
-            ]);
-            const group = groups.get(key);
-            if (group === undefined)
-                groups.set(key, [statement]);
-            else
-                group.push(statement);
-        }
-        for (const group of groups.values()) {
-            const first = group[0];
-            const schemeName = schemeNameOf(first.target);
-            let initial;
-            let denial = group.map((statement) => this.#checkWritable(statement, origin)).find((result) => result !== null) ?? null;
-            if (denial === null) {
-                for (const statement of group) {
-                    denial = await this.#checkFlagsGate(statement, loopId);
-                    if (denial !== null)
-                        break;
-                }
-            }
-            if (denial !== null) {
-                initial = denial;
-            }
-            else if (schemeName === null) {
-                initial = _a.#failure("target-required", 400, "EDIT requires a target scheme.", {}, { retryable: false });
-            }
-            else {
-                const handler = this.#schemes.get(schemeName);
-                const method = handler?.editBatch;
-                const manifest = this.#schemes.manifestFor(schemeName);
-                if (typeof method !== "function" || manifest === undefined) {
-                    initial = _a.#failure("operation-not-implemented", 501, `Scheme '${schemeName}' does not implement EDIT batches.`, {}, {
-                        scheme: schemeName,
-                        operation: "EDIT",
-                        retryable: false,
-                    });
-                }
-                else {
-                    try {
-                        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, group, new SchemeCtxImpl(schemeCtx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions, { publishedChannel })));
-                    }
-                    catch (err) {
-                        if (err instanceof InvalidOperationResultError)
-                            throw err;
-                        console.error(`Scheme '${schemeName}' EDIT batch threw outside its operation result contract:`, err);
-                        initial = _a.#failure("scheme-handler-threw", 500, `The '${schemeName}' scheme did not produce an EDIT result.`, {}, {
-                            stage: "scheme-dispatch",
-                            scheme: schemeName,
-                            operation: "EDIT",
-                        });
-                    }
-                }
-            }
-            let resolveSettled;
-            const settled = new Promise((resolve) => { resolveSettled = resolve; });
-            const candidate = initial.editReceipt;
-            const expectedNormalizations = group.filter(({ lineMarker }) => lineMarker?.marks.length === 3).length;
-            if (initial.status < 400
-                && (initial.scopeNormalizations?.length ?? 0) !== expectedNormalizations) {
-                throw new InvalidOperationResultError(`EDIT batch normalized ${initial.scopeNormalizations?.length ?? 0} scope(s), expected ${expectedNormalizations}.`);
-            }
-            const batch = {
-                initial,
-                settled,
-                aggregate: candidate === undefined || candidate === null
-                    ? undefined
-                    : assertEditBatchReceipt(candidate),
-                settle: resolveSettled,
-            };
-            let normalizationIndex = 0;
-            for (const [index, statement] of group.entries()) {
-                const ownsNormalization = statement.lineMarker?.marks.length === 3 && initial.status < 400;
-                this.#preparedEdits.set(statement, {
-                    first: index === 0,
-                    index,
-                    normalizationIndex: ownsNormalization ? normalizationIndex++ : null,
-                    batch,
-                });
-            }
-        }
+            ]),
+            identity: renderTarget(target),
+        };
+    }
+    async prepareEditBatches(statements, context) {
+        for (const statement of statements)
+            assertClassifyingSignal(statement); // {§log-tag-signal}
+        const { workspaceId, workerId, loopId, turnId, origin } = context;
+        const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId, turnId, origin });
+        await this.#resourceMutations.prepareEditBatches(statements, context, schemeCtx);
     }
     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);
-            if (prepared?.first === true) {
-                const normalizations = prepared.batch.initial.scopeNormalizations;
-                prepared.batch.settle(normalizations === undefined
-                    ? result
-                    : Results.assert({ ...result, scopeNormalizations: normalizations }));
-            }
+            this.#resourceMutations.settleEdit(context.statement, result);
         }
         return result;
     }
@@ -311,6 +266,7 @@ class Dispatcher {
         const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, } = context;
         const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId, turnId, origin });
         let result;
+        let curationPlan = null;
         let denial = this.#checkWritable(statement, origin);
         if (denial === null)
             denial = await this.#checkFlagsGate(statement, loopId);
@@ -325,49 +281,24 @@ class Dispatcher {
             // those are system failures.
             try {
                 if (statement.op === "EDIT") {
-                    const prepared = this.#preparedEdits.get(statement);
-                    if (prepared === undefined) {
-                        throw new InvalidOperationResultError("EDIT reached dispatch without a prepared resource batch.");
-                    }
-                    else {
-                        const settled = prepared.first
-                            ? prepared.batch.initial
-                            : await prepared.batch.settled;
-                        const normalization = prepared.normalizationIndex === null
-                            ? undefined
-                            : settled.scopeNormalizations?.[prepared.normalizationIndex];
-                        const { scopeNormalizations: _scopeNormalizations, ...projectedSettlement } = settled;
-                        const statementResult = normalization === undefined
-                            ? projectedSettlement
-                            : { ...projectedSettlement, scopeNormalizations: [normalization] };
-                        const aggregate = prepared.batch.aggregate;
-                        if (aggregate !== undefined) {
-                            const receipt = assertEditBatchReceipt(aggregate);
-                            const { editReceipt: _editReceipt, ...withoutAggregate } = statementResult;
-                            result = {
-                                ...withoutAggregate,
-                                receipt: projectEditReceipt(receipt, prepared.index),
-                            };
-                        }
-                        else {
-                            result = statementResult;
-                        }
-                    }
+                    result = await this.#resourceMutations.preparedEditResult(statement);
                 }
                 else if (statement.op === "SEND" && statement.target === null) {
                     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);
                 }
                 else if (statement.op === "COPY") {
-                    result = await this.#handleCopy(statement, schemeCtx);
+                    result = await this.#resourceMutations.handleCopy(statement, schemeCtx);
                 }
                 else if (statement.op === "MOVE") {
-                    result = await this.#handleMove(statement, schemeCtx);
+                    result = await this.#resourceMutations.handleMove(statement, schemeCtx);
                 }
                 else if (statement.op === "KILL") {
                     result = await this.#handleKill(statement, schemeCtx);
@@ -376,10 +307,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 {
@@ -406,19 +335,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,
@@ -438,15 +378,13 @@ class Dispatcher {
             }
             if (autoAccept) {
                 const initialSettlement = await this.#proposals.workerApply(statement, result, { decision: "accept" }, { workspaceId, workerId, loopId, turnId });
-                const settlement = _a.#settleProposalEffects(result, initialSettlement);
-                const effective = await this.#settleMoveProposal({
+                const effective = await this.#resourceMutations.settleProposal({
                     statement,
                     result,
-                    settlement,
+                    settlement: initialSettlement,
                     ctx: schemeCtx,
                     ids: { workspaceId, workerId, loopId, turnId },
                 });
-                this.#recordEditSettlement(statement, effective);
                 return this.#proposals.applyResolution(logEntryId, effective);
             }
             // Register the resolution waiter SYNCHRONOUSLY before any await
@@ -475,15 +413,13 @@ class Dispatcher {
             // 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, loopId, turnId });
-            const settlement = _a.#settleProposalEffects(result, initialSettlement);
-            const effective = await this.#settleMoveProposal({
+            const effective = await this.#resourceMutations.settleProposal({
                 statement,
                 result,
-                settlement,
+                settlement: initialSettlement,
                 ctx: schemeCtx,
                 ids: { workspaceId, workerId, loopId, turnId },
             });
-            this.#recordEditSettlement(statement, effective);
             const post = await this.#proposals.applyResolution(logEntryId, effective);
             return post;
         }
@@ -660,7 +596,7 @@ class Dispatcher {
             wakeWorkerNotify: this.#wakeWorkerNotify,
             injectWorker: this.#injectWorker,
             mimetypes: this.#mimetypes,
-            tokenize: this.#tokenize,
+            weigh: this.#weighContent,
             pushNotice: (notice) => this.#notices.push(workspaceId, loopId, notice),
             executors: this.#executors(),
         };
@@ -676,8 +612,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);
         }
@@ -709,8 +645,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,
@@ -817,19 +753,24 @@ 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);
         }
         return check(statement.target);
     }
     // 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 #handleCopy
+    // 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)
@@ -906,45 +847,6 @@ class Dispatcher {
         await ctx.injectWorker({ workspaceId: ctx.workspaceId, workerId: row.id, prompt, flags, parentLoopId: ctx.loopId });
         return { status: 200, body: name };
     }
-    async #handleCopy(statement, ctx) {
-        if (statement.target === null) {
-            return _a.#failure("copy-source-required", 400, "COPY requires a source path.", {}, { retryable: false });
-        }
-        if (statement.body === null) {
-            return _a.#failure("copy-destination-required", 400, "COPY requires a destination.", {}, { retryable: false });
-        }
-        return this.#copyOrchestration({
-            statement,
-            source: {
-                target: statement.target,
-                lineMarker: statement.lineMarker,
-            },
-            destination: statement.body,
-            ctx,
-        });
-    }
-    async #handleMove(statement, ctx) {
-        if (statement.target === null) {
-            return _a.#failure("move-source-required", 400, "MOVE requires a source path.", {}, { retryable: false });
-        }
-        // MOVE is relocation only - deletion is KILL's job ({§move}, {§move-dev-null-not-special}). The /dev/null
-        // and null-body delete-by-MOVE has no alternate meaning.
-        if (statement.body === null) {
-            return _a.#failure("move-destination-required", 400, "MOVE requires a destination.", {}, {
-                recovery: "Use KILL when the intended operation is deletion.",
-                retryable: false,
-            });
-        }
-        return this.#moveOrchestration({
-            statement,
-            source: {
-                target: statement.target,
-                lineMarker: statement.lineMarker,
-            },
-            destination: statement.body,
-            ctx,
-        });
-    }
     // KILL is target-polymorphic. Scheme handlers own the optional numeric code's
     // meaning; core retains worker and entry dispatch. {§operation-code-polymorphism}
     async #handleKill(statement, ctx) {
@@ -1014,35 +916,59 @@ class Dispatcher {
         // carries the delete target to review (#isProposal fires on 202). Plurnk-internal deletes execute inline.
         return this.#deleteEntry(schemeName, entryPathnameOf(path), ctx);
     }
-    // {§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.
-    // 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", admission = "accepted", reasoningItems }) {
+    async #writeActionlessEntry({ verbatim, workerId, loopId, turnId, sequence, origin, kind, folded, modelCallId = null, attrs = {} }) {
+        const durableAttrs = { ...attrs, kind };
+        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, op: null, 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" }),
+            rx,
             mimetype_rx: "application/json",
-            status_rx: 200, tokens: this.#tokenize(verbatim), state: "resolved", outcome: null,
-            attrs: JSON.stringify({
-                kind: "model_emission",
-                ...(admission === "rejected" ? { admission } : {}),
-                ...(reasoningItems !== undefined && reasoningItems.length > 0 ? { reasoning: reasoningItems } : {}),
-            }),
+            status_rx: 200,
+            weight: LogBody.weight({
+                op: null,
+                attrs: durableAttrs,
+                tx: "",
+                rx,
+                mimetypeTx: "text/vnd.plurnk",
+                mimetypeRx: "application/json",
+            }, this.#weighContent),
+            state: "resolved", outcome: null,
+            attrs: JSON.stringify(durableAttrs),
         });
         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.
@@ -1051,732 +977,24 @@ class Dispatcher {
             throw new Error("unreachable");
         return { status: 200 };
     }
-    static #isDispatchResult(value) {
-        return "status" in value;
-    }
-    async #resolveResourceSelection(selection, ctx) {
-        const { target, lineMarker } = selection;
-        const scheme = schemeNameOf(target);
-        if (scheme === null) {
-            return _a.#failure("resource-scheme-required", 400, "COPY and MOVE resources require a scheme.", {}, { retryable: false });
-        }
-        if (target.kind === "url" && target.scheme === "worker" && (target.hostname ?? "") !== "") {
-            return _a.#failure("worker-copy-address-invalid", 400, "COPY and MOVE do not address named worker spaces.", {}, {
-                recovery: "Move worker-space content with READ and EDIT.",
-                retryable: false,
-            });
-        }
-        const handler = this.#schemes.get(scheme);
-        const manifest = this.#schemes.manifestFor(scheme);
-        if (handler === undefined || manifest === undefined) {
-            return _a.#failure("scheme-not-found", 501, `COPY or MOVE addressed the unregistered scheme '${scheme}'.`, {}, {
-                scheme,
-                retryable: false,
-            });
-        }
-        if (manifest.category !== "data") {
-            return _a.#failure("entry-operation-unsupported", 400, `COPY and MOVE require entry-bearing resources; '${scheme}' is a ${manifest.category} scheme.`, {}, {
-                scheme,
-                category: manifest.category,
-                retryable: false,
-            });
-        }
-        const fragment = target.kind === "url" ? target.fragment : null;
-        const channel = fragment ?? manifest.defaultChannel;
-        if (channel.length === 0) {
-            return _a.#failure("channel-required", 400, `The '${scheme}' scheme has no default channel.`, {}, {
-                scheme,
-                recovery: "Address a named channel with a URI fragment.",
-                retryable: false,
-            });
-        }
-        if (fragment !== null
-            && fragment !== manifest.defaultChannel
-            && !Object.hasOwn(manifest.channels, fragment)) {
-            const availableChannels = [
-                ...new Set([manifest.defaultChannel, ...Object.keys(manifest.channels)]),
-            ].filter((candidate) => candidate.length > 0);
-            return _a.#failure("channel-not-found", 400, `Channel #${fragment} is not declared by the '${scheme}' scheme.`, {}, {
-                requestedChannel: fragment,
-                availableChannels,
-                retryable: false,
-            });
-        }
-        const pathname = entryPathnameOf(target);
-        const canonicalFilePath = scheme === "file"
-            ? Namespace.canonicalizeSpelling(pathname, await this.#workspaceRoot(ctx.workspaceId))
-            : pathname;
-        return {
-            target,
-            lineMarker,
-            scheme,
-            pathname,
-            identityPathname: canonicalFilePath ?? pathname,
-            channel,
-            manifest,
-        };
-    }
-    async #selectSource(selection, ctx) {
-        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) {
-            throw new InvalidOperationResultError(`The '${selection.scheme}' scheme returned status ${read.status} without a COPY/MOVE source entry.`);
-        }
-        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(storageAddress.scheme, storageAddress.pathname)}.`, {}, {
-                target: renderAddress(storageAddress.scheme, storageAddress.pathname),
-                requestedChannel: selection.channel,
-                availableChannels: Object.keys(read.entry.channels),
-                retryable: false,
-            });
-        }
-        let content = selected.content;
-        let scopeNormalizations;
-        if (await MimetypeBinary.isBinaryMimetype(selected.mimetype, ctx.mimetypes)) {
-            return _a.#failure("binary-source-unsupported", 415, `Channel #${selection.channel} is a binary marker and cannot be copied or moved.`, {}, {
-                channel: selection.channel,
-                mimetype: selected.mimetype,
-                recovery: "Use a source with a readable text projection.",
-                retryable: false,
-            });
-        }
-        if (selection.lineMarker !== null) {
-            const sliced = LineMarkerOps.sliceLinesRaw(content, 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,
-            storageAddress,
-            content,
-            mimetype: selected.mimetype,
-            ...(scopeNormalizations === undefined ? {} : { scopeNormalizations }),
-        };
-    }
-    static #prependScopeNormalizations(result, scopeNormalizations) {
-        if (scopeNormalizations === undefined)
-            return result;
-        return Results.assert({
-            ...result,
-            scopeNormalizations: [
-                ...scopeNormalizations,
-                ...(result.scopeNormalizations ?? []),
-            ],
-        });
-    }
-    #resourceAddress(selection) {
-        const address = renderTarget({
-            scheme: selection.scheme === "file" ? null : selection.scheme,
-            pathname: selection.scheme === "file"
-                ? selection.identityPathname.replace(/^\//, "")
-                : selection.identityPathname,
-            fragment: selection.channel === selection.manifest.defaultChannel
-                ? null
-                : selection.channel,
+    // {§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,
         });
-        if (address === null)
-            throw new Error("resolved resource selection has no renderable address");
-        return address;
-    }
-    #pendingEffect(selection, action) {
-        return {
-            target: this.#resourceAddress(selection),
-            action,
-        };
-    }
-    static #appliedEffects(result, pending) {
-        // {§edit-result-copy-move-effects} — only an applied mutation earns
-        // engine-composed effects; native scheme receipts remain internal input.
-        const exact = Results.assert(result);
-        if (exact.status === 304 || exact.status === 202 || exact.status >= 300)
-            return exact;
-        if (exact.effects !== undefined) {
-            throw new InvalidOperationResultError("A COPY/MOVE mutation result supplied effects before engine composition.");
-        }
-        const batch = exact.editReceipt === undefined
-            ? undefined
-            : assertEditBatchReceipt(exact.editReceipt);
-        const single = batch === undefined && exact.receipt !== undefined
-            ? assertEditReceipt(exact.receipt)
-            : undefined;
-        const batchSize = batch === undefined
-            ? undefined
-            : "disposition" in batch
-                ? batch.superseded.length
-                : batch.effects.length;
-        if (batchSize !== undefined && batchSize !== pending.length) {
-            throw new InvalidOperationResultError(`COPY/MOVE expected ${pending.length} receipt projections, got ${batchSize}.`);
-        }
-        if (single !== undefined && pending.length !== 1) {
-            throw new InvalidOperationResultError(`COPY/MOVE received one receipt for ${pending.length} resource effects.`);
-        }
-        let effects;
-        if (batch !== undefined && "disposition" in batch) {
-            const replacement = pending[0];
-            if (replacement === undefined) {
-                throw new InvalidOperationResultError("A reviewer-replaced COPY/MOVE batch has no resource effect.");
-            }
-            if (pending.some(({ target, action }) => target !== replacement.target || action !== replacement.action)) {
-                throw new InvalidOperationResultError("A reviewer-replaced COPY/MOVE batch spans incompatible resource effects.");
-            }
-            effects = [{
-                    ...replacement,
-                    receipt: projectEditReceipt(batch, 0),
-                }];
-        }
-        else {
-            effects = pending.map((effect, index) => ({
-                ...effect,
-                ...(batch !== undefined
-                    ? { receipt: projectEditReceipt(batch, index) }
-                    : single !== undefined
-                        ? { receipt: single }
-                        : {}),
-            }));
-        }
-        assertResourceEffects(effects);
-        const { editReceipt: _editReceipt, receipt: _receipt, ...withoutInternalReceipts } = exact;
-        return {
-            ...withoutInternalReceipts,
-            effects,
-        };
-    }
-    // {§copy-move-observation} {§edit-result-copy-move-effects} — scoped
-    // COPY/MOVE into an unscoped channel is a text materialization even when
-    // CRUD creates the channel wholesale. Carry the receipt through synchronous
-    // writes and proposals; the destination scheme owns reviewed output.
-    static #withEditMaterialization(result, receipt) {
-        const exact = Results.assert(result);
-        if (exact.status !== 200 && exact.status !== 201 && exact.status !== 202)
-            return exact;
-        const materialized = exact.editReceipt === undefined
-            ? assertEditBatchReceipt(receipt)
-            : assertEditBatchReceipt(exact.editReceipt);
-        return {
-            ...exact,
-            editReceipt: materialized,
-            ...(exact.status === 202
-                ? {
-                    attrs: {
-                        ...exact.attrs,
-                        editReceipt: materialized,
-                    },
-                }
-                : {}),
-        };
-    }
-    #finalizeEffects(result, selection, pending) {
-        const routed = this.#withProposalRoute(result, selection);
-        if (routed.status !== 202)
-            return _a.#appliedEffects(routed, pending);
-        return {
-            ...routed,
-            attrs: {
-                ...routed.attrs,
-                proposalEffects: pending,
-            },
-        };
-    }
-    static #effectsOf(result) {
-        return result.effects === undefined
-            ? []
-            : assertResourceEffects(result.effects);
-    }
-    static #withCombinedEffects(result, ...additional) {
-        const existing = _a.#effectsOf(result);
-        const effects = [...existing, ...additional.flat()];
-        const { effects: _effects, ...withoutEffects } = result;
-        return effects.length === 0
-            ? withoutEffects
-            : { ...withoutEffects, effects: assertResourceEffects(effects) };
-    }
-    static #settleProposalEffects(original, settlement) {
-        const pending = original.attrs
-            ?.proposalEffects;
-        if (pending === undefined
-            || settlement.resolution.decision !== "accept"
-            || settlement.applied === undefined
-            || settlement.applied.status >= 300) {
-            return settlement;
-        }
-        const projected = settlement.resolution.result ?? {};
-        const aggregate = settlement.applied.editReceipt;
-        const applied = _a.#appliedEffects({
-            ...projected,
-            status: settlement.applied.status,
-            ...(aggregate === undefined ? {} : { editReceipt: aggregate }),
-        }, pending);
-        const { status: _status, body: _body, ...result } = applied;
-        const { body: _resolutionBody, ...resolution } = settlement.resolution;
-        return {
-            ...settlement,
-            resolution: {
-                ...resolution,
-                result,
-            },
-        };
-    }
-    #recordEditSettlement(statement, settlement) {
-        if (statement.op !== "EDIT")
-            return;
-        const prepared = this.#preparedEdits.get(statement);
-        if (prepared === undefined || !prepared.first) {
-            throw new InvalidOperationResultError("An EDIT proposal settled without its prepared batch owner.");
-        }
-        const { resolution, applied } = settlement;
-        if (resolution.decision !== "accept"
-            || applied === undefined
-            || applied.status >= 300) {
-            prepared.batch.aggregate = undefined;
-            return;
-        }
-        if (applied.editReceipt === null) {
-            prepared.batch.aggregate = undefined;
-            return;
-        }
-        if (applied.editReceipt !== undefined) {
-            prepared.batch.aggregate = assertEditBatchReceipt(applied.editReceipt);
-            return;
-        }
-        if (resolution.body !== undefined)
-            prepared.batch.aggregate = undefined;
-    }
-    static #settlementEffects(settlement) {
-        const effects = settlement.resolution.result
-            ?.effects;
-        return effects === undefined ? [] : assertResourceEffects(effects);
-    }
-    static #withSettlementEffects(settlement, effects) {
-        const projected = (settlement.resolution.result ?? {});
-        const { effects: _effects, ...withoutEffects } = projected;
-        const result = effects.length === 0
-            ? withoutEffects
-            : {
-                ...withoutEffects,
-                effects: assertResourceEffects(effects),
-            };
-        return {
-            ...settlement,
-            resolution: {
-                ...settlement.resolution,
-                result,
-            },
-        };
-    }
-    #sameChannel(left, right) {
-        return left.scheme === right.scheme
-            && left.identityPathname === right.identityPathname
-            && left.channel === right.channel;
-    }
-    #withProposalRoute(result, selection) {
-        if (result.status !== 202)
-            return result;
-        return {
-            ...result,
-            attrs: {
-                ...result.attrs,
-                proposalScheme: selection.scheme,
-                proposalTarget: {
-                    scheme: selection.scheme,
-                    pathname: selection.identityPathname,
-                },
-            },
-        };
-    }
-    async #invokeEditBatch(selection, edits, ctx) {
-        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.`, {}, {
-                scheme: selection.scheme,
-                operation: "EDIT",
-                retryable: false,
-            });
-        }
-        const statements = edits.map(({ marker, body, tags, position }) => ({
-            op: "EDIT",
-            suffix: "",
-            signal: tags,
-            target: selection.target,
-            lineMarker: marker,
-            body,
-            position,
-        }));
-        const addressedScheme = selection.target.kind === "url"
-            ? selection.target.scheme
-            : selection.scheme;
-        try {
-            const result = Results.assert(await handler.editBatch(statements, new SchemeCtxImpl(ctx, addressedScheme, selection.manifest, this.#liveSubscriptions)));
-            return this.#withProposalRoute(result, selection);
-        }
-        catch (err) {
-            if (err instanceof InvalidOperationResultError)
-                throw err;
-            console.error(`Scheme '${selection.scheme}' COPY/MOVE edit threw outside its operation result contract:`, err);
-            return _a.#failure("scheme-handler-threw", 500, `The '${selection.scheme}' scheme did not produce a COPY/MOVE edit result.`, {}, {
-                stage: "scheme-dispatch",
-                scheme: selection.scheme,
-                operation: "EDIT",
-            });
-        }
-    }
-    async #writeDestination(statement, source, destination, ctx) {
-        const existingResult = await this.#readEntry(destination.scheme, destination.pathname, ctx);
-        if (existingResult.status >= 400 && existingResult.status !== 404) {
-            return existingResult;
-        }
-        const existing = existingResult.status === 200
-            ? existingResult.entry
-            : null;
-        if (existingResult.status === 200 && existing === null) {
-            throw new InvalidOperationResultError(`The '${destination.scheme}' scheme returned 200 without a destination entry.`);
-        }
-        const destinationChannel = existing?.channels[destination.channel];
-        const expectedMimetype = destinationChannel?.mimetype
-            ?? await PathMimetype.resolveEntryMimetype(destination.pathname, destination.manifest.channels[destination.channel] ?? source.mimetype, ctx.mimetypes);
-        if (source.mimetype !== expectedMimetype) {
-            return _a.#failure("mimetype-mismatch", 415, `COPY or MOVE cannot write '${source.mimetype}' into a '${expectedMimetype}' channel.`, {}, {
-                channel: destination.channel,
-                sourceMimetype: source.mimetype,
-                destinationMimetype: expectedMimetype,
-                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) {
-                return _a.#failure("destination-region-not-found", 404, `A destination region requires an existing #${destination.channel} channel.`, {}, {
-                    destination: this.#resourceAddress(destination),
-                    retryable: false,
-                });
-            }
-            if (await MimetypeBinary.isBinaryMimetype(destinationChannel.mimetype, ctx.mimetypes)) {
-                return _a.#failure("binary-region-unsupported", 415, `Channel #${destination.channel} is binary and cannot receive a textual region.`, {}, {
-                    channel: destination.channel,
-                    mimetype: destinationChannel.mimetype,
-                    retryable: false,
-                });
-            }
-            const edited = await this.#invokeEditBatch(destination, [{
-                    marker: destination.lineMarker,
-                    body: source.content,
-                    tags,
-                    position: statement.position,
-                }], ctx);
-            return this.#finalizeEffects(edited, destination, [destinationEffect]);
-        }
-        if (destinationChannel !== undefined
-            && destinationChannel.content !== source.content) {
-            return _a.#failure("copy-destination-exists", 409, `COPY or MOVE destination ${this.#resourceAddress(destination)} already contains different content.`, {}, {
-                destination: this.#resourceAddress(destination),
-                retryable: false,
-            });
-        }
-        const priorTags = existing?.tags ?? [];
-        const mergedTags = [...new Set([...priorTags, ...tags])];
-        const addsTags = mergedTags.length !== priorTags.length;
-        if (destinationChannel !== undefined && !addsTags)
-            return { status: 304 };
-        const channels = {
-            ...(existing?.channels ?? {}),
-            [destination.channel]: {
-                content: source.content,
-                mimetype: source.mimetype,
-            },
-        };
-        const written = await this.#writeEntry(destination.scheme, destination.pathname, { channels, tags: mergedTags }, ctx);
-        const exactWritten = Results.assert(written);
-        const materialized = source.lineMarker === null
-            || (exactWritten.status !== 200 && exactWritten.status !== 201 && exactWritten.status !== 202)
-            ? exactWritten
-            : _a.#withEditMaterialization(exactWritten, editReceipt(destinationChannel?.content ?? "", source.content, [{
-                    marker: { marks: [1, -1] },
-                    body: source.content,
-                }]));
-        return this.#finalizeEffects(materialized, destination, [destinationEffect]);
-    }
-    async #copyOrchestration({ statement, source, destination, ctx, }) {
-        const resolvedSource = await this.#resolveResourceSelection(source, ctx);
-        if (_a.#isDispatchResult(resolvedSource))
-            return resolvedSource;
-        const resolvedDestination = await this.#resolveResourceSelection(destination, ctx);
-        if (_a.#isDispatchResult(resolvedDestination))
-            return resolvedDestination;
-        const selected = await this.#selectSource(resolvedSource, ctx);
-        if (_a.#isDispatchResult(selected))
-            return selected;
-        const result = await this.#writeDestination(statement, selected, resolvedDestination, ctx);
-        return _a.#prependScopeNormalizations(result, selected.scopeNormalizations);
-    }
-    #deferredMoveSource(source, destination) {
-        return {
-            target: source.target,
-            lineMarker: source.lineMarker,
-            scheme: source.scheme,
-            pathname: source.pathname,
-            channel: source.channel,
-            destination: this.#resourceAddress(destination),
-        };
-    }
-    #moveFailureAfterDestination(result, destination, destinationEffects) {
-        const exact = Results.assert(result);
-        if (exact.status < 400) {
-            throw new InvalidOperationResultError("A successful MOVE source result was classified as a partial failure.");
-        }
-        if (exact.problem === undefined) {
-            throw new InvalidOperationResultError("A failed MOVE source mutation has no Problem Details.");
-        }
-        const failed = Results.assert({
-            ...exact,
-            problem: {
-                ...exact.problem,
-                operation: "MOVE",
-                destinationWritten: true,
-                destination,
-            },
-        });
-        return _a.#withCombinedEffects(failed, destinationEffects);
-    }
-    async #removeMoveSource(statement, source, ctx) {
-        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);
-            return this.#finalizeEffects(Results.assert(deleted), source, [effect]);
-        }
-        const edited = await this.#invokeEditBatch(source, [{
-                marker: source.lineMarker,
-                body: "",
-                tags: null,
-                position: statement.position,
-            }], ctx);
-        return this.#finalizeEffects(edited, source, [effect]);
-    }
-    async #moveWithinChannel(statement, source, destination, ctx) {
-        if (source.lineMarker === null) {
-            if (destination.lineMarker !== null) {
-                return _a.#failure("move-region-overlap", 409, "MOVE cannot insert a whole channel into itself and then remove that channel.", {}, {
-                    source: this.#resourceAddress(source),
-                    destination: this.#resourceAddress(destination),
-                    retryable: false,
-                });
-            }
-            return this.#writeDestination(statement, source, destination, ctx);
-        }
-        if (destination.lineMarker === null) {
-            return this.#writeDestination(statement, source, destination, ctx);
-        }
-        const moved = await this.#invokeEditBatch(destination, [
-            {
-                marker: destination.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]);
-    }
-    async #moveOrchestration({ statement, source, destination, ctx, }) {
-        const resolvedSource = await this.#resolveResourceSelection(source, ctx);
-        if (_a.#isDispatchResult(resolvedSource))
-            return resolvedSource;
-        const resolvedDestination = await this.#resolveResourceSelection(destination, ctx);
-        if (_a.#isDispatchResult(resolvedDestination))
-            return resolvedDestination;
-        const selected = await this.#selectSource(resolvedSource, ctx);
-        if (_a.#isDispatchResult(selected))
-            return selected;
-        if (this.#sameChannel(resolvedSource, resolvedDestination)) {
-            const result = await this.#moveWithinChannel(statement, selected, resolvedDestination, ctx);
-            return resolvedDestination.lineMarker === null
-                ? _a.#prependScopeNormalizations(result, selected.scopeNormalizations)
-                : result;
-        }
-        const destinationResult = _a.#prependScopeNormalizations(await this.#writeDestination(statement, selected, resolvedDestination, ctx), selected.scopeNormalizations);
-        if (destinationResult.status >= 400)
-            return destinationResult;
-        const destinationAddress = this.#resourceAddress(resolvedDestination);
-        const destinationEffects = _a.#effectsOf(destinationResult);
-        if (destinationResult.status === 202) {
-            return {
-                ...destinationResult,
-                attrs: {
-                    ...destinationResult.attrs,
-                    moveSource: this.#deferredMoveSource(resolvedSource, resolvedDestination),
-                },
-            };
-        }
-        const sourceResult = await this.#removeMoveSource(statement, resolvedSource, ctx);
-        if (sourceResult.status === 202) {
-            return {
-                ...sourceResult,
-                ...(destinationResult.scopeNormalizations === undefined
-                    ? {}
-                    : { scopeNormalizations: destinationResult.scopeNormalizations }),
-                attrs: {
-                    ...sourceResult.attrs,
-                    moveDestinationWritten: destinationAddress,
-                    moveDestinationEffects: destinationEffects,
-                },
-            };
-        }
-        if (sourceResult.status >= 400) {
-            return this.#moveFailureAfterDestination(destinationResult.scopeNormalizations === undefined
-                ? sourceResult
-                : Results.assert({
-                    ...sourceResult,
-                    scopeNormalizations: destinationResult.scopeNormalizations,
-                }), destinationAddress, destinationEffects);
-        }
-        const base = destinationResult.status === 304
-            ? { ...destinationResult, status: 200 }
-            : destinationResult;
-        return _a.#withCombinedEffects(base, _a.#effectsOf(sourceResult));
-    }
-    async #settleMoveProposal({ statement, result, settlement, ctx, ids, }) {
-        if (statement.op !== "MOVE")
-            return settlement;
-        const attrs = result.attrs;
-        const destinationWritten = attrs?.moveDestinationWritten;
-        if (destinationWritten !== undefined) {
-            const destinationEffects = attrs?.moveDestinationEffects === undefined
-                ? []
-                : assertResourceEffects(attrs.moveDestinationEffects);
-            if (settlement.resolution.decision !== "accept") {
-                const decision = settlement.resolution.decision;
-                return {
-                    resolution: settlement.resolution,
-                    applied: this.#moveFailureAfterDestination(_a.#failure("move-source-not-applied", decision === "cancel" ? 499 : 409, `The MOVE destination was written, but source removal was ${decision === "cancel" ? "cancelled" : "rejected"}.`, {}, {
-                        retryable: false,
-                    }), destinationWritten, destinationEffects),
-                };
-            }
-            if (settlement.applied === undefined) {
-                return {
-                    resolution: settlement.resolution,
-                    applied: this.#moveFailureAfterDestination(_a.#failure("proposal-apply-missing", 500, "The source scheme accepted its MOVE proposal without applying the source mutation.", {}, {
-                        stage: "proposal-application",
-                        retryable: false,
-                    }), destinationWritten, destinationEffects),
-                };
-            }
-            if (settlement.applied.status >= 400) {
-                return {
-                    resolution: settlement.resolution,
-                    applied: this.#moveFailureAfterDestination(settlement.applied, destinationWritten, destinationEffects),
-                };
-            }
-            return _a.#withSettlementEffects(settlement, [
-                ...destinationEffects,
-                ..._a.#settlementEffects(settlement),
-            ]);
-        }
-        const deferred = attrs?.moveSource;
-        if (deferred === undefined
-            || settlement.resolution.decision !== "accept"
-            || (settlement.applied?.status ?? 200) >= 400) {
-            return settlement;
-        }
-        if (settlement.applied === undefined) {
-            return {
-                resolution: settlement.resolution,
-                applied: _a.#failure("proposal-apply-missing", 500, "The destination scheme accepted its MOVE proposal without applying the destination mutation.", {}, {
-                    stage: "proposal-application",
-                    retryable: false,
-                }),
-            };
-        }
-        const destinationEffects = _a.#settlementEffects(settlement);
-        const resolvedSource = await this.#resolveResourceSelection({
-            target: deferred.target,
-            lineMarker: deferred.lineMarker,
-        }, ctx);
-        if (_a.#isDispatchResult(resolvedSource)) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(resolvedSource, deferred.destination, destinationEffects),
-            };
-        }
-        if (resolvedSource.scheme !== deferred.scheme
-            || resolvedSource.pathname !== deferred.pathname
-            || 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);
-        if (removed.status >= 400) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(removed, deferred.destination, destinationEffects),
-            };
-        }
-        if (removed.status !== 202) {
-            return _a.#withSettlementEffects(settlement, [
-                ...destinationEffects,
-                ..._a.#effectsOf(removed),
-            ]);
-        }
-        const initialSourceSettlement = await this.#proposals.workerApply(statement, removed, { decision: "accept" }, ids);
-        const sourceSettlement = _a.#settleProposalEffects(removed, initialSourceSettlement);
-        if (sourceSettlement.applied === undefined) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(_a.#failure("proposal-apply-missing", 500, "The source scheme accepted its MOVE proposal without applying the source mutation.", {}, {
-                    stage: "proposal-application",
-                    retryable: false,
-                }), deferred.destination, destinationEffects),
-            };
-        }
-        if (sourceSettlement.applied.status >= 400) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(sourceSettlement.applied, deferred.destination, destinationEffects),
-            };
-        }
-        return _a.#withSettlementEffects(settlement, [
-            ...destinationEffects,
-            ..._a.#settlementEffects(sourceSettlement),
-        ]);
+        context.onDispatch?.(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/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.
@@ -1789,30 +1007,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,
         };
@@ -1854,14 +1074,14 @@ class Dispatcher {
             return _a.#failure("send-status-required", 400, "SEND requires a numeric status.", {}, { retryable: false });
         }
         const raw = statement.body === null ? "" : statement.body.raw;
-        // The park rides SEND[202] only ({§park-202-only}). A scoped SEND[102] is neither
+        // 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,
             });
         }
@@ -1875,7 +1095,7 @@ class Dispatcher {
             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
@@ -1894,8 +1114,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);
@@ -1950,7 +1170,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,
                     });
                 }
@@ -1977,7 +1197,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);
@@ -1999,8 +1219,8 @@ class Dispatcher {
                         content: null,
                         mimetype: null,
                         results: [],
-                        itemsTokenTotal: 0,
-                        returnedItemsTokenTotal: 0,
+                        itemsWeightTotal: 0,
+                        returnedItemsWeightTotal: 0,
                         matchingPathCount: 0,
                         matchLocationCount: 0,
                     }
@@ -2070,6 +1290,7 @@ class Dispatcher {
                 statement,
                 manifest,
                 target,
+                identity: target,
                 representation: resolved.representation,
                 mimetypes: ctx.mimetypes,
             }));
@@ -2142,8 +1363,8 @@ class Dispatcher {
                     content: null,
                     mimetype: null,
                     results: [],
-                    itemsTokenTotal: 0,
-                    returnedItemsTokenTotal: 0,
+                    itemsWeightTotal: 0,
+                    returnedItemsWeightTotal: 0,
                     matchingPathCount: 0,
                     matchLocationCount: 0,
                 }, { target });
@@ -2171,11 +1392,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");
@@ -2183,21 +1407,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}
@@ -2207,12 +1430,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,
@@ -2263,6 +1497,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),
@@ -2280,7 +1515,14 @@ class Dispatcher {
             rx: rxJson,
             mimetype_rx: "application/json",
             status_rx: result.status,
-            tokens: this.#tokenize(txJson) + this.#tokenize(rxJson),
+            weight: LogBody.weight({
+                op: durableStatement.op,
+                attrs,
+                tx: txJson,
+                rx: rxJson,
+                mimetypeTx: "application/json",
+                mimetypeRx: "application/json",
+            }, this.#weighContent),
             state: isProposed ? "proposed" : "resolved",
             outcome: null,
             attrs,