@plurnk/plurnk-service 1.29.0 → 3.0.0

package/dist/server/Daemon.js

@@ -1,8 +1,9 @@
 // Top-level daemon orchestrator. Owns the DB connection, engine, registries,
-// the transport-free plugin-module seam ({§rpc}).
+// the transport-free module seam ({§rpc}).
 import { readFile } from "node:fs/promises";
 import { resolve, dirname } from "node:path";
-import Share from "../share/Share.js";
+import { Share } from "@plurnk/plurnk-digest";
+import EvidenceReader from "@plurnk/plurnk-service/evidence";
 import Paths from "../Paths.js";
 import Engine from "../core/Engine.js";
 import ExecutorRegistry from "../core/ExecutorRegistry.js";
@@ -16,20 +17,18 @@ import EffectPolicy from "../schemes/EffectPolicy.js";
 import QuestionTool, { questionRuntimeDecl } from "../schemes/QuestionTool.js";
 import DrainSupervisor from "./DrainSupervisor.js";
 import Retention, { retentionPolicy } from "./Retention.js";
-import PacketBuilder from "../core/PacketBuilder.js";
 import TurnDispositionHandler from "../core/TurnDispositionHandler.js";
 import { Validator } from "@plurnk/plurnk-contracts";
 import LogEntry from "./logEntry.js";
+import HttpListener from "./HttpListener.js";
 import Envelope, { projectWorkerRow } from "./envelope.js";
 import ClientInput from "./client-input.js";
 import Turn from "../core/Turn.js";
-import { expandTargetGroup } from "../core/operation-target-groups.js";
-import SkillsFunctionality from "./SkillsFunctionality.js";
 import WorkspacePlugins from "./WorkspacePlugins.js";
-import { agentRootScopes, configurationDirectories } from "./AgentRoots.js";
+import { agentRootScopes, workspacePaths } from "./AgentRoots.js";
 import ExecEnv from "../schemes/exec-env.js";
 import PlurnkSkill from "./PlurnkSkill.js";
-import Skill from "../schemes/Skill.js";
+import ResourceTreeScheme from "../schemes/ResourceTreeScheme.js";
 import MembersFunctionality, { modelScope, serviceMembers } from "./MembersFunctionality.js";
 import FileCreationPolicy from "../core/file-creation-policy.js";
 import EnvFunctionality, { ENV_OWNER } from "./EnvFunctionality.js";
@@ -39,8 +38,9 @@ import Fork from "../core/fork.js";
 import WorkerControlAddress from "../core/WorkerControlAddress.js";
 import LoopLifecycle from "../core/LoopLifecycle.js";
 import { ConfigurationError, Knob } from "@plurnk/plurnk-meta";
-import LoopPolicies from "../core/LoopPolicies.js";
-import LoopPolicyReader from "../core/LoopPolicyReader.js";
+import ProposalPolicies from "../core/ProposalPolicies.js";
+import WorkerOwners from "../core/WorkerOwners.js";
+import RuntimeWorker from "../core/RuntimeWorker.js";
 import { contentWeight } from "../core/content-weight.js";
 import MessageResources from "../core/MessageResources.js";
 import { parseAliasesFromEnv, resolveActiveRoute } from "@plurnk/plurnk-providers";
