@plurnk/plurnk-service 4.2.1 → 4.3.1

package/dist/core/TurnRunner.js

@@ -1,11 +1,11 @@
+import StoredPacket, {} from "./StoredPacket.js";
 import NativeContent from "./NativeContent.js";
 import { PlurnkParser, parsePath } from "@plurnk/plurnk-parser";
-import { PathSyntax, PlurnkParseError, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
+import { PathSyntax, PlurnkParseError, UNKNOWN_POSITION, Validator } from "@plurnk/plurnk-contracts";
 import WorkerOwners from "./WorkerOwners.js";
 import { setTimeout as delay } from "node:timers/promises";
-import { aggregateProviderAccounting } from "@plurnk/plurnk-providers";
+import { aggregateProviderAccounting, ProviderError, scopeEnvToAlias, } from "@plurnk/plurnk-providers";
 const comparePosition = (a, b) => a.line - b.line || a.column - b.column;
-import { Mimetypes } from "@plurnk/plurnk-mimetypes";
 import FabricatedLog from "./FabricatedLog.js";
 import Meta, { Knob } from "@plurnk/plurnk-meta";
 import GitMembership from "./git-membership.js";
@@ -14,7 +14,6 @@ import GitState, {} from "./git-state.js";
 import WorkspaceSettings from "./workspace-settings.js";
 import { generatedPathname } from "./plurnk-uri.js";
 import { contentWeight } from "./content-weight.js";
-import LiveSubscriptions from "./LiveSubscriptions.js";
 import { readFile } from "node:fs/promises";
 import { resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
@@ -31,16 +30,9 @@ import PacketWire from "./packet-wire.js";
 import { RECEIPT_RESERVE, reserved } from "./ContextFit.js";
 import Results, { OperationFailureError } from "./results.js";
 import Turn, {} from "./Turn.js";
-// TurnRunner owns one inference cycle and any initialization turn
-// that precedes provider admission; Engine retains the surrounding loop
-// lifecycle and public facade.
-import NoticeChannel from "./NoticeChannel.js";
 import ProviderRecovery from "./ProviderRecovery.js";
-import ProblemLog from "./ProblemLog.js";
-import StrikeRail, {} from "./StrikeRail.js";
-import PacketBuilder, {} from "./PacketBuilder.js";
-import StoredPacket, {} from "./StoredPacket.js";
-import Dispatcher from "./Dispatcher.js";
+import {} from "./StrikeRail.js";
+import {} from "./PacketBuilder.js";
 import { observed, observedSync } from "../observe/spans.js";
 import { genAiRequestName, genAiRequestOptions, settleGenAiResponse } from "../observe/genai.js";
 import { PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
@@ -65,7 +57,7 @@ const workerCatalogTarget = (namespace) => {
     };
 };
 const assertOpenPaths = (value, source) => {
-    if (!Array.isArray(value) || value.some((path) => typeof path !== "string" || path.length === 0)) {
+    if (!Array.isArray(value) || !value.every((path) => typeof path === "string" && path.length > 0)) {
         throw new TypeError(`${source}: expected an array of non-empty strings`);
     }
     return value;
@@ -93,14 +85,14 @@ const readFilesItems = () => {
         return null;
     return normalizeFilesItems(Number.parseInt(raw, 10));
 };
-import { ProviderError, scopeEnvToAlias } from "@plurnk/plurnk-providers";
+// Provider contract owned by @plurnk/plurnk-providers; engine is the consumer.
 import ProviderInstantiate from "./ProviderInstantiate.js";
 import TurnMaterialization from "./TurnMaterialization.js";
 import BareBatchRunner from "./BareBatchRunner.js";
-import { ENGINE_PROBLEMS, TURN_STATUS_IMPLICIT_CONTINUE, outputAllowance } from "./turn-signals.js";
+import { TURN_STATUS_IMPLICIT_CONTINUE, outputAllowance } from "./turn-signals.js";
 import AdmittedTurnExecutor from "./AdmittedTurnExecutor.js";
-// {§context-wall} — the window's one terminal: the packet cannot fit the model's window even as receipts.
-const WINDOW_OVERFLOW_DETAIL = "Context window overflow: the packet cannot fit the model's window even as receipts.";
+// {§context-wall} — the window's one terminal: the packet exceeds the model's window.
+const WINDOW_OVERFLOW_DETAIL = "Context window overflow: the packet exceeds the model's window.";
 const windowOverflowFailure = (overflow) => Results.failure("engine:context", "window-overflow", 413, WINDOW_OVERFLOW_DETAIL, {}, { tokens: overflow.tokens, budget: overflow.budget, wall: overflow.wall, excess: overflow.excess });
 // {§context-over-budget-row} — over budget is a row and a request: the row is how the model hears it.
 // {§context-over-budget-row} — the row is the mandate; the gauge is the one home for the numbers
@@ -110,16 +102,12 @@ const OVER_BUDGET_DETAIL = "Context exceeds budget. YOU MUST ONLY KILL, MOVE or
 // labelled as the card's own plan example is: the worker's plan in steps, then its next step.
 const INITIALIZATION_NOTE = {
     op: "NOTE", aside: "plan", metadata: null, target: null, lineMarker: null,
-    body: [
-        "1. Survey the tooling, documentation, extended context, and project root: what exists decides what can be done.",
-        "2. Read the Open Message and restate what it asks for and what will show it is done.",
-        "3. Do the work, saving all new facts, ideas, and plans in NOTEs for later turns.",
-    ].join("\n"),
+    body: ["1. Survey the environment.", "2. Evaluate and react to the Open Message."].join("\n"),
     position: UNKNOWN_POSITION,
 };
 const INITIALIZATION_CLOSING_NOTE = {
     op: "NOTE", aside: "plan", metadata: null, target: null, lineMarker: null,
-    body: "Read and resolve the Open Message.", position: UNKNOWN_POSITION,
+    body: "Evaluate and react to the Open Message.", position: UNKNOWN_POSITION,
 };
 // {§continued-without-note} — said once, in the next packet, of a continuing turn that carried no NOTE.
 const CONTINUED_WITHOUT_NOTE = "The turn continued without a NOTE.";
@@ -168,7 +156,6 @@ export default class TurnRunner {
     #weighContent;
     #notices;
     #problems;
-    #strikes;
     #packets;
     #dispatcher;
     #liveSubscriptions;
@@ -180,19 +167,19 @@ export default class TurnRunner {
     #warmWorkspace;
     #dispatch;
     #resolveWorkerProviderIdentity;
+    #loopGauge;
     // {§operator-grammar} — one read per path per daemon; the file is the operator's and static.
     #grammarCache = new Map();
     #materialization;
     #bareBatch;
     #admitted;
-    constructor({ db, schemes, mimetypes, weigh, notices, problems, strikes, packets, dispatcher, liveSubscriptions, notify, executors, loopSignal, interactions, warmWorkspace, dispatch, resolveWorkerProviderIdentity, }) {
+    constructor({ db, schemes, mimetypes, weigh, notices, problems, packets, dispatcher, liveSubscriptions, notify, executors, loopSignal, interactions, warmWorkspace, dispatch, resolveWorkerProviderIdentity, loopGauge, }) {
         this.#db = db;
         this.#schemes = schemes;
         this.#mimetypes = mimetypes;
         this.#weighContent = weigh;
         this.#notices = notices;
         this.#problems = problems;
-        this.#strikes = strikes;
         this.#packets = packets;
         this.#dispatcher = dispatcher;
         this.#liveSubscriptions = liveSubscriptions;
@@ -204,6 +191,7 @@ export default class TurnRunner {
         this.#warmWorkspace = warmWorkspace;
         this.#dispatch = dispatch;
         this.#resolveWorkerProviderIdentity = resolveWorkerProviderIdentity;
+        this.#loopGauge = loopGauge;
         this.#materialization = new TurnMaterialization({ db: this.#db, weighContent: this.#weighContent, mimetypes: this.#mimetypes });
         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 });
@@ -215,10 +203,14 @@ export default class TurnRunner {
         const packetCount = await this.#db.engine_loop_packet_count.get({ loop_id: args.loopId });
         if (packetCount === undefined)
             throw new Error(`loop ${args.loopId}: packet count row missing`);
+        // {§tokenomics-client-gauge} The turn's inference is recorded: its packet and its call are the gauge now.
+        const gauge = await this.#loopGauge(args.loopId);
         this.#notify.loopPacketNotify(args.workspaceId, {
             workerId: args.workerId,
             loopId: args.loopId,
+            loopSeq: packetCount.sequence,
             packetCount: packetCount.count,
+            gauge,
         });
     }
     // {§operator-grammar} — the operator's grammar text for this provider, or undefined when
@@ -417,28 +409,26 @@ export default class TurnRunner {
         const initializationStatements = [];
         // {§worker-initialization-entry} — the worker's first turn is the worked
         // example itself: the actual orienting operations.
-        // {§turn0-agents-stunt} — the project AGENTS.md (materialized by LoopDocs as
-        // worker:///_plurnk/AGENTS.md) gets one foisted READ on the worker's first
-        // loop, so local repo guidance is visible turn-0 content. Global policy
-        // stays in the system prompt; nothing else is force-read.
+        // {§turn0-agents-stunt} {§turn0-local-instructions} — the project AGENTS.md, then its AGENTS.local.md (materialized
+        // by LoopDocs under worker:///_plurnk/), each get one foisted READ on the worker's first loop, so local repo
+        // guidance is visible turn-0 content. Global policy stays in the system prompt; nothing else is force-read.
         if (initializationTurn !== null) {
-            const agentsEntry = await this.#db.crud_find_workspace_entry.get({
-                workspace_id: workspaceId,
-                scheme: "worker",
-                authority: "",
-                pathname: generatedPathname("/AGENTS.md"),
-            });
-            if (agentsEntry !== undefined) {
-                const agentsTarget = {
-                    kind: "url", raw: "worker:///_plurnk/AGENTS.md", scheme: "worker",
+            for (const name of ["/AGENTS.md", "/AGENTS.local.md"]) {
+                const pathname = generatedPathname(name);
+                const entry = await this.#db.crud_find_workspace_entry.get({
+                    workspace_id: workspaceId, scheme: "worker", authority: "", pathname,
+                });
+                if (entry === undefined)
+                    continue;
+                const target = {
+                    kind: "url", raw: `worker://${pathname}`, scheme: "worker",
                     username: null, password: null, hostname: null, port: null,
-                    pathname: generatedPathname("/AGENTS.md"), query: null, fragment: null,
+                    pathname, query: null, fragment: null,
                 };
-                const agentsRead = {
-                    op: "READ", aside: null, target: agentsTarget,
+                initializationStatements.push({
+                    op: "READ", aside: null, target,
                     metadata: null, lineMarker: null, matcher: null, body: null, position: UNKNOWN_POSITION,
-                };
-                initializationStatements.push(agentsRead);
+                });
             }
         }
         return {
@@ -513,7 +503,17 @@ export default class TurnRunner {
         // {§emission-row} — a `_plurnk` turn has receipts, never a fabricated assistant emission.
         // {§message-arrival} — the message reaches the model as an inbound SEND in the first
         // model turn; initialization does not READ it a second time.
-        const admittedInitializationStatements = initializationStatements.filter((statement) => this.#capabilities.allowsAcross(statement, workspaceId, initializationPolicies));
+        const admittedInitializationStatements = [];
+        for (const statement of initializationStatements) {
+            if (!this.#capabilities.allowsAcross(statement, workspaceId, initializationPolicies))
+                continue;
+            // {§actor-boundary-catalog-preview} — a survey that would select nothing is left out of the program.
+            if (statement.op === "FIND" && !await this.#dispatcher.selects(statement, {
+                workspaceId, workerId, loopId, turnId: initializationTurn.id, origin: "_plurnk",
+            }))
+                continue;
+            admittedInitializationStatements.push(statement);
+        }
         if (admittedInitializationStatements.length === 0) {
             // Nothing to survey (the preview off, no project guidance): the turn opens and completes empty.
             await Turn.complete(this.#db, initializationTurn.id, 200);
@@ -541,7 +541,7 @@ export default class TurnRunner {
             turnId: initializationTurn.id,
             fromSequence: 1,
             failOnOperationError: true,
-            fit: this.#fitFor(args, { turnId: initializationTurn.id, seq: initializationTurn.sequence, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId, projection: { bodiless: new Set(), omitEmissionHistory: false } }),
+            fit: this.#fitFor(args, { turnId: initializationTurn.id, seq: initializationTurn.sequence, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId }),
             signal: this.#loopSignal(loopId),
             onDispatch,
             onSettled,
@@ -553,18 +553,11 @@ export default class TurnRunner {
     // {§actor-boundary-catalog-preview} — the opening surveys, each admitted only when
     // its scheme is registered for the workspace. A positive filesItems caps the
     // project rows.
-    async #catalogSurveys({ workspaceId }, { workerName, initializationPolicies, loopSequence }, filesItems) {
+    async #catalogSurveys({ workspaceId }, { workerName, initializationPolicies }, filesItems) {
         const catalogSchemes = await this.#db.engine_scheme_catalog_summary.all({ workspace_id: workspaceId });
         const fileItems = catalogSchemes.find(({ scheme }) => scheme === "file")?.shallow_items ?? 0;
         const fileCap = filesItems > 0 && fileItems > 0 ? Math.min(filesItems, fileItems) : null;
         const surveys = [
-            {
-                // Trial (#1073): the survey reads its own program, so the log carries one program verbatim
-                // and shows that every ops:// turn is readable.
-                op: "READ", aside: "this program",
-                target: { kind: "url", raw: `ops://${workerName}/${loopSequence}/1`, scheme: "ops", username: null, password: null, hostname: workerName, port: null, pathname: `/${loopSequence}/1`, query: null, fragment: null },
-                metadata: null, lineMarker: null, matcher: null, body: null, position: UNKNOWN_POSITION,
-            },
             {
                 op: "FIND", aside: null,
                 target: { kind: "url", raw: "skill://*/SKILL.md", scheme: "skill", username: null, password: null, hostname: "*", port: null, pathname: "/SKILL.md", query: null, fragment: null },
@@ -674,7 +667,7 @@ export default class TurnRunner {
         const systemCtx = this.#schemeContext(args, turnId);
         // {§context-fit} — one measure for everything this turn lands: the budget less the packet as it
         // would render now. The drained notices join the same facts below.
-        const facts = { turnId, seq, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId, projection: { bodiless: new Set(), omitEmissionHistory: false } };
+        const facts = { turnId, seq, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId };
         const fit = this.#fitFor(args, facts);
         const messages = await this.#publishMessages(args, turnId, fit);
         let nextActionIndex = await this.#readOpenPaths(args, turnId, messages.openPaths, messages.nextActionIndex, fit);
@@ -758,7 +751,7 @@ export default class TurnRunner {
     }
     async #buildPacket(args, facts) {
         const { messages, recap, workspaceId, workerId, loopId, provider } = args;
-        const packet = await this.#packets.buildRequestPacket({
+        return this.#packets.buildRequestPacket({
             initialMessages: messages,
             recap,
             workspaceId,
@@ -770,16 +763,7 @@ export default class TurnRunner {
             notices: facts.notices,
             transientOpenLogEntryId: facts.transientOpenLogEntryId,
             turnId: facts.turnId,
-            bodiless: facts.projection.bodiless,
-            omitEmissionHistory: facts.projection.omitEmissionHistory,
         });
-        // {§emission-history}: all builds, including result-admission probes, shed the optional
-        // replay before taking result bodies. Share the decision across this request's rebuilds.
-        if (PacketWire.sectionContent(packet, "emission-history").length > 0 && this.#packets.windowOverflow(packet, provider) !== null) {
-            facts.projection.omitEmissionHistory = true;
-            return this.#buildPacket(args, facts);
-        }
-        return packet;
     }
     // {§context-fit} — the budget left for one more row, measured by building the packet as it would
     // render now: every row landed so far, every KILL already honoured. Null without a budget.
@@ -806,63 +790,30 @@ export default class TurnRunner {
         const packet = await this.#buildPacket(args, request);
         return { ...request, nextActionIndex: request.nextActionIndex + 1, packet };
     }
-    // {§context-admission} — one request through the room: over the wall by the estimate, it sheds; over
-    // budget, it carries one row whose own weight takes the same wall ({§context-over-budget-row}); then the
-    // provider assesses the exact wire request, and an exact refusal sheds by its excess
-    // ({§context-wall-measure}). Only a packet that cannot fit even as receipts returns its overflow.
+    // {§context-admission} — one request through the room: over the wall by the estimate, it ends the loop;
+    // over budget, it carries one row whose own weight takes the same wall ({§context-over-budget-row});
+    // then the provider assesses the exact wire request, and an exact refusal ends the loop
+    // ({§context-wall-measure}). The daemon never hides, folds, or strips stored rows.
     async #admitPacket(args, request) {
         const { provider, loopId, signal } = args;
         let current = request;
-        let noted = false;
-        for (;;) {
-            const estimated = this.#packets.windowOverflow(current.packet, provider);
-            if (estimated !== null) {
-                const shed = await this.#shed(args, current, estimated);
-                if (shed === null)
-                    return { request: current, wire: null, overflow: estimated };
-                current = shed;
-                continue;
-            }
-            if (!noted && this.#packets.curationOverflow(current.packet) !== null) {
-                current = await this.#noteOverBudget(args, current);
-                noted = true;
-                continue;
-            }
-            const wire = await this.#wireMessages(current.packet, current.systemCtx, provider);
-            const capacity = await provider.assessRequestCapacity(wire.messages, undefined, this.#loopSignal(loopId) ?? signal);
-            const refused = this.#packets.exactOverflow(current.packet, capacity);
-            if (refused === null)
-                return { request: current, wire, overflow: null };
-            const shed = await this.#shed(args, current, refused);
-            if (shed === null)
-                return { request: current, wire: null, overflow: refused };
-            current = shed;
+        const estimated = this.#packets.windowOverflow(current.packet, provider);
+        if (estimated !== null)
+            return { request: current, wire: null, overflow: estimated };
+        if (this.#packets.curationOverflow(current.packet) !== null) {
+            current = await this.#noteOverBudget(args, current);
+            const afterNote = this.#packets.windowOverflow(current.packet, provider);
+            if (afterNote !== null)
+                return { request: current, wire: null, overflow: afterNote };
         }
+        const wire = await this.#wireMessages(current.packet, current.systemCtx, provider);
+        const capacity = await provider.assessRequestCapacity(wire.messages, undefined, this.#loopSignal(loopId) ?? signal);
+        const refused = this.#packets.exactOverflow(current.packet, capacity);
+        if (refused !== null)
+            return { request: current, wire: null, overflow: refused };
+        return { request: current, wire, overflow: null };
     }
-    // {§context-own-rows-fit} — one shedding step for whichever measure found the request over the wall: the
-    // previous program goes whole first ({§emission-history}), then the newest rows still carrying a body,
-    // enough of them by their rendered tokens to shed the excess; every body stays stored. Null when nothing
-    // is left to take.
-    async #shed(args, request, overflow) {
-        if (!request.projection.omitEmissionHistory && PacketWire.sectionContent(request.packet, "emission-history").length > 0) {
-            request.projection.omitEmissionHistory = true;
-        }
-        else {
-            let shed = 0;
-            let taken = 0;
-            for (const { id, tokens } of this.#packets.bodiedRowsOf(request.packet).toReversed()) {
-                if (shed >= overflow.excessWeight)
-                    break;
-                request.projection.bodiless.add(id);
-                shed += tokens;
-                taken += 1;
-            }
-            if (taken === 0)
-                return null;
-        }
-        return { ...request, packet: await this.#buildPacket(args, request) };
-    }
-    // {§context-wall} — the packet cannot fit the window even as receipts: the turn completes on the
+    // {§context-wall} — the packet exceeds the model's window: the turn completes on the
     // overflow and the loop rules the terminal; no provider I/O.
     async #failCuration(request, overflow) {
         const curationFailure = windowOverflowFailure(overflow);
@@ -913,9 +864,8 @@ export default class TurnRunner {
         attempts.railGrammar = await this.#operatorGrammar(provider);
         attempts.wellFormed = await this.#bodyChecks(workspaceId);
         const attemptLimit = readEmissionAttempts();
-        const strikeStreak = await this.#strikes.streak(loopId);
         for (let attempt = 1; attempt <= attemptLimit;) {
-            const verdict = await this.#issueProviderCall(args, request, attempts, attempt, strikeStreak);
+            const verdict = await this.#issueProviderCall(args, request, attempts, attempt);
             if (verdict === "admitted")
                 break;
             if (verdict === "rejected")
@@ -966,7 +916,7 @@ export default class TurnRunner {
     // under the reasoning observer, and its classification. {§provider-recovery}
     // re-issues the same emission attempt; the parser's admission is the one verdict
     // on a completed exchange.
-    async #issueProviderCall(args, request, attempts, attempt, strikeStreak) {
+    async #issueProviderCall(args, request, attempts, attempt) {
         const { provider, workspaceId, workerId, loopId } = args;
         // A recovery re-issue does not consume a grammar-emission attempt. Every
         // logical provider call still receives its own durable sequence and accounting.
@@ -996,10 +946,10 @@ export default class TurnRunner {
         }
         attempts.attemptId = attemptRow.id;
         attempts.callInFlight = true;
-        const reasoning = this.#reasoningObserver(args, request.turnId, modelCall);
+        const reasoning = this.#reasoningObserver(args, request, modelCall);
         let completedResponse;
         try {
-            completedResponse = await this.#generate(args, request, attempts, modelCall, reasoning, strikeStreak);
+            completedResponse = await this.#generate(args, request, attempts, modelCall, reasoning);
         }
         catch (error) {
             if (error instanceof ProviderError
@@ -1037,7 +987,7 @@ export default class TurnRunner {
     // {§notifications-reasoning-event} — only the parent emission is observed;
     // BARE has no observer on its isolated calls. Reasoning deltas cite the physical
     // request they stream in; a new request or the call's end closes the open span.
-    #reasoningObserver({ workspaceId, workerId, loopId }, turnId, modelCall) {
+    #reasoningObserver({ workspaceId, workerId, loopId }, { turnId, loopSeq, seq: turnSeq }, modelCall) {
         let reasoningStarted = false;
         let reasoningRequestSequence = 0;
         const end = () => {
@@ -1047,6 +997,8 @@ export default class TurnRunner {
                 workerId,
                 loopId,
                 turnId,
+                loopSeq,
+                turnSeq,
                 modelCallId: modelCall.id,
                 requestSequence: reasoningRequestSequence,
                 phase: "end",
@@ -1071,6 +1023,8 @@ export default class TurnRunner {
                         workerId,
                         loopId,
                         turnId,
+                        loopSeq,
+                        turnSeq,
                         modelCallId: modelCall.id,
                         requestSequence: reasoningRequestSequence,
                         phase: "start",
@@ -1080,6 +1034,8 @@ export default class TurnRunner {
                     workerId,
                     loopId,
                     turnId,
+                    loopSeq,
+                    turnSeq,
                     modelCallId: modelCall.id,
                     requestSequence: reasoningRequestSequence,
                     phase: "content",
@@ -1091,7 +1047,7 @@ export default class TurnRunner {
     // The exchange under its GenAI span: the packet's observations are recorded, the
     // provider generates against the wire request, and the call's accounting is
     // asserted whether it resolved or failed.
-    async #generate({ provider, workspaceId }, request, attempts, modelCall, reasoning, strikeStreak) {
+    async #generate({ provider, workspaceId }, request, attempts, modelCall, reasoning) {
         return await observed(// {§observability-boundary}
         genAiRequestName(provider.model), { model: provider.model, attempt: attempts.modelCallSequence }, async (span) => {
             try {
@@ -1413,7 +1369,7 @@ export default class TurnRunner {
                 model: callMetadata.model,
                 // Opaque provider metadata plus the grammar transport key.
                 // {§meta-passthrough}, {§operator-grammar}
-                meta: JSON.stringify({ ...(response.meta ?? {}), ...(railKeys ?? {}) }),
+                meta: JSON.stringify({ ...response.meta, ...railKeys }),
             },
         });
     }
@@ -1526,111 +1482,14 @@ export default class TurnRunner {
     }
     #splitResponse(response, executors = [], wellFormed) {
         const { assistant } = response;
-        const preParsedOps = assistant.ops;
-        const ops = [];
-        const parseErrors = [];
-        let contentStatementCount = 0;
-        let hasUnparsedTail = false;
-        let operationOmitted = false;
-        const parseNotices = [];
-        const fabrications = [];
-        const outside = [];
-        if (preParsedOps !== undefined) {
-            ops.push(...preParsedOps);
-            contentStatementCount = preParsedOps.length;
-        }
-        else {
-            // {§observability-boundary} — the parse is observed without its input;
-            // only the resulting statement count is attributable.
-            const parsed = observedSync("contracts.parse", {}, (span) => {
-                // {§executor-heading}: explicit invocations parse without registration; available names
-                // also admit slotless headings. Dispatch resolves the then-current workspace registry.
-                const result = PlurnkParser.parse(assistant.content, { executors, ...(wellFormed === undefined ? {} : { wellFormed }) });
-                span.setAttribute("statements", result.items.filter((item) => item.kind === "statement").length);
-                return result;
-            });
-            // {§outside-text}: beside a fenced operation, the text between two operations is one NOTE at its
-            // position, annotation the model wrote without its fence; a turn that fenced no operation keeps
-            // its text as its outside source and stays an empty turn ({§empty-turn}). Echoed emission
-            // headings are announcements, not annotation, and are dropped ({§fabricated-log-entry}).
-            const fenced = parsed.items.filter((item) => item.kind === "statement").length;
-            let span = null;
-            const flushSpan = () => {
-                if (span === null)
-                    return;
-                const body = span.body.join("\n\n");
-                if (body.length > 0) {
-                    if (fenced > 0) {
-                        ops.push({ op: "NOTE", aside: null, metadata: null, target: null, lineMarker: null, body, position: span.position });
-                        contentStatementCount += 1;
-                    }
-                    else
-                        outside.push(body);
-                }
-                span = null;
+        // A scripted provider's pre-parsed statements, each proven against the statement schema.
+        const preParsedOps = "ops" in assistant && Array.isArray(assistant.ops) ? assistant.ops.map((op) => Validator.assertPlurnkStatement(op)) : undefined;
+        const { ops, contentStatementCount, parseErrors, parseNotices, fabrications, outside, hasUnparsedTail, operationOmitted } = preParsedOps === undefined
+            ? TurnRunner.#parseContent(assistant.content, executors, wellFormed)
+            : {
+                ops: [...preParsedOps], contentStatementCount: preParsedOps.length, parseErrors: [], parseNotices: [], fabrications: [],
+                outside: [], hasUnparsedTail: false, operationOmitted: false,
             };
-            for (const item of parsed.items) {
-                if (item.kind !== "text")
-                    flushSpan();
-                if (item.kind === "statement") {
-                    ops.push(item.statement);
-                    contentStatementCount += 1;
-                }
-                else if (item.kind === "text") {
-                    // {§fabricated-log-entry}: a log-entry heading in outside text rejects the attempt.
-                    const fabricated = FabricatedLog.find(item.content);
-                    if (fabricated !== null) {
-                        fabrications.push({ message: FabricatedLog.message(fabricated.heading), line: item.position.line + fabricated.line, column: 1, source: "harness" });
-                        continue;
-                    }
-                    const body = FabricatedLog.stripEchoes(item.content);
-                    if (body.length === 0)
-                        continue;
-                    span ??= { body: [], position: item.position };
-                    span.body.push(body);
-                }
-                else if (item.kind === "error") {
-                    const err = item.error;
-                    if (err instanceof PlurnkParseError) {
-                        operationOmitted ||= err.operationOmitted;
-                        if (err.severity === "warning") {
-                            parseNotices.push({
-                                source: "grammar",
-                                kind: "parse_advisory",
-                                level: "warn",
-                                directive: DIRECTIVE.advisory,
-                                message: err.message,
-                                position: {
-                                    type: "content-offset",
-                                    line: err.line,
-                                    column: err.column,
-                                },
-                                parserSource: err.source,
-                            });
-                        }
-                        else {
-                            parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source,
-                                ...(err.recovery === undefined ? {} : { recovery: err.recovery }),
-                                ...(item.attempt === undefined ? {} : { attempt: item.attempt }) });
-                        }
-                    }
-                    else {
-                        const msg = err?.message ?? "parse error";
-                        parseErrors.push({ message: msg, line: 0, column: 0, source: "parser" });
-                    }
-                }
-            }
-            flushSpan();
-            // {§unparsed-tail-boundary} — the lexer's one boundary fact: from `unparsedTail.from` on,
-            // nothing was read. The statements that closed before it are ordinary facts and run; the
-            // loss itself is one more hard diagnostic, a failed row the model sees. An emission that
-            // lost its boundary before any statement closed has nothing admissible and is resampled.
-            const tail = parsed.unparsedTail;
-            if (tail !== undefined) {
-                hasUnparsedTail = true;
-                parseErrors.push({ message: tail.reason, line: tail.from.line, column: tail.from.column, source: "grammar" });
-            }
-        }
         const reasoning = assistant.reasoning ?? null;
         const reasoningOps = reasoning === null ? [] : PlurnkParser.parseReasoningOperations(reasoning, (warning) => {
             parseNotices.push({
@@ -1679,6 +1538,115 @@ export default class TurnRunner {
             emissionStatements,
         };
     }
+    // {§outside-text} {§fabricated-log-entry} {§unparsed-tail-boundary} An emission's content parsed into its
+    // statements and what sat beside them: outside text as NOTEs or the empty turn's source, a fabricated log
+    // heading as the rejection it is, each parse error by its severity, and the lexer's one boundary fact.
+    static #parseContent(content, executors, wellFormed) {
+        const ops = [];
+        const parseErrors = [];
+        let contentStatementCount = 0;
+        let hasUnparsedTail = false;
+        let operationOmitted = false;
+        const parseNotices = [];
+        const fabrications = [];
+        const outside = [];
+        // {§observability-boundary} — the parse is observed without its input;
+        // only the resulting statement count is attributable.
+        const parsed = observedSync("contracts.parse", {}, (span) => {
+            // {§executor-heading}: explicit invocations parse without registration; available names
+            // also admit slotless headings. Dispatch resolves the then-current workspace registry.
+            const result = PlurnkParser.parse(content, { executors, ...(wellFormed === undefined ? {} : { wellFormed }) });
+            span.setAttribute("statements", result.items.filter((item) => item.kind === "statement").length);
+            return result;
+        });
+        // {§outside-text}: beside a fenced operation, the text between two operations is one NOTE at its
+        // position, annotation the model wrote without its fence; a turn that fenced no operation keeps
+        // its text as its outside source and stays an empty turn ({§empty-turn}). Echoed emission
+        // headings are announcements, not annotation, and are dropped ({§fabricated-log-entry}).
+        const fenced = parsed.items.filter((item) => item.kind === "statement").length;
+        let span = null;
+        const flushSpan = () => {
+            if (span === null)
+                return;
+            const body = span.body.join("\n\n");
+            if (body.length > 0) {
+                if (fenced > 0) {
+                    ops.push({ op: "NOTE", aside: null, metadata: null, target: null, lineMarker: null, body, position: span.position });
+                    contentStatementCount += 1;
+                }
+                else
+                    outside.push(body);
+            }
+            span = null;
+        };
+        for (const item of parsed.items) {
+            if (item.kind !== "text")
+                flushSpan();
+            if (item.kind === "statement") {
+                ops.push(item.statement);
+                contentStatementCount += 1;
+            }
+            else if (item.kind === "text") {
+                // {§fabricated-log-entry}: a log-entry heading in outside text rejects the attempt.
+                const fabricated = FabricatedLog.find(item.content);
+                if (fabricated !== null) {
+                    fabrications.push({ message: FabricatedLog.message(fabricated.heading), line: item.position.line + fabricated.line, column: 1, source: "harness" });
+                    continue;
+                }
+                const body = FabricatedLog.stripEchoes(item.content);
+                if (body.length === 0)
+                    continue;
+                span ??= { body: [], position: item.position };
+                span.body.push(body);
+            }
+            else if (item.kind === "error") {
+                operationOmitted ||= TurnRunner.#admitParseError(item, parseErrors, parseNotices);
+            }
+        }
+        flushSpan();
+        // {§unparsed-tail-boundary} — the lexer's one boundary fact: from `unparsedTail.from` on,
+        // nothing was read. The statements that closed before it are ordinary facts and run; the
+        // loss itself is one more hard diagnostic, a failed row the model sees. An emission that
+        // lost its boundary before any statement closed has nothing admissible and is resampled.
+        const tail = parsed.unparsedTail;
+        if (tail !== undefined) {
+            hasUnparsedTail = true;
+            parseErrors.push({ message: tail.reason, line: tail.from.line, column: tail.from.column, source: "grammar" });
+        }
+        return { ops, contentStatementCount, parseErrors, parseNotices, fabrications, outside, hasUnparsedTail, operationOmitted };
+    }
+    // One parse error by its severity: an advisory is a grammar Notice beside the turn; an error is a diagnostic
+    // the model sees, with its recovery and the attempt it came from. Returns whether an operation was omitted.
+    static #admitParseError(item, parseErrors, parseNotices) {
+        const err = item.error;
+        if (err instanceof PlurnkParseError) {
+            if (err.severity === "warning") {
+                parseNotices.push({
+                    source: "grammar",
+                    kind: "parse_advisory",
+                    level: "warn",
+                    directive: DIRECTIVE.advisory,
+                    message: err.message,
+                    position: {
+                        type: "content-offset",
+                        line: err.line,
+                        column: err.column,
+                    },
+                    parserSource: err.source,
+                });
+            }
+            else {
+                parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source,
+                    ...(err.recovery === undefined ? {} : { recovery: err.recovery }),
+                    ...(item.attempt === undefined ? {} : { attempt: item.attempt }) });
+            }
+        }
+        else {
+            const msg = err?.message ?? "parse error";
+            parseErrors.push({ message: msg, line: 0, column: 0, source: "parser" });
+        }
+        return err instanceof PlurnkParseError && err.operationOmitted;
+    }
     // #note12 — extension reference docs are materialized beneath
     // worker:///_plurnk/plurnk/ by LoopDocs.
     // {§exec-lifetime} — a `"turn"` lifetime: abort the worker's open turn-scoped streams via their