tribunal-kit 8.0.0 → 9.0.1

package/dist/commands/audit-web.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * cmdAuditWeb — Live Web Quality, Accessibility & Performance Auditor
+ *
+ * Usage:
+ *   tk audit-web https://example.com
+ *   tk audit-web http://localhost:3000 --json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { auditURL } = require('../browser');
+const { codifyAuditViolations } = require('../browser/case_bridge');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdAuditWeb(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url;
+
+  if (!url) {
+    console.error(`  ${c('red', '✖ Error:')} Missing target URL. Usage: tk audit-web <url>`);
+    process.exit(1);
+  }
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '🔍 Auditing Web Target:')} ${c('white', url)}...\n`);
+  }
+
+  try {
+    const report = await auditURL(url, flags);
+
+    let codified = null;
+    if (flags.codify || flags['codify-cases'] || flags.c) {
+      codified = codifyAuditViolations(report, flags);
+    }
+
+    if (flags.json) {
+      if (codified) {
+        report.codified = codified;
+      }
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+
+    if (flags.output) {
+      const outDir = path.resolve(flags.output);
+      fs.mkdirSync(outDir, { recursive: true });
+      fs.writeFileSync(path.join(outDir, 'audit-report.json'), JSON.stringify(report, null, 2));
+      console.log(`  ${c('gray', 'Report written to:')} ${path.join(outDir, 'audit-report.json')}`);
+    }
+
+    console.log(`  ${c('bold', 'Title:')} ${report.page.title || '(No title)'}`);
+    console.log(`  ${c('bold', 'Duration:')} ${report.durationMs}ms\n`);
+
+    // Scores
+    const a11yColor = report.scores.accessibility >= 80 ? 'green' : report.scores.accessibility >= 60 ? 'yellow' : 'red';
+    const secColor = report.scores.security >= 80 ? 'green' : report.scores.security >= 60 ? 'yellow' : 'red';
+
+    console.log(`  ${c('bold', 'Scores:')}`);
+    console.log(`    Accessibility:   ${c(a11yColor, `${report.scores.accessibility}/100`)}`);
+    console.log(`    Security Headers:${c(secColor, `${report.scores.security}/100`)}`);
+    console.log();
+
+    // Issues
+    if (report.violations.accessibility.length > 0) {
+      console.log(`  ${c('yellow', 'Accessibility Issues:')}`);
+      for (const iss of report.violations.accessibility) {
+        console.log(`    ${c('yellow', '⚠')} ${iss.message}`);
+      }
+      console.log();
+    }
+
+    if (report.violations.security.length > 0) {
+      console.log(`  ${c('yellow', 'Security Advisory:')}`);
+      for (const sec of report.violations.security) {
+        console.log(`    ${c('yellow', '⚠')} ${sec}`);
+      }
+      console.log();
+    }
+
+    if (report.violations.consoleErrors.length > 0) {
+      console.log(`  ${c('red', 'Console Errors:')}`);
+      for (const err of report.violations.consoleErrors) {
+        console.log(`    ${c('red', '✖')} [${err.level}] ${err.text}`);
+      }
+      console.log();
+    }
+
+    if (report.summary.passed) {
+      console.log(`  ${c('green', '✔ Web audit passed')} — Accessibility >= 80 and zero console errors.\n`);
+    } else {
+      console.log(`  ${c('yellow', '⚠ Web audit completed')} with ${report.summary.totalIssues} issue(s) identified.\n`);
+    }
+
+    if (codified) {
+      if (codified.codifiedCount > 0) {
+        console.log(`  ${c('green', '✔')} Case Law: Codified ${c('bold', String(codified.codifiedCount))} violation(s) into binding precedents in ${c('cyan', '.agent/history/case-law/')}.\n`);
+      } else {
+        console.log(`  ${c('gray', 'ℹ')} Case Law: No new violations to codify (or all matches already exist in precedents).\n`);
+      }
+    }
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Audit failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdAuditWeb,
+};

package/dist/commands/browse.js

@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * cmdBrowse — Token-Efficient Page Navigation & Semantic Extractor
+ *
+ * Usage:
+ *   tk browse https://example.com
+ *   tk browse http://localhost:3000 --json
+ */
+
+const { browse } = require('../browser');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdBrowse(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url;
+
+  if (!url) {
+    console.error(`  ${c('red', '✖ Error:')} Missing target URL. Usage: tk browse <url>`);
+    process.exit(1);
+  }
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '🌐 Browsing:')} ${c('white', url)} (extracting semantic tokens)...\n`);
+  }
+
+  try {
+    const result = await browse(url);
+
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (result.threatLevel !== 'clean') {
+      console.log(`  ${c('yellow', '⚠ IDPI Warning:')} Potential prompt injection detected (${result.threatLevel}):`);
+      for (const t of result.threats) {
+        console.log(`    ${c('red', '•')} ${t}`);
+      }
+      console.log();
+    }
+
+    console.log(c('gray', '─────────────────────────────────────────────────────────────'));
+    console.log(result.markdown);
+    console.log(c('gray', '─────────────────────────────────────────────────────────────'));
+    console.log(`  ${c('green', '✔')} Extracted page content (${Buffer.byteLength(result.markdown, 'utf8')} bytes, < 1.5k tokens).\n`);
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Browser error:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdBrowse,
+};

