@plurnk/plurnk-service 1.3.12 → 1.5.0

package/dist/core/Engine.js

@@ -1,14 +1,17 @@
-import { PlurnkParser, PlurnkParseError } from "@plurnk/plurnk-grammar";
+import { PlurnkParser, PlurnkParseError, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
+import { RuntimeTag } from "@plurnk/plurnk-execs";
 import Owner from "./Owner.js";
+const TERMINAL_SEND_SIGNALS = new Set([102, 200, 202, 300, 499]);
+const comparePosition = (a, b) => a.line - b.line || a.column - b.column;
 import { Mimetypes, emptyRegistry } from "@plurnk/plurnk-mimetypes";
+import Meta from "@plurnk/plurnk-meta";
 import EntryCrud from "../schemes/_entry-crud.js";
-import EntryManifest from "../schemes/_entry-manifest.js";
-import { markTerminal } from "../schemes/Worker.js";
+import SearchIndex from "../schemes/_search-index.js";
 import GitMembership from "./git-membership.js";
 import GitState from "./git-state.js";
 import WorkspaceSettings from "./workspace-settings.js";
 import { editedSpan } from "../content/index.js";
-import { promptPathname, promptLoopPrefix } from "./plurnk-uri.js";
+import { promptPathname, promptLoopPrefix, renderTarget } from "./plurnk-uri.js";
 import { rulerCount } from "./token-ruler.js";
 import SearchGate from "./search-gate.js";
 import LiveSubscriptions from "./LiveSubscriptions.js";
@@ -19,28 +22,75 @@ import { setTimeout as delay } from "node:timers/promises";
 // Shared module imported by both Engine and bin/digest.ts, so wire
 // projection and digest projection are structurally one function — no
 // drift between wire and digest possible.
-// Format: markdown (user pick over rummy's XML alternative, 2026-05-22).
 import PacketWire from "./packet-wire.js";
+import Results, { OperationFailureError } from "./results.js";
+import BranchReceipt from "./BranchReceipt.js";
+import TerminalResult from "./TerminalResult.js";
+import BudgetOverflow from "./BudgetOverflow.js";
+import WorkerControlAddress from "./WorkerControlAddress.js";
+import JournalTurn from "./JournalTurn.js";
 // The engine's collaborators — each owns one machine; Engine owns the loop/turn
 // lifecycle and wires them together as the public facade.
-import TelemetryChannel from "./TelemetryChannel.js";
+import NoticeChannel from "./NoticeChannel.js";
+import ProblemLog from "./ProblemLog.js";
 import StrikeRail from "./StrikeRail.js";
 import PacketBuilder from "./PacketBuilder.js";
+import StoredPacket from "./StoredPacket.js";
 import ProposalLifecycle from "./ProposalLifecycle.js";
 import Dispatcher from "./Dispatcher.js";
+import { observed, observedSync } from "../observe/spans.js";
+import { OPS_DISPATCHED, PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
 import { scheduleTurnOps } from "./turn-scheduler.js";
+import { readOptimisticSettlementMs } from "./optimistic-settlement.js";
 const DEFAULT_MAX_STRIKES = 3;
-// The foisted prompt EDIT/READ target — prompt:///<loop>/<N>, self-only ({§prompt-self-only}):
+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.
+// Atomic documents wait for close; JSONL stops after its last complete record.
+const streamPublicationEnd = (content, mimetype, cursor, closed) => {
+    const type = baseMimetype(mimetype);
+    if (closed || type.startsWith("text/"))
+        return content.length;
+    if (!RECORD_STREAM_MIMETYPES.has(type))
+        return cursor;
+    return Math.max(cursor, content.lastIndexOf("\n") + 1);
+};
+const ENGINE_PROBLEMS = Object.freeze({
+    max_commands_exceeded: {
+        status: 429,
+        code: "max-commands-exceeded",
+        detail: "Later operations were not executed because the turn exceeded its operation limit.",
+    },
+    idle_turn: {
+        status: 409,
+        code: "idle-turn",
+        detail: "SEND[102] was emitted without an operation to continue from.",
+    },
+});
+// The prompt entry target - prompt:///<loop>/<N>, self-only ({§prompt-self-only}):
 // the owner rides the owner_id column, the address carries only the loop coordinate.
-const promptTarget = (workerId, loopSeq, turnSeq) => {
+const promptTarget = (loopSeq, turnSeq) => {
     const storage = promptPathname(loopSeq, turnSeq);
     return {
         kind: "url", raw: `prompt://${storage}`,
         scheme: "prompt", username: null, password: null,
         hostname: null, port: null,
-        pathname: storage, params: {}, fragment: null,
+        pathname: storage, query: null, fragment: null,
     };
 };
+const assertOpenPaths = (value, source) => {
+    if (!Array.isArray(value) || value.some((path) => typeof path !== "string" || path.length === 0)) {
+        throw new TypeError(`${source}: expected an array of non-empty strings`);
+    }
+    return value;
+};
+const parsePromptAttributes = (encoded, source) => {
+    const attributes = JSON.parse(encoded);
+    if (attributes === null || typeof attributes !== "object" || Array.isArray(attributes)) {
+        throw new TypeError(`${source}: expected a JSON object`);
+    }
+    return attributes;
+};
 const readMaxStrikes = () => {
     const raw = process.env.PLURNK_SERVICE_MAX_STRIKES;
     if (raw === undefined || raw.length === 0)
@@ -50,10 +100,11 @@ const readMaxStrikes = () => {
         return DEFAULT_MAX_STRIKES;
     return n;
 };
-// Per-emission op ceiling — OFF by default. `-1` (or unset/non-positive) = no cap: every
-// generated op dispatches. Runaway degeneration is a sampler concern (repetition penalty),
+// Per-emission action ceiling — OFF by default. `-1` (or unset/non-positive) = no cap:
+// every generated op dispatches. Runaway degeneration is a sampler concern (repetition penalty),
 // not grounds to drop already-generated work. A positive value is an operator ceiling a
-// workspace's maxCommands may tighten (min wins), never widen (#232).
+// workspace's maxCommands may tighten (min wins), never widen
+// ({§operator-config-workspace-max-commands}).
 const readMaxCommands = () => {
     const raw = process.env.PLURNK_SERVICE_MAX_COMMANDS;
     if (raw === undefined || raw.length === 0)
@@ -63,8 +114,8 @@ const readMaxCommands = () => {
         return Number.POSITIVE_INFINITY;
     return n;
 };
-// PLURNK_SERVICE_FILES_ITEMS — the turn-0 manifest preview. null = off (no foist);
-// -1 = the full manifest; positive N = the first N items. 0 / unset = off.
+// PLURNK_SERVICE_FILES_ITEMS — the turn-0 catalog preview. null = off;
+// -1 = the ordinary markerless page; positive N explicitly caps file rows. 0 / unset = off.
 const normalizeFilesItems = (n) => (!Number.isFinite(n) || n === 0 ? null : n < 0 ? -1 : n);
 const readFilesItems = () => {
     const raw = process.env.PLURNK_SERVICE_FILES_ITEMS;
@@ -72,16 +123,14 @@ const readFilesItems = () => {
         return null;
     return normalizeFilesItems(Number.parseInt(raw, 10));
 };
-import { ProviderError, scopeEnvToAlias, resolveActiveAlias } from "@plurnk/plurnk-providers";
+import { ProviderError, providerCostFor, providerCostUsd, validateProviderCost, scopeEnvToAlias, resolveActiveAlias } from "@plurnk/plurnk-providers";
 import { validateGbnf } from "@plurnk/gbnf";
 import ProviderInstantiate from "./ProviderInstantiate.js";
-// Default turn.status when ops were emitted but no SEND. Model is implicitly
-// continuing; loop.status stays 102 either way (only SEND broadcast advances
-// loop terminal). No strike, no telemetry.
+// Runtime normalization for a disposition the engine refuses or resolves as a
+// continue after dispatch ({§send}). Every admitted emission itself ends in an
+// explicit disposition SEND ({§emission-admission}).
 const TURN_STATUS_IMPLICIT_CONTINUE = 102;
-// Status assigned to a turn that emitted NO ops at all. Strike-worthy; the
-// action routes through telemetry.errors[] (§telemetry, §telemetry-no-error-scheme — never an error:// scheme).
-const TURN_STATUS_NO_OPS = 422;
+const INVALID_EMISSION_RECOVERY_MESSAGE = "Your previous response contained an unrecoverable syntax error. No operations were performed. Try again.";
 const DEFAULT_MIN_CYCLES = 3;
 const DEFAULT_MAX_CYCLE_PERIOD = 4;
 const readPositiveInt = (envVar, fallback) => {
@@ -93,7 +142,15 @@ const readPositiveInt = (envVar, fallback) => {
         return fallback;
     return n;
 };
-// §operator-config-loop-timeout — the loop's wall-clock budget (PLURNK_SERVICE_LOOP_TIMEOUT).
+const readEmissionAttempts = () => {
+    const raw = process.env.PLURNK_SERVICE_EMISSION_ATTEMPTS;
+    const value = Number.parseInt(raw ?? "", 10);
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`PLURNK_SERVICE_EMISSION_ATTEMPTS must be a positive integer; got ${raw}`);
+    }
+    return value;
+};
+// {§operator-config-loop-timeout} — the loop's wall-clock budget (PLURNK_SERVICE_LOOP_TIMEOUT).
 const DEFAULT_LOOP_TIMEOUT_MS = 86400000;
 const readLoopTimeoutMs = () => readPositiveInt("PLURNK_SERVICE_LOOP_TIMEOUT", DEFAULT_LOOP_TIMEOUT_MS);
 // The wall's abort reason — runLoop branches a mid-turn teardown to the 504 terminal on it.
@@ -109,30 +166,26 @@ export default class Engine {
     #lifecycle;
     #schemes;
     #mimetypes;
-    // Write-time tokenizer (SPEC §tokenomics). Synchronous per the provider
-    // contract (§provider-surface). Populated from the active provider's countTokens via
-    // the Daemon; a divisor tripwire stands in only for bare/standalone
-    // construction before a provider is wired (same boot affordance as
-    // Mimetypes, §mimetype-surface). Real counts come from provider.countTokens.
+    // {§tokenomics-agnostic-ruler} — the stable model-independent ruler used
+    // for write-time, catalog, receipt, and packet weights.
     #tokenize;
     // Boot-discovered runtime executors. Daemon builds + sets via
     // setExecutors at start(); undefined until then (and in bare tests).
     #executors;
-    // §send-premature-terminate/[102]<T> — park deadlines by loopId, written at dispatch (the
+    // {§send-premature-terminate}/SEND[202]<T> — park deadlines by loopId, written at dispatch (the
     // marker's seconds; -1 = indefinite), consumed by the daemon's drain park-exit to schedule
     // the deadline wake. In-memory: a daemon restart drops pending deadlines (documented).
     parkDeadlines = new Map();
-    // §join-blocking-collect (#354) — loops whose turn issued a READ(worker://running-child): the
-    // blocking join. The dispatcher arms this on the READ; the turn's bare SEND[102] parks on it
-    // (indefinite) instead of continuing, and any SEND clears it. Twin of parkDeadlines.
+    // Per-turn running-worker READ obligations. {§join-blocking-collect}
     joinTargets = new Set();
     // The collaborators. Engine constructs them (they share its deps via
     // thunks where the value is late-injected — executors, loop signals)
     // and fronts their public surface.
-    #telemetry;
+    #notices;
+    #problems;
     #strikes;
-    // §grinder-hard-413-recovery — loops granted their ONE over-ceiling recovery turn. Cleared on a
-    // fitting turn (the model curated; a LATER overflow earns a fresh recovery) and at loop cleanup.
+    // {§grinder-hard-413-recovery} - loops granted their one over-ceiling recovery turn. Cleared on a
+    // fitting turn so a later independent overflow can earn a fresh recovery, and at loop cleanup.
     #hardOverflowRecovery = new Set();
     #packets;
     searchGate = new SearchGate();
@@ -145,9 +198,10 @@ export default class Engine {
     // Streaming schemes (exec) chain their per-spawn controllers off
     // ctx.signal so cancelled loops tear down their background spawns.
     #loopAborts = new Map();
-    // §send-premature-terminate — loops owed one idle-grace turn after a retrieval-only 409
-    // (the steer's own advice is to wait; in-memory, fail-open on restart).
-    #retrievalRefusalGrace = new Set();
+    // {§prompt-loop-containment}: one worker's prompt-frame allocation and
+    // persistence is a serial critical section. A completed later frame can
+    // therefore never overtake or replace an earlier concurrent arrival.
+    #promptWriteLocks = new Map();
     // One coalesced warm per workspace. Creation/membership changes start it as soon
     // as content exists; the first model turn joins it, so no operation observes
     // partial graph/vector coverage. A request arriving mid-pass marks the workspace
@@ -168,14 +222,20 @@ export default class Engine {
         if (!invalidate && this.#workspaceWarmStatus.get(workspaceId)?.phase === "complete") {
             return Promise.resolve();
         }
-        const state = { dirty: false, materialize, ctx, promise: Promise.resolve() };
-        // Register before publishing the first synchronous telemetry event. A
+        const state = {
+            dirty: false,
+            materialize,
+            ctx,
+            abort: new AbortController(),
+            promise: Promise.resolve(),
+        };
+        // Register before publishing the first synchronous Notice. A
         // listener may request another warm from that callback; it must join
         // this state rather than opening a second pump in the re-entrant gap.
         this.#workspaceWarms.set(workspaceId, state);
         const publish = (current, status) => {
             this.#workspaceWarmStatus.set(workspaceId, status);
-            current.pushTelemetry?.({
+            current.pushNotice?.({
                 source: "engine:derivation", kind: "embed_progress", ...status,
             });
         };
@@ -191,25 +251,29 @@ export default class Engine {
                     completed: 0, total: 1, percent: 0, level: "info",
                 });
                 try {
+                    const signal = current.signal === undefined
+                        ? state.abort.signal
+                        : AbortSignal.any([current.signal, state.abort.signal]);
+                    const cancellable = { ...current, signal };
                     if (shouldMaterialize)
-                        await GitMembership.indexGitMembership(current);
-                    await EntryManifest.maintainDerivations({
-                        ...current,
-                        pushTelemetry: (event) => {
-                            if (event.kind === "embed_progress"
-                                && typeof event.completed === "number"
-                                && typeof event.total === "number"
-                                && typeof event.percent === "number") {
+                        await GitMembership.indexGitMembership(cancellable);
+                    await SearchIndex.maintain({
+                        ...cancellable,
+                        pushNotice: (notice) => {
+                            if (notice.kind === "embed_progress"
+                                && typeof notice.completed === "number"
+                                && typeof notice.total === "number"
+                                && typeof notice.percent === "number") {
                                 this.#workspaceWarmStatus.set(workspaceId, {
                                     phase: "indexing",
-                                    completed: event.completed,
-                                    total: event.total,
-                                    percent: event.percent,
-                                    message: event.message ?? "Indexing repository semantics",
-                                    level: event.level === "error" ? "error" : "info",
+                                    completed: notice.completed,
+                                    total: notice.total,
+                                    percent: notice.percent,
+                                    message: notice.message ?? "Indexing repository semantics",
+                                    level: notice.level === "error" ? "error" : "info",
                                 });
                             }
-                            current.pushTelemetry?.(event);
+                            current.pushNotice?.(notice);
                         },
                     });
                 }
@@ -237,14 +301,36 @@ export default class Engine {
     workspaceDerivationStatus(workspaceId) {
         return this.#workspaceWarmStatus.get(workspaceId) ?? null;
     }
-    // Awaited by Daemon.stop before the db closes.
-    async drainDerivations() {
-        await Promise.all([...this.#workspaceWarms.values()].map((state) => state.promise));
+    cancelDerivations(reason = new DOMException("derivations cancelled", "AbortError")) {
+        for (const state of this.#workspaceWarms.values()) {
+            if (!state.abort.signal.aborted)
+                state.abort.abort(reason);
+        }
+    }
+    // Awaited by Daemon.stop before the db closes. Shutdown supplies the exact
+    // cancellation reason it owns; every unrelated failure remains visible.
+    async drainDerivations(ignoredReason) {
+        const results = await Promise.allSettled([...this.#workspaceWarms.values()].map((state) => state.promise));
+        const errors = results
+            .filter((result) => result.status === "rejected")
+            .flatMap((result) => result.reason instanceof AggregateError
+            ? [...result.reason.errors]
+            : [result.reason])
+            .filter((error) => error !== ignoredReason);
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "derivation drain failed");
+    }
+    async drainWorkspaceDerivations(workspaceId) {
+        await this.#workspaceWarms.get(workspaceId)?.promise;
     }
     #streamEventNotify;
     #wakeWorkerNotify;
-    // Cached plurnk GBNF — read once on the first constrained generate (#189).
-    #gbnfCache = new Map(); // variant name -> GBNF text (per-alias selection, #353)
+    #acquireWorkspaceTurn;
+    #workspaceTurnCompleted;
+    // Configured grammar text is cached by variant after its first load.
+    #gbnfCache = new Map();
     // {§rail-truth-engine-verdict} — the verify GAP (a configured grammar @plurnk/gbnf can't
     // parse): warn once per message, never per turn; the turn records railsVerdict "unverifiable".
     static #railGapWarned = new Set();
@@ -254,42 +340,52 @@ export default class Engine {
         Engine.#railGapWarned.add(message);
         process.stderr.write(`plurnk-engine: rail verdict unavailable — the configured grammar did not parse in @plurnk/gbnf (${message})\n`);
     }
-    constructor({ db, schemes, mimetypes, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, cancelDescendants, telemetryEventNotify, tokenize }) {
+    static #requireGrammarEvidence(response) {
+        const evidence = response.grammarEvidence;
+        if (evidence === undefined) {
+            throw new Error("provider contract violation: configured GBNF response omitted grammar evidence");
+        }
+        const input = [...evidence.input];
+        if (!Number.isInteger(evidence.contentStart)
+            || evidence.contentStart < 0
+            || evidence.contentStart > input.length
+            || typeof evidence.transported !== "boolean"
+            || input.slice(evidence.contentStart).join("") !== response.assistant.content) {
+            throw new Error("provider contract violation: grammar evidence does not map exactly to assistant.content");
+        }
+        return evidence;
+    }
+    constructor({ db, schemes, mimetypes, streamEventNotify, wakeWorkerNotify, injectWorker, branchWorker, branchCompletionGate, cancelWorker, cancelDescendants, acquireWorkspaceTurn, workspaceTurnCompleted, noticeNotify, tokenize }) {
         this.#db = db;
         this.#lifecycle = new LoopLifecycle(db);
         this.#schemes = schemes;
         this.#streamEventNotify = streamEventNotify;
         this.#wakeWorkerNotify = wakeWorkerNotify;
+        this.#acquireWorkspaceTurn = acquireWorkspaceTurn ?? (async () => () => { });
+        this.#workspaceTurnCompleted = workspaceTurnCompleted;
         // Default to empty discovery — standalone Engine construction (in
         // tests) gets no handlers, and content flows through the framework's
         // raw-content fitContent fallback. Daemon-managed Engine receives a
         // production-configured Mimetypes via the constructor arg.
         this.#mimetypes = mimetypes ?? new Mimetypes({
-            discovery: { registry: emptyRegistry(), handlers: new Map() },
+            discovery: { registry: emptyRegistry(), handlers: new Map(), skipped: [] },
         });
-        // Tripwire default matches the Mimetypes boot affordance (SPEC §mimetype-surface):
-        // the divisor stands in only until the provider-backed tokenizer is
-        // wired by the Daemon. Real counts come from provider.countTokens.
+        // {§tokenomics-agnostic-ruler} — standalone construction and the daemon
+        // use the same default; provider counting is confined to physical admission.
         this.#tokenize = tokenize ?? rulerCount;
         const executors = () => this.#executors;
         const loopSignal = (loopId) => this.#loopAborts.get(loopId)?.signal;
-        this.#telemetry = new TelemetryChannel({ db, notify: telemetryEventNotify });
-        schemes.bindCore({
+        this.#notices = new NoticeChannel({ notify: noticeNotify });
+        this.#problems = new ProblemLog(db);
+        this.#strikes = new StrikeRail();
+        this.#packets = new PacketBuilder({
             db,
-            mimetypes: this.#mimetypes,
+            schemes,
+            problems: this.#problems,
             executors,
-            tokenize: this.#tokenize,
-            streamEventNotify,
-            wakeWorkerNotify,
-            injectWorker,
-            pushTelemetry: (workspaceId, loopId, event) => this.#telemetry.push(workspaceId, loopId, event),
-            defaultChannelFor: (scheme) => schemes.defaultChannelFor(scheme),
-            liveSubscriptions: this.#liveSubscriptions,
         });
-        this.#strikes = new StrikeRail();
-        this.#packets = new PacketBuilder({ db, schemes, telemetry: this.#telemetry, executors });
         this.#proposals = new ProposalLifecycle({
-            db, schemes, telemetry: this.#telemetry,
+            db, schemes, notices: this.#notices,
             streamEventNotify, wakeWorkerNotify,
             tokenize: this.#tokenize, mimetypes: this.#mimetypes, executors, loopSignal,
             liveSubscriptions: this.#liveSubscriptions,
@@ -297,52 +393,52 @@ export default class Engine {
         this.#dispatcher = new Dispatcher({ searchGate: this.searchGate,
             db, schemes, mimetypes: this.#mimetypes,
             tokenize: this.#tokenize,
-            telemetry: this.#telemetry, proposals: this.#proposals,
+            notices: this.#notices, proposals: this.#proposals,
             executors, loopSignal,
-            streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, cancelDescendants,
+            streamEventNotify, wakeWorkerNotify, injectWorker, branchWorker, branchCompletionGate, cancelWorker, cancelDescendants,
             parkDeadlines: this.parkDeadlines,
             joinTargets: this.joinTargets,
             liveSubscriptions: this.#liveSubscriptions,
         });
+        schemes.bindCore({
+            db,
+            mimetypes: this.#mimetypes,
+            executors,
+            tokenize: this.#tokenize,
+            streamEventNotify,
+            wakeWorkerNotify,
+            injectWorker,
+            pushNotice: (workspaceId, loopId, notice) => this.#notices.push(workspaceId, loopId, notice),
+            defaultChannelFor: (scheme) => schemes.defaultChannelFor(scheme),
+            readExecSource: (statement, ctx) => this.#dispatcher.readExecSource(statement, ctx),
+            liveSubscriptions: this.#liveSubscriptions,
+        });
     }
     // Late injection: the executor registry is async-built at daemon start()
     // (discover + probe), after Engine construction.
     setExecutors(executors) {
         this.#executors = executors;
     }
-    // Runtime hotload (#289) — register an executor TAG live, after boot (the /mcp route: an MCP
-    // server connected at runtime becomes EXEC[<server>]). Registers on BOTH registries the boot path
-    // wires: the ExecutorRegistry (dispatch resolves the tag; the tools sheet, rebuilt per packet, then
-    // offers it to the model) and the SchemeRegistry face (the tag's READ/FIND/KILL scheme), sharing the
-    // same reserved/cross-family arbitration boot uses. Fail-hard if the registry isn't wired yet — a
-    // hotload before daemon start() is a caller bug, not a silent no-op.
-    hotloadRuntime(tag, entry) {
+    // Register a module-owned runtime on the same two registries as boot discovery.
+    // An optional same-name scheme handler lets one capability own both execution
+    // and addressable state without teaching core its protocol.
+    registerRuntime(tag, entry, scheme) {
         if (this.#executors === undefined)
-            throw new Error("hotloadRuntime: executor registry not wired yet (call after daemon start)");
-        // Scheme face FIRST — it is the arbitration gate (reserved / cross-family collision, #240) and
-        // throws before we mutate the executor registry, so a rejected tag leaves neither registry
-        // half-written. A brand-new tag registers on both; a reserved/claimed tag throws here untouched.
-        this.#schemes.registerRuntimeScheme(tag, entry.executor);
+            throw new Error("registerRuntime: executor registry not wired yet");
+        RuntimeTag.assert(tag, "module runtime");
+        // Preflight both owners before either write; synchronous registration
+        // then cannot leave a half-claimed namespace. {§plugin-namespace-arbitration}
+        this.#executors.assertCanRegister(tag, entry.namespaceOwner);
+        this.#schemes.assertRuntimeClaim(tag, entry.namespaceOwner);
+        this.#schemes.registerRuntimeScheme(tag, entry.executor, entry.namespaceOwner, scheme);
         this.#executors.register(tag, entry);
     }
-    // Optional local-model constrained sampling (#189). The PLURNK language is
-    // always parsed by ANTLR; this separately supplies a GBNF artifact to a
-    // backend that explicitly supports constrained sampling.
+    // Supply an explicitly configured local constraint; ANTLR remains the
+    // language authority. {§grammar-enforcement-verified-at-boot}
     async #grammarConstraint(provider) {
-        // PLURNK_PROVIDERS_GBNF SELECTS the GBNF variant to constrain sampling to (#225):
-        // a bare name (`plurnk-strict.gbnf` | `plurnk.gbnf`) is a variant shipped by
-        // @plurnk/plurnk-grammar; an absolute/relative path is a BYO grammar. Empty or "0"
-        // disables the optional constraint.
-        //
-        // PER ALIAS (#353): resolved PLURNK_PROVIDERS_GBNF_<alias> over the bare fallback (providers'
-        // scopeEnvToAlias), scoped by the alias that built this provider. GBNF only helps backends
-        // that constrain sampling (llama-server). The bare default is unset and
-        // local-model aliases opt in via a PLURNK_PROVIDERS_GBNF_<alias> suffix.
-        // #488 — the rail must be VERIFIABLE, never silently off. Two guards:
-        // (1) the alias fallback is only trusted when NO per-alias GBNF opt-ins exist: an
-        //     unregistered provider in a process that configured suffixed rails could fall back
-        //     to a DIFFERENT active alias, miss the suffix, and run unconstrained — the silent
-        //     severance class run78 demonstrated (free decode, fabricated logs, CLEAN telemetry).
+        // 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_"))) {
@@ -357,52 +453,66 @@ export default class Engine {
             return hit;
         const path = variant.startsWith("/") || variant.startsWith(".")
             ? variant
-            : fileURLToPath(import.meta.resolve(`@plurnk/plurnk-grammar/${variant}`));
+            : fileURLToPath(import.meta.resolve(`@plurnk/plurnk-contracts/${variant}`));
         const text = await readFile(path, "utf8"); // unresolvable/unreadable throws — a configured rail never silently degrades
         this.#gbnfCache.set(variant, text);
         process.stderr.write(`plurnk-engine: GBNF constraint: ${alias || "(bare)"} → ${variant} (${text.length} chars)\n`);
         return text;
     }
-    // Per-loop usage totals (#197): SUM the loop's turns (usage is stored per
-    // turn, §tokenomics). Surfaced on loop.run + loop/terminated so clients render real
-    // token/cost numbers. costUsd is the stored USD unit.
-    // #345 — the client-facing budget denominator, ONE meaning on every surface: the prompt
-    // budget the packet actually lives under (effective window minus the partition reserves),
-    // the same number loop-usage stores per turn. providers.list advertised the raw KV and the
-    // client's gauge rendered a window the model can never fill.
-    // #522 — the PRIMARY worker of a turn's lineage: the no-parent root reached by walking
-    // parent_worker_id up. A no-parent worker is its OWN primary (stamped on the primary's own
-    // turns). Supplied on the first-party metadata channel alongside Worker-Id; the endpoint routes
-    // primary→strong / spawned→cheap by `Worker-Primary == Worker-Id` equality. Fail-hard if a
-    // worker resolves to no root — that is a corrupt lineage (a cycle the parent!=id CHECK forbids),
-    // never a silent "assume primary."
+    // A lineage's no-parent root; a root worker resolves to itself. Fail hard
+    // when corruption leaves a worker without one. {§worker-primary}
     async resolveWorkerPrimary(workerId) {
         const root = await this.#db.engine_worker_lineage_root.get({ worker_id: workerId });
         if (root === undefined)
-            throw new Error(`resolveWorkerPrimary: worker ${workerId} has no lineage root — corrupt parent chain (#522)`);
+            throw new Error(`resolveWorkerPrimary: worker ${workerId} has no lineage root — corrupt parent chain`);
         return root.id;
     }
     promptBudgetFor(provider) {
         return this.#packets.promptBudgetFor(provider);
     }
+    async #attemptAttributions(provider, context) {
+        const tags = Meta.composeAttributions(this.#schemes.attributions(context), this.#executors?.attributions(context) ?? [], await this.#mimetypes.attributions(context), provider.attributions?.(context) ?? []);
+        return [...tags];
+    }
+    // {§attribution} — reporting derives from exact provider-request evidence;
+    // malformed durable tags fail here instead of being silently filtered.
+    async loopAttributions(loopId) {
+        const rows = await this.#db.engine_loop_attributions.all({ loop_id: loopId });
+        const tags = rows.map(({ attribution }, index) => {
+            if (typeof attribution !== "string" || attribution.length === 0) {
+                throw new TypeError(`loop ${loopId} attribution row ${index} is not a non-empty string`);
+            }
+            return attribution;
+        });
+        return [...Meta.composeAttributions(tags)];
+    }
+    // Loop totals are billing evidence; the latest-turn pair is the client
+    // occupancy gauge. {§tokenomics-client-gauge}, {§notifications-loop-terminated}
     async loopUsage(loopId) {
         const row = await this.#db.engine_loop_usage.get({ loop_id: loopId });
+        if (row === undefined)
+            throw new Error(`loopUsage: loop ${loopId} does not exist`);
+        const parsedCosts = JSON.parse(row?.costs ?? "[]");
+        if (!Array.isArray(parsedCosts))
+            throw new TypeError(`loop ${loopId} monetary evidence is not an array`);
+        const costs = parsedCosts.map((cost) => validateProviderCost(cost));
         return {
             promptTokens: row?.prompt ?? 0,
             completionTokens: row?.completion ?? 0,
-            costUsd: row?.cost_usd ?? 0,
-            // #263 — the last turn's prompt tokens = current window occupancy (gauge numerator), NOT the
-            // summed promptTokens above, which overcounts a context that grows across turns.
+            reasoningTokens: row?.reasoning ?? 0,
+            cachedTokens: row?.cached ?? 0,
+            costUsd: row?.cost_usd ?? null,
+            costs,
+            // Latest provider attempt on the latest turn, not the billed total.
             contextTokens: row?.context ?? 0,
-            // #274 — the last turn's model window (denominator); null when the provider reports none.
+            // Latest effective packet allowance; null when uncapped or unknown.
             promptBudget: row?.context_size ?? null,
-            // #252 — the latest turn's opaque provider blob, parsed for the wire. Empty {} when the
-            // provider returned no meta. The service forwards it; it never reads a field within.
+            // Latest turn's opaque provider metadata. {§meta-passthrough}
             meta: JSON.parse(row?.meta ?? "{}"),
         };
     }
-    // A @plurnk/gbnf divergence position (providers#24) is a CODE-POINT offset into the
-    // model's content; the snippet/telemetry surface speaks 1-based line + 0-based column.
+    // A mapped rail divergence is a CODE-POINT offset into the model's content;
+    // the snippet/notices surface speaks the parser-point convention. {§parser-position}
     // Convert over code points (not UTF-16 units) so an astral char doesn't skew the line,
     // clamping out-of-range offsets to the content's end.
     #offsetToLineColumn(content, offset) {
@@ -426,7 +536,7 @@ export default class Engine {
         // Its ceiling therefore counts every prior turn, not merely this process-local
         // execution segment.
         const turnIds = await this.#lifecycle.turnIds(loopId);
-        const suddenDeathThreshold = maxTurns - maxStrikes;
+        let invalidEmissionRecoveryEntryId = null;
         // Per-loop AbortController for scheme-side cancellation propagation.
         // Chained from the caller's `signal` so an external abort cascades.
         const loopAbort = new AbortController();
@@ -437,23 +547,24 @@ export default class Engine {
                 signal.addEventListener("abort", () => loopAbort.abort(signal.reason), { once: true });
         }
         this.#loopAborts.set(loopId, loopAbort);
-        // §operator-config-loop-timeout — the wall-clock budget. Expiry aborts the loop signal, so a
+        // {§operator-config-loop-timeout} — the wall-clock budget. Expiry aborts the loop signal, so a
         // mid-flight provider call (generate rides this signal) and in-flight spawns tear down; the
-        // loop terminates 504 (kin to the exec <T> reap's 504, §exec-timeout) — a legible engine
+        // loop terminates 504 (kin to the exec <T> reap's 504, {§exec-timeout}) — a legible engine
         // terminal, never an outside kill. unref'd: the wall never holds the process open.
         const wall = setTimeout(() => loopAbort.abort(LOOP_TIMEOUT_REASON), readLoopTimeoutMs());
         wall.unref();
         const timedOut = () => loopAbort.signal.aborted && loopAbort.signal.reason === LOOP_TIMEOUT_REASON;
         const ruleTimeout = async () => {
-            // {§loop-terminals} — EVERY abandonment names itself (#555; the full terminal
-            // enumeration, not the two first found): live fan-out before cleanup wipes the buffer.
-            this.#telemetry.push(workspaceId, loopId, {
-                source: "engine:rails", kind: "loop_timeout", level: "error",
-                message: `loop abandoned 504: the loop wall expired after ${turnIds.length} turns`,
+            const failure = Results.failure("engine:rails", "loop-timeout", 504, `The loop exceeded its wall-clock deadline after ${turnIds.length} turns.`, {}, {
+                turns: turnIds.length,
+                stage: "loop",
+                retryable: false,
             });
-            await this.#lifecycle.finish(loopId, 504, "loop_timeout");
+            const result = await this.#lifecycle.finish(loopId, failure);
+            if (result === null)
+                throw new Error(`loop ${loopId} became terminal before timeout settlement`);
             cleanup("forceful", "loop_timeout");
-            return { turnIds, finalStatus: 504, hitMaxTurns: false, reason: "loop_timeout" };
+            return { turnIds, result, hitMaxTurns: false, reason: "loop_timeout" };
         };
         // Cleanup splits by termination kind:
         // - "graceful" (SEND[202] Accepted): in-flight streaming-scheme spawns
@@ -471,23 +582,19 @@ export default class Engine {
             this.#strikes.delete(loopId);
             this.searchGate.cleanup(loopId);
             this.#hardOverflowRecovery.delete(loopId);
-            this.#telemetry.delete(loopId);
+            this.#notices.delete(loopId);
         };
         while (true) {
-            // The wall fired between turns — rule 504 before anything else reads the loop.
-            if (timedOut())
-                return await ruleTimeout();
-            signal?.throwIfAborted();
             const row = await this.#db.engine_loop_status.get({ loop_id: loopId });
             if (row === undefined)
                 throw new Error(`Engine.runLoop: loop ${loopId} not found`);
             if (row.status === 100) {
                 // NOT a terminal — a wake re-queued this loop while its own live drain was
                 // between turns (a child concluded in the gap between our 202 write and this
-                // check, §worker-lifecycle-wake-requeue-not-terminal). The wake's intent is KEEP
+                // check, {§worker-lifecycle-wake-requeue-not-terminal}). The wake's intent is KEEP
                 // RUNNING: re-claim atomically and continue — the injected prompt is already
                 // this loop's next turn. Returning it as "external" broadcast a QUEUED loop
-                // as loop/terminated {finalStatus: 100} — the delegation-flags flake.
+                // as a terminal result with status 100 — the delegation-flags race.
                 await this.#db.engine_reclaim_queued_loop.run({ loop_id: loopId });
                 continue; // claimed (or a racer flipped it first — the re-read decides)
             }
@@ -496,34 +603,38 @@ export default class Engine {
                 // contract (E.4). Every other terminal, 200 included, reaps: "done"
                 // must not leak running execs. Trust the code's declared intent.
                 cleanup(row.status === 202 ? "graceful" : "forceful", `loop_terminal_${row.status}`);
-                return { turnIds, finalStatus: row.status, hitMaxTurns: false, reason: "external" };
+                if (row.status === 202) {
+                    return { turnIds, result: { status: 202 }, hitMaxTurns: false, reason: "external" };
+                }
+                const result = await this.#lifecycle.result(loopId);
+                if (result === null) {
+                    throw new Error(`terminal loop ${loopId} status ${row.status} has no operation result`);
+                }
+                return { turnIds, result, hitMaxTurns: false, reason: "external" };
             }
+            // Durable disposition outranks a later process-local cancellation observation.
+            // SEND may commit 202 immediately before daemon shutdown aborts this drain; reading
+            // the abort first launders that lawful park into 499 under load. Only a still-running
+            // 102 loop can be cancelled or time out at this boundary.
+            if (timedOut())
+                return await ruleTimeout();
+            signal?.throwIfAborted();
             if (maxTurns >= 0 && turnIds.length >= maxTurns) {
-                // §loop-terminals — the turn ceiling is exhausted: 429 Too Many Requests
-                // (kin to the soft sudden-death 429 warnings that precede it).
-                // {§loop-terminals} — even the EXPECTED ceiling names itself (warn, not error:
-                // the client configured maxTurns; hitting it is a bound, not a malfunction).
-                this.#telemetry.push(workspaceId, loopId, {
-                    source: "engine:rails", kind: "max_turns", level: "warn",
-                    message: `loop ended 429: the configured turn ceiling (${maxTurns}) is exhausted`,
+                const failure = Results.failure("engine:rails", "max-turns", 429, `The configured turn ceiling (${maxTurns}) is exhausted.`, {}, {
+                    maximumTurns: maxTurns,
+                    stage: "loop",
+                    retryable: false,
                 });
-                await this.#lifecycle.finish(loopId, 429, "max_turns");
+                const result = await this.#lifecycle.finish(loopId, failure);
+                if (result === null)
+                    throw new Error(`loop ${loopId} became terminal before max-turn settlement`);
                 cleanup("forceful", "max_turns");
-                return { turnIds, finalStatus: 429, hitMaxTurns: true, reason: "max_turns" };
+                return { turnIds, result, hitMaxTurns: true, reason: "max_turns" };
             }
-            // PLURNK_SERVICE_EXEC_WAIT_MS — a post-EXEC breath: if a spawn from the prior turn
-            // is still in flight, give it a tunable beat to land in THIS turn's packet
-            // before we assemble it. A fixed grace beat, never a wait-for-completion;
-            // 0/unset = off. Abortable with the loop signal.
             const execHandler = this.#schemes.get("exec");
-            // §exec-hold-until-concluded — the turn-hold exception (owner ruling): for runtimes in
-            // the operator's HOLD set (the search family — streams we know and control: one final
-            // JSON digest, seconds-bounded), the cycle PAUSES here until the stream concludes, so
-            // the model never gets a turn it can only waste asking "are we there yet". Bounded by
-            // PLURNK_SERVICE_EXEC_HOLD_MS and FAIL-OPEN: at the cap the standard cycle resumes
-            // (the stream stays live; parks/wakes/polls all still apply). Zero grammar or teaching
-            // change — the model emits EXEC + SEND[102] as ever; the next packet simply contains
-            // the finished digest, open and final.
+            // {§exec-hold-until-concluded} — hold matching runtime/effect
+            // streams until conclusion or the fail-open cap, then resume the
+            // ordinary cycle without altering stream state.
             const holdSet = new Set((process.env.PLURNK_SERVICE_EXEC_HOLD ?? "").split(",").map((x) => x.trim()).filter((x) => x.length > 0));
             const holdCapMs = Number(process.env.PLURNK_SERVICE_EXEC_HOLD_MS ?? "300000");
             if (holdSet.size > 0 && holdCapMs > 0 && execHandler?.hasActiveHoldSpawns !== undefined) {
@@ -532,16 +643,24 @@ export default class Engine {
                     await delay(150, undefined, { signal });
                 }
             }
-            const execWaitMs = Number(process.env.PLURNK_SERVICE_EXEC_WAIT_MS ?? "0");
-            if (execWaitMs > 0) {
-                if (execHandler?.hasActiveSpawns?.(workerId) === true)
-                    await delay(execWaitMs, undefined, { signal });
-            }
             let turn;
+            const releaseWorkspace = await this.#acquireWorkspaceTurn(workspaceId, workerId);
             try {
-                turn = await this.runTurn({
-                    provider, messages, requirements, workspaceId, workerId, loopId, origin, signal, onDispatch,
-                    turnNumber: turnIds.length + 1, maxTurns,
+                turn = await observed(// {§observability-boundary}
+                "loop.turn", { workerId, "loop.id": loopId }, async (span) => {
+                    const t = await this.runTurn({
+                        provider, messages, requirements, workspaceId, workerId, loopId, origin, signal, onDispatch,
+                        turnNumber: turnIds.length + 1, maxTurns,
+                        invalidEmissionRecoveryEntryId,
+                    });
+                    span.setAttribute("turn.id", t.turnId);
+                    return t;
+                });
+                await this.#workspaceTurnCompleted?.({
+                    workspaceId,
+                    workerId,
+                    loopId,
+                    turnId: turn.turnId,
                 });
             }
             catch (err) {
@@ -551,121 +670,162 @@ export default class Engine {
                     return await ruleTimeout();
                 throw err;
             }
+            finally {
+                releaseWorkspace();
+            }
             turnIds.push(turn.turnId);
-            // SPEC §grinder: budget hard-stop — packet won't fit even collapsed → abandon.
-            if (turn.budgetHardStop) {
-                // §loop-terminals — the packet won't fit even collapsed: 413 Content Too Large.
-                // Same silent-terminal class as strike_threshold ({§loop-terminals}, #555): name it.
-                this.#telemetry.push(workspaceId, loopId, {
-                    source: "engine:rails", kind: "budget_overflow", level: "error",
-                    message: `loop abandoned 413: the packet exceeds the budget even after the newest turn folded — unrecoverable overflow after ${turnIds.length} turns`,
+            // {§invalid-emission-attempts} Invalid provider emissions are retried beneath this turn and never
+            // reach the strike rail. The first consecutive exhaustion has already
+            // exposed its bounded lifeline through ordinary next-turn state. A
+            // second exhaustion is terminal; an admitted turn clears the sequence.
+            if (turn.emissionExhausted) {
+                if (invalidEmissionRecoveryEntryId === null) {
+                    if (turn.rejectedModelEntryId === undefined) {
+                        throw new Error("an admitted invalid-emission recovery requires its rejected model-entry identity");
+                    }
+                    invalidEmissionRecoveryEntryId = turn.rejectedModelEntryId;
+                    continue;
+                }
+                const failure = Results.failure("engine:generation", "invalid-emission-exhausted", 500, `No valid PLAN...SEND turn was received after ${turn.emissionAttempts} emission attempts.`, {}, {
+                    attempts: turn.emissionAttempts,
+                    stage: "emission-validation",
+                    retryable: false,
                 });
-                await this.#lifecycle.finish(loopId, 413, "budget_overflow");
+                const result = await this.#lifecycle.finish(loopId, failure);
+                if (result === null)
+                    throw new Error(`loop ${loopId} became terminal before invalid-emission settlement`);
+                cleanup("forceful", "invalid_emission");
+                return { turnIds, result, hitMaxTurns: false, reason: "invalid_emission" };
+            }
+            invalidEmissionRecoveryEntryId = null;
+            // SPEC {§grinder}: budget hard-stop — packet won't fit even collapsed → abandon.
+            if (turn.budgetHardStop) {
+                if (turn.budget === undefined) {
+                    throw new Error("a budget hard-stop requires its measured overflow");
+                }
+                const failure = BudgetOverflow.result(turn.budget.usage, turn.budget.ceiling, false);
+                const result = await this.#lifecycle.finish(loopId, failure);
+                if (result === null)
+                    throw new Error(`loop ${loopId} became terminal before budget settlement`);
                 cleanup("forceful", "budget_overflow");
-                return { turnIds, finalStatus: 413, hitMaxTurns: false, reason: "budget_overflow" };
+                return { turnIds, result, hitMaxTurns: false, reason: "budget_overflow" };
             }
-            // Rails #38/#39 — per-turn strike accounting (cycle detection, the
-            // grinder/steer coupling, hard-failure statuses). StrikeRail owns the
+            // {§engine-rails} — per-turn strike accounting (cycle detection, the
+            // grinder/steer coupling, hard operation outcomes). StrikeRail owns the
             // bookkeeping; runLoop owns abandonment.
             const verdict = this.#strikes.assess(loopId, {
                 fingerprint: turn.fingerprint,
-                statuses: turn.statuses,
-                noOps: turn.status === TURN_STATUS_NO_OPS,
+                outcomes: turn.outcomes,
                 budgetStruck: turn.budgetStruck,
                 steerStruck: turn.steerStruck,
                 minCycles, maxCyclePeriod, maxStrikes,
             });
             if (verdict.thresholdCrossed) {
-                // §loop-terminals — a cycle-driven strike is the model spinning in place
-                // (508 Loop Detected); a failure/no-op strike is the model failing (500
-                // Internal Server Error). The straw that crossed the threshold picks it.
+                // {§engine-rails} — the source on the crossing turn classifies
+                // the engine verdict: cycle-driven is 508; every other strike is 500.
                 const status = verdict.cycleDetected ? 508 : 500;
-                // {§loop-terminals} — the abandonment NAMES ITSELF (#506 promise; run60/#555): a
-                // deliberate strike terminal returns a clean finalStatus, so the drain's loop_error
-                // catch never sees it and the death would be silent on every channel. Emit a legible
-                // error event — live fan-out fires here, BEFORE cleanup deletes the loop's buffer.
-                this.#telemetry.push(workspaceId, loopId, {
-                    source: "engine:rails", kind: "strike_threshold", level: "error",
-                    message: verdict.cycleDetected
-                        ? `loop abandoned ${status}: strike threshold crossed after ${turnIds.length} turns — the model was spinning in place (cycle detected)`
-                        : `loop abandoned ${status}: strike threshold crossed after ${turnIds.length} turns — repeated failed or no-op turns`,
+                const failure = Results.failure("engine:rails", "strike-threshold", status, verdict.cycleDetected
+                    ? `The loop reached its strike threshold after ${turnIds.length} turns because its operation pattern repeated.`
+                    : `The loop reached its strike threshold after ${turnIds.length} turns because consecutive turns failed.`, {}, {
+                    turns: turnIds.length,
+                    stage: "loop",
+                    retryable: false,
                 });
-                await this.#lifecycle.finish(loopId, status, "strike_threshold");
+                const result = await this.#lifecycle.finish(loopId, failure);
+                if (result === null)
+                    throw new Error(`loop ${loopId} became terminal before strike settlement`);
                 cleanup("forceful", "strike_threshold");
-                return { turnIds, finalStatus: status, hitMaxTurns: false, reason: "strike_threshold" };
-            }
-            // Sudden-death threshold is engine-internal — abandonment
-            // happens at maxTurns regardless. Per gamification policy:
-            // we don't warn the model that it's nearing our limit.
-            if (turnIds.length >= suddenDeathThreshold && turnIds.length < maxTurns) {
-                // Threshold tripped; engine bookkeeping only.
+                return { turnIds, result, hitMaxTurns: false, reason: "strike_threshold" };
             }
         }
     }
-    async runTurn({ provider, messages, requirements = "", workspaceId, workerId, loopId, origin = "model", signal, onDispatch, turnNumber = 1, maxTurns = 50, }) {
+    async runTurn({ 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 telemetry events on any turn. The turn is CLOSED at
+        // 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;
-        // #269 — loops.sequence is the loop's ordinal WITHIN the worker. Turn-0 foists that belong to the
-        // RUN (manifest preview, AGENTS, operator docs) gate on the worker's FIRST loop, not every loop's
-        // first turn; per-loop foists (the prompt, @file) still fire each loop. Read once, turn-1 only.
+        // 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 runFirstLoop = (loopRow?.sequence ?? 0) === 1;
+        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;
-        // Pre-model writes. Each turn opens with a system-origin EDIT
-        // against `plurnk://prompt/<run>/<loop>/<seq>` IF there's a prompt
-        // for THIS turn the model hasn't seen yet:
+        // {§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.#loopAborts.get(loopId)?.signal,
+            streamEventNotify: this.#streamEventNotify,
+            wakeWorkerNotify: this.#wakeWorkerNotify,
+            tokenize: this.#tokenize,
+            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.
-        // The log records the EDIT for forensics. Model ops dispatch
-        // from sequence=2 onward on prompt-foisted turns; 1 onward
-        // otherwise.
+        // Model ops dispatch after these pre-model rows.
         let nextActionIndex = 1;
-        // §model-entry — the worker's first turn opens with the model's own turn-0, mirrored OPEN: a
+        const turnOpenPaths = [];
+        // {§model-entry} — the worker's first turn opens with the model's own turn-0, mirrored OPEN: a
         // worked turn PLAN → the environment FINDs the foist ACTUALLY dispatches → SEND[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 as the emission with the foisted results following.
         const turnZeroMoves = [];
         if (seq === 1) {
-            if (runFirstLoop)
+            if (workerFirstLoop)
                 nextActionIndex = 2; // reserve sequence 1 for the turn-0 echo
-            // Operator doc READs (PLURNK_SERVICE_MD_<ALIAS>, §actor-boundary-doc-injection). The docs were materialized
-            // as plurnk:///<entry> entries by the plurnk worker (loop_run, via the
-            // §actor-boundary keystone); foist a READ of each into THIS turn-0 so the model
+            // 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.
-            // #231 — env docs (PLURNK_SERVICE_MD_*) UNION the workspace's client docs; foist a READ of
-            // each materialized plurnk:///<alias>.md (loop_run materialized the same set).
+            // {§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);
-            // #269 — operator docs are run-once; foist them only on the worker's first loop.
-            for (const doc of runFirstLoop ? await WorkspaceSettings.resolveDocs(mdDocs) : []) {
+            // {§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}`, params: {}, fragment: null,
+                    pathname: `/${doc.entryName}`, query: null, fragment: null,
                 };
                 const docRead = {
                     op: "READ", suffix: "", signal: null, target: docTarget,
-                    lineMarker: null, body: null, position: { line: 1, column: 1 },
+                    lineMarker: null, body: null, position: UNKNOWN_POSITION,
                 };
                 await this.dispatch({
                     statement: docRead, workspaceId, workerId, loopId, turnId,
@@ -673,95 +833,72 @@ export default class Engine {
                 });
                 nextActionIndex++;
             }
-            const promptRow = loopRow; // #269 — already read above (per-loop; fires every loop's turn 1)
+            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 promptLoopSeq = promptRow.sequence; // the loop's PER-RUN sequence — model-facing, matching log coordinates (owner: the db id read as prompt/2/1)
-                const promptPath = promptTarget(workerId, promptLoopSeq, seq);
-                const promptStmt = {
-                    op: "EDIT", suffix: "", signal: null,
-                    target: promptPath, lineMarker: null,
-                    body: promptRow.prompt, position: { line: 1, column: 1 },
+                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" } },
+                    tags: [],
+                    attributes: { openPaths },
                 };
-                let promptLogId;
-                await this.dispatch({
-                    statement: promptStmt, workspaceId, workerId, loopId, turnId,
-                    sequence: nextActionIndex, origin: "plurnk",
-                    onDispatch: (id) => { promptLogId = id; onDispatch?.(id); },
-                });
-                // §prompt-fold: the prompt EDIT's row is folded — the body reaches the model
-                // through the auto-READ below; the EDIT stays forensic, re-OPENable.
-                if (promptLogId !== undefined)
-                    await this.#db.engine_fold_log_entry.run({ id: promptLogId });
-                nextActionIndex++;
-                // §prompt-auto-read (owner): the prompt's body reaches the model as a foisted
-                // READ of its own entry — first 12 lines (<1,12>), or the whole prompt (<1,-1>)
-                // when it runs fewer than 12 (whole-read form doubles as teaching). Prior prompts
-                // stay listed by path in the system packet's User Prompts section — reachable,
-                // never silently lost.
-                // §arrival-law (#499) — the preview bound is the knob (was a hardcoded 12). The
-                // line-slice is an EFFICIENCY (do not materialize hundreds of lines into rx); the
-                // RENDER is the law — packet-wire's arrival preview cuts the char dimension there,
-                // which a line marker structurally cannot (a 1-line slice of a 1-line bomb is 416).
-                const previewLines = Number(process.env.PLURNK_SERVICE_ARRIVAL_PREVIEW_LINES ?? "16");
-                const promptLineCount = promptRow.prompt.split("\n").length;
-                const promptRead = {
-                    op: "READ", suffix: "", signal: null, target: promptPath,
-                    lineMarker: { marks: promptLineCount >= previewLines ? [1, previewLines] : [1, -1] },
-                    body: null, position: { line: 1, column: 1 },
-                };
-                await this.dispatch({
-                    statement: promptRead, workspaceId, workerId, loopId, turnId,
-                    sequence: nextActionIndex, origin: "plurnk", onDispatch,
+                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-auto-read, the mid-loop half + {§prompt-loop-containment}: the loop CONTAINS
-        // every prompt that arrived while it ran — this boundary foists an auto-READ for each
-        // frame not yet delivered (no prior auto-READ in the loop), oldest first, so rapid
-        // arrivals reach the model together, none lost, each exactly once.
-        if (seq > 1) {
+        // {§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 undelivered = (await this.#db.drain_undelivered_prompts_for_loop.all({ owner_id: workerId, pattern: `${promptLoopPrefix(loopSeq)}%`, loop_id: 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 lineCount = injectedRow.content.split("\n").length;
+                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(workerId, loopSeq, ordinal);
-                const injRead = {
-                    op: "READ", suffix: "", signal: null, target: injTarget,
-                    lineMarker: { marks: lineCount >= 12 ? [1, 12] : [1, -1] },
-                    body: null, position: { line: 1, column: 1 },
-                };
-                await this.dispatch({
-                    statement: injRead, workspaceId, workerId, loopId, turnId,
-                    sequence: nextActionIndex, origin: "plurnk", onDispatch,
+                const injTarget = promptTarget(loopSeq, ordinal);
+                const promptLogId = await this.#writePromptLog({
+                    workerId,
+                    loopId,
+                    turnId,
+                    sequence: nextActionIndex,
+                    target: injTarget,
+                    content: injectedRow.content,
                 });
+                onDispatch?.(promptLogId);
                 nextActionIndex++;
             }
         }
-        // The per-turn derivation pump (_entry-manifest.maintainDerivations) — refreshes
-        // every entry's deep channels (symbols/refs/embeddings/FTS, deep_hash-gated) so the
-        // catalog and FIND read current data. NOT an action: no log entry, no sequence slot,
-        // not dispatched. There is no plurnk:///manifest.json entry — the catalog is served
-        // on demand by FIND(scheme:///**), foisted into the worker's first turn below.
-        // #312 — the turn's token gauge: the ACTIVE provider's tokenizer identity + exact counter
-        // (mimetypes seam; provider upper bound surfaced as tokenizer_unavailable when inexact).
-        // Threaded per turn — never engine state — so concurrent loops on different providers
-        // each read their own honest numbers.
-        const systemCtx = {
-            db: this.#db, workspaceId, workerId, loopId, turnId,
-            writer: "plurnk",
-            signal: this.#loopAborts.get(loopId)?.signal,
-            streamEventNotify: this.#streamEventNotify,
-            wakeWorkerNotify: this.#wakeWorkerNotify,
-            tokenize: this.#tokenize,
-            mimetypes: this.#mimetypes,
-            defaultChannelFor: (s) => this.#schemes.defaultChannelFor(s),
-            pushTelemetry: (event) => this.#telemetry.push(workspaceId, loopId, event),
-        };
-        // SPEC §membership D4/D5 — git-ls-files workspace membership, resolved at
+        // 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
@@ -774,431 +911,618 @@ export default class Engine {
         // 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);
-        await this.#logFsFictions(workspaceId, fsDivergences);
+        // {§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.#loopAborts.get(loopId)?.signal);
+        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.#queueWorkspaceWarm(systemCtx, true, false);
-        // Turn-0 catalog preview (PLURNK_SERVICE_FILES_ITEMS, §actor-boundary-catalog-preview):
-        // one FIND(scheme:///**) per scheme that holds entries, foisted into the worker's first
-        // model turn so it opens with its catalog (the per-scheme arrays that replaced the
-        // single manifest.json). -1 → each scheme's whole catalog; N → its first N rows
-        // (clamped to the scheme's count so FIND's strict <L> never 416s); off by default.
+        // Turn-0 catalog preview (PLURNK_SERVICE_FILES_ITEMS, {§actor-boundary-catalog-preview}):
+        // FIND surveys foisted into the worker's first model turn so it opens with its catalog.
+        // Folder-capable surfaces reveal one level with `*`; each deeper directory is an
+        // actionable `dir/**` aggregate. The curated kernel docs remain recursive, so the
+        // opening packet demonstrates both navigation forms. Empty results are orientation.
         if (seq === 1) {
-            // #231 — a workspace's client-chosen filesItems REPLACES the env default outright.
+            // {§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 && runFirstLoop) { // #269 — catalog preview is run-once
-                // engine_scheme_catalog_summary is the scheme source: workspace-scoped, ordered,
-                // one row per scheme that has entries (scheme=null → file). log:// is absent —
+            if (filesItems !== null && workerFirstLoop) { // {§actor-boundary-catalog-preview} — once per worker
+                // engine_scheme_catalog_summary is the workspace-bounded scheme source: ordered,
+                // one row per stored entry scheme. log:// is absent —
                 // it lives in log_entries, not the catalog (present-mode, the # Log section).
                 const catalogSchemes = await this.#db.engine_scheme_catalog_summary.all({ workspace_id: workspaceId });
-                // known:/// + unknown:/// + file ALWAYS foist, even at zero entries — else the
-                // model burns a turn running the FIND itself, assuming the catalog is merely
-                // being withheld. An empty FIND(**) is orienting, not noise (owner): it tells
-                // the model NOT to look there. Other schemes keep the with-entries default.
-                const foistSchemes = [...catalogSchemes].filter((c) => c.scheme !== "prompt" && c.scheme !== "worker");
-                // The COMMONS (worker:///**) + the file tree always foist — even at zero entries the
-                // empty survey is orienting ("don't look here"), per the #527 re-home of the old
-                // known/unknown always-foist role onto the shared blackboard.
-                foistSchemes.push({ scheme: "worker", entries: catalogSchemes.find((c) => c.scheme === "worker")?.entries ?? 0 });
+                // Entry-bearing plugin schemes foist alongside the four structural surveys below.
+                const foistSchemes = catalogSchemes
+                    .filter((catalog) => catalog.scheme !== "prompt" && catalog.scheme !== "worker")
+                    .map(({ scheme, shallow_items }) => ({ scheme, shallow_items }));
+                // Commons + project files always foist. An empty result establishes that the
+                // surface exists and currently contains nothing.
+                foistSchemes.push({
+                    scheme: "worker",
+                    shallow_items: catalogSchemes.find((c) => c.scheme === "worker")?.shallow_items ?? 0,
+                });
                 if (!foistSchemes.some((c) => c.scheme === "file"))
-                    foistSchemes.push({ scheme: "file", entries: 0 }); // {§entry-identity-no-null} — file rows persist under the reserved scheme now; a null key would double-foist the tree
-                for (const { scheme, entries } of foistSchemes) {
-                    const schemeName = scheme ?? "file";
-                    const isFile = schemeName === "file";
-                    // Only the FILE list is cappable (PLURNK_SERVICE_FILES_ITEMS first-N): the tracked-file
-                    // tree is external and arbitrarily large. Every other scheme — known/unknown
-                    // (memory), run (scratch), plurnk (docs) — foists FULL, never truncated: a partial
-                    // view of the model's own memory reads as withheld. file at -1, or any non-file
-                    // scheme → no cap. (file in this loop always has entries>0, so no degenerate <1,0>.)
-                    const cap = isFile && filesItems > 0 ? Math.min(filesItems, entries) : null;
+                    foistSchemes.push({ scheme: "file", shallow_items: 0 }); // Empty project surface still receives its orienting FIND.
+                for (const { scheme, shallow_items: shallowItems } of foistSchemes) {
+                    const isFile = scheme === "file";
+                    const pattern = this.#schemes.manifestFor(scheme)?.folderScopes === true ? "*" : "**";
+                    // Only the file map takes PLURNK_SERVICE_FILES_ITEMS as an explicit first-N
+                    // cap. Every other ordinary survey uses FIND's markerless first page.
+                    const cap = isFile && filesItems > 0 && shallowItems > 0 ? Math.min(filesItems, shallowItems) : null;
+                    const catalogMarker = cap === null ? null : { marks: [1, cap] };
                     // The file survey foists as the BARE relative glob — the path shape plurnk.md
-                    // teaches (`src/**`, `**/notes.md`; bare = project-relative) — so the turn-0
+                    // teaches (`*`, `src/**`, `**/notes.md`; bare = project-relative) — so the turn-0
                     // exemplar and the log rows the model reads never train a leading-slash or
                     // file:/// habit the rest of the teaching contradicts.
                     const catalogFind = {
                         op: "FIND", suffix: "", signal: null,
-                        target: isFile ? { kind: "local", raw: "**" } : {
+                        target: isFile ? { kind: "local", raw: pattern } : {
                             kind: "url",
-                            raw: `${schemeName}:///**`,
-                            scheme: schemeName,
+                            raw: `${scheme}:///${pattern}`,
+                            scheme,
                             username: null, password: null, hostname: null, port: null,
-                            pathname: "/**",
-                            params: {}, fragment: null,
+                            pathname: `/${pattern}`,
+                            query: null, fragment: null,
                         },
                         body: null,
-                        lineMarker: cap === null ? null : { marks: [1, cap] },
-                        position: { line: 1, column: 1 },
+                        lineMarker: catalogMarker,
+                        position: UNKNOWN_POSITION,
                     };
                     await this.dispatch({
                         statement: catalogFind, workspaceId, workerId, loopId, turnId,
                         sequence: nextActionIndex, origin: "plurnk", onDispatch,
                     });
                     nextActionIndex++;
-                    // §model-entry — the same FIND, rendered back to DSL for the turn-0 echo (the model's
-                    // own survey, mirrored OPEN). The <L> cap rides as `<1,N>`, exactly as the model would type it.
-                    turnZeroMoves.push(`<<FIND(${isFile ? "**" : `${schemeName}:///**`})${cap === null ? "" : `<1,${cap}>`}::FIND`);
+                    // {§model-entry} — the same FIND, rendered back to DSL for the turn-0 echo
+                    // (the model's own survey, mirrored OPEN). An explicit file cap rides as
+                    // `<1,N>`; ordinary surveys teach the safe markerless default by example.
+                    const target = isFile ? pattern : `${scheme}:///${pattern}`;
+                    turnZeroMoves.push(`<<FIND(${target})${cap === null ? "" : `<1,${cap}>`}::FIND`);
                 }
                 // The kernel's self-documenting surface — FIND(worker://plurnk/docs/**), uncapped,
-                // always (the law materializes the docs): the #270 discovery foist, re-homed (#527).
+                // always ({§schemes-directory}, published under {§entry-owner}).
                 await Owner.kernelId(this.#db, workspaceId); // the row exists even before docs materialize — the empty survey is orienting, never 404
                 const kernelDocsFind = {
                     op: "FIND", suffix: "", signal: null,
-                    target: { kind: "url", raw: "worker://plurnk/docs/**", scheme: "worker", username: null, password: null, hostname: "plurnk", port: null, pathname: "/docs/**", params: {}, fragment: null },
-                    body: null, lineMarker: null, position: { line: 1, column: 1 },
+                    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,
                 };
                 await this.dispatch({ statement: kernelDocsFind, workspaceId, workerId, loopId, turnId, sequence: nextActionIndex, origin: "plurnk", onDispatch });
                 nextActionIndex++;
-                turnZeroMoves.push("<<FIND(worker://plurnk/docs/**)::FIND");
-                // §worker-scheme — Manifest(run) = workspace-scope ∪ THIS worker's worker-scope. Foist the
-                // building worker's OWN scratch (worker://self/**, uncapped — a worker needs the full view to
-                // manage its private workspace) so it's catalogued in ITS perspective alone; other
-                // runs reach it only via explicit FIND(worker://<name>/**). A worker with no scratch foists nothing.
-                const scratch = (await this.#db.engine_worker_scratch_count.get({ workspace_id: workspaceId, owner_id: workerId }))?.entries ?? 0;
-                if (scratch > 0) {
-                    const runFind = {
-                        op: "FIND", suffix: "", signal: null,
-                        target: { kind: "url", raw: "worker://~/**", scheme: "worker", username: null, password: null, hostname: "~", port: null, pathname: "/**", params: {}, fragment: null },
-                        body: null, lineMarker: null, position: { line: 1, column: 1 },
-                    };
-                    await this.dispatch({ statement: runFind, workspaceId, workerId, loopId, turnId, sequence: nextActionIndex, origin: "plurnk", onDispatch });
-                    nextActionIndex++;
-                    turnZeroMoves.push("<<FIND(worker://~/**)::FIND"); // §model-entry — the own-space survey, into the turn-0 echo
-                }
-            }
-            // #260 — foist a turn-0 READ of each client-passed @file path so its content sits in front
-            // of the model. Daemon owns the workspace → a normal file:/// member READ; a missing or
-            // non-member path surfaces its READ outcome (4xx) in the log, visible to the model.
-            const openPathsRow = await this.#db.engine_get_loop_open_paths.get({ loop_id: loopId });
-            for (const raw of JSON.parse(openPathsRow?.open_paths ?? "[]")) {
-                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, params: {}, fragment: null,
-                    },
-                    body: null, position: { line: 1, column: 1 },
+                turnZeroMoves.push("<<FIND(worker://plurnk/docs/**)<1,-1>::FIND");
+                // {§worker-scheme} — the building worker's own scratch gets the same markerless
+                // one-level survey in its perspective alone. It always executes: an empty private
+                // space is useful orientation, not grounds to hide the surface.
+                const ownFind = {
+                    op: "FIND", suffix: "", signal: null,
+                    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,
                 };
-                await this.dispatch({
-                    statement: fileRead, workspaceId, workerId, loopId, turnId,
-                    sequence: nextActionIndex, origin: "plurnk", onDispatch,
-                });
+                await this.dispatch({ statement: ownFind, workspaceId, workerId, loopId, turnId, sequence: nextActionIndex, origin: "plurnk", onDispatch });
                 nextActionIndex++;
+                turnZeroMoves.push("<<FIND(worker://~/*)::FIND"); // {§model-entry} — the own-space survey, into the turn-0 echo
             }
-            // §model-entry — mirror the model's turn-0 OPEN at sequence 1: PLAN → the FINDs actually
+            // {§model-entry} — mirror the model's turn-0 OPEN at sequence 1: PLAN → the FINDs actually
             // foisted above (real, their results already in the log) → SEND[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. Subsequent turns mirror the model's real output, folded.
-            if (runFirstLoop) {
-                const emission = ["<<PLAN:Initialize:PLAN", ...turnZeroMoves, "<<SEND[102]:Initialized:SEND"].join("\n");
+            if (workerFirstLoop) {
+                const emission = ["<<PLAN:Survey context, then address the prompt.:PLAN", ...turnZeroMoves, "<<SEND[102]:Next, address the prompt using the survey.:SEND"].join("\n");
                 await this.#dispatcher.writeModelEntry({ verbatim: emission, workerId, loopId, turnId, sequence: 1, folded: false, origin: "plurnk" });
             }
         }
-        // §env-delta — pre-seed the worker's ambient observations (what changed since
-        // it last looked) as foisted rows before the packet composes; advance the action index
-        // past them so model ops continue after. Two instances of one machine: env-delta (sibling
-        // edits · timestamp cursor · always folded) and exec streams (channel bytes · byte cursor ·
-        // terminal delta opens). §env-delta §exec-stream
-        // §exec-poll — EXEC `<0>` is turn-scoped: reap the worker's open turn-scoped streams (necessarily
+        // {§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 });
-        // SPEC §telemetry — git working-tree state for the telemetry section, read once
-        // (a service-side `git status` shell-out) and threaded into the budget
-        // rebuild too so it isn't re-shelled on overflow.
-        const gitStatus = await GitState.status(this.#db, workspaceId, this.#loopAborts.get(loopId)?.signal);
-        // Build the spec'd packet (Packet.json) request half. The log build
+        // 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 requestPacket = await this.#packets.buildRequestPacket({
             initialMessages: messages, requirements, workspaceId, workerId, loopId,
-            currentTurnSeq: seq, provider, gitStatus,
+            currentTurnSeq: seq, provider, gitStatus, notices, transientOpenLogEntryId,
         });
-        // SPEC §grinder — budget grinder, pre-LLM: reclaim window on actual overflow.
+        // SPEC {§grinder} — budget grinder, pre-LLM: reclaim window on actual overflow.
         const enforced = await this.#packets.enforceBudget({
             packet: requestPacket, provider, workerId, loopId, turnId,
             // The overflow error row is minted at the turn's running sequence (nextActionIndex), pre-generate;
             // runTurn advances the counter past it below so the post-generate dispatch rows never collide.
             mintSequence: nextActionIndex,
-            // No preset telemetry — the rebuild RE-DERIVES the errors section from log≥400 so the
-            // overflow row just minted surfaces THIS turn (§grinder-overflow-error-row). Safe: the
-            // ephemeral buffer is empty pre-generate (events drain on the next turn's build).
+            // Rebuilds re-derive durable errors and retain the one drained notice
+            // set; neither path can duplicate or swallow a product failure.
             rebuild: () => this.#packets.buildRequestPacket({
                 initialMessages: messages, requirements, workspaceId, workerId, loopId,
-                currentTurnSeq: seq, provider, gitStatus,
+                currentTurnSeq: seq, provider, gitStatus, notices, transientOpenLogEntryId,
             }),
         });
-        if (enforced.struck)
-            nextActionIndex += 1; // the budget-overflow error row consumed a sequence
+        if (enforced.recorded)
+            nextActionIndex += 1; // a fold-to-fit Problem consumed the reserved sequence
         requestPacket = enforced.packet;
         if (!enforced.fit) {
-            // §grinder-hard-413-recovery (Q4, owner ruling: recoverable strike, NO margin) — the
-            // overflow lives in foldable HISTORY the model owns, and the grinder won't touch
-            // history (§grinder-layer1-rollback doctrine). So the first hard overflow is a
-            // RECOVERY TURN, not death: the packet is over the POLICY ceiling but usually well
-            // within PHYSICS (the jumbo pin: ceiling 13k, real window 49k) — send it once, with a
-            // minted steer naming the remedy, and a strike (budgetStruck). The model curates →
-            // next turn fits → the grant clears. It declines → the second consecutive hard
-            // overflow terminates 413 — death only after the model was told. Physically
-            // unsendable (over the provider's real window too) → 413 immediately; physics
-            // doesn't negotiate. The pointer stays at 100% of budget — a margin would mask it.
-            const physicallySendable = provider.contextWindow === null
-                ? true
-                : this.#packets.exactPacketTokens(requestPacket, provider) <= provider.contextWindow - (this.#packets.maxTokensFor(provider) ?? 0);
-            if (physicallySendable && !this.#hardOverflowRecovery.has(loopId)) {
-                this.#hardOverflowRecovery.add(loopId);
-                await this.#db.engine_insert_log_entry.get({
-                    worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: nextActionIndex++,
-                    origin: "model", source: "engine", op: "error", suffix: "", signal: null,
-                    scheme: null, username: null, password: null, hostname: null, port: null,
-                    pathname: null, params: null, fragment: null, lineMarker: null,
-                    tx: "", mimetype_tx: "text/plain",
-                    rx: JSON.stringify({ status: 413, kind: "budget_overflow", message: "the packet exceeds the budget even after the newest turn folded — this is your ONE recovery turn: KILL or FOLD history items now (the budget table lists the heaviest) to reclaim room; a second consecutive overflow terminates the loop" }),
-                    mimetype_rx: "application/json", status_rx: 413, tokens: 0, state: "failed", outcome: "budget_overflow",
-                    attrs: "{}",
+            // {§grinder-hard-413-recovery}/{§grinder-hard-413-abort} — admit
+            // one physically sendable informed recovery turn; a physical
+            // overflow or consecutive policy overflow terminates immediately.
+            let physicalAdmission = await this.#packets.physicalAdmission(requestPacket, provider, this.#loopAborts.get(loopId)?.signal);
+            let recoveryAdmitted = false;
+            if (physicalAdmission.admitted && !this.#hardOverflowRecovery.has(loopId)) {
+                const ceiling = this.#packets.ceilingFor(provider);
+                if (ceiling === null) {
+                    throw new Error("an unbounded prompt budget cannot enter budget recovery");
+                }
+                await this.#problems.record({
+                    workerId,
+                    loopId,
+                    turnId,
+                    sequence: nextActionIndex++,
+                    origin: "model",
+                    source: "engine",
+                    result: BudgetOverflow.result(requestPacket.tokens, ceiling, true),
                 });
                 // Rebuild so the recovery-steer row just minted renders in THIS packet's log +
                 // errors sections (the same re-derive contract the soft grind uses).
-                nextActionIndex += 1;
                 requestPacket = await this.#packets.buildRequestPacket({
                     initialMessages: messages, requirements, workspaceId, workerId, loopId,
-                    currentTurnSeq: seq, provider, gitStatus,
+                    currentTurnSeq: seq, provider, gitStatus, notices, transientOpenLogEntryId,
                 });
+                physicalAdmission = await this.#packets.physicalAdmission(requestPacket, provider, this.#loopAborts.get(loopId)?.signal);
+                if (physicalAdmission.admitted) {
+                    this.#hardOverflowRecovery.add(loopId);
+                    recoveryAdmitted = true;
+                }
             }
-            else {
-                // Hard 413: physically unsendable, or the model already declined its recovery turn.
+            if (!recoveryAdmitted) {
+                // Hard 413: physically unsendable, or still over after the informed recovery turn.
+                const ceiling = this.#packets.ceilingFor(provider);
+                if (ceiling === null) {
+                    throw new Error("an unbounded prompt budget cannot hard-stop");
+                }
+                if (!enforced.recorded || !physicalAdmission.admitted) {
+                    await this.#problems.record({
+                        workerId,
+                        loopId,
+                        turnId,
+                        sequence: nextActionIndex++,
+                        origin: "plurnk",
+                        source: "engine",
+                        result: BudgetOverflow.result(requestPacket.tokens, ceiling, false, physicalAdmission.admitted
+                            ? undefined
+                            : {
+                                reason: physicalAdmission.reason,
+                                detail: physicalAdmission.detail,
+                                capacity: physicalAdmission.capacity,
+                                tokens: physicalAdmission.measurement?.tokens,
+                                tokenKind: physicalAdmission.measurement?.kind,
+                                tokenSource: physicalAdmission.measurement?.source,
+                            }),
+                    });
+                    requestPacket = await this.#packets.buildRequestPacket({
+                        initialMessages: messages, requirements, workspaceId, workerId, loopId,
+                        currentTurnSeq: seq, provider, gitStatus, notices, transientOpenLogEntryId,
+                    });
+                }
                 // Skip the LLM, close the turn, and let runLoop abandon.
-                const hardPacket = this.#packets.completePacket(requestPacket, { content: "", ops: [], reasoning: null }, null, provider);
                 await this.#db.engine_close_turn.run({
-                    id: turnId, status: 413, packet: JSON.stringify(hardPacket),
-                    usage_prompt: 0, usage_completion: 0, usage_reasoning: 0, usage_cached: 0, usage_cost_usd: 0,
-                    usage_prompt_budget: this.#packets.promptBudgetFor(provider), // #274 — the PROMPT BUDGET (window − reserves), even on a hard-413 turn: the gauge denominator the packet actually lives under
+                    id: turnId, status: 413, packet: StoredPacket.stringify(requestPacket),
+                    // The attempted turn retains its effective allowance even
+                    // when no provider exchange completed. {§tokenomics-client-gauge}
+                    usage_prompt_budget: this.#packets.promptBudgetFor(provider),
                     finish_reason: "budget_hard_stop", model: provider.model, meta: "{}",
                 });
-                return { turnId, status: 413, statuses: [], fingerprint: "", budgetStruck: enforced.struck, budgetHardStop: true, steerStruck: false };
+                return {
+                    turnId,
+                    status: 413,
+                    outcomes: [],
+                    fingerprint: "",
+                    budgetStruck: enforced.struck,
+                    budgetHardStop: true,
+                    steerStruck: false,
+                    emissionAttempts: 0,
+                    emissionExhausted: false,
+                    budget: BudgetOverflow.measure(requestPacket.tokens, ceiling),
+                };
             }
         }
         else {
-            // A fitting turn clears the recovery grant — the model curated; a later overflow
-            // earns a fresh recovery turn (chronic overflow still strikes out via the rail).
+            // A fitting turn clears the recovery grant; a later independent overflow can earn
+            // a fresh recovery turn (chronic overflow still strikes out via the rail).
             this.#hardOverflowRecovery.delete(loopId);
         }
         const modelMessages = PacketWire.packetToWireMessages(requestPacket);
-        // No decode cap. Our budget governs the TRANSMISSION packet (the grinder folds
-        // the input under the ceiling); the model's decode — reasoning + emission — is
-        // out of band, owned by the provider's own context window. Deriving a maxTokens
-        // from our budget conflated the two and guillotined a reasoning model's
-        // out-of-band reasoning as the packet filled (`ceiling - packet` → near-zero
-        // decode → finish=length mid-reasoning → no emission → strike spiral). The
-        // provider enforces its physical wall on its own.
+        // Packet pressure and provider generation are independent. The grinder governs
+        // only the request packet; maxTokens comes only from the provider envelope and
+        // never shrinks as the virtual prompt budget fills.
         let response;
+        let splitResponse;
         let railGrammar;
-        // #249 — plugin attribution tags onto the per-turn generate() wire. Value is the
-        // active-plugin set (placeholder); real per-turn grounding is deferred.
-        const attributions = [...new Set([...this.#schemes.attributions(), ...(this.#executors?.attributions() ?? [])])].toSorted();
-        // #249 — tag the loop (the activity) with its active plugins' attribution tags, write-once.
-        if (attributions.length > 0)
-            await this.#db.engine_tag_loop_attributions.run({ loop_id: loopId, attributions: JSON.stringify(attributions) });
-        // #249 — workspace-stable frontend id, forwarded as Plurnk-Client by the plurnk provider only.
+        let railEvidence;
+        let emissionAttempts = 0;
+        let providerCallInFlight = false;
+        let providerAttemptSequence = 0;
+        let providerAttemptId = null;
+        let providerAttemptAttributions = [];
+        const providerSignal = this.#loopAborts.get(loopId)?.signal ?? signal;
+        // {§client-metadata}
         const { client } = await WorkspaceSettings.read(this.#db, workspaceId);
+        const observeProviderAttempt = async (id, attemptResponse) => {
+            const attemptUsage = attemptResponse.assistant.usage;
+            await this.#db.engine_observe_turn_attempt_response.run({
+                id,
+                response: JSON.stringify(attemptResponse),
+                usage_prompt: attemptUsage.prompt,
+                usage_completion: attemptUsage.completion,
+                usage_reasoning: attemptUsage.reasoning,
+                usage_cached: attemptUsage.cached,
+                usage_cost: JSON.stringify({
+                    kind: "unknown",
+                    reason: "provider response retained before monetary classification",
+                }),
+                finish_reason: attemptResponse.assistant.finishReason,
+                model: attemptResponse.assistant.model,
+            });
+        };
+        const classifyProviderAttempt = async (id, attemptResponse, attemptSplit, sequence, accepted, failure = null) => {
+            const attemptUsage = attemptSplit.callMetadata.usage;
+            const attemptCost = providerCostFor(provider, attemptUsage, attemptResponse.charge);
+            const attemptCostUsd = providerCostUsd(attemptCost);
+            await this.#db.engine_classify_turn_attempt_response.run({
+                id,
+                accepted: accepted ? 1 : 0,
+                parse_errors: JSON.stringify(attemptSplit.parseErrors),
+                failure: failure === null ? null : JSON.stringify(failure),
+                usage_cost: JSON.stringify(attemptCost),
+                usage_cost_usd: attemptCostUsd,
+            });
+            emissionAttempts = sequence;
+        };
         try {
-            // §turn-lifecycle (#301) — the provider call is the long, opaque window (submit → first
-            // committed op is provider latency + a full first-turn generation, ~70s local): a static
-            // screen there is indistinguishable from a hang. Bracket generate() with two telemetry beats
-            // so a client can show "awaiting model" the instant the turn starts and flip to "parsing" when
-            // ops are about to land. Base telemetry/event channel (the embed_progress precedent, §tokenomics
-            // clients already render it unconditionally); the abort guard keeps a cancelled loop silent.
+            // {§turn-lifecycle}: bracket the complete provider-attempt window with liveness notices.
             if (!signal?.aborted)
-                this.#telemetry.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_awaiting_model", level: "info", message: "awaiting model response" });
-            // generate rides the LOOP signal (already chained from the caller's), so a loop-level
-            // abort — the §operator-config-loop-timeout wall — cancels a stuck provider call, not
-            // just the schemes. Bare runTurn (no runLoop) has no loop entry → the caller's signal.
-            // #391 — the turn COORDINATE (workspace + loop-seq/turn-seq of the turn being generated)
-            // rides as first-party metadata (Plurnk-Workspace-Id/Loop/Turn) so the endpoint flywheel keys
-            // on an AUTHORITATIVE hierarchy, not a scraped context-log approximation. The daemon owns
-            // the value; providers stamps the header (same split as Worker-Id, #26). loopSeq (the 1-based
-            // coordinate, not the DB id) resolves the same way the prompt-slot path does (§log coords).
+                this.#notices.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_awaiting_model", level: "info", message: "awaiting model response" });
             const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
             railGrammar = await this.#grammarConstraint(provider);
-            response = await provider.generate({ messages: modelMessages, workerId: String(workerId), primaryWorkerId: String(await this.resolveWorkerPrimary(workerId)), signal: this.#loopAborts.get(loopId)?.signal ?? signal, grammar: railGrammar, maxTokens: this.#packets.maxTokensFor(provider) ?? undefined, strikes: this.#strikes.streak(loopId), attributions: attributions.length > 0 ? attributions : undefined, client: client ?? undefined, workspaceId: String(workspaceId), loop: loopSeq, turn: seq }); // strikes: first-party routing signal, 0 sent explicitly (#313) // §provider-surface-generate §provider-guarantees-single-call §provider-guarantees-signal-wired §attribution-plurnk-namespace-reserved §client-telemetry
+            const primaryWorkerId = String(await this.resolveWorkerPrimary(workerId));
+            const attemptLimit = readEmissionAttempts();
+            const maxTokens = this.#packets.maxTokensFor(provider) ?? undefined;
+            const strikeStreak = this.#strikes.streak(loopId);
+            for (let attempt = 1; attempt <= attemptLimit; attempt++) {
+                // Every attempt carries the exact same model packet, coordinates,
+                // limits, and engine-strike state. Plugin-authored tags are pulled
+                // for the attempt and do not alter the model messages. No failed
+                // emission is appended and no new engine turn opens between calls.
+                providerAttemptSequence = attempt;
+                const attributionContext = Object.freeze({
+                    workspaceId: String(workspaceId),
+                    workerId: String(workerId),
+                    primaryWorkerId,
+                    loop: loopSeq,
+                    turn: seq,
+                    attempt,
+                });
+                providerAttemptAttributions = await this.#attemptAttributions(provider, attributionContext);
+                requestPacket = { ...requestPacket, attributions: providerAttemptAttributions };
+                const attemptRow = await this.#db.engine_open_turn_attempt.get({
+                    turn_id: turnId,
+                    sequence: attempt,
+                    attributions: JSON.stringify(providerAttemptAttributions),
+                    model: provider.model,
+                });
+                if (attemptRow === undefined) {
+                    throw new Error(`Engine.runTurn: provider attempt ${attempt} did not open`);
+                }
+                providerAttemptId = attemptRow.id;
+                providerCallInFlight = true;
+                const completedResponse = await observed(// {§observability-boundary}
+                "provider.generate", { model: provider.model, attempt }, async (span) => {
+                    const generated = await provider.generate({
+                        messages: modelMessages,
+                        workerId: String(workerId),
+                        primaryWorkerId,
+                        signal: providerSignal,
+                        grammar: railGrammar,
+                        maxTokens,
+                        strikes: strikeStreak,
+                        attributions: providerAttemptAttributions.length > 0
+                            ? providerAttemptAttributions
+                            : undefined,
+                        client: client ?? undefined,
+                        workspaceId: String(workspaceId),
+                        loop: loopSeq,
+                        turn: seq,
+                    }); // {§provider-surface-generate} {§provider-guarantees-signal-wired} {§provider-guarantees-serial-attempts} {§attribution} {§client-metadata}
+                    providerCallInFlight = false;
+                    recordCounter(PROVIDER_CALLS, {
+                        model: provider.model,
+                        attempt,
+                        status: "resolved",
+                    });
+                    span.setAttribute("status", "resolved");
+                    return generated;
+                });
+                response = completedResponse;
+                await observeProviderAttempt(attemptRow.id, completedResponse);
+                railEvidence = railGrammar === undefined
+                    ? undefined
+                    : Engine.#requireGrammarEvidence(completedResponse);
+                splitResponse = this.#splitResponse(completedResponse);
+                await classifyProviderAttempt(attemptRow.id, completedResponse, splitResponse, attempt, splitResponse.emissionValid);
+                if (splitResponse.emissionValid)
+                    break;
+            }
             if (!signal?.aborted)
-                this.#telemetry.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_generated", level: "info", message: "parsing model response" });
+                this.#notices.push(workspaceId, loopId, { source: "engine:turn", kind: "turn_generated", level: "info", message: "parsing model response" });
         }
         catch (err) {
-            // §turn-never-blank — a ProviderError is an INFRASTRUCTURE failure (auth, network
-            // beyond retries, rate limit): no completed exchange exists, so no turn exists —
-            // telemetry the cause and DIE legibly (the drain writes the loop terminal 500 with
-            // the message). Grammar conformance never arrives here: providers 0.32 retired the
-            // constrained-path throw — a completed exchange ALWAYS returns, bytes in assistant,
-            // the conformance verdict riding response.telemetry as an OBSERVATION (the engine's
-            // ANTLR parse is the judge; the provider transports and observes, never adjudicates).
-            // The old fallback fabricated an empty emission here and laundered a provider
-            // adjudication into a model-behavior 422 — a state the system otherwise forbids,
-            // a record that lied, and days of forensics pointed at the wrong suspect.
-            if (err instanceof ProviderError) {
-                this.#telemetry.push(workspaceId, loopId, { source: "provider", kind: err.kind, message: err.message, level: "error" });
+            // This handler owns only provider-call failures. Parser, cost, SQL,
+            // and engine-contract failures retain their original source.
+            if (!providerCallInFlight)
+                throw err;
+            providerCallInFlight = false;
+            if (providerAttemptId === null) {
+                throw new Error("provider call failed without a durable attempt identity", { cause: err });
+            }
+            const failure = err instanceof ProviderError
+                ? { status: err.problem.status, problem: err.problem }
+                : providerSignal?.aborted === true
+                    ? Results.failure("engine:provider", providerSignal.reason === LOOP_TIMEOUT_REASON ? "provider-call-timeout" : "provider-call-cancelled", providerSignal.reason === LOOP_TIMEOUT_REASON ? 504 : 499, providerSignal.reason === LOOP_TIMEOUT_REASON
+                        ? "The provider call was interrupted by the loop deadline."
+                        : "The provider call was interrupted by loop cancellation.", {}, { stage: "provider-request", retryable: false })
+                    : (() => {
+                        console.error("Provider failed outside its Problem Details contract:", err);
+                        return Results.failure("engine:provider", "provider-contract-violation", 502, "The provider failed without returning its required Problem Details.", {}, {
+                            stage: "provider-request",
+                            retryable: false,
+                        });
+                    })();
+            // {§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 observeProviderAttempt(providerAttemptId, response);
+                splitResponse = this.#splitResponse(response);
+                await classifyProviderAttempt(providerAttemptId, response, splitResponse, providerAttemptSequence, false, failure);
+            }
+            else {
+                const unknownCost = {
+                    kind: "unknown",
+                    reason: "provider call failed without response-bearing charge evidence",
+                };
+                await this.#db.engine_fail_turn_attempt.run({
+                    id: providerAttemptId,
+                    failure: JSON.stringify(failure),
+                    usage_cost: JSON.stringify(unknownCost),
+                });
+                emissionAttempts = providerAttemptSequence;
+            }
+            // {§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_prompt_budget: this.#packets.promptBudgetFor(provider),
+                    finish_reason: splitResponse?.callMetadata.finishReason ?? null,
+                    model: splitResponse?.callMetadata.model ?? provider.model,
+                    meta: JSON.stringify(response?.meta ?? {}),
+                });
+                throw err;
             }
-            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_prompt_budget: this.#packets.promptBudgetFor(provider),
+                finish_reason: splitResponse?.callMetadata.finishReason ?? null,
+                model: splitResponse?.callMetadata.model ?? provider.model,
+                meta: JSON.stringify(response?.meta ?? {}),
+            });
+            throw new OperationFailureError(recorded.result, { cause: err });
         }
-        // Engine splits wire-level response: emission (content, reasoning,
-        // parsed ops) → packet.assistant per Packet.json assistant section;
-        // call-metadata (usage, finishReason, model) → Turn columns per
-        // Turn.json. Mixing the two on packet.assistant was the wrong layer.
-        const { packetAssistant, callMetadata, parseErrors } = this.#splitResponse(response); // raw assistant content is opaque — split, never interpreted — §provider-guarantees-assistantraw-opaque
-        // Surface parse errors to the model's NEXT packet so it can self-
-        // correct. Without this, malformed emissions (e.g. a READ matcher
-        // body starting with `//` being interpreted as xpath) silently
-        // drop, the model sees zero ops dispatched, strike-rail fires,
-        // model has no feedback on WHY its emission didn't take effect.
-        //
-        // Envelope per @plurnk/plurnk-grammar 0.17.0 TelemetryEvent:
-        //   { source, kind, message, position: { type: "content-offset", line, column } }
-        // Plus a `snippet` field (additionalProperties) carrying ±N lines
-        // of the assistant's own content around the error line. Without
-        // the snippet, the model sees "invalid xpath at 1:0" but can't
-        // connect that to what IT wrote — and tends to regenerate the
-        // same broken emission. See edit-todo demo for the canonical case.
-        // Parse errors are LOG ITEMS now (§telemetry — one budget surface): each failed-to-parse
-        // emission records an actionless `error` row below, after the turn's dispatched ops are
-        // sequenced (see the parse-error log write past the dispatch loop). The errors section
-        // derives a pointer to it from log≥400, uniform with action_failure.
-        // providers#24 / #275: non-fatal provider telemetry on a SUCCESSFUL turn. In GBNF-filter
-        // mode the provider no longer THROWS grammar_unenforced — it returns the model's bytes
-        // (here, packetAssistant.content) and attaches the conflict as a telemetry event carrying
-        // the divergence code-point position. Forward each event with a content-offset `line:col`;
-        // the model resolves it against its own emission — READ the folded `model` mirror row at the
-        // cited lines (§model-entry) — not an embedded snippet that would duplicate the emission.
-        for (const event of response.telemetry ?? []) {
-            const located = typeof event.position === "number"
-                ? this.#offsetToLineColumn(packetAssistant.content, event.position)
+        if (response === undefined || splitResponse === undefined) {
+            throw new Error("provider attempt loop completed without a response");
+        }
+        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,
+                    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_prompt_budget: this.#packets.promptBudgetFor(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: "",
+                budgetStruck: enforced.struck,
+                budgetHardStop: 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.#telemetry.push(workspaceId, loopId, {
-                source: event.source,
-                kind: event.kind,
-                message: event.message ?? "",
-                level: event.level ?? "warn", // forward the producer's severity; default for a producer predating the field
+            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 } }
                     : {}),
             });
         }
-        // {§rail-truth-engine-verdict} (#534) — a configured local GBNF constraint is
-        // independently graded by the engine. Endpoint-owned constraints arrive only
-        // through provider metadata; absence of local configuration says nothing about them.
+        // 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");
             let verdict = null;
             try {
-                verdict = validateGbnf(railGrammar, packetAssistant.content);
+                verdict = validateGbnf(railGrammar, railEvidence.input);
             }
             catch (cause) {
                 Engine.#warnRailVerdictGapOnce(cause.message);
             }
-            railKeys = { railsAttached: "client", railsVerdict: verdict?.status ?? "unverifiable" };
-            const providerGraded = (response.telemetry ?? []).some((e) => e.kind === "grammar_unenforced");
-            if (verdict !== null && verdict.status !== "accept" && !providerGraded) {
-                const located = this.#offsetToLineColumn(packetAssistant.content, verdict.pos);
-                this.#telemetry.push(workspaceId, loopId, {
+            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 code point ${verdict.pos}`
-                        : `emission is an incomplete grammar sentence (ends mid-match at ${verdict.pos})`,
+                        ? `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",
-                    position: { type: "content-offset", line: located.line, column: located.column },
+                    ...(located === null
+                        ? {}
+                        : { position: { type: "content-offset", line: located.line, column: located.column } }),
                 });
             }
         }
         const opsCount = packetAssistant.ops.length;
