@plurnk/plurnk-service 1.4.0 → 1.6.0

package/dist/schemes/Log.js

@@ -1,20 +1,20 @@
-import { PathSyntax, } from "@plurnk/plurnk-contracts";
-import { LineMarkerOps } from "../content/index.js";
-import { ReadResolve } from "../content/index.js";
+import { InvalidTagSignalError, PathSyntax, TagSignal, } from "@plurnk/plurnk-contracts";
 import Matcher from "../content/matcher.js";
-import { renderFindContent } from "./_entry-find.js";
+import { emptyFindFields, projectFindResult } from "./_entry-find.js";
 import { CoreSchemeAdapterBase } from "../core/CoreSchemeServices.js";
 import Results from "../core/results.js";
 import LogBody from "../core/LogBody.js";
+import LogEntryProjection from "../core/LogEntryProjection.js";
 import EntrySemantic from "./_entry-semantic.js";
 import EntryGraph from "./_entry-graph.js";
 import { resolveSearchCandidates } from "./_search-candidate.js";
 import { pathFolderSummaries, pathScope, pathScopeMatches } from "./_path-scope.js";
 // log:///<loop_seq>/<turn_seq>/<sequence>[/<op>] — the trailing /op segment
-// is wire-rendering self-documentation derived from the row's `op` field;
-// parsing accepts it (or omits it) and identifies the row by coordinate. The op
-// suffix is case-INSENSITIVE: model ops render UPPERCASE (READ/EDIT/FIND) but the
-// engine-minted rows are lowercase (`error`, `model`), and both are curatable.
+// is canonical model-facing identity derived from the row's projected `op`;
+// parsing accepts it (or omits it), but a supplied suffix must agree. The op
+// suffix is case-INSENSITIVE: model ops render UPPERCASE (READ/EDIT/FIND) while
+// engine-minted selectors such as `error` are lowercase. An actionless model
+// emission has no suffix at all.
 const COORDINATE = /^(\d+)\/(\d+)\/(\d+)(?:\/([A-Za-z]+))?$/;
 // {§log-coordinate-hierarchy} — a log coordinate is a HIERARCHICAL PREFIX: `1` selects loop 1's rows,
 // `1/2` turn 1/2's rows, `1/2/3` the one row. A full coordinate is always 3 parts, so a 1- or 2-part
@@ -42,18 +42,25 @@ const parseCoordinate = (pathname) => {
         loopSeq: Number(match[1]),
         turnSeq: Number(match[2]),
         sequence: Number(match[3]),
+        op: match[4] ?? null,
     };
 };
-const canonicalCoordinate = (coordinate) => coordinate.replace(/\/[A-Za-z]+$/, "");
 // A rendered log path appends `/OP` to the canonical loop/turn/item coordinate
-// as self-documentation. Selection honors both views: ordinary path globs map
+// as identity. Selection honors both views: ordinary path globs map
 // the three-level resource tree, while an explicit OP segment can still filter
 // rows (`log:///**/READ`).
