@plurnk/plurnk-service 1.10.1 → 1.12.0

package/dist/server/Daemon.js

@@ -2,6 +2,7 @@
 // the transport-free plugin-module seam ({§rpc}).
 import { readFile } from "node:fs/promises";
 import { resolve, dirname } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import Paths from "../Paths.js";
 import Engine from "../core/Engine.js";
 import ExecutorRegistry from "../core/ExecutorRegistry.js";
@@ -14,13 +15,13 @@ import WorkerSettingsReader from "../core/worker-settings.js";
 import EffectPolicy from "../schemes/EffectPolicy.js";
 import QuestionTool, { questionRuntimeDecl } from "../schemes/QuestionTool.js";
 import DrainSupervisor from "./DrainSupervisor.js";
-import { parsePath, Validator, } from "@plurnk/plurnk-contracts";
+import { parsePath, CapabilityAdmission, Validator, } from "@plurnk/plurnk-contracts";
 import LogEntry from "./logEntry.js";
 import Envelope from "./envelope.js";
 import ClientInput from "./client-input.js";
 import Turn from "../core/Turn.js";
 import SkillsFunctionality from "./SkillsFunctionality.js";
-import GitMembership from "../core/git-membership.js";
+import MembersFunctionality from "./MembersFunctionality.js";
 import Fork from "../core/fork.js";
 import WorkerName from "../core/WorkerName.js";
 import WorkerControlAddress from "../core/WorkerControlAddress.js";
@@ -30,7 +31,8 @@ import { contentWeight } from "../core/content-weight.js";
 import { parseAliasesFromEnv, resolveActiveRoute, UnsupportedReasoningPolicyError, } from "@plurnk/plurnk-providers";
 import ProviderInstantiate from "../core/ProviderInstantiate.js";
 import { resolveLoopRoute } from "./loop-model.js";
-import LoopFlagsReader from "../core/LoopFlagsReader.js";
+import LoopPolicyReader from "../core/LoopPolicyReader.js";
+import CapabilityPolicies from "../core/CapabilityPolicies.js";
 import Results, { OperationFailureError } from "../core/results.js";
 import WorkspaceGate from "../core/WorkspaceGate.js";
 import WorkerResidency from "./WorkerResidency.js";
