@plurnk/plurnk-service 0.58.0 → 0.60.0

package/dist/core/Engine.js

@@ -29,6 +29,18 @@ const MUTATING_OPS = new Set(["EDIT", "SEND", "COPY", "MOVE", "EXEC", "KILL"]);
 const DEFAULT_MAX_STRIKES = 3;
 const DEFAULT_MAX_COMMANDS = 99;
 const DEFAULT_BUDGET_CEILING = 0.9;
+// §telemetry — the uniform error channel. Every engine failure is a terse op='error'
+// log row: a status code + the canonical term, no prose (the packet teaches recovery).
+// Each surfaces as a LogCoordinate TelemetryEvent derived from log≥400 — one channel,
+// no per-kind handling. {§telemetry-uniform-error-channel}
+const ENGINE_ERRORS = Object.freeze({
+    budget_overflow: { status: 413, term: "Budget Overflow: newest log items automatically FOLDed" },
+    max_commands_exceeded: { status: 429, term: "Max Commands Exceeded" },
+    // premature-terminate is NOT a terse engine-error: it's a SEND op-result (409 + an actionable
+    // outcome, §send-premature-terminate) — the SEND row records the [200] attempt faithfully and
+    // auto-surfaces (status≥400) like any op failure, never an erasure to 102.
+    idle_turn: { status: 409, term: "Idle Turn" },
+});
 // 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}}";
@@ -744,12 +756,20 @@ class Engine {
         });
         // SPEC §grinder — 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({
+            packet: requestPacket, provider, runId, loopId, turnId,
+            // The overflow error row is minted at the turn's running sequence (nextActionIndex), pre-generate;
+            // runTurn advances the counter past it below so the post-generate dispatch rows never collide.
+            mintSequence: nextActionIndex,
+            // No preset telemetry — the rebuild RE-DERIVES the errors section from log≥400 so the
+            // overflow row just minted surfaces THIS turn (§grinder-overflow-error-row). Safe: the
+            // ephemeral buffer is empty pre-generate (events drain on the next turn's build).
+            rebuild: () => this.#buildRequestPacket({
                 initialMessages: messages, requirements, sessionId, runId, loopId,
-                currentTurnSeq: seq, provider, telemetryErrors, gitStatus,
+                currentTurnSeq: seq, provider, gitStatus,
             }),
         });
+        if (enforced.struck)
+            nextActionIndex += 1; // the budget-overflow error row consumed a sequence
         requestPacket = enforced.packet;
         if (!enforced.fit) {
             // Hard 413: won't fit even with only the manifest left. Skip the LLM,
@@ -862,42 +882,34 @@ class Engine {
         // §grinder-strike-coupling): the loop continues, the model sees the steering hint not the strike
         // count, and a non-resolver spins out to the engine's 500.
         let steerStruck = false;
+        // Engine errors raised this turn, minted as op='error' log rows after dispatch (they share the
+        // post-dispatch sequence counter). §telemetry-uniform-error-channel
+        const pendingEngineErrors = [];
         // Premature terminate: a SEND[200] while the run still holds a live thing — an open stream/spawn
         // OR a non-terminal child run (§run-lifecycle: children and streams are the same kind of "live
-        // thing a run holds"). The model declared done with work running. Downgrade the 200 to 102 so it
-        // dispatches as a continue (its body is preserved, not discarded) and steer; the stream's/child's
-        // own conclusion (the wake edge) or a KILL is the exit.
-        if (sendOp?.signal === 200) {
-            const openSubs = await this.#db.find_open_subscriptions_for_run.all({ run_id: runId });
-            const execHandler = this.#schemes.get("exec");
-            const liveChild = await this.#db.engine_run_has_live_child.get({ run_id: runId });
-            if (openSubs.length > 0 || execHandler?.hasActiveSpawns?.(runId) === true || liveChild !== undefined) {
-                sendOp.signal = TURN_STATUS_IMPLICIT_CONTINUE; // 102 — downgraded, no longer a terminal
-                steerStruck = true;
-                this.#pushTelemetry(sessionId, loopId, {
-                    source: "engine:rail",
-                    kind: "premature_terminate",
-                    message: "Attempted termination with active streams or child runs. Terminate with 202 to hibernate until they complete, KILL(path) with 200 again to clean up, or 499 to fail.",
-                    level: "warn",
-                });
-            }
-        }
+        // thing a run holds"). The model declared done with work running. The SEND is REFUSED 409 at
+        // dispatch (#handleSendBroadcast) — the row records the [200] attempt + body faithfully (no
+        // erasure to 102) and auto-surfaces (status≥400); the loop never goes terminal. Here we only
+        // flag it so the turn stays a continue and the strike couples to the grinder (steerStruck →
+        // turnErrors): a model that won't stop premature-200ing escalates out via the rails.
+        const prematureTerminate = sendOp?.signal === 200 && await this.#runHoldsLiveThing(runId);
+        if (prematureTerminate)
+            steerStruck = true;
         // Rail #41 (revised): the per-turn requirement is "emit at least one op," not "emit a terminal
         // SEND." SEND is purely a signal verb; many turns pass without one. An empty op list strikes.
