@plurnk/plurnk-service 1.18.0 → 1.19.0

package/dist/core/Dispatcher.js

@@ -1,18 +1,22 @@
 var _a;
 import { PlurnkParser, parsePath } from "@plurnk/plurnk-parser";
 import { TurnDisposition } from "@plurnk/plurnk-contracts";
-import { foldAuthorityIntoPath, promptLoopPrefix, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
+import Turn from "./Turn.js";
+import { foldAuthorityIntoPath, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
+import WorkerName from "./WorkerName.js";
 import { PathSyntax } from "@plurnk/plurnk-contracts";
 import Namespace from "./namespace.js";
 import CapabilityResolver from "./CapabilityResolver.js";
+import CapabilityPolicies from "./CapabilityPolicies.js";
 import LoopPolicyReader from "./LoopPolicyReader.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
 import Results from "./results.js";
 import { OperationFailureError } from "./results.js";
 import EffectPolicy from "../schemes/EffectPolicy.js";
 import { CoreSchemeAdapterBase } from "./CoreSchemeServices.js";
-import { InvalidOperationResultError } from "@plurnk/plurnk-schemes";
+import { InvalidOperationResultError, MessageAttachments } from "@plurnk/plurnk-schemes";
 import ResourceMutations from "./ResourceMutations.js";
+import ResourceSelector from "./ResourceSelector.js";
 import { primaryTargetOf } from "./statement-primary.js";
 import LogBody from "./LogBody.js";
 import LogVisibility from "./LogVisibility.js";
@@ -35,11 +39,6 @@ class Dispatcher {
     static #failure(code, status, detail, fields = {}, extensions = {}) {
         return Results.failure("engine:dispatcher", code, status, detail, fields, extensions);
     }
-    static #statusResult(status, code, detail, fields = {}) {
-        return status >= 400
-            ? _a.#failure(code, status, detail, fields, { retryable: false })
-            : { ...fields, status };
-    }
     #db;
     #schemes;
     #mimetypes;
@@ -58,11 +57,12 @@ class Dispatcher {
     #wakeWorkerNotify;
     #injectWorker;
     #cancelWorker;
-    #cancelDescendants;
+    #operationSettledNotify;
     // Per-turn running-worker READ obligations. {§join-blocking-collect}
     #liveSubscriptions;
     #lifecycle;
     #resourceMutations;
+    #resourceSelector;
     #entryAddresses;
     #capabilities;
     #workerControl;
@@ -70,7 +70,7 @@ class Dispatcher {
     #disposition;
     #logWriter;
     #dataRun;
-    constructor({ db, lifecycle, schemes, mimetypes, weigh, notices, proposals, interactions, executors, loopSignal, settleDerivations, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, cancelDescendants, liveSubscriptions, entryAddresses }) {
+    constructor({ db, lifecycle, schemes, mimetypes, weigh, notices, proposals, interactions, executors, loopSignal, settleDerivations, streamEventNotify, wakeWorkerNotify, injectWorker, cancelWorker, operationSettledNotify, liveSubscriptions, entryAddresses }) {
         this.#db = db;
         this.#schemes = schemes;
         this.#mimetypes = mimetypes;
@@ -85,11 +85,20 @@ class Dispatcher {
         this.#wakeWorkerNotify = wakeWorkerNotify;
         this.#injectWorker = injectWorker;
         this.#cancelWorker = cancelWorker;
-        this.#cancelDescendants = cancelDescendants;
+        this.#operationSettledNotify = operationSettledNotify;
         this.#liveSubscriptions = liveSubscriptions;
         this.#entryAddresses = entryAddresses;
         this.#capabilities = new CapabilityResolver(db, schemes, executors);
         this.#lifecycle = lifecycle;
+        this.#resourceSelector = new ResourceSelector({
+            schemes,
+            admitRead: (statement, ctx) => this.#checkCapabilities(statement, ctx),
+            canonicalFilePath: (pathname, workspaceId) => this.#canonicalFilePath(pathname, workspaceId),
+            prepareDataRepresentation: (args) => this.#prepareDataRepresentation({
+                ...args,
+                handler: args.handler,
+            }),
+        });
         this.#resourceMutations = new ResourceMutations({
             schemes,
             liveSubscriptions,
@@ -97,11 +106,7 @@ class Dispatcher {
             checkWritable: (statement, origin, workspaceId) => this.#checkWritable(statement, origin, workspaceId),
             checkCapabilities: (statement, ctx) => this.#checkCapabilities(statement, ctx),
             editTargetIdentity: (statement, workspaceId, workerId) => this.#editTargetIdentity(statement, workspaceId, workerId),
-            canonicalFilePath: (pathname, workspaceId) => this.#canonicalFilePath(pathname, workspaceId),
-            prepareDataRepresentation: (args) => this.#prepareDataRepresentation({
-                ...args,
-                handler: args.handler,
-            }),
+            selection: this.#resourceSelector,
             resolveDataEntryAddress: (args) => this.#entryAddresses.resolve(args),
             readEntry: (scheme, address, ctx) => this.#readEntry(scheme, address, ctx),
             writeEntry: (scheme, address, entry, ctx) => this.#writeEntry(scheme, address, entry, ctx),
@@ -110,7 +115,7 @@ class Dispatcher {
         });
         this.#workerControl = new WorkerControlHandler({ db: this.#db, failure: _a.#failure });
         this.#kill = new KillHandler({ db: this.#db, schemes: this.#schemes, liveSubscriptions: this.#liveSubscriptions, cancelWorker: this.#cancelWorker, resolveDataEntryAddress: this.#resolveDataEntryAddress.bind(this), boundEntryContext: this.#boundEntryContext.bind(this), handlerContext: this.#handlerContext.bind(this), deleteEntry: this.#deleteEntry.bind(this), failure: _a.#failure });
