agentic-qe 3.15.3 → 3.15.5

package/dist/mcp/handlers/domain-handler-configs.d.ts

@@ -11,7 +11,8 @@ import { TestGenerateParams, TestGenerateResult, TestExecuteParams, CoverageAnal
 import type { SecurityScanEvidence } from '../../domains/security-compliance/scan-evidence.js';
 import type { SecurityCoverage } from '../../domains/security-compliance/interfaces.js';
 import { type RiskDecision } from '../../contracts/verdicts.js';
-import type { EvaluatedQualityCheck } from '../../domains/quality-assessment/quality-evidence.js';
+import { type EvaluatedQualityCheck } from '../../domains/quality-assessment/quality-evidence.js';
+import { type MeasuredFailure } from '../../domains/quality-assessment/evidence-sufficiency.js';
 export interface TestExecuteResult {
     taskId: string;
     status: string;
@@ -26,6 +27,10 @@ export interface TestExecuteResult {
     summary?: Record<string, unknown>;
     learning?: Record<string, unknown>;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
 }
 export interface QualityAssessResult {
     taskId: string;
@@ -39,8 +44,28 @@ export interface QualityAssessResult {
     recommendations: string[];
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
     /** ADR-103: versioned, schema-validated gate verdict (additive) */
     riskDecision?: RiskDecision;
+    /**
+     * #996 (additive): 'measured' when every requested metric had data;
+     * 'insufficient-evidence' when any did not — `passed` is then false and
+     * `status` is 'insufficient-evidence'.
+     */
+    evidenceStatus?: 'measured' | 'insufficient-evidence';
+    /** #996: requested metrics with no measured data (reported as -1 in `metrics`). */
+    unmeasured?: string[];
+    /** #996: measured metrics that fail their own limit; any entry blocks. */
+    measuredFailures?: MeasuredFailure[];
+    /** #996: false for static analysis (runGate omitted/false) — no quality gate ran. */
+    gateEvaluated?: boolean;
+    /** #996: share of requested metrics that were measured, in [0, 1]. */
+    confidence?: number;
+    /** #996: plain statement of what was (and was not) evaluated. */
+    note?: string;
 }
 export interface SecurityScanResult {
     taskId: string;
@@ -55,6 +80,10 @@ export interface SecurityScanResult {
     recommendations: string[];
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
     informational?: number;
     evidence?: SecurityScanEvidence;
     limitations?: readonly string[];
@@ -78,6 +107,10 @@ export interface ContractValidateResult {
     warnings: string[];
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
 }
 export interface AccessibilityTestResult {
     taskId: string;
@@ -88,6 +121,10 @@ export interface AccessibilityTestResult {
     warnings: unknown[];
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
 }
 export interface ChaosTestResult {
     taskId: string;
@@ -100,11 +137,17 @@ export interface ChaosTestResult {
     };
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
 }
 export interface DefectPredictParams {
     target?: string;
     lookback?: number;
     minConfidence?: number;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 export interface DefectPredictResult {
     taskId: string;
@@ -118,11 +161,17 @@ export interface DefectPredictResult {
     recommendations: string[];
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
 }
 export interface RequirementsValidateParams {
     requirementsPath?: string;
     testPath?: string;
     generateBDD?: boolean;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 export interface RequirementsValidateResult {
     taskId: string;
@@ -133,11 +182,17 @@ export interface RequirementsValidateResult {
     bddScenarios: string[];
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
 }
 export interface CodeIndexParams {
     target?: string;
     incremental?: boolean;
     gitSince?: string;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 export interface CodeIndexResult {
     taskId: string;
@@ -147,6 +202,10 @@ export interface CodeIndexResult {
     relationsFound: number;
     duration: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
 }
 export declare const testGenerateConfig: DomainHandlerConfig<TestGenerateParams, TestGenerateResult>;
 export declare const testExecuteConfig: DomainHandlerConfig<TestExecuteParams, TestExecuteResult>;

package/dist/mcp/handlers/domain-handler-configs.js

@@ -11,6 +11,8 @@ import { describeSavedResults } from './save-results-option.js';
 import { MetricsCollector } from '../metrics/index.js';
 import { DEFAULT_FRAMEWORKS, FRAMEWORK_TO_LANGUAGE, } from '../../shared/types/test-frameworks.js';
 import { buildRiskDecisionFromQualityGate, validateRiskDecision, } from '../../contracts/verdicts.js';
+import { INSUFFICIENT_EVIDENCE, } from '../../domains/quality-assessment/quality-evidence.js';
+import { validateRequestedMetrics, } from '../../domains/quality-assessment/evidence-sufficiency.js';
 import { validateBehaviorExamples } from '../../domains/test-generation/services/behavior-example-validation.js';
 const SUPPORTED_LANGUAGES = Object.keys(DEFAULT_FRAMEWORKS);
 /**
@@ -403,6 +405,8 @@ export const coverageAnalyzeConfig = {
             coverageMethod: data.coverageMethod ?? 'unknown',
             branchDataCollected,
             functionDataCollected,
+            // #995: the target has no measurement at all — distinct from a measured 0%.
+            ...(data.unmeasured === true ? { unmeasured: true } : {}),
             ...(data.warning ? { warning: data.warning } : {}),
         };
     },
@@ -420,32 +424,66 @@ export const qualityAssessConfig = {
         if (params.runGate !== undefined && typeof params.runGate !== 'boolean') {
             throw new Error('runGate must be a boolean.');
         }
+        // #996 (N3): a string or unknown name is a caller error, not a metric list.
+        const metrics = params.metrics === undefined
+            ? ['coverage', 'complexity', 'maintainability']
+            : validateRequestedMetrics(params.metrics);
         return {
             runGate: params.runGate ?? false,
             threshold: params.threshold || 80,
-            metrics: params.metrics || ['coverage', 'complexity', 'maintainability'],
+            // #996: only a caller-supplied threshold overrides the configured/default
+            // per-metric limits; the 80 fallback above must not.
+            thresholdSource: params.threshold === undefined ? 'default' : 'request',
+            metrics,
             routingTier: routingResult?.decision.tier,
             useAgentBooster: routingResult?.useAgentBooster,
             compiledContext: routingResult?.compiledContext,
         };
     },
     mapToResult: (taskId, data, duration, savedFiles) => {
+        // #996: never approve on missing data. Any unmeasured requested metric
+        // forces passed=false and an explicit insufficient-evidence status.
+        const unmeasured = Array.isArray(data.unmeasured)
+            ? data.unmeasured.filter((m) => typeof m === 'string')
+            : undefined;
+        const insufficient = (unmeasured?.length ?? 0) > 0 || data.evidenceStatus === INSUFFICIENT_EVIDENCE;
+        const gateEvaluated = typeof data.gateEvaluated === 'boolean' ? data.gateEvaluated : undefined;
+        const confidence = typeof data.confidence === 'number' ? data.confidence : undefined;
+        const measuredFailures = Array.isArray(data.measuredFailures)
+            ? data.measuredFailures
+            : undefined;
+        const failedMetrics = (measuredFailures ?? []).map((f) => f.metric);
+        const passed = !insufficient && failedMetrics.length === 0 && data.passed === true;
         // ADR-103: attach a schema-validated RiskDecision envelope at the MCP
         // boundary (additive — existing fields unchanged). Omit rather than
         // emit an invalid envelope.
         const riskDecision = buildRiskDecisionFromQualityGate({
-            passed: typeof data.passed === 'boolean' ? data.passed : undefined,
+            passed: insufficient || failedMetrics.length > 0
+                ? false
+                : typeof data.passed === 'boolean' ? data.passed : undefined,
             qualityScore: data.qualityScore,
             recommendations: data.recommendations || [],
+            unmeasured: insufficient ? (unmeasured?.length ? unmeasured : ['unknown']) : [],
+            failedMetrics,
+            evidenceConfidence: confidence,
+            gateEvaluated,
         });
         return {
             taskId,
-            status: 'completed',
+            status: insufficient ? INSUFFICIENT_EVIDENCE : 'completed',
             ...(typeof data.qualityScore === 'number' ? { qualityScore: data.qualityScore } : {}),
             ...(Array.isArray(data.checks) ? { checks: data.checks } : {}),
-            passed: data.passed || false,
+            passed,
             metrics: data.metrics || {},
             recommendations: data.recommendations || [],
+            ...(data.evidenceStatus === 'measured' || insufficient
+                ? { evidenceStatus: insufficient ? INSUFFICIENT_EVIDENCE : 'measured' }
+                : {}),
+            ...(unmeasured ? { unmeasured } : {}),
+            ...(measuredFailures ? { measuredFailures } : {}),
+            ...(gateEvaluated !== undefined ? { gateEvaluated } : {}),
+            ...(confidence !== undefined ? { confidence } : {}),
+            ...(typeof data.note === 'string' ? { note: data.note } : {}),
             duration,
             savedFiles,
             ...(validateRiskDecision(riskDecision).valid ? { riskDecision } : {}),

package/dist/mcp/handlers/handler-factory.js

@@ -636,6 +636,9 @@ export function createDomainHandler(config) {
                 return {
                     success: false,
                     error: result.error || 'Task execution failed',
+                    // #996: structured failure context (e.g. status + unmeasured metrics),
+                    // only when the failing handler provided it. success stays false.
+                    ...(result.errorDetails ? { data: result.errorDetails } : {}),
                 };
             }
             // Step 5: Map result

package/dist/mcp/handlers/wrapped-domain-handlers.js

@@ -53,7 +53,13 @@ function createWrappedHandler(handler, domain, agent) {
         if (result.success) {
             return { success: true, data: result.data };
         }
-        return { success: false, error: result.error || 'Unknown error' };
+        // #996: keep structured failure context (e.g. insufficient-evidence details)
+        // when the domain handler provided it; success stays false.
+        return {
+            success: false,
+            error: result.error || 'Unknown error',
+            ...(result.data !== undefined ? { data: result.data } : {}),
+        };
     };
 }
 // ============================================================================

package/dist/mcp/protocol-server.js

@@ -899,11 +899,12 @@ export class MCPProtocolServer {
         this.registerTool({
             definition: {
                 name: 'quality_assess',
-                description: `Assess code quality metrics and optionally run a pass/fail quality gate. ${SAVE_RESULTS_HINT} Example: quality_assess({ runGate: true })`,
+                description: `Assess code quality metrics and optionally run a pass/fail quality gate. Unmeasured metrics never pass. ${SAVE_RESULTS_HINT} Example: quality_assess({ runGate: true })`,
                 category: 'domain',
                 isConcurrencySafe: true,
                 parameters: [
-                    { name: 'runGate', type: 'boolean', description: 'Evaluate all seven canonical measured quality checks; requires complete, valid evidence from the last 24 hours. Returns individual checks, not a static aggregate score.', default: false },
+                    { name: 'runGate', type: 'boolean', description: 'Evaluate all seven canonical measured quality checks; requires complete, valid evidence from the last 24 hours. Returns individual checks, not a static aggregate score. Missing, stale or malformed evidence fails with status "insufficient-evidence" and lists the metrics in unmeasured. When false, only static analysis runs (gateEvaluated: false).', default: false },
+                    { name: 'metrics', type: 'array', description: 'Static-analysis metrics to assess (default coverage, complexity, maintainability). Known: coverage, complexity, maintainability, duplication, testability, security. Any requested metric without measured data gives status "insufficient-evidence", passed: false, and lists it in unmeasured; a measured metric failing its threshold blocks.', items: { type: 'string' } },
                     saveResultsParameter('quality_assess'),
                 ],
             },

package/dist/mcp/services/session-store.js

@@ -235,7 +235,17 @@ export class SessionStore {
         if (this.flushTimer === null) {
             this.flushTimer = setTimeout(() => {
                 this.flushTimer = null;
-                this.flush();
+                try {
+                    this.flush();
+                }
+                catch {
+                    // #983: a throw here has no caller and reaches 'uncaughtException',
+                    // which the MCP entry logs as "[AQE] FATAL" on every tick while the
+                    // disk stays full. The unwritten entries stay buffered for the next
+                    // append or flush(), and the buffer's one-time WARN reports a
+                    // persistent failure once it reaches its cap. An explicit flush() or
+                    // close() still throws to its caller.
+                }
             }, BATCH_FLUSH_MS);
         }
     }

package/dist/mcp/tools/coverage-analysis/index.js

@@ -143,6 +143,7 @@ export class CoverageAnalyzeTool extends MCPToolBase {
                 coverageData: { files: domainFiles, summary: calculateSummary(domainFiles) },
                 threshold: thresholds.lines || 80,
                 includeFileDetails: true,
+                measured: true, // parsed from a real report (no estimation fallback here)
             });
             if (!analyzeResult.success) {
                 return {

package/dist/mcp/types.d.ts

@@ -199,6 +199,8 @@ export interface TestExecuteParams {
     timeout?: number;
     collectCoverage?: boolean;
     reportFormat?: 'json' | 'junit' | 'html' | 'markdown';
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Coverage analysis parameters
@@ -209,6 +211,8 @@ export interface CoverageAnalyzeParams {
     detectGaps?: boolean;
     mlPowered?: boolean;
     prioritization?: 'complexity' | 'criticality' | 'change-frequency' | 'ml-confidence';
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Quality assessment parameters
@@ -217,6 +221,8 @@ export interface QualityAssessParams {
     runGate?: boolean;
     threshold?: number;
     metrics?: string[];
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Security scan parameters
@@ -228,6 +234,8 @@ export interface SecurityScanParams {
     target?: string;
     /** URL for explicitly requested dynamic scanning. */
     targetUrl?: string;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Contract validation parameters
@@ -237,6 +245,8 @@ export interface ContractValidateParams {
     providerUrl?: string;
     consumerName?: string;
     checkBreakingChanges?: boolean;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Accessibility test parameters
@@ -245,6 +255,8 @@ export interface AccessibilityTestParams {
     url?: string;
     standard?: 'wcag21-aa' | 'wcag21-aaa' | 'wcag22-aa' | 'section508';
     includeScreenReader?: boolean;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Chaos test parameters
@@ -255,6 +267,8 @@ export interface ChaosTestParams {
     duration?: number;
     intensity?: number;
     dryRun?: boolean;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Protocol execute parameters
@@ -528,6 +542,10 @@ export interface CoverageAnalyzeResult {
     gaps?: CoverageGap[];
     riskScore?: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
     /** #569: `null` when no figure was produced — see `lineCoverage`. */
     statementCoverage?: number | null;
     totalFiles?: number;
@@ -550,6 +568,12 @@ export interface CoverageAnalyzeResult {
     branchDataCollected?: boolean;
     /** Whether function-level data was actually collected. */
     functionDataCollected?: boolean;
+    /**
+     * #995: true when coverage data exists for the project but none of it covers
+     * the requested target (or the run executed no code). The figures are null —
+     * this is "no measurement", never 0%.
+     */
+    unmeasured?: boolean;
     /** Caveats the caller should surface (e.g. "no instrumentation ran"). */
     warning?: string;
 }

package/dist/memory/crdt/convergence-tracker.js

@@ -7,6 +7,7 @@
  *
  * @module memory/crdt/convergence-tracker
  */
+import { createHash } from 'node:crypto';
 // =============================================================================
 // Default Configuration
 // =============================================================================
@@ -23,7 +24,7 @@ const DEFAULT_CONFIG = {
  * not the internal representations, so that stores with equivalent data produce
  * the same hash regardless of how they arrived at that state.
  *
- * Not cryptographic - just for detecting differences.
+ * Fingerprints structured semantic entries; this is not authentication.
  */
 function hashState(state) {
     const parts = [];
@@ -31,7 +32,7 @@ function hashState(state) {
     // compare the result - if both have same winner, they have same value)
     for (const [key, reg] of Object.entries(state.registers)) {
         // Include value, timestamp, and nodeId - these together determine the LWW winner
-        parts.push(`r:${key}:${JSON.stringify(reg.value)}:${reg.timestamp}:${reg.nodeId}`);
+        parts.push(JSON.stringify(['r', key, JSON.stringify(reg.value), reg.timestamp, reg.nodeId]));
     }
     // Hash G-Counters by their TOTAL value (not per-node breakdown)
     // Two stores are converged if they produce the same sum, even if the internal
@@ -41,10 +42,9 @@ function hashState(state) {
         // Also include non-zero counts to detect semantic differences
         const nonZeroCounts = Object.entries(counter.counts)
             .filter(([_, count]) => count > 0)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([nodeId, count]) => `${nodeId}=${count}`)
-            .join(',');
-        parts.push(`g:${key}:${total}:{${nonZeroCounts}}`);
+            .sort(([a], [b]) => a === b ? 0 : a < b ? -1 : 1)
+            .map(([nodeId, count]) => [nodeId, count]);
+        parts.push(JSON.stringify(['g', key, total, nonZeroCounts]));
     }
     // Hash PN-Counters by their NET value (positive - negative)
     // Two stores are converged if they evaluate to the same number
@@ -55,15 +55,13 @@ function hashState(state) {
         // Include non-zero contributions for semantic comparison
         const nonZeroPos = Object.entries(counter.positive.counts)
             .filter(([_, count]) => count > 0)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([nodeId, count]) => `${nodeId}=+${count}`)
-            .join(',');
+            .sort(([a], [b]) => a === b ? 0 : a < b ? -1 : 1)
+            .map(([nodeId, count]) => [nodeId, count]);
         const nonZeroNeg = Object.entries(counter.negative.counts)
             .filter(([_, count]) => count > 0)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([nodeId, count]) => `${nodeId}=-${count}`)
-            .join(',');
-        parts.push(`p:${key}:${netValue}:{${nonZeroPos}|${nonZeroNeg}}`);
+            .sort(([a], [b]) => a === b ? 0 : a < b ? -1 : 1)
+            .map(([nodeId, count]) => [nodeId, count]);
+        parts.push(JSON.stringify(['p', key, netValue, nonZeroPos, nonZeroNeg]));
     }
     // Hash OR-Sets by their active elements (elements with at least one non-tombstoned tag)
     for (const [key, set] of Object.entries(state.sets)) {
@@ -77,20 +75,12 @@ function hashState(state) {
             }
         }
         activeElements.sort();
-        parts.push(`s:${key}:[${activeElements.join(',')}]`);
+        parts.push(JSON.stringify(['s', key, activeElements]));
     }
     // Sort for consistency
     parts.sort();
-    // Simple hash: join and get a fingerprint
-    const joined = parts.join('|');
-    let hash = 0;
-    for (let i = 0; i < joined.length; i++) {
-        const char = joined.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32-bit integer
-    }
-    // Return hash without version - version is per-node and shouldn't affect convergence check
-    return hash.toString(16);
+    // Version is per-node and does not affect semantic convergence.
+    return createHash('sha256').update(JSON.stringify(parts)).digest('hex');
 }
 // =============================================================================
 // Convergence Tracker Implementation

package/dist/memory/crdt/crdt-store.js

@@ -365,6 +365,21 @@ export function createCRDTStore(config) {
                 // For initial state, need full state - caller should use getState instead
                 return null;
             }
+            // A retained suffix cannot cover an older checkpoint. Send complete CRDT
+            // state (including OR-set tombstones) through the existing delta merge API.
+            if (sinceVersion < deltaHistory[0].fromVersion) {
+                const snapshot = store.getState();
+                return {
+                    fromVersion: sinceVersion,
+                    toVersion: version,
+                    timestamp: Date.now(),
+                    nodeId,
+                    registers: snapshot.registers,
+                    gCounters: snapshot.gCounters,
+                    pnCounters: snapshot.pnCounters,
+                    sets: snapshot.sets,
+                };
+            }
             // Find deltas that contain changes after the requested version
             // A delta is relevant if its toVersion > sinceVersion
             const relevantDeltas = deltaHistory.filter((d) => d.toVersion > sinceVersion);

package/dist/memory/crdt/lww-register.js

@@ -43,7 +43,7 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
             return timestampA - timestampB;
         }
         // Tiebreaker: lexicographic comparison of node IDs
-        return nodeIdA.localeCompare(nodeIdB);
+        return nodeIdA === nodeIdB ? 0 : nodeIdA > nodeIdB ? 1 : -1;
     }
     return {
         get() {
@@ -52,7 +52,7 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
         set(value, timestamp) {
             const ts = timestamp ?? Date.now();
             // Only update if new timestamp wins
-            if (state.timestamp === 0 ||
+            if (state.version === 0 ||
                 compareTimestamps(ts, nodeId, state.timestamp, state.nodeId) > 0) {
                 state = {
                     value,
@@ -79,7 +79,7 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
         },
         applyState(incoming) {
             // Only update if incoming timestamp wins
-            if (state.timestamp === 0 ||
+            if (state.version === 0 ||
                 compareTimestamps(incoming.timestamp, incoming.nodeId, state.timestamp, state.nodeId) > 0) {
                 state = {
                     value: incoming.value,

package/dist/memory/crdt/or-set.js

@@ -83,6 +83,22 @@ export function createORSet(nodeId) {
     let version = 0;
     let lastUpdated = Date.now();
     let tagCounter = 0;
+    /** Continue this owner's allocation sequence after importing a checkpoint. */
+    function observeOwnedTag(tag) {
+        const prefix = `${nodeId}:`;
+        if (!tag.startsWith(prefix))
+            return;
+        const suffix = tag.slice(prefix.length);
+        const match = /^(-?\d+):(\d+)$/.exec(suffix);
+        if (!match)
+            return;
+        const timestamp = Number(match[1]);
+        const counter = Number(match[2]);
+        if (Number.isSafeInteger(timestamp) && Number.isSafeInteger(counter) &&
+            counter < Number.MAX_SAFE_INTEGER) {
+            tagCounter = Math.max(tagCounter, counter + 1);
+        }
+    }
     /**
      * Check if an element has any active (non-tombstoned) tags
      */
@@ -202,6 +218,7 @@ export function createORSet(nodeId) {
                 }
                 const localTags = elements.get(serialized);
                 for (const tag of incomingTags) {
+                    observeOwnedTag(tag);
                     if (!localTags.has(tag)) {
                         localTags.add(tag);
                         changed = true;
@@ -215,6 +232,7 @@ export function createORSet(nodeId) {
                 }
                 const localTombstones = tombstones.get(serialized);
                 for (const tag of incomingTombstones) {
+                    observeOwnedTag(tag);
                     if (!localTombstones.has(tag)) {
                         localTombstones.add(tag);
                         changed = true;

package/dist/planning/goap-planner.js

@@ -16,6 +16,8 @@ import { safeJsonParse } from '../shared/safe-json.js';
 import { getUnifiedPersistence } from '../kernel/unified-persistence.js';
 import { DEFAULT_MAX_PLAN_STEPS, validateMaxSteps } from './types.js';
 import { getAllQEActions, QE_GOALS } from './actions/qe-action-library.js';
+/** Conservative budget fallback for actions without a declared estimate. */
+const DEFAULT_ACTION_DURATION_MS = 1000;
 // ============================================================================
 // MinHeap for A* Open Set (O(log n) insert/extract vs O(n log n) sort+shift)
 // ============================================================================
@@ -215,18 +217,24 @@ export class GOAPPlanner {
     }
     /** Restore missing estimates only for unchanged legacy library definitions. */
     backfillActionDurationEstimates() {
-        const update = this.ensureDb().prepare(`
+        const db = this.ensureDb();
+        const missing = db.prepare('SELECT 1 FROM goap_actions WHERE estimated_duration_ms IS NULL LIMIT 1').get();
+        if (!missing)
+            return;
+        const update = db.prepare(`
       UPDATE goap_actions SET estimated_duration_ms = ?
       WHERE estimated_duration_ms IS NULL AND name = ?
         AND agent_type IS ? AND category = ? AND qe_domain IS ?
         AND preconditions = ? AND effects = ?
         AND method IS ? AND params IS ? AND implemented = ?
     `);
-        for (const action of getAllQEActions()) {
-            if (action.estimatedDurationMs === undefined)
-                continue;
-            update.run(action.estimatedDurationMs, action.name, action.agentType ?? null, action.category, action.qeDomain ?? null, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0);
-        }
+        db.transaction(() => {
+            for (const action of getAllQEActions()) {
+                if (action.estimatedDurationMs === undefined)
+                    continue;
+                update.run(action.estimatedDurationMs, action.name, action.agentType ?? null, action.category, action.qeDomain ?? null, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0);
+            }
+        })();
     }
     // ==========================================================================
     // Core Planning - A* Search
@@ -258,7 +266,7 @@ export class GOAPPlanner {
                 this.recordPlanReuse(reusedPlan.id, true);
                 const clonedPlan = {
                     ...reusedPlan,
-                    estimatedDurationMs: reusedPlan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? 0), 0),
+                    estimatedDurationMs: reusedPlan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? DEFAULT_ACTION_DURATION_MS), 0),
                     id: `plan-${Date.now()}-${randomUUID().slice(0, 8)}`,
                     initialState: this.cloneState(currentState),
                     reusedFrom: reusedPlan.id,
@@ -285,7 +293,7 @@ export class GOAPPlanner {
             goalState: goal,
             actions: actionSequence,
             totalCost: actionSequence.reduce((sum, a) => sum + a.cost, 0),
-            estimatedDurationMs: actionSequence.reduce((sum, a) => sum + (a.estimatedDurationMs ?? 0), 0),
+            estimatedDurationMs: actionSequence.reduce((sum, a) => sum + (a.estimatedDurationMs ?? DEFAULT_ACTION_DURATION_MS), 0),
             status: 'pending',
         };
         // A14: persist the plan itself (not just its reuse signature) so
@@ -404,7 +412,7 @@ export class GOAPPlanner {
                     continue;
                 }
                 // Check duration constraints
-                const estimatedDuration = current.estimatedDurationMs + (action.estimatedDurationMs ?? 0);
+                const estimatedDuration = current.estimatedDurationMs + (action.estimatedDurationMs ?? DEFAULT_ACTION_DURATION_MS);
                 if (estimatedDuration > maxDuration) {
                     continue;
                 }
@@ -1040,7 +1048,7 @@ export class GOAPPlanner {
         if (plan.actions.length > maxSteps)
             return false;
         if (constraints?.maxDurationMs !== undefined &&
-            plan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? 0), 0)
+            plan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? DEFAULT_ACTION_DURATION_MS), 0)
                 > constraints.maxDurationMs) {
             return false;
         }