@plurnk/plurnk-service 1.14.2 → 1.16.0

package/dist/core/Dispatcher.js

@@ -1,48 +1,27 @@
 var _a;
-import WorkerName, { WorkerNameError } from "./WorkerName.js";
-import WorkerControlAddress from "./WorkerControlAddress.js";
-import { entryCoordinateOf, foldAuthorityIntoPath, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
-import Fork from "./fork.js";
-import WorkerCap from "./worker-cap.js";
-import { PathSyntax, TagSignal } from "@plurnk/plurnk-contracts";
+import { foldAuthorityIntoPath, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
+import { PathSyntax } from "@plurnk/plurnk-contracts";
 import Namespace from "./namespace.js";
-import LoopPolicyReader from "./LoopPolicyReader.js";
 import CapabilityResolver from "./CapabilityResolver.js";
-import CapabilityPolicies from "./CapabilityPolicies.js";
-import ChannelWrite from "./ChannelWrite.js";
-import { ReadProjector } from "../content/index.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
-import EntryOps from "../schemes/_entry-ops.js";
-import EntryFind from "../schemes/_entry-find.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 { InvalidOperationResultError, } from "@plurnk/plurnk-schemes";
-import DurableStatement from "./DurableStatement.js";
+import { InvalidOperationResultError } from "@plurnk/plurnk-schemes";
 import ResourceMutations from "./ResourceMutations.js";
+import { primaryTargetOf } from "./statement-primary.js";
 import LogBody from "./LogBody.js";
 import LogVisibility from "./LogVisibility.js";
-import ErrorDetail from "./ErrorDetail.js";
+import WorkerControlHandler from "./WorkerControlHandler.js";
+import KillHandler from "./KillHandler.js";
+import SendBroadcastHandler from "./SendBroadcastHandler.js";
+import LogWriter from "./LogWriter.js";
+import DataStatementRunner from "./DataStatementRunner.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.
+// READ/FIND are not gated — they 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);
-    }
-    if (statement.op === "EXEC")
-        TagSignal.applied(statement.tags ?? null); // {§exec-tag-signal}
-};
-const primaryTargetOf = (statement) => statement.op === "COPY" || statement.op === "MOVE" ? statement.source.target : statement.target;
-const primaryLineMarkerOf = (statement) => statement.op === "COPY" || statement.op === "MOVE" ? statement.source.lineMarker : statement.lineMarker;
 // Op dispatch ({§op-methods-op-dispatch}): admission, operation-owner routing,
 // durable log writing, and proposal lifecycle.
 class Dispatcher {
@@ -84,6 +63,11 @@ class Dispatcher {
     #resourceMutations;
     #entryAddresses;
     #capabilities;
+    #workerControl;
+    #kill;
+    #sendBroadcast;
+    #logWriter;
+    #dataRun;
     constructor({ db, schemes, mimetypes, weigh, notices, proposals, interactions, executors, loopSignal, settleDerivations, settleVectors, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, cancelDescendants, parkDeadlines, joinTargets, liveSubscriptions, entryAddresses }) {
         this.#db = db;
         this.#schemes = schemes;
@@ -110,7 +94,7 @@ class Dispatcher {
         this.#resourceMutations = new ResourceMutations({
             schemes,
             liveSubscriptions,
-            run: (schemeName, statement, ctx) => this.#run(schemeName, statement, ctx),
+            run: (schemeName, statement, ctx) => this.#dataRun.run(schemeName, statement, ctx),
             checkWritable: (statement, origin, workerId) => this.#checkWritable(statement, origin, workerId),
             checkCapabilities: (statement, workspaceId, loopId, workerId) => this.#checkCapabilities(statement, workspaceId, loopId, workerId),
             editTargetIdentity: (statement, workspaceId, workerId) => this.#editTargetIdentity(statement, workspaceId, workerId),
@@ -125,6 +109,11 @@ class Dispatcher {
             deleteChannel: (scheme, address, channel, ctx) => this.#deleteChannel(scheme, address, channel, ctx),
             applyProposal: (statement, result, resolution, ids) => this.#proposals.workerApply(statement, result, resolution, ids),
         });
+        this.#workerControl = new WorkerControlHandler({ db: this.#db, schemes: this.#schemes, failure: _a.#failure });
+        this.#kill = new KillHandler({ db: this.#db, schemes: this.#schemes, liveSubscriptions: this.#liveSubscriptions, cancelWorker: this.#cancelWorker, resolveDataEntryAddress: this.#resolveDataEntryAddress.bind(this), boundEntryContext: this.#boundEntryContext.bind(this), handlerContext: this.#handlerContext.bind(this), deleteEntry: this.#deleteEntry.bind(this), failure: _a.#failure });
+        this.#sendBroadcast = new SendBroadcastHandler({ db: this.#db, cancelDescendants: this.#cancelDescendants, parkDeadlines: this.#parkDeadlines, joinTargets: this.#joinTargets, lifecycle: this.#lifecycle, nextPacketBoundaries: this.#nextPacketBoundaries.bind(this), unobservedFailureCount: this.#unobservedFailureCount.bind(this), pendingSet: this.#pendingSet.bind(this), hasLiveWork: this.hasLiveWork.bind(this), failure: _a.#failure, statusResult: _a.#statusResult, unobservedFailures: _a.#unobservedFailures });
+        this.#logWriter = new LogWriter({ db: this.#db, weighContent: this.#weighContent, extractTarget: this.#extractTarget.bind(this), canonColumns: this.#canonColumns.bind(this), signalToJson: this.#signalToJson.bind(this), isProposal: _a.#isProposal });
+        this.#dataRun = new DataStatementRunner({ schemes: this.#schemes, liveSubscriptions: this.#liveSubscriptions, resolveDataEntryAddress: this.#resolveDataEntryAddress.bind(this), fixedEntryOwnerId: this.#fixedEntryOwnerId.bind(this), prepareDataRepresentation: this.#prepareDataRepresentation.bind(this), failure: _a.#failure });
     }
     // workspace → project_root, memoized: {§fs-namespace} fixes the root immutably at
     // workspace creation, so a process-lifetime cache can never go stale.
@@ -279,21 +268,57 @@ class Dispatcher {
             identity: renderTarget(target),
         };
     }
+    // {§kill-scope-entry} — a scoped KILL on an entry-bearing scheme is one EDIT with an empty
+    // body over the same marker: prepared, gated, and merged as an EDIT while its log row
+    // records the model's KILL. Schemes that implement kill() (streams) take the scope themselves;
+    // the log's scoped KILL is curation.
+    #scopedEntryEdits = new WeakMap();
+    #scopedEntryEdit(statement, functionalityWorkerId) {
+        if (statement.op === "EDIT")
+            return statement;
+        // A body pattern is a log selector; a scoped KILL carrying one is not an EDIT — the KILL
+        // handler refuses it ({§kill-scope-entry}).
+        if (statement.op !== "KILL" || statement.lineMarker === null || statement.body !== null)
+            return null;
+        const cached = this.#scopedEntryEdits.get(statement);
+        if (cached !== undefined)
+            return cached;
+        const schemeName = schemeNameOf(statement.target);
+        if (schemeName === null || schemeName === "log")
+            return null;
+        const handler = this.#schemes.get(schemeName, functionalityWorkerId);
+        if (handler === undefined || typeof handler.kill === "function")
+            return null;
+        const edit = {
+            op: "EDIT",
+            delimiter: statement.delimiter,
+            annotation: statement.annotation,
+            metadata: statement.metadata,
+            target: statement.target,
+            lineMarker: statement.lineMarker,
+            body: "",
+            position: statement.position,
+        };
+        this.#scopedEntryEdits.set(statement, edit);
+        return edit;
+    }
     async prepareEditBatches(statements, context) {
-        for (const statement of statements)
-            assertClassifyingSignal(statement); // {§log-tag-signal}
         const { workspaceId, workerId, functionalityWorkerId, loopId, turnId, origin } = context;
         const schemeCtx = this.#buildSchemeCtx({ workspaceId, workerId, functionalityWorkerId, loopId, turnId, origin });
-        await this.#resourceMutations.prepareEditBatches(statements, context, schemeCtx);
+        const edits = statements.flatMap((statement) => {
+            const edit = this.#scopedEntryEdit(statement, schemeCtx.functionalityWorkerId);
+            return edit === null ? [] : [edit];
+        });
+        await this.#resourceMutations.prepareEditBatches(edits, context, schemeCtx);
     }
     async dispatch(context) {
-        assertClassifyingSignal(context.statement); // {§log-tag-signal}
         let result = await this.#dispatchOne(context);
-        if (context.statement.op === "EDIT") {
+        const edit = context.statement.op === "EDIT" ? context.statement : this.#scopedEntryEdits.get(context.statement);
+        if (edit !== undefined) {
             // {§edit-batch-merges} — a proposal's apply result replaces the projected one; the
             // statement's merge facts ride every EDIT result, whichever route produced it.
-            result = this.#resourceMutations.withMergeFacts(context.statement, result);
-            this.#resourceMutations.settleEdit(context.statement, result);
+            result = this.#resourceMutations.withMergeFacts(edit, result);
+            this.#resourceMutations.settleEdit(edit, result);
         }
         return result;
     }
@@ -320,7 +345,7 @@ class Dispatcher {
                     result = await this.#resourceMutations.preparedEditResult(statement);
                 }
                 else if (statement.op === "SEND" && statement.target === null) {
-                    result = await this.#handleSendBroadcast(statement, {
+                    result = await this.#sendBroadcast.handleSendBroadcast(statement, {
                         workspaceId,
                         workerId,
                         loopId,
@@ -329,15 +354,13 @@ class Dispatcher {
                         origin,
                     });
                 }