-        // PLAN (reasoning) and informational SEND[103] are no-ops, not actions: both are
-        // excluded from the real-op count so a PLAN-only or prose-only turn still strikes
-        // as no-ops, and the terminal scan ignores 1xx so they never set turnStatus.
-        const realOpsCount = packetAssistant.ops.filter((op) => op.op !== "PLAN" && !(op.op === "SEND" && op.signal === 103 && op.target === null)).length;
-        const sendOp = packetAssistant.ops.findLast((op) => op.op === "SEND" && typeof op.signal === "number" && op.signal >= 200);
-        // §send the terminal contract — two engine error states verify a terminal claim against run
-        // state, never trusting the model's code. Both strike via turn.steerStruck (turnErrors,
-        // §grinder-strike-coupling): the loop continues, the model sees the steering hint not the strike
+        const finalOp = packetAssistant.ops.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");
+        }
+        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");
+        }
+        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 steerStruck = false;
         // Engine errors raised this turn, minted as op='error' log rows after dispatch (they share the
-        // post-dispatch sequence counter). §telemetry-uniform-error-channel
+        // post-dispatch sequence counter). {§operation-result-uniform-error-channel}
         const pendingEngineErrors = [];
-        // Terminal adjudication moved to the DISPATCHER (§send-premature-terminate, the unified
+        // 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 terminal (409) strikes via the dispatch-loop check below.
-        // Rail #41 (revised): the per-turn requirement is "emit at least one op," not "emit a terminal
-        // SEND." SEND is purely a signal verb; many turns pass without one. An empty op list strikes.
-        // Provisional here — a terminal REFUSED at dispatch (the pending-set 409, only knowable
-        // post-dispatch) demotes the turn back to a continue below: the SEND's signal stays on the
-        // row (the un-erased record), but the loop never went terminal, so the turn didn't either.
-        // §broken-packet-no-dispatch (#566) — a BROKEN PACKET is structurally incomplete: the
-        // provider GUILLOTINED the emission at the completion cap (finish=length) and it failed the
-        // parse (empty, or cut mid-op). Its parsed "ops" are a severed frame — garbage (run42: an
-        // unclosed `<<PLAN` swallowed a 57k-char runaway into one bogus status-200 PLAN). Nothing
-        // dispatches and the turn is a NO-OPS strike, so a repeated runaway can't spin as a 102
-        // "continue". The turn still records — the folded `model` mirror + the output_truncated 413 +
-        // the parse-error rows — so the model sees WHY next turn and re-emits through the existing
-        // error channel (no same-turn re-generate). A "flubbed op" is DIFFERENT: a well-framed turn
-        // (finish=stop) whose single op erred dispatches its valid ops and steers on the bad one (the
-        // recovery rail); only a severed FRAME is refused wholesale. The formal framing-vs-op-local
-        // error split is grammar's to tag.
-        const brokenPacket = callMetadata.finishReason === "length"
-            && (packetAssistant.content.trim().length === 0 || (parseErrors?.length ?? 0) > 0);
-        let turnStatus = brokenPacket
-            ? TURN_STATUS_NO_OPS
-            : sendOp !== undefined
-                ? sendOp.signal
-                : realOpsCount === 0 ? TURN_STATUS_NO_OPS : TURN_STATUS_IMPLICIT_CONTINUE;
+        // 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. (Skipped when premature already steered this turn.)
-        // #467 (owner criterion) — a turn whose op ATTEMPTS died at the parser is a FAILED-RETRIEVAL
-        // turn, not an idle one: the model performed an op; the op died. The root parse-400 speaks
-        // alone; stacking the idle-409 on it calls the turn something it factually wasn't (run65's
-        // one malformed FIND minted two error rows for one accident). A dispatched-but-failed op is
-        // already a mid op, so only the parse-emptied class needs the deference. GBNF makes the
-        // emitted-idle shape unemittable (grammar SPEC, no-idle-102); this 409 stays the truly-idle backstop.
-        const midOpsCount = packetAssistant.ops.filter((op) => op.op !== "PLAN" && op.op !== "SEND").length;
-        if (!steerStruck && turnStatus === TURN_STATUS_IMPLICIT_CONTINUE && midOpsCount === 0 && parseErrors.length === 0) {
-            // One grace turn after a retrieval-only 409 (admins specimen): the refusal steer says
-            // "continuing in order to receive results" — a model that obediently waits one bare
-            // [102] turn is following OUR advice, and the idle rail was executing it for that.
-            // The grace is exactly one turn; a second consecutive idle strikes as ever.
-            if (this.#retrievalRefusalGrace.delete(loopId)) {
-                // graced — the wait the steer asked for
-            }
-            else {
-                steerStruck = true;
-                pendingEngineErrors.push("idle_turn");
-            }
-        }
-        else {
-            this.#retrievalRefusalGrace.delete(loopId); // a working turn consumes any pending grace
+        // The model continued with nothing to do.
+        const midOpsCount = packetAssistant.ops.filter((op) => op.op !== "PLAN" && op.op !== "SEND").length
+            + recoverableParseErrors.length;
+        if (!steerStruck && turnStatus === TURN_STATUS_IMPLICIT_CONTINUE && midOpsCount === 0) {
+            steerStruck = true;
+            pendingEngineErrors.push("idle_turn");
         }
         // Close the turn with the final packet, status, and usage stats.
-        const packet = this.#packets.completePacket(requestPacket, packetAssistant, response.assistantRaw, provider);
-        const { usage, finishReason, model } = callMetadata;
+        const packet = StoredPacket.admit(requestPacket, packetAssistant, response.assistantRaw);
         await this.#db.engine_close_turn.run({
             id: turnId,
             status: turnStatus,
-            packet: JSON.stringify(packet),
-            usage_prompt: usage.prompt,
-            usage_completion: usage.completion,
-            usage_reasoning: usage.reasoning,
-            usage_cached: usage.cached,
-            usage_cost_usd: provider.calculateCost(usage), // §provider-surface-calculate-cost
-            usage_prompt_budget: this.#packets.promptBudgetFor(provider), // #274 — the PROMPT BUDGET (window − reserves): the raw n_ctx overstated usable room by the reserve total
-            finish_reason: finishReason,
-            model,
-            // #252 — opaque provider→client metadata passthrough (for example, the
-            // provider normalized), plus the ONE service-authored carve-out: the engine's rail
-            // keys ({§rail-truth-engine-verdict}) merge over any transitional provider railsMeta.
+            packet: StoredPacket.stringify(packet),
+            usage_prompt_budget: this.#packets.promptBudgetFor(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
@@ -1208,149 +1532,179 @@ export default class Engine {
         // 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 telemetry signal next packet.
-        // #232 — a workspace's maxCommands is a tighten-only ceiling: min() the env ceiling.
+        // 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 (reasoning) and a terminal SEND (signal ≥ 200, the conclusion) 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 conclusion
+        // 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.
-        // §broken-packet-no-dispatch (#566) — the severed frame dispatches NOTHING (rationale +
-        // status handling at the brokenPacket definition above).
         let realCommands = 0;
-        const admittedOps = brokenPacket ? [] : packetAssistant.ops.filter((op) => op.op === "PLAN"
-            || (op.op === "SEND" && typeof op.signal === "number" && op.signal >= 200)
-            || realCommands++ < maxCommands);
+        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,
-            turnParseErrors: parseErrors?.length ?? 0,
         });
