@plurnk/plurnk-service 0.7.0 → 0.9.0

package/dist/server/Daemon.js

@@ -4,41 +4,43 @@
 import { WebSocketServer } from "ws";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { PATHS } from "../index.js";
+import { Paths } from "../index.js";
 import Engine from "../core/Engine.js";
+import ExecutorRegistry from "../core/ExecutorRegistry.js";
 import SchemeRegistry from "../core/SchemeRegistry.js";
 import { Mimetypes } from "@plurnk/plurnk-mimetypes";
-import { discoverPlugins, loadPlugin } from "../core/PluginLoader.js";
+import PluginLoader from "../core/PluginLoader.js";
 import MethodRegistry from "./MethodRegistry.js";
 import ClientConnection from "./ClientConnection.js";
-import { fetchLogEntry } from "./logEntry.js";
+import LogEntry from "./logEntry.js";
+import Yolo from "./yolo.js";
+import NoProposals from "./noProposals.js";
 import { DEFAULT_LOOP_FLAGS } from "../core/scheme-types.js";
-import { register as registerPing } from "./methods/ping.js";
-import { register as registerDiscover } from "./methods/discover.js";
-import { register as registerSessionCreate } from "./methods/session_create.js";
-import { register as registerSessionList } from "./methods/session_list.js";
-import { register as registerSessionAttach } from "./methods/session_attach.js";
-import { register as registerSessionRuns } from "./methods/session_runs.js";
-import { register as registerSessionSetRoot } from "./methods/session_set_root.js";
-import { register as registerSessionSetPersona } from "./methods/session_set_persona.js";
-import { register as registerOpEdit } from "./methods/op_edit.js";
-import { register as registerOpRead } from "./methods/op_read.js";
-import { register as registerOpFind } from "./methods/op_find.js";
-import { register as registerOpShow } from "./methods/op_show.js";
-import { register as registerOpHide } from "./methods/op_hide.js";
-import { register as registerOpCopy } from "./methods/op_copy.js";
-import { register as registerOpMove } from "./methods/op_move.js";
-import { register as registerOpSend } from "./methods/op_send.js";
-import { register as registerOpExec } from "./methods/op_exec.js";
-import { register as registerOpDispatch } from "./methods/op_dispatch.js";
-import { register as registerOpParse } from "./methods/op_parse.js";
-import { register as registerLoopRun } from "./methods/loop_run.js";
-import { register as registerLoopCancel } from "./methods/loop_cancel.js";
-import { register as registerEntryRead } from "./methods/entry_read.js";
-import { register as registerLogRead } from "./methods/log_read.js";
-import { register as registerProvidersList } from "./methods/providers_list.js";
-import { register as registerLoopResolve } from "./methods/loop_resolve.js";
-import { attachYolo } from "./yolo.js";
+import PingMethod from "./methods/ping.js";
+import DiscoverMethod from "./methods/discover.js";
+import SessionCreateMethod from "./methods/session_create.js";
+import SessionListMethod from "./methods/session_list.js";
+import SessionAttachMethod from "./methods/session_attach.js";
+import SessionRunsMethod from "./methods/session_runs.js";
+import SessionSetRootMethod from "./methods/session_set_root.js";
+import SessionSetPersonaMethod from "./methods/session_set_persona.js";
+import OpEditMethod from "./methods/op_edit.js";
+import OpReadMethod from "./methods/op_read.js";
+import OpFindMethod from "./methods/op_find.js";
+import OpShowMethod from "./methods/op_show.js";
+import OpHideMethod from "./methods/op_hide.js";
+import OpCopyMethod from "./methods/op_copy.js";
+import OpMoveMethod from "./methods/op_move.js";
+import OpSendMethod from "./methods/op_send.js";
+import OpExecMethod from "./methods/op_exec.js";
+import OpDispatchMethod from "./methods/op_dispatch.js";
+import OpParseMethod from "./methods/op_parse.js";
+import LoopRunMethod from "./methods/loop_run.js";
+import LoopCancelMethod from "./methods/loop_cancel.js";
+import EntryReadMethod from "./methods/entry_read.js";
+import LogReadMethod from "./methods/log_read.js";
+import ProvidersListMethod from "./methods/providers_list.js";
+import LoopResolveMethod from "./methods/loop_resolve.js";
 export default class Daemon {
     #db;
     #engine;
@@ -49,14 +51,21 @@ export default class Daemon {
     #nodeModulesPath;
     #wss = null;
     #connections = new Set();
-    // Run-level drain registry (rummy AgentLoop parallel). At most one
-    // drain per run; concurrent loop.run calls inject into the active
-    // drain instead of starting parallel runLoops.
+    // Run-level drain registry. At most one drain per run. The stored object
+    // is the drain's identity handle: start/exit compare it by reference so a
+    // drain exiting never clobbers a successor that raced in, and a loop
+    // enqueued during teardown is never stranded. A drain is a pure queue
+    // consumer (claim → run → exit on empty queue); streams live independently
+    // (subscriptions + Exec.idle), and a concluding stream routes through
+    // inject() like any other loop source.
     #activeDrains = new Map();
-    // Wake/event signals for drains parked on "queue empty, active subs in
-    // flight." A wake-on-completion → engine.inject can resolve the pending
-    // promise so the drain re-checks the queue without polling.
-    #drainPokes = new Map();
+    // Per-run cancellation scope. Loops AND the streams they spawn (execs)
+    // share this signal, so loop.cancel / shutdown abort it once and every
+    // in-flight subscription tears down — even a spawn that registers AFTER the
+    // cancel self-aborts against the already-aborted signal (no race). Outlives
+    // any single (ephemeral) drain; replaced with a fresh controller once
+    // aborted so a later loop.run isn't born cancelled.
+    #runAborts = new Map();
     constructor({ db, schemes, mimetypes, provider, nodeModulesPath, }) {
         this.#db = db;
         this.#schemes = schemes ?? new SchemeRegistry();
@@ -74,6 +83,11 @@ export default class Daemon {
         });
         this.#engine = new Engine({
             db, schemes: this.#schemes, mimetypes: this.#mimetypes,
+            // Same provider-backed source as the Mimetypes tokenize lambda
+            // above; sync here because countTokens is sync (§2.1) and the
+            // write helpers store the count inline. Divisor tripwire only
+            // until a provider is resolved.
+            tokenize: (text) => this.#provider?.countTokens(text) ?? Math.ceil(text.length / 4),
             streamEventNotify: (sessionId, event) => this.notifyStreamEvent(sessionId, event),
             wakeRunNotify: (payload) => { void this.#handleWakeRun(payload); },
             telemetryEventNotify: (sessionId, payload) => this.notifyTelemetryEvent(sessionId, payload),
@@ -102,7 +116,11 @@ export default class Daemon {
         });
         // In-tree YOLO listener — auto-accepts proposals when the loop's
         // persisted flags.yolo === true. Skips client roundtrip entirely.
-        attachYolo(this.#engine, this.#db);
+        Yolo.attachYolo(this.#engine, this.#db);
+        // Inverse of YOLO: auto-REJECT proposals in-process when the loop's
+        // persisted flags.noProposals === true (client has no review channel).
+        // The model sees an ordinary 400, never the orchestration reason.
+        NoProposals.attachNoProposals(this.#engine, this.#db);
     }
     get registry() { return this.#registry; }
     get engine() { return this.#engine; }
@@ -116,6 +134,11 @@ export default class Daemon {
         // Mimetypes owns its own discovery scan over @plurnk/plurnk-mimetypes-*
         // packages; pre-warm it so first index render doesn't pay the cost.
         await this.#mimetypes.ready();
+        // Discover + probe the installed executor siblings, then hand the
+        // registry to the engine for exec dispatch (plurnk-service#181). The
+        // shell is the default runtime, so its executor must boot usable.
+        const executors = await ExecutorRegistry.build({ defaultRuntime: "sh" });
+        this.#engine.setExecutors(executors);
         return new Promise((resolve, reject) => {
             const wss = new WebSocketServer({ host, port });
             wss.on("listening", () => {
@@ -154,8 +177,14 @@ export default class Daemon {
         // to completion, (3) drain streaming schemes' background work
         // (exec spawn cleanup, channel writes). Only THEN close the DB
         // upstream — drain queries hit the DB right up until they exit.
-        for (const drain of this.#activeDrains.values())
-            drain.controller.abort("daemon_stopping");
+        // Abort every run's cancellation scope — stops in-flight loops AND the
+        // streams (background execs) linked to them, so idle() doesn't block on
+        // a long-running command. Covers runs whose drain already exited but
+        // whose exec is still in flight.
+        for (const scope of this.#runAborts.values()) {
+            if (!scope.signal.aborted)
+                scope.abort("daemon_stopping");
+        }
         const drainPromises = [...this.#activeDrains.values()].map((d) => d.promise);
         await Promise.allSettled(drainPromises);
         await this.#drainStreamingSchemes();
@@ -168,31 +197,31 @@ export default class Daemon {
             await exec.idle();
     }
     #registerBuiltins() {
-        registerPing(this.#registry);
-        registerDiscover(this.#registry);
-        registerSessionCreate(this.#registry);
-        registerSessionList(this.#registry);
-        registerSessionAttach(this.#registry);
-        registerSessionRuns(this.#registry);
-        registerSessionSetRoot(this.#registry);
-        registerSessionSetPersona(this.#registry);
-        registerOpEdit(this.#registry);
-        registerOpRead(this.#registry);
-        registerOpFind(this.#registry);
-        registerOpShow(this.#registry);
-        registerOpHide(this.#registry);
-        registerOpCopy(this.#registry);
-        registerOpMove(this.#registry);
-        registerOpSend(this.#registry);
-        registerOpExec(this.#registry);
-        registerOpDispatch(this.#registry);
-        registerOpParse(this.#registry);
-        registerLoopRun(this.#registry);
-        registerLoopCancel(this.#registry);
-        registerLoopResolve(this.#registry);
-        registerEntryRead(this.#registry);
-        registerLogRead(this.#registry);
-        registerProvidersList(this.#registry);
+        PingMethod.register(this.#registry);
+        DiscoverMethod.register(this.#registry);
+        SessionCreateMethod.register(this.#registry);
+        SessionListMethod.register(this.#registry);
+        SessionAttachMethod.register(this.#registry);
+        SessionRunsMethod.register(this.#registry);
+        SessionSetRootMethod.register(this.#registry);
+        SessionSetPersonaMethod.register(this.#registry);
+        OpEditMethod.register(this.#registry);
+        OpReadMethod.register(this.#registry);
+        OpFindMethod.register(this.#registry);
+        OpShowMethod.register(this.#registry);
+        OpHideMethod.register(this.#registry);
+        OpCopyMethod.register(this.#registry);
+        OpMoveMethod.register(this.#registry);
+        OpSendMethod.register(this.#registry);
+        OpExecMethod.register(this.#registry);
+        OpDispatchMethod.register(this.#registry);
+        OpParseMethod.register(this.#registry);
+        LoopRunMethod.register(this.#registry);
+        LoopCancelMethod.register(this.#registry);
+        LoopResolveMethod.register(this.#registry);
+        EntryReadMethod.register(this.#registry);
+        LogReadMethod.register(this.#registry);
+        ProvidersListMethod.register(this.#registry);
     }
     #registerNotifications() {
         this.#registry.registerNotification("log/entry", {
@@ -224,6 +253,7 @@ export default class Daemon {
             description: "A channel's content grew or its state transitioned. Scoped to the entry's session. Metadata-only; clients fetch new content via entry.read or op.read.",
             params: {
                 entryId: "number — the entry whose channel changed",
+                target: "string — the entry's URI (scheme://pathname); clients route on this without an entryId→URI lookup",
                 channel: "string — the channel name",
                 state: "string — current state (static, active, closed, errored)",
                 contentLength: "number — current length of the channel's content",
@@ -240,6 +270,7 @@ export default class Daemon {
             description: "A streaming-scheme subscription closed (the underlying connection / subprocess finished, errored, or was cancelled). Scoped to the entry's session. wakeAction describes whether the daemon opened a fresh loop to surface the conclusion to the model.",
             params: {
                 entryId: "number",
+                target: "string — the entry's URI (scheme://pathname)",
                 subscriptionId: "number",
                 scheme: "string — the scheme that owned the subscription (e.g. 'exec')",
                 closeStatus: "number — 200 (clean) / 500 (error) / 499 (aborted)",
@@ -281,21 +312,14 @@ export default class Daemon {
      */
     async inject(args) {
         const { sessionId, runId, prompt } = args;
-        // Wake any drain parked on "queue empty + active subs" so it
-        // re-checks the queue immediately regardless of which branch we
-        // take. The poke fires before we return; if we enqueue a new
-        // loop, the drain we start below claims it on its first iteration.
-        this.#pokeDrain(runId);
-        const drainActive = this.#activeDrains.has(runId);
-        if (drainActive) {
+        // Active loop (status=102)? Fold the wake/prompt into its next turn.
+        // engine.inject returns null when no loop is currently executing, so
+        // we enqueue a fresh loop below and ensure a drain claims it.
+        if (this.#activeDrains.has(runId)) {
             const result = await this.#engine.inject(runId, prompt);
             if (result !== null) {
                 return { action: "injected_next_turn", loopId: result.loopId, turnSeq: result.turnSeq };
             }
-            // Race: #activeDrains exists but drain hasn't yet claimed a
-            // loop (status=102). Fall through to the enqueue path — but
-            // we must NOT start a parallel drain. The existing drain
-            // will claim this loop on a subsequent iteration.
         }
         // Enqueue a fresh loop. Persist flags + persona override on the row.
         const seqRow = await this.#db.loop_run_next_sequence.get({ run_id: runId });
@@ -313,18 +337,19 @@ export default class Daemon {
                 loop_id: loopId, flags: JSON.stringify(merged),
             });
         }
-        // Existing drain will pick this loop up — don't start a parallel one.
-        if (drainActive) {
-            // Poke the existing drain in case it's parked.
-            this.#pokeDrain(runId);
-            return { action: "enqueued_new_loop", loopId };
-        }
-        const { firstLoopPromise, drainPromise } = this.#startDrain({
+        // Guarantee a drain claims the loop we just enqueued. Synchronous
+        // check-and-start (no await between the membership test and the
+        // registry write): a live drain re-claims it; otherwise we start one.
+        // The drain's exit coordinates via an identity-checked re-claim so the
+        // loop is never stranded (the lost-loop hang). firstLoopPromise is
+        // present only when THIS call started the drain — loop.run keys its
+        // fast-path response on that.
+        const started = this.#ensureDrain({
             sessionId, runId, provider: args.provider,
             systemPrompt: args.systemPrompt, personaDefault: args.persona,
             maxTurns: args.maxTurns ?? Number(process.env.PLURNK_MAX_TURNS ?? "50"),
         });
-        return { action: "enqueued_new_loop", loopId, firstLoopPromise, drainPromise };
+        return { action: "enqueued_new_loop", loopId, ...(started ?? {}) };
     }
     /**
      * Start a drain for the given run. The drain claims queued loops via
@@ -341,7 +366,12 @@ export default class Daemon {
      */
     #startDrain(opts) {
         const { sessionId, runId, provider, systemPrompt, personaDefault, maxTurns } = opts;
-        const controller = new AbortController();
+        // The drain runs under the run's cancellation scope (shared with the
+        // execs its loops spawn), so loop.cancel/shutdown abort it as a unit.
+        const controller = this.#runSignal(runId);
+        const handle = {
+            controller, promise: Promise.resolve(),
+        };
         let resolveFirst = () => { };
         let rejectFirst = () => { };
         const firstLoopPromise = new Promise((res, rej) => {
@@ -349,55 +379,65 @@ export default class Daemon {
             rejectFirst = rej;
         });
         let firstSettled = false;
+        const claim = () => this.#db.drain_claim_next_loop.get({ run_id: runId });
         const drainPromise = (async () => {
             let loopsDrained = 0;
             let lastResult = null;
             try {
                 while (true) {
                     controller.signal.throwIfAborted();
-                    const loopRow = await this.#db.drain_claim_next_loop.get({ run_id: runId });
-                    if (loopRow !== undefined) {
-                        const onDispatch = (logEntryId) => {
-                            void (async () => {
-                                const entry = await fetchLogEntry(this.#db, logEntryId);
-                                this.#broadcast({ sessionId }, null, "log/entry", { entry });
-                            })();
-                        };
-                        const result = await this.#engine.runLoop({
-                            provider, sessionId, runId, loopId: loopRow.id, maxTurns,
-                            messages: [
-                                { role: "system", content: systemPrompt },
-                                { role: "user", content: loopRow.prompt },
-                            ],
-                            persona: personaDefault,
-                            origin: "model",
-                            onDispatch,
-                            signal: controller.signal,
-                        });
-                        this.#broadcast({ sessionId }, null, "loop/terminated", {
-                            loopId: loopRow.id,
-                            finalStatus: result.finalStatus,
-                            hitMaxTurns: result.hitMaxTurns,
-                        });
-                        loopsDrained++;
-                        const loopResult = {
-                            loopId: loopRow.id,
-                            turnIds: result.turnIds,
-                            finalStatus: result.finalStatus,
-                            hitMaxTurns: result.hitMaxTurns,
-                        };
-                        lastResult = loopResult;
-                        if (!firstSettled) {
-                            firstSettled = true;
-                            resolveFirst(loopResult);
-                        }
-                        continue;
+                    let loopRow = await claim();
+                    if (loopRow === undefined) {
+                        // Queue empty → exit. Coordinate with a concurrent
+                        // inject + #ensureDrain: relinquish ownership, then
+                        // re-claim once. A loop that raced in during teardown
+                        // is caught here (re-acquire + run it); otherwise exit.
+                        // Identity-checked so we never delete a successor entry.
+                        if (this.#activeDrains.get(runId) === handle)
+                            this.#activeDrains.delete(runId);
+                        loopRow = await claim();
+                        if (loopRow === undefined)
+                            break;
+                        this.#activeDrains.set(runId, handle);
                     }
-                    // Queue empty. Stream-aware: don't exit while subs are open.
-                    const subRow = await this.#db.drain_count_active_subs_for_run.get({ run_id: runId });
-                    if ((subRow?.n ?? 0) === 0)
-                        break;
-                    await this.#awaitDrainPoke(runId, controller.signal);
+                    const onDispatch = (logEntryId) => {
+                        void (async () => {
+                            const entry = await LogEntry.fetchLogEntry(this.#db, logEntryId);
+                            this.#broadcast({ sessionId }, null, "log/entry", { entry });
+                        })();
+                    };
+                    const result = await this.#engine.runLoop({
+                        provider, sessionId, runId, loopId: loopRow.id, maxTurns,
+                        messages: [
+                            { role: "system", content: systemPrompt },
+                            { role: "user", content: loopRow.prompt },
+                        ],
+                        persona: personaDefault,
+                        origin: "model",
+                        onDispatch,
+                        signal: controller.signal,
+                    });
+                    this.#broadcast({ sessionId }, null, "loop/terminated", {
+                        loopId: loopRow.id,
+                        finalStatus: result.finalStatus,
+                        hitMaxTurns: result.hitMaxTurns,
+                    });
+                    loopsDrained++;
+                    const loopResult = {
+                        loopId: loopRow.id,
+                        turnIds: result.turnIds,
+                        finalStatus: result.finalStatus,
+                        hitMaxTurns: result.hitMaxTurns,
+                    };
+                    lastResult = loopResult;
+                    if (!firstSettled) {
+                        firstSettled = true;
+                        resolveFirst(loopResult);
+                    }
+                    // A next-turn prompt this loop ended before consuming (a
+                    // wake conclusion or a loop.run-while-active) is promoted to
+                    // a fresh queued loop so it's never silently dropped.
+                    await this.#reconcileOrphanedWake(runId, loopRow.id);
                 }
             }
             catch (err) {
@@ -412,59 +452,83 @@ export default class Daemon {
                     firstSettled = true;
                     rejectFirst(new Error("drain exited without producing a result"));
                 }
-                this.#activeDrains.delete(runId);
-                this.#drainPokes.delete(runId);
+                if (this.#activeDrains.get(runId) === handle)
+                    this.#activeDrains.delete(runId);
             }
             return { loopsDrained, lastResult };
         })();
-        this.#activeDrains.set(runId, { controller, promise: drainPromise });
-        // Attach a swallowing handler so unhandled rejections (e.g. when
-        // the drain aborts and no caller awaited drainPromise) don't
-        // crash the process. The error already surfaced via firstLoopPromise
-        // if relevant, or was already logged inside the drain body.
+        handle.promise = drainPromise;
+        this.#activeDrains.set(runId, handle);
+        // Swallow unhandled rejections (drain aborts with no awaiter); the
+        // error already surfaced via firstLoopPromise or was logged inside.
         drainPromise.catch(() => { });
-        // firstLoopPromise also needs a handler in case nobody awaits it
-        // (e.g. wake-on-completion enqueue path doesn't always read it).
         firstLoopPromise.catch(() => { });
         return { firstLoopPromise, drainPromise };
     }
-    #pokeDrain(runId) {
-        const poke = this.#drainPokes.get(runId);
-        if (poke !== undefined) {
-            this.#drainPokes.delete(runId);
-            poke();
-        }
+    // Idempotent, synchronous drain guarantee. A live drain will claim the
+    // just-enqueued loop in its own iteration (or its exit re-claim) → return
+    // null. Otherwise start one. MUST be called synchronously after the
+    // enqueue (no await between) so the membership test and #startDrain's
+    // registry write are one tick — two concurrent injects can't both start a
+    // drain for the same run.
+    #ensureDrain(opts) {
+        if (this.#activeDrains.has(opts.runId))
+            return null;
+        return this.#startDrain(opts);
     }
-    #awaitDrainPoke(runId, signal) {
-        return new Promise((resolve, reject) => {
-            if (signal.aborted) {
-                reject(new Error("drain aborted"));
-                return;
-            }
-            const onAbort = () => {
-                this.#drainPokes.delete(runId);
-                reject(new Error("drain aborted"));
-            };
-            signal.addEventListener("abort", onAbort, { once: true });
-            this.#drainPokes.set(runId, () => {
-                signal.removeEventListener("abort", onAbort);
-                resolve();
-            });
+    // After a loop terminates, promote any next-turn prompt it never consumed —
+    // an injected wake (stream conclusion) or a loop.run-while-active prompt
+    // that landed on a turn the loop didn't reach — into a fresh queued loop.
+    // The drain claims it on its next iteration, so a conclusion or client
+    // prompt is never silently dropped. Inherits the ended loop's flags + persona.
+    async #reconcileOrphanedWake(runId, endedLoopId) {
+        const prefix = `prompt/${endedLoopId}/`;
+        const orphan = await this.#db.drain_orphaned_prompt_for_loop.get({ loop_id: endedLoopId, pattern: `${prefix}%`, prefix_len: prefix.length });
+        if (orphan === undefined)
+            return;
+        const seqRow = await this.#db.loop_run_next_sequence.get({ run_id: runId });
+        if (seqRow === undefined)
+            throw new Error("reconcileOrphanedWake: next-sequence query returned no row");
+        const fresh = await this.#db.drain_enqueue_loop.get({
+            run_id: runId, sequence: seqRow.next, prompt: orphan.body, persona: orphan.persona,
         });
+        if (fresh === undefined)
+            throw new Error("reconcileOrphanedWake: enqueue returned no row");
+        if (orphan.flags !== null) {
+            await this.#db.engine_set_loop_flags.run({ loop_id: fresh.id, flags: orphan.flags });
+        }
+    }
+    // The run's cancellation scope — lazily created, and replaced once aborted
+    // so a later loop.run gets a live signal. The drain and the execs its loops
+    // spawn all run under it.
+    #runSignal(runId) {
+        const existing = this.#runAborts.get(runId);
+        if (existing !== undefined && !existing.signal.aborted)
+            return existing;
+        const fresh = new AbortController();
+        this.#runAborts.set(runId, fresh);
+        return fresh;
     }
     /**
-     * Cancel the active drain for a run. Fires the drain's AbortController;
-     * the engine's per-loop loopAbort cascades from the runLoop signal arg,
-     * so in-flight scheme operations (exec spawns, future SSE/WS) tear
-     * down. Queued loops in the run remain enqueued — call again if you
-     * want them cleared, or rely on subsequent loop.run to resume.
+     * Cancel the run's in-flight work (loop.cancel). One abort, one scope: the
+     * run signal stops the running loop's turn generation AND tears down every
+     * stream linked to it — a background exec that outlived its loop, or even a
+     * spawn that registers after this abort (it self-aborts against the aborted
+     * signal). Returns cancelled iff there was work. Queued loops stay enqueued.
      */
     cancelDrain(runId, reason = "user_cancelled") {
-        const drain = this.#activeDrains.get(runId);
-        if (drain === undefined)
-            return false;
-        drain.controller.abort(reason);
-        return true;
+        const hadWork = this.#activeDrains.has(runId) || this.#runHasActiveStreams(runId);
+        const scope = this.#runAborts.get(runId);
+        if (scope !== undefined && !scope.signal.aborted)
+            scope.abort(reason);
+        return hadWork;
+    }
+    // Does the run have an in-flight stream (a background exec)? Used only for
+    // loop.cancel's cancelled=true/false answer; the teardown itself rides the
+    // run signal. Duck-typed like #drainStreamingSchemes.
+    #runHasActiveStreams(runId) {
+        const exec = this.#schemes.get("exec");
+        return exec?.hasActiveSpawns?.(runId) ?? false;
     }
     /**
      * Wake-on-completion handler. Streaming schemes call this when a
@@ -480,12 +544,6 @@ export default class Daemon {
      * Rummy parallel: plugins/stream/stream.js stream/completed wake:true.
      */
     async #handleWakeRun(payload) {
-        // Every subscription close pokes the run's drain (if any) so a
-        // parked stream-aware drain re-checks active subs count. This
-        // happens regardless of whether we go on to inject a new loop,
-        // so the 499-skipped / no-provider paths still wake the drain
-        // out of its "queue empty, waiting for streams" state.
-        this.#pokeDrain(payload.runId);
         // Aborted streams don't wake — the abort was deliberate.
         if (payload.closeStatus === 499) {
             this.#broadcast({ sessionId: payload.sessionId }, null, "stream/concluded", {
@@ -500,8 +558,8 @@ export default class Daemon {
             return;
         }
         try {
-            const systemPrompt = await readFile(PATHS.instructionsSystem, "utf8");
-            const personaText = await readFile(PATHS.defaultPersona, "utf8");
+            const systemPrompt = await readFile(Paths.instructionsSystem, "utf8");
+            const personaText = await readFile(Paths.defaultPersona, "utf8");
             // Unified path: this.inject decides whether to write a prompt
             // entry for an active drain's next turn (no-op-active-loop) or
             // enqueue a fresh loop + drain (opened-loop). The summary
@@ -558,11 +616,11 @@ export default class Daemon {
         // bin script). Mimetypes self-discovers — Mimetypes.ready() in start()
         // scans @plurnk/plurnk-mimetypes-* packages via the framework's own
         // discover().
-        const plugins = await discoverPlugins(this.#nodeModulesPath);
+        const plugins = await PluginLoader.discoverPlugins(this.#nodeModulesPath);
         for (const plugin of plugins) {
             if (plugin.manifest.kind !== "scheme")
                 continue;
-            const instance = await loadPlugin(plugin);
+            const instance = await PluginLoader.loadPlugin(plugin);
             this.#schemes.register(plugin.manifest.name, instance);
         }
     }