agentic-qe 3.15.9 → 3.15.11

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,16 +4,24 @@
  * 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';
+import { MAX_PAYLOAD_FILE_BYTES, requirePayloadPath } from '../../shared/io/payload-path-guard.js';
 export function registerRequirementsHandlers(ctx) {
     // Register requirements validation handler
     ctx.registerHandler('validate-requirements', async (task) => {
         const payload = task.payload;
         try {
-            const targetPath = payload.requirementsPath || process.cwd();
+            // #1126: list requirement files only inside the project.
+            let targetPath = process.cwd();
+            if (payload.requirementsPath) {
+                const confined = await requirePayloadPath('validate-requirements', 'requirementsPath', payload.requirementsPath, { allowDirectory: true, allowMissing: true });
+                if (!confined.success)
+                    return confined;
+                targetPath = confined.value;
+            }
             // Look for requirements files (markdown, feature files, etc.)
             const reqFiles = await discoverSourceFiles(targetPath, {
                 includeTests: false,
@@ -58,9 +66,16 @@ export function registerRequirementsHandlers(ctx) {
                     error: 'contractPath is required. Provide a path to an OpenAPI spec, JSON Schema, or Protocol Buffer file.',
                 });
             }
+            // #1126: read only a regular file inside the project, within the size
+            // limit; the result reports its line count and whether it parses. A
+            // missing file keeps its valid:false result below.
+            const confined = await requirePayloadPath('validate-contracts', 'contractPath', payload.contractPath, { allowMissing: true, maxBytes: MAX_PAYLOAD_FILE_BYTES });
+            if (!confined.success)
+                return confined;
             // Check if the contract file exists
             try {
-                const content = await fs.readFile(payload.contractPath, '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';
@@ -13,12 +12,24 @@ import { FilePath } from '../../shared/value-objects/index.js';
 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) => {
         const payload = task.payload;
         try {
-            const targetPath = path.resolve(payload.target || process.cwd());
+            // #1126: read (SAST, manifests, dependencies) only a file or directory
+            // inside the project. A DAST-only scan reads no target path.
+            let targetPath = path.resolve(payload.target || process.cwd());
+            const readsTarget = payload.sast !== false || payload.dependencies === true;
+            if (payload.target && payload.target !== '.' && readsTarget) {
+                const confined = await requirePayloadPath('scan-security', 'target', payload.target, { allowDirectory: true, allowMissing: true, maxBytes: MAX_PAYLOAD_FILE_BYTES });
+                if (!confined.success)
+                    return confined;
+                targetPath = confined.value;
+            }
             const sastRequested = payload.sast !== false;
             const discoveryResult = sastRequested ? await discoverSecurityFiles(targetPath) : undefined;
             const filesToScan = discoveryResult?.files ?? [];
@@ -34,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)) {
@@ -42,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 = [
@@ -65,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',
                                 });
@@ -80,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',
                             });
@@ -101,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',
                             });
@@ -114,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) {
@@ -143,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',
@@ -286,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;
@@ -307,7 +331,7 @@ export function registerSecurityHandlers(ctx) {
             const allVulns = [
                 ...(sastResult?.vulnerabilities || []),
                 ...(dastResult?.vulnerabilities || []),
-                ...crossLangVulns,
+                ...genericVulns,
                 ...depVulns,
             ];
             const topVulnerabilities = allVulns

package/dist/coordination/handlers/test-execution-handlers.js

@@ -8,11 +8,12 @@ import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs/promises';
 import { ok, err } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
-import { getTestRunnerExecutionError, TestRunnerExecutionError } from '../../shared/test-runner-verdict.js';
+import { capDiagnostics, getTestRunnerExecutionError, TestRunnerExecutionError } from '../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../shared/vitest-json-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../shared/test-runner-args.js';
 import { testCasesFromRunnerReport } from '../../domains/test-execution/services/runner-test-cases.js';
 import { runTestRunnerProcess } from '../../shared/test-runner-process.js';
+import { MAX_PAYLOAD_FILE_BYTES, requirePayloadFiles } from '../../shared/io/payload-path-guard.js';
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -69,9 +70,19 @@ export function registerTestExecutionHandlers(ctx) {
             if (payload.sourceFiles && payload.sourceFiles.length > 0) {
                 sourceFiles = payload.sourceFiles;
             }
-            else if (payload.filePath) {
+            else if (payload.filePath && !payload.sourceCode) {
+                // With sourceCode, filePath is only the import target written into the
+                // generated tests (tool contract); it is neither read nor required.
                 sourceFiles = [payload.filePath];
             }
+            if (sourceFiles.length > 0) {
+                // #1126: the generator reads each file whole, so only project files.
+                const field = payload.sourceFiles?.length ? 'sourceFiles' : 'filePath';
+                const confined = await requirePayloadFiles('generate-tests', field, sourceFiles, { maxBytes: MAX_PAYLOAD_FILE_BYTES });
+                if (!confined.success)
+                    return confined;
+                sourceFiles = confined.value;
+            }
             else if (payload.sourceCode) {
                 // Write temporary file for analysis if only source code provided
                 // Use correct file extension based on language parameter
@@ -175,15 +186,22 @@ export function registerTestExecutionHandlers(ctx) {
     ctx.registerHandler('execute-tests', async (task) => {
         const payload = task.payload;
         try {
-            const testFiles = payload.testFiles || [];
-            if (testFiles.length === 0) {
+            const requestedFiles = payload.testFiles || [];
+            if (requestedFiles.length === 0) {
                 return err(new TestRunnerExecutionError('No test files specified. Provide testFiles array with paths to test files.'));
             }
             // Validate test file paths before invoking a runner.
             const safePathPattern = /^[a-zA-Z0-9_./@-]+$/;
-            if (testFiles.some(file => !safePathPattern.test(file))) {
+            if (requestedFiles.some(file => !safePathPattern.test(file))) {
                 return err(new TestRunnerExecutionError('Some test file paths contain invalid characters and were rejected. Provide concrete paths; expand glob patterns before calling.'));
             }
+            // #1126: a runner executes what it is given, so only files and
+            // directories (#909 Jest targets) inside the project, run as the real
+            // paths that were checked. A missing file is still reported by the runner.
+            const confined = await requirePayloadFiles('execute-tests', 'testFiles', requestedFiles, { allowMissing: true, allowDirectory: true });
+            if (!confined.success)
+                return confined;
+            const testFiles = confined.value;
             // A caller-owned MCP task skips the Queen's plugin dispatch. Run through
             // that same domain API here: it owns persistence, measured quality evidence
             // and TestRunStarted/Completed events as well as the runner itself.
@@ -230,7 +248,7 @@ export function registerTestExecutionHandlers(ctx) {
             }
             const diagnostics = [execution.error?.message, execution.signal && `Terminated by ${execution.signal}`, execution.stderr, output].filter(Boolean).join('\n');
             if (execution.error) {
-                return err(new TestRunnerExecutionError(`${runner} could not complete: ${diagnostics.slice(0, 4000)}`));
+                return err(new TestRunnerExecutionError(`${runner} could not complete: ${capDiagnostics(diagnostics)}`));
             }
             try {
                 const jsonStart = output.indexOf('{');
@@ -259,7 +277,7 @@ export function registerTestExecutionHandlers(ctx) {
             catch {
                 // A malformed report cannot establish that the requested tests completed.
             }
-            return err(new TestRunnerExecutionError(`Could not parse ${runner} results (exit code ${execution.status ?? 'unknown'}):\n${diagnostics.slice(0, 4000)}`));
+            return err(new TestRunnerExecutionError(`Could not parse ${runner} results (exit code ${execution.status ?? 'unknown'}):\n${capDiagnostics(diagnostics)}`));
         }
         catch (error) {
             return err(toError(error));

package/dist/coordination/mincut/queen-integration.d.ts

@@ -20,6 +20,19 @@ import { SwarmGraph } from './swarm-graph';
 import { MinCutHealthMonitor } from './mincut-health-monitor';
 import { MinCutPersistence } from './mincut-persistence';
 import { SwarmVertex, SwarmEdge, MinCutHealth, MinCutHealthConfig, WeakVertex } from './interfaces';
+/**
+ * #1130: Queen health reads the MinCut of the fleet's own topology (domains
+ * and long-lived agents). An agent spawned for one task is a leaf with a
+ * single edge, so counting it would put every running task below threshold.
+ */
+export interface FleetMinCutHealth extends MinCutHealth {
+    /** Status of the topology without task-scoped agents; this one degrades Queen health. */
+    readonly fleetStatus: MinCutHealth['status'];
+    /** MinCut of the topology without task-scoped agents. `minCutValue` stays the raw value. */
+    readonly fleetMinCutValue: number;
+    /** Running task-scoped agents left out of `fleetStatus`. */
+    readonly taskAgents: number;
+}
 /**
  * Configuration for Queen-MinCut integration
  */
@@ -56,6 +69,13 @@ export declare class QueenMinCutBridge {
     private readonly monitor;
     private readonly persistence;
     private eventSubscriptions;
+    /**
+     * Agents with a vertex in the graph, from QueenAgentSpawned or from the
+     * coordinator when the graph was built. Pruned once they complete (#1130).
+     */
+    private readonly spawnedAgentIds;
+    /** The subset spawned for a single task (#1130). */
+    private readonly taskAgentIds;
     private snapshotTimer;
     private initialized;
     constructor(eventBus: EventBus, agentCoordinator: AgentCoordinator, config?: Partial<QueenMinCutConfig>);
@@ -100,11 +120,29 @@ export declare class QueenMinCutBridge {
      * Convert MinCut alerts to Queen health issues
      */
     getHealthIssuesFromMinCut(): HealthIssue[];
+    /**
+     * #1130: nothing publishes QueenAgentTerminated, so a finished task agent
+     * stayed in the topology and kept the fleet degraded after its run. Drop the
+     * vertex of every tracked agent that completed normally or that the
+     * coordinator no longer lists. A failed agent keeps its vertex (see
+     * failedAgentIssues), so a crash never makes the fleet look healthier.
+     * Returns the tracked agents that failed.
+     */
+    private pruneCompletedAgents;
+    /** #1130: one issue per failed agent, task-scoped or long-lived. */
+    private failedAgentIssues;
+    private isTaskAgentVertex;
+    /**
+     * #1130: MinCut health with the fleet reading next to the raw one. The fleet
+     * reading drops task-scoped agents from a copy of the graph; the raw graph,
+     * its value and its alerts are unchanged.
+     */
+    getFleetMinCutHealth(): FleetMinCutHealth;
     /**
      * Extend Queen health with MinCut metrics
      */
     extendQueenHealth(baseHealth: QueenHealth): QueenHealth & {
-        minCut?: MinCutHealth;
+        minCut?: FleetMinCutHealth;
     };
     /**
      * Extend Queen metrics with MinCut data

package/dist/coordination/mincut/queen-integration.js

@@ -44,6 +44,13 @@ export class QueenMinCutBridge {
     monitor;
     persistence;
     eventSubscriptions = [];
+    /**
+     * Agents with a vertex in the graph, from QueenAgentSpawned or from the
+     * coordinator when the graph was built. Pruned once they complete (#1130).
+     */
+    spawnedAgentIds = new Set();
+    /** The subset spawned for a single task (#1130). */
+    taskAgentIds = new Set();
     snapshotTimer = null;
     initialized = false;
     constructor(eventBus, agentCoordinator, config = {}) {
@@ -137,6 +144,8 @@ export class QueenMinCutBridge {
         // Add agent vertices
         for (const agent of agents) {
             this.addAgentVertex(agent);
+            // #1130: tracked so a completed agent is pruned like a spawned one
+            this.spawnedAgentIds.add(agent.id);
         }
         // Add edges based on coordination patterns
         this.buildCoordinationEdges(agents);
@@ -239,7 +248,10 @@ export class QueenMinCutBridge {
     subscribeToEvents() {
         // Agent spawned
         const onAgentSpawned = async (event) => {
-            const { agentId, domain, type, capabilities } = event.payload;
+            const { agentId, domain, type, capabilities, taskId } = event.payload;
+            this.spawnedAgentIds.add(agentId);
+            if (taskId)
+                this.taskAgentIds.add(agentId);
             // Cast to extended AgentInfo with optional properties
             this.addAgentVertex({
                 id: agentId,
@@ -381,7 +393,9 @@ export class QueenMinCutBridge {
         }
         // Add issues for weak vertices
         const weakVertices = this.monitor.getWeakVertices();
-        for (const weak of weakVertices.slice(0, 3)) { // Top 3 weak vertices
+        // #1130: a task-scoped agent is a leaf by design, not a weak point of the fleet
+        const fleetWeakVertices = weakVertices.filter(weak => !this.isTaskAgentVertex(weak.vertex.id));
+        for (const weak of fleetWeakVertices.slice(0, 3)) { // Top 3 weak vertices
             if (weak.riskScore > 0.7) {
                 issues.push({
                     severity: 'high',
@@ -393,6 +407,66 @@ export class QueenMinCutBridge {
         }
         return issues;
     }
+    /**
+     * #1130: nothing publishes QueenAgentTerminated, so a finished task agent
+     * stayed in the topology and kept the fleet degraded after its run. Drop the
+     * vertex of every tracked agent that completed normally or that the
+     * coordinator no longer lists. A failed agent keeps its vertex (see
+     * failedAgentIssues), so a crash never makes the fleet look healthier.
+     * Returns the tracked agents that failed.
+     */
+    pruneCompletedAgents() {
+        if (this.spawnedAgentIds.size === 0)
+            return [];
+        const byId = new Map(this.agentCoordinator.listAgents().map(agent => [agent.id, agent]));
+        const failed = [];
+        for (const agentId of this.spawnedAgentIds) {
+            const agent = byId.get(agentId);
+            if (agent?.status === 'failed') {
+                failed.push(agent);
+                continue;
+            }
+            if (agent && agent.status !== 'completed')
+                continue;
+            this.graph.removeVertex(`agent:${agentId}`);
+            this.spawnedAgentIds.delete(agentId);
+            this.taskAgentIds.delete(agentId);
+        }
+        return failed;
+    }
+    /** #1130: one issue per failed agent, task-scoped or long-lived. */
+    failedAgentIssues(failed) {
+        return failed.map(agent => ({
+            severity: 'high',
+            message: `Agent ${agent.id} (${agent.type}) failed`,
+            timestamp: new Date(),
+            domain: agent.domain,
+        }));
+    }
+    isTaskAgentVertex(vertexId) {
+        return vertexId.startsWith('agent:') && this.taskAgentIds.has(vertexId.slice('agent:'.length));
+    }
+    /**
+     * #1130: MinCut health with the fleet reading next to the raw one. The fleet
+     * reading drops task-scoped agents from a copy of the graph; the raw graph,
+     * its value and its alerts are unchanged.
+     */
+    getFleetMinCutHealth() {
+        const raw = this.getMinCutHealth();
+        if (this.taskAgentIds.size === 0) {
+            return { ...raw, fleetStatus: raw.status, fleetMinCutValue: raw.minCutValue, taskAgents: 0 };
+        }
+        const fleetGraph = this.graph.clone();
+        for (const agentId of this.taskAgentIds)
+            fleetGraph.removeVertex(`agent:${agentId}`);
+        const fleet = createMinCutHealthMonitor(fleetGraph, this.config).getHealth();
+        return {
+            ...raw,
+            fleetStatus: fleet.status,
+            fleetMinCutValue: fleet.minCutValue,
+            taskAgents: this.taskAgentIds.size,
+        };
+    }
     /**
      * Extend Queen health with MinCut metrics
      */
@@ -400,19 +474,22 @@ export class QueenMinCutBridge {
         if (!this.config.includeInQueenHealth) {
             return baseHealth;
         }
-        const minCutHealth = this.getMinCutHealth();
-        const minCutIssues = this.getHealthIssuesFromMinCut();
+        const failedAgents = this.pruneCompletedAgents();
+        const minCutHealth = this.getFleetMinCutHealth();
+        // #1130: with only task-scoped agents the fleet topology is idle, and the
+        // raw alerts describe those agents, not the fleet.
+        const minCutIssues = minCutHealth.fleetStatus === 'idle' ? [] : this.getHealthIssuesFromMinCut();
         // Issue #205 fix: Only degrade status for actual critical issues
         // 'idle' status is normal for fresh installs - don't degrade health
         let status = baseHealth.status;
-        if (minCutHealth.status === 'critical' && status === 'healthy') {
+        if ((minCutHealth.fleetStatus === 'critical' || failedAgents.length > 0) && status === 'healthy') {
             status = 'degraded';
         }
         // Note: 'idle' status does NOT trigger degradation - it's expected for fresh systems
         return {
             ...baseHealth,
             status,
-            issues: [...baseHealth.issues, ...minCutIssues],
+            issues: [...baseHealth.issues, ...this.failedAgentIssues(failedAgents), ...minCutIssues],
             minCut: minCutHealth,
         };
     }

package/dist/coordination/protocols/learning-consolidation-archive.d.ts

@@ -14,10 +14,10 @@
  *   deleted. A pattern used or re-scored since it was selected is left active.
  * - The archive copy is read back before the active key is deleted, so a
  *   failed write never loses the pattern.
+ * The move is implemented in domains/learning-optimization/pattern-archive.ts.
  */
-import type { MemoryBackend } from '../../kernel/interfaces.js';
 import type { LearnedPattern } from '../../domains/learning-optimization/interfaces.js';
-export type ArchiveOutcome = 'archived' | 'missing' | 'failed';
+export { archiveSelectedPattern, type ArchiveOutcome } from '../../domains/learning-optimization/pattern-archive.js';
 /** Counts of one consolidation run's archive step, for logs and results. */
 export interface ArchiveCounts {
     /** Patterns the retention and trim rules selected for removal. */
@@ -30,10 +30,6 @@ export interface ArchiveCounts {
     failed: number;
 }
 export declare function emptyArchiveCounts(): ArchiveCounts;
-/**
- * Move one selected pattern to its archive key in the learning namespace.
- */
-export declare function archiveSelectedPattern(memory: MemoryBackend, pattern: LearnedPattern, archivedAt?: Date): Promise<ArchiveOutcome>;
 /** True when the pattern was created less than `graceDays` days ago. */
 export declare function isWithinRetentionGrace(pattern: LearnedPattern, graceDays: number, now?: number): boolean;
 //# sourceMappingURL=learning-consolidation-archive.d.ts.map