@plurnk/plurnk-service 1.27.0 → 1.29.0

package/dist/core/TurnRunner.js

@@ -31,10 +31,11 @@ export const resolveOperatorGrammarPath = (value) => {
 // projection and digest projection are structurally one function — no
 // drift between wire and digest possible.
 import PacketWire from "./packet-wire.js";
-import ReasoningView from "./ReasoningView.js";
+import { RECEIPT_RESERVE, reserved } from "./ContextFit.js";
 import Results, { OperationFailureError } from "./results.js";
 import Turn from "./Turn.js";
 import ProviderRecovery from "./ProviderRecovery.js";
+import PacketBuilder from "./PacketBuilder.js";
 import StoredPacket from "./StoredPacket.js";
 import { observed, observedSync } from "../observe/spans.js";
 import { genAiRequestName, genAiRequestOptions, settleGenAiResponse } from "../observe/genai.js";
@@ -93,15 +94,16 @@ import { ProviderError, scopeEnvToAlias } from "@plurnk/plurnk-providers";
 import ProviderInstantiate from "./ProviderInstantiate.js";
 import TurnMaterialization from "./TurnMaterialization.js";
 import BareBatchRunner from "./BareBatchRunner.js";
-import KnownToxins from "./KnownToxins.js";
 import { TURN_STATUS_IMPLICIT_CONTINUE } from "./turn-signals.js";
 import AdmittedTurnExecutor from "./AdmittedTurnExecutor.js";
-const TOKEN_BUDGET_OVERFLOW_HARD_DETAIL = "Context Token Budget Overflow: logTokensTotal exceeds logTokensMax; retained context cannot fit.";
-const curationOverflowFailure = (pressure) => Results.failure("engine:context", "token-budget-overflow", 413, TOKEN_BUDGET_OVERFLOW_HARD_DETAIL, {}, {
-    usage: pressure.weight,
-    ceiling: pressure.budget,
-    deficit: pressure.excess,
-});
+// {§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.";
+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
+// ({§context-gauge}), which the row's own charge would otherwise put out of agreement.
+const OVER_BUDGET_DETAIL = "Context exceeds budget. YOU MUST ONLY KILL, MOVE or NOTE this turn.";
+const overBudgetFailure = () => Results.failure("engine:context", "packet-exceeds-budget", 413, OVER_BUDGET_DETAIL);
 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
@@ -298,14 +300,18 @@ class TurnRunner {
         const createdTurnIds = [];
         const turnSignal = this.#loopSignal(loopId) ?? signal;
         try {
+            // {§configuration-repair-path} — a retired packet knob refuses inference before any turn opens.
+            PacketBuilder.assertConfiguration();
             const container = await this.#openTurnContainer(args, createdTurnIds);
             const gitStatus = await this.#deriveWorkspace(args, container.systemCtx);
             if (container.initializationTurn !== null)
-                await this.#runInitializationTurn(args, container, container.initializationTurn);
-            const request = await this.#composeRequest(args, container, gitStatus);
-            const overflow = this.#packets.curationOverflow(request.packet);
-            if (overflow !== null)
-                return await this.#failCuration(request, overflow);
+                await this.#runInitializationTurn(args, container, container.initializationTurn, gitStatus);
+            const composed = await this.#composeRequest(args, container, gitStatus);
+            const admitted = await this.#admitPacket(args, composed);
+            // {§context-wall} — only the window ends a loop.
+            if (admitted.overflow !== null)
+                return await this.#failCuration(admitted.request, admitted.overflow);
+            const request = admitted.request;
             const attempts = await this.#prepareProviderAttempts(args, request);
             let emission;
             try {
@@ -386,16 +392,12 @@ class TurnRunner {
         const systemCtx = this.#schemeContext(args, initializationTurn?.id ?? modelTurn.id);
         const initializationStatements = [];
         // {§worker-initialization-entry} — the worker's first turn is the worked
-        // example itself: the actual orienting operations and ordinary NOTEs.
+        // 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.
         if (initializationTurn !== null) {
-            initializationStatements.push({
-                op: "NOTE", aside: null, metadata: null, target: null, lineMarker: null,
-                body: `This turn surveys tooling and environment. The log records results; reasoning://${workerName}/${loopSequence}/${initializationTurn.sequence} contains the submitted OPs.`, position: UNKNOWN_POSITION,
-            });
             const agentsEntry = await this.#db.crud_find_workspace_entry.get({
                 workspace_id: workspaceId,
                 scheme: "worker",
@@ -474,13 +476,13 @@ class TurnRunner {
     // {§worker-initialization-entry} — the worker's first turn is the worked example
     // itself: the actual orienting operations and ordinary NOTEs, executed as a
     // complete turn before the model boundary.
-    async #runInitializationTurn(args, container, initializationTurn) {
-        const { provider, workspaceId, workerId, loopId, onDispatch, onSettled } = args;
-        const { workerName, loopSequence, initializationStatements, initializationPolicies } = container;
+    async #runInitializationTurn(args, container, initializationTurn, gitStatus) {
+        const { workspaceId, workerId, loopId, onDispatch, onSettled } = args;
+        const { initializationStatements, initializationPolicies } = container;
         // Turn-0 catalog preview (PLURNK_SERVICE_FILES_ITEMS, {§actor-boundary-catalog-preview}):
-        // Eight bodyless FIND surveys in the worker's packetless initialization turn establish the Agent
+        // Nine bodyless FIND surveys in the worker's packetless initialization turn establish the Agent
         // Skills, the plurnk references, the enabled tools, agents, and members, then the project, commons,
-        // and named scratch, in that order.
+        // named scratch, and the worker's own reasoning, in that order.
         // Their `init` classification lets the model curate this opening survey as one log set.
         // {§operator-config-workspace-files-items} — workspace filesItems replaces the env default.
         const { filesItems: workspaceMI } = await WorkspaceSettings.read(this.#db, workspaceId);
@@ -488,20 +490,23 @@ class TurnRunner {
         if (filesItems !== null) { // {§actor-boundary-catalog-preview} — once per worker
             initializationStatements.push(...await this.#catalogSurveys(args, container, filesItems));
         }
-        const reasoningRead = ReasoningView.initialRead(provider, workerName, loopSequence, initializationTurn.sequence);
-        if (reasoningRead !== null)
-            initializationStatements.push(reasoningRead);
-        // {§worker-initialization-entry} — publish the complete source before its own READ executes.
-        // {§emission-row} — reasoning-only work has receipts, never a fabricated content emission.
+        // {§worker-initialization-entry} — the survey is an ordinary operation program: recorded as the
+        // turn's ops source and executed through the same path as a model's program; it authors no reasoning.
+        // {§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 reasoning = ReasoningView.initialSource(TurnOps.renderInternal(admittedInitializationStatements));
-        const admitted = PlurnkParser.parseReasoningOperations(reasoning);
+        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);
+            return;
+        }
+        const program = TurnOps.renderInternal(admittedInitializationStatements);
+        const admitted = PlurnkParser.parseStatements(program).items.flatMap((item) => item.kind === "statement" ? [item.statement] : []);
         if (admitted.length !== admittedInitializationStatements.length) {
-            throw new Error("initialization reasoning did not preserve every authored operation");
+            throw new Error("initialization program did not preserve every authored operation");
         }
-        await Turn.recordSource(this.#db, initializationTurn.id, "reasoning", reasoning);
+        await Turn.recordSource(this.#db, initializationTurn.id, "ops", program);
         const result = await this.executeAdmittedTurn({
             statements: admitted,
             source: null,
@@ -513,6 +518,7 @@ class TurnRunner {
             turnId: initializationTurn.id,
             fromSequence: 1,
             failOnOperationError: true,
+            fit: this.#fitFor(args, { turnId: initializationTurn.id, seq: initializationTurn.sequence, gitStatus, notices: [], transientOpenLogEntryId: container.transientOpenLogEntryId, bodiless: new Set() }),
             signal: this.#loopSignal(loopId),
             onDispatch,
             onSettled,
@@ -592,6 +598,14 @@ class TurnRunner {
                 metadata: null,
                 matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
             },
+            {
+                // {§worker-initialization-entry} — the worker's own reasoning is an addressable, searchable
+                // space from the first packet: surveyed by name, never read back.
+                op: "FIND", aside: "this worker's reasoning, by loop and turn",
+                target: { kind: "url", raw: `reasoning://${workerName}/**`, scheme: "reasoning", username: null, password: null, hostname: workerName, port: null, pathname: "/**", query: null, fragment: null },
+                metadata: null,
+                matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
+            },
         ];
         return surveys.filter(({ target }) => this.#schemes.get(target?.kind === "url" ? target.scheme : "file", workspaceId) !== undefined);
     }
@@ -636,8 +650,12 @@ class TurnRunner {
             container.createdTurnIds.push(modelTurn.id);
         const { id: turnId, sequence: seq } = modelTurn;
         const systemCtx = this.#schemeContext(args, turnId);
-        const messages = await this.#publishMessages(args, turnId);
-        let nextActionIndex = await this.#readOpenPaths(args, turnId, messages.openPaths, messages.nextActionIndex);
+        // {§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, bodiless: new Set() };
+        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);
         // {§env-delta-log-pull} — materialize ambient observations before packet
         // composition and reserve their action indices. {§exec-stream} owns the
         // distinct byte-cursor path for this worker's streams.
@@ -647,7 +665,7 @@ class TurnRunner {
         await this.#reapTurnScopedStreams(workerId);
         const ambientEntries = await this.#materialization.materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
         nextActionIndex += ambientEntries.length;
-        const streamEntries = await this.#materialization.materializeStreamDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
+        const streamEntries = await this.#materialization.materializeStreamDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex, fit });
         nextActionIndex += streamEntries.length;
         await Turn.observeCompletions(this.#db, turnId);
         // {§notifications-log-entry-notify}: materialized observations are
@@ -660,18 +678,13 @@ class TurnRunner {
         // and every budget rebuild; overflow never shells again.
         // Notices are non-terminal observations, never operation-failure truth.
         // Drain once and thread the same set through every overflow rebuild.
-        const notices = this.#notices.drain(loopId)
-            .filter((event) => event.level !== "info");
+        facts.notices.push(...this.#notices.drain(loopId)
+            .filter((event) => event.level !== "info"));
         // Build the model request packet ({§packet-stored-shape}). The log build
         // queries log_entries scoped to the worker, including this turn's newly
         // published message arrivals.
-        const facts = { turnId, seq, gitStatus, notices, transientOpenLogEntryId: container.transientOpenLogEntryId, promptProjection: "automatic" };
-        let packet = await this.#buildPacket(args, facts);
-        // {§context-output-admission} — output admission changes no operation
-        // outcome, authored memory, or turn identity.
-        if (await this.#packets.admitOutput(packet, turnId))
-            packet = await this.#buildPacket(args, facts);
-        return { ...facts, createdTurnIds: container.createdTurnIds, workerName: container.workerName, loopSeq: container.loopSequence, systemCtx, nextActionIndex, packet };
+        const packet = await this.#buildPacket(args, facts);
+        return { ...facts, fit, createdTurnIds: container.createdTurnIds, workerName: container.workerName, loopSeq: container.loopSequence, systemCtx, nextActionIndex, packet };
     }
     // Pre-model writes. Each message the model has not seen yet becomes an inbound `SEND`
     // row; model operations continue the same turn sequence after these rows. Returns the
@@ -679,15 +692,18 @@ class TurnRunner {
     // {§message-loop-containment}: the loop contains every message that arrived before this
     // boundary. Publish each unpublished inbox row oldest-first, exactly once, as an inbound
     // SEND row ({§message-arrival}); its selected paths ride along for the READs that follow.
-    async #publishMessages({ workerId, loopId, onDispatch, onSettled }, turnId) {
+    async #publishMessages({ workspaceId, workerId, loopId, onDispatch, onSettled }, turnId, fit) {
         let nextActionIndex = 1;
         const openPaths = [];
         const unpublished = await this.#db.drain_unpublished_messages_for_loop.all({ loop_id: loopId });
-        for (const message of unpublished) {
-            openPaths.push(...assertOpenPaths(JSON.parse(message.open_paths), `Message ${message.id} open_paths`));
+        const selected = unpublished.map((message) => assertOpenPaths(JSON.parse(message.open_paths), `Message ${message.id} open_paths`));
+        const pendingPaths = selected.reduce((count, paths) => count + paths.length, 0);
+        for (const [index, message] of unpublished.entries()) {
+            openPaths.push(...selected[index]);
             const logEntryId = await this.#materialization.writeArrivalLog({
-                workerId, loopId, turnId, sequence: nextActionIndex++, body: message.body, source: message.source, resource: message.path,
+                workspaceId, workerId, loopId, turnId, sequence: nextActionIndex++, body: message.body, source: message.source, resource: message.path,
                 selfAddressed: message.source !== null && message.source === message.durable_path,
+                fit: reserved(fit, unpublished.length - index - 1 + pendingPaths),
             });
             const published = await this.#db.drain_publish_message.get({ id: message.id, log_entry_id: logEntryId });
             if (published === undefined)
@@ -700,9 +716,9 @@ class TurnRunner {
     // {§methods-loop-run-open-paths}: selected workspace paths belong to the message.
     // Publish it, then dispatch ordinary core READs in that same turn;
     // missing/non-member paths retain their normal 4xx. Returns the next action index.
-    async #readOpenPaths({ workspaceId, workerId, loopId, onDispatch, onSettled }, turnId, openPaths, fromSequence) {
+    async #readOpenPaths({ workspaceId, workerId, loopId, onDispatch, onSettled }, turnId, openPaths, fromSequence, fit) {
         let nextActionIndex = fromSequence;
-        for (const raw of openPaths) {
+        for (const [index, raw] of openPaths.entries()) {
             const fileRead = {
                 op: "READ", aside: null, lineMarker: null, matcher: null,
                 target: { kind: "local", raw },
@@ -712,6 +728,7 @@ class TurnRunner {
             await this.#dispatch({
                 statement: fileRead, workspaceId, workerId, loopId, turnId,
                 sequence: nextActionIndex, origin: "_plurnk", onDispatch, onSettled,
+                fit: reserved(fit, openPaths.length - index - 1),
             });
             nextActionIndex++;
         }
@@ -729,14 +746,74 @@ class TurnRunner {
             gitStatus: facts.gitStatus,
             notices: facts.notices,
             transientOpenLogEntryId: facts.transientOpenLogEntryId,
-            promptProjection: facts.promptProjection,
             turnId: facts.turnId,
+            bodiless: facts.bodiless,
         });
     }
-    // Retained context cannot fit: the turn completes on the curation failure and
-    // the loop rules the terminal.
+    // {§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.
+    #fitFor(args, facts) {
+        return {
+            remaining: async () => {
+                const packet = await this.#buildPacket(args, facts);
+                const budget = this.#packets.curationBudgetFor(packet);
+                return budget === null ? null : Math.max(0, budget - packet.weight - RECEIPT_RESERVE);
+            },
+        };
+    }
+    // {§context-over-budget-row} — one `_plurnk` error row at the head of the turn's own rows, then the
+    // packet as it renders with it; the row recurs on every packet that is over.
+    async #noteOverBudget(args, request) {
+        const { workerId, loopId, onDispatch, onSettled } = args;
+        const minted = await this.#problems.record({
+            workerId, loopId, turnId: request.turnId, sequence: request.nextActionIndex, origin: "_plurnk", source: "context",
+            result: overBudgetFailure(),
+        });
+        onDispatch?.(minted.id);
+        await onSettled?.(minted.id);
+        const packet = await this.#buildPacket(args, request);
+        return { ...request, nextActionIndex: request.nextActionIndex + 1, packet };
+    }
+    // The packet against the wall and the budget: the newest rows go bodiless until it fits the window
+    // ({§context-own-rows-fit}); a packet still over budget then says so in a row ({§context-over-budget-row}),
+    // whose own weight takes the same wall. The overflow is returned only when the packet cannot fit even
+    // as receipts.
+    async #admitPacket(args, request) {
+        const fitted = await this.#fitOwnRows(args, request);
+        if (fitted.overflow !== null)
+            return fitted;
+        if (this.#packets.curationOverflow(fitted.request.packet) === null)
+            return fitted;
+        return await this.#fitOwnRows(args, await this.#noteOverBudget(args, fitted.request));
+    }
+    // {§context-own-rows-fit} — while the packet is over the wall ({§context-wall}), the newest rows still
+    // carrying a body are taken, enough of them by their rendered tokens to shed the excess, and the packet
+    // is rebuilt with them bodiless; every body stays stored. The rebuilt packet is measured again until
+    // it fits, or until no row is left to take.
+    async #fitOwnRows(args, request) {
+        let current = request;
+        for (;;) {
+            const overflow = this.#packets.windowOverflow(current.packet, args.provider);
+            if (overflow === null)
+                return { request: current, overflow: null };
+            let shed = 0;
+            let taken = 0;
+            for (const { id, tokens } of this.#packets.bodiedRowsOf(current.packet).toReversed()) {
+                if (shed >= overflow.excessWeight)
+                    break;
+                current.bodiless.add(id);
+                shed += tokens;
+                taken += 1;
+            }
+            if (taken === 0)
+                return { request: current, overflow };
+            current = { ...current, packet: await this.#buildPacket(args, current) };
+        }
+    }
+    // {§context-wall} — the packet cannot fit the window even as receipts: the turn completes on the
+    // overflow and the loop rules the terminal; no provider I/O.
     async #failCuration(request, overflow) {
-        const curationFailure = curationOverflowFailure(overflow);
+        const curationFailure = windowOverflowFailure(overflow);
         await Turn.complete(this.#db, request.turnId, curationFailure.status);
         return turnResult(request, curationFailure.status, { curationFailure });
     }
@@ -882,14 +959,9 @@ class TurnRunner {
                 await this.#recoverProviderFailure(args, request, attempts, modelCall, attemptRow.id, error);
                 return "reissued";
             }
-            if (!(error instanceof ProviderError)
-                || error.kind !== "capacity_exceeded"
-                || attempts.signal?.aborted === true
-                || !await this.#recoverCapacityPacket(args, request, attempts)) {
-                throw error;
-            }
-            await this.#resendForCapacity(args, request, attempts, modelCall, error);
-            return "reissued";
+            // {§context-wall} — a provider capacity rejection after the provider's own retries is this
+            // turn's failure; nothing is withheld to make the request smaller.
+            throw error;
         }
         finally {
             reasoning.end();
@@ -1049,42 +1121,6 @@ class TurnRunner {
         // durable, but recursively materializing them would mutate and cache-bust
         // the request being recovered. {§provider-recovery}
     }
-    // The first capacity rejection withholds the automatic prompt projection; the
-    // rebuilt request is resent only when it actually changed the wire messages.
-    async #recoverCapacityPacket(args, request, attempts) {
-        if (request.promptProjection !== "automatic")
-            return false;
-        request.promptProjection = "withheld";
-        const candidate = await this.#buildPacket(args, request);
-        const candidateRequest = await this.#wireMessages(candidate, request.systemCtx, args.provider);
-        if (JSON.stringify(candidateRequest.messages) === JSON.stringify(attempts.wire.messages))
-            return false;
-        request.packet = candidate;
-        attempts.wire = candidateRequest;
-        return true;
-    }
-    // The capacity rejection is durable as a failed call and a problem row; the
-    // replacement request is rebuilt to include that recovery signal while keeping
-    // the selected projection.
-    async #resendForCapacity(args, request, attempts, modelCall, error) {
-        const { workerId, loopId, provider } = args;
-        const failure = _a.#providerFailure(error, attempts.signal);
-        await modelCall.fail(failure, error.capacity ?? null);
-        attempts.callInFlight = false;
-        await this.#problems.record({
-            workerId,
-            loopId,
-            turnId: request.turnId,
-            sequence: request.nextActionIndex++,
-            origin: "_plurnk",
-            source: "provider",
-            result: failure,
-        });
-        // Include the durable recovery signal in the replacement
-        // request while preserving the selected recovery posture.
-        request.packet = await this.#buildPacket(args, request);
-        attempts.wire = await this.#wireMessages(request.packet, request.systemCtx, provider);
-    }
     // The attempt row's verdict: accepted, or rejected with the parser's errors. The
     // classified emission attempt is the turn's spent count.
     async #classifyProviderAttempt(attempts, id, split, emissionAttempt, accepted) {
@@ -1351,6 +1387,7 @@ class TurnRunner {
             emission: split.emissionStatements === null ? null : {
                 content: TurnOps.renderEmission(split.emissionStatements, `ops://${request.workerName}/${request.loopSeq}/${request.seq}`),
                 workerName: request.workerName, loopSeq: request.loopSeq, turnSeq: request.seq,
+                reasoning: split.packetAssistant.reasoning ?? null, // {§reasoning-row}
             },
             sourceModelCallId: emission.modelCallId,
             origin: "model",
@@ -1360,6 +1397,7 @@ class TurnRunner {
             turnId: request.turnId,
             fromSequence: request.nextActionIndex,
             maxCommands,
+            fit: request.fit,
             recoverableParseErrors: split.recoverableParseErrors,
             emptyTurn: split.emptyTurn,
             finalResponse: split.finalResponse,
@@ -1373,8 +1411,6 @@ class TurnRunner {
             onDispatch,
             onSettled,
         });
-        if (executed.emptyTurn)
-            await this.#readEmptyTurnReasoning(args, request, split.packetAssistant);
         return turnResult(request, executed.status, {
             outcomes: executed.outcomes,
             progressed: executed.progressed,
@@ -1383,40 +1419,6 @@ class TurnRunner {
             emissionAttempts: emission.emissionAttempts,
         });
     }
-    // {§reasoning-empty-turn-read} — after a turn with no operation, one runtime turn READs that
-    // turn's reasoning back to the model. A trace or emission carrying a foreign tool-call grammar
-    // is not echoed (`KnownToxins`); a turn without reasoning has nothing to read.
-    async #readEmptyTurnReasoning(args, request, { content, reasoning, ops }) {
-        const { provider, workspaceId, workerId, loopId, onDispatch, onSettled } = args;
-        if (ops.length > 0 || !reasoning?.length || KnownToxins.match(content) !== null || KnownToxins.match(reasoning) !== null)
-            return;
-        const statement = ReasoningView.emptyTurnRead(provider, request.workerName, request.loopSeq, request.seq);
-        if (statement === null)
-            return;
-        const policies = (await CapabilityPolicies.layers(this.#db, workspaceId, loopId)).map((layer) => layer.policy);
-        if (!this.#capabilities.allowsAcross(statement, workspaceId, policies))
-            return;
-        const turn = await Turn.open(this.#db, { loopId, producer: "_plurnk", kind: "operation" });
-        request.createdTurnIds.push(turn.id);
-        const source = TurnOps.renderInternal([statement]);
-        const result = await this.executeAdmittedTurn({
-            statements: TurnOps.parseInternal(source),
-            source,
-            emission: null,
-            origin: "_plurnk",
-            workspaceId,
-            workerId,
-            loopId,
-            turnId: turn.id,
-            fromSequence: 1,
-            failOnOperationError: true,
-            signal: this.#loopSignal(loopId),
-            onDispatch,
-            onSettled,
-        });
-        if (result.status !== 200)
-            throw new Error(`empty-turn reasoning read returned ${result.status}; expected 200`);
-    }
     // Split the wire-level ProviderResponse into the two destinations:
     // packet.assistant gets the model's emission (content, ops, reasoning);
     // Turn columns get accepted-call metadata (finishReason, model). Physical
@@ -1553,10 +1555,10 @@ class TurnRunner {
                 parserSource: warning.source,
             });
         });
-        const reasoningWork = reasoningOps.filter(({ op }) => op !== "NOTE");
-        const operationCount = contentStatementCount + reasoningWork.length;
-        // {§reasoning-operations}: fact-finding is real work, even without a content program.
-        if (reasoningWork.length > 0) {
+        const operationCount = contentStatementCount + reasoningOps.length;
+        // {§reasoning-operations}: an admitted reasoning operation is the turn's work, a NOTE as much as a
+        // FIND or READ, with or without a content program.
+        if (reasoningOps.length > 0) {
             for (let i = parseErrors.length - 1; i >= 0; i--) {
                 if (parseErrors[i].message === PlurnkParser.NO_VALID_OPERATION)
                     parseErrors.splice(i, 1);
@@ -1569,7 +1571,7 @@ class TurnRunner {
             && !hasUnparsedTail && parseErrors.length === 0
             && assistant.finishReason !== "length";
         const emptyTurn = preParsedOps === undefined && operationCount === 0 && !hasUnparsedTail;
-        // {§unparsed-tail-boundary}: outside text and reasoning NOTEs are not operational work.
+        // {§unparsed-tail-boundary}: outside text is not operational work.
         const emissionValid = fabrications.length === 0 && (preParsedOps !== undefined
             || emptyTurn
             || operationCount > 0);