tribunal-kit 9.2.6 → 9.2.8

package/src/commands/intelligence.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Commands for Tribunal Intelligence (Phase 7U)
+ */
+const { CaseMemory } = require('../intelligence/case_memory');
+const { CaseIndexer } = require('../intelligence/case_indexer');
+const { CaseSimilarity } = require('../intelligence/case_similarity');
+const { FailureIntelligence } = require('../intelligence/failure_intelligence');
+const { RiskPredictionEngine } = require('../intelligence/risk_prediction_engine');
+const { CaseBasedReasoningEngine } = require('../intelligence/cbr_engine');
+const { ReviewerPerformance } = require('../intelligence/reviewer_performance');
+const { GovernanceDriftDetector } = require('../intelligence/governance_drift_detector');
+const { GovernanceSimulator } = require('../intelligence/governance_simulator');
+
+function output(json, readableStr) {
+  if (process.env.JSON_OUTPUT === '1') {
+    console.log(JSON.stringify(json, null, 2));
+  } else {
+    console.log(readableStr);
+  }
+}
+
+async function cmdIntelligence(subcommand, argsArray) {
+  const mem = new CaseMemory();
+  const idx = new CaseIndexer();
+
+  switch (subcommand) {
+    case 'cases': {
+      // Output format supports human readable and JSON
+      const out = '';
+      const allIds = Array.from(idx.listCaseIds());
+      output(allIds, `Total cases stored: ${allIds.length}`);
+      break;
+    }
+    case 'case': {
+      const id = argsArray[0];
+      if (!id) return console.error('Missing ID');
+      const data = mem.getCase(id);
+      output(data, JSON.stringify(data, null, 2));
+      break;
+    }
+    case 'failures': {
+      const fi = new FailureIntelligence({ memory: mem, indexer: idx });
+      // Stub generic invocation
+      const val = argsArray[0];
+      const pattern = fi.detectFailurePattern('FILE', val || 'UNKNOWN');
+      output(pattern, JSON.stringify(pattern, null, 2));
+      break;
+    }
+    case 'reviewer-stats': {
+      const rp = new ReviewerPerformance({ memory: mem, indexer: idx });
+      const name = argsArray[0];
+      if (!name) return console.error('Missing reviewer name');
+      const stats = rp.getReviewerStats(name);
+      output(stats, JSON.stringify(stats, null, 2));
+      break;
+    }
+    case 'governance-drift': {
+      const gdd = new GovernanceDriftDetector({ memory: mem, indexer: idx });
+      const drift = gdd.detectDrift();
+      output(drift, JSON.stringify(drift, null, 2));
+      break;
+    }
+    case 'simulate-policy': {
+      const sim = new GovernanceSimulator({ memory: mem, indexer: idx });
+      // Quick hardcoded policy test
+      const result = sim.simulatePolicy({ maxReviewers: 1 });
+      output(result, JSON.stringify(result, null, 2));
+      break;
+    }
+    case 'review-plan': {
+      const cbr = new CaseBasedReasoningEngine();
+      const file = argsArray[0] || 'src/index.js';
+      const plan = cbr.generateReviewPlan({ files: [file], impactTier: 2, task: 'Test plan' });
+      output(plan, JSON.stringify(plan, null, 2));
+      break;
+    }
+    default:
+      console.log(
+        'Available commands: cases, case, failures, reviewer-stats, governance-drift, simulate-policy, review-plan',
+      );
+  }
+}
+
+module.exports = { cmdIntelligence };

package/src/commands/learn.js

