@plurnk/plurnk-service 1.4.0 → 1.5.0

package/dist/core/Engine.js

@@ -7,7 +7,6 @@ import { Mimetypes, emptyRegistry } from "@plurnk/plurnk-mimetypes";
 import Meta from "@plurnk/plurnk-meta";
 import EntryCrud from "../schemes/_entry-crud.js";
 import SearchIndex from "../schemes/_search-index.js";
-import { markTerminal } from "../schemes/Worker.js";
 import GitMembership from "./git-membership.js";
 import GitState from "./git-state.js";
 import WorkspaceSettings from "./workspace-settings.js";
@@ -26,6 +25,7 @@ import { setTimeout as delay } from "node:timers/promises";
 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";
@@ -41,7 +41,20 @@ 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;
+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,
@@ -102,7 +115,7 @@ const readMaxCommands = () => {
     return n;
 };
 // PLURNK_SERVICE_FILES_ITEMS — the turn-0 catalog preview. null = off;
-// -1 = the complete one-level map; positive N caps its file rows. 0 / unset = 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;
@@ -117,6 +130,7 @@ import ProviderInstantiate from "./ProviderInstantiate.js";
 // continue after dispatch ({§send}). Every admitted emission itself ends in an
 // explicit disposition SEND ({§emission-admission}).
 const TURN_STATUS_IMPLICIT_CONTINUE = 102;