-        this.#disposition = new TurnDispositionHandler({ db: this.#db, cancelDescendants: this.#cancelDescendants, lifecycle: this.#lifecycle, nextPacketBoundaries: this.#nextPacketBoundaries.bind(this), unobservedFailureCount: this.#unobservedFailureCount.bind(this), pendingSet: this.#pendingSet.bind(this), hasLiveWork: this.hasLiveWork.bind(this), failure: _a.#failure, statusResult: _a.#statusResult });
+        this.#disposition = new TurnDispositionHandler({ db: this.#db, lifecycle: this.#lifecycle, unobservedFailureCount: this.#unobservedFailureCount.bind(this), pendingSet: this.#pendingSet.bind(this), hasLiveWork: this.hasLiveWork.bind(this) });
         this.#logWriter = new LogWriter({ db: this.#db, weighContent: this.#weighContent, extractTarget: this.#extractTarget.bind(this), canonColumns: this.#canonColumns.bind(this), signalToJson: this.#signalToJson.bind(this), isProposal: _a.#isProposal });
         this.#dataRun = new DataStatementRunner({ schemes: this.#schemes, liveSubscriptions: this.#liveSubscriptions, resolveDataEntryAddress: this.#resolveDataEntryAddress.bind(this), prepareDataRepresentation: this.#prepareDataRepresentation.bind(this), failure: _a.#failure });
     }
@@ -334,6 +339,7 @@ class Dispatcher {
                 turnId: context.turnId, sequence: context.sequence, origin: context.origin, curationPlan: null, modelCallId: null,
             });
             context.onDispatch?.(logEntryId);
+            await this.#notifySettled(context, logEntryId);
             return result;
         }
         const matchingPathCount = typeof found.matchingPathCount === "number" ? found.matchingPathCount : paths.length;
@@ -356,14 +362,11 @@ class Dispatcher {
         return Results.assert({ ...(results.find(({ status }) => status >= 400) ?? results[results.length - 1]), rowsWritten: results.length });
     }
     async #dispatchOne(context, schemeCtx) {
-        const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, onSettled, } = context;
+        const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, } = context;
         let result;
         let curationPlan = null;