-        // A broken packet's ops aren't max_commands drops — they're refused wholesale, and the
-        // output_truncated 413 already tells the model why; don't also mint max_commands_exceeded.
-        const droppedCount = brokenPacket ? 0 : opsCount - opsToDispatch.length;
-        const statuses = [];
+        const droppedCount = opsCount - opsToDispatch.length;
+        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 parseErrorsRecorded = false;
+        const recordRecoverableParseErrors = async () => {
+            if (parseErrorsRecorded)
+                return;
+            parseErrorsRecorded = true;
+            for (const error of recoverableParseErrors) {
+                const recorded = await this.#problems.record({
+                    workerId,
+                    loopId,
+                    turnId,
+                    sequence: rowSeq++,
+                    origin: "model",
+                    source: "grammar",
+                    result: Results.failure("grammar:parser", "invalid-operation-syntax", 400, error.message, {}, {
+                        line: error.line,
+                        column: error.column,
+                        source: error.source,
+                        stage: "parse",
+                        recovery: "Correct only the failed operation; sibling operations were retained.",
+                        retryable: false,
+                    }),
+                });
+                outcomes.push({ op: null, status: recorded.result.status });
+                onDispatch?.(recorded.id);
+            }
+        };
         for (const statement of opsToDispatch) {
-            const result = await this.#dispatcher.dispatch({
-                statement, workspaceId, workerId, loopId, turnId,
-                sequence: rowSeq,
-                origin, onDispatch,
-                // §send-200-failed-ops — parse errors mint as rows AFTER this loop; the terminal
-                // gate needs them NOW, so the count rides the dispatch context.
-                turnParseErrors: parseErrors?.length ?? 0,
+            if (statement.op === "SEND"
+                && typeof statement.signal === "number"
+                && TERMINAL_SEND_SIGNALS.has(statement.signal)) {
+                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);
+            }
+            const result = await observed(// {§observability-boundary}
+            "op.dispatch", { op: statement.op }, async (span) => {
+                const dispatchResult = await this.#dispatcher.dispatch({
+                    statement, workspaceId, workerId, loopId, turnId,
+                    sequence: rowSeq,
+                    origin, onDispatch,
+                });
+                span.setAttribute("status", dispatchResult.status);
+                recordCounter(OPS_DISPATCHED, { op: statement.op, status: dispatchResult.status });
+                return dispatchResult;
             });
