@lucieri/daxiom 0.2.1

package/src/cli.js

@@ -0,0 +1,423 @@
+'use strict';
+
+const { init, close, getPool } = require('./connection');
+const { getEmbedding } = require('./embeddings');
+const { checkCoherence, runQualityGates } = require('./quality-gates');
+const { searchPatterns, storeLearnedPattern, getStats } = require('./patterns');
+const {
+  updateTiers, getConfidenceTierDistribution, promotePatternConfidence,
+  demoteWithRollback, scanRollbackCandidates, decayPatterns, getDriftReport, previewDecay,
+} = require('./tiers');
+const { storeSelfManaged, listByClass, updateStatus } = require('./self-manage');
+const { getAgentProfile, routeToAgent } = require('./agents');
+const { SELF_MGMT_CLASSES } = require('./constants');
+
+const { loadEnv } = require('./hooks/env');
+loadEnv();
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+
+// Hooks subcommand dispatches separately (has its own init flow)
+if (cmd === 'hooks') {
+  const { dispatch } = require('./hooks');
+  dispatch(args.slice(1)).catch(err => {
+    console.error('Hook error:', err.message);
+    process.exit(1);
+  });
+  return;
+}
+
+(async () => {
+  try {
+    await init();
+
+    switch (cmd) {
+      case 'search': {
+        const query = args.slice(1).join(' ') || 'ruvbot plugin lifecycle';
+        console.log(`Searching: "${query}"`);
+        const results = await searchPatterns(query, { limit: 5 });
+        for (const r of results) {
+          console.log(`  ${r.similarity} | ${r.namespace.padEnd(12)}| ${r.patternName}`);
+        }
+        if (results.length === 0) console.log('  No results above threshold');
+        break;
+      }
+
+      case 'stats': {
+        const stats = await getStats();
+        console.log('DAXIOM Pattern Stats:');
+        for (const row of stats) {
+          console.log(`  ${row.namespace}/${row.tier}: ${row.count} patterns, avg_conf=${row.avg_confidence}, usage=${row.total_usage}`);
+        }
+        break;
+      }
+
+      case 'tiers': {
+        const result = await updateTiers();
+        console.log('Tier updates:', result);
+        break;
+      }
+
+      case 'store': {
+        const skipCoherence = args.includes('--skip-coherence');
+        const agentIdCli = args.includes('--agent-id') ? args[args.indexOf('--agent-id') + 1] : null;
+        const agentTypeCli = args.includes('--agent-type') ? args[args.indexOf('--agent-type') + 1] : null;
+        const filteredArgs = args.filter((a, i, arr) =>
+          a !== '--skip-coherence' &&
+          a !== '--agent-id' && a !== '--agent-type' &&
+          !(i > 0 && (arr[i-1] === '--agent-id' || arr[i-1] === '--agent-type'))
+        );
+        const name = filteredArgs[1] || 'test_pattern';
+        const desc = filteredArgs.slice(2).join(' ') || 'Test pattern from CLI';
+        const result = await storeLearnedPattern({
+          patternName: name, description: desc, compactText: desc,
+          skipCoherence, agentId: agentIdCli, agentType: agentTypeCli,
+        });
+        if (result.action === 'rejected') {
+          console.log('REJECTED:', result.reason);
+        } else {
+          console.log('Stored:', result);
+        }
+        break;
+      }
+
+      case 'todo': {
+        const name = args[1];
+        // If no name or starts with --, list TODOs instead
+        if (!name || name.startsWith('--')) {
+          const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : null;
+          const st = args.includes('--status') ? args[args.indexOf('--status') + 1] : 'open';
+          const rows = await listByClass('todo', { namespace: ns, status: st });
+          if (rows.length === 0) { console.log('  No TODOs found' + (ns ? ` for ${ns}` : '') + ` (status=${st})`); break; }
+          console.log(`TODOs${ns ? ` [${ns}]` : ''} (${rows.length}, status=${st}):`);
+          for (const r of rows) {
+            const prio = r.metadata?.priority ? `[${r.metadata.priority}]` : '';
+            const date = r.created_at ? new Date(r.created_at).toISOString().slice(0, 10) : '';
+            console.log(`  ${date} ${r.namespace.padEnd(14)} ${prio.padEnd(8)} ${r.pattern_name}`);
+          }
+          break;
+        }
+        const flagIdx = args.findIndex(a => a.startsWith('--'));
+        const descParts = args.slice(2, flagIdx > 1 ? flagIdx : undefined);
+        const desc = descParts.join(' ') || name;
+        const repo = args.includes('--repo') ? args[args.indexOf('--repo') + 1] : null;
+        const priority = args.includes('--priority') ? args[args.indexOf('--priority') + 1] : 'medium';
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : 'daxiom';
+        const result = await storeSelfManaged({
+          patternClass: 'todo', name, description: desc, namespace: ns,
+          tags: ['todo'], status: 'open', repo, priority,
+        });
+        console.log(`TODO ${result.action}: ${name} → ${ns} (${result.id})`);
+        break;
+      }
+
+      case 'changelog': {
+        const name = args[1];
+        // If no name or name starts with --, list changelogs instead
+        if (!name || name.startsWith('--')) {
+          const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : null;
+          const lim = args.includes('--limit') ? parseInt(args[args.indexOf('--limit') + 1]) : 20;
+          const rows = await listByClass('changelog', { namespace: ns, limit: lim });
+          if (rows.length === 0) { console.log('  No changelogs found' + (ns ? ` for ${ns}` : '')); break; }
+          console.log(`CHANGELOGS${ns ? ` [${ns}]` : ''} (${rows.length}):`);
+          for (const r of rows) {
+            const repo = r.metadata?.repo ? `(${r.metadata.repo})` : '';
+            const date = r.created_at ? new Date(r.created_at).toISOString().slice(0, 10) : '';
+            console.log(`  ${date} ${r.namespace.padEnd(14)} ${r.pattern_name} ${repo}`);
+          }
+          break;
+        }
+        const desc = args.slice(2).filter(a => !a.startsWith('--')).join(' ') || name;
+        const repo = args.includes('--repo') ? args[args.indexOf('--repo') + 1] : null;
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : 'daxiom';
+        const sessionId = args.includes('--session') ? args[args.indexOf('--session') + 1] : null;
+        const meta = { stored_at: new Date().toISOString() };
+        if (repo) meta.repo = repo;
+        if (sessionId) meta.session_id = sessionId;
+        const result = await storeSelfManaged({
+          patternClass: 'changelog', name, description: desc, namespace: ns,
+          tags: ['changelog', new Date().toISOString().slice(0, 10)], repo,
+        });
+        console.log(`Changelog ${result.action}: ${name} → ${ns} (${result.id})`);
+        break;
+      }
+
+      case 'plan': {
+        const name = args[1];
+        if (!name) { console.log('Usage: daxiom plan <name> <description> [--repo X] [--namespace X]'); break; }
+        const desc = args.slice(2).filter(a => !a.startsWith('--')).join(' ') || name;
+        const repo = args.includes('--repo') ? args[args.indexOf('--repo') + 1] : null;
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : 'daxiom';
+        const result = await storeSelfManaged({
+          patternClass: 'build-plan', name, description: desc, namespace: ns,
+          tags: ['build-plan'], status: 'active', repo,
+        });
+        console.log(`Plan ${result.action}: ${name} → ${ns} (${result.id})`);
+        break;
+      }
+
+      case 'decide': {
+        const name = args[1];
+        if (!name) { console.log('Usage: daxiom decide <name> <rationale> [--repo X] [--namespace X]'); break; }
+        const desc = args.slice(2).filter(a => !a.startsWith('--')).join(' ') || name;
+        const repo = args.includes('--repo') ? args[args.indexOf('--repo') + 1] : null;
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : 'daxiom';
+        const result = await storeSelfManaged({
+          patternClass: 'decision', name, description: desc, namespace: ns,
+          tags: ['decision', 'adr'], repo,
+        });
+        console.log(`Decision ${result.action}: ${name} → ${ns} (${result.id})`);
+        break;
+      }
+
+      case 'incident': {
+        const name = args[1];
+        if (!name) { console.log('Usage: daxiom incident <name> <description> [--repo X] [--namespace X]'); break; }
+        const desc = args.slice(2).filter(a => !a.startsWith('--')).join(' ') || name;
+        const repo = args.includes('--repo') ? args[args.indexOf('--repo') + 1] : null;
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : 'daxiom';
+        const result = await storeSelfManaged({
+          patternClass: 'incident', name, description: desc, namespace: ns,
+          tags: ['incident', 'postmortem'], status: 'resolved', repo,
+        });
+        console.log(`Incident ${result.action}: ${name} → ${ns} (${result.id})`);
+        break;
+      }
+
+      case 'milestone': {
+        const name = args[1];
+        if (!name) { console.log('Usage: daxiom milestone <name> <description> [--repo X] [--namespace X]'); break; }
+        const desc = args.slice(2).filter(a => !a.startsWith('--')).join(' ') || name;
+        const repo = args.includes('--repo') ? args[args.indexOf('--repo') + 1] : null;
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : 'daxiom';
+        const result = await storeSelfManaged({
+          patternClass: 'milestone', name, description: desc, namespace: ns,
+          tags: ['milestone'], repo,
+        });
+        console.log(`Milestone ${result.action}: ${name} → ${ns} (${result.id})`);
+        break;
+      }
+
+      case 'namespaces': {
+        const p = getPool();
+        const client = await p.connect();
+        try {
+          const res = await client.query(`
+            SELECT namespace,
+                   COUNT(*) as total,
+                   COUNT(*) FILTER (WHERE pattern_class = 'changelog') as changelogs,
+                   COUNT(*) FILTER (WHERE pattern_class = 'todo') as todos,
+                   COUNT(*) FILTER (WHERE pattern_class = 'decision') as decisions,
+                   COUNT(*) FILTER (WHERE pattern_class = 'milestone') as milestones,
+                   COUNT(*) FILTER (WHERE pattern_class = 'incident') as incidents,
+                   COUNT(*) FILTER (WHERE pattern_class = 'learned') as learned
+            FROM tribal_intelligence.patterns
+            GROUP BY namespace ORDER BY total DESC
+          `);
+          console.log('NAMESPACE REGISTRY:');
+          console.log('  ' + 'Namespace'.padEnd(18) + 'Total'.padStart(6) + '  CLogs  TODOs  Decs  Miles  Incid  Learn');
+          console.log('  ' + '-'.repeat(80));
+          for (const r of res.rows) {
+            console.log(
+              '  ' + r.namespace.padEnd(18)
+              + String(r.total).padStart(6)
+              + String(r.changelogs).padStart(7)
+              + String(r.todos).padStart(7)
+              + String(r.decisions).padStart(6)
+              + String(r.milestones).padStart(7)
+              + String(r.incidents).padStart(7)
+              + String(r.learned).padStart(7)
+            );
+          }
+        } finally { client.release(); }
+        break;
+      }
+
+      case 'list': {
+        const cls = args[1];
+        if (!cls) {
+          console.log('Usage: daxiom list <pattern_class> [--namespace X] [--status X]');
+          console.log('Classes: ' + SELF_MGMT_CLASSES.join(', ') + ', learned, or any pattern_class');
+          break;
+        }
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : null;
+        const st = args.includes('--status') ? args[args.indexOf('--status') + 1] : null;
+        const rows = await listByClass(cls, { namespace: ns, status: st });
+        if (rows.length === 0) { console.log(`  No ${cls} patterns found`); break; }
+        console.log(`${cls.toUpperCase()} patterns (${rows.length}):`);
+        for (const r of rows) {
+          const status = r.metadata?.status ? `[${r.metadata.status}]` : '';
+          const repo = r.metadata?.repo ? `(${r.metadata.repo})` : '';
+          const date = r.created_at ? new Date(r.created_at).toISOString().slice(0, 10) : '';
+          console.log(`  ${date} ${status.padEnd(10)} ${r.pattern_name} ${repo}`);
+        }
+        break;
+      }
+
+      case 'done': {
+        const pid = args[1];
+        if (!pid) { console.log('Usage: daxiom done <pattern_id_or_uuid>'); break; }
+        const result = await updateStatus(pid, 'done');
+        if (result) { console.log(`Marked done: ${result.pattern_name}`); }
+        else { console.log(`Pattern not found: ${pid}`); }
+        break;
+      }
+
+      case 'coherence': {
+        const text = args.slice(1).join(' ');
+        if (!text) { console.log('Usage: daxiom coherence <text>'); break; }
+        console.log(`Checking coherence for: "${text}"`);
+        const p = getPool();
+        const client = await p.connect();
+        try {
+          await client.query('SET jit = off');
+          const emb = await getEmbedding(text);
+          const vec = '[' + emb.join(',') + ']';
+          const gate = await checkCoherence(client, vec, 'learned', 'learned');
+          console.log(`Action: ${gate.action.toUpperCase()}`);
+          if (gate.reason) console.log(`Reason: ${gate.reason}`);
+          console.log('Nearest neighbors:');
+          for (const n of gate.neighbors) {
+            console.log(`  ${n.similarity} | ${n.namespace.padEnd(12)}| ${n.pattern_class.padEnd(12)}| ${n.pattern_name}`);
+          }
+        } finally { client.release(); }
+        break;
+      }
+
+      case 'tier-check': {
+        const dist = await getConfidenceTierDistribution();
+        console.log('CONFIDENCE TIER DISTRIBUTION:');
+        console.log(`  Platinum (>=0.95): ${dist.platinum || 0} patterns`);
+        console.log(`  Gold (>=0.85):     ${dist.gold || 0} patterns`);
+        console.log(`  Silver (>=0.75):   ${dist.silver || 0} patterns`);
+        console.log(`  Bronze (>=0.70):   ${dist.bronze || 0} patterns`);
+        console.log(`  Expired (<0.70):   ${dist.expired || 0} patterns (need revalidation)`);
+        break;
+      }
+
+      case 'tier-promote': {
+        const pid = args[1];
+        if (!pid) { console.log('Usage: daxiom tier-promote <pattern_id_or_uuid>'); break; }
+        const result = await promotePatternConfidence(pid);
+        if (result.success) {
+          console.log(`Promoted: ${result.patternName} → ${result.newConfidence.toFixed(2)} (${result.tier})`);
+        } else { console.log(`Error: ${result.error}`); }
+        break;
+      }
+
+      case 'agent-profile': {
+        const aid = args[1];
+        if (!aid) { console.log('Usage: daxiom agent-profile <agent_id>'); break; }
+        const profile = await getAgentProfile(aid);
+        if (!profile) { console.log(`No patterns found for agent: ${aid}`); break; }
+        console.log(`AGENT PROFILE: ${profile.agentId}`);
+        for (const p of profile.profiles) {
+          console.log(`  Type: ${p.agentType || 'unknown'} | Patterns: ${p.patternsCreated} | Conf: ${p.avgConfidence.toFixed(4)} | Success: ${p.avgSuccessRate.toFixed(4)}`);
+        }
+        break;
+      }
+
+      case 'agent-route': {
+        const taskDesc = args.slice(1).join(' ');
+        if (!taskDesc) { console.log('Usage: daxiom agent-route <task description>'); break; }
+        console.log(`Routing task: "${taskDesc}"`);
+        const agents = await routeToAgent(taskDesc);
+        if (agents.length === 0) { console.log('  No agents with attribution data found.'); break; }
+        for (let i = 0; i < agents.length; i++) {
+          const a = agents[i];
+          console.log(`  #${i + 1} ${a.agentId} (${a.agentType || 'unknown'}) score=${a.score.toFixed(4)}`);
+        }
+        break;
+      }
+
+      case 'decay': {
+        const baseRate = args.includes('--rate') ? parseFloat(args[args.indexOf('--rate') + 1]) : 0.02;
+        const minIdle = args.includes('--min-idle') ? parseFloat(args[args.indexOf('--min-idle') + 1]) : 1.0;
+        const floor = args.includes('--floor') ? parseFloat(args[args.indexOf('--floor') + 1]) : 0.0;
+        const result = await decayPatterns({ baseRate, minIdleDays: minIdle, floor });
+        console.log(`Decayed: ${result.patternsDecayed} | Avg conf: ${result.avgNewConfidence.toFixed(4)} | Tier changes: ${result.tierChanges}`);
+        break;
+      }
+
+      case 'drift': {
+        const limit = args.includes('--limit') ? parseInt(args[args.indexOf('--limit') + 1]) : 20;
+        const minIdle = args.includes('--min-idle') ? parseFloat(args[args.indexOf('--min-idle') + 1]) : 1.0;
+        const report = await getDriftReport({ limit, minIdleDays: minIdle });
+        if (report.length === 0) { console.log('  No drifting patterns found'); break; }
+        for (const r of report) {
+          console.log(`  drift=${r.driftScore.toFixed(4)} | conf=${r.confidence.toFixed(2)} | ${r.tier} | ${r.namespace}:${r.patternName}`);
+        }
+        break;
+      }
+
+      case 'decay-preview': {
+        const pid = args[1];
+        if (!pid) { console.log('Usage: daxiom decay-preview <pattern_id_or_uuid>'); break; }
+        const preview = await previewDecay(pid);
+        if (!preview) { console.log(`Pattern not found: ${pid}`); break; }
+        console.log(`${preview.patternName}: ${preview.currentConfidence.toFixed(4)} → ${preview.decayedConfidence.toFixed(4)} (${preview.currentTier} → ${preview.projectedTier})`);
+        break;
+      }
+
+      case 'demote': {
+        const pid = args[1];
+        if (!pid) { console.log('Usage: daxiom demote <pattern_id> [--amount 0.1] [--threshold 0.3] [--reason "failure"]'); break; }
+        const amount = args.includes('--amount') ? parseFloat(args[args.indexOf('--amount') + 1]) : 0.1;
+        const threshold = args.includes('--threshold') ? parseFloat(args[args.indexOf('--threshold') + 1]) : 0.3;
+        const reason = args.includes('--reason') ? args[args.indexOf('--reason') + 1] : 'failure';
+        const result = await demoteWithRollback(pid, { amount, threshold, reason });
+        if (!result.success) { console.log(`Error: ${result.error}`); break; }
+        console.log(`Demoted: ${result.patternName} ${result.oldConfidence.toFixed(2)} → ${result.newConfidence.toFixed(2)} (${result.tier})`);
+        if (result.rollbackTriggered) console.log(`  ROLLBACK TRIGGERED: archived`);
+        break;
+      }
+
+      case 'rollback-check': {
+        const threshold = args.includes('--threshold') ? parseFloat(args[args.indexOf('--threshold') + 1]) : 0.3;
+        const candidates = await scanRollbackCandidates({ threshold });
+        if (candidates.length === 0) { console.log('  No patterns below rollback threshold'); break; }
+        for (const c of candidates) {
+          console.log(`  conf=${c.confidence.toFixed(2)} | ${c.tier} | ${c.namespace}:${c.patternName}${c.archived ? ' [ARCHIVED]' : ''}`);
+        }
+        break;
+      }
+
+      case 'quality-check': {
+        const content = args.slice(1).join(' ');
+        if (!content) { console.log('Usage: daxiom quality-check <content> [--class X] [--namespace X]'); break; }
+        const cls = args.includes('--class') ? args[args.indexOf('--class') + 1] : 'learned';
+        const ns = args.includes('--namespace') ? args[args.indexOf('--namespace') + 1] : 'learned';
+        const filtered = content.replace(/--class\s+\S+/g, '').replace(/--namespace\s+\S+/g, '').trim();
+        const result = runQualityGates(filtered, ns, cls, [], {});
+        console.log(`${result.allowed ? 'ALLOWED' : 'BLOCKED'}: ${result.summary}`);
+        for (const r of result.results) {
+          console.log(`  [${r.level.toUpperCase()}] ${r.gate}: ${r.reason}`);
+        }
+        break;
+      }
+
+      default:
+        console.log('daxiom — Self-Learning Second Brain SDK v0.2.0');
+        console.log('');
+        console.log('Knowledge:    search | store | coherence | quality-check | stats');
+        console.log('Tiers:        tiers | tier-check | tier-promote');
+        console.log('Agents:       agent-profile | agent-route');
+        console.log('Self-mgmt:    todo | plan | changelog | decide | incident | milestone | list | done');
+        console.log('Registry:     namespaces');
+        console.log('Rollback:     demote | rollback-check');
+        console.log('Decay:        decay | drift | decay-preview');
+        console.log('Hooks:        hooks pre-task | hooks post-task | hooks session-start | hooks pre-compact | hooks summarize');
+        console.log('');
+        console.log('All self-mgmt commands accept --namespace <ns> to target a specific repo.');
+        console.log('todo/changelog with no args list entries. Use --namespace to filter.');
+        console.log('Hooks auto-load env from ~/.daxiom/.env if DATABASE_URL not set.');
+        console.log('');
+        console.log('Namespaces: daxiom, daxbot, daxiom-app, daxiom-db, ruvector, claude-flow');
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+  } finally {
+    await close();
+  }
+})();

package/src/connection.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { Pool } = require('pg');
+
+let pool = null;
+
+function getPool() {
+  if (pool) return pool;
+
+  const url = process.env.DAXIOM_DATABASE_URL || process.env.DATABASE_URL;
+  if (!url) throw new Error('DAXIOM_DATABASE_URL or DATABASE_URL required');
+
+  const dbUrl = new URL(url);
+  pool = new Pool({
+    host: dbUrl.hostname,
+    port: parseInt(dbUrl.port) || 5432,
+    database: dbUrl.pathname.slice(1),
+    user: dbUrl.username,
+    password: decodeURIComponent(dbUrl.password),
+    max: 3,
+    idleTimeoutMillis: 30000,
+    ssl: false,
+  });
+  pool.on('error', (err) => console.error('[DAXIOM Pool]', err.message));
+  return pool;
+}
+
+async function init() {
+  const p = getPool();
+  const client = await p.connect();
+  await client.query('SELECT 1');
+  client.release();
+  return true;
+}
+
+async function close() {
+  if (pool) {
+    await pool.end();
+    pool = null;
+  }
+}
+
+module.exports = { getPool, init, close };

package/src/constants.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const EMBEDDING_DIM = 1536;
+const RATE_LIMIT_MS = 160;
+const DEFAULT_SEARCH_LIMIT = 5;
+const DEFAULT_THRESHOLD = 0.3;
+
+// Coherence gate thresholds (hallucination prevention)
+const COHERENCE_DUPLICATE_THRESHOLD = 0.95;
+const COHERENCE_CONTRADICTION_THRESHOLD = 0.85;
+
+// Confidence tier system (4-tier evolutionary scoring)
+const CONFIDENCE_TIERS = {
+  PLATINUM: { min: 0.95, label: 'platinum', action: 'auto-apply' },
+  GOLD: { min: 0.85, label: 'gold', action: 'auto-apply-with-commit' },
+  SILVER: { min: 0.75, label: 'silver', action: 'suggest-only' },
+  BRONZE: { min: 0.70, label: 'bronze', action: 'learning-only' },
+};
+const CONFIDENCE_EXPIRED_THRESHOLD = 0.70;
+const CONFIDENCE_SUCCESS_DELTA = 0.05;
+const CONFIDENCE_FAILURE_DELTA = -0.10;
+
+// Quality gate constants
+const KNOWN_CLASSES = [
+  'learned', 'api', 'architecture', 'cli', 'plugin', 'security',
+  'build-plan', 'build-plan-item', 'changelog', 'todo', 'decision',
+  'incident', 'milestone', 'code', 'config', 'error-fix',
+  'tool', 'guidance', 'interface', 'algorithm', 'integration',
+  'ui', 'adapter', 'skill', 'session-context', 'session-summary',
+  'wire_integrate', 'general',
+];
+
+const KNOWN_NAMESPACES = [
+  // Core DAXIOM ecosystem
+  'daxiom',         // SDK npm package
+  'daxbot',         // AI assistant npm package (was ruvbot)
+  'daxiom-app',     // MakerKit Next.js frontend
+  'daxiom-db',      // DigitalOcean PostgreSQL+RuVector instance
+  // Upstream / tooling
+  'ruvector',       // Rust PG extension source repo
+  'claude-flow',    // Agent orchestration tool
+  // Legacy (kept for backward compat with existing patterns)
+  'ruvbot',         // Deprecated — use daxbot
+  'makerkit',       // Deprecated — use daxiom-app
+  // Cross-cutting
+  'learned',        // Cross-repo learnings
+  'session-memory', // Session context patterns
+  // Plugins / ecosystem
+  'forge', 'vibe-cast', 'agentic-qe',
+  'plugin-ecosystem', 'plugin-prime-radiant', 'gastown',
+  'plugin-code-intelligence', 'plugin-test-intelligence',
+];
+
+const SECURITY_PATTERNS = [
+  /(?:sk-[a-zA-Z0-9]{20,})/,
+  /(?:AKIA[0-9A-Z]{16})/,
+  /(?:ghp_[a-zA-Z0-9]{36})/,
+  /(?:postgresql:\/\/[^:]+:[^@]+@)/,
+  /(?:password|secret|token)\s*[:=]\s*['"][^'"]{8,}/i,
+  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/,
+  /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/,
+  /\b\d{3}[-]?\d{2}[-]?\d{4}\b/,
+];
+
+const CONTENT_MIN_LENGTH = 20;
+const CONTENT_MAX_LENGTH = 10000;
+
+const SELF_MGMT_CLASSES = ['build-plan', 'changelog', 'todo', 'decision', 'incident', 'milestone'];
+
+// Alias for backward compat with hooks (they reference KNOWN_CONTEXTS)
+const KNOWN_CONTEXTS = KNOWN_NAMESPACES;
+
+module.exports = {
+  EMBEDDING_DIM,
+  RATE_LIMIT_MS,
+  DEFAULT_SEARCH_LIMIT,
+  DEFAULT_THRESHOLD,
+  COHERENCE_DUPLICATE_THRESHOLD,
+  COHERENCE_CONTRADICTION_THRESHOLD,
+  CONFIDENCE_TIERS,
+  CONFIDENCE_EXPIRED_THRESHOLD,
+  CONFIDENCE_SUCCESS_DELTA,
+  CONFIDENCE_FAILURE_DELTA,
+  KNOWN_CLASSES,
+  KNOWN_NAMESPACES,
+  KNOWN_CONTEXTS,
+  SECURITY_PATTERNS,
+  CONTENT_MIN_LENGTH,
+  CONTENT_MAX_LENGTH,
+  SELF_MGMT_CLASSES,
+};

package/src/embeddings.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const https = require('https');
+const { EMBEDDING_DIM } = require('./constants');
+
+/**
+ * Generate embedding via Gemini embedding-001 API.
+ * Truncates input to 2000 chars, returns float array at EMBEDDING_DIM dimensions.
+ */
+async function getEmbedding(text) {
+  const key = process.env.GEMINI_API_KEY || process.env.DAXIOM_GEMINI_KEY;
+  if (!key) throw new Error('GEMINI_API_KEY or DAXIOM_GEMINI_KEY required');
+
+  const truncated = text.substring(0, 2000);
+  const body = JSON.stringify({
+    model: 'models/gemini-embedding-001',
+    content: { parts: [{ text: truncated }] },
+    outputDimensionality: EMBEDDING_DIM,
+  });
+
+  return new Promise((resolve, reject) => {
+    const req = https.request({
+      hostname: 'generativelanguage.googleapis.com',
+      path: `/v1beta/models/gemini-embedding-001:embedContent?key=${key}`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(Buffer.concat(chunks).toString());
+          if (data?.embedding?.values) {
+            resolve(data.embedding.values);
+          } else {
+            reject(new Error(`Gemini error: ${JSON.stringify(data?.error || data)}`));
+          }
+        } catch (e) {
+          reject(new Error(`Parse error: ${e.message}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+module.exports = { getEmbedding };

package/src/hooks/env.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Load DAXIOM environment variables from standard locations.
+ * Priority: existing env > ~/.daxiom/.env > project .env
+ *
+ * Only loads DATABASE_URL and GEMINI_API_KEY if not already set.
+ */
+function loadEnv() {
+  // Already have what we need
+  if (process.env.DATABASE_URL || process.env.DAXIOM_DATABASE_URL) {
+    return;
+  }
+
+  const candidates = [
+    path.join(os.homedir(), '.daxiom', '.env'),
+    path.join(os.homedir(), '.daxiom', 'env'),
+    path.join(process.cwd(), '.env'),
+  ];
+
+  for (const envPath of candidates) {
+    if (!fs.existsSync(envPath)) continue;
+    try {
+      const lines = fs.readFileSync(envPath, 'utf8').split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx < 1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let val = trimmed.slice(eqIdx + 1).trim();
+        // Strip surrounding quotes
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+          val = val.slice(1, -1);
+        }
+        // Only set if not already in env
+        if (!process.env[key]) {
+          process.env[key] = val;
+        }
+      }
+      break; // Stop at first found file
+    } catch {
+      // Skip unreadable files
+    }
+  }
+}
+
+module.exports = { loadEnv };