@plurnk/plurnk-service 4.1.0 → 4.3.0

package/dist/core/Dispatcher.js

@@ -1,25 +1,25 @@
 import { parsePath } from "@plurnk/plurnk-parser";
 import { ConfigurationError, Knob } from "@plurnk/plurnk-meta";
-import { TurnDisposition, UNKNOWN_POSITION } from "@plurnk/plurnk-contracts";
+import AmbientMembers from "./AmbientMembers.js";
+import { TurnDisposition, UNKNOWN_POSITION, PathSyntax, Validator, isExecution, isRecord } from "@plurnk/plurnk-contracts";
 import Turn from "./Turn.js";
 import { entryAddress, foldAuthorityIntoPath, renderAddress, renderAuthoredTarget, renderTarget, schemeNameOf } from "./plurnk-uri.js";
 import WorkerName from "./WorkerName.js";
-import { PathSyntax } from "@plurnk/plurnk-contracts";
 import Namespace from "./namespace.js";
 import FileAddress from "./FileAddress.js";
 import CapabilityResolver from "./CapabilityResolver.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
-import LoopLifecycle from "./LoopLifecycle.js";
-import Results from "./results.js";
-import { OperationFailureError } from "./results.js";
+import DbMessageCaps from "./caps/DbMessageCaps.js";
+import Results, { OperationFailureError } from "./results.js";
 import EffectPolicy from "../schemes/EffectPolicy.js";
-import { CoreSchemeAdapterBase } from "./CoreSchemeServices.js";
+import { CoreSchemeAdapterBase, coreRepresentationProvider } from "./CoreSchemeServices.js";
 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 BodyPreview from "../content/body-preview.js";
+import LineSelection from "../content/line-selection.js";
 import ReadResolve from "../content/read-resolve.js";
 import LogVisibility from "./LogVisibility.js";
 import PacketWire, {} from "./packet-wire.js";
@@ -36,13 +36,16 @@ import LogEntryProjection from "./LogEntryProjection.js";
 import DurableStatement from "./DurableStatement.js";
 import DataStatementRunner from "./DataStatementRunner.js";
 import ResourceBindings from "./ResourceBindings.js";
-import { isExecution } from "@plurnk/plurnk-contracts";
 // SPEC {§scheme-surface}: writer must be in target scheme's manifest.writableBy.
 // READ/FIND are not gated — they read, never mutating an entry.
 const MUTATING_OPS = new Set(["EDIT", "SEND", "COPY", "MOVE", "KILL", "FORK", "WORK"]);
 // Op dispatch ({§op-methods-op-dispatch}): admission, operation-owner routing,
 // durable log writing, and proposal lifecycle.
 export default class Dispatcher {
+    // {§log-kill-distillation} The log scheme curates: the hook the registry's log handler publishes.
+    static #curates(handler) {
+        return "curate" in handler && typeof handler.curate === "function";
+    }
     static #failure(code, status, detail, fields = {}, extensions = {}) {
         return Results.failure("engine:dispatcher", code, status, detail, fields, extensions);
     }
