tribunal-kit 9.2.5 → 9.2.6

package/src/commands/sdd.js

@@ -1,9 +1,9 @@
-"use strict";
+'use strict';
 
-const fs = require("fs");
-const path = require("path");
-const { execFileSync } = require("child_process");
-const { c, err, log } = require("../utils/logger");
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { c, err, log } = require('../utils/logger');
 
 function getOption(args, names) {
   for (let i = 0; i < args.length; i++) {
@@ -18,9 +18,9 @@ function getOption(args, names) {
 
 function findRepoRoot() {
   try {
-    const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
+    const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
     }).trim();
     if (gitRoot && fs.existsSync(gitRoot)) {
       return gitRoot;
@@ -31,7 +31,7 @@ function findRepoRoot() {
 
   let current = process.cwd();
   while (true) {
-    if (fs.existsSync(path.join(current, ".git"))) {
+    if (fs.existsSync(path.join(current, '.git'))) {
       return current;
     }
     const parent = path.dirname(current);
@@ -43,7 +43,7 @@ function findRepoRoot() {
 
 function sddWorkspace(planFile) {
   if (!planFile) {
-    throw new Error("Missing required argument: --plan <plan_file>");
+    throw new Error('Missing required argument: --plan <plan_file>');
   }
   const resolvedPlan = path.resolve(process.cwd(), planFile);
   if (!fs.existsSync(resolvedPlan)) {
@@ -52,23 +52,23 @@ function sddWorkspace(planFile) {
 
   const fileStem = path.parse(resolvedPlan).name;
   const repoRoot = findRepoRoot();
-  const base = path.join(repoRoot, ".tribunal", "sdd");
+  const base = path.join(repoRoot, '.tribunal', 'sdd');
   const workspace = path.join(base, fileStem);
 
   fs.mkdirSync(workspace, { recursive: true });
 
-  const gitignorePath = path.join(base, ".gitignore");
+  const gitignorePath = path.join(base, '.gitignore');
   if (!fs.existsSync(gitignorePath)) {
-    fs.writeFileSync(gitignorePath, "*\n", "utf8");
+    fs.writeFileSync(gitignorePath, '*\n', 'utf8');
   }
 
   return workspace;
 }
 
 function sddBrief(planFile, taskNum, outFile) {
-  if (!planFile) throw new Error("Missing required argument: --plan <plan_file>");
+  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>");
+    throw new Error('Missing required argument: --task <number>');
   }
 
   const resolvedPlan = path.resolve(process.cwd(), planFile);
@@ -76,7 +76,7 @@ function sddBrief(planFile, taskNum, outFile) {
     throw new Error(`Plan file not found: ${planFile}`);
   }
 
-  const content = fs.readFileSync(resolvedPlan, "utf8");
+  const content = fs.readFileSync(resolvedPlan, 'utf8');
   const lines = content.split(/\r?\n/);
 
   let targetOut;
@@ -96,12 +96,12 @@ function sddBrief(planFile, taskNum, outFile) {
 
   for (const line of lines) {
     const trimmed = line.trim();
-    if (trimmed.startsWith("```")) {
+    if (trimmed.startsWith('```')) {
       inCodeBlock = !inCodeBlock;
     }
 
-    if (!inCodeBlock && trimmed.startsWith("#")) {
-      const headingText = trimmed.replace(/^#+\s*/, "").trim();
+    if (!inCodeBlock && trimmed.startsWith('#')) {
+      const headingText = trimmed.replace(/^#+\s*/, '').trim();
       if (
         headingText.startsWith(targetPrefixColon) ||
         headingText.startsWith(targetPrefix) ||
@@ -110,7 +110,7 @@ function sddBrief(planFile, taskNum, outFile) {
         inTargetTask = true;
         extractedLines.push(line);
         continue;
-      } else if (inTargetTask && headingText.toLowerCase().startsWith("task ")) {
+      } else if (inTargetTask && headingText.toLowerCase().startsWith('task ')) {
         break;
       }
     }
@@ -121,20 +121,22 @@ function sddBrief(planFile, taskNum, outFile) {
   }
 
   if (extractedLines.length === 0) {
-    throw new Error(`Task ${taskNum} not found in ${planFile} (no heading matching 'Task ${taskNum}')`);
+    throw new Error(
+      `Task ${taskNum} not found in ${planFile} (no heading matching 'Task ${taskNum}')`,
+    );
   }
 
-  const briefContent = extractedLines.join("\n") + "\n";
+  const briefContent = extractedLines.join('\n') + '\n';
   fs.mkdirSync(path.dirname(targetOut), { recursive: true });
-  fs.writeFileSync(targetOut, briefContent, "utf8");
+  fs.writeFileSync(targetOut, briefContent, 'utf8');
 
   return targetOut;
 }
 
 function sddScratchpad(planFile, taskNum, outFile) {
-  if (!planFile) throw new Error("Missing required argument: --plan <plan_file>");
+  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>");
+    throw new Error('Missing required argument: --task <number>');
   }
 
   let targetOut;
@@ -148,27 +150,27 @@ function sddScratchpad(planFile, taskNum, outFile) {
   if (!fs.existsSync(targetOut)) {
     const content = `# Scratchpad - Task ${taskNum}\n\n## 1. Goal\n\n## 2. Execution Plan\n\n## 3. Current Context\n\n## 4. Attempt Log\n`;
     fs.mkdirSync(path.dirname(targetOut), { recursive: true });
-    fs.writeFileSync(targetOut, content, "utf8");
+    fs.writeFileSync(targetOut, content, '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>");
+  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>');
 
   // SECURITY: Use execFileSync with argument arrays to prevent command injection
   // via user-supplied --base/--head parameters (CWE-78).
   try {
-    execFileSync('git', ['rev-parse', '--verify', '--quiet', base], { stdio: "ignore" });
+    execFileSync('git', ['rev-parse', '--verify', '--quiet', base], { stdio: 'ignore' });
   } catch {
     throw new Error(`Invalid BASE git revision: ${base}`);
   }
 
   try {
-    execFileSync('git', ['rev-parse', '--verify', '--quiet', head], { stdio: "ignore" });
+    execFileSync('git', ['rev-parse', '--verify', '--quiet', head], { stdio: 'ignore' });
   } catch {
     throw new Error(`Invalid HEAD git revision: ${head}`);
   }
@@ -184,66 +186,74 @@ function sddDiff(planFile, base, head, outFile) {
   }
 
   const diffContent = execFileSync('git', ['diff', `${base}..${head}`], {
-    encoding: "utf8",
+    encoding: 'utf8',
     maxBuffer: 10 * 1024 * 1024,
   });
 
   fs.mkdirSync(path.dirname(targetOut), { recursive: true });
-  fs.writeFileSync(targetOut, diffContent, "utf8");
+  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";
+  const subcommand = args.find(a => !a.startsWith('-')) || 'help';
 
-  if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+  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 scratchpad".padEnd(20))} ${c("gray", "Initialize task scratchpad (--plan, --task, [--out])")}`);
-      log(`  ${c("cyan", "sdd diff".padEnd(20))} ${c("gray", "Generate diff package (--plan, --base, --head, [--out])")}`);
+      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 scratchpad'.padEnd(20))} ${c('gray', 'Initialize task scratchpad (--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"]);
+  const planArg = getOption(args, ['--plan', '-p']) || args[1];
+  const outArg = getOption(args, ['--out', '-o']);
 
   try {
-    if (subcommand === "workspace") {
+    if (subcommand === 'workspace') {
       const ws = sddWorkspace(planArg);
-      if (!quiet) log(c("green", `✔ SDD Workspace: ${ws}`));
+      if (!quiet) log(c('green', `✔ SDD Workspace: ${ws}`));
       else console.log(ws);
       return;
     }
 
-    if (subcommand === "brief") {
-      const taskRaw = getOption(args, ["--task", "-t"]);
+    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}`));
+      if (!quiet) log(c('green', `✔ SDD Task Brief: ${briefPath}`));
       else console.log(briefPath);
       return;
     }
 
-    if (subcommand === "scratchpad") {
-      const taskRaw = getOption(args, ["--task", "-t"]);
+    if (subcommand === 'scratchpad') {
+      const taskRaw = getOption(args, ['--task', '-t']);
       const taskNum = taskRaw ? parseInt(taskRaw, 10) : null;
       const scratchpadPath = sddScratchpad(planArg, taskNum, outArg);
-      if (!quiet) log(c("green", `✔ SDD Task Scratchpad: ${scratchpadPath}`));
+      if (!quiet) log(c('green', `✔ SDD Task Scratchpad: ${scratchpadPath}`));
       else console.log(scratchpadPath);
       return;
     }
 
-    if (subcommand === "diff") {
-      const base = getOption(args, ["--base"]);
-      const head = getOption(args, ["--head"]);
+    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}`));
+      if (!quiet) log(c('green', `✔ SDD Diff Package: ${diffPath}`));
       else console.log(diffPath);
       return;
     }

package/src/commands/status.js

@@ -37,13 +37,23 @@ function cmdStatus(flags, quiet = false) {
     ? fs.readdirSync(path.join(agentDest, 'scripts')).filter(f => f.endsWith('.js')).length
     : 0;
 
-  console.log(`  ${color(RGB.EMERALD, g.success)} ${bold(color(RGB.EMERALD, 'Installed & Active'))}  ${dim('→')}  ${dim(agentDest)}`);
+  console.log(
+    `  ${color(RGB.EMERALD, g.success)} ${bold(color(RGB.EMERALD, 'Installed & Active'))}  ${dim('→')}  ${dim(agentDest)}`,
+  );
   console.log();
 
-  console.log(`    ${color(RGB.FLAME, '🤖')}  ${color(RGB.WHITE, 'Agents'.padEnd(12))}  ${color(RGB.CYAN, String(agentsCount).padStart(3))} ${dim('specialists')}`);
-  console.log(`    ${color(RGB.AMBER, '⚡')}  ${color(RGB.WHITE, 'Workflows'.padEnd(12))}  ${color(RGB.CYAN, String(workflowsCount).padStart(3))} ${dim('commands')}`);
-  console.log(`    ${color(RGB.PURPLE, '🧠')}  ${color(RGB.WHITE, 'Skills'.padEnd(12))}  ${color(RGB.CYAN, String(skillsCount).padStart(3))} ${dim('injected')}`);
-  console.log(`    ${color(RGB.EMERALD, '🔧')}  ${color(RGB.WHITE, 'Scripts'.padEnd(12))}  ${color(RGB.CYAN, String(scriptsCount).padStart(3))} ${dim('enforcers')}`);
+  console.log(
+    `    ${color(RGB.FLAME, '🤖')}  ${color(RGB.WHITE, 'Agents'.padEnd(12))}  ${color(RGB.CYAN, String(agentsCount).padStart(3))} ${dim('specialists')}`,
+  );
+  console.log(
+    `    ${color(RGB.AMBER, '⚡')}  ${color(RGB.WHITE, 'Workflows'.padEnd(12))}  ${color(RGB.CYAN, String(workflowsCount).padStart(3))} ${dim('commands')}`,
+  );
+  console.log(
+    `    ${color(RGB.PURPLE, '🧠')}  ${color(RGB.WHITE, 'Skills'.padEnd(12))}  ${color(RGB.CYAN, String(skillsCount).padStart(3))} ${dim('injected')}`,
+  );
+  console.log(
+    `    ${color(RGB.EMERALD, '🔧')}  ${color(RGB.WHITE, 'Scripts'.padEnd(12))}  ${color(RGB.CYAN, String(scriptsCount).padStart(3))} ${dim('enforcers')}`,
+  );
   console.log();
 
   // IDE Bridges Check

package/src/commands/sync.js

@@ -1,25 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+const __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.cmdSync = cmdSync;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const logger_1 = require("../utils/logger");
-const init_1 = require("./init");
+const fs_1 = __importDefault(require('fs'));
+const path_1 = __importDefault(require('path'));
+const logger_1 = require('../utils/logger');
+const init_1 = require('./init');
 async function cmdSync() {
-    console.log(`\n╭─ ${(0, logger_1.c)('bold', 'Tribunal IDE Sync')} ──────────────────`);
-    console.log('│');
-    console.log(`│  ${(0, logger_1.c)('gray', '✦ Regenerating IDE bridge files...')}`);
-    const cwd = process.cwd();
-    const agentDest = path_1.default.join(cwd, '.agent');
-    if (!fs_1.default.existsSync(agentDest)) {
-        console.error(`│  ${(0, logger_1.c)('red', '✖ Error: .agent/ directory not found.')}`);
-        console.error(`│  ${(0, logger_1.c)('gray', 'Run `tk init` first.')}`);
-        process.exit(1);
-    }
-    await (0, init_1.generateIDEBridges)(cwd, agentDest, false);
-    console.log(`│  ${(0, logger_1.c)('green', '✔ Sync complete.')}`);
-    console.log('╰────────────────────────────────────────\n');
+  console.log(`\n╭─ ${(0, logger_1.c)('bold', 'Tribunal IDE Sync')} ──────────────────`);
+  console.log('│');
+  console.log(`│  ${(0, logger_1.c)('gray', '✦ Regenerating IDE bridge files...')}`);
+  const cwd = process.cwd();
+  const agentDest = path_1.default.join(cwd, '.agent');
+  if (!fs_1.default.existsSync(agentDest)) {
+    console.error(`│  ${(0, logger_1.c)('red', '✖ Error: .agent/ directory not found.')}`);
+    console.error(`│  ${(0, logger_1.c)('gray', 'Run `tk init` first.')}`);
+    process.exit(1);
+  }
+  await (0, init_1.generateIDEBridges)(cwd, agentDest, false);
+  console.log(`│  ${(0, logger_1.c)('green', '✔ Sync complete.')}`);
+  console.log('╰────────────────────────────────────────\n');
 }

package/src/commands/system1.js

@@ -0,0 +1,312 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const child_process = require('child_process');
+const { log, err, dim, c, bold } = require('../utils/logger');
+const { getLayaDir, getConfigPath } = require('../system1/provider');
+
+function verifyChecksum(filePath, expectedHash) {
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(filePath)) {
+      return reject(new Error(`File missing: ${filePath}`));
+    }
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', data => hash.update(data));
+    stream.on('end', () => {
+      const actual = hash.digest('hex');
+      if (actual === expectedHash) {
+        resolve(true);
+      } else {
+        reject(
+          new Error(
+            `Hash mismatch for ${path.basename(filePath)}.\nExpected: ${expectedHash}\nActual:   ${actual}`,
+          ),
+        );
+      }
+    });
+    stream.on('error', err => reject(err));
+  });
+}
+
+// Pinned dependencies for reproducible installations
+const RECEPTRON_LAYA_VERSION = '0.1.2';
+const ONNXRUNTIME_NODE_VERSION = '1.22.0';
+
+async function cmdSystem1Enable(quiet) {
+  const layaDir = getLayaDir();
+  const configPath = getConfigPath();
+  const modelsDir = path.join(layaDir, 'models');
+
+  if (!quiet) {
+    log(`\n  ${c('cyan', '⚡')} ${bold('Tribunal Kit Laya System-1 Initialization')}`);
+    dim('  --------------------------------------------------');
+    dim('  This will install the local Laya ONNX decision engine.');
+    dim('  - Engine: @receptron/laya & onnxruntime-node');
+    dim('  - Model: convaiinnovations/laya (~1.7GB)');
+    dim(`  - Path: ${layaDir}`);
+    log('');
+  }
+
+  if (process.env.TK_MOCK_LAYA_DOWNLOAD) {
+    if (!fs.existsSync(layaDir)) fs.mkdirSync(layaDir, { recursive: true });
+    if (!fs.existsSync(modelsDir)) fs.mkdirSync(modelsDir, { recursive: true });
+    fs.writeFileSync(path.join(modelsDir, 'laya.onnx'), 'mock');
+    fs.writeFileSync(configPath, JSON.stringify({ enabled: true, mocked: true }));
+    if (!quiet) log(`  ${c('green', '✓')} System-1 successfully mocked!`);
+    return;
+  }
+
+  try {
+    if (!fs.existsSync(layaDir)) fs.mkdirSync(layaDir, { recursive: true });
+
+    const lockDir = path.join(layaDir, '.install.lock');
+    const lockPidFile = path.join(lockDir, 'pid');
+    try {
+      fs.mkdirSync(lockDir);
+      fs.writeFileSync(lockPidFile, String(process.pid));
+    } catch (err) {
+      if (err.code === 'EEXIST') {
+        let isStale = false;
+        try {
+          const pidStr = fs.readFileSync(lockPidFile, 'utf8');
+          const pid = parseInt(pidStr, 10);
+          if (pid > 0) {
+            try {
+              process.kill(pid, 0);
+            } catch (_e) {
+              if (_e.code === 'ESRCH') isStale = true;
+            }
+          } else {
+            const stat = fs.statSync(lockPidFile);
+            if (Date.now() - stat.mtimeMs > 900000) isStale = true;
+          }
+        } catch (_e) {
+          try {
+            const stat = fs.statSync(lockDir);
+            if (Date.now() - stat.mtimeMs > 900000) isStale = true;
+          } catch (_e2) {
+            isStale = true;
+          }
+        }
+
+        if (isStale) {
+          if (!quiet)
+            log(`  ${c('yellow', '⚠')} Found stale lock from previous crash. Recovering...`);
+          fs.rmSync(lockDir, { recursive: true, force: true });
+          fs.mkdirSync(lockDir);
+          fs.writeFileSync(lockPidFile, String(process.pid));
+        } else {
+          throw new Error(
+            'System-1 installation is currently in progress by another process (PID is active). Please wait.',
+          );
+        }
+      } else {
+        throw err;
+      }
+    }
+
+    try {
+      if (!fs.existsSync(modelsDir)) fs.mkdirSync(modelsDir, { recursive: true });
+
+      // 1. Install @receptron/laya with strictly reproducible dependency tree
+      if (!quiet)
+        log(`  ${c('yellow', '1.')} Installing local runtime dependency (clean install)...`);
+
+      fs.copyFileSync(
+        path.join(__dirname, '../system1/laya-package.json'),
+        path.join(layaDir, 'package.json'),
+      );
+      fs.copyFileSync(
+        path.join(__dirname, '../system1/laya-package-lock.json'),
+        path.join(layaDir, 'package-lock.json'),
+      );
+
+      // Validate layaDir to prevent shell injection on Windows
+      if (/[&|";<>]/.test(layaDir)) {
+        throw new Error(`Invalid path characters in Laya directory: ${layaDir}`);
+      }
+
+      let cmd;
+      const args = ['ci', '--prefix', layaDir, '--no-audit', '--no-fund'];
+      let shell = false;
+
+      if (process.platform === 'win32') {
+        cmd = 'npm.cmd';
+        shell = true; // Windows requires shell: true for .cmd files
+      } else {
+        cmd = 'npm';
+      }
+
+      child_process.execFileSync(cmd, args, {
+        stdio: quiet ? 'ignore' : 'pipe',
+        shell: shell,
+      });
+
+      // 2. Download model safely without initializing ONNX Runtime
+      if (!quiet)
+        log(`  ${c('yellow', '2.')} Downloading model weights (~1.7GB, this may take a while)...`);
+
+      const layaPkgPath = path.join(layaDir, 'node_modules', '@receptron', 'laya');
+      const { Laya, ensureBundle } = require(layaPkgPath);
+
+      // This natively downloads via huggingface_hub using pinned commit SHA
+      const revision = '68f27dfe5a27a54fb2b1fefc432f43f972e90868';
+      const downloadedModelDir = await ensureBundle({
+        repo: 'receptron/laya-onnx',
+        revision: revision,
+        cacheDir: modelsDir,
+      });
+
+      // 3. Verify SHA-256 for artifacts BEFORE consumption
+      if (!quiet) log(`  ${c('yellow', '3.')} Verifying artifact integrity (SHA-256)...`);
+
+      const expectedHashes = {
+        'laya.onnx': 'a874eb254b58b0fcb1e7ad56fbb188c29d64e08c9a46b689433e1f52c66dba1e',
+        'laya.onnx.data': '487746363a8da57bcadb4345352997d22a0fb90d70aa22c6856668d023242aba',
+      };
+
+      for (const [filename, expectedHash] of Object.entries(expectedHashes)) {
+        const artifactPath = path.join(downloadedModelDir, filename);
+        try {
+          await verifyChecksum(artifactPath, expectedHash);
+        } catch (err) {
+          // If validation fails, completely purge the corrupted installation to prevent bypass
+          fs.rmSync(layaDir, { recursive: true, force: true });
+          throw new Error(
+            `Integrity check failed: ${err.message}\nInstallation aborted and quarantined.`,
+          );
+        }
+      }
+
+      // Also ensure tokenizer files exist
+      for (const filename of ['tokenizer/tokenizer.json', 'tokenizer/tokenizer_config.json']) {
+        if (!fs.existsSync(path.join(downloadedModelDir, filename))) {
+          fs.rmSync(layaDir, { recursive: true, force: true });
+          throw new Error(`Integrity check failed: Missing ${filename}`);
+        }
+      }
+
+      // 4. Initialize model safely (only after verification)
+      if (!quiet) log(`  ${c('yellow', '4.')} Initializing model...`);
+      const laya = await Laya.load({
+        modelDir: downloadedModelDir,
+        executionProviders: ['cpu'],
+      });
+      await laya.close();
+
+      // 4. Save config
+      fs.writeFileSync(
+        configPath,
+        JSON.stringify(
+          {
+            enabled: true,
+            model_version: 'v1.0.0',
+            checksum_verified: true,
+            installed_at: new Date().toISOString(),
+          },
+          null,
+          2,
+        ),
+      );
+
+      if (!quiet) {
+        log(`\n  ${c('green', '✓')} System-1 successfully enabled!`);
+        dim(`  Impact tier resolution will now use local inference.`);
+      }
+    } finally {
+      try {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+      } catch (_e) {}
+    }
+  } catch (error) {
+    err(`\n  ✖ Failed to enable System-1: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+function cmdSystem1Disable(quiet) {
+  const configPath = getConfigPath();
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      config.enabled = false;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      if (!quiet)
+        log(`  ${c('green', '✓')} System-1 has been disabled (installation kept intact).`);
+    } catch {
+      if (!quiet) err(`  ✖ Failed to parse System-1 config.`);
+      process.exitCode = 1;
+    }
+  } else {
+    if (!quiet) dim(`  System-1 is not currently installed.`);
+  }
+}
+
+function cmdSystem1Status(quiet) {
+  const configPath = getConfigPath();
+  const layaDir = getLayaDir();
+  const modelPath = path.join(layaDir, 'models', 'laya.onnx');
+  const runtimePath = path.join(layaDir, 'node_modules', '@receptron', 'laya');
+
+  let config = null;
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch {}
+  }
+
+  if (!quiet) {
+    log(`\n  ${bold('System-1 Status')}`);
+    dim('  --------------------------------------------------');
+    log(`  Provider:      ${c('white', 'Laya (ONNX CPU)')}`);
+    log(`  Enabled:       ${config?.enabled ? c('green', 'Yes') : c('yellow', 'No')}`);
+    log(`  Config path:   ${configPath}`);
+    log(`  Model found:   ${fs.existsSync(modelPath) ? c('green', 'Yes') : c('red', 'No')}`);
+    log(`  Runtime found: ${fs.existsSync(runtimePath) ? c('green', 'Yes') : c('red', 'No')}`);
+    log('');
+  }
+}
+
+function cmdSystem1Clean(quiet) {
+  const layaDir = getLayaDir();
+  if (fs.existsSync(layaDir)) {
+    fs.rmSync(layaDir, { recursive: true, force: true });
+    if (!quiet) log(`  ${c('green', '✓')} System-1 installation completely removed.`);
+  } else {
+    if (!quiet) dim(`  System-1 is not installed.`);
+  }
+}
+
+async function cmdSystem1(flags, args, quiet) {
+  const rawArgs = args.slice(2);
+  const subCommand = rawArgs.find(a => !a.startsWith('-') && a !== 'system1');
+
+  switch (subCommand) {
+    case 'enable':
+      await cmdSystem1Enable(quiet);
+      break;
+    case 'disable':
+      cmdSystem1Disable(quiet);
+      break;
+    case 'status':
+      cmdSystem1Status(quiet);
+      break;
+    case 'clean':
+      cmdSystem1Clean(quiet);
+      break;
+    default:
+      err(`Unknown system1 command: "${subCommand || ''}"`);
+      dim('Available: enable, disable, status, clean');
+      process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  cmdSystem1,
+  verifyChecksum,
+  RECEPTRON_LAYA_VERSION,
+  ONNXRUNTIME_NODE_VERSION,
+};