tribunal-kit 9.2.7 → 9.2.8

package/src/intelligence/governance_simulator.js

@@ -0,0 +1,115 @@
+'use strict';
+
+/**
+ * governance_simulator.js — Tribunal Intelligence: Simulator
+ * ============================================================================
+ * Phase 7P / 7Q / 7R implementation.
+ *
+ * Runs candidate policies against the historical dataset to verify they do not
+ * reduce safety parameters, generating structural PolicyProposals.
+ */
+
+const { CaseIndexer } = require('./case_indexer');
+const { CaseMemory } = require('./case_memory');
+
+class GovernanceSimulator {
+  constructor(options = {}) {
+    this.indexer = options.indexer || new CaseIndexer(options);
+    this.memory = options.memory || new CaseMemory(options);
+  }
+
+  /**
+   * Simulates a candidate policy against historical data.
+   *
+   * @param {Object} candidatePolicy Contains rule overrides (e.g., maxReviewers: 2)
+   * @returns {Object} Simulation metrics comparing baseline vs candidate
+   */
+  simulatePolicy(candidatePolicy) {
+    const allCases = Object.keys(this.indexer.index.cases || {}).map(id => this.memory.getCase(id));
+    if (allCases.length === 0) {
+      throw new Error('No historical cases available for simulation.');
+    }
+
+    const baseline = {
+      tokenCost: 0,
+      rejections: 0,
+      approvals: 0,
+    };
+
+    const candidate = {
+      tokenCost: 0,
+      rejections: 0, // In a full implementation, we'd replay the exact conditions
+      approvals: 0,
+      safetyDegradation: false,
+    };
+
+    for (const c of allCases) {
+      if (!c) continue;
+
+      // Baseline
+      if (c.finalVerdict === 'RESOLVED') baseline.approvals++;
+      else if (c.finalVerdict === 'REJECTED') baseline.rejections++;
+      const trCost = (c.tokenUsage || {}).input + (c.tokenUsage || {}).output || 0;
+      baseline.tokenCost += trCost;
+
+      // Simulation proxy logic - e.g. capping reviewers
+      let candidateCaseCost = trCost;
+      if (candidatePolicy.maxReviewers) {
+        const actualRCount = (c.selectedReviewers || []).length;
+        if (actualRCount > candidatePolicy.maxReviewers) {
+          candidateCaseCost = Math.floor(trCost * (candidatePolicy.maxReviewers / actualRCount));
+
+          // Did pruning this reviewer prune someone who found a critical issue?
+          const rejectedByPruned = (c.reviewResults || []).some((res, idx) => {
+            return idx >= candidatePolicy.maxReviewers && res.status === 'REJECTED';
+          });
+
+          if (rejectedByPruned && c.finalVerdict === 'REJECTED') {
+            // Optimization would have caused a false approval!
+            candidate.safetyDegradation = true;
+            candidate.approvals++;
+          } else if (c.finalVerdict === 'REJECTED') {
+            candidate.rejections++;
+          } else {
+            candidate.approvals++;
+          }
+        } else {
+          if (c.finalVerdict === 'RESOLVED') candidate.approvals++;
+          else if (c.finalVerdict === 'REJECTED') candidate.rejections++;
+        }
+      }
+
+      candidate.tokenCost += candidateCaseCost;
+    }
+
+    return {
+      casesSimulated: allCases.length,
+      baseline,
+      candidate,
+    };
+  }
+
+  /**
+   * Generates a structural policy proposal based on a successful simulation
+   */
+  proposePolicy(policyObj, simulationResult) {
+    if (simulationResult.candidate.safetyDegradation) {
+      throw new Error(
+        'Will not generate proposal: Simulation indicates safety degradation (e.g. false approvals).',
+      );
+    }
+
+    const tokensSaved = simulationResult.baseline.tokenCost - simulationResult.candidate.tokenCost;
+
+    return {
+      proposalId: `PROP-${Date.now()}`,
+      policy: policyObj,
+      evidence: `Simulated across ${simulationResult.casesSimulated} cases.`,
+      projectedSavings: `${tokensSaved} tokens`,
+      safetyRisk: 'No mandatory safety reduction detected in historical replay.',
+      status: 'PENDING_HUMAN_APPROVAL',
+    };
+  }
+}
+
+module.exports = { GovernanceSimulator };

