@plurnk/plurnk-service 1.17.0 → 1.19.0

package/dist/core/TurnRunner.js

@@ -1,6 +1,8 @@
-import { TurnDisposition } from "@plurnk/plurnk-contracts";
+var _a;
 import NativeContent from "./NativeContent.js";
-import { PathSyntax, PlurnkParser, PlurnkParseError, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
+import { PlurnkParser } from "@plurnk/plurnk-parser";
+import { PathSyntax, PlurnkParseError, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
+import LoopPolicyReader from "./LoopPolicyReader.js";
 import { setTimeout as delay } from "node:timers/promises";
 import { aggregateProviderAccounting } from "@plurnk/plurnk-providers";
 const comparePosition = (a, b) => a.line - b.line || a.column - b.column;
@@ -9,9 +11,7 @@ import GitMembership from "./git-membership.js";
 import { acceptedKinds } from "./attachments.js";
 import GitState from "./git-state.js";
 import WorkspaceSettings from "./workspace-settings.js";
-import { taskTiming } from "./LoopLifecycle.js";
-import { generatedPathname, promptLoopPrefix } from "./plurnk-uri.js";
-import PromptFrames from "./PromptFrames.js";
+import { generatedPathname } from "./plurnk-uri.js";
 import { readFile } from "node:fs/promises";
 import { resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
@@ -34,22 +34,13 @@ import Results, { OperationFailureError } from "./results.js";
 import Turn from "./Turn.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 { genAiRequestName, genAiRequestOptions, settleGenAiResponse } from "../observe/genai.js";
 import { PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
 import ModelCall, { ModelCallPersistenceError, ProviderAccountingIntegrityError } from "./ModelCall.js";
 import WorkerName from "./WorkerName.js";
 import TurnOps from "./TurnOps.js";
 import CapabilityPolicies from "./CapabilityPolicies.js";
 import CapabilityResolver from "./CapabilityResolver.js";
-// {§prompt-address}: the same literal address in every observer's packet.
-const promptTarget = (workerName, storage) => {
-    return {
-        kind: "url", raw: `prompt://${workerName}${storage}`,
-        scheme: "prompt", username: null, password: null,
-        hostname: workerName, port: null,
-        pathname: storage, query: null, fragment: null,
-    };
-};
 const regexLiteral = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 const workerCatalogTarget = (namespace) => {
     const pathname = generatedPathname(`/${namespace}/*.md`);
@@ -72,22 +63,6 @@ const assertOpenPaths = (value, source) => {
     }
     return value;
 };
-const parsePromptAttributes = (encoded, source) => {
-    const attributes = JSON.parse(encoded);
-    if (attributes === null || typeof attributes !== "object" || Array.isArray(attributes)) {
-        throw new TypeError(`${source}: expected a JSON object`);
-    }
-    return attributes;
-};
-const promptSourceFromAttributes = (attributes, source) => {
-    const value = attributes.source;
-    if (value === undefined)
-        return null;
-    if (typeof value !== "string" || value.length === 0) {
-        throw new TypeError(`${source}: source must be a non-empty string when present`);
-    }
-    return value;
-};
 // Per-emission action ceiling — OFF by default. `-1` (or unset/non-positive) = no cap:
 // every generated op dispatches. Runaway degeneration is a sampler concern (repetition penalty),
 // not grounds to drop already-generated work. A positive value is an operator ceiling a
@@ -147,14 +122,31 @@ const readMilliseconds = (key) => {
     return value;
 };
 // {§provider-recovery} — how long one turn keeps re-issuing its provider call after a
-// recoverable failure before the loop parks (0 parks at once), and the first backoff delay,
-// which doubles per failure and is capped at twelve times itself.
+// recoverable failure before the loop parks (0 parks at once), the first backoff delay, which
+// doubles per failure, and that delay's ceiling.
 const readProviderRecovery = () => readMilliseconds("PLURNK_SERVICE_PROVIDER_RECOVERY");
 const readProviderRecoveryBackoff = () => readMilliseconds("PLURNK_SERVICE_PROVIDER_RECOVERY_BACKOFF");
+const readProviderRecoveryBackoffMax = () => readMilliseconds("PLURNK_SERVICE_PROVIDER_RECOVERY_BACKOFF_MAX");
 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";
-export default class TurnRunner {
+// Every turn result carries the same shape; a diversion names only what differs.
+const turnResult = ({ createdTurnIds, turnId }, status, facts = {}) => ({
+    createdTurnIds,
+    turnId,
+    producer: "model",
+    kind: "inference",
+    status,
+    outcomes: [],
+    fingerprint: "",
+    capacityHardStop: false,
+    providerParked: false,
+    emptyTurn: false,
+    emissionAttempts: 0,
+    emissionExhausted: false,
+    ...facts,
+});
+class TurnRunner {
     #db;
     #schemes;
     #mimetypes;
@@ -203,8 +195,8 @@ export default class TurnRunner {
         this.#warmWorkspace = warmWorkspace;
         this.#dispatch = dispatch;
         this.#resolveWorkerProviderIdentity = resolveWorkerProviderIdentity;
-        this.#materialization = new TurnMaterialization({ db: this.#db, weighContent: this.#weighContent });
-        this.#bareBatch = new BareBatchRunner({ db: this.#db, providerAttributions: this.#providerAttributions.bind(this), providerFailure: TurnRunner.#providerFailure });
+        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: _a.#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) {
@@ -218,7 +210,6 @@ export default class TurnRunner {
             workerId: args.workerId,
             loopId: args.loopId,
             packetCount: packetCount.count,
-            ...taskTiming(packetCount),
         });
     }
     // {§operator-grammar} — the operator's grammar text for this provider, or undefined when
@@ -244,8 +235,6 @@ export default class TurnRunner {
         process.stderr.write(`plurnk-engine: operator grammar: ${alias || "(bare)"} → ${path} (${text.length} chars)\n`);
         return text;
     }
-    // A lineage's no-parent root; a root worker resolves to itself. Fail hard
-    // when corruption leaves a worker without one. {§worker-primary}
     async #attemptAttributions(provider, context) {
         const tags = Meta.composeAttributions(this.#schemes.attributions(context), this.#executors()?.attributions(context) ?? [], await this.#mimetypes.attributions(context), provider.attributions?.(context) ?? []);
         return [...tags];
@@ -300,1110 +289,1076 @@ export default class TurnRunner {
         }, (kind) => accepted.includes(kind));
         return { messages, nativeInputs: [...nativeInputs] };
     }
-    async runTurn({ provider, childProvider = provider, messages, recap = "", workspaceId, workerId, loopId, signal, onDispatch, onSettled, turnNumber = 1, maxTurns = 50, invalidEmissionRecoveryEntryId, allowUnobservedRetrievalCompletion = false, }) {
+    // One inference cycle: the six phases in order, over the records declared above.
+    // A diversion (curation overflow, a provider failure, an exhausted emission)
+    // completes the turn and returns; anything else that throws fails every turn
+    // this cycle opened.
+    async runTurn({ provider, childProvider = provider, messages, recap = "", workspaceId, workerId, loopId, signal, onDispatch, onSettled, turnNumber = 1, invalidEmissionRecoveryEntryId, }) {
+        const args = {
+            provider, childProvider, messages, recap, workspaceId, workerId, loopId, signal, onDispatch, onSettled,
+            turnNumber, invalidEmissionRecoveryEntryId,
+        };
+        const createdTurnIds = [];
+        try {
+            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);
+            const attempts = await this.#prepareProviderAttempts(args, request);
+            let emission;
+            try {
+                emission = await this.#attemptProvider(args, request, attempts);
+            }
+            catch (error) {
+                return await this.#settleProviderFailure(error, args, request, attempts);
+            }
+            if (!emission.split.emissionValid)
+                return await this.#rejectExhaustedEmission(args, request, emission);
+            await this.#recordAdmittedEmission(args, request, emission);
+            return await this.#settleAdmittedTurn(args, request, emission);
+        }
+        catch (cause) {
+            const completionFailures = [];
+            for (const createdTurnId of createdTurnIds) {
+                try {
+                    await Turn.failOpen(this.#db, createdTurnId);
+                }
+                catch (completionCause) {
+                    completionFailures.push(completionCause);
+                }
+            }
+            if (completionFailures.length > 0) {
+                throw new AggregateError([cause, ...completionFailures], "turn execution failed and its open turn containers could not all be completed");
+            }
+            throw cause;
+        }
+    }
+    // Phase 1 — the producer-neutral turn container. Every producer opens the same
+    // durable turn and completes it only after its ordered operations settle; model
+    // packets and provider metadata are optional inference evidence, not turn identity.
+    async #openTurnContainer(args, createdTurnIds) {
+        const { workspaceId, workerId, loopId, invalidEmissionRecoveryEntryId } = args;
         const workerName = await WorkerName.forId(this.#db, workerId);
         const transientOpenLogEntryId = typeof invalidEmissionRecoveryEntryId === "number"
             ? invalidEmissionRecoveryEntryId
             : null;
-        // === Producer-neutral turn container ===
-        //
-        // Every producer opens the same durable turn and completes it only
-        // after its ordered operations settle. Model packets and provider
-        // metadata are optional inference evidence, not turn identity.
         const initialSequence = await this.#db.engine_next_turn_sequence.get({ loop_id: loopId });
         if (initialSequence === undefined)
             throw new Error("Engine.runTurn: next turn sequence is unavailable");
         // Turn-0 foists that belong to the Worker (catalog preview, AGENTS) gate
         // on its first inference history, not on loop sequence: honest client or
         // runtime administrative turns may precede the first provider exchange.
-        // Per-loop foists such as
-        // {§prompt-entry} still fires once per loop. Durable publication state,
-        // rather than the model-turn ordinal, prevents an overflow diversion
-        // from replaying the prompt and its automatic path READs.
-        const loopRow = await this.#db.engine_get_loop_prompt.get({ loop_id: loopId });
+        // Per-loop foists such as the initial message's publication
+        // ({§message-arrival}) fire once per loop: the inbox row's publication state,
+        // rather than the model-turn ordinal, prevents an overflow diversion from
+        // replaying a message and its automatic path READs.
+        const loopSequence = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
         const priorInference = await this.#db.engine_worker_has_inference_history.get({
             worker_id: workerId,
         });
         const workerFirstInference = priorInference?.present === 0;
-        const createdTurnIds = [];
-        try {
-            // {§worker-initialization-entry} — turn zero is an ordinary `_plurnk`
-            // operation turn. Its model-facing zero is a phase label; durable turn
-            // coordinates remain one-based.
-            const initializationTurn = initialSequence.next === 1 && workerFirstInference
-                ? await Turn.open(this.#db, { loopId, producer: "_plurnk", kind: "initialization" })
-                : null;
-            if (initializationTurn !== null)
-                createdTurnIds.push(initializationTurn.id);
-            const initializationPolicies = initializationTurn === null
-                ? []
-                : (await CapabilityPolicies.layers(this.#db, workspaceId)).map((layer) => layer.policy);
-            const initializationAdmits = (statement) => this.#capabilities.allowsAcross(statement, workspaceId, initializationPolicies);
-            let modelTurn = initializationTurn === null
-                ? await Turn.open(this.#db, { loopId, producer: "model", kind: "inference" })
-                : null;
-            if (modelTurn !== null)
-                createdTurnIds.push(modelTurn.id);
-            // {§env-delta-log-pull} — creation atomically owns the ordinary worker
-            // baseline or fork snapshot. Packet assembly consumes, never invents,
-            // that durable observation boundary.
-            const ambientCursor = await this.#db.engine_initialize_ambient_cursor.get({ workspace_id: workspaceId, worker_id: workerId });
-            if (ambientCursor?.ambient_event_cursor === null || ambientCursor === undefined) {
-                throw new Error(`worker ${workerId} has no durable ambient observation boundary`);
-            }
-            // Threaded per turn, never engine state, so concurrent loops on
-            // different providers each read their own honest tokenizer values.
-            const systemContext = (contextTurnId) => ({
-                db: this.#db, workspaceId, workerId, loopId, turnId: contextTurnId,
-                writer: "_plurnk",
-                signal: this.#loopSignal(loopId),
-                streamEventNotify: this.#streamEventNotify,
-                wakeWorkerNotify: this.#wakeWorkerNotify,
-                weigh: this.#weighContent,
-                mimetypes: this.#mimetypes,
-                defaultChannelFor: (s) => this.#schemes.defaultChannelFor(s, workspaceId),
-                pushNotice: (notice) => this.#notices.push(workspaceId, workerId, loopId, notice),
-                requestInteraction: (request, signal = this.#loopSignal(loopId)) => this.#interactions.request(request, { workspaceId, workerId, loopId, turnId: contextTurnId }, signal),
+        // {§worker-initialization-entry} — turn zero is an ordinary `_plurnk`
+        // operation turn. Its model-facing zero is a phase label; durable turn
+        // coordinates remain one-based.
+        const initializationTurn = initialSequence.next === 1 && workerFirstInference
+            ? await Turn.open(this.#db, { loopId, producer: "_plurnk", kind: "initialization" })
+            : null;
+        if (initializationTurn !== null)
+            createdTurnIds.push(initializationTurn.id);
+        const initializationPolicies = initializationTurn === null
+            ? []
+            : (await CapabilityPolicies.layers(this.#db, workspaceId, loopId)).map((layer) => layer.policy);
+        const modelTurn = initializationTurn === null
+            ? await Turn.open(this.#db, { loopId, producer: "model", kind: "inference" })
+            : null;
+        if (modelTurn !== null)
+            createdTurnIds.push(modelTurn.id);
+        // {§env-delta-log-pull} — creation atomically owns the ordinary worker
+        // baseline or fork snapshot. Packet assembly consumes, never invents,
+        // that durable observation boundary.
+        const ambientCursor = await this.#db.engine_initialize_ambient_cursor.get({ workspace_id: workspaceId, worker_id: workerId });
+        if (ambientCursor?.ambient_event_cursor === null || ambientCursor === undefined) {
+            throw new Error(`worker ${workerId} has no durable ambient observation boundary`);
+        }
+        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.
+        // {§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; ops://${workerName}/${loopSequence}/${initializationTurn.sequence} contains the submitted OPs.`, position: UNKNOWN_POSITION,
             });
-            let systemCtx = systemContext(initializationTurn?.id ?? modelTurn.id);
-            // {§prompt-entry} — the prompt entry exists before any turn of the loop
-            // runs; its `prompt` log row is published to the model turn below (one
-            // durable publication per loop, decided by that row).
-            const promptPublication = turnNumber === 1 && loopRow?.prompt_published === 0
-                && typeof loopRow.prompt === "string" && loopRow.prompt.length > 0
-                ? {
-                    content: loopRow.prompt,
-                    source: loopRow.prompt_source,
-                    path: promptTarget(workerName, await PromptFrames.write(systemCtx, {
-                        loopSequence: loopRow.sequence, ordinal: 1, content: loopRow.prompt,
-                        source: loopRow.prompt_source, pathname: loopRow.prompt_pathname,
-                        openPaths: assertOpenPaths(JSON.parse(loopRow.open_paths), `Loop ${loopId} open_paths`),
-                    })),
-                    openPaths: assertOpenPaths(JSON.parse(loopRow.open_paths), `Loop ${loopId} open_paths`),
-                }
-                : null;
-            const initializationStatements = [];
-            // {§worker-initialization-entry} — the worker's first turn is the worked
-            // example itself: the actual orienting operations and an ordinary TASK.
-            if (initializationTurn !== null) {
-                // {§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 (workerFirstInference) {
-                    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",
-                            username: null, password: null, hostname: null, port: null,
-                            pathname: generatedPathname("/agents.md"), query: null, fragment: null,
-                        };
-                        const agentsRead = {
-                            op: "READ", aside: null, target: agentsTarget,
-                            metadata: null, lineMarker: null, matcher: null, body: null, position: UNKNOWN_POSITION,
-                        };
-                        initializationStatements.push(agentsRead);
-                    }
-                }
-            }
-            // The persistent search-index pass (_search-index.maintain) attaches
-            // every readable entry/log projection to complete graph/FTS derivations.
-            // NOT an action: no log entry, no sequence slot,
-            // not dispatched. There is no materialized manifest entry — the catalog
-            // is served on demand by FIND: recursive when asked, shallow-mapped below.
-            // SPEC {§membership} D4/D5 — git-ls-files workspace membership, resolved at
-            // prompt-composition (EMI is eager + exhaustive — git is the only bound). When the
-            // workspace's project_root is a git working tree, tracked files are
-            // members without a client `add`; active members are materialized
-            // (disk → body channel) so they appear in the catalog. No-ops
-            // on headless / non-git workspaces. Runs BEFORE the derivation pump so
-            // this turn's packet reflects them.
-            // Joining here is the correctness boundary: passive workspace creation and
-            // attachment spend nothing, while the model never runs against partial
-            // graph/vector coverage.
-            await this.#warmWorkspace(systemCtx, false);
-            // The warm materialized membership before deriving. This second pass is the
-            // ordinary cheap change detector and captures any drift that landed meanwhile.
-            const fsDivergences = await GitMembership.indexGitMembership(systemCtx);
-            // {§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.#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
-            // consume the filesystem divergences a second time.
-            await this.#warmWorkspace(systemCtx, true, false);
-            // 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
-            // Skills, the plurnk references, the enabled tools, agents, and members, then the project, commons,
-            // and named scratch, in that order.
-            // Their `init` classification lets the model curate this opening survey as one log set.
-            if (initializationTurn !== null) {
-                // {§operator-config-workspace-files-items} — workspace filesItems replaces the env default.
-                const { filesItems: workspaceMI } = await WorkspaceSettings.read(this.#db, workspaceId);
-                const filesItems = workspaceMI !== null ? normalizeFilesItems(workspaceMI) : readFilesItems();
-                if (filesItems !== null && workerFirstInference) { // {§actor-boundary-catalog-preview} — once per worker
-                    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;
-                    // {§tools-resource-materialization} — expanded families project complete
-                    // invocation blocks, paged through ordinary FIND result ranges.
-                    const registry = this.#executors();
-                    const plurnkCatalog = workerCatalogTarget("plurnk");
-                    const toolsCatalog = workerCatalogTarget("tools");
-                    const toolExpansions = [];
-                    for (const tag of registry?.availableRuntimes(workspaceId) ?? []) {
-                        const entry = registry?.entry(tag, workspaceId);
-                        if (entry?.resourcesPath !== "/tools" || entry.expandTools !== true)
-                            continue;
-                        const tools = registry?.toolRegistry(tag, workspaceId);
-                        const admittedTools = tools?.tools.filter((tool) => this.#capabilities.allowsRuntimeAcross(tag, tool.target, workspaceId, initializationPolicies)) ?? [];
-                        if (admittedTools.length === 0)
-                            continue;
-                        const targetFilter = tools !== null && tools !== undefined && admittedTools.length !== tools.tools.length
-                            ? " \\((?:" + admittedTools.map((tool) => regexLiteral(PathSyntax.escapeTarget(tool.target))).join("|") + ")\\)"
-                            : " ";
-                        const pattern = "^(\x60{3,})" + regexLiteral(tag) + targetFilter + "[^\\n]*?(?:\\1|\\n[\\s\\S]*?\\n\\1)$";
-                        toolExpansions.push({
-                            statement: {
-                                op: "FIND", aside: null,
-                                target: { kind: "url", raw: `worker:///_plurnk/tools/${tag}.md`, scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname(`/tools/${tag}.md`), query: null, fragment: null },
-                                metadata: null,
-                                matcher: { dialect: "regex", raw: `/${pattern.replaceAll("/", "\\/")}/m`, pattern, flags: "m" },
-                                body: null, lineMarker: null, position: UNKNOWN_POSITION,
-                            },
-                        });
-                    }
-                    const surveys = [
-                        {
-                            statement: {
-                                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 },
-                                metadata: null,
-                                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
-                            },
-                        },
-                        ...(plurnkCatalog === null ? [] : [{
-                                statement: {
-                                    op: "FIND", aside: null,
-                                    target: plurnkCatalog,
-                                    metadata: null,
-                                    matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
-                                },
-                            }]),
-                        ...(toolsCatalog === null ? [] : [{
-                                // {§tools-resource-materialization} — enabled tool families
-                                // (MCP servers) survey at family level; each row's summary is
-                                // the server one-liner or its flagship invocation form, so the
-                                // discovery row itself orients. Servers named in
-                                // PLURNK_MCP_EXPANDED add a second survey of their complete
-                                // tool tree.
-                                statement: {
-                                    op: "FIND", aside: null,
-                                    target: toolsCatalog,
-                                    metadata: null,
-                                    matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
-                                },
-                            }]),
-                        ...toolExpansions,
-                        {
-                            // {§a2a-agents-catalog} — enabled outbound agents survey at
-                            // alias level; each row's summary is the agent's identity line,
-                            // the exact card stays pullable through READ a2a://<alias>.
-                            statement: {
-                                op: "FIND", aside: null,
-                                target: { kind: "url", raw: "worker:///_plurnk/agents/*.md", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname("/agents/*.md"), query: null, fragment: null },
-                                metadata: null,
-                                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
-                            },
-                        },
-                        {
-                            // {§members-projection} — enabled members definitions survey at alias
-                            // level; each row's summary is what its glob resolved to.
-                            statement: {
-                                op: "FIND", aside: null,
-                                target: { kind: "url", raw: "worker:///_plurnk/members/*.md", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname("/members/*.md"), query: null, fragment: null },
-                                metadata: null,
-                                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
-                            },
-                        },
-                        {
-                            statement: {
-                                op: "FIND", aside: "project root member files",
-                                target: { kind: "local", raw: "*" },
-                                metadata: null,
-                                matcher: null,
-                                body: null,
-                                lineMarker: fileCap === null ? null : { marks: [1, fileCap] },
-                                position: UNKNOWN_POSITION,
-                            },
-                        },
-                        {
-                            statement: {
-                                op: "FIND", aside: "shared worker Extended Context",
-                                target: { kind: "url", raw: "worker:///*", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: "/*", query: null, fragment: null },
-                                metadata: null,
-                                matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
-                            },
-                        },
-                        {
-                            statement: {
-                                op: "FIND", aside: "private worker Extended Context",
-                                target: { kind: "url", raw: `worker://${workerName}/*`, scheme: "worker", username: null, password: null, hostname: workerName, port: null, pathname: "/*", query: null, fragment: null },
-                                metadata: null,
-                                matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
-                            },
-                        },
-                    ];
-                    initializationStatements.push(...surveys.map(({ statement }) => statement).filter(({ target }) => this.#schemes.get(target?.kind === "url" ? target.scheme : "file", workspaceId) !== undefined));
-                }
-                const task = {
-                    op: "TASK", aside: null, target: null, metadata: null, lineMarker: null,
-                    body: [{ content: "Address the prompt.", status: "in_progress" }],
-                    position: UNKNOWN_POSITION,
+            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",
+                    username: null, password: null, hostname: null, port: null,
+                    pathname: generatedPathname("/AGENTS.md"), query: null, fragment: null,
                 };
-                const pathname = `/${loopRow.sequence}/${initializationTurn.sequence}`;
-                await Turn.recordSource(this.#db, initializationTurn.id, "reasoning", ReasoningView.initialSource());
-                // {§reasoning-initial-read} — the pattern READ needs a text/plain projection to run the regex.
-                const pluck = await this.#mimetypes.getHandler("text/plain") !== null;
-                const reasoningRead = ReasoningView.initialRead(provider, loopRow.sequence, initializationTurn.sequence, pluck);
-                if (reasoningRead !== null)
-                    initializationStatements.push(reasoningRead);
-                initializationStatements.push({
-                    op: "READ", aside: "inspect this turn's emission", matcher: null, body: null, metadata: null,
-                    target: {
-                        kind: "url", raw: `ops://${pathname}`, scheme: "ops", pathname,
-                        username: null, password: null, hostname: null, port: null, query: null, fragment: null,
-                    },
-                    lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
-                });
-                // {§prompt-entry} — the prompt reaches the model as its `prompt` row in the first
-                // model turn; initialization does not READ it a second time.
-                initializationStatements.push(task);
-                const admittedInitializationStatements = initializationStatements.filter(initializationAdmits);
-                const source = TurnOps.renderInternal(admittedInitializationStatements);
-                const admitted = TurnOps.parseInternal(source);
-                const result = await this.executeAdmittedTurn({
-                    statements: admitted,
-                    source,
-                    origin: "_plurnk",
-                    workspaceId,
-                    workerId,
-                    loopId,
-                    turnId: initializationTurn.id,
-                    fromSequence: 1,
-                    failOnOperationError: true,
-                    signal: this.#loopSignal(loopId),
-                    onDispatch,
-                    onSettled,
-                });
-                if (result.status !== TURN_STATUS_IMPLICIT_CONTINUE) {
-                    throw new Error(`initialization TASK returned ${result.status}; expected ${TURN_STATUS_IMPLICIT_CONTINUE}`);
-                }
-            }
-            // Initialization is a complete preceding turn, not a set of rows
-            // interleaved with the model boundary. The engine may now acquire the
-            // inference turn inside the same warmed workspace cycle.
-            if (modelTurn === null) {
-                modelTurn = await Turn.open(this.#db, { loopId, producer: "model", kind: "inference" });
-                createdTurnIds.push(modelTurn.id);
-            }
-            const seq = modelTurn.sequence;
-            const turnId = modelTurn.id;
-            systemCtx = systemContext(turnId);
-            // Pre-model writes. Each prompt the model has not seen yet becomes a
-            // `prompt` operation row whose target is its durable prompt:// entry.
-            // Model operations continue the same turn sequence after these rows.
-            let nextActionIndex = 1;
-            const turnOpenPaths = [];
-            if (promptPublication !== null) { // {§prompt-entry} — one durable publication per loop
-                turnOpenPaths.push(...promptPublication.openPaths);
-                const promptLogId = await this.#materialization.writePromptLog({
-                    workerId,
-                    loopId,
-                    turnId,
-                    sequence: nextActionIndex++,
-                    target: promptPublication.path,
-                    content: promptPublication.content,
-                    source: promptPublication.source,
-                });
-                onDispatch?.(promptLogId);
-                await onSettled?.(promptLogId);
+                const agentsRead = {
+                    op: "READ", aside: null, target: agentsTarget,
+                    metadata: null, lineMarker: null, matcher: null, body: null, position: UNKNOWN_POSITION,
+                };
+                initializationStatements.push(agentsRead);
             }
-            // {§prompt-loop-containment}: the loop contains every prompt that arrived
-            // while it ran. Publish each undelivered frame oldest-first exactly once.
+        }
+        return {
+            workerName, transientOpenLogEntryId, loopSequence, createdTurnIds,
+            initializationTurn, initializationPolicies, initializationStatements,
+            modelTurn, systemCtx,
+        };
+    }
+    // The `_plurnk` scheme context for one turn. Threaded per turn, never engine
+    // state, so concurrent loops on different providers each read their own honest
+    // tokenizer values.
+    #schemeContext({ workspaceId, workerId, loopId }, turnId) {
+        return {
+            db: this.#db, workspaceId, workerId, loopId, turnId,
+            writer: "_plurnk",
+            signal: this.#loopSignal(loopId),
+            streamEventNotify: this.#streamEventNotify,
+            wakeWorkerNotify: this.#wakeWorkerNotify,
+            weigh: this.#weighContent,
+            mimetypes: this.#mimetypes,
+            defaultChannelFor: (s) => this.#schemes.defaultChannelFor(s, workspaceId),
+            pushNotice: (notice) => this.#notices.push(workspaceId, workerId, loopId, notice),
+            requestInteraction: (request, signal = this.#loopSignal(loopId)) => this.#interactions.request(request, { workspaceId, workerId, loopId, turnId }, signal),
+        };
+    }
+    // Phase 2 — membership and derivation to completion, then the one git snapshot
+    // every packet rebuild reads.
+    async #deriveWorkspace({ workspaceId, loopId }, systemCtx) {
+        // The persistent search-index pass (_search-index.maintain) attaches
+        // every readable entry/log projection to complete graph/FTS derivations.
+        // NOT an action: no log entry, no sequence slot,
+        // not dispatched. There is no materialized manifest entry — the catalog
+        // is served on demand by FIND: recursive when asked, shallow-mapped below.
+        // SPEC {§membership} D4/D5 — git-ls-files workspace membership, resolved at
+        // prompt-composition (EMI is eager + exhaustive — git is the only bound). When the
+        // workspace's project_root is a git working tree, tracked files are
+        // members without a client `add`; active members are materialized
+        // (disk → body channel) so they appear in the catalog. No-ops
+        // on headless / non-git workspaces. Runs BEFORE the derivation pump so
+        // this turn's packet reflects them.
+        // Joining here is the correctness boundary: passive workspace creation and
+        // attachment spend nothing, while the model never runs against partial
+        // graph/vector coverage.
+        await this.#warmWorkspace(systemCtx, false);
+        // The warm materialized membership before deriving. This second pass is the
+        // ordinary cheap change detector and captures any drift that landed meanwhile.
+        const fsDivergences = await GitMembership.indexGitMembership(systemCtx);
+        // {§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.#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
+        // consume the filesystem divergences a second time.
+        await this.#warmWorkspace(systemCtx, true, false);
+        return gitStatus;
+    }
+    // {§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;
+        // 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
+        // Skills, the plurnk references, the enabled tools, agents, and members, then the project, commons,
+        // and named scratch, 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);
+        const filesItems = workspaceMI !== null ? normalizeFilesItems(workspaceMI) : readFilesItems();
+        if (filesItems !== null) { // {§actor-boundary-catalog-preview} — once per worker
+            initializationStatements.push(...await this.#catalogSurveys(args, container, filesItems));
+        }
+        const pathname = `/${loopSequence}/${initializationTurn.sequence}`;
+        const reasoning = ReasoningView.initialSource();
+        await Turn.recordSource(this.#db, initializationTurn.id, "reasoning", reasoning);
+        const reasoningRead = ReasoningView.initialRead(provider, workerName, loopSequence, initializationTurn.sequence);
+        if (reasoningRead !== null)
+            initializationStatements.push(reasoningRead);
+        initializationStatements.push({
+            op: "READ", aside: "inspect this turn's emission", matcher: null, body: null, metadata: null,
+            target: {
+                kind: "url", raw: `ops://${workerName}${pathname}`, scheme: "ops", pathname,
+                username: null, password: null, hostname: workerName, port: null, query: null, fragment: null,
+            },
+            lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+        });
+        // {§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 source = admittedInitializationStatements.length === 0 ? "" : TurnOps.renderInternal(admittedInitializationStatements);
+        const admitted = [...PlurnkParser.parseReasoningNotes(reasoning), ...(source.length === 0 ? [] : TurnOps.parseInternal(source))];
+        const result = await this.executeAdmittedTurn({
+            statements: admitted,
+            source,
+            origin: "_plurnk",
+            workspaceId,
+            workerId,
+            loopId,
+            turnId: initializationTurn.id,
+            fromSequence: 1,
+            failOnOperationError: true,
+            signal: this.#loopSignal(loopId),
+            onDispatch,
+            onSettled,
+        });
+        if (result.status !== 200) {
+            throw new Error(`initialization returned ${result.status}; expected 200`);
+        }
+    }
+    // {§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 }, 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 = [
             {
-                const loopSeqRow = await this.#db.engine_loop_sequence.get({ loop_id: loopId });
-                const loopSeq = loopSeqRow?.sequence ?? loopId;
-                const prefix = promptLoopPrefix(loopSeq);
-                const undelivered = (await this.#db.drain_undelivered_prompts_for_loop.all({
-                    worker_id: workerId,
-                    pattern: `${prefix}%`,
-                    prefix_len: prefix.length,
-                    loop_id: loopId,
-                }))
-                    .filter((row) => typeof row.content === "string" && row.content.length > 0);
-                for (const injectedRow of undelivered) {
-                    const attributes = parsePromptAttributes(injectedRow.attributes, `Prompt ${injectedRow.pathname} attributes`);
-                    if (attributes.openPaths !== undefined) {
-                        turnOpenPaths.push(...assertOpenPaths(attributes.openPaths, `Prompt ${injectedRow.pathname} openPaths`));
-                    }
-                    const promptLogId = await this.#materialization.writePromptLog({
-                        workerId,
-                        loopId,
-                        turnId,
-                        sequence: nextActionIndex++,
-                        target: promptTarget(workerName, injectedRow.pathname),
-                        content: injectedRow.content,
-                        source: promptSourceFromAttributes(attributes, `Prompt ${injectedRow.pathname} attributes`),
-                    });
-                    onDispatch?.(promptLogId);
-                    await onSettled?.(promptLogId);
-                }
+                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 },
+                metadata: null,
+                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+            },
+            {
+                op: "FIND", aside: null,
+                target: workerCatalogTarget("plurnk"),
+                metadata: null,
+                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+            },
+            {
+                // {§tools-resource-materialization} — enabled tool families
+                // (MCP servers) survey at family level; each row's summary is
+                // the server one-liner or its flagship invocation form, so the
+                // discovery row itself orients. Servers named in
+                // PLURNK_MCP_EXPANDED add a second survey of their complete
+                // tool tree.
+                op: "FIND", aside: null,
+                target: workerCatalogTarget("tools"),
+                metadata: null,
+                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+            },
+            ...this.#toolExpansions(workspaceId, initializationPolicies),
+            {
+                // {§a2a-catalog} — enabled outbound agents survey at
+                // alias level; each row's summary is the agent's identity line,
+                // the exact card stays pullable through READ a2a://<alias>.
+                op: "FIND", aside: null,
+                target: { kind: "url", raw: "worker:///_plurnk/a2a/*.md", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname("/a2a/*.md"), query: null, fragment: null },
+                metadata: null,
+                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+            },
+            {
+                // {§members-projection} — enabled members definitions survey at alias
+                // level; each row's summary is what its glob resolved to.
+                op: "FIND", aside: null,
+                target: { kind: "url", raw: "worker:///_plurnk/members/*.md", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname("/members/*.md"), query: null, fragment: null },
+                metadata: null,
+                matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+            },
+            {
+                op: "FIND", aside: "project root member files",
+                target: { kind: "local", raw: "*" },
+                metadata: null,
+                matcher: null,
+                body: null,
+                lineMarker: fileCap === null ? null : { marks: [1, fileCap] },
+                position: UNKNOWN_POSITION,
+            },
+            {
+                op: "FIND", aside: "workspace knowledgebase entries",
+                target: { kind: "url", raw: "worker:///*", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: "/*", query: null, fragment: null },
+                metadata: null,
+                matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
+            },
+            {
+                op: "FIND", aside: "worker knowledgebase entries",
+                target: { kind: "url", raw: `worker://${workerName}/*`, scheme: "worker", 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);
+    }
+    // {§tools-resource-materialization} — expanded families project complete
+    // invocation blocks, paged through ordinary FIND result ranges: one pattern FIND
+    // per family, naming the admitted tools when the policy narrows them.
+    #toolExpansions(workspaceId, policies) {
+        const registry = this.#executors();
+        const expansions = [];
+        for (const tag of registry?.availableRuntimes(workspaceId) ?? []) {
+            const entry = registry?.entry(tag, workspaceId);
+            if (entry?.resourcesPath !== "/tools" || entry.expandTools !== true)
+                continue;
+            const tools = registry?.toolRegistry(tag, workspaceId);
+            const admittedTools = tools?.tools.filter((tool) => this.#capabilities.allowsRuntimeAcross(tag, tool.target, workspaceId, policies)) ?? [];
+            if (admittedTools.length === 0)
+                continue;
+            const targetFilter = tools !== null && tools !== undefined && admittedTools.length !== tools.tools.length
+                ? " \\((?:" + admittedTools.map((tool) => regexLiteral(PathSyntax.escapeTarget(tool.target))).join("|") + ")\\)"
+                : " ";
+            const pattern = "^(\x60{3,})" + regexLiteral(tag) + targetFilter + "[^\\n]*?(?:\\1|\\n[\\s\\S]*?\\n\\1)$";
+            expansions.push({
+                op: "FIND", aside: null,
+                target: { kind: "url", raw: `worker:///_plurnk/tools/${tag}.md`, scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname(`/tools/${tag}.md`), query: null, fragment: null },
+                metadata: null,
+                matcher: { dialect: "regex", raw: `/${pattern.replaceAll("/", "\\/")}/m`, pattern, flags: "m" },
+                body: null, lineMarker: null, position: UNKNOWN_POSITION,
+            });
+        }
+        return expansions;
+    }
+    // Phase 3 — the inference turn and its request: the prompts the model has not
+    // seen, their open-path READs, the ambient and stream deltas, then the packet
+    // ({§packet-stored-shape}).
+    async #composeRequest(args, container, gitStatus) {
+        const { workspaceId, workerId, loopId } = args;
+        // Initialization is a complete preceding turn, not a set of rows
+        // interleaved with the model boundary. The engine may now acquire the
+        // inference turn inside the same warmed workspace cycle.
+        const modelTurn = container.modelTurn ?? await Turn.open(this.#db, { loopId, producer: "model", kind: "inference" });
+        if (container.modelTurn === null)
+            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);
+        // {§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.
+        // {§exec-lifetime} — a `"turn"` lifetime: reap the worker's open turn-scoped streams (necessarily
+        // 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 initially visible via the stream-delta path.
+        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 });
+        nextActionIndex += streamEntries.length;
+        await Turn.observeCompletions(this.#db, turnId);
+        // {§notifications-log-entry-notify}: materialized observations are
+        // ordinary committed log rows, not packet-only content.
+        for (const id of [...ambientEntries, ...streamEntries]) {
+            args.onDispatch?.(id);
+            await args.onSettled?.(id);
+        }
+        // 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.
+        // Drain once and thread the same set through every overflow rebuild.
+        const notices = 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, 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
+    // next action index and the messages' open paths.
+    // {§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) {
+        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 logEntryId = await this.#materialization.writeArrivalLog({
+                workerId, loopId, turnId, sequence: nextActionIndex++, body: message.body, source: message.source, resource: message.path,
+                selfAddressed: message.source !== null && message.source === message.durable_path,
+            });
+            const published = await this.#db.drain_publish_message.get({ id: message.id, log_entry_id: logEntryId });
+            if (published === undefined)
+                throw new Error(`TurnRunner.#publishMessages: message ${message.id} was already published`);
+            onDispatch?.(logEntryId);
+            await onSettled?.(logEntryId);
+        }
+        return { nextActionIndex, openPaths };
+    }
+    // {§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) {
+        let nextActionIndex = fromSequence;
+        for (const raw of openPaths) {
+            const pathname = raw.startsWith("/") ? raw : `/${raw}`;
+            const fileRead = {
+                op: "READ", aside: null, lineMarker: null, matcher: null,
+                target: {
+                    kind: "url", raw: `file://${pathname}`, scheme: "file",
+                    username: null, password: null, hostname: null, port: null,
+                    pathname, query: null, fragment: null,
+                },
+                metadata: null,
+                body: null, position: UNKNOWN_POSITION,
+            };
+            await this.#dispatch({
+                statement: fileRead, workspaceId, workerId, loopId, turnId,
+                sequence: nextActionIndex, origin: "_plurnk", onDispatch, onSettled,
+            });
+            nextActionIndex++;
+        }
+        return nextActionIndex;
+    }
+    #buildPacket({ messages, recap, workspaceId, workerId, loopId, provider }, facts) {
+        return this.#packets.buildRequestPacket({
+            initialMessages: messages,
+            recap,
+            workspaceId,
+            workerId,
+            loopId,
+            currentTurnSeq: facts.seq,
+            provider,
+            gitStatus: facts.gitStatus,
+            notices: facts.notices,
+            transientOpenLogEntryId: facts.transientOpenLogEntryId,
+            promptProjection: facts.promptProjection,
+            turnId: facts.turnId,
+        });
+    }
+    // Retained context cannot fit: the turn completes on the curation failure and
+    // the loop rules the terminal.
+    async #failCuration(request, overflow) {
+        const curationFailure = curationOverflowFailure(overflow);
+        await Turn.complete(this.#db, request.turnId, curationFailure.status);
+        return turnResult(request, curationFailure.status, { curationFailure });
+    }
+    // Phase 4's bookkeeping: the wire request, the recovery knobs, the signal the
+    // provider sees, the client id and the worker's provider identity.
+    async #prepareProviderAttempts({ provider, workspaceId, workerId, loopId, signal }, request) {
+        const wire = await this.#wireMessages(request.packet, request.systemCtx, provider);
+        // {§provider-recovery} — this turn's recovery clock: the first recoverable provider
+        // failure starts it; the budget and backoff are the operator's.
+        const recoveryBudget = readProviderRecovery();
+        const recoveryBackoff = readProviderRecoveryBackoff();
+        const providerSignal = this.#loopSignal(loopId) ?? signal;
+        const { workerId: providerWorkerId } = await this.#resolveWorkerProviderIdentity(workerId);
+        return {
+            wire,
+            response: undefined,
+            split: undefined,
+            railGrammar: undefined,
+            railEvidence: undefined,
+            emissionAttempts: 0,
+            callInFlight: false,
+            modelCallSequence: 0,
+            currentEmissionAttempt: 0,
+            attemptId: null,
+            modelCall: null,
+            recoveryStartedAt: null,
+            recoveryFailures: 0,
+            parked: false,
+            attributions: [],
+            recoveryBudget,
+            recoveryBackoff,
+            signal: providerSignal,
+            providerWorkerId,
+            turnWireAccounting: [],
+        };
+    }
+    // Phase 4 — the provider attempt loop. Each iteration is one logical call: a
+    // recoverable failure or a capacity rebuild re-issues the same emission attempt,
+    // an invalid emission spends one, and a valid emission ends the loop
+    // ({§invalid-emission-attempts}).
+    async #attemptProvider(args, request, attempts) {
+        const { provider, workspaceId, workerId, loopId, signal } = args;
+        // {§turn-lifecycle}: bracket the complete provider-attempt window with liveness notices.
+        if (!signal?.aborted)
+            this.#notices.push(workspaceId, workerId, loopId, { source: "engine:turn", kind: "turn_awaiting_model", level: "info", message: "awaiting model response" });
+        attempts.railGrammar = await this.#operatorGrammar(provider);
+        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);
+            if (verdict === "admitted")
+                break;
+            if (verdict === "rejected")
+                attempt++;
+        }
+        if (!signal?.aborted) {
+            const wire = aggregateProviderAccounting(attempts.turnWireAccounting);
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: "engine:turn",
+                kind: "turn_generated",
+                level: "info",
+                message: "parsing model response",
+                // {§turn-accounting-notice} (#465) — the exact settled derivation,
+                // never a second stored fact: a live watcher accrues loop cost per turn.
+                accounting: {
+                    requests: attempts.turnWireAccounting.length,
+                    costUsd: wire.costUsd,
+                    inputTokens: wire.usage?.inputTokens ?? null,
+                    outputTokens: wire.usage?.outputTokens ?? null,
+                    reasoningTokens: wire.usage?.outputTokenDetails?.reasoningTokens ?? null,
+                    cacheReadTokens: wire.usage?.inputTokenDetails?.cacheReadTokens ?? null,
+                },
+            });
+        }
+        if (attempts.response === undefined || attempts.split === undefined || attempts.modelCall === null) {
+            throw new Error("provider attempt loop completed without a response");
+        }
+        const emission = {
+            response: attempts.response,
+            split: attempts.split,
+            modelCallId: attempts.modelCall.id,
+            railGrammar: attempts.railGrammar,
+            railEvidence: attempts.railEvidence,
+            emissionAttempts: attempts.emissionAttempts,
+            signal: attempts.signal,
+        };
+        if (emission.split.packetAssistant.reasoning?.length) {
+            await Turn.recordSource(this.#db, request.turnId, "reasoning", emission.split.packetAssistant.reasoning, { modelCallId: emission.modelCallId });
+        }
+        return emission;
+    }
+    // One logical provider call: its durable model call and attempt row, the exchange
+    // under the reasoning observer, and its classification. Capacity recovery and
+    // {§provider-recovery} re-issue the same emission attempt; the parser's admission
+    // is the one verdict on a completed exchange.
+    async #issueProviderCall(args, request, attempts, attempt, strikeStreak) {
+        const { provider, workspaceId, workerId, loopId } = args;
+        // Capacity recovery may rebuild and resend the request without
+        // consuming a grammar-emission attempt. Every logical provider
+        // call still receives its own durable sequence and accounting.
+        attempts.currentEmissionAttempt = attempt;
+        attempts.modelCallSequence++;
+        const attributionContext = Object.freeze({
+            workspaceId: String(workspaceId),
+            workerId: attempts.providerWorkerId,
+            loop: request.loopSeq,
+            turn: request.seq,
+            attempt: attempts.modelCallSequence,
+        });
+        attempts.attributions = await this.#attemptAttributions(provider, attributionContext);
+        request.packet = { ...request.packet, attributions: attempts.attributions };
+        const modelCall = await ModelCall.open(this.#db, {
+            turnId: request.turnId,
+            kind: "emission",
+            attributions: attempts.attributions,
+            model: provider.model,
+        });
+        attempts.modelCall = modelCall;
+        const attemptRow = await this.#db.engine_open_turn_attempt.get({
+            model_call_id: modelCall.id,
+        });
+        if (attemptRow === undefined) {
+            throw new Error(`Engine.runTurn: provider call ${attempts.modelCallSequence} did not open`);
+        }
+        attempts.attemptId = attemptRow.id;
+        attempts.callInFlight = true;
+        const reasoning = this.#reasoningObserver(args, request.turnId, modelCall);
+        let completedResponse;
+        try {
+            completedResponse = await this.#generate(args, request, attempts, modelCall, reasoning, strikeStreak);
+        }
+        catch (error) {
+            if (error instanceof ProviderError
+                && RECOVERABLE_PROVIDER_FAILURES.has(error.kind)
+                && attempts.signal?.aborted !== true) {
+                await this.#recoverProviderFailure(args, request, attempts, modelCall, attemptRow.id, error);
+                return "reissued";
             }
-            // {§methods-loop-run-open-paths}: selected workspace paths belong to
-            // the prompt frame. Publish the frame, then dispatch ordinary core READs
-            // in that same turn; missing/non-member paths retain their normal 4xx.
-            for (const raw of turnOpenPaths) {
-                const pathname = raw.startsWith("/") ? raw : `/${raw}`;
-                const fileRead = {
-                    op: "READ", aside: null, lineMarker: null, matcher: null,
-                    target: {
-                        kind: "url", raw: `file://${pathname}`, scheme: "file",
-                        username: null, password: null, hostname: null, port: null,
-                        pathname, query: null, fragment: null,
-                    },
-                    metadata: null,
-                    body: null, position: UNKNOWN_POSITION,
-                };
-                await this.#dispatch({
-                    statement: fileRead, workspaceId, workerId, loopId, turnId,
-                    sequence: nextActionIndex, origin: "_plurnk", onDispatch, onSettled,
-                });
-                nextActionIndex++;
+            if (!(error instanceof ProviderError)
+                || error.kind !== "capacity_exceeded"
+                || attempts.signal?.aborted === true
+                || !await this.#recoverCapacityPacket(args, request, attempts)) {
+                throw error;
             }
