@plurnk/plurnk-service 1.3.12 → 1.5.0

package/dist/schemes/Log.js

@@ -1,46 +1,35 @@
-import { LineMarkerOps } from "../content/index.js";
-import { ReadResolve } from "../content/index.js";
+import { PathSyntax, } from "@plurnk/plurnk-contracts";
 import Matcher from "../content/matcher.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 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 those are curatable too —
-// a `[A-Z]+`-only suffix silently rejected FOLD(log:///1/6/2/error), so the model
-// could not reclaim budget by folding its own error rows and spiralled to 413 (jumbo).
+// 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,
+// {§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
 // path is unambiguously a prefix — the trailing slash is OPTIONAL (`log:///1/2` ≡ `log:///1/2/`).
 const PARTIAL_COORDINATE = /^\d+(?:\/\d+)?\/?$/;
-// The ONE content projection of a stored rx — what READ shows and therefore what FIND matches
-// (§find-source-agnostic: the matcher must see exactly the content the model can retrieve).
-// rx.content (with its own mimetype) when the op produced a body; the rx itself as compact JSON
-// otherwise (EDIT/SEND acks — inspectable, matchable); the raw string if the rx isn't JSON.
-const rxProjection = (rawRx) => {
-    try {
-        const rx = JSON.parse(rawRx);
-        if (typeof rx.content === "string") {
-            return { content: rx.content, mimetype: typeof rx.mimetype === "string" ? rx.mimetype : "text/plain" };
-        }
-        return { content: JSON.stringify(rx), mimetype: "application/json" };
-    }
-    catch {
-        return { content: rawRx, mimetype: "text/plain" };
-    }
-};
-// A log target pathname → the coordinate GLOB it scopes (§log-coordinate-hierarchy): a partial
+// A log target pathname → the coordinate GLOB it scopes ({§log-coordinate-hierarchy}): a partial
 // coordinate (`1`, `1/2`, with or without slash) is a prefix over its descendants; a trailing
 // slash is the folder idiom; a full coordinate/glob passes through. null = malformed.
 const coordinateGlob = (pathname) => {
     if (pathname === "")
-        return "*";
+        return "**";
     if (pathname.endsWith("/"))
-        return `${pathname}*`;
+        return `${pathname}**`;
     if (PARTIAL_COORDINATE.test(pathname))
-        return `${pathname}/*`;
-    if (parseCoordinate(pathname) !== null || pathname.includes("*"))
+        return `${pathname}/**`;
+    if (parseCoordinate(pathname) !== null || PathSyntax.hasGlob(pathname))
         return pathname;
     return null;
 };
@@ -54,209 +43,322 @@ const parseCoordinate = (pathname) => {
         sequence: Number(match[3]),
     };
 };
-// <L> over a matched row set (mirrors EntryFind.#paginate): <N> picks the Nth,
-// <N,M> the range; 0→1, -1→last; out-of-range → 416.
-const paginate = (items, marker) => {
-    const total = items.length;
-    const { first, last } = marker;
-    if (last === null) {
-        if (first === 0 || first === -1)
-            return { status: 200, items: [] };
-        if (first > 0 && first <= total)
-            return { status: 200, items: [items[first - 1]] };
-        return { status: 416 };
-    }
-    const n = first === 0 ? 1 : first;
-    const m = last === -1 ? total : last;
-    if (n < 1 || n > total || m < 1 || m > total || n > m)
-        return { status: 416 };
-    return { status: 200, items: items.slice(n - 1, m) };
-};
+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
+// 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));
 export default class Log extends CoreSchemeAdapterBase {
     static manifest = {
         name: "log",
-        channels: {}, // logs render through read(), not channel storage
+        channels: {},
         defaultChannel: "",
         category: "logging",
-        scope: "workspace",
-        // Engine-only WRITES — but KILL ∈ MUTATING_OPS rides this same gate, and log-KILL is the
-        // model's DB-storage curation lever (plurnk.md:10/:47 + the OP×resource matrix; §model-entry-log-curation).
-        // The model clears the gate; Log's handler surface (kill only — no edit/writeEntry) is the
-        // op-level truth, so every other mutating op still 501s.
+        // Log KILL is model-authorized curation. Other mutations remain unavailable
+        // because Log exposes no edit/writeEntry handler. {§model-entry-log-curation}
         writableBy: ["plurnk", "model"],
         volatile: false,
         modelVisible: true,
         folderScopes: true,
         example: "<<READ(log:///1/2/3)::READ",
     };
-    async read(statement, ctx) {
+    async resolveCoreRepresentation(target, ctx) {
         const core = this.coreContext(ctx);
         const { db, workerId } = core;
-        if (statement.target === null)
-            return { status: 400, content: null, mimetype: null };
-        // 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 { status: 404, content: null, mimetype: 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,
+            });
         }