package/src/intelligence/human_intelligence.js

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * human_intelligence.js — Tribunal Intelligence: Human-in-the-Loop
+ * ============================================================================
+ * Phase 7N implementation.
+ *
+ * Tracks human overrides of Tribunal decisions. Ensures that human override
+ * DOES NOT equate to an automatic policy rewrite.
+ */
+
+const { CaseMemory } = require('./case_memory');
+
+class HumanIntelligence {
+  constructor(options = {}) {
+    this.memory = options.memory || new CaseMemory(options);
+    this.overrides = [];
+  }
+
+  /**
+   * Records a human overriding a deterministic tribunal decision.
+   */
+  recordOverride(caseId, originalVerdict, finalVerdict, reason) {
+    if (!caseId || !originalVerdict || !finalVerdict || !reason) {
+      throw new Error('Missing require params for human override.');
+    }
+
+    const overrideRecord = {
+      overrideId: `OVR-${Date.now()}`,
+      timestamp: new Date().toISOString(),
+      caseId,
+      originalTribunalVerdict: originalVerdict,
+      humanDecision: finalVerdict,
+      reason,
+      status: 'PENDING_POLICY_ANALYSIS',
+    };
+
+    this.overrides.push(overrideRecord);
+
+    // In a real system, this would write to `.agent/intelligence/overrides/`
+    // For this step, we'll keep it simple or hook into a write function.
+    return overrideRecord;
+  }
+}
+
+module.exports = { HumanIntelligence };

package/src/intelligence/mcp_tools.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * mcp_tools.js — Tribunal Intelligence: MCP Layer
+ * ============================================================================
+ * Phase 7T implementation.
+ */
+
+const { CaseMemory } = require('./case_memory');
+const { CaseIndexer } = require('./case_indexer');
+const { CaseBasedReasoningEngine } = require('./cbr_engine');
+
+const TOOLS = [
+  {
+    name: 'tribunal_search_cases',
+    description: 'Search historical cases by tier, files, or categories.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: { type: 'array', items: { type: 'string' } },
+        impactTier: { type: 'number' },
+      },
+    },
+  },
+  {
+    name: 'tribunal_get_case',
+    description: 'Retrieve full case structured data.',
+    inputSchema: {
+      type: 'object',
+      properties: { caseId: { type: 'string' } },
+      required: ['caseId'],
+    },
+  },
+  {
+    name: 'tribunal_generate_review_plan',
+    description: 'Generate an intelligence-driven review plan.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        files: { type: 'array', items: { type: 'string' } },
+        impactTier: { type: 'number' },
+      },
+    },
+  },
+];
+
+class IntelligenceMCPHandler {
+  constructor() {
+    this.cbr = new CaseBasedReasoningEngine();
+    this.mem = new CaseMemory();
+    this.idx = new CaseIndexer();
+  }
+
+  getToolDefinitions() {
+    return TOOLS;
+  }
+
+  async callTool(name, args) {
+    switch (name) {
+      case 'tribunal_search_cases': {
+        return {
+          content: [
+            { type: 'text', text: JSON.stringify(this.cbr.similarity.findSimilar(args), null, 2) },
+          ],
+        };
+      }
+      case 'tribunal_get_case': {
+        const caseRecord = this.mem.getCase(args.caseId);
+        return {
+          content: [
+            { type: 'text', text: JSON.stringify(caseRecord || { error: 'Not found' }, null, 2) },
+          ],
+        };
+      }
+      case 'tribunal_generate_review_plan': {
+        const plan = this.cbr.generateReviewPlan(args);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(plan, null, 2) }],
+        };
+      }
+      default:
+        throw new Error(`Unknown intelligence tool: ${name}`);
+    }
+  }
+}
+
+module.exports = { IntelligenceMCPHandler, TOOLS };

package/src/intelligence/reviewer_performance.js

