agentic-qe 3.15.9 → 3.15.11

package/dist/shared/io/payload-path-guard.js

@@ -0,0 +1,190 @@
+/**
+ * #1126: decide which caller-named paths a task handler may read.
+ *
+ * A task payload can come from MCP task_submit, task_orchestrate, a domain
+ * MCP tool or `aqe task submit`, so every handler that reads a path from its
+ * payload applies the same rule as code indexing (#1096) and sast-scan
+ * (#1144): a path is read only when its realpath is a regular file (or, for a
+ * target to walk, a directory) inside the project root's realpath. A path
+ * spelled outside the root is refused before any filesystem call, so the
+ * reason does not reveal whether it exists, and an outside directory is never
+ * listed. A symlink pointing out, a device such as /dev/zero or a directory
+ * is refused by name, and so is a file over the size limit when the handler
+ * reads files whole.
+ *
+ * The check runs inside each handler rather than at one MCP entry point, so
+ * no route into the handler can skip it. A refusal is a CallerInputError: it
+ * is not retried and does not count toward the domain circuit breaker.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { findProjectRoot } from '../../kernel/project-root.js';
+import { ok, err } from '../types/index.js';
+import { CallerInputError } from '../error-utils.js';
+/** Largest file a handler reads whole into memory (the #1144 sast limit). */
+export const MAX_PAYLOAD_FILE_BYTES = 2 * 1024 * 1024;
+/** True when `candidate` is `root` or lies beneath it (both absolute). */
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+/**
+ * The path the kernel will open for `requested`. path.resolve() collapses
+ * `..` as text, but the kernel follows a symlink before applying `..`, so
+ * `src/link/../x` opens a file beside the link's target (review of #1162).
+ * Keep the caller's spelling and let realpath resolve it the kernel's way.
+ */
+function kernelPath(basePath, requested) {
+    return path.isAbsolute(requested) ? requested : `${basePath}${path.sep}${requested}`;
+}
+/**
+ * For a path that does not exist: resolve its deepest existing ancestor the
+ * kernel's way and append the missing names. Returns null when the ancestor
+ * resolves outside the root or a missing name is `..`.
+ */
+async function resolveMissing(raw, rootReal) {
+    const missing = [];
+    let dir = raw;
+    for (;;) {
+        missing.unshift(path.basename(dir));
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+        const real = await fs.realpath(dir).catch(() => null);
+        if (!real)
+            continue;
+        if (!isWithin(rootReal, real) || missing.some(name => name === '..'))
+            return null;
+        return path.join(real, ...missing.filter(name => name !== '.' && name !== ''));
+    }
+}
+/**
+ * Split `paths` into those a handler may read and those it must refuse.
+ * `resolved[i]` is the symlink-free path checked for `accepted[i]` (relative
+ * to basePath when the request was relative); a handler opens that path,
+ * never the caller's string.
+ */
+export async function confinePayloadPaths(paths, options = {}) {
+    const projectRoot = options.projectRoot ?? findProjectRoot();
+    const basePath = options.basePath ?? process.cwd();
+    const accepted = [];
+    const resolved = [];
+    const skipped = [];
+    const rootLexical = path.resolve(projectRoot);
+    const rootReal = await fs.realpath(projectRoot).catch(() => rootLexical);
+    const baseReal = await fs.realpath(basePath).catch(() => null);
+    // A relative request stays relative, to the base's realpath: the kernel
+    // resolves it through the same real directories, and records keep the
+    // caller's spelling for ordinary paths ('tests/a.test.ts').
+    const accept = (requested, real) => {
+        accepted.push(requested);
+        resolved.push(!path.isAbsolute(requested) && baseReal ? (path.relative(baseReal, real) || '.') : real);
+    };
+    for (const requested of paths) {
+        const lexical = path.resolve(basePath, requested);
+        // Spelled outside the root: refused before any filesystem call, so the
+        // reason cannot reveal whether an outside path exists.
+        if (!isWithin(rootLexical, lexical) && !isWithin(rootReal, lexical)) {
+            skipped.push({ path: requested, reason: 'outside-project-root' });
+            continue;
+        }
+        const raw = kernelPath(basePath, requested);
+        let real;
+        try {
+            real = await fs.realpath(raw);
+        }
+        catch (error) {
+            const code = error.code;
+            const missing = code === 'ENOENT' || code === 'ENOTDIR';
+            // A dangling symlink exists by name: it is not a missing file to accept.
+            const dangling = await fs.lstat(raw).then(() => true, () => false);
+            const target = missing && !dangling && options.allowMissing ? await resolveMissing(raw, rootReal) : null;
+            if (target)
+                accept(requested, target);
+            else
+                skipped.push({ path: requested, reason: missing ? 'not-found' : 'unreadable' });
+            continue;
+        }
+        if (!isWithin(rootReal, real)) {
+            skipped.push({ path: requested, reason: 'outside-project-root' });
+            continue;
+        }
+        // stat, never open: a FIFO, device or directory is refused unread.
+        const stat = await fs.stat(real).catch(() => null);
+        if (!stat) {
+            skipped.push({ path: requested, reason: 'unreadable' });
+        }
+        else if (!(stat.isFile() || (options.allowDirectory && stat.isDirectory()))) {
+            skipped.push({ path: requested, reason: 'not-a-file' });
+        }
+        else if (options.maxBytes !== undefined && stat.size > options.maxBytes) {
+            skipped.push({ path: requested, reason: 'too-large' });
+        }
+        else {
+            accept(requested, real);
+        }
+    }
+    return { accepted, resolved, skipped };
+}
+function describe(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+/**
+ * Handler-side check for a payload path list: `value` must be an array of
+ * non-empty path strings, and every entry must pass confinePayloadPaths.
+ * Otherwise the whole request is refused and nothing is read. Returns the real
+ * paths that were checked; the handler reads those, not the payload strings.
+ * `taskType` and `field` name the payload in the error.
+ */
+export async function requirePayloadFiles(taskType, field, value, options = {}) {
+    const context = `Invalid ${taskType} payload`;
+    if (!Array.isArray(value)) {
+        return err(new CallerInputError(`${context}: '${field}' must be an array of file paths, got ${describe(value)}`));
+    }
+    for (let i = 0; i < value.length; i++) {
+        const entry = value[i];
+        if (typeof entry !== 'string' || entry.trim() === '') {
+            return err(new CallerInputError(`${context}: '${field}[${i}]' must be a non-empty string, got ${describe(entry)}`));
+        }
+        if (entry.includes('\0')) {
+            return err(new CallerInputError(`${context}: '${field}[${i}]' contains a null byte`));
+        }
+    }
+    const { resolved, skipped } = await confinePayloadPaths(value, options);
+    if (skipped.length > 0)
+        return err(refusal(context, field, skipped, options));
+    return ok(resolved);
+}
+function refusal(context, field, skipped, options) {
+    const limit = options.maxBytes !== undefined
+        ? `, at most ${Math.round(options.maxBytes / (1024 * 1024))} MB each`
+        : '';
+    const kinds = options.allowDirectory ? 'regular files or directories' : 'regular files';
+    return new CallerInputError(`${context}: ${field} cannot be read: ${skipped.map(s => `${s.path} (${s.reason})`).join(', ')}. ` +
+        `Pass ${kinds} inside the project${limit}.`);
+}
+/**
+ * Handler-side check for one caller-named path (a file, or with
+ * allowDirectory a directory to walk). Returns the real path that was
+ * checked, which the handler reads instead of the payload string, or an error
+ * naming the reason without reading anything.
+ */
+export async function requirePayloadPath(taskType, field, value, options = {}) {
+    const context = `Invalid ${taskType} payload`;
+    if (typeof value !== 'string' || value.trim() === '') {
+        return err(new CallerInputError(`${context}: '${field}' must be a non-empty path string, got ${describe(value)}`));
+    }
+    if (value.includes('\0')) {
+        return err(new CallerInputError(`${context}: '${field}' contains a null byte`));
+    }
+    const { resolved, skipped } = await confinePayloadPaths([value], options);
+    if (skipped.length > 0)
+        return err(refusal(context, field, skipped, options));
+    return ok(resolved[0]);
+}
+//# sourceMappingURL=payload-path-guard.js.map

package/dist/shared/llm/providers/claude-code.js

@@ -16,6 +16,7 @@
 import { spawn } from 'node:child_process';
 import { createLLMError, } from '../interfaces.js';
 import { TokenMetricsCollector } from '../../../learning/token-tracker.js';
+import { redactLogText } from '../../../logging/redaction.js';
 /** Env vars whose presence flips the CLI from subscription to API billing. */
 export const API_BILLING_ENV_VARS = [
     'ANTHROPIC_API_KEY',
@@ -108,7 +109,9 @@ export class ClaudeCodeProvider {
             data = JSON.parse(stdout);
         }
         catch {
-            throw createLLMError(`Could not parse claude -p JSON output: ${stdout.slice(0, 200)}`, 'PROVIDER_UNAVAILABLE', { provider: 'claude-code', model, retryable: true });
+            throw createLLMError(
+            // #1150: redact, then cut, so a cut secret leaves no fragment behind.
+            `Could not parse claude -p JSON output: ${redactLogText(stdout, Number.POSITIVE_INFINITY).slice(0, 200)}`, 'PROVIDER_UNAVAILABLE', { provider: 'claude-code', model, retryable: true });
         }
         if (data.is_error) {
             throw this.classifyError(data.result ?? data.api_error_status ?? 'claude error', model);

package/dist/shared/llm/router/agent-router-config.js

@@ -278,7 +278,8 @@ export const DEFAULT_CATEGORY_CAPABILITIES = {
  */
 export function getAgentRoutingCategory(agentType) {
     // Direct lookup first
-    if (agentType in AGENT_CATEGORY_MAP) {
+    // #1136: own entries only; `constructor` is not an agent type.
+    if (Object.hasOwn(AGENT_CATEGORY_MAP, agentType)) {
         return AGENT_CATEGORY_MAP[agentType];
     }
     // Pattern-based detection

package/dist/shared/llm/translation/tool-translator.js

@@ -246,7 +246,8 @@ export function validateToolDefinition(tool) {
         const params = tool.parameters;
         const props = params.properties || {};
         for (const req of tool.required) {
-            if (!(req in props)) {
+            // #1136: own properties only.
+            if (!Object.hasOwn(props, req)) {
                 errors.push(`Required parameter '${req}' not found in properties`);
             }
         }

package/dist/shared/native-module-errors.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Native module load-failure diagnostics (issue #1173).
+ *
+ * better-sqlite3 ships a native addon whose binary is fetched/compiled by its
+ * `install` script. npm 12 blocks dependency install scripts unless they are
+ * allowed (`allowScripts`), so a plain `npm install -g agentic-qe` leaves the
+ * addon missing and the first `new Database()` throws "Could not locate the
+ * bindings file". Other installs hit the same wall via a Node upgrade
+ * (NODE_MODULE_VERSION mismatch) or an arch mismatch.
+ *
+ * These helpers recognise those failures and turn them into a message that
+ * names the cause and the exact command that fixes it, instead of a 20-line
+ * list of probed paths (or, in `aqe init`, nothing at all).
+ */
+export type NativeModuleFailureReason = 'missing-binding' | 'abi-mismatch' | 'load-failed';
+export interface NativeModuleFailure {
+    /** npm package whose native addon failed to load */
+    readonly moduleName: string;
+    readonly reason: NativeModuleFailureReason;
+    /** First line of the original error, without the probed-path list */
+    readonly detail: string;
+}
+/** Marker present in every remedy we emit; used to avoid double-wrapping. */
+export declare const NATIVE_MODULE_REMEDY_MARKER = "native module could not be loaded";
+/** Packages with install scripts that a global agentic-qe install needs allowed. */
+export declare const AQE_INSTALL_SCRIPT_PACKAGES = "agentic-qe,better-sqlite3,hnswlib-node";
+/**
+ * Classify `error` as a native-addon load failure, or return null when it is
+ * something else (I/O error, corrupt DB, lock contention, ...).
+ */
+export declare function diagnoseNativeModuleError(error: unknown, moduleName?: string): NativeModuleFailure | null;
+/** Multi-line, actionable explanation for a diagnosed native-module failure. */
+export declare function formatNativeModuleRemedy(failure: NativeModuleFailure): string;
+/**
+ * Error raised when a native addon cannot be loaded. The message carries the
+ * remedy; the original error is preserved as `cause`.
+ */
+export declare class NativeModuleLoadError extends Error {
+    readonly moduleName: string;
+    readonly reason: NativeModuleFailureReason;
+    constructor(failure: NativeModuleFailure, cause: unknown);
+}
+/**
+ * Return a NativeModuleLoadError for native-load failures, or the original
+ * error unchanged otherwise. Idempotent: an error that already carries the
+ * remedy is returned as-is.
+ */
+export declare function withNativeModuleRemedy(error: unknown, moduleName?: string): unknown;
+/** True when `error` (or its message, after re-wrapping) is a native-load failure. */
+export declare function isNativeModuleLoadFailure(error: unknown): boolean;
+//# sourceMappingURL=native-module-errors.d.ts.map

package/dist/shared/native-module-errors.js

@@ -0,0 +1,129 @@
+/**
+ * Native module load-failure diagnostics (issue #1173).
+ *
+ * better-sqlite3 ships a native addon whose binary is fetched/compiled by its
+ * `install` script. npm 12 blocks dependency install scripts unless they are
+ * allowed (`allowScripts`), so a plain `npm install -g agentic-qe` leaves the
+ * addon missing and the first `new Database()` throws "Could not locate the
+ * bindings file". Other installs hit the same wall via a Node upgrade
+ * (NODE_MODULE_VERSION mismatch) or an arch mismatch.
+ *
+ * These helpers recognise those failures and turn them into a message that
+ * names the cause and the exact command that fixes it, instead of a 20-line
+ * list of probed paths (or, in `aqe init`, nothing at all).
+ */
+import { toErrorMessage } from './error-utils.js';
+/** Marker present in every remedy we emit; used to avoid double-wrapping. */
+export const NATIVE_MODULE_REMEDY_MARKER = 'native module could not be loaded';
+/** Packages with install scripts that a global agentic-qe install needs allowed. */
+export const AQE_INSTALL_SCRIPT_PACKAGES = 'agentic-qe,better-sqlite3,hnswlib-node';
+const MISSING_BINDING_PATTERNS = [
+    /Could not locate the bindings file/i,
+];
+const ABI_MISMATCH_PATTERNS = [
+    /NODE_MODULE_VERSION/,
+    /compiled against a different Node\.js version/i,
+    /Module did not self-register/i,
+];
+const LOAD_FAILED_PATTERNS = [
+    /ERR_DLOPEN_FAILED/,
+    /invalid ELF header/i,
+    /wrong ELF class/i,
+    /incompatible architecture/i,
+    /mach-o file, but is an incompatible architecture/i,
+    /\.node: cannot open shared object file/i,
+    /is not a valid Win32 application/i,
+];
+function collectMessages(error) {
+    const parts = [];
+    let current = error;
+    // Walk the cause chain: callers commonly re-wrap the original error.
+    for (let depth = 0; current !== undefined && current !== null && depth < 5; depth++) {
+        parts.push(toErrorMessage(current));
+        const code = current.code;
+        if (typeof code === 'string')
+            parts.push(code);
+        current = current.cause;
+    }
+    return parts.join('\n');
+}
+function firstLine(message) {
+    // Drop the dangling "Tried:" that introduces the bindings package's path list.
+    const line = message.split('\n')[0].trim();
+    return line.endsWith('Tried:') ? line.slice(0, -'Tried:'.length).trimEnd() : line;
+}
+/**
+ * Classify `error` as a native-addon load failure, or return null when it is
+ * something else (I/O error, corrupt DB, lock contention, ...).
+ */
+export function diagnoseNativeModuleError(error, moduleName = 'better-sqlite3') {
+    if (error === undefined || error === null)
+        return null;
+    const text = collectMessages(error);
+    const detail = firstLine(toErrorMessage(error));
+    if (MISSING_BINDING_PATTERNS.some((p) => p.test(text))) {
+        return { moduleName, reason: 'missing-binding', detail };
+    }
+    if (ABI_MISMATCH_PATTERNS.some((p) => p.test(text))) {
+        return { moduleName, reason: 'abi-mismatch', detail };
+    }
+    if (LOAD_FAILED_PATTERNS.some((p) => p.test(text))) {
+        return { moduleName, reason: 'load-failed', detail };
+    }
+    return null;
+}
+const CAUSE_TEXT = {
+    'missing-binding': 'its compiled binary is missing. Its install script never ran — npm 12+ blocks ' +
+        'dependency install scripts unless they are allowed (allowScripts).',
+    'abi-mismatch': `it was built for a different Node.js version than the one running now (${process.version}). ` +
+        'Rebuild it after switching Node versions.',
+    'load-failed': 'the binary exists but the OS refused to load it (wrong platform/architecture or a corrupt build).',
+};
+/** Multi-line, actionable explanation for a diagnosed native-module failure. */
+export function formatNativeModuleRemedy(failure) {
+    const { moduleName } = failure;
+    return [
+        `${moduleName} ${NATIVE_MODULE_REMEDY_MARKER}: ${CAUSE_TEXT[failure.reason]}`,
+        '  Fix a global install (reinstall, naming the package):',
+        `    npm install -g agentic-qe --allow-scripts=${AQE_INSTALL_SCRIPT_PACKAGES}`,
+        '  Or rebuild just the native module in an existing global install:',
+        `    npm rebuild -g ${moduleName} --allow-scripts=${moduleName}`,
+        '  For a project-local install (devDependency), run in the project:',
+        `    npm install-scripts approve ${moduleName} && npm rebuild ${moduleName}`,
+        `  Original error: ${failure.detail}`,
+    ].join('\n');
+}
+/**
+ * Error raised when a native addon cannot be loaded. The message carries the
+ * remedy; the original error is preserved as `cause`.
+ */
+export class NativeModuleLoadError extends Error {
+    moduleName;
+    reason;
+    constructor(failure, cause) {
+        super(formatNativeModuleRemedy(failure), { cause });
+        this.name = 'NativeModuleLoadError';
+        this.moduleName = failure.moduleName;
+        this.reason = failure.reason;
+    }
+}
+/**
+ * Return a NativeModuleLoadError for native-load failures, or the original
+ * error unchanged otherwise. Idempotent: an error that already carries the
+ * remedy is returned as-is.
+ */
+export function withNativeModuleRemedy(error, moduleName = 'better-sqlite3') {
+    if (error instanceof NativeModuleLoadError)
+        return error;
+    if (toErrorMessage(error).includes(NATIVE_MODULE_REMEDY_MARKER))
+        return error;
+    const failure = diagnoseNativeModuleError(error, moduleName);
+    return failure ? new NativeModuleLoadError(failure, error) : error;
+}
+/** True when `error` (or its message, after re-wrapping) is a native-load failure. */
+export function isNativeModuleLoadFailure(error) {
+    return error instanceof NativeModuleLoadError
+        || toErrorMessage(error).includes(NATIVE_MODULE_REMEDY_MARKER)
+        || diagnoseNativeModuleError(error) !== null;
+}
+//# sourceMappingURL=native-module-errors.js.map

package/dist/shared/safe-db.js

@@ -11,6 +11,7 @@
 import Database from 'better-sqlite3';
 import { basename } from 'node:path';
 import { attemptAutoRestore } from './db-recovery.js';
+import { withNativeModuleRemedy } from './native-module-errors.js';
 /**
  * Open a SQLite database with safe defaults that prevent corruption.
  *
@@ -53,10 +54,19 @@ export function openDatabase(dbPath, opts) {
     const disableWal = process.env.AQE_DISABLE_WAL === '1' ||
         journalOverride === 'DELETE' ||
         journalOverride === 'TRUNCATE';
-    const db = new Database(dbPath, {
-        readonly,
-        fileMustExist,
-    });
+    // better-sqlite3 loads its native addon lazily, on the first construction.
+    // A missing/mismatched binary (e.g. npm 12 blocked its install script, #1173)
+    // surfaces here; rethrow it with the cause and the fix command.
+    let db;
+    try {
+        db = new Database(dbPath, {
+            readonly,
+            fileMustExist,
+        });
+    }
+    catch (err) {
+        throw withNativeModuleRemedy(err);
+    }
     // Always set busy_timeout — even for readonly connections.
     // Without this, concurrent access gets SQLITE_BUSY immediately.
     db.pragma(`busy_timeout = ${busyTimeout}`);

package/dist/shared/security/osv-client.js

@@ -7,6 +7,7 @@
  */
 import { isIP } from 'node:net';
 import { HttpClient } from '../http/index.js';
+import { getOwn } from '../utils/safe-record.js';
 import { OSVLookupError, advisoryAffectsVersion, boundedList, classifyNpmSpec, exactNpmVersion, isAdvisoryRecord, isConcreteVersion, lookupKey, lookupStatus, parseBatchBody, } from './osv-lookup.js';
 export { OSVLookupError } from './osv-lookup.js';
 const DEFAULT_BASE_URL = 'https://api.osv.dev';
@@ -198,7 +199,9 @@ export class OSVClient {
             }
             // An `npm:<real>@<range>` alias is the registry package <real>.
             const packageName = kind.kind === 'alias' ? kind.name : name;
-            const locked = lockedVersions[name] !== undefined ? exactNpmVersion(lockedVersions[name]) : null;
+            // #1157: own entries only; a dependency named `constructor` has no lock entry.
+            const lockedSpec = getOwn(lockedVersions, name);
+            const locked = lockedSpec !== undefined ? exactNpmVersion(lockedSpec) : null;
             const version = locked ?? exactNpmVersion(kind.spec);
             if (version)
                 queries.push({ name: packageName, ecosystem: 'npm', version });

package/dist/shared/test-runner-args.d.ts

@@ -35,6 +35,11 @@ export declare function jestExactPathPattern(file: string, cwd?: string): string
 /**
  * Literal test-name filter in `--flag=value` form. Mocha uses `--grep`; Jest
  * and Vitest use `--testNamePattern` (the long form of `-t`).
+ *
+ * `testName` is the full name the runner reported (describe titles, then the
+ * test title). Runners match the filter against that name joined with ' '
+ * (Jest, Mocha, Vitest 3) or ' > ' (Vitest 4+), so each space matches either
+ * separator, and the name is anchored so a retry targets that one test (#1141).
  */
 export declare function nameFilterArg(runner: NameFilterRunner, testName: string): string;
 /** True when a command vector (runner command plus its arguments) runs Jest. */

package/dist/shared/test-runner-args.js

@@ -62,9 +62,14 @@ export function jestExactPathPattern(file, cwd = process.cwd()) {
 /**
  * Literal test-name filter in `--flag=value` form. Mocha uses `--grep`; Jest
  * and Vitest use `--testNamePattern` (the long form of `-t`).
+ *
+ * `testName` is the full name the runner reported (describe titles, then the
+ * test title). Runners match the filter against that name joined with ' '
+ * (Jest, Mocha, Vitest 3) or ' > ' (Vitest 4+), so each space matches either
+ * separator, and the name is anchored so a retry targets that one test (#1141).
  */
 export function nameFilterArg(runner, testName) {
-    const pattern = escapeRegExpLiteral(testName);
+    const pattern = `^${testName.split(' ').map(escapeRegExpLiteral).join('(?: > | )')}$`;
     return runner === 'mocha' ? `--grep=${pattern}` : `--testNamePattern=${pattern}`;
 }
 /** True when a command vector (runner command plus its arguments) runs Jest. */

package/dist/shared/test-runner-process.d.ts

@@ -33,4 +33,10 @@ export interface TestRunnerProcessOptions {
  * the promise settles and before any report file is removed.
  */
 export declare function runTestRunnerProcess(command: string, args: readonly string[], options: TestRunnerProcessOptions): Promise<TestRunnerProcessResult>;
+/**
+ * Stdout of a command that must exit 0, run like runTestRunnerProcess (no
+ * blocking, process-group stop on timeout). Rejects with the ETIMEDOUT,
+ * ENOBUFS or spawn error, or with an error carrying `status` and `stderr`.
+ */
+export declare function runProcessText(command: string, args: readonly string[], options: TestRunnerProcessOptions): Promise<string>;
 //# sourceMappingURL=test-runner-process.d.ts.map

package/dist/shared/test-runner-process.js

@@ -298,4 +298,18 @@ export function runTestRunnerProcess(command, args, options) {
         proc.once('close', (status, signal) => settle(status, signal));
     });
 }
+/**
+ * Stdout of a command that must exit 0, run like runTestRunnerProcess (no
+ * blocking, process-group stop on timeout). Rejects with the ETIMEDOUT,
+ * ENOBUFS or spawn error, or with an error carrying `status` and `stderr`.
+ */
+export async function runProcessText(command, args, options) {
+    const result = await runTestRunnerProcess(command, args, options);
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        throw Object.assign(new Error(`${command} exited with ${result.status ?? result.signal}: ${result.stderr.trim()}`), { status: result.status, stderr: result.stderr });
+    }
+    return result.stdout;
+}
 //# sourceMappingURL=test-runner-process.js.map

package/dist/shared/test-runner-verdict.d.ts

@@ -1,4 +1,7 @@
-/** A runner or suite error is not an assertion result. */
+/**
+ * A runner or suite error is not an assertion result. Its message carries
+ * runner output and is returned over MCP, so it is redacted (#1122).
+ */
 export declare class TestRunnerExecutionError extends Error {
     constructor(message: string);
 }
@@ -19,6 +22,11 @@ interface RunnerReport {
         }>;
     }>;
 }
+/**
+ * Runner output quoted in an error, redacted before it is cut so a secret
+ * that straddles the cut cannot survive half-matched (#1122).
+ */
+export declare function capDiagnostics(text: string, maxLength?: number): string;
 /**
  * Preserve ordinary assertion failures, but reject incomplete/failed execution
  * that assertion counts cannot represent. Process status is authoritative even

package/dist/shared/test-runner-verdict.js

@@ -1,10 +1,21 @@
-/** A runner or suite error is not an assertion result. */
+import { redactLogText } from '../logging/redaction.js';
+/**
+ * A runner or suite error is not an assertion result. Its message carries
+ * runner output and is returned over MCP, so it is redacted (#1122).
+ */
 export class TestRunnerExecutionError extends Error {
     constructor(message) {
-        super(message);
+        super(redactLogText(message, Number.POSITIVE_INFINITY));
         this.name = 'TestRunnerExecutionError';
     }
 }
+/**
+ * Runner output quoted in an error, redacted before it is cut so a secret
+ * that straddles the cut cannot survive half-matched (#1122).
+ */
+export function capDiagnostics(text, maxLength = 4000) {
+    return redactLogText(text, Number.POSITIVE_INFINITY).slice(0, maxLength);
+}
 /**
  * Preserve ordinary assertion failures, but reject incomplete/failed execution
  * that assertion counts cannot represent. Process status is authoritative even
@@ -36,8 +47,8 @@ export function getTestRunnerExecutionError(runner, files, exitCode, counts, out
     const diagnostics = [
         ...suiteErrors.map(suite => suite.message).filter(Boolean),
         output.trim(),
-    ].filter(Boolean).join('\n').slice(0, 4000);
+    ].filter(Boolean).join('\n');
     return new TestRunnerExecutionError(`${runner} ${reason} for ${files} (exit code ${exitCode ?? 'unknown'}).` +
-        (diagnostics ? `\n${diagnostics}` : ''));
+        (diagnostics ? `\n${capDiagnostics(diagnostics)}` : ''));
 }
 //# sourceMappingURL=test-runner-verdict.js.map

package/dist/shared/types/test-frameworks.js

@@ -98,8 +98,8 @@ export function resolveFrameworkAlias(input) {
     if (ALL_TEST_FRAMEWORKS.includes(lower)) {
         return lower;
     }
-    // Alias match
-    return FRAMEWORK_ALIASES[lower];
+    // Alias match. #1157: own entries only, so `constructor` is not an alias.
+    return Object.hasOwn(FRAMEWORK_ALIASES, lower) ? FRAMEWORK_ALIASES[lower] : undefined;
 }
 /**
  * Get the language for a given file extension.

package/dist/shared/utils/namespaced-search.d.ts

@@ -30,6 +30,13 @@ export interface SearchAllKeysOptions {
     /** First request size (tests). Defaults to `DEFAULT_KEY_SCAN_PAGE_SIZE`. */
     pageSize?: number;
 }
+/**
+ * Most `search()` requests one scan may make (#1106). The limit doubles each
+ * time, so this covers more keys than any store holds (2^31 x the first page)
+ * while still guaranteeing the loop ends for a backend that never returns a
+ * short page.
+ */
+export declare const MAX_KEY_SCAN_REQUESTS = 32;
 /**
  * Every key matching `pattern`, bare (usable with `get(key, retrieve)`),
  * de-duplicated and sorted.
@@ -37,6 +44,13 @@ export interface SearchAllKeysOptions {
  * `search()` has no offset, so this widens the request until the backend
  * returns fewer keys than were asked for. That is the only point at which the
  * result is known to be complete; no cap ever truncates it.
+ *
+ * #1106: a backend that always returns at least `limit` keys (for example
+ * one that pads or repeats results) never gives a short page. After
+ * MAX_KEY_SCAN_REQUESTS this throws instead of looping forever or returning a
+ * list that may be incomplete, because callers select patterns to archive
+ * from it. A backend that ignores `limit` and returns every key still ends:
+ * the limit doubles past the key count.
  */
 export declare function searchAllKeys(memory: MemoryBackend, pattern: string, options?: SearchAllKeysOptions): Promise<string[]>;
 //# sourceMappingURL=namespaced-search.d.ts.map