@plurnk/plurnk-service 1.17.0 → 1.19.0

package/dist/server/Daemon.js

@@ -23,12 +23,17 @@ import SkillsFunctionality from "./SkillsFunctionality.js";
 import PlurnkSkill from "./PlurnkSkill.js";
 import Skill from "../schemes/Skill.js";
 import MembersFunctionality from "./MembersFunctionality.js";
+import EnvFunctionality, { ENV_OWNER } from "./EnvFunctionality.js";
+import HostPaths from "../core/HostPaths.js";
+import WorkspaceStorage from "./WorkspaceStorage.js";
 import Fork from "../core/fork.js";
 import WorkerControlAddress from "../core/WorkerControlAddress.js";
-import LoopLifecycle, { taskTiming } from "../core/LoopLifecycle.js";
+import LoopLifecycle from "../core/LoopLifecycle.js";
+import Knob from "../core/Knob.js";
+import LoopPolicies from "../core/LoopPolicies.js";
 import LoopPolicyReader from "../core/LoopPolicyReader.js";
-import { promptLoopPrefix } from "../core/plurnk-uri.js";
 import { contentWeight } from "../core/content-weight.js";
+import MessageResources from "../core/MessageResources.js";
 import { parseAliasesFromEnv, resolveActiveRoute } from "@plurnk/plurnk-providers";
 import ProviderInstantiate from "../core/ProviderInstantiate.js";
 import Results, { OperationFailureError } from "../core/results.js";
