@lucieri/daxiom 0.2.1

package/src/quality-gates.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const {
+  COHERENCE_DUPLICATE_THRESHOLD,
+  COHERENCE_CONTRADICTION_THRESHOLD,
+  CONFIDENCE_TIERS,
+  CONFIDENCE_EXPIRED_THRESHOLD,
+  KNOWN_CLASSES,
+  KNOWN_NAMESPACES,
+  SECURITY_PATTERNS,
+  CONTENT_MIN_LENGTH,
+  CONTENT_MAX_LENGTH,
+} = require('./constants');
+
+// ── Gate 1: Coherence (hallucination prevention) ─────────────────────────────
+async function checkCoherence(client, embeddingVecStr, candidateNamespace, candidateClass) {
+  const sql = `
+    SELECT pattern_name, description, namespace, pattern_class,
+           ROUND((1 - (embedding <=> $1::ruvector(1536)))::numeric, 4) as similarity
+    FROM tribal_intelligence.patterns
+    WHERE embedding IS NOT NULL
+    ORDER BY embedding <=> $1::ruvector(1536)
+    LIMIT 5
+  `;
+  const res = await client.query(sql, [embeddingVecStr]);
+  const neighbors = res.rows.map(r => ({
+    pattern_name: r.pattern_name,
+    similarity: parseFloat(r.similarity),
+    namespace: r.namespace,
+    pattern_class: r.pattern_class,
+  }));
+
+  for (const n of neighbors) {
+    if (n.similarity > COHERENCE_DUPLICATE_THRESHOLD) {
+      return {
+        allowed: false,
+        action: 'reject',
+        reason: `Near-duplicate detected: "${n.pattern_name}" (${n.namespace}/${n.pattern_class}) with similarity ${n.similarity}`,
+        neighbors,
+        coherence_warning: false,
+      };
+    }
+  }
+
+  for (const n of neighbors) {
+    if (
+      n.similarity > COHERENCE_CONTRADICTION_THRESHOLD &&
+      n.pattern_class === candidateClass &&
+      n.namespace === candidateNamespace
+    ) {
+      return {
+        allowed: true,
+        action: 'warn',
+        reason: `Potential contradiction with "${n.pattern_name}" (similarity ${n.similarity}, same ${candidateNamespace}/${candidateClass})`,
+        neighbors,
+        coherence_warning: true,
+      };
+    }
+  }
+
+  return { allowed: true, action: 'allow', reason: null, neighbors, coherence_warning: false };
+}
+
+// ── Gate 2: Confidence Tier ──────────────────────────────────────────────────
+function getConfidenceTier(confidence) {
+  if (confidence < CONFIDENCE_EXPIRED_THRESHOLD) return null;
+  if (confidence >= CONFIDENCE_TIERS.PLATINUM.min) return CONFIDENCE_TIERS.PLATINUM;
+  if (confidence >= CONFIDENCE_TIERS.GOLD.min) return CONFIDENCE_TIERS.GOLD;
+  if (confidence >= CONFIDENCE_TIERS.SILVER.min) return CONFIDENCE_TIERS.SILVER;
+  if (confidence >= CONFIDENCE_TIERS.BRONZE.min) return CONFIDENCE_TIERS.BRONZE;
+  return null;
+}
+
+// ── Gate 4: Security — Detects secrets, PII, credentials ────────────────────
+function checkSecurity(content, metadata) {
+  const corpus = content + (metadata ? ' ' + JSON.stringify(metadata) : '');
+  for (const pattern of SECURITY_PATTERNS) {
+    if (pattern.test(corpus)) {
+      return {
+        pass: false,
+        level: 'block',
+        gate: 'security',
+        reason: `Security violation: content matches pattern ${pattern.source.slice(0, 40)}`,
+      };
+    }
+  }
+  return { pass: true, level: 'pass', gate: 'security', reason: 'No secrets or PII detected' };
+}
+
+// ── Gate 5: Behavioral — Validates pattern class and namespace ───────────────
+function checkBehavioral(patternClass, namespace) {
+  const warnings = [];
+  if (!KNOWN_CLASSES.includes(patternClass)) {
+    warnings.push(`Unknown pattern class "${patternClass}"`);
+  }
+  if (!KNOWN_NAMESPACES.includes(namespace)) {
+    warnings.push(`Unknown namespace "${namespace}"`);
+  }
+  if (warnings.length > 0) {
+    return { pass: true, level: 'warn', gate: 'behavioral', reason: warnings.join('; ') };
+  }
+  return { pass: true, level: 'pass', gate: 'behavioral', reason: 'Class and namespace recognized' };
+}
+
+// ── Gate 6: Resilience — Validates content length bounds ─────────────────────
+function checkResilience(content) {
+  if (typeof content !== 'string') {
+    return { pass: false, level: 'block', gate: 'resilience', reason: 'Content is not a string' };
+  }
+  if (content.length < CONTENT_MIN_LENGTH) {
+    return {
+      pass: false, level: 'block', gate: 'resilience',
+      reason: `Content too short (${content.length} chars, min ${CONTENT_MIN_LENGTH})`,
+    };
+  }
+  if (content.length > CONTENT_MAX_LENGTH) {
+    return {
+      pass: false, level: 'block', gate: 'resilience',
+      reason: `Content too long (${content.length} chars, max ${CONTENT_MAX_LENGTH})`,
+    };
+  }
+  return { pass: true, level: 'pass', gate: 'resilience', reason: 'Content length within bounds' };
+}
+
+// ── Gate 7: Contract — Validates required fields and types ───────────────────
+function checkContract(content, namespace, patternClass, tags, metadata) {
+  const violations = [];
+  if (typeof content !== 'string' || content.length === 0) {
+    violations.push('content must be a non-empty string');
+  }
+  if (typeof namespace !== 'string' || namespace.length === 0) {
+    violations.push('namespace must be a non-empty string');
+  }
+  if (typeof patternClass !== 'string' || patternClass.length === 0) {
+    violations.push('patternClass must be a non-empty string');
+  }
+  if (tags != null && !Array.isArray(tags)) {
+    violations.push('tags must be an array or null/undefined');
+  }
+  if (metadata != null && (typeof metadata !== 'object' || Array.isArray(metadata))) {
+    violations.push('metadata must be a plain object or null/undefined');
+  }
+  if (violations.length > 0) {
+    return { pass: false, level: 'block', gate: 'contract', reason: violations.join('; ') };
+  }
+  return { pass: true, level: 'pass', gate: 'contract', reason: 'All fields valid' };
+}
+
+// ── Aggregator — Runs gates 4-7 and returns combined verdict ─────────────────
+function runQualityGates(content, namespace, patternClass, tags, metadata, options = {}) {
+  const results = [];
+  if (!options.skipSecurity) {
+    results.push(checkSecurity(content, metadata));
+  }
+  results.push(checkBehavioral(patternClass, namespace));
+  results.push(checkResilience(content));
+  results.push(checkContract(content, namespace, patternClass, tags, metadata));
+
+  const blocked = results.filter(r => r.level === 'block');
+  const warned = results.filter(r => r.level === 'warn');
+
+  return {
+    allowed: blocked.length === 0,
+    results,
+    blocked,
+    warned,
+    summary: blocked.length > 0
+      ? `BLOCKED by ${blocked.map(b => b.gate).join(', ')}: ${blocked.map(b => b.reason).join('; ')}`
+      : warned.length > 0
+        ? `PASSED with warnings: ${warned.map(w => w.reason).join('; ')}`
+        : 'All gates passed',
+  };
+}
+
+module.exports = {
+  checkCoherence,
+  getConfidenceTier,
+  checkSecurity,
+  checkBehavioral,
+  checkResilience,
+  checkContract,
+  runQualityGates,
+};