-        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 { status: 400, content: null, mimetype: null };
+        if (coord === null) {
+            return failure("coordinate-malformed", 400, `The log coordinate '${pathname}' is malformed.`, {
+                target: pathname,
+                recovery: "Use one exact loop/turn/sequence coordinate.",
+                retryable: false,
+            });
+        }
         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 { status: 404, content: null, mimetype: null };
-        const { content: underlyingContent, mimetype: underlyingMimetype } = rxProjection(row.rx);
-        return ReadResolve.resolve({
-            content: underlyingContent,
-            mimetype: underlyingMimetype,
-            lineMarker: statement.lineMarker,
-            body: statement.body,
-            mimetypes: core.mimetypes,
+            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 tags = JSON.parse(row.tags);
+        if (!Array.isArray(tags) || !tags.every((tag) => typeof tag === "string")) {
+            throw new TypeError(`Log row ${pathname} contains invalid tag storage.`);
+        }
+        return {
+            representation: {
+                channels: {
+                    "": {
+                        content: underlyingContent,
+                        mimetype: underlyingMimetype,
+                        state: "static",
+                    },
+                },
+                tags,
+            },
+        };
     }
-    // §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 projected exactly as READ shows them (rxProjection), so every content
-    // dialect works on log BY CONSTRUCTION and FIND(log)→READ(coordinate) composes like any scheme.
-    // ~semantic stays 501 until the pump embeds log rows (epic S5); @graph is 501 (log rows carry
-    // no symbol channels — an honest absence, not an exception).
+    // {§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.
     async find(statement, ctx) {
-        const core = this.coreContext(ctx);
+        return this.#find(statement, this.coreContext(ctx));
+    }
+    async #find(statement, core, allowTargetless = false) {
         const { db, workerId, mimetypes } = core;
-        const empty = (status) => ({ status, content: null, mimetype: null, results: [], itemsTokenTotal: 0, pathnames: [], matches: [] });
-        if (statement.target === null)
-            return empty(400);
-        if (statement.body !== null && (statement.body.dialect === "semantic" || statement.body.dialect === "graph"))
-            return empty(501);
-        const pathname = (statement.target.kind === "url" ? statement.target.pathname : statement.target.raw).replace(/^\//, "");
+        const empty = (status, detail, extensions = {}) => {
+            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 === 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) {
+            return empty(400, "FIND requires a log target.", {
+                recovery: "Provide a log coordinate, prefix, or glob.",
+                retryable: false,
+            });
+        }
+        const pathname = statement.target === null
+            ? ""
+            : (statement.target.kind === "url" ? statement.target.pathname : statement.target.raw).replace(/^\//, "");
         const glob = coordinateGlob(pathname);
-        if (glob === null)
-            return empty(400);
-        // §log-region-tagging — a tag signal AND-filters the candidates (§find-tag-filter-and-semantics):
+        if (glob === null) {
+            return empty(400, `The log target '${pathname}' is malformed.`, {
+                target: pathname,
+                recovery: "Use a log coordinate, prefix, or glob.",
+                retryable: false,
+            });
+        }
+        const scope = pathScope(glob, false);
+        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)}`);
+            const exact = await db.log_id_by_coordinate.get({
+                worker_id: workerId,
+                loop_seq: coordinate.loopSeq,
+                turn_seq: coordinate.turnSeq,
+                sequence: coordinate.sequence,
+            });
+            if (exact === undefined) {
+                return empty(404, `No log entry exists at ${statement.target?.raw ?? `log:///${scope.pathname}`}.`, { target: statement.target?.raw ?? `log:///${scope.pathname}` });
+            }
+        }
+        // {§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 rows = tags.length > 0
-            ? await db.log_find_candidates_tagged.all({ worker_id: workerId, glob, tags: JSON.stringify(tags) })
-            : await db.log_find_candidates.all({ worker_id: workerId, glob });
+        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 });
+        let rows;
+        try {
+            rows = candidateRows.filter((row) => coordinateScopeMatches(scope, row.coordinate));
+        }
+        catch {
+            return empty(400, `The log glob '${glob}' is malformed.`, {
+                target: glob,
+                recovery: "Correct the log glob.",
+                retryable: false,
+            });
+        }
+        const candidateByCanonicalCoord = new Map(candidateRows.map((row) => [canonicalCoordinate(row.coordinate), row]));
         const byCoord = new Map(rows.map((r) => [r.coordinate, r]));