@@ -72,6 +74,7 @@ export default class Daemon {
     #residency;
     #functionality;
     #skills;
+    #members;
     // {§methods-event-subscribe} — the broadcast's in-process event source. A transport
     // module (plurnk-agui) subscribes and fans out to its OWN clients; core emits, never owns
     // client transport or connection state.
@@ -127,20 +130,25 @@ export default class Daemon {
         // {§skills-functionality} — Core's own family: standard Agent Skills.
         this.#skills = new SkillsFunctionality({ db, ...skills });
         this.#skills.attach(this.#functionality.register(this.#skills));
+        // {§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);
         this.#branchBatches = new BranchBatches(db, this.#workspaceGate, {
             settleWorkspace: async (workspaceId) => this.#engine.drainWorkspaceDerivations(workspaceId),
-            createChild: async ({ workspaceId, parentWorkerId, parentLoopId, op, name, prompt, flags, origin }) => {
+            createChild: async ({ workspaceId, parentWorkerId, parentLoopId, op, name, prompt, policy, origin }) => {
                 const parentPolicy = await this.#providerPolicyForLoop(parentLoopId);
                 const providerSpec = parentPolicy.childProviderSpec ?? parentPolicy.providerSpec;
                 const workerName = WorkerName.assert(name);
+                const capabilityBound = await CapabilityPolicies.delegationBound(this.#db, workspaceId, parentWorkerId, policy);
                 const workerId = op === "FORK"
-                    ? await Fork.fork(this.#db, parentWorkerId, workerName, (scheme) => this.#schemes.entryInheritanceForStoredScheme(scheme, parentWorkerId))
+                    ? await Fork.fork(this.#db, parentWorkerId, workerName, capabilityBound, (scheme) => this.#schemes.entryInheritanceForStoredScheme(scheme, parentWorkerId))
                     : (await this.#db.fork_insert_worker.get({
                         workspace_id: workspaceId,
                         name: workerName,
                         parent_worker_id: parentWorkerId,
                         origin,
                         fork_snapshot: 0,
+                        capability_bound: JSON.stringify(capabilityBound),
                     }))?.id;
                 if (workerId === undefined)
                     throw new Error("Branch worker insert returned no row");
@@ -160,7 +168,7 @@ export default class Daemon {
                     providerSpec,
                     reasoningPolicy: parentPolicy.reasoningPolicy,
                     childProviderSpec: parentPolicy.childProviderSpec,
-                    flags,
+                    policy,
                 });
                 return { workerId, loopId };
             },
@@ -197,7 +205,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, sourceWorkerId, prompt, flags, parentLoopId }) => {
+            injectWorker: async ({ workspaceId, workerId, sourceWorkerId, prompt, freshLoopPolicy, parentLoopId }) => {
                 await this.#assertModelWorker(workspaceId, workerId);
                 const source = await this.#workerPromptSource(workspaceId, sourceWorkerId, workerId);
                 const systemPrompt = await readFile(Paths.instructionsSystem, "utf8");
@@ -241,7 +249,7 @@ export default class Daemon {
                     reasoningPolicy,
                     childProviderSpec,
                     systemPrompt,
-                    ...(flags === undefined ? {} : { flags }),
+                    ...(freshLoopPolicy === undefined ? {} : { freshLoopPolicy }),
                 });
                 return { action, loopId };
             },
@@ -270,8 +278,8 @@ export default class Daemon {
             db,
             lifecycle: this.#lifecycle,
             injectPrompt: (workerId, prompt, openPaths, source) => this.#engine.inject(workerId, prompt, openPaths, source),
-            assertInjectionCompatibility: async ({ workerId, loopId, providerSpec, providerSpecExplicit, reasoningPolicy, childProviderSpec, turnCeiling, flags, }) => {
-                await this.#assertFoldPosture(workerId, flags, loopId);
+            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
                 // explicit selection is checked against it (a deliberate switch).
                 if (providerSpecExplicit !== false) {
@@ -284,7 +292,7 @@ export default class Daemon {
                 await this.#assertLoopMaxTurns(loopId, turnCeiling?.source === "explicit" ? turnCeiling.effective : undefined);
             },
             reconcilePrompts: (workerId, endedLoopId) => this.#reconcileOrphanedPrompts(workerId, endedLoopId),
-            runLoop: async ({ workspaceId, workerId, loopId, maxTurns, prompt, systemPrompt, signal, onDispatch, }) => {
+            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.
                 await this.#assertModelWorker(workspaceId, workerId);
@@ -307,7 +315,7 @@ export default class Daemon {
                             { role: "user", content: prompt },
                         ],
                         signal,
-                        onDispatch,
+                        onSettled,
                     });
                 }
                 finally {
@@ -386,7 +394,9 @@ 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 flags = ClientInput.normalizeLoopFlags("runLoop", args.flags);
+        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.
@@ -418,7 +428,7 @@ export default class Daemon {
             workerId,
             prompt,
             ...(source === undefined ? {} : { source }),
-            ...(flags !== undefined ? { flags } : {}),
+            ...(policy !== undefined ? { policy } : {}),
             ...(openPaths !== undefined ? { openPaths } : {}),
             turnCeiling,
             providerSpec: selection,
@@ -685,30 +695,31 @@ export default class Daemon {
     // {§worker-settings} — merge known keys into the worker's behavioral-rules bag.
     // Validated at the boundary; unprovided keys keep their durable value.
     async #mergeWorkerSettings(workerId, settings) {
+        const normalized = ClientInput.normalizeWorkerSettings(settings);
         const current = await WorkerSettingsReader.read(this.#db, workerId);
         const merged = {
-            requestUserInput: settings.requestUserInput ?? current.requestUserInput,
+            capabilities: normalized.capabilities ?? current.capabilities,
         };
         await this.#db.worker_settings_update.run({ id: workerId, settings: JSON.stringify(merged) });
     }
-    // {§worker-settings} — project the worker's behavioral rules for a client-interface surface.
-    async readWorkerSettings(args) {
-        const workspaceId = ClientInput.assertId("worker.settings.get", "workspaceId", args.workspaceId);
-        const workerId = ClientInput.assertId("worker.settings.get", "workerId", args.workerId);
+    // {§capability-policy-projection} — clients inspect the same complete cascade
+    // that dispatch and packet projection consume; the mutable Worker layer is
+    // never presented as if it were effective authority.
+    async readWorkerCapabilities(args) {
+        const workspaceId = ClientInput.assertId("worker.capabilities.get", "workspaceId", args.workspaceId);
+        const workerId = ClientInput.assertId("worker.capabilities.get", "workerId", args.workerId);
         await this.#assertWorkerOwned(workspaceId, workerId);
-        const settings = await WorkerSettingsReader.read(this.#db, workerId);
-        return { requestUserInput: settings.requestUserInput };
-    }
-    // {§worker-settings} — persist known behavioral-rule keys; unknown keys are
-    // rejected at the input boundary, never persisted.
-    async setWorkerSettings(args) {
-        const workspaceId = ClientInput.assertId("worker.settings.set", "workspaceId", args.workspaceId);
-        const workerId = ClientInput.assertId("worker.settings.set", "workerId", args.workerId);
+        return this.#engine.capabilityProjection(workspaceId, workerId);
+    }
+    // {§worker-settings} — replace the Worker's mutable policy, then return the
+    // resolver-owned projection so a narrowing ceiling cannot be mistaken for
+    // newly effective authority.
+    async setWorkerCapabilities(args) {
+        const workspaceId = ClientInput.assertId("worker.capabilities.set", "workspaceId", args.workspaceId);
+        const workerId = ClientInput.assertId("worker.capabilities.set", "workerId", args.workerId);
         await this.#assertWorkerOwned(workspaceId, workerId);
-        ClientInput.parseWorkerSettings(args.settings);
-        await this.#mergeWorkerSettings(workerId, args.settings);
-        const settings = await WorkerSettingsReader.read(this.#db, workerId);
-        return { requestUserInput: settings.requestUserInput };
+        await this.#mergeWorkerSettings(workerId, { capabilities: args.policy });
+        return this.#engine.capabilityProjection(workspaceId, workerId);
     }
     // {§worker-model-selection} — project a worker's durable model and spawn override
     // for a client-interface get/set surface. Ownership is checked at this boundary.
@@ -1186,20 +1197,6 @@ export default class Daemon {
         const checkedLimit = ClientInput.assertLimit("workspace.prompts", limit);
         return Envelope.listPromptsForWorkspace(this.#db, checkedWorkspaceId, checkedLimit ?? 100);
     }
-    async listMembers(workspaceId) {
-        const checkedWorkspaceId = ClientInput.assertId("workspace.members", "workspaceId", workspaceId);
-        const release = await this.#workspaceGate.acquireTurn(checkedWorkspaceId, 0);
-        try {
-            return await GitMembership.resolveMembershipEffects(this.#db, checkedWorkspaceId, undefined);
-        }
-        finally {
-            release();
-        }
-    }
-    listConstraints(workspaceId) {
-        const checkedWorkspaceId = ClientInput.assertId("workspace.constraints", "workspaceId", workspaceId);
-        return this.#db.crud_list_workspace_constraints.all({ workspace_id: checkedWorkspaceId });
-    }
     workspaceDerivationStatus(workspaceId) {
         return this.#engine.workspaceDerivationStatus(ClientInput.assertId("workspace.derivation", "workspaceId", workspaceId));
     }
@@ -1209,22 +1206,14 @@ export default class Daemon {
     // (which client is on which workspace) lives here — that's the module's.
     async createWorkspace(args) {
         // The seam fails hard on malformed semantic input so every module inherits one wall:
-        // the settings bag
-        // ({§operator-config-workspace-settings}),
-        // constraints, and absolute projectRoot.
+        // the settings bag ({§operator-config-workspace-settings}) and absolute projectRoot.
         const name = ClientInput.assertOptionalName("workspace.create", "name", args.name);
         const projectRoot = ClientInput.assertProjectRoot("workspace.create", args.projectRoot);
         const settings = ClientInput.parseSettings(args.settings);
-        const constraints = ClientInput.parseConstraints(args.constraints);
         return observed(// {§observability-boundary}
         "workspace.create", {}, async (span) => {
             const envelope = await Envelope.createClientEnvelope(this.#db, { name, projectRoot, settings });
             span.setAttribute("workspace.id", envelope.workspaceId);
-            for (const { effect, glob } of constraints) {
-                await this.#db.crud_insert_workspace_constraint.run({ workspace_id: envelope.workspaceId, effect, glob });
-            }
-            if (constraints.length > 0)
-                await GitMembership.resolveGitMembership(this.#db, envelope.workspaceId, undefined);
             this.#broadcast("all", "workspace/created", { id: envelope.workspaceId, name: envelope.workspaceName, projectRoot: envelope.projectRoot });
             return envelope;
         });
@@ -1245,36 +1234,6 @@ 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) };
     }
-    async constrain(workspaceId, effect, glob) {
-        const checkedWorkspaceId = ClientInput.assertId("workspace.constrain", "workspaceId", workspaceId);
-        const release = await this.#workspaceGate.acquireTurn(checkedWorkspaceId, 0);
-        try {
-            ClientInput.assertConstraint("workspace.constrain", effect, glob);
-            await this.#db.crud_insert_workspace_constraint.run({ workspace_id: checkedWorkspaceId, effect, glob });
-            await GitMembership.resolveGitMembership(this.#db, checkedWorkspaceId, undefined);
-            // Members may have just landed — begin warming now, but return the constraint response
-            // immediately so prompts do not wait for the complete derivation corpus.
-            void this.#engine.warmWorkspaceDerivations(checkedWorkspaceId).catch(() => { });
-            return { effect, glob, source: "explicit" };
-        }
-        finally {
-            release();
-        }
-    }
-    async unconstrain(workspaceId, effect, glob) {
-        const checkedWorkspaceId = ClientInput.assertId("workspace.unconstrain", "workspaceId", workspaceId);
-        const release = await this.#workspaceGate.acquireTurn(checkedWorkspaceId, 0);
-        try {
-            ClientInput.assertConstraint("workspace.unconstrain", effect, glob);
-            await this.#db.crud_delete_workspace_constraint.run({ workspace_id: checkedWorkspaceId, effect, glob });
-            await GitMembership.resolveGitMembership(this.#db, checkedWorkspaceId, undefined);
-            void this.#engine.warmWorkspaceDerivations(checkedWorkspaceId).catch(() => { });
-            return { effect, glob };
-        }
-        finally {
-            release();
-        }
-    }
     // Contracts {§entry-read-result}: resolve through the scheme's address law,
     // then project one owner-scoped entry without exposing persistence columns.
     async readEntry(args) {
@@ -1453,7 +1412,7 @@ export default class Daemon {
                 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 });
             }
         }
-        const branchWorkerId = await Fork.fork(this.#db, workerId, name, (scheme) => this.#schemes.entryInheritanceForStoredScheme(scheme, workerId));
+        const branchWorkerId = await Fork.fork(this.#db, workerId, name, await CapabilityPolicies.delegationBound(this.#db, workspaceId, workerId), (scheme) => this.#schemes.entryInheritanceForStoredScheme(scheme, workerId));
         const branch = await this.#db.envelope_get_worker_by_id.get({ id: branchWorkerId });
         return { workerId: branchWorkerId, workerName: branch?.name ?? null, parentWorkerId: workerId };
     }
@@ -1651,6 +1610,7 @@ export default class Daemon {
         await this.#db.recovery_fail_active_loops.run({});
         await this.#db.recovery_settle_open_provider_requests.run({});
         await this.#db.recovery_fail_open_model_calls.run({});
+        await this.#db.recovery_fail_open_embedding_calls.run({});
         await this.#db.recovery_fail_open_turns.run({});
         await this.#db.recovery_fail_ownerless_proposals.run({});
         await this.#db.recovery_remove_ownerless_client_interactions.run({});
@@ -1818,21 +1778,28 @@ export default class Daemon {
         this.#broadcast({ workspaceId }, "notice/event", payload);
     }
     // {§methods-loop-run-fold-consistency} — a folded prompt cannot reconfigure its loop.
-    async #assertFoldPosture(workerId, flags, loopId) {
-        if (flags === undefined || Object.keys(flags).length === 0)
+    async #assertFoldPosture(workerId, policy, loopId) {
+        if (policy === undefined || Object.keys(policy).length === 0)
             return;
-        const effective = await LoopFlagsReader.read(this.#db, loopId);
-        const requested = Object.entries(flags);
+        const effective = await LoopPolicyReader.read(this.#db, loopId);
+        const requested = Object.entries(policy);
         const conflicts = requested
-            .filter(([key, value]) => value !== undefined && effective[key] !== value)
+            .filter(([key, value]) => {
+            if (value === undefined)
+                return false;
+            if (key === "capabilities") {
+                return !isDeepStrictEqual(CapabilityAdmission.intersect([effective.capabilities]), CapabilityAdmission.intersect([value]));
+            }
+            return effective[key] !== value;
+        })
             .map(([key, value]) => `${key}: ${JSON.stringify(effective[key])} -> ${JSON.stringify(value)}`);
         if (conflicts.length > 0) {
-            throw daemonFailure("daemon:loop", "loop-flags-conflict", 409, "The requested loop flags differ from the active loop flags.", {
+            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 flags, or omit flags to keep its current posture.",
+                recovery: "Cancel the active loop before changing policy, or omit policy to keep its current posture.",
                 retryable: false,
             });
         }
@@ -1857,7 +1824,7 @@ export default class Daemon {
             sequence: seqRow.next,
             prompt: first.body,
             prompt_source: first.prompt_source,
-            flags: first.flags,
+            policy: first.policy,
             model_route_id: first.model_route_id,
             spawn_model_route_id: first.spawn_model_route_id,
             reasoning_policy: first.reasoning_policy,