package/src/self-manage.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const { getPool } = require('./connection');
+const { storeLearnedPattern } = require('./patterns');
+const { SELF_MGMT_CLASSES } = require('./constants');
+
+// ── Store structured project artifacts ───────────────────────────────────────
+async function storeSelfManaged({
+  patternClass,
+  name,
+  description,
+  namespace = 'daxiom',
+  category = null,
+  tags = [],
+  status = null,
+  repo = null,
+  priority = null,
+  skipCoherence = false,
+}) {
+  if (!SELF_MGMT_CLASSES.includes(patternClass)) {
+    throw new Error(`Invalid class: ${patternClass}. Must be one of: ${SELF_MGMT_CLASSES.join(', ')}`);
+  }
+
+  const meta = { stored_at: new Date().toISOString() };
+  if (status) meta.status = status;
+  if (repo) meta.repo = repo;
+  if (priority) meta.priority = priority;
+
+  return storeLearnedPattern({
+    patternName: name,
+    description,
+    compactText: description,
+    patternClass,
+    namespace,
+    category: category || patternClass,
+    tier: patternClass === 'todo' ? 'hot' : 'warm',
+    tags,
+    metadata: meta,
+    skipCoherence,
+  });
+}
+
+// ── List patterns by class ───────────────────────────────────────────────────
+async function listByClass(patternClass, options = {}) {
+  const { namespace = null, limit = 20, status = null } = options;
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    let sql = `
+      SELECT id, pattern_id, pattern_name, description, pattern_class, namespace,
+             category, tier, confidence, usage_count, tags, metadata,
+             created_at, updated_at, last_used_at
+      FROM tribal_intelligence.patterns WHERE pattern_class = $1
+    `;
+    const params = [patternClass];
+
+    if (namespace) {
+      sql += ` AND namespace = $${params.length + 1}`;
+      params.push(namespace);
+    }
+    if (status) {
+      sql += ` AND metadata->>'status' = $${params.length + 1}`;
+      params.push(status);
+    }
+
+    sql += ` ORDER BY created_at DESC LIMIT $${params.length + 1}`;
+    params.push(limit);
+
+    const res = await client.query(sql, params);
+    return res.rows;
+  } finally {
+    client.release();
+  }
+}
+
+// ── Update pattern status ────────────────────────────────────────────────────
+async function updateStatus(patternId, newStatus) {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const res = await client.query(`
+      UPDATE tribal_intelligence.patterns
+      SET metadata = jsonb_set(COALESCE(metadata, '{}'), '{status}', to_jsonb($2::text)),
+          updated_at = NOW(), last_used_at = NOW()
+      WHERE pattern_id = $1
+      RETURNING id, pattern_name, metadata->>'status' as status
+    `, [patternId, newStatus]);
+
+    if (res.rows.length === 0) {
+      const res2 = await client.query(`
+        UPDATE tribal_intelligence.patterns
+        SET metadata = jsonb_set(COALESCE(metadata, '{}'), '{status}', to_jsonb($2::text)),
+            updated_at = NOW(), last_used_at = NOW()
+        WHERE id = $1::uuid
+        RETURNING id, pattern_name, metadata->>'status' as status
+      `, [patternId, newStatus]);
+      return res2.rows[0] || null;
+    }
+    return res.rows[0];
+  } finally {
+    client.release();
+  }
+}
+
+module.exports = { storeSelfManaged, listByClass, updateStatus };