-            // {§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.
-            // {§exec-poll} — EXEC `<0>` is turn-scoped: reap the worker's open turn-scoped streams (necessarily
-            // 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 initially visible via the stream-delta path.
-            await this.#reapTurnScopedStreams(workerId);
-            nextActionIndex += await this.#materialization.materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
-            nextActionIndex += await this.#materialization.materializeStreamDeltas({ workspaceId, 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.
-            // Drain once and thread the same set through every overflow rebuild.
-            const notices = 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 — the prompt entry just
-            // written (if turn 1) is part of that query result.
-            let promptProjection = "automatic";
-            const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
-            const buildPacket = () => this.#packets.buildRequestPacket({
-                initialMessages: messages,
-                recap,
-                workspaceId,
+            await this.#resendForCapacity(args, request, attempts, modelCall, error);
+            return "reissued";
+        }
+        finally {
+            reasoning.end();
+        }
+        if (attempts.recoveryFailures > 0) {
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: "engine:provider",
+                kind: "provider_recovered",
+                level: "info",
+                message: `Provider recovered after ${attempts.recoveryFailures} failed call${attempts.recoveryFailures === 1 ? "" : "s"}.`,
+            });
+            attempts.recoveryFailures = 0;
+            attempts.recoveryStartedAt = null;
+        }
+        attempts.response = completedResponse;
+        attempts.turnWireAccounting.push(...completedResponse.accounting);
+        await modelCall.observeResponse(completedResponse, null, attempts.wire.nativeInputs);
+        attempts.railEvidence = attempts.railGrammar === undefined ? undefined : completedResponse.grammarEvidence;
+        const split = this.#splitResponse(completedResponse, this.#executors()?.availableRuntimes(workspaceId) ?? []);
+        attempts.split = split;
+        await this.#classifyProviderAttempt(attempts, attemptRow.id, split, attempt, split.emissionValid);
+        return split.emissionValid ? "admitted" : "rejected";
+    }
+    // {§notifications-reasoning-event} — only the parent emission is conversational;
+    // 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) {
+        let reasoningStarted = false;
+        let reasoningRequestSequence = 0;
+        const end = () => {
+            if (!reasoningStarted)
+                return;
+            this.#reasoningEventNotify(workspaceId, {
                 workerId,
                 loopId,
-                currentTurnSeq: seq,
-                provider,
-                gitStatus,
-                notices,
-                transientOpenLogEntryId,
-                promptProjection,
                 turnId,
+                modelCallId: modelCall.id,
+                requestSequence: reasoningRequestSequence,
+                phase: "end",
             });