package/dist/commands/compare-web.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/**
+ * cmdCompareWeb — Visual Regression Comparison Command
+ *
+ * Usage:
+ *   tk compare-web http://localhost:3000 https://example.com
+ *   tk compare-web https://staging.site.com https://prod.site.com --max-diff 2.0
+ */
+
+const { compareURLs } = require('../browser');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdCompareWeb(flags, processArgs, quiet = false) {
+  const url1 = processArgs[3] || flags.url1;
+  const url2 = processArgs[4] || flags.url2;
+
+  if (!url1 || !url2) {
+    console.error(`  ${c('red', '✖ Error:')} Missing target URLs. Usage: tk compare-web <url1> <url2>`);
+    process.exit(1);
+  }
+
+  const maxDiff = flags.maxDiff ? parseFloat(flags.maxDiff) : 1.0;
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '📸 Comparing Visual Viewports:')}`);
+    console.log(`    URL 1: ${c('white', url1)}`);
+    console.log(`    URL 2: ${c('white', url2)}\n`);
+  }
+
+  try {
+    const result = await compareURLs(url1, url2, { maxDiffPercent: maxDiff });
+
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.passed ? 0 : 1);
+    }
+
+    const diffColor = result.passed ? 'green' : 'red';
+
+    console.log(`  Visual Mismatch: ${c(diffColor, `${result.diffPercentage}%`)} (Allowed Threshold: ${maxDiff}%)`);
+    console.log(`  Compared Bytes:  ${result.totalPixelsCompared}`);
+
+    if (result.passed) {
+      console.log(`\n  ${c('green', '✔ Visual comparison passed')} — Difference is within acceptable threshold.\n`);
+      process.exit(0);
+    } else {
+      console.log(`\n  ${c('red', '✖ Visual regression detected!')} Diff ${result.diffPercentage}% exceeds max allowed ${maxDiff}%.\n`);
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Comparison failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdCompareWeb,
+};

package/dist/commands/deconstruct.js

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * cmdDeconstruct — Reverse-Engineer Live Web Elements into Production React Code
+ *
+ * Usage:
+ *   tk deconstruct https://example.com --selector "button.primary"
+ *   tk deconstruct http://localhost:3000 --selector "#pricing-card" --name PricingCard --output src/components/PricingCard.tsx
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { deconstructElement } = require('../browser/synapse');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdDeconstruct(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url;
+  const selector = flags.selector || processArgs[4];
+
+  if (!url || !selector) {
+    console.error(`  ${c('red', '✖ Error:')} Missing URL or selector. Usage: tk deconstruct <url> --selector "<css-selector>"`);
+    process.exit(1);
+  }
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '⚡ Component Synapse Deconstructing:')} ${c('white', selector)} on ${c('gray', url)}...\n`);
+  }
+
+  try {
+    const result = await deconstructElement(url, selector, flags);
+
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    if (flags.output) {
+      const outPath = path.resolve(flags.output);
+      fs.mkdirSync(path.dirname(outPath), { recursive: true });
+      fs.writeFileSync(outPath, result.code, 'utf8');
+      console.log(`  ${c('green', '✔ Synthesized React component saved to:')} ${c('bold', outPath)}\n`);
+    } else {
+      console.log(c('gray', '────────────────── Synthesized React TSX Component ──────────────────'));
+      console.log(result.code);
+      console.log(c('gray', '─────────────────────────────────────────────────────────────────────'));
+      console.log(`  ${c('green', '✔')} Extracted computed CSSOM and synthesized ${c('bold', result.componentName)}.\n`);
+    }
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Deconstruction failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdDeconstruct,
+};

