@plurnk/plurnk-service 1.14.2 → 1.16.0

package/dist/server/Daemon.js

@@ -15,7 +15,7 @@ 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, CapabilityAdmission, Validator } from "@plurnk/plurnk-contracts";
+import { CapabilityAdmission, Validator } from "@plurnk/plurnk-contracts";
 import LogEntry from "./logEntry.js";
 import Envelope from "./envelope.js";
 import ClientInput from "./client-input.js";
@@ -27,9 +27,8 @@ import WorkerControlAddress from "../core/WorkerControlAddress.js";
 import LoopLifecycle from "../core/LoopLifecycle.js";
 import { promptLoopPrefix } from "../core/plurnk-uri.js";
 import { contentWeight } from "../core/content-weight.js";
-import { parseAliasesFromEnv, resolveActiveRoute, UnsupportedReasoningPolicyError } from "@plurnk/plurnk-providers";
+import { parseAliasesFromEnv, resolveActiveRoute } from "@plurnk/plurnk-providers";
 import ProviderInstantiate from "../core/ProviderInstantiate.js";
-import { resolveLoopRoute } from "./loop-model.js";
 import LoopPolicyReader from "../core/LoopPolicyReader.js";
 import CapabilityPolicies from "../core/CapabilityPolicies.js";
 import Results, { OperationFailureError } from "../core/results.js";
@@ -38,6 +37,9 @@ import WorkerResidency from "./WorkerResidency.js";
 import Functionality from "./Functionality.js";
 import { observed, observedSync } from "../observe/spans.js";
 import { listModelCatalog } from "./model-catalog.js";
+import { daemonFailure, modelRouteLabel } from "./daemon-results.js";
+import WorkerModelResolver from "./WorkerModelResolver.js";
+import ClientReads from "./ClientReads.js";
 const clientActionFailure = (error) => {
     if (error instanceof OperationFailureError)
         return error.result;
@@ -47,11 +49,6 @@ const clientActionFailure = (error) => {
         retryable: false
     });
 };