-                else if (statement.op === "OPEN"
-                    || statement.op === "FOLD"
-                    || (statement.op === "KILL" && schemeNameOf(statement.target) === "log")) {
+                else if (statement.op === "KILL" && schemeNameOf(statement.target) === "log") {
                     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);
+                    result = await this.#workerControl.handleWorkerControl(statement, schemeCtx);
                 }
                 else if (statement.op === "COPY") {
                     result = await this.#resourceMutations.handleCopy(statement, schemeCtx);
@@ -345,8 +368,11 @@ class Dispatcher {
                 else if (statement.op === "MOVE") {
                     result = await this.#resourceMutations.handleMove(statement, schemeCtx);
                 }
+                else if (statement.op === "KILL" && this.#scopedEntryEdits.has(statement)) {
+                    result = await this.#resourceMutations.preparedEditResult(this.#scopedEntryEdits.get(statement));
+                }
                 else if (statement.op === "KILL") {
-                    result = await this.#handleKill(statement, schemeCtx);
+                    result = await this.#kill.handleKill(statement, schemeCtx);
                 }
                 else if (statement.op === "PLAN") {
                     result = this.#handlePlan(statement);
@@ -354,10 +380,10 @@ class Dispatcher {
                 else if (statement.op === "EXEC") {
                     // EXEC routes unconditionally to its operation owner after
                     // the shared capability resolver admits its runtime/tool.
-                    result = await this.#run("exec", statement, schemeCtx);
+                    result = await this.#dataRun.run("exec", statement, schemeCtx);
                 }
                 else {
-                    result = await this.#run(schemeNameOf(statement.target), statement, schemeCtx); // {§op-methods-op-dispatch}
+                    result = await this.#dataRun.run(schemeNameOf(statement.target), statement, schemeCtx); // {§op-methods-op-dispatch}
                 }
             }
             catch (err) { // a scheme exception becomes the op's 500 outcome — {§scheme-surface-exception-500}
@@ -383,7 +409,7 @@ class Dispatcher {
         // {§join-blocking-collect}
         if (typeof result.awaitWorker === "string")
             this.#joinTargets.add(loopId);
-        const logEntryId = await this.#writeLog({
+        const logEntryId = await this.#logWriter.writeLog({
             statement,
             result,
             functionalityWorkerId,
@@ -484,7 +510,7 @@ class Dispatcher {
         const denial = await this.#checkCapabilities(statement, schemeCtx.workspaceId, loopId, schemeCtx.functionalityWorkerId);
         if (denial !== null)
             return denial;
-        return this.#run(schemeNameOf(statement.target), statement, schemeCtx);
+        return this.#dataRun.run(schemeNameOf(statement.target), statement, schemeCtx);
     }
     capabilityProjection(workspaceId, workerId) {
         return this.#capabilities.projection(workspaceId, workerId);
@@ -587,7 +613,7 @@ class Dispatcher {
                 retryable: false,
             });
         }
-        return Results.assertReadResult(await this.#run(schemeName, statement, ctx));
+        return Results.assertReadResult(await this.#dataRun.run(schemeName, statement, ctx));
     }
     // The one place per-dispatch coordinates are built; a caller that carries no
     // explicit Functionality coordinate acts in its own Worker's
@@ -722,209 +748,6 @@ class Dispatcher {
     #isWorkerControl(statement) {
         return statement.op === "FORK" || statement.op === "WORK"; // worker control targets worker://<name> (grammar 0.74.55)
     }
-    // WORK and FORK name the new worker in the target authority and carry its seed task in the body.
-    // Their distinct fresh/branched histories are specified by {§worker-scheme-spawn} and {§worker-scheme-fork}.
-    async #handleWorkerControl(statement, ctx) {
-        const address = WorkerControlAddress.resolve(statement.target, statement.op);
-        if (!address.ok)
-            return address.result;
-        const name = address.authority;
-        try {
-            WorkerName.assert(name); // {§worker-name-minting}
-        }
-        catch (error) {
-            if (!(error instanceof WorkerNameError))
-                throw error;
-            return _a.#failure(`worker-${error.code}`, 400, error.message, {}, {
-                operation: statement.op,
-                worker: error.workerName,
-                recovery: error.recovery,
-                retryable: false,
-            });
-        }
-        if (ctx.injectWorker === undefined)
-            throw new Error("worker control: injectWorker capability absent");
-        const denied = await WorkerCap.deny(this.#db, ctx.workspaceId);
-        if (denied !== null)
-            return denied;
-        const prompt = statement.body;
-        // {§worker-delegation-inherits-policy} — authority flows down the
-        // delegation edge. The child receives the delegator's complete loop
-        // policy and an immutable snapshot of its effective capability bound.
-        const policy = await LoopPolicyReader.read(this.#db, ctx.loopId);
-        const capabilityBound = await CapabilityPolicies.delegationBound(this.#db, ctx.workspaceId, ctx.workerId, policy);
-        const delegationPolicy = {
-            ...policy,
-            capabilities: capabilityBound,
-        };
-        // A name is frozen per worker but reclaimable across time ({§machine-processes-worker-origin}): a LIVE
-        // sister holding it is a 409 (legible, never a raw UNIQUE 500); a free/terminated name reclaims.
-        const live = await this.#db.worker_live_by_name.get({ workspace_id: ctx.workspaceId, name });
-        if (live !== undefined) {
-            return _a.#failure("worker-already-running", 409, `Worker '${name}' is already running.`, {}, { worker: name, retryable: false });
-        }
-        if (statement.signal !== null && statement.signal !== undefined) {
-            // {§worker-spawn-no-signal} (#396) — WORK/FORK take no signal. Branch
-            // delegation was removed outright; a model manages git branches through
-            // ordinary EXEC git, taught by the git skill, never engine machinery.
-            return _a.#failure("worker-signal-invalid", 400, `${statement.op} takes no signal.`, {}, {
-                worker: name,
-                signal: statement.signal,
-                recovery: `Spawn without a signal: \`## ${statement.op}0 (worker://${name})\` with the prompt as the body.`,
-                retryable: false,
-            });
-        }
-        if (statement.op === "FORK") {
-            // Branch the current worker's log into a named sister.
-            const branchWorkerId = await Fork.fork(this.#db, ctx.workerId, name, capabilityBound, (scheme) => this.#schemes.entryInheritanceForStoredScheme(scheme, ctx.workerId));
-            await ctx.injectWorker({
-                workspaceId: ctx.workspaceId,
-                workerId: branchWorkerId,
-                sourceWorkerId: ctx.workerId,
-                prompt,
-                freshLoopPolicy: delegationPolicy,
-                parentLoopId: ctx.loopId,
-            });
-            return { status: 200, body: name };
-        }
-        // WORK — a fresh worker sister named <name>.
-        const row = await this.#db.fork_insert_worker.get({
-            workspace_id: ctx.workspaceId, name, parent_worker_id: ctx.workerId, origin: ctx.writer,
-            fork_snapshot: 0,
-            capability_bound: JSON.stringify(capabilityBound),
-        });
-        if (row === undefined)
-            throw new Error("worker spawn: worker insert returned no row");
-        await ctx.injectWorker({
-            workspaceId: ctx.workspaceId,
-            workerId: row.id,
-            sourceWorkerId: ctx.workerId,
-            prompt,
-            freshLoopPolicy: delegationPolicy,
-            parentLoopId: ctx.loopId,
-        });
-        return { status: 200, body: name };
-    }
-    // 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) {
-        if (statement.op !== "KILL")
-            throw new Error("unreachable");
-        const path = statement.target;
-        if (path === null) {
-            return _a.#failure("kill-target-required", 400, "KILL requires a target path.", {}, { retryable: false });
-        }
-        const schemeName = schemeNameOf(path);
-        if (schemeName === null) {
-            return _a.#failure("kill-target-scheme-required", 400, "KILL target requires a scheme.", {}, { retryable: false });
-        }
-        const manifest = this.#schemes.manifestFor(schemeName, ctx.functionalityWorkerId);
-        const coordinate = entryCoordinateOf(path, manifest?.authority ?? "namespace");
-        // log:/// KILL has already gone through the projection-curation owner.
-        // This path owns scheme-specific world and process KILL semantics.
-        // Process-KILL: any scheme whose handler exposes kill() aborts a live stream — the
-        // exec handler, registered as "exec" + under every runtime tag (sh/node), so a tag-
-        // addressed stream (sh:///l/t/s) routes here, not to deleteEntry. {§exec}
-        const killable = this.#schemes.get(schemeName, ctx.functionalityWorkerId);
-        if (killable !== undefined && typeof killable.kill === "function") {
-            // Pass the model's OWN scheme so a stream-KILL error answers in the runtime tag the
-            // model addressed (sh:///…), not the internal `exec` ({§fs-answer-in-canon}).
-            let handlerCtx;
-            if (manifest?.category === "data") {
-                const resolved = await this.#resolveDataEntryAddress({
-                    target: path,
-                    routedScheme: schemeName,
-                    handler: killable,
-                    manifest,
-                    ctx,
-                });
-                if (resolved.result !== null)
-                    return resolved.result;
-                if (resolved.address === null) {
-                    return _a.#failure("entry-not-found", 404, `No entry exists at ${renderAddress({ scheme: schemeName, ...coordinate })}.`);
-                }
-                handlerCtx = this.#boundEntryContext(schemeName, resolved.address, ctx);
-            }
-            else {
-                handlerCtx = await this.#handlerContext(schemeName, ctx, coordinate.authority);
-            }
-            if (handlerCtx === null) {
-                throw new InvalidOperationResultError(`Registered scheme '${schemeName}' has no dispatch context.`);
-            }
-            return await killable.kill(coordinate.pathname, statement.signal, handlerCtx, schemeName);
-        }
-        if (schemeName === "worker") {
-            // Entry-path present → KILL a private owner-held entry (delete it), self-only —
-            // NOT worker cancellation. The authority (hostname) names the owner, the pathname the
-            // entry; only the path-ABSENT form (worker://<name>) terminates the worker-as-actor. {§worker-scheme}
-            const entryPath = path.kind === "url" ? (path.pathname ?? "") : "";
-            if (entryPath !== "" && entryPath !== "/") {
-                const workerHandler = this.#schemes.get("worker");
-                if (manifest?.category !== "data") {
-                    throw new InvalidOperationResultError("Registered scheme 'worker' is not entry-bearing.");
-                }
-                const resolved = await this.#resolveDataEntryAddress({
-                    target: path,
-                    routedScheme: "worker",
-                    handler: workerHandler,
-                    manifest,
-                    ctx,
-                });
-                if (resolved.result !== null)
-                    return resolved.result;
-                if (resolved.address === null) {
-                    return _a.#failure("entry-not-found", 404, "The worker entry does not exist.");
-                }
-                const handlerCtx = this.#boundEntryContext("worker", resolved.address, ctx);
-                if (handlerCtx === null) {
-                    throw new InvalidOperationResultError("Registered scheme 'worker' has no dispatch context.");
-                }
-                return await workerHandler.killEntry(statement, handlerCtx);
-            }
-            const address = WorkerControlAddress.resolve(path, "KILL");
-            if (!address.ok)
-                return address.result;
-            // `~` is the sole current-worker sigil; every other authority is a literal name.
-            // An idle worker is a no-op 200; a missing named worker is 404. {§worker-control-addressing}
-            const name = address.authority;
-            let workerId = ctx.workerId;
-            if (name !== "~") {
-                const row = await this.#db.worker_resolve_by_name.get({ workspace_id: ctx.workspaceId, name });
-                if (row === undefined) {
-                    return _a.#failure("worker-not-found", 404, `Worker '${name}' does not exist in this workspace.`, {}, { worker: name, retryable: false });
-                }
-                workerId = row.id;
-            }
-            if (this.#cancelWorker === undefined)
-                throw new Error("worker kill: cancelWorker capability absent");
-            // {§op-synchronous} — KILL is decisive. Await the one lifecycle owner so the
-            // same-turn pending-work gate observes the complete subtree as terminal.
-            await this.#cancelWorker(workerId, "killed via worker:// KILL");
-            return { status: 200 };
-        }
-        if (!this.#schemes.has(schemeName, ctx.functionalityWorkerId)) {
-            return _a.#failure("scheme-not-found", 501, `Scheme '${schemeName}' is not registered.`, {}, { scheme: schemeName, retryable: false });
-        }
-        const handler = this.#schemes.get(schemeName, ctx.functionalityWorkerId);
-        if (handler === undefined || manifest?.category !== "data") {
-            return _a.#failure("entry-operation-unsupported", 400, `KILL requires an entry-bearing target; '${schemeName}' does not provide one.`, {}, { scheme: schemeName, retryable: false });
-        }
-        const resolved = await this.#resolveDataEntryAddress({
-            target: path,
-            routedScheme: schemeName,
-            handler,
-            manifest,
-            ctx,
-        });
-        if (resolved.result !== null)
-            return resolved.result;
-        if (resolved.address === null) {
-            return _a.#failure("entry-not-found", 404, "The KILL target does not exist.");
-        }
-        // A host-effecting delete (file) returns 202 to PROPOSE — pass its attrs through so the proposal
-        // carries the delete target to review (#isProposal fires on 202). Plurnk-internal deletes execute inline.
-        return this.#deleteEntry(schemeName, resolved.address, ctx);
-    }
     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" });