@@ -0,0 +1,94 @@
+'use strict';
+
+/**
+ * reviewer_performance.js — Tribunal Intelligence: Reviewer Performance Model
+ * ============================================================================
+ * Phase 7G implementation.
+ *
+ * Tracks reviewer effectiveness dynamically without reducing it to simple
+ * approval rates. Evaluates usefulness against independently verified outcomes
+ * and regressions.
+ */
+
+const { CaseIndexer } = require('./case_indexer');
+const { CaseMemory } = require('./case_memory');
+
+class ReviewerPerformance {
+  constructor(options = {}) {
+    this.indexer = options.indexer || new CaseIndexer(options);
+    this.memory = options.memory || new CaseMemory(options);
+  }
+
+  /**
+   * Calculates comprehensive reviewer performance statistics.
+   *
+   * Metrics:
+   * - Participation count
+   * - Final agreement (did their verdict match the finalized case outcome)
+   * - False Acceptances (they approved, but a regression occurred later)
+   * - False Rejections (they blocked excessively on cases that ultimately required no structure changes)
+   *
+   * @param {string} reviewerName
+   * @returns {Object} Structured metrics
+   */
+  getReviewerStats(reviewerName) {
+    const caseIds = this.indexer.index.byReviewer[reviewerName];
+    if (!caseIds || caseIds.size === 0) {
+      return {
+        reviewer: reviewerName,
+        participationCount: 0,
+        reliabilityScore: null,
+        falseAcceptances: 0,
+        regressionsMissed: 0,
+      };
+    }
+
+    let participationCount = 0;
+    let agreementCount = 0;
+    let regressionsMissed = 0;
+
+    for (const caseId of caseIds) {
+      const caseRecord = this.memory.getCase(caseId);
+      if (!caseRecord) continue;
+
+      participationCount++;
+
+      // Find this reviewer's verdict in the case
+      const revResult = (caseRecord.reviewResults || []).find(r => r.reviewer === reviewerName);
+      if (revResult) {
+        const reviewerApproved = revResult.status === 'APPROVED';
+        const finalApproved = caseRecord.finalVerdict === 'RESOLVED';
+
+        if (reviewerApproved === finalApproved) {
+          agreementCount++;
+        }
+
+        // Did they approve, but it resulted in a regression case logging against this file?
+        const hasRegressions = caseRecord.regressions && caseRecord.regressions.length > 0;
+        if (reviewerApproved && hasRegressions) {
+          regressionsMissed++;
+        }
+      }
+    }
+
+    const agreementRate = participationCount > 0 ? agreementCount / participationCount : 0;
+
+    // Reliability penalizes missed regressions heavily.
+    // Base agreement is good, but letting a bug slip through is the primary failure mode.
+    const missPenalty = participationCount > 0 ? (regressionsMissed / participationCount) * 1.5 : 0;
+    let reliabilityScore = Math.max(0, agreementRate - missPenalty);
+
+    // Cap max
+    reliabilityScore = Math.min(1.0, reliabilityScore);
+
+    return {
+      reviewer: reviewerName,
+      participationCount,
+      agreementRate,
+      regressionsMissed,
+      reliabilityScore,
+    };
+  }
+}
+
+module.exports = { ReviewerPerformance };

package/src/intelligence/risk_prediction_engine.js

