@plurnk/plurnk-service 1.18.0 → 1.19.0

package/dist/core/TurnRunner.js

@@ -1,8 +1,8 @@
 var _a;
-import { TurnDisposition } from "@plurnk/plurnk-contracts";
 import NativeContent from "./NativeContent.js";
 import { PlurnkParser } from "@plurnk/plurnk-parser";
 import { PathSyntax, PlurnkParseError, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
+import LoopPolicyReader from "./LoopPolicyReader.js";
 import { setTimeout as delay } from "node:timers/promises";
 import { aggregateProviderAccounting } from "@plurnk/plurnk-providers";
 const comparePosition = (a, b) => a.line - b.line || a.column - b.column;
@@ -11,9 +11,7 @@ import GitMembership from "./git-membership.js";
 import { acceptedKinds } from "./attachments.js";
 import GitState from "./git-state.js";
 import WorkspaceSettings from "./workspace-settings.js";
-import { taskTiming } from "./LoopLifecycle.js";
-import { generatedPathname, promptLoopPrefix } from "./plurnk-uri.js";
-import PromptFrames from "./PromptFrames.js";
+import { generatedPathname } from "./plurnk-uri.js";
 import { readFile } from "node:fs/promises";
 import { resolve as resolvePath } from "node:path";
 import { homedir } from "node:os";
@@ -36,22 +34,13 @@ import Results, { OperationFailureError } from "./results.js";
 import Turn from "./Turn.js";
 import StoredPacket from "./StoredPacket.js";
 import { observed, observedSync } from "../observe/spans.js";
-import { GEN_AI_REQUEST_SPAN, genAiRequestOptions, settleGenAiResponse } from "../observe/genai.js";
+import { genAiRequestName, genAiRequestOptions, settleGenAiResponse } from "../observe/genai.js";
 import { PROVIDER_CALLS, recordCounter } from "../observe/metrics.js";
 import ModelCall, { ModelCallPersistenceError, ProviderAccountingIntegrityError } from "./ModelCall.js";
 import WorkerName from "./WorkerName.js";
 import TurnOps from "./TurnOps.js";
 import CapabilityPolicies from "./CapabilityPolicies.js";
 import CapabilityResolver from "./CapabilityResolver.js";
-// {§prompt-address}: the same literal address in every observer's packet.
-const promptTarget = (workerName, storage) => {
-    return {
-        kind: "url", raw: `prompt://${workerName}${storage}`,
-        scheme: "prompt", username: null, password: null,
-        hostname: workerName, port: null,
-        pathname: storage, query: null, fragment: null,
-    };
-};
 const regexLiteral = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 const workerCatalogTarget = (namespace) => {
     const pathname = generatedPathname(`/${namespace}/*.md`);
@@ -74,22 +63,6 @@ const assertOpenPaths = (value, source) => {
     }
     return value;
 };
-const parsePromptAttributes = (encoded, source) => {
-    const attributes = JSON.parse(encoded);
-    if (attributes === null || typeof attributes !== "object" || Array.isArray(attributes)) {
-        throw new TypeError(`${source}: expected a JSON object`);
-    }
-    return attributes;
-};
-const promptSourceFromAttributes = (attributes, source) => {
-    const value = attributes.source;
-    if (value === undefined)
-        return null;
-    if (typeof value !== "string" || value.length === 0) {
-        throw new TypeError(`${source}: source must be a non-empty string when present`);
-    }
-    return value;
-};
 // Per-emission action ceiling — OFF by default. `-1` (or unset/non-positive) = no cap:
 // every generated op dispatches. Runaway degeneration is a sampler concern (repetition penalty),
 // not grounds to drop already-generated work. A positive value is an operator ceiling a
@@ -149,10 +122,11 @@ const readMilliseconds = (key) => {
     return value;
 };
 // {§provider-recovery} — how long one turn keeps re-issuing its provider call after a
-// recoverable failure before the loop parks (0 parks at once), and the first backoff delay,
-// which doubles per failure and is capped at twelve times itself.
+// recoverable failure before the loop parks (0 parks at once), the first backoff delay, which
+// doubles per failure, and that delay's ceiling.
 const readProviderRecovery = () => readMilliseconds("PLURNK_SERVICE_PROVIDER_RECOVERY");
 const readProviderRecoveryBackoff = () => readMilliseconds("PLURNK_SERVICE_PROVIDER_RECOVERY_BACKOFF");
+const readProviderRecoveryBackoffMax = () => readMilliseconds("PLURNK_SERVICE_PROVIDER_RECOVERY_BACKOFF_MAX");
 const RECOVERABLE_PROVIDER_FAILURES = new Set(["rate_limit", "network_failure", "deadline_exceeded", "resource_interrupted"]);
 // The wall's abort reason — runLoop branches a mid-turn teardown to the 504 terminal on it.
 export const LOOP_TIMEOUT_REASON = "loop_timeout";
@@ -221,7 +195,7 @@ class TurnRunner {
         this.#warmWorkspace = warmWorkspace;
         this.#dispatch = dispatch;
         this.#resolveWorkerProviderIdentity = resolveWorkerProviderIdentity;
-        this.#materialization = new TurnMaterialization({ db: this.#db, weighContent: this.#weighContent });
+        this.#materialization = new TurnMaterialization({ db: this.#db, weighContent: this.#weighContent, mimetypes: this.#mimetypes });
         this.#bareBatch = new BareBatchRunner({ db: this.#db, providerAttributions: this.#providerAttributions.bind(this), providerFailure: _a.#providerFailure });
         this.#admitted = new AdmittedTurnExecutor({ db: this.#db, schemes: this.#schemes, notices: this.#notices, problems: this.#problems, dispatcher: this.#dispatcher, bareBatch: this.#bareBatch });
     }
@@ -236,7 +210,6 @@ class TurnRunner {
             workerId: args.workerId,
             loopId: args.loopId,
             packetCount: packetCount.count,
-            ...taskTiming(packetCount),
         });
     }
     // {§operator-grammar} — the operator's grammar text for this provider, or undefined when