@@ -987,9 +810,8 @@ class Dispatcher {
     // {§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({
+        const logEntryId = await this.#logWriter.writeLog({
             ...context,
             functionalityWorkerId: context.functionalityWorkerId ?? context.workerId,
             result,
@@ -1009,8 +831,10 @@ class Dispatcher {
     // BY STATED INTENT and is never gated.
     async #pendingSet(workerId, turnId) {
         const pending = [];
-        const openSubs = await this.#db.find_open_subscriptions_for_worker.all({ worker_id: workerId });
         const execHandler = this.#schemes.get("exec");
+        // {§exec-timeout} — a `<-1>` spawn outlives the loop and is nobody's obligation.
+        const openSubs = (await this.#db.find_open_subscriptions_for_worker.all({ worker_id: workerId }))
+            .filter(({ id }) => execHandler?.isDetachedSpawn?.(id) !== true);
         if (openSubs.length > 0 || execHandler?.hasActiveSpawns?.(workerId) === true)
             pending.push("streams");
         const liveChild = await this.#db.engine_worker_has_live_child.get({ worker_id: workerId });
@@ -1042,8 +866,10 @@ class Dispatcher {
                 .get({ worker_id: workerId }),
         ]);
         return {
-            retrievals: turnBoundaries.some(({ op }) => op !== "FOLD"),
-            folds: turnBoundaries.some(({ op }) => op === "FOLD"),
+            // {§log-kill-scope} — a log KILL is housekeeping: it continues an empty (WAIT) but never
+            // blocks an explicit (TERM); every other boundary row is a retrieval receipt.
+            retrievals: turnBoundaries.some(({ op }) => op !== "KILL"),
+            folds: turnBoundaries.some(({ op }) => op === "KILL"),
             streamTerminations,
             childTerminations: childTermination !== undefined,
         };
@@ -1066,374 +892,17 @@ class Dispatcher {
     // J — a live obligation to WAIT on: a spawned child or an open stream (NOT retrievals, which land
     // next turn regardless). The wait-side twin of #pendingSet's stream+child legs ({§wait-obligation-matrix}).
     async hasLiveWork(workerId) {
-        const openSubs = await this.#db.find_open_subscriptions_for_worker.all({ worker_id: workerId });
+        const execHandler = this.#schemes.get("exec");
+        // {§exec-timeout} — a `<-1>` spawn outlives the loop and is nobody's obligation.
+        const openSubs = (await this.#db.find_open_subscriptions_for_worker.all({ worker_id: workerId }))
+            .filter(({ id }) => execHandler?.isDetachedSpawn?.(id) !== true);
         if (openSubs.length > 0)
             return true;
-        const execHandler = this.#schemes.get("exec");
         if (execHandler?.hasActiveSpawns?.(workerId) === true)
             return true;
         const liveChild = await this.#db.engine_worker_has_live_child.get({ worker_id: workerId });
         return liveChild !== undefined;
     }
-    async #handleSendBroadcast(statement, ctx) {
-        if (statement.op !== "SEND")
-            throw new Error("unreachable");
-        const { workerId, loopId, turnId } = ctx;
-        const status = statement.signal;
-        if (status === null) {
-            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 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, "`## SEND0 [102]` does not accept a scope.", {}, {
-                requestedStatus: 102,
-                scope: statement.lineMarker,
-                recovery: "Use `## SEND0 [202] <scope>` to wait, or remove the scope to continue.",
-                retryable: false,
-            });
-        }
-        // A bare continue after an armed running-worker READ becomes an
-        // indefinite park. {§join-blocking-collect}
-        const joinArmed = this.#joinTargets.delete(loopId);
-        if (status === 102 && statement.lineMarker === null && joinArmed) {
-            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 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
-        // retrieval (R) just lands next turn, so the wait continues.
-        if (status === 202) {
-            const marks = statement.lineMarker?.marks[0];
-            // `<T>` is MINUTES, held in seconds; bare 202 / absent T = indefinite, bounded by the join.
-            const seconds = typeof marks === "number" ? (marks > 0 ? marks * 60 : marks) : -1;
-            if (await this.hasLiveWork(workerId)) {
-                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);
-                return { status: 202, attrs: { waiting: seconds } };
-            }
-            // Retrievals, fast stream conclusions, and child conclusions are
-            // all complete-but-unobserved. Their wake edge may already have
-            // fired, so do not park; continue directly to the packet that
-            // materializes them.
-            const boundaries = await this.#nextPacketBoundaries(workerId, turnId);
-            if (boundaries.retrievals || boundaries.folds || boundaries.streamTerminations.length > 0 || boundaries.childTerminations) {
-                return { status: 102 };
-            }
-            const failCount = await this.#unobservedFailureCount(turnId);
-            if (failCount > 0)
-                return _a.#unobservedFailures(failCount);
-            // 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, TerminalResult.success(raw));
-            return {
-                status: finished !== null ? 200 : await this.#lifecycle.status(loopId),
-                attrs: { joined: true, pending: 0 },
-            };
-        }
-        // [200] — terminate, gated by the pending set (post-batch). The row records the refused
-        // attempt faithfully (status_rx=409, never erased); the loop stays a continue; the strike
-        // couples in runTurn. [499] abandons and cancels the descendant scope.
-        if (status === 200) {
-            // Model completion is a claim about the Worker's observed work and
-            // therefore crosses the pending-result rails. A `_plurnk`
-            // maintenance program closes only its own administrative loop; it
-            // must not claim, consume, or be blocked by model work elsewhere in
-            // the same Worker.
-            if (ctx.origin === "model") {
-                // {§send-premature-terminate} — same-turn failures are unobserved
-                // pending results and therefore refuse completion.
-                const failCount = await this.#unobservedFailureCount(turnId);
-                if (failCount > 0)
-                    return _a.#unobservedFailures(failCount);
-                const pending = await this.#pendingSet(workerId, turnId);
-                if (pending.length > 0) {
-                    // A receipts-only refusal needs no KILL/park remedy menu: the results simply
-                    // arrive in the next packet. Streams and children retain their remedy steer.
-                    const receiptsOnly = pending.every((kind) => kind === "receipts");
-                    if (receiptsOnly) {
-                        return _a.#failure("retrieval-results-unobserved", 409, "Completion preceded this turn's operation results; they enter the next packet.", {}, {
-                            pending: [...pending],
-                            stage: "completion",
-                            retryable: false,
-                        });
-                    }
-                    return _a.#failure("work-remains", 409, "Completion encountered pending work or results.", {}, {
-                        pending: [...pending],
-                        stage: "completion",
-                        retryable: false,
-                    });
-                }
-            }
-            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) {
-            const reason = raw === "" ? null : ErrorDetail.preview(raw);
-            const failure = _a.#failure("scope-abandoned", 499, "The worker ended its scope with SEND[499].", {}, {
-                ...(reason === null ? {} : { reason }),
-                retryable: false,
-            });
-            const seqs = await this.#db.engine_loop_turn_seqs.get({
-                loop_id: loopId,
-                turn_id: turnId,
-            });
-            if (seqs === undefined) {
-                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);
-            if (finished === null)
-                return _a.#statusResult(await this.#lifecycle.status(loopId), "loop-already-terminal", "The loop was already terminal when SEND attempted to abandon it.");
-            await this.#cancelDescendants?.(workerId, reason ?? "parent worker ended its scope with SEND[499]");
-            return failure;
-        }
-        // Every other signal — 102 bare, 202 (retired as a terminal; now ordinary mid-comms), 1xx —
-        // is a plain broadcast row: no loop transition.
-        return _a.#statusResult(status, "send-broadcast-failed", raw === "" ? `SEND broadcast reported status ${status}.` : raw);
-    }
-    async #run(schemeName, statement, ctx) {
-        if (schemeName === null) {
-            const fields = statement.op === "READ"
-                ? { content: null, mimetype: null, channel: null }
-                : statement.op === "FIND"
-                    ? {
-                        content: null,
-                        mimetype: null,
-                        results: [],
-                        itemsWeightTotal: 0,
-                        returnedItemsWeightTotal: 0,
-                        matchingPathCount: 0,
-                        matchLocationCount: 0,
-                    }
-                    : {};
-            return _a.#failure("target-scheme-required", 400, `${statement.op} requires a target scheme.`, fields, { operation: statement.op, retryable: false });
-        }
-        const manifest = this.#schemes.manifestFor(schemeName, ctx.functionalityWorkerId);
-        const handler = this.#schemes.get(schemeName, ctx.functionalityWorkerId);
-        if (handler === undefined) {
-            return _a.#failure("scheme-not-found", 501, `Scheme '${schemeName}' is not registered.`, {}, { scheme: schemeName, retryable: false });
-        }
-        const methodName = statement.op.toLowerCase();
-        const method = handler[methodName];
-        const addressedScheme = statement.target?.kind === "url" ? statement.target.scheme : null;
-        if (manifest === undefined)
-            throw new Error(`scheme '${schemeName}' has no manifest`);
-        // Metadata belongs to the handler that receives it. EXEC over a
-        // non-file resource is the one split route: exec hosts the operation,
-        // while the canonically routed source scheme receives the metadata.
-        const metadataScheme = schemeName === "exec"
-            && statement.target?.kind === "url"
-            && statement.target.scheme !== "file"
-            ? schemeNameOf(statement.target) ?? schemeName
-            : schemeName;
-        const metadataManifest = metadataScheme === schemeName
-            ? manifest
-            : this.#schemes.manifestFor(metadataScheme, ctx.functionalityWorkerId);
-        if (statement.metadata !== null && metadataManifest === undefined) {
-            return _a.#failure("scheme-not-found", 501, `Scheme '${metadataScheme}' is not registered.`, {}, { scheme: metadataScheme, retryable: false });
-        }
-        if (statement.metadata !== null && metadataManifest?.metadataModifier !== true) {
-            return _a.#failure("scheme-metadata-unsupported", 400, `Scheme '${metadataScheme}' does not accept the {metadata} modifier.`, {}, {
-                scheme: metadataScheme,
-                operation: statement.op,
-                retryable: false,
-            });
-        }
-        const publishedChannel = statement.target?.kind === "url"
-            ? statement.target.fragment ?? manifest.defaultChannel
-            : manifest.defaultChannel;
-        const authoredCoordinate = statement.target === null
-            ? { authority: "", pathname: "" }
-            : entryCoordinateOf(statement.target, manifest.authority ?? "namespace");
-        // EXEC's authored target belongs to its declared invocation contract;
-        // a resource target is input to the executor, never the output-stream
-        // address owned by the internal exec scheme. {§exec-target-routing}
-        const addressResolution = manifest.category === "data"
-            && statement.target !== null
-            && statement.op !== "EXEC"
-            ? await this.#resolveDataEntryAddress({
-                target: statement.target,
-                routedScheme: schemeName,
-                handler: handler,
-                manifest,
-                ctx,
-            })
-            : null;
-        if (addressResolution?.result !== null && addressResolution?.result !== undefined) {
-            return addressResolution.result;
-        }
-        const operationAddress = addressResolution?.address ?? null;
-        const schemeCtx = new SchemeCtxImpl(ctx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions, {
-            authority: operationAddress?.authority ?? authoredCoordinate.authority,
-            ownerId: operationAddress?.ownerId ?? await this.#fixedEntryOwnerId(manifest, ctx),
-            publishedChannel,
-        });
-        if (statement.op === "SEND"
-            && statement.signal === 499
-            && statement.target?.kind === "url"
-            && operationAddress !== null) {
-            const addressedScheme = statement.target.scheme;
-            const entry = await this.#db.crud_find_workspace_entry.get({
-                workspace_id: ctx.workspaceId,
-                owner_id: operationAddress.ownerId,
-                scheme: operationAddress.scheme,
-                authority: operationAddress.authority,
-                pathname: operationAddress.pathname,
-            });
-            if (entry !== undefined) {
-                const subscription = await ChannelWrite.findActiveSubscription(this.#db, {
-                    workerId: ctx.workerId,
-                    entryId: entry.id,
-                });
-                if (subscription !== null && subscription.scheme === addressedScheme) {
-                    const cancelled = await this.#liveSubscriptions.cancel(subscription.id);
-                    if (!cancelled) {
-                        throw new InvalidOperationResultError(`Subscription ${subscription.id} is durable but has no live cancellation handle.`);
-                    }
-                    return { status: 200 };
-                }
-            }
-        }
-        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,
-                    metadata: statement.metadata,
-                    routedScheme: schemeName,
-                    handler: handler,
-                    manifest,
-                    ctx,
-                    publishedChannel,
-                    ...(addressResolution === null ? {} : { resolved: addressResolution }),
-                });
-            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
-                ? null
-                : {
-                    ownerId: resolved.ownerId,
-                    authority: resolved.authority,
-                    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(authoredCoordinate.pathname);
-        if (exactTarget && statement.target !== null) {
-            const prepared = await this.#prepareDataRepresentation({
-                target: statement.target,
-                metadata: statement.metadata,
-                routedScheme: schemeName,
-                handler: handler,
-                manifest,
-                ctx,
-                publishedChannel,
-                ...(addressResolution === null ? {} : { resolved: addressResolution }),
-            });
-            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: [],
-                    itemsWeightTotal: 0,
-                    returnedItemsWeightTotal: 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,
-                authority: prepared.address.authority,
-                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);
-            if (prepared.status >= 300)
-                return Results.assert(prepared);
-        }
-        return Results.assert(await schemeCtx.entries.operations.find(statement));
-    }
     async #runLogCuration(statement, ctx) {
         const addressedScheme = schemeNameOf(statement.target);
         if (addressedScheme !== null && addressedScheme !== "log") {
@@ -1462,125 +931,6 @@ class Dispatcher {
             return false;
         return !(statement.op === "SEND" && statement.target === null);
     }
-    async #writeLog({ statement, result, workspaceId, workerId, functionalityWorkerId, loopId, turnId, sequence, origin, curationPlan, modelCallId, }) {
-        const durableStatement = DurableStatement.project(statement);
-        const target = this.#extractTarget(primaryTargetOf(durableStatement), functionalityWorkerId);
-        await this.#canonColumns(target, workspaceId); // {§fs-answer-in-canon}
-        const lineMarker = primaryLineMarkerOf(durableStatement);
-        const lineMarkerJson = lineMarker !== null
-            ? JSON.stringify(lineMarker)
-            : null;
-        // 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 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 = {
-                targets: curationPlan.targets,
-                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,
-                turn_id: turnId,
-            })
-            : undefined;
-        if ((statement.op === "EXEC" || result.problem !== undefined) && seqs === undefined) {
-            throw new Error(`Dispatcher.#writeLog: loop_turn_seqs returned no row for loop=${loopId} turn=${turnId}`);
-        }
-        if (statement.op === "READ")
-            Results.assertReadResult(result);
-        if (result.problem !== undefined && seqs !== undefined) {
-            Results.attachInstance(result, `log:///${seqs.loop_seq}/${seqs.turn_seq}/${sequence}/${statement.op}`);
-        }
-        else {
-            Results.assert(result);
-        }
-        // EXEC produces a stream entry addressed by RUNTIME TAG as authority ({§exec}): it lives
-        // at <runtime>:///<loop_seq>/<turn_seq>/<sequence> (e.g. sh:///1/1/2). That address is a
-        // SEPARATE `stream` link in attrs — NOT an overload of `target`, which stays faithful to
-        // the EXEC's own slot (the cwd, or the path to the executable). The log:/// coordinate
-        // shares the trailing <loop>/<turn>/<seq>, so the op still correlates to its stream.
-        // Runtime comes from statement.signal (EXEC's runtime slot), resolvable for failed execs
-        // too; empty/absent = the default shell.
-        if (statement.op === "EXEC") {
-            if (seqs === undefined)
-                throw new Error("Dispatcher.#writeLog: EXEC coordinate was not resolved");
-            const runtime = (typeof statement.signal === "string" && statement.signal.length > 0) ? statement.signal : "sh";
-            const coordPathname = `/${seqs.loop_seq}/${seqs.turn_seq}/${sequence}`;
-            attrsObj.pathname = coordPathname;
-            attrsObj.stream = `${runtime}://${coordPathname}`;
-            // Mutate the in-memory result.attrs too: the dispatch path
-            // hands originalResult.attrs to handler.applyResolution after
-            // proposal accept (see ProposalLifecycle.workerApply). Both views —
-            // the stored row AND the in-memory proposal — need the same
-            // pathname so applyResolution writes the entry at the same URI.
-            if (result.attrs !== undefined && result.attrs !== null) {
-                result.attrs.pathname = coordPathname;
-            }
-        }
-        const attrs = JSON.stringify(attrsObj);
-        const txJson = JSON.stringify(durableStatement);
-        const rxJson = JSON.stringify(result);
-        const row = await this.#db.engine_insert_log_entry.get({
-            worker_id: workerId,
-            loop_id: loopId,
-            turn_id: turnId,
-            sequence: sequence,
-            origin,
-            source: null, // dispatch entries are self-authored; {§env-delta} deltas set this
-            model_call_id: modelCallId,
-            op: durableStatement.op,
-            delimiter: durableStatement.delimiter,
-            signal: this.#signalToJson(durableStatement.signal),
-            scheme: target.scheme,
-            username: target.username,
-            password: target.password,
-            hostname: target.hostname,
-            port: target.port,
-            pathname: target.pathname,
-            query: target.query,
-            fragment: target.fragment,
-            lineMarker: lineMarkerJson,
-            tx: txJson,
-            mimetype_tx: "application/json",
-            rx: rxJson,
-            mimetype_rx: "application/json",
-            status_rx: result.status,
-            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,
-            initial_folded: LogVisibility.serialize(LogVisibility.OPEN),
-        });
-        // {§exec-tag-signal} — an EXEC row's signal is its runtime; its tag signal classifies
-        // through the same idempotent primitive the log-write trigger uses for tag operations.
-        if (row !== undefined && statement.op === "EXEC" && statement.tags !== undefined && statement.tags !== null) {
-            for (const tag of TagSignal.applied(statement.tags).add) {
-                await this.#db.log_write_tag.run({ log_entry_id: row.id, tag });
-            }
-        }
-        if (row === undefined)
-            throw new Error("Dispatcher.#writeLog: INSERT ... RETURNING produced no row");
-        return row.id;
-    }
     // Normalize a parsed target for log storage. Bare paths and `file:///...`
     // inputs collapse to scheme=null in log target metadata because both render
     // as bare paths. Addressable file entries separately persist under the