agentic-qe 3.15.10 → 3.15.12

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.d.ts

@@ -19,6 +19,7 @@
  * and the CLI `coverage` command can share it.
  */
 import type { CoverageData, FileCoverage } from '../../domains/coverage-analysis/interfaces';
+import { type CoverageEvidence } from './coverage-evidence';
 /**
  * Walk up from a target to the nearest directory that holds a project marker.
  *
@@ -75,6 +76,7 @@ export type NoDataReason =
 export type CoverageEvaluation = {
     status: 'measured';
     files: FileCoverage[];
+    evidence: CoverageEvidence;
 } | {
     status: 'no-data';
     reason: NoDataReason;
@@ -88,9 +90,16 @@ export type CoverageEvaluation = {
  *   - the report has no entry under the target.
  * Hit counts are never used: a file listed with 0 hits is a measured 0%,
  * whether the report came from our run or from the user (#995 review B3).
+ *
+ * A measured result carries its evidence (#1154): the target's source files
+ * the report has no entry for (UNMEASURED), and whether the report at
+ * `reportPath` is older than the sources. Insufficient evidence keeps the
+ * figures for the measured files, but no caller may pass a verdict on it.
  */
 export declare function evaluateCoverageForTarget(report: CoverageData, projectRoot: string, target: string, options?: {
     numTotalTests?: number | null;
+    reportPath?: string;
+    checkCompleteness?: boolean;
 }): CoverageEvaluation;
 export type ExistingCoverage = {
     status: 'target-missing';

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

@@ -19,10 +19,12 @@
  * 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';
+import { loadCoverageReport, parseCoberturaXml, parseCoverageJson, parseCoverageSummaryJson, parseLcovInfo, } from './handler-utils.js';
 import { isTestPath } from './coverage-collection.js';
+import { assessCoverageEvidence } from './coverage-evidence.js';
 import { findProjectRoot } from '../../kernel/project-root.js';
 // ============================================================================
 // Project root
@@ -99,7 +101,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 +130,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 +328,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;
@@ -415,6 +419,11 @@ export function scopeCoverageToTarget(data, root, target) {
  *   - the report has no entry under the target.
  * Hit counts are never used: a file listed with 0 hits is a measured 0%,
  * whether the report came from our run or from the user (#995 review B3).
+ *
+ * A measured result carries its evidence (#1154): the target's source files
+ * the report has no entry for (UNMEASURED), and whether the report at
+ * `reportPath` is older than the sources. Insufficient evidence keeps the
+ * figures for the measured files, but no caller may pass a verdict on it.
  */
 export function evaluateCoverageForTarget(report, projectRoot, target, options = {}) {
     if (options.numTotalTests === 0)
@@ -427,7 +436,10 @@ export function evaluateCoverageForTarget(report, projectRoot, target, options =
     const production = scoped.filter(f => !isTestPath(f.path, projectRoot));
     if (production.length === 0)
         return { status: 'no-data', reason: 'test-only-report' };
-    return { status: 'measured', files: production };
+    const evidence = assessCoverageEvidence(report, production, projectRoot, target, {
+        reportPath: options.reportPath, checkCompleteness: options.checkCompleteness,
+    });
+    return { status: 'measured', files: production, evidence };
 }
 /**
  * Resolve a target to coverage that already exists on disk, without running
@@ -451,18 +463,19 @@ export async function resolveExistingCoverage(targetPath) {
         const projectRoot = findCoverageProjectRoot(reportDir)
             ?? (path.basename(reportDir) === 'coverage' ? path.dirname(reportDir) : reportDir);
         const report = await loadCoverageReportFile(target);
+        // The report itself is the target: judged whole, but still checked for staleness.
         const evaluation = report
-            ? evaluateCoverageForTarget(report, projectRoot, projectRoot)
+            ? evaluateCoverageForTarget(report, projectRoot, projectRoot, { reportPath: target, checkCompleteness: false })
             : { status: 'no-data', reason: 'unreadable-report' };
         return { status: 'evaluated', target, projectRoot, source: 'report-file', evaluation };
     }
     const projectRoot = findCoverageProjectRoot(target) ?? (stat.isDirectory() ? target : path.dirname(target));
-    const existing = await loadCoverageData(projectRoot);
+    const existing = await loadCoverageReport(projectRoot);
     if (!existing)
         return { status: 'no-report', target, projectRoot };
     return {
         status: 'evaluated', target, projectRoot, source: 'project-report',
-        evaluation: evaluateCoverageForTarget(existing, projectRoot, target),
+        evaluation: evaluateCoverageForTarget(existing.data, projectRoot, target, { reportPath: existing.path }),
     };
 }
 /**

package/dist/coordination/handlers/handler-utils.d.ts

@@ -74,6 +74,11 @@ export interface IstanbulFileCoverage {
  * Load coverage data from common coverage file formats
  */
 export declare function loadCoverageData(targetPath: string): Promise<CoverageData | null>;
+/** `loadCoverageData` plus the path of the report it read (#1154: staleness needs it). */
+export declare function loadCoverageReport(targetPath: string): Promise<{
+    data: CoverageData;
+    path: string;
+} | null>;
 /**
  * Per-line hit counts of one istanbul file entry, computed the way istanbul's
  * own `FileCoverage#getLineCoverage` (and therefore coverage-summary.json

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';
@@ -15,6 +16,10 @@ import { safeJsonParse } from '../../shared/safe-json.js';
  * Load coverage data from common coverage file formats
  */
 export async function loadCoverageData(targetPath) {
+    return (await loadCoverageReport(targetPath))?.data ?? null;
+}
+/** `loadCoverageData` plus the path of the report it read (#1154: staleness needs it). */
+export async function loadCoverageReport(targetPath) {
     // Try various coverage file locations (JS, Python, Java, etc.)
     const coverageLocations = [
         // JavaScript/TypeScript (Istanbul/nyc/vitest)
@@ -32,18 +37,19 @@ 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);
+                return { data: parseCoverageSummaryJson(content), path: coveragePath };
             }
             else if (coveragePath.endsWith('.json')) {
-                return parseCoverageJson(content);
+                return { data: parseCoverageJson(content), path: coveragePath };
             }
             else if (coveragePath.endsWith('.info')) {
-                return parseLcovInfo(content);
+                return { data: parseLcovInfo(content), path: coveragePath };
             }
             else if (coveragePath.endsWith('.xml')) {
-                return parseCoberturaXml(content);
+                return { data: parseCoberturaXml(content), path: coveragePath };
             }
         }
         catch {

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/metric-collector/listing-process-owner.js

@@ -32,7 +32,10 @@ function interrupted(signal) {
     removeHandlers();
     // Restore signal termination (including its exit status) instead of swallowing
     // Ctrl-C or converting a requested shutdown into a successful metrics result.
-    process.kill(process.pid, signal);
+    // An embedding host with its own listener already received this signal, so
+    // re-raising would deliver it twice; the host decides how to shut down (#992).
+    if (process.listenerCount(signal) === 0)
+        process.kill(process.pid, signal);
 }
 const signalHandlers = {
     SIGINT: () => interrupted('SIGINT'),

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 {