-        const turnStatus = sendOp !== undefined
-            ? sendOp.signal
-            : realOpsCount === 0 ? TURN_STATUS_NO_OPS : TURN_STATUS_IMPLICIT_CONTINUE;
+        // A refused premature-terminate keeps the turn a continue (102) though the SEND's signal stays
+        // 200 (the un-erased record) — the loop never went terminal, so the turn didn't either.
+        const turnStatus = prematureTerminate
+            ? TURN_STATUS_IMPLICIT_CONTINUE
+            : sendOp !== undefined
+                ? sendOp.signal
+                : realOpsCount === 0 ? TURN_STATUS_NO_OPS : TURN_STATUS_IMPLICIT_CONTINUE;
         // Idle turn: an implicit-continue (102) that did no WORK — its ops are only PLAN/SEND, no mid op.
         // The model continued with nothing to do. (Skipped when premature already steered this turn.)
         const midOpsCount = packetAssistant.ops.filter((op) => op.op !== "PLAN" && op.op !== "SEND").length;
         if (!steerStruck && turnStatus === TURN_STATUS_IMPLICIT_CONTINUE && midOpsCount === 0) {
             steerStruck = true;
-            this.#pushTelemetry(sessionId, loopId, {
-                source: "engine:rail",
-                kind: "idle_turn",
-                message: "If the turn's work is complete, terminate with 200. If awaiting a stream or run trigger, terminate with 202 to hibernate.",
-                level: "warn",
-            });
+            pendingEngineErrors.push("idle_turn");
         }
         // Close the turn with the final packet, status, and usage stats.
         const packet = this.#completePacket(requestPacket, packetAssistant, response.assistantRaw, provider);
@@ -948,28 +960,22 @@ class Engine {
                 statement, sessionId, runId, loopId, turnId,
                 sequence: rowSeq,
                 origin, onDispatch,
+                prematureRefusal: prematureTerminate && statement === sendOp, // the pre-dispatch snapshot's decision, only for this turn's terminal SEND
             });
             statuses.push(result.status);
             rowSeq += result.rowsWritten ?? 1;
         }
