tribunal-kit 9.2.7 → 9.2.8

package/.agent/scripts/skill_human_validation.js

@@ -0,0 +1,32 @@
+const crypto = require('crypto');
+
+function createReviewPackage(skillId, expectations, observations) {
+  const pkg = {
+    skill_id: skillId,
+    timestamp: new Date().toISOString(),
+    expectations,
+    observations,
+  };
+  pkg.hash = crypto.createHash('sha256').update(JSON.stringify(pkg)).digest('hex');
+  return pkg;
+}
+
+function processHumanValidation(reviewPackage, decision, reviewerName, reason) {
+  if (!['ACCEPT', 'REJECT', 'REQUEST_MORE_EVIDENCE'].includes(decision)) {
+    throw new Error('Invalid decision');
+  }
+
+  return {
+    reviewer: reviewerName,
+    timestamp: new Date().toISOString(),
+    scope: 'behavioral',
+    decision,
+    reason,
+    hash_of_review_package: reviewPackage.hash,
+  };
+}
+
+module.exports = {
+  createReviewPackage,
+  processHumanValidation,
+};

package/.agent/scripts/skill_intelligence.js

@@ -135,40 +135,6 @@ const {
   Phase6MetricsTracker,
   getPhase6MetricsTracker,
 } = require('./simulation_engine');
-const {
-  RELATIONSHIP_TYPES,
-  INTERACTION_PRIORITY,
-  INTERACTION_CONFIDENCE,
-  runCrossDomainAnalysis,
-  Phase9MetricsTracker,
-  getPhase9MetricsTracker,
-} = require('./cross_domain_engine');
-const {
-  OUTCOME_INVARIANT,
-  REQUIREMENT_SOURCES,
-  REQUIREMENT_CATEGORIES,
-  REQUIREMENT_PRIORITY: PHASE10_REQUIREMENT_PRIORITY,
-  COMPLEXITY_BUDGETS,
-  ASSUMPTION_STATUS,
-  REVERSIBILITY_LEVELS: PHASE10_REVERSIBILITY_LEVELS,
-  CAPABILITY_DEPTH,
-  REASONING_DEPTH,
-  discoverRequirements,
-  evaluateComplexityBudget,
-  auditArchitectureJustification,
-  generateDecisionRecords,
-  analyzeAssumptionsAndUnknowns,
-  buildSolutionShape,
-  verifyOutcomeAndRegressions,
-  runOutcomeOptimization,
-  evaluateSkillSelection,
-  Phase10OutcomeMemory,
-  getPhase10OutcomeMemory,
-  runAntiShortcutCheck,
-  runAntiOverengineeringCheck,
-  Phase10MetricsTracker,
-  getPhase10MetricsTracker,
-} = require('./outcome_optimization_engine');
 
 const _skillsCache = new Map();
 
@@ -365,12 +331,15 @@ function loadAllSkills(agentDir) {
   return list;
 }
 