-        const projected = rows.map((r) => ({ key: r.coordinate, ...rxProjection(r.rx) }));
+        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,
+                mimetypeRx: r.mimetype_rx,
+            }),
+        }));
         let matches;
-        if (statement.body === null) {
-            matches = projected.map((c) => ({ pathname: c.key, span: null }));
+        if (statement.body?.dialect === "semantic") {
+            if (mimetypes === undefined) {
+                return empty(501, "Semantic search requires the mimetypes capability.", {
+                    stage: "semantic-search",
+                    retryable: false,
+                });
+            }
+            const candidateSet = resolveSearchCandidates(rows.map(({ coordinate, deep_hash }) => ({ key: coordinate, deepHash: deep_hash })));
+            if (candidateSet.state === "incomplete")
+                return empty(503, `The persistent search index covers ${candidateSet.indexed} of ${candidateSet.total} selected log results.`, {
+                    search: candidateSet,
+                    stage: "search-index",
+                    recovery: "Wait for search indexing to complete before repeating the search.",
+                    retryable: false,
+                });
+            const selection = EntrySemantic.resultSelection(statement.lineMarker);
+            const ranked = await EntrySemantic.rankCandidates(db, candidateSet.candidates, mimetypes, statement.body.raw, selection);
+            if (ranked.status !== 200) {
+                return empty(ranked.status, ranked.status === 501
+                    ? "Similarity-threshold search requires an embedding provider."
+                    : "The requested similarity threshold is outside the supported range.", {
+                    stage: "semantic-search",
+                    ...(selection.threshold === null ? {} : { threshold: selection.threshold }),
+                    recovery: ranked.status === 501
+                        ? "Remove the decimal similarity threshold while embeddings are unavailable."
+                        : "Use a similarity threshold greater than zero and less than one.",
+                    retryable: false,
+                });
+            }
+            const sourceMatches = ranked.results.map(({ key, lineStart, lineEnd }) => ({
+                key,
+                span: { lineStart, lineEnd },
+            }));
+            const readable = Matcher.addTextRegions(sourceMatches, projected);
+            matches = readable.map(({ key, matches: ranges }) => ({ pathname: key, matches: ranges }));
         }
-        else {
-            if (mimetypes === undefined)
-                return empty(501);
-            const r = await Matcher.matchCandidates(statement.body, projected, mimetypes);
-            if (r.status !== 200)
-                return empty(r.status);
-            matches = r.matches.map((m) => ({
-                pathname: m.key,
-                span: m.span === null ? null : {
-                    ...m.span,
-                    rowStart: m.span.lineStart,
-                    rowEnd: m.span.lineEnd,
-                },
-                ...(m.path !== undefined ? { path: m.path } : {}),
+        else if (statement.body?.dialect === "graph") {
+            const candidateSet = resolveSearchCandidates(rows.map(({ coordinate, deep_hash }) => ({ key: coordinate, deepHash: deep_hash })));
+            if (candidateSet.state === "incomplete")
+                return empty(503, `The persistent search index covers ${candidateSet.indexed} of ${candidateSet.total} selected log results.`, {
+                    search: candidateSet,
+                    stage: "search-index",
+                    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 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.`, {
+                    search: universe,
+                    stage: "search-index",
+                    recovery: "Wait for search indexing to complete before repeating the search.",
+                    retryable: false,
+                });
+            const graph = await EntryGraph.matchCandidates(db, universe.candidates, candidateSet.candidates, statement.body.raw);
+            if (graph.status !== 200) {
+                return empty(graph.status, `The graph matcher '${statement.body.raw}' is malformed.`, {
+                    stage: "matcher",
+                    dialect: "graph",
+                    recovery: "Correct or remove the matcher.",
+                    retryable: false,
+                });
+            }
+            const sourceMatches = graph.matches.map(({ key, lineStart, lineEnd }) => ({
+                key,
+                span: { lineStart, lineEnd },
             }));
+            const readable = Matcher.addTextRegions(sourceMatches, projected);
+            matches = readable.map(({ key, matches: ranges }) => ({ pathname: key, matches: ranges }));
         }
-        if (statement.lineMarker !== null) {
-            const page = paginate(matches, LineMarkerOps.firstLast(statement.lineMarker));
-            if (page.status !== 200)
-                return empty(page.status);
-            matches = page.items ?? [];
+        else if (statement.body === null) {
+            matches = projected.map(({ key }) => ({ pathname: key, matches: [] }));
         }
-        if (matches.length === 0)
-            return empty(204);
-        // §find-count-not-contents is source-agnostic. Log used the shared
-        // matcher but skipped its cardinality gate, allowing one matcher over a
-        // large READ projection to retain and later fan out tens of thousands
-        // of rows. Count-forward here before catalog materialization.
-        const budget = Number.parseInt(process.env.PLURNK_SERVICE_FIND_MAX_MATCHES ?? "0", 10);
-        if (budget > 0 && matches.length > budget) {
-            const unique = new Set(matches.map((m) => m.pathname));
-            const itemsTokenTotal = [...unique].reduce((sum, pathname) => sum + (byCoord.get(pathname)?.tokens ?? 0), 0);
-            return {
-                status: 200,
-                content: `${matches.length} entries match, exceeding the render budget (${budget}) — not enumerated.`,
-                mimetype: "text/markdown",
-                results: [],
-                itemsTokenTotal,
-                pathnames: [],
-                matches: [],
-                overflow: matches.length,
-            };
+        else {
+            if (mimetypes === undefined) {
+                return empty(501, "Content matching requires the mimetypes capability.", {
+                    stage: "matcher",
+                    dialect: statement.body.dialect,
+                    retryable: false,
+                });
+            }
+            const r = await Matcher.matchCandidates(statement.body, projected, mimetypes);
+            if (r.status !== 200) {
+                if (r.problem === undefined) {
+                    throw new Error(`Log.find: matcher returned status ${r.status} without Problem Details`);
+                }
+                return Results.assert({
+                    status: r.status,
+                    problem: r.problem,
+                    ...emptyFindFields(),
+                });
+            }
+            matches = r.matches.map(({ key, matches: ranges }) => ({ pathname: key, matches: ranges }));
         }
-        // The result rows mirror the catalog-row shape (§find-result-catalog-rows): one item per
-        // match, keyed by the row's self-documenting path, carrying {mimetype, tokens, lines} so
-        // the model budgets its READs — uniform with every scheme's FIND.
-        const results = [];
-        const seenPath = [];
-        const seen = new Set();
-        let itemsTokenTotal = 0;
+        const folderSummaries = statement.body === null
+            ? pathFolderSummaries(scope, candidateRows.map((row) => canonicalCoordinate(row.coordinate)))
+            : [];
+        const resources = [];
         for (const m of matches) {
             const row = byCoord.get(m.pathname);
             if (row === undefined)
                 continue;
             const path = `log:///${m.pathname}`;
-            const proj = rxProjection(row.rx);
+            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 = {
                 path,
                 channels: { [path]: { mimetype: proj.mimetype, tokens: row.tokens, lines: proj.content.length === 0 ? 0 : proj.content.split("\n").length } },
             };
-            results.push(m.span !== null ? { ...item, matchSpan: m.span, ...(m.path !== undefined ? { matchPath: m.path } : {}) } : item);
-            if (!seen.has(m.pathname)) {
-                seen.add(m.pathname);
-                seenPath.push(m.pathname);
-                itemsTokenTotal += row.tokens;
-            }
+            resources.push({ item, match: m });
         }
-        // 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: JSON.stringify(results), mimetype: "application/json", results, itemsTokenTotal, pathnames: seenPath.map((p) => `/${p}`), matches: fanMatches };
+        const scopes = [];
+        for (const folder of folderSummaries) {
+            const members = folder.pathnames.map((coordinate) => candidateByCanonicalCoord.get(coordinate)).filter((row) => row !== undefined);
+            const item = {
+                path: `log:///${folder.selector}`,
+                items: members.length,
+                tokens: members.reduce((sum, row) => sum + row.tokens, 0),
+            };
+            scopes.push(item);
+        }
+        return projectFindResult(statement, scope, resources, scopes);
     }
     async open(statement, ctx) {
         return this.#setExpanded(statement, this.coreContext(ctx), 1);
     }
-    // FOLD toggles the expanded bit only — an active subscription stays alive. §subscriptions-fold-keeps-subscription
+    // 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);
     }
-    // Resolve a log:/// target — a concrete coordinate, or a path-glob optionally paginated
-    // by <L> (OPEN/FOLD only) — to the matched row ids. The ONE resolution OPEN/FOLD and
-    // KILL share: fold flips `expanded` on the ids, kill deletes them.
-    async #resolveIds(pathname, lineMarker, ctx) {
+    // 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 #resolveIds(pathname, ctx) {
         const { db, workerId } = ctx;
         const coord = parseCoordinate(pathname);
-        if (coord !== null && lineMarker === null) {
+        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] };
         }
-        // §log-coordinate-hierarchy — one resolution for every consumer (curation here, find below).
+        // {§log-coordinate-hierarchy} — one resolution for every consumer (curation here, find below).
         const glob = coordinateGlob(pathname);
         if (glob === null)
-            return { status: 400, ids: [], error: `malformed log target '${pathname}' — a coordinate (1/2/3), a prefix (1 or 1/2), or a glob (**/READ)` };
-        const matched = await db.log_match_coordinates.all({ worker_id: workerId, glob });
-        // Zero matches on a well-formed glob is a NO-OP SUCCESS, not an error (owner ruling): a
-        // curation sweep that found nothing to curate steers nothing — 204 keeps it out of the
-        // errors surface (>= 400), and the rx carries matched: 0, clearly shown.
+            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 });
+        let matched;
+        try {
+            matched = candidates.filter((row) => coordinateScopeMatches(scope, row.coordinate));
+        }
+        catch {
+            return { status: 400, ids: [], error: `The log glob '${glob}' is malformed.` };
+        }
+        // {§log-curation-folder-idiom} — a well-formed empty selection is a
+        // successful no-op and remains outside the error surface.
         if (matched.length === 0)
             return { status: 204, ids: [] };
-        let selected = matched;
-        if (lineMarker !== null) {
-            const page = paginate(matched, LineMarkerOps.firstLast(lineMarker));
-            if (page.status !== 200)
-                return { status: page.status, ids: [] };
-            selected = page.items ?? [];
-        }
-        if (selected.length === 0)
-            return { status: 404, ids: [] };
-        return { status: 200, ids: selected.map((s) => s.id) };
+        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 run when targetless — a bare OPEN[tag] recalls the entire tagged working-set),
+    // {§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),
     // 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) {
