agentic-qe 3.15.10 → 3.15.11

package/dist/coordination/handlers/coverage-stderr.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Caller-facing summary of a coverage runner's stderr.
+ *
+ * #1150: the summary reaches `provenance.notes` of a SUCCESS result, where the
+ * #1139 error backstop never sees it, so it is redacted here. Redaction runs
+ * BEFORE slicing: a slice boundary that cut a token or connection string in
+ * half would leave a fragment the redaction patterns no longer recognise.
+ * The collector therefore keeps a wide raw window at each end of the stream;
+ * each window is redacted whole, and only then are the short head and tail
+ * taken from it. A secret cut by a window edge lies far outside the part
+ * that is kept.
+ */
+/** Raw stderr kept at each end of the stream, before redaction. */
+export declare const STDERR_WINDOW_BYTES: number;
+/**
+ * Summarise a runner's stderr for a caller: the FIRST error-looking line (or
+ * the first ~512 bytes) plus the last ~2 KB (#995 review NB-C). A tail alone
+ * loses the cause when a long stack follows it — a vitest config syntax error
+ * prints `[PARSE_ERROR] …` first and then kilobytes of frames. `head` and
+ * `tail` are the raw windows at each end; both are redacted before slicing.
+ */
+export declare function summarizeStderr(head: string, tail: string, totalBytes: number): string;
+//# sourceMappingURL=coverage-stderr.d.ts.map

package/dist/coordination/handlers/coverage-stderr.js

@@ -0,0 +1,39 @@
+/**
+ * Caller-facing summary of a coverage runner's stderr.
+ *
+ * #1150: the summary reaches `provenance.notes` of a SUCCESS result, where the
+ * #1139 error backstop never sees it, so it is redacted here. Redaction runs
+ * BEFORE slicing: a slice boundary that cut a token or connection string in
+ * half would leave a fragment the redaction patterns no longer recognise.
+ * The collector therefore keeps a wide raw window at each end of the stream;
+ * each window is redacted whole, and only then are the short head and tail
+ * taken from it. A secret cut by a window edge lies far outside the part
+ * that is kept.
+ */
+import { redactLogText } from '../../logging/redaction.js';
+/** Raw stderr kept at each end of the stream, before redaction. */
+export const STDERR_WINDOW_BYTES = 64 * 1024;
+const STDERR_TAIL_BYTES = 2048;
+const STDERR_HEAD_BYTES = 4096;
+const STDERR_PREFIX_BYTES = 512;
+const ERROR_LINE_RE = /^.*(?:error|\[[A-Z][A-Z_]{2,}\]|ERR_[A-Z_]+).*$/im;
+/**
+ * Summarise a runner's stderr for a caller: the FIRST error-looking line (or
+ * the first ~512 bytes) plus the last ~2 KB (#995 review NB-C). A tail alone
+ * loses the cause when a long stack follows it — a vitest config syntax error
+ * prints `[PARSE_ERROR] …` first and then kilobytes of frames. `head` and
+ * `tail` are the raw windows at each end; both are redacted before slicing.
+ */
+export function summarizeStderr(head, tail, totalBytes) {
+    const safeTail = redactLogText(tail, Number.POSITIVE_INFINITY);
+    if (totalBytes <= STDERR_TAIL_BYTES)
+        return safeTail.trim();
+    const safeHead = redactLogText(head, Number.POSITIVE_INFINITY).slice(0, STDERR_HEAD_BYTES);
+    const tailPart = safeTail.slice(-STDERR_TAIL_BYTES);
+    const errorLine = ERROR_LINE_RE.exec(safeHead)?.[0]?.trim();
+    const prefix = (errorLine ?? safeHead.slice(0, STDERR_PREFIX_BYTES)).trim();
+    if (prefix && tailPart.includes(prefix))
+        return tailPart.trim();
+    return `${prefix}\n…\n${tailPart.trim()}`;
+}
+//# sourceMappingURL=coverage-stderr.js.map

package/dist/coordination/handlers/coverage-target.js

@@ -19,6 +19,7 @@
  * and the CLI `coverage` command can share it.
  */
 import * as fs from 'fs';
+import { readConfinedText, readConfinedTextSync } from '../../shared/io/confined-read.js';
 import * as os from 'os';
 import * as path from 'path';
 import { loadCoverageData, parseCoberturaXml, parseCoverageJson, parseCoverageSummaryJson, parseLcovInfo, } from './handler-utils.js';