-            statuses.push(result.status);
-            // A refused terminal (the pending-set 409) demotes the turn to a continue: the loop
-            // never went terminal, so the turn didn't either (the close persisted the provisional
-            // status BEFORE dispatch — run20's T3 stored 200 with a 409-refused SEND). Whether it
-            // ALSO strikes is kind-specific (owner ruling): a retrievals-only refusal teaches
-            // without striking — atomic-turn-pretrained models pair fetch-and-answer by habit,
-            // the refusal is correct each time, and maxTurns bounds the walk; striking executed
-            // converging behavior (jumbo/admins specimens: 3 correct refusals → 500 mid-adapt).
-            // Streams/children refusals keep the strike — discarding live work stays serious.
+            outcomes.push({ op: statement.op, status: result.status });
+            for (const normalization of result.scopeNormalizations ?? []) {
+                this.#notices.push(workspaceId, loopId, {
+                    source: "engine:slicer",
+                    kind: "scope_normalized",
+                    level: "warn",
+                    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) {
-                if (result.attrs?.retrievalOnly !== true)
-                    steerStruck = true;
-                else
-                    this.#retrievalRefusalGrace.add(loopId); // the steer says "continuing to receive" — the NEXT turn's obedient wait must not idle-strike
+                steerStruck = true;
                 turnStatus = TURN_STATUS_IMPLICIT_CONTINUE;
-                await this.#db.engine_demote_turn_status.run({ id: turnId, status: turnStatus });
+                await this.#db.engine_reconcile_turn_status.run({ id: turnId, status: turnStatus });
             }
