@plurnk/plurnk-service 1.6.1 → 1.8.0

package/dist/core/TurnRunner.js

@@ -1,7 +1,7 @@
 var _a;
 import { PlurnkParser, PlurnkParseError, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
 import Owner from "./Owner.js";
-const TERMINAL_SEND_SIGNALS = new Set([102, 200, 202, 300, 499]);
+const TERMINAL_SEND_SIGNALS = new Set([102, 200, 202, 499]);
 const comparePosition = (a, b) => a.line - b.line || a.column - b.column;
 import Meta from "@plurnk/plurnk-meta";
 import EntryCrud from "../schemes/_entry-crud.js";
@@ -11,6 +11,14 @@ import WorkspaceSettings from "./workspace-settings.js";
 import { editedSpan } from "../content/index.js";
 import { promptPathname, promptLoopPrefix, renderTarget } from "./plurnk-uri.js";
 import { readFile } from "node:fs/promises";
+// {§grammar-rail-registration} — bare names are the built-in rail namespace;
+// everything else is an import specifier resolved through the Node chain.
+export const resolveGrammarRailPath = (variant) => variant.startsWith("/") || variant.startsWith(".")
+    || variant.includes("/") || variant.includes(":")
+    ? (variant.startsWith("/") || variant.startsWith(".")
+        ? variant
+        : fileURLToPath(import.meta.resolve(variant)))
+    : fileURLToPath(import.meta.resolve(`@plurnk/plurnk-contracts/${variant}`));
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
 // Shared module imported by both Engine and bin/digest.ts, so wire
@@ -20,16 +28,22 @@ import PacketWire from "./packet-wire.js";
 import Results, { OperationFailureError } from "./results.js";
 import BranchReceipt from "./BranchReceipt.js";
 import TerminalResult from "./TerminalResult.js";
+import LoopLifecycle from "./LoopLifecycle.js";
 import WorkerControlAddress from "./WorkerControlAddress.js";
-import JournalTurn from "./JournalTurn.js";
+import Turn from "./Turn.js";
 import LogBody from "./LogBody.js";
+import LogVisibility from "./LogVisibility.js";
 import StrikeRail from "./StrikeRail.js";
 import StoredPacket from "./StoredPacket.js";
 import { observed, observedSync } from "../observe/spans.js";
+import { GEN_AI_REQUEST_SPAN, genAiRequestOptions, settleGenAiResponse, } from "../observe/genai.js";
 import { OPS_DISPATCHED, PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
 import { scheduleTurnOps } from "./turn-scheduler.js";
+import { expandSafeUriTargetGroup } from "./operation-target-groups.js";
 import { readOptimisticSettlementMs } from "./optimistic-settlement.js";
 import ModelCall, { ModelCallPersistenceError, ProviderAccountingIntegrityError, } from "./ModelCall.js";
+import OverflowTurn from "./OverflowTurn.js";
+import TurnOps from "./TurnOps.js";
 const RECORD_STREAM_MIMETYPES = new Set(["application/jsonl", "application/x-ndjson"]);
 const baseMimetype = (mimetype) => mimetype.split(";", 1)[0].trim().toLowerCase();
 // {§exec-stream} Active streams publish only independently meaningful units.
@@ -56,8 +70,8 @@ const ENGINE_PROBLEMS = Object.freeze({
 });
 // The prompt entry target - prompt:///<loop>/<N>, self-only ({§prompt-self-only}):
 // the owner rides the owner_id column, the address carries only the loop coordinate.
-const promptTarget = (loopSeq, turnSeq) => {
-    const storage = promptPathname(loopSeq, turnSeq);
+const promptTarget = (loopSeq, promptOrdinal) => {
+    const storage = promptPathname(loopSeq, promptOrdinal);
     return {
         kind: "url", raw: `prompt://${storage}`,
         scheme: "prompt", username: null, password: null,
@@ -101,7 +115,7 @@ const readFilesItems = () => {
         return null;
     return normalizeFilesItems(Number.parseInt(raw, 10));
 };
-import { ProviderError, resolveActiveAlias, scopeEnvToAlias, } from "@plurnk/plurnk-providers";
+import { ProviderError, scopeEnvToAlias, } from "@plurnk/plurnk-providers";
 import { validateGbnf } from "@plurnk/gbnf";
 import ProviderInstantiate from "./ProviderInstantiate.js";
 // A generated rail may constrain only the sampled continuation while the chat
@@ -126,8 +140,8 @@ const grammarConstraint = (grammar) => {
         response: grammar.replace(roots[0][0], `root ::= ${responseRoot}`),
     };
 };
-const TOKEN_BUDGET_OVERFLOW_DETAIL = "Token Budget Overflow: Token Usage exceeded Token Ceiling. Newest log items were automatically FOLDed to fit within token budget. Curate the log and/or perform more conservatively scoped or chunked retrieval operations to recover.";
-const curationOverflowFailure = (pressure) => Results.failure("engine:context", "token-budget-overflow", 413, TOKEN_BUDGET_OVERFLOW_DETAIL, {}, {
+const TOKEN_BUDGET_OVERFLOW_HARD_DETAIL = "Context Token Budget Overflow: tokensActiveTotal exceeded tokensActiveMax, and the causal overflow turn could not make enough room.";
+const curationOverflowFailure = (pressure) => Results.failure("engine:context", "token-budget-overflow", 413, TOKEN_BUDGET_OVERFLOW_HARD_DETAIL, {}, {
     usage: pressure.weight,
     ceiling: pressure.budget,
     deficit: pressure.excess,
@@ -162,11 +176,12 @@ class TurnRunner {
     #wakeWorkerNotify;
     #executors;
     #loopSignal;
+    #interactions;
     #warmWorkspace;
     #dispatch;
     #resolveWorkerProviderIdentity;
     #gbnfCache = new Map();
-    constructor({ db, schemes, mimetypes, weigh, notices, problems, strikes, packets, dispatcher, liveSubscriptions, streamEventNotify, wakeWorkerNotify, executors, loopSignal, warmWorkspace, dispatch, resolveWorkerProviderIdentity, }) {
+    constructor({ db, schemes, mimetypes, weigh, notices, problems, strikes, packets, dispatcher, liveSubscriptions, streamEventNotify, wakeWorkerNotify, executors, loopSignal, interactions, warmWorkspace, dispatch, resolveWorkerProviderIdentity, }) {
         this.#db = db;
         this.#schemes = schemes;
         this.#mimetypes = mimetypes;
@@ -181,6 +196,7 @@ class TurnRunner {
         this.#wakeWorkerNotify = wakeWorkerNotify;
         this.#executors = executors;
         this.#loopSignal = loopSignal;
+        this.#interactions = interactions;
         this.#warmWorkspace = warmWorkspace;
         this.#dispatch = dispatch;
         this.#resolveWorkerProviderIdentity = resolveWorkerProviderIdentity;
@@ -194,7 +210,7 @@ class TurnRunner {
         _a.#railGapWarned.add(message);
         process.stderr.write(`plurnk-engine: rail verdict unavailable — the configured grammar did not parse in @plurnk/gbnf (${message})\n`);
     }
-    static #requireGrammarEvidence(response) {
+    static #requireGrammarEvidence(response, allowWithheld) {
         const evidence = response.grammarEvidence;
         if (evidence === undefined) {
             throw new Error("provider contract violation: configured GBNF response omitted grammar evidence");
@@ -207,32 +223,42 @@ class TurnRunner {
             || input.slice(evidence.contentStart).join("") !== response.assistant.content) {
             throw new Error("provider contract violation: grammar evidence does not map exactly to assistant.content");
         }
+        if (!allowWithheld && !evidence.transported) {
+            throw new Error("provider contract violation: configured GBNF was not transported outside explicit debug mode");
+        }
         return evidence;
     }
     async #grammarConstraint(provider) {
-        // Resolve through the registered or active alias; ambiguity and load
-        // failures never degrade to unconstrained generation.
-        // {§grammar-enforcement-verified-at-boot}
-        const registered = ProviderInstantiate.aliasOf(provider);
-        const fallback = registered === undefined ? resolveActiveAlias(process.env)?.alias : undefined;
-        if (registered === undefined && fallback === undefined && Object.keys(process.env).some((k) => k.startsWith("PLURNK_PROVIDERS_GBNF_"))) {
-            throw new Error("GBNF constraint: provider has no registered alias and no active alias resolves, while per-alias PLURNK_PROVIDERS_GBNF_* constraints are configured");
-        }
-        const alias = registered ?? fallback ?? "";
-        const variant = scopeEnvToAlias(process.env, alias, ["PLURNK_PROVIDERS_GBNF"]).PLURNK_PROVIDERS_GBNF;
+        // A real alias scopes its rail; an alias-free direct route uses the
+        // global provider configuration. Unrelated alias settings never apply.
+        // {§grammar-configuration-admission}
+        ProviderInstantiate.assertGrammarConfigurationScope(provider);
+        const alias = ProviderInstantiate.configurationAliasOf(provider);
+        const scoped = alias === undefined
+            ? process.env
+            : scopeEnvToAlias(process.env, alias, [
+                "PLURNK_PROVIDERS_GBNF",
+                "PLURNK_PROVIDERS_GBNF_DEBUG",
+            ]);
+        const variant = scoped.PLURNK_PROVIDERS_GBNF;
         if (variant === undefined || variant === "" || variant === "0")
             return undefined;
+        const allowWithheld = scoped.PLURNK_PROVIDERS_GBNF_DEBUG !== undefined
+            && scoped.PLURNK_PROVIDERS_GBNF_DEBUG !== ""
+            && scoped.PLURNK_PROVIDERS_GBNF_DEBUG !== "0";
         const hit = this.#gbnfCache.get(variant);
         if (hit !== undefined)
-            return hit;
-        const path = variant.startsWith("/") || variant.startsWith(".")
-            ? variant
-            : fileURLToPath(import.meta.resolve(`@plurnk/plurnk-contracts/${variant}`));
+            return { ...hit, allowWithheld };
+        // {§grammar-rail-registration} — a bare name is a built-in rail subpath
+        // under @plurnk/plurnk-contracts; any other form is an import specifier
+        // (an operator file path or a package export subpath), so a third-party
+        // rail package plugs in with no built-in registry change.
+        const path = resolveGrammarRailPath(variant);
         const text = await readFile(path, "utf8"); // unresolvable/unreadable throws — a configured rail never silently degrades
         const constraint = grammarConstraint(text);
         this.#gbnfCache.set(variant, constraint);
         process.stderr.write(`plurnk-engine: GBNF constraint: ${alias || "(bare)"} → ${variant} (${text.length} chars)\n`);
-        return constraint;
+        return { ...constraint, allowWithheld };
     }
     // A lineage's no-parent root; a root worker resolves to itself. Fail hard
     // when corruption leaves a worker without one. {§worker-primary}
@@ -280,7 +306,7 @@ class TurnRunner {
         }
         const settlements = await Promise.allSettled(prepared.map(async ({ statement, modelCall, attributions, providerWorkerId }) => {
             try {
-                const response = await observed("provider.generate", { model: provider.model, attempt: 1, kind: "bare" }, async (span) => {
+                const response = await observed(GEN_AI_REQUEST_SPAN, { model: provider.model, attempt: 1, kind: "bare" }, async (span) => {
                     try {
                         const generated = await provider.generate({
                             messages: [{ role: "user", content: statement.body }],
@@ -301,6 +327,7 @@ class TurnRunner {
                             status: "resolved",
                         });
                         span.setAttribute("status", "resolved");
+                        settleGenAiResponse(span, generated);
                         return generated;
                     }
                     catch (error) {
@@ -309,7 +336,7 @@ class TurnRunner {
                         }
                         throw error;
                     }
-                });
+                }, genAiRequestOptions(ProviderInstantiate.aliasOf(provider) ?? "plurnk", provider.model));
                 await modelCall.observeResponse(response);
                 return {
                     statement,
@@ -359,776 +386,44 @@ class TurnRunner {
         }
         return { line, column };
     }
-    async runTurn({ provider, childProvider = provider, messages, requirements = "", workspaceId, workerId, loopId, origin = "model", signal, onDispatch, turnNumber = 1, maxTurns = 50, invalidEmissionRecoveryEntryId, }) {
-        const allowInvalidEmissionRecovery = invalidEmissionRecoveryEntryId === null;
-        const transientOpenLogEntryId = typeof invalidEmissionRecoveryEntryId === "number"
-            ? invalidEmissionRecoveryEntryId
-            : null;
-        // === Turn-as-container model ===
-        //
-        // Turn rows are created at runTurn OPEN (status=102, placeholder
-        // packet) so things can be written into the turn before the model
-        // is called: the user prompt on turn 1; later, system signals or
-        // injected Notices on any turn. The turn is CLOSED at
-        // the end with the final packet + status + usage stats.
-        //
-        // sequence is "ordinal of stuff in this turn." Pre-model
-        // writes consume low indices; model ops continue from there.
-        const seqRow = await this.#db.engine_next_turn_sequence.get({ loop_id: loopId });
-        const seq = seqRow.next;
-        // loops.sequence is the loop's ordinal within the worker. Turn-0 foists that belong to the
-        // WORKER (manifest preview, AGENTS, operator docs) gate on the worker's first loop, not every loop's
-        // first turn ({§actor-boundary-catalog-preview}); per-loop foists such as
-        // {§prompt-entry} still fire each loop. Read once, turn-1 only.
-        const loopRow = seq === 1
-            ? await this.#db.engine_get_loop_prompt.get({ loop_id: loopId })
-            : undefined;
-        const workerFirstLoop = (loopRow?.sequence ?? 0) === 1;
-        const openRow = await this.#db.engine_open_turn.get({
-            loop_id: loopId, sequence: seq,
-        });
-        if (openRow === undefined)
-            throw new Error("Engine.runTurn: turn open returned no row");
-        const turnId = openRow.id;
-        // {§env-delta-log-pull} — establish a fresh worker's observation
-        // baseline immediately after its first turn opens. A fork already has
-        // its parent's cursor, so the NULL-guarded statement leaves it intact.
-        // Events committed after this statement belong to this or a later
-        // closed pull window; pre-existing state is read through the ordinary
-        // shared-world projections in this first packet.
-        await this.#db.engine_initialize_ambient_cursor.get({ workspace_id: workspaceId, worker_id: workerId });
-        // Threaded per turn, never engine state, so concurrent loops on
-        // different providers each read their own honest tokenizer values.
-        const systemCtx = {
-            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),
-            pushNotice: (notice) => this.#notices.push(workspaceId, loopId, notice),
-        };
-        // Pre-model writes. Each prompt the model has not seen yet becomes an
-        // actionless `prompt` log row whose target is its durable prompt:// entry:
-        //   - Turn 1: loop.prompt is the initial user prompt.
-        //   - Turn N>1: only if Engine.inject (or wake-on-completion via
-        //     daemon.inject) wrote a prompt entry for this turn slot
-        //     between turn N-1 and N. Inject writes directly to entries;
-        //     we DON'T re-foist here for N>1.
-        // Model ops dispatch after these pre-model rows.
-        let nextActionIndex = 1;
-        const turnOpenPaths = [];
-        // {§worker-initialization-entry} — the worker's first turn opens with a kernel-authored initialization: a
-        // worked turn PLAN → the environment FINDs the foist ACTUALLY dispatches → SEND signal 102. Built
-        // from the real ops below (not a static print — we lean into the genuine echo paradigm) and
-        // written at sequence 1, so it reads first with the foisted results following.
-        const turnZeroMoves = [];
-        if (seq === 1) {
-            if (workerFirstLoop)
-                nextActionIndex = 2; // reserve sequence 1 for initialization
-            // Operator doc READs (PLURNK_SERVICE_MD_<ALIAS>, {§actor-boundary-doc-injection}). The docs were materialized
-            // as worker://plurnk/<entry> entries by the plurnk worker (LoopDocs, via the
-            // {§actor-boundary} keystone); foist a READ of each into THIS turn-0 so the model
-            // reads them inline. It sees only the READ — the materializing EDIT
-            // lives in the plurnk worker's log, never the model's.
-            // {§operator-config-workspace-md-docs} — env docs union the workspace's client docs; foist a READ of
-            // each materialized worker://plurnk/<alias>.md (LoopDocs materialized the same set).
-            const { mdDocs } = await WorkspaceSettings.read(this.#db, workspaceId);
-            // {§actor-boundary-doc-injection} — operator docs appear on the worker's first loop.
-            for (const doc of workerFirstLoop ? await WorkspaceSettings.resolveDocs(mdDocs) : []) {
-                const docTarget = {
-                    kind: "url", raw: `worker://plurnk/${doc.entryName}`, scheme: "worker",
-                    username: null, password: null, hostname: "plurnk", port: null,
-                    pathname: `/${doc.entryName}`, query: null, fragment: null,
-                };
-                const docRead = {
-                    op: "READ", suffix: "", signal: null, target: docTarget,
-                    lineMarker: null, body: null, position: UNKNOWN_POSITION,
-                };
-                await this.#dispatch({
-                    statement: docRead, workspaceId, workerId, loopId, turnId,
-                    sequence: nextActionIndex, origin: "plurnk", onDispatch,
-                });
-                nextActionIndex++;
-            }
-            const promptRow = loopRow; // {§prompt-entry} — per-loop; fires every loop's turn 1
-            if (promptRow !== undefined && typeof promptRow.prompt === "string" && promptRow.prompt.length > 0) {
-                const openPaths = assertOpenPaths(JSON.parse(promptRow.open_paths), `Loop ${loopId} open_paths`);
-                const promptLoopSeq = promptRow.sequence; // the loop's per-worker sequence — model-facing, matching log coordinates (owner: the db id read as prompt/2/1)
-                const promptPath = promptTarget(promptLoopSeq, seq);
-                const entry = {
-                    channels: { body: { content: promptRow.prompt, mimetype: "text/markdown" } },
-                    attributes: { openPaths },
-                };
-                await EntryCrud.writeEntry(promptPath.pathname, entry, systemCtx, "prompt", workerId);
-                turnOpenPaths.push(...openPaths);
-                const promptLogId = await this.#writePromptLog({
-                    workerId,
-                    loopId,
-                    turnId,
-                    sequence: nextActionIndex,
-                    target: promptPath,
-                    content: promptRow.prompt,
-                });
-                onDispatch?.(promptLogId);
-                nextActionIndex++;
-            }
-        }
-        // {§prompt-loop-containment}: the loop contains every prompt that arrived
-        // while it ran. Publish each undelivered frame as a prompt row, oldest
-        // first, so rapid arrivals reach the model together exactly once.
-        {
-            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({
-                owner_id: workerId,
-                pattern: `${prefix}%`,
-                prefix_len: prefix.length,
-                loop_id: loopId,
-            }))
-                .filter((r) => typeof r.content === "string" && r.content.length > 0);
-            for (const injectedRow of undelivered) {
-                const attributes = parsePromptAttributes(injectedRow.attributes, `Prompt ${injectedRow.pathname} attributes`);
-                const encodedOpenPaths = attributes.openPaths;
-                if (encodedOpenPaths !== undefined) {
-                    turnOpenPaths.push(...assertOpenPaths(encodedOpenPaths, `Prompt ${injectedRow.pathname} openPaths`));
-                }
-                const ordinal = Number(injectedRow.pathname.split("/").filter(Boolean).at(-1));
-                const injTarget = promptTarget(loopSeq, ordinal);
-                const promptLogId = await this.#writePromptLog({
-                    workerId,
-                    loopId,
-                    turnId,
-                    sequence: nextActionIndex,
-                    target: injTarget,
-                    content: injectedRow.content,
-                });
-                onDispatch?.(promptLogId);
-                nextActionIndex++;
-            }
-        }
-        // The persistent search-index pass (_search-index.maintain) attaches
-        // every readable entry/log projection to complete graph/FTS/vector 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.
-        // {§semantic-embed-dedup} — one pass-wide semantic plan binds every
-        // chunk counter to the derivation identity it produces.
-        // 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.
-        // Workspace creation starts this eagerly. Joining here is the correctness
-        // boundary: 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.#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}):
-        // Four FIND surveys foisted into the worker's first model turn establish the project,
-        // commons, private, and documentation surfaces in that order. Their `init`
-        // classification lets the model curate this opening survey as one log set.
-        if (seq === 1) {
-            // {§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 && workerFirstLoop) { // {§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;
-                await Owner.kernelId(this.#db, workspaceId);
-                const surveys = [
-                    {
-                        statement: {
-                            op: "FIND", suffix: "", signal: ["+init"],
-                            target: { kind: "local", raw: "*" },
-                            body: null,
-                            lineMarker: fileCap === null ? null : { marks: [1, fileCap] },
-                            position: UNKNOWN_POSITION,
-                        },
-                        exemplar: `## FIND0 [+init] (*)${fileCap === null ? "" : ` <1,${fileCap}>`}`,
-                    },
-                    {
-                        statement: {
-                            op: "FIND", suffix: "", signal: ["+init"],
-                            target: { kind: "url", raw: "worker:///*", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: "/*", query: null, fragment: null },
-                            body: null, lineMarker: null, position: UNKNOWN_POSITION,
-                        },
-                        exemplar: "## FIND0 [+init] (worker:///*)",
-                    },
-                    {
-                        statement: {
-                            op: "FIND", suffix: "", signal: ["+init"],
-                            target: { kind: "url", raw: "worker://~/*", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: "/*", query: null, fragment: null },
-                            body: null, lineMarker: null, position: UNKNOWN_POSITION,
-                        },
-                        exemplar: "## FIND0 [+init] (worker://~/*)",
-                    },
-                    {
-                        statement: {
-                            op: "FIND", suffix: "", signal: ["+init", "+docs"],
-                            target: { kind: "url", raw: "worker://plurnk/docs/**", scheme: "worker", username: null, password: null, hostname: "plurnk", port: null, pathname: "/docs/**", query: null, fragment: null },
-                            body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
-                        },
-                        exemplar: "## FIND0 [+init,+docs] (worker://plurnk/docs/**) <1,-1>",
-                    },
-                ];
-                for (const { statement, exemplar } of surveys) {
-                    await this.#dispatch({ statement, workspaceId, workerId, loopId, turnId, sequence: nextActionIndex, origin: "plurnk", onDispatch });
-                    nextActionIndex++;
-                    turnZeroMoves.push(exemplar);
-                }
-            }
-            // {§worker-initialization-entry} — write the kernel's turn-0 initialization OPEN at sequence 1: PLAN → the FINDs actually
-            // foisted above (real, their results already in the log) → SEND signal 102. Dynamic — it reflects
-            // the true survey, never a frozen print — and OPEN: the worked example the model orients on,
-            // so the grammar can stay thin.
-            if (workerFirstLoop) {
-                const initialization = [
-                    "# PLAN0\n* Initialization complete.\n* Next: address the prompt.",
-                    ...turnZeroMoves,
-                    "## SEND0 [102]\nNext, address the prompt.",
-                ].join("\n\n");
-                await this.#dispatcher.writeInitializationEntry({ verbatim: initialization, workerId, loopId, turnId, sequence: 1 });
-            }
-        }
-        // {§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", suffix: "", signal: null, lineMarker: null,
-                target: {
-                    kind: "url", raw: `file://${pathname}`, scheme: "file",
-                    username: null, password: null, hostname: null, port: null,
-                    pathname, query: null, fragment: null,
-                },
-                body: null, position: UNKNOWN_POSITION,
-            };
-            await this.#dispatch({
-                statement: fileRead, workspaceId, workerId, loopId, turnId,
-                sequence: nextActionIndex, origin: "plurnk", onDispatch,
-            });
-            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-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 born-OPEN via the stream-delta path.
-        await this.#reapTurnScopedStreams(workerId);
-        nextActionIndex += await this.#materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
-        nextActionIndex += await this.#materializeStreamDeltas({ workerId, loopId, turnId, fromSequence: nextActionIndex });
-        // 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 grinder 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 buildPacket = () => this.#packets.buildRequestPacket({
-            initialMessages: messages,
-            requirements,
-            workspaceId,
-            workerId,
-            loopId,
-            currentTurnSeq: seq,
-            provider,
-            gitStatus,
-            notices,
-            transientOpenLogEntryId,
-            promptProjection,
-        });
-        let requestPacket = await buildPacket();
-        // SPEC {§grinder} — budget grinder, pre-LLM: reclaim window on actual overflow.
-        const enforced = await this.#packets.enforceBudget({
-            packet: requestPacket, provider, loopId, turnId,
-            recordOverflow: async (pressure) => {
-                await this.#problems.record({
-                    workerId,
-                    loopId,
-                    turnId,
-                    sequence: nextActionIndex++,
-                    origin: "plurnk",
-                    source: "engine",
-                    result: curationOverflowFailure(pressure),
-                });
-            },
-            rebuild: buildPacket,
-        });
-        requestPacket = enforced.packet;
-        let boundaryRolledBack = enforced.boundaryRolledBack;
-        let modelMessages = PacketWire.packetToWireMessages(requestPacket);
-        // Curation pressure and provider generation are independent. The
-        // provider owns its configured total output envelope.
-        let response;
-        let splitResponse;
-        let railGrammar;
-        let railResponseGrammar;
-        let railEvidence;
-        let emissionAttempts = 0;
-        let providerCallInFlight = false;
-        let modelCallSequence = 0;
-        let currentEmissionAttempt = 0;
-        let providerAttemptId = null;
-        let providerModelCall = null;
-        let providerAttemptAttributions = [];
-        const providerSignal = this.#loopSignal(loopId) ?? signal;
-        // {§client-metadata}
-        const { client } = await WorkspaceSettings.read(this.#db, workspaceId);
-        const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
-        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 candidateMessages = PacketWire.packetToWireMessages(candidate);
-                if (JSON.stringify(candidateMessages) !== JSON.stringify(baselineMessages)) {
-                    requestPacket = candidate;
-                    modelMessages = candidateMessages;
-                    return true;
-                }
-                baselineMessages = candidateMessages;
-            }
-            if (!boundaryRolledBack) {
-                await this.#packets.rollbackNewestBoundary(loopId, turnId);
-                boundaryRolledBack = true;
-                const candidate = await buildPacket();
-                const candidateMessages = PacketWire.packetToWireMessages(candidate);
-                if (JSON.stringify(candidateMessages) !== JSON.stringify(baselineMessages)) {
-                    requestPacket = candidate;
-                    modelMessages = candidateMessages;
-                    return true;
-                }
-            }
-            return false;
-        };
-        try {
-            // {§turn-lifecycle}: bracket the complete provider-attempt window with liveness notices.
-            if (!signal?.aborted)
-                this.#notices.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_awaiting_model", level: "info", message: "awaiting model response" });
-            const railConstraint = await this.#grammarConstraint(provider);
-            railGrammar = railConstraint?.transport;
-            railResponseGrammar = railConstraint?.response;
-            const attemptLimit = readEmissionAttempts();
-            const strikeStreak = this.#strikes.streak(loopId);
-            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, {
-                    turnId,
-                    sequence: modelCallSequence,
-                    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 completedResponse;
-                try {
-                    completedResponse = await observed(// {§observability-boundary}
-                    "provider.generate", { model: provider.model, attempt: modelCallSequence }, async (span) => {
-                        try {
-                            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: currentModelCall.observeRequest,
-                                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");
-                            return generated;
-                        }
-                        catch (error) {
-                            if (error instanceof ProviderError) {
-                                currentModelCall.assertAccounting(error.accounting);
-                            }
-                            throw error;
-                        }
-                    });
-                }
-                catch (error) {
-                    if (!(error instanceof ProviderError)
-                        || error.kind !== "capacity_exceeded"
-                        || providerSignal?.aborted === true
-                        || !await recoverCapacityPacket()) {
-                        throw error;
-                    }
-                    const failure = _a.#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();
-                    modelMessages = PacketWire.packetToWireMessages(requestPacket);
-                    continue;
-                }
-                response = completedResponse;
-                await currentModelCall.observeResponse(completedResponse);
-                railEvidence = railGrammar === undefined
-                    ? undefined
-                    : _a.#requireGrammarEvidence(completedResponse);
-                splitResponse = this.#splitResponse(completedResponse);
-                await classifyProviderAttempt(attemptRow.id, splitResponse, attempt, splitResponse.emissionValid);
-                if (splitResponse.emissionValid)
-                    break;
-                attempt++;
-            }
-            if (!signal?.aborted)
-                this.#notices.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_generated", level: "info", message: "parsing model response" });
-        }
-        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 = _a.#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);
-                splitResponse = this.#splitResponse(response);
-                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 evidence
-            // and its engine-owned verdict exist only on completed responses
-            // ({§rail-truth-engine-verdict}). 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) {
-                await this.#db.engine_close_turn.run({
-                    id: turnId,
-                    status: providerSignal.reason === LOOP_TIMEOUT_REASON ? 504 : 499,
-                    packet: StoredPacket.stringify(requestPacket),
-                    usage_curation_budget: this.#packets.curationBudgetFor(provider),
-                    finish_reason: splitResponse?.callMetadata.finishReason ?? null,
-                    model: splitResponse?.callMetadata.model ?? provider.model,
-                    meta: JSON.stringify(response?.meta ?? {}),
-                });
-                throw err;
-            }
-            const recorded = await this.#problems.record({
-                workerId,
-                loopId,
-                turnId,
-                sequence: 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.#db.engine_close_turn.run({
-                id: turnId,
-                status: recorded.result.status,
-                packet: StoredPacket.stringify(requestPacket),
-                usage_curation_budget: this.#packets.curationBudgetFor(provider),
-                finish_reason: splitResponse?.callMetadata.finishReason ?? null,
-                model: splitResponse?.callMetadata.model ?? provider.model,
-                meta: JSON.stringify(response?.meta ?? {}),
-            });
-            if (capacityFailure) {
-                return {
-                    turnId,
-                    status: recorded.result.status,
-                    outcomes: [],
-                    fingerprint: "",
-                    capacityHardStop: true,
-                    capacityFailure: recorded.result,
-                    steerStruck: 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.emissionValid) {
-            // {§invalid-emission-attempts} The first consecutive exhaustion
-            // publishes only the raw final response and generic recovery fact.
-            let rejectedModelEntryId;
-            if (allowInvalidEmissionRecovery) {
-                rejectedModelEntryId = await this.#dispatcher.writeModelEntry({
-                    verbatim: splitResponse.packetAssistant.content,
-                    workerId,
-                    loopId,
-                    turnId,
-                    sequence: nextActionIndex,
-                    folded: true,
-                    modelCallId: emissionModelCallId,
-                    admission: "rejected",
-                });
-                this.#notices.push(workspaceId, loopId, {
-                    source: "engine:grammar",
-                    kind: "invalid_emission",
-                    level: "error",
-                    message: INVALID_EMISSION_RECOVERY_MESSAGE,
-                });
-            }
-            await this.#db.engine_close_turn.run({
-                id: turnId,
-                status: allowInvalidEmissionRecovery ? TURN_STATUS_IMPLICIT_CONTINUE : 500,
-                packet: StoredPacket.stringify(requestPacket),
-                usage_curation_budget: this.#packets.curationBudgetFor(provider),
-                finish_reason: splitResponse.callMetadata.finishReason,
-                model: splitResponse.callMetadata.model,
-                meta: JSON.stringify(response.meta ?? {}),
-            });
-            return {
-                turnId,
-                status: allowInvalidEmissionRecovery ? TURN_STATUS_IMPLICIT_CONTINUE : 500,
-                outcomes: [],
-                fingerprint: "",
-                capacityHardStop: false,
-                steerStruck: false,
-                emissionAttempts,
-                emissionExhausted: true,
-                ...(rejectedModelEntryId === undefined ? {} : { rejectedModelEntryId }),
-            };
-        }
-        // {§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, loopId, notice);
-        }
-        // 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 the folded model-emission row at the
-        // cited lines ({§model-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, 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 } }
-                    : {}),
-            });
-        }
-        // Grade configured local evidence independently. Endpoint-owned
-        // constraints remain provider observations. {§rail-truth-engine-verdict}
-        let railKeys;
-        if (railGrammar !== undefined) {
-            if (railEvidence === undefined)
-                throw new Error("configured GBNF response has no final grammar evidence");
-            if (railResponseGrammar === undefined)
-                throw new Error("configured GBNF has no response grammar");
-            let verdict = null;
-            try {
-                verdict = validateGbnf(railResponseGrammar, railEvidence.input);
-            }
-            catch (cause) {
-                _a.#warnRailVerdictGapOnce(cause.message);
-            }
-            railKeys = {
-                railsAttached: railEvidence.transported ? "client" : "withheld",
-                railsVerdict: verdict?.status ?? "unverifiable",
-            };
-            if (verdict !== null && verdict.status !== "accept") {
-                const contentPosition = verdict.pos >= railEvidence.contentStart
-                    ? verdict.pos - railEvidence.contentStart
-                    : null;
-                const located = contentPosition === null
-                    ? null
-                    : this.#offsetToLineColumn(packetAssistant.content, contentPosition);
-                this.#notices.push(workspaceId, loopId, {
-                    source: "engine:rails",
-                    kind: "grammar_unenforced",
-                    message: verdict.status === "reject"
-                        ? `emission rejects the grammar at raw code point ${verdict.pos}`
-                        : `emission is an incomplete grammar sentence (ends at raw code point ${verdict.pos})`,
-                    level: "warn",
-                    ...(located === null
-                        ? {}
-                        : { position: { type: "content-offset", line: located.line, column: located.column } }),
-                });
-            }
-        }
-        const opsCount = packetAssistant.ops.length;
-        const finalOp = packetAssistant.ops.at(-1);
+    // {§turn-ops-admission-path} — source acquisition ends before this seam.
+    // Every admitted producer program is scheduled, dispatched, recorded, and
+    // completed here; inference is only the model-specific way one program is
+    // acquired and supplied with BARE capability.
+    async #executeAdmittedTurn({ statements, source, sourceFolded, sourceModelCallId = null, sourceReasoningItems, origin, workspaceId, workerId, loopId, turnId, fromSequence, maxCommands = Number.POSITIVE_INFINITY, enforceIdle = false, failOnOperationError = false, recoverableParseErrors = [], bare, signal, onDispatch, }) {
+        const plan = statements[0];
+        const finalOp = statements.at(-1);
         if (finalOp?.op !== "SEND") {
-            // Text emissions cannot reach this point without a disposition;
-            // this fail-hard guard also keeps Mock's trusted pre-parsed seam
-            // from creating runtime states that production admission forbids.
-            throw new Error("an admitted emission must end in a disposition SEND");
+            throw new Error("an admitted operation batch must end in a disposition SEND");
+        }
+        if (source !== null && plan?.op !== "PLAN") {
+            throw new Error("an admitted source-backed turnOps program must begin with PLAN");
         }
         const dispositionSignal = finalOp.signal;
         if (typeof dispositionSignal !== "number" || !TERMINAL_SEND_SIGNALS.has(dispositionSignal)) {
-            throw new Error("an admitted emission must end in a disposition SEND");
+            throw new Error("an admitted turnOps program must end in a terminal disposition SEND");
         }
         const sendOp = finalOp;
