tribunal-kit 9.2.4 → 9.2.6

package/src/commands/init.js

@@ -0,0 +1,462 @@
+'use strict';
+const __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.cmdInit = cmdInit;
+exports.generateIDEBridges = generateIDEBridges;
+const fs_1 = __importDefault(require('fs'));
+const path_1 = __importDefault(require('path'));
+const logger_1 = require('../utils/logger');
+const fs_2 = require('../utils/fs');
+const helpers_1 = require('../utils/helpers');
+const hasher_1 = require('../utils/hasher');
+const { ActionTree } = require('../tui');
+// Core agents to install in --minimal mode
+const CORE_AGENTS = new Set([
+  'backend-specialist.md',
+  'frontend-specialist.md',
+  'database-architect.md',
+  'debugger.md',
+  'security-auditor.md',
+  'logic-reviewer.md',
+  'dependency-reviewer.md',
+  'type-safety-reviewer.md',
+  'performance-reviewer.md',
+  'orchestrator.md',
+  'explorer-agent.md',
+  'project-planner.md',
+  'test-engineer.md',
+  'ui-ux-auditor.md',
+  'ui-visual-auditor.md',
+  'accessibility-reviewer.md',
+  'ux-reviewer.md',
+  'visual-reviewer.md',
+  'interaction-reviewer.md',
+  'anti-pattern-reviewer.md',
+  'product-reviewer.md',
+]);
+// Core skills to install in --minimal mode
+const CORE_SKILLS = new Set([
+  'clean-code',
+  'architecture',
+  'testing-patterns',
+  'systematic-debugging',
+  'frontend-design',
+  'database-design',
+  'api-patterns',
+  'nodejs-best-practices',
+  'vulnerability-scanner',
+  'typescript-advanced',
+  'python-pro',
+  'nextjs-react-expert',
+  'react-specialist',
+  'performance-profiling',
+  'lint-and-validate',
+  'ui-ux-pro-max',
+  'ui-reasoning-engine',
+  'product-aware-heuristics',
+  'web-design-guidelines',
+]);
+async function cmdInit(flags, quiet = false) {
+  const agentSrc = (0, helpers_1.getKitAgent)();
+  const targetDir = flags.path ? path_1.default.resolve(flags.path) : process.cwd();
+  const agentDest = path_1.default.join(targetDir, '.agent');
+  const dryRun = flags.dryRun || false;
+  const pkgStr = fs_1.default.readFileSync(
+    path_1.default.resolve(__dirname, '../../package.json'),
+    'utf8',
+  );
+  const pkg = JSON.parse(pkgStr);
+  // ── Self-install guard ──────────────────────────────────
+  if ((0, fs_2.isSelfInstall)(targetDir, pkg.name, path_1.default.resolve(__dirname, '../..'))) {
+    (0, logger_1.err)('Cannot run init/update inside the tribunal-kit package itself.');
+    (0, logger_1.err)(`Target: ${targetDir}`);
+    (0, logger_1.err)(`Package: ${path_1.default.resolve(__dirname, '../..')}`);
+    console.log();
+    (0, logger_1.dim)('This command is designed to install .agent/ into OTHER projects.');
+    (0, logger_1.dim)('Run it from the root of the project you want to set up:');
+    (0, logger_1.dim)('  cd /path/to/your-project');
+    (0, logger_1.dim)('  npx tribunal-kit init');
+    console.log();
+    process.exit(1);
+  }
+  // ────────────────────────────────────────────────────────
+  let diff = null;
+  let incremental = false;
+
+  if (!dryRun && fs_1.default.existsSync(agentDest) && flags.force) {
+    const oldManifest = (0, hasher_1.readManifest)(agentDest);
+    if (oldManifest) {
+      const newManifest = await (0, hasher_1.generateManifest)(agentSrc);
+      diff = (0, hasher_1.diffManifests)(oldManifest, newManifest);
+      incremental = true;
+
+      const addCount = diff.added.length;
+      const changeCount = diff.changed.length;
+      const removeCount = diff.removed.length;
+
+      (0, logger_1.log)(
+        `  ${(0, logger_1.c)('cyan', '↻')} ${(0, logger_1.bold)('Performing incremental update...')}`,
+      );
+
+      const addedPart = `${(0, logger_1.c)('green', `[+ ${addCount}]`)} added`;
+      const changedPart = `${(0, logger_1.c)('yellow', `[~ ${changeCount}]`)} changed`;
+      const removedPart = `${(0, logger_1.c)('red', `[- ${removeCount}]`)} removed`;
+      (0, logger_1.log)(`    ${addedPart}   ${changedPart}   ${removedPart}`);
+
+      const totalChanges = addCount + changeCount + removeCount;
+      if (totalChanges > 0) {
+        const maxBarWidth = 30;
+        const addPct = Math.round((addCount / totalChanges) * maxBarWidth);
+        const changePct = Math.round((changeCount / totalChanges) * maxBarWidth);
+        const removePct = Math.max(0, maxBarWidth - addPct - changePct);
+
+        const bar =
+          (0, logger_1.c)('green', '█'.repeat(addPct)) +
+          (0, logger_1.c)('yellow', '█'.repeat(changePct)) +
+          (0, logger_1.c)('red', '█'.repeat(removePct));
+
+        (0, logger_1.log)(`    Syncing: [${bar}] ${totalChanges} files`);
+      }
+
+      // Backup ONLY changed or removed files
+      const toBackup = [...diff.changed, ...diff.removed];
+      if (toBackup.length > 0) {
+        const backupDir = path_1.default.join(agentDest, '.backups', `backup-${Date.now()}`);
+        fs_1.default.mkdirSync(backupDir, { recursive: true });
+        let backedUpCount = 0;
+        for (const file of toBackup) {
+          const srcPath = path_1.default.join(agentDest, file);
+          const destPath = path_1.default.join(backupDir, file);
+          if (fs_1.default.existsSync(srcPath)) {
+            fs_1.default.mkdirSync(path_1.default.dirname(destPath), { recursive: true });
+            fs_1.default.copyFileSync(srcPath, destPath);
+            backedUpCount++;
+          }
+        }
+        (0, logger_1.log)(
+          `  ${(0, logger_1.c)('gray', '✦')} Backed up ${backedUpCount} modified/removed files ${(0, logger_1.c)('gray', '→')} ${(0, logger_1.c)('gray', '.agent/.backups/')}`,
+        );
+      }
+
+      // Remove removed files
+      for (const file of diff.removed) {
+        const target = path_1.default.join(agentDest, file);
+        if (fs_1.default.existsSync(target)) {
+          fs_1.default.rmSync(target);
+        }
+      }
+    } else {
+      // Legacy full backup
+      const backupDir = path_1.default.join(agentDest, '.backups', `backup-${Date.now()}`);
+      fs_1.default.mkdirSync(backupDir, { recursive: true });
+      const subdirs = ['agents', 'workflows', 'skills', 'scripts', '.shared', 'rules'];
+      for (const sub of subdirs) {
+        const subPath = path_1.default.join(agentDest, sub);
+        if (fs_1.default.existsSync(subPath)) {
+          await (0, fs_2.copyDir)(subPath, path_1.default.join(backupDir, sub), false);
+          await fs_1.default.promises.rm(subPath, { recursive: true, force: true });
+        }
+      }
+      (0, logger_1.log)(
+        `  ${(0, logger_1.c)('gray', '✦')} Backed up existing configurations ${(0, logger_1.c)('gray', '→')} ${(0, logger_1.c)('gray', '.agent/.backups/')}`,
+      );
+    }
+  }
+  // ────────────────────────────────────────────────────────
+  (0, helpers_1.banner)(quiet);
+  if (dryRun) {
+    (0, logger_1.log)((0, logger_1.colorize)('yellow', '  DRY RUN — no files will be written'));
+    console.log();
+  }
+  // Check target exists
+  if (!fs_1.default.existsSync(targetDir)) {
+    (0, logger_1.err)(`Target directory not found: ${targetDir}`);
+    process.exit(1);
+  }
+  // Check if .agent already exists
+  if (fs_1.default.existsSync(agentDest) && !flags.force) {
+    (0, logger_1.warn)('.agent/ already exists in this project.');
+    (0, logger_1.log)(
+      `  ${(0, logger_1.c)('gray', '▸')} To refresh or update it, run: ${(0, logger_1.colorize)('white', 'tribunal-kit init --force')}`,
+    );
+    (0, logger_1.log)(
+      `  ${(0, logger_1.c)('gray', '▸')} Or check status with:    ${(0, logger_1.colorize)('cyan', 'tribunal-kit status')}`,
+    );
+    console.log();
+    process.exit(0);
+  }
+  // Ensure history dirs exist (Case Law + Skill Evolution)
+  if (!dryRun) {
+    const caseDir = path_1.default.join(agentDest, 'history', 'case-law', 'cases');
+    const evoDir = path_1.default.join(agentDest, 'history', 'skill-evolution');
+    fs_1.default.mkdirSync(caseDir, { recursive: true });
+    fs_1.default.mkdirSync(evoDir, { recursive: true });
+    const gkCase = path_1.default.join(caseDir, '.gitkeep');
+    const gkEvo = path_1.default.join(evoDir, '.gitkeep');
+    if (!fs_1.default.existsSync(gkCase)) fs_1.default.writeFileSync(gkCase, '');
+    if (!fs_1.default.existsSync(gkEvo)) fs_1.default.writeFileSync(gkEvo, '');
+  }
+  // Count what we're installing
+  const isMinimal = flags.minimal || false;
+  if (isMinimal) {
+    (0, logger_1.log)(
+      `  ${(0, logger_1.c)('yellow', '⚡')} ${(0, logger_1.bold)('Minimal mode')} — installing core agents and skills only`,
+    );
+    console.log();
+  }
+  const totalFiles = await (0, fs_2.countDir)(agentSrc);
+  (0, logger_1.dbg)(`Source: ${agentSrc}`);
+  (0, logger_1.dbg)(`Target: ${agentDest}`);
+  (0, logger_1.dbg)(`Total source files: ${totalFiles}`);
+  (0, logger_1.log)(
+    `  ${(0, logger_1.c)('gray', '▸')} Scanning ${(0, logger_1.c)('white', String(totalFiles))} files  ${(0, logger_1.c)('gray', '→')}  ${(0, logger_1.c)('gray', agentDest)}`,
+  );
+  try {
+    // Build filter for --minimal mode
+    let filterFunc = isMinimal
+      ? (name, parentDir, isDir) => {
+          if (isDir) return true; // always traverse directories
+          const parentName = path_1.default.basename(parentDir);
+          if (parentName === 'agents') return CORE_AGENTS.has(name);
+          if (parentName === 'skills') return CORE_SKILLS.has(name);
+          return true; // everything else passes
+        }
+      : null;
+
+    if (incremental && diff) {
+      const addedSet = new Set(diff.added);
+      const changedSet = new Set(diff.changed);
+      const baseFilter = filterFunc;
+      filterFunc = (name, parentDir, isDir) => {
+        if (isDir) return true;
+        if (baseFilter && !baseFilter(name, parentDir, isDir)) return false;
+
+        const relativePath = path_1.default
+          .relative(agentSrc, path_1.default.join(parentDir, name))
+          .replace(/\\/g, '/');
+        return addedSet.has(relativePath) || changedSet.has(relativePath);
+      };
+    }
+
+    const copied = await (0, fs_2.copyDir)(agentSrc, agentDest, dryRun, filterFunc);
+    // Generate and save hash manifest for incremental future updates
+    if (!dryRun) {
+      try {
+        const manifest = await (0, hasher_1.generateManifest)(agentSrc);
+        (0, hasher_1.writeManifest)(agentDest, manifest);
+        (0, logger_1.dbg)(`  Manifest saved: ${Object.keys(manifest).length} files hashed`);
+      } catch (e) {
+        (0, logger_1.dbg)(`  Manifest generation skipped: ${e.message}`);
+      }
+    }
+    console.log();
+    if (dryRun) {
+      (0, logger_1.ok)(
+        `${(0, logger_1.bold)('DRY RUN')} complete — would install ${(0, logger_1.c)('cyan', String(copied))} files`,
+      );
+      (0, logger_1.dim)(`Target: ${agentDest}`);
+    } else {
+      const agentsCount = fs_1.default.readdirSync(path_1.default.join(agentDest, 'agents')).length;
+      const workflowsCount = fs_1.default.readdirSync(
+        path_1.default.join(agentDest, 'workflows'),
+      ).length;
+      const skillsCount = fs_1.default.readdirSync(path_1.default.join(agentDest, 'skills')).length;
+      const scriptsCount = fs_1.default.readdirSync(
+        path_1.default.join(agentDest, 'scripts'),
+      ).length;
+
+      const tree = new ActionTree();
+      await tree.action('Establishing Anti-Hallucination Barrier', agentDest);
+      await tree.branch(`${agentsCount} Core Specialists active in registry`);
+      await tree.branch(`${skillsCount} Agentic Skills mapped via lazy routing`);
+      await tree.branch(
+        `${workflowsCount} Workflows & ${scriptsCount} Enforcement scripts installed`,
+      );
+      await tree.action('Synthesizing IDE Bridges');
+      await generateIDEBridges(targetDir, agentDest, dryRun, isMinimal);
+      await scaffoldDesignSystem(targetDir, agentSrc, dryRun);
+      tree.complete(`Tribunal-Kit v${pkg.version} initialized successfully at ${targetDir}`);
+    }
+    console.log();
+  } catch (e) {
+    if (e instanceof Error) {
+      (0, logger_1.err)(`Failed to install: ${e.message}`);
+    } else {
+      (0, logger_1.err)(`Failed to install: ${String(e)}`);
+    }
+    process.exit(1);
+  }
+}
+async function generateIDEBridges(targetDir, agentDest, dryRun = false, isMinimal = false) {
+  const rulesFilename = isMinimal ? 'kernel.md' : 'GEMINI.md';
+  const rulesFile = path_1.default.join(agentDest, 'rules', rulesFilename);
+  let rulesContent = '';
+  try {
+    rulesContent = await fs_1.default.promises.readFile(rulesFile, 'utf8');
+  } catch {
+    // rules file doesn't exist
+  }
+  // Bridge files consume the high-density kernel rules to save tokens, falling back to GEMINI.md
+  const kernelFile = path_1.default.join(agentDest, 'rules', 'kernel.md');
+  let bridgeRulesContent = '';
+  let bridgeSource = rulesFilename;
+  try {
+    bridgeRulesContent = await fs_1.default.promises.readFile(kernelFile, 'utf8');
+    bridgeSource = 'kernel.md';
+  } catch {
+    bridgeRulesContent = rulesContent;
+  }
+  if (!bridgeRulesContent) {
+    bridgeRulesContent = rulesContent;
+  }
+  // Helper: write a bridge file only if it doesn't already exist
+  const writeBridge = async (filePath, content, label) => {
+    if (dryRun) {
+      (0, logger_1.dbg)(`  would create: ${filePath}`);
+      return;
+    }
+    const dir = path_1.default.dirname(filePath);
+    try {
+      await fs_1.default.promises.mkdir(dir, { recursive: true });
+      await fs_1.default.promises.stat(filePath);
+      (0, logger_1.dbg)(`  skip (exists): ${path_1.default.basename(filePath)}`);
+    } catch (statErr) {
+      if (statErr instanceof Error && statErr.code === 'ENOENT') {
+        await fs_1.default.promises.writeFile(filePath, content, 'utf8');
+        (0, logger_1.ok)(
+          `${label} → ${(0, logger_1.c)('gray', path_1.default.relative(targetDir, filePath))}`,
+        );
+      }
+    }
+  };
+  // ── 1. Cursor (.cursorrules) ──────────────────────────
+  const cursorRules = `# Tribunal Kit — Cursor Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/${bridgeSource}
+
+${bridgeRulesContent}
+`;
+  // ── 2. Windsurf (.windsurfrules) ─────────────────────
+  const windsurfRules = `# Tribunal Kit — Windsurf Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/${bridgeSource}
+
+${bridgeRulesContent}
+`;
+  // ── 3. Gemini / Antigravity (.gemini/settings.json) ──
+  const geminiSettings =
+    JSON.stringify(
+      {
+        rules: [{ path: `../.agent/rules/${rulesFilename}`, trigger: 'always_on' }],
+        agents: { directory: '../.agent/agents' },
+        skills: { directory: '../.agent/skills' },
+        workflows: { directory: '../.agent/workflows' },
+      },
+      null,
+      2,
+    ) + '\n';
+  // ── Also create .gemini/GEMINI.md as a direct rules file ──
+  const geminiRulesBridge = `---
+trigger: always_on
+---
+
+# Tribunal Kit — Gemini Bridge
+# Auto-generated by tribunal-kit init.
+# Full rules: .agent/rules/${rulesFilename}
+
+${bridgeRulesContent}
+`;
+  // ── 4. GitHub Copilot (.github/copilot-instructions.md) ──
+  const copilotInstructions = `# Tribunal Kit — Copilot Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/${bridgeSource}
+
+${bridgeRulesContent}
+`;
+  // ── 5. Claude (.claude/CLAUDE.md & CLAUDE.md) ───────
+  const claudeRules = `# Tribunal Kit — Claude Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/${bridgeSource}
+
+${bridgeRulesContent}
+`;
+  // ── 6. Codex & Universal Agents (AGENTS.md) ──────────
+  const codexRules = `# Tribunal Kit — Codex Bridge
+# Auto-generated by tribunal-kit init. Do not edit manually.
+# Source: .agent/rules/${bridgeSource}
+
+${bridgeRulesContent}
+`;
+  // Fire ALL bridge writes concurrently via Promise.all
+  const bridges = [
+    { path: path_1.default.join(targetDir, '.cursorrules'), content: cursorRules, label: 'Cursor' },
+    {
+      path: path_1.default.join(targetDir, '.windsurfrules'),
+      content: windsurfRules,
+      label: 'Windsurf',
+    },
+    {
+      path: path_1.default.join(targetDir, '.gemini', 'settings.json'),
+      content: geminiSettings,
+      label: 'Gemini/Antigravity',
+    },
+    {
+      path: path_1.default.join(targetDir, '.gemini', 'GEMINI.md'),
+      content: geminiRulesBridge,
+      label: 'Gemini rules',
+    },
+    {
+      path: path_1.default.join(targetDir, '.github', 'copilot-instructions.md'),
+      content: copilotInstructions,
+      label: 'GitHub Copilot',
+    },
+    {
+      path: path_1.default.join(targetDir, '.claude', 'CLAUDE.md'),
+      content: claudeRules,
+      label: 'Claude',
+    },
+    {
+      path: path_1.default.join(targetDir, 'CLAUDE.md'),
+      content: claudeRules,
+      label: 'Claude root',
+    },
+    {
+      path: path_1.default.join(targetDir, 'AGENTS.md'),
+      content: codexRules,
+      label: 'Codex / Multi-Agent',
+    },
+  ];
+  await Promise.all(bridges.map(b => writeBridge(b.path, b.content, b.label)));
+  console.log();
+}
+async function scaffoldDesignSystem(targetDir, agentSrc, dryRun = false) {
+  const designMdSrc = path_1.default.join(agentSrc, 'templates', 'DESIGN.md');
+  const designTokensSrc = path_1.default.join(agentSrc, 'templates', 'design-tokens.json');
+  const designMdDest = path_1.default.join(targetDir, 'DESIGN.md');
+  const designTokensDest = path_1.default.join(targetDir, 'design-tokens.json');
+
+  const copyIfMissing = async (src, dest, label) => {
+    if (!fs_1.default.existsSync(src)) return;
+    if (fs_1.default.existsSync(dest)) {
+      (0, logger_1.dbg)(`  skip (exists): ${path_1.default.basename(dest)}`);
+      return;
+    }
+    if (dryRun) {
+      (0, logger_1.dbg)(`  would create: ${dest}`);
+      return;
+    }
+    await fs_1.default.promises.copyFile(src, dest);
+    (0, logger_1.ok)(
+      `${label} → ${(0, logger_1.c)('gray', path_1.default.relative(targetDir, dest))}`,
+    );
+  };
+
+  await copyIfMissing(designMdSrc, designMdDest, 'DESIGN.md System');
+  await copyIfMissing(designTokensSrc, designTokensDest, 'Design Tokens');
+}
+exports.CORE_AGENTS = CORE_AGENTS;
+exports.CORE_SKILLS = CORE_SKILLS;