@@ -0,0 +1,92 @@
+'use strict';
+
+/**
+ * risk_prediction_engine.js — Tribunal Intelligence: Predictive Risk
+ * ============================================================================
+ * Phase 7J implementation.
+ *
+ * Models probability of rejection, regression, and correction failure.
+ * Predictions are explicitly ADVISORY.
+ */
+
+const { CaseIndexer } = require('./case_indexer');
+const { CaseMemory } = require('./case_memory');
+
+class RiskPredictionEngine {
+  constructor(options = {}) {
+    this.indexer = options.indexer || new CaseIndexer(options);
+    this.memory = options.memory || new CaseMemory(options);
+  }
+
+  /**
+   * Generates a structural risk prediction report based on similar cases.
+   *
+   * @param {Array} similarCases Output from CaseSimilarity.findSimilar
+   * @returns {Object} Prediction report containing probabilities and historical basis
+   */
+  predictRisk(similarCases) {
+    if (!similarCases || similarCases.length === 0) {
+      return {
+        probabilityOfRejection: 'UNKNOWN',
+        probabilityOfRegression: 'UNKNOWN',
+        probabilityOfCorrectionFailure: 'UNKNOWN',
+        expectedVerificationCost: 'UNKNOWN',
+        advisoryMessage: 'Insufficient historical data to generate predictions.',
+        basis: { similarCaseCount: 0 },
+      };
+    }
+
+    let rejectionCount = 0;
+    let regressionCount = 0;
+    let correctionFailureCount = 0;
+    let totalTokens = 0;
+
+    const analyzedCount = similarCases.length;
+
+    for (const simCase of similarCases) {
+      const caseRecord = this.memory.getCase(simCase.caseId);
+      if (!caseRecord) continue;
+
+      if (caseRecord.finalVerdict === 'REJECTED') rejectionCount++;
+      if (caseRecord.regressions && caseRecord.regressions.length > 0) regressionCount++;
+
+      const corrections = caseRecord.correctionAttempts || [];
+      if (corrections.length > 0) {
+        const lastCorrection = corrections[corrections.length - 1];
+        if (lastCorrection.status === 'FAILED') {
+          correctionFailureCount++;
+        }
+      }
+
+      const input = (caseRecord.tokenUsage || {}).input || 0;
+      const output = (caseRecord.tokenUsage || {}).output || 0;
+      totalTokens += input + output;
+    }
+
+    const rejectionProb = analyzedCount > 0 ? rejectionCount / analyzedCount : 0;
+    const regressionProb = analyzedCount > 0 ? regressionCount / analyzedCount : 0;
+    const correctionFailureProb = analyzedCount > 0 ? correctionFailureCount / analyzedCount : 0;
+    const avgCost = analyzedCount > 0 ? Math.round(totalTokens / analyzedCount) : 0;
+
+    return {
+      probabilityOfRejection: (rejectionProb * 100).toFixed(1) + '%',
+      probabilityOfRegression: (regressionProb * 100).toFixed(1) + '%',
+      probabilityOfCorrectionFailure: (correctionFailureProb * 100).toFixed(1) + '%',
+      expectedVerificationCost: avgCost > 0 ? `${avgCost} tokens` : 'UNKNOWN',
+      prediction: {
+        correctionDifficulty:
+          correctionFailureProb > 0.4 ? 'HIGH' : correctionFailureProb > 0.1 ? 'MEDIUM' : 'LOW',
+        regressionRisk: regressionProb > 0.3 ? 'HIGH' : regressionProb > 0.1 ? 'MEDIUM' : 'LOW',
+      },
+      advisoryMessage: `Based on ${analyzedCount} historical cases. This prediction must never directly approve a transaction.`,
+      basis: {
+        similarCaseCount: analyzedCount,
+        rejections: rejectionCount,
+        regressions: regressionCount,
+        correctionFailures: correctionFailureCount,
+      },
+    };
+  }
+}
+
+module.exports = { RiskPredictionEngine };

package/src/intelligence/token_intelligence.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/**
+ * token_intelligence.js — Tribunal Intelligence: Token Economics
+ * ============================================================================
+ * Phase 7I implementation.
+ *
+ * Tracks input/output tokens, cost per verified resolution, and identifies
+ * where context can be compressed safely.
+ */
+
+const { CaseMemory } = require('./case_memory');
+
+class TokenIntelligence {
+  constructor(options = {}) {
+    this.memory = options.memory || new CaseMemory(options);
+  }
+
+  /**
+   * Generates economics metadata for a completed case to be indexed.
+   */
+  calculateCaseEconomics(caseRecord) {
+    if (!caseRecord || !caseRecord.tokenUsage) return null;
+
+    const input = caseRecord.tokenUsage.input || 0;
+    const output = caseRecord.tokenUsage.output || 0;
+    const total = input + output;
+
+    const reviewerCount = (caseRecord.selectedReviewers || []).length;
+    const avgTokensPerReviewer = reviewerCount > 0 ? total / reviewerCount : 0;
+    const findingsCount = (caseRecord.reviewResults || []).reduce(
+      (acc, r) => acc + (r.findings ? r.findings.length : 0),
+      0,
+    );
+
+    const tokensPerFinding = findingsCount > 0 ? total / findingsCount : total;
+
+    return {
+      totalTokens: total,
+      avgTokensPerReviewer: Math.round(avgTokensPerReviewer),
+      tokensPerFinding: Math.round(tokensPerFinding),
+      correctionCount: (caseRecord.correctionAttempts || []).length,
+      efficiencyRating: total < 10000 ? 'EXCELLENT' : total < 30000 ? 'GOOD' : 'HEAVY',
+    };
+  }
+
+  /**
+   * Proposes a token budget given historical performance.
+   * "Optimization objective is: MINIMIZE TOKEN COST SUBJECT TO SAFETY >= CURRENT BASELINE"
+   */
+  proposeContextLimits(impactTier, reviewerCount, similarityConfidence) {
+    let maxTokens = 4000;
+
+    // High tier needs more context
+    if (impactTier === 3) maxTokens = 15000;
+    else if (impactTier === 2) maxTokens = 8000;
+
+    // If we are highly confident in our similarity match, we know exactly what evidence matters.
+    // We can compress the context boundary aggressively.
+    if (similarityConfidence === 'HIGH') {
+      maxTokens = Math.floor(maxTokens * 0.6); // 40% reduction
+    } else if (similarityConfidence === 'MEDIUM') {
+      maxTokens = Math.floor(maxTokens * 0.85); // 15% reduction
+    }
+
+    return {
+      recommendedTokenLimit: maxTokens,
+      projectedCostSavings: 4000 - maxTokens > 0 ? 4000 - maxTokens : 0,
+    };
+  }
+}
+
+module.exports = { TokenIntelligence };