-        // {§send} the terminal contract — engine error states verify a terminal claim against loop
-        // state, never trusting the model's code. They strike via turn.steerStruck
-        // ({§engine-rails}): the loop continues, the model sees the steering hint not the strike
-        // count, and a non-resolver spins out to the engine's 500.
+        let turnStatus = dispositionSignal;
         let steerStruck = false;
-        // Engine errors raised this turn, minted as op='error' log rows after dispatch (they share the
-        // post-dispatch sequence counter). {§operation-result-uniform-error-channel}
         const pendingEngineErrors = [];
-        // Terminal adjudication moved to the DISPATCHER ({§send-premature-terminate}, the unified
-        // pending set): the terminal SEND is judged AT ITS OWN DISPATCH — after the emission's
-        // earlier ops executed — so a same-turn KILL+[200] repairs in one turn and a same-turn
-        // WORK+[200] is caught. A refused final disposition (409) strikes via
-        // the dispatch-loop check below.
-        let turnStatus = dispositionSignal;
-        // Idle turn: an implicit-continue (102) that did no WORK — its ops are only PLAN/SEND, no mid op.
-        // The model continued with nothing to do.
-        const midOpsCount = packetAssistant.ops.filter((op) => op.op !== "PLAN" && op.op !== "SEND").length
+        const middleCount = statements.filter((statement) => statement.op !== "PLAN" && statement.op !== "SEND").length
             + recoverableParseErrors.length;