@@ -264,86 +366,153 @@ export default class Log extends CoreSchemeAdapterBase {
         const pathname = statement.target === null ? "" : (statement.target.kind === "url" ? statement.target.pathname : statement.target.raw).replace(/^\//, "");
         const glob = coordinateGlob(pathname);
         if (glob === null)
-            return { status: 400, ids: [], error: `malformed log target '${pathname}' — a coordinate (1/2/3), a prefix (1 or 1/2), or a glob (**/READ)` };
-        const matched = await db.log_match_coordinates_tagged.all({ worker_id: workerId, glob, tags: JSON.stringify(tags) });
+            return { status: 400, ids: [], error: `The log target '${pathname}' is malformed.` };
+        const scope = pathScope(glob, false);
+        const candidates = await db.log_match_coordinates_tagged.all({
+            worker_id: workerId,
+            scope_prefix: scope.candidatePrefix,
+            tags: JSON.stringify(tags),
+        });
+        let matched;
+        try {
+            matched = candidates.filter((row) => coordinateScopeMatches(scope, row.coordinate));
+        }
+        catch {
+            return { status: 400, ids: [], error: `The log glob '${glob}' is malformed.` };
+        }
         if (matched.length === 0)
             return { status: 204, ids: [] };
-        let selected = matched;
-        if (statement.lineMarker !== null) {
-            const page = paginate(matched, LineMarkerOps.firstLast(statement.lineMarker));
-            if (page.status !== 200)
-                return { status: page.status, ids: [] };
-            selected = page.items ?? [];
+        return { status: 200, ids: matched.map((row) => row.id) };
+    }
+    // A matcher-bearing curation op reuses FIND's complete source-agnostic selector with
+    // explicit all-results pagination. OPEN's tags filter candidates; FOLD's tags are withheld until
+    // after selection because they apply to the rows being folded.
+    async #resolveByMatcher(statement, filterTags, ctx) {
+        const selected = await this.#find({
+            ...statement,
+            op: "FIND",
+            signal: filterTags ? statement.signal : null,
+            lineMarker: { marks: [1, -1] },
+        }, ctx, filterTags && Array.isArray(statement.signal) && statement.signal.length > 0 && statement.target === null);
+        if (selected.status !== 200)
+            return { status: selected.status, ids: [], problem: selected.problem };
+        let selectedPaths = selected.results.flatMap((item) => typeof item.path === "string" ? [item.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 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)
+                return { status: 404, ids: [] };
+            ids.push(row.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 });
         }