-const daemonFailure = (owner, code, status, detail, extensions = {}) => new OperationFailureError(Results.failure(owner, code, status, detail, {}, extensions));
-const entryReadResult = (result) => Validator.assertEntryReadResult(result);
-const modelRouteLabel = (route) => route.alias === undefined
-    ? `model route '${route.provider}/${route.model}'`
-    : `provider alias '${route.alias}' (${route.provider}/${route.model})`;
 export default class Daemon {
     #db;
     #engine;
@@ -76,6 +73,8 @@ export default class Daemon {
     // module (plurnk-agui) subscribes and fans out to its OWN clients; core emits, never owns
     // client transport or connection state.
     #eventSubscribers = new Set();
+    #workerModels;
+    #reads;
     constructor({ db, schemes, mimetypes, provider, nodeModulesPath, skills }) {
         this.#db = db;
         this.#lifecycle = new LoopLifecycle(db);
@@ -156,13 +155,13 @@ export default class Daemon {
                     // existing worker. Its own durable generation policy is the
                     // receiver's identity; the daemon default and sender do not
                     // overwrite it merely because a new loop must be minted.
-                    const targetPolicy = await this.#resolveWorkerModel(workerId, undefined);
+                    const targetPolicy = await this.#workerModels.resolveWorkerModel(workerId, undefined);
                     if (targetPolicy === null) {
                         throw new Error(`injectWorker: worker ${workerId} has no resolvable model route`);
                     }
                     providerSpec = targetPolicy.providerSpec;
                     reasoningPolicy = targetPolicy.reasoningPolicy;
-                    childProviderSpec = await this.#resolveWorkerSpawnModel(workerId, undefined);
+                    childProviderSpec = await this.#workerModels.resolveWorkerSpawnModel(workerId, undefined);
                 }
                 else {
                     const parentPolicy = await this.#providerPolicyForLoop(parentLoopId);
@@ -265,6 +264,8 @@ export default class Daemon {
             },
             cancelSubscription: (subscriptionId) => this.#engine.cancelSubscription(subscriptionId),
             hasActiveStreams: (workerId) => this.#workerHasActiveStreams(workerId),
+            // {§exec-timeout} — a `<-1>` spawn is nobody's obligation.
+            isDetachedSubscription: (subscriptionId) => this.#schemes.get("exec")?.isDetachedSpawn?.(subscriptionId) === true,
             readSystemPrompt: () => readFile(Paths.instructionsSystem, "utf8"),
             emitLogEntry: async (workspaceId, logEntryId) => {
                 const entry = await LogEntry.fetchLogEntry(this.#db, logEntryId);
@@ -282,6 +283,8 @@ export default class Daemon {
             const { workspaceId, ...interaction } = event;
             this.#broadcast({ workspaceId }, "loop/interaction", interaction);
         });
+        this.#workerModels = new WorkerModelResolver({ db: this.#db, provider: this.#provider });
+        this.#reads = new ClientReads({ db: this.#db, engine: this.#engine, workspaceGate: this.#workspaceGate, residency: this.#residency });
     }
     // {§methods-event-subscribe}. A transport module subscribes to the daemon's in-process
     // event source: it receives every workspace-scoped engine event as `(workspaceId, method, params)`
@@ -336,7 +339,7 @@ export default class Daemon {
         // (seeded once from the daemon default). The loop then snapshots the resolved route.
         // A continuation's omitted selector must still keep the loop's durable provider.
         const selectorExplicit = selector !== undefined;
-        const generationPolicy = await this.#resolveWorkerModel(workerId, selector);
+        const generationPolicy = await this.#workerModels.resolveWorkerModel(workerId, selector);
         if (generationPolicy === null) {
             throw new OperationFailureError(Results.failure("daemon:provider", "not-configured", 501, "No provider is configured for this worker.", {}, {
                 stage: "provider-selection",
@@ -346,7 +349,7 @@ export default class Daemon {
         }
         const { providerSpec: selection, reasoningPolicy } = generationPolicy;
         // {§methods-loop-run-child-provider} — the worker's persistent spawn override.
-        const childSelection = await this.#resolveWorkerSpawnModel(workerId, childSelector);
+        const childSelection = await this.#workerModels.resolveWorkerSpawnModel(workerId, childSelector);
         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).
@@ -373,157 +376,6 @@ export default class Daemon {
         });
         return { status: 100, action, loopId, ...(turnSeq !== undefined ? { turnSeq } : {}) };
     }
-    // {§methods-loop-run-model} — resolve one alias-or-route selector to a cached
-    // Provider; absent uses the boot default. An unknown alias or malformed exact
-    // route throws legibly rather than silently running the wrong model.
-    async #resolveLoopProvider(selector, reasoningPolicy) {
-        const requested = resolveLoopRoute(selector, parseAliasesFromEnv());
-        if (requested === null && this.#provider === null)
-            return null;
-        const spec = requested ?? resolveActiveRoute();
-        if (spec === null) {
-            throw daemonFailure("daemon:provider", "active-model-unresolved", 500, "The active provider has no resolvable model route.", { stage: "provider-selection", retryable: false });
-        }
-        await this.#providerForPolicy(spec, reasoningPolicy);
-        return spec;
-    }
-    // Resolve eagerly so runLoop fails before enqueue when the selected route
-    // and durable reasoning policy cannot compose. The drain later retrieves
-    // this cached handle from the loop's immutable snapshot.
-    async #providerForPolicy(spec, reasoningPolicy) {
-        try {
-            const provider = await ProviderInstantiate.instantiateProvider(spec, process.env, reasoningPolicy);
-            ProviderInstantiate.validateGrammarConfiguration(provider, process.env, reasoningPolicy);
-            return provider;
-        }
-        catch (cause) {
-            if (cause instanceof OperationFailureError)
-                throw cause;
-            if (cause instanceof UnsupportedReasoningPolicyError) {
-                throw daemonFailure("daemon:provider", "reasoning-policy-unsupported", 409, `${modelRouteLabel(spec)} does not support reasoning policy '${cause.policy}'.`, {
-                    ...(spec.alias === undefined ? {} : { alias: spec.alias }),
-                    provider: spec.provider,
-                    model: spec.model,
-                    reasoningPolicy: cause.policy,
-                    supportedReasoningPolicies: cause.supported,
-                    stage: "provider-selection",
-                    recovery: "Select one of the provider's supported reasoning policies.",
-                    retryable: false
-                });
-            }
-            console.error(`${modelRouteLabel(spec)} could not be instantiated:`, cause);
-            throw daemonFailure("daemon:provider", "provider-unavailable", 503, `${modelRouteLabel(spec)} is unavailable.`, {
-                ...(spec.alias === undefined ? {} : { alias: spec.alias }),
-                provider: spec.provider,
-                model: spec.model,
-                stage: "provider-selection",
-                retryable: false
-            });
-        }
-    }
-    // {§worker-model-selection} — a model worker owns one durable model. An explicit
-    // selector persists onto the worker; an omitted selector resolves the worker's
-    // durable model, seeded once from the daemon default. A deliberately modelless
-    // daemon leaves the worker unset until an explicit selection arrives.
-    async #resolveWorkerModel(workerId, selector) {
-        const worker = await this.#db.worker_generation_policy_read.get({ id: workerId });
-        if (worker === undefined)
-            throw new Error(`worker ${workerId}: model route row missing`);
-        if (selector !== undefined) {
-            const spec = await this.#resolveLoopProvider(selector, worker.reasoning_policy ?? undefined);
-            if (spec === null)
-                return null;
-            const reasoningPolicy = worker.reasoning_policy
-                ?? ProviderInstantiate.configuredReasoningPolicy(spec);
-            if (worker.spawn_model_route_id !== null) {
-                const spawnSpec = await specForRoute(this.#db, worker.spawn_model_route_id);
-                if (spawnSpec === null)
-                    throw new Error(`worker ${workerId}: spawn model route is missing`);
-                await this.#providerForPolicy(spawnSpec, reasoningPolicy);
-            }
-            await this.#db.worker_generation_policy_update.run({
-                id: workerId,
-                model_route_id: await routeForSpec(this.#db, spec),
-                spawn_model_route_id: worker.spawn_model_route_id,
-                reasoning_policy: reasoningPolicy
-            });
-            return { providerSpec: spec, reasoningPolicy };
-        }
-        if (worker.model_route_id !== null) {
-            if (worker.reasoning_policy === null) {
-                throw new Error(`worker ${workerId}: durable model has no reasoning policy`);
-            }
-            const spec = await specForRoute(this.#db, worker.model_route_id);
-            if (spec === null)
-                throw new Error(`worker ${workerId}: model route is missing`);
-            await this.#providerForPolicy(spec, worker.reasoning_policy);
-            return { providerSpec: spec, reasoningPolicy: worker.reasoning_policy };
-        }
-        if (this.#provider === null)
-            return null;
-        const spec = resolveActiveRoute();
-        if (spec !== null) {
-            const reasoningPolicy = ProviderInstantiate.configuredReasoningPolicy(spec);
-            await this.#providerForPolicy(spec, reasoningPolicy);
-            if (worker.spawn_model_route_id !== null) {
-                const spawnSpec = await specForRoute(this.#db, worker.spawn_model_route_id);
-                if (spawnSpec === null)
-                    throw new Error(`worker ${workerId}: spawn model route is missing`);
-                await this.#providerForPolicy(spawnSpec, reasoningPolicy);
-            }
-            await this.#db.worker_generation_policy_update.run({
-                id: workerId,
-                model_route_id: await routeForSpec(this.#db, spec),
-                spawn_model_route_id: worker.spawn_model_route_id,
-                reasoning_policy: reasoningPolicy
-            });
-            return { providerSpec: spec, reasoningPolicy };
-        }
-        return null;
-    }
-    // {§worker-model-selection} — the persistent spawn override. An explicit child
-    // selector persists onto the worker (null clears it back to inherit); an omitted
-    // selector resolves the persisted override, seeded once from the operator's
-    // PLURNK_MODEL_CHILD default.
-    async #resolveWorkerSpawnModel(workerId, childSelector) {
-        const worker = await this.#db.worker_generation_policy_read.get({ id: workerId });
-        if (worker === undefined)
-            throw new Error(`worker ${workerId}: model route row missing`);
-        if (childSelector !== undefined) {
-            const spec = childSelector === null
-                ? null
-                : await this.#resolveLoopProvider(childSelector, worker.reasoning_policy ?? undefined);
-            await this.#db.worker_generation_policy_update.run({
-                id: workerId,
-                model_route_id: worker.model_route_id,
-                spawn_model_route_id: spec === null ? null : await routeForSpec(this.#db, spec),
-                reasoning_policy: worker.reasoning_policy
-            });
-            return spec;
-        }
-        if (worker.spawn_model_route_id !== null) {
-            const spec = await specForRoute(this.#db, worker.spawn_model_route_id);
-            if (spec === null)
-                throw new Error(`worker ${workerId}: spawn model route is missing`);
-            if (worker.reasoning_policy !== null) {
-                await this.#providerForPolicy(spec, worker.reasoning_policy);
-            }
-            return spec;
-        }
-        const configured = process.env.PLURNK_MODEL_CHILD;
-        if (configured === undefined || configured.length === 0)
-            return null;
-        const spec = await this.#resolveLoopProvider(configured, worker.reasoning_policy ?? undefined);
-        if (spec !== null) {
-            await this.#db.worker_generation_policy_update.run({
-                id: workerId,
-                model_route_id: worker.model_route_id,
-                spawn_model_route_id: await routeForSpec(this.#db, spec),
-                reasoning_policy: worker.reasoning_policy
-            });
-        }
-        return spec;
-    }
     // {§worker-model-selection} — the loop's durable snapshot is the immutable route ids,
     // resolved through model_routes at the claim boundary; never re-resolved through the
     // alias cascade (a changed alias declaration must not rewrite history).
@@ -549,10 +401,10 @@ export default class Daemon {
     }
     async #providersForLoop(loopId) {
         const policy = await this.#providerPolicyForLoop(loopId);
-        const provider = await this.#providerForPolicy(policy.providerSpec, policy.reasoningPolicy);
+        const provider = await this.#workerModels.providerForPolicy(policy.providerSpec, policy.reasoningPolicy);
         const childProvider = policy.childProviderSpec === null
             ? provider
-            : await this.#providerForPolicy(policy.childProviderSpec, policy.reasoningPolicy);
+            : await this.#workerModels.providerForPolicy(policy.childProviderSpec, policy.reasoningPolicy);
         return { provider, childProvider };
     }
     async #assertLoopProvider(loopId, requested) {
@@ -679,20 +531,20 @@ export default class Daemon {
         await this.#assertWorkerOwned(workspaceId, workerId);
         await this.#assertWorkerSelectable(workerId);
         const selector = ClientInput.assertSelector("worker.model.set", "selector", args.selector);
-        const policy = await this.#resolveWorkerModel(workerId, selector);
+        const policy = await this.#workerModels.resolveWorkerModel(workerId, selector);
         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);
     }
     async #reasoningSupportForWorker(workerId, row, providerSpec, policy) {
-        const provider = await this.#providerForPolicy(providerSpec, policy);
+        const provider = await this.#workerModels.providerForPolicy(providerSpec, policy);
         if (row.spawn_model_route_id === null)
             return provider.supportedReasoningPolicies;
         const spawnSpec = await specForRoute(this.#db, row.spawn_model_route_id);
         if (spawnSpec === null)
             throw new Error(`worker ${workerId}: spawn model route is missing`);
-        const spawnProvider = await this.#providerForPolicy(spawnSpec, policy);
+        const spawnProvider = await this.#workerModels.providerForPolicy(spawnSpec, policy);
         return provider.supportedReasoningPolicies.filter((candidate) => spawnProvider.supportedReasoningPolicies.includes(candidate));
     }
     // {§worker-reasoning-policy} — the worker's reasoning policy is durable and
@@ -701,7 +553,7 @@ export default class Daemon {
         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.#resolveWorkerModel(workerId, undefined);
+        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`);
@@ -736,7 +588,7 @@ export default class Daemon {
         }
         await this.#assertWorkerOwned(workspaceId, workerId);
         await this.#assertWorkerSelectable(workerId);
-        await this.#resolveWorkerModel(workerId, undefined);
+        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`);
@@ -766,7 +618,7 @@ export default class Daemon {
         await this.#assertWorkerOwned(workspaceId, workerId);
         await this.#assertWorkerSelectable(workerId);
         const selector = ClientInput.assertChildSelector("worker.child.set", args.selector);
-        const spec = await this.#resolveWorkerSpawnModel(workerId, selector);
+        const spec = await this.#workerModels.resolveWorkerSpawnModel(workerId, selector);
         if (spec === null)
             return null;
         const row = await this.#db.worker_generation_policy_read.get({ id: workerId });
@@ -970,64 +822,6 @@ export default class Daemon {
             releaseCapabilities();
         }
     }
-    // {§methods-log-read} — a workspace's journal, the module's primary render input. The worker is
-    // ownership-verified against the workspace (a workspace reads only its own workers — the model worker included,
-    // {§methods-log-coordinate}); entries filter by loop/turn/since-id or the full L/T/S display coordinate. Core owns the
-    // journal + the invariant; the module shapes the entries into AG-UI messages at its edge.
-    async readLog(args) {
-        const workspaceId = ClientInput.assertId("log.read", "workspaceId", args.workspaceId);
-        const workerId = ClientInput.assertId("log.read", "workerId", args.workerId);
-        const target = await this.#db.envelope_get_worker_by_id.get({ id: workerId });
-        if (target === undefined) {
-            throw daemonFailure("daemon:worker", "worker-not-found", 404, `Worker ${workerId} does not exist.`, { workerId });
-        }
-        if (target.workspace_id !== workspaceId) {
-            throw daemonFailure("daemon:worker", "workspace-mismatch", 409, `Worker ${workerId} does not belong to workspace ${workspaceId}.`, {
-                workerId,
-                workspaceId,
-                actualWorkspaceId: target.workspace_id,
-                retryable: false
-            });
-        }
-        const coordinateFields = {
-            loopId: args.loopId,
-            turnId: args.turnId,
-            sinceId: args.sinceId,
-            loopSeq: args.loopSeq,
-            turnSeq: args.turnSeq,
-            sequence: args.sequence
-        };
-        for (const [field, value] of Object.entries(coordinateFields)) {
-            if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-                throw daemonFailure("daemon:log", "coordinate-invalid", 400, `Log coordinate field '${field}' is not a non-negative safe integer.`, {
-                    field,
-                    value,
-                    stage: "log-read",
-                    recovery: "Use a non-negative integer coordinate.",
-                    retryable: false
-                });
-            }
-        }
-        if (args.limit !== undefined && (!Number.isSafeInteger(args.limit) || args.limit < 1)) {
-            throw daemonFailure("daemon:log", "limit-invalid", 400, `Log limit ${args.limit} is not a positive safe integer.`, {
-                field: "limit",
-                value: args.limit,
-                stage: "log-read",
-                recovery: "Use a positive integer log limit.",
-                retryable: false
-            });
-        }
-        const rows = await this.#db.log_read_recent_ids.all({
-            worker_id: workerId,
-            loop_id: args.loopId ?? null, turn_id: args.turnId ?? null, since_id: args.sinceId ?? null,
-            loop_seq: args.loopSeq ?? null, turn_seq: args.turnSeq ?? null, sequence: args.sequence ?? null,
-            limit: Math.min(args.limit ?? 100, 1000)
-        });
-        const entries = [];
-        for (const r of rows)
-            entries.push(await LogEntry.fetchLogEntry(this.#db, r.id));
-        return entries;
-    }
     // {§methods} — the module's render surface beyond the journal. Thin delegations
     // into core's envelope / membership / provider machinery; the module fans the results into its own views.
     listProviders() {
@@ -1170,139 +964,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) };
     }