-        if (!steerStruck && turnStatus === TURN_STATUS_IMPLICIT_CONTINUE && midOpsCount === 0) {
+        if (enforceIdle && turnStatus === TURN_STATUS_IMPLICIT_CONTINUE && middleCount === 0) {
             steerStruck = true;
             pendingEngineErrors.push("idle_turn");
         }
-        // Close the turn with the final packet, status, and usage stats.
-        const packet = StoredPacket.admit(requestPacket, packetAssistant, response.assistantRaw);
-        await this.#db.engine_close_turn.run({
-            id: turnId,
-            status: turnStatus,
-            packet: StoredPacket.stringify(packet),
-            usage_curation_budget: this.#packets.curationBudgetFor(provider), // {§tokenomics-client-gauge}
-            finish_reason: callMetadata.finishReason,
-            model: callMetadata.model,
-            // Opaque provider metadata plus engine-authored rail keys.
-            // {§meta-passthrough}, {§rail-truth-engine-verdict}
-            meta: JSON.stringify({ ...(response.meta ?? {}), ...(railKeys ?? {}) }),
-        });
-        // Dispatch model ops starting at nextActionIndex (continues the
-        // turn's running counter after any pre-model writes).
-        //
-        // Max-commands ceiling: OFF by default (unlimited) — every generated op dispatches.
-        // A degenerate op-loop is a sampler failure guarded at generation, not by dropping
-        // already-generated work post-hoc. The ceiling is an OPT-IN operator/client bound:
-        // when set, overflow ops drop without per-op log entries (no forensics flood) and the
-        // model gets one notices signal next packet.
-        // {§operator-config-workspace-max-commands} — workspace maxCommands min()s the env ceiling.
-        const maxCommands = Math.min(readMaxCommands(), (await WorkspaceSettings.read(this.#db, workspaceId)).maxCommands ?? Number.POSITIVE_INFINITY);
-        // PLAN (intended goals) and the final disposition SEND are not actions —
-        // they always dispatch and never count against the cap. maxCommands
-        // bounds real actions only; maxCommands:0 still admits a plan and a disposition
-        // (the PLAN/SEND ops, zero actions), which is its only coherent meaning.
         let realCommands = 0;
-        const admittedOps = packetAssistant.ops.filter((op) => {
-            return op.op === "PLAN"
-                || op === sendOp
-                || realCommands++ < maxCommands;
-        });
-        const opsToDispatch = scheduleTurnOps(admittedOps);
-        await this.#dispatcher.prepareEditBatches(opsToDispatch.filter((statement) => statement.op === "EDIT"), {
-            workspaceId, workerId, loopId, turnId,
-            origin, onDispatch,
-        });
-        const droppedCount = opsCount - opsToDispatch.length;
-        const bareStatements = opsToDispatch.filter((statement) => statement.op === "BARE");
+        const admitted = statements.filter((statement) => statement.op === "PLAN"
+            || statement === sendOp
+            || realCommands++ < maxCommands);
+        const scheduled = scheduleTurnOps(admitted.flatMap(expandSafeUriTargetGroup));
+        await this.#dispatcher.prepareEditBatches(scheduled.filter((statement) => statement.op === "EDIT"), { workspaceId, workerId, loopId, turnId, origin, onDispatch });
+        const droppedCount = statements.length - admitted.length;
+        const bareStatements = scheduled.filter((statement) => statement.op === "BARE");
         let bareResults = null;
         const outcomes = [];
-        // Running counter — a multi-file READ writes N rows from one statement (rowsWritten),
-        // so the next op's sequence picks up after them. Collapses to nextActionIndex+i when
-        // every op writes one row (the common case).
-        let rowSeq = nextActionIndex;
+        let rowSequence = fromSequence;
         let parseErrorsRecorded = false;
         const recordRecoverableParseErrors = async () => {
             if (parseErrorsRecorded)
@@ -1139,8 +434,8 @@ class TurnRunner {
                     workerId,
                     loopId,
                     turnId,
-                    sequence: rowSeq++,
-                    origin: "model",
+                    sequence: rowSequence++,
+                    origin,
                     source: "grammar",
                     result: Results.failure("grammar:parser", "invalid-operation-syntax", 400, error.message, {}, {
                         line: error.line,
@@ -1155,39 +450,35 @@ class TurnRunner {
                 onDispatch?.(recorded.id);
             }
         };
-        for (const statement of opsToDispatch) {
-            if (statement.op === "SEND"
-                && typeof statement.signal === "number"
-                && TERMINAL_SEND_SIGNALS.has(statement.signal)) {
+        for (const statement of scheduled) {
+            if (statement === sendOp) {
                 await recordRecoverableParseErrors();
-                // {§worker-optimistic-settlement} — SEND judges the refreshed
-                // lifecycle after this turn's own fast streams receive one
-                // bounded opportunity to conclude. This is not a sleep and
-                // does not delay a later turn for older monitored streams.
                 const execHandler = this.#schemes.get("exec");
-                await execHandler?.settleTurnSpawns?.(workerId, turnId, readOptimisticSettlementMs(), providerSignal);
+                await execHandler?.settleTurnSpawns?.(workerId, turnId, readOptimisticSettlementMs(), signal);
             }
-            const result = await observed(// {§observability-boundary}
-            "op.dispatch", { op: statement.op }, async (span) => {
+            const result = await observed("op.dispatch", { op: statement.op }, async (span) => {
                 let dispatchResult;
                 if (statement.op === "BARE") {
+                    if (bare === undefined) {
+                        throw new Error(`${origin} turnOps cannot execute BARE without provider acquisition context`);
+                    }
                     if (bareResults === null) {
                         const batch = await this.#runBareBatch({
                             statements: bareStatements,
-                            provider: childProvider,
+                            provider: bare.provider,
                             turnId,
-                            modelCallSequenceStart: modelCallSequence + 1,
+                            modelCallSequenceStart: bare.modelCallSequenceStart,
                             workspaceId,
                             workerId,
-                            primaryWorkerId,
-                            loopSequence: loopSeq,
-                            turnSequence: seq,
-                            signal: providerSignal,
+                            primaryWorkerId: bare.primaryWorkerId,
+                            loopSequence: bare.loopSequence,
+                            turnSequence: bare.turnSequence,
+                            signal: bare.signal,
                         });
                         bareResults = new Map(batch.map((item) => [item.statement, item]));
                     }
-                    const bare = bareResults.get(statement);
-                    if (bare === undefined) {
+                    const bareResult = bareResults.get(statement);
+                    if (bareResult === undefined) {
                         throw new Error("BARE statement reached dispatch without its batch result");
                     }
                     dispatchResult = await this.#dispatcher.recordBareResult({
@@ -1196,16 +487,21 @@ class TurnRunner {
                         workerId,
                         loopId,
                         turnId,
-                        sequence: rowSeq,
+                        sequence: rowSequence,
                         origin,
                         onDispatch,
-                    }, bare.result, bare.modelCallId);
+                    }, bareResult.result, bareResult.modelCallId);
                 }
                 else {
                     dispatchResult = await this.#dispatcher.dispatch({
-                        statement, workspaceId, workerId, loopId, turnId,
-                        sequence: rowSeq,
-                        origin, onDispatch,
+                        statement,
+                        workspaceId,
+                        workerId,
+                        loopId,
+                        turnId,
+                        sequence: rowSequence,
+                        origin,
+                        onDispatch,
                     });
                 }
                 span.setAttribute("status", dispatchResult.status);
@@ -1213,6 +509,8 @@ class TurnRunner {
                 return dispatchResult;
             });
             outcomes.push({ op: statement.op, status: result.status });
+            if (failOnOperationError && result.status >= 400)
+                throw new OperationFailureError(result);
             for (const normalization of result.scopeNormalizations ?? []) {
                 this.#notices.push(workspaceId, loopId, {
                     source: "engine:slicer",
@@ -1221,39 +519,20 @@ class TurnRunner {
                     message: `Scope <${normalization.requested.join(",")}> was normalized to <${normalization.canonical.join(",")}>.`,
                 });
             }
-            // {§engine-rails} — a refused final disposition leaves both loop
-            // and turn continuing, and its 409 steering ruling strikes once.
             if (statement === sendOp && result.status === 409) {
                 steerStruck = true;
                 turnStatus = TURN_STATUS_IMPLICIT_CONTINUE;
-                await this.#db.engine_reconcile_turn_status.run({ id: turnId, status: turnStatus });
             }
-            // {§send-300-choices}: a question resolves through the proposal system; whatever the
-            // resolution (answer/reject/timeout), the LOOP continues to the turn where the model
-            // reads it; the turn record is a continue, never a 300 terminal.
-            if (statement === sendOp && sendOp.signal === 300 && result.status !== 409) {
-                turnStatus = TURN_STATUS_IMPLICIT_CONTINUE;
-                await this.#db.engine_reconcile_turn_status.run({ id: turnId, status: turnStatus });
-            }
-            // A broadcast [202] is a conditional wait, not an unconditional turn status:
-            // live work parks at 202; completed-but-unobserved work continues at 102; an
-            // empty join completes at 200. Persist and return the dispatcher's actual ruling.
             if (statement === sendOp
                 && result.status !== 409
                 && sendOp.target === null
                 && sendOp.signal === 202
                 && result.status !== 202) {
                 turnStatus = result.status;
-                await this.#db.engine_reconcile_turn_status.run({ id: turnId, status: turnStatus });
             }
-            rowSeq += result.rowsWritten ?? 1;
+            rowSequence += result.rowsWritten ?? 1;
         }
         await recordRecoverableParseErrors();
-        // Engine rail failures mint as op='error' log rows at the turn's next
-        // free sequence. Bounded syntax failures were recorded in their
-        // authored turn before its terminal disposition.
-        let errSeq = rowSeq;
-        // max_commands_exceeded IS model-facing: dropped ops the model emitted that didn't run.
         if (droppedCount > 0)
             pendingEngineErrors.push("max_commands_exceeded");
         for (const kind of pendingEngineErrors) {
@@ -1275,47 +554,887 @@ class TurnRunner {
                 workerId,
                 loopId,
                 turnId,
-                sequence: errSeq++,
-                origin: "plurnk",
+                sequence: rowSequence++,
+                origin: "_plurnk",
                 source: "rail",
                 result: Results.failure("engine:rail", problem.code, problem.status, problem.detail, {}, extensions),
             });
         }
-        // {§log-row-self-explains} — model-operation failures remain on their
-        // own rows; genuine engine faults fail hard and mint no substitute row.
-        // {§model-entry} — mirror this turn's verbatim emission back as a `model` row, so the NEXT
-        // packet shows the model exactly what it last produced. ALWAYS born FOLDED — the old
-        // born-OPEN-on-error auto-trigger was conditional helpfulness that bred its own hazards
-        // (a 24k-char ramble mirrored open re-injects itself into the next packet: cost,
-        // contamination, pressure feedback).
-        // {§encrypted-reasoning-carrier} — core relays every provider-normalized
-        // item unchanged.
-        const reasoningItems = response.assistant.reasoningEncrypted?.length
-            ? response.assistant.reasoningEncrypted
-            : undefined;
-        if (packetAssistant.content.trim().length > 0 || reasoningItems !== undefined) {
-            await this.#dispatcher.writeModelEntry({
-                verbatim: packetAssistant.content,
+        if (source !== null) {
+            await this.#dispatcher.writeTurnOps({
+                verbatim: source,
                 workerId,
                 loopId,
                 turnId,
-                sequence: errSeq++,
-                folded: true,
-                modelCallId: emissionModelCallId,
-                ...(reasoningItems !== undefined ? { reasoningItems } : {}),
+                sequence: rowSequence,
+                origin,
+                folded: sourceFolded,
+                modelCallId: sourceModelCallId,
+                ...(sourceReasoningItems !== undefined ? { reasoningItems: sourceReasoningItems } : {}),
             });
         }