@@ -99,7 +100,7 @@ function packageCanUseRootRunner(pkgDir, rootDir) {
 }
 function readPackageJson(dir) {
     try {
-        const parsed = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+        const parsed = JSON.parse(readConfinedTextSync(path.join(dir, 'package.json'), { outsideRoot: 'allow' }));
         return typeof parsed === 'object' && parsed !== null ? parsed : null;
     }
     catch {
@@ -128,7 +129,7 @@ function readWorkspacePatterns(dir) {
     // Only the block-list `packages:` form is read; the flow form gives no
     // patterns, so the root is not adopted (fails safe).
     try {
-        const yaml = fs.readFileSync(path.join(dir, 'pnpm-workspace.yaml'), 'utf-8');
+        const yaml = readConfinedTextSync(path.join(dir, 'pnpm-workspace.yaml'), { outsideRoot: 'allow' });
         isRoot = true;
         let inPackages = false;
         for (const raw of yaml.split(/\r?\n/)) {
@@ -326,7 +327,9 @@ export function isCoverageReportFile(filePath) {
 export async function loadCoverageReportFile(filePath) {
     let content;
     try {
-        content = await fs.promises.readFile(filePath, 'utf-8');
+        // #1161: read from the validated descriptor, not the name checked earlier;
+        // a report linked out of the project, or to a device, is not read.
+        content = await readConfinedText(filePath, { outsideRoot: 'allow' });
     }
     catch {
         return null;

package/dist/coordination/handlers/handler-utils.js

@@ -5,6 +5,7 @@
  * now co-located with the handlers that use them.
  */
 import * as fs from 'fs/promises';
+import { readConfinedText } from '../../shared/io/confined-read.js';
 import * as path from 'path';
 import { isAqeManagedDir } from '../../shared/aqe-managed-dirs.js';
 import { safeJsonParse } from '../../shared/safe-json.js';
@@ -32,7 +33,8 @@ export async function loadCoverageData(targetPath) {
     ];
     for (const coveragePath of coverageLocations) {
         try {
-            const content = await fs.readFile(coveragePath, 'utf-8');
+            // #1161: a report linked out of the project, or to a device, is not read.
+            const content = await readConfinedText(coveragePath, { outsideRoot: 'allow' });
             if (coveragePath.endsWith('coverage-summary.json')) {
                 return parseCoverageSummaryJson(content);
             }

package/dist/coordination/handlers/requirements-handlers.js

@@ -4,7 +4,7 @@
  * Extracted from task-executor.ts registerHandlers().
  * Covers: validate-requirements, validate-contracts
  */
-import * as fs from 'fs/promises';
+import { readConfinedText } from '../../shared/io/confined-read.js';
 import { ok, err } from '../../shared/types/index.js';
 import { toError, toErrorMessage } from '../../shared/error-utils.js';
 import { discoverSourceFiles } from './handler-utils.js';
@@ -74,7 +74,8 @@ export function registerRequirementsHandlers(ctx) {
                 return confined;
             // Check if the contract file exists
             try {
-                const content = await fs.readFile(confined.value, 'utf-8');
+                // #1161: read from the descriptor that was validated, not the name.
+                const content = await readConfinedText(confined.value, { maxBytes: MAX_PAYLOAD_FILE_BYTES });
                 const isJson = payload.contractPath.endsWith('.json');
                 const isYaml = payload.contractPath.endsWith('.yaml') || payload.contractPath.endsWith('.yml');
                 // Basic structural validation

package/dist/coordination/handlers/security-handlers.js

@@ -4,7 +4,6 @@
  * Extracted from task-executor.ts registerHandlers().
  * Covers: scan-security
  */
-import * as fs from 'fs/promises';
 import * as path from 'path';
 import { ok, err } from '../../shared/types/index.js';
 import { createHash } from 'node:crypto';
@@ -14,6 +13,8 @@ import { generateSecurityRecommendations } from './handler-utils.js';
 import { discoverSecurityFiles, isSecuritySourceFile } from '../../domains/security-compliance/scan-discovery.js';
 import { runDependencyAdvisoryScan } from '../../domains/security-compliance/dependency-advisory-engine.js';
 import { MAX_PAYLOAD_FILE_BYTES, requirePayloadPath } from '../../shared/io/payload-path-guard.js';
+import { dropGenericEvalCoveredBySast, GENERIC_EVAL_EXEC_TITLE } from '../../domains/security-compliance/generic-finding-dedup.js';
+import { readConfinedFile } from '../../shared/io/confined-read.js';
 export function registerSecurityHandlers(ctx) {
     // Register security scan handler - REAL IMPLEMENTATION
     ctx.registerHandler('scan-security', async (task) => {
@@ -44,6 +45,8 @@ export function registerSecurityHandlers(ctx) {
             const otherFiles = filesToScan.filter(f => !/\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(f));
             // Run basic cross-language security patterns on non-JS/TS files
             const crossLangVulns = [];
+            // Generic eval/exec matches whose line calls eval() and not exec() (#1170).
+            const evalOnlyFindings = new Set();
             // Run secret/CORS patterns on ALL files (not just otherFiles) to catch JS/TS secrets too
             for (const filePath of filesToScan) {
                 if (!isSecuritySourceFile(filePath)) {
@@ -52,13 +55,15 @@ export function registerSecurityHandlers(ctx) {
                     continue;
                 }
                 try {
-                    const source = await fs.readFile(filePath);
+                    // #1161: validate the opened descriptor, not the name checked earlier.
+                    const source = await readConfinedFile(filePath, { outsideRoot: 'allow' });
                     const content = source.toString('utf-8');
                     const lines = content.split('\n');
                     fileEvidence.push({ path: filePath, engineId: 'generic-patterns', status: 'analyzed',
                         sourceDigest: createHash('sha256').update(source).digest('hex'),
                         readLines: lines.length, analyzedLines: lines.length });
-                    const relPath = path.relative(targetPath, filePath) || path.basename(filePath);
+                    // #1170: report the scanned path, as SAST does, so a finding names the
+                    // real file and the same line from both engines can be matched.
                     // Pattern: Hardcoded secrets/keys
                     // Fix #287: Use \w* around keywords to match SECRET_KEY, JWT_SECRET, API_TOKEN, etc.
                     const secretPatterns = [
@@ -75,7 +80,7 @@ export function registerSecurityHandlers(ctx) {
                                 crossLangVulns.push({
                                     title: pattern.title,
                                     severity: pattern.severity,
-                                    location: { file: relPath, line: i + 1 },
+                                    location: { file: filePath, line: i + 1 },
                                     description: `Potential hardcoded secret found at line ${i + 1}`,
                                     category: 'sensitive-data',
                                 });
@@ -90,7 +95,7 @@ export function registerSecurityHandlers(ctx) {
                             crossLangVulns.push({
                                 title: 'Potential SQL injection',
                                 severity: 'high',
-                                location: { file: relPath, line: i + 1 },
+                                location: { file: filePath, line: i + 1 },
                                 description: 'String interpolation in SQL query — use parameterized queries',
                                 category: 'injection',
                             });
@@ -111,7 +116,7 @@ export function registerSecurityHandlers(ctx) {
                             crossLangVulns.push({
                                 title: 'CORS wildcard origin',
                                 severity: 'high',
-                                location: { file: relPath, line: lines.findIndex(l => corsPattern.test(l)) + 1 },
+                                location: { file: filePath, line: lines.findIndex(l => corsPattern.test(l)) + 1 },
                                 description: 'CORS configured with wildcard (*) origin — restrict to specific domains',
                                 category: 'security-misconfiguration',
                             });
@@ -124,21 +129,26 @@ export function registerSecurityHandlers(ctx) {
                         crossLangVulns.push({
                             title: 'Debug mode enabled',
                             severity: 'medium',
-                            location: { file: relPath, line: lines.findIndex(l => /DEBUG\s*[=:]\s*(?:True|true|1)/i.test(l)) + 1 },
+                            location: { file: filePath, line: lines.findIndex(l => /DEBUG\s*[=:]\s*(?:True|true|1)/i.test(l)) + 1 },
                             description: 'Debug mode should be disabled in production',
                             category: 'security-misconfiguration',
                         });
                     }
-                    // Pattern: Eval/exec usage
+                    // Pattern: Eval/exec usage, one finding per matching line (#1170)
                     genericRules.set('eval-exec', /\b(?:eval|exec)\s*\(/i.toString());
-                    if (/\b(?:eval|exec)\s*\(/i.test(content)) {
-                        crossLangVulns.push({
-                            title: 'Dangerous eval/exec usage',
+                    for (let i = 0; i < lines.length; i++) {
+                        if (!/\b(?:eval|exec)\s*\(/i.test(lines[i]))
+                            continue;
+                        const finding = {
+                            title: GENERIC_EVAL_EXEC_TITLE,
                             severity: 'high',
-                            location: { file: relPath, line: lines.findIndex(l => /\b(?:eval|exec)\s*\(/.test(l)) + 1 },
+                            location: { file: filePath, line: i + 1 },
                             description: 'eval/exec can lead to code injection — avoid using with user input',
                             category: 'injection',
-                        });
+                        };
+                        crossLangVulns.push(finding);
+                        if (!/\bexec\s*\(/i.test(lines[i]))
+                            evalOnlyFindings.add(finding);
                     }
                 }
                 catch (error) {
@@ -153,7 +163,8 @@ export function registerSecurityHandlers(ctx) {
             for (const manifest of sastRequested ? depManifests : []) {
                 const manifestPath = path.join(targetPath, manifest);
                 try {
-                    const manifestSource = await fs.readFile(manifestPath);
+                    // #1161: a manifest linked out of the project is not read.
+                    const manifestSource = await readConfinedFile(manifestPath, { outsideRoot: 'allow' });
                     const manifestContent = manifestSource.toString('utf-8');
                     const manifestLines = manifestContent.split('\n').length;
                     fileEvidence.push({ path: manifestPath, engineId: 'dependency-manifest-patterns', status: 'analyzed',
@@ -296,13 +307,16 @@ export function registerSecurityHandlers(ctx) {
             };
             const deepAnalysisPerformed = Boolean(sastResult?.evidence?.engines.some(engine => engine.id === 'patterns' && (engine.status === 'completed' || engine.status === 'partial') &&
                 (engine.analyzedFiles ?? 0) > 0));
+            // #1170: a generic eval() match on a line SAST reported as CWE-95 is the
+            // same finding, so it is counted once, as SAST reported it.
+            const genericVulns = await dropGenericEvalCoveredBySast(crossLangVulns, sastResult?.vulnerabilities ?? [], finding => evalOnlyFindings.has(finding));
             // Combine results from all scan sources - SAST, DAST, and cross-language patterns
             const crossLangSeverityCounts = {
-                critical: crossLangVulns.filter(v => v.severity === 'critical').length,
-                high: crossLangVulns.filter(v => v.severity === 'high').length,
-                medium: crossLangVulns.filter(v => v.severity === 'medium').length,
-                low: crossLangVulns.filter(v => v.severity === 'low').length,
-                informational: crossLangVulns.filter(v => v.severity === 'informational').length,
+                critical: genericVulns.filter(v => v.severity === 'critical').length,
+                high: genericVulns.filter(v => v.severity === 'high').length,
+                medium: genericVulns.filter(v => v.severity === 'medium').length,
+                low: genericVulns.filter(v => v.severity === 'low').length,
+                informational: genericVulns.filter(v => v.severity === 'informational').length,
             };
             const depVulns = dependencyScan?.vulnerabilities ?? [];
             const depCount = (severity) => depVulns.filter(v => v.severity === severity).length;
@@ -317,7 +331,7 @@ export function registerSecurityHandlers(ctx) {
             const allVulns = [
                 ...(sastResult?.vulnerabilities || []),
                 ...(dastResult?.vulnerabilities || []),
-                ...crossLangVulns,
+                ...genericVulns,
                 ...depVulns,
             ];
             const topVulnerabilities = allVulns

package/dist/coordination/queen-coordinator.js

@@ -51,7 +51,7 @@ import { DEFAULT_QUEEN_CONFIG, getTaskDomains, initializeTaskDomainMap, } from '
 export { DOMAIN_GROUPS, TASK_DOMAIN_MAP } from './queen-types.js';
 // Extracted modules
 import { subscribeToEvents, computeDomainHealthFromAgents } from './queen-event-handlers.js';
-import { findDomainsWithoutHandler, describeMissingHandler } from './task-executability.js';
+import { findDomainsWithoutHandler, resolveTaskDomains, describeMissingHandler } from './task-executability.js';
 import { enqueueTask, removeFromQueues, getQueuePosition, processQueue, listTasks as listTasksImpl, assignTask, dispatchStolenTask, canDomainExecuteTask, } from './queen-task-management.js';
 import { triggerWorkStealing as triggerWorkStealingImpl, startWorkStealingTimer } from './queen-work-stealing.js';
 import { isMinCutAwarePlugin, injectMinCutBridgeIntoPlugins, loadState, saveState, startMetricsCollectionTimer, cleanupCompletedTasks as cleanupCompletedTasksImpl, getEnabledDomains, } from './queen-lifecycle.js';
@@ -296,9 +296,9 @@ export class QueenCoordinator {
      * accept the type unchanged.
      */
     validateTaskExecutable(type, targetDomains = []) {
-        const candidates = targetDomains.length > 0 ? targetDomains : getTaskDomains(type);
+        const candidates = resolveTaskDomains(type, targetDomains, this.domainPlugins);
         if (candidates.length === 0) {
-            return err(new Error(`Unknown task type '${type}': no domain is configured for it. Pass a target domain.`));
+            return err(new Error(`Unknown task type '${type}': no domain is configured for it and no loaded domain handles it. Pass a target domain.`));
         }
         if (!this.domainPlugins)
             return ok(undefined);
@@ -314,6 +314,11 @@ export class QueenCoordinator {
         const taskId = `task_${uuidv4()}`;
         const task = {
             ...taskInput,
+            // #1170: a plugin task type with no configured domain (e.g. sast-scan)
+            // runs in the domains that handle it, so routing and queueing see them.
+            targetDomains: getTaskDomains(taskInput.type).length > 0
+                ? taskInput.targetDomains
+                : [...resolveTaskDomains(taskInput.type, taskInput.targetDomains, this.domainPlugins)],
             id: taskId,
             createdAt: new Date(),
             timeout: taskInput.timeout || this.config.defaultTaskTimeout,

package/dist/coordination/task-executability.d.ts

@@ -14,5 +14,17 @@ import type { DomainPlugin } from '../kernel/interfaces';
  * every domain can run the task.
  */
 export declare function findDomainsWithoutHandler(domainPlugins: ReadonlyMap<DomainName, DomainPlugin>, type: string, domains: readonly DomainName[]): string[];
+/**
+ * #1170: the loaded domains whose plugin executes `type`. A plugin task type
+ * such as `sast-scan` has no entry in TASK_DOMAIN_MAP, so a caller that names
+ * no target domain is routed to the domains that handle it.
+ */
+export declare function findDomainsWithHandler(domainPlugins: ReadonlyMap<DomainName, DomainPlugin>, type: string): DomainName[];
+/**
+ * The domains a task may run in: the caller's target domains, else the
+ * domains configured for its type, else (#1170) the loaded domains whose
+ * plugin handles the type.
+ */
+export declare function resolveTaskDomains(type: string, targetDomains: readonly DomainName[], domainPlugins?: ReadonlyMap<DomainName, DomainPlugin>): readonly DomainName[];
 export declare function describeMissingHandler(type: string, gaps: readonly string[]): string;
 //# sourceMappingURL=task-executability.d.ts.map

package/dist/coordination/task-executability.js

@@ -6,6 +6,7 @@
  * the `TaskAssigned` event fallback, which nothing answers, so the task stayed
  * `running` and held a concurrency slot for good.
  */
+import { getTaskDomains } from './queen-types.js';
 /**
  * List the domains among `domains` that cannot execute `type`, each with the
  * reason and, where known, the types it does support. An empty list means
@@ -25,6 +26,32 @@ export function findDomainsWithoutHandler(domainPlugins, type, domains) {
     }
     return gaps;
 }
+/**
+ * #1170: the loaded domains whose plugin executes `type`. A plugin task type
+ * such as `sast-scan` has no entry in TASK_DOMAIN_MAP, so a caller that names
+ * no target domain is routed to the domains that handle it.
+ */
+export function findDomainsWithHandler(domainPlugins, type) {
+    const domains = [];
+    for (const [domain, plugin] of domainPlugins) {
+        if (plugin.executeTask && plugin.canHandleTask?.(type))
+            domains.push(domain);
+    }
+    return domains;
+}
+/**
+ * The domains a task may run in: the caller's target domains, else the
+ * domains configured for its type, else (#1170) the loaded domains whose
+ * plugin handles the type.
+ */
+export function resolveTaskDomains(type, targetDomains, domainPlugins) {
+    if (targetDomains.length > 0)
+        return targetDomains;
+    const configured = getTaskDomains(type);
+    if (configured.length > 0 || !domainPlugins)
+        return configured;
+    return findDomainsWithHandler(domainPlugins, type);
+}
 export function describeMissingHandler(type, gaps) {
     return `No handler for task type '${type}' in domain ${gaps.join('; ')}`;
 }

package/dist/coordination/workflow-orchestrator.d.ts

@@ -49,6 +49,12 @@ export declare class WorkflowOrchestrator implements IWorkflowOrchestrator {
      */
     rejectStep(executionId: string, stepId: string, reason?: string): boolean;
     isActionRegistered(domain: DomainName, action: string): boolean;
+    /**
+     * #1157: a registered action by domain and action name. Both names come from
+     * pipeline YAML, so only own registry entries count: `toString` or
+     * `constructor` is an unregistered action, not an Object.prototype member.
+     */
+    private lookupAction;
     getRegisteredActions(domain: DomainName): string[];
     getDomainsWithActions(): DomainName[];
     spawnWorkflowAgent(workflowId: string, stepId: string, domain: DomainName): Promise<Result<string, Error>>;

package/dist/coordination/workflow-orchestrator.js

@@ -209,7 +209,18 @@ export class WorkflowOrchestrator {
     // Public Utility Methods
     // ============================================================================
     isActionRegistered(domain, action) {
-        return !!this.actionRegistry[domain]?.[action];
+        return this.lookupAction(domain, action) !== undefined;
+    }
+    /**
+     * #1157: a registered action by domain and action name. Both names come from
+     * pipeline YAML, so only own registry entries count: `toString` or
+     * `constructor` is an unregistered action, not an Object.prototype member.
+     */
+    lookupAction(domain, action) {
+        const actions = Object.hasOwn(this.actionRegistry, domain)
+            ? this.actionRegistry[domain]
+            : undefined;
+        return actions && Object.hasOwn(actions, action) ? actions[action] : undefined;
     }
     getRegisteredActions(domain) {
         return Object.keys(this.actionRegistry[domain] || {});
@@ -612,9 +623,9 @@ export class WorkflowOrchestrator {
             return actionResult.value;
         }
         // Fall back to registered domain actions
-        const domainActions = this.actionRegistry[step.domain];
-        if (domainActions?.[step.action]) {
-            const actionResult = await Promise.race([domainActions[step.action](input, context), timeoutPromise]);
+        const domainAction = this.lookupAction(step.domain, step.action);
+        if (domainAction) {
+            const actionResult = await Promise.race([domainAction(input, context), timeoutPromise]);
             if (!actionResult.success)
                 throw actionResult.error;
             return actionResult.value;
@@ -624,12 +635,12 @@ export class WorkflowOrchestrator {
     }
     async executeRollback(rollback, context) {
         try {
-            const domainActions = this.actionRegistry[rollback.domain];
-            if (!domainActions?.[rollback.action]) {
+            const domainAction = this.lookupAction(rollback.domain, rollback.action);
+            if (!domainAction) {
                 console.warn(`Rollback action '${rollback.action}' not registered for domain '${rollback.domain}'. Skipping rollback.`);
                 return;
             }
-            const result = await domainActions[rollback.action](rollback.input || {}, context);
+            const result = await domainAction(rollback.input || {}, context);
             if (!result.success)
                 console.error(`Rollback failed for ${rollback.domain}.${rollback.action}:`, result.error);
         }
@@ -669,8 +680,11 @@ export class WorkflowOrchestrator {
         for (const part of parts) {
             if (current === null || current === undefined)
                 return undefined;
-            if (typeof current === 'object')
+            // #1157: paths come from pipeline YAML (conditions, input/output
+            // mappings); an inherited member such as `constructor` is absent.
+            if (typeof current === 'object' && Object.hasOwn(current, part)) {
                 current = current[part];
+            }
             else
                 return undefined;
         }

package/dist/domains/code-intelligence/services/product-factors-bridge.js

@@ -15,6 +15,7 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import * as path from 'path';
 import * as fs from 'fs/promises';
+import { readConfinedText } from '../../../shared/io/confined-read.js';
 import { ok, err } from '../../../shared/types/index.js';
 import { CodeIntelligenceEvents, createEvent, } from '../../../shared/events/domain-events.js';
 import { toError } from '../../../shared/error-utils.js';
@@ -319,7 +320,7 @@ export class ProductFactorsBridgeService {
     async getProjectMetadata(projectPath) {
         try {
             const packageJsonPath = path.join(projectPath, 'package.json');
-            const content = await fs.readFile(packageJsonPath, 'utf-8');
+            const content = await readConfinedText(packageJsonPath, { outsideRoot: 'allow' }); // #1161
             const pkg = safeJsonParse(content);
             return {
                 name: pkg.name || 'Project',
@@ -344,14 +345,16 @@ export class ProductFactorsBridgeService {
             catch {
                 return systems;
             }
-            const content = await fs.readFile(packageJsonPath, 'utf-8');
+            const content = await readConfinedText(packageJsonPath, { outsideRoot: 'allow' }); // #1161
             const pkg = safeJsonParse(content);
             const allDeps = {
                 ...pkg.dependencies,
                 ...pkg.devDependencies,
             };
             for (const [depName] of Object.entries(allDeps)) {
-                const pattern = EXTERNAL_SYSTEM_PATTERNS[depName];
+                // #1157: dependency names come from package.json; a package named
+                // `constructor` is not a known external system.
+                const pattern = Object.hasOwn(EXTERNAL_SYSTEM_PATTERNS, depName) ? EXTERNAL_SYSTEM_PATTERNS[depName] : undefined;
                 if (pattern) {
                     systems.push({
                         id: sanitizeId(depName),
@@ -636,7 +639,7 @@ export class ProductFactorsBridgeService {
         // Simple hash based on package.json and file count
         try {
             const packageJsonPath = path.join(projectPath, 'package.json');
-            const content = await fs.readFile(packageJsonPath, 'utf-8');
+            const content = await readConfinedText(packageJsonPath, { outsideRoot: 'allow' }); // #1161
             return this.hashString(content);
         }
         catch {

package/dist/domains/coverage-analysis/services/coverage-parser.js

@@ -19,6 +19,15 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { readConfinedText } from '../../../shared/io/confined-read.js';
+/**
+ * #1161: coverage reports are found under caller-named directories, so read
+ * them from a validated descriptor: a report linked out of the project, or to
+ * a device such as /dev/zero, is refused instead of read.
+ */
+function readCoverageFile(file) {
+    return readConfinedText(file, { outsideRoot: 'allow' });
+}
 // ============================================================================
 // LCOV Parser
 // ============================================================================
@@ -28,7 +37,7 @@ import { safeJsonParse } from '../../../shared/safe-json.js';
  * LCOV format is the most common output from Istanbul, nyc, c8, etc.
  */
 export async function parseLCOV(lcovPath, projectRoot) {
-    const content = await fs.readFile(lcovPath, 'utf-8');
+    const content = await readCoverageFile(lcovPath);
     return parseLCOVContent(content, projectRoot || path.dirname(lcovPath));
 }
 /**
@@ -221,7 +230,7 @@ export function parseLCOVContent(content, projectRoot) {
  * Parse JSON coverage data (Istanbul/Vitest format)
  */
 export async function parseJSONCoverage(jsonPath, projectRoot) {
-    const content = await fs.readFile(jsonPath, 'utf-8');
+    const content = await readCoverageFile(jsonPath);
     const data = safeJsonParse(content);
     const root = projectRoot || path.dirname(jsonPath);
     const files = new Map();
@@ -334,7 +343,7 @@ export async function parseJSONCoverage(jsonPath, projectRoot) {
  *   <report><package><class><method><counter type="LINE" missed="X" covered="Y"/></method></class></package></report>
  */
 export async function parseJaCoCo(xmlPath, projectRoot) {
-    const content = await fs.readFile(xmlPath, 'utf-8');
+    const content = await readCoverageFile(xmlPath);
     return parseJaCoCoContent(content, projectRoot || path.dirname(xmlPath));
 }
 export function parseJaCoCoContent(content, projectRoot) {
@@ -437,7 +446,7 @@ function parseJaCoCoCounters(xml) {
  *   <Root CoveredStatements="X" TotalStatements="Y"><Assembly><Namespace><Type><Member Statement="..."/></Type></Namespace></Assembly></Root>
  */
 export async function parseDotcover(xmlPath, projectRoot) {
-    const content = await fs.readFile(xmlPath, 'utf-8');
+    const content = await readCoverageFile(xmlPath);
     return parseDotcoverContent(content, projectRoot || path.dirname(xmlPath));
 }
 export function parseDotcoverContent(content, projectRoot) {
@@ -531,7 +540,7 @@ export function parseDotcoverContent(content, projectRoot) {
  * Also handles tarpaulin LCOV output by delegating to parseLCOVContent.
  */
 export async function parseTarpaulin(filePath, projectRoot) {
-    const content = await fs.readFile(filePath, 'utf-8');
+    const content = await readCoverageFile(filePath);
     const root = projectRoot || path.dirname(filePath);
     // If it looks like LCOV, delegate
     if (content.includes('SF:') && content.includes('end_of_record')) {
@@ -603,7 +612,7 @@ export function parseTarpaulinContent(content, projectRoot) {
  *   pkg/file.go:startLine.startCol,endLine.endCol numStatements count
  */
 export async function parseGoCover(coverPath, projectRoot) {
-    const content = await fs.readFile(coverPath, 'utf-8');
+    const content = await readCoverageFile(coverPath);
     return parseGoCoverContent(content, projectRoot || path.dirname(coverPath));
 }
 export function parseGoCoverContent(content, projectRoot) {
@@ -681,7 +690,7 @@ export function parseGoCoverContent(content, projectRoot) {
  * but sets the format and language appropriately.
  */
 export async function parseKover(xmlPath, projectRoot) {
-    const content = await fs.readFile(xmlPath, 'utf-8');
+    const content = await readCoverageFile(xmlPath);
     const report = parseJaCoCoContent(content, projectRoot || path.dirname(xmlPath));
     report.format = 'kover';
     report.language = 'kotlin';
@@ -698,7 +707,7 @@ export async function parseKover(xmlPath, projectRoot) {
  *   { "targets": [ { "files": [ { "path": "...", "lineCoverage": 0.85, "coveredLines": N, "executableLines": N, "functions": [...] } ] } ] }
  */
 export async function parseXcresult(jsonPath, projectRoot) {
-    const content = await fs.readFile(jsonPath, 'utf-8');
+    const content = await readCoverageFile(jsonPath);
     return parseXcresultContent(content, projectRoot || path.dirname(jsonPath));
 }
 export function parseXcresultContent(content, projectRoot) {
@@ -830,7 +839,7 @@ export async function parseCoverage(coveragePath, projectRoot, format, language)
         return parseXcresult(coveragePath, projectRoot);
     }
     // Content-based detection
-    const content = await fs.readFile(coveragePath, 'utf-8');
+    const content = await readCoverageFile(coveragePath);
     const trimmed = content.trim();
     if (trimmed.startsWith('{')) {
         // Check for tarpaulin JSON structure
@@ -869,7 +878,7 @@ export async function parseCoverage(coveragePath, projectRoot, format, language)
     // Language-based fallback: try the first format associated with the language
     if (language) {
         const langLower = language.toLowerCase();
-        const hints = LANGUAGE_FORMAT_HINTS[langLower];
+        const hints = Object.hasOwn(LANGUAGE_FORMAT_HINTS, langLower) ? LANGUAGE_FORMAT_HINTS[langLower] : undefined; // #1157
         if (hints && hints.length > 0) {
             try {
                 return await parseCoverage(coveragePath, projectRoot, hints[0]);

package/dist/domains/learning-optimization/interfaces.d.ts

@@ -36,6 +36,8 @@ export interface PatternContext {
     readonly testType?: string;
     readonly codeContext?: string;
     readonly tags: string[];
+    /** Explicit strategy objective; absent means no requested direction. */
+    readonly objective?: Pick<OptimizationObjective, 'metric' | 'direction'>;
 }
 export interface PatternTemplate {
     readonly type: 'code' | 'prompt' | 'workflow' | 'config';

package/dist/domains/learning-optimization/services/learning-coordinator.js

@@ -290,7 +290,8 @@ Provide:
             let output = pattern.template.content;
             // Replace template variables
             for (const variable of pattern.template.variables) {
-                const value = variables[variable.name] ?? variable.defaultValue;
+                // #1157: the variable name comes from a stored pattern; read own values only.
+                const value = (Object.hasOwn(variables, variable.name) ? variables[variable.name] : undefined) ?? variable.defaultValue;
                 if (variable.required && value === undefined) {
                     return err(new Error(`Required variable ${variable.name} not provided`));
                 }