+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) => {
@@ -208,7 +222,13 @@ export default class Engine {
         if (!invalidate && this.#workspaceWarmStatus.get(workspaceId)?.phase === "complete") {
             return Promise.resolve();
         }
-        const state = { dirty: false, materialize, ctx, promise: Promise.resolve() };
+        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.
@@ -231,10 +251,14 @@ 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 GitMembership.indexGitMembership(cancellable);
                     await SearchIndex.maintain({
-                        ...current,
+                        ...cancellable,
                         pushNotice: (notice) => {
                             if (notice.kind === "embed_progress"
                                 && typeof notice.completed === "number"
@@ -277,9 +301,26 @@ 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;
@@ -449,14 +490,19 @@ export default class Engine {
     // 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,
+            reasoningTokens: row?.reasoning ?? 0,
+            cachedTokens: row?.cached ?? 0,
             costUsd: row?.cost_usd ?? null,
-            costs: parsedCosts.map((cost) => validateProviderCost(cost)),
+            costs,
             // Latest provider attempt on the latest turn, not the billed total.
             contextTokens: row?.context ?? 0,
             // Latest effective packet allowance; null when uncapped or unknown.
@@ -490,6 +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);
+        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();
@@ -547,7 +594,7 @@ export default class Engine {
                 // 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 a terminal result with status 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)
             }
@@ -584,10 +631,6 @@ export default class Engine {
                 cleanup("forceful", "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} — hold matching runtime/effect
             // streams until conclusion or the fail-open cap, then resume the
@@ -600,11 +643,6 @@ 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 {
@@ -613,6 +651,7 @@ export default class Engine {
                     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;
@@ -635,10 +674,18 @@ export default class Engine {
                 releaseWorkspace();
             }
             turnIds.push(turn.turnId);
-            // Invalid provider emissions are retried beneath this turn and never
-            // reach the strike rail. Exhausting that inner attempt budget is a
-            // terminal generation failure, not one of the engine's three strikes.
+            // {§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",
@@ -650,6 +697,7 @@ export default class Engine {
                 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) {
@@ -663,11 +711,11 @@ export default class Engine {
                 return { turnIds, result, hitMaxTurns: false, reason: "budget_overflow" };
             }
             // {§engine-rails} — per-turn strike accounting (cycle detection, the
-            // grinder/steer coupling, hard-failure statuses). StrikeRail owns 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,
+                outcomes: turn.outcomes,
                 budgetStruck: turn.budgetStruck,
                 steerStruck: turn.steerStruck,
                 minCycles, maxCyclePeriod, maxStrikes,
@@ -691,7 +739,11 @@ export default class Engine {
             }
         }
     }
-    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
@@ -859,7 +911,10 @@ 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
@@ -894,10 +949,10 @@ export default class Engine {
                 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 a first-N cap;
-                    // other schemes always render their complete one-level map. An empty file
-                    // survey has no range: `<1,0>` would turn useful orientation into an error.
+                    // 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
                     // exemplar and the log rows the model reads never train a leading-slash or
@@ -913,7 +968,7 @@ export default class Engine {
                             query: null, fragment: null,
                         },
                         body: null,
-                        lineMarker: cap === null ? null : { marks: [1, cap] },
+                        lineMarker: catalogMarker,
                         position: UNKNOWN_POSITION,
                     };
                     await this.dispatch({
@@ -921,9 +976,11 @@ export default class Engine {
                         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 ? pattern : `${scheme}:///${pattern}`})${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 ({§schemes-directory}, published under {§entry-owner}).
@@ -931,13 +988,13 @@ export default class Engine {
                 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/**", query: null, fragment: null },
-                    body: null, lineMarker: null, position: UNKNOWN_POSITION,
+                    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} — the building worker's own scratch gets the same complete
-                // one-level map in its perspective alone. It always executes: an empty private
+                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,
@@ -953,7 +1010,7 @@ export default class Engine {
             // 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 (workerFirstLoop) {
-                const emission = ["<<PLAN:Initialize:PLAN", ...turnZeroMoves, "<<SEND[102]:Next, address the prompt from the initialized context.:SEND"].join("\n");
+                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" });
             }
         }
@@ -986,10 +1043,8 @@ export default class Engine {
         await this.#reapTurnScopedStreams(workerId);
         nextActionIndex += await this.#materializeEnvironmentDeltas({ workspaceId, workerId, loopId, turnId, fromSequence: nextActionIndex });
         nextActionIndex += await this.#materializeStreamDeltas({ workerId, loopId, turnId, fromSequence: nextActionIndex });
-        // Git working-tree state is read once for the packet and threaded
-        // (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);
+        // 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)
@@ -999,7 +1054,7 @@ export default class Engine {
         // 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, notices,
+            currentTurnSeq: seq, provider, gitStatus, notices, transientOpenLogEntryId,
         });
         // SPEC {§grinder} — budget grinder, pre-LLM: reclaim window on actual overflow.
         const enforced = await this.#packets.enforceBudget({
@@ -1011,18 +1066,18 @@ export default class Engine {
             // set; neither path can duplicate or swallow a product failure.
             rebuild: () => this.#packets.buildRequestPacket({
                 initialMessages: messages, requirements, workspaceId, workerId, loopId,
-                currentTurnSeq: seq, provider, gitStatus, notices,
+                currentTurnSeq: seq, provider, gitStatus, notices, transientOpenLogEntryId,
             }),
         });
         if (enforced.recorded)
             nextActionIndex += 1; // a fold-to-fit Problem consumed the reserved sequence
         requestPacket = enforced.packet;
-        let operationConstraint;
         if (!enforced.fit) {
             // {§grinder-hard-413-recovery}/{§grinder-hard-413-abort} — admit
-            // one physically sendable constrained recovery turn; a physical
+            // 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) {
@@ -1041,20 +1096,16 @@ export default class Engine {
                 // errors sections (the same re-derive contract the soft grind uses).
                 requestPacket = await this.#packets.buildRequestPacket({
                     initialMessages: messages, requirements, workspaceId, workerId, loopId,
-                    currentTurnSeq: seq, provider, gitStatus, notices,
+                    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);
-                    operationConstraint = {
-                        code: "budget-recovery",
-                        detail: "budget recovery is active",
-                        allowedOperations: BudgetOverflow.recoveryOperations,
-                    };
+                    recoveryAdmitted = true;
                 }
             }
-            if (operationConstraint === undefined) {
-                // Hard 413: physically unsendable, or still over after the constrained 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");
@@ -1080,14 +1131,12 @@ export default class Engine {
                     });
                     requestPacket = await this.#packets.buildRequestPacket({
                         initialMessages: messages, requirements, workspaceId, workerId, loopId,
-                        currentTurnSeq: seq, provider, gitStatus, notices,
+                        currentTurnSeq: seq, provider, gitStatus, notices, transientOpenLogEntryId,
                     });
                 }
                 // Skip the LLM, close the turn, and let runLoop abandon.
                 await this.#db.engine_close_turn.run({
                     id: turnId, status: 413, packet: StoredPacket.stringify(requestPacket),
-                    usage_prompt: 0, usage_completion: 0, usage_reasoning: 0, usage_cached: 0,
-                    usage_cost: "[]", usage_cost_usd: 0,
                     // The attempted turn retains its effective allowance even
                     // when no provider exchange completed. {§tokenomics-client-gauge}
                     usage_prompt_budget: this.#packets.promptBudgetFor(provider),
@@ -1096,7 +1145,7 @@ export default class Engine {
                 return {
                     turnId,
                     status: 413,
-                    statuses: [],
+                    outcomes: [],
                     fingerprint: "",
                     budgetStruck: enforced.struck,
                     budgetHardStop: true,
@@ -1121,43 +1170,42 @@ export default class Engine {
         let railGrammar;
         let railEvidence;
         let emissionAttempts = 0;
-        const usage = { prompt: 0, completion: 0, reasoning: 0, cached: 0 };
-        let usageCostUsd = 0;
-        const providerCosts = [];
         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 recordProviderAttempt = async (attemptResponse, attemptSplit, sequence, accepted, attributions) => {
-            const attemptUsage = attemptSplit.callMetadata.usage;
-            const attemptCost = providerCostFor(provider, attemptUsage, attemptResponse.charge);
-            const attemptCostUsd = providerCostUsd(attemptCost);
-            await this.#db.engine_record_turn_attempt.run({
-                turn_id: turnId,
-                sequence,
-                accepted: accepted ? 1 : 0,
+        const observeProviderAttempt = async (id, attemptResponse) => {
+            const attemptUsage = attemptResponse.assistant.usage;
+            await this.#db.engine_observe_turn_attempt_response.run({
+                id,
                 response: JSON.stringify(attemptResponse),
-                parse_errors: JSON.stringify(attemptSplit.parseErrors),
-                attributions: JSON.stringify(attributions),
                 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,
-                finish_reason: attemptSplit.callMetadata.finishReason,
-                model: attemptSplit.callMetadata.model,
             });
-            usage.prompt += attemptUsage.prompt;
-            usage.completion += attemptUsage.completion;
-            usage.reasoning += attemptUsage.reasoning;
-            usage.cached += attemptUsage.cached;
-            providerCosts.push(attemptCost);
-            usageCostUsd = usageCostUsd === null || attemptCostUsd === null
-                ? null
-                : usageCostUsd + attemptCostUsd;
             emissionAttempts = sequence;
         };
         try {
@@ -1186,6 +1234,16 @@ export default class Engine {
                 });
                 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) => {
@@ -1205,6 +1263,7 @@ export default class Engine {
                         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,
@@ -1214,12 +1273,12 @@ export default class Engine {
                     return generated;
                 });
                 response = completedResponse;
-                providerCallInFlight = false;
+                await observeProviderAttempt(attemptRow.id, completedResponse);
                 railEvidence = railGrammar === undefined
                     ? undefined
                     : Engine.#requireGrammarEvidence(completedResponse);
                 splitResponse = this.#splitResponse(completedResponse);
-                await recordProviderAttempt(completedResponse, splitResponse, attempt, splitResponse.emissionValid, providerAttemptAttributions);
+                await classifyProviderAttempt(attemptRow.id, completedResponse, splitResponse, attempt, splitResponse.emissionValid);
                 if (splitResponse.emissionValid)
                     break;
             }
@@ -1231,20 +1290,43 @@ export default class Engine {
             // 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 recordProviderAttempt(response, splitResponse, providerAttemptSequence, false, providerAttemptAttributions);
+                await classifyProviderAttempt(providerAttemptId, response, splitResponse, providerAttemptSequence, false, failure);
             }
             else {
-                providerCosts.push({
+                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),
                 });
-                usageCostUsd = null;
+                emissionAttempts = providerAttemptSequence;
             }
             // {§turn-never-blank} — a ProviderError means no completed exchange exists.
             // Persist its exact RFC 9457 result before propagating it. Grammar evidence
@@ -1258,12 +1340,6 @@ export default class Engine {
                     id: turnId,
                     status: providerSignal.reason === LOOP_TIMEOUT_REASON ? 504 : 499,
                     packet: StoredPacket.stringify(requestPacket),
-                    usage_prompt: usage.prompt,
-                    usage_completion: usage.completion,
-                    usage_reasoning: usage.reasoning,
-                    usage_cached: usage.cached,
-                    usage_cost: JSON.stringify(providerCosts),
-                    usage_cost_usd: usageCostUsd,
                     usage_prompt_budget: this.#packets.promptBudgetFor(provider),
                     finish_reason: splitResponse?.callMetadata.finishReason ?? null,
                     model: splitResponse?.callMetadata.model ?? provider.model,
@@ -1271,15 +1347,6 @@ export default class Engine {
                 });
                 throw err;
             }
-            const failure = err instanceof ProviderError
-                ? { status: err.problem.status, problem: err.problem }
-                : (() => {
-                    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,
-                    });
-                })();
             const recorded = await this.#problems.record({
                 workerId,
                 loopId,
@@ -1296,12 +1363,6 @@ export default class Engine {
                 id: turnId,
                 status: recorded.result.status,
                 packet: StoredPacket.stringify(requestPacket),
-                usage_prompt: usage.prompt,
-                usage_completion: usage.completion,
-                usage_reasoning: usage.reasoning,
-                usage_cached: usage.cached,
-                usage_cost: JSON.stringify(providerCosts),
-                usage_cost_usd: usageCostUsd,
                 usage_prompt_budget: this.#packets.promptBudgetFor(provider),
                 finish_reason: splitResponse?.callMetadata.finishReason ?? null,
                 model: splitResponse?.callMetadata.model ?? provider.model,
@@ -1313,16 +1374,30 @@ export default class Engine {
             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: 500,
+                status: allowInvalidEmissionRecovery ? TURN_STATUS_IMPLICIT_CONTINUE : 500,
                 packet: StoredPacket.stringify(requestPacket),
-                usage_prompt: usage.prompt,
-                usage_completion: usage.completion,
-                usage_reasoning: usage.reasoning,
-                usage_cached: usage.cached,
-                usage_cost: JSON.stringify(providerCosts),
-                usage_cost_usd: usageCostUsd,
                 usage_prompt_budget: this.#packets.promptBudgetFor(provider),
                 finish_reason: splitResponse.callMetadata.finishReason,
                 model: splitResponse.callMetadata.model,
@@ -1330,14 +1405,15 @@ export default class Engine {
             });
             return {
                 turnId,
-                status: 500,
-                statuses: [],
+                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;
@@ -1348,7 +1424,7 @@ export default class Engine {
         }
         // 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` mirror row at the
+        // 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"
@@ -1442,12 +1518,6 @@ export default class Engine {
             id: turnId,
             status: turnStatus,
             packet: StoredPacket.stringify(packet),
-            usage_prompt: usage.prompt,
-            usage_completion: usage.completion,
-            usage_reasoning: usage.reasoning,
-            usage_cached: usage.cached,
-            usage_cost: JSON.stringify(providerCosts),
-            usage_cost_usd: usageCostUsd,
             usage_prompt_budget: this.#packets.promptBudgetFor(provider), // {§tokenomics-client-gauge}
             finish_reason: callMetadata.finishReason,
             model: callMetadata.model,
@@ -1471,22 +1541,17 @@ export default class Engine {
         // (the PLAN/SEND ops, zero actions), which is its only coherent meaning.
         let realCommands = 0;
         const admittedOps = packetAssistant.ops.filter((op) => {
-            const constrained = operationConstraint !== undefined
-                && !operationConstraint.allowedOperations.includes(op.op);
             return op.op === "PLAN"
                 || op === sendOp
-                || constrained
                 || realCommands++ < maxCommands;
         });
         const opsToDispatch = scheduleTurnOps(admittedOps);
-        await this.#dispatcher.prepareEditBatches(opsToDispatch.filter((statement) => statement.op === "EDIT"
-            && (operationConstraint === undefined
-                || operationConstraint.allowedOperations.includes(statement.op))), {
+        await this.#dispatcher.prepareEditBatches(opsToDispatch.filter((statement) => statement.op === "EDIT"), {
             workspaceId, workerId, loopId, turnId,
             origin, onDispatch,
         });
         const droppedCount = opsCount - opsToDispatch.length;
-        const statuses = [];
+        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).
@@ -1513,7 +1578,7 @@ export default class Engine {
                         retryable: false,
                     }),
                 });
-                statuses.push(recorded.result.status);
+                outcomes.push({ op: null, status: recorded.result.status });
                 onDispatch?.(recorded.id);
             }
         };
@@ -1522,20 +1587,25 @@ export default class Engine {
                 && 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,
-                    ...(operationConstraint === undefined ? {} : { operationConstraint }),
                     origin, onDispatch,
                 });
                 span.setAttribute("status", dispatchResult.status);
                 recordCounter(OPS_DISPATCHED, { op: statement.op, status: dispatchResult.status });
                 return dispatchResult;
             });
-            statuses.push(result.status);
+            outcomes.push({ op: statement.op, status: result.status });
             for (const normalization of result.scopeNormalizations ?? []) {
                 this.#notices.push(workspaceId, loopId, {
                     source: "engine:slicer",
@@ -1622,7 +1692,7 @@ export default class Engine {
         return {
             turnId,
             status: turnStatus,
-            statuses,
+            outcomes,
             fingerprint: StrikeRail.fingerprintTurn(packetAssistant.ops),
             budgetStruck: enforced.struck,
             budgetHardStop: false,
@@ -1647,10 +1717,8 @@ 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
-        // only structured operations are executable). 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).
+        // 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 = [];
@@ -1671,7 +1739,6 @@ export default class Engine {
                 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) {
@@ -1758,11 +1825,28 @@ export default class Engine {
                 || r.op === null || r.status_rx === null)
                 continue;
             const termination = r.kind === "loop_termination";
-            const rx = termination
-                ? BranchReceipt.append(markTerminal(r.terminated_by, r.rx) ?? `loop "${r.prompt ?? ""}" ended (${r.status_rx})`, await BranchReceipt.render(this.#db, r.producer_worker_id))
-                : r.rx;
-            if (rx === null)
+            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,
                 event_id: r.event_id,
@@ -1771,11 +1855,11 @@ export default class Engine {
                 scheme: r.scheme,
                 hostname: r.hostname,
                 pathname: r.pathname,
-                rx,
-                mimetype_rx: termination ? "text/markdown" : "application/json",
+                rx: r.rx,
+                mimetype_rx: "application/json",
                 status: r.status_rx,
-                expanded: termination && r.status_rx >= 200 && r.status_rx < 300 ? 1 : 0,
-                attrs: r.attrs ?? "{}",
+                expanded: terminal !== null && terminal.status >= 200 && terminal.status < 300 ? 1 : 0,
+                attrs,
             });
             if (inserted !== undefined)
                 written++;
@@ -1801,11 +1885,10 @@ export default class Engine {
         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 row. It is 200
-    // while the channel streams and preserves the exact terminal result when closed. Ongoing
-    // deltas fold; the terminal delta 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}
+    // 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 });
@@ -1847,14 +1930,15 @@ export default class Engine {
                 }
                 return result;
             };
-            if (ch.content.length <= cursor) {
-                // The cursor-terminal race (owner's dogfood find): a channel written in one final
+            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,
@@ -1867,12 +1951,15 @@ export default class Engine {
                         ? `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,
                         scheme: ch.runtime, pathname: ch.coord, fragment: visibleFragment,
                         rx: JSON.stringify(await terminalResult({
-                            content: `[ stream closed (${ch.close_status ?? 200}) - ${pointer} ]`,
-                            mimetype: "text/stream",
+                            content,
+                            mimetype: ch.mimetype,
                         }, sequence)),
                         status: terminal?.status ?? 200,
                         attrs: JSON.stringify({ streamEnd: ch.content.length, terminal: true }),
@@ -1886,16 +1973,19 @@ export default class Engine {
             // 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 result = closed
-                ? await terminalResult({ content: ch.content.slice(cursor), mimetype: "text/stream", startLine }, sequence)
-                : { status: 200, content: ch.content.slice(cursor), mimetype: "text/stream", startLine };
+            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,
                 scheme: ch.runtime, pathname: ch.coord, fragment: visibleFragment,
                 rx: JSON.stringify(result),
                 status: result.status,
-                attrs: JSON.stringify({ streamEnd: ch.content.length, terminal: closed }),
-                expanded: closed ? 1 : 0, // {§exec-stream} — terminal delta auto-OPENs; ongoing folds
+                attrs: JSON.stringify({ streamEnd: publishEnd, terminal: terminalDelivery }),
+                expanded: terminalDelivery ? 1 : 0, // {§exec-stream} — terminal observation auto-OPENs; ongoing folds
             });
             written++;
         }
@@ -1903,9 +1993,10 @@ export default class Engine {
     }
     // {§env-delta-filesystem-narration} {§membership-emi-divergence-signal}
     // — journal project-file divergence once through the reserved actor.
-    async #logFsFictions(workspaceId, divergences) {
+    async #logFsFictions(workspaceId, divergences, gitStatus) {
         if (divergences.length === 0)
             return;
+        const gitByPath = new Map(gitStatus?.files.map(({ path, status }) => [path, status]) ?? []);
         const worker = await this.#db.envelope_get_worker_by_name.get({ workspace_id: workspaceId, name: "plurnk" })
             ?? await this.#db.envelope_insert_worker.get({ workspace_id: workspaceId, name: "plurnk", origin: "plurnk" });
         if (worker === undefined)
@@ -1926,7 +2017,10 @@ export default class Engine {
                 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) })
+                    : "{}",
             });
         }
     }