@@ -69,15 +69,13 @@ export default class Daemon {
     static validateConfiguration() {
         FileCreationPolicy.serviceScope();
         EffectPolicy.validateConfiguration();
-        LoopPolicies.validateConfiguration();
+        ProposalPolicies.read();
         TurnDispositionHandler.configuredWaitSeconds();
         retentionPolicy();
-        PacketBuilder.validateConfiguration();
         Exec.validateConfiguration();
         ExecutorRegistry.validateConfiguration();
     }
     static validateWorkspaceConfiguration() {
-        SkillsFunctionality.validateConfiguration();
         agentRootScopes();
         serviceMembers();
         modelScope();
@@ -100,13 +98,15 @@ export default class Daemon {
     #discoveryCwd;
     #started = false; // {§module-lifecycle}: one discovery/module boot; no listener
     #modules = [];
+    // {§module-http-mounts} — each claimed prefix's owner, and the claims mounted at start.
+    #mountClaims = new Map();
+    #mounted = new Set();
     #moduleLifetimes = [];
     #moduleActions = new Map();
     #residency;
     #functionality;
     // {§retention-policy} — the operator's retention, run on a cadence and at shutdown.
     #retention = null;
-    #skills;
     #plugins;
     #members;
     // {§methods-event-subscribe} — the broadcast's in-process event source. A transport
@@ -127,9 +127,9 @@ export default class Daemon {
         this.#lifecycle = new LoopLifecycle(db);
         this.#schemes = schemes ?? new SchemeRegistry();
         this.#provider = provider ?? null;
-        // Plugin discovery resolves from the SERVICE's node_modules (its exec/scheme/mimetype
+        // Extension discovery resolves from the SERVICE's node_modules (its exec/scheme/mimetype
         // deps), NOT process.cwd() — else a globally-installed daemon started from a project dir
-        // finds no plugins. The bin passes the package-relative path; cwd default holds for
+        // finds no extensions. The bin passes the package-relative path; cwd default holds for
         // in-repo tests. discover() takes a cwd and joins node_modules, so derive the parent.
         this.#nodeModulesPath = nodeModulesPath ?? resolve(process.cwd(), "node_modules");
         this.#discoveryCwd = dirname(this.#nodeModulesPath);
@@ -174,20 +174,7 @@ export default class Daemon {
             retainWorkspace: (workspaceId) => this.#residency.retain(workspaceId),
             preparationChanged: (workspaceId, preparation) => this.#broadcast({ workspaceId }, "workspace/preparation", { workspaceId, preparation })
         });
-        // {§skills-functionality} — Core's own family: standard Agent Skills.
         this.#plugins = new WorkspacePlugins({ db, hostPaths, nodeModules: this.#nodeModulesPath });
-        this.#skills = new SkillsFunctionality({
-            db,
-            plugins: this.#plugins,
-            storage: this.#storage,
-            hostPaths,
-            provided: async () => {
-                const tree = await PlurnkSkill.load(this.#nodeModulesPath);
-                return new Map([[tree.document.name, tree]]);
-            },
-        });
-        this.#skills.attach(this.#functionality.register(this.#skills));
-        this.#schemes.register("skill", new Skill((workspaceId) => this.#skills.trees(workspaceId)));
         // {§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);
@@ -210,7 +197,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, environment, attachments }) => {
+            injectWorker: async ({ workspaceId, workerId, sourceLoopId, prompt, 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) {
@@ -267,8 +254,7 @@ export default class Daemon {
                     providerSpec,
                     effort,
                     childProviderSpec,
-                    systemPrompt,
-                    ...(freshLoopPolicy === undefined ? {} : { freshLoopPolicy })
+                    systemPrompt
                 });
                 return { action, loopId };
             },
@@ -292,8 +278,7 @@ export default class Daemon {
             db,
             lifecycle: this.#lifecycle,
             injectPrompt: (loopId, prompt, openPaths, source, evidence, messageAddress) => this.#engine.injectIntoLoop(loopId, prompt, openPaths, source, evidence, messageAddress),
-            assertInjectionCompatibility: async ({ workerId, loopId, providerSpec, providerSpecExplicit, effort, childProviderSpec, turnCeiling, policy }) => {
-                await this.#assertFoldPosture(workerId, policy, loopId);
+            assertInjectionCompatibility: async ({ workerId, loopId, providerSpec, providerSpecExplicit, effort, childProviderSpec, turnCeiling }) => {
                 // An omitted selector keeps the loop's durable provider; only an
                 // explicit selection is checked against it (a deliberate switch).
                 if (providerSpecExplicit !== false) {
@@ -371,6 +356,18 @@ export default class Daemon {
         this.#eventSubscribers.add(handler);
         return () => { this.#eventSubscribers.delete(handler); };
     }
+    async registerWorkerOwner(workspaceId, owner) {
+        const id = ClientInput.assertId("registerWorkerOwner", "workspaceId", workspaceId);
+        await WorkerOwners.register(this.#db, id, owner);
+    }
+    async claimWorkerOwner(args) {
+        const workspaceId = ClientInput.assertId("claimWorkerOwner", "workspaceId", args.workspaceId);
+        const workerId = ClientInput.assertId("claimWorkerOwner", "workerId", args.workerId);
+        const worker = await this.readWorker({ workspaceId, identity: { id: workerId } });
+        if (worker === null)
+            throw daemonFailure("worker:owner", "worker-not-found", 404, `Worker ${workerId} does not belong to workspace ${workspaceId}.`, { workspaceId, workerId });
+        return WorkerOwners.claim(this.#db, workspaceId, workerId, args.owner);
+    }
     // {§methods-proposal-resolve} — proposal HITL. A transport module reads the stopped-world
     // proposals for a workspace (rendering each as a TOOL_CALL) and feeds back the human's decision. The
     // gate, validation, and applyResolution stay core (Engine.resolveProposal); the seam is the read +
@@ -379,23 +376,29 @@ export default class Daemon {
         const checkedWorkspaceId = ClientInput.assertId("pendingProposals", "workspaceId", workspaceId);
         return this.#engine.pendingProposals(checkedWorkspaceId);
     }
-    resolveProposal(logEntryId, resolution) {
+    async resolveProposal(logEntryId, resolution, owner) {
         const checkedLogEntryId = ClientInput.assertId("resolveProposal", "logEntryId", logEntryId);
         const checkedResolution = ClientInput.assertProposalResolution("resolveProposal", resolution);
+        const workspaceId = ClientInput.assertId("resolveProposal", "workspaceId", owner.workspaceId);
+        const pending = await this.#db.worker_owner_for_proposal.get({ log_entry_id: checkedLogEntryId });
+        if (pending !== undefined && (pending.workspaceId !== workspaceId || pending.owner !== owner.address)) {
+            throw daemonFailure("proposal:resolution", "owner-mismatch", 403, "Only the worker's owner may resolve this proposal.", { logEntryId: checkedLogEntryId });
+        }
         this.#engine.resolveProposal(checkedLogEntryId, checkedResolution);
     }
     async pendingClientInteractions(workspaceId) {
         const checkedWorkspaceId = ClientInput.assertId("pendingClientInteractions", "workspaceId", workspaceId);
         return this.#engine.pendingClientInteractions(checkedWorkspaceId);
     }
-    async resolveClientInteraction(interactionId, resolution, message) {
+    async resolveClientInteraction(interactionId, resolution, respondent, message) {
         const checkedInteractionId = ClientInput.assertId("resolveClientInteraction", "interactionId", interactionId);
         const checkedResolution = ClientInput.assertClientInteractionResolution("resolveClientInteraction", resolution);
         if (message !== undefined) {
             ClientInput.assertPrompt("resolveClientInteraction", message.body);
             ClientInput.assertOptionalSource("resolveClientInteraction", message.source);
         }
-        await this.#engine.resolveClientInteraction(checkedInteractionId, checkedResolution, message);
+        ClientInput.assertId("resolveClientInteraction", "workspaceId", respondent.workspaceId);
+        await this.#engine.resolveClientInteraction(checkedInteractionId, checkedResolution, respondent, message);
     }
     async #prepareMessage(workspaceId, workerId, body, attachments = [], envelope) {
         const published = await MessageResources.publish(body, attachments, {
@@ -427,9 +430,6 @@ export default class Daemon {
         const openPaths = ClientInput.assertOpenPaths("runLoop", args.openPaths);
         const selector = ClientInput.assertOptionalSelector("runLoop", "selector", args.selector);
         const childSelector = ClientInput.assertOptionalChildSelector("runLoop", args.childSelector);
-        const policy = args.policy === undefined
-            ? undefined
-            : ClientInput.normalizeLoopPolicy("runLoop", args.policy);
         // {§worker-model-selection} — the worker owns the model. An explicit selector
         // persists onto the worker; an omitted selector resolves the worker's durable model
         // (seeded once from the daemon default). The loop then snapshots the resolved route.
@@ -464,7 +464,6 @@ export default class Daemon {
             evidence: delivered.evidence,
             ...(messageAddress === undefined ? {} : { messageAddress }),
             ...(source === undefined ? {} : { source }),
-            ...(policy !== undefined ? { policy } : {}),
             ...(openPaths !== undefined ? { openPaths } : {}),
             turnCeiling,
             providerSpec: selection,
@@ -572,6 +571,13 @@ export default class Daemon {
         const checked = ClientInput.assertId("worker.ensure-model", "workspaceId", workspaceId);
         return await Envelope.ensureModelWorker(this.#db, checked);
     }
+    async ensureRuntimeWorker(workspaceId) {
+        const checked = ClientInput.assertId("worker.ensure-runtime", "workspaceId", workspaceId);
+        if (await this.#db.envelope_get_workspace.get({ id: checked }) === undefined) {
+            throw daemonFailure("worker:owner", "workspace-not-found", 404, `Workspace ${checked} does not exist.`);
+        }
+        return RuntimeWorker.ensure(this.#db, checked);
+    }
     async readWorkspaceCapabilities(args) {
         const workspaceId = ClientInput.assertId("workspace.capabilities.get", "workspaceId", args.workspaceId);
         return this.#engine.capabilityProjection(workspaceId);
@@ -769,14 +775,7 @@ export default class Daemon {
         try {
             const clientLoopId = await Envelope.ensureClientLoop(this.#db, workerId);
             try {
-                // {§safe-uri-target-groups} — a client-authored group runs member by member on the one seam
-                // result: the first failure, otherwise the last outcome.
-                let result;
-                for (const member of expandTargetGroup(statement)) {
-                    const outcome = await this.#dispatchClientStatement({ workspaceId, workerId, loopId: clientLoopId, statement: member });
-                    if (result === undefined || result.status < 400)
-                        result = outcome;
-                }
+                const result = await this.#dispatchClientStatement({ workspaceId, workerId, loopId: clientLoopId, statement });
                 await Envelope.closeClientLoop(this.#db, clientLoopId, { status: 200 });
                 return result;
             }
@@ -813,8 +812,7 @@ export default class Daemon {
             const clientLoopId = await Envelope.ensureClientLoop(this.#db, workerId);
             try {
                 const results = [];
-                // {§safe-uri-target-groups} — a client-authored group is one result per member.
-                for (const statement of statements.flatMap(expandTargetGroup)) {
+                for (const statement of statements) {
                     results.push(await this.#dispatchClientStatement({ workspaceId, workerId, loopId: clientLoopId, statement }));
                 }
                 await Envelope.closeClientLoop(this.#db, clientLoopId, { status: 200 });
@@ -874,7 +872,7 @@ export default class Daemon {
     // full scheme resolver and return its content, writing NO log row — the client's out-of-band
     // inspection primitive (the module rewrites LOOK→READ and parses at its edge, exactly like
     // dispatchClientAction). Its closed observation segment supplies the numeric loop coordinate
-    // required by plugin context and relative log:/// addresses without impersonating an active
+    // required by extension 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) {
@@ -1034,7 +1032,7 @@ export default class Daemon {
         const checkedFolder = ClientInput.assertShareFolder("workspace.share", folder);
         if (this.#dbPath === undefined)
             throw new Error("share: this daemon was started without its database path");
-        return await Share.write({ dbPath: this.#dbPath, folder: checkedFolder, workspaceId: checkedWorkspaceId });
+        return await Share.write({ openEvidence: EvidenceReader.open, dbPath: this.#dbPath, folder: checkedFolder, workspaceId: checkedWorkspaceId });
     }
     listPrompts(workspaceId, limit, workerId) {
         const checkedWorkspaceId = ClientInput.assertId("workspace.prompts", "workspaceId", workspaceId);
@@ -1082,7 +1080,7 @@ export default class Daemon {
             throw new Error("ClientInput.assertOptionalName accepted a required name as undefined");
         return { id: checkedWorkspaceId, name: await Envelope.updateWorkspaceName(this.#db, checkedWorkspaceId, checkedName) };
     }
-    // {§methods-conversation-worker}: a fresh conversation is a model-origin root worker with an empty private log.
+    // {§methods-conversation-worker}: a fresh conversation is a model-origin worker with an empty private log.
     // AG-UI threads map to these workers while the workspace world remains shared ({§machine-processes}).
     async createConversationWorker(args) {
         const workspaceId = ClientInput.assertId("worker.create", "workspaceId", args.workspaceId);
@@ -1091,13 +1089,24 @@ export default class Daemon {
         if (workspace === undefined) {
             throw daemonFailure("daemon:workspace", "workspace-not-found", 404, `Workspace ${workspaceId} does not exist.`, { workspaceId });
         }
+        const parentWorkerId = args.parentWorkerId === undefined ? undefined : ClientInput.assertId("worker.create", "parentWorkerId", args.parentWorkerId);
+        if (parentWorkerId !== undefined) {
+            if (args.owner !== undefined)
+                throw daemonFailure("worker:owner", "child-owner-inherited", 400, "A child inherits its parent's owner.", { workspaceId, parentWorkerId });
+            const parent = await this.readWorker({ workspaceId, identity: { id: parentWorkerId } });
+            if (parent === null)
+                throw daemonFailure("worker:owner", "worker-not-found", 404, `Parent worker ${parentWorkerId} does not belong to workspace ${workspaceId}.`, { workspaceId, parentWorkerId });
+        }
+        else if (args.owner !== undefined) {
+            await WorkerOwners.registered(this.#db, workspaceId, args.owner);
+        }
         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} 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);
+        const worker = await Envelope.createModelWorker(this.#db, workspaceId, name, parentWorkerId, args.owner);
         return { workerId: worker.id, workerName: worker.name };
     }
     // {§worker-scheme-fork} — branch a worker's log while sharing the workspace world.
@@ -1142,6 +1151,9 @@ export default class Daemon {
             await this.#schemes.ready();
         await this.#residency.rematerializeActive();
     }
+    registerResourceTreeScheme(name, source) {
+        return this.registerScheme(name, new ResourceTreeScheme(name, source));
+    }
     #normalizeRuntime({ namespaceOwner, decl, executor, availability, scheme }) {
         if (typeof namespaceOwner !== "string" || namespaceOwner.trim().length === 0) {
             throw new Error("runtime registration namespaceOwner must be a non-empty string");
@@ -1169,7 +1181,11 @@ export default class Daemon {
     registerHttpRoute(prefix, handler) {
         if (this.#http === null)
             throw new Error(`registerHttpRoute: this daemon has no HTTP listener to mount '${prefix}' on`);
+        // {§module-http-mounts} — a module mounts exactly what it claimed.
+        if (!this.#mountClaims.has(prefix))
+            throw new Error(`registerHttpRoute: no module declared '${prefix}' among its mounts`);
         this.#http.registerHttpRoute(prefix, handler);
+        this.#mounted.add(prefix);
     }
     httpAddress() {
         if (this.#http === null)
@@ -1271,14 +1287,18 @@ export default class Daemon {
     workspaceStateDirectory(workspaceId, namespaceOwner) {
         return this.#storage.directory(workspaceId, namespaceOwner);
     }
-    async workspaceConfigurationDirectories(workspaceId) {
+    async workspacePaths(workspaceId) {
         const workspace = await this.#db.envelope_get_workspace.get({ id: workspaceId });
-        return configurationDirectories(this.#hostPaths, workspace?.project_root ?? null);
+        return workspacePaths(this.#hostPaths, workspace?.project_root ?? null);
     }
     // {§agent-plugins-hosting}
     readWorkspacePlugins(workspaceId) {
         return this.#plugins.read(workspaceId);
     }
+    async readProvidedSkills() {
+        const tree = await PlurnkSkill.load(this.#nodeModulesPath);
+        return new Map([[tree.document.name, tree]]);
+    }
     // {§mcp-launch-environment}
     operatorEnvironment() {
         return ExecEnv.withoutOwnSecrets();
@@ -1301,19 +1321,19 @@ export default class Daemon {
     get provider() { return this.#provider; }
     get schemes() { return this.#schemes; }
     get mimetypes() { return this.#mimetypes; }
-    registerModule(module) {
+    // {§module-discovery} — `owner` is the module's package name; diagnostics name it.
+    registerModule(module, owner) {
         if (this.#started)
             throw new Error("registerModule: modules must be registered before daemon start");
-        this.#modules.push(module);
+        this.#modules.push({ module, owner });
     }
     async start() {
         if (this.#started)
             throw new Error("daemon already started");
         await this.#configuration.capture("file-creation", () => FileCreationPolicy.serviceScope());
         await this.#configuration.capture("effect-policy", () => EffectPolicy.validateConfiguration());
-        await this.#configuration.capture("loop-policy", () => LoopPolicies.validateConfiguration());
+        await this.#configuration.capture("proposal-policy", () => ProposalPolicies.read());
         await this.#configuration.capture("wait", () => TurnDispositionHandler.configuredWaitSeconds());
-        await this.#configuration.capture("packet", () => PacketBuilder.validateConfiguration());
         await this.#configuration.capture("execution", () => Exec.validateConfiguration());
         this.#retention = await this.#configuration.capture("retention", () => new Retention(this.#db, retentionPolicy()));
         this.#started = true;
@@ -1330,7 +1350,7 @@ export default class Daemon {
         // packages; pre-warm it so first index render doesn't pay the cost.
         await this.#mimetypes.ready();
         for (const name of await this.#mimetypes.skippedPackages()) {
-            console.warn(`mimetype discovery: '${name}' is discovered but untrusted (PLURNK_PLUGINS_TRUSTED_ONLY); not registered`);
+            console.warn(`mimetype discovery: '${name}' is discovered but untrusted (PLURNK_EXTENSIONS_TRUSTED_ONLY); not registered`);
         }
         // Discover + probe the installed executor siblings, then hand the
         // registry to the engine for exec dispatch ({§exec-registry-resolves}).
@@ -1360,23 +1380,42 @@ export default class Daemon {
         this.#schemes.registerRuntimeSchemes(executors);
         // Discover external @plurnk/plurnk-schemes-* siblings + register them
         // (agnostic, by plurnk.kind:"scheme"). They light up http://, etc. with
-        // no further engine change — #run wraps their context in SchemeCtxImpl ({§plugin-discovery}).
+        // no further engine change — #run wraps their context in SchemeCtxImpl ({§extension-discovery}).
         await this.#schemes.discoverExternal(this.#discoveryCwd);
         // {§module-discovery} — third-party daemon-module composition: trusted
         // packages declaring `plurnk.kind: "module"` register beside the
         // service's explicit composition before any module setup runs.
-        const discoveredModules = await discoverDaemonModules({ cwd: this.#discoveryCwd, hostPaths: this.#hostPaths });
-        for (const cause of discoveredModules.configurationErrors)
-            this.#configuration.record("native-plugins", cause);
+        const discoveredModules = await discoverDaemonModules({
+            cwd: this.#discoveryCwd, hostPaths: this.#hostPaths, registered: new Set(this.#modules.map(({ owner }) => owner)),
+        });
+        for (const { owner, cause } of discoveredModules.configurationErrors)
+            this.#configuration.record(owner, cause);
         this.#configuration.pluginReports(discoveredModules.reports);
         for (const packageName of discoveredModules.skipped) {
-            console.warn(`module discovery: '${packageName}' is discovered but untrusted (PLURNK_PLUGINS_TRUSTED_ONLY); not registered`);
+            console.warn(`module discovery: '${packageName}' is discovered but untrusted (PLURNK_EXTENSIONS_TRUSTED_ONLY); not registered`);
+        }
+        for (const { module, owner } of discoveredModules.modules) {
+            this.#modules.push({ module, owner });
+        }
+        // {§module-http-mounts} — a daemon without a listener has nothing to serve a mount on: it
+        // leaves out every module that declares one, and says so.
+        if (this.#http === null) {
+            this.#modules = this.#modules.filter(({ module, owner }) => {
+                const mounts = module.mounts ?? [];
+                if (mounts.length === 0)
+                    return true;
+                this.#configuration.leftOut(`module:${owner}`, `module '${owner}' mounts ${mounts.map((prefix) => `'${prefix}'`).join(", ")} and this daemon has no HTTP listener: left out`);
+                return false;
+            });
         }
-        for (const module of discoveredModules.modules) {
-            this.#modules.push(module);
+        // {§module-contained-configuration} — what a module contained is its own configuration diagnostic.
+        for (const { module, owner } of this.#modules) {
+            for (const { key, message } of module.contained ?? [])
+                this.#configuration.record(`module:${owner}`, new ConfigurationError(key, message));
         }
+        this.#claimMounts();
         const setupSeam = this;
-        for (const module of this.#modules) {
+        for (const { module } of this.#modules) {
             if (module.stop !== undefined || module.close !== undefined)
                 this.#moduleLifetimes.push(module);
             await module.setup?.(setupSeam);
@@ -1387,12 +1426,39 @@ export default class Daemon {
         // {§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) {
+        for (const { module } of this.#modules) {
             const started = await module.start?.(this);
             if (started !== undefined && !this.#moduleLifetimes.includes(started)) {
                 this.#moduleLifetimes.push(started);
             }
         }
+        this.#admitMounts();
+    }
+    // {§module-http-mounts} — every prefix is claimed before any module sets up: one owner per
+    // prefix, including the optional root mount.
+    #claimMounts() {
+        for (const { module, owner } of this.#modules) {
+            for (const prefix of module.mounts ?? []) {
+                if (!HttpListener.isPrefix(prefix)) {
+                    throw new Error(`module '${owner}' declares HTTP mount '${prefix}', which is not an absolute pathname prefix`);
+                }
+                const holder = this.#mountClaims.get(prefix);
+                if (holder !== undefined)
+                    throw new Error(`HTTP mount '${prefix}' is claimed by both '${holder}' and '${owner}'`);
+                this.#mountClaims.set(prefix, owner);
+            }
+        }
+    }
+    // {§module-http-mounts} — the listener is admitted once every module has started and every
+    // claim is mounted, so readiness never depends on registration order.
+    #admitMounts() {
+        if (this.#http === null)
+            return;
+        for (const [prefix, owner] of this.#mountClaims) {
+            if (!this.#mounted.has(prefix))
+                throw new Error(`module '${owner}' claimed HTTP mount '${prefix}' but did not mount it at start`);
+        }
+        this.#http.admit();
     }
     async #recoverLifecycle() {
         await this.#db.recovery_fail_active_loops.run({});
@@ -1554,30 +1620,6 @@ export default class Daemon {
     notifyNotice(workspaceId, payload) {
         this.#broadcast({ workspaceId }, "notice/event", payload);
     }
-    // {§methods-loop-run-fold-consistency} — a folded prompt cannot reconfigure its loop.
-    async #assertFoldPosture(workerId, policy, loopId) {
-        if (policy === undefined || Object.keys(policy).length === 0)
-            return;
-        const effective = await LoopPolicyReader.read(this.#db, loopId);
-        const requested = Object.entries(policy);
-        const conflicts = requested
-            .filter(([key, value]) => {
-            if (value === undefined)
-                return false;
-            return effective[key] !== value;
-        })
-            .map(([key, value]) => `${key}: ${JSON.stringify(effective[key])} -> ${JSON.stringify(value)}`);
-        if (conflicts.length > 0) {
-            throw daemonFailure("daemon:loop", "loop-policy-conflict", 409, "The requested loop policy differs from the active loop policy.", {
-                workerId,
-                loopId,
-                conflicts,
-                stage: "loop-injection",
-                recovery: "Cancel the active loop before changing policy, or omit policy to keep its current posture.",
-                retryable: false
-            });
-        }
-    }
     inject(args) {
         return this.#drains.inject(args);
     }
@@ -1592,7 +1634,6 @@ export default class Daemon {
             worker_id: workerId,
             prompt: first.body,
             prompt_source: first.source,
-            policy: first.policy,
             model_route_id: first.model_route_id,
             spawn_model_route_id: first.spawn_model_route_id,
             effort: first.effort,
@@ -1649,7 +1690,7 @@ export default class Daemon {
             // {§methods-event-subscribe}: publish to the in-process source; transport modules subscribe
             // here (plurnk-agui renders to AG-UI+). Each subscriber owns its own fan-out; core just emits.
             // Scope-stamping onto the notification envelope ({§notifications-envelope-carries-workspaceid})
-            // is each subscriber's edge concern now — the seam hands (workspaceId, method, params) raw.
+            // is each subscriber's edge concern; the seam hands (workspaceId, method, params) raw.
             this.#emitTo(target.workspaceId, method, params);
         });
     }