package/dist/commands/heal.js

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * cmdHeal — Runtime Sentinel Error Hunter and Fix Verifier
+ *
+ * Usage:
+ *   tk heal http://localhost:3000
+ *   tk heal http://localhost:5173 --verify
+ *   tk heal http://localhost:3000 --json
+ */
+
+const { captureRuntimeErrors, verifyRuntimeFix } = require('../browser/sentinel');
+const { c } = require('../utils/logger');
+const { banner } = require('../utils/helpers');
+
+async function cmdHeal(flags, processArgs, quiet = false) {
+  const url = processArgs[3] || flags.url || 'http://localhost:3000';
+
+  if (!quiet && !flags.json) {
+    banner(quiet);
+    console.log(`  ${c('cyan', '🛡 Runtime Sentinel:')} Scanning ${c('white', url)} for live runtime errors...\n`);
+  }
+
+  try {
+    if (flags.verify) {
+      const verification = await verifyRuntimeFix(url, flags);
+      if (flags.json) {
+        console.log(JSON.stringify(verification, null, 2));
+        return;
+      }
+
+      if (verification.isFixed) {
+        console.log(`  ${c('green', '✔ Verification Passed!')} Runtime errors cleared on ${c('bold', url)}.\n`);
+      } else {
+        console.log(`  ${c('red', '✖ Verification Failed:')} ${verification.remainingIssues} issue(s) still remaining.\n`);
+      }
+      return;
+    }
+
+    const report = await captureRuntimeErrors(url, flags);
+
+    if (flags.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+
+    if (report.healthy) {
+      console.log(`  ${c('green', '✔ Runtime Healthy:')} Zero uncaught exceptions or error overlays detected on ${c('bold', url)}.\n`);
+      return;
+    }
+
+    console.log(`  ${c('red', '✖ Runtime Errors Detected:')}\n`);
+
+    if (report.overlay.hasOverlay) {
+      console.log(`    ${c('red', '• Dev Error Overlay Active:')} ${c('yellow', report.overlay.overlayType || 'Generic Framework Overlay')}`);
+      if (report.overlay.bodyText) {
+        console.log(`      ${c('gray', report.overlay.bodyText.slice(0, 160))}...\n`);
+      }
+    }
+
+    for (const exc of report.exceptions) {
+      console.log(`    ${c('red', '• Uncaught Exception:')} ${c('bold', exc.text)}`);
+      if (exc.locations && exc.locations.length > 0) {
+        for (const loc of exc.locations) {
+          const locStr = loc.existsLocally
+            ? `${c('green', loc.filePath)}:${loc.line}:${loc.column}`
+            : `${c('gray', loc.rawUrl)}`;
+          console.log(`      ${c('cyan', '→ Source:')} ${locStr}`);
+        }
+      }
+      console.log();
+    }
+
+    for (const cerr of report.consoleErrors) {
+      console.log(`    ${c('yellow', '• Console Error:')} ${cerr.text}`);
+      if (cerr.locations && cerr.locations.length > 0) {
+        for (const loc of cerr.locations) {
+          const locStr = loc.existsLocally
+            ? `${c('green', loc.filePath)}:${loc.line}:${loc.column}`
+            : `${c('gray', loc.rawUrl)}`;
+          console.log(`      ${c('cyan', '→ Source:')} ${locStr}`);
+        }
+      }
+      console.log();
+    }
+
+    console.log(`  ${c('yellow', 'ℹ Remedy Guidance:')}`);
+    console.log(`    1. Inspect the source file(s) listed above.`);
+    console.log(`    2. Apply targeted fix.`);
+    console.log(`    3. Run ${c('bold', `tk heal ${url} --verify`)} to confirm resolution.\n`);
+  } catch (err) {
+    console.error(`  ${c('red', '✖ Sentinel scan failed:')} ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdHeal,
+};

package/dist/commands/init.js

@@ -323,11 +323,18 @@ ${rulesContent}
 
 ${rulesContent}
 `;
-    // ── 5. Claude (.claude/CLAUDE.md) ─────────────────────
+    // ── 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/${rulesFilename}
 
+${rulesContent}
+`;
+    // ── 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/${rulesFilename}
+
 ${rulesContent}
 `;
     // Fire ALL bridge writes concurrently via Promise.all
@@ -338,6 +345,8 @@ ${rulesContent}
         { 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();

package/dist/commands/sdd.js

@@ -0,0 +1,229 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const { c, err, log } = require("../utils/logger");
+
+function getOption(args, names) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    for (const name of names) {
+      if (arg === name) return args[i + 1] || null;
+      if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+    }
+  }
+  return null;
+}
+
+function findRepoRoot() {
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (gitRoot && fs.existsSync(gitRoot)) {
+      return gitRoot;
+    }
+  } catch {
+    // Ignore git error and fallback to directory walk
+  }
+
+  let current = process.cwd();
+  while (true) {
+    if (fs.existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return process.cwd();
+}
+
+function sddWorkspace(planFile) {
+  if (!planFile) {
+    throw new Error("Missing required argument: --plan <plan_file>");
+  }
+  const resolvedPlan = path.resolve(process.cwd(), planFile);
+  if (!fs.existsSync(resolvedPlan)) {
+    throw new Error(`Plan file not found: ${planFile}`);
+  }
+
+  const fileStem = path.parse(resolvedPlan).name;
+  const repoRoot = findRepoRoot();
+  const base = path.join(repoRoot, ".tribunal", "sdd");
+  const workspace = path.join(base, fileStem);
+
+  fs.mkdirSync(workspace, { recursive: true });
+
+  const gitignorePath = path.join(base, ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, "*\n", "utf8");
+  }
+
+  return workspace;
+}
+
+function sddBrief(planFile, taskNum, outFile) {
+  if (!planFile) throw new Error("Missing required argument: --plan <plan_file>");
+  if (taskNum === null || taskNum === undefined || isNaN(taskNum)) {
+    throw new Error("Missing required argument: --task <number>");
+  }
+
+  const resolvedPlan = path.resolve(process.cwd(), planFile);
+  if (!fs.existsSync(resolvedPlan)) {
+    throw new Error(`Plan file not found: ${planFile}`);
+  }
+
+  const content = fs.readFileSync(resolvedPlan, "utf8");
+  const lines = content.split(/\r?\n/);
+
+  let targetOut;
+  if (outFile) {
+    targetOut = path.resolve(process.cwd(), outFile);
+  } else {
+    const ws = sddWorkspace(planFile);
+    targetOut = path.join(ws, `task-${taskNum}-brief.md`);
+  }
+
+  let inTargetTask = false;
+  let inCodeBlock = false;
+  const extractedLines = [];
+
+  const targetPrefix = `Task ${taskNum}`;
+  const targetPrefixColon = `Task ${taskNum}:`;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+    }
+
+    if (!inCodeBlock && trimmed.startsWith("#")) {
+      const headingText = trimmed.replace(/^#+\s*/, "").trim();
+      if (
+        headingText.startsWith(targetPrefixColon) ||
+        headingText.startsWith(targetPrefix) ||
+        headingText === targetPrefix
+      ) {
+        inTargetTask = true;
+        extractedLines.push(line);
+        continue;
+      } else if (inTargetTask && headingText.toLowerCase().startsWith("task ")) {
+        break;
+      }
+    }
+
+    if (inTargetTask) {
+      extractedLines.push(line);
+    }
+  }
+
+  if (extractedLines.length === 0) {
+    throw new Error(`Task ${taskNum} not found in ${planFile} (no heading matching 'Task ${taskNum}')`);
+  }
+
+  const briefContent = extractedLines.join("\n") + "\n";
+  fs.mkdirSync(path.dirname(targetOut), { recursive: true });
+  fs.writeFileSync(targetOut, briefContent, "utf8");
+
+  return targetOut;
+}
+
+function sddDiff(planFile, base, head, outFile) {
+  if (!planFile) throw new Error("Missing required argument: --plan <plan_file>");
+  if (!base) throw new Error("Missing required argument: --base <revision>");
+  if (!head) throw new Error("Missing required argument: --head <revision>");
+
+  try {
+    execSync(`git rev-parse --verify --quiet "${base}"`, { stdio: "ignore" });
+  } catch {
+    throw new Error(`Invalid BASE git revision: ${base}`);
+  }
+
+  try {
+    execSync(`git rev-parse --verify --quiet "${head}"`, { stdio: "ignore" });
+  } catch {
+    throw new Error(`Invalid HEAD git revision: ${head}`);
+  }
+
+  let targetOut;
+  if (outFile) {
+    targetOut = path.resolve(process.cwd(), outFile);
+  } else {
+    const ws = sddWorkspace(planFile);
+    const shortBase = base.length > 7 ? base.slice(0, 7) : base;
+    const shortHead = head.length > 7 ? head.slice(0, 7) : head;
+    targetOut = path.join(ws, `review-${shortBase}..${shortHead}.diff`);
+  }
+
+  const diffContent = execSync(`git diff "${base}..${head}"`, {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  fs.mkdirSync(path.dirname(targetOut), { recursive: true });
+  fs.writeFileSync(targetOut, diffContent, "utf8");
+
+  return targetOut;
+}
+
+async function cmdSdd(flags, processArgs, quiet = false) {
+  const args = processArgs.slice(3);
+  const subcommand = args.find((a) => !a.startsWith("-")) || "help";
+
+  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    if (!quiet) {
+      log(c("cyan", "  Subagent-Driven Development (SDD) — Commands"));
+      log(`  ${c("gray", "─".repeat(45))}`);
+      log(`  ${c("cyan", "sdd workspace".padEnd(20))} ${c("gray", "Ensure plan-scoped workspace (.tribunal/sdd/<slug>)")}`);
+      log(`  ${c("cyan", "sdd brief".padEnd(20))} ${c("gray", "Extract task brief out-of-band (--plan, --task, [--out])")}`);
+      log(`  ${c("cyan", "sdd diff".padEnd(20))} ${c("gray", "Generate diff package (--plan, --base, --head, [--out])")}`);
+    }
+    return;
+  }
+
+  const planArg = getOption(args, ["--plan", "-p"]) || args[1];
+  const outArg = getOption(args, ["--out", "-o"]);
+
+  try {
+    if (subcommand === "workspace") {
+      const ws = sddWorkspace(planArg);
+      if (!quiet) log(c("green", `✔ SDD Workspace: ${ws}`));
+      else console.log(ws);
+      return;
+    }
+
+    if (subcommand === "brief") {
+      const taskRaw = getOption(args, ["--task", "-t"]);
+      const taskNum = taskRaw ? parseInt(taskRaw, 10) : null;
+      const briefPath = sddBrief(planArg, taskNum, outArg);
+      if (!quiet) log(c("green", `✔ SDD Task Brief: ${briefPath}`));
+      else console.log(briefPath);
+      return;
+    }
+
+    if (subcommand === "diff") {
+      const base = getOption(args, ["--base"]);
+      const head = getOption(args, ["--head"]);
+      const diffPath = sddDiff(planArg, base, head, outArg);
+      if (!quiet) log(c("green", `✔ SDD Diff Package: ${diffPath}`));
+      else console.log(diffPath);
+      return;
+    }
+
+    err(`Unknown SDD subcommand: "${subcommand}"`);
+    process.exit(1);
+  } catch (error) {
+    err(error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  cmdSdd,
+  sddWorkspace,
+  sddBrief,
+  sddDiff,
+};

package/dist/commands/uninstall.js

@@ -8,8 +8,20 @@ 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 fs_2 = require("../utils/fs");
 function cmdUninstall(flags, quiet = false) {
     const targetDir = flags.path ? path_1.default.resolve(flags.path) : process.cwd();
+    const pkgStr = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../package.json'), 'utf8');
+    const pkg = JSON.parse(pkgStr);
+    if ((0, fs_2.isSelfInstall)(targetDir, pkg.name, path_1.default.resolve(__dirname, '../..'))) {
+        (0, logger_1.err)('Cannot run uninstall inside the tribunal-kit package itself.');
+        (0, logger_1.err)(`Target: ${targetDir}`);
+        console.log();
+        (0, logger_1.dim)('This command is designed to remove .agent/ from OTHER projects.');
+        (0, logger_1.dim)('Run it from the root of the target project you want to uninstall from.');
+        console.log();
+        process.exit(1);
+    }
     const agentDest = path_1.default.join(targetDir, '.agent');
     (0, helpers_1.banner)(quiet);
     if (!fs_1.default.existsSync(agentDest)) {