-            let requestPacket = await buildPacket();
-            // {§context-output-admission} — output admission changes no operation
-            // outcome, authored inventory, or turn identity.
-            if (await this.#packets.admitOutput(requestPacket, turnId))
-                requestPacket = await buildPacket();
-            const remaining = this.#packets.curationOverflow(requestPacket);
-            if (remaining !== null) {
-                const curationFailure = curationOverflowFailure(remaining);
-                await Turn.complete(this.#db, turnId, curationFailure.status);
-                return {
-                    createdTurnIds,
-                    turnId,
-                    producer: "model",
-                    kind: "inference",
-                    status: curationFailure.status,
-                    outcomes: [],
-                    fingerprint: "",
-                    capacityHardStop: false,
-                    providerParked: false,
-                    steerStruck: false,
-                    emptyTurn: false,
-                    emissionAttempts: 0,
-                    emissionExhausted: false,
-                    curationFailure,
-                };
-            }
-            let materializedRequest = await this.#wireMessages(requestPacket, systemCtx, provider);
-            let modelMessages = materializedRequest.messages;
-            let nativeInputs = materializedRequest.nativeInputs;
-            // Curation pressure and provider generation are independent. The
-            // provider owns its configured total output envelope.
-            let response;
-            let splitResponse;
-            let railGrammar;
-            let railEvidence;
-            let emissionAttempts = 0;
-            let providerCallInFlight = false;
-            let modelCallSequence = 0;
-            let currentEmissionAttempt = 0;
-            let providerAttemptId = null;
-            let providerModelCall = null;
-            // {§provider-recovery} — this turn's recovery clock: the first recoverable provider
-            // failure starts it; the budget and backoff are the operator's.
-            let recoveryStartedAt = null;
-            let recoveryFailures = 0;
-            let providerParked = false;
-            const recoveryBudget = readProviderRecovery();
-            const recoveryBackoff = readProviderRecoveryBackoff();
-            let providerAttemptAttributions = [];
-            const providerSignal = this.#loopSignal(loopId) ?? signal;
-            // {§client-metadata}
-            const { client } = await WorkspaceSettings.read(this.#db, workspaceId);
-            const providerIdentity = await this.#resolveWorkerProviderIdentity(workerId);
-            const { workerId: providerWorkerId, primaryWorkerId } = providerIdentity;
-            const classifyProviderAttempt = async (id, attemptSplit, emissionAttempt, accepted) => {
-                const result = await this.#db.engine_classify_turn_attempt_response.run({
-                    id,
-                    accepted: accepted ? 1 : 0,
-                    parse_errors: JSON.stringify(attemptSplit.parseErrors),
-                });
-                if (result.changes !== 1) {
-                    throw new Error(`emission attempt ${id} was not awaiting classification`);
-                }
-                emissionAttempts = emissionAttempt;
-            };
-            const recoverCapacityPacket = async () => {
-                let baselineMessages = modelMessages;
-                if (promptProjection === "automatic") {
-                    promptProjection = "withheld";
-                    const candidate = await buildPacket();
-                    const candidateRequest = await this.#wireMessages(candidate, systemCtx, provider);
-                    if (JSON.stringify(candidateRequest.messages) !== JSON.stringify(baselineMessages)) {
-                        requestPacket = candidate;
-                        materializedRequest = candidateRequest;
-                        modelMessages = materializedRequest.messages;
-                        nativeInputs = materializedRequest.nativeInputs;
-                        return true;
-                    }
-                    baselineMessages = candidateRequest.messages;
+            reasoningStarted = false;
+        };
+        const observeRequest = async (...args) => {
+            end();
+            const settle = await modelCall.observeRequest(...args);
+            reasoningRequestSequence = modelCall.requestSequence;
+            return settle;
+        };
+        const observeReasoning = this.#reasoningEventNotify === undefined
+            ? undefined
+            : (delta) => {
+                if (reasoningRequestSequence === 0) {
+                    throw new Error("provider emitted reasoning before opening its physical request");
                 }
-                return false;
-            };
-            try {
-                // {§turn-lifecycle}: bracket the complete provider-attempt window with liveness notices.
-                if (!signal?.aborted)
-                    this.#notices.push(workspaceId, workerId, loopId, { source: "engine:turn", kind: "turn_awaiting_model", level: "info", message: "awaiting model response" });
-                railGrammar = await this.#operatorGrammar(provider);
-                const attemptLimit = readEmissionAttempts();
-                const strikeStreak = await this.#strikes.streak(loopId);
-                // {§turn-accounting-notice} (#465) — every physical exchange this turn pays
-                // for, successes and failed calls alike, so the completion notice carries
-                // the exact settled wire spend.
-                const turnWireAccounting = [];
-                for (let attempt = 1; attempt <= attemptLimit;) {
-                    // Capacity recovery may rebuild and resend the request without
-                    // consuming a grammar-emission attempt. Every logical provider
-                    // call still receives its own durable sequence and accounting.
-                    currentEmissionAttempt = attempt;
-                    modelCallSequence++;
-                    const attributionContext = Object.freeze({
-                        workspaceId: String(workspaceId),
-                        workerId: providerWorkerId,
-                        primaryWorkerId,
-                        loop: loopSeq,
-                        turn: seq,
-                        attempt: modelCallSequence,
-                    });
-                    providerAttemptAttributions = await this.#attemptAttributions(provider, attributionContext);
-                    requestPacket = { ...requestPacket, attributions: providerAttemptAttributions };
-                    providerModelCall = await ModelCall.open(this.#db, {
+                if (!reasoningStarted) {
+                    reasoningStarted = true;
+                    this.#reasoningEventNotify(workspaceId, {
+                        workerId,
+                        loopId,
                         turnId,
-                        kind: "emission",
-                        attributions: providerAttemptAttributions,
-                        model: provider.model,
-                    });
-                    const attemptRow = await this.#db.engine_open_turn_attempt.get({
-                        model_call_id: providerModelCall.id,
-                    });
-                    if (attemptRow === undefined) {
-                        throw new Error(`Engine.runTurn: provider call ${modelCallSequence} did not open`);
-                    }
-                    providerAttemptId = attemptRow.id;
-                    providerCallInFlight = true;
-                    const currentModelCall = providerModelCall;
-                    let reasoningStarted = false;
-                    let reasoningRequestSequence = 0;
-                    const endReasoning = () => {
-                        if (!reasoningStarted)
-                            return;
-                        this.#reasoningEventNotify(workspaceId, {
-                            workerId,
-                            loopId,
-                            turnId,
-                            modelCallId: currentModelCall.id,
-                            requestSequence: reasoningRequestSequence,
-                            phase: "end",
-                        });
-                        reasoningStarted = false;
-                    };
-                    const observeRequest = async (...args) => {
-                        endReasoning();
-                        const settle = await currentModelCall.observeRequest(...args);
-                        reasoningRequestSequence = currentModelCall.requestSequence;
-                        return settle;
-                    };
-                    // {§notifications-reasoning-event} Only the parent emission is
-                    // conversational; BARE has no observer on its isolated calls.
-                    const observeReasoning = this.#reasoningEventNotify === undefined
-                        ? undefined
-                        : (delta) => {
-                            if (reasoningRequestSequence === 0) {
-                                throw new Error("provider emitted reasoning before opening its physical request");
-                            }
-                            if (!reasoningStarted) {
-                                reasoningStarted = true;
-                                this.#reasoningEventNotify(workspaceId, {
-                                    workerId,
-                                    loopId,
-                                    turnId,
-                                    modelCallId: currentModelCall.id,
-                                    requestSequence: reasoningRequestSequence,
-                                    phase: "start",
-                                });
-                            }
-                            this.#reasoningEventNotify(workspaceId, {
-                                workerId,
-                                loopId,
-                                turnId,
-                                modelCallId: currentModelCall.id,
-                                requestSequence: reasoningRequestSequence,
-                                phase: "content",
-                                delta,
-                            });
-                        };
-                    let completedResponse;
-                    try {
-                        completedResponse = await observed(// {§observability-boundary}
-                        GEN_AI_REQUEST_SPAN, { model: provider.model, attempt: modelCallSequence }, async (span) => {
-                            try {
-                                await this.#packets.recordObservations(requestPacket);
-                                const generated = await provider.generate({
-                                    messages: modelMessages,
-                                    workerId: providerWorkerId,
-                                    primaryWorkerId,
-                                    signal: providerSignal,
-                                    grammar: railGrammar,
-                                    strikes: strikeStreak,
-                                    attributions: providerAttemptAttributions.length > 0
-                                        ? providerAttemptAttributions
-                                        : undefined,
-                                    client: client ?? undefined,
-                                    workspaceId: String(workspaceId),
-                                    loop: loopSeq,
-                                    turn: seq,
-                                    observeRequest,
-                                    observeReasoning,
-                                    callKind: "emission",
-                                }); // {§provider-surface-generate} {§provider-guarantees-signal-wired} {§provider-guarantees-serial-attempts} {§attribution} {§client-metadata}
-                                currentModelCall.assertAccounting(generated.accounting);
-                                providerCallInFlight = false;
-                                recordCounter(PROVIDER_CALLS, {
-                                    model: provider.model,
-                                    attempt: modelCallSequence,
-                                    status: "resolved",
-                                });
-                                span.setAttribute("status", "resolved");
-                                settleGenAiResponse(span, generated);
-                                return generated;
-                            }
-                            catch (error) {
-                                if (error instanceof ProviderError) {
-                                    currentModelCall.assertAccounting(error.accounting);
-                                    turnWireAccounting.push(...error.accounting);
-                                }
-                                throw error;
-                            }
-                        }, genAiRequestOptions(ProviderInstantiate.aliasOf(provider) ?? "plurnk", provider.model));
-                    }
-                    catch (error) {
-                        if (error instanceof ProviderError
-                            && RECOVERABLE_PROVIDER_FAILURES.has(error.kind)
-                            && providerSignal?.aborted !== true) {
-                            // {§provider-recovery} — a transient provider failure never ends the loop:
-                            // record it, wait, and re-issue the same turn; once the budget is spent the
-                            // outer handler parks the loop instead of failing it.
-                            recoveryStartedAt ??= Date.now();
-                            const elapsed = Date.now() - recoveryStartedAt;
-                            if (elapsed >= recoveryBudget) {
-                                providerParked = true;
-                                throw error;
-                            }
-                            recoveryFailures += 1;
-                            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.
-                                await currentModelCall.observeResponse(error.attempt, failure, nativeInputs);
-                                await classifyProviderAttempt(providerAttemptId, this.#splitResponse(error.attempt, this.#executors()?.availableRuntimes(workspaceId) ?? []), currentEmissionAttempt, false);
-                            }
-                            else {
-                                await currentModelCall.fail(failure, error.capacity ?? null);
-                            }
-                            providerCallInFlight = false;
-                            await this.#problems.record({
-                                workerId,
-                                loopId,
-                                turnId,
-                                sequence: nextActionIndex++,
-                                origin: "_plurnk",
-                                source: "provider",
-                                result: failure,
-                            });
-                            const wait = Math.min(recoveryBackoff * 2 ** (recoveryFailures - 1), recoveryBackoff * 12);
-                            this.#notices.push(workspaceId, workerId, loopId, {
-                                source: "engine:provider",
-                                kind: "provider_unavailable",
-                                level: "warn",
-                                message: `${failure.problem?.title ?? "Provider failure"}: retrying in ${Math.round(wait / 1000)}s (${Math.round(elapsed / 1000)}s of the ${Math.round(recoveryBudget / 1000)}s recovery budget spent).`,
-                            });
-                            // An abort during the wait re-enters generate, which refuses on the aborted signal.
-                            await delay(wait, undefined, { signal: providerSignal }).catch(() => undefined);
-                            // The response is still owed for this exact input. Failure rows remain
-                            // durable, but recursively materializing them would mutate and cache-bust
-                            // the request being recovered. {§provider-recovery}
-                            continue;
-                        }
-                        if (!(error instanceof ProviderError)
-                            || error.kind !== "capacity_exceeded"
-                            || providerSignal?.aborted === true
-                            || !await recoverCapacityPacket()) {
-                            throw error;
-                        }
-                        const failure = TurnRunner.#providerFailure(error, providerSignal);
-                        await currentModelCall.fail(failure, error.capacity ?? null);
-                        providerCallInFlight = false;
-                        await this.#problems.record({
-                            workerId,
-                            loopId,
-                            turnId,
-                            sequence: nextActionIndex++,
-                            origin: "_plurnk",
-                            source: "provider",
-                            result: failure,
-                        });
-                        // Include the durable recovery signal in the replacement
-                        // request while preserving the selected recovery posture.
-                        requestPacket = await buildPacket();
-                        materializedRequest = await this.#wireMessages(requestPacket, systemCtx, provider);
-                        modelMessages = materializedRequest.messages;
-                        nativeInputs = materializedRequest.nativeInputs;
-                        continue;
-                    }
-                    finally {
-                        endReasoning();
-                    }
-                    if (recoveryFailures > 0) {
-                        this.#notices.push(workspaceId, workerId, loopId, {
-                            source: "engine:provider",
-                            kind: "provider_recovered",
-                            level: "info",
-                            message: `Provider recovered after ${recoveryFailures} failed call${recoveryFailures === 1 ? "" : "s"}.`,
-                        });
-                        recoveryFailures = 0;
-                        recoveryStartedAt = null;
-                    }
-                    response = completedResponse;
-                    turnWireAccounting.push(...completedResponse.accounting);
-                    await currentModelCall.observeResponse(completedResponse, null, nativeInputs);
-                    railEvidence = railGrammar === undefined ? undefined : completedResponse.grammarEvidence;
-                    splitResponse = this.#splitResponse(completedResponse, this.#executors()?.availableRuntimes(workspaceId) ?? []);
-                    await classifyProviderAttempt(attemptRow.id, splitResponse, attempt, splitResponse.emissionValid);
-                    if (splitResponse.emissionValid)
-                        break;
-                    attempt++;
-                }
-                if (!signal?.aborted) {
-                    const wire = aggregateProviderAccounting(turnWireAccounting);
-                    this.#notices.push(workspaceId, workerId, loopId, {
-                        source: "engine:turn",
-                        kind: "turn_generated",
-                        level: "info",
-                        message: "parsing model response",
-                        // {§turn-accounting-notice} (#465) — the exact settled derivation,
-                        // never a second stored fact: a live watcher accrues loop cost per turn.
-                        accounting: {
-                            requests: turnWireAccounting.length,
-                            costUsd: wire.costUsd,
-                            inputTokens: wire.usage?.inputTokens ?? null,
-                            outputTokens: wire.usage?.outputTokens ?? null,
-                            reasoningTokens: wire.usage?.outputTokenDetails?.reasoningTokens ?? null,
-                            cacheReadTokens: wire.usage?.inputTokenDetails?.cacheReadTokens ?? null,
-                        },
+                        modelCallId: modelCall.id,
+                        requestSequence: reasoningRequestSequence,
+                        phase: "start",
                     });
                 }