package/src/tui/banner.js

@@ -1,74 +1,53 @@
 'use strict';
 
 /**
- * Minimalist framed header cards and status banners.
- * Parity with Brainless & Claude Code design tokens.
+ * Minimalist header cards and status banners.
+ * Redesigned for Pro-Max Aesthetic.
  */
 
-const { isTTY, hasColor, hasTrueColor, RGB, GLYPHS, color, bold, getColumns } = require('./theme');
+const { isTTY, hasColor, hasTrueColor, RGB, color, bold, dim, inverse, getColumns } = require('./theme');
 
-function renderBanner(version = '9.2.7', quiet = false) {
+function renderBanner(version = '9.2.8', quiet = false) {
   if (quiet) return;
   if (!isTTY && !hasColor) {
     console.error(`TRIBUNAL-KIT v${version} — Anti-Hallucination Governance Layer`);
     return;
   }
 
-  const g = GLYPHS;
   const cols = getColumns();
   const width = Math.min(84, Math.max(64, cols));
-  const innerWidth = width - 4;
 
-  const titleLeft = `🛡️  TRIBUNAL-KIT  v${version}`;
-  const rightPill = '[Fortress Mode · ⚡ Rust Core]';
-  const leftLen = titleLeft.length; // emojis and text
-  const rightLen = rightPill.length;
-
-  const spaces = innerWidth > leftLen + rightLen ? innerWidth - (leftLen + rightLen) : 2;
-
-  const borderTop = `  ${g.boxTl}${g.boxH.repeat(innerWidth + 2)}${g.boxTr}`;
-  const borderBottom = `  ${g.boxBl}${g.boxH.repeat(innerWidth + 2)}${g.boxBr}`;
-
-  const coloredBorderTop = color(RGB.SLATE_700, borderTop);
-  const coloredBorderBottom = color(RGB.SLATE_700, borderBottom);
-  const pipe = color(RGB.SLATE_700, g.boxV);
-
-  // Gradient title line
-  let boldTitle;
+  const titleText = ` TRIBUNAL-KIT `;
+  let styledTitle;
   if (hasTrueColor) {
-    let res = '🛡️  ';
-    const text = `TRIBUNAL-KIT  v${version}`;
-    const len = text.length;
-    for (let i = 0; i < len; i++) {
-      const ratio = i / len;
-      const r = 255;
-      const gVal = Math.floor(105 + ratio * 80);
-      const bVal = Math.floor(74 - ratio * 30);
-      res += `\x1b[38;2;${r};${gVal};${bVal}m\x1b[1m${text[i]}\x1b[0m`;
-    }
-    boldTitle = res;
+    styledTitle = `\x1b[48;2;${RGB.FLAME[0]};${RGB.FLAME[1]};${RGB.FLAME[2]}m\x1b[38;2;${RGB.PURE_WHITE[0]};${RGB.PURE_WHITE[1]};${RGB.PURE_WHITE[2]}m\x1b[1m${titleText}\x1b[0m`;
   } else {
-    boldTitle = bold(titleLeft);
+    styledTitle = inverse(bold(titleText));
   }
 
-  const coloredRightPill = color(RGB.ZINC_500, rightPill);
-  const subtitle = 'Autonomous Anti-Hallucination Governance Layer for AI Coding Agents';
-  const subSpaces = Math.max(0, innerWidth - subtitle.length);
-  const coloredSubtitle = color(RGB.ZINC_400, subtitle);
+  const versionTag = dim(`v${version}`);
+  const rightPill = dim('[Fortress Mode · Rust Core]');
+  const leftLen = titleText.length + versionTag.length - (hasTrueColor ? 0 : 0); 
+  
+  // Roughly calculate spaces
+  const spaces = Math.max(2, width - titleText.length - `v${version}`.length - '[Fortress Mode · Rust Core]'.length - 4);
+
+  const subtitle = 'Autonomous Anti-Hallucination Governance Layer';
+  const subtitleColored = color(RGB.ZINC_400, subtitle);
 
   console.log();
-  console.log(coloredBorderTop);
-  console.log(`  ${pipe} ${boldTitle}${' '.repeat(spaces)}${coloredRightPill} ${pipe}`);
-  console.log(`  ${pipe} ${coloredSubtitle}${' '.repeat(subSpaces)} ${pipe}`);
-  console.log(coloredBorderBottom);
+  console.log(`  ${styledTitle}  ${versionTag}${' '.repeat(spaces)}${rightPill}`);
+  console.log(`  ${subtitleColored}`);
   console.log();
 }
 
-function renderSectionHeader(title) {
-  const g = GLYPHS;
-  const prefix = color(RGB.FLAME, g.chevron);
-  const boldTitle = bold(title);
-  console.log(`  ${prefix} ${boldTitle}`);
+function renderSectionHeader(title, subtitle = '') {
+  const boldTitle = bold(color(RGB.WHITE, title));
+  if (subtitle) {
+    console.log(`\n  ${boldTitle}  ${dim(subtitle)}\n`);
+  } else {
+    console.log(`\n  ${boldTitle}\n`);
+  }
 }
 
 module.exports = {

package/src/tui/index.js

@@ -10,6 +10,8 @@ const tree = require('./tree');
 const shimmer = require('./shimmer');
 const reviewerGrid = require('./reviewer-grid');
 const wizard = require('./wizard');
+const panel = require('./panel');
+const progress = require('./progress');
 
 module.exports = {
   ...theme,
@@ -18,4 +20,6 @@ module.exports = {
   ...shimmer,
   ...reviewerGrid,
   ...wizard,
+  ...panel,
+  ...progress,
 };

package/src/tui/panel.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { isTTY, hasColor, RGB, GLYPHS, color, bold, dim, getColumns } = require('./theme');
+
+/**
+ * Render a bordered panel with an optional title and content.
+ * Follows the Pro-Max high-density aesthetic with subtle borders.
+ * 
+ * @param {string} title The title of the panel
+ * @param {string[]} lines Array of strings to render inside the panel
+ * @param {object} options
+ * @param {string} options.accessory Right-aligned text in the header
+ * @param {number} options.width Max width of the panel (defaults to terminal width or 100)
+ */
+function renderPanel(title, lines, options = {}) {
+  const g = GLYPHS;
+  const cols = getColumns();
+  const width = Math.min(options.width || 100, Math.max(64, cols));
+  const innerWidth = width - 4;
+
+  const topBorder = color(RGB.SLATE_700, g.boxTl + g.boxH.repeat(innerWidth + 2) + g.boxTr);
+  const bottomBorder = color(RGB.SLATE_700, g.boxBl + g.boxH.repeat(innerWidth + 2) + g.boxBr);
+  const pipe = color(RGB.SLATE_700, g.boxV);
+
+  console.log();
+
+  if (title) {
+    const boldTitle = bold(color(RGB.WHITE, title));
+    const accessory = options.accessory ? dim(options.accessory) : '';
+    // Strip ANSI codes to calculate actual text length for padding
+    const titleLen = title.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const accessoryLen = options.accessory ? options.accessory.replace(/\x1b\[[0-9;]*m/g, '').length : 0;
+    const spaceCount = Math.max(1, innerWidth - titleLen - accessoryLen);
+    
+    console.log(`  ${topBorder}`);
+    console.log(`  ${pipe} ${boldTitle}${' '.repeat(spaceCount)}${accessory} ${pipe}`);
+    console.log(`  ${color(RGB.SLATE_700, g.treeMid + g.boxH.repeat(innerWidth + 2) + '┤')}`);
+  } else {
+    console.log(`  ${topBorder}`);
+  }
+
+  lines.forEach(line => {
+    // Strip ANSI to find visual length
+    const visualLength = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = Math.max(0, innerWidth - visualLength + 1);
+    console.log(`  ${pipe} ${line}${' '.repeat(padding)}${pipe}`);
+  });
+
+  console.log(`  ${bottomBorder}`);
+  console.log();
+}
+
+module.exports = {
+  renderPanel,
+};