@nexrall/code-core 1.4.73 → 1.4.75

package/dist/plugins/eval.js

@@ -0,0 +1,470 @@
+"use strict";
+// S21 — `nex plugin eval`: run a plugin against a suite of test cases and score
+// the results (Claude Code's `claude plugin eval`, shipped in their W37).
+//
+// This file is the PURE half: case discovery/parsing, the grader vocabulary,
+// the trace-based graders, and the scoring/aggregation. The caller owns ALL
+// I/O — spawning each run, reading the child's event log, and judging (the
+// `llm`/`baseline` graders call a model through an injected `judge` function so
+// this module stays unit-testable without a backend).
+//
+// Suite layout (CC's, minus what we do not support yet — see below):
+//
+//   my-plugin/
+//     evals/
+//       first-case/
+//         prompt.md          # frontmatter = case fields; body = the prompt
+//         graders/
+//           criteria.md      # frontmatter = grader; body = llm criteria
+//           skill-fired.md
+//       results/             # written by each run; never discovered as a case
+//
+// Deliberately NOT supported yet (refused loudly, never silently skipped):
+//   · case.yaml — needs a real YAML parser, which this repo does not carry
+//     (the frontmatter reader is "not a full YAML parser" by design). A case
+//     that ships one is an ERROR, because silently ignoring its fields would
+//     run a DIFFERENT suite than the author wrote.
+//   · mock MCP servers (`evals/mocks/`) — a follow-up; a case using them is
+//     likewise refused rather than run without the mocks.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVAL_MAX_TIMEOUT_S = exports.EVAL_MAX_TURNS_CEILING = exports.EVAL_DEFAULT_TIMEOUT_S = exports.EVAL_DEFAULT_MAX_TURNS = exports.EVAL_DEFAULT_THRESHOLD = exports.EVAL_MAX_RUNS = exports.EVAL_DEFAULT_RUNS = exports.EVAL_SCHEMA_VERSION = void 0;
+exports.parseList = parseList;
+exports.parseGraderFile = parseGraderFile;
+exports.parseEvalCase = parseEvalCase;
+exports.discoverEvalCases = discoverEvalCases;
+exports.targetText = targetText;
+exports.evaluateGrader = evaluateGrader;
+exports.gradersForArm = gradersForArm;
+exports.scoreRun = scoreRun;
+exports.aggregateReport = aggregateReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const frontmatter_1 = require("../util/frontmatter");
+const nestedInstructions_1 = require("../agent/nestedInstructions");
+exports.EVAL_SCHEMA_VERSION = 1;
+/** CC's default: each case runs three times. */
+exports.EVAL_DEFAULT_RUNS = 3;
+exports.EVAL_MAX_RUNS = 50;
+exports.EVAL_DEFAULT_THRESHOLD = 1.0;
+exports.EVAL_DEFAULT_MAX_TURNS = 10;
+exports.EVAL_DEFAULT_TIMEOUT_S = 300;
+/** CC caps both; larger values are refused, not clamped silently. */
+exports.EVAL_MAX_TURNS_CEILING = 200;
+exports.EVAL_MAX_TIMEOUT_S = 3600;
+/** `match: count:N` in a regex grader. */
+const COUNT_RE = /^count:(\d+)$/;
+// ─── Parsing helpers ─────────────────────────────────────────────────────────
+/** `[a, b]` / `a, b` / `a` → ['a','b'] — the two shapes real files use. */
+function parseList(value) {
+    if (value === undefined)
+        return [];
+    const inner = value.trim().replace(/^\[|\]$/g, '');
+    return inner
+        .split(',')
+        .map((s) => s.trim().replace(/^["']|["']$/g, ''))
+        .filter(Boolean);
+}
+function parsePositiveInt(value, dflt, ceiling, what) {
+    if (value === undefined || value.trim() === '')
+        return dflt;
+    const n = Number(value.trim());
+    if (!Number.isInteger(n) || n < 1)
+        throw new Error(`${what} must be a positive integer (got "${value}")`);
+    if (n > ceiling)
+        throw new Error(`${what} ${n} exceeds the ceiling of ${ceiling}`);
+    return n;
+}
+/**
+ * One grader file → EvalGrader. Throws on anything that would make the grader
+ * silently unscorable (unknown type, missing pattern/tool/path, bad count).
+ */
+function parseGraderFile(file, raw) {
+    const { meta, body } = (0, frontmatter_1.parseFrontmatter)(raw);
+    const type = (meta.type ?? '').trim();
+    if (!['regex', 'tool_used', 'tool_order', 'file_exists', 'llm', 'baseline'].includes(type)) {
+        throw new Error(`grader "${file}": type must be regex|tool_used|tool_order|file_exists|llm|baseline (got "${meta.type ?? ''}")`);
+    }
+    const weightRaw = (meta.weight ?? '1').trim();
+    const weight = Number(weightRaw);
+    if (!Number.isFinite(weight) || weight <= 0)
+        throw new Error(`grader "${file}": weight must be a positive number`);
+    const arm = (meta.arm ?? 'both').trim() === 'with-only' ? 'with-only' : 'both';
+    if (meta.arm !== undefined && !['both', 'with-only'].includes(meta.arm.trim())) {
+        throw new Error(`grader "${file}": arm must be both or with-only (got "${meta.arm}")`);
+    }
+    const g = { file, type, weight, arm };
+    if (type === 'regex') {
+        if (!meta.pattern)
+            throw new Error(`grader "${file}": regex grader needs a \`pattern\``);
+        g.pattern = meta.pattern;
+        g.flags = meta.flags?.trim() || '';
+        const match = (meta.match ?? 'contains').trim();
+        if (!(match === 'contains' || match === 'not_contains' || COUNT_RE.test(match))) {
+            throw new Error(`grader "${file}": match must be contains | not_contains | count:<n> (got "${match}")`);
+        }
+        g.match = match;
+        const target = (meta.target ?? 'last_message').trim();
+        if (!['last_message', 'trace', 'file'].includes(target)) {
+            throw new Error(`grader "${file}": target must be last_message | trace | file (got "${target}")`);
+        }
+        g.target = target;
+        if (target === 'file') {
+            if (!meta.path)
+                throw new Error(`grader "${file}": target "file" needs a \`path\``);
+            g.pathPattern = meta.path;
+        }
+    }
+    else if (type === 'tool_used') {
+        if (!meta.tool)
+            throw new Error(`grader "${file}": tool_used grader needs a \`tool\``);
+        g.tool = meta.tool.trim();
+        g.inputMatch = meta.input_match?.trim() || undefined;
+        g.min = parsePositiveInt(meta.min, 1, 10000, 'min');
+        g.max = meta.max !== undefined && meta.max.trim() !== '' ? parsePositiveInt(meta.max, 1, 10000, 'max') : undefined;
+        if (g.max !== undefined && g.max < (g.min ?? 1))
+            throw new Error(`grader "${file}": max < min`);
+    }
+    else if (type === 'tool_order') {
+        if (!meta.before || !meta.after)
+            throw new Error(`grader "${file}": tool_order needs \`before\` and \`after\``);
+        g.before = meta.before.trim();
+        g.after = meta.after.trim();
+    }
+    else if (type === 'file_exists') {
+        if (!meta.path)
+            throw new Error(`grader "${file}": file_exists needs a \`path\``);
+        g.path = meta.path.trim();
+        const ex = (meta.exists ?? 'true').trim().toLowerCase();
+        g.exists = !(ex === 'false' || ex === '0' || ex === 'no');
+    }
+    else {
+        // llm / baseline: criteria from the body (the file IS the criteria text).
+        const criteria = body.trim();
+        if (!criteria)
+            throw new Error(`grader "${file}": ${type} grader needs criteria in the file body`);
+        g.criteria = criteria;
+        if (type === 'llm') {
+            const focus = (meta.focus ?? 'last_message').trim();
+            if (!['last_message', 'trace'].includes(focus)) {
+                throw new Error(`grader "${file}": focus must be last_message | trace (got "${focus}")`);
+            }
+            g.focus = focus;
+        }
+        else {
+            if (!meta.baseline_file)
+                throw new Error(`grader "${file}": baseline grader needs \`baseline_file\``);
+            g.baselineFile = meta.baseline_file.trim();
+        }
+    }
+    return g;
+}
+/** One case directory → EvalCase. See the header for the layout. */
+function parseEvalCase(dir) {
+    const promptFile = path.join(dir, 'prompt.md');
+    const caseYaml = path.join(dir, 'case.yaml');
+    if (fs.existsSync(caseYaml)) {
+        throw new Error('case.yaml is not supported yet (this repo carries no YAML parser) — move its fields into prompt.md frontmatter');
+    }
+    if (fs.existsSync(path.join(dir, 'mocks'))) {
+        throw new Error('mock MCP servers (mocks/) are not supported yet');
+    }
+    let raw;
+    try {
+        raw = fs.readFileSync(promptFile, 'utf-8');
+    }
+    catch {
+        throw new Error('no prompt.md (a case needs one; case.yaml alone is not supported yet)');
+    }
+    const { meta, body } = (0, frontmatter_1.parseFrontmatter)(raw);
+    const prompt = body.trim();
+    if (!prompt)
+        throw new Error('prompt.md has an empty prompt body');
+    const gradersDir = path.join(dir, 'graders');
+    let graderFiles;
+    try {
+        graderFiles = fs
+            .readdirSync(gradersDir)
+            .filter((f) => f.endsWith('.md'))
+            .sort();
+    }
+    catch {
+        throw new Error('no graders/ directory (at least one grader is required)');
+    }
+    if (!graderFiles.length)
+        throw new Error('graders/ holds no .md files (at least one grader is required)');
+    const graders = graderFiles.map((f) => parseGraderFile(f, fs.readFileSync(path.join(gradersDir, f), 'utf-8')));
+    return {
+        name: meta.name?.trim() || path.basename(dir),
+        dir,
+        prompt,
+        runs: parsePositiveInt(meta.runs, exports.EVAL_DEFAULT_RUNS, exports.EVAL_MAX_RUNS, 'runs'),
+        maxTurns: parsePositiveInt(meta.max_turns, exports.EVAL_DEFAULT_MAX_TURNS, exports.EVAL_MAX_TURNS_CEILING, 'max_turns'),
+        timeoutSeconds: parsePositiveInt(meta.timeout_seconds, exports.EVAL_DEFAULT_TIMEOUT_S, exports.EVAL_MAX_TIMEOUT_S, 'timeout_seconds'),
+        allowedTools: parseList(meta.allowed_tools),
+        tags: parseList(meta.tags),
+        expectedOutcome: meta.expected_outcome?.trim() || undefined,
+        graders,
+    };
+}
+/** Every case under `<pluginDir>/evals` (the results dir is never a case). */
+function discoverEvalCases(pluginDir) {
+    const evalsDir = path.join(pluginDir, 'evals');
+    const errors = [];
+    let names;
+    try {
+        names = fs
+            .readdirSync(evalsDir)
+            .filter((n) => n !== 'results' && !n.startsWith('.'))
+            .sort();
+    }
+    catch {
+        return { cases: [], errors: [] };
+    }
+    const cases = [];
+    for (const n of names) {
+        const dir = path.join(evalsDir, n);
+        let isDir;
+        try {
+            isDir = fs.statSync(dir).isDirectory();
+        }
+        catch {
+            isDir = false;
+        }
+        if (!isDir)
+            continue;
+        try {
+            cases.push(parseEvalCase(dir));
+        }
+        catch (e) {
+            errors.push({ dir, error: e.message });
+        }
+    }
+    return { cases, errors };
+}
+// ─── The graders ─────────────────────────────────────────────────────────────
+/** The text a grader's target names. Exposed for tests and the report's `why`. */
+function targetText(g, trace) {
+    if (g.type === 'regex' && g.target === 'trace') {
+        return trace.toolCalls.map((c) => `${c.tool} ${JSON.stringify(c.input)}`).join('\n');
+    }
+    if (g.type === 'regex' && g.target === 'file') {
+        const content = trace.readFile(g.pathPattern ?? '');
+        return content; // null = no matching file; the grader fails with that reason
+    }
+    if (g.type === 'llm' && g.focus === 'trace') {
+        return trace.toolCalls.map((c) => `${c.tool} ${JSON.stringify(c.input)}`).join('\n');
+    }
+    return trace.lastMessage;
+}
+/** null = the pattern does not compile; the grader FAILS with that reason. */
+function compileRegex(g) {
+    try {
+        return new RegExp(g.pattern ?? '', g.flags ?? '');
+    }
+    catch {
+        return null;
+    }
+}
+function countMatches(re, text) {
+    // A global clone: a non-global regex .match() returns the first hit only, and
+    // count:N must count every occurrence.
+    const flags = re.flags.includes('g') ? re.flags : re.flags + 'g';
+    return (text.match(new RegExp(re.source, flags)) ?? []).length;
+}
+/**
+ * Score ONE grader over ONE run. Async because llm/baseline call the judge.
+ * A grader that cannot be evaluated FAILS (with the reason in `why`) — it must
+ * never pass by accident, or a broken suite would look green.
+ */
+async function evaluateGrader(g, trace, judge) {
+    try {
+        switch (g.type) {
+            case 'regex': {
+                const text = targetText(g, trace);
+                if (text === null)
+                    return { passed: false, why: `no file matches ${g.pathPattern} (regex ${g.pattern})` };
+                const re = compileRegex(g);
+                if (!re)
+                    return { passed: false, why: `invalid pattern: ${g.pattern}` };
+                const match = g.match ?? 'contains';
+                if (match === 'contains') {
+                    return { passed: re.test(text), why: re.test(text) ? 'found' : `not found in ${g.target ?? 'last_message'}` };
+                }
+                if (match === 'not_contains') {
+                    return {
+                        passed: !re.test(text),
+                        why: re.test(text) ? `unexpectedly found in ${g.target ?? 'last_message'}` : 'absent, as required',
+                    };
+                }
+                const cm = COUNT_RE.exec(match);
+                const want = Number(cm[1]);
+                const got = countMatches(re, text);
+                return { passed: got === want, why: `count ${got}, wanted ${want}` };
+            }
+            case 'tool_used': {
+                const n = trace.toolCalls.filter((c) => {
+                    if (c.tool !== g.tool)
+                        return false;
+                    if (!g.inputMatch)
+                        return true;
+                    try {
+                        return new RegExp(g.inputMatch).test(JSON.stringify(c.input));
+                    }
+                    catch {
+                        return false;
+                    }
+                }).length;
+                const min = g.min ?? 1;
+                const ok = n >= min && (g.max === undefined || n <= g.max);
+                return {
+                    passed: ok,
+                    why: `${g.tool} used ${n} time(s)` +
+                        (ok ? '' : ` (wanted ${g.max === undefined ? `>=${min}` : `${min}..${g.max}`})`),
+                };
+            }
+            case 'tool_order': {
+                const iBefore = trace.toolCalls.findIndex((c) => c.tool === g.before);
+                const iAfter = trace.toolCalls.findIndex((c) => c.tool === g.after);
+                if (iBefore === -1)
+                    return { passed: false, why: `${g.before} never called` };
+                if (iAfter === -1)
+                    return { passed: false, why: `${g.after} never called` };
+                return iBefore < iAfter
+                    ? { passed: true, why: `${g.before} before ${g.after}` }
+                    : { passed: false, why: `${g.after} came before ${g.before}` };
+            }
+            case 'file_exists': {
+                const re = (0, nestedInstructions_1.pathGlobToRegExp)(g.path ?? '');
+                const hit = re ? trace.files.some((f) => re.test(f)) : false;
+                const want = g.exists !== false;
+                return {
+                    passed: hit === want,
+                    why: want ? (hit ? 'present' : 'missing') : hit ? 'present, wanted absent' : 'absent, as required',
+                };
+            }
+            case 'llm': {
+                if (!judge)
+                    return { passed: false, why: 'no judge available (pass --judge-model or provide NEXRALL_EVAL_JUDGE_MODEL)' };
+                const focusText = targetText(g, trace) ?? '';
+                const verdict = await judge({ criteria: g.criteria ?? '', focusText });
+                if (verdict === null)
+                    return { passed: false, why: 'judge could not be reached' };
+                return { passed: verdict, why: verdict ? 'judge: pass' : 'judge: fail' };
+            }
+            case 'baseline': {
+                if (!judge)
+                    return { passed: false, why: 'no judge available (pass --judge-model)' };
+                const baselineText = trace.readFile(g.baselineFile ?? '');
+                if (baselineText === null)
+                    return { passed: false, why: `baseline file ${g.baselineFile} not found` };
+                const verdict = await judge({ criteria: g.criteria ?? '', focusText: trace.lastMessage, baselineText });
+                if (verdict === null)
+                    return { passed: false, why: 'judge could not be reached' };
+                return { passed: verdict, why: verdict ? 'at least as good as the baseline' : 'worse than the baseline' };
+            }
+        }
+    }
+    catch (e) {
+        return { passed: false, why: e.message };
+    }
+}
+/** Which graders count in an arm: with-only graders never score the baseline. */
+function gradersForArm(graders, arm) {
+    return arm === 'with' ? graders : graders.filter((g) => g.arm !== 'with-only');
+}
+/** Score one run: weighted fraction of its graders that passed. */
+async function scoreRun(graders, trace, judge, arm) {
+    const active = gradersForArm(graders, arm);
+    if (!active.length)
+        return { score: 0, results: [] };
+    const results = [];
+    let passedWeight = 0;
+    let totalWeight = 0;
+    for (const g of active) {
+        const v = await evaluateGrader(g, trace, judge);
+        totalWeight += g.weight;
+        if (v.passed)
+            passedWeight += g.weight;
+        results.push({ file: g.file, type: g.type, weight: g.weight, passed: v.passed, why: v.why });
+    }
+    return { score: totalWeight > 0 ? passedWeight / totalWeight : 0, results };
+}
+const mean = (xs) => (xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : null);
+/**
+ * Fold run outcomes into the report. Case score = mean of the plugin-arm run
+ * scores; `delta` = with − without (null when the baseline did not run).
+ * A case PASSES at ≥ threshold (CC's default: every grader, every run).
+ */
+function aggregateReport(i) {
+    const cases = i.cases.map((c) => {
+        const withScore = mean(c.with.map((r) => r.score));
+        const withoutScore = mean(c.without.map((r) => r.score));
+        return {
+            name: c.name,
+            with: c.with,
+            without: c.without,
+            withScore,
+            withoutScore,
+            delta: withScore !== null && withoutScore !== null ? withScore - withoutScore : null,
+            passed: withScore !== null && withScore >= i.threshold,
+        };
+    });
+    const scores = cases.map((c) => c.withScore).filter((s) => s !== null);
+    const deltas = cases.map((c) => c.delta).filter((d) => d !== null);
+    const allRuns = cases.flatMap((c) => [...c.with, ...c.without]);
+    const reported = allRuns.filter((r) => r.costReported && r.costUsd !== null);
+    return {
+        schemaVersion: exports.EVAL_SCHEMA_VERSION,
+        plugin: i.plugin,
+        startedAt: i.startedAt,
+        durationMs: i.durationMs,
+        threshold: i.threshold,
+        runs: i.runs,
+        ...(i.judgeModel ? { judgeModel: i.judgeModel } : {}),
+        ...(i.partial ? { partial: true, partialReason: i.partial.reason } : {}),
+        cases,
+        errors: i.errors,
+        aggregates: {
+            casesPassed: cases.filter((c) => c.passed).length,
+            casesTotal: cases.length,
+            overallScore: scores.length ? scores.reduce((a, b) => a + b, 0) / scores.length : 0,
+            meanDelta: deltas.length ? deltas.reduce((a, b) => a + b, 0) / deltas.length : null,
+        },
+        costUsd: reported.reduce((a, r) => a + (r.costUsd ?? 0), 0),
+        costMissing: allRuns.length - reported.length,
+    };
+}
+//# sourceMappingURL=eval.js.map

package/dist/tools/executor.d.ts

@@ -29,6 +29,12 @@ export declare function runCapture(cmd: string, args: string[], opts: {
     timeout: number;
     maxBuffer: number;
 }): Promise<CaptureResult>;
+/**
+ * Path of the ripgrep binary this process would use — the NEXRALL_RG_PATH override, `rg`
+ * from PATH, or an editor-bundled copy — or undefined when the grep fallback is in charge.
+ * `nex doctor` reports through this so its verdict matches what the search tools do.
+ */
+export declare function resolveRipgrepBinary(): string | undefined;
 /**
  * Glob → anchored RegExp. Scans the pattern once, so the `*` / `?` rules can never
  * rewrite the regex emitted for `**` (the old chained .replace() calls turned

package/dist/tools/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAyuCtE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAmB,GAAG,MAAM,CAgBpG;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;CAC/B;AACD,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACzD,OAAO,CAAC,aAAa,CAAC,CAmDxB;AAw1CD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAuCnD;AAq8BD,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EAMlC,QAAQ,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtC,OAAO,CAAC,UAAU,CAAC,CAmCrB"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAyuCtE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAmB,GAAG,MAAM,CAgBpG;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC;CAC/B;AACD,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACzD,OAAO,CAAC,aAAa,CAAC,CAmDxB;AAqID;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,SAAS,CAEzD;AA2zCD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAuCnD;AAq8BD,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EAMlC,QAAQ,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACtC,OAAO,CAAC,UAAU,CAAC,CAmCrB"}

package/dist/tools/executor.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.capExternalOutput = capExternalOutput;
 exports.runCapture = runCapture;
+exports.resolveRipgrepBinary = resolveRipgrepBinary;
 exports.globToRegex = globToRegex;
 exports.executeTool = executeTool;
 const fs = __importStar(require("fs"));
@@ -1314,18 +1315,119 @@ function runCapture(cmd, args, opts) {
 }
 // Detect ripgrep once per process — preferred over grep (faster, respects .gitignore).
 //
-// Binary resolution: NEXRALL_RG_PATH first (the VS Code extension points it at the rg
-// that ships inside every VS Code / Cursor install, so users without a system rg still
-// get the fast, .gitignore-aware path), then `rg` on PATH. Before this, a machine with
-// no rg installed silently fell back to grep and a full, ignore-unaware directory walk.
+// Binary resolution, in order:
+//   1. NEXRALL_RG_PATH (the VS Code extension points it at its own bundled rg),
+//   2. `rg` on PATH,
+//   3. the copy bundled inside every VS Code-family editor — the one ripgrep most dev
+//      machines actually have, even when nothing put it on PATH. Layouts differ by
+//      editor and version (asar.unpacked vs plain node_modules, per-arch subdir), so
+//      probe a short list of known shapes instead of trusting any single path,
+//   4. common user-install dirs (Homebrew, cargo, /usr/local, snap).
+// Before the editor probe, a machine with no rg on PATH silently fell back to grep and
+// a full, ignore-unaware directory walk even though an editor next door shipped rg 15.
 let _rgChecked = false;
 let _rgAvailable = false;
 let _rgBin = 'rg';
+/** One editor's bundled-ripgrep candidates, given its `Resources/app`-equivalent dir. */
+function bundledRipgrepPaths(appDir, platform, arch) {
+    const exe = platform === 'win32' ? 'rg.exe' : 'rg';
+    const other = arch === 'arm64' ? 'x64' : 'arm64';
+    const out = [];
+    for (const nm of ['node_modules.asar.unpacked', 'node_modules']) {
+        out.push(path.join(appDir, nm, '@vscode', 'ripgrep', 'bin', exe));
+        for (const tag of [`${platform}-${arch}`, `${platform}-${other}`]) {
+            out.push(path.join(appDir, nm, '@vscode', 'ripgrep-universal', 'bin', tag, exe));
+        }
+    }
+    return out;
+}
+function listDirsSafe(dir) {
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+function editorRipgrepCandidates(platform, arch) {
+    const out = [];
+    if (platform === 'darwin') {
+        const apps = [
+            'Visual Studio Code.app',
+            'Visual Studio Code - Insiders.app',
+            'VSCodium.app',
+            'Cursor.app',
+            'Windsurf.app',
+            'Antigravity IDE.app',
+        ];
+        for (const root of ['/Applications', path.join(os.homedir(), 'Applications')]) {
+            for (const app of apps) {
+                out.push(...bundledRipgrepPaths(path.join(root, app, 'Contents', 'Resources', 'app'), platform, arch));
+            }
+        }
+    }
+    else if (platform === 'win32') {
+        const appDirs = [];
+        if (process.env.LOCALAPPDATA) {
+            appDirs.push(path.join(process.env.LOCALAPPDATA, 'Programs', 'Microsoft VS Code'));
+        }
+        if (process.env.ProgramFiles) {
+            appDirs.push(path.join(process.env.ProgramFiles, 'Microsoft VS Code'));
+        }
+        appDirs.push(path.join(os.homedir(), 'AppData', 'Local', 'Programs', 'Microsoft VS Code'));
+        for (const dir of appDirs)
+            out.push(...bundledRipgrepPaths(path.join(dir, 'resources', 'app'), platform, arch));
+    }
+    else {
+        for (const root of ['/usr/share/code', '/usr/lib/code', '/opt/visual-studio-code', '/snap/code/current']) {
+            out.push(...bundledRipgrepPaths(path.join(root, 'resources', 'app'), platform, arch));
+        }
+        // Remote/server installs keep one directory per commit hash or server name.
+        for (const base of ['.vscode-server', '.cursor-server', '.windsurf-server', '.vscodium-server']) {
+            const home = path.join(os.homedir(), base);
+            for (const dir of listDirsSafe(path.join(home, 'bin'))) {
+                out.push(...bundledRipgrepPaths(path.join(home, 'bin', dir), platform, arch));
+            }
+            for (const dir of listDirsSafe(path.join(home, 'cli', 'servers'))) {
+                out.push(...bundledRipgrepPaths(path.join(home, 'cli', 'servers', dir, 'server'), platform, arch));
+                out.push(...bundledRipgrepPaths(path.join(home, 'cli', 'servers', dir), platform, arch));
+            }
+        }
+    }
+    return out;
+}
+function ripgrepCandidates() {
+    const out = [];
+    const env = process.env.NEXRALL_RG_PATH?.trim();
+    if (env)
+        out.push(env);
+    out.push('rg');
+    if (process.platform === 'win32')
+        out.push('rg.exe');
+    out.push(...editorRipgrepCandidates(process.platform, process.arch));
+    const home = os.homedir();
+    if (process.platform === 'darwin') {
+        out.push('/opt/homebrew/bin/rg', '/usr/local/bin/rg', path.join(home, '.cargo', 'bin', 'rg'));
+    }
+    else if (process.platform === 'win32') {
+        out.push(path.join(home, '.cargo', 'bin', 'rg.exe'));
+    }
+    else {
+        out.push('/usr/bin/rg', '/usr/local/bin/rg', '/snap/bin/rg', path.join(home, '.local', 'bin', 'rg'), path.join(home, '.cargo', 'bin', 'rg'));
+    }
+    return [...new Set(out)];
+}
 function ripgrepAvailable() {
     if (!_rgChecked) {
         _rgChecked = true;
-        const candidates = [process.env.NEXRALL_RG_PATH, 'rg'].filter((c) => !!c);
-        for (const bin of candidates) {
+        for (const bin of ripgrepCandidates()) {
+            // Skip absolute paths that plainly don't exist (other machines' editor bundles):
+            // a miss still costs a spawnSync, and the editor list alone can hold dozens.
+            if (path.isAbsolute(bin) && !fs.existsSync(bin))
+                continue;
             const probe = (0, child_process_1.spawnSync)(bin, ['--version'], { encoding: 'utf-8', timeout: 3000 });
             if (probe.status === 0) {
                 _rgBin = bin;
@@ -1340,6 +1442,14 @@ function ripgrepAvailable() {
 function rgBin() {
     return _rgBin;
 }
+/**
+ * Path of the ripgrep binary this process would use — the NEXRALL_RG_PATH override, `rg`
+ * from PATH, or an editor-bundled copy — or undefined when the grep fallback is in charge.
+ * `nex doctor` reports through this so its verdict matches what the search tools do.
+ */
+function resolveRipgrepBinary() {
+    return ripgrepAvailable() ? _rgBin : undefined;
+}
 // ── Cross-file breakage warning ──────────────────────────────────────────────
 // After an edit removes/renames an exported symbol, scan the rest of the repo for
 // surviving references. Returns a short warning string (or '' when clean). Best-

package/dist/types.d.ts

@@ -495,6 +495,16 @@ export interface AgentLoopOptions {
      * @peer-name: ...") the way Claude Code's own inline preview does.
      */
     onPeerMessage?: (messages: import('./agent/peerTransport').PeerMessage[]) => void;
+    /**
+     * Fired once per turn boundary where cross-session task-board notes (see
+     * agent/taskEvents.ts) are being folded into the conversation — lets a UI
+     * show the same event the model is about to see ("the task you were
+     * waiting on just completed") instead of the user having to run `nex tasks`
+     * to find out. Only CONSEQUENTIAL events produce notes (`completed` /
+     * `reopened` / `removed` with live waiters), so a UI on this callback is
+     * exactly as quiet as the model is.
+     */
+    onTaskNotes?: (notes: import('./agent/taskEvents').TaskEventNote[]) => void;
     /**
      * This session's own peer identity (see agent/peerRegistry.ts's
      * registerPeer), if it registered as a discoverable peer at all —