-            }
-            catch (err) {
-                // This handler owns only provider-call failures. Parser, cost, SQL,
-                // and engine-contract failures retain their original source.
-                if (err instanceof ModelCallPersistenceError || err instanceof ProviderAccountingIntegrityError)
-                    throw err;
-                if (!providerCallInFlight)
-                    throw err;
-                providerCallInFlight = false;
-                if (providerAttemptId === null || providerModelCall === null) {
-                    throw new Error("provider call failed without durable model-call and attempt identities", { cause: err });
-                }
-                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.
-                // Persist it as an unaccepted attempt before settling the failure.
-                if (err instanceof ProviderError && err.attempt !== undefined) {
-                    response = err.attempt;
-                    await providerModelCall.observeResponse(response, failure, nativeInputs);
-                    splitResponse = this.#splitResponse(response, this.#executors()?.availableRuntimes(workspaceId) ?? []);
-                    await classifyProviderAttempt(providerAttemptId, splitResponse, currentEmissionAttempt, false);
-                }
-                else {
-                    await providerModelCall.fail(failure, err instanceof ProviderError ? err.capacity ?? null : null);
-                    if (!capacityFailure)
-                        emissionAttempts = currentEmissionAttempt;
-                }
-                // {§turn-never-blank} — a ProviderError means no completed exchange exists.
-                // Persist its exact RFC 9457 result before propagating it. Grammar transport
-                // evidence exists only on completed responses ({§operator-grammar}).
-                // Cancellation is lifecycle truth, not a provider failure. Close the
-                // attempted turn without inventing an assistant response, then let
-                // runLoop/Daemon settle the exact 504/499 loop result.
-                if (providerSignal?.aborted) {
-                    const status = providerSignal.reason === LOOP_TIMEOUT_REASON ? 504 : 499;
-                    await this.#recordInference({
-                        workspaceId, workerId, loopId, turnId,
-                        evidence: {
-                            packet: StoredPacket.stringify(requestPacket),
-                            sections: StoredPacket.sections(requestPacket),
-                            usageCurationBudget: this.#packets.curationBudgetFor(requestPacket),
-                            finishReason: splitResponse?.callMetadata.finishReason ?? null,
-                            model: splitResponse?.callMetadata.model ?? provider.model,
-                            meta: JSON.stringify(response?.meta ?? {}),
-                        },
-                    });
-                    await Turn.complete(this.#db, turnId, status);
-                    throw err;
-                }
-                const recorded = await this.#problems.record({
+                this.#reasoningEventNotify(workspaceId, {
                     workerId,
                     loopId,
                     turnId,