-const coordinateScopeMatches = (scope, coordinate) => pathScopeMatches(scope, coordinate) || pathScopeMatches(scope, canonicalCoordinate(coordinate));
+const coordinateScopeMatches = (scope, coordinate) => pathScopeMatches(scope, coordinate) || pathScopeMatches(scope, LogEntryProjection.base(coordinate));
+const projectedCoordinateRows = (rows) => rows.map((row) => ({
+    ...row,
+    coordinate: LogEntryProjection.coordinate(row.coordinate, row),
+}));
+const coordinateCandidatePrefix = (prefix) => prefix === null
+    ? null
+    : LogEntryProjection.base(prefix);
 export default class Log extends CoreSchemeAdapterBase {
     static manifest = {
         name: "log",
-        channels: {}, // logs render through read(), not channel storage
+        channels: {},
         defaultChannel: "",
         category: "logging",
         // Log KILL is model-authorized curation. Other mutations remain unavailable
@@ -62,27 +69,21 @@ export default class Log extends CoreSchemeAdapterBase {
         volatile: false,
         modelVisible: true,
         folderScopes: true,
-        example: "<<READ(log:///1/2/3)::READ",
+        example: "## READ0 (log:///1/2/3)",
     };
-    async read(statement, ctx) {
+    async resolveCoreRepresentation(target, ctx) {
         const core = this.coreContext(ctx);
         const { db, workerId } = core;
-        const failure = (code, status, detail, extensions = {}) => Results.failure("scheme:log", code, status, detail, { content: null, mimetype: null }, extensions);
-        if (statement.target === null) {
+        const failure = (code, status, detail, extensions = {}) => ({
+            result: Results.failure("scheme:log", code, status, detail, { content: null, mimetype: null, channel: null }, extensions),
+        });
+        if (target === null) {
             return failure("read-target-required", 400, "READ requires a log coordinate.", {
                 recovery: "Provide one exact log coordinate.",
                 retryable: false,
             });
         }
-        // READ is exact — one coordinate, one row. Tag recall is OPEN[tag]/FIND[tag]'s job ({§log-region-tagging}),
-        // not a filter on a single-row read.
-        if (Array.isArray(statement.signal) && statement.signal.length > 0) {
-            return failure("tagged-coordinate-not-found", 404, "The exact log row does not carry every requested tag.", {
-                recovery: "Remove the tag filter or use a log row carrying those tags.",
-                retryable: false,
-            });
-        }
-        const pathname = (statement.target.kind === "url" ? statement.target.pathname : statement.target.raw).replace(/^\//, "");
+        const pathname = (target.kind === "url" ? target.pathname : target.raw).replace(/^\//, "");
         const coord = parseCoordinate(pathname);
         if (coord === null) {
             return failure("coordinate-malformed", 400, `The log coordinate '${pathname}' is malformed.`, {
@@ -94,67 +95,45 @@ export default class Log extends CoreSchemeAdapterBase {
         const row = await db.log_read_by_coordinate.get({ worker_id: workerId, loop_seq: coord.loopSeq, turn_seq: coord.turnSeq, sequence: coord.sequence });
         if (row === undefined)
             return failure("entry-not-found", 404, `No log entry exists at log:///${pathname}.`);
+        if (!LogEntryProjection.accepts(coord.op, row)) {
+            return failure("entry-not-found", 404, `No log entry exists at log:///${pathname}.`);
+        }
         const { content: underlyingContent, mimetype: underlyingMimetype } = LogBody.resolve({
             op: row.op,
+            attrs: row.attrs,
             tx: row.tx,
             rx: row.rx,
             mimetypeTx: row.mimetype_tx,
             mimetypeRx: row.mimetype_rx,
         });
-        const resolved = await ReadResolve.resolve({
-            content: underlyingContent,
-            mimetype: underlyingMimetype,
-            lineMarker: statement.lineMarker,
-            body: statement.body,
-            mimetypes: core.mimetypes,
-        });
-        if (resolved.status >= 400) {
-            if (resolved.problem !== undefined) {
-                return Results.assert({
-                    ...resolved,
-                    content: null,
-                    mimetype: null,
-                });
-            }
-            if (resolved.reason === undefined) {
-                throw new Error(`Log.read: ReadResolve returned status ${resolved.status} without Problem Details or a diagnostic`);
-            }
-            return failure(resolved.status === 416
-                ? "range-not-satisfiable"
-                : resolved.status === 501
-                    ? "matcher-unavailable"
-                    : "read-resolution-failed", resolved.status, resolved.reason, {
-                ...(resolved.range === undefined ? {} : { range: resolved.range, stage: "projection" }),
-                ...(statement.body === null || resolved.status === 416
-                    ? {}
-                    : {
-                        stage: "matcher",
-                        dialect: statement.body.dialect,
-                        recovery: resolved.status === 501
-                            ? "Retry the READ without a content matcher."
-                            : "Correct or remove the matcher.",
-                        retryable: false,
-                    }),
-            });
-        }
-        return { ...resolved };
+        return {
+            representation: {
+                channels: {
+                    "": {
+                        content: underlyingContent,
+                        mimetype: underlyingMimetype,
+                        state: "static",
+                    },
+                },
+            },
+        };
     }
     // {§log-uniform-query} — FIND over the worker's log rows, on the SAME source-agnostic primitive
     // every entry scheme runs (Matcher.matchCandidates, {§find-source-agnostic}): candidates are the
     // coordinate-scoped rows resolved by LogBody exactly as READ shows them, so every content
-    // dialect works on log BY CONSTRUCTION and FIND(log)->READ(coordinate) composes like any scheme.
+    // dialect works on log BY CONSTRUCTION and log FIND -> coordinate READ composes like any scheme.
     async find(statement, ctx) {
-        return this.#find(statement, this.coreContext(ctx), true);
+        return this.#find(statement, this.coreContext(ctx));
     }
-    async #find(statement, core, enforceRenderBudget, allowTargetless = false) {
+    async #find(statement, core, allowTargetless = false, filterTags = []) {
         const { db, workerId, mimetypes } = core;
         const empty = (status, detail, extensions = {}) => {
-            const fields = { content: null, mimetype: null, results: [], itemsTokenTotal: 0, pathnames: [], matches: [] };
+            const fields = emptyFindFields();
             if (status >= 400 && detail === undefined) {
                 throw new Error(`Log.find: selection returned status ${status} without Problem Details or a diagnostic`);
             }
             return status >= 400
-                ? Results.failure("scheme:log", status === 416 ? "range-not-satisfiable" : status === 501 ? "matcher-not-implemented" : "find-failed", status, detail, fields, extensions)
+                ? Results.failure("scheme:log", status === 404 ? "entry-not-found" : status === 416 ? "range-not-satisfiable" : status === 501 ? "matcher-not-implemented" : "find-failed", status, detail, fields, extensions)
                 : { status, ...fields };
         };
         if (statement.target === null && !allowTargetless) {
@@ -175,12 +154,18 @@ export default class Log extends CoreSchemeAdapterBase {
             });
         }
         const scope = pathScope(glob, false);
-        // {§log-region-tagging} — a tag signal AND-filters the candidates ({§find-tag-filter-and-semantics}):
-        // a row survives only if it carries EVERY listed tag. No signal → the plain coordinate scope.
-        const tags = Array.isArray(statement.signal) ? statement.signal : [];
-        const candidateRows = tags.length > 0
-            ? await db.log_find_candidates_tagged.all({ worker_id: workerId, scope_prefix: scope.candidatePrefix, tags: JSON.stringify(tags) })
-            : await db.log_find_candidates.all({ worker_id: workerId, scope_prefix: scope.candidatePrefix });
+        if (scope.kind === "exact") {
+            const coordinate = parseCoordinate(scope.pathname);
+            if (coordinate === null)
+                throw new Error(`Exact log scope has a malformed coordinate ${JSON.stringify(scope.pathname)}`);
+            if (await this.#resolveExactId(coordinate, core) === null) {
+                return empty(404, `No log entry exists at ${statement.target?.raw ?? `log:///${scope.pathname}`}.`, { target: statement.target?.raw ?? `log:///${scope.pathname}` });
+            }
+        }
+        const storedCandidateRows = filterTags.length > 0
+            ? await db.log_curation_find_candidates_tagged.all({ worker_id: workerId, scope_prefix: coordinateCandidatePrefix(scope.candidatePrefix), tags: JSON.stringify(filterTags) })
+            : await db.log_find_candidates.all({ worker_id: workerId, scope_prefix: coordinateCandidatePrefix(scope.candidatePrefix) });
+        const candidateRows = projectedCoordinateRows(storedCandidateRows);
         let rows;
         try {
             rows = candidateRows.filter((row) => coordinateScopeMatches(scope, row.coordinate));
@@ -192,12 +177,13 @@ export default class Log extends CoreSchemeAdapterBase {
                 retryable: false,
             });
         }
-        const candidateByCanonicalCoord = new Map(candidateRows.map((row) => [canonicalCoordinate(row.coordinate), row]));
+        const candidateByCanonicalCoord = new Map(candidateRows.map((row) => [LogEntryProjection.base(row.coordinate), row]));
         const byCoord = new Map(rows.map((r) => [r.coordinate, r]));
         const projected = rows.map((r) => ({
             key: r.coordinate,
             ...LogBody.resolve({
                 op: r.op,
+                attrs: r.attrs,
                 tx: r.tx,
                 rx: r.rx,
                 mimetypeTx: r.mimetype_tx,
@@ -234,26 +220,7 @@ export default class Log extends CoreSchemeAdapterBase {
                     retryable: false,
                 });
             }
-            let selected = ranked.results;
-            if (selection.page !== null) {
-                const page = LineMarkerOps.page(selected, selection.page);
-                if (page.status !== 200) {
-                    if (page.problem === undefined)
-                        throw new Error("Log semantic FIND pagination failed without Problem Details");
-                    return Results.assert({
-                        status: page.status,
-                        problem: page.problem,
-                        content: null,
-                        mimetype: null,
-                        results: [],
-                        itemsTokenTotal: 0,
-                        pathnames: [],
-                        matches: [],
-                    });
-                }
-                selected = page.items ?? [];
-            }
-            const sourceMatches = selected.map(({ key, lineStart, lineEnd }) => ({
+            const sourceMatches = ranked.results.map(({ key, lineStart, lineEnd }) => ({
                 key,
                 span: { lineStart, lineEnd },
             }));
@@ -269,7 +236,7 @@ export default class Log extends CoreSchemeAdapterBase {
                     recovery: "Wait for search indexing to complete before repeating the search.",
                     retryable: false,
                 });
-            const universeRows = await db.log_find_candidates.all({ worker_id: workerId, scope_prefix: null });
+            const universeRows = projectedCoordinateRows(await db.log_find_candidates.all({ worker_id: workerId, scope_prefix: null }));
             const universe = resolveSearchCandidates(universeRows.map(({ coordinate, deep_hash }) => ({ key: coordinate, deepHash: deep_hash })));
             if (universe.state === "incomplete")
                 return empty(503, `The persistent search index covers ${universe.indexed} of ${universe.total} log results in the relationship universe.`, {
@@ -313,43 +280,15 @@ export default class Log extends CoreSchemeAdapterBase {
                 return Results.assert({
                     status: r.status,
                     problem: r.problem,
-                    content: null,
-                    mimetype: null,
-                    results: [],
-                    itemsTokenTotal: 0,
-                    pathnames: [],
-                    matches: [],
+                    ...emptyFindFields(),
                 });
             }
             matches = r.matches.map(({ key, matches: ranges }) => ({ pathname: key, matches: ranges }));
         }
         const folderSummaries = statement.body === null
-            ? pathFolderSummaries(scope, candidateRows.map((row) => canonicalCoordinate(row.coordinate)))
+            ? pathFolderSummaries(scope, candidateRows.map((row) => LogEntryProjection.base(row.coordinate)))
             : [];
-        if (statement.lineMarker !== null && statement.body?.dialect !== "semantic" && folderSummaries.length === 0) {
-            const page = LineMarkerOps.page(matches, statement.lineMarker);
-            if (page.status !== 200) {
-                if (page.problem === undefined)
-                    throw new Error("Log FIND pagination failed without Problem Details");
-                return Results.assert({
-                    status: page.status,
-                    problem: page.problem,
-                    content: null,
-                    mimetype: null,
-                    results: [],
-                    itemsTokenTotal: 0,
-                    pathnames: [],
-                    matches: [],
-                });
-            }
-            matches = page.items ?? [];
-        }
-        // The result rows mirror the catalog-row shape: one item per selected
-        // resource, with optional match coordinates for a surgical READ.
-        let results = [];
-        const seenPath = [];
-        const seen = new Set();
-        let itemsTokenTotal = 0;
+        const resources = [];
         for (const m of matches) {
             const row = byCoord.get(m.pathname);
             if (row === undefined)
@@ -357,22 +296,28 @@ export default class Log extends CoreSchemeAdapterBase {
             const path = `log:///${m.pathname}`;
             const proj = LogBody.resolve({
                 op: row.op,
+                attrs: row.attrs,
                 tx: row.tx,
                 rx: row.rx,
                 mimetypeTx: row.mimetype_tx,
                 mimetypeRx: row.mimetype_rx,
             });
-            const item = {
+            const channel = {
                 path,
-                channels: { [path]: { mimetype: proj.mimetype, tokens: row.tokens, lines: proj.content.length === 0 ? 0 : proj.content.split("\n").length } },
+                mimetype: proj.mimetype,
+                tokens: row.tokens,
+                lines: proj.content.length === 0 ? 0 : proj.content.split("\n").length,
             };
-            results.push(m.matches.length > 0 ? { ...item, matches: m.matches } : item);
-            if (!seen.has(m.pathname)) {
-                seen.add(m.pathname);
-                seenPath.push(m.pathname);
-                itemsTokenTotal += row.tokens;
+            const storedTags = JSON.parse(row.tags);
+            if (!Array.isArray(storedTags) || !storedTags.every((tag) => typeof tag === "string" && tag.length > 0)) {
+                throw new TypeError(`Log row ${m.pathname} contains invalid tag storage.`);
             }
+            if (storedTags.length > 0)
+                channel.tags = storedTags;
+            const item = [channel];
+            resources.push({ item, match: m });
         }
+        const scopes = [];
         for (const folder of folderSummaries) {
             const members = folder.pathnames.map((coordinate) => candidateByCanonicalCoord.get(coordinate)).filter((row) => row !== undefined);
             const item = {
@@ -380,83 +325,56 @@ export default class Log extends CoreSchemeAdapterBase {
                 items: members.length,
                 tokens: members.reduce((sum, row) => sum + row.tokens, 0),
             };
-            results.push(item);
-            itemsTokenTotal += item.tokens;
+            scopes.push(item);
         }
-        if (folderSummaries.length > 0) {
-            results.sort((a, b) => a.path.localeCompare(b.path));
-            if (statement.lineMarker !== null) {
-                const page = LineMarkerOps.page(results, statement.lineMarker);
-                if (page.status !== 200) {
-                    if (page.problem === undefined)
-                        throw new Error("Log FIND pagination failed without Problem Details");
-                    return Results.assert({
-                        status: page.status,
-                        problem: page.problem,
-                        content: null,
-                        mimetype: null,
-                        results: [],
-                        itemsTokenTotal: 0,
-                        pathnames: [],
-                        matches: [],
-                    });
-                }
-                results = page.items ?? [];
-                const retained = new Set(results.filter((item) => item.items === undefined).map((item) => item.path.replace(/^log:\/\/\//, "").replace(/^\//, "")));
-                matches = matches.filter((match) => retained.has(match.pathname));
-                seenPath.splice(0, seenPath.length, ...matches.map((match) => match.pathname).filter((coordinate, i, all) => all.indexOf(coordinate) === i));
-                itemsTokenTotal = results.reduce((sum, item) => sum + (item.items === undefined
-                    ? Object.values(item.channels).reduce((channelSum, channel) => channelSum + channel.tokens, 0)
-                    : item.tokens ?? 0), 0);
-            }
-        }
-        if (results.length === 0)
-            return empty(204);
-        // {§find-count-not-contents} is source-agnostic. Count the rendered
-        // catalog items; a shallow map's folder summaries replace, rather than
-        // conceal, their descendants.
-        const budget = Number.parseInt(process.env.PLURNK_SERVICE_FIND_MAX_MATCHES ?? "0", 10);
-        if (enforceRenderBudget && budget > 0 && results.length > budget) {
-            const noun = results.some((item) => item.items !== undefined) ? "catalog items" : "entries";
-            return {
-                status: 200,
-                content: `${results.length} ${noun} match, exceeding the render budget (${budget}) — not enumerated.`,
-                mimetype: "text/markdown",
-                results: [],
-                itemsTokenTotal,
-                pathnames: [],
-                matches: [],
-                omittedItems: results.length,
-                maximumItems: budget,
-            };
-        }
-        // matches[].pathname is the fan-out's retarget key — `/loop/turn/seq/OP` re-parses as a
-        // coordinate (the /OP suffix is accepted), so READ(log://)<matcher> fan-out delivers rows.
-        const fanMatches = matches.map((m) => ({ ...m, pathname: `/${m.pathname}` }));
-        return { status: 200, content: renderFindContent(results), mimetype: "application/json", results, itemsTokenTotal, pathnames: seenPath.map((p) => `/${p}`), matches: fanMatches };
+        return projectFindResult(statement, scope, resources, scopes);
     }
     async open(statement, ctx) {
-        return this.#setExpanded(statement, this.coreContext(ctx), 1);
+        const core = this.coreContext(ctx);
+        const outcome = await this.#planCuration(statement, core, 1);
+        if (outcome.plan !== null)
+            await this.#applyDirect(outcome.plan, core);
+        return outcome.result;
     }
     // FOLD toggles the expanded bit only — an active subscription stays alive. {§subscriptions-fold-keeps-subscription}
     async fold(statement, ctx) {
-        return this.#setExpanded(statement, this.coreContext(ctx), 0);
+        const core = this.coreContext(ctx);
+        const outcome = await this.#planCuration(statement, core, 0);
+        if (outcome.plan !== null)
+            await this.#applyDirect(outcome.plan, core);
+        return outcome.result;
+    }
+    // Core dispatch retains the exact landed effect beside the suppressed
+    // OPEN/FOLD event. Direct scheme callers receive the ordinary result above.
+    async curate(statement, ctx) {
+        return this.#planCuration(statement, this.coreContext(ctx), statement.op === "OPEN" ? 1 : 0);
     }
     // Resolve a log:/// target — a concrete coordinate or path-glob — to the matched row ids.
     // OPEN/FOLD/KILL share this one path selection; log curation has no positional pagination.
+    async #resolveExactId(coordinate, ctx) {
+        const row = await ctx.db.log_id_by_coordinate.get({
+            worker_id: ctx.workerId,
+            loop_seq: coordinate.loopSeq,
+            turn_seq: coordinate.turnSeq,
+            sequence: coordinate.sequence,
+        });
+        return row !== undefined && LogEntryProjection.accepts(coordinate.op, row) ? row.id : null;
+    }
     async #resolveIds(pathname, ctx) {
         const { db, workerId } = ctx;
         const coord = parseCoordinate(pathname);
         if (coord !== null) {
-            const row = await db.log_id_by_coordinate.get({ worker_id: workerId, loop_seq: coord.loopSeq, turn_seq: coord.turnSeq, sequence: coord.sequence });
-            return row === undefined ? { status: 404, ids: [] } : { status: 200, ids: [row.id] };
+            const id = await this.#resolveExactId(coord, ctx);
+            return id === null
+                ? { status: 404, ids: [] }
+                : { status: 200, ids: [id] };
         }
         // {§log-coordinate-hierarchy} — one resolution for every consumer (curation here, find below).
         const glob = coordinateGlob(pathname);
         if (glob === null)
             return { status: 400, ids: [], error: `The log target '${pathname}' is malformed.` };
         const scope = pathScope(glob, false);
-        const candidates = await db.log_match_coordinates.all({ worker_id: workerId, scope_prefix: scope.candidatePrefix });
+        const candidates = projectedCoordinateRows(await db.log_match_coordinates.all({ worker_id: workerId, scope_prefix: coordinateCandidatePrefix(scope.candidatePrefix) }));
         let matched;
         try {
             matched = candidates.filter((row) => coordinateScopeMatches(scope, row.coordinate));
@@ -470,8 +388,8 @@ export default class Log extends CoreSchemeAdapterBase {
             return { status: 204, ids: [] };
         return { status: 200, ids: matched.map((row) => row.id) };
     }
-    // {§log-region-tagging} — resolve OPEN[tag] to ids: candidates are the target's glob scope (the
-    // whole worker log when targetless — a bare OPEN[tag] recalls the entire tagged working-set),
+    // {§log-item-tags} — resolve tagged OPEN/FOLD to ids: candidates are the target's glob scope (the
+    // whole worker log when targetless),
     // AND-filtered to rows carrying EVERY listed tag. Zero matches is a no-op success (204), mirroring
     // #resolveIds — recalling a name that tags nothing steers nothing.
     async #resolveByTags(statement, tags, ctx) {
@@ -480,12 +398,16 @@ export default class Log extends CoreSchemeAdapterBase {
         const glob = coordinateGlob(pathname);
         if (glob === null)
             return { status: 400, ids: [], error: `The log target '${pathname}' is malformed.` };
+        const coordinate = parseCoordinate(pathname);
+        if (coordinate !== null && await this.#resolveExactId(coordinate, ctx) === null) {
+            return { status: 404, ids: [] };
+        }
         const scope = pathScope(glob, false);
-        const candidates = await db.log_match_coordinates_tagged.all({
+        const candidates = projectedCoordinateRows(await db.log_match_coordinates_tagged.all({
             worker_id: workerId,
-            scope_prefix: scope.candidatePrefix,
+            scope_prefix: coordinateCandidatePrefix(scope.candidatePrefix),
             tags: JSON.stringify(tags),
-        });
+        }));
         let matched;
         try {
             matched = candidates.filter((row) => coordinateScopeMatches(scope, row.coordinate));
@@ -498,100 +420,145 @@ export default class Log extends CoreSchemeAdapterBase {
         return { status: 200, ids: matched.map((row) => row.id) };
     }
     // A matcher-bearing curation op reuses FIND's complete source-agnostic selector with
-    // rendering disabled. OPEN's tags filter candidates; FOLD's tags are withheld until
-    // after selection because they apply to the rows being folded.
+    // explicit all-results pagination. Curation tags are an independent selector;
+    // an authored FIND signal classifies its result row and never enters candidate selection.
     async #resolveByMatcher(statement, filterTags, ctx) {
         const selected = await this.#find({
             ...statement,
             op: "FIND",
-            signal: filterTags ? statement.signal : null,
-            lineMarker: null,
-        }, ctx, false, filterTags && Array.isArray(statement.signal) && statement.signal.length > 0 && statement.target === null);
+            signal: null,
+            lineMarker: { marks: [1, -1] },
+        }, ctx, true, filterTags);
         if (selected.status !== 200)
             return { status: selected.status, ids: [], problem: selected.problem };
+        let selectedPaths = selected.results.flatMap((item) => Array.isArray(item) && typeof item[0]?.path === "string"
+            ? [item[0].path]
+            : []);
+        if (selectedPaths.length === 0) {
+            if (statement.target === null) {
+                throw new Error("A successful broad log matcher selection returned no resource paths");
+            }
+            const pathname = (statement.target.kind === "url" ? statement.target.pathname : statement.target.raw).replace(/^\//, "");
+            const glob = coordinateGlob(pathname);
+            if (glob === null)
+                throw new Error(`Log matcher selected malformed target ${JSON.stringify(pathname)}`);
+            const scope = pathScope(glob, false);
+            if (scope.kind !== "exact") {
+                throw new Error("A successful broad log matcher selection returned no resource paths");
+            }
+            selectedPaths = [scope.pathname];
+        }
         const ids = [];
-        for (const { pathname } of selected.matches) {
-            const coordinate = parseCoordinate(pathname.replace(/^\//, ""));
+        for (const pathname of selectedPaths) {
+            const coordinate = parseCoordinate(pathname.replace(/^log:\/\/\//, "").replace(/^\//, ""));
             if (coordinate === null)
                 throw new Error(`Log matcher selected malformed coordinate '${pathname}'`);
-            const row = await ctx.db.log_id_by_coordinate.get({
-                worker_id: ctx.workerId,
-                loop_seq: coordinate.loopSeq,
-                turn_seq: coordinate.turnSeq,
-                sequence: coordinate.sequence,
-            });
-            if (row === undefined)
+            const id = await this.#resolveExactId(coordinate, ctx);
+            if (id === null)
                 return { status: 404, ids: [] };
-            ids.push(row.id);
+            ids.push(id);
         }
         return ids.length === 0 ? { status: 204, ids: [] } : { status: 200, ids };
     }
-    async #applyExpanded(ids, expanded, tags, ctx) {
-        for (const id of ids)
-            await ctx.db.log_set_expanded_by_id.run({ id, expanded });
-        if (expanded === 0) {
-            for (const id of ids)
-                for (const tag of tags)
-                    await ctx.db.log_write_tag.run({ log_entry_id: id, tag });
+    async #applyDirect(plan, ctx) {
+        for (const id of plan.targetLogEntryIds) {
+            await ctx.db.log_set_expanded_by_id.run({ id, expanded: plan.expanded });
+            for (const tag of plan.remove)
+                await ctx.db.log_remove_tag.run({ log_entry_id: id, tag });
+            for (const tag of plan.add)
+                await ctx.db.log_write_tag.run({ log_entry_id: id, tag });
         }
-        return { status: 200, matched: ids.length };
     }
-    async #setExpanded(statement, ctx, expanded) {
-        const signal = Array.isArray(statement.signal) ? statement.signal : [];
+    async #planCuration(statement, ctx, expanded) {
+        let tags;
+        try {
+            tags = TagSignal.curation(statement.signal);
+        }
+        catch (cause) {
+            if (!(cause instanceof InvalidTagSignalError))
+                throw cause;
+            return {
+                result: Results.failure("scheme:log", "tag-signal-invalid", 400, cause.message, {}, { retryable: false }),
+                plan: null,
+            };
+        }
+        const planned = (ids) => ({
+            result: { status: 200, matched: ids.length },
+            plan: {
+                targetLogEntryIds: ids,
+                expanded,
+                add: tags.add,
+                remove: tags.remove,
+            },
+        });
         if (statement.body !== null) {
-            const matched = await this.#resolveByMatcher(statement, expanded === 1, ctx);
+            const matched = await this.#resolveByMatcher(statement, tags.filter, ctx);
             if (matched.status === 204)
-                return { status: 204, matched: 0 };
+                return { result: { status: 204, matched: 0 }, plan: null };
             if (matched.status !== 200) {
                 if (matched.problem !== undefined) {
-                    return Results.assert({ status: matched.status, problem: matched.problem });
+                    return {
+                        result: Results.assert({ status: matched.status, problem: matched.problem }),
+                        plan: null,
+                    };
                 }
-                return Results.failure("scheme:log", matched.status === 404 ? "entry-not-found" : "curation-failed", matched.status, "No log entry matches the requested selection.");
+                return {
+                    result: Results.failure("scheme:log", matched.status === 404 ? "entry-not-found" : "curation-failed", matched.status, "No log entry matches the requested selection."),
+                    plan: null,
+                };
             }
-            return this.#applyExpanded(matched.ids, expanded, signal, ctx);
+            return planned(matched.ids);
         }
-        // {§log-region-tagging} — OPEN[tag] is the READ side: recall rows by tag, target optional (a bare
-        // OPEN[tag] recalls the whole tagged working-set). FOLD never resolves by tag — it is the WRITE
-        // side (it stamps the tag below), always scoped to the target region it folds.
-        if (expanded === 1 && signal.length > 0) {
-            const rt = await this.#resolveByTags(statement, signal, ctx);
-            if (rt.status === 204)
-                return { status: 204, matched: 0 };
-            if (rt.status !== 200) {
-                return Results.failure("scheme:log", "open-failed", rt.status, rt.error ?? "No log entry matches the requested selection.", {}, {
-                    target: statement.target?.raw ?? null,
-                    ...(rt.status === 400
-                        ? {
-                            recovery: "Use a log coordinate, prefix, or glob.",
-                            retryable: false,
-                        }
-                        : {}),
-                });
+        // {§log-item-tags} — unsigned terms are the symmetric ALL-tags selector;
+        // signed terms are changes applied only after the exact set is resolved.
+        if (tags.filter.length > 0) {
+            const selected = await this.#resolveByTags(statement, [...tags.filter], ctx);
+            if (selected.status === 204)
+                return { result: { status: 204, matched: 0 }, plan: null };
+            if (selected.status !== 200) {
+                return {
+                    result: Results.failure("scheme:log", "curation-failed", selected.status, selected.error ?? "No log entry matches the requested selection.", {}, {
+                        target: statement.target?.raw ?? null,
+                        ...(selected.status === 400
+                            ? {
+                                recovery: "Use a log coordinate, prefix, or glob.",
+                                retryable: false,
+                            }
+                            : {}),
+                    }),
+                    plan: null,
+                };
             }
-            return this.#applyExpanded(rt.ids, 1, signal, ctx);
+            return planned(selected.ids);
         }
         if (statement.target === null) {
-            return Results.failure("scheme:log", "target-required", 400, `${expanded === 1 ? "OPEN" : "FOLD"} requires a log target.`, {}, {
-                recovery: "Provide a log coordinate, prefix, or glob.",
-                retryable: false,
-            });
+            return {
+                result: Results.failure("scheme:log", "target-required", 400, `${expanded === 1 ? "OPEN" : "FOLD"} requires a path, body pattern, or unsigned tag; signed tags do not select log items.`, {}, {
+                    recovery: "Provide a log coordinate, prefix, glob, body pattern, or unsigned tag.",
+                    retryable: false,
+                }),
+                plan: null,
+            };
         }
         const pathname = (statement.target.kind === "url" ? statement.target.pathname : statement.target.raw).replace(/^\//, "");
-        const r = await this.#resolveIds(pathname, ctx);
-        if (r.status === 204)
-            return { status: 204, matched: 0 };
-        if (r.status !== 200) {
-            return Results.failure("scheme:log", r.status === 404 ? "entry-not-found" : "curation-failed", r.status, r.error ?? `No log entry matches '${pathname}'.`, {}, {
-                target: pathname,
-                ...(r.status === 400
-                    ? {
-                        recovery: "Use a log coordinate, prefix, or glob.",
-                        retryable: false,
-                    }
-                    : {}),
-            });
+        const selected = await this.#resolveIds(pathname, ctx);
+        if (selected.status === 204)
+            return { result: { status: 204, matched: 0 }, plan: null };
+        if (selected.status !== 200) {
+            return {
+                result: Results.failure("scheme:log", selected.status === 404 ? "entry-not-found" : "curation-failed", selected.status, selected.error ?? `No log entry matches '${pathname}'.`, {}, {
+                    target: pathname,
+                    ...(selected.status === 400
+                        ? {
+                            recovery: "Use a log coordinate, prefix, or glob.",
+                            retryable: false,
+                        }
+                        : {}),
+                }),
+                plan: null,
+            };
         }
-        return this.#applyExpanded(r.ids, expanded, signal, ctx);
+        return planned(selected.ids);
     }
     // KILL shares OPEN/FOLD's address resolution, deletes instead of flipping visibility,
     // and carries no positional scope. {§model-entry-log-curation} {§log-curation-set-selection}