mixdog 0.9.51 → 0.9.53

package/src/runtime/agent/orchestrator/stall-policy.mjs

@@ -68,17 +68,7 @@ export const DEFAULT_ACTIVITY_HEARTBEAT_MS = resolveTimeoutMs(
 
 export const PROVIDER_FIRST_BYTE_TIMEOUT_MS = resolveTimeoutMs(
     'MIXDOG_PROVIDER_FIRST_BYTE_TIMEOUT_MS',
-    // 2026-07-05 trace audit (24h): worker claude-sonnet-5 successful TTFT
-    // p90 43s / p99 164s / max 171s — the distribution hugs the previous 180s
-    // window, and 16/178 fetches "died" in repeated back-to-back 183s
-    // fetch→fetch cycles (3+ consecutive in the worst session). That pattern
-    // is queued-but-alive first bytes being axed AT the window and re-queued
-    // from scratch, not dead sockets: each trip doubled the wait (one worker
-    // session burned ~40min purely on 180s-abort→retry loops). Raise to the
-    // policy ceiling (STALL_WARN - tick, ~285s): models with fast first bytes
-    // never reach the timer, and a truly wedged socket is still bounded by
-    // the agent stall first-byte abort (300s, DEFAULT_STALL_FIRST_BYTE_ABORT_S).
-    PROVIDER_MAX_BEFORE_WARN_MS,
+    60_000,
     { minMs: MIN_PROVIDER_TIMEOUT_MS, maxMs: PROVIDER_MAX_BEFORE_WARN_MS },
 );
 
@@ -252,7 +242,7 @@ export const PROVIDER_WS_INTER_CHUNK_TIMEOUT_MS = resolveTimeoutMs(
 // provider layer catches the wedge before the agent watchdog does. Env-tunable.
 export const PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS = resolveTimeoutMs(
     'MIXDOG_PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS',
-    120_000,
+    60_000,
     { minMs: 10_000, maxMs: STALL_WARN_MS },
 );
 

package/src/runtime/agent/orchestrator/tools/bash-session.mjs

@@ -48,6 +48,7 @@ import { _captureTrackedMtimes, _trackedDriftNoteAfter, getDedupedDestructiveWar
 import { scrubLoaderVars, scrubProviderSecrets } from './env-scrub.mjs';
 import { checkExecPolicyMessage } from './bash-policy-scan.mjs';
 import { startChildGuardian } from '../../../shared/child-guardian.mjs';
+import { resourceAdmission } from '../../../shared/resource-admission.mjs';
 
 globalThis.__mixdogBashSessionRuntimeLoaded = true;
 
@@ -344,7 +345,7 @@ function buildBashEnv() {
     return env;
 }
 
-function _spawnSession(id, initialCwd = process.cwd()) {
+function _spawnSession(id, initialCwd = process.cwd(), resourceLease = null) {
     _installParentExitHook();
     _evictOldestIfFull();
     const shell = resolveBash();
@@ -376,6 +377,12 @@ function _spawnSession(id, initialCwd = process.cwd()) {
         busy: false,
         dead: false,
         exitInfo: null,
+        resourceLease,
+    };
+    const releaseResourceLease = () => {
+        if (!entry.resourceLease) return;
+        try { entry.resourceLease.release(); } catch {}
+        entry.resourceLease = null;
     };
     // Hard-capped concat: past STREAM_BUF_BYTE_CAP we drop further
     // chunks and stamp a truncation marker once. Without this a runaway
@@ -402,18 +409,27 @@ function _spawnSession(id, initialCwd = process.cwd()) {
     proc.on('error', (err) => {
         entry.dead = true;
         entry.exitInfo = { error: err?.message || String(err) };
+        // An error event is not proof of process exit. Keep admission until
+        // exit/close confirms termination, and force the failed tree down.
+        _killProcessTree(proc);
     });
     proc.on('exit', (code, signal) => {
         entry.dead = true;
         entry.exitInfo = { code, signal };
         _sessions.delete(id);
+        releaseResourceLease();
+    });
+    proc.on('close', () => {
+        entry.dead = true;
+        _sessions.delete(id);
+        releaseResourceLease();
     });
     _sessions.set(id, entry);
     _startReaper();
     return entry;
 }
 
-function _getOrCreate(sessionId, initialCwd = process.cwd(), opts = {}) {
+async function _getOrCreate(sessionId, initialCwd = process.cwd(), opts = {}) {
     const explicit = typeof sessionId === 'string' && sessionId.length > 0;
     const id = explicit ? sessionId : `sess_${randomUUID()}`;
     let entry = _sessions.get(id);
@@ -425,7 +441,20 @@ function _getOrCreate(sessionId, initialCwd = process.cwd(), opts = {}) {
         if (explicit && opts.create !== true) {
             return { error: `Error: unknown session_id "${id}" (pass create:true to start a new persistent session)` };
         }
-        entry = _spawnSession(id, initialCwd);
+        const admission = opts.resourceAdmission || resourceAdmission;
+        const lease = await admission.acquire('shell', {
+            signal: opts.signal || null,
+            label: `persistent:${id}`,
+            dependency: 'detached',
+        });
+        try {
+            entry = _sessions.get(id);
+            if (!entry || entry.dead) entry = _spawnSession(id, initialCwd, lease);
+            else await lease.release();
+        } catch (error) {
+            await lease.release();
+            throw error;
+        }
     }
     return { id, entry };
 }
@@ -656,7 +685,16 @@ async function bash_session(args, cwd = process.cwd(), opts = {}) {
     const effectiveTimeout = hasExplicitTimeout
         ? Math.min(Math.max(timeoutMs, 1), wmicRewrite?.timeoutMs || TIMER_MAX_MS)
         : Math.min(Math.max(timeoutMs, 1), wmicRewrite?.timeoutMs || MAX_TIMEOUT_MS);
-    const resolved = _getOrCreate(requestedSessionId || args?.session_id, baseCwd, { create: args?.create === true });
+    let resolved;
+    try {
+        resolved = await _getOrCreate(requestedSessionId || args?.session_id, baseCwd, {
+            create: args?.create === true,
+            resourceAdmission: opts?.resourceAdmission || resourceAdmission,
+            signal: abortSignal,
+        });
+    } catch (error) {
+        return `Error: ${error?.message || String(error)}`;
+    }
     if (resolved.error) return resolved.error;
     const { id, entry } = resolved;
     if (entry.syncError) {

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -17,6 +17,7 @@ import {
     endShellJobWait,
     clearShellJobNotifyCtx,
     shellJobPublicTaskResult,
+    attachShellJobResourceLease,
 } from './shell-jobs.mjs';
 import {
     analyzeShellCommandEffects,
@@ -45,6 +46,7 @@ import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { resolveOptionalCwd } from './cwd-utils.mjs';
 import { scrubLoaderVars, scrubProviderSecrets } from '../env-scrub.mjs';
 import { resolveSessionCwd, stateFilePath, wrapPowerShellWithCwdProbe, wrapBashWithCwdProbe } from '../shell-state.mjs';
+import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 
 // Post-exec drift detection. After a foreground shell command, compare the
 // live mtime+size of files mixdog has already read this session against their
@@ -263,7 +265,11 @@ export async function executeBashTool(args, workDir, options = {}) {
         const shouldCreate = args.create === true || !userProvidedSession;
         effectiveArgs = { ...effectiveArgs, create: shouldCreate };
         try {
-            return await executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, { abortSignal: combinedPersistAbort.signal, sessionId: options?.sessionId });
+            return await executeBashSessionTool('bash_session', effectiveArgs, bashWorkDir, {
+                abortSignal: combinedPersistAbort.signal,
+                sessionId: options?.sessionId,
+                resourceAdmission: options?.resourceAdmission || resourceAdmission,
+            });
         } finally {
             combinedPersistAbort.cleanup();
         }
@@ -406,24 +412,50 @@ export async function executeBashTool(args, workDir, options = {}) {
             wrappedCommand = command;
         }
         if (runInBackground) {
-            const job = startBackgroundShellJob({
-                command: wrappedCommand,
-                timeoutMs: timeout,
-                workDir: bashWorkDir,
-                mergeStderr,
-                spawnEnv,
-                shell,
-                shellArg,
-                shellArgs,
-                shellType,
-                // Per-terminal session stamp: the dispatching terminal's
-                // claude.exe pid (server-main threads callerSession.clientHostPid).
-                clientHostPid: options?.clientHostPid,
-            });
-            if (job && job.error) return formatShellToolFailure(job.error);
-            let task;
+            let asyncAbortSignal = null;
+            try { asyncAbortSignal = (await getAbortSignalForSession(options?.sessionId)) || null; }
+            catch { asyncAbortSignal = null; }
+            const combinedAsyncAbort = _combineAbortSignals(asyncAbortSignal, options?.abortSignal || null);
+            let asyncLease = null;
+            let job;
             try {
-                task = registerBackgroundTask({
+                asyncLease = await (options?.resourceAdmission || resourceAdmission).acquire('shell', {
+                    signal: combinedAsyncAbort.signal,
+                    label: String(command).replace(/\s+/g, ' ').slice(0, 120),
+                    dependency: 'detached',
+                });
+                if (combinedAsyncAbort.signal?.aborted) {
+                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled before spawn');
+                }
+                job = await startBackgroundShellJob({
+                    command: wrappedCommand,
+                    timeoutMs: timeout,
+                    workDir: bashWorkDir,
+                    mergeStderr,
+                    spawnEnv,
+                    shell,
+                    shellArg,
+                    shellArgs,
+                    shellType,
+                    // Per-terminal session stamp: the dispatching terminal's
+                    // claude.exe pid (server-main threads callerSession.clientHostPid).
+                    clientHostPid: options?.clientHostPid,
+                    ...(options?.shellJobRuntime || {}),
+                });
+                if (job && job.error) {
+                    if (job.rollbackPending && attachShellJobResourceLease(job.jobId, asyncLease, { allowUnpersisted: true })) {
+                        asyncLease = null;
+                    }
+                    return formatShellToolFailure(job.error);
+                }
+                if (combinedAsyncAbort.signal?.aborted) {
+                    try { killShellJob(job.jobId); } catch {}
+                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled before registration');
+                }
+                if (job && !job.error && attachShellJobResourceLease(job.jobId, asyncLease)) {
+                    asyncLease = null;
+                }
+                const task = registerBackgroundTask({
                     taskId: job.jobId,
                     surface: 'shell',
                     operation: 'shell',
@@ -446,26 +478,31 @@ export async function executeBashTool(args, workDir, options = {}) {
                     resultType: 'shell_task_result',
                     cancel: () => killShellJob(job.jobId),
                 });
-            } catch (err) {
-                try { killShellJob(job.jobId); } catch { /* best effort cleanup */ }
-                return formatShellToolFailure(normalizeErrorMessage(err instanceof Error ? err.message : String(err)));
+                if (combinedAsyncAbort.signal?.aborted) {
+                    try { killShellJob(job.jobId); } catch {}
+                    cancelBackgroundTask(job.jobId, 'cancelled before background registration completed');
+                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled during registration');
+                }
+                // Wire a one-shot completion push so the dispatching session learns
+                // the background task finished (no polling tool is auto-driven).
+                try {
+                    watchBackgroundShellJob(job.jobId, {
+                        notifyFn: typeof options?.notifyFn === 'function' ? options.notifyFn : null,
+                        callerSessionId: options?.callerSessionId || options?.sessionId,
+                        routingSessionId: options?.routingSessionId,
+                        clientHostPid: options?.clientHostPid,
+                    });
+                } catch { /* watcher arm is best-effort; never blocks the spawn */ }
+                return _prependDestructiveWarning(command, renderBackgroundTask(task));
+            } catch (error) {
+                if (job?.jobId && !job.error) {
+                    try { killShellJob(job.jobId); } catch {}
+                }
+                return formatShellToolFailure(normalizeErrorMessage(error instanceof Error ? error.message : String(error)));
+            } finally {
+                combinedAsyncAbort.cleanup();
+                try { await asyncLease?.release(); } catch {}
             }
-            // Wire a one-shot completion push so the dispatching session learns
-            // the background task finished (no polling tool is auto-driven). The
-            // notify ctx is threaded down from the MCP dispatch frame
-            // (server-main agentContext / _dispatchByModule) the same way the
-            // agent/explore-style tools receive notifyFn/routingSessionId/clientHostPid.
-            // Missing notifyFn (e.g. a non-MCP caller) degrades to a stderr
-            // diagnostic inside watchBackgroundShellJob — never fails the spawn.
-            try {
-                watchBackgroundShellJob(job.jobId, {
-                    notifyFn: typeof options?.notifyFn === 'function' ? options.notifyFn : null,
-                    callerSessionId: options?.callerSessionId || options?.sessionId,
-                    routingSessionId: options?.routingSessionId,
-                    clientHostPid: options?.clientHostPid,
-                });
-            } catch { /* watcher arm is best-effort; never blocks the spawn */ }
-            return _prependDestructiveWarning(command, renderBackgroundTask(task));
         }
 
         let bashAbortSignal = null;

package/src/runtime/agent/orchestrator/tools/builtin/lib/list-helpers.mjs

@@ -0,0 +1,46 @@
+import {
+    buildNotFoundHint,
+    finalizeReadFamilyEnoentTail,
+    tryReadFamilyEnoentRedirect,
+} from '../search-path-diagnostics.mjs';
+import { normalizeErrorMessage } from '../path-diagnostics.mjs';
+import { isUncPath, isWindowsDevicePath, hasUnsafeWin32Component } from '../device-paths.mjs';
+import { normalizeOutputPath } from '../path-utils.mjs';
+
+/** undefined / invalid / negative → defaultCap; 0 = no page cap (absolute caps still apply). */
+export async function readFamilyPathEnoentOrError(workDir, fullPath, inputPath, args, options, err, rerunTool) {
+    const redirected = await tryReadFamilyEnoentRedirect({
+        workDir,
+        resolvedPath: fullPath,
+        requestedPath: inputPath,
+        errCode: err?.code,
+        options,
+        rerun: (target, opts) => rerunTool({ ...args, path: target }, workDir, opts),
+    });
+    if (redirected) return redirected;
+    const msg = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+    const hint = buildNotFoundHint(workDir, fullPath, 'List', err?.code);
+    return msg + finalizeReadFamilyEnoentTail(hint, inputPath, err?.code);
+}
+
+export function normalizeListHeadLimit(raw, defaultCap) {
+    if (raw === undefined || raw === null || raw === '') return defaultCap;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0) return defaultCap;
+    return Math.floor(n);
+}
+
+// UNC / Windows-device / NTFS-ADS guard for directory-walking modes
+// (list / tree / find). Walking a UNC share auto-authenticates to the
+// remote host (NTLM hash leak); a raw-device / reserved-name path can
+// hang or grant raw access. Mirrors the read path's string-based checks.
+// Returns an Error string when the path is blocked, else null.
+export function listGuardPath(p) {
+    if (typeof isUncPath === 'function' && isUncPath(p))
+        return `Error: cannot walk UNC / SMB path (network credential leak risk): ${normalizeOutputPath(p)}`;
+    if (typeof isWindowsDevicePath === 'function' && isWindowsDevicePath(p))
+        return `Error: cannot walk Windows device path (reserved name or raw-device namespace): ${normalizeOutputPath(p)}`;
+    if (typeof hasUnsafeWin32Component === 'function' && hasUnsafeWin32Component(p))
+        return `Error: cannot walk Windows path with trailing dot/space or NTFS ADS suffix (bypasses device guard): ${normalizeOutputPath(p)}`;
+    return null;
+}

package/src/runtime/agent/orchestrator/tools/builtin/lib/search-grep-chunks.mjs

@@ -0,0 +1,173 @@
+import { splitGrepLinePrefix } from '../grep-formatting.mjs';
+
+const GREP_RESULT_LINE_SKIP = /^\[(?:Showing|total|pattern set|capped|warning|redirected|regex parse)/;
+const GREP_CHUNK_AGGREGATE_FLOOR = 200;
+const GREP_CHUNK_AGGREGATE_DEFAULT = 800;
+const GREP_CHUNK_AGGREGATE_MAX = 4000;
+
+export function chunkPatternList(patterns, cap) {
+    const out = [];
+    for (let i = 0; i < patterns.length; i += cap) out.push(patterns.slice(i, i + cap));
+    return out;
+}
+
+export function computeGrepChunkAggregateBudget(offset, headLimit, headLimitCoerced) {
+    if (headLimitCoerced === 0 && headLimit === Infinity) return GREP_CHUNK_AGGREGATE_MAX;
+    if (headLimit === Infinity) return GREP_CHUNK_AGGREGATE_DEFAULT;
+    const need = offset + headLimit;
+    return Math.min(GREP_CHUNK_AGGREGATE_MAX, Math.max(GREP_CHUNK_AGGREGATE_FLOOR, need * 2));
+}
+
+function compareGrepLinesByPathLine(a, b) {
+    const pa = splitGrepLinePrefix(a);
+    const pb = splitGrepLinePrefix(b);
+    if (!pa && !pb) return String(a).localeCompare(String(b));
+    if (!pa) return 1;
+    if (!pb) return -1;
+    const byPath = pa.path.localeCompare(pb.path);
+    if (byPath !== 0) return byPath;
+    return pa.lineNo - pb.lineNo;
+}
+
+function deriveGrepCountLinesFromMatchContent(lines) {
+    const byPath = new Map();
+    for (const line of lines) {
+        const split = splitGrepLinePrefix(line);
+        if (!split || split.delimiter !== ':') continue;
+        if (!byPath.has(split.path)) byPath.set(split.path, new Set());
+        byPath.get(split.path).add(split.lineNo);
+    }
+    return [...byPath.entries()]
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([path, lineNos]) => `${path}:${lineNos.size}`);
+}
+
+function isGrepMatchLine(line) {
+    const split = splitGrepLinePrefix(line);
+    return !!(split && split.delimiter === ':');
+}
+
+function grepMatchAnchorKey(line) {
+    const split = splitGrepLinePrefix(line);
+    if (!split || split.delimiter !== ':') return '';
+    return `${split.path}\0${split.lineNo}`;
+}
+
+function parseGrepContextBlocksInSegment(segmentLines) {
+    const blocks = [];
+    let pending = [];
+    let i = 0;
+    while (i < segmentLines.length) {
+        const line = segmentLines[i];
+        if (isGrepMatchLine(line)) {
+            const blockLines = pending.concat([line]);
+            pending = [];
+            i += 1;
+            while (i < segmentLines.length) {
+                const next = segmentLines[i];
+                if (next === '--' || isGrepMatchLine(next)) break;
+                blockLines.push(next);
+                i += 1;
+            }
+            const anchor = grepMatchAnchorKey(line);
+            if (anchor) blocks.push({ anchor, lines: blockLines });
+            continue;
+        }
+        pending.push(line);
+        i += 1;
+    }
+    return blocks;
+}
+
+function compareGrepAnchorKeys(a, b) {
+    const [pa, la] = String(a || '').split('\0');
+    const [pb, lb] = String(b || '').split('\0');
+    const byPath = pa.localeCompare(pb);
+    if (byPath !== 0) return byPath;
+    return Number(la) - Number(lb);
+}
+
+function mergeGrepContextChunkLines(lines) {
+    const segments = [];
+    let current = [];
+    for (const line of lines) {
+        if (line === '--') {
+            segments.push(current);
+            current = [];
+        } else {
+            current.push(line);
+        }
+    }
+    segments.push(current);
+    const seen = new Set();
+    const blocks = [];
+    for (const segment of segments) {
+        if (!segment.length) continue;
+        for (const block of parseGrepContextBlocksInSegment(segment)) {
+            if (!block.anchor || seen.has(block.anchor)) continue;
+            seen.add(block.anchor);
+            blocks.push(block);
+        }
+    }
+    blocks.sort((a, b) => compareGrepAnchorKeys(a.anchor, b.anchor));
+    const out = [];
+    for (const block of blocks) {
+        if (out.length) out.push('--');
+        out.push(...block.lines);
+    }
+    return out;
+}
+
+export function mergeGrepChunkLines(lines, { outputMode, beforeN, afterN, contextN }) {
+    const hasContext = (beforeN > 0 || afterN > 0 || contextN > 0);
+    if (outputMode === 'count') {
+        return deriveGrepCountLinesFromMatchContent(lines);
+    }
+    if (outputMode === 'files_with_matches') {
+        const seen = new Set();
+        const out = [];
+        for (const line of lines) {
+            const path = String(line || '').trim();
+            if (!path || seen.has(path)) continue;
+            seen.add(path);
+            out.push(path);
+        }
+        out.sort((a, b) => a.localeCompare(b));
+        return out;
+    }
+    if (outputMode === 'content' && hasContext) {
+        return mergeGrepContextChunkLines(lines);
+    }
+    const matches = new Map();
+    for (const line of lines) {
+        const split = splitGrepLinePrefix(line);
+        if (split && split.delimiter === ':') {
+            const key = `${split.path}\0${split.lineNo}`;
+            if (!matches.has(key)) matches.set(key, line);
+        }
+    }
+    return [...matches.values()].sort(compareGrepLinesByPathLine);
+}
+
+export function extractGrepChunkResultLines(body, room = Infinity) {
+    const text = String(body || '').trim();
+    if (!text || /^Error:/i.test(text)) return { error: text || 'Error: empty grep chunk result' };
+    if (/^\(no matches\)/i.test(text)) return { lines: [], truncated: false };
+    const rawLines = text.split('\n');
+    const childShowingTruncated = rawLines.some((line) => /^\[Showing /i.test(String(line || '').trim()));
+    const lines = rawLines.filter((line) => line && !GREP_RESULT_LINE_SKIP.test(line));
+    const truncated = childShowingTruncated
+        || (Number.isFinite(room) && room >= 0 && lines.length >= room);
+    return { lines, truncated };
+}
+
+export function buildGrepChunkMergePrefix(patternChunkCount, truncated, aggregateBudget, outputMode = 'content') {
+    if (patternChunkCount <= 1 && !truncated) return '';
+    const parts = [];
+    if (patternChunkCount > 1) parts.push(`pattern set split into ${patternChunkCount} chunks`);
+    if (truncated) {
+        parts.push(`chunk results truncated at aggregate budget ${aggregateBudget} lines; results are partial`);
+        if (outputMode === 'count') parts.push('counts are lower bounds (>=)');
+    }
+    return `[${parts.join('; ')}]\n`;
+}

package/src/runtime/agent/orchestrator/tools/builtin/lib/search-input-helpers.mjs

@@ -0,0 +1,117 @@
+import { isAbsolute } from 'path';
+import { canonicalizeGlobSlashes, normalizeOutputPath } from '../path-utils.mjs';
+import {
+    relativePathPrefix,
+} from '../search-path-diagnostics.mjs';
+import {
+    normalizeGrepLine,
+    splitGrepCountPrefix,
+    splitGrepLinePrefix,
+} from '../grep-formatting.mjs';
+
+export function expandLegacyEscapedAlternationPattern(rawPattern) {
+    if (typeof rawPattern !== 'string' || !rawPattern.includes('\\|')) return null;
+    const parts = rawPattern.split('\\|').map((part) => part.trim()).filter(Boolean);
+    return parts.length > 1 ? parts : null;
+}
+
+export function relativeGrepLine(line, workDir, pathOnly = false, outputMode = 'content', filenameOmitted = false) {
+    const normalized = normalizeGrepLine(line, pathOnly, outputMode, filenameOmitted);
+    if (!workDir) return normalized;
+    if (pathOnly) return relativePathPrefix(normalized, workDir);
+    if (filenameOmitted) return normalized;
+    const split = splitGrepLinePrefix(normalized);
+    if (split) {
+        return relativePathPrefix(normalized.slice(0, split.pathEnd), workDir) + normalized.slice(split.pathEnd);
+    }
+    if (outputMode === 'count') {
+        const countSplit = splitGrepCountPrefix(normalized);
+        if (countSplit) {
+            return relativePathPrefix(normalized.slice(0, countSplit.pathEnd), workDir) + normalized.slice(countSplit.pathEnd);
+        }
+    }
+    return normalized;
+}
+
+export function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => typeof value === 'string' && value)));
+}
+
+export function isRgRegexParseError(err) {
+    const msg = `${err?.stderr || ''}\n${err?.message || err || ''}`;
+    return /regex parse error/i.test(msg);
+}
+
+export function regexPatternToFixedTerms(pattern) {
+    const raw = String(pattern || '');
+    if (!raw) return [];
+    return raw
+        .split(/\\?\|/g)
+        .map((part) => part.trim())
+        .map((part) => part
+            .replace(/\\[bB]/g, '')
+            .replace(/^\^/, '')
+            .replace(/\$$/, '')
+            .replace(/\\([\\.^$*+?()[\]{}|/-])/g, '$1')
+            .trim())
+        .filter((part) => part.length > 0);
+}
+
+export function coerceNonNegInt(value) {
+    if (value === undefined || value === null || value === '') return null;
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0) return NaN;
+    return Math.floor(n);
+}
+
+export function globMtimeTiePath(entry) {
+    const p = String(entry?.path ?? entry?.full ?? '');
+    return process.platform === 'win32' ? p.toLocaleLowerCase() : p;
+}
+
+export function splitGlobString(value) {
+    const out = [];
+    const str = String(value);
+    let depth = 0;
+    let token = '';
+    const flush = () => {
+        const trimmed = token.trim();
+        if (trimmed) out.push(trimmed);
+        token = '';
+    };
+    for (const ch of str) {
+        if (ch === '{') {
+            depth++;
+            token += ch;
+        } else if (ch === '}') {
+            if (depth > 0) depth--;
+            token += ch;
+        } else if (depth === 0 && (ch === ',' || /\s/.test(ch))) {
+            flush();
+        } else {
+            token += ch;
+        }
+    }
+    flush();
+    return out;
+}
+
+export function isRedundantAllFilesGlob(value) {
+    const g = canonicalizeGlobSlashes(String(value || '').trim())
+        .replace(/^\.\//, '')
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '');
+    return g === '**/*' || g === '**';
+}
+
+export function parseGrepCountLine(line) {
+    const text = String(line || '');
+    const searchFrom = /^[A-Za-z]:/.test(text) ? 2 : 0;
+    const idx = text.lastIndexOf(':');
+    if (idx <= searchFrom) return null;
+    const count = Number(text.slice(idx + 1));
+    if (!Number.isFinite(count) || count <= 0) return null;
+    const path = text.slice(0, idx);
+    if (!path) return null;
+    return { path, count };
+}