@@ -28,7 +28,10 @@ async function cmdLearn(flags, quiet = false) {
   if (flags.approve) {
     try {
       const p = approveEvolutionProposal(String(flags.approve), 'Human Developer', agentDest);
-      if (!quiet) (0, logger_1.log)(`  ${(0, logger_1.c)('green', '✓')} Approved evolution proposal: ${(0, logger_1.bold)(p.proposal_id)} [${p.target}]`);
+      if (!quiet)
+        (0, logger_1.log)(
+          `  ${(0, logger_1.c)('green', '✓')} Approved evolution proposal: ${(0, logger_1.bold)(p.proposal_id)} [${p.target}]`,
+        );
       return;
     } catch (e) {
       (0, logger_1.err)(`Failed to approve proposal: ${e.message}`);
@@ -38,8 +41,15 @@ async function cmdLearn(flags, quiet = false) {
 
   if (flags.reject) {
     try {
-      const p = rejectEvolutionProposal(String(flags.reject), flags.reason || 'Rejected by developer', agentDest);
-      if (!quiet) (0, logger_1.log)(`  ${(0, logger_1.c)('yellow', '✓')} Rejected evolution proposal: ${(0, logger_1.bold)(p.proposal_id)}`);
+      const p = rejectEvolutionProposal(
+        String(flags.reject),
+        flags.reason || 'Rejected by developer',
+        agentDest,
+      );
+      if (!quiet)
+        (0, logger_1.log)(
+          `  ${(0, logger_1.c)('yellow', '✓')} Rejected evolution proposal: ${(0, logger_1.bold)(p.proposal_id)}`,
+        );
       return;
     } catch (e) {
       (0, logger_1.err)(`Failed to reject proposal: ${e.message}`);
@@ -49,14 +59,19 @@ async function cmdLearn(flags, quiet = false) {
 
   if (flags.status || flags.proposals) {
     const proposals = loadEvolutionProposals(agentDest);
-    (0, logger_1.log)(`\n  ${(0, logger_1.bold)('Tribunal Evolution Proposals')} (${proposals.length} total)`);
+    (0, logger_1.log)(
+      `\n  ${(0, logger_1.bold)('Tribunal Evolution Proposals')} (${proposals.length} total)`,
+    );
     (0, logger_1.dim)('  ──────────────────────────────────────────────────');
     if (proposals.length === 0) {
       (0, logger_1.dim)('  No evolution proposals recorded yet.');
     } else {
       for (const p of proposals) {
-        const color = p.status === 'APPROVED' ? 'green' : p.status === 'REJECTED' ? 'red' : 'yellow';
-        (0, logger_1.log)(`  ${(0, logger_1.c)(color, `[${p.status}]`)} ${(0, logger_1.bold)(p.proposal_id)} — Target: ${(0, logger_1.c)('cyan', p.target)} (Risk: ${p.risk})`);
+        const color =
+          p.status === 'APPROVED' ? 'green' : p.status === 'REJECTED' ? 'red' : 'yellow';
+        (0, logger_1.log)(
+          `  ${(0, logger_1.c)(color, `[${p.status}]`)} ${(0, logger_1.bold)(p.proposal_id)} — Target: ${(0, logger_1.c)('cyan', p.target)} (Risk: ${p.risk})`,
+        );
         (0, logger_1.dim)(`    Evidence: ${p.observed_evidence}`);
         (0, logger_1.dim)(`    Change:   ${p.proposed_change}`);
       }

package/src/commands/memory.js

@@ -210,12 +210,21 @@ function memoryStore(agentDest, type, content, tags, sessionId) {
 
 // ── Recall ──────────────────────────────────────────────────────────────────
 
-function memoryRecall(agentDest, query, budget = 2000) {
+function memoryRecall(agentDest, query, budget = 2000, options = {}) {
   const lockPath = acquireLock(agentDest);
   try {
     const index = loadIndex(agentDest);
+    const targetSessionId = options && typeof options === 'object' ? options.sessionId : null;
 
     const scored = index.entries
+      .filter(entry => {
+        if (entry.memory_type === 'working') {
+          if (entry.session_id) {
+            if (!targetSessionId || entry.session_id !== targetSessionId) return false;
+          }
+        }
+        return true;
+      })
       .map(entry => ({ entry, score: computeScore(entry, query) }))
       .filter(s => s.score > 0)
       .sort((a, b) => b.score - a.score);

package/src/commands/native.js

@@ -252,9 +252,15 @@ function resolveMonotonicImpactTier(options = {}) {
   const files = Array.isArray(rawFiles)
     ? rawFiles.filter(Boolean)
     : typeof rawFiles === 'string' && rawFiles.length > 0
-      ? rawFiles.split(',').map(f => f.trim()).filter(Boolean)
+      ? rawFiles
+          .split(',')
+          .map(f => f.trim())
+          .filter(Boolean)
       : [];
-  const lines = typeof opts.lines === 'number' && !isNaN(opts.lines) ? opts.lines : parseInt(opts.lines, 10) || 0;
+  const lines =
+    typeof opts.lines === 'number' && !isNaN(opts.lines)
+      ? opts.lines
+      : parseInt(opts.lines, 10) || 0;
   const task = typeof opts.task === 'string' ? opts.task : '';
   const diff = typeof opts.diff === 'string' ? opts.diff : '';
   const layaTier = opts.layaTier;
@@ -283,7 +289,10 @@ function resolveMonotonicImpactTier(options = {}) {
   const secretOrExecPatterns =
     /(?:-----BEGIN [A-Z ]+KEY-----|eyJ[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+|(?:api[_-]?key|secret|password|bearer|auth[_-]?token)\s*[:=]\s*['"][^'"]{6,}['"])/i;
 
-  const diffHasCode = /^\+[ \t]*(?:const|let|var|function|def|import|require|class|export|db\.|SELECT|UPDATE|DELETE|INSERT|jwt\.|auth\.)/mi.test(diff);
+  const diffHasCode =
+    /^\+[ \t]*(?:const|let|var|function|def|import|require|class|export|db\.|SELECT|UPDATE|DELETE|INSERT|jwt\.|auth\.)/im.test(
+      diff,
+    );
   const diffMatchesHighRiskCode = diffHasCode && HIGH_RISK_PATTERNS.test(diff);
 
   const diffHasHighRisk =

package/src/commands/review.js

@@ -1,6 +1,8 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.cmdReview = cmdReview;
+exports.FIXTURES = null;
+exports.REVIEWER_CONFIGS = null;
 
 /**
  * tk review — EXPERIMENTAL Reviewer Execution Harness
@@ -26,6 +28,10 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 const { log, err, ok, c, bold } = require('../utils/logger');
+const { ReviewExecutor } = require('../execution/review_executor');
+const { VerdictAggregator } = require('../execution/verdict_aggregator');
+const { ProviderAdapter } = require('../execution/provider_adapter');
+const { evaluateDecision } = require('../system1/decision_engine');
 
 // ─── LLM CLIENT (EXPERIMENTAL ONLY) ─────────────────────────────────────────
 
@@ -634,7 +640,8 @@ function analyzeRuns(runFiles) {
 // ─── CLI COMMAND ─────────────────────────────────────────────────────────────
 
 async function cmdReview(flags, argv, quiet) {
-  const args = argv.slice(2);
+  const rawArgv = Array.isArray(argv) ? argv : process.argv;
+  const args = rawArgv.slice(2);
 
   // Parse review-specific args
   let configKey = null;
@@ -644,10 +651,39 @@ async function cmdReview(flags, argv, quiet) {
   let analyzeFiles = [];
   let listFixtures = false;
   let outputDir = '.tk-review-runs';
+  let modePlan = false;
+  let modeExecute = false;
+  let outputJson = false;
+  let isMock = false;
+  let reviewersArg = null;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === 'review') continue;
+    if (arg === '--plan') {
+      modePlan = true;
+      continue;
+    }
+    if (arg === '--execute') {
+      modeExecute = true;
+      continue;
+    }
+    if (arg === '--json') {
+      outputJson = true;
+      continue;
+    }
+    if (arg === '--mock') {
+      isMock = true;
+      continue;
+    }
+    if (arg === '--reviewers' && args[i + 1]) {
+      reviewersArg = args[++i];
+      continue;
+    }
+    if (arg.startsWith('--reviewers=')) {
+      reviewersArg = arg.split('=')[1];
+      continue;
+    }
     if (arg === '--config' && args[i + 1]) {
       configKey = args[++i].toUpperCase();
       continue;
@@ -702,6 +738,201 @@ async function cmdReview(flags, argv, quiet) {
     }
   }
 
+  // Handle Phase 1 Governance: --plan or --execute
+  if (modePlan || modeExecute) {
+    let customDiff = '';
+    let files = [];
+    let task = taskDesc || '';
+
+    if (fixtureId) {
+      const fixture = FIXTURES[fixtureId];
+      if (!fixture) {
+        err(`Unknown fixture: ${fixtureId}. Use tk review --list to see available fixtures.`);
+        process.exit(1);
+      }
+      task = taskDesc || fixture.task;
+      customDiff = fixture.diff;
+      files = fixture.files || [];
+    } else if (diffPath) {
+      if (!fs.existsSync(diffPath)) {
+        err(`Diff file not found: ${diffPath}`);
+        process.exit(1);
+      }
+      customDiff = fs.readFileSync(diffPath, 'utf8');
+      task = taskDesc || 'Review proposed code change';
+      const extracted = [];
+      for (const line of customDiff.split('\n')) {
+        if (line.startsWith('+++ b/')) {
+          extracted.push(line.slice(6).trim());
+        } else if (line.startsWith('+++ ') && !line.startsWith('+++ /dev/null')) {
+          extracted.push(line.slice(4).trim());
+        }
+      }
+      files = extracted.length > 0 ? extracted : ['src/unknown'];
+    } else {
+      err('Missing required change input. Provide --fixture <name> or --diff <path>');
+      log(`  ${c('gray', 'Example: tk review --plan --fixture mfa-implementation')}`);
+      log(`  ${c('gray', 'Example: tk review --execute --fixture mfa-implementation --mock')}`);
+      process.exit(1);
+    }
+
+    // 1. Run deterministic decision engine
+    const decision = evaluateDecision({
+      task,
+      diff: customDiff,
+      files,
+    });
+
+    const forcedReviewers = reviewersArg
+      ? reviewersArg
+          .split(',')
+          .map(s => s.trim())
+          .filter(Boolean)
+      : null;
+
+    const selectedReviewers = forcedReviewers ||
+      decision.reviewers?.selected?.map(r =>
+        typeof r === 'string' ? r : r.reviewer || r.name,
+      ) || ['security-auditor', 'logic-reviewer'];
+
+    // 2. Mode: PLAN
+    if (modePlan) {
+      if (outputJson) {
+        console.log(
+          JSON.stringify(
+            {
+              mode: 'plan',
+              decision_id: decision.decision_id,
+              tier: decision.tier,
+              tier_name: decision.tier_name,
+              routing: decision.routing,
+              socratic_gate: decision.socratic_gate,
+              selected_reviewers: selectedReviewers,
+              signals: decision.signals,
+              evidence_summary: decision.evidence_summary,
+              explanation: decision.explanation,
+              timestamp: new Date().toISOString(),
+            },
+            null,
+            2,
+          ),
+        );
+      } else {
+        log('');
+        log(bold('  ⚖️  Tribunal Review Plan'));
+        log(`  ${c('gray', '─'.repeat(50))}`);
+        log(`  Decision Tier:   ${c('cyan', `Tier ${decision.tier} (${decision.tier_name})`)}`);
+        log(`  Routing:         ${c('cyan', decision.routing)}`);
+        log(`  Socratic Gate:   ${c('cyan', decision.socratic_gate)}`);
+        log(`  Selected Reviewers:`);
+        for (const r of selectedReviewers) {
+          log(`    ${c('green', '✓')} ${r}`);
+        }
+        log(`  ${c('gray', '─'.repeat(50))}`);
+        log(
+          `  Signals:         ${decision.signals?.change_files_count || files.length} file(s), ${decision.signals?.change_lines || 0} line(s)`,
+        );
+        log(
+          `  Evidence:        ${decision.evidence_summary?.total_selected || 0} fact(s) selected`,
+        );
+        log(
+          `  Reason:          ${decision.explanation?.why_tier_selected || 'Classified by volume and risk patterns.'}`,
+        );
+        log('');
+      }
+      return;
+    }
+
+    // 3. Mode: EXECUTE
+    if (modeExecute) {
+      const provider = new ProviderAdapter({ provider: isMock ? 'mock' : undefined });
+      const executor = new ReviewExecutor({
+        provider,
+        maxConcurrency: 3,
+        timeoutMs: 30000,
+      });
+
+      const execRes = await executor.executeReview({
+        decision,
+        code: customDiff,
+        task,
+        reviewers: selectedReviewers,
+      });
+
+      const aggregated = VerdictAggregator.aggregate({
+        results: execRes.results,
+        decision,
+        tier: decision.tier,
+        reviewRunId: execRes.reviewRunId,
+      });
+
+      if (outputJson) {
+        console.log(
+          JSON.stringify(
+            {
+              mode: 'execute',
+              reviewRunId: execRes.reviewRunId,
+              decision_id: decision.decision_id,
+              tier: decision.tier,
+              tier_name: decision.tier_name,
+              reviewers: selectedReviewers,
+              execution: {
+                duration_ms: execRes.durationMs,
+                telemetry: execRes.telemetry,
+                results: execRes.results,
+              },
+              aggregated,
+            },
+            null,
+            2,
+          ),
+        );
+      } else {
+        log('');
+        log(bold('  Tribunal Review'));
+        log('');
+        log(bold('  Decision:'));
+        log(`  Tier: Tier ${decision.tier} (${decision.tier_name})`);
+        log('');
+        log(bold('  Reviewers:'));
+        for (const r of aggregated.reviewersExecuted) {
+          log(`  ${c('green', '✓')} ${r}`);
+        }
+        log('');
+        log(bold('  Execution:'));
+        log(`  ${execRes.results.length} reviewer(s)`);
+        log(`  ${(execRes.durationMs / 1000).toFixed(2)}s`);
+        log(
+          `  ${execRes.telemetry.totalTokens !== 'UNAVAILABLE' ? execRes.telemetry.totalTokens.toLocaleString() + ' tokens' : 'Tokens: UNAVAILABLE'}`,
+        );
+        log('');
+        log(bold('  Findings:'));
+        log(`  ${aggregated.findingsCount.critical} Critical`);
+        log(`  ${aggregated.findingsCount.high} High`);
+        log(`  ${aggregated.findingsCount.medium} Medium`);
+        log(`  ${aggregated.findingsCount.low} Low`);
+        log('');
+        log(bold('  Final Verdict:'));
+        const verdictColor =
+          aggregated.verdict === 'APPROVED'
+            ? 'green'
+            : aggregated.verdict === 'WARNING'
+              ? 'yellow'
+              : 'red';
+        log(`  ${c(verdictColor, bold(aggregated.verdict))}`);
+        log('');
+        log(bold('  Reason:'));
+        log(`  ${aggregated.reason}`);
+        log('');
+      }
+
+      if (aggregated.verdict === 'REJECTED') {
+        process.exitCode = 1;
+      }
+      return;
+    }
+  }
+
   // Run all live mode
   if (argv.runAllLive) {
     log(bold('Running ALL fixtures live (A, B, C)...'));
@@ -969,3 +1200,6 @@ async function runLiveExecution(configKey, fixtureId, outputDir) {
 
   return true;
 }
+
+exports.FIXTURES = FIXTURES;
+exports.REVIEWER_CONFIGS = REVIEWER_CONFIGS;