@@ -262,8 +235,6 @@ class TurnRunner {
         process.stderr.write(`plurnk-engine: operator grammar: ${alias || "(bare)"} → ${path} (${text.length} chars)\n`);
         return text;
     }
-    // A lineage's no-parent root; a root worker resolves to itself. Fail hard
-    // when corruption leaves a worker without one. {§worker-primary}
     async #attemptAttributions(provider, context) {
         const tags = Meta.composeAttributions(this.#schemes.attributions(context), this.#executors()?.attributions(context) ?? [], await this.#mimetypes.attributions(context), provider.attributions?.(context) ?? []);
         return [...tags];
@@ -370,7 +341,7 @@ class TurnRunner {
     // durable turn and completes it only after its ordered operations settle; model
     // packets and provider metadata are optional inference evidence, not turn identity.
     async #openTurnContainer(args, createdTurnIds) {
-        const { workspaceId, workerId, loopId, turnNumber, invalidEmissionRecoveryEntryId } = args;
+        const { workspaceId, workerId, loopId, invalidEmissionRecoveryEntryId } = args;
         const workerName = await WorkerName.forId(this.#db, workerId);
         const transientOpenLogEntryId = typeof invalidEmissionRecoveryEntryId === "number"
             ? invalidEmissionRecoveryEntryId
@@ -381,11 +352,11 @@ class TurnRunner {
         // Turn-0 foists that belong to the Worker (catalog preview, AGENTS) gate
         // on its first inference history, not on loop sequence: honest client or
         // runtime administrative turns may precede the first provider exchange.
-        // Per-loop foists such as
-        // {§prompt-entry} still fires once per loop. Durable publication state,
-        // rather than the model-turn ordinal, prevents an overflow diversion
-        // from replaying the prompt and its automatic path READs.
-        const loopRow = await this.#db.engine_get_loop_prompt.get({ loop_id: loopId });
+        // Per-loop foists such as the initial message's publication
+        // ({§message-arrival}) fire once per loop: the inbox row's publication state,
+        // rather than the model-turn ordinal, prevents an overflow diversion from
+        // replaying a message and its automatic path READs.
+        const loopSequence = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
         const priorInference = await this.#db.engine_worker_has_inference_history.get({
             worker_id: workerId,
         });
@@ -400,7 +371,7 @@ class TurnRunner {
             createdTurnIds.push(initializationTurn.id);
         const initializationPolicies = initializationTurn === null
             ? []
-            : (await CapabilityPolicies.layers(this.#db, workspaceId)).map((layer) => layer.policy);
+            : (await CapabilityPolicies.layers(this.#db, workspaceId, loopId)).map((layer) => layer.policy);
         const modelTurn = initializationTurn === null
             ? await Turn.open(this.#db, { loopId, producer: "model", kind: "inference" })
             : null;
@@ -414,41 +385,29 @@ class TurnRunner {
             throw new Error(`worker ${workerId} has no durable ambient observation boundary`);
         }
         const systemCtx = this.#schemeContext(args, initializationTurn?.id ?? modelTurn.id);
-        // {§prompt-entry} — the prompt entry exists before any turn of the loop
-        // runs; its `prompt` log row is published to the model turn below (one
-        // durable publication per loop, decided by that row).
-        const promptPublication = turnNumber === 1 && loopRow?.prompt_published === 0
-            && typeof loopRow.prompt === "string" && loopRow.prompt.length > 0
-            ? {
-                content: loopRow.prompt,
-                source: loopRow.prompt_source,
-                path: promptTarget(workerName, await PromptFrames.write(systemCtx, {
-                    loopSequence: loopRow.sequence, ordinal: 1, content: loopRow.prompt,
-                    source: loopRow.prompt_source, pathname: loopRow.prompt_pathname,
-                    openPaths: assertOpenPaths(JSON.parse(loopRow.open_paths), `Loop ${loopId} open_paths`),
-                })),
-                openPaths: assertOpenPaths(JSON.parse(loopRow.open_paths), `Loop ${loopId} open_paths`),
-            }
-            : null;
         const initializationStatements = [];
         // {§worker-initialization-entry} — the worker's first turn is the worked
-        // example itself: the actual orienting operations and an ordinary TASK.
+        // example itself: the actual orienting operations and ordinary NOTEs.
         // {§turn0-agents-stunt} — the project AGENTS.md (materialized by LoopDocs as
-        // worker:///_plurnk/agents.md) gets one foisted READ on the worker's first
+        // worker:///_plurnk/AGENTS.md) gets one foisted READ on the worker's first
         // loop, so local repo guidance is visible turn-0 content. Global policy
         // stays in the system prompt; nothing else is force-read.
         if (initializationTurn !== null) {
+            initializationStatements.push({
+                op: "NOTE", aside: null, metadata: null, target: null, lineMarker: null,
+                body: `This turn surveys tooling and environment. The log records results; ops://${workerName}/${loopSequence}/${initializationTurn.sequence} contains the submitted OPs.`, position: UNKNOWN_POSITION,
+            });
             const agentsEntry = await this.#db.crud_find_workspace_entry.get({
                 workspace_id: workspaceId,
                 scheme: "worker",
                 authority: "",
-                pathname: generatedPathname("/agents.md"),
+                pathname: generatedPathname("/AGENTS.md"),
             });
             if (agentsEntry !== undefined) {
                 const agentsTarget = {
-                    kind: "url", raw: "worker:///_plurnk/agents.md", scheme: "worker",
+                    kind: "url", raw: "worker:///_plurnk/AGENTS.md", scheme: "worker",
                     username: null, password: null, hostname: null, port: null,
-                    pathname: generatedPathname("/agents.md"), query: null, fragment: null,
+                    pathname: generatedPathname("/AGENTS.md"), query: null, fragment: null,
                 };
                 const agentsRead = {
                     op: "READ", aside: null, target: agentsTarget,
@@ -458,9 +417,9 @@ class TurnRunner {
             }
         }
         return {
-            workerName, transientOpenLogEntryId, loopRow, createdTurnIds,
+            workerName, transientOpenLogEntryId, loopSequence, createdTurnIds,
             initializationTurn, initializationPolicies, initializationStatements,
-            modelTurn, systemCtx, promptPublication,
+            modelTurn, systemCtx,
         };
     }
     // The `_plurnk` scheme context for one turn. Threaded per turn, never engine
@@ -514,11 +473,11 @@ class TurnRunner {
         return gitStatus;
     }
     // {§worker-initialization-entry} — the worker's first turn is the worked example
-    // itself: the actual orienting operations and an ordinary TASK, executed as a
+    // itself: the actual orienting operations and ordinary NOTEs, executed as a
     // complete turn before the model boundary.
     async #runInitializationTurn(args, container, initializationTurn) {
         const { provider, workspaceId, workerId, loopId, onDispatch, onSettled } = args;
-        const { loopRow, initializationStatements, initializationPolicies } = container;
+        const { workerName, loopSequence, initializationStatements, initializationPolicies } = container;
         // Turn-0 catalog preview (PLURNK_SERVICE_FILES_ITEMS, {§actor-boundary-catalog-preview}):
         // Eight bodyless FIND surveys in the worker's packetless initialization turn establish the Agent
         // Skills, the plurnk references, the enabled tools, agents, and members, then the project, commons,
@@ -530,32 +489,25 @@ class TurnRunner {
         if (filesItems !== null) { // {§actor-boundary-catalog-preview} — once per worker
             initializationStatements.push(...await this.#catalogSurveys(args, container, filesItems));
         }
-        const task = {
-            op: "TASK", aside: null, target: null, metadata: null, lineMarker: null,
-            body: [{ content: "Address the prompt.", status: "in_progress" }],
-            position: UNKNOWN_POSITION,
-        };
-        const pathname = `/${loopRow.sequence}/${initializationTurn.sequence}`;
-        await Turn.recordSource(this.#db, initializationTurn.id, "reasoning", ReasoningView.initialSource());
-        // {§reasoning-initial-read} — the pattern READ needs a text/plain projection to run the regex.
-        const pluck = await this.#mimetypes.getHandler("text/plain") !== null;
-        const reasoningRead = ReasoningView.initialRead(provider, loopRow.sequence, initializationTurn.sequence, pluck);
+        const pathname = `/${loopSequence}/${initializationTurn.sequence}`;
+        const reasoning = ReasoningView.initialSource();
+        await Turn.recordSource(this.#db, initializationTurn.id, "reasoning", reasoning);
+        const reasoningRead = ReasoningView.initialRead(provider, workerName, loopSequence, initializationTurn.sequence);
         if (reasoningRead !== null)
             initializationStatements.push(reasoningRead);
         initializationStatements.push({
             op: "READ", aside: "inspect this turn's emission", matcher: null, body: null, metadata: null,
             target: {
-                kind: "url", raw: `ops://${pathname}`, scheme: "ops", pathname,
-                username: null, password: null, hostname: null, port: null, query: null, fragment: null,
+                kind: "url", raw: `ops://${workerName}${pathname}`, scheme: "ops", pathname,
+                username: null, password: null, hostname: workerName, port: null, query: null, fragment: null,
             },
             lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
         });
-        // {§prompt-entry} — the prompt reaches the model as its `prompt` row in the first
+        // {§message-arrival} — the message reaches the model as an inbound SEND in the first
         // model turn; initialization does not READ it a second time.
-        initializationStatements.push(task);
         const admittedInitializationStatements = initializationStatements.filter((statement) => this.#capabilities.allowsAcross(statement, workspaceId, initializationPolicies));
-        const source = TurnOps.renderInternal(admittedInitializationStatements);
-        const admitted = TurnOps.parseInternal(source);
+        const source = admittedInitializationStatements.length === 0 ? "" : TurnOps.renderInternal(admittedInitializationStatements);
+        const admitted = [...PlurnkParser.parseReasoningNotes(reasoning), ...(source.length === 0 ? [] : TurnOps.parseInternal(source))];
         const result = await this.executeAdmittedTurn({
             statements: admitted,
             source,
@@ -570,8 +522,8 @@ class TurnRunner {
             onDispatch,
             onSettled,
         });
-        if (result.status !== TURN_STATUS_IMPLICIT_CONTINUE) {
-            throw new Error(`initialization TASK returned ${result.status}; expected ${TURN_STATUS_IMPLICIT_CONTINUE}`);
+        if (result.status !== 200) {
+            throw new Error(`initialization returned ${result.status}; expected 200`);
         }
     }
     // {§actor-boundary-catalog-preview} — the opening surveys, each admitted only when
@@ -608,11 +560,11 @@ class TurnRunner {
             },
             ...this.#toolExpansions(workspaceId, initializationPolicies),
             {
-                // {§a2a-agents-catalog} — enabled outbound agents survey at
+                // {§a2a-catalog} — enabled outbound agents survey at
                 // alias level; each row's summary is the agent's identity line,
                 // the exact card stays pullable through READ a2a://<alias>.
                 op: "FIND", aside: null,
-                target: { kind: "url", raw: "worker:///_plurnk/agents/*.md", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname("/agents/*.md"), query: null, fragment: null },
+                target: { kind: "url", raw: "worker:///_plurnk/a2a/*.md", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: generatedPathname("/a2a/*.md"), query: null, fragment: null },
                 metadata: null,
                 matcher: null, body: null, lineMarker: { marks: [1, -1] }, position: UNKNOWN_POSITION,
             },
@@ -634,13 +586,13 @@ class TurnRunner {
                 position: UNKNOWN_POSITION,
             },
             {
-                op: "FIND", aside: "shared worker Extended Context",
+                op: "FIND", aside: "workspace knowledgebase entries",
                 target: { kind: "url", raw: "worker:///*", scheme: "worker", username: null, password: null, hostname: null, port: null, pathname: "/*", query: null, fragment: null },
                 metadata: null,
                 matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
             },
             {
-                op: "FIND", aside: "private worker Extended Context",
+                op: "FIND", aside: "worker knowledgebase entries",
                 target: { kind: "url", raw: `worker://${workerName}/*`, scheme: "worker", username: null, password: null, hostname: workerName, port: null, pathname: "/*", query: null, fragment: null },
                 metadata: null,
                 matcher: null, body: null, lineMarker: null, position: UNKNOWN_POSITION,
@@ -689,18 +641,26 @@ class TurnRunner {
             container.createdTurnIds.push(modelTurn.id);
         const { id: turnId, sequence: seq } = modelTurn;
         const systemCtx = this.#schemeContext(args, turnId);
-        const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
-        const prompts = await this.#publishPrompts(args, container, turnId, loopSeq);
-        let nextActionIndex = await this.#readOpenPaths(args, turnId, prompts.openPaths, prompts.nextActionIndex);
+        const messages = await this.#publishMessages(args, turnId);
+        let nextActionIndex = await this.#readOpenPaths(args, turnId, messages.openPaths, messages.nextActionIndex);
         // {§env-delta-log-pull} — materialize ambient observations before packet
         // composition and reserve their action indices. {§exec-stream} owns the
         // distinct byte-cursor path for this worker's streams.
-        // {§exec-poll} — an execution `<0>` is turn-scoped: reap the worker's open turn-scoped streams (necessarily
+        // {§exec-lifetime} — a `"turn"` lifetime: reap the worker's open turn-scoped streams (necessarily
         // from a prior turn — this runs before the turn's own spawns) so a `<0>` never survives into
         // the subsequent turn. The terminal output then surfaces initially visible via the stream-delta path.
         await this.#reapTurnScopedStreams(workerId);
-        nextActionIndex += await this.#materialization.materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
-        nextActionIndex += await this.#materialization.materializeStreamDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
+        const ambientEntries = await this.#materialization.materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
+        nextActionIndex += ambientEntries.length;
+        const streamEntries = await this.#materialization.materializeStreamDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
+        nextActionIndex += streamEntries.length;
+        await Turn.observeCompletions(this.#db, turnId);
+        // {§notifications-log-entry-notify}: materialized observations are
+        // ordinary committed log rows, not packet-only content.
+        for (const id of [...ambientEntries, ...streamEntries]) {
+            args.onDispatch?.(id);
+            await args.onSettled?.(id);
+        }
         // The post-reconciliation Git snapshot above is threaded into the packet
         // and every budget rebuild; overflow never shells again.
         // Notices are non-terminal observations, never operation-failure truth.
@@ -708,68 +668,42 @@ class TurnRunner {
         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.
+        // queries log_entries scoped to the worker, including this turn's newly
+        // published message arrivals.
         const facts = { turnId, seq, gitStatus, notices, transientOpenLogEntryId: container.transientOpenLogEntryId, promptProjection: "automatic" };
         let packet = await this.#buildPacket(args, facts);
         // {§context-output-admission} — output admission changes no operation
-        // outcome, authored inventory, or turn identity.
+        // outcome, authored memory, or turn identity.
         if (await this.#packets.admitOutput(packet, turnId))
             packet = await this.#buildPacket(args, facts);
-        return { ...facts, createdTurnIds: container.createdTurnIds, loopSeq, systemCtx, nextActionIndex, packet };
+        return { ...facts, createdTurnIds: container.createdTurnIds, loopSeq: container.loopSequence, systemCtx, nextActionIndex, packet };
     }
-    // Pre-model writes. Each prompt the model has not seen yet becomes a `prompt`
-    // operation row whose target is its durable prompt:// entry; model operations
-    // continue the same turn sequence after these rows. Returns the next action index
-    // and the frames' open paths.
-    async #publishPrompts({ workerId, loopId, onDispatch, onSettled }, { workerName, promptPublication }, turnId, loopSeq) {
+    // Pre-model writes. Each message the model has not seen yet becomes an inbound `SEND`
+    // row; model operations continue the same turn sequence after these rows. Returns the
+    // next action index and the messages' open paths.
+    // {§message-loop-containment}: the loop contains every message that arrived before this
+    // boundary. Publish each unpublished inbox row oldest-first, exactly once, as an inbound
+    // SEND row ({§message-arrival}); its selected paths ride along for the READs that follow.
+    async #publishMessages({ workerId, loopId, onDispatch, onSettled }, turnId) {
         let nextActionIndex = 1;
         const openPaths = [];
-        if (promptPublication !== null) { // {§prompt-entry} — one durable publication per loop
-            openPaths.push(...promptPublication.openPaths);
-            const promptLogId = await this.#materialization.writePromptLog({
-                workerId,
-                loopId,
-                turnId,
-                sequence: nextActionIndex++,
-                target: promptPublication.path,
-                content: promptPublication.content,
-                source: promptPublication.source,
-            });
-            onDispatch?.(promptLogId);
-            await onSettled?.(promptLogId);
-        }
-        // {§prompt-loop-containment}: the loop contains every prompt that arrived
-        // while it ran. Publish each undelivered frame oldest-first exactly once.
-        const prefix = promptLoopPrefix(loopSeq);
-        const undelivered = (await this.#db.drain_undelivered_prompts_for_loop.all({
-            worker_id: workerId,
-            pattern: `${prefix}%`,
-            prefix_len: prefix.length,
-            loop_id: loopId,
-        }))
-            .filter((row) => typeof row.content === "string" && row.content.length > 0);
-        for (const injectedRow of undelivered) {
-            const attributes = parsePromptAttributes(injectedRow.attributes, `Prompt ${injectedRow.pathname} attributes`);
-            if (attributes.openPaths !== undefined) {
-                openPaths.push(...assertOpenPaths(attributes.openPaths, `Prompt ${injectedRow.pathname} openPaths`));
-            }
-            const promptLogId = await this.#materialization.writePromptLog({
-                workerId,
-                loopId,
-                turnId,
-                sequence: nextActionIndex++,
-                target: promptTarget(workerName, injectedRow.pathname),
-                content: injectedRow.content,
-                source: promptSourceFromAttributes(attributes, `Prompt ${injectedRow.pathname} attributes`),
+        const unpublished = await this.#db.drain_unpublished_messages_for_loop.all({ loop_id: loopId });
+        for (const message of unpublished) {
+            openPaths.push(...assertOpenPaths(JSON.parse(message.open_paths), `Message ${message.id} open_paths`));
+            const logEntryId = await this.#materialization.writeArrivalLog({
+                workerId, loopId, turnId, sequence: nextActionIndex++, body: message.body, source: message.source, resource: message.path,
+                selfAddressed: message.source !== null && message.source === message.durable_path,
             });
-            onDispatch?.(promptLogId);
-            await onSettled?.(promptLogId);
+            const published = await this.#db.drain_publish_message.get({ id: message.id, log_entry_id: logEntryId });
+            if (published === undefined)
+                throw new Error(`TurnRunner.#publishMessages: message ${message.id} was already published`);
+            onDispatch?.(logEntryId);
+            await onSettled?.(logEntryId);
         }
         return { nextActionIndex, openPaths };
     }
-    // {§methods-loop-run-open-paths}: selected workspace paths belong to the prompt
-    // frame. Publish the frame, then dispatch ordinary core READs in that same turn;
+    // {§methods-loop-run-open-paths}: selected workspace paths belong to the message.
+    // Publish it, then dispatch ordinary core READs in that same turn;
     // missing/non-member paths retain their normal 4xx. Returns the next action index.
     async #readOpenPaths({ workspaceId, workerId, loopId, onDispatch, onSettled }, turnId, openPaths, fromSequence) {
         let nextActionIndex = fromSequence;
@@ -825,9 +759,7 @@ class TurnRunner {
         const recoveryBudget = readProviderRecovery();
         const recoveryBackoff = readProviderRecoveryBackoff();
         const providerSignal = this.#loopSignal(loopId) ?? signal;
-        // {§client-metadata}
-        const { client } = await WorkspaceSettings.read(this.#db, workspaceId);
-        const { workerId: providerWorkerId, primaryWorkerId } = await this.#resolveWorkerProviderIdentity(workerId);
+        const { workerId: providerWorkerId } = await this.#resolveWorkerProviderIdentity(workerId);
         return {
             wire,
             response: undefined,
@@ -847,9 +779,7 @@ class TurnRunner {
             recoveryBudget,
             recoveryBackoff,
             signal: providerSignal,
-            client,
             providerWorkerId,
-            primaryWorkerId,
             turnWireAccounting: [],
         };
     }
@@ -902,7 +832,6 @@ class TurnRunner {
             railEvidence: attempts.railEvidence,
             emissionAttempts: attempts.emissionAttempts,
             signal: attempts.signal,
-            primaryWorkerId: attempts.primaryWorkerId,
         };
         if (emission.split.packetAssistant.reasoning?.length) {
             await Turn.recordSource(this.#db, request.turnId, "reasoning", emission.split.packetAssistant.reasoning, { modelCallId: emission.modelCallId });
@@ -923,7 +852,6 @@ class TurnRunner {
         const attributionContext = Object.freeze({
             workspaceId: String(workspaceId),
             workerId: attempts.providerWorkerId,
-            primaryWorkerId: attempts.primaryWorkerId,
             loop: request.loopSeq,
             turn: request.seq,
             attempt: attempts.modelCallSequence,
@@ -1047,27 +975,19 @@ class TurnRunner {
     // asserted whether it resolved or failed.
     async #generate({ provider, workspaceId }, request, attempts, modelCall, reasoning, strikeStreak) {
         return await observed(// {§observability-boundary}
-        GEN_AI_REQUEST_SPAN, { model: provider.model, attempt: attempts.modelCallSequence }, async (span) => {
+        genAiRequestName(provider.model), { model: provider.model, attempt: attempts.modelCallSequence }, async (span) => {
             try {
                 await this.#packets.recordObservations(request.packet);
                 const generated = await provider.generate({
                     messages: attempts.wire.messages,
                     workerId: attempts.providerWorkerId,
-                    primaryWorkerId: attempts.primaryWorkerId,
+                    workspaceId: String(workspaceId),
                     signal: attempts.signal,
                     grammar: attempts.railGrammar,
-                    strikes: strikeStreak,
-                    attributions: attempts.attributions.length > 0
-                        ? attempts.attributions
-                        : undefined,
-                    client: attempts.client ?? undefined,
-                    workspaceId: String(workspaceId),
-                    loop: request.loopSeq,
-                    turn: request.seq,
                     observeRequest: reasoning.observeRequest,
                     observeReasoning: reasoning.observeReasoning,
                     callKind: "emission",
-                }); // {§provider-surface-generate} {§provider-guarantees-signal-wired} {§provider-guarantees-serial-attempts} {§attribution} {§client-metadata}
+                }); // {§provider-surface-generate} {§provider-guarantees-signal-wired} {§provider-guarantees-serial-attempts} {§attribution}
                 modelCall.assertAccounting(generated.accounting);
                 attempts.callInFlight = false;
                 recordCounter(PROVIDER_CALLS, {
@@ -1086,7 +1006,7 @@ class TurnRunner {
                 }
                 throw error;
             }
-        }, genAiRequestOptions(ProviderInstantiate.aliasOf(provider) ?? "plurnk", provider.model));
+        }, genAiRequestOptions(ProviderInstantiate.providerIdOf(provider) ?? "other", provider.model));
     }
     // {§provider-recovery} — a transient provider failure never ends the loop: record
     // it, wait, and re-issue the same turn; once the budget is spent the failure
@@ -1119,7 +1039,7 @@ class TurnRunner {
             source: "provider",
             result: failure,
         });
-        const wait = Math.min(attempts.recoveryBackoff * 2 ** (attempts.recoveryFailures - 1), attempts.recoveryBackoff * 12);
+        const wait = Math.min(attempts.recoveryBackoff * 2 ** (attempts.recoveryFailures - 1), readProviderRecoveryBackoffMax());
         this.#notices.push(workspaceId, workerId, loopId, {
             source: "engine:provider",
             kind: "provider_unavailable",
@@ -1242,11 +1162,14 @@ class TurnRunner {
         if (attempts.parked) {
             // {§provider-recovery} — the recovery budget is spent: the loop parks exactly like a
             // [202] wait and resumes on the next prompt or wake; the failure stays durable.
+            // {§loop-attendance} — unattended, nothing will wake it, so LoopDriver concludes instead
+            // and the notice says that rather than promising a resumption nobody can deliver.
+            const { attended } = await LoopPolicyReader.read(this.#db, loopId);
             this.#notices.push(workspaceId, workerId, loopId, {
                 source: "engine:provider",
                 kind: "provider_unavailable",
                 level: "error",
-                message: `${recorded.result.problem?.title ?? "Provider failure"}: the ${Math.round(attempts.recoveryBudget / 1000)}s recovery budget is spent; the loop is parked and resumes on the next prompt or wake.`,
+                message: `${recorded.result.problem?.title ?? "Provider failure"}: the ${Math.round(attempts.recoveryBudget / 1000)}s recovery budget is spent; ${attended ? "the loop is parked and resumes on the next prompt or wake" : "this run is unattended, so the loop ends here"}.`,
             });
             return turnResult(request, 202, { providerParked: true, providerFailure: recorded.result, emissionAttempts });
         }
@@ -1349,7 +1272,7 @@ class TurnRunner {
         }
         // Non-fatal provider transport notices on an accepted turn. Forward each
         // Notice with a content-offset `line:col`;
-        // the model resolves it against its own emission — READ ops:///<loop>/<turn> at the
+        // the model resolves it against its own emission — READ ops://<worker>/<loop>/<turn> at the
         // cited lines ({§turn-ops-entry}) — not an embedded snippet that would duplicate the emission.
         for (const notice of response.notices ?? []) {
             const located = typeof notice.position === "number"
@@ -1419,9 +1342,9 @@ class TurnRunner {
             maxCommands,
             recoverableParseErrors: split.recoverableParseErrors,
             emptyTurn: split.emptyTurn,
+            proseAnswer: split.proseAnswer,
             bare: {
                 provider: childProvider,
-                primaryWorkerId: emission.primaryWorkerId,
                 loopSequence: request.loopSeq,
                 turnSequence: request.seq,
                 signal: emission.signal,
@@ -1494,7 +1417,7 @@ class TurnRunner {
                             });
                         }
                         else {
-                            parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source, ...(err.code === undefined ? {} : { code: err.code }) });
+                            parseErrors.push({ message: err.message, line: err.line, column: err.column, source: err.source });
                         }
                     }
                     else {
@@ -1503,34 +1426,69 @@ class TurnRunner {
                     }
                 }
             }
-            // Boundary loss is the parser's one public fact from `unparsedTail.from` onward;
-            // preserve it with the rejected forensic attempt. {§unparsed-tail-boundary}
+            // {§unparsed-tail-boundary} — the lexer's one boundary fact: from `unparsedTail.from` on,
+            // nothing was read. The statements that closed before it are ordinary facts and run; the
+            // loss itself is one more hard diagnostic, a failed row the model sees. An emission that
+            // lost its boundary before any statement closed has nothing admissible and is resampled.
             const tail = parsed.unparsedTail;
             if (tail !== undefined) {
                 hasUnparsedTail = true;
                 parseErrors.push({ message: tail.reason, line: tail.from.line, column: tail.from.column, source: "grammar" });
             }
         }
+        // {§prose-conclusion} — a response whose content is prose (no operation, no attempt at one,
+        // not cut at the output allowance) is the model's answer: a SEND to the open messages.
+        // {§quotation} a reply wrapped whole in one markdown fence is delivered as its content.
+        const wrapped = /^(`{3,}|~{3,})(?:markdown|md)[ \t]*\n([\s\S]*?)\n\1[ \t]*$/u.exec(assistant.content.trim());
+        const prose = (wrapped?.[2] ?? assistant.content).trim();
+        const concludes = preParsedOps === undefined
+            && ops.length === 0
+            && !hasUnparsedTail
+            && prose.length > 0
+            && assistant.finishReason !== "length"
+            && parseErrors.every((error) => error.message === PlurnkParser.NO_VALID_OPERATION)
+            && PlurnkParser.operationAttempt(assistant.content, executors) === null
+            // {§quotation} an answer says something of its own: a reply that is nothing but quoted
+            // material is a misfenced program, not prose (operator, 2026-09-18).
+            && PlurnkParser.unquoted(prose, executors).trim().length > 0
+            // {§quotation} an operation fence that merely missed column zero is a misplaced program,
+            // never an answer: the loop continues and the next packet carries the parser's word.
+            && !parseNotices.some(({ message }) => (message ?? "").includes("must start its line to run"));
+        const proseAnswer = concludes
+            ? { op: "SEND", aside: null, target: null, metadata: null, lineMarker: null, body: { raw: prose, json: null }, position: { line: 1, column: 0 } }
+            : null;
+        if (proseAnswer !== null) {
+            parseErrors.length = 0;
+            ops.push(proseAnswer);
+        }
+        // The statements the content itself closed: a lost boundary is admissible only behind one
+        // of these, never behind a reasoning NOTE alone ({§reasoning-notes}).
+        const contentStatementCount = ops.filter(({ position }) => position.line > 0).length;
+        const reasoning = assistant.reasoning ?? null;
+        const notes = reasoning === null ? [] : PlurnkParser.parseReasoningNotes(reasoning);
+        ops.unshift(...notes);
+        if (notes.length > 0) {
+            // A reasoned NOTE is an operation even when the content contains no program.
+            for (let index = parseErrors.length - 1; index >= 0; index--) {
+                if (parseErrors[index].message === PlurnkParser.NO_VALID_OPERATION)
+                    parseErrors.splice(index, 1);
+            }
+        }
         const sourceStatementCount = ops.filter(({ position }) => position.line > 0).length;
-        const dispositions = ops.filter(TurnDisposition.is);
-        const trustworthyBoundary = dispositions.length <= 1 && !hasUnparsedTail;
-        // {§turn-shape} — bounded operation errors are recoverable and ride with the
-        // admitted program; document-boundary failures still reject it.
-        const recoverableParseErrors = trustworthyBoundary
-            ? parseErrors.filter((error) => error.code !== "invalid-turn-structure").toSorted(comparePosition)
-            : [];
+        // {§turn-shape} — every hard diagnostic is recoverable and rides with the admitted program
+        // as a failed row; a lost boundary refuses only what follows it. The harness admits every
+        // program whose meaning it can determine and reports what it could not read.
+        const recoverableParseErrors = [...parseErrors].toSorted(comparePosition);
         // {§empty-turn} — no operation and no other hard error: admitted as an empty turn, never
-        // resampled; its advisories ({§bare-heading-advisory}) ride as notices.
+        // resampled; its advisories ({§bare-heading-advisory}) ride as notices. A boundary lost
+        // before any statement closed is not an empty turn: the model tried, and is resampled.
         const emptyTurn = preParsedOps === undefined
-            && trustworthyBoundary
+            && !hasUnparsedTail
             && sourceStatementCount === 0
             && parseErrors.every((error) => error.message === PlurnkParser.NO_VALID_OPERATION);
         const emissionValid = preParsedOps !== undefined
             || emptyTurn
-            || (trustworthyBoundary
-                && sourceStatementCount > 0
-                && recoverableParseErrors.length === parseErrors.length);
-        const reasoning = assistant.reasoning ?? null;
+            || (hasUnparsedTail ? contentStatementCount > 0 : sourceStatementCount > 0);
         return {
             packetAssistant: { content: assistant.content, ops, reasoning },
             sourceBacked: preParsedOps === undefined,
@@ -1538,18 +1496,19 @@ class TurnRunner {
             parseErrors,
             recoverableParseErrors: emissionValid && !emptyTurn ? recoverableParseErrors : [],
             emptyTurn,
+            proseAnswer,
             parseNotices,
             // The ANTLR model-turn parser is authoritative. At least one source
-            // operation is required; TASK omission continues silently. Bounded
+            // operation is required; lifecycle omission continues silently. Bounded
             // statement failures become durable operation results.
-            // Boundary loss and an unparsed tail still reject
-            // wholesale. Pre-parsed ops are Mock's trusted test seam.
+            // A boundary lost before any statement closed rejects; after one, the
+            // statements run and the loss is a row. Pre-parsed ops are Mock's trusted test seam.
             emissionValid,
         };
     }
     // #note12 — plugin reference docs are materialized beneath
     // worker:///_plurnk/plurnk/ by LoopDocs.
-    // {§exec-poll} — an execution `<0>` is turn-scoped: abort the worker's open turn-scoped streams via their
+    // {§exec-lifetime} — a `"turn"` lifetime: abort the worker's open turn-scoped streams via their
     // owning scheme (the same registry-routed abort the total reap uses). Called at each pre-turn
     // before the turn's own spawns, so every open turn-scoped sub here is from a prior turn — it
     // never survives into the subsequent turn. Fire-and-forget: the spawn finalizes async and its