@plurnk/plurnk-service 1.14.2 → 1.16.0

package/dist/core/TurnRunner.js

@@ -1,17 +1,14 @@
-var _a;
 import { PathSyntax, PlurnkParser, PlurnkParseError, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
 import { setTimeout as delay } from "node:timers/promises";
 import { aggregateProviderAccounting } from "@plurnk/plurnk-providers";
-const TERMINAL_SEND_SIGNALS = new Set([102, 200, 202, 499]);
 const comparePosition = (a, b) => a.line - b.line || a.column - b.column;
 import Meta from "@plurnk/plurnk-meta";
 import EntryCrud from "../schemes/_entry-crud.js";
 import GitMembership from "./git-membership.js";
+import { acceptedKinds } from "./attachments.js";
 import GitState from "./git-state.js";
 import WorkspaceSettings from "./workspace-settings.js";
-import { editedSpan } from "../content/index.js";
-import ReadResolve from "../content/read-resolve.js";
-import { authorityParts, generatedPathname, promptPathname, promptLoopPrefix } from "./plurnk-uri.js";
+import { generatedPathname, promptPathname, promptLoopPrefix } from "./plurnk-uri.js";
 import { readFile } from "node:fs/promises";
 // {§grammar-rail-registration} — bare names are the built-in rail namespace;
 // everything else is an import specifier resolved through the Node chain.
@@ -22,44 +19,22 @@ export const resolveGrammarRailPath = (variant) => variant.startsWith("/") || va
         : fileURLToPath(import.meta.resolve(variant)))
     : fileURLToPath(import.meta.resolve(`@plurnk/plurnk-contracts/${variant}`));
 import { fileURLToPath } from "node:url";
-import { randomUUID } from "node:crypto";
 // Shared module imported by both Engine and bin/digest.ts, so wire
 // projection and digest projection are structurally one function — no
 // drift between wire and digest possible.
 import PacketWire from "./packet-wire.js";
 import Results, { OperationFailureError } from "./results.js";
-import TerminalResult from "./TerminalResult.js";
-import LoopLifecycle from "./LoopLifecycle.js";
-import WorkerControlAddress from "./WorkerControlAddress.js";
 import Turn from "./Turn.js";
-import LogBody from "./LogBody.js";
-import LogVisibility from "./LogVisibility.js";
-import StrikeRail from "./StrikeRail.js";
 import StoredPacket from "./StoredPacket.js";
 import { observed, observedSync } from "../observe/spans.js";