package/src/commands/learn.js

@@ -0,0 +1,195 @@
+'use strict';
+const __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.cmdLearn = cmdLearn;
+const fs_1 = __importDefault(require('fs'));
+const path_1 = __importDefault(require('path'));
+const logger_1 = require('../utils/logger');
+const helpers_1 = require('../utils/helpers');
+const {
+  loadEvolutionProposals,
+  approveEvolutionProposal,
+  rejectEvolutionProposal,
+} = require('../evolution/engine');
+
+async function cmdLearn(flags, quiet = false) {
+  const targetDir = flags.path ? path_1.default.resolve(flags.path) : process.cwd();
+  const agentDest = path_1.default.join(targetDir, '.agent');
+  if (!fs_1.default.existsSync(agentDest)) {
+    (0, logger_1.err)('.agent/ not found. Run: npx tribunal-kit init');
+    process.exit(1);
+  }
+
+  // Handle explicit proposal actions
+  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}]`);
+      return;
+    } catch (e) {
+      (0, logger_1.err)(`Failed to approve proposal: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  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)}`);
+      return;
+    } catch (e) {
+      (0, logger_1.err)(`Failed to reject proposal: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  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.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})`);
+        (0, logger_1.dim)(`    Evidence: ${p.observed_evidence}`);
+        (0, logger_1.dim)(`    Change:   ${p.proposed_change}`);
+      }
+    }
+    (0, logger_1.log)('');
+    return;
+  }
+
+  (0, helpers_1.banner)(quiet);
+  const W = 62;
+  const title = '  Tribunal Learn — Supreme Court Mode';
+  const trail = ' '.repeat(Math.max(0, W - title.length));
+  console.log(`  ${(0, logger_1.c)('cyan', '\u2554' + '\u2550'.repeat(W) + '\u2557')}`);
+  console.log(
+    `  ${(0, logger_1.c)('cyan', '\u2551')}${(0, logger_1.bold)((0, logger_1.c)('white', title))}${trail}${(0, logger_1.c)('cyan', '\u2551')}`,
+  );
+  console.log(`  ${(0, logger_1.c)('cyan', '\u255a' + '\u2550'.repeat(W) + '\u255d')}`);
+  console.log();
+  const dryRun = flags.dryRun ? '--dry-run' : '';
+  const useHead = flags.head ? '--head' : '';
+
+  // Phase 1: Skill Evolution & Proposal Governance
+  (0, logger_1.log)(
+    `  ${(0, logger_1.c)('cyan', '\u229b')} ${(0, logger_1.bold)('Phase 1')} \u2014 Skill Evolution Forge & Governance Proposals`,
+  );
+  const existingProposals = loadEvolutionProposals(agentDest);
+  const pending = existingProposals.filter(p => p.status === 'PROPOSED');
+  if (pending.length > 0) {
+    (0, logger_1.log)(
+      `    ${(0, logger_1.c)('yellow', '⚠')} ${pending.length} pending evolution proposal(s) awaiting Human Gate approval (run: tk learn --status)`,
+    );
+  }
+  const evoScript = path_1.default.join(agentDest, 'scripts', 'skill_evolution.js');
+  if (!fs_1.default.existsSync(evoScript)) {
+    (0, logger_1.warn)('skill_evolution.js not found \u2014 run: npx tribunal-kit update');
+  } else {
+    try {
+      const args = [evoScript, 'digest'];
+      if (dryRun) args.push('--dry-run');
+      if (useHead) args.push('--head');
+      await (0, helpers_1.runShellAsync)('node', args, { stdio: 'inherit', cwd: targetDir });
+    } catch (e) {
+      if (e instanceof Error) {
+        (0, logger_1.warn)(`Skill Evolution error: ${e.message}`);
+      } else {
+        (0, logger_1.warn)(`Skill Evolution error: ${String(e)}`);
+      }
+    }
+  }
+  console.log();
+  // Phase 2: Case Law prompt
+  (0, logger_1.log)(
+    `  ${(0, logger_1.c)('cyan', '\u229b')} ${(0, logger_1.bold)('Phase 2')} \u2014 Case Law Engine (building precedence record)`,
+  );
+  console.log();
+  (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '\u25b8')} Record a new rejection precedent:`);
+  (0, logger_1.log)(`    ${(0, logger_1.c)('white', 'npx tribunal-kit case add')}`);
+  console.log();
+  (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '\u25b8')} Search existing case law:`);
+  (0, logger_1.log)(`    ${(0, logger_1.c)('white', 'npx tribunal-kit case search "your query"')}`);
+  console.log();
+  // Phase 3: Memory Distillation
+  (0, logger_1.log)(
+    `  ${(0, logger_1.c)('cyan', '\u229b')} ${(0, logger_1.bold)('Phase 3')} \u2014 Memory Distillation (storing project knowledge)`,
+  );
+  try {
+    const { _memoryStore } = require('./memory');
+    // Auto-extract SEMANTIC memories from project-idioms if it exists
+    const idiomsPath = path_1.default.join(agentDest, 'skills', 'project-idioms', 'SKILL.md');
+    let memoriesStored = 0;
+    if (fs_1.default.existsSync(idiomsPath)) {
+      const idiomsContent = fs_1.default.readFileSync(idiomsPath, 'utf8');
+      // Extract lines that look like project rules (lines starting with - or * that contain actionable content)
+      const ruleLines = idiomsContent
+        .split('\n')
+        .filter(line => /^[\s]*[-*]\s+/.test(line) && line.trim().length > 20)
+        .map(line => line.replace(/^[\s]*[-*]\s+/, '').trim())
+        .slice(0, 10); // Cap at 10 to prevent bloat
+
+      for (const rule of ruleLines) {
+        try {
+          _memoryStore(agentDest, 'semantic', rule, ['project-idiom', 'auto-learned'], null);
+          memoriesStored++;
+        } catch {
+          // Skip duplicates or capacity errors silently
+        }
+      }
+    }
+    // Auto-extract PROCEDURAL memories from package.json scripts
+    const pkgPath = path_1.default.join(targetDir, 'package.json');
+    if (fs_1.default.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+        if (pkg.scripts) {
+          const importantScripts = ['build', 'test', 'dev', 'start', 'deploy', 'lint'];
+          for (const key of importantScripts) {
+            if (pkg.scripts[key]) {
+              try {
+                _memoryStore(
+                  agentDest,
+                  'procedural',
+                  `Run \`${pkg.scripts[key]}\` to ${key} the project`,
+                  ['build-script', key, 'auto-learned'],
+                  null,
+                );
+                memoriesStored++;
+              } catch {
+                // Skip
+              }
+            }
+          }
+        }
+      } catch {
+        // Unreadable package.json
+      }
+    }
+    if (memoriesStored > 0) {
+      (0, logger_1.log)(
+        `    ${(0, logger_1.c)('green', '\u2714')} ${memoriesStored} memories auto-stored (semantic + procedural)`,
+      );
+    } else {
+      (0, logger_1.log)(
+        `    ${(0, logger_1.c)('gray', '\u25b8')} No new memories to distill (run again after committing changes)`,
+      );
+    }
+  } catch (e) {
+    (0, logger_1.log)(
+      `    ${(0, logger_1.c)('yellow', '\u26a0')} Memory distillation skipped: ${e.message || String(e)}`,
+    );
+  }
+  console.log();
+  (0, logger_1.log)(
+    `  ${(0, logger_1.c)('green', '\u2714')} ${(0, logger_1.bold)('Learn cycle complete.')} Your Tribunal grows smarter with every commit.`,
+  );
+  console.log();
+}