@@ -274,7 +277,7 @@ export default class Dispatcher {
         if (schemeName === null || schemeName === "log")
             return null;
         const handler = this.#schemes.get(schemeName, workspaceId);
-        if (handler === undefined || typeof handler.kill === "function")
+        if (handler === undefined || ("kill" in handler && typeof handler.kill === "function"))
             return null;
         const edit = {
             op: "EDIT",
@@ -296,7 +299,8 @@ export default class Dispatcher {
         await this.#operationEvent(context, "settled", execution.result);
         return execution;
     }
-    // {§file-path-normalization} Authored operands, once, before internal fan-out.
+    // {§file-path-normalization} Authored operands, once, before internal fan-out: an absolute or home spelling
+    // whose canonical address reads differently — the key inside the root, the absolute path beyond it.
     async #noticeFilePaths({ statement, origin, workspaceId, workerId, loopId }) {
         if (origin !== "model" || isExecution(statement) || TurnDisposition.is(statement) || statement.op === "NOTE")
             return;
@@ -320,7 +324,7 @@ export default class Dispatcher {
             if (key === null)
                 continue;
             const address = renderTarget({ scheme: null, pathname: key }, root, target);
-            if (address?.startsWith("file://"))
+            if (address === null || address.startsWith("file://") || address === pathname)
                 continue;
             this.#notices.push(workspaceId, workerId, loopId, {
                 source: "scheme:file", kind: "path_normalized", level: "warn",
@@ -345,7 +349,9 @@ export default class Dispatcher {
         this.#loopSignal(context.loopId)?.throwIfAborted();
         const execution = await ResourceBindings.using(this.#schemes, this.#buildSchemeCtx(context), (ctx) => this.#dispatchOne(context, ctx, targetsResolved));
         let { result } = execution;
-        const edit = context.statement.op === "EDIT" ? context.statement : this.#scopedEntryEdits.get(context.statement);
+        const edit = context.statement.op === "EDIT"
+            ? context.statement
+            : context.statement.op === "KILL" ? this.#scopedEntryEdits.get(context.statement) : undefined;
         if (edit !== undefined) {
             // {§edit-batch-merges} — a proposal's apply result replaces the projected one; the
             // statement's merge facts ride every EDIT result, whichever route produced it.
@@ -358,13 +364,13 @@ export default class Dispatcher {
         // environment is the model's to retire, never the daemon's to drop.
         const distillation = Dispatcher.#distillationOf(context.statement);
         if (distillation !== null) {
-            const note = { op: "NOTE", aside: null, metadata: null, target: null, lineMarker: null, body: distillation, position: context.statement.position };
-            this.#distillations.set(note, context.statement.target.raw);
+            const note = { op: "NOTE", aside: null, metadata: null, target: null, lineMarker: null, body: distillation.body, position: context.statement.position };
+            this.#distillations.set(note, distillation.target);
             const noteContext = { ...context, statement: note, sequence: context.sequence + 1 };
             delete noteContext.fanout;
             delete noteContext.emissionIndex;
             await ResourceBindings.using(this.#schemes, this.#buildSchemeCtx(noteContext), (ctx) => this.#dispatchOne(noteContext, ctx));
-            result = Results.assert({ ...result, rowsWritten: (result.rowsWritten ?? 1) + 1 });
+            result = Results.assert({ ...result, rowsWritten: Results.rowsWritten(result) + 1 });
         }
         return { ...execution, result };
     }
@@ -380,9 +386,17 @@ export default class Dispatcher {
         return Results.failure("grammar:matcher", "unreadable-pattern", 400, unreadable.message, {}, { stage: "matcher", recovery: unreadable.recovery, retryable: false });
     }
     static #distillationOf(statement) {
-        if (statement.op !== "KILL" || schemeNameOf(statement.target) !== "log" || typeof statement.body !== "string")
+        if (statement.op !== "KILL" || statement.target === null || schemeNameOf(statement.target) !== "log" || typeof statement.body !== "string")
             return null;
-        return statement.body.trim() === "" ? null : statement.body;
+        return statement.body.trim() === "" ? null : { body: statement.body, target: statement.target.raw };
+    }
+    // {§bulk-resource-targeting} — the paths a FIND matched: each catalog item's, never a scope group's.
+    static #matchedPaths(results) {
+        const items = Array.isArray(results) ? results : [];
+        return items.flatMap((item) => {
+            const head = Array.isArray(item) ? item[0] : undefined;
+            return isRecord(head) && !("items" in head) && typeof head.path === "string" ? [head.path] : [];
+        });
     }
     static #globTarget(target) {
         if (target === null)
@@ -400,7 +414,7 @@ export default class Dispatcher {
         if (found.status >= 400)
             return { result: found };
         const paths = found.status < 300
-            ? (found.results ?? []).flatMap((item) => Array.isArray(item) && !("items" in item[0]) ? [item[0].path] : [])
+            ? Dispatcher.#matchedPaths(found.results)
             : [];
         const matched = typeof found.matchingPathCount === "number" ? found.matchingPathCount : paths.length;
         if (survey.lineMarker !== null && matched !== paths.length) {
@@ -419,7 +433,7 @@ export default class Dispatcher {
         if (statement.op === "COPY" || statement.op === "MOVE") {
             if (![statement.source, statement.destination].some(({ target }) => Dispatcher.#globTarget(target)))
                 return null;
-            let resolved = statement;
+            const resolved = { ...statement };
             for (const operand of ["source", "destination"]) {
                 const selection = statement[operand];
                 if (!Dispatcher.#globTarget(selection.target))
@@ -432,7 +446,7 @@ export default class Dispatcher {
                     return found;
                 if (found.targets.length !== 1)
                     return { result: Dispatcher.#failure("target-cardinality", 400, `${statement.op} ${operand} matched ${found.matched} resources; expected one.`, {}, { operand, matchingPathCount: found.matched, recovery: "Name one source and one destination per pair.", retryable: false }) };
-                resolved = { ...resolved, [operand]: { ...selection, target: found.targets[0] } };
+                resolved[operand] = { ...selection, target: found.targets[0] };
             }
             return { statements: [resolved] };
         }
@@ -471,7 +485,7 @@ export default class Dispatcher {
                 ...(context.fit === undefined ? {} : { fit: reserved(context.fit, admitted.length - index - 1) }),
             }, true);
             results.push(result);
-            rowsWritten += result.rowsWritten ?? 1;
+            rowsWritten += Results.rowsWritten(result);
             if (context.failOnOperationError && result.status >= 400 && !isContextReceipt(result))
                 break;
         }
@@ -486,6 +500,54 @@ export default class Dispatcher {
     }
     async #dispatchOne(context, schemeCtx, targetsResolved = false) {
         const { statement, workspaceId, workerId, loopId, turnId, sequence, origin, onDispatch, } = context;
+        const routed = await this.#route(context, schemeCtx, targetsResolved);
+        let { result } = routed;
+        const { resolved, curationPlan } = routed;
+        // Child dispatch includes persistence and proposal settlement; their failures are
+        // internal, not exceptions from a scheme handler.
+        if (resolved !== null)
+            return this.#dispatchSelection(context, resolved);
+        if (result === undefined)
+            throw new Error("Operation dispatch produced neither targets nor a result.");
+        result = await this.#fitResult(context, statement, result);
+        // {§configuration-repair-path}: decide admission before persisting a proposed row.
+        const admission = this.#proposalAdmission(statement, result, workspaceId, origin);
+        const { autoAccept } = admission;
+        result = admission.result;
+        // {§bulk-resource-targeting} — a row on behalf of a glob names the statement it came from.
+        if (context.fanout !== undefined) {
+            const attrs = isRecord(result.attrs) ? result.attrs : {};
+            result = { ...result, attrs: { ...attrs, fanout: context.fanout } };
+        }
+        // Persist log curation for forensics; packet rendering suppresses its
+        // successful receipts while the exact state effects remain durable.
+        // A running-worker READ arms this turn's blocking collect.
+        // {§join-blocking-collect}
+        const logEntryId = await this.#logWriter.writeLog({
+            statement,
+            emissionIndex: context.emissionIndex,
+            result,
+            workspaceId,
+            workerId,
+            loopId,
+            turnId,
+            sequence,
+            origin,
+            curationPlan,
+            modelCallId: null,
+        });
+        onDispatch?.(logEntryId);
+        // {§proposal-202-pauses} A 202 that proposes (a WAIT parks instead — #isProposal) settles in its own step.
+        if (Dispatcher.#isProposal(statement, result))
+            return this.#settleProposedRow(context, schemeCtx, result, logEntryId, autoAccept);
+        await this.#notifySettled(context, logEntryId);
+        return Dispatcher.#singleExecution(result);
+    }
+    // {§op-methods-op-dispatch} The operation's owner, by statement: a refusal first — an unwritable target, a denied
+    // capability, an unreadable matcher — then the one handler whose result is the row's, or the target selection a
+    // glob resolves to. A scheme handler's exception is the row's 500 ({§scheme-surface-exception-500}), never a throw.
+    async #route(context, schemeCtx, targetsResolved) {
+        const { statement, workspaceId, workerId, loopId, turnId, sequence, origin } = context;
         let result;
         let resolved = null;
         let curationPlan = null;
@@ -580,17 +642,15 @@ export default class Dispatcher {
                 }
             }
         }
-        // Child dispatch includes persistence and proposal settlement; their failures are
-        // internal, not exceptions from a scheme handler.
-        if (resolved !== null)
-            return this.#dispatchSelection(context, resolved);
-        if (result === undefined)
-            throw new Error("Operation dispatch produced neither targets nor a result.");
-        result = await this.#fitResult(context, statement, result);
-        // {§configuration-repair-path}: decide admission before persisting a proposed row.
+        return { result, resolved, curationPlan };
+    }
+    // {§configuration-repair-path} {§runtime-bookkeeping-policy} Whether a proposal settles itself under the effect
+    // policy, decided before its row is persisted: an execution or a runtime-scheme SEND must declare its effect, the
+    // runtime actor never grants itself authority, and a policy the configuration cannot read is the row's failure.
+    #proposalAdmission(statement, result, workspaceId, origin) {
         let autoAccept = false;
         if (Dispatcher.#isProposal(statement, result)) {
-            const effect = result.attrs?.effect;
+            const effect = isRecord(result.attrs) ? result.attrs.effect : undefined;
             const mustDeclareEffect = isExecution(statement) || (statement.op === "SEND"
                 && this.#schemes.isRuntimeScheme(schemeNameOf(statement.target) ?? "", workspaceId));
             if (mustDeclareEffect || effect !== undefined) {
@@ -608,80 +668,18 @@ export default class Dispatcher {
                 }
             }
         }
-        // {§bulk-resource-targeting} — a row on behalf of a glob names the statement it came from.
-        if (context.fanout !== undefined) {
-            const attrs = typeof result.attrs === "object" && result.attrs !== null ? result.attrs : {};
-            result = { ...result, attrs: { ...attrs, fanout: context.fanout } };
-        }
-        // Persist log curation for forensics; packet rendering suppresses its
-        // successful receipts while the exact state effects remain durable.
-        // A running-worker READ arms this turn's blocking collect.
-        // {§join-blocking-collect}
-        const logEntryId = await this.#logWriter.writeLog({
-            statement,
-            emissionIndex: context.emissionIndex,
-            result,
-            workspaceId,
-            workerId,
-            loopId,
-            turnId,
-            sequence,
-            origin,
-            curationPlan,
-            modelCallId: null,
-        });
-        onDispatch?.(logEntryId);
-        // Proposal lifecycle (SPEC.md {§engine-rails} + {§methods-proposal-resolve}; {§proposal-202-pauses}). When a
-        // 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,
-        // core-owned disposition, or timeout). The post-resolution status replaces 202 in the
-        // result the caller sees, so runTurn never branches on a pending state.
-        if (Dispatcher.#isProposal(statement, result)) {
-            if (autoAccept) {
-                await this.#proposals.recordDecision(logEntryId, { decision: "accept" });
-                const initialSettlement = await this.#proposals.workerApply(statement, result, { decision: "accept" }, { workspaceId, workerId, loopId, turnId, logEntryId, resources: schemeCtx.resources });
-                const effective = await this.#resourceMutations.settleProposal({
-                    statement,
-                    result,
-                    settlement: initialSettlement,
-                    ctx: schemeCtx,
-                    ids: { workspaceId, workerId, loopId, turnId, logEntryId },
-                });
-                const post = await this.#proposals.applyResolution(logEntryId, effective);
-                await this.#notifySettled(context, logEntryId);
-                return Dispatcher.#singleExecution(post);
-            }
-            // Register the resolution waiter SYNCHRONOUSLY before any await
-            // yields. A same-tick resolveProposal() (e.g. from a test that
-            // awaits the onDispatch callback and immediately resolves) must
-            // find the waiter registered — adding an await between insert
-            // and waiter-registration would open a race window.
-            // Core derives one validated projection from the durable row for both
-            // this live event and reconnect discovery ({§proposal-projection}). Its
-            // disposition is also the one automatic settlement decision: policy is
-            // not an observer and cannot silently degrade into client ownership.
-            let resolutionPromise;
-            try {
-                resolutionPromise = this.#proposals.awaitResolution(logEntryId, this.#loopSignal(loopId));
-                const event = await this.#proposals.pending(logEntryId);
-                if (event !== null) {
-                    this.#proposals.settleOwned(event);
-                    this.#proposals.notifyPending(event);
-                }
-            }
-            catch (cause) {
-                await this.#proposals.failPreparation(logEntryId, cause);
-                await this.#notifySettled(context, logEntryId);
-                throw cause;
-            }
-            const resolution = await resolutionPromise;
-            // Run the scheme's applyResolution hook on accept (writes the
-            // 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, logEntryId, resources: schemeCtx.resources });
+        return { autoAccept, result };
+    }
+    // Proposal lifecycle (SPEC.md {§engine-rails} + {§methods-proposal-resolve}; {§proposal-202-pauses}). A
+    // side-effecting op that returned 202 was written state='proposed'; an automatic acceptance applies at once,
+    // otherwise dispatch PAUSES on a per-entry waiter until resolution arrives via Engine.resolveProposal (a client
+    // resume, core-owned disposition, or timeout). The post-resolution status replaces 202 in the result the caller
+    // sees, so runTurn never branches on a pending state.
+    async #settleProposedRow(context, schemeCtx, result, logEntryId, autoAccept) {
+        const { statement, workspaceId, workerId, loopId, turnId } = context;
+        if (autoAccept) {
+            await this.#proposals.recordDecision(logEntryId, { decision: "accept" });
+            const initialSettlement = await this.#applyProposal(context, schemeCtx, result, { decision: "accept" }, logEntryId);
             const effective = await this.#resourceMutations.settleProposal({
                 statement,
                 result,
@@ -693,8 +691,45 @@ export default class Dispatcher {
             await this.#notifySettled(context, logEntryId);
             return Dispatcher.#singleExecution(post);
         }
+        // Register the resolution waiter SYNCHRONOUSLY before any await
+        // yields. A same-tick resolveProposal() (e.g. from a test that
+        // awaits the onDispatch callback and immediately resolves) must
+        // find the waiter registered — adding an await between insert
+        // and waiter-registration would open a race window.
+        // Core derives one validated projection from the durable row for both
+        // this live event and reconnect discovery ({§proposal-projection}). Its
+        // disposition is also the one automatic settlement decision: policy is
+        // not an observer and cannot silently degrade into client ownership.
+        let resolutionPromise;
+        try {
+            resolutionPromise = this.#proposals.awaitResolution(logEntryId, this.#loopSignal(loopId));
+            const event = await this.#proposals.pending(logEntryId);
+            if (event !== null) {
+                this.#proposals.settleOwned(event);
+                this.#proposals.notifyPending(event);
+            }
+        }
+        catch (cause) {
+            await this.#proposals.failPreparation(logEntryId, cause);
+            await this.#notifySettled(context, logEntryId);
+            throw cause;
+        }
+        const resolution = await resolutionPromise;
+        // Run the scheme's applyResolution hook on accept (writes the
+        // 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.#applyProposal(context, schemeCtx, result, resolution, logEntryId);
+        const effective = await this.#resourceMutations.settleProposal({
+            statement,
+            result,
+            settlement: initialSettlement,
+            ctx: schemeCtx,
+            ids: { workspaceId, workerId, loopId, turnId, logEntryId },
+        });
+        const post = await this.#proposals.applyResolution(logEntryId, effective);
         await this.#notifySettled(context, logEntryId);
-        return Dispatcher.#singleExecution(result);
+        return Dispatcher.#singleExecution(post);
     }
     // {§context-fit} — a result the model asked for arrives whole when it fits the remaining budget;
     // otherwise the row is its size and address — a READ of lines above the longest prefix of them that
@@ -710,15 +745,15 @@ export default class Dispatcher {
         const tokens = await this.#rowTokens(context, statement, result);
         if (tokens <= remaining)
             return result;
-        const size = resultSize(result);
-        const range = result.range;
+        const range = result.range === undefined ? undefined : Validator.assertRangeExtent(result.range);
+        const size = resultSize({ range, content: result.content });
         const retained = statement.op === "READ"
             ? { content: null, mimetype: null, channel: result.channel ?? null, ...(range === undefined ? {} : { range }) }
             : { ...(range === undefined ? {} : { range }), ...Object.fromEntries(["matchingPathCount", "matchLocationCount", "itemsWeightTotal"].flatMap((key) => key in result ? [[key, result[key]]] : [])) };
         const receipt = (delivered) => unfitResult(retained, size, tokens, remaining, statement.op, delivered);
         if (statement.op !== "READ" || size.unit !== "line")
             return receipt(0);
-        const whole = result;
+        const whole = { ...result, content: result.content };
         const withPrefix = (count) => {
             const prefix = resultPrefix(whole, count);
             const carried = Object.fromEntries(["content", "mimetype", "startLine", "lineAnchors", "lineNumberWidth", "lineOrdinals", "matches", "range"]
@@ -753,35 +788,81 @@ export default class Dispatcher {
         await context.onSettled?.(logEntryId);
         await this.#notify.operationSettledNotify?.(context.workspaceId, logEntryId);
     }
+    // {§actor-boundary-catalog-preview} Whether a survey selects anything: its FIND run through the scheme context and
+    // owner its dispatch would use, writing no row. A survey the FIND refuses counts as selecting, so its dispatch reports it.
+    async selects(survey, ids) {
+        const found = await ResourceBindings.using(this.#schemes, this.#buildSchemeCtx(ids), (ctx) => this.#dataRun.run(schemeNameOf(survey.target), survey, ctx));
+        return found.status >= 300 || !Array.isArray(found.results) || found.results.length > 0;
+    }
     capabilityProjection(workspaceId) {
         return this.#capabilities.projection(workspaceId);
     }
-    // Resolve the client selector through the owning scheme before persistence
-    // is consulted. Public schemes choose a semantic owner; core-owned authority
-    // schemes may return the already-authorized principal key.
-    async resolveEntryAddress(context) {
+    // {§client-entry-address} A client read acquires `target` as exact READ does, from the worker's perspective: the
+    // representation a core scheme computes, or a data entry. Only core's own acquisition runs for it: a core scheme's
+    // preparation, and the materialization of a message core retains, whichever module minted its address
+    // ({§message-source-scheme}); never an extension's. Null for a target no data or computing scheme claims.
+    async readClientEntry(context) {
         const { target, workspaceId, workerId } = context;
-        const coreCtx = this.#buildSchemeCtx({
-            workspaceId,
-            workerId,
-            loopId: 0,
-            turnId: 0,
-            origin: "client",
-        });
-        const resolved = await this.bindEntryAddress(target, coreCtx);
-        if (resolved === null)
-            return null;
-        if (resolved.address === null)
+        const routedScheme = schemeNameOf(target);
+        if (routedScheme === null)
             return null;
-        const rendered = resolved.address.scheme === "file"
-            ? entryAddress("file", "", resolved.address.pathname, await this.#workspaceRoot(workspaceId))
-            : renderAuthoredTarget({ ...target, fragment: null });
-        return {
-            scheme: resolved.address.scheme,
-            authority: resolved.address.authority,
-            pathname: resolved.address.pathname,
-            target: rendered,
-        };
+        const coreCtx = this.#buildSchemeCtx({ workspaceId, workerId, loopId: 0, turnId: 0, origin: "client" });
+        return ResourceBindings.using(this.#schemes, coreCtx, async (ctx) => {
+            try {
+                const binding = await ResourceBindings.resolve(target, ctx);
+                if (binding === undefined)
+                    return null;
+                const neutral = target.kind === "url"
+                    ? { ...target, raw: renderTarget({ ...target, fragment: null }) ?? target.raw, fragment: null }
+                    : target;
+                const computing = coreRepresentationProvider(binding.handler);
+                if (computing !== null) {
+                    const resolved = await computing.resolveCoreRepresentation(neutral, ctx);
+                    if ("result" in resolved)
+                        return resolved.result.status >= 400 ? { kind: "refused", result: resolved.result } : null;
+                    return { kind: "computed", target: resolved.identity ?? renderAuthoredTarget(neutral), channels: this.#computedChannels(resolved) };
+                }
+                if (binding.manifest.category !== "data")
+                    return null;
+                const handler = binding.handler;
+                const coreScheme = this.#schemes.coreOwns(routedScheme);
+                const resolved = coreScheme
+                    ? await this.#prepareDataRepresentation({ target, metadata: null, routedScheme, handler, manifest: binding.manifest, ctx, publishedChannel: null })
+                    : await this.#resolveDataEntryAddress({ target, routedScheme, handler, manifest: binding.manifest, ctx });
+                if (resolved.result !== null && resolved.result.status >= 400)
+                    return { kind: "refused", result: resolved.result };
+                if (resolved.address === null)
+                    return null;
+                if (!coreScheme) {
+                    const retained = await new DbMessageCaps(ctx, routedScheme).prepare(neutral.raw);
+                    if (retained.status >= 400 && retained.status !== 404)
+                        return { kind: "refused", result: retained };
+                }
+                const rendered = resolved.address.scheme === "file"
+                    ? entryAddress("file", "", resolved.address.pathname, await this.#workspaceRoot(workspaceId))
+                    : renderAuthoredTarget(neutral);
+                return { kind: "stored", address: {
+                        scheme: resolved.address.scheme,
+                        authority: resolved.address.authority,
+                        pathname: resolved.address.pathname,
+                        target: rendered,
+                    } };
+            }
+            catch (error) {
+                if (error instanceof OperationFailureError)
+                    return { kind: "refused", result: error.result };
+                throw error;
+            }
+        });
+    }
+    // {§client-entry-address} {§log-readable-projection} A computed representation's channels as a client reads them:
+    // deliberate trimming applied, each weighed as a stored channel is.
+    #computedChannels(resolved) {
+        return Object.fromEntries(Object.entries(resolved.representation.channels).map(([name, { content, mimetype, state }]) => {
+            const retained = resolved.visibleLines?.[name];
+            const visible = retained === undefined ? content : LineSelection.retain(content, retained).content;
+            return [name, { content: visible, mimetype, state, weight: visible.length === 0 ? 0 : this.#weighContent(visible) }];
+        }));
     }
     async bindEntryAddress(target, ctx) {
         const routedScheme = schemeNameOf(target);
@@ -905,6 +986,14 @@ export default class Dispatcher {
             defaultChannelFor: (scheme) => this.#schemes.defaultChannelFor(scheme, context.workspaceId),
             settleDerivations: () => this.#settleDerivations(context),
             pushNotice: (notice) => this.#notices.push(workspaceId, workerId, loopId, notice),
+            // {§membership-auto-add} — the model's reads reach the untracked universe and admit what they read.
+            ...(origin === "model" && this.#notify.admitMembers !== undefined && AmbientMembers.enabled() ? {
+                ambientMembers: AmbientMembers.seam({
+                    db: this.#db, workspaceId, signal: this.#loopSignal(loopId), mimetypes: this.#mimetypes,
+                    admit: (files) => this.#notify.admitMembers({ workspaceId, workerId }, files),
+                    notice: (notice) => this.#notices.push(workspaceId, workerId, loopId, notice),
+                }),
+            } : {}),
             requestInteraction: (request, signal = this.#loopSignal(loopId)) => this.#interactions.request(request, { workspaceId, workerId, loopId, turnId }, signal),
             executors: this.#executors(),
         };
@@ -1336,7 +1425,8 @@ export default class Dispatcher {
                 plan: null,
             };
         }
-        const handler = this.#schemes.get("log");
+        const registered = this.#schemes.get("log");
+        const handler = registered !== undefined && Dispatcher.#curates(registered) ? registered : undefined;
         const manifest = this.#schemes.manifestFor("log");
         if (handler === undefined || manifest === undefined) {
             throw new Error("the core log curation owner is not registered");
@@ -1352,6 +1442,26 @@ export default class Dispatcher {
         return { result: Results.assert(outcome.result), plan: outcome.plan };
     }
     // {§proposal}/{§send} — native dispositions park; other 202 results propose.
+    // {§proposal-accept-applies} — an accepted proposal runs its scheme's effect; an accepted admission
+    // ({§membership-auto-add}) admits the files the read reached and runs that read or find again, and the
+    // operation's own result is what the row records.
+    async #applyProposal(context, schemeCtx, result, resolution, logEntryId) {
+        const { statement, workspaceId, workerId, loopId, turnId } = context;
+        const admission = AmbientMembers.admissionOf(result);
+        if (admission === null || (statement.op !== "READ" && statement.op !== "FIND")) {
+            return this.#proposals.workerApply(statement, result, resolution, { workspaceId, workerId, loopId, turnId, logEntryId, resources: schemeCtx.resources });
+        }
+        if (resolution.decision !== "accept")
+            return { resolution };
+        // What the members scope refuses stays unadmitted, and the operation run again misses it as a non-member.
+        if (schemeCtx.ambientMembers !== undefined)
+            await schemeCtx.ambientMembers.admit(admission);
+        const rerun = await this.#fitResult(context, statement, await this.#dataRun.run(schemeNameOf(statement.target), statement, schemeCtx));
+        // {§proposal-projection} — the accepted row is composed from `resolution.result`: the operation's own
+        // payload rides there, and a failed run again is the applied result as it stands.
+        const { status: _status, problem: _problem, error: _error, ...payload } = rerun;
+        return { resolution: { ...resolution, result: payload }, applied: rerun };
+    }
     static #isProposal(statement, result) {
         if (result.status !== 202)
             return false;