@plurnk/plurnk-service 0.2.0 → 0.4.0

package/dist/core/Engine.js

@@ -1,6 +1,9 @@
 import { PlurnkParser } from "@plurnk/plurnk-grammar";
 import { Mimetypes, emptyRegistry } from "@plurnk/plurnk-mimetypes";
+import { writeEntry } from "../schemes/_entry-crud.js";
 import { DEFAULT_LOOP_FLAGS } from "./scheme-types.js";
+import { sliceLinesRaw } from "./line-marker.js";
+import { isBinaryMimetype } from "./mimetype-binary.js";
 // 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/.
@@ -67,17 +70,57 @@ const readPositiveInt = (envVar, fallback) => {
         return fallback;
     return n;
 };
-// Per-op fingerprint: op verb + target URI. Body deliberately excluded so the
-// model writing varied content to the same target still trips. Path kind is
-// included as a discriminator (url vs local). Rummy parallel: scheme +
-// sorted attributes joined by '='.
+// Per-op fingerprint: op verb + target URI, plus an op-specific discriminator
+// where the activity isn't fully captured by target alone:
+//   - EDIT/COPY/MOVE: body excluded — re-writing the same target with varied
+//     content IS cycling (the model is producing different versions of the
+//     same artifact instead of progressing).
+//   - FIND/READ/SHOW/HIDE: body IS the search/selection pattern; varied
+//     matchers on the same target ARE different activities (the model is
+//     exploring different queries, not repeating one).
 const fingerprintOp = (stmt) => {
-    const path = stmt.path;
-    if (path === null)
+    const path = stmt.target;
+    const matcherDiscriminator = () => {
+        // For matcher-bearing ops, the body's `raw` (matcher source) plus
+        // any lineMarker forms the activity discriminator.
+        const parts = [];
+        const body = stmt.body;
+        if (body !== null && typeof body === "object" && typeof body.raw === "string") {
+            parts.push(`body:${body.raw.slice(0, 64)}`);
+        }
+        const lm = stmt.lineMarker;
+        if (lm !== null && lm !== undefined)
+            parts.push(`L:${lm.first},${lm.last ?? ""}`);
+        return parts.length > 0 ? `|${parts.join("|")}` : "";
+    };
+    if (path === null) {
+        // Path-less ops need an activity-defining discriminator other
+        // than `target`. Picked per op so the cycle detector reflects
+        // intent rather than syntax:
+        //   - EXEC: the command body IS the activity. Without a body
+        //     digest, varied shell commands (find / ls / wc) collapse to
+        //     one fingerprint and the detector mislabels exploration
+        //     as a loop.
+        //   - SEND: the status code (signal) IS the activity. Different
+        //     SEND[X] are different intentions; same SEND[X] with
+        //     different message bodies is the same termination signal.
+        if (stmt.op === "EXEC") {
+            const body = typeof stmt.body === "string" ? stmt.body : "";
+            return `EXEC|(no-path)${body.length > 0 ? `|body:${body.slice(0, 64)}` : ""}`;
+        }
+        if (stmt.op === "SEND") {
+            const signal = typeof stmt.signal === "number" ? stmt.signal : "";
+            return `SEND|(no-path)|signal:${signal}`;
+        }
         return `${stmt.op}|(no-path)`;
-    if (path.kind === "url")
-        return `${stmt.op}|${path.scheme}://${path.pathname}`;
-    return `${stmt.op}|local:${path.raw}`;
+    }
+    const base = path.kind === "url"
+        ? `${stmt.op}|${path.scheme}://${path.pathname}`
+        : `${stmt.op}|local:${path.raw}`;
+    if (stmt.op === "FIND" || stmt.op === "READ" || stmt.op === "SHOW" || stmt.op === "HIDE") {
+        return `${base}${matcherDiscriminator()}`;
+    }
+    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.
@@ -135,9 +178,19 @@ export default class Engine {
     // event emitter — no priority, no veto chain at this layer; filter
     // chains come later if a real consumer needs them.
     #proposalPendingListeners = [];
-    constructor({ db, schemes, mimetypes }) {
+    // Per-loop AbortController for cancellation propagation into scheme
+    // ctx.signal. runLoop creates one at entry, cleans up at end. Engine
+    // cancellation paths (strikes, max_turns, external) abort it.
+    // Streaming schemes (exec) chain their per-spawn controllers off
+    // ctx.signal so cancelled loops tear down their background spawns.
+    #loopAborts = new Map();
+    #streamEventNotify;
+    #wakeRunNotify;
+    constructor({ db, schemes, mimetypes, streamEventNotify, wakeRunNotify }) {
         this.#db = db;
         this.#schemes = schemes;
+        this.#streamEventNotify = streamEventNotify;
+        this.#wakeRunNotify = wakeRunNotify;
         // Default to empty discovery — standalone Engine construction (in
         // tests) gets no handlers, and content flows through the framework's
         // raw-content fitContent fallback. Daemon-managed Engine receives a
@@ -164,7 +217,29 @@ export default class Engine {
     async runLoop({ provider, messages, persona = "", sessionId, runId, loopId, maxTurns = 50, maxStrikes = readMaxStrikes(), minCycles = readPositiveInt("PLURNK_MIN_CYCLES", DEFAULT_MIN_CYCLES), maxCyclePeriod = readPositiveInt("PLURNK_MAX_CYCLE_PERIOD", DEFAULT_MAX_CYCLE_PERIOD), origin = "model", signal, onDispatch, }) {
         const turnIds = [];
         const suddenDeathThreshold = maxTurns - maxStrikes;
-        const cleanup = () => {
+        // Per-loop AbortController for scheme-side cancellation propagation.
+        // Chained from the caller's `signal` so an external abort cascades.
+        const loopAbort = new AbortController();
+        if (signal !== undefined) {
+            if (signal.aborted)
+                loopAbort.abort(signal.reason);
+            else
+                signal.addEventListener("abort", () => loopAbort.abort(signal.reason), { once: true });
+        }
+        this.#loopAborts.set(loopId, loopAbort);
+        // Cleanup splits by termination kind:
+        // - "graceful" (loop emitted SEND[2xx]): in-flight streaming-scheme
+        //   spawns are ALLOWED to outlive the loop. They complete naturally,
+        //   write final channel state, and wake-on-completion (E.4) opens a
+        //   fresh loop in the same run if the model needs to react.
+        // - "forceful" (max_turns, strike_threshold, external cancel,
+        //   non-2xx loop status): fire the loop-level abort so spawns
+        //   tear down immediately.
+        const cleanup = (kind, reason) => {
+            if (kind === "forceful" && !loopAbort.signal.aborted) {
+                loopAbort.abort(reason ?? "loop_forceful_termination");
+            }
+            this.#loopAborts.delete(loopId);
             this.#strikeState.delete(loopId);
             this.#telemetryBuffer.delete(loopId);
         };
@@ -174,12 +249,15 @@ export default class Engine {
             if (row === undefined)
                 throw new Error(`Engine.runLoop: loop ${loopId} not found`);
             if (row.status !== 102) {
-                cleanup();
+                // Status 2xx = graceful (model said done); 4xx/5xx = forceful
+                // (external cancel or upstream failure). The threshold splits
+                // at 400 to match HTTP success/error semantics.
+                cleanup(row.status < 400 ? "graceful" : "forceful", `loop_terminal_${row.status}`);
                 return { turnIds, finalStatus: row.status, hitMaxTurns: false, reason: "external" };
             }
             if (turnIds.length >= maxTurns) {
                 await this.#db.engine_loop_cancel.run({ loop_id: loopId });
-                cleanup();
+                cleanup("forceful", "max_turns");
                 return { turnIds, finalStatus: 499, hitMaxTurns: true, reason: "max_turns" };
             }
             const turn = await this.runTurn({
@@ -199,7 +277,7 @@ export default class Engine {
                     kind: "cycle",
                     period: cycle.period,
                     cycles: cycle.cycles,
-                    message: `repeating pattern detected: ${cycle.cycles}× period-${cycle.period}; vary your approach`,
+                    message: "Loop detected",
                 });
             }
             this.#strikeState.set(loopId, state);
@@ -214,15 +292,17 @@ export default class Engine {
             const struck = noOps || recordedFailed || state.turnErrors > 0;
             if (struck) {
                 state.streak++;
+                const reason = noOps ? "no_ops" : recordedFailed ? "recorded_failure" : "rail";
                 this.#pushTelemetry(loopId, {
                     kind: "strike",
                     streak: state.streak,
                     maxStrikes,
-                    reason: noOps ? "no_ops" : recordedFailed ? "recorded_failure" : "rail",
+                    reason,
+                    message: `strike ${state.streak}/${maxStrikes} (${reason}); ${maxStrikes - state.streak} before abandonment`,
                 });
                 if (state.streak >= maxStrikes) {
                     await this.#db.engine_loop_cancel.run({ loop_id: loopId });
-                    cleanup();
+                    cleanup("forceful", "strike_threshold");
                     return { turnIds, finalStatus: 499, hitMaxTurns: false, reason: "strike_threshold" };
                 }
             }
@@ -238,19 +318,70 @@ export default class Engine {
             if (turnIds.length >= suddenDeathThreshold && turnIds.length < maxTurns) {
                 this.#pushTelemetry(loopId, {
                     kind: "sudden_death",
-                    message: `approaching max turns: ${turnIds.length} of ${maxTurns}; emit SEND[200] to complete`,
+                    message: `${turnIds.length} of ${maxTurns}`,
                     remaining: maxTurns - turnIds.length,
                 });
             }
         }
     }
     async runTurn({ provider, messages, persona = "", sessionId, runId, loopId, origin = "model", signal, onDispatch, turnNumber = 1, maxTurns = 50, }) {
-        // Build the spec'd packet (Packet.json) request half BEFORE the
-        // provider call. The wire payload is a projection OF this packet;
-        // the stored packet is the same object completed with the
-        // assistant section after the response arrives.
+        // === Turn-as-container model ===
+        //
+        // Turn rows are created at runTurn OPEN (status=102, placeholder
+        // packet) so things can be written into the turn before the model
+        // is called: the user prompt on turn 1; later, system signals or
+        // injected telemetry events on any turn. The turn is CLOSED at
+        // the end with the final packet + status + usage stats.
+        //
+        // sequence is "ordinal of stuff in this turn." Pre-model
+        // writes consume low indices; model ops continue from there.
+        const seqRow = await this.#db.engine_next_turn_sequence.get({ loop_id: loopId });
+        const seq = seqRow.next;
+        const openRow = await this.#db.engine_open_turn.get({
+            loop_id: loopId, sequence: seq,
+        });
+        if (openRow === undefined)
+            throw new Error("Engine.runTurn: turn open returned no row");
+        const turnId = openRow.id;
+        // Pre-model writes. Each turn opens with a system-origin EDIT
+        // against `plurnk://prompt/<loop_id>/<seq>` IF there's a prompt
+        // for THIS turn the model hasn't seen yet:
+        //   - Turn 1: loop.prompt is the initial user prompt.
+        //   - Turn N>1: only if Engine.inject (or wake-on-completion via
+        //     daemon.inject) wrote a prompt entry for this turn slot
+        //     between turn N-1 and N. Inject writes directly to entries;
+        //     we DON'T re-foist here for N>1.
+        // The log records the EDIT for forensics. Model ops dispatch
+        // from sequence=2 onward on prompt-foisted turns; 1 onward
+        // otherwise.
+        let nextActionIndex = 1;
+        if (seq === 1) {
+            const promptRow = await this.#db.engine_get_loop_prompt.get({ loop_id: loopId });
+            if (promptRow !== undefined && typeof promptRow.prompt === "string" && promptRow.prompt.length > 0) {
+                const promptPath = {
+                    kind: "url", raw: `plurnk://prompt/${loopId}/${seq}`,
+                    scheme: "plurnk", username: null, password: null,
+                    hostname: null, port: null,
+                    pathname: `prompt/${loopId}/${seq}`, params: {}, fragment: null,
+                };
+                const promptStmt = {
+                    op: "EDIT", suffix: "", signal: null,
+                    target: promptPath, lineMarker: null,
+                    body: promptRow.prompt, position: { line: 1, column: 1 },
+                };
+                await this.dispatch({
+                    statement: promptStmt, sessionId, runId, loopId, turnId,
+                    sequence: nextActionIndex, origin: "system",
+                });
+                nextActionIndex++;
+            }
+        }
+        // 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({
-            initialMessages: messages, persona, runId, loopId, turnNumber, maxTurns, provider,
+            initialMessages: messages, persona, runId, loopId,
+            turnNumber, currentTurnSeq: seq, maxTurns, provider,
         });
         const modelMessages = this.#packetToWireMessages(requestPacket);
         const response = await provider.generate({ messages: modelMessages, signal });
@@ -258,7 +389,15 @@ export default class Engine {
         // parsed ops) → packet.assistant per Packet.json §assistant;
         // call-metadata (usage, finishReason, model) → Turn columns per
         // Turn.json. Mixing the two on packet.assistant was the wrong layer.
-        const { packetAssistant, callMetadata } = this.#splitResponse(response);
+        const { packetAssistant, callMetadata, parseErrors } = this.#splitResponse(response);
+        // Surface parse errors to the model's NEXT packet so it can self-
+        // correct. Without this, malformed emissions (e.g. a READ matcher
+        // body starting with `//` being interpreted as xpath) silently
+        // drop, the model sees zero ops dispatched, strike-rail fires,
+        // model has no feedback on WHY its emission didn't take effect.
+        for (const message of parseErrors ?? []) {
+            this.#pushTelemetry(loopId, { kind: "parse_error", message });
+        }
         const opsCount = packetAssistant.ops.length;
         const sendOp = packetAssistant.ops.findLast((op) => op.op === "SEND" && typeof op.signal === "number");
         // Rail #41 (revised): the per-turn requirement is "emit at least one
@@ -267,16 +406,11 @@ export default class Engine {
         const turnStatus = sendOp !== undefined
             ? sendOp.signal
             : opsCount === 0 ? TURN_STATUS_NO_OPS : TURN_STATUS_IMPLICIT_CONTINUE;
-        const seqRow = await this.#db.engine_next_turn_sequence.get({ loop_id: loopId });
-        const seq = seqRow.next;
-        // Complete the spec'd packet by adding the response section.
-        // requestPacket already has system + user matching what was sent
-        // to the LLM (one source of truth across wire payload and storage).
+        // Close the turn with the final packet, status, and usage stats.
         const packet = this.#completePacket(requestPacket, packetAssistant, response.assistantRaw, provider);
         const { usage, finishReason, model } = callMetadata;
-        const turnRow = await this.#db.engine_insert_turn.get({
-            loop_id: loopId,
-            sequence: seq,
+        await this.#db.engine_close_turn.run({
+            id: turnId,
             status: turnStatus,
             packet: JSON.stringify(packet),
             usage_prompt: usage.prompt,
@@ -286,13 +420,14 @@ export default class Engine {
             finish_reason: finishReason,
             model,
         });
-        if (turnRow === undefined)
-            throw new Error("Engine.runTurn: turn insert returned no row");
-        const turnId = turnRow.id;
+        // Dispatch model ops starting at nextActionIndex (continues the
+        // turn's running counter after any pre-model writes).
         const statuses = [];
-        for (const [actionIndex, statement] of packetAssistant.ops.entries()) {
+        for (const [i, statement] of packetAssistant.ops.entries()) {
             const result = await this.dispatch({
-                statement, sessionId, runId, loopId, turnId, actionIndex, origin, onDispatch,
+                statement, sessionId, runId, loopId, turnId,
+                sequence: nextActionIndex + i,
+                origin, onDispatch,
             });
             statuses.push(result.status);
         }
@@ -323,6 +458,7 @@ export default class Engine {
         const preParsedOps = assistant.ops;
         const ops = [];
         const textFragments = [];
+        const parseErrors = [];
         if (preParsedOps !== undefined) {
             ops.push(...preParsedOps);
         }
@@ -336,6 +472,11 @@ export default class Engine {
                     if (trimmed.length > 0)
                         textFragments.push(trimmed);
                 }
+                else if (item.kind === "error") {
+                    const err = item.error;
+                    const msg = (err && typeof err.message === "string") ? err.message : "parse error";
+                    parseErrors.push(msg);
+                }
             }
         }
         const wireReasoning = assistant.reasoning ?? "";
@@ -345,6 +486,7 @@ export default class Engine {
         return {
             packetAssistant: { content: assistant.content, ops, reasoning },
             callMetadata: { usage: assistant.usage, finishReason: assistant.finishReason, model: assistant.model },
+            parseErrors,
         };
     }
     // Assemble the request half of the spec'd packet (Packet.json §system
@@ -354,18 +496,26 @@ export default class Engine {
     // Per Packet.json: user.prompt is "Copy of loop.prompt — never null on
     // a continuation turn"; the turn-N-of-M continuation marker rides on
     // user.system_requirements (per-turn rules), NOT a mutated prompt.
-    async #buildRequestPacket({ initialMessages, persona: defaultPersona, runId, loopId, turnNumber, maxTurns, provider, }) {
+    async #buildRequestPacket({ initialMessages, persona: defaultPersona, runId, loopId, turnNumber, currentTurnSeq, maxTurns, provider, }) {
         const byRole = (role) => initialMessages.filter((m) => m.role === role).map((m) => m.content).join("\n\n");
         const system_definition = byRole("system");
-        const prompt = byRole("user");
+        // user.prompt sources from the loop's most recent prompt entry first
+        // (plurnk://prompt/<loop_id>/<N> for the highest N written to date).
+        // This is what inject + the turn-1 foist write into. Falls back to
+        // the runLoop caller's messages.user for tests that bypass the
+        // foist mechanism entirely.
+        const latestPromptRow = await this.#db.drain_get_latest_prompt_body_for_loop.get({ pattern: `prompt/${loopId}/%` });
+        const prompt = (latestPromptRow !== undefined && typeof latestPromptRow.content === "string" && latestPromptRow.content.length > 0)
+            ? latestPromptRow.content
+            : byRole("user");
         // Resolve persona cascade: loops.persona > runs.persona >
         // sessions.persona > caller-supplied default. SQL coalesces in one
         // query; null result means no DB override exists, use the default.
         const row = await this.#db.engine_resolve_persona.get({ loop_id: loopId });
         const persona = (row?.persona !== undefined && row?.persona !== null) ? row.persona : defaultPersona;
-        const index = await this.#buildIndex(runId);
-        const log = await this.#buildLog(loopId);
-        const telemetryErrors = await this.#buildTelemetryErrors(loopId);
+        const index = await this.#buildIndex(runId, loopId);
+        const log = await this.#buildLog(runId);
+        const telemetryErrors = await this.#buildTelemetryErrors(loopId, currentTurnSeq);
         // Rummy AgentLoop.js #buildContinuationPrompt: literally
         // `Turn ${turn}/${maxTurns}`. That's the whole string. The model
         // can read the action log to see what it already did; it does
@@ -455,16 +605,16 @@ export default class Engine {
     //   1. Previous-turn action-bound failures (status_rx >= 400 on log_entries).
     //   2. Engine-buffered actionless failures (no_send, parse, watchdog, rails).
     // Buffer drains on read — each error appears in exactly one packet.
-    async #buildTelemetryErrors(loopId) {
-        const rows = await this.#db.engine_render_telemetry_errors.all({ loop_id: loopId });
+    async #buildTelemetryErrors(loopId, currentTurnSeq) {
+        const rows = await this.#db.engine_render_telemetry_errors.all({ loop_id: loopId, current_turn_seq: currentTurnSeq });
         const actionFailures = rows.map((r) => {
-            const target = r.target_scheme !== null
-                ? `${r.target_scheme}://${r.target_pathname ?? ""}`
-                : (r.target_pathname ?? null);
+            const target = r.scheme !== null
+                ? `${r.scheme}://${r.pathname ?? ""}`
+                : (r.pathname ?? null);
             const parsedRx = r.mimetype_rx === "application/json" ? JSON.parse(r.rx) : r.rx;
             return {
                 kind: "action_failure",
-                coordinate: `${r.loop_seq}/${r.turn_seq}/${r.action_index}`,
+                coordinate: `${r.loop_seq}/${r.turn_seq}/${r.sequence}`,
                 op: r.op,
                 target,
                 status: r.status_rx,
@@ -478,60 +628,64 @@ export default class Engine {
     // SPEC §15 packet.system.log — chronological action-entries for the loop.
     // Snapshot is taken at packet build (pre-dispatch this turn), so it
     // reflects "what has happened before this turn." Each row carries a
-    // log://<loop_seq>/<turn_seq>/<action_index> coordinate the model can READ.
-    async #buildLog(loopId) {
-        const rows = await this.#db.engine_render_log.all({ loop_id: loopId });
-        const entries = rows.map((r) => ({
-            coordinate: `${r.loop_seq}/${r.turn_seq}/${r.action_index}`,
+    // log://<loop_seq>/<turn_seq>/<sequence> coordinate the model can READ.
+    async #buildLog(runId) {
+        // SPEC §0.6: runs own log entries — log is the run's history,
+        // not the loop's. Span all loops in the run so the model sees
+        // earlier loops' work as conversational memory.
+        //
+        // User prompts are first-class log entries: runTurn writes a
+        // client-origin SEND[200] row at sequence=0 of each new
+        // turn-1. Prompts thus surface naturally in this query — no
+        // synthetic / shim layer.
+        const rows = await this.#db.engine_render_log.all({ run_id: runId });
+        return rows.map((r) => ({
+            coordinate: `${r.loop_seq}/${r.turn_seq}/${r.sequence}`,
             origin: r.origin,
             op: r.op,
             suffix: r.suffix,
             signal: r.signal === null ? null : JSON.parse(r.signal),
             target: {
-                scheme: r.target_scheme,
-                username: r.target_username, password: r.target_password,
-                hostname: r.target_hostname, port: r.target_port,
-                pathname: r.target_pathname,
-                params: r.target_params === null ? null : JSON.parse(r.target_params),
-                fragment: r.target_fragment,
+                scheme: r.scheme,
+                username: r.username, password: r.password,
+                hostname: r.hostname, port: r.port,
+                pathname: r.pathname,
+                params: r.params === null ? null : JSON.parse(r.params),
+                fragment: r.fragment,
             },
             status: r.status_rx,
             rx: r.mimetype_rx === "application/json" ? JSON.parse(r.rx) : r.rx,
             mimetype_rx: r.mimetype_rx,
+            tx: r.mimetype_tx === "application/json" ? JSON.parse(r.tx) : r.tx,
+            mimetype_tx: r.mimetype_tx,
         }));
-        // Synthetic prompt entry — SHIM per AGENTS.md §Open. Prepends a
-        // "PROMPT" entry sourced from loops.prompt so `# Plurnk System Log`
-        // is never empty on turn 1. NOT URI-addressable yet (no
-        // corresponding row in log_entries / no scheme handler); real fix
-        // logs the prompt as a first-class entry the model can READ.
-        const loopRow = await this.#db.engine_get_loop_prompt.get({ loop_id: loopId });
-        if (loopRow !== undefined && typeof loopRow.prompt === "string" && loopRow.prompt.length > 0) {
-            entries.unshift({
-                coordinate: `${loopRow.sequence}/0/0`,
-                origin: "client",
-                op: "PROMPT",
-                suffix: "",
-                signal: null,
-                target: {
-                    scheme: null, username: null, password: null,
-                    hostname: null, port: null, pathname: null,
-                    params: null, fragment: null,
-                },
-                status: 200,
-                rx: loopRow.prompt,
-                mimetype_rx: "text/plain",
-            });
-        }
-        return entries;
     }
-    async #buildIndex(runId) {
+    async #buildIndex(runId, currentLoopId) {
         const rows = await this.#db.engine_render_index.all({ run_id: runId });
         const tagsStmt = this.#db.engine_entry_tags;
+        // Foist the CURRENT loop's prompt entries out of the index render —
+        // their bodies are materialized in packet.user.prompt instead. With
+        // multi-turn injection, a loop can have multiple prompt entries at
+        // plurnk://prompt/<loop_id>/<N>; all of them get foisted, leaving
+        // only previous loops' prompts (still addressable for HIDE).
+        const foistedPrefix = `prompt/${currentLoopId}/`;
+        // Backward compat: legacy single-slot path. Tests / older runs may
+        // still have a `prompt/<loop_id>` entry (no trailing /N); foist it too.
+        const foistedExact = `prompt/${currentLoopId}`;
         const entries = new Map();
         for (const row of rows) {
+            if (row.scheme === "plurnk"
+                && (row.pathname === foistedExact || row.pathname.startsWith(foistedPrefix)))
+                continue;
             let entry = entries.get(row.entry_id);
             if (entry === undefined) {
                 const tagRows = await tagsStmt.all({ entry_id: row.entry_id });
+                // defaultChannel pulled from the row's scheme manifest. The
+                // wire renderer uses it to omit `#channel` on fences whose
+                // channel is the scheme's default — that absence is the
+                // addressing of the default channel.
+                const handler = this.#schemes.get(row.scheme ?? "");
+                const manifest = handler?.constructor?.manifest;
                 entry = {
                     id: row.entry_id,
                     version: row.version,
@@ -545,6 +699,7 @@ export default class Engine {
                     pathname: row.pathname,
                     params: row.params === null ? null : JSON.parse(row.params),
                     channels: {},
+                    defaultChannel: manifest?.defaultChannel ?? "",
                     attributes: JSON.parse(row.attributes),
                     tags: tagRows.map((r) => r.tag),
                 };
@@ -565,15 +720,20 @@ export default class Engine {
         return [...entries.values()];
     }
     async dispatch(context) {
-        const { statement, sessionId, runId, loopId, turnId, actionIndex, origin, onDispatch } = context;
+        const { statement, sessionId, runId, loopId, turnId, sequence, origin, onDispatch } = context;
         const schemeCtx = {
             db: this.#db,
             sessionId, runId, loopId, turnId,
             writer: origin,
-            signal: undefined,
+            signal: this.#loopAborts.get(loopId)?.signal,
+            streamEventNotify: this.#streamEventNotify,
+            wakeRunNotify: this.#wakeRunNotify,
+            mimetypes: this.#mimetypes,
         };
         let result;
-        const denial = this.#checkWritable(statement, origin);
+        let denial = this.#checkWritable(statement, origin);
+        if (denial === null)
+            denial = await this.#checkFlagsGate(statement, loopId);
         if (denial !== null) {
             result = denial;
         }
@@ -584,7 +744,7 @@ export default class Engine {
             // skips it. Logging failures (#writeLog throws) are NOT caught —
             // those are system failures.
             try {
-                if (statement.op === "SEND" && statement.path === null) {
+                if (statement.op === "SEND" && statement.target === null) {
                     result = await this.#handleSendBroadcast(statement, loopId);
                 }
                 else if (statement.op === "COPY") {
@@ -593,8 +753,15 @@ export default class Engine {
                 else if (statement.op === "MOVE") {
                     result = await this.#handleMove(statement, schemeCtx);
                 }
+                else if (statement.op === "EXEC") {
+                    // EXEC's target slot is `cwd`, not a scheme address.
+                    // Per plurnk.md the op routes unconditionally to the
+                    // exec scheme; the scheme handler reads runtime
+                    // (signal), cwd (target), and command (body).
+                    result = await this.#run("exec", statement, schemeCtx);
+                }
                 else {
-                    result = await this.#run(this.#schemeNameOf(statement.path), statement, schemeCtx);
+                    result = await this.#run(this.#schemeNameOf(statement.target), statement, schemeCtx);
                 }
             }
             catch (err) {
@@ -604,7 +771,7 @@ export default class Engine {
                 };
             }
         }
-        const logEntryId = await this.#writeLog({ statement, result, runId, loopId, turnId, actionIndex, origin });
+        const logEntryId = await this.#writeLog({ statement, result, runId, loopId, turnId, sequence, origin });
         onDispatch?.(logEntryId);
         // Proposal lifecycle (task #42, AGENTS.md §Phase E). When a scheme
         // returns status 202, the entry is written as state='proposed';
@@ -623,7 +790,7 @@ export default class Engine {
             // Notify external listeners (Daemon broadcasts loop/proposal;
             // YOLO listener auto-resolves) BEFORE awaiting — they may
             // resolve synchronously inside their handlers.
-            const target = this.#extractTarget(statement.path);
+            const target = this.#extractTarget(statement.target);
             const flags = await this.#loadLoopFlags(loopId);
             const event = {
                 logEntryId, sessionId, runId, loopId, turnId,
@@ -645,26 +812,40 @@ export default class Engine {
             // 4xx/5xx or throws, the resolution is downgraded to a reject
             // with the failure outcome — engine treats it like a client
             // rejection.
-            const effective = await this.#runApplyResolution(statement, result, resolution);
+            const effective = await this.#runApplyResolution(statement, result, resolution, { sessionId, runId, loopId, turnId });
             const post = await this.#applyResolution(logEntryId, effective);
             return post;
         }
         return result;
     }
-    async #runApplyResolution(statement, originalResult, resolution) {
+    async #runApplyResolution(statement, originalResult, resolution, ids) {
+        const { sessionId, runId, loopId, turnId } = ids;
         if (resolution.decision !== "accept")
             return resolution;
-        const schemeName = this.#schemeNameOf(statement.path);
+        // EXEC routes to the exec scheme regardless of target (cwd, not
+        // a scheme address). All other ops resolve their handler from
+        // statement.target's scheme.
+        const schemeName = statement.op === "EXEC" ? "exec" : this.#schemeNameOf(statement.target);
         if (schemeName === null)
             return resolution;
         const handler = this.#schemes.get(schemeName);
         if (handler === undefined || typeof handler.applyResolution !== "function")
             return resolution;
         try {
+            // Build a ctx for the scheme's applyResolution. The proposal
+            // was raised inside a specific (session, run, loop, turn);
+            // the scheme uses ctx to write the entry that makes the
+            // operation's artifact visible in the next packet's index.
+            const applyCtx = {
+                db: this.#db, sessionId, runId, loopId, turnId,
+                writer: "model", signal: this.#loopAborts.get(loopId)?.signal,
+                streamEventNotify: this.#streamEventNotify,
+                wakeRunNotify: this.#wakeRunNotify,
+            };
             const applyResult = await handler.applyResolution({
                 attrs: (originalResult.attrs ?? {}),
                 body: resolution.body,
-            });
+            }, applyCtx);
             if (applyResult.status >= 400) {
                 return {
                     decision: "reject",
@@ -672,6 +853,14 @@ export default class Engine {
                     body: applyResult.body,
                 };
             }
+            // 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;
         }
         catch (err) {
@@ -702,6 +891,52 @@ export default class Engine {
     pendingProposalIds() {
         return [...this.#pendingProposals.keys()];
     }
+    // Used by wake-on-completion (daemon side): "is there any loop in this
+    // run still accepting turns?" If yes, skip the wake — the active loop
+    // will pick up the channel transition at its next turn boundary. If no,
+    // the daemon opens a fresh loop with the wake prompt.
+    async hasActiveLoopForRun(runId) {
+        const row = await this.#db.engine_count_active_loops_for_run.get({ run_id: runId });
+        return (row?.n ?? 0) > 0;
+    }
+    // Inject a prompt into the run's currently-executing loop. Writes a
+    // plurnk://prompt/<loop_id>/<next-turn> entry whose body becomes
+    // packet.user.prompt at the next turn boundary. Last-wins: if two
+    // injects target the same next-turn slot, the second overwrites the
+    // first.
+    //
+    // Returns null when no loop in the run is currently active (status=102).
+    // The daemon-side inject path then enqueues a fresh loop with this
+    // prompt; engine doesn't open loops itself.
+    //
+    // Rummy parallel: AgentLoop.inject(). The "active drain → write
+    // prompt entry, return immediately" branch.
+    async inject(runId, prompt) {
+        const loopRow = await this.#db.drain_current_loop_for_run.get({ run_id: runId });
+        if (loopRow === undefined)
+            return null;
+        const loopId = loopRow.id;
+        const turnRow = await this.#db.drain_next_turn_seq_for_loop.get({ loop_id: loopId });
+        const turnSeq = turnRow?.next ?? 1;
+        const sessionRow = await this.#db.drain_get_run_session.get({ run_id: runId });
+        if (sessionRow === undefined)
+            throw new Error(`Engine.inject: run ${runId} not found`);
+        const pathname = `prompt/${loopId}/${turnSeq}`;
+        const ctx = {
+            db: this.#db, sessionId: sessionRow.session_id, runId, loopId,
+            turnId: 0, // no turn open at inject time; entries don't pin turnId
+            writer: "system",
+            signal: this.#loopAborts.get(loopId)?.signal,
+            streamEventNotify: this.#streamEventNotify,
+            wakeRunNotify: this.#wakeRunNotify,
+        };
+        const entry = {
+            channels: { body: { content: prompt, mimetype: "text/markdown" } },
+            tags: [],
+        };
+        await writeEntry(pathname, entry, ctx, "plurnk");
+        return { loopId, turnSeq };
+    }
     // Subscribe to proposal-pending events. Daemon registers a listener
     // that broadcasts the loop/proposal WS notification; YOLO listener
     // (Phase E.3) registers one that auto-resolves. Listeners fire BEFORE
@@ -760,7 +995,13 @@ export default class Engine {
             : decision === "reject" ? "rejected"
                 : "loop_aborted";
         const outcome = resolution.outcome ?? defaultOutcome;
-        const rx = JSON.stringify({ status, outcome, body: resolution.body ?? null });
+        // 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.
+        // Per AGENTS.md "Operational hygiene on what the model sees."
+        const rx = JSON.stringify({ status });
         await this.#db.engine_resolve_log_entry.run({
             id: logEntryId, state, outcome, status_rx: status, rx,
         });
@@ -776,15 +1017,20 @@ export default class Engine {
     #checkWritable(statement, origin) {
         if (!MUTATING_OPS.has(statement.op))
             return null;
-        if (statement.op === "SEND" && statement.path === null)
+        if (statement.op === "SEND" && statement.target === null)
             return null;
+        // EXEC's target slot is `cwd`, not a scheme address. The op's
+        // authority always belongs to the exec scheme regardless of cwd.
+        if (statement.op === "EXEC") {
+            return this.#denyIfDisallowed("exec", origin);
+        }
         if (statement.op === "COPY" || statement.op === "MOVE") {
             const dstScheme = this.#schemeNameOf(statement.body);
             const dstDenial = this.#denyIfDisallowed(dstScheme, origin);
             if (dstDenial !== null)
                 return dstDenial;
             if (statement.op === "MOVE") {
-                const srcScheme = this.#schemeNameOf(statement.path);
+                const srcScheme = this.#schemeNameOf(statement.target);
                 if (srcScheme !== dstScheme) {
                     const srcDenial = this.#denyIfDisallowed(srcScheme, origin);
                     if (srcDenial !== null)
@@ -793,7 +1039,7 @@ export default class Engine {
             }
             return null;
         }
-        const target = this.#schemeNameOf(statement.path);
+        const target = this.#schemeNameOf(statement.target);
         return this.#denyIfDisallowed(target, origin);
     }
     #denyIfDisallowed(schemeName, origin) {
@@ -809,10 +1055,37 @@ export default class Engine {
             return null;
         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 /
+    // 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.
+    async #checkFlagsGate(statement, loopId) {
+        // Broadcast SEND has no scheme to gate.
+        if (statement.op === "SEND" && statement.target === null)
+            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")
+            return null;
+        const active = this.#schemes.resolveForLoop(flags);
+        const check = (target) => {
+            const scheme = this.#schemeNameOf(target);
+            if (scheme === null)
+                return null;
+            if (active.has(scheme))
+                return null;
+            return { status: 403, error: `scheme '${scheme}' is inactive under current loop flags` };
+        };
+        if (statement.op === "COPY" || statement.op === "MOVE") {
+            return check(statement.target) ?? check(statement.body);
+        }
+        return check(statement.target);
+    }
     async #handleCopy(statement, ctx) {
         if (statement.op !== "COPY")
             throw new Error("unreachable");
-        const srcPath = statement.path;
+        const srcPath = statement.target;
         const dstPath = statement.body;
         if (srcPath === null)
             return { status: 400, error: "COPY requires source path" };
@@ -823,7 +1096,7 @@ export default class Engine {
     async #handleMove(statement, ctx) {
         if (statement.op !== "MOVE")
             throw new Error("unreachable");
-        const srcPath = statement.path;
+        const srcPath = statement.target;
         const dstPath = statement.body;
         if (srcPath === null)
             return { status: 400, error: "MOVE requires source path" };
@@ -881,11 +1154,30 @@ export default class Engine {
                 return { status: 415, error: `mimetype mismatch on channel '${channelName}': ${channelData.mimetype} vs ${expectedMimetype}` };
             }
         }
+        // `<L>` source range slicing per AGENTS.md "Resolved ambiguities" §4
+        // (symmetric with READ `<L>` — source range, no line-number prefix).
+        // Applied to every channel of the source entry. Binary channels return
+        // 415 since line semantics don't apply.
+        const lineMarker = statement.lineMarker ?? null;
+        let channels = entry.channels;
+        if (lineMarker !== null) {
+            const sliced = {};
+            for (const [channelName, channelData] of Object.entries(entry.channels)) {
+                if (isBinaryMimetype(channelData.mimetype)) {
+                    return { status: 415, error: `cannot slice <L> on binary channel '${channelName}' (${channelData.mimetype})` };
+                }
+                const r = sliceLinesRaw(channelData.content ?? "", lineMarker);
+                if (r.status !== 200)
+                    return { status: r.status, error: r.error };
+                sliced[channelName] = { ...channelData, content: r.text ?? "" };
+            }
+            channels = sliced;
+        }
         // Tag resolution: signal = replace; absent/empty = carry from source
         const tags = (Array.isArray(statement.signal) && statement.signal.length > 0)
             ? statement.signal
             : entry.tags;
-        const writeResult = await dstHandler.writeEntry(dstPathname, { channels: entry.channels, tags }, ctx);
+        const writeResult = await dstHandler.writeEntry(dstPathname, { channels, tags }, ctx);
         return { status: writeResult.status, entryId: writeResult.entryId, created: writeResult.created };
     }
     async #handleSendBroadcast(statement, loopId) {
@@ -921,8 +1213,8 @@ export default class Engine {
             return path.scheme;
         return "file"; // local (bare) → file
     }
-    async #writeLog({ statement, result, runId, loopId, turnId, actionIndex, origin, }) {
-        const target = this.#extractTarget(statement.path);
+    async #writeLog({ statement, result, runId, loopId, turnId, sequence, origin, }) {
+        const target = this.#extractTarget(statement.target);
         const lineMarkerJson = "lineMarker" in statement && statement.lineMarker !== null
             ? JSON.stringify(statement.lineMarker)
             : null;
@@ -940,19 +1232,19 @@ export default class Engine {
             run_id: runId,
             loop_id: loopId,
             turn_id: turnId,
-            action_index: actionIndex,
+            sequence: sequence,
             origin,
             op: statement.op,
             suffix: statement.suffix,
             signal: this.#signalToJson(statement.signal),
-            target_scheme: target.scheme,
-            target_username: target.username,
-            target_password: target.password,
-            target_hostname: target.hostname,
-            target_port: target.port,
-            target_pathname: target.pathname,
-            target_params: target.params,
-            target_fragment: target.fragment,
+            scheme: target.scheme,
+            username: target.username,
+            password: target.password,
+            hostname: target.hostname,
+            port: target.port,
+            pathname: target.pathname,
+            params: target.params,
+            fragment: target.fragment,
             lineMarker: lineMarkerJson,
             tx: JSON.stringify(statement),
             mimetype_tx: "application/json",
@@ -967,13 +1259,18 @@ export default class Engine {
             throw new Error("Engine.#writeLog: INSERT ... RETURNING produced no row");
         return row.id;
     }
+    // Normalize a parsed path for storage. The `file` scheme is a routing
+    // internal — never stored, never rendered to the model. Both bare paths
+    // and `file://...` inputs collapse to scheme=null at this boundary, so
+    // entries.scheme / log_entries.scheme never carry the string "file".
     #extractTarget(path) {
         if (path === null)
             return { scheme: null, username: null, password: null, hostname: null, port: null, pathname: null, params: null, fragment: null };
         if (path.kind === "local")
             return { scheme: null, username: null, password: null, hostname: null, port: null, pathname: path.raw, params: null, fragment: null };
+        const scheme = path.scheme === "file" ? null : path.scheme;
         return {
-            scheme: path.scheme, username: path.username, password: path.password,
+            scheme, username: path.username, password: path.password,
             hostname: path.hostname, port: path.port, pathname: path.pathname,
             params: JSON.stringify(path.params), fragment: path.fragment,
         };