-import { GEN_AI_REQUEST_SPAN, genAiRequestOptions, settleGenAiResponse, } from "../observe/genai.js";
-import { OPS_DISPATCHED, PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
-import { scheduleTurnOps } from "./turn-scheduler.js";
-import { expandSafeUriTargetGroup } from "./operation-target-groups.js";
-import { readOptimisticSettlementMs } from "./optimistic-settlement.js";
-import ModelCall, { ModelCallPersistenceError, ProviderAccountingIntegrityError, } from "./ModelCall.js";
+import { GEN_AI_REQUEST_SPAN, genAiRequestOptions, settleGenAiResponse } from "../observe/genai.js";
+import { PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
+import ModelCall, { ModelCallPersistenceError, ProviderAccountingIntegrityError } from "./ModelCall.js";
 import OverflowTurn from "./OverflowTurn.js";
 import TurnOps from "./TurnOps.js";
 import CapabilityPolicies from "./CapabilityPolicies.js";
 import CapabilityResolver from "./CapabilityResolver.js";
 import LoopPolicyReader from "./LoopPolicyReader.js";
-const ENGINE_PROBLEMS = Object.freeze({
-    max_commands_exceeded: {
-        status: 429,
-        code: "max-commands-exceeded",
-        detail: "Later operations were not executed because the turn exceeded its operation limit.",
-    },
-    idle_turn: {
-        status: 409,
-        code: "idle-turn",
-        detail: "`## SEND0 [102]` was emitted without an operation to continue from.",
-    },
-});
 // The prompt entry target - prompt:///<loop>/<N>, self-only ({§prompt-self-only}):
 // the owner rides the owner_id column, the address carries only the loop coordinate.
 const promptTarget = (loopSeq, promptOrdinal) => {
@@ -139,9 +114,13 @@ const readFilesItems = () => {
         return null;
     return normalizeFilesItems(Number.parseInt(raw, 10));
 };
-import { ProviderError, scopeEnvToAlias, } from "@plurnk/plurnk-providers";
+import { ProviderError, scopeEnvToAlias } from "@plurnk/plurnk-providers";
 import { validateGbnf } from "@plurnk/gbnf";
 import ProviderInstantiate from "./ProviderInstantiate.js";
+import TurnMaterialization from "./TurnMaterialization.js";
+import BareBatchRunner from "./BareBatchRunner.js";
+import { TERMINAL_SEND_SIGNALS, TURN_STATUS_IMPLICIT_CONTINUE } from "./turn-signals.js";
+import AdmittedTurnExecutor from "./AdmittedTurnExecutor.js";
 // A generated rail may constrain only the sampled continuation while the chat
 // template contributes a prefix that llama-server preserves in its response.
 // The artifact names the alternate root that composes those bytes for evidence
@@ -170,10 +149,6 @@ const curationOverflowFailure = (pressure) => Results.failure("engine:context",
     ceiling: pressure.budget,
     deficit: pressure.excess,
 });
-// Runtime normalization for a disposition the engine refuses or resolves as a
-// continue after dispatch ({§send}). Every admitted emission itself ends in an
-// explicit disposition SEND ({§emission-admission}).
-const TURN_STATUS_IMPLICIT_CONTINUE = 102;
 const INVALID_EMISSION_RECOVERY_MESSAGE = "Response rejected before dispatch; no operations were performed.";
 // {§output-allowance-notice} — THE single derivation of a ceiling cut: a
 // `length` finish is the engine's own allowance ending the emission, and it
@@ -205,7 +180,7 @@ const readProviderRecoveryBackoff = () => readMilliseconds("PLURNK_SERVICE_PROVI
 const RECOVERABLE_PROVIDER_FAILURES = new Set(["rate_limit", "network_failure", "deadline_exceeded", "resource_interrupted"]);
 // The wall's abort reason — runLoop branches a mid-turn teardown to the 504 terminal on it.
 export const LOOP_TIMEOUT_REASON = "loop_timeout";
-class TurnRunner {
+export default class TurnRunner {
     #db;
     #schemes;
     #mimetypes;
@@ -228,6 +203,9 @@ class TurnRunner {
     #dispatch;
     #resolveWorkerProviderIdentity;
     #gbnfCache = new Map();
+    #materialization;
+    #bareBatch;
+    #admitted;
     constructor({ db, schemes, mimetypes, weigh, notices, problems, strikes, packets, dispatcher, liveSubscriptions, streamEventNotify, reasoningEventNotify, loopPacketNotify, wakeWorkerNotify, executors, loopSignal, interactions, warmWorkspace, dispatch, resolveWorkerProviderIdentity, }) {
         this.#db = db;
         this.#schemes = schemes;
@@ -250,6 +228,9 @@ class TurnRunner {
         this.#warmWorkspace = warmWorkspace;
         this.#dispatch = dispatch;
         this.#resolveWorkerProviderIdentity = resolveWorkerProviderIdentity;
+        this.#materialization = new TurnMaterialization({ db: this.#db, schemes: this.#schemes, weighContent: this.#weighContent });
+        this.#bareBatch = new BareBatchRunner({ db: this.#db, providerAttributions: this.#providerAttributions.bind(this), providerFailure: TurnRunner.#providerFailure });
+        this.#admitted = new AdmittedTurnExecutor({ db: this.#db, schemes: this.#schemes, notices: this.#notices, problems: this.#problems, dispatcher: this.#dispatcher, bareBatch: this.#bareBatch });
     }
     async #recordInference(args) {
         await Turn.recordInference(this.#db, args.turnId, args.evidence);
@@ -268,9 +249,9 @@ class TurnRunner {
     // parse): warn once per message, never per turn; the turn records railsVerdict "unverifiable".
     static #railGapWarned = new Set();
     static #warnRailVerdictGapOnce(message) {
-        if (_a.#railGapWarned.has(message))
+        if (TurnRunner.#railGapWarned.has(message))
             return;
-        _a.#railGapWarned.add(message);
+        TurnRunner.#railGapWarned.add(message);
         process.stderr.write(`plurnk-engine: rail verdict unavailable — the configured grammar did not parse in @plurnk/gbnf (${message})\n`);
     }
     static #requireGrammarEvidence(response, allowWithheld) {
@@ -345,93 +326,6 @@ class TurnRunner {
         console.error("Provider failed outside its Problem Details contract:", error);
         return Results.failure("engine:provider", "provider-contract-violation", 502, "The provider failed without returning its required Problem Details.", {}, { stage: "provider-request", retryable: false });
     }
-    async #runBareBatch({ statements, provider, turnId, workspaceId, workerId, primaryWorkerId, loopSequence, turnSequence, signal, }) {
-        const prepared = [];
-        for (const statement of statements) {
-            const providerWorkerId = randomUUID();
-            const attributionContext = Object.freeze({
-                workspaceId: String(workspaceId),
-                workerId: providerWorkerId,
-                primaryWorkerId,
-                loop: loopSequence,
-                turn: turnSequence,
-                attempt: 1,
-            });
-            const attributions = this.#providerAttributions(provider, attributionContext);
-            const modelCall = await ModelCall.open(this.#db, {
-                turnId,
-                kind: "bare",
-                attributions,
-                model: provider.model,
-            });
-            prepared.push({ statement, modelCall, attributions, providerWorkerId });
-        }
-        const settlements = await Promise.allSettled(prepared.map(async ({ statement, modelCall, attributions, providerWorkerId }) => {
-            try {
-                const response = await observed(GEN_AI_REQUEST_SPAN, { model: provider.model, attempt: 1, kind: "bare" }, async (span) => {
-                    try {
-                        const generated = await provider.generate({
-                            messages: [{ role: "user", content: statement.body }],
-                            workerId: providerWorkerId,
-                            primaryWorkerId,
-                            signal,
-                            attributions: attributions.length > 0 ? attributions : undefined,
-                            workspaceId: String(workspaceId),
-                            loop: loopSequence,
-                            turn: turnSequence,
-                            observeRequest: modelCall.observeRequest,
-                            callKind: "bare",
-                        });
-                        modelCall.assertAccounting(generated.accounting);
-                        recordCounter(PROVIDER_CALLS, {
-                            model: provider.model,
-                            attempt: 1,
-                            status: "resolved",
-                        });
-                        span.setAttribute("status", "resolved");
-                        settleGenAiResponse(span, generated);
-                        return generated;
-                    }
-                    catch (error) {
-                        if (error instanceof ProviderError) {
-                            modelCall.assertAccounting(error.accounting);
-                        }
-                        throw error;
-                    }
-                }, genAiRequestOptions(ProviderInstantiate.aliasOf(provider) ?? "plurnk", provider.model));
-                await modelCall.observeResponse(response);
-                return {
-                    statement,
-                    modelCallId: modelCall.id,
-                    result: Results.assert({
-                        status: 200,
-                        content: response.assistant.content,
-                        mimetype: "text/plain",
-                    }),
-                };
-            }
-            catch (error) {
-                if (error instanceof ModelCallPersistenceError || error instanceof ProviderAccountingIntegrityError) {
-                    throw error;
-                }
-                const failure = _a.#providerFailure(error, signal);
-                if (error instanceof ProviderError && error.attempt !== undefined) {
-                    await modelCall.observeResponse(error.attempt, failure);
-                }
-                else {
-                    await modelCall.fail(failure);
-                }
-                return { statement, modelCallId: modelCall.id, result: failure };
-            }
-        }));
-        const internalFailure = settlements.find((settlement) => settlement.status === "rejected");
-        if (internalFailure !== undefined)
-            throw internalFailure.reason;
-        signal?.throwIfAborted();
-        return settlements.map((settlement) => settlement.value);
-    }
-    // {§attribution} — reporting derives from exact provider-request evidence;
-    // malformed durable tags fail here instead of being silently filtered.
     #offsetToLineColumn(content, offset) {
         const cps = Array.from(content);
         const clamped = Math.max(0, Math.min(offset, cps.length));
@@ -448,226 +342,22 @@ class TurnRunner {
         }
         return { line, column };
     }
-    // {§turn-ops-admission-path} — source acquisition ends before this seam.
-    // Every admitted producer program is scheduled, dispatched, recorded, and
-    // completed here; inference is only the model-specific way one program is
-    // acquired and supplied with BARE capability.
-    async executeAdmittedTurn({ statements, source, sourceFolded, sourceModelCallId = null, sourceReasoningItems, origin, workspaceId, workerId, loopId, turnId, fromSequence, maxCommands = Number.POSITIVE_INFINITY, enforceIdle = false, failOnOperationError = false, recoverableParseErrors = [], bare, signal, onDispatch, onSettled, }) {
-        const plan = statements[0];
-        const finalOp = statements.at(-1);
-        if (finalOp?.op !== "SEND") {
-            throw new Error("an admitted operation batch must end in a disposition SEND");
-        }
-        if (source !== null && plan?.op !== "PLAN") {
-            throw new Error("an admitted source-backed turnOps program must begin with PLAN");
-        }
-        const dispositionSignal = finalOp.signal;
-        if (typeof dispositionSignal !== "number" || !TERMINAL_SEND_SIGNALS.has(dispositionSignal)) {
-            throw new Error("an admitted turnOps program must end in a terminal disposition SEND");
-        }
-        let sendOp = finalOp;
-        let turnStatus = dispositionSignal;
-        let steerStruck = false;
-        const pendingEngineErrors = [];
-        const middleCount = statements.filter((statement) => statement.op !== "PLAN" && statement.op !== "SEND").length
-            + recoverableParseErrors.length;
-        if (enforceIdle && turnStatus === TURN_STATUS_IMPLICIT_CONTINUE && middleCount === 0) {
-            // {§send-idle-turn} — an empty [102] while the worker holds a live stream or child is a
-            // mis-spelled wait, not idleness: it parks as [202] and no strike (#441). The correction
-            // rides the SEND row's annotation — a park drops transient notices, the row survives the
-            // wake. With nothing in flight the idle-turn 409 stands.
-            if (await this.#dispatcher.hasLiveWork(workerId)) {
-                const note = "empty [102] while a stream or child is in flight waits like [202] - say [202] to wait on it";
-                sendOp = { ...finalOp, signal: 202, annotation: finalOp.annotation === null ? note : `${finalOp.annotation} · ${note}` };
-                turnStatus = 202;
-            }
-            else {
-                steerStruck = true;
-                pendingEngineErrors.push("idle_turn");
-            }
-        }
-        const turnStatements = sendOp === finalOp ? statements : statements.map((statement) => statement === finalOp ? sendOp : statement);
-        let realCommands = 0;
-        const admitted = turnStatements.filter((statement) => statement.op === "PLAN"
-            || statement === sendOp
-            || realCommands++ < maxCommands);
-        const scheduled = scheduleTurnOps(admitted.flatMap(expandSafeUriTargetGroup));
-        await this.#dispatcher.prepareEditBatches(scheduled.filter((statement) => statement.op === "EDIT"), { workspaceId, workerId, loopId, turnId, origin, onDispatch, onSettled });
-        const droppedCount = statements.length - admitted.length;
-        const bareStatements = scheduled.filter((statement) => statement.op === "BARE");
-        let bareResults = null;
-        const outcomes = [];
-        let rowSequence = fromSequence;
-        let parseErrorsRecorded = false;
-        const recordRecoverableParseErrors = async () => {
-            if (parseErrorsRecorded)
-                return;
-            parseErrorsRecorded = true;
-            for (const error of recoverableParseErrors) {
-                const envelopeDefault = error.message === PlurnkParser.MISSING_PLAN
-                    || error.message === PlurnkParser.MISSING_SEND;
-                const recorded = await this.#problems.record({
-                    workerId,
-                    loopId,
-                    turnId,
-                    sequence: rowSequence++,
-                    origin,
-                    source: "grammar",
-                    result: Results.failure("grammar:parser", "invalid-operation-syntax", 400, error.message, {}, {
-                        line: error.line,
-                        column: error.column,
-                        source: error.source,
-                        stage: "parse",
-                        ...(envelopeDefault ? {} : { siblingsRetained: true }),
-                        retryable: false,
-                    }),
-                });
-                outcomes.push({ op: null, status: recorded.result.status, problemType: recorded.result.problem?.type ?? null });
-                onDispatch?.(recorded.id);
-                await onSettled?.(recorded.id);
-            }
-        };
-        for (const statement of scheduled) {
-            if (statement === sendOp) {
-                await recordRecoverableParseErrors();
-                const execHandler = this.#schemes.get("exec");
-                await execHandler?.settleTurnSpawns?.(workerId, turnId, readOptimisticSettlementMs(), signal);
-            }
-            const result = await observed("op.dispatch", { op: statement.op }, async (span) => {
-                let dispatchResult;
-                if (statement.op === "BARE") {
-                    if (bare === undefined) {
-                        throw new Error(`${origin} turnOps cannot execute BARE without provider acquisition context`);
-                    }
-                    if (bareResults === null) {
-                        const batch = await this.#runBareBatch({
-                            statements: bareStatements,
-                            provider: bare.provider,
-                            turnId,
-                            workspaceId,
-                            workerId,
-                            primaryWorkerId: bare.primaryWorkerId,
-                            loopSequence: bare.loopSequence,
-                            turnSequence: bare.turnSequence,
-                            signal: bare.signal,
-                        });
-                        bareResults = new Map(batch.map((item) => [item.statement, item]));
-                    }
-                    const bareResult = bareResults.get(statement);
-                    if (bareResult === undefined) {
-                        throw new Error("BARE statement reached dispatch without its batch result");
-                    }
-                    dispatchResult = await this.#dispatcher.recordBareResult({
-                        statement,
-                        workspaceId,
-                        workerId,
-                        loopId,
-                        turnId,
-                        sequence: rowSequence,
-                        origin,
-                        onDispatch,
-                        onSettled,
-                    }, bareResult.result, bareResult.modelCallId);
-                }
-                else {
-                    dispatchResult = await this.#dispatcher.dispatch({
-                        statement,
-                        workspaceId,
-                        workerId,
-                        loopId,
-                        turnId,
-                        sequence: rowSequence,
-                        origin,
-                        onDispatch,
-                        onSettled,
-                    });
-                }
-                span.setAttribute("status", dispatchResult.status);
-                recordCounter(OPS_DISPATCHED, { op: statement.op, status: dispatchResult.status });
-                return dispatchResult;
-            });
-            outcomes.push({ op: statement.op, status: result.status, problemType: result.problem?.type ?? null });
-            if (failOnOperationError && result.status >= 400)
-                throw new OperationFailureError(result);
-            for (const normalization of result.scopeNormalizations ?? []) {
-                this.#notices.push(workspaceId, workerId, loopId, {
-                    source: "engine:slicer",
-                    kind: "scope_normalized",
-                    level: "warn",
-                    message: `Scope <${normalization.requested.join(",")}> was normalized to <${normalization.canonical.join(",")}>.`,
-                });
-            }
-            // {§edit-batch-merges} — every applied resolution is also a notice, so the row's
-            // `merged` fact is never the only place it is said.
-            for (const merge of result.merged ?? []) {
-                this.#notices.push(workspaceId, workerId, loopId, {
-                    source: "engine:slicer",
-                    kind: "edit_merged",
-                    level: "warn",
-                    message: `EDIT resolution applied: ${merge.rule} - the row's merged fact has the coordinates; verify before building on it.`,
-                });
-            }
-            if (statement === sendOp && result.status === 409) {
-                steerStruck = true;
-                turnStatus = TURN_STATUS_IMPLICIT_CONTINUE;
-            }
-            if (statement === sendOp
-                && result.status !== 409
-                && sendOp.target === null
-                && sendOp.signal === 202
-                && result.status !== 202) {
-                turnStatus = result.status;
-            }
-            rowSequence += result.rowsWritten ?? 1;
-        }
-        await recordRecoverableParseErrors();
-        if (droppedCount > 0)
-            pendingEngineErrors.push("max_commands_exceeded");
-        for (const kind of pendingEngineErrors) {
-            const problem = ENGINE_PROBLEMS[kind];
-            const extensions = kind === "max_commands_exceeded"
-                ? {
-                    operationLimit: maxCommands,
-                    omittedOperations: droppedCount,
-                    stage: "dispatch-admission",
-                    recovery: "Continue with no more than the configured operation limit.",
-                    retryable: false,
-                }
-                : {
-                    stage: "turn",
-                    recovery: "Perform an operation before continuing with `## SEND0 [102]`.",
-                    retryable: false,
-                };
-            await this.#problems.record({
-                workerId,
-                loopId,
-                turnId,
-                sequence: rowSequence++,
-                origin: "_plurnk",
-                source: "rail",
-                result: Results.failure("engine:rail", problem.code, problem.status, problem.detail, {}, extensions),
-            });
-        }
-        if (source !== null) {
-            await this.#dispatcher.writeTurnOps({
-                verbatim: source,
-                workerId,
-                loopId,
-                turnId,
-                sequence: rowSequence,
-                origin,
-                folded: sourceFolded,
-                modelCallId: sourceModelCallId,
-                ...(sourceReasoningItems !== undefined ? { reasoningItems: sourceReasoningItems } : {}),
-            });
+    // {§packet-attachment-parts} — a route receives, as native parts read from the scheme's bytes at
+    // request time, the packet's attachments of every kind its model accepts; every other attachment
+    // reaches it as the text projection alone.
+    async #wireMessages(packet, workspaceId, provider) {
+        const accepted = acceptedKinds(provider.inputModalities);
+        if (accepted.length === 0 || !(packet.attachments ?? []).some((attachment) => accepted.includes(attachment.kind))) {
+            return PacketWire.packetToWireMessages(packet);
         }
