agentic-qe 3.15.10 → 3.15.11

package/dist/domains/learning-optimization/services/metrics-optimizer.js

@@ -186,11 +186,21 @@ export class MetricsOptimizerService {
     async recommendStrategy(context) {
         try {
             // Search for strategies that worked well in similar contexts
-            const keys = await this.memory.search('learning:strategy:optimized:*', 100);
+            const keys = await this.memory.search('learning:strategy:optimized:*', 100, { namespace: 'learning-optimization' });
             const candidates = [];
-            for (const key of keys) {
-                const optimized = await this.memory.get(key);
-                if (optimized && optimized.confidence > 0.6) {
+            for (const found of keys) {
+                // SQLite returns bare keys; in-memory search includes the namespace.
+                // get() applies that namespace separately, as storeOptimizationResult does.
+                const prefix = 'learning-optimization:';
+                const key = found.startsWith(prefix) ? found.slice(prefix.length) : found;
+                const optimized = await this.memory.get(key, { namespace: 'learning-optimization' });
+                if (optimized
+                    && context.tags.includes(optimized.domain)
+                    && context.tags.includes(optimized.objective.metric)
+                    && (!context.objective || (context.tags.includes(context.objective.metric)
+                        && optimized.objective.metric === context.objective.metric
+                        && optimized.objective.direction === context.objective.direction))
+                    && optimized.confidence > 0.6) {
                     const contextScore = this.scoreContextMatch(optimized, context);
                     const performanceScore = optimized.improvement * optimized.confidence;
                     candidates.push({

package/dist/domains/learning-optimization/services/production-intel.js

@@ -7,6 +7,7 @@ import { ok, err } from '../../../shared/types/index.js';
 import { TimeRange } from '../../../shared/value-objects/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { rehydrateDates } from '../../../shared/utils/kv-date-rehydrate.js';
+import { createSafeRecord } from '../../../shared/utils/safe-record.js';
 const DEFAULT_CONFIG = {
     metricsRetentionDays: 90,
     anomalyThreshold: 2.5,
@@ -268,7 +269,8 @@ export class ProductionIntelService {
     async getDomainHealth(domain) {
         const timeRange = TimeRange.lastNDays(1);
         const metricsResult = await this.getMetricsHistory('*', timeRange, domain);
-        const metrics = {};
+        // #1157: metric names come from stored production metrics.
+        const metrics = createSafeRecord();
         if (metricsResult.success) {
             for (const metric of metricsResult.value) {
                 if (!metrics[metric.name]) {

package/dist/domains/security-compliance/generic-finding-dedup.d.ts

@@ -0,0 +1,40 @@
+/**
+ * #1170: drop the generic eval/exec finding that language-specific SAST
+ * already reported as code injection on the same line.
+ *
+ * The scan-security task runs text patterns over every file and SAST over
+ * JS/TS files, so one `eval()` was counted twice: once by SAST (critical,
+ * CWE-95) and once by the generic eval/exec pattern (high). Only that pair is
+ * the same finding. Other generic rules (secrets, CORS, debug mode) can flag
+ * a different value or a higher severity on a line SAST also matched, so
+ * they are always kept.
+ */
+/** Title of the generic-pattern eval/exec finding in the scan-security handler. */
+export declare const GENERIC_EVAL_EXEC_TITLE = "Dangerous eval/exec usage";
+interface LocatedFinding {
+    title: string;
+    severity?: string;
+    location: {
+        file: string;
+        line?: number;
+    };
+}
+interface SastFinding {
+    severity?: string;
+    description?: string;
+    references?: readonly string[];
+    location: {
+        file: string;
+        line?: number;
+    };
+}
+/**
+ * Generic findings without the eval/exec matches SAST already reported as
+ * CWE-95 on the same real file and line, at the same or a higher severity, so
+ * dropping one never lowers what the scan reports. `isEvalOnly` says whether a generic
+ * eval/exec match is eval alone; a line that also calls exec() is kept,
+ * since SAST's eval rule does not report the exec call.
+ */
+export declare function dropGenericEvalCoveredBySast<T extends LocatedFinding>(generic: readonly T[], sast: readonly SastFinding[], isEvalOnly: (finding: T) => boolean): Promise<T[]>;
+export {};
+//# sourceMappingURL=generic-finding-dedup.d.ts.map

package/dist/domains/security-compliance/generic-finding-dedup.js

@@ -0,0 +1,63 @@
+/**
+ * #1170: drop the generic eval/exec finding that language-specific SAST
+ * already reported as code injection on the same line.
+ *
+ * The scan-security task runs text patterns over every file and SAST over
+ * JS/TS files, so one `eval()` was counted twice: once by SAST (critical,
+ * CWE-95) and once by the generic eval/exec pattern (high). Only that pair is
+ * the same finding. Other generic rules (secrets, CORS, debug mode) can flag
+ * a different value or a higher severity on a line SAST also matched, so
+ * they are always kept.
+ */
+import { realpath } from 'node:fs/promises';
+import * as path from 'node:path';
+/** Title of the generic-pattern eval/exec finding in the scan-security handler. */
+export const GENERIC_EVAL_EXEC_TITLE = 'Dangerous eval/exec usage';
+/** CWE-95 (eval injection): SAST's eval() and Function-constructor rules. */
+function isEvalInjection(finding) {
+    return /\[CWE-95\]/.test(finding.description ?? '') ||
+        (finding.references ?? []).some(ref => /\/definitions\/95\.html$/.test(ref));
+}
+const SEVERITY_RANK = {
+    informational: 0, low: 1, medium: 2, high: 3, critical: 4,
+};
+const rank = (severity) => SEVERITY_RANK[severity ?? ''] ?? -1;
+async function realPathOf(file, cache) {
+    const resolved = path.resolve(file);
+    let real = cache.get(resolved);
+    if (real === undefined) {
+        real = await realpath(resolved).catch(() => resolved);
+        cache.set(resolved, real);
+    }
+    return real;
+}
+/**
+ * Generic findings without the eval/exec matches SAST already reported as
+ * CWE-95 on the same real file and line, at the same or a higher severity, so
+ * dropping one never lowers what the scan reports. `isEvalOnly` says whether a generic
+ * eval/exec match is eval alone; a line that also calls exec() is kept,
+ * since SAST's eval rule does not report the exec call.
+ */
+export async function dropGenericEvalCoveredBySast(generic, sast, isEvalOnly) {
+    const evalSast = sast.filter(isEvalInjection);
+    if (evalSast.length === 0)
+        return [...generic];
+    const cache = new Map();
+    // Highest SAST CWE-95 severity per real file and line.
+    const covered = new Map();
+    for (const finding of evalSast) {
+        const key = `${await realPathOf(finding.location.file, cache)}:${finding.location.line ?? 0}`;
+        covered.set(key, Math.max(covered.get(key) ?? -1, rank(finding.severity)));
+    }
+    const kept = [];
+    for (const finding of generic) {
+        const key = `${await realPathOf(finding.location.file, cache)}:${finding.location.line ?? 0}`;
+        const sastRank = covered.get(key);
+        const duplicate = finding.title === GENERIC_EVAL_EXEC_TITLE && isEvalOnly(finding) &&
+            sastRank !== undefined && sastRank >= rank(finding.severity);
+        if (!duplicate)
+            kept.push(finding);
+    }
+    return kept;
+}
+//# sourceMappingURL=generic-finding-dedup.js.map

package/dist/domains/security-compliance/services/scanners/dependency-resolver.js

@@ -22,28 +22,33 @@
  * complete, with a reason; each member can be scanned directly.
  */
 import * as fs from 'fs/promises';
+// #1161: manifests and lockfiles are read from a validated descriptor; one
+// linked out of the project, or to a device, is refused instead of read.
+import { readConfinedText } from '../../../../shared/io/confined-read.js';
 import * as path from 'path';
 import semver from 'semver';
 import { parse as parseYaml } from 'yaml';
 import { safeJsonParse } from '../../../../shared/safe-json.js';
 import { classifyNpmSpec, exactNpmVersion } from '../../../../shared/security/osv-lookup.js';
+import { createSafeRecord, getOwn, setOwn } from '../../../../shared/utils/safe-record.js';
 import { LOCKFILES, parseLockfile } from './lockfile-versions.js';
 /** The reason a workspace root's scan is not complete (#1057). */
 export const WORKSPACE_NOT_SCANNED = 'workspace member dependencies are not scanned yet (#1057); scan each member directory separately';
 const OUT_OF_SYNC = 'lockfile out of sync with package.json';
 /** All declared dependencies of a manifest (later fields win, as npm resolves them). */
 export function declaredDependencies(manifest) {
-    const out = {};
+    // #1157: a dependency named `__proto__` is kept as an own entry, not dropped.
+    const out = createSafeRecord();
     for (const field of ['peerDependencies', 'optionalDependencies', 'devDependencies', 'dependencies']) {
         for (const [name, spec] of Object.entries(manifest[field] ?? {})) {
             if (typeof spec === 'string')
-                out[name] = spec;
+                setOwn(out, name, spec);
         }
     }
     return out;
 }
 async function readManifest(file) {
-    return safeJsonParse(await fs.readFile(file, 'utf-8'));
+    return safeJsonParse(await readConfinedText(file, { outsideRoot: 'allow' }));
 }
 async function exists(file) {
     try {
@@ -123,7 +128,7 @@ async function pnpmDeclaresPackages(file) {
         const st = await fs.stat(file); // follows a link; a dangling one throws
         if (!st.isFile() || st.size > MAX_PNPM_WORKSPACE_BYTES)
             return true;
-        const text = await fs.readFile(file, 'utf-8');
+        const text = await readConfinedText(file, { outsideRoot: 'allow', maxBytes: MAX_PNPM_WORKSPACE_BYTES });
         doc = parseYaml(text, { uniqueKeys: false, merge: true, maxAliasCount: 100 });
     }
     catch {
@@ -182,7 +187,10 @@ export function resolveFromRecord(dependencies, lockedVersions = {}) {
         members: () => [],
         hasImporter: () => true,
         recordedSpec: () => null,
-        resolve: (_importer, name) => (lockedVersions[name] !== undefined ? { version: lockedVersions[name] } : undefined),
+        resolve: (_importer, name) => {
+            const version = getOwn(lockedVersions, name);
+            return version !== undefined ? { version } : undefined;
+        },
     };
     return Object.entries(dependencies).map(([name, spec]) => resolveOne(name, spec, '', index, new Set()));
 }
@@ -202,7 +210,7 @@ export async function resolveDependencies(manifestPath) {
     if (found) {
         const member = path.relative(found.dir, realManifestDir).split(path.sep).join('/');
         try {
-            const parsed = parseLockfile(found.file, await fs.readFile(path.join(found.dir, found.file), 'utf-8'));
+            const parsed = parseLockfile(found.file, await readConfinedText(path.join(found.dir, found.file), { outsideRoot: 'allow' }));
             const rootManifest = member ? await readManifest(path.join(found.dir, 'package.json')).catch(() => ({})) : manifest;
             // A member scanned directly: the root lockfile covers it if it lists the
             // importer (npm/pnpm) or, for yarn, if the root declares workspaces.

package/dist/domains/security-compliance/services/scanners/sast-scanner.js

@@ -11,6 +11,7 @@ import { ok, err } from '../../../../shared/types/index.js';
 import { ALL_SECURITY_PATTERNS, BUILT_IN_RULE_SETS } from './security-patterns.js';
 import { toError } from '../../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../../shared/safe-json.js';
+import { readConfinedFile } from '../../../../shared/io/confined-read.js';
 import { CLAUDE_TIER_MODELS, DEFAULT_OPUS_MODEL } from '../../../../shared/llm/model-registry.js';
 import { isSemgrepAvailable, runSemgrepWithRules, convertSemgrepFindings, } from '../semgrep-integration.js';
 // ============================================================================
@@ -303,8 +304,9 @@ export class SASTScanner {
         let content;
         let sourceDigest;
         try {
-            const fs = await import('fs/promises');
-            const bytes = await fs.readFile(filePath);
+            // #1161: open once and validate the opened descriptor, so a file swapped
+            // after the sast-scan path check cannot redirect the read.
+            const bytes = await readConfinedFile(filePath, { outsideRoot: 'allow' });
             sourceDigest = createHash('sha256').update(bytes).digest('hex');
             content = bytes.toString('utf8');
         }

package/dist/domains/security-compliance/services/security-auditor-sast.js

@@ -4,7 +4,7 @@
  */
 import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
-import * as fs from 'fs/promises';
+import { readConfinedText } from '../../../shared/io/confined-read.js';
 import * as path from 'path';
 /**
  * Get the default SAST vulnerability patterns for JS/TS analysis
@@ -173,7 +173,7 @@ export async function performSASTScan(findSourceFiles, shouldExclude) {
                 continue;
             }
             try {
-                const content = await fs.readFile(filePath, 'utf-8');
+                const content = await readConfinedText(filePath, { outsideRoot: 'allow' }); // #1161
                 const lines = content.split('\n');
                 filesScanned++;
                 linesScanned += lines.length;

package/dist/domains/security-compliance/services/security-auditor-secrets.js

@@ -3,7 +3,7 @@
  * Extracted from security-auditor.ts - Secret/credential detection
  */
 import { LoggerFactory } from '../../../logging/index.js';
-import * as fs from 'fs/promises';
+import { readConfinedText } from '../../../shared/io/confined-read.js';
 /**
  * Get the comprehensive set of secret detection patterns
  */
@@ -198,7 +198,7 @@ export function validateSecret(type, value) {
 export async function scanFileForSecrets(file) {
     const secrets = [];
     try {
-        const content = await fs.readFile(file.value, 'utf-8');
+        const content = await readConfinedText(file.value, { outsideRoot: 'allow' }); // #1161
         const lines = content.split('\n');
         const secretPatterns = getSecretPatterns();
         for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {

package/dist/domains/security-compliance/services/security-auditor.js

@@ -12,6 +12,7 @@
 import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs/promises';
+import { readConfinedText } from '../../../shared/io/confined-read.js';
 import * as path from 'path';
 import { ok, err } from '../../../shared/types/index.js';
 import { toError } from '../../../shared/error-utils.js';
@@ -249,7 +250,7 @@ export class SecurityAuditorService {
         const dependencies = [];
         try {
             if (ecosystem === 'npm') {
-                const content = await fs.readFile(manifest, 'utf-8');
+                const content = await readConfinedText(manifest, { outsideRoot: 'allow' }); // #1161
                 const packageJson = safeJsonParse(content);
                 const allDeps = {
                     ...packageJson.dependencies,
@@ -263,7 +264,7 @@ export class SecurityAuditorService {
                 }
             }
             else if (ecosystem === 'pip') {
-                const content = await fs.readFile(manifest, 'utf-8');
+                const content = await readConfinedText(manifest, { outsideRoot: 'allow' }); // #1161
                 const lines = content.split('\n');
                 for (const line of lines) {
                     const trimmed = line.trim();

package/dist/domains/test-execution/coordinator.d.ts

@@ -125,7 +125,8 @@ export declare class TestExecutionCoordinator extends BaseDomainCoordinator<Test
     runTests(request: SimpleTestRequest): Promise<Result<TestRunResult, Error>>;
     /**
      * Retry a run's failed tests when retries were requested, and attach what
-     * the retries did to the run (#1130). The run's own counts are unchanged.
+     * the retries did to the run (#1130). A test that passed on a retry counts
+     * as passed and flaky in the run's own counts (#1170).
      */
     private retryFailures;
     /**

package/dist/domains/test-execution/coordinator.js

@@ -9,6 +9,7 @@ import { TestExecutionEvents, createEvent, } from '../../shared/events/index.js'
 import { TestExecutorService } from './services/test-executor.js';
 import { FlakyDetectorService } from './services/flaky-detector.js';
 import { RetryHandlerService } from './services/retry-handler.js';
+import { applyRetryOutcome } from './services/retry-outcome.js';
 import { TestPrioritizerService } from './services/test-prioritizer.js';
 import { createE2ETestRunnerService, } from './services/e2e-runner.js';
 import { createDomainFinding, } from '../../coordination/consensus/domain-findings.js';
@@ -162,7 +163,8 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
     }
     /**
      * Retry a run's failed tests when retries were requested, and attach what
-     * the retries did to the run (#1130). The run's own counts are unchanged.
+     * the retries did to the run (#1130). A test that passed on a retry counts
+     * as passed and flaky in the run's own counts (#1170).
      */
     async retryFailures(run, retryCount) {
         if (!retryCount || retryCount <= 0)
@@ -179,17 +181,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         });
         if (!retried.success)
             return;
-        const byId = new Map(run.failedTests.map(t => [t.testId, t]));
-        run.retries = {
-            totalRetries: retried.value.retried,
-            nowPassing: retried.value.nowPassing,
-            stillFailing: retried.value.stillFailing,
-            tests: (retried.value.tests ?? []).map(({ testId, ...outcome }) => ({
-                name: byId.get(testId)?.testName ?? testId,
-                file: byId.get(testId)?.file ?? '',
-                ...outcome,
-            })),
-        };
+        applyRetryOutcome(run, retried.value);
     }
     /**
      * Detect test framework from file patterns and project configuration
@@ -686,11 +678,10 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
     /**
      * Record execution results for DT learning
      */
-    async recordExecutionResults(runId, testFiles, result, prioritizationInfo) {
+    async recordExecutionResults(runId, testFiles, result, _prioritizationInfo) {
         // Record each test execution for learning
         for (let i = 0; i < testFiles.length; i++) {
             const testId = this.generateTestId(testFiles[i]);
-            const info = prioritizationInfo;
             // Find if this test failed (check if it's in failed tests)
             const failedTest = result.failedTests.find(t => t.file === testFiles[i]);
             const passed = !failedTest;

package/dist/domains/test-execution/interfaces.d.ts

@@ -80,6 +80,11 @@ export interface ITestRunResult {
     fileCoverages?: IFileCoverageData[];
     /** #1130: what the requested retries of failed tests did. Absent when none were requested. */
     retries?: IRunRetrySummary;
+    /**
+     * #1170: tests that failed and then passed on a retry. They are counted in
+     * `passed`, not `failed`. Absent when no test passed on a retry.
+     */
+    flaky?: number;
 }
 /** #1130: the measured outcome of a run's retries, per failed test. */
 export interface IRunRetrySummary {
@@ -102,8 +107,13 @@ export interface ITestCaseResult {
     status: 'passed' | 'failed' | 'skipped';
     /** Runner-reported duration in ms; omitted when the runner reported none. */
     duration?: number;
-    /** The runner's failure message for a failed test, when it reported one. */
+    /**
+     * The runner's failure message for a failed test, or for the failed first
+     * attempt of a flaky test, when it reported one.
+     */
     failureMessage?: string;
+    /** #1170: the test failed and then passed on a retry, so it is `passed`. */
+    flaky?: true;
 }
 export interface IFileCoverageData {
     path: string;

package/dist/domains/test-execution/services/retry-outcome.d.ts

@@ -0,0 +1,18 @@
+/**
+ * #1170: a run's final outcome after its failed tests were retried.
+ *
+ * A test that failed and then passed on a retry is passed, and flaky: it
+ * leaves `failed`/`failedTests`, its runner test case reads `passed` with
+ * `flaky: true`, and the run counts it in `flaky`. A test whose retries all
+ * failed, or whose retry matched no test, stays failed.
+ */
+import type { IRetryResult, ITestRunResult } from '../interfaces';
+/**
+ * Default retries of a failed test, shared by `aqe test execute` and MCP
+ * `test_execute_parallel` so both surfaces rerun a failure the same number of
+ * times (#1170).
+ */
+export declare const DEFAULT_TEST_RETRY_COUNT = 2;
+/** Attach the retry outcome to `run` and move tests that passed on retry from failed to passed. */
+export declare function applyRetryOutcome(run: ITestRunResult, retried: IRetryResult): void;
+//# sourceMappingURL=retry-outcome.d.ts.map

package/dist/domains/test-execution/services/retry-outcome.js

@@ -0,0 +1,53 @@
+/**
+ * #1170: a run's final outcome after its failed tests were retried.
+ *
+ * A test that failed and then passed on a retry is passed, and flaky: it
+ * leaves `failed`/`failedTests`, its runner test case reads `passed` with
+ * `flaky: true`, and the run counts it in `flaky`. A test whose retries all
+ * failed, or whose retry matched no test, stays failed.
+ */
+/**
+ * Default retries of a failed test, shared by `aqe test execute` and MCP
+ * `test_execute_parallel` so both surfaces rerun a failure the same number of
+ * times (#1170).
+ */
+export const DEFAULT_TEST_RETRY_COUNT = 2;
+/** Attach the retry outcome to `run` and move tests that passed on retry from failed to passed. */
+export function applyRetryOutcome(run, retried) {
+    const byId = new Map(run.failedTests.map(t => [t.testId, t]));
+    const outcomes = retried.tests ?? [];
+    const summary = {
+        totalRetries: retried.retried,
+        nowPassing: retried.nowPassing,
+        stillFailing: retried.stillFailing,
+        tests: outcomes.map(({ testId, ...outcome }) => ({
+            name: byId.get(testId)?.testName ?? testId,
+            file: byId.get(testId)?.file ?? '',
+            ...outcome,
+        })),
+    };
+    run.retries = summary;
+    const passedOnRetry = new Set(outcomes.filter(o => o.passed && !o.unmatched).map(o => o.testId));
+    const recovered = run.failedTests.filter(t => passedOnRetry.has(t.testId));
+    if (recovered.length === 0)
+        return;
+    run.failedTests = run.failedTests.filter(t => !passedOnRetry.has(t.testId));
+    run.failed = Math.max(0, run.failed - recovered.length);
+    run.passed += recovered.length;
+    run.flaky = (run.flaky ?? 0) + recovered.length;
+    if (run.failed === 0 && run.status === 'failed')
+        run.status = 'passed';
+    if (run.testCases) {
+        const pending = [...recovered];
+        run.testCases = run.testCases.map(testCase => {
+            if (testCase.status !== 'failed')
+                return testCase;
+            const index = pending.findIndex(t => t.testName === testCase.name && t.file === testCase.file);
+            if (index < 0)
+                return testCase;
+            pending.splice(index, 1);
+            return { ...testCase, status: 'passed', flaky: true };
+        });
+    }
+}
+//# sourceMappingURL=retry-outcome.js.map

package/dist/domains/test-generation/coordinator.js

@@ -9,7 +9,7 @@
  */
 import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
-import { readFile } from 'node:fs/promises';
+import { readConfinedText } from '../../shared/io/confined-read.js';
 import { ok, err, } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
 // Opt-in free-tier local test generation (cross-pollination plan 06, D7-wire/D8/D9).
@@ -425,7 +425,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             return null;
         let code = '';
         try {
-            code = await readFile(src, 'utf8');
+            code = await readConfinedText(src, { outsideRoot: 'allow' }); // #1161
         }
         catch {
             return null; // unreadable → fall back

package/dist/domains/test-generation/services/pattern-matcher.js

@@ -7,7 +7,7 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import ts from 'typescript';
-import * as fs from 'fs';
+import { readConfinedTextSync } from '../../../shared/io/confined-read.js';
 import * as path from 'path';
 import { ok, err } from '../../../shared/types/index.js';
 import { NomicEmbedder, EMBEDDING_CONFIG } from '../../../shared/embeddings/index.js';
@@ -45,7 +45,7 @@ export class PatternMatcherService {
             // Read file content
             let content;
             try {
-                content = fs.readFileSync(filePath, 'utf-8');
+                content = readConfinedTextSync(filePath, { outsideRoot: 'allow' }); // #1161
             }
             catch {
                 return err(new Error(`Cannot read file: ${filePath}`));
@@ -737,7 +737,7 @@ export class PatternMatcherService {
             // Read the file content
             let content;
             try {
-                content = fs.readFileSync(file, 'utf-8');
+                content = readConfinedTextSync(file, { outsideRoot: 'allow' }); // #1161
             }
             catch {
                 // File doesn't exist or can't be read, return empty
@@ -1068,7 +1068,7 @@ class TypeScriptASTParser {
             this.sourceCode = content;
         }
         else {
-            this.sourceCode = fs.readFileSync(filePath, 'utf-8');
+            this.sourceCode = readConfinedTextSync(filePath, { outsideRoot: 'allow' }); // #1161
         }
         this.sourceFile = ts.createSourceFile(path.basename(filePath), this.sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
         return this.sourceFile;

package/dist/domains/test-generation/services/test-generator.js

@@ -10,7 +10,7 @@ import { generateBehaviorExamples } from './behavior-examples.js';
 import { validateBehaviorExamples } from './behavior-example-validation.js';
 import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
-import * as fs from 'fs';
+import { readConfinedTextSync } from '../../../shared/io/confined-read.js';
 import * as path from 'path';
 import ts from 'typescript';
 import { ok, err } from '../../../shared/types/index.js';
@@ -445,7 +445,7 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         let codeAnalysis = null;
         let sourceContent = '';
         try {
-            sourceContent = fs.readFileSync(sourceFile, 'utf-8');
+            sourceContent = readConfinedTextSync(sourceFile, { outsideRoot: 'allow' }); // #1161
             codeAnalysis = await this.analyzeSourceCode(sourceContent, sourceFile);
         }
         catch {

package/dist/governance/evolution-pipeline-integration.js

@@ -19,6 +19,7 @@
 import { governanceFlags } from './feature-flags.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { createSafeRecord } from '../shared/utils/safe-record.js';
 // ============================================================================
 // Feature Flag Helpers
 // ============================================================================
@@ -799,7 +800,8 @@ export class EvolutionPipelineIntegration {
      * Group array by key function
      */
     groupBy(array, keyFn) {
-        const groups = {};
+        // #1157: keys come from recorded rule applications.
+        const groups = createSafeRecord();
         for (const item of array) {
             const key = keyFn(item);
             if (!groups[key]) {

package/dist/hooks/cross-phase-hooks.js

@@ -12,6 +12,7 @@ import { join } from 'path';
 import { parse as parseYaml } from 'yaml';
 import { getCrossPhaseMemory, } from '../memory/cross-phase-memory.js';
 import { captureHooksConfigSnapshot, validateHookUrl, classifyHookExit, } from './security/index.js';
+import { createSafeRecord } from '../shared/utils/safe-record.js';
 // =============================================================================
 // Hook Executor
 // =============================================================================
@@ -79,7 +80,8 @@ export class CrossPhaseHookExecutor {
         // IMP-07: Runtime kill-switch check
         if (process.env.AQE_HOOKS_DISABLED === 'true')
             return {};
-        const injectedSignals = {};
+        // #1157: agent names come from the hooks YAML file.
+        const injectedSignals = createSafeRecord();
         const matchingHooks = this.filterManagedHooks(Object.entries(this.config.hooks).filter(([_, hook]) => hook.trigger.event === 'phase-start' &&
             hook.trigger.phase === phaseName));
         for (const [hookName, hook] of matchingHooks) {

package/dist/init/init-wizard-steps.js

@@ -11,6 +11,7 @@ import { createSkillsInstaller } from './skills-installer.js';
 import { createAgentsInstaller } from './agents-installer.js';
 import { createN8nInstaller } from './n8n-installer.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { isNativeModuleLoadFailure, withNativeModuleRemedy } from '../shared/native-module-errors.js';
 import { openDatabase } from '../shared/safe-db.js';
 import { safeJsonParse } from '../shared/safe-json.js';
 // ============================================================================
@@ -112,7 +113,7 @@ export async function initializePersistenceDatabase(projectRoot) {
         const mod = await import('better-sqlite3');
         Database = mod.default;
     }
-    catch (error) {
+    catch {
         throw new Error('SQLite persistence REQUIRED but better-sqlite3 is not installed.\n' +
             'Install it with: npm install better-sqlite3\n' +
             'If you see native compilation errors, ensure build tools are installed:\n' +
@@ -157,6 +158,9 @@ export async function initializePersistenceDatabase(projectRoot) {
         return true;
     }
     catch (error) {
+        if (isNativeModuleLoadFailure(error)) {
+            throw new Error(`SQLite persistence initialization FAILED: ${toErrorMessage(withNativeModuleRemedy(error))}`, { cause: error });
+        }
         throw new Error(`SQLite persistence initialization FAILED: ${error}\n` +
             `Database path: ${dbPath}\n` +
             'Ensure the directory is writable and has sufficient disk space.');

package/dist/init/phases/04-database.js

@@ -17,6 +17,8 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { BasePhase, } from './phase-interface.js';
 import { getAQEVersion } from '../types.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+import { isNativeModuleLoadFailure, withNativeModuleRemedy } from '../../shared/native-module-errors.js';
 /**
  * Database phase - initializes SQLite persistence via UnifiedMemoryManager
  */
@@ -106,6 +108,11 @@ export class DatabasePhase extends BasePhase {
             };
         }
         catch (error) {
+            // A native-addon load failure (#1173) is not a disk/permission problem:
+            // report the cause and the install fix instead of the generic advice.
+            if (isNativeModuleLoadFailure(error)) {
+                throw new Error(`SQLite persistence initialization FAILED: ${toErrorMessage(withNativeModuleRemedy(error))}`, { cause: error });
+            }
             throw new Error(`SQLite persistence initialization FAILED: ${error}\n` +
                 `Database path: ${dbPath}\n` +
                 'Ensure the directory is writable and has sufficient disk space.');