-        if (selected.length === 0)
-            return { status: 404, ids: [] };
-        return { status: 200, ids: selected.map((s) => s.id) };
+        return { status: 200, matched: ids.length };
     }
     async #setExpanded(statement, ctx, expanded) {
         const signal = Array.isArray(statement.signal) ? statement.signal : [];
-        // §log-region-tagging — OPEN[tag] is the READ side: recall rows by tag, target optional (a bare
+        if (statement.body !== null) {
+            const matched = await this.#resolveByMatcher(statement, expanded === 1, ctx);
+            if (matched.status === 204)
+                return { status: 204, matched: 0 };
+            if (matched.status !== 200) {
+                if (matched.problem !== undefined) {
+                    return Results.assert({ status: matched.status, problem: matched.problem });
+                }
+                return Results.failure("scheme:log", matched.status === 404 ? "entry-not-found" : "curation-failed", matched.status, "No log entry matches the requested selection.");
+            }
+            return this.#applyExpanded(matched.ids, expanded, signal, ctx);
+        }
+        // {§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 { status: rt.status, ...(rt.error !== undefined ? { error: rt.error } : {}) };
-            for (const id of rt.ids)
-                await ctx.db.log_set_expanded_by_id.run({ id, expanded: 1 });
-            return { status: 200, matched: rt.ids.length };
+            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,
+                        }
+                        : {}),
+                });
+            }
+            return this.#applyExpanded(rt.ids, 1, signal, ctx);
+        }
+        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,
+            });
         }
