@sema-agent/core 5.41.0 → 5.43.0

package/dist/tools/fs/fs-search-tools.js

@@ -2,6 +2,75 @@ import { Type } from "typebox";
 import { defineTool, errorResult } from "../../core/tools.js";
 import { resolveKey, violationText, violationDetails } from "./safety.js";
 import { runGrepDetailed, runGlobDetailed, splitAbsoluteGlobPattern, invalidGlobTokens } from "./search.js";
+export function grepDetailFields(text, mode, offset, structuredRows) {
+    const structuredIdentityComplete = structuredRows !== undefined && structuredRows.every((r) => r.path !== undefined || r.text === "--");
+    const structuredPaths = structuredIdentityComplete && structuredRows !== undefined ? [...new Set(structuredRows.filter((r) => r.path !== undefined).map((r) => r.path))] : undefined;
+    const rows = text.startsWith("No matches.")
+        ? []
+        : text
+            .split("\n")
+            .filter((l) => l.length > 0 &&
+            l !== "No matches." &&
+            !l.startsWith("…[") &&
+            !l.startsWith("[offset") &&
+            !l.startsWith("[note") &&
+            !l.startsWith("[!]") &&
+            !l.startsWith("<<<UNTRUSTED ") &&
+            !l.startsWith("<<<END UNTRUSTED "));
+    const contentPathOf = (l) => {
+        const m = /^(.*?):(\d+):/.exec(l);
+        return m ? m[1] : l;
+    };
+    const byteTruncated = text.includes("…[output truncated at ");
+    const truncatedFlag = byteTruncated ? { truncated: true } : {};
+    const capMarker = /^…\[capped at (\d+) of (\d+)\]$/m.exec(text);
+    const cappedAt = capMarker ? Number(capMarker[1]) : undefined;
+    const capTotal = capMarker ? Number(capMarker[2]) : undefined;
+    const appliedOffset = typeof offset === "number" && offset > 0 ? { appliedOffset: offset } : {};
+    const appliedLimit = cappedAt !== undefined ? { appliedLimit: cappedAt } : {};
+    let detailFields;
+    if (mode === "files_with_matches") {
+        const fileNames = structuredPaths ?? rows;
+        detailFields = { filenames: fileNames, numFiles: fileNames.length, totalFiles: capTotal ?? fileNames.length, ...appliedLimit, ...appliedOffset };
+    }
+    else if (mode === "count") {
+        const filenames = structuredPaths ?? [...new Set(rows.map((l) => (l.includes(":") ? l.slice(0, l.lastIndexOf(":")) : l)))];
+        let numMatches = 0;
+        let malformed = false;
+        for (const l of rows) {
+            const m = /:(\d+)$/.exec(l);
+            if (m)
+                numMatches += Number(m[1]);
+            else
+                malformed = true;
+        }
+        detailFields = {
+            filenames,
+            numFiles: filenames.length,
+            content: rows.join("\n"),
+            ...(malformed || byteTruncated ? {} : { numMatches }),
+            ...truncatedFlag,
+            ...appliedLimit,
+            ...appliedOffset,
+        };
+    }
+    else {
+        const filenames = structuredPaths ?? [...new Set(rows.map(contentPathOf))];
+        const joined = rows.join("\n");
+        const GREP_CONTENT_PREVIEW_CHARS = 16_000;
+        detailFields = {
+            filenames,
+            numFiles: filenames.length,
+            content: joined.length > GREP_CONTENT_PREVIEW_CHARS ? `${joined.slice(0, GREP_CONTENT_PREVIEW_CHARS)}\n…[truncated — full text in the tool output]` : joined,
+            numLines: rows.length,
+            ...(byteTruncated ? {} : { totalLines: capTotal ?? rows.length }),
+            ...truncatedFlag,
+            ...appliedLimit,
+            ...appliedOffset,
+        };
+    }
+    return detailFields;
+}
 export function createGrepTool(env, rootCanonical, additionalRoots, readDeny, readFace) {
     return defineTool({
         name: "Grep",
@@ -95,64 +164,7 @@ export function createGrepTool(env, rootCanonical, additionalRoots, readDeny, re
             if (text.startsWith("Error (grep)") || text.startsWith("Error (Grep)"))
                 return errorResult(text);
             const mode = a.output_mode ?? "files_with_matches";
-            const rows = text.startsWith("No matches.")
-                ? []
-                : text
-                    .split("\n")
-                    .filter((l) => l.length > 0 &&
-                    !l.startsWith("…[") &&
-                    !l.startsWith("[offset") &&
-                    !l.startsWith("[note") &&
-                    !l.startsWith("[!]") &&
-                    !l.startsWith("<<<UNTRUSTED ") &&
-                    !l.startsWith("<<<END UNTRUSTED "));
-            const contentPathOf = (l) => {
-                const m = /^(.*?):(\d+):/.exec(l);
-                return m ? m[1] : l;
-            };
-            const capMarker = /^…\[capped at (\d+) of (\d+)\]$/m.exec(text);
-            const cappedAt = capMarker ? Number(capMarker[1]) : undefined;
-            const capTotal = capMarker ? Number(capMarker[2]) : undefined;
-            const appliedOffset = typeof a.offset === "number" && a.offset > 0 ? { appliedOffset: a.offset } : {};
-            const appliedLimit = cappedAt !== undefined ? { appliedLimit: cappedAt } : {};
-            let detailFields;
-            if (mode === "files_with_matches") {
-                detailFields = { filenames: rows, numFiles: rows.length, totalFiles: capTotal ?? rows.length, ...appliedLimit, ...appliedOffset };
-            }
-            else if (mode === "count") {
-                const filenames = [...new Set(rows.map((l) => (l.includes(":") ? l.slice(0, l.lastIndexOf(":")) : l)))];
-                let numMatches = 0;
-                let malformed = false;
-                for (const l of rows) {
-                    const m = /:(\d+)$/.exec(l);
-                    if (m)
-                        numMatches += Number(m[1]);
-                    else
-                        malformed = true;
-                }
-                detailFields = {
-                    filenames,
-                    numFiles: filenames.length,
-                    content: rows.join("\n"),
-                    ...(malformed ? {} : { numMatches }),
-                    ...appliedLimit,
-                    ...appliedOffset,
-                };
-            }
-            else {
-                const filenames = [...new Set(rows.map(contentPathOf))];
-                const joined = rows.join("\n");
-                const GREP_CONTENT_PREVIEW_CHARS = 16_000;
-                detailFields = {
-                    filenames,
-                    numFiles: filenames.length,
-                    content: joined.length > GREP_CONTENT_PREVIEW_CHARS ? `${joined.slice(0, GREP_CONTENT_PREVIEW_CHARS)}\n…[truncated — full text in the tool output]` : joined,
-                    numLines: rows.length,
-                    totalLines: capTotal ?? rows.length,
-                    ...appliedLimit,
-                    ...appliedOffset,
-                };
-            }
+            const detailFields = grepDetailFields(text, mode, a.offset, grepRun.rows);
             return {
                 content: text,
                 details: { type: "grep", mode, ...detailFields, ...(grepRun.degraded ?? {}), ...(grepRun.withheld !== undefined ? { withheld: grepRun.withheld } : {}) },

package/dist/tools/fs/search.d.ts

@@ -1,4 +1,9 @@
 import type { ExecutionEnv } from "../../internal/harness-types.js";
+/** backlog #310 — the JS scanner's own output ceiling, in bytes of emitted content rows. Pinned to the
+ *  ripgrep leg's figure ({@link MAX_EXEC_OUTPUT_BYTES}, the exec pipe's rolling-tail bound) so the two
+ *  legs cannot disagree about how much one search may return; see the collection site in {@link jsGrep}
+ *  for why this leg bounds the HEAD where the pipe bounds the tail. */
+export declare const JS_GREP_OUTPUT_MAX_BYTES: number;
 /** Directories never worth crawling (design/64 §10.3) — dependency/build/cache trees, PLUS the VCS
  *  metadata directories CC names explicitly (RB-200 F1, 220 @368402: `Ok_ = [".git",".svn",".hg",
  *  ".bzr",".jj",".sl"]` — git/svn/mercurial/bazaar/jujutsu/sapling). `.bzr`/`.jj`/`.sl` are additive here
@@ -153,6 +158,10 @@ export interface JsGrepGuards {
     budgetMs?: number;
     /** Longest line/content (chars) a gray-zone pattern may be matched against. */
     longLineLimit?: number;
+    /** backlog #310 — bytes of content rows this scan may accumulate before it stops collecting and
+     *  says so (default {@link JS_GREP_OUTPUT_MAX_BYTES}). A seam for the same reason the two above
+     *  are: the boundary is pinnable at a testable size instead of only at an 8MB harness. */
+    outputMaxBytes?: number;
 }
 /** design/199 件B — what a traversal withheld under the sensitive-path read deny list, structured
  *  (the prose note is the model-facing twin). Three shapes (§3.1): `pruned_count` = the JS walker
@@ -201,13 +210,26 @@ export type GrepDegradation = {
 };
 /** Structured grep result: the model-facing text plus the degradation facts, so the tool layer can
  *  ship them on the structured frame instead of leaving them prose-only. */
+/** #313 (first stage, rg legs) — one SERVED result row with its path read from ripgrep's own
+ *  field ({@link parseRgRecords}), exactly the window `text` shows (post cap/offset). The tool
+ *  layer prefers these over re-parsing `text` (whose `path:line:text` split mis-cuts a path that
+ *  itself contains `:digits:`); absent = a leg that has no structured rows yet (the JS scanner —
+ *  its rows stage is the ticket's remainder) and the text parse is the honest fallback. */
+export interface GrepRow {
+    path?: string;
+    text: string;
+}
 export interface GrepRunResult {
     text: string;
+    /** Served rows (#313): present on the ripgrep legs, absent on the JS-scanner legs. */
+    rows?: readonly GrepRow[];
     degraded?: GrepDegradation;
     /** design/199 件B — deny-list withholding facts (see {@link ReadDenyWithheld}); absent = nothing
      *  withheld / no deny judge in play. */
     withheld?: ReadDenyWithheld;
 }
+/** The output modes the rg leg and {@link jsGrep} share. */
+type GrepOutputMode = "content" | "files_with_matches" | "count";
 /**
  * backlog #303 (rescan-hardened form) — the rg leg's deny TRIPWIRE. rg's exclusion globs are spelled
  * from the pattern text and cannot express the win32 component-alias family (`.aws.` / `.aws ` —
@@ -220,21 +242,31 @@ export interface GrepRunResult {
  * ripgrep prints filenames verbatim, so a path component containing a NEWLINE splits one record
  * across physical lines whose fragments carry no `:line:` boundary — the filter kept them and the
  * deny-listed content passed (a protection hole, not a precision residual); and pruning every line
- * of a partial run fabricated a `No matches.` row inside the structured card. Text-splitting rg
- * records is unsalvageable without structured output (`--json`, backlog #306), so this function no
- * longer edits anything: it JUDGES. Any deny hit — or any line the format cannot account for —
+ * of a partial run fabricated a `No matches.` row inside the structured card. So this function no
+ * longer edits anything: it JUDGES. Any deny hit — or any record the format cannot account for —
  * trips, and the caller abandons the rg run for the JS scanner, whose walk prunes with the
  * authoritative judge and needs no path parsing at all. rg stays the fast path for the common case
  * (no guarded entries in the result); the moment a guarded spelling is involved, the engine that
  * cannot mis-parse it owns the answer.
  *
- * Trip conditions by mode — `files_with_matches`: every line IS a path, judged whole; `count`:
- * `path:N` (a line without the numeric tail is a split record — ambiguous, trip); `content`:
- * judged at EVERY `:digits:` boundary and every `-digits-` boundary (a candidate cut inside match
- * text can over-trip — safe: the fallback re-derives the exact answer), and a non-separator line
- * with NO boundary at all is a split record — trip. `--` separators and empty lines pass.
+ * backlog #306 — what it judges is now ripgrep's OWN path field ({@link parseRgRecords}, `--null`),
+ * not a prefix cut at a guessed separator. Trip conditions, all three modes alike: a record whose
+ * path the deny judge names trips as `deny-hit`; a record with no path field at all (rg's binary-file
+ * notice, a no-filename row, an unterminated tail, output from an env that ignored `--null`) is
+ * unaccountable and trips as `ambiguous-record` — same abandonment, same reason code as before.
+ * `dropIncompleteTail` mirrors {@link parseRgRecords}: on the partial legs the cut tail is dropped
+ * BEFORE judging, because judging a record the caller will never receive can only cost an
+ * unnecessary rescan — every record that does reach the output is still judged, which is what the
+ * rule is for. (A killed stream ending mid-record is an EXPECTED shape with a rule of its own; the
+ * unaccountable arm is for records that survive that rule.)
+ * `--` group separators and empty lines carry no path by construction and pass. The `:digits:` /
+ * `-digits-` boundary family this used to reason about is gone with the guessing: both of #303's
+ * declared residuals (over-tripping on a cluster inside match TEXT, and the dedup key folding two
+ * denied files whose own names carry a cluster) were artifacts of that decision, not of the judge.
  */
-export declare function rgOutputDenyTripwire(stdout: string, mode: "content" | "files_with_matches" | "count", judge: Pick<ReadDenyJudge, "matchPath">): {
+export declare function rgOutputDenyTripwire(stdout: string, mode: GrepOutputMode, judge: Pick<ReadDenyJudge, "matchPath">, opts?: {
+    dropIncompleteTail?: boolean;
+}): {
     trip: false;
 } | {
     trip: true;
@@ -285,3 +317,4 @@ export declare function runGlobDetailed(env: ExecutionEnv, root: string, pattern
     error?: string;
     withheld?: ReadDenyWithheld;
 }>;
+export {};

package/dist/tools/fs/search.js

@@ -1,9 +1,11 @@
 import { delimitUntrusted } from "../../core/untrusted-text.js";
+import { MAX_EXEC_OUTPUT_BYTES } from "../../core/exec-output-tail.js";
 import { hasBinaryExtension, isAbsolutePathForm } from "./safety.js";
 const WALK_MAX_FILES = 5000;
 const WALK_MAX_DEPTH = 32;
 const GREP_DEFAULT_CAP = 250;
 const FILE_MAX_BYTES = 5 * 1024 * 1024;
+export const JS_GREP_OUTPUT_MAX_BYTES = MAX_EXEC_OUTPUT_BYTES;
 export const DEFAULT_IGNORE_DIRS = new Set([
     "node_modules", ".git", ".hg", ".svn", ".bzr", ".jj", ".sl", "build", "dist", "out", "target",
     ".dart_tool", ".pub-cache", ".next", ".nuxt", ".gradle", ".idea", ".vscode", "Pods", ".venv", "venv",
@@ -840,6 +842,27 @@ export async function jsGrep(env, root, p, signal, guards, deny, denyOut) {
     const off = Math.min(100_000, Math.max(0, Math.floor(p.offset ?? 0)));
     const collectCap = cap + off;
     const out = [];
+    const outputMaxBytes = guards?.outputMaxBytes ?? JS_GREP_OUTPUT_MAX_BYTES;
+    let outBytes = 0;
+    let outputTruncated = false;
+    let rowsBeforeWindow = 0;
+    const pushRow = (row) => {
+        if (outputTruncated)
+            return;
+        if (rowsBeforeWindow < off) {
+            rowsBeforeWindow++;
+            return;
+        }
+        if (out.length >= cap)
+            return;
+        const size = Buffer.byteLength(row, "utf8") + 1;
+        if (outBytes + size > outputMaxBytes) {
+            outputTruncated = true;
+            return;
+        }
+        outBytes += size;
+        out.push(row);
+    };
     const fileMatches = [];
     const counts = [];
     let totalContent = 0;
@@ -888,14 +911,12 @@ export async function jsGrep(env, root, p, signal, guards, deny, denyOut) {
                     if (p.only_matching && text !== undefined) {
                         const parts = text.split("\n");
                         for (let k = 0; k < parts.length; k++) {
-                            if (out.length < collectCap)
-                                out.push(`${relOut(f)}:${s + k}:${clipLine(parts[k])}`);
+                            pushRow(`${relOut(f)}:${s + k}:${clipLine(parts[k])}`);
                         }
                         continue;
                     }
                     for (let j = Math.max(0, s - 1 - ctxB); j <= Math.min(lines.length - 1, eL - 1 + ctxA); j++) {
-                        if (out.length < collectCap)
-                            out.push(`${relOut(f)}:${j + 1}:${clipLine(lines[j])}`);
+                        pushRow(`${relOut(f)}:${j + 1}:${clipLine(lines[j])}`);
                     }
                 }
             }
@@ -924,18 +945,16 @@ export async function jsGrep(env, root, p, signal, guards, deny, denyOut) {
                 if (mode === "content") {
                     if (p.only_matching) {
                         for (const part of matchedParts(lines[i], p)) {
-                            if (out.length < collectCap)
-                                out.push(`${relOut(f)}:${i + 1}:${clipLine(part)}`);
+                            pushRow(`${relOut(f)}:${i + 1}:${clipLine(part)}`);
                         }
                     }
                     else if (ctx > 0) {
                         for (let j = Math.max(0, i - ctxB); j <= Math.min(lines.length - 1, i + ctxA); j++) {
-                            if (out.length < collectCap)
-                                out.push(`${relOut(f)}:${j + 1}:${clipLine(lines[j])}`);
+                            pushRow(`${relOut(f)}:${j + 1}:${clipLine(lines[j])}`);
                         }
                     }
-                    else if (out.length < collectCap) {
-                        out.push(`${relOut(f)}:${i + 1}:${clipLine(lines[i])}`);
+                    else {
+                        pushRow(`${relOut(f)}:${i + 1}:${clipLine(lines[i])}`);
                     }
                 }
             }
@@ -990,15 +1009,16 @@ export async function jsGrep(env, root, p, signal, guards, deny, denyOut) {
             ? NO_MATCHES + offNote + typeNote + caveat
             : body.join("\n") + (totalFiles > off + cap ? `\n…[capped at ${cap} of ${totalFiles}]` : "") + offNote + typeNote + caveat;
     }
-    const body = paged(out);
+    const body = out;
+    const byteNote = outputTruncated ? `\n…[output truncated at ${outputMaxBytes} bytes — narrow the pattern or set a smaller head_limit]` : "";
     if (body.length === 0)
-        return NO_MATCHES + offNote + typeNote + caveat;
-    if (out.length < collectCap)
-        return body.join("\n") + offNote + typeNote + caveat;
+        return NO_MATCHES + byteNote + offNote + typeNote + caveat;
+    if (out.length < cap)
+        return body.join("\n") + byteNote + offNote + typeNote + caveat;
     const marker = ctx > 0 || p.multiline || p.only_matching
         ? `\n…[capped at ${cap}; ${totalContent}+ match(es) found, more output omitted]`
         : `\n…[capped at ${cap} of ${totalContent}]`;
-    return body.join("\n") + marker + offNote + typeNote + caveat;
+    return body.join("\n") + marker + byteNote + offNote + typeNote + caveat;
 }
 const rgCache = new WeakMap();
 export function detectRipgrep(env) {
@@ -1012,79 +1032,93 @@ export function detectRipgrep(env) {
     }
     return cached;
 }
-async function sortRgFilesByMtime(env, root, stdout, signal) {
-    const paths = stdout.split("\n").filter((l) => l.length > 0);
-    if (paths.length === 0)
-        return stdout;
+async function sortRgFilesByMtime(env, root, records, signal) {
+    if (records.length === 0)
+        return [...records];
     const rootPrefix = root.replace(/[\\/]+$/, "") + (root.includes("\\") ? "\\" : "/");
     const toAbs = (p) => {
         const stripped = p.startsWith("./") ? p.slice(2) : p;
         return isAbsolutePathForm(stripped) ? stripped : `${rootPrefix}${stripped}`;
     };
+    const paths = records.map((r) => r.path ?? r.text);
     const infos = await Promise.all(paths.map((p) => env.fileInfo(toAbs(p), signal)));
-    const withMtime = paths.map((p, i) => {
-        const r = infos[i];
-        return { p, m: r.ok && typeof r.value.mtimeMs === "number" ? r.value.mtimeMs : undefined };
+    const withMtime = records.map((r, i) => {
+        const info = infos[i];
+        return { r, p: paths[i], m: info.ok && typeof info.value.mtimeMs === "number" ? info.value.mtimeMs : undefined };
     });
     const sorted = withMtime.every((x) => x.m !== undefined)
         ? [...withMtime].sort((a, b) => b.m - a.m || (a.p < b.p ? -1 : a.p > b.p ? 1 : 0))
         : [...withMtime].sort((a, b) => (a.p < b.p ? -1 : a.p > b.p ? 1 : 0));
-    return sorted.map((x) => x.p).join("\n");
+    return sorted.map((x) => x.r);
+}
+function rgRecordSeparator(mode, rest) {
+    if (mode === "count")
+        return /^\d+$/.test(rest) ? ":" : null;
+    const m = /^\d+([:\-])/.exec(rest);
+    return m === null ? null : m[1];
 }
-function formatRgStdout(stdout, p, caveat = "") {
+function parseRgRecords(stdout, mode, dropIncompleteTail = false) {
+    if (stdout.length === 0)
+        return [];
+    if (mode === "files_with_matches") {
+        if (!stdout.includes("\0")) {
+            if (dropIncompleteTail)
+                return [];
+            return stdout.split("\n").filter((l) => l.length > 0).map((l) => ({ path: l, text: l }));
+        }
+        const parts = stdout.split("\0");
+        const tail = parts.pop() ?? "";
+        const records = parts.filter((p) => p.length > 0).map((p) => ({ path: p, text: p }));
+        if (tail.length > 0 && !dropIncompleteTail)
+            records.push({ text: tail });
+        return records;
+    }
+    const lines = stdout.split("\n");
+    if (!stdout.endsWith("\n") && dropIncompleteTail)
+        lines.pop();
+    const records = [];
+    for (const line of lines) {
+        if (line.length === 0)
+            continue;
+        const nul = line.indexOf("\0");
+        const rest = nul < 0 ? "" : line.slice(nul + 1);
+        const sep = nul < 0 ? null : rgRecordSeparator(mode, rest);
+        if (nul < 0 || sep === null) {
+            records.push({ text: line });
+            continue;
+        }
+        const path = line.slice(0, nul);
+        records.push({ path, text: `${path}${sep}${rest}` });
+    }
+    return records;
+}
+function formatRgRecords(records, p, caveat = "") {
     const cap = p.head_limit === 0 ? Infinity : Math.max(1, Math.floor(p.head_limit ?? GREP_DEFAULT_CAP));
     const off = Math.max(0, Math.floor(p.offset ?? 0));
-    const lines = stdout.split("\n").filter((l) => l.length > 0);
-    const capped = lines.slice(off, off + cap);
+    const capped = records.slice(off, off + cap);
+    const served = capped.map((r) => (r.path !== undefined ? { path: r.path, text: r.text } : { text: r.text }));
     if (capped.length === 0)
-        return NO_MATCHES + (off > 0 ? `\n[offset ${off}]` : "") + caveat;
-    return (capped.join("\n") +
-        (lines.length > off + cap ? `\n…[capped at ${cap} of ${lines.length}]` : "") +
-        (off > 0 ? `\n[offset ${off}]` : "") +
-        caveat);
+        return { text: NO_MATCHES + (off > 0 ? `\n[offset ${off}]` : "") + caveat, served };
+    return {
+        text: capped.map((r) => r.text).join("\n") +
+            (records.length > off + cap ? `\n…[capped at ${cap} of ${records.length}]` : "") +
+            (off > 0 ? `\n[offset ${off}]` : "") +
+            caveat,
+        served,
+    };
 }
-export function rgOutputDenyTripwire(stdout, mode, judge) {
+export function rgOutputDenyTripwire(stdout, mode, judge, opts = {}) {
     if (stdout.length === 0)
         return { trip: false };
-    const judgeBoundaries = (line, boundary) => {
-        let sawBoundary = false;
-        for (let m = boundary.exec(line); m !== null; m = boundary.exec(line)) {
-            sawBoundary = true;
-            const prefix = line.slice(0, m.index);
-            if (prefix.length === 0)
+    for (const record of parseRgRecords(stdout, mode, opts.dropIncompleteTail === true)) {
+        if (record.path === undefined) {
+            if (record.text === "--")
                 continue;
-            const hit = judge.matchPath(prefix);
-            if (hit !== null)
-                return hit.pattern;
-        }
-        return sawBoundary ? null : "";
-    };
-    for (const line of stdout.split("\n")) {
-        if (line.length === 0 || line === "--")
-            continue;
-        if (mode === "files_with_matches") {
-            const h = judge.matchPath(line);
-            if (h !== null)
-                return { trip: true, reason: "deny-hit", pattern: h.pattern };
-        }
-        else if (mode === "count") {
-            const m = /^(.*):\d+$/.exec(line);
-            if (m === null)
-                return { trip: true, reason: "ambiguous-record" };
-            const h = judge.matchPath(m[1]);
-            if (h !== null)
-                return { trip: true, reason: "deny-hit", pattern: h.pattern };
-        }
-        else {
-            const colon = judgeBoundaries(line, /:\d+:/g);
-            if (colon !== null && colon !== "")
-                return { trip: true, reason: "deny-hit", pattern: colon };
-            const dash = judgeBoundaries(line, /-\d+-/g);
-            if (dash !== null && dash !== "")
-                return { trip: true, reason: "deny-hit", pattern: dash };
-            if (colon === "" && dash === "")
-                return { trip: true, reason: "ambiguous-record" };
+            return { trip: true, reason: "ambiguous-record" };
         }
+        const hit = judge.matchPath(record.path);
+        if (hit !== null)
+            return { trip: true, reason: "deny-hit", pattern: hit.pattern };
     }
     return { trip: false };
 }
@@ -1113,7 +1147,7 @@ async function jsGrepFallback(env, root, p, signal, reason, deny) {
 }
 export async function rgGrepDetailed(env, root, p, signal, deny) {
     const mode = p.output_mode ?? "files_with_matches";
-    const flags = ["--no-messages", "--no-require-git", "--hidden"];
+    const flags = ["--null", "-H", "--no-messages", "--no-require-git", "--hidden"];
     for (const d of VCS_DIRS)
         flags.push("--glob", `!${d}`);
     flags.push("--max-columns", "500", "--max-columns-preview");
@@ -1155,12 +1189,15 @@ export async function rgGrepDetailed(env, root, p, signal, deny) {
             const partial = err.partialStdout ?? "";
             if (partial.trim().length > 0) {
                 if (deny !== undefined) {
-                    const trip = rgOutputDenyTripwire(partial, mode, deny);
+                    const trip = rgOutputDenyTripwire(partial, mode, deny, { dropIncompleteTail: true });
                     if (trip.trip)
                         return jsGrepDenyTripFallback(env, root, p, signal, trip, deny);
                 }
+                const records = parseRgRecords(partial, mode, true);
+                if (records.length === 0)
+                    return jsGrepFallback(env, root, p, signal, "timed out before completing a result", deny);
                 return {
-                    text: `${delimitUntrusted("ripgrep partial output", formatRgStdout(partial, p))}\n…[ripgrep timed out after producing partial output — results may be incomplete]`,
+                    ...(() => { const f = formatRgRecords(records, p); return { text: `${delimitUntrusted("ripgrep partial output", f.text)}\n…[ripgrep timed out after producing partial output — results may be incomplete]`, rows: f.served }; })(),
                     degraded: { partial: true, reason: "ripgrep timed out" },
                 };
             }
@@ -1172,6 +1209,12 @@ export async function rgGrepDetailed(env, root, p, signal, deny) {
     const denyDisclosure = async () => {
         if (deny === undefined || deny.rgExclusionGlobs.length === 0)
             return { note: "" };
+        if (p.path) {
+            const startPath = isAbsolutePathForm(p.path) ? p.path : `${root.replace(/[\\/]+$/, "")}${root.includes("\\") ? "\\" : "/"}${p.path}`;
+            const info = await env.fileInfo(startPath, signal);
+            if (info.ok && info.value.kind === "file")
+                return { note: "" };
+        }
         const withheld = await rgDenyExistenceProbe(env, root, deny, target, signal);
         if (withheld === undefined)
             return { note: "" };
@@ -1182,17 +1225,20 @@ export async function rgGrepDetailed(env, root, p, signal, deny) {
     };
     if (exitCode === 1) {
         const d = await denyDisclosure();
-        return { text: NO_MATCHES + d.note, ...(d.withheld !== undefined ? { withheld: d.withheld } : {}) };
+        return { text: NO_MATCHES + d.note, rows: [], ...(d.withheld !== undefined ? { withheld: d.withheld } : {}) };
     }
     if (exitCode >= 2) {
         if (stdout.trim().length > 0) {
             if (deny !== undefined) {
-                const trip = rgOutputDenyTripwire(stdout, mode, deny);
+                const trip = rgOutputDenyTripwire(stdout, mode, deny, { dropIncompleteTail: true });
                 if (trip.trip)
                     return jsGrepDenyTripFallback(env, root, p, signal, trip, deny);
             }
+            const records = parseRgRecords(stdout, mode, true);
+            if (records.length === 0)
+                return jsGrepFallback(env, root, p, signal, `exited with code ${exitCode} and produced no complete result`, deny);
             return {
-                text: `${delimitUntrusted("ripgrep partial output", formatRgStdout(stdout, p))}\n…[ripgrep exited with an error after producing partial output — results may be incomplete]`,
+                ...(() => { const f = formatRgRecords(records, p); return { text: `${delimitUntrusted("ripgrep partial output", f.text)}\n…[ripgrep exited with an error after producing partial output — results may be incomplete]`, rows: f.served }; })(),
                 degraded: { partial: true, reason: `ripgrep exited with code ${exitCode}` },
             };
         }
@@ -1203,9 +1249,11 @@ export async function rgGrepDetailed(env, root, p, signal, deny) {
         if (trip.trip)
             return jsGrepDenyTripFallback(env, root, p, signal, trip, deny);
     }
-    const orderedStdout = mode === "files_with_matches" ? await sortRgFilesByMtime(env, root, stdout, signal) : stdout;
+    const parsed = parseRgRecords(stdout, mode);
+    const ordered = mode === "files_with_matches" ? await sortRgFilesByMtime(env, root, parsed, signal) : parsed;
     const d = await denyDisclosure();
-    return { text: formatRgStdout(orderedStdout, p) + d.note, ...(d.withheld !== undefined ? { withheld: d.withheld } : {}) };
+    const formatted = formatRgRecords(ordered, p);
+    return { text: formatted.text + d.note, rows: formatted.served, ...(d.withheld !== undefined ? { withheld: d.withheld } : {}) };
 }
 async function rgDenyExistenceProbe(env, root, deny, target, signal) {
     const probeFlags = ["--files", "--hidden", "--no-require-git", "--no-messages"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "5.41.0",
+  "version": "5.43.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",

package/test/export-surface.snapshot.json

@@ -1,6 +1,6 @@
 {
   "_comment": "design/87 L3 — frozen public export surface of src/index.ts (name -> kind). DO NOT edit by hand to silence a red test. A removed/changed entry = a SemVer-BREAKING change; bump MAJOR and update this fixture in the SAME commit (design/87 §4.2 / §5.2). Regenerate via REGEN in test/export-surface.test.ts.",
-  "count": 1605,
+  "count": 1606,
   "exports": {
     "A2ATaskState": "type",
     "A2ATaskStateReversal": "type",
@@ -1390,6 +1390,7 @@
     "mergeRecallHits": "function",
     "mergeWorkflowArgs": "function",
     "migrateScope": "function",
+    "mintCheckpointId": "function",
     "mintCheckpointToken": "function",
     "mintRuleTicket": "function",
     "missingRestoreSurface": "function",