-            // A [300] question resolves through the proposal system (#346) — whatever the
+            // {§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_demote_turn_status.run({ id: turnId, status: turnStatus });
+                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;
         }
-        // §telemetry-uniform-error-channel — every engine + parse failure mints as an op='error'
-        // log row at the turn's next free sequence (after every dispatched row, incl. a multi-file
-        // READ's fan-out). One channel: the errors section derives a LogCoordinate pointer from log≥400.
+        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)
-            await this.#telemetry.mintEngineError(kind, { workerId, loopId, turnId, sequence: errSeq++ });
-        // §log-row-self-explains (Q2, owner-clarified) — a model-op failure is the MODEL'S OWN op
-        // result: the op row carries its failure message on its meta line (packet-wire), and the
-        // errors section points at the row. No separate minted item (the retired action_failure
-        // mint dressed op results as source:"engine" faults — the jumbo model chased a phantom
-        // "engine run 400 error" off a message-less item). Genuine engine-internal faults CRASH
-        // (fail-hard, §turn-never-blank) and never mint model-facing rows.
-        // §tokenomics-output-truncated — packet honesty at the completion cap: a finish=length turn was
-        // GUILLOTINED at the decode pool, and this actionless row MINTS to LEAD the artifact rows it
-        // explains (the cause must lead, or the model fixes syntax forever). Two shapes, honestly
-        // distinguished: content cut MID-OP (a valid prefix dispatched; the parse errors are the
-        // severed tail) vs the pool consumed with NOTHING emitted (reasoning ran away — the parse
-        // 'must begin with PLAN' is an artifact of the empty emission, not a malformed turn). The parse
-        // rows below STAY (the record never hides); the 413 leads and frames them for what they are.
-        const truncatedEmpty = finishReason === "length" && packetAssistant.content.trim().length === 0;
-        if (finishReason === "length" && (truncatedEmpty || (parseErrors?.length ?? 0) > 0)) {
-            const cap = this.#packets.maxTokensFor(provider);
-            const message = truncatedEmpty
-                ? `output truncated at the completion cap (${cap} tokens): nothing was emitted before the pool was consumed — the parse error below is an artifact of the empty emission, not a malformed turn`
-                : `output truncated at the completion cap (${cap} tokens): the emission was cut mid-op — the parse errors below are truncation artifacts`;
-            await this.#db.engine_insert_log_entry.get({
-                worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: errSeq++,
-                origin: "model", source: "engine", op: "error", suffix: "", signal: null,
-                scheme: null, username: null, password: null, hostname: null, port: null,
-                pathname: null, params: null, fragment: null, lineMarker: null,
-                tx: "", mimetype_tx: "text/plain",
-                rx: JSON.stringify({ status: 413, kind: "output_truncated", message }),
-                mimetype_rx: "application/json", status_rx: 413, tokens: 0, state: "failed", outcome: "output_truncated",
-                attrs: "{}",
-            });
-        }
-        // Parse errors carry the parser message + a content-offset line:col (a ContentOffset position),
-        // resolved against the model's folded mirror row (§model-entry) — origin 'model', not engine.
-        for (const { message, line, column, source } of parseErrors ?? []) {
-            await this.#db.engine_insert_log_entry.get({
-                worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: errSeq++,
-                origin: "model", source: "grammar", op: "error", suffix: "", signal: null,
-                scheme: null, username: null, password: null, hostname: null, port: null,
-                pathname: null, params: null, fragment: null, lineMarker: null,
-                tx: "", mimetype_tx: "text/plain",
-                // The error carries the parser message + a content-offset `line:col`; the model READs
-                // its own folded mirror row (§model-entry) at the cited lines, so no snippet is
-                // embedded. The derived errors-section pointer stays minimal (status + coordinate).
-                rx: JSON.stringify({ message, position: { type: "content-offset", line, column }, parserSource: source }),
-                mimetype_rx: "application/json",
-                status_rx: 400, tokens: 0, state: "resolved", outcome: null, attrs: "{}",
+        for (const kind of pendingEngineErrors) {
+            const problem = ENGINE_PROBLEMS[kind];
+            const extensions = kind === "max_commands_exceeded"
+                ? {
+                    operationLimit: maxCommands,
+                    omittedOperations: droppedCount,
+                    stage: "dispatch-admission",
+                    recovery: "Continue with no more than the configured operation limit.",
+                    retryable: false,
+                }
+                : {
+                    stage: "turn",
+                    recovery: "Perform an operation before continuing with SEND[102].",
+                    retryable: false,
+                };
+            await this.#problems.record({
+                workerId,
+                loopId,
+                turnId,
+                sequence: errSeq++,
+                origin: "plurnk",
+                source: "rail",
+                result: Results.failure("engine:rail", problem.code, problem.status, problem.detail, {}, extensions),
             });
         }