@@ -60,6 +65,9 @@ export default class Daemon {
     #ownsMimetypes;
     #provider;
     #nodeModulesPath;
+    // {§http-host} — the one listener, bound by the service before durable admission; null in
+    // tests that never open a transport.
+    #http;
     #discoveryCwd;
     #started = false; // {§module-lifecycle}: one discovery/module boot; no listener
     #modules = [];
@@ -77,8 +85,11 @@ export default class Daemon {
     #eventSubscribers = new Set();
     #workerModels;
     #reads;
-    constructor({ db, schemes, mimetypes, provider, nodeModulesPath, skills }) {
+    #storage;
+    constructor({ db, schemes, mimetypes, provider, nodeModulesPath, hostPaths = new HostPaths(), skills, http = null }) {
         this.#db = db;
+        this.#http = http;
+        this.#storage = new WorkspaceStorage(db, hostPaths);
         this.#lifecycle = new LoopLifecycle(db);
         this.#schemes = schemes ?? new SchemeRegistry();
         this.#provider = provider ?? null;
@@ -123,12 +134,15 @@ export default class Daemon {
             registerWorkspaceCapabilityProvider: (owner, provider) => this.registerWorkspaceCapabilityProvider(owner, provider),
             readWorkspaceModuleState: (workspaceId, owner) => this.readWorkspaceModuleState(workspaceId, owner),
             replaceWorkspaceCapabilities: (replacement, options) => this.replaceWorkspaceCapabilities(replacement, options),
+            readWorkerModuleState: (workerId, owner) => this.#residency.readWorkerModuleState(workerId, owner),
+            replaceWorkerModuleState: (workerId, owner, state) => this.#residency.replaceWorkerModuleState(workerId, owner, state),
             mutateWorkspace: (workspaceId, owner, caller, run) => this.#residency.exclusively(workspaceId, owner, caller === "operation" ? "wait" : "try", run),
             retainWorkspace: (workspaceId) => this.#residency.retain(workspaceId)
         });
         // {§skills-functionality} — Core's own family: standard Agent Skills.
         this.#skills = new SkillsFunctionality({
             db,
+            hostPaths,
             ...skills,
             provided: async () => {
                 const tree = await PlurnkSkill.load(this.#nodeModulesPath);
@@ -140,6 +154,8 @@ export default class Daemon {
         // {§members-functionality} — Core's own family: file membership on the same surface.
         this.#members = new MembersFunctionality({ db, engine: () => this.#engine });
         this.#functionality.register(this.#members);
+        // {§env-functionality} — Core's own family: the environment a Worker's commands run in.
+        this.#functionality.register(new EnvFunctionality(EnvFunctionality.defaultsReader(Paths.packageRoot, this.#nodeModulesPath)));
         this.#engine = new Engine({
             db, lifecycle: this.#lifecycle, schemes: this.#schemes, mimetypes: this.#mimetypes,
             // {§tokenomics-agnostic-ruler} — stored and catalog curation weights
@@ -147,6 +163,7 @@ export default class Daemon {
             // model-independent. Request-shaped token facts stay provider-owned.
             weigh: contentWeight,
             streamEventNotify: (workspaceId, event) => this.notifyStreamEvent(workspaceId, event),
+            operationSettledNotify: (workspaceId, logEntryId) => this.#drains.operationSettled(workspaceId, logEntryId),
             reasoningEventNotify: (workspaceId, event) => this.notifyReasoningEvent(workspaceId, event),
             wakeWorkerNotify: (payload) => this.#drains.notifyWakeWorker(payload),
             // worker:// loop-start primitive — spawn/fork/irc deliver through
@@ -154,7 +171,7 @@ export default class Daemon {
             // daemon owns provider + the law-file system prompt; the worker scheme
             // handler carries neither. Fire-and-forget: the returned drain runs
             // independently (the sister is its own worker). {§machine-processes}
-            injectWorker: async ({ workspaceId, workerId, sourceLoopId, prompt, freshLoopPolicy, spawn, schedule }) => {
+            injectWorker: async ({ workspaceId, workerId, sourceLoopId, prompt, freshLoopPolicy, spawn, environment, attachments }) => {
                 await this.#assertModelWorker(workspaceId, workerId);
                 const sender = await this.#db.drain_message_source.get({ loop_id: sourceLoopId });
                 if (sender === undefined || sender.workspace_id !== workspaceId) {
@@ -193,13 +210,20 @@ export default class Daemon {
                         reasoning_policy: reasoningPolicy,
                         reasoning_source: "default"
                     });
+                    // {§env-option} — the heading's environment lands as the child's own entries through the
+                    // family's add, after the copy it inherited at creation ({§functionality-scope}); names
+                    // were admitted at the operation, so a refusal here is a defect and throws.
+                    for (const [alias, value] of Object.entries(environment ?? {})) {
+                        await this.#functionality.invoke("env", "add", { alias, definition: { value } }, { workspaceId, workerId }, "operation");
+                    }
                 }
-                const { action, loopId, scheduledAt, intervalMinutes, recurrenceId } = await this.inject({
+                const delivered = await this.#prepareMessage(workspaceId, workerId, prompt, attachments);
+                const { action, loopId } = await this.inject({
                     workspaceId,
                     workerId,
-                    prompt,
+                    prompt: delivered.body,
+                    evidence: delivered.evidence,
                     sourceLoopId,
-                    ...(schedule === undefined ? {} : { schedule }),
                     ...(source === undefined ? {} : { source }),
                     providerSpec,
                     reasoningPolicy,
@@ -207,7 +231,7 @@ export default class Daemon {
                     systemPrompt,
                     ...(freshLoopPolicy === undefined ? {} : { freshLoopPolicy })
                 });
-                return { action, loopId, scheduledAt, intervalMinutes, recurrenceId };
+                return { action, loopId };
             },
             acquireWorkspaceTurn: async (workspaceId, workerId, signal) => this.#workspaceGate.acquireTurn(workspaceId, workerId, signal),
             // {§skills-hotload} — filesystem installers operate out of band.
@@ -219,7 +243,6 @@ export default class Daemon {
             // worker:// KILL (terminate) — cancel the addressed worker subtree and
             // tear down its held streams before the operation completes.
             cancelWorker: async (workerId, reason) => this.#drains.cancelWorkerTree(workerId, reason),
-            cancelDescendants: async (workerId, reason) => this.#drains.cancelDescendants(workerId, reason),
             noticeNotify: (workspaceId, payload) => this.notifyNotice(workspaceId, payload),
             loopPacketNotify: (workspaceId, payload) => {
                 this.#broadcast({ workspaceId }, "loop/packet", payload);
@@ -229,7 +252,7 @@ export default class Daemon {
         this.#drains = new DrainSupervisor({
             db,
             lifecycle: this.#lifecycle,
-            injectPrompt: (loopId, prompt, openPaths, source) => this.#engine.injectIntoLoop(loopId, prompt, openPaths, source),
+            injectPrompt: (loopId, prompt, openPaths, source, evidence, messageAddress) => this.#engine.injectIntoLoop(loopId, prompt, openPaths, source, evidence, messageAddress),
             assertInjectionCompatibility: async ({ workerId, loopId, providerSpec, providerSpecExplicit, reasoningPolicy, childProviderSpec, turnCeiling, policy }) => {
                 await this.#assertFoldPosture(workerId, policy, loopId);
                 // An omitted selector keeps the loop's durable provider; only an
@@ -243,7 +266,7 @@ export default class Daemon {
                 }
                 await this.#assertLoopMaxTurns(loopId, turnCeiling?.source === "explicit" ? turnCeiling.effective : undefined);
             },
-            reconcilePrompts: (workerId, endedLoopId) => this.#reconcileOrphanedPrompts(workerId, endedLoopId),
+            reconcileMessages: (workerId, endedLoopId) => this.#reconcileOrphanedMessages(workerId, endedLoopId),
             runLoop: async ({ workspaceId, workerId, loopId, maxTurns, prompt, systemPrompt, signal, onSettled }) => {
                 // The drain callback is the final provider/model boundary. Every
                 // admission path, including boot recovery, terminates here.
@@ -291,6 +314,7 @@ export default class Daemon {
             const { workspaceId, ...proposal } = event;
             this.#broadcast({ workspaceId }, "loop/proposal", proposal);
         });
+        // {§notifications-loop-interaction} — the projection is the payload; its scope is the envelope's.
         this.#engine.onClientInteractionPending((event) => {
             const { workspaceId, ...interaction } = event;
             this.#broadcast({ workspaceId }, "loop/interaction", interaction);
@@ -324,10 +348,28 @@ export default class Daemon {
         const checkedWorkspaceId = ClientInput.assertId("pendingClientInteractions", "workspaceId", workspaceId);
         return this.#engine.pendingClientInteractions(checkedWorkspaceId);
     }
-    async resolveClientInteraction(interactionId, resolution) {
+    async resolveClientInteraction(interactionId, resolution, message) {
         const checkedInteractionId = ClientInput.assertId("resolveClientInteraction", "interactionId", interactionId);
         const checkedResolution = ClientInput.assertClientInteractionResolution("resolveClientInteraction", resolution);
-        await this.#engine.resolveClientInteraction(checkedInteractionId, checkedResolution);
+        if (message !== undefined) {
+            ClientInput.assertPrompt("resolveClientInteraction", message.body);
+            ClientInput.assertOptionalSource("resolveClientInteraction", message.source);
+        }
+        await this.#engine.resolveClientInteraction(checkedInteractionId, checkedResolution, message);
+    }
+    async #prepareMessage(workspaceId, workerId, body, attachments = [], envelope) {
+        const published = await MessageResources.publish(body, attachments, {
+            db: this.#db, workspaceId, workerId, loopId: 0, turnId: 0, writer: "_plurnk", signal: undefined,
+            weigh: contentWeight, mimetypes: this.#mimetypes,
+        });
+        return { body: published.body, evidence: {
+                ...(envelope === undefined ? {} : { envelope: structuredClone(envelope) }),
+                ...(published.attachments.length === 0 ? {} : { attachments: published.attachments }),
+            } };
+    }
+    async readMessages(args) {
+        await this.#assertModelWorker(args.workspaceId, args.workerId);
+        return MessageResources.read(this.#db, args);
     }
     // {§methods-loop-run} — drive/steer a loop. The module supplies only workspace/worker/prompt;
     // the provider and the law-file system prompt are core's and stay inside. Returns immediately — the
@@ -337,8 +379,10 @@ export default class Daemon {
         const workspaceId = ClientInput.assertId("runLoop", "workspaceId", args.workspaceId);
         const workerId = ClientInput.assertId("runLoop", "workerId", args.workerId);
         await this.#assertModelWorker(workspaceId, workerId);
-        const prompt = ClientInput.assertPrompt("runLoop", args.prompt);
+        const attachments = ClientInput.assertMessageResources("runLoop", args.attachments);
+        const body = ClientInput.assertPrompt("runLoop", args.prompt, attachments.length > 0);
         const source = ClientInput.assertOptionalSource("runLoop", args.source);
+        const messageAddress = ClientInput.assertOptionalSource("runLoop", args.messageAddress);
         const requestedMaxTurns = ClientInput.assertMaxTurns("runLoop", args.maxTurns);
         const openPaths = ClientInput.assertOpenPaths("runLoop", args.openPaths);
         const selector = ClientInput.assertOptionalSelector("runLoop", "selector", args.selector);
@@ -365,17 +409,20 @@ export default class Daemon {
         const systemPrompt = await readFile(Paths.instructionsSystem, "utf8");
         // {§operator-config-max-turns-ceiling} — the operator ceiling clamps a per-call maxTurns; a
         // seam caller must not bypass operator policy (inject only DEFAULTS from env, never clamps).
-        const ceiling = Number(process.env.PLURNK_SERVICE_MAX_TURNS ?? "-1");
+        const ceiling = Knob.integer("PLURNK_SERVICE_MAX_TURNS", -1);
         const requested = requestedMaxTurns ?? ceiling;
         const maxTurns = ceiling < 0 ? requested : (requested < 0 ? ceiling : Math.min(requested, ceiling));
         const turnCeiling = {
             effective: maxTurns,
             source: requestedMaxTurns === undefined ? "implicit" : "explicit"
         };
+        const delivered = await this.#prepareMessage(workspaceId, workerId, body, attachments, args.envelope);
         const { action, loopId, turnSeq } = await this.inject({
             workspaceId,
             workerId,
-            prompt,
+            prompt: delivered.body,
+            evidence: delivered.evidence,
+            ...(messageAddress === undefined ? {} : { messageAddress }),
             ...(source === undefined ? {} : { source }),
             ...(policy !== undefined ? { policy } : {}),
             ...(openPaths !== undefined ? { openPaths } : {}),
@@ -510,7 +557,7 @@ export default class Daemon {
     async readWorkerModel(args) {
         const workspaceId = ClientInput.assertId("worker.model.get", "workspaceId", args.workspaceId);
         const workerId = ClientInput.assertId("worker.model.get", "workerId", args.workerId);
-        await this.#assertWorkerOwned(workspaceId, workerId);
+        await this.#assertModelWorker(workspaceId, workerId);
         const row = await this.#db.worker_generation_policy_read.get({ id: workerId });
         if (row === undefined)
             throw new Error(`worker ${workerId}: model route row missing`);
@@ -526,7 +573,7 @@ export default class Daemon {
     async setWorkerModel(args) {
         const workspaceId = ClientInput.assertId("worker.model.set", "workspaceId", args.workspaceId);
         const workerId = ClientInput.assertId("worker.model.set", "workerId", args.workerId);
-        await this.#assertWorkerOwned(workspaceId, workerId);
+        await this.#assertModelWorker(workspaceId, workerId);
         const selector = ClientInput.assertSelector("worker.model.set", "selector", args.selector);
         const policy = await this.#workerModels.resolveWorkerModel(workerId, selector);
         if (policy === null) {
@@ -539,7 +586,7 @@ export default class Daemon {
     async readWorkerReasoning(args) {
         const workspaceId = ClientInput.assertId("worker.reasoning.get", "workspaceId", args.workspaceId);
         const workerId = ClientInput.assertId("worker.reasoning.get", "workerId", args.workerId);
-        await this.#assertWorkerOwned(workspaceId, workerId);
+        await this.#assertModelWorker(workspaceId, workerId);
         await this.#workerModels.resolveWorkerModel(workerId, undefined);
         const row = await this.#db.worker_generation_policy_read.get({ id: workerId });
         if (row === undefined)
@@ -571,7 +618,7 @@ export default class Daemon {
         catch (cause) {
             throw daemonFailure("daemon:input", "reasoning-policy-invalid", 400, cause instanceof Error ? cause.message : "The reasoning policy is invalid.", { field: "policy", retryable: false });
         }
-        await this.#assertWorkerOwned(workspaceId, workerId);
+        await this.#assertModelWorker(workspaceId, workerId);
         await this.#workerModels.resolveWorkerModel(workerId, undefined);
         const row = await this.#db.worker_generation_policy_read.get({ id: workerId });
         if (row === undefined)
@@ -598,7 +645,7 @@ export default class Daemon {
     async setWorkerSpawnModel(args) {
         const workspaceId = ClientInput.assertId("worker.child.set", "workspaceId", args.workspaceId);
         const workerId = ClientInput.assertId("worker.child.set", "workerId", args.workerId);
-        await this.#assertWorkerOwned(workspaceId, workerId);
+        await this.#assertModelWorker(workspaceId, workerId);
         const selector = ClientInput.assertChildSelector("worker.child.set", args.selector);
         const spec = await this.#workerModels.resolveWorkerSpawnModel(workerId, selector);
         if (spec === null)
@@ -616,8 +663,9 @@ export default class Daemon {
         }
     }
     // {§machine-processes} — provider inference is an exclusive capability of a
-    // model worker. The same assertion is used by early client admissions and
-    // the final drain callback, so recovery and internal callers cannot bypass it.
+    // model worker. The same assertion is used by early client admissions, the final
+    // drain callback, and the model, reasoning, and spawn-model controls
+    // ({§worker-model-selection}), so recovery and internal callers cannot bypass it.
     async #assertModelWorker(workspaceId, workerId) {
         const worker = await this.#db.envelope_get_worker_by_id.get({ id: workerId });
         if (worker === undefined) {
@@ -635,7 +683,7 @@ export default class Daemon {
             throw daemonFailure("daemon:worker", "model-worker-required", 409, `Worker ${workerId} is not a model worker.`, {
                 workerId,
                 actualOrigin: worker.origin,
-                recovery: "Select or create a model worker for this loop.",
+                recovery: "Select or create a model worker.",
                 retryable: false
             });
         }
@@ -764,11 +812,17 @@ export default class Daemon {
     // dispatchClientAction). Its closed observation segment supplies the numeric loop coordinate
     // required by plugin context and relative log:/// addresses without impersonating an active
     // client lifecycle. It creates no turn or log row. Engine.look enforces READ-only.
+    // {§op-look} — the segment is the acting worker's; the READ resolves as the perspective worker.
     async look(args) {
         const workspaceId = ClientInput.assertId("operation.look", "workspaceId", args.workspaceId);
         const workerId = ClientInput.assertId("operation.look", "workerId", args.workerId);
+        const perspective = args.perspectiveWorkerId === undefined
+            ? workerId
+            : ClientInput.assertId("operation.look", "perspectiveWorkerId", args.perspectiveWorkerId);
         const { statement } = args;
         await this.#assertWorkerOwned(workspaceId, workerId);
+        if (perspective !== workerId)
+            await this.#assertWorkerOwned(workspaceId, perspective);
         const releaseCapabilities = await this.#residency.acquire(workspaceId);
         try {
             const releaseWorkspace = await this.#workspaceGate.acquireTurn(workspaceId, workerId);
@@ -776,7 +830,7 @@ export default class Daemon {
                 await this.#residency.reconcile(workspaceId);
                 const clientLoopId = await Envelope.ensureClientLoop(this.#db, workerId);
                 try {
-                    const result = await this.#engine.look({ statement, workspaceId, workerId, loopId: clientLoopId });
+                    const result = await this.#engine.look({ statement, workspaceId, workerId: perspective, loopId: clientLoopId });
                     await Envelope.closeClientLoop(this.#db, clientLoopId, { status: 200 });
                     return result;
                 }
@@ -887,7 +941,6 @@ export default class Daemon {
             promptSource: row.promptSource,
             terminatedAt: row.terminatedAt,
             packetCount: row.packetCount,
-            ...taskTiming(row),
             terminalResult: row.terminalResult === null
                 ? null
                 : Validator.assertOperationResult(JSON.parse(row.terminalResult))
@@ -897,7 +950,7 @@ export default class Daemon {
     listPrompts(workspaceId, limit) {
         const checkedWorkspaceId = ClientInput.assertId("workspace.prompts", "workspaceId", workspaceId);
         const checkedLimit = ClientInput.assertLimit("workspace.prompts", limit);
-        return Envelope.listPromptsForWorkspace(this.#db, checkedWorkspaceId, checkedLimit ?? 100);
+        return Envelope.listPromptsForWorkspace(this.#db, checkedWorkspaceId, checkedLimit ?? Knob.integer("PLURNK_SERVICE_PROMPTS_PAGE", 1));
     }
     workspaceDerivationStatus(workspaceId) {
         return this.#engine.workspaceDerivationStatus(ClientInput.assertId("workspace.derivation", "workspaceId", workspaceId));
@@ -948,7 +1001,7 @@ export default class Daemon {
         if (name !== undefined) {
             const taken = await this.#db.envelope_get_worker_by_name.get({ workspace_id: workspaceId, name });
             if (taken !== undefined) {
-                throw daemonFailure("daemon:worker", "name-conflict", 409, `Worker name '${name}' is already in use in workspace ${workspaceId}.`, { workspaceId, name, recovery: "Choose another worker name.", retryable: false });
+                throw daemonFailure("daemon:worker", "name-conflict", 409, `Worker name '${name}' is already in use in workspace ${workspaceId} by a ${taken.origin} worker.`, { workspaceId, name, actualOrigin: taken.origin, recovery: "Choose another worker name.", retryable: false });
             }
         }
         const worker = await Envelope.createModelWorker(this.#db, workspaceId, name);
@@ -975,7 +1028,7 @@ export default class Daemon {
         if (name !== undefined) {
             const taken = await this.#db.envelope_get_worker_by_name.get({ workspace_id: workspaceId, name });
             if (taken !== undefined) {
-                throw daemonFailure("daemon:worker", "name-conflict", 409, `Worker name '${name}' is already in use in workspace ${workspaceId}.`, { workspaceId, name, recovery: "Choose another worker name.", retryable: false });
+                throw daemonFailure("daemon:worker", "name-conflict", 409, `Worker name '${name}' is already in use in workspace ${workspaceId} by a ${taken.origin} worker.`, { workspaceId, name, actualOrigin: taken.origin, recovery: "Choose another worker name.", retryable: false });
             }
         }
         const branchWorkerId = await Fork.fork(this.#db, workerId, name);
@@ -1018,6 +1071,18 @@ export default class Daemon {
             scheme
         };
     }
+    // {§http-host} — exterior adapters mount on the daemon's one listener at start(); the
+    // daemon never opens a second transport, and a daemon without a listener says so.
+    registerHttpRoute(prefix, handler) {
+        if (this.#http === null)
+            throw new Error(`registerHttpRoute: this daemon has no HTTP listener to mount '${prefix}' on`);
+        this.#http.registerHttpRoute(prefix, handler);
+    }
+    httpAddress() {
+        if (this.#http === null)
+            throw new Error("httpAddress: this daemon has no HTTP listener");
+        return this.#http.httpAddress();
+    }
     registerModuleAction(registration) {
         const { name, scope, inputSchema, outputSchema, handler } = registration;
         if (name.length === 0)
@@ -1094,9 +1159,24 @@ export default class Daemon {
     registerWorkspaceCapabilityProvider(namespaceOwner, provider) {
         this.#residency.registerProvider(namespaceOwner, provider);
     }
+    // {§module-functionality-adapter}
     registerFunctionalityAdapter(adapter) {
         return this.#functionality.register(adapter);
     }
+    async readWorkspaceEnvironment(workspaceId) {
+        const snapshot = await EnvFunctionality.workspace(this.#db, workspaceId);
+        return (ambient) => snapshot(ambient).env;
+    }
+    workspaceStateDirectory(workspaceId, namespaceOwner) {
+        return this.#storage.directory(workspaceId, namespaceOwner);
+    }
+    async readWorkerEnvironment(workspaceId, workerId) {
+        await this.#assertWorkerOwned(workspaceId, workerId);
+        const shared = await EnvFunctionality.workspace(this.#db, workspaceId);
+        const row = await this.#db.worker_module_state_get.get({ worker_id: workerId, namespace_owner: ENV_OWNER });
+        const state = row === undefined ? { version: 1, definitions: {} } : JSON.parse(row.state);
+        return (ambient) => EnvFunctionality.compose(shared(ambient).env, state).env;
+    }
     async readWorkspaceModuleState(workspaceId, namespaceOwner) {
         return this.#residency.readModuleState(workspaceId, namespaceOwner);
     }
@@ -1116,6 +1196,11 @@ export default class Daemon {
         if (this.#started)
             throw new Error("daemon already started");
         this.#started = true;
+        // {§db-space-reclamation} — the file is brought to the policy's auto-vacuum mode before any work.
+        const storage = await this.#retention.prepareStorage();
+        if (storage.converted) {
+            console.error(`database: converted to auto_vacuum=${this.#retention.policy.autoVacuum} (${storage.pagesBefore} → ${storage.pagesAfter} pages)`);
+        }
         this.#drains.start();
         this.#retention.start((cause) => { console.error("retention pass failed:", cause instanceof Error ? cause.message : String(cause)); });
         // Mimetypes owns its own discovery scan over @plurnk/plurnk-mimetypes-*
@@ -1145,10 +1230,11 @@ export default class Daemon {
                     detail: "in-process"
                 }
             }]);
-        // {§effect-policy-tunable} — invalid operator policy fails boot, not the first EXEC.
+        // {§effect-policy-tunable} — invalid operator policy fails boot, not the first execution.
         EffectPolicy.validateConfiguration();
+        LoopPolicies.validateConfiguration();
         // {§exec} — mint a scheme per runtime tag so exec output entries address by tag
-        // authority (sh:///l/t/s). The "exec" scheme stays for the EXEC op dispatch.
+        // authority (sh:///l/t/s). The "exec" scheme stays for execution dispatch.
         this.#schemes.registerRuntimeSchemes(executors);
         // Discover external @plurnk/plurnk-schemes-* siblings + register them
         // (agnostic, by plurnk.kind:"scheme"). They light up http://, etc. with
@@ -1173,8 +1259,9 @@ export default class Daemon {
         await this.#schemes.ready();
         this.#residency.publish();
         await this.#recoverLifecycle();
-        // {§module-lifecycle} — the daemon opens no transport. Modules start their listeners only
-        // after capability publication and durable lifecycle recovery are complete.
+        // {§module-lifecycle} — the daemon opened its one transport before admission ({§http-host});
+        // modules mount their routes on it here, only after capability publication and durable
+        // lifecycle recovery are complete. None opens a listener of its own.
         for (const module of this.#modules) {
             const started = await module.start?.(this);
             if (started !== undefined && !this.#moduleClosers.includes(started)) {
@@ -1192,13 +1279,13 @@ export default class Daemon {
         await this.#db.recovery_error_orphan_subscription_channels.run({});
         await this.#db.recovery_fail_orphan_subscriptions.run({});
         await this.#db.recovery_resume_unblocked_parks.run({});
-        const orphanSources = await this.#db.recovery_orphan_prompt_sources.all({});
+        const orphanSources = await this.#db.recovery_orphan_message_sources.all({});
         const invalidOrphan = orphanSources.find(({ origin }) => origin !== "model");
         if (invalidOrphan !== undefined) {
             throw new Error(`Orphaned provider work belongs to ${invalidOrphan.origin} worker ${invalidOrphan.worker_id}; only model workers may enter inference.`);
         }
         for (const source of orphanSources) {
-            await this.#drains.reconcileOrphanedPrompts(source.worker_id, source.loop_id);
+            await this.#drains.reconcileOrphanedMessages(source.worker_id, source.loop_id);
         }
         const systemPrompt = await readFile(Paths.instructionsSystem, "utf8");
         const queued = await this.#db.recovery_queued_workers.all({});
@@ -1227,15 +1314,11 @@ export default class Daemon {
             await this.#drains.scheduleWakes(row.workspace_id, row.worker_id, systemPrompt);
         }
     }
-    // {§crash-only-stop} — the settle deadline. Default 30s; an operator can
-    // raise it for slow hosts or lower it for tests. 0 is refused (an unbounded
-    // stop is exactly the wedge this exists to prevent).
+    // {§crash-only-stop} — the settle deadline. The panel owns the value; an operator can raise it
+    // for slow hosts or lower it for tests. 0 is refused (an unbounded stop is exactly the wedge
+    // this exists to prevent).
     static #stopDeadlineMs() {
-        const raw = Number(process.env.PLURNK_SERVICE_STOP_TIMEOUT_MS ?? 30_000);
-        if (!Number.isSafeInteger(raw) || raw <= 0) {
-            throw new Error(`PLURNK_SERVICE_STOP_TIMEOUT_MS must be a positive integer; got ${JSON.stringify(process.env.PLURNK_SERVICE_STOP_TIMEOUT_MS)}.`);
-        }
-        return raw;
+        return Knob.integer("PLURNK_SERVICE_STOP_TIMEOUT_MS", 1);
     }
     async stop() {
         if (!this.#started)
@@ -1335,7 +1418,7 @@ export default class Daemon {
     // (SSE, WS) add themselves here as they land.
     async #drainStreamingSchemes() {
         const exec = this.#schemes.get("exec");
-        // {§exec-timeout} — a `<-1>` spawn ends with the daemon: nothing else ever aborts it.
+        // {§exec-lifetime} — a detached spawn ends with the daemon: nothing else ever aborts it.
         exec?.abortDetached?.();
         if (exec?.idle !== undefined)
             await exec.idle();
@@ -1385,40 +1468,34 @@ export default class Daemon {
     inject(args) {
         return this.#drains.inject(args);
     }
-    // Durable prompt promotion remains daemon policy; DrainSupervisor invokes
+    // Durable message promotion remains daemon policy; DrainSupervisor invokes
     // it under the same worker lock as enqueue and drain teardown.
-    async #reconcileOrphanedPrompts(workerId, endedLoopId) {
-        const endedSeq = (await this.#db.engine_loop_sequence.get({ loop_id: endedLoopId }))?.sequence ?? endedLoopId;
-        const prefix = promptLoopPrefix(endedSeq);
-        const frames = await this.#db.drain_orphaned_prompts_for_loop.all({ loop_id: endedLoopId, worker_id: workerId, pattern: `${prefix}%`, prefix_len: prefix.length });
-        const first = frames[0];
+    async #reconcileOrphanedMessages(workerId, endedLoopId) {
+        const messages = await this.#db.drain_orphaned_messages_for_loop.all({ loop_id: endedLoopId });
+        const first = messages[0];
         if (first === undefined)
             return;
         const recovery = await this.#db.drain_enqueue_orphan_recovery_loop.get({
             worker_id: workerId,
             prompt: first.body,
-            prompt_source: first.prompt_source,
+            prompt_source: first.source,
             policy: first.policy,
             model_route_id: first.model_route_id,
             spawn_model_route_id: first.spawn_model_route_id,
             reasoning_policy: first.reasoning_policy,
             max_turns: first.max_turns,
-            open_paths: first.open_paths ?? "[]",
             orphan_source_loop_id: endedLoopId
         });
         if (recovery === undefined)
-            throw new Error("reconcileOrphanedPrompts: enqueue returned no row");
+            throw new Error("reconcileOrphanedMessages: enqueue returned no row");
         if (recovery.status !== 100)
             return;
-        const moved = await this.#db.drain_rehome_orphaned_prompt_frames.all({
-            worker_id: workerId,
+        const moved = await this.#db.drain_rehome_orphaned_messages.all({
             source_loop_id: endedLoopId,
-            source_pattern: `${prefix}%`,
-            source_prefix_len: prefix.length,
-            target_prefix: promptLoopPrefix(recovery.sequence)
+            target_loop_id: recovery.id
         });
-        if (moved.length !== frames.length) {
-            throw new Error(`reconcileOrphanedPrompts: expected to re-home ${frames.length} frames, moved ${moved.length}`);
+        if (moved.length !== messages.length) {
+            throw new Error(`reconcileOrphanedMessages: expected to re-home ${messages.length} messages, moved ${moved.length}`);
         }
     }
     cancelDrain(workerId, reason = "user_cancelled") {