@plurnk/plurnk-service 0.7.0 → 0.9.0

package/dist/core/Engine.js

@@ -1,18 +1,27 @@
+var _a;
 import { PlurnkParser, PlurnkParseError } from "@plurnk/plurnk-grammar";
 import { Mimetypes, emptyRegistry } from "@plurnk/plurnk-mimetypes";
-import { writeEntry } from "../schemes/_entry-crud.js";
+import EntryCrud from "../schemes/_entry-crud.js";
+import EntryManifest from "../schemes/_entry-manifest.js";
+import GitMembership from "./git-membership.js";
 import { DEFAULT_LOOP_FLAGS } from "./scheme-types.js";
-import { sliceLinesRaw, isBinaryMimetype } from "@plurnk/plurnk-schemes";
-// Plain JS module shared with bin/digest.js so wire projection and
-// digest projection are structurally one function. tsconfig.build.json
-// has allowJs:true so this gets copied through to dist/.
-import { packetToWireMessages } from "./packet-wire.js";
+import { LineMarkerOps, MimetypeBinary } from "../content/index.js";
+// Shared module imported by both Engine and bin/digest.ts, so wire
+// projection and digest projection are structurally one function — no
+// drift between wire and digest possible.
+import PacketWire from "./packet-wire.js";
 // SPEC §3.6: writer must be in target scheme's manifest.writableBy.
 // SHOW/HIDE/READ/FIND are not gated — they touch visibility metadata or read.
 const MUTATING_OPS = new Set(["EDIT", "SEND", "COPY", "MOVE", "EXEC"]);
 const DEFAULT_PREVIEW_BUDGET = 256;
 const DEFAULT_MAX_STRIKES = 3;
 const DEFAULT_MAX_COMMANDS = 99;