+        await Turn.complete(this.#db, turnId, turnStatus);
         return {
-            turnId,
             status: turnStatus,
             outcomes,
-            fingerprint: StrikeRail.fingerprintTurn(packetAssistant.ops),
-            capacityHardStop: false,
+            fingerprint: StrikeRail.fingerprintTurn(statements),
             steerStruck,
-            emissionAttempts,
-            emissionExhausted: false,
         };
     }
+    async runTurn({ provider, childProvider = provider, messages, requirements = "", workspaceId, workerId, loopId, signal, onDispatch, turnNumber = 1, maxTurns = 50, invalidEmissionRecoveryEntryId, }) {
+        const allowInvalidEmissionRecovery = invalidEmissionRecoveryEntryId === null;
+        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");
+        // loops.sequence is the loop's ordinal within the worker. Turn-0 foists that belong to the
+        // WORKER (manifest preview, AGENTS, operator docs) gate on the worker's first loop, not every loop's
+        // first turn ({§actor-boundary-catalog-preview}); 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 });
+        const workerFirstLoop = (loopRow?.sequence ?? 0) === 1;
+        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 && workerFirstLoop
+                ? await Turn.open(this.#db, { loopId, producer: "_plurnk", kind: "initialization" })
+                : null;
+            if (initializationTurn !== null)
+                createdTurnIds.push(initializationTurn.id);
+            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} — establish a fresh worker's observation
+            // baseline immediately after its first turn opens. A fork already has
+            // its parent's cursor, so the NULL-guarded statement leaves it intact.
+            // Events committed after this statement belong to this or a later
+            // closed pull window; pre-existing state is read through the ordinary
+            // shared-world projections in this first packet.
+            await this.#db.engine_initialize_ambient_cursor.get({ workspace_id: workspaceId, worker_id: workerId });
+            // 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, loopId, notice),
+                requestInteraction: (request) => this.#interactions.request(request, { workspaceId, workerId, loopId, turnId: contextTurnId }, this.#loopSignal(loopId)),
+            });
+            let systemCtx = systemContext(initializationTurn?.id ?? modelTurn.id);
+            const initializationStatements = [];
+            // {§worker-initialization-entry} — the worker's first turn is the worked
+            // example itself: an ordinary PLAN, the actual orienting operations,
+            // and an ordinary terminal SEND.
+            if (initializationTurn !== null) {
+                const plan = {
+                    op: "PLAN", delimiter: "", annotation: null,
+                    signal: null, target: null, lineMarker: null,
+                    body: "* Discover the tooling available and survey the workspace file root.",
+                    position: UNKNOWN_POSITION,
+                };
+                initializationStatements.push(plan);
+                // {§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 (workerFirstLoop) {
+                    const kernelId = await Owner.kernelId(this.#db, workspaceId);
+                    const agentsEntry = await this.#db.crud_find_workspace_entry.get({
+                        workspace_id: workspaceId,
+                        owner_id: kernelId,
+                        scheme: "worker",
+                        pathname: "/agents.md",
+                    });
+                    if (agentsEntry !== undefined) {
+                        const agentsTarget = {
+                            kind: "url", raw: "worker://plurnk/agents.md", scheme: "worker",
+                            username: null, password: null, hostname: "plurnk", port: null,
+                            pathname: "/agents.md", query: null, fragment: null,
+                        };
+                        const agentsRead = {
+                            op: "READ", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+policy"], target: agentsTarget,
+                            lineMarker: 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/vector 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.
+            // {§semantic-embed-dedup} — one pass-wide semantic plan binds every
+            // chunk counter to the derivation identity it produces.
+            // 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.
+            // Workspace creation starts this eagerly. Joining here is the correctness
+            // boundary: 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.#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}):
+            // Six bodyless FIND surveys in the worker's packetless initialization turn establish the skills tree
+            // (authored and Plurnk-generated families), attached tools tree, project, commons, and private
+            // surfaces 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 && workerFirstLoop) { // {§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} — PLURNK_MCP_EXPANDED servers
+                    // contribute one complete tool-tree survey each, directly after the
+                    // family survey, so turn 0 names every tool they expose in order.
+                    const registry = this.#executors();
+                    const toolExpansions = [];
+                    for (const tag of registry?.availableRuntimes(workspaceId) ?? []) {
+                        const entry = registry?.entry(tag, workspaceId);
+                        if (entry?.resourcesPath !== "/tools" || entry.expandTools !== true)
+                            continue;
+                        toolExpansions.push({
+                            statement: {
+                                op: "FIND", delimiter: "", annotation: `enabled tools: ${tag}`, signal: ["+_plurnk", "+init", "+tools"],
+                                target: { kind: "url", raw: `worker://plurnk/tools/${tag}/**`, scheme: "worker", username: null, password: null, hostname: "plurnk", port: null, pathname: `/tools/${tag}/**`, query: null, fragment: null },
+                                body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+                            },
+                        });
+                    }
+                    const surveys = [
+                        {
+                            statement: {
+                                op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+skills"],
+                                target: { kind: "url", raw: "worker://plurnk/skills/*.md", scheme: "worker", username: null, password: null, hostname: "plurnk", port: null, pathname: "/skills/*.md", query: null, fragment: null },
+                                body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+                            },
+                        },
+                        {
+                            statement: {
+                                op: "FIND", delimiter: "", annotation: null, signal: ["+_plurnk", "+init", "+skills"],
+                                target: { kind: "url", raw: "worker://plurnk/skills/plurnk/*.md", scheme: "worker", username: null, password: null, hostname: "plurnk", port: null, pathname: "/skills/plurnk/*.md", query: null, fragment: 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.
+                            statement: {
+                                op: "FIND", delimiter: "", annotation: "enabled tools", signal: ["+_plurnk", "+init", "+tools"],
+                                target: { kind: "url", raw: "worker://plurnk/tools/*.md", scheme: "worker", username: null, password: null, hostname: "plurnk", port: null, pathname: "/tools/*.md", query: null, fragment: null },
+                                body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
+                            },
+                        },
+                        ...toolExpansions,
+                        {
+                            statement: {
+                                op: "FIND", delimiter: "", annotation: "workspace files", signal: ["+_plurnk", "+init"],
+                                target: { kind: "local", raw: "*" },
+                                body: null,
+                                lineMarker: fileCap === null ? null : { marks: [1, fileCap] },
+                                position: UNKNOWN_POSITION,
+                            },
+                        },
+                        {
+                            statement: {
+                                op: "FIND", delimiter: "", annotation: "workspace entries", signal: ["+_plurnk", "+init"],
+                                target: { kind: "url", raw: "worker:///*", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: "/*", query: null, fragment: null },
+                                body: null, lineMarker: null, position: UNKNOWN_POSITION,
+                            },
+                        },
+                        {
+                            statement: {
+                                op: "FIND", delimiter: "", annotation: "worker entries", signal: ["+_plurnk", "+init"],
+                                target: { kind: "url", raw: "worker://~/*", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: "/*", query: null, fragment: null },
+                                body: null, lineMarker: null, position: UNKNOWN_POSITION,
+                            },
+                        },
+                    ];
+                    initializationStatements.push(...surveys.map(({ statement }) => statement));
+                }
+                const send = {
+                    op: "SEND", delimiter: "", annotation: null,
+                    signal: 102, target: null, lineMarker: null,
+                    body: { raw: "Next: Address the prompt.", json: null },
+                    position: UNKNOWN_POSITION,
+                };
+                initializationStatements.push(send);
+                const source = TurnOps.renderInternal(initializationStatements);
+                const admitted = TurnOps.parseInternal(source);
+                const result = await this.#executeAdmittedTurn({
+                    statements: admitted,
+                    source,
+                    sourceFolded: false,
+                    origin: "_plurnk",
+                    workspaceId,
+                    workerId,
+                    loopId,
+                    turnId: initializationTurn.id,
+                    fromSequence: 1,
+                    failOnOperationError: true,
+                    signal: this.#loopSignal(loopId),
+                    onDispatch,
+                });
+                if (result.status !== TURN_STATUS_IMPLICIT_CONTINUE) {
+                    throw new Error(`initialization SEND 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 (turnNumber === 1 && loopRow?.prompt_published === 0) {
+                const promptRow = loopRow; // {§prompt-entry} — one durable publication per loop
+                if (promptRow !== undefined && typeof promptRow.prompt === "string" && promptRow.prompt.length > 0) {
+                    const openPaths = assertOpenPaths(JSON.parse(promptRow.open_paths), `Loop ${loopId} open_paths`);
+                    const promptLoopSeq = promptRow.sequence;
+                    const promptPath = promptTarget(promptLoopSeq, 1);
+                    const entry = {
+                        channels: { body: { content: promptRow.prompt, mimetype: "text/markdown" } },
+                        attributes: { openPaths },
+                    };
+                    await EntryCrud.writeEntry(promptPath.pathname, entry, systemCtx, "prompt", workerId);
+                    turnOpenPaths.push(...openPaths);
+                    const promptLogId = await this.#writePromptLog({
+                        workerId,
+                        loopId,
+                        turnId,
+                        sequence: nextActionIndex++,
+                        target: promptPath,
+                        content: promptRow.prompt,
+                    });
+                    onDispatch?.(promptLogId);
+                }
+            }
+            // {§prompt-loop-containment}: the loop contains every prompt that arrived
+            // while it ran. Publish each undelivered frame oldest-first exactly once.
+            {
+                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({
+                    owner_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 ordinal = Number(injectedRow.pathname.split("/").filter(Boolean).at(-1));
+                    const promptLogId = await this.#writePromptLog({
+                        workerId,
+                        loopId,
+                        turnId,
+                        sequence: nextActionIndex++,
+                        target: promptTarget(loopSeq, ordinal),
+                        content: injectedRow.content,
+                    });
+                    onDispatch?.(promptLogId);
+                }
+            }
+            // {§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", delimiter: "", annotation: null, signal: null, lineMarker: null,
+                    target: {
+                        kind: "url", raw: `file://${pathname}`, scheme: "file",
+                        username: null, password: null, hostname: null, port: null,
+                        pathname, query: null, fragment: null,
+                    },
+                    body: null, position: UNKNOWN_POSITION,
+                };
+                await this.#dispatch({
+                    statement: fileRead, workspaceId, workerId, loopId, turnId,
+                    sequence: nextActionIndex, origin: "_plurnk", onDispatch,
+                });
+                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-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 born-OPEN via the stream-delta path.
+            await this.#reapTurnScopedStreams(workerId);
+            nextActionIndex += await this.#materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
+            nextActionIndex += await this.#materializeStreamDeltas({ 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 buildPacket = () => this.#packets.buildRequestPacket({
+                initialMessages: messages,
+                requirements,
+                workspaceId,
+                workerId,
+                loopId,
+                currentTurnSeq: seq,
+                provider,
+                gitStatus,
+                notices,
+                transientOpenLogEntryId,
+                promptProjection,
+            });
+            let requestPacket = await buildPacket();
+            // {§overflow-turn} — measured overflow diverts this would-be model
+            // turn into an ordinary packetless `_plurnk` operation batch. Every
+            // visibility effect goes through Dispatcher FOLD; provider I/O is
+            // structurally unreachable on this branch.
+            const pressure = this.#packets.curationOverflow(requestPacket, provider);
+            if (pressure !== null) {
+                const folds = await OverflowTurn.plan(this.#db, loopId, turnId);
+                await Turn.becomeOverflow(this.#db, turnId);
+                const internalStatements = [
+                    OverflowTurn.planStatement(),
+                    ...folds.map(({ statement }) => statement),
+                    OverflowTurn.sendStatement(),
+                ];
+                const source = TurnOps.renderInternal(internalStatements);
+                const admitted = TurnOps.parseInternal(source);
+                const executed = await this.#executeAdmittedTurn({
+                    statements: admitted,
+                    source,
+                    sourceFolded: true,
+                    origin: "_plurnk",
+                    workspaceId,
+                    workerId,
+                    loopId,
+                    turnId,
+                    fromSequence: nextActionIndex,
+                    failOnOperationError: true,
+                    signal: this.#loopSignal(loopId),
+                    onDispatch,
+                });
+                if (executed.status !== TURN_STATUS_IMPLICIT_CONTINUE) {
+                    throw new Error(`overflow SEND returned ${executed.status}; expected ${TURN_STATUS_IMPLICIT_CONTINUE}`);
+                }
+                const rebuilt = await buildPacket();
+                const remaining = this.#packets.curationOverflow(rebuilt, provider);
+                const curationFailure = folds.length === 0 || remaining !== null
+                    ? curationOverflowFailure(remaining ?? pressure)
+                    : undefined;
+                return {
+                    createdTurnIds,
+                    turnId,
+                    producer: "_plurnk",
+                    kind: "overflow",
+                    status: curationFailure?.status ?? TURN_STATUS_IMPLICIT_CONTINUE,
+                    outcomes: [],
+                    fingerprint: "",
+                    capacityHardStop: false,
+                    steerStruck: false,
+                    emissionAttempts: 0,
+                    emissionExhausted: false,
+                    ...(curationFailure === undefined ? {} : { curationFailure }),
+                };
+            }
+            let modelMessages = PacketWire.packetToWireMessages(requestPacket);
+            // Curation pressure and provider generation are independent. The
+            // provider owns its configured total output envelope.
+            let response;
+            let splitResponse;
+            let railGrammar;
+            let railResponseGrammar;
+            let railAllowWithheld = false;
+            let railEvidence;
+            let emissionAttempts = 0;
+            let providerCallInFlight = false;
+            let modelCallSequence = 0;
+            let currentEmissionAttempt = 0;
+            let providerAttemptId = null;
+            let providerModelCall = null;
+            let providerAttemptAttributions = [];
+            const providerSignal = this.#loopSignal(loopId) ?? signal;
+            // {§client-metadata}
+            const { client } = await WorkspaceSettings.read(this.#db, workspaceId);
+            const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
+            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 candidateMessages = PacketWire.packetToWireMessages(candidate);
+                    if (JSON.stringify(candidateMessages) !== JSON.stringify(baselineMessages)) {
+                        requestPacket = candidate;
+                        modelMessages = candidateMessages;
+                        return true;
+                    }
+                    baselineMessages = candidateMessages;
+                }
+                return false;
+            };
+            try {
+                // {§turn-lifecycle}: bracket the complete provider-attempt window with liveness notices.
+                if (!signal?.aborted)
+                    this.#notices.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_awaiting_model", level: "info", message: "awaiting model response" });
+                const railConstraint = await this.#grammarConstraint(provider);
+                railGrammar = railConstraint?.transport;
+                railResponseGrammar = railConstraint?.response;
+                railAllowWithheld = railConstraint?.allowWithheld ?? false;
+                const attemptLimit = readEmissionAttempts();
+                const strikeStreak = this.#strikes.streak(loopId);
+                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, {
+                        turnId,
+                        sequence: modelCallSequence,
+                        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 completedResponse;
+                    try {
+                        completedResponse = await observed(// {§observability-boundary}
+                        GEN_AI_REQUEST_SPAN, { model: provider.model, attempt: modelCallSequence }, async (span) => {
+                            try {
+                                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: currentModelCall.observeRequest,
+                                    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);
+                                }
+                                throw error;
+                            }
+                        }, genAiRequestOptions(ProviderInstantiate.aliasOf(provider) ?? "plurnk", provider.model));
+                    }
+                    catch (error) {
+                        if (!(error instanceof ProviderError)
+                            || error.kind !== "capacity_exceeded"
+                            || providerSignal?.aborted === true
+                            || !await recoverCapacityPacket()) {
+                            throw error;
+                        }
+                        const failure = _a.#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();
+                        modelMessages = PacketWire.packetToWireMessages(requestPacket);
+                        continue;
+                    }
+                    response = completedResponse;
+                    await currentModelCall.observeResponse(completedResponse);
+                    railEvidence = railGrammar === undefined
+                        ? undefined
+                        : _a.#requireGrammarEvidence(completedResponse, railAllowWithheld);
+                    splitResponse = this.#splitResponse(completedResponse);
+                    await classifyProviderAttempt(attemptRow.id, splitResponse, attempt, splitResponse.emissionValid);
+                    if (splitResponse.emissionValid)
+                        break;
+                    attempt++;
+                }
+                if (!signal?.aborted)
+                    this.#notices.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_generated", level: "info", message: "parsing model response" });
+            }
+            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 = _a.#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);
+                    splitResponse = this.#splitResponse(response);
+                    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 evidence
+                // and its engine-owned verdict exist only on completed responses
+                // ({§rail-truth-engine-verdict}). 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 Turn.recordInference(this.#db, turnId, {
+                        packet: StoredPacket.stringify(requestPacket),
+                        usageCurationBudget: this.#packets.curationBudgetFor(provider),
+                        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({
+                    workerId,
+                    loopId,
+                    turnId,
+                    sequence: 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 Turn.recordInference(this.#db, turnId, {
+                    packet: StoredPacket.stringify(requestPacket),
+                    usageCurationBudget: this.#packets.curationBudgetFor(provider),
+                    finishReason: splitResponse?.callMetadata.finishReason ?? null,
+                    model: splitResponse?.callMetadata.model ?? provider.model,
+                    meta: JSON.stringify(response?.meta ?? {}),
+                });
+                await Turn.complete(this.#db, turnId, recorded.result.status);
+                if (capacityFailure) {
+                    return {
+                        createdTurnIds,
+                        turnId,
+                        producer: "model",
+                        kind: "inference",
+                        status: recorded.result.status,
+                        outcomes: [],
+                        fingerprint: "",
+                        capacityHardStop: true,
+                        capacityFailure: recorded.result,
+                        steerStruck: 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.emissionValid) {
+                // {§invalid-emission-attempts} The first consecutive exhaustion
+                // publishes only the raw final response and generic recovery fact.
+                let rejectedModelEntryId;
+                if (allowInvalidEmissionRecovery) {
+                    rejectedModelEntryId = await this.#dispatcher.writeEmissionAttempt({
+                        verbatim: splitResponse.packetAssistant.content,
+                        workerId,
+                        loopId,
+                        turnId,
+                        sequence: nextActionIndex,
+                        modelCallId: emissionModelCallId,
+                        ...(response.assistant.reasoningEncrypted?.length
+                            ? { reasoningItems: response.assistant.reasoningEncrypted }
+                            : {}),
+                    });
+                    this.#notices.push(workspaceId, loopId, {
+                        source: "engine:grammar",
+                        kind: "invalid_emission",
+                        level: "error",
+                        message: INVALID_EMISSION_RECOVERY_MESSAGE,
+                    });
+                }
+                const status = allowInvalidEmissionRecovery ? TURN_STATUS_IMPLICIT_CONTINUE : 500;
+                await Turn.recordInference(this.#db, turnId, {
+                    packet: StoredPacket.stringify(requestPacket),
+                    usageCurationBudget: this.#packets.curationBudgetFor(provider),
+                    finishReason: splitResponse.callMetadata.finishReason,
+                    model: splitResponse.callMetadata.model,
+                    meta: JSON.stringify(response.meta ?? {}),
+                });
+                await Turn.complete(this.#db, turnId, status);
+                return {
+                    createdTurnIds,
+                    turnId,
+                    producer: "model",
+                    kind: "inference",
+                    status: allowInvalidEmissionRecovery ? TURN_STATUS_IMPLICIT_CONTINUE : 500,
+                    outcomes: [],
+                    fingerprint: "",
+                    capacityHardStop: false,
+                    steerStruck: false,
+                    emissionAttempts,
+                    emissionExhausted: true,
+                    ...(rejectedModelEntryId === undefined ? {} : { rejectedModelEntryId }),
+                };
+            }
+            // {§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, loopId, notice);
+            }
+            // 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 the folded turnOps row 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, 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 } }
+                        : {}),
+                });
+            }
+            // Grade configured local evidence independently. Endpoint-owned
+            // constraints remain provider observations. {§rail-truth-engine-verdict}
+            let railKeys;
+            if (railGrammar !== undefined) {
+                if (railEvidence === undefined)
+                    throw new Error("configured GBNF response has no final grammar evidence");
+                if (railResponseGrammar === undefined)
+                    throw new Error("configured GBNF has no response grammar");
+                let verdict = null;
+                try {
+                    verdict = validateGbnf(railResponseGrammar, railEvidence.input);
+                }
+                catch (cause) {
+                    _a.#warnRailVerdictGapOnce(cause.message);
+                }
+                railKeys = {
+                    railsAttached: railEvidence.transported ? "client" : "withheld",
+                    railsVerdict: verdict?.status ?? "unverifiable",
+                };
+                if (verdict !== null && verdict.status !== "accept") {
+                    const contentPosition = verdict.pos >= railEvidence.contentStart
+                        ? verdict.pos - railEvidence.contentStart
+                        : null;
+                    const located = contentPosition === null
+                        ? null
+                        : this.#offsetToLineColumn(packetAssistant.content, contentPosition);
+                    this.#notices.push(workspaceId, loopId, {
+                        source: "engine:rails",
+                        kind: "grammar_unenforced",
+                        message: verdict.status === "reject"
+                            ? `emission rejects the grammar at raw code point ${verdict.pos}`
+                            : `emission is an incomplete grammar sentence (ends at raw code point ${verdict.pos})`,
+                        level: "warn",
+                        ...(located === null
+                            ? {}
+                            : { position: { type: "content-offset", line: located.line, column: located.column } }),
+                    });
+                }
+            }
+            // 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 Turn.recordInference(this.#db, turnId, {
+                packet: StoredPacket.stringify(packet),
+                usageCurationBudget: this.#packets.curationBudgetFor(provider), // {§tokenomics-client-gauge}
+                finishReason: callMetadata.finishReason,
+                model: callMetadata.model,
+                // Opaque provider metadata plus engine-authored rail keys.
+                // {§meta-passthrough}, {§rail-truth-engine-verdict}
+                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 reasoningItems = response.assistant.reasoningEncrypted?.length
+                ? response.assistant.reasoningEncrypted
+                : undefined;
+            const executed = await this.#executeAdmittedTurn({
+                statements: packetAssistant.ops,
+                source: splitResponse.sourceBacked ? packetAssistant.content : null,
+                sourceFolded: true,
+                sourceModelCallId: emissionModelCallId,
+                ...(reasoningItems !== undefined ? { sourceReasoningItems: reasoningItems } : {}),
+                origin: "model",
+                workspaceId,
+                workerId,
+                loopId,
+                turnId,
+                fromSequence: nextActionIndex,
+                maxCommands,
+                enforceIdle: true,
+                recoverableParseErrors,
+                bare: {
+                    provider: childProvider,
+                    modelCallSequenceStart: modelCallSequence + 1,
+                    primaryWorkerId,
+                    loopSequence: loopSeq,
+                    turnSequence: seq,
+                    signal: providerSignal,
+                },
+                signal: providerSignal,
+                onDispatch,
+            });
+            return {
+                createdTurnIds,
+                turnId,
+                producer: "model",
+                kind: "inference",
+                status: executed.status,
+                outcomes: executed.outcomes,
+                fingerprint: executed.fingerprint,
+                capacityHardStop: false,
+                steerStruck: executed.steerStruck,
+                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;
+        }
+    }
     // Split the wire-level ProviderResponse into the two destinations:
     // packet.assistant gets the model's emission (content, ops, reasoning);
     // Turn columns get accepted-call metadata (finishReason, model). Physical