-        // §model-entry — mirror this turn's verbatim emission back as a `model` row, so the NEXT
+        // {§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). An error's line:col resolves the same way anything
-        // else does: the model that cares READs the folded row at the lines it wants — and can
-        // introspect any prior emission of its own the same way. Empty emissions (a struck/
-        // silent turn) write nothing — no prior output to mirror.
-        const sealed = response.assistant.reasoningEncrypted;
-        // #482 — relay the FULL item ARRAY verbatim (agui projects one correlated span per item), so a
-        // multi-id turn serves N entities, not a collapsed first. Providers already expose the array.
-        const reasoningItems = sealed !== undefined && sealed.length > 0 ? sealed : undefined;
+        // 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, workerId, loopId, turnId, sequence: errSeq++, folded: true, ...(reasoningItems !== undefined ? { reasoningItems } : {}) });
         }
-        // Zero ops is NOT an error to report — the model knows it emitted
-        // nothing. Strike accounting (engine-internal) treats it as a
-        // struck turn; the model just sees an empty packet next turn.
-        // Per SPEC §telemetry gamification policy.
-        return { turnId, status: turnStatus, statuses, fingerprint: StrikeRail.fingerprintTurn(packetAssistant.ops), budgetStruck: enforced.struck, budgetHardStop: false, steerStruck };
+        return {
+            turnId,
+            status: turnStatus,
+            outcomes,
+            fingerprint: StrikeRail.fingerprintTurn(packetAssistant.ops),
+            budgetStruck: enforced.struck,
+            budgetHardStop: false,
+            steerStruck,
+            emissionAttempts,
+            emissionExhausted: false,
+        };
     }
     // Split the wire-level ProviderResponse into the two destinations:
     // packet.assistant gets the model's emission (content, ops, reasoning);
     // Turn columns get the call-metadata (usage, finishReason, model).