-        if (statement.target === null)
-            return { status: 400 };
         const pathname = (statement.target.kind === "url" ? statement.target.pathname : statement.target.raw).replace(/^\//, "");
-        const r = await this.#resolveIds(pathname, statement.lineMarker, ctx);
+        const r = await this.#resolveIds(pathname, ctx);
         if (r.status === 204)
             return { status: 204, matched: 0 };
-        if (r.status !== 200)
-            return { status: r.status, ...(r.error !== undefined ? { error: r.error } : {}) };
-        let ids = r.ids;
-        // §prompt-fold-illegal (#382, owner) — the task frame stays visible: the CURRENT loop's
-        // foisted preview READ (prompt target, origin plurnk, op READ) refuses FOLD (run43: a weak
-        // model folded its own task in a housekeeping turn and lost the plot). Every other
-        // prompt-target row — the born-folded EDIT foist, the model's own deeper prompt READs,
-        // prior loops' previews — is ordinary curatable memory; KILL still DELETES deliberately.
-        // A glob sweep silently spares the preview and folds the rest; an explicit fold whose
-        // whole target IS the preview gets the steer.
-        if (expanded === 0) {
-            const previewIds = new Set();
-            for (const id of r.ids) {
-                const row = await ctx.db.log_row_target.get({ id });
-                if (row?.scheme === "prompt" && row.origin === "plurnk" && row.op === "READ" && row.loop_id === ctx.loopId)
-                    previewIds.add(id);
-            }
-            if (previewIds.size > 0) {
-                ids = r.ids.filter((id) => !previewIds.has(id));
-                if (ids.length === 0)
-                    return { status: 403, error: "Illegal attempt to FOLD the task preview. Use KILL if you want it removed." };
-            }
+        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,
+                    }
+                    : {}),
+            });
         }