-function discoverSkills(taskQuery, agentDir) {
+function discoverSkills(taskQuery, agentDir, options = {}) {
   const allSkills = loadAllSkills(agentDir);
   const q = taskQuery.toLowerCase();
   const rawTokens = q.split(/\W+/).filter(t => t.length > 2);
   const queryTokens = rawTokens.filter(t => !STOP_WORDS.has(t));
 
+  const explicitIncludes = options.explicitIncludes || [];
+  const explicitExcludes = options.explicitExcludes || [];
+
   // Evaluate failure mode hits
   const failureSkills = new Set();
   for (const sig of FAILURE_SIGNALS) {
@@ -379,58 +348,104 @@ function discoverSkills(taskQuery, agentDir) {
     }
   }
 
+  const routingDecision = {
+    requestId: options.requestId || `REQ-${Date.now()}`,
+    candidates: [],
+    selected: [],
+    policy: {
+      priority: options.priority || 'standard',
+      conflictResolution: 'explicit-wins',
+    },
+  };
+
   const scored = [];
 
   for (const skill of allSkills) {
     let score = 0;
+    const signals = {
+      keyword: false,
+      domain: false,
+      concept: false,
+      semantic: false,
+      dependency: false,
+    };
     const sName = skill.name.toLowerCase();
     const sDesc = skill.description.toLowerCase();
+    let rejected = false;
+    let rejectionReason = null;
+    let isExplicit = false;
+
+    if (explicitExcludes.includes(skill.name)) {
+      rejected = true;
+      rejectionReason = 'Explicitly excluded by user';
+    } else if (explicitIncludes.includes(skill.name)) {
+      score += 100;
+      isExplicit = true;
+      signals.keyword = true;
+    } else {
+      // Exact skill name in query
+      if (q.includes(sName.replace(/-/g, ' ')) || q.includes(sName)) {
+        score += 15;
+        signals.keyword = true;
+      }
 
-    // Exact skill name in query
-    if (q.includes(sName.replace(/-/g, ' ')) || q.includes(sName)) {
-      score += 15;
-    }
+      // Token matches in skill name
+      for (const token of queryTokens) {
+        if (sName === token) {
+          score += 12;
+          signals.keyword = true;
+        } else if (sName.includes(token)) {
+          score += 6;
+          signals.keyword = true;
+        }
 
-    // Token matches in skill name
-    for (const token of queryTokens) {
-      if (sName === token) {
-        score += 12;
-      } else if (sName.includes(token)) {
-        score += 6;
-      }
+        // Trigger matches
+        if (skill.triggers.some(tr => tr.includes(token))) {
+          score += 8;
+          signals.concept = true;
+        }
 
-      // Trigger matches
-      if (skill.triggers.some(tr => tr.includes(token))) {
-        score += 8;
+        // Description token match (exact word boundary)
+        const wordRegex = new RegExp(`\\b${token}\\b`, 'i');
+        if (wordRegex.test(sDesc)) {
+          score += 3;
+          signals.semantic = true;
+        }
       }
 
-      // Description token match (exact word boundary)
-      const wordRegex = new RegExp(`\\b${token}\\b`, 'i');
-      if (wordRegex.test(sDesc)) {
-        score += 3;
+      // Failure mode signal boost
+      if (failureSkills.has(skill.name)) {
+        score += 10;
+        signals.domain = true;
       }
     }
 
-    // Failure mode signal boost
-    if (failureSkills.has(skill.name)) {
-      score += 10;
-    }
-
-    if (score >= 4) {
+    if (score >= 4 || rejected) {
       let state = 'OPTIONAL';
-      if (score >= 12) {
+      if (score >= 12 || isExplicit) {
         state = 'MANDATORY';
       } else if (score >= 6) {
         state = 'RECOMMENDED';
       }
 
-      scored.push({
-        skill: skill.name,
+      routingDecision.candidates.push({
+        skillId: skill.name,
         score,
-        state,
-        domain: skill.domain,
-        description: skill.description,
+        signals,
+        matched: !rejected,
+        rejected,
+        rejectionReason,
       });
+
+      if (!rejected) {
+        scored.push({
+          skill: skill.name,
+          score,
+          state,
+          domain: skill.domain,
+          description: skill.description,
+        });
+      }
     }
   }
 
@@ -447,6 +462,12 @@ function discoverSkills(taskQuery, agentDir) {
     return orderA - orderB;
   });
 
+  routingDecision.selected = pipelineCandidates.map(p => ({
+    skillId: p.skill,
+    score: p.score,
+    confidence: p.state,
+  }));
+
   return {
     query: taskQuery,
     totalDiscovered: scored.length,
@@ -454,6 +475,7 @@ function discoverSkills(taskQuery, agentDir) {
     recommended: scored.filter(s => s.state === 'RECOMMENDED'),
     optional: scored.filter(s => s.state === 'OPTIONAL'),
     pipeline: pipeline.map(p => p.skill),
+    routingDecision,
   };
 }
 
@@ -602,7 +624,7 @@ function analyzeTask(taskQuery, agentDir, options = {}) {
     }
   }
 
-  const discoveredSkills = discoverSkills(taskQuery, agentDir);
+  const discoveredSkills = discoverSkills(taskQuery, agentDir, options);
   const allSkills = loadAllSkills(agentDir);
   const coverageData = evaluateCoverage(conceptData, discoveredSkills, allSkills);
 
@@ -716,44 +738,6 @@ function analyzeTask(taskQuery, agentDir, options = {}) {
     }
   }
 
-  // Phase 9: Cross-Domain Engineering Intelligence
-  const crossDomainAnalysis = runCrossDomainAnalysis(taskQuery, conceptData, options);
-
-  // Integrate cross-domain validation requirements into verification plan
-  if (!crossDomainAnalysis.skipped) {
-    for (const vr of crossDomainAnalysis.validation_requirements || []) {
-      if (!verificationPlan.some(v => v.test === vr.test)) {
-        verificationPlan.push({
-          target: vr.source,
-          test: vr.test,
-          action: `[CROSS-DOMAIN VERIFICATION] ${vr.reason}`,
-          status: 'pending',
-        });
-      }
-    }
-  }
-
-  // Phase 10: Engineering Outcome Optimization
-  const outcomeOptimization = runOutcomeOptimization(taskQuery, {
-    conceptData,
-    considerationsData: considerations,
-    crossDomainAnalysis,
-    preMortem,
-    options,
-  });
-
-  // Integrate Phase 10 validation requirements into verification plan
-  for (const vr of outcomeOptimization.validation_requirements || []) {
-    if (!verificationPlan.some(v => v.test === vr.test)) {
-      verificationPlan.push({
-        target: vr.source,
-        test: vr.test,
-        action: `[OUTCOME OPTIMIZATION VERIFICATION] ${vr.reason}`,
-        status: 'pending',
-      });
-    }
-  }
-
   return {
     task: {
       query: taskQuery,
@@ -789,36 +773,11 @@ function analyzeTask(taskQuery, agentDir, options = {}) {
     unsupported_claims: unsupportedClaims,
     simulation_plan: preMortem.simulation_plan,
     phase6_metrics: phase6Tracker.getMetrics(),
-    // Phase 9: Cross-Domain Engineering Intelligence
-    cross_domain_analysis: crossDomainAnalysis.skipped
-      ? null
-      : {
-          interactions: crossDomainAnalysis.interactions,
-          second_order_effects: crossDomainAnalysis.second_order_effects,
-          failure_propagation: crossDomainAnalysis.failure_propagation,
-          resource_contention: crossDomainAnalysis.resource_contention,
-          security_boundaries: crossDomainAnalysis.security_boundaries,
-          constraint_conflicts: crossDomainAnalysis.constraint_conflicts,
-          emergent_failures: crossDomainAnalysis.emergent_failures,
-          tradeoff_graph: crossDomainAnalysis.tradeoffs,
-          blind_spots: crossDomainAnalysis.blind_spots,
-          validation_requirements: crossDomainAnalysis.validation_requirements,
-          summary: crossDomainAnalysis.summary,
-        },
-    phase9_metrics: crossDomainAnalysis.phase9_metrics || null,
-    // Phase 10: Engineering Outcome Optimization
-    outcome_optimization: outcomeOptimization,
-    outcome_requirements: outcomeOptimization.requirements,
-    engineering_options: outcomeOptimization.engineering_options,
-    decision_records: outcomeOptimization.decision_records,
-    solution_shape: outcomeOptimization.solution_shape,
-    early_validations: outcomeOptimization.early_validations,
-    anti_slop_audit: outcomeOptimization.architecture_audit,
-    phase10_metrics: outcomeOptimization.phase10_metrics,
     risks: considerations.risks,
     failure_modes: considerations.failure_modes,
     quality_attributes: considerations.quality_attributes,
     skills: skillsList,
+    routing_decision: discoveredSkills.routingDecision,
     coverage: coverageData.coverage_matrix,
     coverage_summary: {
       full: coverageData.full.length,
@@ -1334,36 +1293,6 @@ module.exports = {
   comparePredictionsWithObserved,
   Phase6MetricsTracker,
   getPhase6MetricsTracker,
-  // Phase 9: Cross-Domain Engineering Intelligence
-  RELATIONSHIP_TYPES,
-  INTERACTION_PRIORITY,
-  INTERACTION_CONFIDENCE,
-  runCrossDomainAnalysis,
-  Phase9MetricsTracker,
-  getPhase9MetricsTracker,
-  // Phase 10: Engineering Outcome Optimization Engine
-  OUTCOME_INVARIANT,
-  REQUIREMENT_SOURCES,
-  REQUIREMENT_CATEGORIES,
-  COMPLEXITY_BUDGETS,
-  ASSUMPTION_STATUS,
-  CAPABILITY_DEPTH,
-  REASONING_DEPTH,
-  discoverRequirements,
-  evaluateComplexityBudget,
-  auditArchitectureJustification,
-  generateDecisionRecords,
-  analyzeAssumptionsAndUnknowns,
-  buildSolutionShape,
-  verifyOutcomeAndRegressions,
-  runOutcomeOptimization,
-  evaluateSkillSelection,
-  Phase10OutcomeMemory,
-  getPhase10OutcomeMemory,
-  runAntiShortcutCheck,
-  runAntiOverengineeringCheck,
-  Phase10MetricsTracker,
-  getPhase10MetricsTracker,
 };
 
 if (require.main === module) {

package/.agent/scripts/skill_observation_engine.js

@@ -0,0 +1,25 @@
+const crypto = require('crypto');
+
+function hashObservation(obs) {
+  return crypto.createHash('sha256').update(JSON.stringify(obs)).digest('hex');
+}
+
+function observeExecution(skillId, fixture, mockOutputs = {}) {
+  const obs = {
+    observation_id: `OBS-${Date.now()}`,
+    skill_id: skillId,
+    execution_id: `EXEC-${Date.now()}`,
+    outputs: mockOutputs,
+    filesystem_diff: [], // empty for mock
+    exit_code: 0,
+    timestamp: new Date().toISOString(),
+  };
+
+  obs.sha256 = hashObservation(obs);
+  return obs;
+}
+
+module.exports = {
+  observeExecution,
+  hashObservation,
+};

package/.agent/scripts/skill_ontology_engine.js

@@ -0,0 +1,83 @@
+const fs = require('fs');
+const path = require('path');
+
+let ontologyCache = null;
+
+function loadOntology() {
+  if (ontologyCache) return ontologyCache;
+  const filePath = path.join(__dirname, '../data/skill_ontology.json');
+  if (!fs.existsSync(filePath)) return { skills: {} };
+
+  const raw = fs.readFileSync(filePath, 'utf8');
+  ontologyCache = JSON.parse(raw);
+  return ontologyCache;
+}
+
+function validateOntology(ontology) {
+  const errors = [];
+  const skills = ontology.skills;
+
+  for (const [skillId, node] of Object.entries(skills)) {
+    // Self-parenting
+    if (node.parents && node.parents.includes(skillId)) {
+      errors.push(`Self-parenting detected for ${skillId}`);
+    }
+
+    // Check missing skill IDs & reverse connections
+    if (node.parents) {
+      for (const parent of node.parents) {
+        if (!skills[parent]) {
+          errors.push(`Missing parent skill ID ${parent} for ${skillId}`);
+        } else if (skills[parent].parents && skills[parent].parents.includes(skillId)) {
+          errors.push(`Cycle detected between ${skillId} and ${parent}`);
+        }
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+function getHierarchyCompatibility(predictedSkill, expectedSkill) {
+  const ontology = loadOntology();
+  if (predictedSkill === expectedSkill) return 'EXACT';
+
+  const predictedNode = ontology.skills[predictedSkill];
+  const expectedNode = ontology.skills[expectedSkill];
+
+  if (!predictedNode && !expectedNode) return 'WRONG';
+
+  // Specific-child: The predicted skill specializes the expected skill.
+  // E.g. expected = frontend-design, predicted = landing-page
+  if (predictedNode && predictedNode.parents && predictedNode.parents.includes(expectedSkill)) {
+    return 'SPECIFIC_CHILD';
+  }
+
+  // Parent-fallback: The predicted skill generalizes the expected skill.
+  // E.g. expected = landing-page, predicted = frontend-design
+  if (predictedNode && predictedNode.children && predictedNode.children.includes(expectedSkill)) {
+    return 'PARENT_FALLBACK';
+  }
+
+  return 'WRONG';
+}
+
+function getSpecificity(skillName) {
+  const ontology = loadOntology();
+  const node = ontology.skills[skillName];
+  if (!node) return 0; // Baseline for unknown skills
+
+  let depth = 1;
+  // If it has parents, it's deeper.
+  if (node.parents && node.parents.length > 0) depth += 1;
+  if (node.children && node.children.length === 0) depth += 1; // Leaf nodes are more specific
+
+  return depth;
+}
+
+module.exports = {
+  loadOntology,
+  validateOntology,
+  getHierarchyCompatibility,
+  getSpecificity,
+};