+const DEFAULT_BUDGET_CEILING = 0.9;
+// Substituted into the budget readout after the assembled packet is measured
+// (the figure depends on the packet's own rendered size — chicken/egg).
+const TOKENS_FREE_PLACEHOLDER = "{{tokensFree}}";
+const TOKEN_USAGE_PLACEHOLDER = "{{tokenUsage}}";
+const TOKEN_PERCENT_PLACEHOLDER = "{{tokenPercent}}";
 const readBudget = () => {
     const raw = process.env.PLURNK_ENTRY_SIZE_DEFAULT_TOKENS;
     if (raw === undefined || raw.length === 0)
@@ -22,6 +31,18 @@ const readBudget = () => {
         return DEFAULT_PREVIEW_BUDGET;
     return n;
 };
+// PLURNK_BUDGET_CEILING is dual-mode: <=1 is a fraction of the provider's
+// context window, >1 is an absolute token wall — lets a demo pin a tiny
+// ceiling regardless of the model's real window to force the grinder.
+const readCeiling = () => {
+    const raw = process.env.PLURNK_BUDGET_CEILING;
+    if (raw === undefined || raw.length === 0)
+        return DEFAULT_BUDGET_CEILING;
+    const n = Number.parseFloat(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        return DEFAULT_BUDGET_CEILING;
+    return n;
+};
 const readMaxStrikes = () => {
     const raw = process.env.PLURNK_MAX_STRIKES;
     if (raw === undefined || raw.length === 0)
@@ -131,41 +152,59 @@ const fingerprintOp = (stmt) => {
     }
     return base;
 };
-// Per-turn fingerprint: sorted set of per-op fingerprints, joined. Order
-// within a turn doesn't matter — we want the SET of activities.
-export const fingerprintTurn = (ops) => {
-    return ops.map(fingerprintOp).toSorted().join(",");
-};
-// Rail #39 cycle detector. For each candidate period k in [1, maxCyclePeriod],
-// check whether the last k*minCycles entries form minCycles repetitions of the
-// same length-k pattern. O(maxCyclePeriod × minCycles × max k) ≈ tiny. Rummy
-// parallel: src/plugins/error/error.js detectCycle.
-export const detectCycle = (history, minCycles, maxCyclePeriod) => {
-    for (let k = 1; k <= maxCyclePeriod; k++) {
-        const needed = k * minCycles;
-        if (history.length < needed)
-            continue;
-        const tail = history.slice(-needed);
-        const cycle = tail.slice(0, k);
-        let match = true;
-        outer: for (let rep = 0; rep < minCycles; rep++) {
-            for (let j = 0; j < k; j++) {
-                if (tail[rep * k + j] !== cycle[j]) {
-                    match = false;
-                    break outer;
+class Engine {
+    static computeCeiling(contextSize, config) {
+        // Absolute wall (config > 1) is window-independent — the point of the >1
+        // mode is to pin a ceiling even when the provider reports no window; cap at
+        // the real window when one is known. Ratio mode needs a window to scale.
+        if (config > 1)
+            return contextSize === null ? Math.floor(config) : Math.min(Math.floor(config), contextSize);
+        return contextSize === null ? null : Math.floor(contextSize * config);
+    }
+    // Per-turn fingerprint: sorted set of per-op fingerprints, joined. Order
+    // within a turn doesn't matter — we want the SET of activities.
+    static fingerprintTurn(ops) {
+        return ops.map(fingerprintOp).toSorted().join(",");
+    }
+    // Rail #39 cycle detector. For each candidate period k in [1, maxCyclePeriod],
+    // check whether the last k*minCycles entries form minCycles repetitions of the
+    // same length-k pattern. O(maxCyclePeriod × minCycles × max k) ≈ tiny. Rummy
+    // parallel: src/plugins/error/error.js detectCycle.
+    static detectCycle(history, minCycles, maxCyclePeriod) {
+        for (let k = 1; k <= maxCyclePeriod; k++) {
+            const needed = k * minCycles;
+            if (history.length < needed)
+                continue;
+            const tail = history.slice(-needed);
+            const cycle = tail.slice(0, k);
+            let match = true;
+            outer: for (let rep = 0; rep < minCycles; rep++) {
+                for (let j = 0; j < k; j++) {
+                    if (tail[rep * k + j] !== cycle[j]) {
+                        match = false;
+                        break outer;
+                    }
                 }
             }
+            if (match)
+                return { detected: true, period: k, cycles: minCycles };
         }
-        if (match)
-            return { detected: true, period: k, cycles: minCycles };
+        return { detected: false };
     }
-    return { detected: false };
-};
-export default class Engine {
     #db;
     #schemes;
     #mimetypes;
     #previewBudget;
+    #budgetCeiling;
+    // Write-time tokenizer (SPEC §14.2). Synchronous per the provider
+    // contract (§2.1). Populated from the active provider's countTokens via
+    // the Daemon; a divisor tripwire stands in only for bare/standalone
+    // construction before a provider is wired (same boot affordance as
+    // Mimetypes, §4.5). Real counts come from provider.countTokens.
+    #tokenize;
+    // Boot-discovered runtime executors. Daemon builds + sets via
+    // setExecutors at start(); undefined until then (and in bare tests).
+    #executors;
     // Per-loop transient buffer of actionless failures pending surface in the
     // NEXT packet's user.telemetry.errors[]. Drained by #buildTelemetryErrors.
     // Map<loopId, TelemetryError[]>. SPEC §15.1.
@@ -200,7 +239,7 @@ export default class Engine {
     // status code but has no way to surface why the loop degraded.
     // Per-grammar 0.17.0 protocol — see SPEC §15.1.
     #telemetryEventNotify;
-    constructor({ db, schemes, mimetypes, streamEventNotify, wakeRunNotify, telemetryEventNotify }) {
+    constructor({ db, schemes, mimetypes, streamEventNotify, wakeRunNotify, telemetryEventNotify, tokenize }) {
         this.#db = db;
         this.#schemes = schemes;
         this.#streamEventNotify = streamEventNotify;
@@ -214,6 +253,16 @@ export default class Engine {
             discovery: { registry: emptyRegistry(), handlers: new Map() },
         });
         this.#previewBudget = readBudget();
+        this.#budgetCeiling = readCeiling();
+        // Tripwire default matches the Mimetypes boot affordance (SPEC §4.5):
+        // the divisor stands in only until the provider-backed tokenizer is
+        // wired by the Daemon. Real counts come from provider.countTokens.
+        this.#tokenize = tokenize ?? ((text) => Math.ceil(text.length / 4));
+    }
+    // Late injection: the executor registry is async-built at daemon start()
+    // (discover + probe), after Engine construction.
+    setExecutors(executors) {
+        this.#executors = executors;
     }
     #pushTelemetry(sessionId, loopId, event) {
         const existing = this.#telemetryBuffer.get(loopId);
@@ -305,6 +354,12 @@ export default class Engine {
                 turnNumber: turnIds.length + 1, maxTurns,
             });
             turnIds.push(turn.turnId);
+            // SPEC §14.4: budget hard-stop — packet won't fit even collapsed → abandon.
+            if (turn.budgetHardStop) {
+                await this.#db.engine_loop_cancel.run({ loop_id: loopId });
+                cleanup("forceful", "budget_overflow");
+                return { turnIds, finalStatus: 499, hitMaxTurns: false, reason: "budget_overflow" };
+            }
             // Rail #39: cycle detection. Push this turn's fingerprint to
             // history, scan for repetition patterns. Detection bumps
             // turnErrors so the strike system handles abandonment
@@ -315,9 +370,12 @@ export default class Engine {
             // reason for treating the turn as a failure, not its own alert.
             const state = this.#strikeState.get(loopId) ?? { streak: 0, turnErrors: 0, history: [] };
             state.history.push(turn.fingerprint);
-            const cycle = detectCycle(state.history, minCycles, maxCyclePeriod);
+            const cycle = _a.detectCycle(state.history, minCycles, maxCyclePeriod);
             if (cycle.detected)
                 state.turnErrors++;
+            // SPEC §14.4: a non-soft grinder fire counts toward the strike streak.
+            if (turn.budgetStruck)
+                state.turnErrors++;
             this.#strikeState.set(loopId, state);
             // Rail #38: strike accounting. Three sources strike a turn:
             //  1. recordedFailed — any action-entry at hard failure status
@@ -409,13 +467,61 @@ export default class Engine {
                 nextActionIndex++;
             }
         }
+        // plurnk://manifest.json — rewritten EVERY turn (a live view of the
+        // entry set, which changes each turn). A derived view like the index,
+        // NOT an action — written directly (Engine.inject's path): no log entry,
+        // no sequence slot, not dispatched. The catalog body is built in the
+        // schemes layer (_entry-manifest); the engine only orchestrates the
+        // per-turn write. Does not list itself.
+        const systemCtx = {
+            db: this.#db, sessionId, runId, loopId, turnId,
+            writer: "system",
+            signal: this.#loopAborts.get(loopId)?.signal,
+            streamEventNotify: this.#streamEventNotify,
+            wakeRunNotify: this.#wakeRunNotify,
+            tokenize: this.#tokenize,
+            mimetypes: this.#mimetypes,
+            pushTelemetry: (event) => this.#pushTelemetry(sessionId, loopId, event),
+        };
+        // SPEC §14.3 D4/D5 — git-ls-files workspace membership, resolved at
+        // prompt-composition (EMI is eager + relevance-bounded). When the
+        // session's project_root is a git working tree, tracked files are
+        // members without a client `add`; active members are materialized
+        // (disk → body channel + visibility) so they surface in the index
+        // below. No-ops on headless / non-git sessions. Runs BEFORE the
+        // manifest + index build so this turn's packet reflects them.
+        await GitMembership.indexGitMembership(systemCtx);
+        await EntryCrud.writeEntry("manifest.json", {
+            channels: { body: { content: await EntryManifest.buildManifestBody(systemCtx, this.#previewBudget), mimetype: "application/json" } },
+            tags: [],
+        }, systemCtx, "plurnk");
         // Build the spec'd packet (Packet.json) request half. #buildLog
         // queries log_entries scoped to the run — the prompt entry just
         // written (if turn 1) is part of that query result.
-        const requestPacket = await this.#buildRequestPacket({
+        let requestPacket = await this.#buildRequestPacket({
             initialMessages: messages, persona, requirements, runId, loopId,
             currentTurnSeq: seq, provider,
         });
+        // SPEC §14.4 — budget grinder, pre-LLM: reclaim window on actual overflow.
+        const enforced = await this.#enforceBudget({
+            packet: requestPacket, provider, runId, loopId, turnId, sessionId, turnNumber,
+            rebuild: (telemetryErrors) => this.#buildRequestPacket({
+                initialMessages: messages, persona, requirements, runId, loopId,
+                currentTurnSeq: seq, provider, telemetryErrors,
+            }),
+        });
+        requestPacket = enforced.packet;
+        if (!enforced.fit) {
+            // Hard 413: won't fit even with only the manifest left. Skip the LLM,
+            // close the turn, and let runLoop abandon (499).
+            const hardPacket = this.#completePacket(requestPacket, { content: "", ops: [], reasoning: null }, null, provider);
+            await this.#db.engine_close_turn.run({
+                id: turnId, status: 413, packet: JSON.stringify(hardPacket),
+                usage_prompt: 0, usage_completion: 0, usage_cached: 0, usage_cost_pico: 0,
+                finish_reason: "budget_hard_stop", model: provider.model,
+            });
+            return { turnId, status: 413, statuses: [], fingerprint: "", budgetStruck: enforced.struck, budgetHardStop: true };
+        }
         const modelMessages = this.#packetToWireMessages(requestPacket);
         const response = await provider.generate({ messages: modelMessages, signal });
         // Engine splits wire-level response: emission (content, reasoning,
@@ -506,7 +612,7 @@ export default class Engine {
         // nothing. Strike accounting (engine-internal) treats it as a
         // struck turn; the model just sees an empty packet next turn.
         // Per SPEC §15.1 gamification policy.
-        return { turnId, status: turnStatus, statuses, fingerprint: fingerprintTurn(packetAssistant.ops) };
+        return { turnId, status: turnStatus, statuses, fingerprint: _a.fingerprintTurn(packetAssistant.ops), budgetStruck: enforced.struck, budgetHardStop: false };
     }
     // Split the wire-level ProviderResponse into the two destinations:
     // packet.assistant gets the model's emission (content, ops, reasoning);
@@ -568,7 +674,7 @@ export default class Engine {
     // and §user) BEFORE the provider call. The same packet object is then
     // completed with assistant + assistantRaw after the model responds, so
     // the stored packet and the wire payload share one source of truth.
-    async #buildRequestPacket({ initialMessages, persona: defaultPersona, requirements, runId, loopId, currentTurnSeq, provider, }) {
+    async #buildRequestPacket({ initialMessages, persona: defaultPersona, requirements, runId, loopId, currentTurnSeq, provider, telemetryErrors: presetTelemetry, }) {
         const byRole = (role) => initialMessages.filter((m) => m.role === role).map((m) => m.content).join("\n\n");
         const system_definition = byRole("system");
         // user.prompt sources from the loop's most recent prompt entry first
@@ -587,65 +693,117 @@ export default class Engine {
         const persona = (row?.persona !== undefined && row?.persona !== null) ? row.persona : defaultPersona;
         const index = await this.#buildIndex(runId, loopId);
         const log = await this.#buildLog(runId);
-        const telemetryErrors = await this.#buildTelemetryErrors(loopId, currentTurnSeq);
+        const telemetryErrors = presetTelemetry ?? await this.#buildTelemetryErrors(loopId, currentTurnSeq);
         // Per-section render-cost subtotals via provider's tokenizer.
         // Engine approximates each section by tokenizing its serialized
         // form — wire-payload tokens may differ slightly because chat-
         // template scaffolding adds bytes, but the subtotal tracks "what
         // the model has to process" closely enough for budget diagnostics.
-        const systemTokens = provider.countTokens(system_definition) +
-            provider.countTokens(persona) +
-            provider.countTokens(JSON.stringify(index)) +
-            provider.countTokens(JSON.stringify(log));
-        // user.telemetry.budget — shimmed with section-aggregate table.
-        // Real per-scheme breakdown is the tokenomics chapter (SPEC.md §14.2);
-        // depends on provider.getContextSize and write-time per-row tokens.
-        const budget = this.#renderBudgetShim(systemTokens, provider, prompt, telemetryErrors);
-        const userTokens = provider.countTokens(prompt) +
-            provider.countTokens(JSON.stringify(telemetryErrors)) +
-            provider.countTokens(budget) +
-            provider.countTokens(requirements);
-        return {
-            system: {
-                tokens: systemTokens,
-                system_definition,
-                persona,
-                index,
-                log,
-            },
-            user: {
-                tokens: userTokens,
-                prompt,
-                telemetry: { budget, errors: telemetryErrors },
-                system_requirements: requirements,
-            },
+        const countTokens = (t) => provider.countTokens(t);
+        // Budget readout (SPEC.md §14.2). Two-pass: measure the wire-rendered
+        // index/log sections (budget-independent), install the readout with a
+        // tokensFree placeholder, measure the assembled total, resolve free,
+        // substitute. Subtotals come from the real render — meta and fences
+        // included — not a serialized approximation. ceiling is the provider's
+        // window × PLURNK_BUDGET_CEILING (null when no window is reported →
+        // headline omitted, section lines still shown).
+        const ceiling = _a.computeCeiling(provider.contextSize, this.#budgetCeiling);
+        const scratch = {
+            system: { system_definition, persona, index, log },
+            user: { prompt, telemetry: { budget: "", errors: telemetryErrors }, system_requirements: requirements },
         };
+        const sections = PacketWire.measureBudgetSections(scratch, countTokens);
+        scratch.user.telemetry.budget = this.#renderBudget(sections, ceiling);
+        const total = countTokens(PacketWire.renderSystemContent(scratch.system)) + countTokens(PacketWire.renderUserContent(scratch.user));
+        const tokensFree = ceiling === null ? null : Math.max(0, ceiling - total);
+        const percent = ceiling === null ? null : Math.round((total / ceiling) * 100);
+        const budget = tokensFree === null
+            ? scratch.user.telemetry.budget
+            : scratch.user.telemetry.budget
+                .replace(TOKEN_USAGE_PLACEHOLDER, String(total))
+                .replace(TOKEN_PERCENT_PLACEHOLDER, String(percent))
+                .replace(TOKENS_FREE_PLACEHOLDER, String(tokensFree));
+        const system = { tokens: 0, system_definition, persona, index, log };
+        const user = { tokens: 0, prompt, telemetry: { budget, errors: telemetryErrors }, system_requirements: requirements };
+        system.tokens = countTokens(PacketWire.renderSystemContent(system));
+        user.tokens = countTokens(PacketWire.renderUserContent(user));
+        return { system, user };
+    }
+    // Budget readout body, rendered into the `# Plurnk System Budget` section.
+    // Headline `ceiling/free` only when a ceiling exists; section lines for the
+    // curatable index/log weight the model can HIDE back. tokensFree is a
+    // placeholder here — buildSystem substitutes it after measuring the packet.
+    #renderBudget(sections, ceiling) {
+        const lines = [];
+        if (ceiling !== null)
+            lines.push(`ceiling ${ceiling} · usage ${TOKEN_USAGE_PLACEHOLDER} (${TOKEN_PERCENT_PLACEHOLDER}%) · free ${TOKENS_FREE_PLACEHOLDER}`);
+        if (sections.index.channels > 0)
+            lines.push(`Index previews: ${sections.index.channels} channels, ${sections.index.tokens} tokens`);
+        if (sections.log.entries > 0) {
+            lines.push(`Log entries: ${sections.log.entries} entries, ${sections.log.tokens} tokens`);
+            if (sections.log.byScheme.length > 0) {
+                lines.push("| scheme | entries | tokens |", "|---|--:|--:|");
+                for (const s of sections.log.byScheme)
+                    lines.push(`| ${s.scheme} | ${s.entries} | ${s.tokens} |`);
+            }
+        }
+        return lines.join("\n");
     }
-    // user.telemetry.budget — SHIM. Real per-scheme breakdown +
-    // context-window "free/percent-of-total" is SPEC.md §14.2; depends on
-    // provider.getContextSize and write-time per-row tokens. Until then,
-    // render the section-aggregate counts we already compute so the wire's
-    // `# Plurnk System Budget` section is non-empty for picking-apart purposes.
-    #renderBudgetShim(systemTokens, provider, prompt, telemetryErrors) {
-        const userPromptTokens = provider.countTokens(prompt);
-        const userErrTokens = provider.countTokens(JSON.stringify(telemetryErrors));
-        const userTokens = userPromptTokens + userErrTokens;
-        const total = systemTokens + userTokens;
-        const pct = (n) => total === 0 ? "0.0%" : `${((n / total) * 100).toFixed(1)}%`;
-        return [
-            "| Section | Used | Percent |",
-            "|---|---|---|",
-            `| system | ${systemTokens} | ${pct(systemTokens)} |`,
-            `| user | ${userTokens} | ${pct(userTokens)} |`,
-            `| **Total** | **${total}** | **100.0%** |`,
-        ].join("\n");
+    // SPEC §14.4 — the budget grinder. Runs pre-LLM (in runTurn, after the packet
+    // is built, before provider.generate); fires only on actual overflow. Two
+    // passes, re-measuring between. Hides (never deletes) — the prior turn's logs,
+    // then the catalog except the manifest lifeline. The strike it raises and the
+    // hard-stop it can signal are returned to runLoop, which owns abandonment.
+    async #enforceBudget({ packet, provider, runId, loopId, turnId, sessionId, turnNumber, rebuild }) {
+        const ceiling = _a.computeCeiling(provider.contextSize, this.#budgetCeiling);
+        const measure = (p) => p.system.tokens + p.user.tokens;
+        if (ceiling === null || measure(packet) <= ceiling)
+            return { packet, fit: true, struck: false };
+        const hidden = new Map();
+        const note = (scheme) => { hidden.set(scheme, (hidden.get(scheme) ?? 0) + 1); };
+        // Pass 1 — prior-turn rollback: hide the latest emissions (the ones that
+        // pushed it over). No prior turn (turn 1, env overflow) → no-op → pass 2.
+        const priorLogs = await this.#db.engine_grinder_prior_turn_logs.all({ loop_id: loopId, turn_id: turnId });
+        for (const le of priorLogs)
+            note(le.scheme ?? "log");
+        if (priorLogs.length > 0)
+            await this.#db.engine_grinder_hide_prior_turn_logs.run({ loop_id: loopId, turn_id: turnId });
+        const errors = packet.user.telemetry.errors;
+        let current = priorLogs.length > 0 ? await rebuild(errors) : packet;
+        if (measure(current) <= ceiling) {
+            this.#emitBudgetOverflow(sessionId, loopId, hidden);
+            return { packet: current, fit: true, struck: turnNumber > 1 };
+        }
+        // Pass 2 — index collapse: hide every catalog entry except the manifest.
+        const catalog = await this.#db.engine_grinder_catalog.all({ run_id: runId, session_id: sessionId });
+        for (const c of catalog)
+            note(c.scheme);
+        if (catalog.length > 0) {
+            const pairs = JSON.stringify(catalog.map((c) => ({ entry_id: c.entry_id, channel: c.channel })));
+            await this.#db.engine_grinder_hide_catalog.run({ run_id: runId, pairs });
+        }
+        current = catalog.length > 0 ? await rebuild(errors) : current;
+        this.#emitBudgetOverflow(sessionId, loopId, hidden);
+        return { packet: current, fit: measure(current) <= ceiling, struck: turnNumber > 1 };
     }
-    // Wire projection lives in ./packet-wire.js (plain JS) so Engine and
-    // bin/digest.js import the exact same function — structurally one
+    // The model-facing budget event (SPEC §14.4, §15.1): which entries left the
+    // window, by scheme — the model's own terms, no mechanism vocabulary. The
+    // strike this overflow triggers stays engine-internal (gamification policy).
+    #emitBudgetOverflow(sessionId, loopId, hidden) {
+        if (hidden.size === 0)
+            return;
+        this.#pushTelemetry(sessionId, loopId, {
+            source: "engine:rail",
+            kind: "budget_overflow",
+            hidden: [...hidden.entries()].map(([scheme, count]) => ({ scheme, count })),
+        });
+    }
+    // Wire projection lives in ./packet-wire.ts so Engine and
+    // bin/digest.ts import the exact same function — structurally one
     // implementation, no drift between wire and digest possible.
     // Format: markdown (user pick over rummy's XML alternative, 2026-05-22).
     #packetToWireMessages(packet) {
-        return packetToWireMessages(packet);
+        return PacketWire.packetToWireMessages(packet);
     }
     // Complete the packet by adding the model's response. After this the
     // packet matches Packet.json fully and is ready for storage.
@@ -779,6 +937,7 @@ export default class Engine {
                 content: result.preview,
                 mimetype: row.mimetype,
                 tokens: row.tokens,
+                lines: result.totalLines,
             };
         }
         return [...entries.values()];