-    // Contracts {§entry-read-result}: resolve through the scheme's address law,
-    // then project one owner-scoped entry without exposing persistence columns.
-    async readEntry(args) {
-        const workspaceId = ClientInput.assertId("entry.read", "workspaceId", args.workspaceId);
-        const workerId = ClientInput.assertId("entry.read", "workerId", args.workerId);
-        if (typeof args.target !== "string" || args.target.length === 0) {
-            throw daemonFailure("daemon:input", "target-invalid", 400, "target is not a non-empty string.", {
-                context: "entry.read",
-                field: "target",
-                stage: "input-validation",
-                recovery: "Provide an entry URI.",
-                retryable: false
-            });
-        }
-        const channel = ClientInput.assertOptionalChannel("entry.read", args.channel);
-        const worker = await this.#db.envelope_get_worker_by_id.get({ id: workerId });
-        if (worker === undefined) {
-            throw daemonFailure("daemon:worker", "worker-not-found", 404, `Worker ${workerId} does not exist.`, { workerId });
-        }
-        if (worker.workspace_id !== workspaceId) {
-            throw daemonFailure("daemon:worker", "workspace-mismatch", 409, `Worker ${workerId} does not belong to workspace ${workspaceId}.`, {
-                workerId,
-                workspaceId,
-                actualWorkspaceId: worker.workspace_id,
-                retryable: false
-            });
-        }
-        const releaseCapabilities = await this.#residency.acquire(workspaceId, workerId);
-        let releaseWorkspace;
-        try {
-            releaseWorkspace = await this.#workspaceGate.acquireTurn(workspaceId, workerId);
-            let parsed;
-            try {
-                parsed = parsePath(args.target);
-            }
-            catch {
-                parsed = null;
-            }
-            if (parsed === null || parsed.kind !== "url") {
-                return entryReadResult(Results.failure("daemon:entry", "target-invalid", 400, `The entry target '${args.target}' is not URL-shaped.`, { entry: null }, {
-                    target: args.target,
-                    stage: "entry-read",
-                    recovery: "Use a scheme://path target.",
-                    retryable: false
-                }));
-            }
-            if (args.offset !== undefined && channel === undefined) {
-                return entryReadResult(Results.failure("daemon:entry", "offset-channel-required", 400, "An entry offset requires a channel.", { entry: null }, {
-                    offset: args.offset,
-                    stage: "entry-read",
-                    recovery: "Select the channel to read from the offset.",
-                    retryable: false
-                }));
-            }
-            if (args.offset !== undefined && (!Number.isSafeInteger(args.offset) || args.offset < 0)) {
-                return entryReadResult(Results.failure("daemon:entry", "offset-invalid", 400, `Entry offset ${args.offset} is not a non-negative safe integer.`, { entry: null }, {
-                    offset: args.offset,
-                    stage: "entry-read",
-                    recovery: "Use a non-negative integer offset.",
-                    retryable: false
-                }));
-            }
-            if (parsed.username !== null || parsed.password !== null) {
-                return entryReadResult(Results.failure("daemon:entry", "userinfo-not-allowed", 400, "Entry target URL userinfo is not allowed.", { entry: null }, {
-                    stage: "entry-read",
-                    recovery: "Remove credentials from the entry URL.",
-                    retryable: false
-                }));
-            }
-            const location = await this.#engine.resolveEntryAddress({
-                workspaceId,
-                workerId,
-                target: parsed
-            });
-            if (location === null) {
-                return entryReadResult(Results.failure("daemon:entry", "entry-not-found", 404, "No visible entry exists at the requested target.", { entry: null }, { target: args.target }));
-            }
-            const row = await this.#db.entry_read_lookup.get({
-                workspace_id: workspaceId,
-                owner_id: location.ownerId,
-                scheme: location.scheme,
-                authority: location.authority,
-                pathname: location.pathname
-            });
-            if (row === undefined) {
-                return entryReadResult(Results.failure("daemon:entry", "entry-not-found", 404, `No visible entry exists at ${location.target}.`, { entry: null }, { target: location.target }));
-            }
-            let channelRows;
-            if (channel === undefined) {
-                channelRows = await this.#db.entry_read_channels.all({ entry_id: row.id });
-            }
-            else {
-                const r = await this.#db.entry_read_channel_slice.get({ entry_id: row.id, channel, offset: args.offset ?? 0 });
-                if (r === undefined) {
-                    const availableChannels = (await this.#db.entry_read_channels.all({ entry_id: row.id }))
-                        .map(({ name }) => name);
-                    return entryReadResult(Results.failure("daemon:entry", "channel-not-found", 404, `Channel #${channel} does not exist at ${location.target}.`, { entry: null }, {
-                        target: location.target,
-                        requestedChannel: channel,
-                        availableChannels,
-                        ...(availableChannels.length === 0
-                            ? {}
-                            : { recovery: `Use one of the available channels: ${availableChannels.map((channel) => `#${channel}`).join(", ")}.` }),
-                        retryable: false
-                    }));
-                }
-                channelRows = [r];
-            }
-            const channels = {};
-            for (const c of channelRows) {
-                channels[c.name] = {
-                    content: c.content,
-                    contentOffset: c.contentOffset,
-                    contentLength: c.contentLength,
-                    mimetype: c.mimetype,
-                    weight: c.weight,
-                    state: c.state
-                };
-            }
-            return entryReadResult({
-                status: 200,
-                entry: {
-                    entryId: row.id,
-                    target: location.target,
-                    channels
-                }
-            });
-        }
-        finally {
-            releaseWorkspace?.();
-            releaseCapabilities();
-        }
-    }
     // {§methods-conversation-worker}: a fresh conversation is a model-origin root worker with an empty private log.
     // AG-UI threads map to these workers while the workspace world remains shared ({§machine-processes}).
     async createConversationWorker(args) {
@@ -1688,6 +1349,8 @@ 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?.abortDetached?.();
         if (exec?.idle !== undefined)
             await exec.idle();
     }
@@ -1821,5 +1484,11 @@ export default class Daemon {
             this.#emitTo(target.workspaceId, method, params);
         });
     }
+    async readEntry(...args) {
+        return this.#reads.readEntry(...args);
+    }
+    async readLog(...args) {
+        return this.#reads.readLog(...args);
+    }
 }
 //# sourceMappingURL=Daemon.js.map