agentic-qe 3.13.8 → 3.13.10

package/dist/cli/chunks/{workflow-F5HE4FGG.js → workflow-VNAYFUVY.js}

@@ -1,5 +1,5 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.13.8");process.exit(0)}
-import"./chunk-QMMRUFEI.js";import{b as $}from"./chunk-Y6EFJG52.js";import{d as R}from"./chunk-QFHOF4F3.js";import{b as k,c as C,d as b}from"./chunk-BC37ZYBO.js";import{c as W}from"./chunk-HD22NMGP.js";import"./chunk-MRLPZMA3.js";import"./chunk-XKKCH24C.js";import"./chunk-NW5XQQMC.js";import{Command as O}from"commander";import o from"chalk";function P(d,a){let m=d.indexOf("=");return m>0&&(a[d.substring(0,m)]=d.substring(m+1)),a}function x(d,a,m){let y=new O("workflow").description("Manage QE workflows and pipelines (ADR-041)");return y.command("run <file>").description("Execute a QE pipeline from YAML file").option("-w, --watch","Watch execution progress").option("-v, --verbose","Show detailed output").option("--params <json>","Additional parameters as JSON","{}").action(async(t,l)=>{if(!await m())return;let e=await import("fs"),c=(await import("path")).resolve(t);try{console.log(o.blue(`
+import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.13.10");process.exit(0)}
+import"./chunk-U5WFVIKL.js";import{b as $}from"./chunk-FBJUNJ2A.js";import{d as R}from"./chunk-H7AACUYS.js";import{b as k,c as C,d as b}from"./chunk-BM5BSYPW.js";import{c as W}from"./chunk-GQ6H37RN.js";import"./chunk-54RIPGMC.js";import"./chunk-OLETDPH2.js";import"./chunk-W3DCBOLL.js";import{Command as O}from"commander";import o from"chalk";function P(d,a){let m=d.indexOf("=");return m>0&&(a[d.substring(0,m)]=d.substring(m+1)),a}function x(d,a,m){let y=new O("workflow").description("Manage QE workflows and pipelines (ADR-041)");return y.command("run <file>").description("Execute a QE pipeline from YAML file").option("-w, --watch","Watch execution progress").option("-v, --verbose","Show detailed output").option("--params <json>","Additional parameters as JSON","{}").action(async(t,l)=>{if(!await m())return;let e=await import("fs"),c=(await import("path")).resolve(t);try{console.log(o.blue(`
  Running workflow from: ${t}
 `));let s=k(c);if(!s.success||!s.workflow){console.log(o.red("Failed to parse pipeline:"));for(let w of s.errors)console.log(o.red(`   ${w}`));await a(1)}let r={...W(l.params,"params")};if(s.pipeline){for(let w of s.pipeline.stages)if(w.params)for(let[S,h]of Object.entries(w.params))r[S]=h}if(!d.workflowOrchestrator.getWorkflow(s.workflow.id)){let w=d.workflowOrchestrator.registerWorkflow(s.workflow);w.success||(console.log(o.red(`Failed to register workflow: ${w.error.message}`)),await a(1))}let n=await d.workflowOrchestrator.executeWorkflow(s.workflow.id,r);if(!n.success){console.log(o.red(`Failed to start workflow: ${n.error.message}`)),await a(1);return}let p=n.value;if(console.log(o.cyan(`  Execution ID: ${p}`)),console.log(o.gray(`  Workflow: ${s.workflow.name}`)),console.log(o.gray(`  Stages: ${s.workflow.steps.length}`)),console.log(""),l.watch){console.log(o.blue(`Workflow Progress:
 `));let w,S=Date.now();for(;;){let g=d.workflowOrchestrator.getWorkflowStatus(p);if(!g)break;if(!w||w.progress!==g.progress||w.status!==g.status||JSON.stringify(w.currentSteps)!==JSON.stringify(g.currentSteps)){process.stdout.write("\r\x1B[K");let v="\u2588".repeat(Math.floor(g.progress/5))+"\u2591".repeat(20-Math.floor(g.progress/5)),D=g.status==="completed"?o.green:g.status==="failed"?o.red:g.status==="running"?o.yellow:o.gray;console.log(`  [${v}] ${g.progress}% - ${D(g.status)}`),g.currentSteps.length>0&&l.verbose&&console.log(o.gray(`    Running: ${g.currentSteps.join(", ")}`)),w=g}if(g.status==="completed"||g.status==="failed"||g.status==="cancelled")break;await new Promise(v=>setTimeout(v,500))}let h=d.workflowOrchestrator.getWorkflowStatus(p);if(h){console.log("");let g=h.duration||Date.now()-S;h.status==="completed"?(console.log(o.green("Workflow completed successfully")),console.log(o.gray(`   Duration: ${$(g)}`)),console.log(o.gray(`   Completed: ${h.completedSteps.length} stages`)),h.skippedSteps.length>0&&console.log(o.yellow(`   Skipped: ${h.skippedSteps.length} stages`))):h.status==="failed"?(console.log(o.red("Workflow failed")),console.log(o.red(`   Error: ${h.error}`)),console.log(o.gray(`   Failed stages: ${h.failedSteps.join(", ")}`))):console.log(o.yellow(`Workflow ${h.status}`))}}else console.log(o.green("Workflow execution started")),console.log(o.gray(`   Use 'aqe workflow status ${p}' to check progress`));console.log(""),await a(0)}catch(s){console.error(o.red(`
@@ -35,10 +35,10 @@ Workflow cancelled: ${t}
 `)):console.log(o.red(`
 Failed to cancel workflow: ${l.error.message}
 `)),await a(l.success?0:1)}catch(l){console.error(o.red(`
-Failed to cancel workflow:`),l),await a(1)}}),y.command("browser-list").description("List available browser workflow templates").action(async()=>{try{let{BrowserWorkflowTool:t}=await import("./browser-workflow-CRZ6635H.js"),e=await new t().invoke({});if(e.success&&e.data){console.log(o.blue(`
+Failed to cancel workflow:`),l),await a(1)}}),y.command("browser-list").description("List available browser workflow templates").action(async()=>{try{let{BrowserWorkflowTool:t}=await import("./browser-workflow-EBSNGTSH.js"),e=await new t().invoke({});if(e.success&&e.data){console.log(o.blue(`
  Browser Workflow Templates:
 `));for(let u of e.data.availableTemplates)console.log(`  ${o.cyan(u)}`);console.log("")}else console.log(o.red(`Failed: ${e.error||"Unknown error"}`));await a(0)}catch(t){console.error(o.red(`
-Failed:`),t),await a(1)}}),y.command("browser-load [template]").description("Load and validate a browser workflow template or inline YAML").option("--yaml <yaml>","Inline YAML workflow definition").option("-v, --var <key=value>","Variable override (repeatable)",P,{}).option("-F, --format <format>","Output format (text|json)","text").option("-o, --output <path>","Write output to file").action(async(t,l)=>{try{let{BrowserWorkflowTool:e}=await import("./browser-workflow-CRZ6635H.js"),{writeOutput:u,toJSON:c}=await import("./ci-output-ETGFFPKJ.js"),s=new e,f={variables:l.var||{}};if(l.yaml)f.workflowYaml=l.yaml;else if(t)if(t.endsWith(".yaml")||t.endsWith(".yml")){let i=await import("fs"),p=(await import("path")).resolve(t);i.existsSync(p)||(console.log(o.red(`
+Failed:`),t),await a(1)}}),y.command("browser-load [template]").description("Load and validate a browser workflow template or inline YAML").option("--yaml <yaml>","Inline YAML workflow definition").option("-v, --var <key=value>","Variable override (repeatable)",P,{}).option("-F, --format <format>","Output format (text|json)","text").option("-o, --output <path>","Write output to file").action(async(t,l)=>{try{let{BrowserWorkflowTool:e}=await import("./browser-workflow-EBSNGTSH.js"),{writeOutput:u,toJSON:c}=await import("./ci-output-WGP4YKPQ.js"),s=new e,f={variables:l.var||{}};if(l.yaml)f.workflowYaml=l.yaml;else if(t)if(t.endsWith(".yaml")||t.endsWith(".yml")){let i=await import("fs"),p=(await import("path")).resolve(t);i.existsSync(p)||(console.log(o.red(`
 File not found: ${p}
 `)),await a(1)),f.workflowYaml=i.readFileSync(p,"utf-8")}else f.templateName=t;else console.log(o.red(`
 Provide a template name or --yaml. Use "workflow browser-list" to see templates.

package/dist/cli/chunks/workflow-orchestrator-TXEMI5DD.js

@@ -0,0 +1,2 @@
+import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.13.10");process.exit(0)}
+import{a,b,c,d}from"./chunk-KBJYXZI7.js";import"./chunk-OZLMIEJC.js";import"./chunk-37GWETSW.js";import"./chunk-F3AHUNWH.js";import"./chunk-WSPEAYPG.js";import"./chunk-TL5FMEKW.js";import"./chunk-DR4V75BF.js";import"./chunk-KQVTTP2S.js";import"./chunk-GQ6H37RN.js";import"./chunk-54RIPGMC.js";import"./chunk-OLETDPH2.js";import"./chunk-4TSLLWE7.js";import"./chunk-G427QR5W.js";import"./chunk-NRD76M7A.js";import"./chunk-GRTU5QOT.js";import"./chunk-PUN3KZ6N.js";import"./chunk-WIB6KRFJ.js";import"./chunk-Q7QKJY6Y.js";import"./chunk-JWV5ZM2S.js";import"./chunk-EJRDL5W5.js";import"./chunk-VUCCPPQ6.js";import"./chunk-W3DCBOLL.js";export{b as DEFAULT_WORKFLOW_CONFIG,a as WorkflowEvents,c as WorkflowOrchestrator,d as createWorkflowOrchestrator};

package/dist/cli/chunks/{wrappers-UHG2KXGO.js → wrappers-KO3QXNZP.js}

@@ -1,2 +1,2 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.13.8");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v as L,w as M,x as N}from"./chunk-3KSB2PDF.js";import{a as v,b as w,c as x,d as y,e as z,f as A,g as B,h as C,i as D,j as E,k as F,l as G,m as H,n as I,o as J,p as K}from"./chunk-XUB5UG7C.js";import"./chunk-426SRHIW.js";import"./chunk-SSIOQDWN.js";import"./chunk-C37IK75J.js";import"./chunk-K6XYLMXO.js";import"./chunk-PVUQMV6P.js";import"./chunk-ZO6QWQ2G.js";import"./chunk-HD22NMGP.js";import"./chunk-XKKCH24C.js";import"./chunk-QYZLZ6P3.js";import"./chunk-YLFM5AZ4.js";import"./chunk-CDBTYQ4N.js";import"./chunk-7TK24XF7.js";import"./chunk-NJ7SVXE6.js";import"./chunk-7VWAKVRE.js";import"./chunk-XJT6TR5E.js";import"./chunk-SECJ2IQE.js";import"./chunk-DW5F6DJM.js";import"./chunk-NW5XQQMC.js";export{z as GNNLayerFactory,i as QEFlashAttention,x as QEGNNEmbeddingIndex,y as QEGNNIndexFactory,a as QESONA,e as QE_FLASH_ATTENTION_CONFIG,g as QE_PERFORMANCE_TARGETS,f as QE_SONA_CONFIG,A as TensorCompressionFactory,u as batchComputeAttention,K as batchDifferentiableSearch,M as checkRuvectorPackagesAvailable,c as createDomainQESONA,j as createQEFlashAttention,b as createQESONA,D as getDifferentiableSearch,F as getGetCompressionLevel,E as getHierarchicalForward,G as getInit,h as getOptimalBlockConfig,k as getQEFlashAttentionConfig,n as getRuvectorDotProductAttention,m as getRuvectorFlashAttention,p as getRuvectorHyperbolicAttention,B as getRuvectorLayer,q as getRuvectorLinearAttention,r as getRuvectorMoEAttention,o as getRuvectorMultiHeadAttention,L as getRuvectorPackageVersions,C as getTensorCompress,l as getWorkloadTypes,N as initAllRuvectorPackages,w as initGNN,d as isAttentionAvailable,v as isGNNAvailable,s as toFloat32Array,H as toFloat32ArrayGNN,J as toIEmbedding,t as toNumberArrayAttn,I as toNumberArrayGNN};
+import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.13.10");process.exit(0)}
+import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v as L,w as M,x as N}from"./chunk-J6H2LUBM.js";import{a as v,b as w,c as x,d as y,e as z,f as A,g as B,h as C,i as D,j as E,k as F,l as G,m as H,n as I,o as J,p as K}from"./chunk-IYLSML27.js";import"./chunk-37GWETSW.js";import"./chunk-F3AHUNWH.js";import"./chunk-WSPEAYPG.js";import"./chunk-TL5FMEKW.js";import"./chunk-DR4V75BF.js";import"./chunk-KQVTTP2S.js";import"./chunk-GQ6H37RN.js";import"./chunk-OLETDPH2.js";import"./chunk-G427QR5W.js";import"./chunk-NRD76M7A.js";import"./chunk-GRTU5QOT.js";import"./chunk-PUN3KZ6N.js";import"./chunk-WIB6KRFJ.js";import"./chunk-Q7QKJY6Y.js";import"./chunk-JWV5ZM2S.js";import"./chunk-EJRDL5W5.js";import"./chunk-VUCCPPQ6.js";import"./chunk-W3DCBOLL.js";export{z as GNNLayerFactory,i as QEFlashAttention,x as QEGNNEmbeddingIndex,y as QEGNNIndexFactory,a as QESONA,e as QE_FLASH_ATTENTION_CONFIG,g as QE_PERFORMANCE_TARGETS,f as QE_SONA_CONFIG,A as TensorCompressionFactory,u as batchComputeAttention,K as batchDifferentiableSearch,M as checkRuvectorPackagesAvailable,c as createDomainQESONA,j as createQEFlashAttention,b as createQESONA,D as getDifferentiableSearch,F as getGetCompressionLevel,E as getHierarchicalForward,G as getInit,h as getOptimalBlockConfig,k as getQEFlashAttentionConfig,n as getRuvectorDotProductAttention,m as getRuvectorFlashAttention,p as getRuvectorHyperbolicAttention,B as getRuvectorLayer,q as getRuvectorLinearAttention,r as getRuvectorMoEAttention,o as getRuvectorMultiHeadAttention,L as getRuvectorPackageVersions,C as getTensorCompress,l as getWorkloadTypes,N as initAllRuvectorPackages,w as initGNN,d as isAttentionAvailable,v as isGNNAvailable,s as toFloat32Array,H as toFloat32ArrayGNN,J as toIEmbedding,t as toNumberArrayAttn,I as toNumberArrayGNN};

package/dist/cli/commands/hooks-handlers/hooks-dream-learning.js

@@ -6,7 +6,7 @@
  */
 import { randomUUID } from 'crypto';
 import chalk from 'chalk';
-import { recordPatternUsage } from '../../../learning/pattern-usage-recorder.js';
+import { recordPatternUsage, recordPatternUsageBatch, } from '../../../learning/pattern-usage-recorder.js';
 // ============================================================================
 // Dream Scheduler State (persisted in kv_store between hook invocations)
 // ============================================================================
@@ -739,16 +739,26 @@ export async function consolidateExperiencesToPatterns() {
         LIMIT 1
       `).get(agg.domain, patternName);
             if (existing) {
-                // Reinforce existing monthly pattern
+                // Issue #618: the aggregate writer must use the same audited write
+                // path as individual usage. The former inline UPDATE skipped every
+                // qe_pattern_usage row and never evaluated promotion.
+                recordPatternUsageBatch(db, {
+                    patternId: existing.id,
+                    usageCount: agg.cnt,
+                    successfulUses: agg.successes,
+                    metrics: { source: 'session-consolidation', domain: agg.domain, agent: agg.agent },
+                });
                 db.prepare(`
           UPDATE qe_patterns
-          SET usage_count = usage_count + ?,
-              successful_uses = successful_uses + ?,
-              confidence = MIN(0.99, confidence + 0.01),
-              quality_score = MIN(0.99, quality_score + 0.005),
-              updated_at = datetime('now')
+          SET confidence = MIN(0.99, confidence + 0.01), updated_at = datetime('now')
           WHERE id = ?
-        `).run(agg.cnt, agg.successes, existing.id);
+        `).run(existing.id);
+                db.prepare(`
+          UPDATE qe_patterns
+          SET tier = 'long-term', updated_at = datetime('now')
+          WHERE id = ? AND tier = 'short-term'
+            AND successful_uses >= 3 AND success_rate >= 0.7 AND confidence >= 0.6
+        `).run(existing.id);
             }
             else {
                 const patternId = uuidv4();

package/dist/cli/commands/learning.js

@@ -219,28 +219,60 @@ function registerConsolidateCommand(learning) {
         .action(async (options) => {
         try {
             const reasoningBank = await initializeLearningSystem();
-            const threshold = parseInt(options.threshold, 10);
-            const successRateMin = parseFloat(options.successRate);
+            const threshold = Number(options.threshold);
+            const successRateMin = Number(options.successRate);
+            const confidenceMin = 0.6;
+            if (!Number.isInteger(threshold) || threshold < 1) {
+                throw new Error('threshold must be a positive integer');
+            }
+            if (!Number.isFinite(successRateMin) || successRateMin < 0 || successRateMin > 1) {
+                throw new Error('success rate must be between 0 and 1');
+            }
             const eligiblePatterns = [];
-            const searchResult = await reasoningBank.searchPatterns('*', { limit: 1000 });
-            if (searchResult.success) {
-                for (const match of searchResult.value) {
-                    const pattern = match.pattern;
-                    if (pattern.tier === 'short-term' && pattern.successfulUses >= threshold && pattern.successRate >= successRateMin) {
-                        eligiblePatterns.push({
-                            id: pattern.id, name: pattern.name, domain: pattern.qeDomain,
-                            successfulUses: pattern.successfulUses, successRate: pattern.successRate, currentTier: pattern.tier,
-                        });
-                    }
+            const searchResult = await reasoningBank.searchPatterns('', { limit: 1000 });
+            if (!searchResult.success)
+                throw new Error(searchResult.error.message);
+            for (const match of searchResult.value) {
+                const pattern = match.pattern;
+                if (pattern.tier === 'short-term' &&
+                    pattern.successfulUses >= threshold &&
+                    pattern.successRate >= successRateMin &&
+                    pattern.confidence >= confidenceMin) {
+                    eligiblePatterns.push({
+                        id: pattern.id, name: pattern.name, domain: pattern.qeDomain,
+                        successfulUses: pattern.successfulUses, successRate: pattern.successRate, currentTier: pattern.tier,
+                    });
+                }
+            }
+            let promotedCount = 0;
+            const failures = [];
+            if (!options.dryRun) {
+                for (const pattern of eligiblePatterns) {
+                    const result = await reasoningBank.promotePattern(pattern.id);
+                    if (result.success)
+                        promotedCount++;
+                    else
+                        failures.push({ id: pattern.id, error: result.error.message });
                 }
             }
             if (options.json) {
-                printJson({ dryRun: options.dryRun || false, eligibleCount: eligiblePatterns.length, threshold, successRateMin, patterns: eligiblePatterns });
+                printJson({
+                    dryRun: options.dryRun || false,
+                    eligibleCount: eligiblePatterns.length,
+                    promotedCount,
+                    failedCount: failures.length,
+                    threshold,
+                    successRateMin,
+                    confidenceMin,
+                    patterns: eligiblePatterns,
+                    failures,
+                });
             }
             else {
                 console.log(chalk.bold('\n🔄 Pattern Consolidation\n'));
                 console.log(`  Promotion threshold: ${threshold} successful uses`);
                 console.log(`  Minimum success rate: ${(successRateMin * 100).toFixed(0)}%`);
+                console.log(`  Minimum confidence: ${(confidenceMin * 100).toFixed(0)}%`);
                 console.log(`  Eligible patterns: ${eligiblePatterns.length}\n`);
                 if (eligiblePatterns.length === 0) {
                     console.log(chalk.dim('  No patterns eligible for promotion yet.'));
@@ -252,7 +284,13 @@ function registerConsolidateCommand(learning) {
                         console.log(chalk.dim(`      Domain: ${p.domain}, Uses: ${p.successfulUses}, Rate: ${(p.successRate * 100).toFixed(0)}%`));
                     }
                     if (!options.dryRun) {
-                        console.log(chalk.yellow('\n  Promotion would happen here (not yet implemented)'));
+                        console.log(chalk.green(`\n  Promoted: ${promotedCount}`));
+                        if (failures.length > 0) {
+                            console.log(chalk.red(`  Failed: ${failures.length}`));
+                            for (const failure of failures) {
+                                console.log(chalk.dim(`    ${failure.id}: ${failure.error}`));
+                            }
+                        }
                     }
                     else {
                         console.log(chalk.yellow('\n  Dry run - no changes made'));
@@ -282,7 +320,7 @@ function registerExportCommand(learning) {
         .action(async (options) => {
         try {
             const reasoningBank = await initializeLearningSystem();
-            const searchResult = await reasoningBank.searchPatterns('*', { limit: 10000, domain: options.domain });
+            const searchResult = await reasoningBank.searchPatterns('', { limit: 10000, domain: options.domain });
             if (!searchResult.success)
                 throw new Error(searchResult.error.message);
             const patterns = searchResult.value.map(m => m.pattern).filter(p => !options.longTermOnly || p.tier === 'long-term');
@@ -817,7 +855,7 @@ function registerExportFullCommand(learning) {
                 throw new Error('No learning database found. Run "aqe init --auto" first.');
             const reasoningBank = await initializeLearningSystem();
             const schemaVersion = await getSchemaVersion(dbPath);
-            const searchResult = await reasoningBank.searchPatterns('*', { limit: 10000 });
+            const searchResult = await reasoningBank.searchPatterns('', { limit: 10000 });
             if (!searchResult.success)
                 throw new Error(searchResult.error.message);
             const patterns = searchResult.value.map(m => ({
@@ -912,7 +950,7 @@ function registerImportMergeCommand(learning) {
             if (!importData.patterns || !Array.isArray(importData.patterns))
                 throw new Error('Invalid import file format: missing patterns array');
             const reasoningBank = await initializeLearningSystem();
-            const existingResult = await reasoningBank.searchPatterns('*', { limit: 10000 });
+            const existingResult = await reasoningBank.searchPatterns('', { limit: 10000 });
             const existingNames = new Set();
             if (existingResult.success)
                 for (const m of existingResult.value)

package/dist/cli/commands/ruvector-commands.js

@@ -69,7 +69,7 @@ const FLAG_DESCRIPTIONS = {
     useColdTierGNN: 'Cold-tier GNN training (R6, ADR-087)',
     // Phase 5 Milestone 3 (ADR-087)
     useMetaLearningEnhancements: 'Meta-learning enhancements (R7, ADR-087)',
-    useSublinearSolver: 'Sublinear PageRank solver (R8, ADR-087)',
+    useSublinearSolver: 'Weighted PageRank solver (R8, ADR-087)',
     useSpectralSparsification: 'Spectral graph sparsification (R9, ADR-087)',
     useReservoirReplay: 'Reservoir replay with coherence gating (R10, ADR-087)',
     // Phase 5 Milestone 4 (ADR-087)

package/dist/cli/commands/upgrade.d.ts

@@ -9,7 +9,8 @@
  * Related: issue #383 item 2.
  */
 import { Command } from 'commander';
-export type LoadStatus = 'loaded' | 'missing' | 'required-missing';
+export type LoadStatus = 'loaded' | 'missing' | 'unavailable' | 'required-missing';
+export type PackageAvailability = 'published' | 'unpublished';
 export interface NativeCheck {
     /** npm package name as it appears in package.json */
     readonly packageName: string;
@@ -21,6 +22,8 @@ export interface NativeCheck {
     readonly affectsFlags: readonly string[];
     /** Whether missing is fatal or just degrades performance */
     readonly required: boolean;
+    /** Whether users can currently install the package from npm. */
+    readonly availability?: PackageAvailability;
 }
 export interface NativeResult extends NativeCheck {
     readonly status: LoadStatus;
@@ -59,6 +62,7 @@ export interface UpgradeReport {
         readonly requiredOk: boolean;
         readonly optionalMissingCount: number;
         readonly optionalLoadedCount: number;
+        readonly optionalUnavailableCount: number;
     };
 }
 /**

package/dist/cli/commands/upgrade.js

@@ -50,11 +50,12 @@ export const NATIVE_CATALOG = [
         required: false,
     },
     {
-        packageName: '@ruvector/solver-node',
-        role: 'Sublinear PageRank on the pattern citation graph',
-        fallback: 'TypeScript power iteration — O(n·m) (practical cap ≈ 50K nodes)',
+        packageName: '@ruvector/solver',
+        role: 'Async native weighted PageRank on the pattern citation graph',
+        fallback: 'TypeScript power iteration — O(iterations × (nodes + edges)); no hard size limit',
         affectsFlags: ['useSublinearSolver'],
         required: false,
+        availability: 'unpublished',
     },
     {
         packageName: '@ruvector/attention',
@@ -90,6 +91,9 @@ export function detectNatives(catalog, probe) {
         if (result.ok) {
             return { ...check, status: 'loaded' };
         }
+        if (check.availability === 'unpublished') {
+            return { ...check, status: 'unavailable', loadError: result.error.message };
+        }
         const missingModule = isModuleNotFound(result.error);
         const status = check.required
             ? 'required-missing'
@@ -150,11 +154,23 @@ export function buildRecommendations(input) {
             });
         }
     }
+    // Known unpublished packages are informational: keep the fallback visible,
+    // but never offer an install command that is guaranteed to fail.
+    for (const n of input.natives) {
+        if (n.status === 'unavailable') {
+            recs.push({
+                severity: 'info',
+                message: `Optional native unavailable on npm: ${n.packageName} — ` +
+                    `using ${n.fallback}. No install action is currently available.`,
+            });
+        }
+    }
     // Env override conflicts: user forced a flag ON but the native isn't loadable.
     const flagByName = { ...input.flags };
     for (const override of input.envOverrides) {
         const natives = input.natives.filter((n) => n.affectsFlags.includes(override.flagName));
         const anyLoaded = natives.some((n) => n.status === 'loaded');
+        const installableMissing = natives.find((n) => n.status === 'missing');
         const wantsOn = override.value === 'true' || override.value === '1';
         if (wantsOn && natives.length > 0 && !anyLoaded) {
             const missing = natives.map((n) => n.packageName).join(', ');
@@ -162,7 +178,9 @@ export function buildRecommendations(input) {
                 severity: 'warn',
                 message: `${override.envVar}=${override.value} requests flag ${override.flagName}=true, ` +
                     `but required native(s) not loaded: ${missing}. The flag will silently fall back.`,
-                action: natives[0] ? `npm install ${natives[0].packageName}` : undefined,
+                action: installableMissing
+                    ? `npm install ${installableMissing.packageName}`
+                    : undefined,
             });
         }
     }
@@ -170,7 +188,10 @@ export function buildRecommendations(input) {
     void nativeByName;
     // All optionals loaded → positive-confirmation info line.
     const optionalMissing = input.natives.filter((n) => !n.required && n.status === 'missing');
-    if (optionalMissing.length === 0 && input.natives.every((n) => n.status !== 'required-missing')) {
+    const optionalUnavailable = input.natives.filter((n) => !n.required && n.status === 'unavailable');
+    if (optionalMissing.length === 0 &&
+        optionalUnavailable.length === 0 &&
+        input.natives.every((n) => n.status !== 'required-missing')) {
         recs.push({
             severity: 'info',
             message: 'All recommended native bindings are loaded — no action required.',
@@ -188,6 +209,7 @@ export function buildReport(input) {
     });
     const optionalLoadedCount = natives.filter((n) => !n.required && n.status === 'loaded').length;
     const optionalMissingCount = natives.filter((n) => !n.required && n.status === 'missing').length;
+    const optionalUnavailableCount = natives.filter((n) => !n.required && n.status === 'unavailable').length;
     const requiredOk = natives.filter((n) => n.required).every((n) => n.status === 'loaded');
     return {
         aqeVersion: input.aqeVersion,
@@ -204,6 +226,7 @@ export function buildReport(input) {
             requiredOk,
             optionalMissingCount,
             optionalLoadedCount,
+            optionalUnavailableCount,
         },
     };
 }
@@ -272,7 +295,10 @@ export function renderReportHuman(report) {
     const okBadge = report.summary.requiredOk ? chalk.green('OK') : chalk.red('FAIL');
     push(`  Summary:   required ${okBadge}    ` +
         `optional loaded ${chalk.cyan(report.summary.optionalLoadedCount)} / ` +
-        `${chalk.cyan(report.summary.optionalLoadedCount + report.summary.optionalMissingCount)}`);
+        `${chalk.cyan(report.summary.optionalLoadedCount +
+            report.summary.optionalMissingCount +
+            report.summary.optionalUnavailableCount)} ` +
+        `(${chalk.cyan(report.summary.optionalUnavailableCount)} unavailable)`);
     push('');
     return lines.join('\n');
 }
@@ -282,6 +308,8 @@ function statusBadge(status) {
             return chalk.green('✓');
         case 'missing':
             return chalk.yellow('…');
+        case 'unavailable':
+            return chalk.gray('–');
         case 'required-missing':
             return chalk.red('✗');
     }

package/dist/init/phases/12-verification.js

@@ -108,7 +108,7 @@ export class VerificationPhase extends BasePhase {
                 db.close();
                 return true;
             }
-            catch (err) {
+            catch {
                 db.close();
                 return false;
             }
@@ -286,6 +286,12 @@ export class VerificationPhase extends BasePhase {
         if (existing.learning?.enabled !== undefined) {
             newConfig.learning.enabled = existing.learning.enabled;
         }
+        if (existing.learning?.qualityThreshold !== undefined) {
+            newConfig.learning.qualityThreshold = existing.learning.qualityThreshold;
+        }
+        if (existing.learning?.promotionThreshold !== undefined) {
+            newConfig.learning.promotionThreshold = existing.learning.promotionThreshold;
+        }
         // Preserve user's hook preferences
         if (existing.hooks?.claudeCode !== undefined) {
             newConfig.hooks.claudeCode = existing.hooks.claudeCode;
@@ -326,7 +332,7 @@ export class VerificationPhase extends BasePhase {
             '# take effect immediately. The following settings are merged on reinstall:',
             '#   - domains.enabled (custom domains like visual-accessibility)',
             '#   - domains.disabled',
-            '#   - learning.enabled',
+            '#   - learning.enabled, qualityThreshold, and promotionThreshold',
             '#   - hooks.* preferences',
             '#   - workers.enabled',
             '#   - agents.maxConcurrent and defaultTimeout',

package/dist/integrations/ruvector/feature-flags.d.ts

@@ -305,8 +305,8 @@ export interface RuVectorFeatureFlags {
     useMetaLearningEnhancements: boolean;
     /**
      * Enable Sublinear Solver (R8, ADR-087)
-     * O(log n) PageRank for graph-based pattern importance scoring.
-     * TypeScript power-iteration fallback; native @ruvector/solver-node optional.
+     * Sparse weighted PageRank for graph-based pattern importance scoring.
+     * TypeScript power-iteration fallback; native @ruvector/solver optional.
      * Consumer: pattern-promotion.ts (future integration)
      * Activation: enable after bootstrapping a pattern citation graph
      * @default false

package/dist/integrations/ruvector/index.d.ts

@@ -108,7 +108,7 @@ export { VectorDeltaTracker, createVectorDeltaTracker, type PatternDelta, type S
 export { GraphMAEEncoder, createGraphMAEEncoder, type GraphMAEConfig, type QEGraph, type GraphMAEResult, } from './graphmae-encoder';
 export { HopfieldMemory, createHopfieldMemory, type HopfieldConfig, type StoredPattern, type RecallResult, } from './hopfield-memory';
 export { ColdTierTrainer, InMemoryGraph, FileBackedGraph, createColdTierTrainer, type ColdTierConfig, type ColdTierGraph, type TrainingResult, type CacheStats, } from './cold-tier-trainer';
-export { PageRankSolver, createPageRankSolver, type PatternGraph, type ImportanceScore, type SolverConfig, } from './solver-adapter';
+export { PageRankSolver, createPageRankSolver, type PatternGraph, type ImportanceScore, type SolverConfig, type PageRankRuntimeOptions, } from './solver-adapter';
 export { SpectralSparsifier, createSpectralSparsifier, type SparsifierGraph, type SpectralValidation, type SparsifierConfig, } from './spectral-sparsifier';
 export { ReservoirReplayBuffer, createReservoirReplayBuffer, type ReservoirEntry, type ReservoirConfig, type ReservoirStats, type CoherenceTier, } from './reservoir-replay';
 export { EpropNetwork, createEpropNetwork, type EpropConfig, type EpropStats, } from './eprop-learner';

package/dist/integrations/ruvector/page-rank-backends.d.ts

@@ -0,0 +1,41 @@
+export interface PatternGraph {
+    nodes: string[];
+    edges: Array<[number, number, number]>;
+}
+export interface SolverConfig {
+    dampingFactor: number;
+    tolerance: number;
+    maxIterations: number;
+}
+export interface NativePageRankResult {
+    scores: number[] | Float64Array;
+    converged: boolean;
+    iterations: number;
+    residual: number;
+}
+export interface NativePageRankSolver {
+    pagerank(input: {
+        values: number[];
+        colIndices: number[];
+        rowPtrs: number[];
+        numNodes: number;
+        damping: number;
+        tolerance: number;
+        maxIterations: number;
+    }): Promise<NativePageRankResult>;
+}
+export interface NativeSolverModule {
+    NapiSolver: new () => NativePageRankSolver;
+}
+export type AsyncPageRankRunner = (graph: PatternGraph, config: SolverConfig, timeoutMs?: number) => Promise<Float64Array>;
+/** Standard weighted PageRank with uniform dangling-node redistribution. */
+export declare function computeTypeScriptPageRank(graph: PatternGraph, config: SolverConfig): Float64Array;
+export declare function edgeListToCsr(graph: PatternGraph): {
+    values: number[];
+    colIndices: number[];
+    rowPtrs: number[];
+};
+export declare function loadNativeSolverModule(): NativeSolverModule | null;
+export declare function runNativePageRank(module: NativeSolverModule, graph: PatternGraph, config: SolverConfig): Promise<Float64Array>;
+export declare function runPageRankWorker(graph: PatternGraph, config: SolverConfig, timeoutMs?: number): Promise<Float64Array>;
+//# sourceMappingURL=page-rank-backends.d.ts.map

package/dist/integrations/ruvector/page-rank-backends.js

@@ -0,0 +1,154 @@
+import { createRequire } from 'node:module';
+import { Worker } from 'node:worker_threads';
+/** Standard weighted PageRank with uniform dangling-node redistribution. */
+export function computeTypeScriptPageRank(graph, config) {
+    const n = graph.nodes.length;
+    if (n === 0)
+        return new Float64Array();
+    const { dampingFactor: d, tolerance, maxIterations } = config;
+    const weightedOutDegree = new Float64Array(n);
+    const inEdges = new Array(n);
+    for (let i = 0; i < n; i++)
+        inEdges[i] = [];
+    for (const [from, to, weight] of graph.edges) {
+        weightedOutDegree[from] += weight;
+        inEdges[to].push([from, weight]);
+    }
+    const danglingNodes = [];
+    for (let i = 0; i < n; i++) {
+        if (weightedOutDegree[i] === 0)
+            danglingNodes.push(i);
+    }
+    let scores = new Float64Array(n);
+    scores.fill(1 / n);
+    const base = (1 - d) / n;
+    for (let iter = 0; iter < maxIterations; iter++) {
+        let danglingSum = 0;
+        for (const index of danglingNodes)
+            danglingSum += scores[index];
+        const danglingContribution = d * danglingSum / n;
+        const next = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            let incoming = 0;
+            for (const [from, weight] of inEdges[i]) {
+                incoming += scores[from] * weight / weightedOutDegree[from];
+            }
+            next[i] = base + d * incoming + danglingContribution;
+        }
+        let maxDelta = 0;
+        for (let i = 0; i < n; i++) {
+            maxDelta = Math.max(maxDelta, Math.abs(next[i] - scores[i]));
+        }
+        scores = next;
+        if (maxDelta < tolerance)
+            break;
+    }
+    return scores;
+}
+export function edgeListToCsr(graph) {
+    const rows = Array.from({ length: graph.nodes.length }, () => []);
+    for (const [from, to, weight] of graph.edges)
+        rows[from].push([to, weight]);
+    const values = [];
+    const colIndices = [];
+    const rowPtrs = [0];
+    for (const row of rows) {
+        row.sort((left, right) => left[0] - right[0]);
+        for (const [column, value] of row) {
+            colIndices.push(column);
+            values.push(value);
+        }
+        rowPtrs.push(values.length);
+    }
+    return { values, colIndices, rowPtrs };
+}
+export function loadNativeSolverModule() {
+    try {
+        const req = createRequire(import.meta.url);
+        const candidate = req('@ruvector/solver');
+        return typeof candidate.NapiSolver === 'function'
+            ? candidate
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runNativePageRank(module, graph, config) {
+    const csr = edgeListToCsr(graph);
+    const result = await new module.NapiSolver().pagerank({
+        ...csr,
+        numNodes: graph.nodes.length,
+        damping: config.dampingFactor,
+        tolerance: config.tolerance,
+        maxIterations: config.maxIterations,
+    });
+    if (!result.converged)
+        throw new Error('Native PageRank did not converge');
+    return validatePageRankScores(result.scores, graph.nodes.length);
+}
+export function runPageRankWorker(graph, config, timeoutMs = 30_000) {
+    const workerSource = `
+    const { parentPort, workerData } = require('node:worker_threads');
+    const compute = ${computeTypeScriptPageRank.toString()};
+    try {
+      const graph = {
+        nodes: new Array(workerData.nodeCount),
+        edges: workerData.edges,
+      };
+      const scores = compute(graph, workerData.config);
+      parentPort.postMessage(scores, [scores.buffer]);
+    } catch (error) {
+      throw error;
+    }
+  `;
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(workerSource, {
+            eval: true,
+            workerData: {
+                nodeCount: graph.nodes.length,
+                edges: graph.edges,
+                config,
+            },
+        });
+        const timeout = setTimeout(() => {
+            void worker.terminate();
+            reject(new Error(`PageRank worker timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        worker.once('message', (scores) => {
+            clearTimeout(timeout);
+            resolve(validatePageRankScores(scores, graph.nodes.length));
+        });
+        worker.once('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        worker.once('exit', (code) => {
+            if (code !== 0) {
+                clearTimeout(timeout);
+                reject(new Error(`PageRank worker exited with code ${code}`));
+            }
+        });
+    });
+}
+function validatePageRankScores(input, expectedLength) {
+    const scores = input instanceof Float64Array ? input : Float64Array.from(input);
+    if (scores.length !== expectedLength) {
+        throw new Error(`PageRank returned ${scores.length} scores for ${expectedLength} nodes`);
+    }
+    let total = 0;
+    for (const score of scores) {
+        if (!Number.isFinite(score) || score < 0) {
+            throw new Error('PageRank returned an invalid score');
+        }
+        total += score;
+    }
+    if (!(total > 0))
+        throw new Error('PageRank returned a zero score total');
+    if (Math.abs(total - 1) > 1e-12) {
+        for (let i = 0; i < scores.length; i++)
+            scores[i] /= total;
+    }
+    return scores;
+}
+//# sourceMappingURL=page-rank-backends.js.map