@plurnk/plurnk-service 0.3.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,7 +318,7 @@ 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,
                 });
             }
@@ -263,26 +343,30 @@ export default class Engine {
         if (openRow === undefined)
             throw new Error("Engine.runTurn: turn open returned no row");
         const turnId = openRow.id;
-        // Pre-model writes. For the loop's first turn (DB sequence 1),
-        // the user's prompt becomes the first action: a system-origin
-        // EDIT against `plurnk://prompt/<loop_id>` (loop-scoped indexed
-        // entry, body=prompt text). The log row records the EDIT;
-        // content lives at the plurnk:// entry. Model ops dispatch from
-        // sequence=2 onward on the first turn; 1 onward thereafter.
-        // 1-based throughout (migration 019).
+        // 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}`,
+                    kind: "url", raw: `plurnk://prompt/${loopId}/${seq}`,
                     scheme: "plurnk", username: null, password: null,
                     hostname: null, port: null,
-                    pathname: `prompt/${loopId}`, params: {}, fragment: null,
+                    pathname: `prompt/${loopId}/${seq}`, params: {}, fragment: null,
                 };
                 const promptStmt = {
                     op: "EDIT", suffix: "", signal: null,
-                    path: promptPath, lineMarker: null,
+                    target: promptPath, lineMarker: null,
                     body: promptRow.prompt, position: { line: 1, column: 1 },
                 };
                 await this.dispatch({
@@ -305,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
@@ -366,6 +458,7 @@ export default class Engine {
         const preParsedOps = assistant.ops;
         const ops = [];
         const textFragments = [];
+        const parseErrors = [];
         if (preParsedOps !== undefined) {
             ops.push(...preParsedOps);
         }
@@ -379,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 ?? "";
@@ -388,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
@@ -400,7 +499,15 @@ export default class Engine {
     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.
@@ -549,19 +656,26 @@ export default class Engine {
             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,
         }));
     }
     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 entry out of the index render —
-        // it's materialized in packet.user.prompt instead. Previous loops'
-        // prompt entries stay in the index, addressable for the model to
-        // HIDE if it wants.
-        const foistedPathname = `prompt/${currentLoopId}`;
+        // 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 === foistedPathname)
+            if (row.scheme === "plurnk"
+                && (row.pathname === foistedExact || row.pathname.startsWith(foistedPrefix)))
                 continue;
             let entry = entries.get(row.entry_id);
             if (entry === undefined) {
@@ -611,7 +725,10 @@ export default class Engine {
             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;
         let denial = this.#checkWritable(statement, origin);
@@ -627,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") {
@@ -636,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) {
@@ -666,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,
@@ -698,7 +822,10 @@ export default class Engine {
         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);
@@ -711,7 +838,9 @@ export default class Engine {
             // operation's artifact visible in the next packet's index.
             const applyCtx = {
                 db: this.#db, sessionId, runId, loopId, turnId,
-                writer: "model", signal: undefined,
+                writer: "model", signal: this.#loopAborts.get(loopId)?.signal,
+                streamEventNotify: this.#streamEventNotify,
+                wakeRunNotify: this.#wakeRunNotify,
             };
             const applyResult = await handler.applyResolution({
                 attrs: (originalResult.attrs ?? {}),
@@ -724,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) {
@@ -754,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
@@ -834,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)
@@ -851,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) {
@@ -874,15 +1062,15 @@ export default class Engine {
     // 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.path === null)
+        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 = (path) => {
-            const scheme = this.#schemeNameOf(path);
+        const check = (target) => {
+            const scheme = this.#schemeNameOf(target);
             if (scheme === null)
                 return null;
             if (active.has(scheme))
@@ -890,14 +1078,14 @@ export default class Engine {
             return { status: 403, error: `scheme '${scheme}' is inactive under current loop flags` };
         };
         if (statement.op === "COPY" || statement.op === "MOVE") {
-            return check(statement.path) ?? check(statement.body);
+            return check(statement.target) ?? check(statement.body);
         }
-        return check(statement.path);
+        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" };
@@ -908,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" };
@@ -966,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) {
@@ -1007,7 +1214,7 @@ export default class Engine {
         return "file"; // local (bare) → file
     }
     async #writeLog({ statement, result, runId, loopId, turnId, sequence, origin, }) {
-        const target = this.#extractTarget(statement.path);
+        const target = this.#extractTarget(statement.target);
         const lineMarkerJson = "lineMarker" in statement && statement.lineMarker !== null
             ? JSON.stringify(statement.lineMarker)
             : null;