agentic-qe 3.15.12 → 3.15.14

package/dist/cli/commands/learning-prune.js

@@ -0,0 +1,105 @@
+/**
+ * `aqe learning prune` (#1239)
+ *
+ * Bounds the learning tables on demand. A dry run by default: it prints the
+ * row counts each step would change and writes nothing. `--apply` makes the
+ * changes, after a verified backup of memory.db unless `--no-backup`.
+ *
+ * The two default steps (failed dream cycles, outcome concepts) also run
+ * after every committed dream. The other two drop data that may still be of
+ * use, so they run only when asked for here.
+ */
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import chalk from 'chalk';
+import { openDatabase } from '../../shared/safe-db.js';
+import { backupLearningDatabase } from './learning-snapshot.js';
+import { getDbPath, printError, printJson } from './learning-helpers.js';
+import { DEFAULT_FAILED_DREAM_CYCLE_RETENTION_DAYS, DEFAULT_OUTCOME_CONCEPT_CAP, MIN_OUTCOME_CONCEPT_CAP, capOutcomeConcepts, compactConsolidatedExperiences, describeRetention, pruneFailedDreamCycles, pruneRoutingOutcomes, } from '../../learning/learning-retention.js';
+function wholeNumber(flag, raw, min) {
+    if (!/^\d+$/.test(raw) || Number(raw) < min) {
+        throw new Error(`${flag} must be a whole number >= ${min}, got "${raw}"`);
+    }
+    return Number(raw);
+}
+export function registerPruneCommand(learning) {
+    learning
+        .command('prune')
+        .description('Bound learning-table growth (dry run unless --apply)')
+        .option('--dry-run', 'Print the row counts that would change; write nothing (default)')
+        .option('--apply', 'Make the changes (backs up memory.db first)')
+        .option('--no-backup', 'With --apply: skip the backup')
+        .option('--failed-dream-cycles-days <n>', 'Remove failed/interrupted dream cycles older than n days', String(DEFAULT_FAILED_DREAM_CYCLE_RETENTION_DAYS))
+        .option('--outcome-concepts-max <n>', 'Keep the newest n outcome concept nodes', String(DEFAULT_OUTCOME_CONCEPT_CAP))
+        .option('--compact-experiences', 'Opt-in: clear result_json and embedding of archived/merged experiences')
+        .option('--routing-outcomes-older-than <days>', 'Opt-in: remove routing outcomes older than this')
+        .option('--json', 'Output as JSON')
+        .addHelpText('after', `
+Examples:
+  aqe learning prune                                   # dry run of the default steps
+  aqe learning prune --compact-experiences             # dry run, including compaction
+  aqe learning prune --compact-experiences --apply     # back up, then compact
+
+Rows deleted inside the file are reused by SQLite; run VACUUM to shrink the file itself.`)
+        .action(async (options) => {
+        try {
+            if (options.apply && options.dryRun)
+                throw new Error('--apply and --dry-run cannot be combined');
+            const dryRun = !options.apply;
+            const failedDays = wholeNumber('--failed-dream-cycles-days', options.failedDreamCyclesDays, 1);
+            const outcomeMax = wholeNumber('--outcome-concepts-max', options.outcomeConceptsMax, MIN_OUTCOME_CONCEPT_CAP);
+            const routingDays = options.routingOutcomesOlderThan === undefined
+                ? undefined
+                : wholeNumber('--routing-outcomes-older-than', options.routingOutcomesOlderThan, 1);
+            const dbPath = getDbPath();
+            if (!existsSync(dbPath))
+                throw new Error(`No learning database found at: ${dbPath}`);
+            let backupPath;
+            if (!dryRun && options.backup) {
+                const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 23);
+                const output = path.join(path.dirname(dbPath), 'backups', `pre-prune-${stamp}-${randomUUID()}.db`);
+                backupPath = (await backupLearningDatabase(dbPath, output, { verify: true })).backupPath;
+            }
+            const db = openDatabase(dbPath, { readonly: dryRun, fileMustExist: true });
+            const results = [];
+            try {
+                results.push(pruneFailedDreamCycles(db, { retentionDays: failedDays, dryRun }));
+                results.push(capOutcomeConcepts(db, { maxNodes: outcomeMax, dryRun }));
+                if (options.compactExperiences)
+                    results.push(compactConsolidatedExperiences(db, { dryRun }));
+                if (routingDays !== undefined) {
+                    results.push(pruneRoutingOutcomes(db, { olderThanDays: routingDays, dryRun }));
+                }
+            }
+            finally {
+                db.close();
+            }
+            if (options.json) {
+                printJson({ dryRun, dbPath, backupPath, steps: results });
+                return;
+            }
+            console.log(chalk.bold(`\nLearning prune${dryRun ? ' (dry run, nothing written)' : ''}\n`));
+            console.log(`  Database: ${dbPath}`);
+            if (backupPath)
+                console.log(`  Backup:   ${backupPath}`);
+            for (const step of results) {
+                const extra = step.payloadBytes !== undefined
+                    ? `, ${(step.payloadBytes / (1024 * 1024)).toFixed(1)} MB of payload`
+                    : '';
+                console.log(`  ${describeRetention(step)}${extra}`);
+            }
+            if (dryRun)
+                console.log(chalk.gray('\n  Re-run with --apply to make these changes.'));
+            if (!options.compactExperiences || routingDays === undefined) {
+                console.log(chalk.gray('  Opt-in steps: --compact-experiences, --routing-outcomes-older-than <days>.'));
+            }
+            console.log('');
+        }
+        catch (error) {
+            printError(`prune failed: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=learning-prune.js.map

package/dist/cli/commands/learning.js

@@ -22,6 +22,8 @@ import { createLearningMetricsTracker, } from '../../learning/metrics-tracker.js
 import { createRegretTracker, } from '../../learning/regret-tracker.js';
 import { openDatabase } from '../../shared/safe-db.js';
 import { backupLearningDatabase, restoreLearningDatabase } from './learning-snapshot.js';
+import { registerPruneCommand } from './learning-prune.js';
+import { describeDreamRetention } from '../../learning/learning-retention.js';
 import { createSQLitePatternStore } from '../../learning/sqlite-persistence.js';
 import { getActiveEmbeddingSpaceIdentity } from '../../learning/real-embeddings.js';
 import { inspectEmbeddingSpaceRows } from '../../learning/embedding-space.js';
@@ -75,6 +77,7 @@ Examples:
     registerRepairCommand(learning);
     registerHealthCommand(learning);
     registerLoopHealthCommand(learning);
+    registerPruneCommand(learning);
     return learning;
 }
 // ============================================================================
@@ -1244,6 +1247,9 @@ function registerDreamCommand(learning) {
                     conceptsProcessed: result.cycle.conceptsProcessed, associationsFound: result.cycle.associationsFound,
                     insightsGenerated: result.cycle.insightsGenerated, activationStats: result.activationStats,
                     patternsCreated: result.patternsCreated,
+                    retention: result.retention
+                        ? { enabled: result.retention.enabled, steps: describeDreamRetention(result.retention) }
+                        : undefined,
                     insights: result.insights.map(i => ({ id: i.id, type: i.type, description: i.description, noveltyScore: i.noveltyScore, confidenceScore: i.confidenceScore, actionable: i.actionable })),
                 });
             }
@@ -1255,6 +1261,9 @@ function registerDreamCommand(learning) {
                 console.log(`  Concepts:       ${result.cycle.conceptsProcessed}`);
                 console.log(`  Associations:   ${result.cycle.associationsFound}`);
                 console.log(`  Insights:       ${result.cycle.insightsGenerated}`);
+                for (const line of result.retention ? describeDreamRetention(result.retention) : []) {
+                    console.log(`  Retention:      ${line}`);
+                }
                 if (result.activationStats) {
                     console.log(chalk.bold('\n  Activation Stats:'));
                     console.log(`    Iterations:   ${result.activationStats.totalIterations}`);

package/dist/cli/handlers/brain-handler.js

@@ -107,13 +107,24 @@ export class BrainHandler {
                 console.log(`  RVF Size: ${chalk.cyan(formatBytes(rvf.fileSizeBytes))}`);
                 console.log(`  Segments: ${chalk.cyan(rvf.totalSegments)}`);
             }
+            const skippedVectors = manifest.stats
+                .skippedCacheRows?.vectors;
+            if (skippedVectors) {
+                console.log(`  Skipped:  ${chalk.gray(`${skippedVectors} code-index vectors (regenerable: aqe code index <path>)`)}`);
+            }
             console.log(`  Checksum: ${chalk.gray(manifest.checksum)}`);
             console.log(`  Output:   ${chalk.cyan(path.resolve(options.output))}`);
             console.log('');
             await this.cleanupAndExit(0);
         }
         catch (error) {
-            console.error(chalk.red('\n  Brain export failed:'), error);
+            if (error?.code === 'RVF_KERNEL_TOO_LARGE') {
+                // Expected condition, not a crash: the message names the size and the fix.
+                console.error(chalk.red('\n  Brain export failed:'), error.message);
+            }
+            else {
+                console.error(chalk.red('\n  Brain export failed:'), error);
+            }
             await this.cleanupAndExit(1);
         }
     }

package/dist/cli/handlers/task-handler.d.ts

@@ -5,6 +5,11 @@
  */
 import { Command } from 'commander';
 import { ICommandHandler, CLIContext } from './interfaces.js';
+/**
+ * What a completed task's result says it could not check (#1135, #1052):
+ * `incompleteChecks`, or a top-level status of incomplete/failed with its reason.
+ */
+export declare function incompleteResultReasons(result: unknown): string[];
 export declare class TaskHandler implements ICommandHandler {
     readonly name = "task";
     readonly description = "Manage QE tasks";

package/dist/cli/handlers/task-handler.js

@@ -13,6 +13,20 @@ import { writeOutput, toJSON } from '../utils/ci-output.js';
 // ============================================================================
 // Task Handler
 // ============================================================================
+/**
+ * What a completed task's result says it could not check (#1135, #1052):
+ * `incompleteChecks`, or a top-level status of incomplete/failed with its reason.
+ */
+export function incompleteResultReasons(result) {
+    if (!result || typeof result !== 'object')
+        return [];
+    const { status, error, incompleteChecks } = result;
+    const reasons = Array.isArray(incompleteChecks) ? incompleteChecks.filter((reason) => typeof reason === 'string') : [];
+    if (reasons.length === 0 && (status === 'incomplete' || status === 'failed')) {
+        reasons.push(typeof error === 'string' ? error : `result status is ${status}`);
+    }
+    return reasons;
+}
 export class TaskHandler {
     name = 'task';
     description = 'Manage QE tasks';
@@ -149,6 +163,12 @@ export class TaskHandler {
                         const taskStatus = context.queen.getTaskStatus(taskId);
                         if (taskStatus) {
                             if (taskStatus.status === 'completed') {
+                                // #1135, #1052: a result that reports an incomplete or failed check is not a clean run.
+                                const incomplete = incompleteResultReasons(taskStatus.result);
+                                if (incomplete.length > 0) {
+                                    waitSpinner.fail(`Task completed, but its result is incomplete: ${incomplete.join('; ')}`);
+                                    return this.cleanupAndExit(1);
+                                }
                                 waitSpinner.succeed('Task completed successfully');
                                 completed = true;
                             }

package/dist/cli/utils/coverage-verdict.js

@@ -23,7 +23,7 @@ import chalk from 'chalk';
 import { walkSourceFiles } from './file-discovery.js';
 import { buildCoverageData, summarizeCoverage } from './coverage-data.js';
 import { describeNoData, reconcileRecommendations, resolveExistingCoverage, thresholdVerdict, } from '../../coordination/handlers/coverage-target.js';
-import { describeEvidence } from '../../coordination/handlers/coverage-evidence.js';
+import { describeEvidence, describeExcludedEntries } from '../../coordination/handlers/coverage-evidence.js';
 /** `aqe coverage` exit code when no coverage measurement exists for the target (#995). */
 export const EXIT_UNMEASURED = 3;
 /** Provenance labels, the same vocabulary as MCP `coverage_analyze_sublinear`. */
@@ -157,6 +157,15 @@ export function coverageExitCode(outcome, threshold) {
             return 1;
     }
 }
+/** The JSON `warning`: the evidence gaps, then the report entries left out (#1219). */
+function coverageWarning(insufficient, excludedNotes) {
+    if (insufficient.length === 0 && excludedNotes.length === 0)
+        return {};
+    const gaps = insufficient.length > 0 ? `INSUFFICIENT EVIDENCE: ${insufficient.join('; ')}` : '';
+    if (excludedNotes.length === 0)
+        return { warning: gaps };
+    return { warning: [gaps && gaps.replace(/\.?$/, '.'), ...excludedNotes].filter(Boolean).join(' ') };
+}
 /** The `-F json` document for an outcome (same shape in every case). */
 export function coverageJson(outcome, threshold, target) {
     const nulls = { line: null, branch: null, function: null, statement: null };
@@ -176,8 +185,10 @@ export function coverageJson(outcome, threshold, target) {
                 ...(outcome.data.unmeasuredFiles?.length ? { unmeasuredFiles: outcome.data.unmeasuredFiles } : {}),
                 ...(outcome.evidence ? { evidenceStatus: outcome.evidence.status } : {}),
                 ...(outcome.evidence?.stale ? { staleReport: outcome.evidence.stale } : {}),
-                ...(outcome.insufficientEvidence.length > 0
-                    ? { warning: `INSUFFICIENT EVIDENCE: ${outcome.insufficientEvidence.join('; ')}` } : {}),
+                // #1219: report entries that are not project files, left out of the figures.
+                ...(outcome.evidence?.conflictingFiles ? { conflictingFiles: outcome.evidence.conflictingFiles } : {}),
+                ...(outcome.evidence?.excludedEntries ? { excludedReportEntries: outcome.evidence.excludedEntries } : {}),
+                ...coverageWarning(outcome.insufficientEvidence, describeExcludedEntries(outcome.evidence)),
             };
         case 'estimate':
             return {

package/dist/cli/utils/fleet-operation.d.ts

@@ -32,6 +32,9 @@ export type FleetOperationPlan = {
 };
 /** Coverage threshold `analyze` judges against, as `aqe coverage` does by default. */
 export declare const FLEET_COVERAGE_THRESHOLD = 80;
-/** Build the domain task for a fleet operation on `target`, or say why it cannot run. */
-export declare function planFleetOperation(operation: FleetOperation, target: string): Promise<FleetOperationPlan>;
+/**
+ * Build the domain task for a fleet operation on `target`, or say why it
+ * cannot run. `projectRoot` defaults to the project `aqe` runs in.
+ */
+export declare function planFleetOperation(operation: FleetOperation, target: string, projectRoot?: string): Promise<FleetOperationPlan>;
 //# sourceMappingURL=fleet-operation.d.ts.map

package/dist/cli/utils/fleet-operation.js

@@ -17,17 +17,28 @@ import { summarizeCoverage } from './coverage-data.js';
 import { describeNoData, resolveExistingCoverage } from '../../coordination/handlers/coverage-target.js';
 import { describeEvidence } from '../../coordination/handlers/coverage-evidence.js';
 import { MAX_SAST_FILE_BYTES } from '../../domains/security-compliance/sast-path-guard.js';
+import { confinePayloadPaths } from '../../shared/io/payload-path-guard.js';
 export const FLEET_OPERATIONS = ['test', 'analyze', 'scan'];
 /** Coverage threshold `analyze` judges against, as `aqe coverage` does by default. */
 export const FLEET_COVERAGE_THRESHOLD = 80;
 /** Extensions the built-in SAST patterns cover (sast-scanner.ts). */
 const SAST_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
 const refuse = (error) => ({ success: false, error });
-/** Build the domain task for a fleet operation on `target`, or say why it cannot run. */
-export async function planFleetOperation(operation, target) {
+/**
+ * Build the domain task for a fleet operation on `target`, or say why it
+ * cannot run. `projectRoot` defaults to the project `aqe` runs in.
+ */
+export async function planFleetOperation(operation, target, projectRoot) {
     const targetPath = resolve(target);
     if (!existsSync(targetPath))
         return refuse(`Target does not exist: ${target}`);
+    // #1146: the target is confined to the project, as handler paths are
+    // (#1096): a symlink that leads out of the project is refused here instead
+    // of failing every worker later.
+    const { skipped } = await confinePayloadPaths([target], { projectRoot, allowDirectory: true });
+    if (skipped[0]?.reason === 'outside-project-root') {
+        return refuse(`Target ${target} resolves outside the project. Run aqe from the project the target belongs to.`);
+    }
     switch (operation) {
         case 'test': {
             const sourceFiles = walkSourceFiles(targetPath, { includeTests: false });

package/dist/cli/utils/fleet-result.d.ts

@@ -21,11 +21,25 @@ export interface FleetResultSummary {
 }
 /** Summarize one completed task's result for its fleet operation. */
 export declare function summarizeFleetResult(operation: FleetOperation, result: unknown): FleetResultSummary;
+export interface FleetVerdict {
+    /** The workers' results combined into one (#1146); undefined when no worker completed. */
+    combined: unknown;
+    /** Summary of the combined result; undefined when no worker completed. */
+    summary?: FleetResultSummary;
+    passed: boolean;
+    reasons: string[];
+}
 /**
- * Print each distinct worker result once and the verdict over all workers.
+ * Judge a fleet run: the completed workers' results are combined (each worker
+ * handled its own share of the target, #1146) and summarized once.
  * `insufficientEvidence` (from the operation's plan) fails the verdict whatever
- * the workers returned. Returns whether the operation passed.
+ * the workers returned.
  */
+export declare function judgeFleetRun(operation: FleetOperation, workers: ReadonlyArray<{
+    success: boolean;
+    result: unknown;
+}>, insufficientEvidence?: readonly string[]): FleetVerdict;
+/** Print the combined result and the verdict over all workers. Returns whether the operation passed. */
 export declare function reportFleetVerdict(operation: FleetOperation, workers: ReadonlyArray<{
     success: boolean;
     result: unknown;

package/dist/cli/utils/fleet-result.js

@@ -15,6 +15,7 @@
 import chalk from 'chalk';
 import { FLEET_COVERAGE_THRESHOLD } from './fleet-operation.js';
 import { thresholdVerdict } from '../../coordination/handlers/coverage-target.js';
+import { combineFleetResults } from './fleet-shard.js';
 const SEVERITIES = ['critical', 'high', 'medium', 'low', 'informational'];
 const MAX_LISTED_FINDINGS = 10;
 const asRecord = (value) => value !== null && typeof value === 'object' ? value : undefined;
@@ -33,8 +34,9 @@ function summarizeScan(result) {
         `Files scanned: ${coverage?.filesScanned ?? 'n/a'} (evidence: ${completeness})`,
         ...findings.slice(0, MAX_LISTED_FINDINGS).map(f => `  [${f.severity ?? '?'}] ${f.title ?? 'untitled'} @ ${f.location?.file ?? '?'}:${f.location?.line ?? '?'}`),
     ];
-    if (findings.length > MAX_LISTED_FINDINGS)
-        lines.push(`  … ${findings.length - MAX_LISTED_FINDINGS} more`);
+    if (findings.length > MAX_LISTED_FINDINGS) {
+        lines.push(`  … ${findings.length - MAX_LISTED_FINDINGS} more (--format json lists every finding)`);
+    }
     const reasons = [];
     if (count('critical') + count('high') > 0)
         reasons.push(`${count('critical')} critical and ${count('high')} high findings`);
@@ -97,34 +99,37 @@ export function summarizeFleetResult(operation, result) {
     }
 }
 /**
- * Print each distinct worker result once and the verdict over all workers.
+ * Judge a fleet run: the completed workers' results are combined (each worker
+ * handled its own share of the target, #1146) and summarized once.
  * `insufficientEvidence` (from the operation's plan) fails the verdict whatever
- * the workers returned. Returns whether the operation passed.
+ * the workers returned.
  */
+export function judgeFleetRun(operation, workers, insufficientEvidence = []) {
+    const completed = workers.filter(w => w.success).map(w => w.result);
+    const combined = completed.length > 0 ? combineFleetResults(operation, completed) : undefined;
+    const summary = completed.length > 0 ? summarizeFleetResult(operation, combined) : undefined;
+    const incomplete = workers.length - completed.length;
+    const reasons = [...(summary?.reasons ?? [])];
+    if (insufficientEvidence.length > 0)
+        reasons.push('insufficient evidence: the coverage report is incomplete or stale for the target');
+    if (incomplete > 0)
+        reasons.unshift(`${incomplete} of ${workers.length} workers did not complete`);
+    return { combined, ...(summary ? { summary } : {}), passed: reasons.length === 0, reasons };
+}
+/** Print the combined result and the verdict over all workers. Returns whether the operation passed. */
 export function reportFleetVerdict(operation, workers, log = line => console.log(line), insufficientEvidence = []) {
-    const summaries = workers.filter(w => w.success).map(w => summarizeFleetResult(operation, w.result));
-    const shown = new Set();
-    for (const summary of summaries) {
-        const text = summary.lines.join('\n');
-        if (shown.has(text))
-            continue;
-        shown.add(text);
+    const verdict = judgeFleetRun(operation, workers, insufficientEvidence);
+    if (verdict.summary) {
         log('');
-        for (const line of summary.lines)
+        for (const line of verdict.summary.lines)
             log(`   ${line}`);
     }
     for (const reason of insufficientEvidence)
         log(chalk.yellow(`   Evidence: ${reason}`));
-    const incomplete = workers.filter(w => !w.success).length;
-    const reasons = [...new Set(summaries.flatMap(s => s.reasons))];
-    if (insufficientEvidence.length > 0)
-        reasons.push('insufficient evidence: the coverage report is incomplete or stale for the target');
-    if (incomplete > 0)
-        reasons.unshift(`${incomplete} of ${workers.length} workers did not complete`);
     log('');
-    log(reasons.length === 0
+    log(verdict.passed
         ? chalk.green('   Verdict: PASSED')
-        : chalk.red(`   Verdict: FAILED (${reasons.join('; ')})`));
-    return reasons.length === 0;
+        : chalk.red(`   Verdict: FAILED (${verdict.reasons.join('; ')})`));
+    return verdict.passed;
 }
 //# sourceMappingURL=fleet-result.js.map

package/dist/cli/utils/fleet-shard.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Agentic QE v3 - `aqe fleet run` work split (#1146)
+ *
+ * `--parallel N` used to submit the same payload N times, so every worker did
+ * the whole job again. Now the target's files are split across the workers:
+ *   - scan -> each worker scans its own share of the files
+ *   - test -> each worker generates tests for its own share of the source files
+ *   - analyze -> one coverage report is judged as a whole, so it runs as one task
+ * The shard results are then combined into one result for the verdict. Only
+ * figures the workers returned are combined; nothing is estimated.
+ */
+import type { FleetOperation } from './fleet-operation.js';
+/** Workers used when --parallel is not given. */
+export declare const DEFAULT_FLEET_WORKERS = 4;
+export interface FleetShardPlan {
+    /** One payload per worker. */
+    payloads: Array<Record<string, unknown>>;
+    /** Files given to each worker (empty for an operation that is not split). */
+    files: string[][];
+    /** Why fewer workers run than were asked for, if they do. */
+    note?: string;
+}
+/** Split `items` into at most `parts` contiguous chunks whose sizes differ by at most one. */
+export declare function splitEvenly<T>(items: readonly T[], parts: number): T[][];
+/**
+ * Split an operation's payload across workers. `requested` is the --parallel
+ * value, or undefined when the flag was not given.
+ */
+export declare function shardFleetPayload(operation: FleetOperation, payload: Record<string, unknown>, requested: number | undefined): FleetShardPlan;
+/**
+ * Combine the results of the workers that completed into one result of the
+ * operation's shape. Returns undefined when a result cannot be read, so the
+ * verdict fails as unreadable instead of passing on part of the results.
+ */
+export declare function combineFleetResults(operation: FleetOperation, results: readonly unknown[]): unknown;
+//# sourceMappingURL=fleet-shard.d.ts.map

package/dist/cli/utils/fleet-shard.js

@@ -0,0 +1,110 @@
+/**
+ * Agentic QE v3 - `aqe fleet run` work split (#1146)
+ *
+ * `--parallel N` used to submit the same payload N times, so every worker did
+ * the whole job again. Now the target's files are split across the workers:
+ *   - scan -> each worker scans its own share of the files
+ *   - test -> each worker generates tests for its own share of the source files
+ *   - analyze -> one coverage report is judged as a whole, so it runs as one task
+ * The shard results are then combined into one result for the verdict. Only
+ * figures the workers returned are combined; nothing is estimated.
+ */
+/** Workers used when --parallel is not given. */
+export const DEFAULT_FLEET_WORKERS = 4;
+/** The payload field each splittable operation's files are in. */
+const SHARD_FIELD = { scan: 'files', test: 'sourceFiles' };
+/** Split `items` into at most `parts` contiguous chunks whose sizes differ by at most one. */
+export function splitEvenly(items, parts) {
+    const count = Math.max(1, Math.min(parts, items.length));
+    const base = Math.floor(items.length / count);
+    const extra = items.length % count;
+    const chunks = [];
+    let start = 0;
+    for (let i = 0; i < count; i++) {
+        const size = base + (i < extra ? 1 : 0);
+        chunks.push(items.slice(start, start + size));
+        start += size;
+    }
+    return chunks;
+}
+/**
+ * Split an operation's payload across workers. `requested` is the --parallel
+ * value, or undefined when the flag was not given.
+ */
+export function shardFleetPayload(operation, payload, requested) {
+    const field = SHARD_FIELD[operation];
+    if (!field) {
+        const note = requested !== undefined && requested > 1
+            ? `${operation} judges one coverage report as a whole, so it runs as one task; --parallel ${requested} does not apply.`
+            : undefined;
+        return { payloads: [payload], files: [[]], ...(note ? { note } : {}) };
+    }
+    const files = Array.isArray(payload[field]) ? payload[field] : [];
+    const wanted = requested ?? DEFAULT_FLEET_WORKERS;
+    const chunks = splitEvenly(files, wanted);
+    const note = requested !== undefined && chunks.length < requested
+        ? `--parallel ${requested} asks for more workers than there are files (${files.length}); ${chunks.length} run.`
+        : undefined;
+    return {
+        payloads: chunks.map(chunk => ({ ...payload, [field]: chunk })),
+        files: chunks,
+        ...(note ? { note } : {}),
+    };
+}
+const asRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+const SCAN_COUNTS = ['critical', 'high', 'medium', 'low', 'informational', 'totalFiles'];
+function sum(records, key) {
+    const values = records.map(r => r?.[key]);
+    return values.every(v => typeof v === 'number') ? values.reduce((a, b) => a + b, 0) : undefined;
+}
+function combineScans(results) {
+    if (!results.every(r => asRecord(r.summary) && Array.isArray(r.vulnerabilities)))
+        return undefined;
+    const summaries = results.map(r => asRecord(r.summary));
+    const summary = {};
+    for (const key of SCAN_COUNTS) {
+        const total = sum(summaries, key);
+        if (total !== undefined)
+            summary[key] = total;
+    }
+    const coverages = results.map(r => asRecord(r.coverage));
+    const filesScanned = sum(coverages, 'filesScanned');
+    const linesScanned = sum(coverages, 'linesScanned');
+    // Complete only when every shard says so; a shard without evidence leaves it unknown.
+    const completeness = results.map(r => asRecord(r.evidence)?.completeness);
+    const combinedCompleteness = !completeness.every(c => typeof c === 'string') ? undefined
+        : completeness.every(c => c === 'complete') ? 'complete'
+            : completeness.every(c => c === 'none') ? 'none' : 'partial';
+    return {
+        vulnerabilities: results.flatMap(r => r.vulnerabilities),
+        summary,
+        ...(filesScanned !== undefined || linesScanned !== undefined
+            ? { coverage: { ...(filesScanned !== undefined ? { filesScanned } : {}), ...(linesScanned !== undefined ? { linesScanned } : {}) } }
+            : {}),
+        ...(combinedCompleteness ? { evidence: { completeness: combinedCompleteness } } : {}),
+    };
+}
+/**
+ * Combine the results of the workers that completed into one result of the
+ * operation's shape. Returns undefined when a result cannot be read, so the
+ * verdict fails as unreadable instead of passing on part of the results.
+ */
+export function combineFleetResults(operation, results) {
+    if (results.length === 0)
+        return undefined;
+    if (results.length === 1)
+        return results[0];
+    const records = results.map(asRecord);
+    if (records.some(r => !r))
+        return undefined;
+    const valid = records;
+    switch (operation) {
+        case 'scan': return combineScans(valid);
+        case 'test':
+            return valid.every(r => Array.isArray(r.tests)) ? { tests: valid.flatMap(r => r.tests) } : undefined;
+        case 'analyze':
+            // Never split, so several results mean duplicated work; none is preferred.
+            return undefined;
+    }
+}
+//# sourceMappingURL=fleet-shard.js.map

package/dist/context/compaction/index.d.ts

@@ -79,6 +79,13 @@ export declare class CompactionPipeline {
      * Triggers Tier 4 reactive compaction immediately.
      */
     handleOverflow(trigger?: 'status_413' | 'context_overflow'): Promise<Tier4Result>;
+    /** Get the active conversation history (a copy) as the next tier would see it. */
+    getConversationHistory(): ConversationMessage[];
+    /**
+     * Set the budget to the token estimate of the retained history (#1249), so
+     * it describes what is actually kept rather than a tier's reported saving.
+     */
+    private reconcileBudget;
     /** Get compaction statistics for the session_cache_stats tool. */
     getStats(): {
         conversationMessages: number;

package/dist/context/compaction/index.js

@@ -120,10 +120,22 @@ export class CompactionPipeline {
                 tierResults.push(t2);
                 tiersExecuted.push(2);
                 totalTokensSaved += t2.tokensSaved;
-                // Replace conversation history with preserved messages
+                // #1249: keep the Tier-2 summary in history ahead of the preserved
+                // tail. It used to be dropped, so the summarized messages had no
+                // representation left and Tier 3 saw only the tail.
                 if (t2.removedMessageCount > 0) {
-                    this.conversationHistory = [...t2.preservedMessages];
-                    this.budget.releaseTokens(t2.tokensSaved);
+                    const summaryMessage = t2.summary
+                        ? [{
+                                role: 'assistant',
+                                content: t2.summary,
+                                timestamp: Date.now(),
+                                estimatedTokens: t2.summaryTokens,
+                                id: t2.summaryItem?.id,
+                                provenance: t2.summaryItem,
+                            }]
+                        : [];
+                    this.conversationHistory = [...summaryMessage, ...t2.preservedMessages];
+                    this.reconcileBudget();
                 }
             }
             if (maxTier >= 3 && this.budget.shouldAutoCompact()) {
@@ -142,7 +154,7 @@ export class CompactionPipeline {
                             id: t3.summaryItem?.id,
                             provenance: t3.summaryItem,
                         }];
-                    this.budget.releaseTokens(t3.tokensSaved);
+                    this.reconcileBudget();
                 }
             }
             if (maxTier >= 4 && this.budget.isBlocking()) {
@@ -153,7 +165,7 @@ export class CompactionPipeline {
                 totalTokensSaved += t4.tokensSaved;
                 if (t4.droppedCount > 0) {
                     this.conversationHistory = [...t4.survivingMessages];
-                    this.budget.releaseTokens(t4.tokensSaved);
+                    this.reconcileBudget();
                 }
             }
         }
@@ -175,10 +187,22 @@ export class CompactionPipeline {
         const result = this.tier4.compact(this.conversationHistory, trigger);
         if (result.droppedCount > 0) {
             this.conversationHistory = [...result.survivingMessages];
-            this.budget.releaseTokens(result.tokensSaved);
+            this.reconcileBudget();
         }
         return result;
     }
+    /** Get the active conversation history (a copy) as the next tier would see it. */
+    getConversationHistory() {
+        return [...this.conversationHistory];
+    }
+    /**
+     * Set the budget to the token estimate of the retained history (#1249), so
+     * it describes what is actually kept rather than a tier's reported saving.
+     */
+    reconcileBudget() {
+        const retained = this.conversationHistory.reduce((sum, m) => sum + (m.estimatedTokens ?? estimateTokensPadded(m.content)), 0);
+        this.budget.setUsedTokens(retained);
+    }
     /** Get compaction statistics for the session_cache_stats tool. */
     getStats() {
         return {