-    // SPEC §provider-surface / plurnk-providers#1: text-fragment scraping policy lives
+    // {§provider-surface} Text-fragment scraping policy lives
     // here — engine owns the parse and the scraping rule, providers stay
     // grammar-unaware.
     //
@@ -1363,29 +1717,48 @@ export default class Engine {
         const preParsedOps = assistant.ops;
         const ops = [];
         // PLAN is an ordinary op — emitted by the model, dispatched, and passed to the
-        // client as a log entry. No special hoisting into the reasoning field (that
-        // legacy paradigm is abandoned). Interstitial free text is DROPPED — the prior
-        // #free-text-capture synthesis of SEND[103] log ops was retired as tech debt
-        // (grammar 0.70 forbids free text between ops, so a prose-only turn strikes 422).
-        // Full PlurnkParseError context (line/column/source) is preserved
-        // here so runTurn can build TelemetryEvent envelopes per the
-        // grammar 0.17.0 protocol — model needs position info to locate
-        // its own offending content on the next turn.
+        // client as a log entry. No special hoisting into the reasoning field. Only
+        // structured operations are executable; interstitial text is not an operation.
+        // Full PlurnkParseError context is preserved on rejected attempt evidence;
+        // warnings remain admissible Notices. {§parse-diagnostics}
         const parseErrors = [];
+        let hasUnparsedTail = false;
+        const parseNotices = [];
         if (preParsedOps !== undefined) {
             ops.push(...preParsedOps);
         }
         else {
-            const parsed = PlurnkParser.parse(assistant.content);
+            // {§observability-boundary} — the parse is observed without its input;
+            // only the resulting statement count is attributable.
+            const parsed = observedSync("contracts.parse", {}, (span) => {
+                const result = PlurnkParser.parse(assistant.content);
+                span.setAttribute("statements", result.items.filter((item) => item.kind === "statement").length);
+                return result;
+            });
             for (const item of parsed.items) {
                 if (item.kind === "statement") {
                     ops.push(item.statement);
                 }
-                // Free text (kind "text") is dropped — #free-text-capture retired (above).
                 else if (item.kind === "error") {
                     const err = item.error;
                     if (err instanceof PlurnkParseError) {
-                        parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source });
+                        if (err.severity === "warning") {
+                            parseNotices.push({
+                                source: "grammar",
+                                kind: "parse_advisory",
+                                level: "warn",
+                                message: err.message,
+                                position: {
+                                    type: "content-offset",
+                                    line: err.line,
+                                    column: err.column,
+                                },
+                                parserSource: err.source,
+                            });
+                        }
+                        else {
+                            parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source });
+                        }
                     }
                     else {
                         const msg = err?.message ?? "parse error";
@@ -1393,72 +1766,117 @@ export default class Engine {
                     }
                 }
             }
-            // The grammar also reports an `unparsedTail` when input ends
-            // mid-statement (a body opened but never closed): its `reason`
-            // names the op AND the fix ("…never closed — add `:READ`"), where
-            // the item-level error only says "expected close tag" for a tag the
-            // model thinks it already wrote. Surface it — phenomenal messages
-            // the model can self-correct from are the whole point of the DSL.
+            // Boundary loss is the parser's one public fact from `unparsedTail.from` onward;
+            // preserve it with the rejected forensic attempt. {§unparsed-tail-boundary}
             const tail = parsed.unparsedTail;
             if (tail !== undefined) {
+                hasUnparsedTail = true;
                 parseErrors.push({ message: tail.reason, line: tail.from.line, column: tail.from.column, source: "grammar" });
             }
         }
+        const plan = ops[0]?.op === "PLAN" ? ops[0] : undefined;
+        const finalOp = ops.at(-1);
+        const terminalSend = finalOp?.op === "SEND"
+            && typeof finalOp.signal === "number"
+            && TERMINAL_SEND_SIGNALS.has(finalOp.signal)
+            ? finalOp
+            : undefined;
+        const recoverableParseErrors = plan !== undefined && terminalSend !== undefined && !hasUnparsedTail
+            ? parseErrors.filter((error) => comparePosition(error, plan.position) > 0
+                && comparePosition(error, terminalSend.position) < 0).toSorted(comparePosition)
+            : [];
+        const emissionValid = preParsedOps !== undefined
+            || (plan !== undefined
+                && terminalSend !== undefined
+                && !hasUnparsedTail
+                && recoverableParseErrors.length === parseErrors.length);
         const reasoning = assistant.reasoning ?? null;
         return {
             packetAssistant: { content: assistant.content, ops, reasoning },
             callMetadata: { usage: assistant.usage, finishReason: assistant.finishReason, model: assistant.model },
             parseErrors,
+            recoverableParseErrors: emissionValid ? recoverableParseErrors : [],
+            parseNotices,
+            // The ANTLR model-turn parser is authoritative. A trustworthy
+            // PLAN...SEND frame admits bounded interior statement failures so
+            // they become durable operation results. Missing boundaries,
+            // errors outside the frame, and an unparsed tail reject wholesale.
+            // Pre-parsed ops are Mock's trusted test seam.
+            emissionValid,
         };
     }
     // #note12 — the plugin-provided reference docs (schemes' + execs' `documentation`),
-    // materialized at plurnk:///docs/<name>.md by loop_run (like operator docs).
+    // materialized at worker://plurnk/docs/<name>.md by LoopDocs (like operator docs).
     docEntries(workspaceId) {
         return this.#packets.docEntries(workspaceId);
     }
-    // §env-delta (§actor-boundary-no-mutex: runs share without locks; a conflict surfaces as a delta, never prevented) — at pre-turn build, surface what changed in the shared world since this
-    // run last looked. No per-worker snapshot (§machine-processes "a worker is its log"): every
-    // edit is already a span-carrying log row, so PULL other actors' EDITs on shared
-    // entries since this worker's prior turn — real cross-worker edits and the plurnk worker's
-    // fs-sync fictions — and materialize each as a FOLDED delta reusing the row's span +
-    // cause. Returns the count so the caller advances nextActionIndex past the deltas.
+    // {§env-delta-log-pull} — materialize one closed interval of the ambient
+    // occurrence journal into this worker's self-contained log. #67 owns only
+    // the remaining model-facing actor-name projection.
     async #materializeEnvironmentDeltas(args) {
         const { workspaceId, workerId, loopId, turnId, fromSequence } = args;
-        const boundary = await this.#db.engine_worker_prior_turn_time.get({ worker_id: workerId, turn_id: turnId });
-        const since = boundary?.since ?? null;
-        if (since === null)
-            return 0; // first turn — nothing prior; the model reads current state fresh
-        const rows = await this.#db.engine_pull_env_deltas.all({ workspace_id: workspaceId, worker_id: workerId, since });
+        const rows = await this.#db.engine_pull_ambient_events.all({ workspace_id: workspaceId, worker_id: workerId });
+        const window = rows[0];
+        if (window === undefined)
+            throw new Error(`ambient pull: worker ${workerId} has no observation window`);
         let written = 0;
         for (const r of rows) {
-            // source: the originating run (a real cross-worker edit) or 'file' (an fs fiction);
-            // rx reuses the originating row's result span — the edit as it looked then.
-            await this.#db.engine_insert_env_delta.run({
-                worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: fromSequence + written,
-                source: r.source ?? String(r.worker_id), scheme: r.scheme, pathname: r.pathname, rx: r.rx, attrs: r.attrs,
-            });
-            written++;
-        }
-        // §worker-scheme — loop-terminations: a sibling's loop reaching terminal surfaces the
-        // same way an entry-change does, carrying its deliverable (the SEND body) or the
-        // abandonment reason. Folded, attributed to the terminated run.
-        const terms = await this.#db.engine_pull_loop_terminations.all({ workspace_id: workspaceId, worker_id: workerId, since });
-        for (const t of terms) {
-            await this.#db.engine_insert_loop_termination_delta.run({
+            if (r.event_id === null || r.producer_worker_id === null || r.producer_worker_name === null || r.kind === null
+                || r.op === null || r.status_rx === null)
+                continue;
+            const termination = r.kind === "loop_termination";
+            if (r.rx === null)
+                throw new Error(`ambient event ${r.event_id} has no materializable result`);
+            const terminal = termination
+                ? TerminalResult.parse(r.rx, `ambient loop-termination event ${r.event_id}`)
+                : null;
+            if (terminal !== null && terminal.status !== r.status_rx) {
+                throw new Error(`ambient loop-termination event ${r.event_id} status ${r.status_rx} does not match its terminal result status ${terminal.status}`);
+            }
+            let attrs = r.attrs ?? "{}";
+            if (terminal !== null) {
+                const inherited = JSON.parse(attrs);
+                if (inherited === null || typeof inherited !== "object" || Array.isArray(inherited)) {
+                    throw new TypeError(`ambient loop-termination event ${r.event_id} attrs must be an object`);
+                }
+                const receipt = await BranchReceipt.render(this.#db, r.producer_worker_id);
+                attrs = JSON.stringify({
+                    ...inherited,
+                    kind: "loop_termination",
+                    ...(r.terminated_by === null ? {} : { terminatedBy: r.terminated_by }),
+                    ...(receipt === null ? {} : { receipt }),
+                });
+            }
+            const inserted = await this.#db.engine_insert_ambient_delta.get({
                 worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: fromSequence + written,
-                source: String(t.worker_id), pathname: `/${t.worker_name}`,
-                rx: markTerminal(t.terminated_by, t.terminal_message) ?? `loop "${t.prompt}" ended (${t.status})`,
-                status: t.status,
+                event_id: r.event_id,
+                source: r.source ?? WorkerControlAddress.render(r.producer_worker_name),
+                op: r.op,
+                scheme: r.scheme,
+                hostname: r.hostname,
+                pathname: r.pathname,
+                rx: r.rx,
+                mimetype_rx: "application/json",
+                status: r.status_rx,
+                expanded: terminal !== null && terminal.status >= 200 && terminal.status < 300 ? 1 : 0,
+                attrs,
             });
-            written++;
+            if (inserted !== undefined)
+                written++;
         }
+        await this.#db.engine_advance_ambient_cursor.get({
+            workspace_id: workspaceId,
+            worker_id: workerId,
+            cursor: window.cursor,
+            boundary: window.boundary,
+        });
         return written;
     }
-    // §exec-poll — EXEC `<0>` is turn-scoped: abort the worker's open turn-scoped streams via their
+    // {§exec-poll} — EXEC `<0>` is turn-scoped: abort the worker's open turn-scoped streams via their
     // owning scheme (the same registry-routed abort the total reap uses). Called at each pre-turn
     // before the turn's own spawns, so every open turn-scoped sub here is from a prior turn — it
     // never survives into the subsequent turn. Fire-and-forget: the spawn finalizes async and its