@@ -1409,6 +1528,7 @@ class TurnRunner {
         const reasoning = assistant.reasoning ?? null;
         return {
             packetAssistant: { content: assistant.content, ops, reasoning },
+            sourceBacked: preParsedOps === undefined,
             callMetadata: { finishReason: assistant.finishReason, model: assistant.model },
             parseErrors,
             recoverableParseErrors: emissionValid ? recoverableParseErrors : [],
@@ -1421,8 +1541,8 @@ class TurnRunner {
             emissionValid,
         };
     }
-    // #note12 — the plugin-provided reference docs (schemes' + execs' `documentation`),
-    // materialized at worker://plurnk/docs/<name>.md by LoopDocs (like operator docs).
+    // #note12 — plugin reference docs are materialized beneath
+    // worker://plurnk/skills/plurnk/ by LoopDocs.
     async #materializeEnvironmentDeltas(args) {
         const { workspaceId, workerId, loopId, turnId, fromSequence } = args;
         const rows = await this.#db.engine_pull_ambient_events.all({ workspace_id: workspaceId, worker_id: workerId });
@@ -1484,7 +1604,9 @@ class TurnRunner {
                     mimetypeTx: "text/plain",
                     mimetypeRx: "application/json",
                 }, this.#weighContent),
-                expanded: terminal !== null && terminal.status >= 200 && terminal.status < 300 ? 1 : 0,
+                folded: LogVisibility.serialize(terminal !== null && terminal.status >= 200 && terminal.status < 300
+                    ? LogVisibility.OPEN
+                    : LogVisibility.FOLDED),
                 attrs,
             });
             const materialized = inserted ?? await this.#db.engine_ambient_delta_id.get({