@@ -793,7 +952,9 @@ export default class Engine {
             streamEventNotify: this.#streamEventNotify,
             wakeRunNotify: this.#wakeRunNotify,
             mimetypes: this.#mimetypes,
+            tokenize: this.#tokenize,
             pushTelemetry: (event) => this.#pushTelemetry(sessionId, loopId, event),
+            executors: this.#executors,
         };
         let result;
         let denial = this.#checkWritable(statement, origin);
@@ -846,6 +1007,13 @@ export default class Engine {
         // 202 in the result the caller sees, so runTurn never branches on
         // a pending state.
         if (result.status === 202) {
+            // Effect-gated auto-run (read/pure runtimes, plurnk-service#182):
+            // no human gate, no loop/proposal notification. Accept + apply
+            // in-process; the model sees the outcome directly, never a review.
+            if (result.attrs?.inline === true) {
+                const effective = await this.#runApplyResolution(statement, result, { decision: "accept" }, { sessionId, runId, loopId, turnId });
+                return this.#applyResolution(logEntryId, effective);
+            }
             // Register the resolution waiter SYNCHRONOUSLY before any await
             // yields. A same-tick resolveProposal() (e.g. from a test that
             // awaits the onDispatch callback and immediately resolves) must
@@ -906,7 +1074,9 @@ export default class Engine {
                 writer: "model", signal: this.#loopAborts.get(loopId)?.signal,
                 streamEventNotify: this.#streamEventNotify,
                 wakeRunNotify: this.#wakeRunNotify,
+                tokenize: this.#tokenize,
                 pushTelemetry: (event) => this.#pushTelemetry(sessionId, loopId, event),
+                executors: this.#executors,
             };
             const applyResult = await handler.applyResolution({
                 attrs: (originalResult.attrs ?? {}),
@@ -920,14 +1090,14 @@ export default class Engine {
                 };
             }
             // Propagate applyResolution.outcome onto the accepted resolution
-            // so the log entry's outcome column reflects operational metadata
-            // (e.g. exec's "exit_N"). Without this, only failures get an
-            // outcome on the durable record, and "ran cleanly but with a
-            // notable detail" has nowhere to land.
-            if (applyResult.outcome !== undefined && resolution.outcome === undefined) {
-                return { ...resolution, outcome: applyResult.outcome };
-            }
-            return resolution;
+            // (operational metadata, e.g. exec's "exit_N") AND its body — an
+            // inline (read/pure) run returns its output as the body, which has
+            // to reach the model-facing result this turn, not just stream to
+            // the entry. Host accepts carry no body (fire-and-forget).
+            const withOutcome = applyResult.outcome !== undefined && resolution.outcome === undefined
+                ? { ...resolution, outcome: applyResult.outcome }
+                : resolution;
+            return applyResult.body === undefined ? withOutcome : { ...withOutcome, body: applyResult.body };
         }
         catch (err) {
             return {
@@ -995,13 +1165,14 @@ export default class Engine {
             signal: this.#loopAborts.get(loopId)?.signal,
             streamEventNotify: this.#streamEventNotify,
             wakeRunNotify: this.#wakeRunNotify,
+            tokenize: this.#tokenize,
             pushTelemetry: (event) => this.#pushTelemetry(sessionRow.session_id, loopId, event),
         };
         const entry = {
             channels: { body: { content: prompt, mimetype: "text/markdown" } },
             tags: [],
         };
-        await writeEntry(pathname, entry, ctx, "plurnk");
+        await EntryCrud.writeEntry(pathname, entry, ctx, "plurnk");
         return { loopId, turnSeq };
     }
     // Subscribe to proposal-pending events. Daemon registers a listener
@@ -1062,13 +1233,15 @@ export default class Engine {
             : decision === "reject" ? "rejected"
                 : "loop_aborted";
         const outcome = resolution.outcome ?? defaultOutcome;
-        // rx is the model-facing operation result. ONLY status — outcome
-        // is operational (security/admin) and stays on the log_entries
-        // column for forensics; body was an input echo with no value to
-        // the model; target/path lives in log_entries metadata and
-        // surfaces via the log section's `target` field uniformly.
+        // rx is the model-facing operation result. Status always; outcome is
+        // operational (stays on log_entries for forensics, never model-facing).
+        // Body is normally dropped — the propose preview was an input echo —
+        // EXCEPT an inline auto-run (read/pure) carries its run output AS the
+        // body, which is exactly the "what happened" the model needs this turn.
         // Per AGENTS.md "Operational hygiene on what the model sees."
-        const rx = JSON.stringify({ status });
+        const rx = (decision === "accept" && resolution.body !== undefined)
+            ? JSON.stringify({ status, body: resolution.body })
+            : JSON.stringify({ status });
         await this.#db.engine_resolve_log_entry.run({
             id: logEntryId, state, outcome, status_rx: status, rx,
         });
@@ -1123,7 +1296,7 @@ export default class Engine {
         return { status: 403, error: `writer '${origin}' is not in writableBy for scheme '${schemeName}'` };
     }
     // Per-loop flag gating. Schemes self-declare their flag affinity in
-    // their manifest (proposes / excludedInAsk / requiresWeb /
+    // their manifest (excludedInAsk / requiresWeb /
     // requiresInteraction); SchemeRegistry.resolveForLoop returns the
     // active set under the loop's persisted flags. Anything outside the
     // set returns 403 — action-entry-as-outcome carries the rejection.
@@ -1133,7 +1306,7 @@ export default class Engine {
             return null;
         const flags = await this.#loadLoopFlags(loopId);
         // Fast path: default flags gate nothing. (yolo never gates.)
-        if (!flags.noProposals && !flags.noWeb && !flags.noInteraction && flags.mode === "act")
+        if (!flags.noWeb && !flags.noInteraction && flags.mode === "act")
             return null;
         const active = this.#schemes.resolveForLoop(flags);
         const check = (target) => {
@@ -1173,8 +1346,9 @@ export default class Engine {
         const srcHandler = this.#schemes.get(srcSchemeName);
         if (srcHandler === undefined || typeof srcHandler.deleteEntry !== "function")
             return { status: 501 };
-        // Null-body MOVE = delete the source entry (per SPEC §6.5)
-        if (dstPath === null) {
+        // MOVE to /dev/null (the grammar's idiomatic delete) or a null-body
+        // MOVE deletes the source entry. SPEC §6.5.
+        if (dstPath === null || pathnameFromPath(dstPath) === "/dev/null") {
             const srcPathname = pathnameFromPath(srcPath);
             const delResult = await srcHandler.deleteEntry(srcPathname, ctx);
             return { status: delResult.status };
@@ -1206,12 +1380,12 @@ export default class Engine {
         if (srcResult.status !== 200 || srcResult.entry === null)
             return { status: 404, error: `COPY/MOVE source not found: ${srcSchemeName}://${srcPathname}` };
         const entry = srcResult.entry;
-        // Conflict check on destination
-        if (typeof dstHandler.readEntry === "function") {
-            const dstExists = await dstHandler.readEntry(dstPathname, ctx);
-            if (dstExists.status === 200)
-                return { status: 409, error: `COPY/MOVE destination exists: ${dstSchemeName}://${dstPathname}` };
-        }
+        // Destination read — the conflict/no-op verdict is deferred until the
+        // to-be-written content is known (after <L> slice + tag resolution below),
+        // so an identical re-copy resolves to 304 instead of a phantom 409.
+        const dstExisting = typeof dstHandler.readEntry === "function"
+            ? await dstHandler.readEntry(dstPathname, ctx)
+            : null;
         // Mimetype compatibility check against the destination scheme's manifest
         const dstManifest = dstHandler.constructor.manifest;
         const dstChannels = dstManifest?.channels ?? {};
@@ -1230,10 +1404,10 @@ export default class Engine {
         if (lineMarker !== null) {
             const sliced = {};
             for (const [channelName, channelData] of Object.entries(entry.channels)) {
-                if (isBinaryMimetype(channelData.mimetype)) {
+                if (MimetypeBinary.isBinaryMimetype(channelData.mimetype)) {
                     return { status: 415, error: `cannot slice <L> on binary channel '${channelName}' (${channelData.mimetype})` };
                 }
-                const r = sliceLinesRaw(channelData.content ?? "", lineMarker);
+                const r = LineMarkerOps.sliceLinesRaw(channelData.content ?? "", lineMarker);
                 if (r.status !== 200)
                     return { status: r.status, error: r.error };
                 sliced[channelName] = { ...channelData, content: r.text ?? "" };
@@ -1244,6 +1418,21 @@ export default class Engine {
         const tags = (Array.isArray(statement.signal) && statement.signal.length > 0)
             ? statement.signal
             : entry.tags;
+        // 304/409 on an existing destination (SPEC §6.4): a re-copy that would write
+        // exactly what's already there — same channel contents, same tags — is a no-op
+        // (304), mirroring EDIT's 304-on-noop (§6.1). A divergent destination is a real
+        // collision (409); COPY/MOVE never clobbers.
+        if (dstExisting !== null && dstExisting.status === 200 && dstExisting.entry !== null) {
+            const dstChannels = dstExisting.entry.channels;
+            const writeNames = Object.keys(channels).sort();
+            const dstNames = Object.keys(dstChannels).sort();
+            const sameContent = writeNames.length === dstNames.length
+                && writeNames.every((n, i) => n === dstNames[i] && (channels[n]?.content ?? "") === (dstChannels[n]?.content ?? ""));
+            const sameTags = [...tags].sort().join("") === [...dstExisting.entry.tags].sort().join("");
+            if (sameContent && sameTags)
+                return { status: 304 };
+            return { status: 409, error: `COPY/MOVE destination exists: ${dstSchemeName}://${dstPathname}` };
+        }
         const writeResult = await dstHandler.writeEntry(dstPathname, { channels, tags }, ctx);
         return { status: writeResult.status, entryId: writeResult.entryId, created: writeResult.created };
     }
@@ -1322,6 +1511,8 @@ export default class Engine {
             }
         }
         const attrs = JSON.stringify(attrsObj);
+        const txJson = JSON.stringify(statement);
+        const rxJson = JSON.stringify(result);
         const row = await this.#db.engine_insert_log_entry.get({
             run_id: runId,
             loop_id: loopId,
@@ -1340,11 +1531,12 @@ export default class Engine {
             params: target.params,
             fragment: target.fragment,
             lineMarker: lineMarkerJson,
-            tx: JSON.stringify(statement),
+            tx: txJson,
             mimetype_tx: "application/json",
-            rx: JSON.stringify(result),
+            rx: rxJson,
             mimetype_rx: "application/json",
             status_rx: result.status,
+            tokens: this.#tokenize(txJson) + this.#tokenize(rxJson),
             state: isProposed ? "proposed" : "resolved",
             outcome: null,
             attrs,
@@ -1375,4 +1567,6 @@ export default class Engine {
         return JSON.stringify(signal);
     }
 }
+_a = Engine;
+export default Engine;
 //# sourceMappingURL=Engine.js.map