package/src/tiers.js

@@ -0,0 +1,305 @@
+'use strict';
+
+const { getPool } = require('./connection');
+const { getConfidenceTier } = require('./quality-gates');
+const { CONFIDENCE_SUCCESS_DELTA } = require('./constants');
+
+// ── Promote/demote tiers based on usage ──────────────────────────────────────
+async function updateTiers() {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const promoted = await client.query(`
+      UPDATE tribal_intelligence.patterns SET tier = 'hot', updated_at = NOW()
+      WHERE tier = 'warm' AND usage_count >= 10 AND success_rate >= 0.7
+      RETURNING id, pattern_name
+    `);
+
+    const demoted = await client.query(`
+      UPDATE tribal_intelligence.patterns SET tier = 'warm', updated_at = NOW()
+      WHERE tier = 'hot' AND last_used_at < NOW() - INTERVAL '30 days'
+      RETURNING id, pattern_name
+    `);
+
+    const cooled = await client.query(`
+      UPDATE tribal_intelligence.patterns SET tier = 'cold', updated_at = NOW()
+      WHERE tier = 'warm' AND last_used_at IS NOT NULL
+        AND last_used_at < NOW() - INTERVAL '90 days'
+      RETURNING id, pattern_name
+    `);
+
+    await client.query(`
+      UPDATE tribal_intelligence.patterns
+      SET metadata = jsonb_set(
+        jsonb_set(
+          COALESCE(metadata, '{}'),
+          '{confidence_tier}',
+          to_jsonb(
+            CASE
+              WHEN confidence >= 0.95::real THEN 'platinum'
+              WHEN confidence >= 0.85::real THEN 'gold'
+              WHEN confidence >= 0.75::real THEN 'silver'
+              WHEN confidence >= 0.70::real THEN 'bronze'
+              ELSE 'expired'
+            END
+          )
+        ),
+        '{needs_revalidation}',
+        to_jsonb(confidence < 0.70::real)
+      ),
+      updated_at = NOW()
+      WHERE confidence IS NOT NULL
+    `);
+
+    return {
+      promoted: promoted.rows.length,
+      demotedToWarm: demoted.rows.length,
+      demotedToCold: cooled.rows.length,
+    };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Confidence tier distribution ─────────────────────────────────────────────
+async function getConfidenceTierDistribution() {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const res = await client.query(`
+      SELECT
+        COUNT(*) FILTER (WHERE confidence >= 0.95) as platinum,
+        COUNT(*) FILTER (WHERE confidence >= 0.85 AND confidence < 0.95) as gold,
+        COUNT(*) FILTER (WHERE confidence >= 0.75 AND confidence < 0.85) as silver,
+        COUNT(*) FILTER (WHERE confidence >= 0.70 AND confidence < 0.75) as bronze,
+        COUNT(*) FILTER (WHERE confidence < 0.70) as expired
+      FROM tribal_intelligence.patterns WHERE confidence IS NOT NULL
+    `);
+    return res.rows[0];
+  } finally {
+    client.release();
+  }
+}
+
+// ── Force-promote pattern confidence ─────────────────────────────────────────
+async function promotePatternConfidence(patternId) {
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    let res = await client.query(`
+      UPDATE tribal_intelligence.patterns
+      SET confidence = LEAST(1.0, confidence + $2), updated_at = NOW()
+      WHERE pattern_id = $1 RETURNING confidence, pattern_name
+    `, [patternId, CONFIDENCE_SUCCESS_DELTA]);
+
+    if (res.rows.length === 0) {
+      try {
+        res = await client.query(`
+          UPDATE tribal_intelligence.patterns
+          SET confidence = LEAST(1.0, confidence + $2), updated_at = NOW()
+          WHERE id = $1::uuid RETURNING confidence, pattern_name
+        `, [patternId, CONFIDENCE_SUCCESS_DELTA]);
+      } catch (e) { return { success: false, error: 'Pattern not found' }; }
+    }
+
+    if (res.rows.length === 0) return { success: false, error: 'Pattern not found' };
+
+    const newConfidence = res.rows[0].confidence;
+    const tier = getConfidenceTier(newConfidence);
+    return { success: true, patternName: res.rows[0].pattern_name, newConfidence, tier: tier?.label || 'expired' };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Demote with rollback ─────────────────────────────────────────────────────
+async function demoteWithRollback(patternId, options = {}) {
+  const amount = options.amount ?? 0.1;
+  const threshold = options.threshold ?? 0.3;
+  const reason = options.reason ?? 'failure';
+
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    let res = await client.query(`
+      UPDATE tribal_intelligence.patterns
+      SET confidence = GREATEST(0.0, confidence - $2),
+          failure_count = failure_count + 1, usage_count = usage_count + 1,
+          metadata = jsonb_set(
+            jsonb_set(COALESCE(metadata, '{}'), '{last_demotion_reason}', to_jsonb($3::text)),
+            '{last_demotion_at}', to_jsonb(NOW()::text)
+          ), updated_at = NOW()
+      WHERE pattern_id = $1
+      RETURNING id, pattern_id, pattern_name, confidence, (confidence + $2) as old_confidence
+    `, [patternId, amount, reason]);
+
+    if (res.rows.length === 0) {
+      try {
+        res = await client.query(`
+          UPDATE tribal_intelligence.patterns
+          SET confidence = GREATEST(0.0, confidence - $2),
+              failure_count = failure_count + 1, usage_count = usage_count + 1,
+              metadata = jsonb_set(
+                jsonb_set(COALESCE(metadata, '{}'), '{last_demotion_reason}', to_jsonb($3::text)),
+                '{last_demotion_at}', to_jsonb(NOW()::text)
+              ), updated_at = NOW()
+          WHERE id = $1::uuid
+          RETURNING id, pattern_id, pattern_name, confidence, (confidence + $2) as old_confidence
+        `, [patternId, amount, reason]);
+      } catch (e) { return { success: false, error: 'Pattern not found' }; }
+    }
+
+    if (res.rows.length === 0) return { success: false, error: 'Pattern not found' };
+
+    const row = res.rows[0];
+    const newConfidence = parseFloat(row.confidence);
+    const oldConfidence = parseFloat(row.old_confidence);
+    const tier = getConfidenceTier(newConfidence);
+    const rollbackTriggered = newConfidence < threshold;
+    let rollbackEvent = null;
+
+    if (rollbackTriggered) {
+      await client.query(`
+        UPDATE tribal_intelligence.patterns
+        SET tier = 'cold',
+            metadata = jsonb_set(
+              jsonb_set(
+                jsonb_set(COALESCE(metadata, '{}'), '{archived}', 'true'::jsonb),
+                '{archived_at}', to_jsonb(NOW()::text)
+              ), '{rollback_reason}', to_jsonb($2::text)
+            ), updated_at = NOW()
+        WHERE id = $1
+      `, [row.id, `Confidence ${newConfidence.toFixed(2)} below threshold ${threshold}`]);
+
+      rollbackEvent = {
+        patternId: row.pattern_id, patternName: row.pattern_name,
+        previousConfidence: oldConfidence, triggeredAtConfidence: newConfidence,
+        threshold, action: 'archived', timestamp: new Date().toISOString(), reason,
+      };
+    }
+
+    return { success: true, patternName: row.pattern_name, oldConfidence, newConfidence, tier: tier?.label || 'expired', rollbackTriggered, rollbackEvent };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Scan rollback candidates ─────────────────────────────────────────────────
+async function scanRollbackCandidates(options = {}) {
+  const threshold = options.threshold ?? 0.3;
+  const limit = options.limit ?? 50;
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const res = await client.query(`
+      SELECT pattern_id, pattern_name, namespace, confidence, tier,
+             COALESCE((metadata->>'archived')::boolean, false) as archived,
+             metadata->>'rollback_reason' as rollback_reason
+      FROM tribal_intelligence.patterns
+      WHERE confidence IS NOT NULL AND confidence < $1
+      ORDER BY confidence ASC LIMIT $2
+    `, [threshold, limit]);
+
+    return res.rows.map(r => ({
+      patternId: r.pattern_id, patternName: r.pattern_name, namespace: r.namespace,
+      confidence: parseFloat(r.confidence), tier: r.tier,
+      archived: r.archived || false, rollbackReason: r.rollback_reason || null,
+    }));
+  } finally {
+    client.release();
+  }
+}
+
+// ── Temporal decay ───────────────────────────────────────────────────────────
+async function decayPatterns(options = {}) {
+  const { baseRate = 0.02, minIdleDays = 1.0, floor = 0.0 } = options;
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    const res = await client.query(
+      `SELECT * FROM tribal_intelligence.decay_pattern_confidence($1, $2, $3)`,
+      [baseRate, minIdleDays, floor]
+    );
+    const row = res.rows[0] || {};
+    return {
+      patternsDecayed: parseInt(row.patterns_decayed) || 0,
+      avgNewConfidence: parseFloat(row.avg_new_confidence) || 0,
+      tierChanges: parseInt(row.tier_changes) || 0,
+    };
+  } finally {
+    client.release();
+  }
+}
+
+// ── Drift report ─────────────────────────────────────────────────────────────
+async function getDriftReport(options = {}) {
+  const { limit = 20, minIdleDays = 1.0 } = options;
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    await client.query('SET jit = off');
+    const res = await client.query(
+      `SELECT * FROM tribal_intelligence.get_drift_report($1, $2)`,
+      [limit, minIdleDays]
+    );
+    return res.rows.map(r => ({
+      patternId: r.pattern_id, patternName: r.pattern_name, namespace: r.namespace,
+      patternClass: r.pattern_class, confidence: parseFloat(r.confidence) || 0,
+      daysIdle: parseFloat(r.days_idle) || 0, driftScore: parseFloat(r.drift_score) || 0,
+      tier: r.tier,
+    }));
+  } finally {
+    client.release();
+  }
+}
+
+// ── Preview decay ────────────────────────────────────────────────────────────
+async function previewDecay(patternId, options = {}) {
+  const { baseRate = 0.02 } = options;
+  const p = getPool();
+  const client = await p.connect();
+  try {
+    let res;
+    try {
+      res = await client.query(
+        `SELECT * FROM tribal_intelligence.preview_pattern_decay($1::uuid, $2)`,
+        [patternId, baseRate]
+      );
+    } catch (e) {
+      const lookup = await client.query(
+        `SELECT id FROM tribal_intelligence.patterns WHERE pattern_id = $1`,
+        [patternId]
+      );
+      if (lookup.rows.length === 0) return null;
+      res = await client.query(
+        `SELECT * FROM tribal_intelligence.preview_pattern_decay($1::uuid, $2)`,
+        [lookup.rows[0].id, baseRate]
+      );
+    }
+    if (!res || res.rows.length === 0) return null;
+    const r = res.rows[0];
+    return {
+      patternName: r.pattern_name,
+      currentConfidence: parseFloat(r.current_confidence) || 0,
+      decayedConfidence: parseFloat(r.decayed_confidence) || 0,
+      daysIdle: parseFloat(r.days_idle) || 0,
+      decayAmount: parseFloat(r.decay_amount) || 0,
+      effectiveRate: parseFloat(r.effective_rate) || 0,
+      currentTier: r.current_tier,
+      projectedTier: r.projected_tier,
+    };
+  } finally {
+    client.release();
+  }
+}
+
+module.exports = {
+  updateTiers,
+  getConfidenceTierDistribution,
+  promotePatternConfidence,
+  demoteWithRollback,
+  scanRollbackCandidates,
+  decayPatterns,
+  getDriftReport,
+  previewDecay,
+};