-        // max_commands_exceeded IS model-facing: dropped ops are things
-        // the model emitted that didn't run — it needs to know. Engine
-        // bookkeeping (the cap value, our threshold reasoning) stays
-        // internal; only the facts of what happened are reported.
-        if (droppedCount > 0) {
-            this.#pushTelemetry(sessionId, loopId, {
-                source: "engine:rail",
-                kind: "max_commands_exceeded",
-                emitted: opsCount,
-                dropped: droppedCount,
-                level: "error",
-            });
-        }
-        // §telemetry — parse errors as LOG ITEMS: a failed-to-parse emission records an actionless
-        // `error` row (status 400, no target, snippet = the foldable body) at the turn's next free
-        // sequence (after the dispatched ops). The model folds/kills/recalls it like any log entry,
-        // and the errors section derives a pointer (status + coordinate) from log≥400 — one surface.
-        let errSeq = rowSeq; // after every dispatched row, including a multi-file READ's fan-out
+        // §telemetry-uniform-error-channel — every engine + parse failure mints as an op='error'
+        // log row at the turn's next free sequence (after every dispatched row, incl. a multi-file
+        // READ's fan-out). One channel: the errors section derives a LogCoordinate pointer from log≥400.
+        let errSeq = rowSeq;
+        // max_commands_exceeded IS model-facing: dropped ops the model emitted that didn't run.
+        if (droppedCount > 0)
+            pendingEngineErrors.push("max_commands_exceeded");
+        for (const kind of pendingEngineErrors)
+            await this.#mintEngineError(kind, { runId, loopId, turnId, sequence: errSeq++ });
+        // Parse errors carry the parser message + a content-offset line:col (a ContentOffset position),
+        // resolved against the model's born-OPEN emission (§model-entry) — origin 'model', not engine.
         for (const { message, line, column, source } of parseErrors ?? []) {
             await this.#db.engine_insert_log_entry.get({
                 run_id: runId, loop_id: loopId, turn_id: turnId, sequence: errSeq++,
@@ -1081,10 +1087,11 @@ class Engine {
         // 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 promptRows = (await this.#db.drain_get_all_prompt_bodies_for_loop.all({ pattern: `/prompt/${loopId}/%` }))
+            .filter((r) => typeof r.content === "string" && r.content.length > 0);
         const promptCap = Number.parseInt(process.env.PLURNK_PROMPT_PREVIEW_CHARS ?? "", 10);
-        const prompt = (latestPromptRow !== undefined && typeof latestPromptRow.content === "string" && latestPromptRow.content.length > 0)
-            ? PacketWire.previewPrompt(latestPromptRow.content, renderAddress("plurnk", latestPromptRow.pathname), Number.isInteger(promptCap) ? promptCap : -1)
+        const prompt = promptRows.length > 0
+            ? PacketWire.renderActivePrompts(promptRows, Number.isInteger(promptCap) ? promptCap : -1)
             : byRole("user");
         // Requirements is engine-sourced, NOT threaded from callers — that threading is
         // exactly how it went missing (callers read the sysprompt but never the
@@ -1120,28 +1127,43 @@ class Engine {
         const sessionRoot = (await this.#db.envelope_get_session.get({ id: sessionId }))?.project_root ?? null;
         const systemPolicy = await readSystemPolicy(); // ~/.plurnk/AGENTS.md (or PLURNK_POLICY)
         const projectPolicy = await readProjectPolicy(sessionRoot); // <projectRoot>/AGENTS.md (or PLURNK_PROJECT)
+        // Child-orientation (§child-orientation): the live things THIS run holds — open streams +
+        // unconcluded child runs — surfaced every turn as terse `* <status> <path>` pointers (same shape
+        // as errors) just above the errors section. Orienting STATE so the model never loses track of
+        // what it's holding (the premature-terminate trap), never advice on what to do. Empty → omitted.
+        const childStreams = (await this.#db.engine_child_streams_open.all({ run_id: runId }))
+            .map((s) => ({ status: "active", path: renderAddress(s.scheme, s.pathname) }));
+        const childRuns = (await this.#db.engine_child_runs_live.all({ run_id: runId }))
+            .map((r) => ({ status: r.status, path: `run://${r.name}` }));
         const defaults = [
             { name: "definition", slot: "system", header: null, content: system_definition, tokens: 0 },
             { name: "tools", slot: "system", header: null, content: tools.join("\n"), tokens: 0 }, // titleless — the examples flow on from plurnk.md (definition) directly above
-            { name: "schemes", slot: "system", header: "Plurnk System Schemes", content: this.#schemes.teach(), tokens: 0 },
+            { name: "schemes", slot: "system", header: "Plurnk Service Schemes", content: this.#schemes.teach(), tokens: 0 },
             ...(inject !== null ? [{ name: "inject", slot: "system", header: "Plurnk Operator Notes", content: inject, tokens: 0 }] : []),
             // policy: the client's privileged rules — ~/.plurnk/AGENTS.md (system) then <root>/AGENTS.md (project) — below grammar/tools/schemes, above budget-the-law. AGENTS is POLICY here, never a curatable READable entry. Empty content ⇒ section omitted.
-            { name: "system-policy", slot: "system", header: "Plurnk System Policy", content: systemPolicy ?? "", tokens: 0 },
+            { name: "system-policy", slot: "system", header: "Plurnk Service Policy", content: systemPolicy ?? "", tokens: 0 },
             { name: "project-policy", slot: "system", header: "Project Policy", content: projectPolicy ?? "", tokens: 0 },
             // The packet split is a TRUST boundary: system carries only framework-authored, non-injectable
             // sections; anything that could carry attacker-reachable text (a READ result, exec output, the
             // model's own mirrored bytes) stays in user. errors + git are framework status — the errors
             // section is uri+status POINTERS (the error item + body live in the log), git is counts — so
             // neither is an injection surface; both sit at the bottom of system, just above budget-the-law.
-            { name: "errors", slot: "system", header: "Plurnk System Errors", content: PacketWire.renderErrors(telemetryErrors), tokens: 0 },
-            { name: "git", slot: "system", header: "Plurnk System Git Status", content: PacketWire.renderGit(gitStatus), tokens: 0 },
+            // child-orientation: what THIS run holds live — streams then runs — just above errors. Terse
+            // pointers (the path is the actionable address the model READs/OPENs/KILLs), never advice. §child-orientation
+            { name: "child-streams", slot: "system", header: "Plurnk Service Child Streams", content: PacketWire.renderChildPointers(childStreams), tokens: 0 },
+            { name: "child-runs", slot: "system", header: "Plurnk Service Child Runs", content: PacketWire.renderChildPointers(childRuns), tokens: 0 },
+            { name: "errors", slot: "system", header: "Plurnk Service Errors", content: PacketWire.renderErrors(telemetryErrors), tokens: 0 },
+            { name: "git", slot: "system", header: "Plurnk Service Git Status", content: PacketWire.renderGit(gitStatus), tokens: 0 },
             // budget is the very last system line — LAW (a hard ceiling the model must obey), the final word before the model acts.
-            { name: "budget", slot: "system", header: "Plurnk System Budget", content: budgetReadout, tokens: 0 },
-            { name: "prompt", slot: "user", header: "Plurnk System User Prompt", content: prompt, tokens: 0 },
+            { name: "budget", slot: "system", header: "Plurnk Service Budget", content: budgetReadout, tokens: 0 },
             // log in the user slot: injectable content (READ results, exec output, the model's own mirror) — data, never rules — kept at the action point so the model consults its history.
-            { name: "log", slot: "user", header: "Plurnk System Log", content: PacketWire.renderLog(log, countTokens), tokens: 0 },
+            { name: "log", slot: "user", header: "Plurnk Service Log", content: PacketWire.renderLog(log, countTokens), tokens: 0 },
+            // the ACTIVE user prompts (all the current loop holds, in order — a loop admits injected
+            // prompts) render at the BOTTOM, just above requirements — at the action point, closest to
+            // the model's turn. Each is a bare heredoc (the fence is the link); §prompt-fold.
+            { name: "prompt", slot: "user", header: "Plurnk Service Active User Prompts", content: prompt, tokens: 0 },
             // requirements renders LAST — the user-slot footer, the syntax contract closest to the model's turn (a recency carve-out for weak models).
-            { name: "requirements", slot: "user", header: "Plurnk System Requirements", content: baseRequirements, tokens: 0 },
+            { name: "requirements", slot: "user", header: "Plurnk Service Requirements", content: baseRequirements, tokens: 0 },
         ];
         // Plugin packet control (§packet-construction): trusted schemes rewrite the
         // default list — add, remove, reorder — in-process, before measurement.
@@ -1167,7 +1189,7 @@ class Engine {
         const packetTokens = countTokens(PacketWire.renderSlot(sections, "system")) + countTokens(PacketWire.renderSlot(sections, "user"));
         return { tokens: packetTokens, sections, telemetryErrors };
     }
-    // Budget readout body, rendered into the `## Plurnk System Budget` section.
+    // Budget readout body, rendered into the `## Plurnk Service Budget` section.
     // Headline `ceiling/free` only when a ceiling exists; section lines for the
     // curatable index/log weight the model can FOLD back. tokensFree is a
     // placeholder here — buildSystem substitutes it after measuring the packet.
@@ -1179,8 +1201,8 @@ class Engine {
             if (lines.length > 0)
                 lines.push("");
             lines.push(`Log entries: ${log.entries} entries, ${log.tokens} tokens`);
-            // Per-turn weight — the grinder's rollback unit, oldest first: the
-            // model sees what's first to go (§tokenomics {§tokenomics-turn-totals}).
+            // Per-turn weight — chronological (oldest first); the turn is the grinder's
+            // rollback unit and the rail folds the newest first (§tokenomics {§tokenomics-turn-totals}).
             if (log.byTurn.length > 0) {
                 lines.push("", "Turns:", "| turn | tokens |", "|---|--:|");
                 for (const t of log.byTurn)
@@ -1198,7 +1220,7 @@ class Engine {
         }
         return lines.join("\n");
     }
-    // The ## Plurnk System Tools capability sheet (SPEC §tools). A hook: each enabled
+    // The ## Plurnk Service Tools capability sheet (SPEC §tools). A hook: each enabled
     // capability contributes one line, rendered above Requirements so the model sees what
     // it can do before the rules. Each available executor tag contributes its self-documenting
     // example (plurnk-execs#7), retiring the blind EXEC.
@@ -1249,44 +1271,56 @@ class Engine {
     // 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.
     // §grinder-overflow-only — fires only on actual overflow, never speculatively
-    async #enforceBudget({ packet, provider, runId, loopId, turnId, sessionId, turnNumber, rebuild }) {
+    async #enforceBudget({ packet, provider, runId, loopId, turnId, mintSequence, rebuild }) {
         const ceiling = _a.computeCeiling(provider.contextSize, this.#budgetCeiling);
         const measure = (p) => p.tokens;
         if (ceiling === null || measure(packet) <= ceiling)
             return { packet, fit: true, struck: false };
-        const folded = new Map();
-        const note = (scheme) => { folded.set(scheme, (folded.get(scheme) ?? 0) + 1); };
-        // Pass 1 — prior-turn rollback: fold 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 }); // prior-turn rollback folds the latest emissions — §grinder-layer1-rollback
-        for (const le of priorLogs)
-            note(le.scheme ?? "log");
-        if (priorLogs.length > 0)
+        // The grinder may compact ONLY the newest turn — the immediately-prior turn's emissions
+        // (turn N>1), or, when there is no prior turn (turn 1), THIS turn's own foists. It NEVER
+        // reaches older history; the model alone curates history via FOLD/KILL, and the engine never
+        // janitors stale context. §grinder-newest-turn-only
+        let foldedAny = false;
+        const priorLogs = await this.#db.engine_grinder_prior_turn_logs.all({ loop_id: loopId, turn_id: turnId });
+        if (priorLogs.length > 0) {
             await this.#db.engine_grinder_fold_prior_turn_logs.run({ loop_id: loopId, turn_id: turnId });
-        const errors = packet.telemetryErrors;
-        let current = priorLogs.length > 0 ? await rebuild(errors) : packet;
-        if (measure(current) <= ceiling) {
-            this.#emitBudgetOverflow(sessionId, loopId, folded);
-            return { packet: current, fit: true, struck: turnNumber > 1 }; // turn 0/1 overflow is the environment, never a strike — §grinder-soft-turn-0-1
+            foldedAny = true;
         }
-        // Prior-turn rollback is the only budget lever now: entries don't render
-        // (no index), so there is no catalog to collapse. If pass 1 didn't fit,
-        // the packet is over and the caller hard-413s. §grinder-hard-413-abort
-        this.#emitBudgetOverflow(sessionId, loopId, folded);
-        return { packet: current, fit: measure(current) <= ceiling, struck: turnNumber > 1 };
-    }
-    // The model-facing budget event (SPEC §grinder, §telemetry): 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).
-    // §grinder-event-model-terms — model-facing terms only; the strike stays engine-internal
-    #emitBudgetOverflow(sessionId, loopId, folded) {
-        if (folded.size === 0)
-            return;
-        this.#pushTelemetry(sessionId, loopId, {
-            source: "engine:rail",
-            kind: "budget_overflow",
-            folded: [...folded.entries()].map(([scheme, count]) => ({ scheme, count })),
-            level: "warn",
+        else {
+            // Turn 1 — no prior turn: fold THIS turn's own foists (the catalog/prompt that overflowed). §grinder-turn-1-self-fold (#2)
+            const curLogs = await this.#db.engine_grinder_current_turn_logs.all({ loop_id: loopId, turn_id: turnId });
+            if (curLogs.length > 0) {
+                await this.#db.engine_grinder_fold_current_turn_logs.run({ loop_id: loopId, turn_id: turnId });
+                foldedAny = true;
+            }
+        }
+        if (!foldedAny)
+            return { packet, fit: measure(packet) <= ceiling, struck: false };
+        // Mint the overflow as a terse op='error' log row BEFORE the rebuild, so the rebuild's
+        // re-derived errors section surfaces it THIS turn — the warning lands at strike 1, not a
+        // turn late. The row is grinder-exempt, so it stacks into a visible recurrence trail. It
+        // sits at the turn's reserved running sequence (mintSequence) so it never collides with the
+        // post-generate dispatch rows. §telemetry-uniform-error-channel, §grinder-overflow-error-row
+        await this.#mintEngineError("budget_overflow", { runId, loopId, turnId, sequence: mintSequence });
+        const current = await rebuild();
+        // Every compaction is a strike — including turn 0/1 (no soft exemption, #4). §grinder-compaction-strikes
+        return { packet: current, fit: measure(current) <= ceiling, struck: true };
+    }
+    // Mint an engine failure as a uniform op='error' log row (§telemetry-uniform-error-channel):
+    // a terse status + canonical term keyed by `kind` (the packet teaches recovery, not the row),
+    // origin engine:rail. The errors section derives its LogCoordinate pointer from log≥400 — one
+    // channel, no per-kind handling.
+    async #mintEngineError(kind, { runId, loopId, turnId, sequence }) {
+        const { status, term } = ENGINE_ERRORS[kind];
+        await this.#db.engine_insert_log_entry.get({
+            run_id: runId, loop_id: loopId, turn_id: turnId, sequence,
+            origin: "plurnk", source: "rail", op: "error", suffix: "", signal: null,
+            scheme: null, username: null, password: null, hostname: null, port: null,
+            pathname: null, params: null, fragment: null, lineMarker: null,
+            tx: "", mimetype_tx: "text/plain",
+            rx: JSON.stringify({ kind, message: term }),
+            mimetype_rx: "application/json",
+            status_rx: status, tokens: 0, state: "resolved", outcome: null, attrs: "{}",
         });
     }
     // Wire projection lives in ./packet-wire.ts so Engine and
@@ -1319,25 +1353,20 @@ class Engine {
     //   2. Engine-buffered actionless failures (no_send, parse, watchdog, rails).
     // Buffer drains on read — each error appears in exactly one packet.
     async #buildTelemetryErrors(loopId, currentTurnSeq) {
+        // The uniform error channel (§telemetry-uniform-error-channel): every 4xx/5xx log row
+        // becomes a LogCoordinate-positioned TelemetryEvent — a terse pointer; the model READs the
+        // row for its term + detail. Buffer events that point at the model's own emission keep their
+        // ContentOffset position. info-level notices (progress) are not errors and never surface here.
         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.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",
-                level: "error", // the derived error pointer is always an error — clients color off level (#276)
-                coordinate: `${r.loop_seq}/${r.turn_seq}/${r.sequence}`,
-                op: r.op,
-                target,
-                status: r.status_rx,
-                error: typeof parsedRx === "object" && parsedRx !== null && "error" in parsedRx
-                    ? parsedRx.error
-                    : typeof parsedRx === "string" ? parsedRx : "",
-            };
-        });
-        return [...this.#drainTelemetry(loopId), ...actionFailures];
+        const logErrors = rows.map((r) => ({
+            source: "engine:rail",
+            kind: "log_error",
+            level: "error",
+            status: r.status_rx,
+            position: { type: "log-coordinate", coordinate: `${r.loop_seq}/${r.turn_seq}/${r.sequence}/${r.op}` },
+        }));
+        const bufferEvents = this.#drainTelemetry(loopId).filter((e) => e.level !== "info");
+        return [...bufferEvents, ...logErrors];
     }
     // SPEC §packet the log section — chronological action-entries for the loop.
     // Snapshot is taken at packet build (pre-dispatch this turn), so it
@@ -1494,7 +1523,7 @@ class Engine {
         }
     }
     async dispatch(context) {
-        const { statement, sessionId, runId, loopId, turnId, sequence, origin, onDispatch } = context;
+        const { statement, sessionId, runId, loopId, turnId, sequence, origin, onDispatch, prematureRefusal } = context;
         const schemeCtx = this.#buildSchemeCtx({ sessionId, runId, loopId, turnId, origin });
         let result;
         let denial = this.#checkWritable(statement, origin);
@@ -1517,7 +1546,7 @@ class Engine {
             // those are system failures.
             try {
                 if (statement.op === "SEND" && statement.target === null) {
-                    result = await this.#handleSendBroadcast(statement, loopId);
+                    result = await this.#handleSendBroadcast(statement, loopId, prematureRefusal === true);
                 }
                 else if (statement.op === "COPY") {
                     result = await this.#handleCopy(statement, schemeCtx);
@@ -1738,6 +1767,27 @@ class Engine {
         const row = await this.#db.engine_count_active_loops_for_run.get({ run_id: runId });
         return (row?.n ?? 0) > 0;
     }
+    // #290 — run the derivation pump (deep channels: symbols/refs/FTS +
+    // embeddings, deep_hash-gated) at SESSION-SCOPE, off the per-turn path, so a freshly-created
+    // session's corpus warms DURING the client's startup window instead of freezing the first
+    // loop.run. session.create fires this and returns immediately; embed_progress live-fans-out as it
+    // runs. Idempotent + deep_hash-gated, so turn 1's pump finds the work done (or harmlessly re-runs);
+    // a no-embedder build derives the cheap symbols/refs/FTS channels and skips the embed pass. Has no
+    // loop yet — telemetry fans out live only (loopId 0), never buffered to a loop that never drains.
+    async warmSessionDerivations(sessionId) {
+        const ctx = {
+            db: this.#db, sessionId, runId: 0, loopId: 0, turnId: 0,
+            writer: "plurnk",
+            signal: undefined,
+            streamEventNotify: this.#streamEventNotify,
+            wakeRunNotify: this.#wakeRunNotify,
+            tokenize: this.#tokenize,
+            mimetypes: this.#mimetypes,
+            defaultChannelFor: (s) => this.#schemes.defaultChannelFor(s),
+            pushTelemetry: (event) => this.#telemetryEventNotify?.(sessionId, { loopId: 0, event }),
+        };
+        await EntryManifest.maintainDerivations(ctx);
+    }
     // Inject a prompt into the run's currently-executing loop. Writes a
     // plurnk:///prompt/<loop_id>/<next-turn> entry whose body becomes the
     // prompt section at the next turn boundary. Last-wins: if two
@@ -1867,10 +1917,10 @@ class Engine {
         if (statement.op === "EXEC") {
             return this.#denyIfDisallowed("exec", origin);
         }
-        // A run-fork (COPY src=run://) is gated by run://'s writableBy — its body
-        // is a fork prompt, not a dst path, so the entry-COPY dst-parse below
-        // doesn't apply. §machine-processes
-        if (this.#isRunFork(statement))
+        // Run control (COPY target=run://, spawn or fork) is gated by run://'s writableBy — its
+        // body is a seed prompt, not a dst path, so the entry-COPY dst-parse below doesn't apply.
+        // §machine-processes
+        if (this.#isRunCopy(statement))
             return this.#denyIfDisallowed("run", origin);
         if (statement.op === "COPY" || statement.op === "MOVE") {
             const dst = statement.op === "COPY" ? (statement.body === null ? null : parsePath(statement.body)) : statement.body;
@@ -1926,56 +1976,68 @@ class Engine {
                 return null;
             return { status: 403, error: `scheme '${scheme}' is inactive under current loop flags` };
         };
-        if (this.#isRunFork(statement))
-            return check(statement.target); // body is a fork prompt, not a dst path
+        if (this.#isRunCopy(statement))
+            return check(statement.target); // body is a spawn/fork prompt, not a dst path
         if (statement.op === "COPY" || statement.op === "MOVE") {
             return check(statement.target) ?? check(statement.op === "COPY" ? (statement.body === null ? null : parsePath(statement.body)) : statement.body);
         }
         return check(statement.target);
     }
-    // A COPY whose SOURCE is run:// is a run-fork, not an entry-copy — its body
-    // is the fork's seed prompt, not a destination path. The COPY gates and
-    // #handleCopy branch on this so they never parse the prompt as a dst path.
-    #isRunFork(statement) {
+    // A COPY whose TARGET is run:// is run control (spawn/fork), not an entry-copy — its body
+    // is the new run's seed prompt, not a destination path. The COPY gates and #handleCopy
+    // branch on this so they never parse the prompt as a dst path.
+    #isRunCopy(statement) {
         return statement.op === "COPY" && this.#schemeNameOf(statement.target) === "run";
     }
-    // COPY(run://<src>):prompt — fork: deep-copy the source run's log into a new
-    // run (Fork), then start it with the prompt (ctx.injectRun). Source `run://self` =
-    // self (ctx.runId); a name resolves within the session (404 if absent). §run-scheme,
-    // §machine-processes-fork-copies-the-log
-    async #handleRunFork(statement, ctx) {
+    // COPY(run://<dst>):prompt — run control via COPY (grammar 0.74.41 OP×resource matrix):
+    //   • run://self   → FORK: deep-copy the current run's log into a new sister (Fork), then
+    //     continue it with the prompt (§machine-processes-fork-copies-the-log).
+    //   • run://<name> → SPAWN: a fresh sister (empty log) named <name>, started on the prompt.
+    //     A LIVE sister already holding <name> is a 409 conflict; a free or terminated name is
+    //     reclaimed (§run-scheme-spawn). The self form is fork; only a name spawns.
+    // Both ride the daemon inject and obey the active-runs cap (508, §run-scheme-cap).
+    async #handleRunCopy(statement, ctx) {
         const target = statement.target;
         if (target === null)
-            return { status: 400, error: "run:// fork requires a source run" };
+            return { status: 400, error: "run:// control requires a run target" };
         const name = target.kind === "url" ? (target.hostname ?? "") : ""; // §run-scheme — run is the AUTHORITY (run://<name>), not the path
         if (name === "")
-            return { status: 400, error: "run:// fork requires a source run name or 'self' (run://self)" };
-        let srcRunId = ctx.runId;
-        if (name !== "self") {
-            const row = await this.#db.run_resolve_by_name.get({ session_id: ctx.sessionId, name });
-            if (row === undefined)
-                return { status: 404, error: `run://${name} not found in this session` };
-            srcRunId = row.id;
-        }
+            return { status: 400, error: "run:// control requires a run name or 'self' (run://<name>)" };
         if (ctx.injectRun === undefined)
-            throw new Error("run fork: injectRun capability absent");
+            throw new Error("run copy: injectRun capability absent");
         const denied = await RunCap.deny(this.#db, ctx.sessionId);
         if (denied !== null)
             return denied;
-        const branchRunId = await Fork.fork(this.#db, srcRunId);
-        const branch = await this.#db.fork_get_run.get({ id: branchRunId });
-        await ctx.injectRun({ sessionId: ctx.sessionId, runId: branchRunId, prompt: typeof statement.body === "string" ? statement.body : "" });
-        return { status: 200, body: branch?.name ?? "" };
+        const prompt = typeof statement.body === "string" ? statement.body : "";
+        if (name === "self") {
+            // FORK — branch the current run's log into a new sister.
+            const branchRunId = await Fork.fork(this.#db, ctx.runId);
+            const branch = await this.#db.fork_get_run.get({ id: branchRunId });
+            await ctx.injectRun({ sessionId: ctx.sessionId, runId: branchRunId, prompt });
+            return { status: 200, body: branch?.name ?? "" };
+        }
+        // SPAWN — a fresh sister named <name>. A name is frozen per run but reclaimable across time
+        // (§machine-processes-run-origin): a LIVE sister holding it is a 409 conflict (legible, never
+        // a raw UNIQUE 500); a free or terminated name is reclaimed (the resolver picks newest).
+        const live = await this.#db.run_live_by_name.get({ session_id: ctx.sessionId, name });
+        if (live !== undefined)
+            return { status: 409, error: `run '${name}' is already running` };
+        const row = await this.#db.fork_insert_run.get({
+            session_id: ctx.sessionId, name, parent_run_id: ctx.runId, origin: ctx.writer,
+        });
+        if (row === undefined)
+            throw new Error("run spawn: run insert returned no row");
+        await ctx.injectRun({ sessionId: ctx.sessionId, runId: row.id, prompt });
+        return { status: 200, body: name };
     }
     async #handleCopy(statement, ctx) {
         if (statement.op !== "COPY")
             throw new Error("unreachable");
-        if (this.#isRunFork(statement))
-            return await this.#handleRunFork(statement, ctx);
+        if (this.#isRunCopy(statement))
+            return await this.#handleRunCopy(statement, ctx);
         const srcPath = statement.target;
-        // COPY's body is an opaque raw string (grammar §COPY: a dest path OR a run-fork
-        // prompt); parse it to the dest path. Non-path bodies (run:// fork prompts) are
-        // not yet handled and surface as a 400.
+        // Past the run-control branch above, COPY's body is a dest path (grammar §COPY).
+        // Parse it; an unparseable dest surfaces as a 400.
         const dstPath = statement.body === null ? null : parsePath(statement.body);
         if (srcPath === null)
             return { status: 400, error: "COPY requires source path" };
@@ -2259,12 +2321,34 @@ class Engine {
             return { status: 202, attrs: writeResult.attrs, body: writeResult.body };
         return { status: writeResult.status, entryId: writeResult.entryId, created: writeResult.created };
     }
-    async #handleSendBroadcast(statement, loopId) {
+    // A run "holds a live thing" iff it has an open stream/spawn (subscription registry or an
+    // exec spawn) OR a non-terminal child run — the structured-concurrency invariant a terminal
+    // SEND[200] must respect (§send-premature-terminate, §run-lifecycle: children and streams are
+    // the same kind of live thing a run holds).
+    async #runHoldsLiveThing(runId) {
+        const openSubs = await this.#db.find_open_subscriptions_for_run.all({ run_id: runId });
+        if (openSubs.length > 0)
+            return true;
+        const execHandler = this.#schemes.get("exec");
+        if (execHandler?.hasActiveSpawns?.(runId) === true)
+            return true;
+        const liveChild = await this.#db.engine_run_has_live_child.get({ run_id: runId });
+        return liveChild !== undefined;
+    }
+    async #handleSendBroadcast(statement, loopId, prematureRefusal) {
         if (statement.op !== "SEND")
             throw new Error("unreachable");
         const status = statement.signal;
         if (status === null)
             return { status: 400 };
+        // Premature terminate (§send-premature-terminate): a terminal SEND[200] while the run holds a
+        // live thing is REFUSED 409 — the row keeps the [200] emission + body (faithful, never erased),
+        // the loop never goes terminal. The model hibernates [202] to wait or KILLs before terminating.
+        // The decision is the runTurn PRE-DISPATCH snapshot (threaded), so a same-turn fire-and-forget
+        // spawn isn't miscounted as a live thing the SEND holds.
+        if (status === 200 && prematureRefusal) {
+            return { status: 409, error: "Attempted [200] termination despite active streams or worker runs. You may either hibernate [202] to wait or KILL them before terminating." };
+        }
         if (status === 200 || status === 202 || status === 499) {
             // The broadcast terminals (200 done, 202 parked-async, 499 cancelled) advance
             // the loop; each carries its body as the loop's terminal message — the deliverable.