-        await Turn.complete(this.#db, turnId, turnStatus);
-        return {
-            status: turnStatus,
-            outcomes,
-            fingerprint: StrikeRail.fingerprintTurn(statements),
-            steerStruck,
-        };
+        return PacketWire.wireMessages(packet, async (attachment) => {
+            const handler = this.#schemes.get(attachment.scheme);
+            const source = handler?.byteSource?.(attachment.pathname, { db: this.#db, workspaceId });
+            if (source === undefined)
+                return null;
+            const total = await source.size();
+            return total === null || total === 0 ? null : source.read(1, total);
+        }, (kind) => accepted.includes(kind));
     }
     async runTurn({ provider, childProvider = provider, messages, recap = "", workspaceId, workerId, loopId, signal, onDispatch, onSettled, turnNumber = 1, maxTurns = 50, invalidEmissionRecoveryEntryId, }) {
         const transientOpenLogEntryId = typeof invalidEmissionRecoveryEntryId === "number"
@@ -764,10 +454,10 @@ class TurnRunner {
             if (initializationTurn !== null) {
                 const plan = {
                     op: "PLAN", delimiter: "", annotation: null,
-                    signal: null, target: null, metadata: null, lineMarker: null,
+                    target: null, metadata: null, lineMarker: null,
                     body: [
                         {
-                            content: "Persist Determinations and Decisions",
+                            content: "Determinations and Decisions must be persisted as `memory` items.",
                             status: "memory",
                         },
                         {
@@ -785,7 +475,7 @@ class TurnRunner {
                 // ({§op-mode-phases}: Mutate precedes Observe).
                 if (promptPublication !== null) {
                     const archive = {
-                        op: "COPY", delimiter: "", annotation: null, signal: ["+_plurnk", "+backup"],
+                        op: "COPY", delimiter: "", annotation: null,
                         source: { target: promptPublication.path, metadata: null, lineMarker: null },
                         destination: {
                             target: { kind: "url", raw: "worker://~/prompts.md", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: "/prompts.md", query: null, fragment: null },
@@ -815,7 +505,7 @@ class TurnRunner {
                             pathname: generatedPathname("/agents.md"), query: null, fragment: null,
                         };
                         const agentsRead = {
-                            op: "READ", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+policy"], target: agentsTarget,
+                            op: "READ", delimiter: "", annotation: null, target: agentsTarget,
                             metadata: null, lineMarker: null, body: null, position: UNKNOWN_POSITION,
                         };
                         initializationStatements.push(agentsRead);
@@ -846,7 +536,7 @@ class TurnRunner {
             // {§packet-git-status} — one post-reconciliation snapshot supplies both
             // the compact packet summary and each causal file event's exact XY state.
             const gitStatus = await GitState.status(this.#db, workspaceId, this.#loopSignal(loopId));
-            await this.#logFsFictions(workspaceId, fsDivergences, gitStatus);
+            await this.#materialization.logFsFictions(workspaceId, fsDivergences, gitStatus);
             // The refresh above may have changed bodies (including model/client edits
             // since the startup warm). Re-derive to completion before packet/model
             // construction. Membership is already current, so this pass does not
@@ -867,7 +557,7 @@ class TurnRunner {
                     const fileCap = filesItems > 0 && fileItems > 0 ? Math.min(filesItems, fileItems) : null;
                     // {§tools-resource-materialization} — a PLURNK_MCP_EXPANDED server
                     // contributes one FIND over its family document matching the
-                    // `## EXEC0` headings: one row per tool — heading, annotation,
+                    // `### EXEC0` headings: one row per tool — heading, annotation,
                     // signature — paged like every survey. No document is delivered
                     // unasked; per-target child documents do not exist.
                     const registry = this.#executors();
@@ -911,13 +601,13 @@ class TurnRunner {
                         if (admittedTools.length === 0)
                             continue;
                         const pattern = tools !== null && tools !== undefined && admittedTools.length !== tools.tools.length
-                            ? `^## EXEC0 \\[${regexLiteral(tag)}\\] \\((?:${admittedTools
+                            ? `^### EXEC0 \\[${regexLiteral(tag)}\\] \\((?:${admittedTools
                                 .map((tool) => regexLiteral(PathSyntax.escapeTarget(tool.target)))
                                 .join("|")})\\).*\\n.*$`
-                            : "^## EXEC0 .*\\n.*$";
+                            : "^### EXEC0 .*\\n.*$";
                         toolExpansions.push({
                             statement: {
-                                op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+tools"],
+                                op: "FIND", delimiter: "", annotation: null,
                                 target: { kind: "url", raw: `worker://~/_plurnk/tools/${tag}.md`, scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: generatedPathname(`/tools/${tag}.md`), query: null, fragment: null },
                                 metadata: null,
                                 body: { dialect: "regex", raw: `/${pattern.replaceAll("/", "\\/")}/m`, pattern, flags: "m" },
@@ -928,7 +618,7 @@ class TurnRunner {
                     const surveys = [
                         {
                             statement: {
-                                op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+skills"],
+                                op: "FIND", delimiter: "", annotation: null,
                                 target: { kind: "url", raw: "worker://~/_plurnk/skills/*.md", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: generatedPathname("/skills/*.md"), query: null, fragment: null },
                                 metadata: null,
                                 body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
@@ -936,7 +626,7 @@ class TurnRunner {
                         },
                         ...(plurnkCatalog === null ? [] : [{
                                 statement: {
-                                    op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+plurnk"],
+                                    op: "FIND", delimiter: "", annotation: null,
                                     target: plurnkCatalog,
                                     metadata: null,
                                     body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
@@ -950,7 +640,7 @@ class TurnRunner {
                                 // PLURNK_MCP_EXPANDED add a second survey of their complete
                                 // tool tree.
                                 statement: {
-                                    op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+tools"],
+                                    op: "FIND", delimiter: "", annotation: null,
                                     target: toolsCatalog,
                                     metadata: null,
                                     body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
@@ -962,7 +652,7 @@ class TurnRunner {
                             // alias level; each row's summary is the agent's identity line,
                             // the exact card stays pullable through READ a2a://<alias>.
                             statement: {
-                                op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+agents"],
+                                op: "FIND", delimiter: "", annotation: null,
                                 target: { kind: "url", raw: "worker://~/_plurnk/agents/*.md", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: generatedPathname("/agents/*.md"), query: null, fragment: null },
                                 metadata: null,
                                 body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
@@ -972,7 +662,7 @@ class TurnRunner {
                             // {§members-projection} — enabled members definitions survey at alias
                             // level; each row's summary is what its glob resolved to.
                             statement: {
-                                op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+members"],
+                                op: "FIND", delimiter: "", annotation: null,
                                 target: { kind: "url", raw: "worker://~/_plurnk/members/*.md", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: generatedPathname("/members/*.md"), query: null, fragment: null },
                                 metadata: null,
                                 body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
@@ -980,7 +670,7 @@ class TurnRunner {
                         },
                         {
                             statement: {
-                                op: "FIND", delimiter: "", annotation: "workspace files", signal: ["+_plurnk", "+init"],
+                                op: "FIND", delimiter: "", annotation: "workspace files",
                                 target: { kind: "local", raw: "*" },
                                 metadata: null,
                                 body: null,
@@ -990,7 +680,7 @@ class TurnRunner {
                         },
                         {
                             statement: {
-                                op: "FIND", delimiter: "", annotation: "workspace entries", signal: ["+_plurnk", "+init"],
+                                op: "FIND", delimiter: "", annotation: "workspace entries",
                                 target: { kind: "url", raw: "worker:///*", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: "/*", query: null, fragment: null },
                                 metadata: null,
                                 body: null, lineMarker: null, position: UNKNOWN_POSITION,
@@ -998,7 +688,7 @@ class TurnRunner {
                         },
                         {
                             statement: {
-                                op: "FIND", delimiter: "", annotation: "private worker entries", signal: ["+_plurnk", "+init"],
+                                op: "FIND", delimiter: "", annotation: "private worker entries",
                                 target: { kind: "url", raw: "worker://~/*", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: "/*", query: null, fragment: null },
                                 metadata: null,
                                 body: null, lineMarker: null, position: UNKNOWN_POSITION,
@@ -1009,7 +699,7 @@ class TurnRunner {
                 }
                 const send = {
                     op: "SEND", delimiter: "", annotation: null,
-                    signal: 102, target: null, metadata: null, lineMarker: null,
+                    status: 102, target: null, metadata: null, lineMarker: null,
                     body: { raw: "Next: Address the prompt.", json: null },
                     position: UNKNOWN_POSITION,
                 };
@@ -1053,7 +743,7 @@ class TurnRunner {
             const turnOpenPaths = [];
             if (promptPublication !== null) { // {§prompt-entry} — one durable publication per loop
                 turnOpenPaths.push(...promptPublication.openPaths);
-                const promptLogId = await this.#writePromptLog({
+                const promptLogId = await this.#materialization.writePromptLog({
                     workerId,
                     loopId,
                     turnId,
@@ -1084,7 +774,7 @@ class TurnRunner {
                         turnOpenPaths.push(...assertOpenPaths(attributes.openPaths, `Prompt ${injectedRow.pathname} openPaths`));
                     }
                     const ordinal = Number(injectedRow.pathname.split("/").filter(Boolean).at(-1));
-                    const promptLogId = await this.#writePromptLog({
+                    const promptLogId = await this.#materialization.writePromptLog({
                         workerId,
                         loopId,
                         turnId,
@@ -1103,7 +793,7 @@ class TurnRunner {
             for (const raw of turnOpenPaths) {
                 const pathname = raw.startsWith("/") ? raw : `/${raw}`;
                 const fileRead = {
-                    op: "READ", delimiter: "", annotation: null, signal: null, lineMarker: null,
+                    op: "READ", delimiter: "", annotation: null, lineMarker: null,
                     target: {
                         kind: "url", raw: `file://${pathname}`, scheme: "file",
                         username: null, password: null, hostname: null, port: null,
@@ -1125,8 +815,8 @@ class TurnRunner {
             // from a prior turn — this runs before the turn's own spawns) so a `<0>` never survives into
             // the subsequent turn. The terminal output then surfaces born-OPEN via the stream-delta path.
             await this.#reapTurnScopedStreams(workerId);
-            nextActionIndex += await this.#materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
-            nextActionIndex += await this.#materializeStreamDeltas({ workerId, loopId, turnId, fromSequence: nextActionIndex });
+            nextActionIndex += await this.#materialization.materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
+            nextActionIndex += await this.#materialization.materializeStreamDeltas({ workerId, loopId, turnId, fromSequence: nextActionIndex });
             // The post-reconciliation Git snapshot above is threaded into the packet
             // and every budget rebuild; overflow never shells again.
             // Notices are non-terminal observations, never operation-failure truth.
@@ -1205,7 +895,7 @@ class TurnRunner {
                     ...(curationFailure === undefined ? {} : { curationFailure }),
                 };
             }
-            let modelMessages = PacketWire.packetToWireMessages(requestPacket);
+            let modelMessages = await this.#wireMessages(requestPacket, workspaceId, provider);
             // Curation pressure and provider generation are independent. The
             // provider owns its configured total output envelope.
             let response;
@@ -1250,7 +940,7 @@ class TurnRunner {
                 if (promptProjection === "automatic") {
                     promptProjection = "withheld";
                     const candidate = await buildPacket();
-                    const candidateMessages = PacketWire.packetToWireMessages(candidate);
+                    const candidateMessages = await this.#wireMessages(candidate, workspaceId, provider);
                     if (JSON.stringify(candidateMessages) !== JSON.stringify(baselineMessages)) {
                         requestPacket = candidate;
                         modelMessages = candidateMessages;
@@ -1412,7 +1102,7 @@ class TurnRunner {
                                 throw error;
                             }
                             recoveryFailures += 1;
-                            const failure = _a.#providerFailure(error, providerSignal);
+                            const failure = TurnRunner.#providerFailure(error, providerSignal);
                             if (error.attempt !== undefined) {
                                 // {§provider-interrupted-attempt} — the interrupted response stays durable
                                 // as an unaccepted attempt; it is never admitted or replayed.
@@ -1452,7 +1142,7 @@ class TurnRunner {
                             || !await recoverCapacityPacket()) {
                             throw error;
                         }
-                        const failure = _a.#providerFailure(error, providerSignal);
+                        const failure = TurnRunner.#providerFailure(error, providerSignal);
                         await currentModelCall.fail(failure, error.capacity ?? null);
                         providerCallInFlight = false;
                         await this.#problems.record({
@@ -1467,7 +1157,7 @@ class TurnRunner {
                         // Include the durable recovery signal in the replacement
                         // request while preserving the selected recovery posture.
                         requestPacket = await buildPacket();
-                        modelMessages = PacketWire.packetToWireMessages(requestPacket);
+                        modelMessages = await this.#wireMessages(requestPacket, workspaceId, provider);
                         continue;
                     }
                     finally {
@@ -1488,7 +1178,7 @@ class TurnRunner {
                     await currentModelCall.observeResponse(completedResponse);
                     railEvidence = railGrammar === undefined
                         ? undefined
-                        : _a.#requireGrammarEvidence(completedResponse, railAllowWithheld);
+                        : TurnRunner.#requireGrammarEvidence(completedResponse, railAllowWithheld);
                     splitResponse = this.#splitResponse(completedResponse);
                     await classifyProviderAttempt(attemptRow.id, splitResponse, attempt, splitResponse.emissionValid);
                     if (splitResponse.emissionValid)
@@ -1526,7 +1216,7 @@ class TurnRunner {
                 if (providerAttemptId === null || providerModelCall === null) {
                     throw new Error("provider call failed without durable model-call and attempt identities", { cause: err });
                 }
-                const failure = _a.#providerFailure(err, providerSignal);
+                const failure = TurnRunner.#providerFailure(err, providerSignal);
                 const capacityFailure = err instanceof ProviderError && err.kind === "capacity_exceeded";
                 // {§provider-interrupted-attempt} — a provider-declared interruption
                 // carries response evidence without becoming a completed exchange.
@@ -1773,7 +1463,7 @@ class TurnRunner {
                     verdict = validateGbnf(railResponseGrammar, railEvidence.input);
                 }
                 catch (cause) {
-                    _a.#warnRailVerdictGapOnce(cause.message);
+                    TurnRunner.#warnRailVerdictGapOnce(cause.message);
                 }
                 railKeys = {
                     railsAttached: railEvidence.transported ? "client" : "withheld",
@@ -1957,21 +1647,20 @@ class TurnRunner {
         const plan = ops[0]?.op === "PLAN" ? ops[0] : undefined;
         const finalOp = ops.at(-1);
         const terminalSend = finalOp?.op === "SEND"
-            && typeof finalOp.signal === "number"
-            && TERMINAL_SEND_SIGNALS.has(finalOp.signal)
+            && finalOp.status !== null
+            && TERMINAL_SEND_SIGNALS.has(finalOp.status)
             ? finalOp
             : undefined;
-        const recoveredPlan = plan?.position.line === 0;
         const recoveredSend = terminalSend?.position.line === 0;
-        const recoverableParseErrors = plan !== undefined && terminalSend !== undefined && !hasUnparsedTail
-            ? parseErrors.filter((error) => (error.message === PlurnkParser.MISSING_PLAN
-                || error.message === PlurnkParser.MISSING_SEND
-                || ((recoveredPlan || comparePosition(error, plan.position) > 0)
+        // {§turn-shape} — PLAN is a SHOULD: a turn without one is complete once it ends in a
+        // terminal SEND, and the recoverable window then starts at the turn's first statement.
+        const recoverableParseErrors = terminalSend !== undefined && !hasUnparsedTail
+            ? parseErrors.filter((error) => (error.message === PlurnkParser.MISSING_SEND
+                || ((plan === undefined || comparePosition(error, plan.position) > 0)
                     && (recoveredSend || comparePosition(error, terminalSend.position) < 0)))).toSorted(comparePosition)
             : [];
         const emissionValid = preParsedOps !== undefined
-            || (plan !== undefined
-                && terminalSend !== undefined
+            || (terminalSend !== undefined
                 && sourceStatementCount > 0
                 && !hasUnparsedTail
                 && recoverableParseErrors.length === parseErrors.length);
@@ -1984,7 +1673,7 @@ class TurnRunner {
             recoverableParseErrors: emissionValid ? recoverableParseErrors : [],
             parseNotices,
             // The ANTLR model-turn parser is authoritative. At least one source
-            // operation lets omitted PLAN/SEND ceremony default around it; the
+            // operation lets an omitted terminal SEND default around it; the
             // exact defaults and bounded statement failures become durable
             // operation results. Boundary loss and an unparsed tail still reject
             // wholesale. Pre-parsed ops are Mock's trusted test seam.
@@ -1993,102 +1682,6 @@ class TurnRunner {
     }
     // #note12 — plugin reference docs are materialized beneath
     // worker://~/_plurnk/plurnk/ by LoopDocs.
-    async #materializeEnvironmentDeltas(args) {
-        const { workspaceId, workerId, loopId, turnId, fromSequence } = args;
-        const rows = await this.#db.engine_pull_ambient_events.all({ workspace_id: workspaceId, worker_id: workerId });
-        const window = rows[0];
-        if (window === undefined)
-            throw new Error(`ambient pull: worker ${workerId} has no observation window`);
-        let written = 0;
-        for (const r of rows) {
-            if (r.event_id === null || r.producer_worker_id === null || r.producer_worker_name === null || r.kind === null
-                || r.at === null || r.op === null || r.delimiter === null || r.tx === null || r.mimetype_tx === null
-                || r.rx === null || r.mimetype_rx === null || r.status_rx === null || r.state === null)
-                continue;
-            const termination = r.kind === "loop_termination";
-            const terminal = termination
-                ? TerminalResult.parse(r.rx, `ambient loop-termination event ${r.event_id}`)
-                : null;
-            if (terminal !== null && terminal.status !== r.status_rx) {
-                throw new Error(`ambient loop-termination event ${r.event_id} status ${r.status_rx} does not match its terminal result status ${terminal.status}`);
-            }
-            let attrs = r.attrs ?? "{}";
-            const parsedTags = JSON.parse(r.tags ?? "[]");
-            if (!Array.isArray(parsedTags) || !parsedTags.every((tag) => typeof tag === "string" && tag.length > 0)) {
-                throw new TypeError(`ambient event ${r.event_id} tags must be an array of nonempty strings`);
-            }
-            const tags = [...new Set(parsedTags)].toSorted();
-            if (tags.length !== parsedTags.length || tags.some((tag, index) => tag !== parsedTags[index])) {
-                throw new TypeError(`ambient event ${r.event_id} tags must be unique and sorted`);
-            }
-            if (terminal !== null) {
-                const inherited = JSON.parse(attrs);
-                if (inherited === null || typeof inherited !== "object" || Array.isArray(inherited)) {
-                    throw new TypeError(`ambient loop-termination event ${r.event_id} attrs must be an object`);
-                }
-                attrs = JSON.stringify({
-                    ...inherited,
-                    kind: "loop_termination",
-                    ...(r.terminated_by === null ? {} : { terminatedBy: r.terminated_by }),
-                });
-            }
-            const inserted = await this.#db.engine_insert_ambient_delta.get({
-                worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: fromSequence + written,
-                at: r.at,
-                event_id: r.event_id,
-                source: WorkerControlAddress.render(r.producer_worker_name),
-                op: r.op,
-                delimiter: r.delimiter,
-                signal: r.signal,
-                scheme: r.scheme,
-                username: r.username,
-                password: r.password,
-                hostname: r.hostname,
-                port: r.port,
-                pathname: r.pathname,
-                query: r.query,
-                fragment: r.fragment,
-                line_marker: r.line_marker,
-                tx: r.tx,
-                mimetype_tx: r.mimetype_tx,
-                rx: r.rx,
-                mimetype_rx: r.mimetype_rx,
-                status: r.status_rx,
-                weight: LogBody.weight({
-                    op: r.op,
-                    attrs,
-                    tx: r.tx,
-                    rx: r.rx,
-                    mimetypeTx: r.mimetype_tx,
-                    mimetypeRx: r.mimetype_rx,
-                }, this.#weighContent),
-                state: r.state,
-                outcome: r.outcome,
-                folded: LogVisibility.serialize(terminal !== null && terminal.status >= 200 && terminal.status < 300
-                    ? LogVisibility.OPEN
-                    : LogVisibility.FOLDED),
-                attrs,
-            });
-            const materialized = inserted ?? await this.#db.engine_ambient_delta_id.get({
-                worker_id: workerId,
-                event_id: r.event_id,
-            });
-            if (materialized === undefined)
-                throw new Error(`ambient event ${r.event_id} has no observer log row after materialization`);
-            for (const tag of tags) {
-                await this.#db.log_write_tag.run({ log_entry_id: materialized.id, tag });
-            }
-            if (inserted !== undefined)
-                written++;
-        }
-        await this.#db.engine_advance_ambient_cursor.get({
-            workspace_id: workspaceId,
-            worker_id: workerId,
-            cursor: window.cursor,
-            boundary: window.boundary,
-        });
-        return written;
-    }
     // {§exec-poll} — EXEC `<0>` is turn-scoped: abort the worker's open turn-scoped streams via their
     // owning scheme (the same registry-routed abort the total reap uses). Called at each pre-turn
     // before the turn's own spawns, so every open turn-scoped sub here is from a prior turn — it
@@ -2098,195 +1691,8 @@ class TurnRunner {
         const open = await this.#db.find_open_turn_scoped_subscriptions_for_worker.all({ worker_id: workerId });
         await Promise.all(open.map(({ id }) => this.#liveSubscriptions.cancel(id)));
     }
-    async #materializeStreamDeltas(args) {
-        const { workerId, loopId, turnId, fromSequence } = args;
-        const channels = await this.#db.engine_worker_stream_channels.all({ worker_id: workerId });
-        let written = 0;
-        for (const ch of channels) {
-            // Default channels are an implementation detail. Preserve the
-            // channel internally on the entry/subscription, but present the
-            // ordinary address to the model; only an explicitly non-default
-            // channel earns a fragment in the log.
-            const visibleFragment = ch.published_channel !== null
-                && ch.channel === this.#schemes.defaultChannelFor(ch.runtime, workerId)
-                ? null
-                : ch.channel;
-            const targetParts = authorityParts(ch.authority);
-            // {§exec-stream} — nothing publishes while a stream is active: the Child Streams
-            // section reports its size and growth ({§child-orientation}); the model READs any
-            // range it wants. At close, ONE foisted READ that is exactly a markerless READ —
-            // the first page, the extent, the terminal status and Problem — born OPEN. {§exec-stream-page}
-            if (ch.state !== "closed" && ch.state !== "errored")
-                continue;
-            const terminal = Results.assert(JSON.parse(ch.producer_result ?? "null"));
-            const sequence = fromSequence + written;
-            const source = this.#schemes.isRuntimeScheme(ch.runtime, workerId)
-                && /^\/[1-9]\d*\/[1-9]\d*\/[1-9]\d*$/.test(ch.coord)
-                ? `log://${ch.coord}/EXEC`
-                : null;
-            const page = await ReadResolve.resolve({ content: ch.content, mimetype: ch.mimetype, lineMarker: null });
-            const result = Results.assert({
-                ...terminal,
-                ...(terminal.problem === undefined ? {} : { problem: { ...terminal.problem } }),
-                content: page.content ?? "",
-                mimetype: page.mimetype,
-                ...(page.startLine === undefined || page.startLine === null ? {} : { startLine: page.startLine }),
-                ...(page.range === undefined ? {} : { range: page.range }),
-            });
-            if (result.problem !== undefined) {
-                const seqs = await this.#db.engine_loop_turn_seqs.get({
-                    loop_id: loopId,
-                    turn_id: turnId,
-                });
-                if (seqs === undefined)
-                    throw new Error(`stream delta has no log coordinate for loop=${loopId} turn=${turnId}`);
-                Results.attachInstance(result, `log:///${seqs.loop_seq}/${seqs.turn_seq}/${sequence}/READ`);
-            }
-            const rx = JSON.stringify(result);
-            await this.#db.engine_insert_stream_delta.run({
-                worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence,
-                subscription_publication_id: ch.publication_id,
-                source,
-                scheme: ch.runtime, hostname: targetParts.hostname, port: targetParts.port,
-                pathname: ch.coord, fragment: visibleFragment,
-                rx,
-                weight: LogBody.weight({
-                    op: "READ",
-                    attrs: {},
-                    tx: "",
-                    rx,
-                    mimetypeTx: "text/plain",
-                    mimetypeRx: "application/json",
-                }, this.#weighContent),
-                status: terminal.status,
-                attrs: JSON.stringify({ streamEnd: ch.content.length, terminal: true }),
-                folded: LogVisibility.serialize(LogVisibility.OPEN), // {§exec-stream} — the conclusion is born OPEN
-            });
-            written++;
-        }
-        return written;
-    }
-    // {§env-delta-filesystem-narration} {§membership-emi-divergence-signal}
-    // — record project-file divergence once through the reserved actor.
-    async #logFsFictions(workspaceId, divergences, gitStatus) {
-        if (divergences.length === 0)
-            return;
-        const gitByPath = new Map(gitStatus?.files.map(({ path, status }) => [path, status]) ?? []);
-        const worker = await this.#db.envelope_get_worker_by_name.get({ workspace_id: workspaceId, name: "plurnk" })
-            ?? await this.#db.envelope_insert_worker.get({ workspace_id: workspaceId, name: "plurnk", origin: "_plurnk" });
-        if (worker === undefined)
-            throw new Error("logFsFictions: plurnk worker resolution returned no row");
-        const loop = await this.#db.envelope_insert_client_loop.get({ worker_id: worker.id });
-        if (loop === undefined)
-            throw new Error("logFsFictions: loop insert returned no row");
-        const turn = await Turn.open(this.#db, { loopId: loop.id, producer: "_plurnk", kind: "operation" });
-        let turnOpen = true;
-        try {
-            let sequence = 1;
-            for (const d of divergences) {
-                const span = editedSpan(d.before, d.after);
-                const rx = JSON.stringify({ status: 200, entryId: d.entryId, channel: d.channel, span });
-                const attrs = gitByPath.has(d.pathname)
-                    ? JSON.stringify({ git: gitByPath.get(d.pathname) })
-                    : "{}";
-                await this.#db.engine_insert_log_entry.get({
-                    worker_id: worker.id, loop_id: loop.id, turn_id: turn.id, sequence: sequence++,
-                    origin: "_plurnk", source: "file", model_call_id: null,
-                    op: "EDIT", delimiter: "", signal: null,
-                    // Match Dispatcher.#extractTarget: a bare file address has NULL scheme
-                    // only in log target metadata; its entry identity remains `file`.
-                    scheme: null, username: null, password: null, hostname: null, port: null,
-                    pathname: d.pathname, query: null, fragment: null, lineMarker: null,
-                    tx: "", mimetype_tx: "text/plain",
-                    rx, mimetype_rx: "application/json",
-                    status_rx: 200,
-                    weight: LogBody.weight({
-                        op: "EDIT",
-                        attrs,
-                        tx: "",
-                        rx,
-                        mimetypeTx: "text/plain",
-                        mimetypeRx: "application/json",
-                    }, this.#weighContent),
-                    state: "resolved", outcome: null,
-                    attrs,
-                    initial_folded: LogVisibility.serialize(LogVisibility.OPEN),
-                });
-            }
-            await Turn.complete(this.#db, turn.id, 200);
-            turnOpen = false;
-            const closed = await new LoopLifecycle(this.#db).finish(loop.id, { status: 200 });
-            if (closed === null)
-                throw new Error(`logFsFictions: narration loop ${loop.id} was not open at completion`);
-        }
-        catch (cause) {
-            const settlementFailures = [];
-            const failure = Results.failure("engine:filesystem-narration", "narration-failed", 500, "Filesystem divergence narration failed before its operation turn settled.", {}, { stage: "filesystem-narration", retryable: false });
-            if (turnOpen) {
-                try {
-                    await Turn.complete(this.#db, turn.id, failure.status);
-                }
-                catch (turnCause) {
-                    settlementFailures.push(turnCause);
-                }
-            }
-            try {
-                await new LoopLifecycle(this.#db).finish(loop.id, failure);
-            }
-            catch (loopCause) {
-                settlementFailures.push(loopCause);
-            }
-            if (settlementFailures.length > 0) {
-                throw new AggregateError([cause, ...settlementFailures], `filesystem narration ${turn.id} failed to settle`);
-            }
-            throw cause;
-        }
-    }
-    async #writePromptLog({ workerId, loopId, turnId, sequence, target, content, source, }) {
-        const rx = JSON.stringify({ content, mimetype: "text/markdown" });
-        const row = await this.#db.engine_insert_log_entry.get({
-            worker_id: workerId,
-            loop_id: loopId,
-            turn_id: turnId,
-            sequence,
-            origin: "_plurnk",
-            source,
-            model_call_id: null,
-            op: "prompt",
-            delimiter: "",
-            signal: null,
-            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: null,
-            tx: "",
-            mimetype_tx: "text/plain",
-            rx,
-            mimetype_rx: "application/json",
-            status_rx: 200,
-            weight: LogBody.weight({
-                op: "prompt",
-                attrs: {},
-                tx: "",
-                rx,
-                mimetypeTx: "text/plain",
-                mimetypeRx: "application/json",
-            }, this.#weighContent),
-            state: "resolved",
-            outcome: null,
-            attrs: "{}",
-            initial_folded: LogVisibility.serialize(LogVisibility.OPEN),
-        });
-        if (row === undefined)
-            throw new Error("TurnRunner.#writePromptLog: INSERT ... RETURNING produced no row");
-        return row.id;
+    async executeAdmittedTurn(...args) {
+        return this.#admitted.executeAdmittedTurn(...args);
     }
 }
-_a = TurnRunner;
-export default TurnRunner;
 //# sourceMappingURL=TurnRunner.js.map