-                    sequence: nextActionIndex,
-                    origin: "_plurnk",
-                    source: "provider",
-                    result: failure,
+                    modelCallId: modelCall.id,
+                    requestSequence: reasoningRequestSequence,
+                    phase: "content",
+                    delta,
                 });
-                // The provider call was attempted, but no completed exchange exists.
-                // Persist the exact request half and failure status; omitting assistant
-                // is materially different from fabricating an empty model turn.
-                await this.#recordInference({
-                    workspaceId, workerId, loopId, turnId,
-                    evidence: {
-                        packet: StoredPacket.stringify(requestPacket),
-                        sections: StoredPacket.sections(requestPacket),
-                        usageCurationBudget: this.#packets.curationBudgetFor(requestPacket),
-                        finishReason: splitResponse?.callMetadata.finishReason ?? null,
-                        model: splitResponse?.callMetadata.model ?? provider.model,
-                        meta: JSON.stringify(response?.meta ?? {}),
-                    },
-                });
-                await Turn.complete(this.#db, turnId, providerParked ? 202 : recorded.result.status);
-                if (providerParked) {
-                    // {§provider-recovery} — the recovery budget is spent: the loop parks exactly like a
-                    // [202] wait and resumes on the next prompt or wake; the failure stays durable.
-                    this.#notices.push(workspaceId, workerId, loopId, {
-                        source: "engine:provider",
-                        kind: "provider_unavailable",
-                        level: "error",
-                        message: `${recorded.result.problem?.title ?? "Provider failure"}: the ${Math.round(recoveryBudget / 1000)}s recovery budget is spent; the loop is parked and resumes on the next prompt or wake.`,
-                    });
-                    return {
-                        createdTurnIds,
-                        turnId,
-                        producer: "model",
-                        kind: "inference",
-                        status: 202,
-                        outcomes: [],
-                        fingerprint: "",
-                        capacityHardStop: false, providerParked: true,
-                        providerFailure: recorded.result,
-                        steerStruck: false,
-                        emptyTurn: false,
-                        emissionAttempts,
-                        emissionExhausted: false,
-                    };
-                }
-                if (capacityFailure) {
-                    return {
-                        createdTurnIds,
-                        turnId,
-                        producer: "model",
-                        kind: "inference",
-                        status: recorded.result.status,
-                        outcomes: [],
-                        fingerprint: "",
-                        capacityHardStop: true,
-                        providerParked: false,
-                        capacityFailure: recorded.result,
-                        steerStruck: false,
-                        emptyTurn: false,
-                        emissionAttempts,
-                        emissionExhausted: false,
-                    };
-                }
-                if (err instanceof ProviderError
-                    && err.kind === "invalid_response"
-                    && providerSignal?.aborted !== true) {
-                    // {§engine-rails} Contract Strikes: the provider violated its response
-                    // contract. The failure is durable and the turn is complete; the strike
-                    // rail — never an instant loop death — rules whether the streak ends it.
-                    return {
-                        createdTurnIds,
-                        turnId,
-                        producer: "model",
-                        kind: "inference",
-                        status: recorded.result.status,
-                        outcomes: [{ op: null, status: recorded.result.status, problemType: recorded.result.problem?.type ?? null }],
-                        fingerprint: `provider-contract-violation:${turnId}`,
-                        capacityHardStop: false,
-                        providerParked: false,
-                        providerFailure: recorded.result,
-                        steerStruck: false,
-                        emptyTurn: false,
-                        emissionAttempts,
-                        emissionExhausted: false,
-                    };
-                }
-                throw new OperationFailureError(recorded.result, { cause: err });
-            }
-            if (response === undefined || splitResponse === undefined || providerModelCall === null) {
-                throw new Error("provider attempt loop completed without a response");
-            }
-            const emissionModelCallId = providerModelCall.id;
-            if (splitResponse.packetAssistant.reasoning?.length) {
-                await Turn.recordSource(this.#db, turnId, "reasoning", splitResponse.packetAssistant.reasoning, { modelCallId: emissionModelCallId });
-            }
-            if (!splitResponse.emissionValid) {
-                // {§invalid-emission-attempts} Every exhaustion publishes the raw final
-                // response and its recovery fact; {§engine-rails} Contract Strikes rule
-                // how many consecutive frame-contract violations the loop survives.
-                let rejectedModelEntryId;
-                {
-                    rejectedModelEntryId = await this.#dispatcher.writeEmissionAttempt({
-                        verbatim: splitResponse.packetAssistant.content,
-                        workerId,
-                        loopId,
-                        turnId,
-                        sequence: nextActionIndex,
-                        modelCallId: emissionModelCallId,
-                    });
-                    // {§invalid-emission-attempts} — the informed turn carries the parser's own
-                    // diagnostic and position: the model sees WHY, not only that it was refused.
-                    const diagnostic = splitResponse.parseErrors[0];
-                    const cut = allowanceCutMessage(splitResponse.callMetadata.finishReason, response.capacity.responseMax ?? provider.outputBudget);
-                    if (cut !== null) {
-                        this.#notices.push(workspaceId, workerId, loopId, {
-                            source: "engine:capacity",
-                            kind: "output_truncated",
-                            level: "error",
-                            message: `${cut}; no operations were performed`,
-                        });
-                    }
-                    else {
-                        this.#notices.push(workspaceId, workerId, loopId, {
-                            source: "engine:grammar",
-                            kind: "invalid_emission",
-                            level: "error",
-                            message: diagnostic === undefined
-                                ? INVALID_EMISSION_RECOVERY_MESSAGE
-                                : `${INVALID_EMISSION_RECOVERY_MESSAGE} Parser: ${diagnostic.message}`,
-                            ...(diagnostic !== undefined && diagnostic.line > 0
-                                ? { position: { type: "content-offset", line: diagnostic.line, column: diagnostic.column } }
-                                : {}),
-                        });
-                    }
-                }
-                const status = TURN_STATUS_IMPLICIT_CONTINUE;
-                await this.#recordInference({
-                    workspaceId, workerId, loopId, turnId,
-                    evidence: {
-                        packet: StoredPacket.stringify(requestPacket),
-                        sections: StoredPacket.sections(requestPacket),
-                        usageCurationBudget: this.#packets.curationBudgetFor(requestPacket),
-                        finishReason: splitResponse.callMetadata.finishReason,
-                        model: splitResponse.callMetadata.model,
-                        meta: JSON.stringify(response.meta ?? {}),
-                    },
+            };
+        return { observeRequest, observeReasoning, end };
+    }
+    // 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) {
+        return await observed(// {§observability-boundary}
+        genAiRequestName(provider.model), { model: provider.model, attempt: attempts.modelCallSequence }, async (span) => {
+            try {
+                await this.#packets.recordObservations(request.packet);
+                const generated = await provider.generate({
+                    messages: attempts.wire.messages,
+                    workerId: attempts.providerWorkerId,
+                    workspaceId: String(workspaceId),
+                    signal: attempts.signal,
+                    grammar: attempts.railGrammar,
+                    observeRequest: reasoning.observeRequest,
+                    observeReasoning: reasoning.observeReasoning,
+                    callKind: "emission",
+                }); // {§provider-surface-generate} {§provider-guarantees-signal-wired} {§provider-guarantees-serial-attempts} {§attribution}
+                modelCall.assertAccounting(generated.accounting);
+                attempts.callInFlight = false;
+                recordCounter(PROVIDER_CALLS, {
+                    model: provider.model,
+                    attempt: attempts.modelCallSequence,
+                    status: "resolved",
                 });
-                await Turn.complete(this.#db, turnId, status);
-                return {
-                    createdTurnIds,
-                    turnId,
-                    producer: "model",
-                    kind: "inference",
-                    status: TURN_STATUS_IMPLICIT_CONTINUE,
-                    outcomes: [{ op: null, status: 500, problemType: "https://problems.plurnk.xyz/engine/invalid-emission-exhausted" }],
-                    fingerprint: `frame-contract-violation:${turnId}`,
-                    capacityHardStop: false,
-                    providerParked: false,
-                    steerStruck: false,
-                    emptyTurn: false,
-                    emissionAttempts,
-                    emissionExhausted: true,
-                    ...(rejectedModelEntryId === undefined ? {} : { rejectedModelEntryId }),
-                };
+                span.setAttribute("status", "resolved");
+                settleGenAiResponse(span, generated);
+                return generated;
             }
-            // {§packet-stored-shape} — admitted emission data extends the packet;
-            // provider-call metadata remains on the Turn row.
-            const { packetAssistant, callMetadata, parseNotices, recoverableParseErrors, } = splitResponse; // raw assistant content is opaque — split, never interpreted — {§provider-guarantees-assistantraw-opaque}
-            for (const notice of parseNotices) {
-                this.#notices.push(workspaceId, workerId, loopId, notice);
-            }
-            // {§empty-turn} — a response cut at the output allowance with nothing admitted names the
-            // cut, so the model reads the ceiling, never a parser symptom (#478).
-            if (splitResponse.emptyTurn && callMetadata.finishReason === "length") {
-                const cut = allowanceCutMessage(callMetadata.finishReason, response.capacity.responseMax ?? provider.outputBudget);
-                if (cut !== null) {
-                    this.#notices.push(workspaceId, workerId, loopId, {
-                        source: "engine:turn",
-                        kind: "output_truncated",
-                        level: "warn",
-                        message: `${cut}; no operations were performed`,
-                    });
+            catch (error) {
+                if (error instanceof ProviderError) {
+                    modelCall.assertAccounting(error.accounting);
+                    attempts.turnWireAccounting.push(...error.accounting);
                 }
+                throw error;
             }
-            // Non-fatal provider transport notices on an accepted turn. Forward each
-            // Notice with a content-offset `line:col`;
-            // the model resolves it against its own emission — READ ops:///<loop>/<turn> at the
-            // cited lines ({§turn-ops-entry}) — not an embedded snippet that would duplicate the emission.
-            for (const notice of response.notices ?? []) {
-                const located = typeof notice.position === "number"
-                    ? this.#offsetToLineColumn(packetAssistant.content, notice.position)
-                    : null;
-                this.#notices.push(workspaceId, workerId, loopId, {
-                    source: notice.source,
-                    kind: notice.kind,
-                    message: notice.message ?? "",
-                    level: notice.level,
-                    ...(located !== null
-                        ? { position: { type: "content-offset", line: located.line, column: located.column } }
-                        : {}),
-                });
-            }
-            const allowanceCut = allowanceCutMessage(splitResponse.callMetadata.finishReason, response.capacity.responseMax ?? provider.outputBudget);
-            if (allowanceCut !== null) {
-                this.#notices.push(workspaceId, workerId, loopId, {
-                    source: "engine:capacity",
-                    kind: "output_truncated",
-                    message: allowanceCut,
-                    level: "warn",
-                });
-            }
-            // {§operator-grammar} — transport evidence only: the turn records whether the operator's
-            // grammar reached the wire. Nothing grades the response against it; the parser's
-            // admission is the one verdict (#588).
-            const railKeys = railGrammar === undefined
-                ? undefined
-                : { railsAttached: railEvidence?.transported === true ? "client" : "withheld" };
-            // Attach the admitted inference evidence. The turn remains open until
-            // the producer-neutral admitted-turn executor settles every operation
-            // and its exact source artifact.
-            const packet = StoredPacket.admit(requestPacket, packetAssistant, response.assistantRaw);
-            await this.#recordInference({
-                workspaceId, workerId, loopId, turnId,
-                evidence: {
-                    packet: StoredPacket.stringify(packet),
-                    sections: StoredPacket.sections(packet),
-                    usageCurationBudget: this.#packets.curationBudgetFor(requestPacket), // {§tokenomics-client-gauge}
-                    finishReason: callMetadata.finishReason,
-                    model: callMetadata.model,
-                    // Opaque provider metadata plus the grammar transport key.
-                    // {§meta-passthrough}, {§operator-grammar}
-                    meta: JSON.stringify({ ...(response.meta ?? {}), ...(railKeys ?? {}) }),
-                },
-            });
-            // {§operator-config-workspace-max-commands} — workspace maxCommands
-            // narrows the operator ceiling before the admitted program reaches the
-            // shared executor.
-            const maxCommands = Math.min(readMaxCommands(), (await WorkspaceSettings.read(this.#db, workspaceId)).maxCommands ?? Number.POSITIVE_INFINITY);
-            const executed = await this.executeAdmittedTurn({
-                statements: packetAssistant.ops,
-                source: splitResponse.sourceBacked ? packetAssistant.content : null,
-                sourceModelCallId: emissionModelCallId,
-                origin: "model",
-                workspaceId,
-                workerId,
-                loopId,
-                turnId,
-                fromSequence: nextActionIndex,
-                maxCommands,
-                allowUnobservedRetrievalCompletion,
-                recoverableParseErrors,
-                emptyTurn: splitResponse.emptyTurn,
-                bare: {
-                    provider: childProvider,
-                    primaryWorkerId,
-                    loopSequence: loopSeq,
-                    turnSequence: seq,
-                    signal: providerSignal,
-                },
-                signal: providerSignal,
-                onDispatch,
-                onSettled,
+        }, genAiRequestOptions(ProviderInstantiate.providerIdOf(provider) ?? "other", provider.model));
+    }
+    // {§provider-recovery} — a transient provider failure never ends the loop: record
+    // it, wait, and re-issue the same turn; once the budget is spent the failure
+    // handler parks the loop instead of failing it.
+    async #recoverProviderFailure({ workspaceId, workerId, loopId }, request, attempts, modelCall, attemptId, error) {
+        attempts.recoveryStartedAt ??= Date.now();
+        const elapsed = Date.now() - attempts.recoveryStartedAt;
+        if (elapsed >= attempts.recoveryBudget) {
+            attempts.parked = true;
+            throw error;
+        }
+        attempts.recoveryFailures += 1;
+        const failure = _a.#providerFailure(error, attempts.signal);
+        if (error.attempt !== undefined) {
+            // {§provider-interrupted-attempt} — the interrupted response stays durable
+            // as an unaccepted attempt; it is never admitted or replayed.
+            await modelCall.observeResponse(error.attempt, failure, attempts.wire.nativeInputs);
+            await this.#classifyProviderAttempt(attempts, attemptId, this.#splitResponse(error.attempt, this.#executors()?.availableRuntimes(workspaceId) ?? []), attempts.currentEmissionAttempt, false);
+        }
+        else {
+            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,
+        });
+        const wait = Math.min(attempts.recoveryBackoff * 2 ** (attempts.recoveryFailures - 1), readProviderRecoveryBackoffMax());
+        this.#notices.push(workspaceId, workerId, loopId, {
+            source: "engine:provider",
+            kind: "provider_unavailable",
+            level: "warn",
+            message: `${failure.problem?.title ?? "Provider failure"}: retrying in ${Math.round(wait / 1000)}s (${Math.round(elapsed / 1000)}s of the ${Math.round(attempts.recoveryBudget / 1000)}s recovery budget spent).`,
+        });
+        // An abort during the wait re-enters generate, which refuses on the aborted signal.
+        await delay(wait, undefined, { signal: attempts.signal }).catch(() => undefined);
+        // The response is still owed for this exact input. Failure rows remain
+        // 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) {
+        const result = await this.#db.engine_classify_turn_attempt_response.run({
+            id,
+            accepted: accepted ? 1 : 0,
+            parse_errors: JSON.stringify(split.parseErrors),
+        });
+        if (result.changes !== 1) {
+            throw new Error(`emission attempt ${id} was not awaiting classification`);
+        }
+        attempts.emissionAttempts = emissionAttempt;
+    }
+    // The provider-call failure handler. It owns only failures raised while a call
+    // was in flight; parser, cost, SQL, and engine-contract failures retain their
+    // original source.
+    async #settleProviderFailure(err, args, request, attempts) {
+        if (err instanceof ModelCallPersistenceError || err instanceof ProviderAccountingIntegrityError)
+            throw err;
+        if (!attempts.callInFlight)
+            throw err;
+        attempts.callInFlight = false;
+        if (attempts.attemptId === null || attempts.modelCall === null) {
+            throw new Error("provider call failed without durable model-call and attempt identities", { cause: err });
+        }
+        const { provider, workspaceId, workerId, loopId } = args;
+        const { turnId } = request;
+        const failure = _a.#providerFailure(err, attempts.signal);
+        const capacityFailure = err instanceof ProviderError && err.kind === "capacity_exceeded";
+        // {§provider-interrupted-attempt} — a provider-declared interruption
+        // carries response evidence without becoming a completed exchange.
+        // Persist it as an unaccepted attempt before settling the failure.
+        if (err instanceof ProviderError && err.attempt !== undefined) {
+            attempts.response = err.attempt;
+            await attempts.modelCall.observeResponse(err.attempt, failure, attempts.wire.nativeInputs);
+            attempts.split = this.#splitResponse(err.attempt, this.#executors()?.availableRuntimes(workspaceId) ?? []);
+            await this.#classifyProviderAttempt(attempts, attempts.attemptId, attempts.split, attempts.currentEmissionAttempt, false);
+        }
+        else {
+            await attempts.modelCall.fail(failure, err instanceof ProviderError ? err.capacity ?? null : null);
+            if (!capacityFailure)
+                attempts.emissionAttempts = attempts.currentEmissionAttempt;
+        }
+        const evidence = this.#requestEvidence(provider, request.packet, attempts.split, attempts.response);
+        // {§turn-never-blank} — a ProviderError means no completed exchange exists.
+        // Persist its exact RFC 9457 result before propagating it. Grammar transport
+        // evidence exists only on completed responses ({§operator-grammar}).
+        // Cancellation is lifecycle truth, not a provider failure. Close the
+        // attempted turn without inventing an assistant response, then let
+        // runLoop/Daemon settle the exact 504/499 loop result.
+        if (attempts.signal?.aborted) {
+            const status = attempts.signal.reason === LOOP_TIMEOUT_REASON ? 504 : 499;
+            await this.#recordInference({ workspaceId, workerId, loopId, turnId, evidence });
+            await Turn.complete(this.#db, turnId, status);
+            throw err;
+        }
+        const recorded = await this.#problems.record({
+            workerId,
+            loopId,
+            turnId,
+            sequence: request.nextActionIndex,
+            origin: "_plurnk",
+            source: "provider",
+            result: failure,
+        });
+        // The provider call was attempted, but no completed exchange exists.
+        // Persist the exact request half and failure status; omitting assistant
+        // is materially different from fabricating an empty model turn.
+        await this.#recordInference({ workspaceId, workerId, loopId, turnId, evidence });
+        await Turn.complete(this.#db, turnId, attempts.parked ? 202 : recorded.result.status);
+        const { emissionAttempts } = attempts;
+        if (attempts.parked) {
+            // {§provider-recovery} — the recovery budget is spent: the loop parks exactly like a
+            // [202] wait and resumes on the next prompt or wake; the failure stays durable.
+            // {§loop-attendance} — unattended, nothing will wake it, so LoopDriver concludes instead
+            // and the notice says that rather than promising a resumption nobody can deliver.
+            const { attended } = await LoopPolicyReader.read(this.#db, loopId);
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: "engine:provider",
+                kind: "provider_unavailable",
+                level: "error",
+                message: `${recorded.result.problem?.title ?? "Provider failure"}: the ${Math.round(attempts.recoveryBudget / 1000)}s recovery budget is spent; ${attended ? "the loop is parked and resumes on the next prompt or wake" : "this run is unattended, so the loop ends here"}.`,
             });
-            return {
-                createdTurnIds,
-                turnId,
-                producer: "model",
-                kind: "inference",
-                status: executed.status,
-                outcomes: executed.outcomes,
-                fingerprint: executed.fingerprint,
-                capacityHardStop: false,
-                providerParked: false,
-                steerStruck: executed.steerStruck,
-                emptyTurn: executed.emptyTurn,
+            return turnResult(request, 202, { providerParked: true, providerFailure: recorded.result, emissionAttempts });
+        }
+        if (capacityFailure) {
+            return turnResult(request, recorded.result.status, { capacityHardStop: true, capacityFailure: recorded.result, emissionAttempts });
+        }
+        if (err instanceof ProviderError && err.kind === "invalid_response") {
+            // {§engine-rails} Contract Strikes: the provider violated its response
+            // contract. The failure is durable and the turn is complete; the strike
+            // rail — never an instant loop death — rules whether the streak ends it.
+            return turnResult(request, recorded.result.status, {
+                outcomes: [{ op: null, status: recorded.result.status, problemType: recorded.result.problem?.type ?? null }],
+                fingerprint: `provider-contract-violation:${turnId}`,
+                providerFailure: recorded.result,
                 emissionAttempts,
-                emissionExhausted: false,
-            };
+            });
         }