-        // {§send-prompt-acceptance} — a model SEND addressed to one of this loop's own prompts
-        // means what an untargeted SEND means; the address the packet showed it is accepted.
-        const ownPrompt = statement.op === "SEND" && origin === "model" && await this.#isOwnPromptAddress(statement.target, workerId, loopId);
-        const denial = ownPrompt ? null : (this.#checkWritable(statement, origin, workspaceId)
-            ?? await this.#checkCapabilities(statement, schemeCtx));
+        const denial = this.#checkWritable(statement, origin, workspaceId)
+            ?? await this.#checkCapabilities(statement, schemeCtx);
         if (denial !== null) {
             result = denial;
         }
@@ -377,18 +380,23 @@ class Dispatcher {
                 if (statement.op === "EDIT") {
                     result = await this.#resourceMutations.edit(statement, schemeCtx, context.editSequence);
                 }
-                else if (statement.op === "SEND" && (statement.target === null || ownPrompt)) {
+                else if (statement.op === "SEND" && statement.target === null) {
                     result = await this.#respond(statement, schemeCtx, origin, workerId, loopId);
+                    if (context.proseAnswer === true && result.status === 200)
+                        result = await this.#answered(result, workerId, loopId);
+                }
+                else if (statement.op === "NOTE") {
+                    await Turn.recordSource(this.#db, turnId, "note", statement.body ?? "", { sequence });
+                    const coordinate = await this.#db.engine_loop_turn_seqs.get({ loop_id: loopId, turn_id: turnId });
+                    if (coordinate === undefined)
+                        throw new Error(`NOTE has no turn coordinate for ${turnId}`);
+                    const workerName = await WorkerName.forId(this.#db, workerId);
+                    result = { status: 200, resource: renderAddress({ scheme: "note", authority: workerName, pathname: `/${coordinate.loop_seq}/${coordinate.turn_seq}/${sequence}` }) };
                 }
                 else if (TurnDisposition.is(statement)) {
-                    result = await this.#disposition.handle(statement, {
-                        workspaceId,
-                        workerId,
-                        loopId,
-                        turnId,
-                        sequence,
-                        origin,
-                    });
+                    // {§turn-disposition} — WAIT is the park; whatever it names is its label in the
+                    // row, never a join: the next wake is a message, a child's end, a stream's close.
+                    result = await this.#disposition.handle({ workerId, loopId, turnId, origin });
                 }
                 else if (statement.op === "KILL" && schemeNameOf(statement.target) === "log") {
                     const curation = await this.#runLogCuration(statement, schemeCtx, context.logSelectionMaxId);
@@ -461,7 +469,7 @@ class Dispatcher {
         });
         onDispatch?.(logEntryId);
         // Proposal lifecycle (SPEC.md {§engine-rails} + {§methods-proposal-resolve}; {§proposal-202-pauses}). When a
-        // side-effecting op returns status 202 (a waiting TASK parks rather
+        // side-effecting op returns status 202 (a WAIT parks rather
         // than proposing — #isProposal), the entry is written
         // state='proposed'; dispatch then PAUSES on a per-entry waiter until
         // resolution arrives via Engine.resolveProposal (from a client-interface resume,
@@ -471,17 +479,21 @@ class Dispatcher {
             // Effect-gated auto-run (read/pure runtimes, {§exec-readpure-ungated}):
             // An execution stores its one canonical effect fact before admission. Reuse
             // that exact fact here; no human gate or loop/proposal notification.
+            // {§exec-host-proposes} — the rule is the effect, not the op: an execution and a
+            // runtime SEND MUST declare one, and any other proposal that declares one (an
+            // outbound HTTP mutation, {§http-outbound-proposes}) is mapped by the same panel.
             const effect = result.attrs?.effect;
             let autoAccept = false;
-            if (isExecution(statement) || (statement.op === "SEND"
-                && this.#schemes.isRuntimeScheme(schemeNameOf(statement.target) ?? "", workspaceId))) {
+            const mustDeclareEffect = isExecution(statement) || (statement.op === "SEND"
+                && this.#schemes.isRuntimeScheme(schemeNameOf(statement.target) ?? "", workspaceId));
+            if (mustDeclareEffect || effect !== undefined) {
                 if (!EffectPolicy.isEffect(effect)) {
                     throw new InvalidOperationResultError("Execution proposal omitted its canonical effect fact.");
                 }
                 autoAccept = EffectPolicy.decide(effect) === "auto";
             }
             if (autoAccept) {
-                const initialSettlement = await this.#proposals.workerApply(statement, result, { decision: "accept" }, { workspaceId, workerId, loopId, turnId });
+                const initialSettlement = await this.#proposals.workerApply(statement, result, { decision: "accept" }, { workspaceId, workerId, loopId, turnId, resources: schemeCtx.resources });
                 const effective = await this.#resourceMutations.settleProposal({
                     statement,
                     result,
@@ -490,7 +502,7 @@ class Dispatcher {
                     ids: { workspaceId, workerId, loopId, turnId },
                 });
                 const post = await this.#proposals.applyResolution(logEntryId, effective);
-                await onSettled?.(logEntryId);
+                await this.#notifySettled(context, logEntryId);
                 return post;
             }
             // Register the resolution waiter SYNCHRONOUSLY before any await
@@ -504,14 +516,14 @@ class Dispatcher {
             // not an observer and cannot silently degrade into client ownership.
             let resolutionPromise;
             try {
-                resolutionPromise = this.#proposals.awaitResolution(logEntryId);
+                resolutionPromise = this.#proposals.awaitResolution(logEntryId, this.#loopSignal(loopId));
                 const event = await this.#proposals.pending(logEntryId);
                 this.#proposals.settleOwned(event);
                 this.#proposals.notifyPending(event);
             }
             catch (cause) {
                 await this.#proposals.failPreparation(logEntryId, cause);
-                await onSettled?.(logEntryId);
+                await this.#notifySettled(context, logEntryId);
                 throw cause;
             }
             const resolution = await resolutionPromise;
@@ -519,7 +531,7 @@ class Dispatcher {
             // file, spawns the process, etc.). Its operation result is
             // preserved: an apply failure keeps its original status and
             // Problem Details instead of masquerading as a client rejection.
-            const initialSettlement = await this.#proposals.workerApply(statement, result, resolution, { workspaceId, workerId, loopId, turnId });
+            const initialSettlement = await this.#proposals.workerApply(statement, result, resolution, { workspaceId, workerId, loopId, turnId, resources: schemeCtx.resources });
             const effective = await this.#resourceMutations.settleProposal({
                 statement,
                 result,
@@ -528,12 +540,16 @@ class Dispatcher {
                 ids: { workspaceId, workerId, loopId, turnId },
             });
             const post = await this.#proposals.applyResolution(logEntryId, effective);
-            await onSettled?.(logEntryId);
+            await this.#notifySettled(context, logEntryId);
             return post;
         }
-        await onSettled?.(logEntryId);
+        await this.#notifySettled(context, logEntryId);
         return result;
     }
+    async #notifySettled(context, logEntryId) {
+        await context.onSettled?.(logEntryId);
+        await this.#operationSettledNotify?.(context.workspaceId, logEntryId);
+    }
     // {§op-look}: resolve a READ and return its content without writing a
     // log_entries row: the client's out-of-band inspection primitive (LOOK → READ,
     // invisible to the model). READ never mutates and never proposes, so this is
@@ -618,7 +634,7 @@ class Dispatcher {
         if (metadata !== null && manifest.metadataModifier !== true) {
             return {
                 address: null,
-                result: _a.#failure("scheme-metadata-unsupported", 400, `Scheme '${routedScheme}' does not accept the [metadata] modifier.`, {}, { scheme: routedScheme, retryable: false }),
+                result: _a.#failure("scheme-metadata-unsupported", 400, `Resource acquisition from '${routedScheme}' does not accept the [metadata] modifier.`, {}, { scheme: routedScheme, retryable: false }),
             };
         }
         const resolved = priorResolution ?? await this.#resolveDataEntryAddress({
@@ -697,6 +713,8 @@ class Dispatcher {
             db: this.#db,
             workspaceId, workerId, loopId, turnId,
             writer: origin,
+            resources: { capture: (targets) => ResourceBindings.using(this.#schemes, context, (bound) => this.#resourceSelector.capture(targets, bound)) },
+            replyToMessage: (statement) => this.#respond(statement, context, origin, workerId, loopId),
             signal: this.#loopSignal(loopId),
             streamEventNotify: this.#streamEventNotify,
             wakeWorkerNotify: this.#wakeWorkerNotify,
@@ -766,7 +784,7 @@ class Dispatcher {
             return _a.#failure("send-target-not-a-recipient", 400, "The addressed scheme is not a SEND recipient.", {}, {
                 target: statement.target?.raw ?? String(target),
                 stage: "dispatch",
-                recovery: "A targetless SEND answers the active prompt; a directed SEND requires a recipient that implements SEND.",
+                recovery: "A targetless SEND answers the open messages; a directed SEND requires a recipient that implements SEND.",
                 retryable: false,
             });
         }
@@ -795,7 +813,7 @@ class Dispatcher {
     // owner; a known policy denial is one factual, non-presumptuous 403.
     async #checkCapabilities(statement, ctx) {
         await LoopPolicyReader.read(this.#db, ctx.loopId);
-        const denied = await this.#capabilities.denial(statement, ctx.workspaceId, ctx.writer, async (target) => (await ResourceBindings.resolve(target, ctx))?.manifest);
+        const denied = await this.#capabilities.denial(statement, ctx.workspaceId, ctx.writer, async (target) => (await ResourceBindings.resolve(target, ctx))?.manifest, ctx.loopId);
         if (denied === null)
             return null;
         const { descriptor, scope } = denied;
@@ -808,6 +826,10 @@ class Dispatcher {
         return _a.#failure("capability-denied", 403, `Capability '${route}' is denied by ${scope} policy.`, {}, {
             ...descriptor,
             policyScope: scope,
+            // {§loop-attendance} — the innermost ring subtracts for a reason the model can act
+            // on, so it says it. Every other scope is the operator's configuration and speaks
+            // for itself.
+            ...(scope === "loop" ? { recovery: CapabilityPolicies.UNATTENDED_RECOVERY } : {}),
             retryable: false,
         });
     }
@@ -925,20 +947,22 @@ class Dispatcher {
             modelCallId,
         });
         context.onDispatch?.(logEntryId);
-        await context.onSettled?.(logEntryId);
+        await this.#notifySettled(context, logEntryId);
         return result;
     }
-    // {§send-prompt-acceptance} `prompt://<this worker>/<this loop>/<id>` names a prompt the loop
-    // contains; a SEND to it is the response, exactly as if untargeted. Another worker's or
-    // another loop's prompt is not a recipient and keeps the ordinary refusal.
-    // {§send-response-receipt} — a response names the prompts it answers, so the receipt
-    // says where the text went. {§send-looks-like-operation} — a model response whose first
-    // line is an operation heading is a mis-fenced operation, not a reply: the 2026-09-11
-    // dogfood put four operations on the line after their fences, delivered all four to the
-    // user as 200 replies, then waited fifteen minutes for receipts that could never come.
+    // {§loop-answer} a prose answer's row names where the answer lives, ops://<worker>/<loop>, and
+    // renders under its own leaf ({§log-coordinate-hierarchy}) rather than as a SEND.
+    async #answered(result, workerId, loopId) {
+        const loop = await this.#db.engine_loop_sequence.get({ loop_id: loopId });
+        if (loop === undefined)
+            throw new Error(`prose answer has no loop sequence for loop ${loopId}`);
+        const resource = renderAddress({ scheme: "ops", authority: await WorkerName.forId(this.#db, workerId), pathname: `/${loop.sequence}` });
+        return { ...result, resource, attrs: { ...(result.attrs ?? {}), answer: "prose" } };
+    }
+    // {§send-response-receipt} {§send-looks-like-operation}
     async #respond(statement, schemeCtx, origin, workerId, loopId) {
         if (origin === "model") {
-            const heading = this.#operationHeading(statement.body?.raw ?? "", schemeCtx);
+            const heading = this.#operationHeading(typeof statement.body === "string" ? statement.body : statement.body?.raw ?? "", schemeCtx);
             if (heading !== null) {
                 return _a.#failure("send-looks-like-operation", 400, `The response begins with the operation heading \`${heading}\`; nothing ran and nothing was delivered.`, {}, {
                     heading,
@@ -948,7 +972,24 @@ class Dispatcher {
                 });
             }
         }
-        return { status: 200, recipients: await this.#activePrompts(workerId, loopId) };
+        const captured = await MessageAttachments.capture(statement.metadata, schemeCtx.resources, "message:reply");
+        if ("failure" in captured)
+            return captured.failure;
+        const target = statement.target;
+        let answers;
+        if (target === null) {
+            answers = await this.#openMessages(loopId);
+        }
+        else {
+            const message = await this.#db.message_source_by_address.get({
+                workspace_id: schemeCtx.workspaceId, path: target.raw,
+            });
+            if (message === undefined)
+                return _a.#failure("message-not-found", 404, `No accepted message exists at ${target.raw}.`, {}, { retryable: false });
+            answers = [message.path];
+        }
+        return { status: 200, answers,
+            ...(captured.attachments.length === 0 ? {} : { attachments: MessageAttachments.receipts(captured.attachments) }) };
     }
     // The first non-blank line, when it parses alone as one clean heading naming an operation
     // this worker could perform: a Plurnk operation, or a registered executor or MCP service.
@@ -972,38 +1013,21 @@ class Dispatcher {
             return null;
         return line;
     }
-    // The loop's Active Prompts, oldest first, exactly as the packet lists them.
-    async #activePrompts(workerId, loopId) {
-        const worker = await this.#db.worker_get.get({ id: workerId });
-        if (worker === undefined)
-            throw new Error(`worker ${workerId} does not exist`);
-        const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
-        const prefix = promptLoopPrefix(loopSeq);
-        const rows = await this.#db.drain_get_all_prompt_bodies_for_loop.all({
-            worker_id: workerId,
-            pattern: `${prefix}%`,
-            prefix_len: prefix.length,
-        });
-        return rows.map((row) => `prompt://${worker.name}${row.pathname}`);
+    // {§send-response-receipt}: published unanswered source addresses, oldest first.
+    async #openMessages(loopId) {
+        const rows = await this.#db.engine_open_messages.all({ loop_id: loopId });
+        return rows.map((row) => row.path);
     }
