@plurnk/plurnk-service 1.21.0 → 1.22.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 Share from "../share/Share.js";
 import Paths from "../Paths.js";
 import Engine from "../core/Engine.js";
 import ExecutorRegistry from "../core/ExecutorRegistry.js";
@@ -56,6 +57,7 @@ const clientActionFailure = (error) => {
 };
 export default class Daemon {
     #db;
+    #dbPath;
     #engine;
     #workspaceGate;
     #lifecycle;
@@ -86,8 +88,9 @@ export default class Daemon {
     #workerModels;
     #reads;
     #storage;
-    constructor({ db, schemes, mimetypes, provider, nodeModulesPath, hostPaths = new HostPaths(), skills, http = null }) {
+    constructor({ db, schemes, mimetypes, provider, nodeModulesPath, hostPaths = new HostPaths(), skills, http = null, dbPath }) {
         this.#db = db;
+        this.#dbPath = dbPath;
         this.#http = http;
         this.#storage = new WorkspaceStorage(db, hostPaths);
         this.#lifecycle = new LoopLifecycle(db);
@@ -165,6 +168,7 @@ export default class Daemon {
             streamEventNotify: (workspaceId, event) => this.notifyStreamEvent(workspaceId, event),
             operationSettledNotify: (workspaceId, logEntryId) => this.#drains.operationSettled(workspaceId, logEntryId),
             reasoningEventNotify: (workspaceId, event) => this.notifyReasoningEvent(workspaceId, event),
+            outsideEventNotify: (workspaceId, event) => this.notifyOutsideEvent(workspaceId, event),
             wakeWorkerNotify: (payload) => this.#drains.notifyWakeWorker(payload),
             // worker:// loop-start primitive — spawn/fork/irc deliver through
             // Daemon.inject (active sister → fold; idle → enqueue + drain). The
@@ -181,7 +185,7 @@ export default class Daemon {
                 const systemPrompt = await readFile(Paths.instructionsSystem, "utf8");
                 let providerSpec;
                 let childProviderSpec;
-                let reasoningPolicy;
+                let effort;
                 if (spawn !== true) {
                     // {§worker-model-selection} — the voice door addresses an
                     // existing worker. Its own durable generation policy is the
@@ -192,23 +196,23 @@ export default class Daemon {
                         throw new Error(`injectWorker: worker ${workerId} has no resolvable model route`);
                     }
                     providerSpec = targetPolicy.providerSpec;
-                    reasoningPolicy = targetPolicy.reasoningPolicy;
+                    effort = targetPolicy.effort;
                     childProviderSpec = await this.#workerModels.resolveWorkerSpawnModel(workerId, undefined);
                 }
                 else {
                     const parentPolicy = await this.#providerPolicyForLoop(sourceLoopId);
                     providerSpec = parentPolicy.childProviderSpec ?? parentPolicy.providerSpec;
-                    reasoningPolicy = parentPolicy.reasoningPolicy;
+                    effort = parentPolicy.effort;
                     // {§worker-model-selection} — lineage inheritance by value:
                     // the child begins with the spawning loop's effective spawn
                     // model and no separate override of its own.
                     childProviderSpec = null;
-                    // {§worker-reasoning-source} — inherited by value, chosen by nobody on this worker.
+                    // {§worker-effort-source} — inherited by value, chosen by nobody on this worker.
                     await this.#workerModels.persistGenerationPolicy(workerId, {
                         model_route_id: await routeForSpec(this.#db, providerSpec),
                         spawn_model_route_id: null,
-                        reasoning_policy: reasoningPolicy,
-                        reasoning_source: "default"
+                        effort: effort,
+                        effort_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
@@ -226,7 +230,7 @@ export default class Daemon {
                     sourceLoopId,
                     ...(source === undefined ? {} : { source }),
                     providerSpec,
-                    reasoningPolicy,
+                    effort,
                     childProviderSpec,
                     systemPrompt,
                     ...(freshLoopPolicy === undefined ? {} : { freshLoopPolicy })
@@ -253,14 +257,14 @@ 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, reasoningPolicy, childProviderSpec, turnCeiling, policy }) => {
+            assertInjectionCompatibility: async ({ workerId, loopId, providerSpec, providerSpecExplicit, effort, 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) {
                     await this.#assertLoopProvider(loopId, providerSpec);
                 }
-                await this.#assertLoopReasoningPolicy(loopId, reasoningPolicy);
+                await this.#assertLoopEffort(loopId, effort);
                 if (childProviderSpec !== undefined) {
                     await this.#assertLoopChildProvider(loopId, childProviderSpec);
                 }
@@ -403,7 +407,7 @@ export default class Daemon {
                 retryable: false
             }));
         }
-        const { providerSpec: selection, reasoningPolicy } = generationPolicy;
+        const { providerSpec: selection, effort } = generationPolicy;
         // {§methods-loop-run-child-provider} — the worker's persistent spawn override.
         const childSelection = await this.#workerModels.resolveWorkerSpawnModel(workerId, childSelector);
         const systemPrompt = await readFile(Paths.instructionsSystem, "utf8");
@@ -429,7 +433,7 @@ export default class Daemon {
             turnCeiling,
             providerSpec: selection,
             providerSpecExplicit: selectorExplicit,
-            reasoningPolicy,
+            effort,
             childProviderSpec: childSelection,
             systemPrompt
         });
@@ -446,13 +450,13 @@ export default class Daemon {
         if (providerSpec === null) {
             throw new Error(`loop ${loopId}: persisted provider selection is missing — refusing boot-default substitution`);
         }
-        if (row.reasoning_policy === null) {
-            throw new Error(`loop ${loopId}: persisted reasoning policy is missing`);
+        if (row.effort === null) {
+            throw new Error(`loop ${loopId}: persisted effort is missing`);
         }
         return {
             providerSpec,
             childProviderSpec: await specForRoute(this.#db, row.spawn_model_route_id),
-            reasoningPolicy: row.reasoning_policy
+            effort: row.effort
         };
     }
     async #providerSpecForLoop(loopId) {
@@ -460,10 +464,10 @@ export default class Daemon {
     }
     async #providersForLoop(loopId) {
         const policy = await this.#providerPolicyForLoop(loopId);
-        const provider = await this.#workerModels.providerForPolicy(policy.providerSpec, policy.reasoningPolicy);
+        const provider = await this.#workerModels.providerForPolicy(policy.providerSpec, policy.effort);
         const childProvider = policy.childProviderSpec === null
             ? provider
-            : await this.#workerModels.providerForPolicy(policy.childProviderSpec, policy.reasoningPolicy);
+            : await this.#workerModels.providerForPolicy(policy.childProviderSpec, policy.effort);
         return { provider, childProvider };
     }
     async #assertLoopProvider(loopId, requested) {
@@ -481,15 +485,15 @@ export default class Daemon {
             });
         }
     }
-    async #assertLoopReasoningPolicy(loopId, requested) {
-        const selected = (await this.#providerPolicyForLoop(loopId)).reasoningPolicy;
+    async #assertLoopEffort(loopId, requested) {
+        const selected = (await this.#providerPolicyForLoop(loopId)).effort;
         if (selected !== requested) {
-            throw daemonFailure("daemon:provider", "loop-reasoning-policy-conflict", 409, `Loop ${loopId} uses reasoning policy '${selected}', not '${requested}'.`, {
+            throw daemonFailure("daemon:provider", "loop-effort-conflict", 409, `Loop ${loopId} uses effort '${selected}', not '${requested}'.`, {
                 loopId,
-                selectedReasoningPolicy: selected,
-                requestedReasoningPolicy: requested,
+                selectedEffort: selected,
+                requestedEffort: requested,
                 stage: "loop-injection",
-                recovery: "Cancel or conclude the loop before selecting another reasoning policy.",
+                recovery: "Cancel or conclude the loop before selecting another effort.",
                 retryable: false
             });
         }
@@ -564,8 +568,8 @@ export default class Daemon {
         const modelSpec = await specForRoute(this.#db, row.model_route_id);
         const spawnModelSpec = await specForRoute(this.#db, row.spawn_model_route_id);
         return {
-            model: modelSpec === null ? null : projectModelRoute(modelSpec, row.reasoning_policy, row.reasoning_source),
-            spawnModel: spawnModelSpec === null ? null : projectModelRoute(spawnModelSpec, row.reasoning_policy, row.reasoning_source)
+            model: modelSpec === null ? null : projectModelRoute(modelSpec, row.effort, row.effort_source),
+            spawnModel: spawnModelSpec === null ? null : projectModelRoute(spawnModelSpec, row.effort, row.effort_source)
         };
     }
     // {§worker-model-selection} — persist an explicit model selection onto the worker
@@ -575,70 +579,83 @@ export default class Daemon {
         const workerId = ClientInput.assertId("worker.model.set", "workerId", args.workerId);
         await this.#assertModelWorker(workspaceId, workerId);
         const selector = ClientInput.assertSelector("worker.model.set", "selector", args.selector);
-        const policy = await this.#workerModels.resolveWorkerModel(workerId, selector);
+        let chosen;
+        if (args.effort !== undefined) {
+            try {
+                chosen = Validator.assertEffort(args.effort);
+            }
+            catch (cause) {
+                throw daemonFailure("daemon:input", "effort-invalid", 400, cause instanceof Error ? cause.message : "The effort is invalid.", { field: "effort", retryable: false });
+            }
+        }
+        const policy = await this.#workerModels.resolveWorkerModel(workerId, selector, chosen);
         if (policy === null) {
             throw new OperationFailureError(Results.failure("daemon:provider", "not-configured", 501, "No provider is configured for this worker.", {}, { stage: "provider-selection", recovery: "Select a configured model provider.", retryable: false }));
         }
-        return projectModelRoute(policy.providerSpec, policy.reasoningPolicy, policy.reasoningSource);
+        return projectModelRoute(policy.providerSpec, policy.effort, policy.effortSource);
     }
-    // {§worker-reasoning-policy} — the worker's reasoning policy is durable and
+    // {§worker-effort} — the worker's effort is durable and
     // provider-relative. A model-less worker remains explicitly uninitialized.
-    async readWorkerReasoning(args) {
-        const workspaceId = ClientInput.assertId("worker.reasoning.get", "workspaceId", args.workspaceId);
-        const workerId = ClientInput.assertId("worker.reasoning.get", "workerId", args.workerId);
+    async readWorkerEffort(args) {
+        const workspaceId = ClientInput.assertId("worker.effort.get", "workspaceId", args.workspaceId);
+        const workerId = ClientInput.assertId("worker.effort.get", "workerId", args.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)
             throw new Error(`worker ${workerId}: generation policy row missing`);
         if (row.model_route_id === null) {
-            if (row.reasoning_policy !== null) {
-                throw new Error(`worker ${workerId}: reasoning policy exists without a model route`);
+            if (row.effort !== null) {
+                throw new Error(`worker ${workerId}: effort exists without a model route`);
             }
-            return { policy: null, source: "default", supportedPolicies: [] };
+            return { effort: null, source: "default", supportedEfforts: [] };
         }
-        if (row.reasoning_policy === null) {
-            throw new Error(`worker ${workerId}: durable model has no reasoning policy`);
+        if (row.effort === null) {
+            throw new Error(`worker ${workerId}: durable model has no effort`);
         }
         return {
-            policy: row.reasoning_policy,
-            source: row.reasoning_source,
-            supportedPolicies: await this.#workerModels.supportedPolicies(row)
+            effort: row.effort,
+            source: row.effort_source,
+            supportedEfforts: await this.#workerModels.supportedEfforts(row)
         };
     }
-    // {§worker-reasoning-policy} — mutate between loops, validate against both
+    // {§worker-effort} — mutate between loops, validate against both
     // the worker model and its optional spawn model, then persist atomically.
-    async setWorkerReasoning(args) {
-        const workspaceId = ClientInput.assertId("worker.reasoning.set", "workspaceId", args.workspaceId);
-        const workerId = ClientInput.assertId("worker.reasoning.set", "workerId", args.workerId);
-        let policy;
+    async setWorkerEffort(args) {
+        const workspaceId = ClientInput.assertId("worker.effort.set", "workspaceId", args.workspaceId);
+        const workerId = ClientInput.assertId("worker.effort.set", "workerId", args.workerId);
+        let effort;
         try {
-            policy = Validator.assertReasoningPolicy(args.policy);
+            effort = Validator.assertEffort(args.effort);
         }
         catch (cause) {
-            throw daemonFailure("daemon:input", "reasoning-policy-invalid", 400, cause instanceof Error ? cause.message : "The reasoning policy is invalid.", { field: "policy", retryable: false });
+            throw daemonFailure("daemon:input", "effort-invalid", 400, cause instanceof Error ? cause.message : "The effort is invalid.", { field: "effort", retryable: false });
         }
         await this.#assertModelWorker(workspaceId, workerId);
-        await this.#workerModels.resolveWorkerModel(workerId, undefined);
+        // A model-less worker takes the default first; an existing pair is replaced, not re-validated, so an
+        // effort its model no longer supports can be corrected ({§worker-effort}).
+        const current = await this.#db.worker_generation_policy_read.get({ id: workerId });
+        if (current?.model_route_id === null)
+            await this.#workerModels.resolveWorkerModel(workerId, undefined);
         const row = await this.#db.worker_generation_policy_read.get({ id: workerId });
         if (row === undefined)
             throw new Error(`worker ${workerId}: generation policy row missing`);
         const spec = await specForRoute(this.#db, row.model_route_id);
         if (spec === null) {
-            throw daemonFailure("daemon:provider", "worker-model-unset", 409, `Worker ${workerId} has no model against which to validate a reasoning policy.`, {
+            throw daemonFailure("daemon:provider", "worker-model-unset", 409, `Worker ${workerId} has no model against which to validate an effort.`, {
                 workerId,
                 stage: "provider-selection",
-                recovery: "Select a model before selecting its reasoning policy.",
+                recovery: "Select a model before selecting its effort.",
                 retryable: false
             });
         }
-        const supportedPolicies = await this.#workerModels.persistGenerationPolicy(workerId, {
+        const supportedEfforts = await this.#workerModels.persistGenerationPolicy(workerId, {
             model_route_id: row.model_route_id,
             spawn_model_route_id: row.spawn_model_route_id,
-            reasoning_policy: policy,
-            reasoning_source: "explicit"
+            effort,
+            effort_source: "explicit"
         });
-        return { policy, source: "explicit", supportedPolicies };
+        return { effort, source: "explicit", supportedEfforts };
     }
     // {§worker-model-selection} — persist the worker's spawn override; a null
     // selector means inherit (clears the override).
@@ -651,7 +668,7 @@ export default class Daemon {
         if (spec === null)
             return null;
         const row = await this.#db.worker_generation_policy_read.get({ id: workerId });
-        return projectModelRoute(spec, row?.reasoning_policy ?? null, row?.reasoning_source ?? "default");
+        return projectModelRoute(spec, row?.effort ?? null, row?.effort_source ?? "default");
     }
     async #assertWorkerOwned(workspaceId, workerId) {
         const owner = await this.#db.envelope_get_worker_by_id.get({ id: workerId });
@@ -736,6 +753,9 @@ export default class Daemon {
     executorTags(workspaceId) {
         return this.#engine.executorTags(workspaceId);
     }
+    executorJsonBodyTags(workspaceId) {
+        return this.#engine.executorJsonBodyTags(workspaceId);
+    }
     async dispatchClientAction(args) {
         const workspaceId = ClientInput.assertId("operation.dispatch-batch", "workspaceId", args.workspaceId);
         const workerId = ClientInput.assertId("operation.dispatch-batch", "workerId", args.workerId);
@@ -941,12 +961,19 @@ export default class Daemon {
             promptSource: row.promptSource,
             terminatedAt: row.terminatedAt,
             packetCount: row.packetCount,
-            terminalResult: row.terminalResult === null
-                ? null
-                : Validator.assertOperationResult(JSON.parse(row.terminalResult))
+            // {§validation-topology}: a stored result is chapter 3's (`loops_terminal_result_contract`); it is parsed, not re-asserted.
+            terminalResult: row.terminalResult === null ? null : JSON.parse(row.terminalResult)
         }));
     }
     // {§methods-workspace-prompts}: root-conversation loop seeds, newest-first.
+    // {§share} — one workspace's share. The daemon names its own database; the caller names an absolute folder.
+    async shareWorkspace({ workspaceId, folder }) {
+        const checkedWorkspaceId = ClientInput.assertId("workspace.share", "workspaceId", workspaceId);
+        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 });
+    }
     listPrompts(workspaceId, limit) {
         const checkedWorkspaceId = ClientInput.assertId("workspace.prompts", "workspaceId", workspaceId);
         const checkedLimit = ClientInput.assertLimit("workspace.prompts", limit);
@@ -1435,6 +1462,10 @@ export default class Daemon {
     notifyReasoningEvent(workspaceId, event) {
         this.#broadcast({ workspaceId }, "reasoning/event", event);
     }
+    /** Emit one admitted emission's text outside every operation ({§notifications-outside-event}). */
+    notifyOutsideEvent(workspaceId, event) {
+        this.#broadcast({ workspaceId }, "outside/event", event);
+    }
     /**
      * Emit a transient notice scoped to the workspace containing the loop.
      */
@@ -1482,7 +1513,7 @@ export default class Daemon {
             policy: first.policy,
             model_route_id: first.model_route_id,
             spawn_model_route_id: first.spawn_model_route_id,
-            reasoning_policy: first.reasoning_policy,
+            effort: first.effort,
             max_turns: first.max_turns,
             orphan_source_loop_id: endedLoopId
         });