-        catch (cause) {
-            const completionFailures = [];
-            for (const createdTurnId of createdTurnIds) {
-                try {
-                    await Turn.failOpen(this.#db, createdTurnId);
-                }
-                catch (completionCause) {
-                    completionFailures.push(completionCause);
-                }
-            }
-            if (completionFailures.length > 0) {
-                throw new AggregateError([cause, ...completionFailures], "turn execution failed and its open turn containers could not all be completed");
-            }
-            throw cause;
+        throw new OperationFailureError(recorded.result, { cause: err });
+    }
+    // Inference evidence for a turn without an admitted exchange: the exact request
+    // half, the last attempt's metadata when one exists, the provider's own model otherwise.
+    #requestEvidence(provider, packet, split, response) {
+        return {
+            packet: StoredPacket.stringify(packet),
+            sections: StoredPacket.sections(packet),
+            usageCurationBudget: this.#packets.curationBudgetFor(packet),
+            finishReason: split?.callMetadata.finishReason ?? null,
+            model: split?.callMetadata.model ?? provider.model,
+            meta: JSON.stringify(response?.meta ?? {}),
+        };
+    }
+    // Phase 5, refused — {§invalid-emission-attempts}: every exhaustion publishes the
+    // raw final response and its recovery fact; {§engine-rails} Contract Strikes rule
+    // how many consecutive frame-contract violations the loop survives.
+    async #rejectExhaustedEmission({ provider, workspaceId, workerId, loopId }, request, emission) {
+        const { split, response } = emission;
+        const { turnId } = request;
+        const rejectedModelEntryId = await this.#dispatcher.writeEmissionAttempt({
+            verbatim: split.packetAssistant.content,
+            workerId,
+            loopId,
+            turnId,
+            sequence: request.nextActionIndex,
+            modelCallId: emission.modelCallId,
+        });
+        // {§invalid-emission-attempts} — the informed turn carries the parser's own
+        // diagnostic and position: the model sees WHY, not only that it was refused.
+        const diagnostic = split.parseErrors[0];
+        const cut = allowanceCutMessage(split.callMetadata.finishReason, response.capacity.responseMax ?? provider.outputBudget);
+        if (cut !== null) {
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: "engine:capacity",
+                kind: "output_truncated",
+                level: "error",
+                message: `${cut}; no operations were performed`,
+            });
+        }
+        else {
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: "engine:grammar",
+                kind: "invalid_emission",
+                level: "error",
+                message: diagnostic === undefined
+                    ? INVALID_EMISSION_RECOVERY_MESSAGE
+                    : `${INVALID_EMISSION_RECOVERY_MESSAGE} Parser: ${diagnostic.message}`,
+                ...(diagnostic !== undefined && diagnostic.line > 0
+                    ? { position: { type: "content-offset", line: diagnostic.line, column: diagnostic.column } }
+                    : {}),
+            });
         }