-        for (const id of ids)
-            await ctx.db.log_set_expanded_by_id.run({ id, expanded });
-        // §log-region-tagging — FOLD[tag] is the log's write-op: stamp the tags on the folded rows,
-        // additively (§edit-tags-additive). Only the rows actually folded are tagged (a preview spared
-        // above is neither folded nor tagged). OPEN with a signal never reaches here.
-        if (expanded === 0 && signal.length > 0) {
-            for (const id of ids)
-                for (const tag of signal)
-                    await ctx.db.log_write_tag.run({ log_entry_id: id, tag });
-        }
-        return { status: 200, matched: ids.length };
+        return this.#applyExpanded(r.ids, expanded, signal, ctx);
     }
-    // KILL erases log items (plurnk.md:36, :98) — the model's DB-storage curation lever and
-    // the only way to shed accumulated log rows in a long workspace (FOLD only collapses the
-    // render; the row persists). Same resolution as OPEN/FOLD, DELETE instead of flip. KILL
-    // carries no <L> result slot, so no pagination — a concrete coordinate or a path-glob.
+    // 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}
     async kill(pathname, _signal, ctx) {
         const core = this.coreContext(ctx);
-        const r = await this.#resolveIds(pathname.replace(/^\//, ""), null, core);
-        if (r.status !== 200)
-            return { status: r.status };
+        const r = await this.#resolveIds(pathname.replace(/^\//, ""), core);
+        if (r.status === 204)
+            return { status: 204 };
+        if (r.status !== 200) {
+            return Results.failure("scheme:log", r.status === 404 ? "entry-not-found" : "kill-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,
+                    }
+                    : {}),
+            });
+        }
         for (const id of r.ids)
             await core.db.log_delete_by_id.run({ id });
         return { status: 200 };