-    // terminal output surfaces born-OPEN through the stream-delta path (§exec-stream).
+    // terminal output surfaces born-OPEN through the stream-delta path ({§exec-stream}).
     async #reapTurnScopedStreams(workerId) {
         const open = await this.#db.find_open_turn_scoped_subscriptions_for_worker.all({ worker_id: workerId });
         await Promise.all(open.map(({ id }) => this.#liveSubscriptions.cancel(id)));
@@ -1466,11 +1884,11 @@ export default class Engine {
     cancelSubscription(subscriptionId) {
         return this.#liveSubscriptions.cancel(subscriptionId);
     }
-    // §env-delta — exec streams as an instance of the ambient-observe machine:
-    // each turn, emit each owned channel's unshown byte-delta as a foisted READ@200 row. Folded
-    // while the channel streams; the terminal delta (channel closed) auto-OPENs. The cursor is the
-    // streamEnd recorded on the channel's prior delta — no exec-specific surfacing, just the
-    // env-observe loop with a byte cursor where env-delta uses a timestamp. §exec-stream
+    // {§env-delta} — exec streams as an instance of the ambient-observe machine:
+    // each turn, emit each owned channel's next publishable content as a foisted READ row. It is
+    // 200 while the channel streams and preserves the exact terminal result when closed. Ongoing
+    // observations fold; the terminal observation auto-OPENs. The cursor is the streamEnd recorded
+    // on the channel's prior observation. {§exec-stream}
     async #materializeStreamDeltas(args) {
         const { workerId, loopId, turnId, fromSequence } = args;
         const channels = await this.#db.engine_worker_stream_channels.all({ worker_id: workerId });
@@ -1490,26 +1908,60 @@ export default class Engine {
             const priorAttrs = prior !== undefined ? JSON.parse(prior.attrs) : {};
             const cursor = priorAttrs.streamEnd ?? 0;
             const closed = ch.state === "closed" || ch.state === "errored";
-            if (ch.content.length <= cursor) {
-                // The cursor-terminal race (owner's dogfood find): a channel written in one final
+            const terminal = closed
+                ? Results.assert(JSON.parse(ch.close_result ?? "null"))
+                : null;
+            const terminalResult = async (fields, sequence) => {
+                if (terminal === null)
+                    throw new Error(`closed subscription ${ch.subscription_id} has no terminal result`);
+                const result = Results.assert({
+                    ...terminal,
+                    ...(terminal.problem === undefined ? {} : { problem: { ...terminal.problem } }),
+                    ...fields,
+                });
+                if (result.problem !== undefined) {
+                    const seqs = await this.#db.engine_loop_turn_seqs.get({
+                        loop_id: loopId,
+                        turn_id: turnId,
+                    });
+                    if (seqs === undefined)
+                        throw new Error(`stream delta has no log coordinate for loop=${loopId} turn=${turnId}`);
+                    Results.attachInstance(result, `log:///${seqs.loop_seq}/${seqs.turn_seq}/${sequence}/READ`);
+                }
+                return result;
+            };
+            const publishEnd = streamPublicationEnd(ch.content, ch.mimetype, cursor, closed);
+            if (publishEnd <= cursor) {
+                // The cursor-terminal race: a channel written in one final
                 // burst gets fully shown FOLDED while still active; the close then has zero new
-                // bytes and the auto-OPEN terminal delta never fired — the model was never shown
+                // 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 stream produced zero bytes: completion is
-                // information independently of payload. Emit the terminal marker ONCE: open,
-                // terse, carrying the close status (§tokenomics-fetch-fits-free).
+                // 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.
                 if (closed && priorAttrs.terminal !== true) {
+                    const streamTarget = renderTarget({
+                        scheme: ch.runtime,
+                        pathname: ch.coord,
+                        fragment: visibleFragment,
+                    });
+                    if (streamTarget === null)
+                        throw new Error(`stream ${ch.subscription_id} has no renderable address`);
                     const pointer = cursor > 0
-                        ? `full output already delivered above; READ ${ch.runtime}://${ch.coord}${visibleFragment === null ? "" : `#${visibleFragment}`} to revisit`
+                        ? `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} ]`
+                        : "";
                     await this.#db.engine_insert_stream_delta.run({
-                        worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: fromSequence + written,
+                        worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence,
                         scheme: ch.runtime, pathname: ch.coord, fragment: visibleFragment,
-                        rx: JSON.stringify({
-                            status: ch.close_status ?? 200,
-                            content: `[ stream closed (${ch.close_status ?? 200}) — ${pointer} ]`,
-                            mimetype: "text/stream",
-                        }),
+                        rx: JSON.stringify(await terminalResult({
+                            content,
+                            mimetype: ch.mimetype,
+                        }, sequence)),
+                        status: terminal?.status ?? 200,
                         attrs: JSON.stringify({ streamEnd: ch.content.length, terminal: true }),
                         expanded: 1,
                     });
@@ -1518,91 +1970,136 @@ export default class Engine {
                 continue;
             }
             // startLine continues the line count across turns: a multi-turn stream's deltas number
-            // into one sequence (lines N..M, then M+1..), not N independent "1:" restarts. §exec-stream
+            // into one sequence (lines N..M, then M+1..), not N independent "1:" restarts. {§exec-stream}
             const startLine = (ch.content.slice(0, cursor).match(/\n/g)?.length ?? 0) + 1;
+            const sequence = fromSequence + written;
+            const content = ch.content.slice(cursor, publishEnd);
+            const terminalDelivery = closed && publishEnd === ch.content.length;
+            const fields = { content, mimetype: ch.mimetype, startLine };
+            const result = terminalDelivery
+                ? await terminalResult(fields, sequence)
+                : { status: 200, ...fields };
             await this.#db.engine_insert_stream_delta.run({
-                worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence: fromSequence + written,
+                worker_id: workerId, loop_id: loopId, turn_id: turnId, sequence,
                 scheme: ch.runtime, pathname: ch.coord, fragment: visibleFragment,
-                rx: JSON.stringify({ status: 200, content: ch.content.slice(cursor), mimetype: "text/stream", startLine }),
-                attrs: JSON.stringify({ streamEnd: ch.content.length, terminal: closed }),
-                expanded: closed ? 1 : 0, // §exec-stream — terminal delta auto-OPENs; ongoing folds
+                rx: JSON.stringify(result),
+                status: result.status,
+                attrs: JSON.stringify({ streamEnd: publishEnd, terminal: terminalDelivery }),
+                expanded: terminalDelivery ? 1 : 0, // {§exec-stream} — terminal observation auto-OPENs; ongoing folds
             });
             written++;
         }
         return written;
     }
-    // §env-delta — the filesystem as an actor. Ambient disk divergences detected at
-    // pre-turn (git membership re-read) are logged as the plurnk worker's source=file EDIT
-    // "fictions": no op happened, but EDIT is the only grammar the model has for "your
-    // world changed," so the fiction keeps its perspective aligned with what its tooling
-    // would show. The fiction lives in the plurnk worker's log; every other run pulls it
-    // through the one delta path, exactly like a sibling's real edit.
-    // §membership-emi-divergence-signal — disk divergences logged as the plurnk worker's source=file EDIT fictions
-    async #logFsFictions(workspaceId, divergences) {
+    // {§env-delta-filesystem-narration} {§membership-emi-divergence-signal}
+    // — journal project-file divergence once through the reserved actor.
+    async #logFsFictions(workspaceId, divergences, gitStatus) {
         if (divergences.length === 0)
             return;
-        const run = await this.#db.envelope_get_worker_by_name.get({ workspace_id: workspaceId, name: "plurnk" })
+        const gitByPath = new Map(gitStatus?.files.map(({ path, status }) => [path, status]) ?? []);
+        const worker = await this.#db.envelope_get_worker_by_name.get({ workspace_id: workspaceId, name: "plurnk" })
             ?? await this.#db.envelope_insert_worker.get({ workspace_id: workspaceId, name: "plurnk", origin: "plurnk" });
-        if (run === undefined)
+        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: run.id });
+        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 seq = await this.#db.client_turn_next_sequence.get({ loop_id: loop.id });
-        const turn = await this.#db.client_turn_insert.get({ loop_id: loop.id, sequence: seq?.next ?? 1, packet: "{}" });
-        if (turn === undefined)
-            throw new Error("logFsFictions: turn 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);
             await this.#db.engine_insert_log_entry.get({
-                worker_id: run.id, loop_id: loop.id, turn_id: turn.id, sequence: sequence++,
+                worker_id: worker.id, loop_id: loop.id, turn_id: turn.id, sequence: sequence++,
                 origin: "plurnk", source: "file", op: "EDIT", suffix: "", signal: null,
-                // `file` is an entry-routing scheme, never a stored log scheme. Match
-                // Dispatcher.#extractTarget so the fiction and a model's file EDIT
-                // address the same nullable log key.
-                scheme: d.scheme === "file" ? null : d.scheme, username: null, password: null, hostname: null, port: null,
-                pathname: d.pathname, params: null, fragment: null, lineMarker: 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: JSON.stringify({ status: 200, entryId: d.entryId, channel: d.channel, span }), mimetype_rx: "application/json",
-                status_rx: 200, tokens: 0, state: "resolved", outcome: null, attrs: "{}",
+                status_rx: 200, tokens: 0, state: "resolved", outcome: null,
+                attrs: gitByPath.has(d.pathname)
+                    ? JSON.stringify({ git: gitByPath.get(d.pathname) })
+                    : "{}",
             });
         }
     }
     async dispatch(context) {
-        if (context.statement.op === "EDIT") {
-            const { statement, sequence: _sequence, ...batchContext } = context;
-            await this.#dispatcher.prepareEditBatches([statement], batchContext);
-        }
-        return this.#dispatcher.dispatch(context);
+        return observed(// {§observability-boundary}
+        "op.dispatch", { op: context.statement.op }, async (span) => {
+            if (context.statement.op === "EDIT") {
+                const { statement, sequence: _sequence, ...batchContext } = context;
+                await this.#dispatcher.prepareEditBatches([statement], batchContext);
+            }
+            const result = await this.#dispatcher.dispatch(context);
+            span.setAttribute("status", result.status);
+            return result;
+        });
     }
-    // op.look (#283) — resolve a READ and return its content WITHOUT writing a
-    // log_entries row: the client's off-run inspection primitive. {§op-look}
+    // {§op-look}: resolve a READ without writing a log_entries row.
     async look(context) {
         return this.#dispatcher.look(context);
     }
-    // External API to feed a resolution into a pending proposal — the loop/resolve
-    // RPC handler, the in-tree auto listener, or the timeout watcher.
-    // Shutdown lane: settle every pending proposal with a cancel so a stopped world can never
-    // deadlock the stop (§proposal-cancel-aborts; the #344 wedge class).
+    async resolveEntryAddress(context) {
+        return this.#dispatcher.resolveEntryAddress(context);
+    }
+    async #writePromptLog({ workerId, loopId, turnId, sequence, target, content, }) {
+        const row = await this.#db.engine_insert_log_entry.get({
+            worker_id: workerId,
+            loop_id: loopId,
+            turn_id: turnId,
+            sequence,
+            origin: "plurnk",
+            source: null,
+            op: "prompt",
+            suffix: "",
+            signal: null,
+            scheme: target.scheme,
+            username: target.username,
+            password: target.password,
+            hostname: target.hostname,
+            port: target.port,
+            pathname: target.pathname,
+            query: target.query,
+            fragment: target.fragment,
+            lineMarker: null,
+            tx: "",
+            mimetype_tx: "text/plain",
+            rx: JSON.stringify({ content, mimetype: "text/markdown" }),
+            mimetype_rx: "application/json",
+            status_rx: 200,
+            tokens: this.#tokenize(content),
+            state: "resolved",
+            outcome: null,
+            attrs: "{}",
+        });
+        if (row === undefined)
+            throw new Error("Engine.#writePromptLog: INSERT ... RETURNING produced no row");
+        return row.id;
+    }
+    // External API to feed a resolution into a pending proposal — the client-interface
+    // seam, core-owned disposition, or the timeout watcher.
+    // {§worker-lifecycle-total-reap}: release every stopped-world waiter before joining drains.
     cancelAllProposals(outcome) {
         this.#proposals.cancelAll(outcome);
     }
     resolveProposal(logEntryId, resolution) {
         this.#proposals.resolve(logEntryId, resolution);
     }
-    // Snapshot of pending proposals (for diagnostic / RPC listings).
+    // Snapshot of pending proposals for client-interface discovery.
     pendingProposalIds() {
         return this.#proposals.pendingIds();
     }
-    // Subscribe to proposal-pending events. Daemon registers a listener
-    // that broadcasts the loop/proposal WS notification; auto listener
-    // registers one that auto-resolves.
+    // Subscribe to proposal-pending observations. Automatic settlement is
+    // core-owned and happens before observers run.
     onProposalPending(listener) {
         this.#proposals.onPending(listener);
     }
+    async pendingProposals(workspaceId) {
+        return this.#proposals.list(workspaceId);
+    }
     // Used by wake-on-completion (daemon side): "is there any loop in this
-    // run still accepting turns?" If yes, skip the wake — the active loop
+    // worker still accepting turns?" If yes, skip the wake — the active loop
     // will pick up the channel transition at its next turn boundary. If no,
     // the daemon opens a fresh loop with the wake prompt.
     async hasActiveLoopForWorker(workerId) {
@@ -1610,7 +2107,7 @@ export default class Engine {
         return (row?.n ?? 0) > 0;
     }
     // Workspace-scope eager warm: creation and membership changes start the
-    // exhaustive graph/FTS/vector derivation immediately. The RPC returns while
+    // exhaustive graph/FTS/vector derivation immediately. The seam call returns while
     // progress live-fans-out at loopId 0; a model turn joins this same coalesced
     // promise and cannot reach its provider until coverage is complete.
     async warmWorkspaceDerivations(workspaceId) {
@@ -1623,23 +2120,33 @@ export default class Engine {
             tokenize: this.#tokenize,
             mimetypes: this.#mimetypes,
             defaultChannelFor: (s) => this.#schemes.defaultChannelFor(s),
-            pushTelemetry: (event) => this.#telemetry.notify(workspaceId, 0, event),
+            pushNotice: (notice) => this.#notices.notify(workspaceId, 0, notice),
         };
         await this.#queueWorkspaceWarm(ctx); // materialize first; overlapping requests coalesce and rescan
     }
-    // Inject a prompt into the worker's currently-executing loop. Writes a
-    // plurnk://prompt/<run>/<loop>/<next-turn> entry whose body becomes the
-    // prompt section at the next turn boundary. Last-wins: if two
-    // injects target the same next-turn slot, the second overwrites the
-    // first.
+    // Inject a prompt into the worker's current non-terminal loop. Writes the
+    // next owner-keyed prompt:///<loop>/<N> entry; the next turn publishes it
+    // as one actionless prompt row. Prompt-frame writes serialize per worker,
+    // so concurrent arrivals retain distinct ordered ordinals.
     //
-    // Returns null when no loop in the worker is currently active (status=102).
+    // Returns null when no loop in the worker is active or parked (102/202).
     // The daemon-side inject path then enqueues a fresh loop with this
     // prompt; engine doesn't open loops itself.
-    //
-    // Rummy parallel: AgentLoop.inject(). The "active drain → write
-    // prompt entry, return immediately" branch.
-    async inject(workerId, prompt) {
+    inject(workerId, prompt, openPaths = []) {
+        return this.#withPromptWriteLock(workerId, () => this.#injectPrompt(workerId, prompt, openPaths));
+    }
+    #withPromptWriteLock(workerId, write) {
+        const previous = this.#promptWriteLocks.get(workerId) ?? Promise.resolve();
+        const run = previous.then(write, write);
+        const tail = run.catch(() => { });
+        this.#promptWriteLocks.set(workerId, tail);
+        void tail.then(() => {
+            if (this.#promptWriteLocks.get(workerId) === tail)
+                this.#promptWriteLocks.delete(workerId);
+        });
+        return run;
+    }
+    async #injectPrompt(workerId, prompt, openPaths) {
         const loopRow = await this.#db.drain_current_loop_for_worker.get({ worker_id: workerId });
         if (loopRow === undefined)
             return null;
@@ -1648,11 +2155,16 @@ export default class Engine {
         const turnSeq = turnRow?.next ?? 1;
         const workspaceRow = await this.#db.drain_get_worker_workspace.get({ worker_id: workerId });
         if (workspaceRow === undefined)
-            throw new Error(`Engine.inject: run ${workerId} not found`);
+            throw new Error(`Engine.inject: worker ${workerId} not found`);
         // {§prompt-loop-containment} — the frame is the loop's NEXT prompt ordinal, never a turn
         // slot: rapid arrivals land as N and N+1, both contained, nothing superseded.
-        const countRow = await this.#db.drain_count_prompts_for_loop.get({ owner_id: workerId, pattern: `${promptLoopPrefix(loopRow.sequence)}%` });
-        const pathname = promptPathname(loopRow.sequence, (countRow?.n ?? 0) + 1);
+        const prefix = promptLoopPrefix(loopRow.sequence);
+        const ordinalRow = await this.#db.drain_next_prompt_ordinal_for_loop.get({
+            owner_id: workerId,
+            pattern: `${prefix}%`,
+            prefix_len: prefix.length,
+        });
+        const pathname = promptPathname(loopRow.sequence, ordinalRow?.next ?? 2);
         const ctx = {
             db: this.#db, workspaceId: workspaceRow.workspace_id, workerId, loopId,
             turnId: 0, // no turn open at inject time; entries don't pin turnId
@@ -1661,11 +2173,12 @@ export default class Engine {
             streamEventNotify: this.#streamEventNotify,
             wakeWorkerNotify: this.#wakeWorkerNotify,
             tokenize: this.#tokenize,
-            pushTelemetry: (event) => this.#telemetry.push(workspaceRow.workspace_id, loopId, event),
+            pushNotice: (notice) => this.#notices.push(workspaceRow.workspace_id, loopId, notice),
         };
         const entry = {
             channels: { body: { content: prompt, mimetype: "text/markdown" } },
             tags: [],
+            attributes: { openPaths },
         };
         await EntryCrud.writeEntry(pathname, entry, ctx, "prompt", workerId);
         return { loopId, turnSeq };