agentic-qe 3.15.9 → 3.15.11

package/dist/shared/utils/namespaced-search.js

@@ -31,6 +31,13 @@ export function bareSearchKey(found, namespace, pattern) {
 }
 /** First request size for `searchAllKeys`. Each further request doubles it. */
 export const DEFAULT_KEY_SCAN_PAGE_SIZE = 10_000;
+/**
+ * Most `search()` requests one scan may make (#1106). The limit doubles each
+ * time, so this covers more keys than any store holds (2^31 x the first page)
+ * while still guaranteeing the loop ends for a backend that never returns a
+ * short page.
+ */
+export const MAX_KEY_SCAN_REQUESTS = 32;
 /**
  * Every key matching `pattern`, bare (usable with `get(key, retrieve)`),
  * de-duplicated and sorted.
@@ -38,11 +45,22 @@ export const DEFAULT_KEY_SCAN_PAGE_SIZE = 10_000;
  * `search()` has no offset, so this widens the request until the backend
  * returns fewer keys than were asked for. That is the only point at which the
  * result is known to be complete; no cap ever truncates it.
+ *
+ * #1106: a backend that always returns at least `limit` keys (for example
+ * one that pads or repeats results) never gives a short page. After
+ * MAX_KEY_SCAN_REQUESTS this throws instead of looping forever or returning a
+ * list that may be incomplete, because callers select patterns to archive
+ * from it. A backend that ignores `limit` and returns every key still ends:
+ * the limit doubles past the key count.
  */
 export async function searchAllKeys(memory, pattern, options = {}) {
     let limit = Math.max(1, Math.floor(options.pageSize ?? DEFAULT_KEY_SCAN_PAGE_SIZE));
     let found = await memory.search(pattern, limit, options.retrieve);
-    while (found.length >= limit) {
+    for (let requests = 1; found.length >= limit; requests++) {
+        if (requests >= MAX_KEY_SCAN_REQUESTS) {
+            throw new Error(`searchAllKeys('${pattern}'): the backend never returned a short page after ${requests} requests ` +
+                `(last limit ${limit}); refusing to return a possibly incomplete key list`);
+        }
         limit *= 2;
         found = await memory.search(pattern, limit, options.retrieve);
     }

package/dist/shared/utils/safe-expression-evaluator.js

@@ -243,8 +243,9 @@ class Parser {
     parseIdentifier() {
         let value = this.context;
         const name = this.advance().value;
-        // Get initial value from context
-        if (typeof value === 'object' && value !== null && name in value) {
+        // Get initial value from context. #1136: own properties only, so an
+        // identifier such as `constructor` does not read an inherited member.
+        if (typeof value === 'object' && value !== null && Object.hasOwn(value, name)) {
             value = value[name];
         }
         else {
@@ -254,7 +255,7 @@ class Parser {
         while (this.current().type === 'DOT') {
             this.advance(); // consume dot
             const prop = this.expect('IDENTIFIER').value;
-            if (value !== null && value !== undefined && typeof value === 'object') {
+            if (value !== null && value !== undefined && typeof value === 'object' && Object.hasOwn(value, prop)) {
                 value = value[prop];
             }
             else {

package/dist/strange-loop/infra-healing/recovery-playbook.js

@@ -59,7 +59,11 @@ export class RecoveryPlaybook {
     getRecoveryPlan(serviceName) {
         if (!this.config)
             return undefined;
-        return this.config.services[serviceName];
+        // Own-property lookup only: a name like `constructor` or `toString` must
+        // not resolve to an Object.prototype member (#1118).
+        return Object.hasOwn(this.config.services, serviceName)
+            ? this.config.services[serviceName]
+            : undefined;
     }
     /**
      * List all service names defined in the playbook.
@@ -89,7 +93,9 @@ export class RecoveryPlaybook {
         const defaultTimeoutMs = defaults.timeoutMs ?? 10_000;
         const defaultMaxRetries = defaults.maxRetries ?? 3;
         const defaultBackoffMs = defaults.backoffMs ?? [2000, 5000, 10_000];
-        const services = {};
+        // Null-prototype map so a service named `__proto__` is stored as an own
+        // key instead of silently replacing the prototype (#1118).
+        const services = Object.create(null);
         if (raw.services) {
             for (const [name, rawService] of Object.entries(raw.services)) {
                 services[name] = this.parseService(name, rawService, defaultTimeoutMs, defaultMaxRetries, defaultBackoffMs);
@@ -137,7 +143,11 @@ export class RecoveryPlaybook {
      */
     interpolate(template) {
         return template.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
-            return this.variables[varName] ?? _match;
+            // Own properties only: `${constructor}` must stay unresolved rather
+            // than expand to Object's function source (#1118).
+            return Object.hasOwn(this.variables, varName)
+                ? (this.variables[varName] ?? _match)
+                : _match;
         });
     }
 }

package/dist/sync/readers/json-reader.js

@@ -130,7 +130,8 @@ export class JSONReader {
         const pathParts = jsonPath.replace(/^\$\./, '').split('.');
         let current = data;
         for (const part of pathParts) {
-            if (current && typeof current === 'object' && part in current) {
+            // #1157: own keys only; `$.constructor` is not a path into the data.
+            if (current && typeof current === 'object' && Object.hasOwn(current, part)) {
                 current = current[part];
             }
             else {

package/dist/validation/anchor-set.d.ts

@@ -57,6 +57,12 @@ export declare function computeContentHash(items: AnchorItem[]): string;
  * except through this loader.
  */
 export declare function loadAnchorSet(path: string): AnchorSet;
+/**
+ * Parse and verify an anchor set already read by the caller (#1161: the MCP
+ * gate reads a caller-named anchor through a confined read). `path` only
+ * labels error messages. Applies the same hash and non-empty checks.
+ */
+export declare function parseAnchorSet(text: string, path: string): AnchorSet;
 /** The score of one anchor item = its oracle mutation kill rate. */
 export declare function anchorItemScore(oracleResult: {
     mutationScore: number;

package/dist/validation/anchor-set.js

@@ -43,7 +43,15 @@ export function computeContentHash(items) {
  * except through this loader.
  */
 export function loadAnchorSet(path) {
-    const raw = JSON.parse(fs.readFileSync(path, 'utf8'));
+    return parseAnchorSet(fs.readFileSync(path, 'utf8'), path);
+}
+/**
+ * Parse and verify an anchor set already read by the caller (#1161: the MCP
+ * gate reads a caller-named anchor through a confined read). `path` only
+ * labels error messages. Applies the same hash and non-empty checks.
+ */
+export function parseAnchorSet(text, path) {
+    const raw = JSON.parse(text);
     const recomputed = computeContentHash(raw.items);
     if (recomputed !== raw.contentHash) {
         throw new Error(`Anchor set hash drift at ${path}: recorded ${raw.contentHash}, `

package/dist/validation/gate-reexecute.js

@@ -26,6 +26,7 @@ import { createHash } from 'node:crypto';
 import { meetsNoRegression } from './anchor-set.js';
 import { tierAllowsPromotion } from '../learning/provenance-tier.js';
 import { bootstrapDeltaCILow, pairedDeltas } from './paired-bootstrap.js';
+import { getOwn } from '../shared/utils/safe-record.js';
 /** Tag domain-separating the rule fingerprint hash. */
 const RULE_TAG = 'aqe:accept-rule:v1+sig';
 /**
@@ -137,14 +138,16 @@ export function sealedHash(sealed) {
  * unknown version so a missing rule can never silently pass verification.
  */
 export function gateFingerprint(ruleVersion) {
-    if (!(ruleVersion in ACCEPTANCE_RULES)) {
+    // #1136: own entries only; `constructor` is not a registered rule.
+    if (!Object.hasOwn(ACCEPTANCE_RULES, ruleVersion)) {
         throw new Error(`Unknown acceptance rule version '${ruleVersion}' — cannot fingerprint an unregistered rule.`);
     }
     return createHash('sha256').update(RULE_TAG).update('\0').update(ruleVersion).digest('hex');
 }
 /** Re-execute a frozen rule on sealed inputs. Throws for an unknown version. */
 export function reExecuteGate(ruleVersion, sealed) {
-    const rule = ACCEPTANCE_RULES[ruleVersion];
+    // #1136: an inherited member (`constructor` is Object) is not a rule.
+    const rule = getOwn(ACCEPTANCE_RULES, ruleVersion);
     if (!rule) {
         throw new Error(`Unknown acceptance rule version '${ruleVersion}' — refusing to re-execute an unregistered rule.`);
     }
@@ -260,14 +263,14 @@ export function pathSealedHash(sealed) {
 }
 /** Fingerprint of a path-rule VERSION. Throws for an unregistered rule. */
 export function pathGateFingerprint(ruleVersion) {
-    if (!(ruleVersion in PROMOTION_PATH_RULES)) {
+    if (!Object.hasOwn(PROMOTION_PATH_RULES, ruleVersion)) {
         throw new Error(`Unknown promotion-path rule version '${ruleVersion}' — cannot fingerprint an unregistered rule.`);
     }
     return createHash('sha256').update(PATH_RULE_TAG).update('\0').update(ruleVersion).digest('hex');
 }
 /** Re-execute a frozen path rule on sealed inputs. Throws for an unknown version. */
 export function reExecutePathGate(ruleVersion, sealed) {
-    const rule = PROMOTION_PATH_RULES[ruleVersion];
+    const rule = getOwn(PROMOTION_PATH_RULES, ruleVersion);
     if (!rule) {
         throw new Error(`Unknown promotion-path rule version '${ruleVersion}' — refusing to re-execute an unregistered rule.`);
     }

package/dist/validation/quality-gate-runner.d.ts

@@ -16,6 +16,7 @@
  * The oracle result and the judge are injected — this module owns no LLM and no
  * mutation runner, so it is deterministic and unit-testable with a fake judge.
  */
+import { type AnchorSet } from './anchor-set.js';
 import { type Judge, type QualityVerdictResult, type RequirementChecklist } from './quality-verdict.js';
 import type { OracleResult } from './oracle-eval.js';
 import { type VerificationCoverageVerdict, type VerificationReachManifest, type VerificationReachResult } from './verification-reach.js';
@@ -35,6 +36,11 @@ export interface QualityGateRequest {
     judge: Judge;
     /** Override the frozen anchor path (absolute, or relative to project root). */
     anchorPath?: string;
+    /**
+     * The anchor set, already read and verified by the caller (#1161). When
+     * given, it is used instead of reading `anchorPath`, which only labels errors.
+     */
+    anchor?: AnchorSet;
     /** Revision-bound failure-mode reach evidence. Omit only for legacy migration. */
     verificationManifest?: VerificationReachManifest;
 }
@@ -66,7 +72,7 @@ export declare function runQualityGate(req: QualityGateRequest): Promise<ReachAw
  * Load the pinned checklist for `checklistId` from the frozen anchor. Exposed so
  * callers (CLI/MCP) can list valid ids or pre-validate before building a judge.
  */
-export declare function loadChecklist(checklistId: string, anchorPath?: string): RequirementChecklist;
+export declare function loadChecklist(checklistId: string, anchorPath?: string, preloaded?: AnchorSet): RequirementChecklist;
 /** List every checklist id in the frozen anchor (for CLI/MCP discoverability). */
 export declare function listChecklistIds(anchorPath?: string): string[];
 //# sourceMappingURL=quality-gate-runner.d.ts.map

package/dist/validation/quality-gate-runner.js

@@ -29,7 +29,7 @@ export const DEFAULT_ANCHOR_RELATIVE_PATH = 'verification/anchors/qe-anchor-v1.j
  * every judgement outcome is returned as a three-valued reach-aware result.
  */
 export async function runQualityGate(req) {
-    const checklist = loadChecklist(req.checklistId, req.anchorPath);
+    const checklist = loadChecklist(req.checklistId, req.anchorPath, req.anchor);
     if (req.verificationManifest
         && req.verificationManifest.artifact.digest !== computeVerificationArtifactDigest(req.artifact)) {
         throw new Error('Verification reach manifest artifact digest does not match the judged artifact');
@@ -67,9 +67,9 @@ function combineVerdicts(quality, coverage) {
  * Load the pinned checklist for `checklistId` from the frozen anchor. Exposed so
  * callers (CLI/MCP) can list valid ids or pre-validate before building a judge.
  */
-export function loadChecklist(checklistId, anchorPath) {
+export function loadChecklist(checklistId, anchorPath, preloaded) {
     const resolved = resolveAnchorPath(anchorPath);
-    const anchor = loadAnchorSet(resolved); // throws on hash drift (ADR-117 §2)
+    const anchor = preloaded ?? loadAnchorSet(resolved); // throws on hash drift (ADR-117 §2)
     const item = anchor.items.find((it) => it.id === checklistId);
     if (!item) {
         const available = anchor.items.map((it) => it.id).join(', ');

package/dist/workers/daemon.js

@@ -74,7 +74,19 @@ export class QEDaemon {
         this._healthCheckTimer.unref?.();
         // Auto-start workers if configured
         if (this.config.autoStart) {
-            await this.workerManager.startAll();
+            try {
+                await this.workerManager.startAll();
+            }
+            catch (error) {
+                // #1116: a failed start must not leave the daemon reporting running.
+                this._running = false;
+                this._startedAt = undefined;
+                if (this._healthCheckTimer)
+                    clearInterval(this._healthCheckTimer);
+                this._healthCheckTimer = undefined;
+                await this.workerManager.stopAll().catch(() => undefined);
+                throw error;
+            }
             console.info('[Daemon] All workers started');
         }
         // Log registered workers

package/dist/workers/quality-daemon/git-watcher.js

@@ -6,12 +6,12 @@
  * 'next' priority analysis tasks into the daemon queue.
  */
 import { watch } from 'fs';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
 import { resolve, join } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { getGitRefError } from '../../shared/git/ref-validation.js';
-const execFileAsync = promisify(execFile);
+import { runGit } from '../../shared/git/git-process.js';
+/** A hung git must not stall the watcher; its process group is stopped (#1115). */
+const GIT_TIMEOUT_MS = 10_000;
 const DEFAULTS = {
     repoRoot: process.cwd(),
     debounceMs: 500,
@@ -100,11 +100,11 @@ export class GitWatcher {
         this._polling = true;
         const changedBranches = [];
         try {
-            const { stdout } = await execFileAsync('git', [
+            const stdout = await runGit([
                 'for-each-ref',
                 '--format=%(refname:short) %(objectname:short)',
                 'refs/heads/',
-            ], { cwd: this.options.repoRoot });
+            ], { cwd: this.options.repoRoot, timeout: GIT_TIMEOUT_MS });
             for (const line of stdout.trim().split('\n')) {
                 if (!line)
                     continue;
@@ -162,13 +162,13 @@ export class GitWatcher {
             return;
         let changedFiles = [];
         try {
-            const { stdout } = await execFileAsync('git', [
+            const stdout = await runGit([
                 'diff-tree',
                 '--no-commit-id',
                 '--name-only',
                 '-r',
                 commitHash,
-            ], { cwd: this.options.repoRoot });
+            ], { cwd: this.options.repoRoot, timeout: GIT_TIMEOUT_MS });
             changedFiles = stdout
                 .trim()
                 .split('\n')
@@ -196,11 +196,11 @@ export class GitWatcher {
     }
     async snapshotHeads() {
         try {
-            const { stdout } = await execFileAsync('git', [
+            const stdout = await runGit([
                 'for-each-ref',
                 '--format=%(refname:short) %(objectname:short)',
                 'refs/heads/',
-            ], { cwd: this.options.repoRoot });
+            ], { cwd: this.options.repoRoot, timeout: GIT_TIMEOUT_MS });
             for (const line of stdout.trim().split('\n')) {
                 if (!line)
                     continue;

package/dist/workers/workers/defect-predictor.d.ts

@@ -8,10 +8,14 @@
  *
  * #1043: every prediction comes from a run of the defect-intelligence
  * predictor (`defect-intelligence:predictor:prediction:<id>` in the
- * `defect-intelligence` namespace, written by DefectPredictorService), and
+ * `defect-intelligence` namespace, written by DefectPredictorService or the
+ * public MCP handler), and
  * only files that exist in the project are kept. Code hotspots have no
  * measured source and are reported unmeasured. Nothing predicted → nothing
- * stored, an "unmeasured" info finding. A `defect:predictions` record without
+ * stored, an "unmeasured" info finding. A recorded static scan is labelled
+ * `estimated: true` with its prediction method: `measured` means an actual
+ * analysis ran, not that its risk estimate is a calibrated probability.
+ * A `defect:predictions` record without
  * the measured stamp (the invented one written by <= 3.15.6) is ignored and
  * replaced by the next measured run.
  */
@@ -30,7 +34,8 @@ export declare class DefectPredictorWorker extends BaseWorker {
      * #1043: the most recent prediction run the defect-intelligence predictor
      * recorded, restricted to regular files whose real path is inside the
      * project root. `measured` is `null` when there is no such prediction;
-     * `unusable` describes a newest prediction none of whose files qualify.
+     * `unusable` describes an ambiguous newest timestamp or a newest prediction
+     * none of whose files qualify.
      */
     private readLatestPrediction;
     private analyzeHighRiskPredictions;

package/dist/workers/workers/defect-predictor.js

@@ -8,16 +8,21 @@
  *
  * #1043: every prediction comes from a run of the defect-intelligence
  * predictor (`defect-intelligence:predictor:prediction:<id>` in the
- * `defect-intelligence` namespace, written by DefectPredictorService), and
+ * `defect-intelligence` namespace, written by DefectPredictorService or the
+ * public MCP handler), and
  * only files that exist in the project are kept. Code hotspots have no
  * measured source and are reported unmeasured. Nothing predicted → nothing
- * stored, an "unmeasured" info finding. A `defect:predictions` record without
+ * stored, an "unmeasured" info finding. A recorded static scan is labelled
+ * `estimated: true` with its prediction method: `measured` means an actual
+ * analysis ran, not that its risk estimate is a calibrated probability.
+ * A `defect:predictions` record without
  * the measured stamp (the invented one written by <= 3.15.6) is ignored and
  * replaced by the next measured run.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { bareSearchKey } from '../namespaced-keys.js';
+import { parsePredictionRecord } from '../../domains/defect-intelligence/prediction-history.js';
 import { BaseWorker } from '../base-worker.js';
 import { findProjectRoot } from '../../kernel/project-root.js';
 const CONFIG = {
@@ -36,10 +41,6 @@ const DEFECT_NAMESPACE = 'defect-intelligence';
 const PREDICTION_KEY_PATTERN = 'defect-intelligence:predictor:prediction:*';
 const PREDICTIONS_KEY = 'defect:predictions';
 const SCHEMA_VERSION = 1;
-/** The predictor keeps its records for 7 days; nothing older is current. */
-const MAX_PREDICTION_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-const MAX_PREDICTION_RECORDS = 1000;
-const RISK_LEVELS = ['critical', 'high', 'medium', 'low', 'info'];
 /**
  * Where a predicted path lies, resolved against the project root with
  * symlinks followed: only a regular file whose real path is inside the
@@ -75,39 +76,6 @@ function realProjectRoot() {
         return path.resolve(root);
     }
 }
-const isRecord = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-function parseFilePrediction(raw) {
-    if (!isRecord(raw))
-        return null;
-    const { file, probability, riskLevel } = raw;
-    if (typeof file !== 'string' || file.length === 0)
-        return null;
-    if (typeof probability !== 'number' || !Number.isFinite(probability) || probability < 0 || probability > 1)
-        return null;
-    if (!RISK_LEVELS.includes(riskLevel))
-        return null;
-    const factors = Array.isArray(raw.factors)
-        ? raw.factors.filter((f) => isRecord(f) && typeof f.name === 'string' && typeof f.contribution === 'number' && Number.isFinite(f.contribution))
-        : [];
-    const recommendations = Array.isArray(raw.recommendations)
-        ? raw.recommendations.filter((r) => typeof r === 'string')
-        : [];
-    return { file, probability, riskLevel: riskLevel, factors, recommendations };
-}
-/** A recorded prediction run, or `null` when the record is not a usable one. */
-function parsePredictionRecord(raw, now) {
-    if (!isRecord(raw) || typeof raw.id !== 'string' || typeof raw.timestamp !== 'string')
-        return null;
-    const t = Date.parse(raw.timestamp);
-    if (!Number.isFinite(t) || t > now + 60_000 || now - t > MAX_PREDICTION_AGE_MS)
-        return null;
-    if (!Array.isArray(raw.predictions) || raw.predictions.length === 0)
-        return null;
-    const predictions = raw.predictions.map(parseFilePrediction);
-    if (predictions.some((p) => p === null))
-        return null;
-    return { id: raw.id, timestamp: raw.timestamp, predictions: predictions };
-}
 export class DefectPredictorWorker extends BaseWorker {
     constructor() {
         super(CONFIG);
@@ -124,10 +92,12 @@ export class DefectPredictorWorker extends BaseWorker {
                 severity: 'info',
                 domain: 'defect-intelligence',
                 title: 'Defect Prediction Unmeasured',
-                description: (unusable
-                    ? `The latest defect prediction (${unusable.id}) names no file inside this project ` +
-                        `(${unusable.outside} outside the project root, ${unusable.missing} missing), so no risk is reported. `
-                    : 'No defect prediction for files in this project has been recorded in the last 7 days, so no risk is reported. ') +
+                description: (unusable?.ambiguous
+                    ? 'Multiple defect predictions have the same timestamp, so no unique latest analysis can be identified. No risk is reported. '
+                    : unusable
+                        ? `The latest defect prediction (${unusable.id}) names no file inside this project ` +
+                            `(${unusable.outside} outside the project root, ${unusable.missing} missing), so no risk is reported. `
+                        : 'No defect prediction for files in this project has been recorded in the last 7 days, so no risk is reported. ') +
                     'Run defect_predict on the files to assess.',
             });
             if (unusable)
@@ -147,7 +117,14 @@ export class DefectPredictorWorker extends BaseWorker {
             }, findings, recommendations);
         }
         const { predictions } = latest;
-        this.analyzeHighRiskPredictions(predictions, findings, recommendations);
+        if (latest.filesSkipped) {
+            findings.push({
+                type: 'defect-prediction-partial', severity: 'info', domain: 'defect-intelligence',
+                title: 'Partial Defect Prediction',
+                description: `${latest.filesSkipped} source files could not be read; risk estimates cover only ${predictions.length} successfully analyzed files.`,
+            });
+        }
+        this.analyzeHighRiskPredictions(predictions, findings, recommendations, latest.estimated === true);
         await context.memory.set(PREDICTIONS_KEY, latest);
         await context.memory.set('defect:lastAnalysis', latest.evaluatedAt);
         const healthScore = this.calculateHealthScore(predictions);
@@ -165,6 +142,8 @@ export class DefectPredictorWorker extends BaseWorker {
             trend: 'stable',
             domainMetrics: {
                 filesAnalyzed: predictions.length,
+                filesSkipped: latest.filesSkipped ?? 0,
+                scanStatus: latest.filesSkipped ? 'partial' : 'complete',
                 highRiskFiles: highRisk,
                 missingFilesSkipped: latest.missingFilesSkipped,
                 outsideProjectSkipped: latest.outsideProjectSkipped,
@@ -192,21 +171,37 @@ export class DefectPredictorWorker extends BaseWorker {
      * #1043: the most recent prediction run the defect-intelligence predictor
      * recorded, restricted to regular files whose real path is inside the
      * project root. `measured` is `null` when there is no such prediction;
-     * `unusable` describes a newest prediction none of whose files qualify.
+     * `unusable` describes an ambiguous newest timestamp or a newest prediction
+     * none of whose files qualify.
      */
     async readLatestPrediction(context) {
-        const keys = await context.memory.search(PREDICTION_KEY_PATTERN, MAX_PREDICTION_RECORDS, { namespace: DEFECT_NAMESPACE });
+        const keys = await context.memory.search(PREDICTION_KEY_PATTERN, Number.MAX_SAFE_INTEGER, { namespace: DEFECT_NAMESPACE });
         const now = Date.now();
         let latest = null;
+        let ambiguous = false;
         for (const found of keys) {
             // #1049: the in-memory backend returns `<namespace>:<key>` from a namespaced search.
             const key = bareSearchKey(found, DEFECT_NAMESPACE, PREDICTION_KEY_PATTERN);
             const parsed = parsePredictionRecord(await context.memory.get(key, { namespace: DEFECT_NAMESPACE }), now);
-            if (parsed && (!latest || Date.parse(parsed.timestamp) > Date.parse(latest.timestamp)))
+            if (!parsed)
+                continue;
+            if (!latest || Date.parse(parsed.timestamp) > Date.parse(latest.timestamp)) {
                 latest = parsed;
+                ambiguous = false;
+            }
+            else if (Date.parse(parsed.timestamp) === Date.parse(latest.timestamp) && parsed.id !== latest.id) {
+                ambiguous = true;
+            }
         }
         if (!latest)
             return { measured: null, unusable: null };
+        // Timestamp precision cannot establish ordering between concurrent runs.
+        // Never let backend key ordering decide whether the current scan is clean.
+        if (ambiguous)
+            return {
+                measured: null,
+                unusable: { id: `ambiguous:${latest.timestamp}`, outside: 0, missing: 0, ambiguous: true },
+            };
         const realRoot = realProjectRoot();
         const disposition = latest.predictions.map((p) => classifyPredictedFile(p.file, realRoot));
         const existing = latest.predictions.filter((_, i) => disposition[i] === 'inside');
@@ -224,6 +219,7 @@ export class DefectPredictorWorker extends BaseWorker {
                 schemaVersion: SCHEMA_VERSION,
                 source: 'defect-intelligence',
                 predictionId: latest.id,
+                ...(latest.estimated ? { estimated: true, predictionMethod: latest.predictionMethod, filesSkipped: latest.filesSkipped } : {}),
                 predictedAt: latest.timestamp,
                 evaluatedAt: new Date().toISOString(),
                 predictions: existing,
@@ -231,7 +227,7 @@ export class DefectPredictorWorker extends BaseWorker {
                 outsideProjectSkipped: outside,
             } };
     }
-    analyzeHighRiskPredictions(predictions, findings, recommendations) {
+    analyzeHighRiskPredictions(predictions, findings, recommendations, estimated = false) {
         const critical = predictions.filter(p => p.riskLevel === 'critical');
         const high = predictions.filter(p => p.riskLevel === 'high');
         for (const prediction of [...critical, ...high]) {
@@ -241,10 +237,13 @@ export class DefectPredictorWorker extends BaseWorker {
                 severity: prediction.riskLevel,
                 domain: 'defect-intelligence',
                 title: `${prediction.riskLevel === 'critical' ? 'Critical' : 'High'} Defect Risk: ${name}`,
-                description: `${(prediction.probability * 100).toFixed(0)}% predicted defect probability (defect-intelligence predictor)`,
+                description: estimated
+                    ? `${(prediction.probability * 100).toFixed(0)}% estimated code-risk score (static-code-indicators); not a calibrated defect probability`
+                    : `${(prediction.probability * 100).toFixed(0)}% predicted defect probability (defect-intelligence predictor)`,
                 resource: prediction.file,
                 context: {
                     probability: prediction.probability,
+                    ...(estimated ? { estimated: true, predictionMethod: 'static-code-indicators' } : {}),
                     factors: prediction.factors,
                     recommendations: prediction.recommendations,
                 },

package/dist/workers/workers/learning-consolidation.d.ts

@@ -31,6 +31,8 @@ export declare class LearningConsolidationWorker extends BaseWorker {
     private readonly dreamInsightsPruneNotBefore;
     /** #1061: an invalid retention value is reported once per process. */
     private retentionWarningLogged;
+    /** #1116: NULL-id stale rows last reported, so the warning is not repeated every tick. */
+    private nullIdRowsReported;
     constructor();
     /**
      * Initialize or get the pattern lifecycle manager

package/dist/workers/workers/learning-consolidation.js

@@ -61,6 +61,8 @@ export class LearningConsolidationWorker extends BaseWorker {
     dreamInsightsPruneNotBefore = Date.now() + CONFIG.intervalMs;
     /** #1061: an invalid retention value is reported once per process. */
     retentionWarningLogged = false;
+    /** #1116: NULL-id stale rows last reported, so the warning is not repeated every tick. */
+    nullIdRowsReported = 0;
     constructor() {
         super(CONFIG);
     }
@@ -252,7 +254,16 @@ export class LearningConsolidationWorker extends BaseWorker {
             return 0;
         const db = getUnifiedMemory().getDatabase();
         // #1066: rows are copied to dream_insights_archive and verified first.
-        const { pruned, archived } = pruneStaleDreamInsights(db, { retentionDays });
+        const { pruned, archived, skippedNullId } = pruneStaleDreamInsights(db, { retentionDays });
+        // #1116: rows with a NULL id cannot be archived and are left in place.
+        // Warn when their number changes, not on every tick.
+        if (skippedNullId !== this.nullIdRowsReported) {
+            this.nullIdRowsReported = skippedNullId;
+            if (skippedNullId > 0) {
+                process.stderr.write(`[AQE] WARN dream_insights retention: ${skippedNullId} stale insight(s) have no id and were ` +
+                    'left in place (they cannot be archived); the other stale insights were archived as usual\n');
+            }
+        }
         if (pruned > 0) {
             // Default log level, stderr only: MCP stdout carries JSON-RPC.
             process.stderr.write(`[AQE] dream_insights retention: moved ${pruned} unapplied insight(s) ` +

package/dist/workflows/browser/workflow-loader.js

@@ -3,6 +3,7 @@ import { join, basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { parse as parseYaml } from 'yaml';
 import { safeEvaluateBoolean } from '../../shared/utils/safe-expression-evaluator.js';
+import { setOwn } from '../../shared/utils/safe-record.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -142,8 +143,9 @@ export class WorkflowLoader {
     async createContext(templateName, variables) {
         const workflow = await this.load(templateName);
         // Validate required variables
+        // #1136: a variable counts as given only when it is an own property.
         const missingVars = workflow.variables
-            .filter(v => v.required && !(v.name in variables))
+            .filter(v => v.required && !Object.hasOwn(variables, v.name))
             .map(v => v.name);
         if (missingVars.length > 0) {
             throw new Error(`Missing required variables: ${missingVars.join(', ')}`);
@@ -151,11 +153,11 @@ export class WorkflowLoader {
         // Resolve variables with defaults
         const resolvedVariables = {};
         workflow.variables.forEach(varDef => {
-            if (varDef.name in variables) {
-                resolvedVariables[varDef.name] = variables[varDef.name];
+            if (Object.hasOwn(variables, varDef.name)) {
+                setOwn(resolvedVariables, varDef.name, variables[varDef.name]);
             }
             else if ('default' in varDef) {
-                resolvedVariables[varDef.name] = varDef.default;
+                setOwn(resolvedVariables, varDef.name, varDef.default);
             }
         });
         return {
@@ -217,7 +219,8 @@ export function interpolateVariables(template, variables) {
         const keys = trimmedKey.split('.');
         let value = variables;
         for (const k of keys) {
-            if (value && typeof value === 'object' && k in value) {
+            // #1136: own properties only; {{constructor}} is not a variable.
+            if (value && typeof value === 'object' && Object.hasOwn(value, k)) {
                 value = value[k];
             }
             else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.15.9",
+  "version": "3.15.11",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",

package/dist/cli/chunks/adapter-R2Q4QGXQ.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.9");process.exit(0)}
-import{a,b,c}from"./chunk-PBZI2ZPV.js";import"./chunk-A6YIH4C4.js";import"./chunk-KIXYKUCI.js";import"./chunk-PVIA2FPD.js";import"./chunk-N3KEY4XJ.js";import"./chunk-HZ5NC6U5.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};