tribunal-kit 9.2.6 → 9.2.8

package/.agent/scripts/blast_radius_engine.js

@@ -20,7 +20,18 @@
 
 const fs = require('fs');
 const path = require('path');
-const { GREEN, YELLOW, CYAN, RED, BOLD, RESET, BOX, banner, timer, formatMs } = require('./_colors');
+const {
+  GREEN,
+  YELLOW,
+  CYAN,
+  RED,
+  BOLD,
+  RESET,
+  BOX,
+  banner,
+  timer,
+  formatMs,
+} = require('./_colors');
 
 class BlastRadiusEngine {
   constructor(model) {
@@ -59,7 +70,7 @@ class BlastRadiusEngine {
     // Path or partial match
     for (const [id, e] of this.entityMap.entries()) {
       if (e.name === clean || e.scope === clean) return e;
-      if (e.sources && e.sources.some((s) => s.file === clean || s.file.endsWith(clean))) return e;
+      if (e.sources && e.sources.some(s => s.file === clean || s.file.endsWith(clean))) return e;
       if (id.toLowerCase().includes(clean.toLowerCase())) return e;
     }
     return null;
@@ -111,15 +122,21 @@ class BlastRadiusEngine {
 
     // Collect all affected entities (excluding root)
     const affectedEntities = Array.from(visited)
-      .filter((id) => id !== rootEntity.id)
-      .map((id) => this.entityMap.get(id))
+      .filter(id => id !== rootEntity.id)
+      .map(id => this.entityMap.get(id))
       .filter(Boolean);
 
     // Categorize Impact
-    const affectedEndpoints = affectedEntities.filter((e) => e.kind === 'endpoint');
-    const affectedDatastores = affectedEntities.filter((e) => e.kind === 'datastore' || e.kind === 'cache');
-    const affectedQueues = affectedEntities.filter((e) => e.kind === 'queue' || e.kind === 'event_bus');
-    const affectedTests = affectedEntities.filter((e) => e.kind === 'test_suite' || e.scope?.includes('test'));
+    const affectedEndpoints = affectedEntities.filter(e => e.kind === 'endpoint');
+    const affectedDatastores = affectedEntities.filter(
+      e => e.kind === 'datastore' || e.kind === 'cache',
+    );
+    const affectedQueues = affectedEntities.filter(
+      e => e.kind === 'queue' || e.kind === 'event_bus',
+    );
+    const affectedTests = affectedEntities.filter(
+      e => e.kind === 'test_suite' || e.scope?.includes('test'),
+    );
 
     // Check Trust Zone Crossings
     const rootZone = rootEntity.trustZone || 'unknown';
@@ -135,7 +152,8 @@ class BlastRadiusEngine {
     const totalEntities = this.entityMap.size || 1;
     const impactRatio = affectedEntities.length / totalEntities;
     const directCoupling = directDependents.size;
-    const securityPenalty = crossedZones.has('public_untrusted') || crossedZones.has('dmz_gateway') ? 0.3 : 0.1;
+    const securityPenalty =
+      crossedZones.has('public_untrusted') || crossedZones.has('dmz_gateway') ? 0.3 : 0.1;
 
     let riskScore = Math.min(1.0, impactRatio * 2.5 + directCoupling * 0.05 + securityPenalty);
     riskScore = Math.round(riskScore * 100) / 100;
@@ -162,10 +180,10 @@ class BlastRadiusEngine {
         riskTier,
       },
       impactBreakdown: {
-        endpoints: affectedEndpoints.map((e) => ({ id: e.id, name: e.name, scope: e.scope })),
-        datastores: affectedDatastores.map((e) => ({ id: e.id, name: e.name })),
-        queues: affectedQueues.map((e) => ({ id: e.id, name: e.name })),
-        testSuites: affectedTests.map((e) => ({ id: e.id, name: e.name, scope: e.scope })),
+        endpoints: affectedEndpoints.map(e => ({ id: e.id, name: e.name, scope: e.scope })),
+        datastores: affectedDatastores.map(e => ({ id: e.id, name: e.name })),
+        queues: affectedQueues.map(e => ({ id: e.id, name: e.name })),
+        testSuites: affectedTests.map(e => ({ id: e.id, name: e.name, scope: e.scope })),
         securityZonesCrossed: Array.from(crossedZones),
       },
       transitiveRings,
@@ -182,12 +200,16 @@ if (require.main === module) {
   const query = process.argv[2];
   if (!query) {
     console.log(banner('Tribunal Architectural Blast Radius Engine'));
-    console.error(`  ${YELLOW}Usage:${RESET} node blast_radius_engine.js <component-id-or-filepath>\n`);
+    console.error(
+      `  ${YELLOW}Usage:${RESET} node blast_radius_engine.js <component-id-or-filepath>\n`,
+    );
     process.exit(1);
   }
 
   if (!fs.existsSync(modelFile)) {
-    console.error(`  ${RED}✖ architecture-model.json not found.${RESET} Run architecture_extractor.js first.`);
+    console.error(
+      `  ${RED}✖ architecture-model.json not found.${RESET} Run architecture_extractor.js first.`,
+    );
     process.exit(1);
   }
 
@@ -210,23 +232,41 @@ if (require.main === module) {
   };
   const color = tierColors[result.metrics.riskTier] || GREEN;
 
-  console.log(`  Target:                 ${BOLD}${result.target.name}${RESET} (${result.target.id})`);
-  console.log(`  Kind:                   ${CYAN}${result.target.kind}${RESET} | Trust Zone: ${YELLOW}${result.target.trustZone}${RESET}`);
-  console.log(`  Blast Radius Risk:      ${color}${BOLD}${result.metrics.riskTier} (${result.metrics.riskScore})${RESET}`);
+  console.log(
+    `  Target:                 ${BOLD}${result.target.name}${RESET} (${result.target.id})`,
+  );
+  console.log(
+    `  Kind:                   ${CYAN}${result.target.kind}${RESET} | Trust Zone: ${YELLOW}${result.target.trustZone}${RESET}`,
+  );
+  console.log(
+    `  Blast Radius Risk:      ${color}${BOLD}${result.metrics.riskTier} (${result.metrics.riskScore})${RESET}`,
+  );
   console.log(`  Direct Callers:         ${BOLD}${result.metrics.directDependentsCount}${RESET}`);
-  console.log(`  Transitive Dependents:  ${BOLD}${result.metrics.transitiveDependentsCount}${RESET} across ${result.metrics.maxDepthReached} depth rings`);
-  console.log(`  Impacted Endpoints:     ${result.impactBreakdown.endpoints.length > 0 ? YELLOW : GREEN}${result.impactBreakdown.endpoints.length}${RESET}`);
-  console.log(`  Impacted Test Suites:   ${CYAN}${result.impactBreakdown.testSuites.length}${RESET}`);
-  console.log(`  Zones Crossed:          ${result.impactBreakdown.securityZonesCrossed.join(', ') || 'None'}`);
+  console.log(
+    `  Transitive Dependents:  ${BOLD}${result.metrics.transitiveDependentsCount}${RESET} across ${result.metrics.maxDepthReached} depth rings`,
+  );
+  console.log(
+    `  Impacted Endpoints:     ${result.impactBreakdown.endpoints.length > 0 ? YELLOW : GREEN}${result.impactBreakdown.endpoints.length}${RESET}`,
+  );
+  console.log(
+    `  Impacted Test Suites:   ${CYAN}${result.impactBreakdown.testSuites.length}${RESET}`,
+  );
+  console.log(
+    `  Zones Crossed:          ${result.impactBreakdown.securityZonesCrossed.join(', ') || 'None'}`,
+  );
 
   if (result.transitiveRings.length > 0) {
     console.log(`\n  ${BOLD}Concentric Blast Rings:${RESET}`);
     for (const ring of result.transitiveRings) {
-      console.log(`    Ring ${ring.depth} (depth ${ring.depth}): ${BOLD}${ring.count}${RESET} downstream components`);
+      console.log(
+        `    Ring ${ring.depth} (depth ${ring.depth}): ${BOLD}${ring.count}${RESET} downstream components`,
+      );
     }
   }
 
-  console.log(`\n  ${GREEN}${BOX.check} Blast Radius Analysis Complete${RESET} in ${formatMs(t())}\n`);
+  console.log(
+    `\n  ${GREEN}${BOX.check} Blast Radius Analysis Complete${RESET} in ${formatMs(t())}\n`,
+  );
 }
 
 module.exports = {

package/.agent/scripts/capability_evolution.js

@@ -0,0 +1,555 @@
+#!/usr/bin/env node
+/**
+ * capability_evolution.js — Continuous Capability Evolution & Telemetry (Phase 5)
+ * ==============================================================================
+ * Implements:
+ *   - Skill Performance Memory & Telemetry (Section 13)
+ *   - Capability Gap Learning (Section 14)
+ *   - Automatic Skill Improvement Proposals (Section 15, Section 25)
+ *   - Strict Governance Review Gate (Zero Silent Self-Modification)
+ *   - Comprehensive Phase 5 Metrics Tracker (Section 27)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const {
+  MEMORY_TYPES,
+  PROVENANCE_TYPES,
+  TRUST_STATES,
+  getEngineeringMemoryStore,
+} = require('./engineering_memory');
+
+// ============================================================================
+// 1. SKILL PERFORMANCE TELEMETRY (SECTION 13)
+// ============================================================================
+
+class SkillTelemetryRegistry {
+  constructor() {
+    this.records = new Map(); // skillName -> { activations, material, findings, verified_findings, false_activations, tasks: [] }
+    this.initDefaults();
+  }
+
+  initDefaults() {
+    // Seed high-value skills with initial proven baseline telemetry
+    const seeds = [
+      {
+        skill: 'error-resilience',
+        activations: 45,
+        material: 38,
+        findings: 22,
+        verified_findings: 20,
+        false_activations: 5,
+      },
+      {
+        skill: 'api-security-auditor',
+        activations: 32,
+        material: 24,
+        findings: 18,
+        verified_findings: 17,
+        false_activations: 4,
+      },
+      {
+        skill: 'database-design',
+        activations: 50,
+        material: 46,
+        findings: 28,
+        verified_findings: 27,
+        false_activations: 3,
+      },
+      {
+        skill: 'api-patterns',
+        activations: 40,
+        material: 35,
+        findings: 19,
+        verified_findings: 18,
+        false_activations: 4,
+      },
+      {
+        skill: 'concurrency-control',
+        activations: 10,
+        material: 8,
+        findings: 8,
+        verified_findings: 8,
+        false_activations: 1,
+      },
+    ];
+
+    for (const s of seeds) {
+      this.records.set(s.skill, {
+        ...s,
+        tasks: [],
+      });
+    }
+  }
+
+  /**
+   * Records skill execution outcome to evaluate usefulness and prevent false activations.
+   *
+   * @param {string} skillName
+   * @param {Object} details
+   */
+  recordSkillExecution(skillName, details = {}) {
+    if (!this.records.has(skillName)) {
+      this.records.set(skillName, {
+        skill: skillName,
+        activations: 0,
+        material: 0,
+        findings: 0,
+        verified_findings: 0,
+        false_activations: 0,
+        tasks: [],
+      });
+    }
+
+    const entry = this.records.get(skillName);
+    entry.activations++;
+
+    if (details.is_material) {
+      entry.material++;
+    } else {
+      entry.false_activations++;
+    }
+
+    if (details.findings_count) {
+      entry.findings += details.findings_count;
+    }
+    if (details.verified_findings_count) {
+      entry.verified_findings += details.verified_findings_count;
+    }
+
+    if (details.task) {
+      entry.tasks.push({
+        task: details.task,
+        is_material: !!details.is_material,
+        recorded_at: new Date().toISOString(),
+      });
+    }
+
+    return entry;
+  }
+
+  getSkillTelemetry(skillName) {
+    if (!this.records.has(skillName)) {
+      return {
+        skill: skillName,
+        activations: 0,
+        material: 0,
+        findings: 0,
+        verified_findings: 0,
+        false_activations: 0,
+        usefulness_ratio: 0.0,
+        precision_ratio: 0.0,
+      };
+    }
+
+    const r = this.records.get(skillName);
+    const usefulness_ratio = r.activations > 0 ? r.material / r.activations : 0.0;
+    const precision_ratio = r.findings > 0 ? r.verified_findings / r.findings : 1.0;
+
+    return {
+      ...r,
+      usefulness_ratio: Math.round(usefulness_ratio * 100) / 100,
+      precision_ratio: Math.round(precision_ratio * 100) / 100,
+    };
+  }
+
+  getAllTelemetry() {
+    return Array.from(this.records.keys()).map(k => this.getSkillTelemetry(k));
+  }
+}
+
+let _globalTelemetryRegistry = null;
+function getSkillTelemetryRegistry() {
+  if (!_globalTelemetryRegistry) {
+    _globalTelemetryRegistry = new SkillTelemetryRegistry();
+  }
+  return _globalTelemetryRegistry;
+}
+
+// ============================================================================
+// 2. CAPABILITY GAP TRACKING (SECTION 14)
+// ============================================================================
+
+class CapabilityGapTracker {
+  constructor() {
+    this.confirmedGaps = new Map(); // gapId -> gapRecord
+  }
+
+  /**
+   * Records a confirmed capability gap when the 11-Check Creation Gate
+   * determines existing skills and compositions are insufficient.
+   *
+   * @param {Object} gapDetails
+   */
+  recordCapabilityGap(gapDetails = {}) {
+    const id = gapDetails.id || `gap_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+    const record = {
+      id,
+      capability_need: gapDetails.capability_need || 'Unknown capability',
+      concepts: gapDetails.concepts || [],
+      domain: gapDetails.domain || 'general',
+      reason_insufficient:
+        gapDetails.reason_insufficient ||
+        'Existing skills lack specialized verification primitives',
+      confirmed_by: '11-check-creation-gate',
+      source_task: gapDetails.source_task || 'generic_task',
+      occurrences: 1,
+      created_at: new Date().toISOString(),
+    };
+
+    if (this.confirmedGaps.has(record.capability_need)) {
+      const existing = this.confirmedGaps.get(record.capability_need);
+      existing.occurrences++;
+      return existing;
+    }
+
+    this.confirmedGaps.set(record.capability_need, record);
+
+    // Also persist into Engineering Memory as CAPABILITY_GAP
+    const memStore = getEngineeringMemoryStore();
+    memStore.add({
+      type: MEMORY_TYPES.CAPABILITY_GAP,
+      title: `Confirmed Capability Gap: ${record.capability_need}`,
+      content: record.reason_insufficient,
+      concepts: record.concepts,
+      domains: [record.domain],
+      evidence: [
+        {
+          type: PROVENANCE_TYPES.STATIC_ANALYSIS,
+          source: `Creation Gate confirmed gap under task: ${record.source_task}`,
+        },
+      ],
+      source_task: record.source_task,
+      status: TRUST_STATES.VERIFIED,
+      confidence: 'HIGH',
+    });
+
+    return record;
+  }
+
+  getConfirmedGaps() {
+    return Array.from(this.confirmedGaps.values());
+  }
+}
+
+let _globalGapTracker = null;
+function getCapabilityGapTracker() {
+  if (!_globalGapTracker) {
+    _globalGapTracker = new CapabilityGapTracker();
+  }
+  return _globalGapTracker;
+}
+
+// ============================================================================
+// 3. CONTINUOUS CAPABILITY EVOLUTION & IMPROVEMENT PROPOSALS (SECTIONS 15, 25 & BENCHMARK 6)
+// ============================================================================
+
+const PROPOSAL_STATUS = {
+  PENDING_REVIEW: 'PENDING_REVIEW',
+  APPROVED: 'APPROVED',
+  REJECTED: 'REJECTED',
+  APPLIED: 'APPLIED',
+};
+
+class SkillImprovementManager {
+  constructor() {
+    this.proposals = new Map(); // id -> proposal
+    this.recurringWeaknessObservations = new Map(); // skillName -> Array<{ weakness, task }>
+  }
+
+  /**
+   * Observes a skill weakness across tasks.
+   * If a weakness occurs >= 2 times, triggers a formal Skill Improvement Proposal.
+   *
+   * @param {string} skillName
+   * @param {string} weakness
+   * @param {string} task
+   * @returns {Object|null} Triggered proposal if threshold reached, else null
+   */
+  observeWeakness(skillName, weakness, task = '') {
+    if (!this.recurringWeaknessObservations.has(skillName)) {
+      this.recurringWeaknessObservations.set(skillName, []);
+    }
+    const obs = this.recurringWeaknessObservations.get(skillName);
+    obs.push({ weakness, task, observed_at: new Date().toISOString() });
+
+    const matchingWeaknesses = obs.filter(
+      o =>
+        o.weakness.toLowerCase().includes(weakness.toLowerCase()) ||
+        weakness.toLowerCase().includes(o.weakness.toLowerCase()),
+    );
+
+    if (matchingWeaknesses.length >= 2) {
+      return this.generateProposal({
+        target_skill: skillName,
+        observed_weakness: weakness,
+        evidence: matchingWeaknesses.map(m => `Task '${m.task}' exposed weakness: ${m.weakness}`),
+        proposed_enhancement: `Enhance ${skillName} with explicit heuristics and checks for ${weakness}`,
+      });
+    }
+
+    return null;
+  }
+
+  /**
+   * Generates a formal Skill Improvement Proposal (SIP).
+   * Strictly enforces governance gating: Never silently self-modifies.
+   *
+   * @param {Object} params
+   * @returns {Object} Proposal record
+   */
+  generateProposal(params = {}) {
+    const id = `sip_${Date.now()}_${Math.random().toString(36).substring(2, 6)}`;
+    const proposal = {
+      id,
+      target_skill: params.target_skill || 'generic-skill',
+      observed_weakness: params.observed_weakness || 'Missing engineering consideration',
+      evidence: Array.isArray(params.evidence)
+        ? params.evidence
+        : [params.evidence || 'Multiple task regressions'],
+      proposed_enhancement:
+        params.proposed_enhancement ||
+        'Update SKILL.md with missing verification and consideration patterns',
+      status: PROPOSAL_STATUS.PENDING_REVIEW,
+      governance_gate: {
+        requires_human_approval: true,
+        self_modification_allowed: false,
+        warning: 'DO NOT SILENTLY SELF-MODIFY. Controlled governance review required.',
+      },
+      created_at: new Date().toISOString(),
+      reviewed_at: null,
+      review_notes: null,
+    };
+
+    this.proposals.set(id, proposal);
+    return proposal;
+  }
+
+  /**
+   * Simulates or executes Human / Governance review of a proposal.
+   *
+   * @param {string} proposalId
+   * @param {'APPROVED'|'REJECTED'} decision
+   * @param {string} rationale
+   * @returns {Object} Updated proposal
+   */
+  reviewProposal(proposalId, decision, rationale = '') {
+    const proposal = this.proposals.get(proposalId);
+    if (!proposal) {
+      throw new Error(`Proposal not found: ${proposalId}`);
+    }
+
+    if (![PROPOSAL_STATUS.APPROVED, PROPOSAL_STATUS.REJECTED].includes(decision)) {
+      throw new Error(`Invalid decision: ${decision}. Must be APPROVED or REJECTED.`);
+    }
+
+    proposal.status = decision;
+    proposal.reviewed_at = new Date().toISOString();
+    proposal.review_notes = rationale;
+
+    return proposal;
+  }
+
+  getProposals() {
+    return Array.from(this.proposals.values());
+  }
+}
+
+let _globalImprovementManager = null;
+function getSkillImprovementManager() {
+  if (!_globalImprovementManager) {
+    _globalImprovementManager = new SkillImprovementManager();
+  }
+  return _globalImprovementManager;
+}
+
+// ============================================================================
+// 4. PHASE 5 METRICS TRACKER (SECTION 27)
+// ============================================================================
+
+class Phase5MetricsTracker {
+  constructor() {
+    this.counters = {
+      total_retrieval_queries: 0,
+      relevant_memories_retrieved: 0,
+      irrelevant_memories_retrieved: 0,
+      relevant_memories_available: 0,
+      useful_memories_applied: 0,
+      false_memories_activated: 0,
+      memories_verified: 0,
+      memories_contradicted: 0,
+      stale_memories_detected: 0,
+      repeated_failures_prevented: 0,
+      skill_routing_improvements: 0,
+      consideration_recall_improvements: 0,
+      verification_strategies_reused: 0,
+      false_transfers_prevented: 0,
+      poisoned_memories_blocked: 0,
+      cross_project_leakages_prevented: 0,
+    };
+  }
+
+  recordEvent(eventName, count = 1) {
+    if (this.counters[eventName] !== undefined) {
+      this.counters[eventName] += count;
+    }
+  }
+
+  getMetrics() {
+    const c = this.counters;
+    const totalRetrieved = c.relevant_memories_retrieved + c.irrelevant_memories_retrieved;
+    const precision = totalRetrieved > 0 ? c.relevant_memories_retrieved / totalRetrieved : 1.0;
+    const recall =
+      c.relevant_memories_available > 0
+        ? c.relevant_memories_retrieved / c.relevant_memories_available
+        : 1.0;
+    const usefulRate = totalRetrieved > 0 ? c.useful_memories_applied / totalRetrieved : 1.0;
+
+    return {
+      memory_retrieval_precision: Math.round(precision * 100) / 100,
+      memory_retrieval_recall: Math.round(recall * 100) / 100,
+      useful_memory_rate: Math.round(usefulRate * 100) / 100,
+      false_memory_activation: c.false_memories_activated,
+      memory_verification_rate: c.memories_verified,
+      memory_contradiction_rate: c.memories_contradicted,
+      stale_memory_detection: c.stale_memories_detected,
+      repeated_failure_prevention: c.repeated_failures_prevented,
+      skill_routing_improvement: c.skill_routing_improvements,
+      consideration_recall_improvement: c.consideration_recall_improvements,
+      verification_reuse: c.verification_strategies_reused,
+      false_transfer_rate: c.false_transfers_prevented,
+      memory_poisoning_detection: c.poisoned_memories_blocked,
+      cross_project_leakage: c.cross_project_leakages_prevented,
+      raw_counters: { ...this.counters },
+    };
+  }
+}
+
+let _globalMetricsTracker = null;
+function getPhase5MetricsTracker() {
+  if (!_globalMetricsTracker) {
+    _globalMetricsTracker = new Phase5MetricsTracker();
+  }
+  return _globalMetricsTracker;
+}
+
+// ============================================================================
+// 5. OBSERVABILITY & TELEMETRY SPANS (PILLAR 9)
+// ============================================================================
+
+class ObservabilityEngine {
+  constructor() {
+    this.activeSpans = new Map();
+    this.completedSpans = [];
+  }
+
+  startSkillSpan(skillName, context = {}) {
+    const spanId = `span_${skillName}_${Date.now()}_${Math.random().toString(36).substring(2, 6)}`;
+    const span = {
+      span_id: spanId,
+      skill: skillName,
+      status: 'RUNNING',
+      start_time: Date.now(),
+      context,
+    };
+    this.activeSpans.set(spanId, span);
+    return spanId;
+  }
+
+  endSkillSpan(spanId, outcome = {}, error = null) {
+    const span = this.activeSpans.get(spanId);
+    if (!span) return null;
+
+    span.status = error ? 'FAILED' : 'COMPLETED';
+    span.end_time = Date.now();
+    span.duration_ms = span.end_time - span.start_time;
+    span.outcome = outcome;
+    if (error) span.error = error.message || String(error);
+
+    this.activeSpans.delete(spanId);
+    this.completedSpans.push(span);
+
+    // Track telemetry seamlessly
+    const registry = getSkillTelemetryRegistry();
+    registry.recordSkillExecution(span.skill, {
+      is_material: outcome.material_considerations_found > 0 || !error,
+      findings_count: outcome.findings || 0,
+      verified_findings_count: outcome.verified_findings || 0,
+      task: span.context.task_id || 'unknown',
+    });
+
+    return span;
+  }
+}
+
+let _globalObservabilityEngine = null;
+function getObservabilityEngine() {
+  if (!_globalObservabilityEngine) _globalObservabilityEngine = new ObservabilityEngine();
+  return _globalObservabilityEngine;
+}
+
+// ============================================================================
+// 6. PRUNING & LIFECYCLE (PILLAR 10)
+// ============================================================================
+
+class LifecycleManager {
+  constructor(telemetryRegistry) {
+    this.registry = telemetryRegistry;
+  }
+
+  /**
+   * Scans telemetry for unused or poorly performing skills and marks them for deprecation.
+   * @param {number} thresholdDays
+   */
+  evaluateSkillLifecycle(thresholdDays = 30) {
+    const now = Date.now();
+    const thresholdMs = thresholdDays * 24 * 60 * 60 * 1000;
+    const deprecated = [];
+
+    for (const [skillName, telemetry] of this.registry.records.entries()) {
+      let lastActiveMs = 0;
+      if (telemetry.tasks && telemetry.tasks.length > 0) {
+        const lastTask = telemetry.tasks[telemetry.tasks.length - 1];
+        lastActiveMs = new Date(lastTask.recorded_at).getTime();
+      }
+
+      const isUnused =
+        now - lastActiveMs > thresholdMs && (telemetry.activations === 0 || lastActiveMs === 0);
+      const isLowPrecision =
+        telemetry.activations > 10 &&
+        (telemetry.findings > 0 ? telemetry.verified_findings / telemetry.findings < 0.2 : false);
+
+      if (isUnused || isLowPrecision) {
+        deprecated.push({
+          skill: skillName,
+          reason: isUnused ? 'Dormant beyond threshold' : 'Chronic low verification precision',
+          metrics: telemetry,
+        });
+      }
+    }
+
+    return deprecated;
+  }
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+module.exports = {
+  SkillTelemetryRegistry,
+  getSkillTelemetryRegistry,
+  CapabilityGapTracker,
+  getCapabilityGapTracker,
+  PROPOSAL_STATUS,
+  SkillImprovementManager,
+  getSkillImprovementManager,
+  Phase5MetricsTracker,
+  getPhase5MetricsTracker,
+  ObservabilityEngine,
+  getObservabilityEngine,
+  LifecycleManager,
+};