agentic-qe 3.15.8 → 3.15.9

package/dist/mcp/tools/learning-optimization/optimize.js

@@ -14,7 +14,7 @@ import { LearningCoordinatorService } from '../../../domains/learning-optimizati
 import { MetricsOptimizerService } from '../../../domains/learning-optimization/services/metrics-optimizer.js';
 import { TransferSpecialistService } from '../../../domains/learning-optimization/services/transfer-specialist.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
-import { secureRandom, secureRandomFloat } from '../../../shared/utils/crypto-random.js';
+import { partitionByRewardSource } from '../../../domains/learning-optimization/reward-source.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -59,12 +59,18 @@ export class LearningOptimizeTool extends MCPToolBase {
             switch (action) {
                 case 'learn':
                     result.learnResult = await this.executeLearn(domain, experienceIds, context);
+                    if (result.learnResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 case 'optimize':
                     if (!objective) {
                         return { success: false, error: 'Objective is required for optimize action' };
                     }
                     result.optimizeResult = await this.executeOptimize(domain, objective, context);
+                    if (result.optimizeResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 case 'transfer':
                     if (!domain || !targetDomain) {
@@ -77,6 +83,9 @@ export class LearningOptimizeTool extends MCPToolBase {
                     break;
                 case 'dashboard':
                     result.dashboardResult = await this.executeDashboard(context);
+                    if (result.dashboardResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 default:
                     return { success: false, error: `Unknown action: ${action}` };
@@ -112,9 +121,15 @@ export class LearningOptimizeTool extends MCPToolBase {
         const mineResult = await learningCoordinator.mineExperiences(targetDomain, timeRange);
         const newPatterns = [];
         let experiencesProcessed = 0;
-        let improvement = 0;
+        let evidence = {};
         if (mineResult.success) {
             experiencesProcessed = mineResult.value.experienceCount;
+            // #1109: patterns come from measured outcomes only; say how many were left out.
+            evidence = {
+                measuredExperiences: mineResult.value.measuredExperienceCount ?? experiencesProcessed,
+                assignedRewardsExcluded: mineResult.value.assignedRewardsExcluded ?? 0,
+                ...(mineResult.value.evidenceStatus ? { evidenceStatus: mineResult.value.evidenceStatus } : {}),
+            };
             // Convert mined patterns to result format
             for (const pattern of mineResult.value.patterns) {
                 newPatterns.push({
@@ -127,10 +142,6 @@ export class LearningOptimizeTool extends MCPToolBase {
                     successRate: pattern.successRate,
                 });
             }
-            // Calculate improvement based on success rate vs baseline
-            improvement = mineResult.value.successRate > 0.5
-                ? (mineResult.value.successRate - 0.5) * 20 // Scale to percentage
-                : 0;
         }
         // If specific experience IDs provided, record them
         if (experienceIds && experienceIds.length > 0) {
@@ -138,22 +149,16 @@ export class LearningOptimizeTool extends MCPToolBase {
         }
         // If no patterns were learned, return empty result (not fake data)
         // This is a valid state - no patterns discovered yet
-        if (newPatterns.length === 0) {
-            this.markAsRealData(); // Still real data, just empty
-            return {
-                experiencesProcessed,
-                patternsLearned: 0,
-                newPatterns: [],
-                improvement: 0,
-            };
-        }
-        // Mark as real data - we have actual learning results
+        // #1109: there is no recorded baseline, so improvement is never computed
+        // here. The former (successRate - 0.5) * 20 was an invented scale.
         this.markAsRealData();
         return {
             experiencesProcessed,
+            ...evidence,
             patternsLearned: newPatterns.length,
             newPatterns,
-            improvement,
+            improvement: null,
+            unmeasured: ['improvement'],
         };
     }
     /**
@@ -205,30 +210,18 @@ export class LearningOptimizeTool extends MCPToolBase {
         // Get recent experiences for optimization
         const targetDomain = domain || 'learning-optimization';
         const timeRange = TimeRange.lastNDays(30);
-        const mineResult = await learningCoordinator.mineExperiences(targetDomain, timeRange);
-        // Build experiences array from mined data
-        const experiences = [];
-        if (mineResult.success && mineResult.value.experienceCount > 0) {
-            // Mine experiences provides insights, so we construct dummy experiences for optimization
-            // Real implementation would fetch actual experiences from memory
-            const dummyAgentId = { value: 'optimizer-agent', domain: targetDomain, type: 'optimizer' };
-            for (let i = 0; i < Math.min(mineResult.value.experienceCount, 20); i++) {
-                experiences.push({
-                    id: `exp-${i}`,
-                    agentId: dummyAgentId,
-                    domain: targetDomain,
-                    action: 'optimize',
-                    state: { context: {}, metrics: {} },
-                    result: {
-                        success: secureRandom() > 0.3,
-                        outcome: { [objective.metric]: secureRandomFloat(70, 100) },
-                        duration: secureRandomFloat(1000, 6000),
-                    },
-                    reward: mineResult.value.avgReward,
-                    timestamp: new Date(),
-                });
-            }
-        }
+        const recorded = await learningCoordinator.getExperiences(targetDomain, timeRange);
+        if (!recorded.success)
+            throw recorded.error;
+        // #1109: an assigned reward is not an observation; leave it out before the
+        // sample-count gate so it can neither pad the count nor fail the optimizer.
+        const { measured, assignedExcluded } = partitionByRewardSource(recorded.value);
+        // Missing objective values are absence of evidence, not zero or a random
+        // synthetic observation. Preserve eligible records (including failures).
+        const experiences = measured.filter(experience => {
+            const value = experience.result.outcome[objective.metric];
+            return typeof value === 'number' && Number.isFinite(value);
+        });
         // Create current strategy
         const currentStrategy = {
             name: `${targetDomain}-current`,
@@ -237,7 +230,8 @@ export class LearningOptimizeTool extends MCPToolBase {
                 retryCount: 3,
                 timeout: 30000,
             },
-            expectedOutcome: { [objective.metric]: 70 },
+            // #1099: the current strategy's outcome was never measured here.
+            expectedOutcome: {},
         };
         // Convert objective to domain type, properly cast constraints
         const domainConstraints = (objective.constraints || []).map(c => ({
@@ -253,19 +247,32 @@ export class LearningOptimizeTool extends MCPToolBase {
         // Run optimization if we have enough experiences
         let bestStrategy = currentStrategy;
         let improvement = 0;
-        let confidence = 0.5;
+        let confidence = 0;
         let validationResults = [];
+        let unmeasured = [];
+        let estimated;
+        let evaluation;
         if (experiences.length >= 20) {
             const optimizeResult = await metricsOptimizer.optimizeStrategy(currentStrategy, domainObjective, experiences);
-            if (optimizeResult.success) {
-                bestStrategy = {
-                    name: optimizeResult.value.optimizedStrategy.name,
-                    parameters: optimizeResult.value.optimizedStrategy.parameters,
-                    expectedOutcome: optimizeResult.value.optimizedStrategy.expectedOutcome,
+            if (!optimizeResult.success)
+                throw optimizeResult.error;
+            bestStrategy = {
+                name: optimizeResult.value.optimizedStrategy.name,
+                parameters: optimizeResult.value.optimizedStrategy.parameters,
+                expectedOutcome: optimizeResult.value.optimizedStrategy.expectedOutcome,
+            };
+            improvement = optimizeResult.value.improvement * 100; // Convert to percentage
+            confidence = optimizeResult.value.confidence;
+            validationResults = optimizeResult.value.validationResults;
+            const derived = optimizeResult.value.evaluation;
+            if (derived) {
+                evaluation = {
+                    method: derived.method,
+                    trainingSamples: derived.trainingSamples,
+                    heldOutSamples: derived.heldOutSamples,
                 };
-                improvement = optimizeResult.value.improvement * 100; // Convert to percentage
-                confidence = optimizeResult.value.confidence;
-                validationResults = optimizeResult.value.validationResults;
+                estimated = derived.estimated;
+                unmeasured = [...(derived.unmeasured ?? [])];
             }
         }
         else {
@@ -274,16 +281,27 @@ export class LearningOptimizeTool extends MCPToolBase {
                 tags: [targetDomain, objective.metric],
             };
             const recommendResult = await metricsOptimizer.recommendStrategy(contextForRecommendation);
-            if (recommendResult.success) {
-                bestStrategy = {
-                    name: recommendResult.value.name,
-                    parameters: recommendResult.value.parameters,
-                    expectedOutcome: recommendResult.value.expectedOutcome,
-                };
-            }
+            if (!recommendResult.success)
+                throw recommendResult.error;
+            bestStrategy = {
+                name: recommendResult.value.name,
+                parameters: recommendResult.value.parameters,
+                expectedOutcome: recommendResult.value.expectedOutcome,
+            };
+            unmeasured = ['improvement', 'confidence'];
+        }
+        if (Object.keys(bestStrategy.expectedOutcome).length === 0) {
+            unmeasured.push('expectedOutcome');
         }
         return {
-            strategiesEvaluated: experiences.length > 0 ? Math.min(experiences.length, 12) : 1,
+            inputSource: 'recorded-experiences',
+            experiencesUsed: experiences.length,
+            ...(assignedExcluded > 0 ? { assignedRewardsExcluded: assignedExcluded } : {}),
+            strategiesEvaluated: experiences.length >= 20 ? 1 : 0,
+            ...(experiences.length < 20 ? { evidenceStatus: 'insufficient-evidence' } : {}),
+            ...(unmeasured.length > 0 ? { unmeasured } : {}),
+            ...(estimated ? { estimated } : {}),
+            ...(evaluation ? { evaluation } : {}),
             bestStrategy,
             improvement,
             confidence,
@@ -395,16 +413,17 @@ export class LearningOptimizeTool extends MCPToolBase {
             'quality-assessment', 'defect-intelligence', 'learning-optimization'
         ];
         let experiencesLast24h = 0;
+        let assignedRewardsExcluded = 0;
         const domainPerformance = [];
         for (const domain of domains) {
             const mineResult = await learningCoordinator.mineExperiences(domain, recentTimeRange);
             if (mineResult.success) {
                 experiencesLast24h += mineResult.value.experienceCount;
-                if (mineResult.value.experienceCount > 0) {
-                    domainPerformance.push({
-                        domain,
-                        successRate: mineResult.value.successRate,
-                    });
+                assignedRewardsExcluded += mineResult.value.assignedRewardsExcluded ?? 0;
+                // #1109: only a measured success rate can rank a domain.
+                const { successRate } = mineResult.value;
+                if (successRate !== null) {
+                    domainPerformance.push({ domain, successRate });
                 }
             }
         }
@@ -414,8 +433,14 @@ export class LearningOptimizeTool extends MCPToolBase {
             .slice(0, 3)
             .map(d => d.domain);
         // Calculate overall learning rate from pattern stats
+        // getPatternStats already leaves out patterns learned from assigned rewards.
         const totalPatterns = statsResult.success ? statsResult.value.totalPatterns : 0;
-        const avgSuccessRate = statsResult.success ? statsResult.value.avgSuccessRate : 0;
+        const assignedPatternsExcluded = statsResult.success
+            ? statsResult.value.assignedPatternsExcluded ?? 0
+            : 0;
+        const avgSuccessRate = totalPatterns > 0 && statsResult.success
+            ? statsResult.value.avgSuccessRate
+            : null;
         const overallLearningRate = avgSuccessRate;
         // Generate learning trend from weekly pattern mining
         const learningTrend = [];
@@ -437,28 +462,39 @@ export class LearningOptimizeTool extends MCPToolBase {
                 value: dayPatterns,
             });
         }
-        // Generate milestones based on actual achievements
+        // Milestones from measured figures. When each was first reached is not
+        // recorded, so achievedAt is null rather than an invented date (#1109).
         const recentMilestones = [];
         if (totalPatterns >= 100) {
             recentMilestones.push({
                 name: `Reached ${Math.floor(totalPatterns / 50) * 50} patterns`,
-                achievedAt: new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000).toISOString(),
+                achievedAt: null,
                 domain: 'learning-optimization',
             });
         }
-        if (avgSuccessRate >= 0.8) {
+        if (avgSuccessRate !== null && avgSuccessRate >= 0.8) {
             recentMilestones.push({
                 name: `${Math.round(avgSuccessRate * 100)}% pattern success rate`,
-                achievedAt: new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000).toISOString(),
+                achievedAt: null,
                 domain: topPerformingDomains[0] || 'learning-optimization',
             });
         }
+        const unmeasured = [];
+        if (overallLearningRate === null)
+            unmeasured.push('overallLearningRate');
+        if (topPerformingDomains.length === 0)
+            unmeasured.push('topPerformingDomains');
         return {
             overallLearningRate,
             totalPatterns,
             totalKnowledge: knowledgeResult.success ? knowledgeResult.value.length : 0,
             experiencesLast24h,
-            topPerformingDomains: topPerformingDomains.length > 0 ? topPerformingDomains : ['test-generation'],
+            ...(assignedRewardsExcluded > 0 ? { assignedRewardsExcluded } : {}),
+            ...(assignedPatternsExcluded > 0 ? { assignedPatternsExcluded } : {}),
+            topPerformingDomains,
+            ...(unmeasured.length > 0
+                ? { evidenceStatus: 'insufficient-evidence', unmeasured }
+                : {}),
             learningTrend,
             recentMilestones,
             sona,

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

@@ -50,7 +50,13 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
             return state.value;
         },
         set(value, timestamp) {
-            const ts = timestamp ?? Date.now();
+            let ts = timestamp ?? Date.now();
+            // Without an explicit timestamp the write means "now": a second write by
+            // this node within one clock tick (or after a backwards clock step) must
+            // still supersede its own earlier write, not tie with it and be dropped.
+            if (timestamp === undefined && state.version > 0 && state.nodeId === nodeId && ts <= state.timestamp) {
+                ts = state.timestamp + 1;
+            }
             // Only update if new timestamp wins
             if (state.version === 0 ||
                 compareTimestamps(ts, nodeId, state.timestamp, state.nodeId) > 0) {
@@ -78,6 +84,10 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
             };
         },
         applyState(incoming) {
+            // An unwritten register is the merge identity: its placeholder timestamp
+            // (0) would otherwise beat a real write at a negative timestamp.
+            if (incoming.version === 0)
+                return;
             // Only update if incoming timestamp wins
             if (state.version === 0 ||
                 compareTimestamps(incoming.timestamp, incoming.nodeId, state.timestamp, state.nodeId) > 0) {

package/dist/routing/calibration/ema-calibrator.js

@@ -118,7 +118,9 @@ export class EMACalibrator {
      * Serialize all records for persistence.
      */
     serialize() {
-        const result = {};
+        // Null prototype: an agentId of `__proto__` must stay an own key (a plain
+        // object would turn the assignment into a prototype change and drop it).
+        const result = Object.create(null);
         for (const [key, record] of this.records) {
             result[key] = { ...record };
         }

package/dist/shared/base-domain-plugin.d.ts

@@ -180,6 +180,10 @@ export declare abstract class BaseDomainPlugin implements DomainPlugin {
      * Based on registered task handlers
      */
     canHandleTask(taskType: string): boolean;
+    /**
+     * Task types this domain executes, from its registered task handlers (#1075)
+     */
+    getSupportedTaskTypes(): string[];
     /**
      * Execute a task assigned by Queen Coordinator
      * Routes to the appropriate handler based on task type

package/dist/shared/base-domain-plugin.js

@@ -201,6 +201,12 @@ export class BaseDomainPlugin {
     canHandleTask(taskType) {
         return this.getTaskHandlers().has(taskType);
     }
+    /**
+     * Task types this domain executes, from its registered task handlers (#1075)
+     */
+    getSupportedTaskTypes() {
+        return Array.from(this.getTaskHandlers().keys());
+    }
     /**
      * Execute a task assigned by Queen Coordinator
      * Routes to the appropriate handler based on task type

package/dist/shared/llm/cache.js

@@ -316,7 +316,10 @@ export class LLMResponseCache {
      * Cache a completion response
      */
     setCompletion(prompt, response, options, ttlMs) {
-        if (!this.config.cacheCompletions) {
+        // CompletionResponse does not carry finishReason. In particular, Gemini
+        // returns an empty completion for a safety refusal (#912). Return that
+        // result to its caller, but never pin it as a reusable completion.
+        if (!this.config.cacheCompletions || response.completion.length === 0) {
             return;
         }
         const key = LLMCache.generateKey('completion', prompt, options);

package/dist/shared/security/compliance-patterns.js

@@ -3,6 +3,7 @@
  * Detects security and compliance patterns in source code
  */
 import { FileReader } from '../io/index.js';
+import { findProjectRoot } from '../../kernel/project-root.js';
 // ============================================================================
 // Pattern Definitions
 // ============================================================================
@@ -156,7 +157,8 @@ const SECURITY_CONTROLS_PATTERNS = {
 export class CompliancePatternAnalyzer {
     fileReader;
     constructor() {
-        this.fileReader = new FileReader();
+        // #1096: a symlink inside the project must not expose an outside file.
+        this.fileReader = new FileReader({ projectRoot: findProjectRoot() });
     }
     /**
      * Analyze encryption patterns in files

package/dist/shared/test-runner-process.d.ts

@@ -7,4 +7,30 @@ export declare function trackTestRunnerExit(proc: ChildProcess): () => void;
  * Windows uses taskkill's tree operation while the root PID still exists.
  */
 export declare function terminateTestRunner(proc: ChildProcess): Promise<void>;
+/** The `spawnSync` result fields a test-runner caller reads. */
+export interface TestRunnerProcessResult {
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    error?: NodeJS.ErrnoException;
+}
+export interface TestRunnerProcessOptions {
+    cwd: string;
+    /** Kill the runner and report ETIMEDOUT after this many milliseconds. */
+    timeout: number;
+    env?: NodeJS.ProcessEnv;
+    /** Per-stream output limit; exceeding it kills the runner (ENOBUFS). */
+    maxBuffer?: number;
+}
+/**
+ * #1074: run a test runner without blocking the event loop. Resolves with the
+ * same fields and failure semantics `spawnSync` reports: exit status or
+ * terminating signal, captured UTF-8 stdout/stderr, an ETIMEDOUT error after
+ * `timeout`, an ENOBUFS error once a stream exceeds `maxBuffer`, and the
+ * spawn error itself when the command cannot start. The runner gets its own
+ * process group, so a timeout or overflow stops the whole `npx` tree before
+ * the promise settles and before any report file is removed.
+ */
+export declare function runTestRunnerProcess(command: string, args: readonly string[], options: TestRunnerProcessOptions): Promise<TestRunnerProcessResult>;
 //# sourceMappingURL=test-runner-process.d.ts.map

package/dist/shared/test-runner-process.js

@@ -207,4 +207,95 @@ export function terminateTestRunner(proc) {
         }
     });
 }
+/** `spawnSync`'s default per-stream output limit. */
+const DEFAULT_MAX_BUFFER = 1024 * 1024;
+/** Longest wait for the runner's pipes to close after it has been stopped. */
+const PIPE_RELEASE_GRACE_MS = 3000;
+/**
+ * #1074: run a test runner without blocking the event loop. Resolves with the
+ * same fields and failure semantics `spawnSync` reports: exit status or
+ * terminating signal, captured UTF-8 stdout/stderr, an ETIMEDOUT error after
+ * `timeout`, an ENOBUFS error once a stream exceeds `maxBuffer`, and the
+ * spawn error itself when the command cannot start. The runner gets its own
+ * process group, so a timeout or overflow stops the whole `npx` tree before
+ * the promise settles and before any report file is removed.
+ */
+export function runTestRunnerProcess(command, args, options) {
+    const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    return new Promise(resolve => {
+        let stdout = '';
+        let stderr = '';
+        let error;
+        let stopping;
+        let releaseTimer;
+        let settled = false;
+        let proc;
+        try {
+            proc = spawn(command, [...args], {
+                cwd: options.cwd,
+                env: options.env ?? process.env,
+                detached: process.platform !== 'win32',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (spawnError) {
+            resolve({ status: null, signal: null, stdout, stderr, error: spawnError });
+            return;
+        }
+        const untrackExit = trackTestRunnerExit(proc);
+        const settle = (status, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(releaseTimer);
+            // Report the signal the runner was stopped with, as spawnSync does.
+            const stoppedWith = stopping && !signal ? 'SIGTERM' : signal;
+            const result = { status: stopping ? null : status, signal: stoppedWith, stdout, stderr, error };
+            const done = () => { untrackExit(); resolve(result); };
+            if (stopping)
+                stopping.then(done, done);
+            else
+                done();
+        };
+        const stop = (code, message) => {
+            if (stopping)
+                return;
+            error = Object.assign(new Error(message), { code, syscall: `spawnSync ${command}` });
+            stopping = terminateTestRunner(proc);
+            // spawnSync closes the runner's pipes when it kills it. Do the same once
+            // the runner is stopped, or after a grace period, so a descendant that
+            // left the process group (e.g. a detached server holding the inherited
+            // stdout) cannot keep 'close', and so the result, pending forever.
+            const release = () => {
+                proc.stdout?.destroy();
+                proc.stderr?.destroy();
+            };
+            stopping.then(release, release);
+            releaseTimer = setTimeout(release, PIPE_RELEASE_GRACE_MS);
+        };
+        const timer = setTimeout(() => stop('ETIMEDOUT', `spawnSync ${command} ETIMEDOUT`), options.timeout);
+        const collect = (stream) => (chunk) => {
+            if (stopping)
+                return;
+            const next = (stream === 'stdout' ? stdout : stderr) + chunk;
+            const kept = next.length > maxBuffer ? next.slice(0, maxBuffer) : next;
+            if (stream === 'stdout')
+                stdout = kept;
+            else
+                stderr = kept;
+            if (next.length > maxBuffer)
+                stop('ENOBUFS', `spawnSync ${command} ENOBUFS`);
+        };
+        proc.stdout?.setEncoding('utf8').on('data', collect('stdout'));
+        proc.stderr?.setEncoding('utf8').on('data', collect('stderr'));
+        proc.once('error', (spawnError) => {
+            error ??= spawnError;
+            // A runner that never started emits no 'close' with a status to wait for.
+            if (proc.pid === undefined)
+                settle(null, null);
+        });
+        proc.once('close', (status, signal) => settle(status, signal));
+    });
+}
 //# sourceMappingURL=test-runner-process.js.map

package/dist/shared/types/index.d.ts

@@ -69,6 +69,15 @@ export interface QualityScore {
 }
 export type Severity = 'critical' | 'high' | 'medium' | 'low' | 'info';
 export type Priority = 'p0' | 'p1' | 'p2' | 'p3';
+export declare const ALL_PRIORITIES: readonly Priority[];
+/**
+ * Type guard for a user-supplied task priority (CLI flags, MCP arguments).
+ * Validate at the boundary so an unknown priority is rejected instead of being
+ * silently accepted (#1108).
+ */
+export declare function isPriority(value: unknown): value is Priority;
+/** Shared rejection message so `task_submit` and `aqe task submit` stay in parity (#1108). */
+export declare function invalidPriorityMessage(value: unknown): string;
 export interface DomainConfig {
     enabled: boolean;
     maxAgents: number;

package/dist/shared/types/index.js

@@ -32,4 +32,17 @@ export function ok(value) {
 export function err(error) {
     return { success: false, error };
 }
+export const ALL_PRIORITIES = ['p0', 'p1', 'p2', 'p3'];
+/**
+ * Type guard for a user-supplied task priority (CLI flags, MCP arguments).
+ * Validate at the boundary so an unknown priority is rejected instead of being
+ * silently accepted (#1108).
+ */
+export function isPriority(value) {
+    return typeof value === 'string' && ALL_PRIORITIES.includes(value);
+}
+/** Shared rejection message so `task_submit` and `aqe task submit` stay in parity (#1108). */
+export function invalidPriorityMessage(value) {
+    return `Invalid priority: ${String(value)}. Valid priorities: ${ALL_PRIORITIES.join(', ')}`;
+}
 //# sourceMappingURL=index.js.map

package/dist/shared/utils/namespaced-search.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Agentic QE v3 - namespaced kv key scans (#1049, #1071)
+ *
+ * Two problems with reading every key of a family through
+ * `MemoryBackend.search()`:
+ *
+ * 1. Kernel backends disagree on what a namespaced `search` returns: the
+ *    hybrid (sqlite) backend returns bare keys, the in-memory backend returns
+ *    `<namespace>:<key>`. A caller that passes a result straight back to
+ *    `get(key, { namespace })` double-prefixes the key and reads nothing.
+ * 2. `search()` takes a row limit and has no offset or ordering, so a single
+ *    call with a fixed cap silently drops every key past the cap.
+ *
+ * `searchAllKeys` addresses both: it returns every matching key, bare and in
+ * a stable order.
+ */
+import type { MemoryBackend, RetrieveOptions } from '../../kernel/interfaces.js';
+/**
+ * The bare key for a key returned by `search(pattern, limit, { namespace })`.
+ * A result that already matches `pattern` is bare (keys may legitimately start
+ * with the namespace name, e.g. `defect-intelligence:predictor:…`); otherwise a
+ * leading `<namespace>:` is the backend's prefix and is removed.
+ */
+export declare function bareSearchKey(found: string, namespace: string, pattern: string): string;
+/** First request size for `searchAllKeys`. Each further request doubles it. */
+export declare const DEFAULT_KEY_SCAN_PAGE_SIZE = 10000;
+export interface SearchAllKeysOptions {
+    /** Namespace for the scan. Omit for the backend default. */
+    retrieve?: RetrieveOptions;
+    /** First request size (tests). Defaults to `DEFAULT_KEY_SCAN_PAGE_SIZE`. */
+    pageSize?: number;
+}
+/**
+ * Every key matching `pattern`, bare (usable with `get(key, retrieve)`),
+ * de-duplicated and sorted.
+ *
+ * `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.
+ */
+export declare function searchAllKeys(memory: MemoryBackend, pattern: string, options?: SearchAllKeysOptions): Promise<string[]>;
+//# sourceMappingURL=namespaced-search.d.ts.map