+        await this.#recordInference({ workspaceId, workerId, loopId, turnId, evidence: this.#requestEvidence(provider, request.packet, split, response) });
+        await Turn.complete(this.#db, turnId, TURN_STATUS_IMPLICIT_CONTINUE);
+        return turnResult(request, TURN_STATUS_IMPLICIT_CONTINUE, {
+            outcomes: [{ op: null, status: 500, problemType: "https://problems.plurnk.xyz/engine/invalid-emission-exhausted" }],
+            fingerprint: `frame-contract-violation:${turnId}`,
+            emissionAttempts: emission.emissionAttempts,
+            emissionExhausted: true,
+            rejectedModelEntryId,
+        });
+    }
+    // Phase 5, admitted — the emission's notices, then {§packet-stored-shape}: admitted
+    // emission data extends the packet while provider-call metadata remains on the
+    // Turn row.
+    async #recordAdmittedEmission({ provider, workspaceId, workerId, loopId }, request, emission) {
+        const { split, response } = emission;
+        const { packetAssistant, callMetadata, parseNotices } = split; // raw assistant content is opaque — split, never interpreted — {§provider-guarantees-assistantraw-opaque}
+        for (const notice of parseNotices) {
+            this.#notices.push(workspaceId, workerId, loopId, notice);
+        }
+        const allowanceCut = allowanceCutMessage(callMetadata.finishReason, response.capacity.responseMax ?? provider.outputBudget);
+        // {§empty-turn} — a response cut at the output allowance with nothing admitted names the
+        // cut, so the model reads the ceiling, never a parser symptom (#478).
+        if (split.emptyTurn && allowanceCut !== null) {
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: "engine:turn",
+                kind: "output_truncated",
+                level: "warn",
+                message: `${allowanceCut}; no operations were performed`,
+            });
+        }
+        // Non-fatal provider transport notices on an accepted turn. Forward each
+        // Notice with a content-offset `line:col`;
+        // the model resolves it against its own emission — READ ops://<worker>/<loop>/<turn> at the
+        // cited lines ({§turn-ops-entry}) — not an embedded snippet that would duplicate the emission.
+        for (const notice of response.notices ?? []) {
+            const located = typeof notice.position === "number"
+                ? this.#offsetToLineColumn(packetAssistant.content, notice.position)
+                : null;
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: notice.source,
+                kind: notice.kind,
+                message: notice.message ?? "",
+                level: notice.level,
+                ...(located !== null
+                    ? { position: { type: "content-offset", line: located.line, column: located.column } }
+                    : {}),
+            });
+        }
+        if (allowanceCut !== null) {
+            this.#notices.push(workspaceId, workerId, loopId, {
+                source: "engine:capacity",
+                kind: "output_truncated",
+                message: allowanceCut,
+                level: "warn",
+            });
+        }
+        // {§operator-grammar} — transport evidence only: the turn records whether the operator's
+        // grammar reached the wire. Nothing grades the response against it; the parser's
+        // admission is the one verdict (#588).
+        const railKeys = emission.railGrammar === undefined
+            ? undefined
+            : { railsAttached: emission.railEvidence?.transported === true ? "client" : "withheld" };
+        // Attach the admitted inference evidence. The turn remains open until
+        // the producer-neutral admitted-turn executor settles every operation
+        // and its exact source artifact.
+        const packet = StoredPacket.admit(request.packet, packetAssistant, response.assistantRaw);
+        await this.#recordInference({
+            workspaceId, workerId, loopId, turnId: request.turnId,
+            evidence: {
+                packet: StoredPacket.stringify(packet),
+                sections: StoredPacket.sections(packet),
+                usageCurationBudget: this.#packets.curationBudgetFor(request.packet), // {§tokenomics-client-gauge}
+                finishReason: callMetadata.finishReason,
+                model: callMetadata.model,
+                // Opaque provider metadata plus the grammar transport key.
+                // {§meta-passthrough}, {§operator-grammar}
+                meta: JSON.stringify({ ...(response.meta ?? {}), ...(railKeys ?? {}) }),
+            },
+        });
+    }
+    // Phase 6 — the admitted program runs under the workspace's command ceiling and
+    // the turn settles on the executor's verdict.
+    async #settleAdmittedTurn(args, request, emission) {
+        const { childProvider, workspaceId, workerId, loopId, onDispatch, onSettled } = args;
+        const { split } = emission;
+        // {§operator-config-workspace-max-commands} — workspace maxCommands
+        // narrows the operator ceiling before the admitted program reaches the
+        // shared executor.
+        const maxCommands = Math.min(readMaxCommands(), (await WorkspaceSettings.read(this.#db, workspaceId)).maxCommands ?? Number.POSITIVE_INFINITY);
+        const executed = await this.executeAdmittedTurn({
+            statements: split.packetAssistant.ops,
+            source: split.sourceBacked ? split.packetAssistant.content : null,
+            sourceModelCallId: emission.modelCallId,
+            origin: "model",
+            workspaceId,
+            workerId,
+            loopId,
+            turnId: request.turnId,
+            fromSequence: request.nextActionIndex,
+            maxCommands,
+            recoverableParseErrors: split.recoverableParseErrors,
+            emptyTurn: split.emptyTurn,
+            proseAnswer: split.proseAnswer,
+            bare: {
+                provider: childProvider,
+                loopSequence: request.loopSeq,
+                turnSequence: request.seq,
+                signal: emission.signal,
+            },
+            signal: emission.signal,
+            onDispatch,
+            onSettled,
+        });
+        return turnResult(request, executed.status, {
+            outcomes: executed.outcomes,
+            fingerprint: executed.fingerprint,
+            emptyTurn: executed.emptyTurn,
+            emissionAttempts: emission.emissionAttempts,
+        });
     }
     // Split the wire-level ProviderResponse into the two destinations:
     // packet.assistant gets the model's emission (content, ops, reasoning);
@@ -1462,7 +1417,7 @@ export default class TurnRunner {
                             });
                         }
                         else {
-                            parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source, ...(err.code === undefined ? {} : { code: err.code }) });
+                            parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source });
                         }
                     }
                     else {
@@ -1471,34 +1426,69 @@ export default class TurnRunner {
                     }
                 }
             }