@@ -1517,7 +1639,7 @@ class TurnRunner {
         await Promise.all(open.map(({ id }) => this.#liveSubscriptions.cancel(id)));
     }
     async #materializeStreamDeltas(args) {
-        const { workerId, loopId, turnId, fromSequence } = args;
+        const { workspaceId, workerId, loopId, turnId, fromSequence } = args;
         const channels = await this.#db.engine_worker_stream_channels.all({ worker_id: workerId });
         let written = 0;
         for (const ch of channels) {
@@ -1526,7 +1648,7 @@ class TurnRunner {
             // ordinary address to the model; only an explicitly non-default
             // channel earns a fragment in the log.
             const visibleFragment = ch.published_channel !== null
-                && ch.channel === this.#schemes.defaultChannelFor(ch.runtime)
+                && ch.channel === this.#schemes.defaultChannelFor(ch.runtime, workspaceId)
                 ? null
                 : ch.channel;
             const prior = await this.#db.engine_stream_cursor.get({
@@ -1564,8 +1686,9 @@ class TurnRunner {
                 // content and the auto-OPEN terminal observation never fired — the model was never shown
                 // the conclusion of a stream whose result it already holds folded. The same
                 // observation is required when the channel produced no publishable content:
-                // completion is information independently of payload. Text streams retain their
-                // terse marker; structured channels emit a bodyless typed conclusion.
+                // completion is information independently of payload. A text stream that delivered
+                // content retains its terse revisit marker; an empty text stream and every structured
+                // channel emit a bodyless typed conclusion.
                 if (closed && priorAttrs.terminal !== true) {
                     const streamTarget = renderTarget({
                         scheme: ch.runtime,
@@ -1574,12 +1697,9 @@ class TurnRunner {
                     });
                     if (streamTarget === null)
                         throw new Error(`stream ${ch.subscription_id} has no renderable address`);
-                    const pointer = cursor > 0
-                        ? `full output already delivered above; READ ${streamTarget} to revisit`
-                        : "stream produced no output";
                     const sequence = fromSequence + written;
-                    const content = baseMimetype(ch.mimetype).startsWith("text/")
-                        ? `[ stream closed (${ch.close_status ?? 200}) - ${pointer} ]`
+                    const content = cursor > 0 && baseMimetype(ch.mimetype).startsWith("text/")
+                        ? `[ stream closed (${ch.close_status ?? 200}) - full output already delivered above; READ ${streamTarget} to revisit ]`
                         : "";
                     const rx = JSON.stringify(await terminalResult({
                         content,
@@ -1599,7 +1719,7 @@ class TurnRunner {
                         }, this.#weighContent),
                         status: terminal?.status ?? 200,
                         attrs: JSON.stringify({ streamEnd: ch.content.length, terminal: true }),
-                        expanded: 1,
+                        folded: LogVisibility.serialize(LogVisibility.OPEN),
                     });
                     written++;
                 }
@@ -1630,55 +1750,85 @@ class TurnRunner {
                 }, this.#weighContent),
                 status: result.status,
                 attrs: JSON.stringify({ streamEnd: publishEnd, terminal: terminalDelivery }),
-                expanded: terminalDelivery ? 1 : 0, // {§exec-stream} — terminal observation auto-OPENs; ongoing folds
+                folded: LogVisibility.serialize(terminalDelivery ? LogVisibility.OPEN : LogVisibility.FOLDED), // {§exec-stream} — terminal observation auto-OPENs; ongoing folds
             });
             written++;
         }
         return written;
     }
     // {§env-delta-filesystem-narration} {§membership-emi-divergence-signal}
-    // — journal project-file divergence once through the reserved actor.
+    // — record project-file divergence once through the reserved actor.
     async #logFsFictions(workspaceId, divergences, gitStatus) {
         if (divergences.length === 0)
             return;
         const gitByPath = new Map(gitStatus?.files.map(({ path, status }) => [path, status]) ?? []);
         const worker = await this.#db.envelope_get_worker_by_name.get({ workspace_id: workspaceId, name: "plurnk" })
-            ?? await this.#db.envelope_insert_worker.get({ workspace_id: workspaceId, name: "plurnk", origin: "plurnk" });
+            ?? await this.#db.envelope_insert_worker.get({ workspace_id: workspaceId, name: "plurnk", origin: "_plurnk" });
         if (worker === undefined)
             throw new Error("logFsFictions: plurnk worker resolution returned no row");
         const loop = await this.#db.envelope_insert_client_loop.get({ worker_id: worker.id });
         if (loop === undefined)
             throw new Error("logFsFictions: loop insert returned no row");
-        const turn = await JournalTurn.insert(this.#db, loop.id);
-        let sequence = 1;
-        for (const d of divergences) {
-            const span = editedSpan(d.before, d.after);
-            const rx = JSON.stringify({ status: 200, entryId: d.entryId, channel: d.channel, span });
-            const attrs = gitByPath.has(d.pathname)
-                ? JSON.stringify({ git: gitByPath.get(d.pathname) })
-                : "{}";
-            await this.#db.engine_insert_log_entry.get({
-                worker_id: worker.id, loop_id: loop.id, turn_id: turn.id, sequence: sequence++,
-                origin: "plurnk", source: "file", model_call_id: null,
-                op: "EDIT", suffix: "", signal: null,
-                // Match Dispatcher.#extractTarget: a bare file address has NULL scheme
-                // only in log target metadata; its entry identity remains `file`.
-                scheme: null, username: null, password: null, hostname: null, port: null,
-                pathname: d.pathname, query: null, fragment: null, lineMarker: null,
-                tx: "", mimetype_tx: "text/plain",
-                rx, mimetype_rx: "application/json",
-                status_rx: 200,
-                weight: LogBody.weight({
-                    op: "EDIT",
+        const turn = await Turn.open(this.#db, { loopId: loop.id, producer: "_plurnk", kind: "operation" });
+        let turnOpen = true;
+        try {
+            let sequence = 1;
+            for (const d of divergences) {
+                const span = editedSpan(d.before, d.after);
+                const rx = JSON.stringify({ status: 200, entryId: d.entryId, channel: d.channel, span });
+                const attrs = gitByPath.has(d.pathname)
+                    ? JSON.stringify({ git: gitByPath.get(d.pathname) })
+                    : "{}";
+                await this.#db.engine_insert_log_entry.get({
+                    worker_id: worker.id, loop_id: loop.id, turn_id: turn.id, sequence: sequence++,
+                    origin: "_plurnk", source: "file", model_call_id: null,
+                    op: "EDIT", delimiter: "", signal: null,
+                    // Match Dispatcher.#extractTarget: a bare file address has NULL scheme
+                    // only in log target metadata; its entry identity remains `file`.
+                    scheme: null, username: null, password: null, hostname: null, port: null,
+                    pathname: d.pathname, query: null, fragment: null, lineMarker: null,
+                    tx: "", mimetype_tx: "text/plain",
+                    rx, mimetype_rx: "application/json",
+                    status_rx: 200,
+                    weight: LogBody.weight({
+                        op: "EDIT",
+                        attrs,
+                        tx: "",
+                        rx,
+                        mimetypeTx: "text/plain",
+                        mimetypeRx: "application/json",
+                    }, this.#weighContent),
+                    state: "resolved", outcome: null,
                     attrs,
-                    tx: "",
-                    rx,
-                    mimetypeTx: "text/plain",
-                    mimetypeRx: "application/json",
-                }, this.#weighContent),
-                state: "resolved", outcome: null,
-                attrs,
-            });
+                });
+            }
+            await Turn.complete(this.#db, turn.id, 200);
+            turnOpen = false;
+            const closed = await new LoopLifecycle(this.#db).finish(loop.id, { status: 200 });
+            if (closed === null)
+                throw new Error(`logFsFictions: narration loop ${loop.id} was not open at completion`);
+        }
+        catch (cause) {
+            const settlementFailures = [];
+            const failure = Results.failure("engine:filesystem-narration", "narration-failed", 500, "Filesystem divergence narration failed before its operation turn settled.", {}, { stage: "filesystem-narration", retryable: false });
+            if (turnOpen) {
+                try {
+                    await Turn.complete(this.#db, turn.id, failure.status);
+                }
+                catch (turnCause) {
+                    settlementFailures.push(turnCause);
+                }
+            }
+            try {
+                await new LoopLifecycle(this.#db).finish(loop.id, failure);
+            }
+            catch (loopCause) {
+                settlementFailures.push(loopCause);
+            }
+            if (settlementFailures.length > 0) {
+                throw new AggregateError([cause, ...settlementFailures], `filesystem narration ${turn.id} failed to settle`);
+            }
+            throw cause;
         }
     }
     async #writePromptLog({ workerId, loopId, turnId, sequence, target, content, }) {
@@ -1688,11 +1838,11 @@ class TurnRunner {
             loop_id: loopId,
             turn_id: turnId,
             sequence,
-            origin: "plurnk",
+            origin: "_plurnk",
             source: null,
             model_call_id: null,
             op: "prompt",
-            suffix: "",
+            delimiter: "",
             signal: null,
             scheme: target.scheme,
             username: target.username,