-    async #isOwnPromptAddress(target, workerId, loopId) {
-        if (target === null || target.kind !== "url" || target.scheme !== "prompt")
-            return false;
-        const worker = await this.#db.worker_get.get({ id: workerId });
-        if (worker === undefined || target.hostname !== worker.name)
-            return false;
-        const loopSeq = (await this.#db.engine_loop_sequence.get({ loop_id: loopId }))?.sequence ?? loopId;
-        return target.pathname.startsWith(promptLoopPrefix(loopSeq));
+    async settleProgram(ctx, wait) {
+        return this.#disposition.settle(ctx, wait);
     }
-    // {§send-premature-terminate} The pending set is judged at TASK's dispatch point,
-    // after earlier operations have executed. Every non-SEND/TASK/KILL model operation
-    // requires a new packet, independently of its result or log visibility.
-    async #pendingSet(workerId, turnId) {
+    // {§send-premature-terminate}: judge observation boundaries after the whole program settles.
+    async #pendingSet(workerId, turnId, loopId) {
         const pending = [];
-        // {§worker-obligations} — the stream and child legs are one durable row.
-        const held = await this.#db.worker_live_obligations.get({ worker_id: workerId });
+        // {§worker-obligations} — all held work shares one durable projection.
+        const held = await this.#db.loop_live_obligations.get({ loop_id: loopId });
         if (held === undefined)
-            throw new Error(`worker ${workerId} does not exist`);
+            throw new Error(`loop ${loopId} does not exist`);
         if (held.streams === 1)
             pending.push("streams");
         if (held.workers === 1)
@@ -1016,7 +1040,7 @@ class Dispatcher {
             receipts.push("stream completion");
         if (receipts.length > 0)
             pending.push("receipts");
-        // The final-strike escape hatch cannot discard an unobserved failure.
+        // A failed stream result is still owed to the model before ordinary completion.
         if (boundaries.streamTerminations.some(({ closeStatus }) => closeStatus >= 400))
             pending.push("failed-stream-results");
         if (boundaries.childTerminations)
@@ -1046,11 +1070,9 @@ class Dispatcher {
         const failedRows = await this.#db.engine_turn_failures.all({ turn_id: turnId });
         return failedRows.length;
     }
-    // A live obligation to wait on: a spawned child or an open stream (not retrievals, which land
-    // next turn regardless). The wait-side twin of #pendingSet's stream+child legs ({§wait-obligation-matrix}).
-    async hasLiveWork(workerId) {
-        // {§worker-obligations} — one durable row answers both legs.
-        const held = await this.#db.worker_live_obligations.get({ worker_id: workerId });
+    // {§wait-obligation-matrix}: retrievals land next turn; only held work permits parking.
+    async hasLiveWork(loopId) {
+        const held = await this.#db.loop_live_obligations.get({ loop_id: loopId });
         return held !== undefined && (held.streams === 1 || held.workers === 1);
     }
     async #runLogCuration(statement, ctx, admittedMaxId) {
@@ -1103,7 +1125,7 @@ class Dispatcher {
         const routedScheme = schemeNameOf(path);
         const manifest = routedScheme === null
             ? undefined
-            : this.#schemes.manifestFor(routedScheme, workspaceId);
+            : this.#schemes.manifestAt(routedScheme, path, workspaceId);
         const foldNs = scheme !== null
             && manifest !== undefined
             && (manifest.authority ?? "namespace") === "namespace";