-            // Boundary loss is the parser's one public fact from `unparsedTail.from` onward;
-            // preserve it with the rejected forensic attempt. {§unparsed-tail-boundary}
+            // {§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" });
             }
         }
+        // {§prose-conclusion} — a response whose content is prose (no operation, no attempt at one,
+        // not cut at the output allowance) is the model's answer: a SEND to the open messages.
+        // {§quotation} a reply wrapped whole in one markdown fence is delivered as its content.
+        const wrapped = /^(`{3,}|~{3,})(?:markdown|md)[ \t]*\n([\s\S]*?)\n\1[ \t]*$/u.exec(assistant.content.trim());
+        const prose = (wrapped?.[2] ?? assistant.content).trim();
+        const concludes = preParsedOps === undefined
+            && ops.length === 0
+            && !hasUnparsedTail
+            && prose.length > 0
+            && assistant.finishReason !== "length"
+            && parseErrors.every((error) => error.message === PlurnkParser.NO_VALID_OPERATION)
+            && PlurnkParser.operationAttempt(assistant.content, executors) === null
+            // {§quotation} an answer says something of its own: a reply that is nothing but quoted
+            // material is a misfenced program, not prose (operator, 2026-09-18).
+            && PlurnkParser.unquoted(prose, executors).trim().length > 0
+            // {§quotation} an operation fence that merely missed column zero is a misplaced program,
+            // never an answer: the loop continues and the next packet carries the parser's word.
+            && !parseNotices.some(({ message }) => (message ?? "").includes("must start its line to run"));
+        const proseAnswer = concludes
+            ? { op: "SEND", aside: null, target: null, metadata: null, lineMarker: null, body: { raw: prose, json: null }, position: { line: 1, column: 0 } }
+            : null;
+        if (proseAnswer !== null) {
+            parseErrors.length = 0;
+            ops.push(proseAnswer);
+        }
+        // The statements the content itself closed: a lost boundary is admissible only behind one
+        // of these, never behind a reasoning NOTE alone ({§reasoning-notes}).
+        const contentStatementCount = ops.filter(({ position }) => position.line > 0).length;
+        const reasoning = assistant.reasoning ?? null;
+        const notes = reasoning === null ? [] : PlurnkParser.parseReasoningNotes(reasoning);
+        ops.unshift(...notes);
+        if (notes.length > 0) {
+            // A reasoned NOTE is an operation even when the content contains no program.
+            for (let index = parseErrors.length - 1; index >= 0; index--) {
+                if (parseErrors[index].message === PlurnkParser.NO_VALID_OPERATION)
+                    parseErrors.splice(index, 1);
+            }
+        }
         const sourceStatementCount = ops.filter(({ position }) => position.line > 0).length;
-        const dispositions = ops.filter(TurnDisposition.is);
-        const trustworthyBoundary = dispositions.length <= 1 && !hasUnparsedTail;
-        // {§turn-shape} — bounded operation errors are recoverable and ride with the
-        // admitted program; document-boundary failures still reject it.
-        const recoverableParseErrors = trustworthyBoundary
-            ? parseErrors.filter((error) => error.code !== "invalid-turn-structure").toSorted(comparePosition)
-            : [];
+        // {§turn-shape} — every hard diagnostic is recoverable and rides with the admitted program
+        // as a failed row; a lost boundary refuses only what follows it. The harness admits every
+        // program whose meaning it can determine and reports what it could not read.
+        const recoverableParseErrors = [...parseErrors].toSorted(comparePosition);
         // {§empty-turn} — no operation and no other hard error: admitted as an empty turn, never
-        // resampled; its advisories ({§bare-heading-advisory}) ride as notices.
+        // resampled; its advisories ({§bare-heading-advisory}) ride as notices. A boundary lost
+        // before any statement closed is not an empty turn: the model tried, and is resampled.
         const emptyTurn = preParsedOps === undefined
-            && trustworthyBoundary
+            && !hasUnparsedTail
             && sourceStatementCount === 0
             && parseErrors.every((error) => error.message === PlurnkParser.NO_VALID_OPERATION);
         const emissionValid = preParsedOps !== undefined
             || emptyTurn
-            || (trustworthyBoundary
-                && sourceStatementCount > 0
-                && recoverableParseErrors.length === parseErrors.length);
-        const reasoning = assistant.reasoning ?? null;
+            || (hasUnparsedTail ? contentStatementCount > 0 : sourceStatementCount > 0);
         return {
             packetAssistant: { content: assistant.content, ops, reasoning },
             sourceBacked: preParsedOps === undefined,
@@ -1506,18 +1496,19 @@ export default class TurnRunner {
             parseErrors,
             recoverableParseErrors: emissionValid && !emptyTurn ? recoverableParseErrors : [],
             emptyTurn,
+            proseAnswer,
             parseNotices,
             // The ANTLR model-turn parser is authoritative. At least one source
-            // operation is required; TASK omission continues silently. Bounded
+            // operation is required; lifecycle omission continues silently. 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.
+            // A boundary lost before any statement closed rejects; after one, the
+            // statements run and the loss is a row. Pre-parsed ops are Mock's trusted test seam.
             emissionValid,
         };
     }
     // #note12 — plugin reference docs are materialized beneath
     // worker:///_plurnk/plurnk/ by LoopDocs.
-    // {§exec-poll} — EXEC `<0>` is turn-scoped: abort the worker's open turn-scoped streams via their
+    // {§exec-lifetime} — a `"turn"` lifetime: 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
     // never survives into the subsequent turn. Fire-and-forget: the spawn finalizes async and its
@@ -1530,4 +1521,6 @@ export default class TurnRunner {
         return this.#admitted.executeAdmittedTurn(...args);
     }
 }
+_a = TurnRunner;
+export default TurnRunner;
 //# sourceMappingURL=TurnRunner.js.map