claws-code 0.8.0

package/lib/shell-hook.js

@@ -0,0 +1,343 @@
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { dryRunLog, getDefaultShellRcFile } = require('./platform.js');
+
+// Canonical marker — matches install.sh's HOOK_MARKER exactly.
+const MARKER = '# CLAWS terminal hook';
+
+// Legacy format from old Node installer. Stripped as a one-time migration during inject.
+const LEGACY_BEGIN = '# >>> claws-code shell hook >>>';
+const LEGACY_END   = '# <<< claws-code shell hook <<<';
+
+/**
+ * Returns the list of standard shell rc files to inject into.
+ * macOS: ~/.zshrc, ~/.bashrc, ~/.bash_profile
+ * Linux: ~/.zshrc, ~/.bashrc
+ * win32: [] (no-op on Windows)
+ * Matches install.sh's multi-file injection (lines 1419–1433).
+ * @param {object} [opts]
+ * @returns {string[]}
+ */
+function _getStandardRcFiles(opts = {}) {
+  const platform = opts.platform !== undefined ? opts.platform : process.platform;
+  const home     = opts.home     !== undefined ? opts.home     : os.homedir();
+
+  if (platform === 'win32') return [];
+
+  const files = [
+    path.join(home, '.zshrc'),
+    path.join(home, '.bashrc'),
+  ];
+  if (platform === 'darwin') {
+    files.push(path.join(home, '.bash_profile'));
+  }
+  return files;
+}
+
+/**
+ * Inject (or replace) the claws shell hook block in all standard rc files.
+ * On macOS: ~/.zshrc, ~/.bashrc, ~/.bash_profile.
+ * On Linux: ~/.zshrc, ~/.bashrc.
+ * Also handles fish (conf.d/claws.fish) and nushell (env.nu) when present.
+ * Idempotent per file.
+ * @param {string} installDir  - path to the claws repo (contains scripts/shell-hook.sh)
+ * @param {boolean} [dryRun]
+ */
+function injectShellHook(installDir, dryRun = false) {
+  if (process.platform === 'win32') {
+    _injectPowershellHook(installDir, dryRun);
+    return;
+  }
+  const rcFiles = _getStandardRcFiles();
+  for (const rcFile of rcFiles) {
+    _injectIntoFile(rcFile, installDir, dryRun);
+  }
+  _injectFishHook(installDir, dryRun);
+  _injectNushellHook(installDir, dryRun);
+}
+
+/**
+ * Write (or overwrite) ~/.config/fish/conf.d/claws.fish when the fish
+ * config directory exists. Fish sources conf.d/ automatically on startup.
+ * Matches install.sh lines 1435-1448.
+ * @param {string} installDir
+ * @param {boolean} [dryRun]
+ */
+function _injectFishHook(installDir, dryRun) {
+  const home = os.homedir();
+  if (!fs.existsSync(path.join(home, '.config', 'fish'))) return;
+
+  const confD    = path.join(home, '.config', 'fish', 'conf.d');
+  const fishFile = path.join(confD, 'claws.fish');
+  const hookFish = path.join(installDir, 'scripts', 'shell-hook.fish');
+
+  const content = [
+    '# CLAWS terminal hook (auto-generated — do not edit)',
+    `set -gx CLAWS_DIR '${installDir}'`,
+    `set -gx CLAWS_SOCKET '.claws/claws.sock'`,
+    `if test -f '${hookFish}'`,
+    `    source '${hookFish}'`,
+    'end',
+    '',
+  ].join('\n');
+
+  if (dryRun) {
+    dryRunLog(`write fish hook to ${fishFile}`);
+    return;
+  }
+
+  fs.mkdirSync(confD, { recursive: true });
+  const tmp = fishFile + '.claws-tmp.' + process.pid;
+  fs.writeFileSync(tmp, content, 'utf8');
+  fs.renameSync(tmp, fishFile);
+  process.stdout.write(`  \x1b[32m✓\x1b[0m fish hook written to ${fishFile}\n`);
+}
+
+/**
+ * Append the CLAWS_DIR assignment to nushell env.nu (or config.nu) when
+ * either file exists. Idempotent: skips if CLAWS_DIR already present.
+ * Matches install.sh lines 1450-1466.
+ * @param {string} installDir
+ * @param {boolean} [dryRun]
+ */
+function _injectNushellHook(installDir, dryRun) {
+  const home     = os.homedir();
+  const nuEnv    = path.join(home, '.config', 'nushell', 'env.nu');
+  const nuConfig = path.join(home, '.config', 'nushell', 'config.nu');
+
+  let target = null;
+  if (fs.existsSync(nuEnv)) target = nuEnv;
+  else if (fs.existsSync(nuConfig)) target = nuConfig;
+  if (!target) return;
+
+  if (dryRun) {
+    dryRunLog(`append CLAWS_DIR to nushell ${path.basename(target)}`);
+    return;
+  }
+
+  const existing = fs.readFileSync(target, 'utf8');
+  if (existing.includes('CLAWS_DIR')) {
+    process.stdout.write(`  \x1b[2m${path.basename(target)} already has CLAWS_DIR — skipped\x1b[0m\n`);
+    return;
+  }
+
+  const append = `\n${MARKER}\n$env.CLAWS_DIR = "${installDir}"\n$env.CLAWS_SOCKET = ".claws/claws.sock"\n`;
+  fs.appendFileSync(target, append, 'utf8');
+  process.stdout.write(`  \x1b[32m✓\x1b[0m nushell env written to ${target}\n`);
+}
+
+/**
+ * Remove the claws shell hook block from rcFile.
+ * Handles both canonical install.sh format and legacy >>>...<<< format.
+ * @param {string} rcFile
+ * @param {boolean} [dryRun]
+ */
+function removeShellHook(rcFile, dryRun = false) {
+  if (!fs.existsSync(rcFile)) return;
+
+  if (dryRun) {
+    dryRunLog(`remove shell hook from ${rcFile}`);
+    return;
+  }
+
+  const original = fs.readFileSync(rcFile, 'utf8');
+  const cleaned  = _removePriorBlock(original);
+  if (cleaned === original) return;
+
+  const tmp = rcFile + '.claws-tmp.' + process.pid;
+  fs.writeFileSync(tmp, cleaned, 'utf8');
+  fs.renameSync(tmp, rcFile);
+}
+
+/**
+ * Inject the Claws shell hook into the PowerShell profile on win32.
+ * Copies shell-hook.ps1 to a stable location ($HOME/.claude/claws/) so that
+ * $PROFILE never references the install-time temp dir (which is deleted post-install).
+ * Uses the same `# CLAWS terminal hook` marker as the bash installer.
+ * @param {string} installDir  - path to the claws repo (contains scripts/shell-hook.ps1)
+ * @param {boolean} [dryRun]
+ * @param {object}  [opts]     - internal overrides for testing
+ * @param {string}  [opts.home]   - override os.homedir()
+ * @param {Function}[opts.execFn] - override execSync for powershell profile lookup
+ */
+function _injectPowershellHook(installDir, dryRun, opts = {}) {
+  const home        = opts.home   !== undefined ? opts.home   : os.homedir();
+  const profilePath = getDefaultShellRcFile({ platform: 'win32', home, execFn: opts.execFn });
+  const hookPs1     = path.join(installDir, 'scripts', 'shell-hook.ps1');
+
+  // Stable location: $HOME/.claude/claws/shell-hook.ps1 — one level above the lifecycle
+  // hooks dir (~/.claude/claws/hooks/). $PROFILE sources this stable copy so it survives
+  // the install temp-dir deletion (root cause of W7-4B).
+  const stableDir     = path.join(home, '.claude', 'claws');
+  const stableHookPs1 = path.join(stableDir, 'shell-hook.ps1');
+
+  // PowerShell dot-source syntax: . "absolute\path\to\shell-hook.ps1"
+  const block = `\n${MARKER}\n. "${stableHookPs1}"\n`;
+
+  if (dryRun) {
+    dryRunLog(`copy shell-hook.ps1 to ${stableHookPs1}`);
+    dryRunLog(`inject PS shell hook into ${profilePath}`);
+    return;
+  }
+
+  // Copy hook to stable dir before writing $PROFILE entry.
+  fs.mkdirSync(stableDir, { recursive: true });
+  if (fs.existsSync(hookPs1)) {
+    fs.copyFileSync(hookPs1, stableHookPs1);
+    process.stdout.write(`  \x1b[32m✓\x1b[0m shell-hook.ps1 copied to ${stableHookPs1}\n`);
+  }
+
+  fs.mkdirSync(path.dirname(profilePath), { recursive: true });
+  if (!fs.existsSync(profilePath)) {
+    fs.writeFileSync(profilePath, '', 'utf8');
+  }
+
+  // Backup before modification — mirrors _injectIntoFile's backup pattern.
+  const ts     = new Date().toISOString().replace(/[:.]/g, '-');
+  const backup = profilePath + '.claws-bak.' + ts;
+  try {
+    fs.copyFileSync(profilePath, backup);
+  } catch (e) {
+    process.stderr.write(`  ! Warning: could not backup ${profilePath}: ${e.message}\n`);
+  }
+
+  const original = fs.readFileSync(profilePath, 'utf8');
+  const cleaned  = _removePriorBlock(original);
+  const updated  = cleaned + block;
+
+  const tmp = profilePath + '.claws-tmp.' + process.pid;
+  fs.writeFileSync(tmp, updated, 'utf8');
+  fs.renameSync(tmp, profilePath);
+  process.stdout.write(`  \x1b[32m✓\x1b[0m PS profile updated: ${profilePath}\n`);
+}
+
+/**
+ * Return the shell binary to use for syntax-checking rcFile, or null if
+ * no check is applicable. Mirrors install.sh lines 1420-1432 (use zsh for
+ * .zshrc to avoid false positives with zsh-only syntax like setopt/autoload).
+ * @param {string} rcFile
+ * @returns {string|null}
+ */
+function _getValidatorShell(rcFile) {
+  const base = path.basename(rcFile);
+  if (base === '.zshrc') return 'zsh';
+  if (base === '.bashrc' || base === '.bash_profile') return 'bash';
+  return null;
+}
+
+function _injectIntoFile(rcFile, installDir, dryRun) {
+  const hookSh = path.join(installDir, 'scripts', 'shell-hook.sh');
+  // Canonical format matches install.sh: marker line + source line (no closing marker).
+  const block  = `\n${MARKER}\nsource "${hookSh}"\n`;
+
+  if (dryRun) {
+    dryRunLog(`backup ${rcFile}`);
+    dryRunLog(`inject shell hook into ${rcFile}`);
+    return;
+  }
+
+  if (!fs.existsSync(rcFile)) {
+    fs.mkdirSync(path.dirname(rcFile), { recursive: true });
+    fs.writeFileSync(rcFile, '', 'utf8');
+  }
+
+  // Backup before modification — matches install.sh lines 1360-1369.
+  const ts     = new Date().toISOString().replace(/[:.]/g, '-');
+  const backup = rcFile + '.claws-bak.' + ts;
+  try {
+    fs.copyFileSync(rcFile, backup);
+  } catch (e) {
+    process.stderr.write(`  ! Warning: could not backup ${rcFile}: ${e.message}\n`);
+  }
+
+  const original = fs.readFileSync(rcFile, 'utf8');
+  const cleaned  = _removePriorBlock(original);
+  const updated  = cleaned + block;
+
+  const tmp = rcFile + '.claws-tmp.' + process.pid;
+  fs.writeFileSync(tmp, updated, 'utf8');
+  fs.renameSync(tmp, rcFile);
+
+  // Syntax validation — matches install.sh lines 1423-1432.
+  const shellBin = _getValidatorShell(rcFile);
+  if (shellBin) {
+    const check = spawnSync(shellBin, ['-n', rcFile], { encoding: 'utf8', stdio: 'pipe' });
+    if (check.status !== 0) {
+      process.stderr.write(
+        `  ! Warning: ${path.basename(rcFile)} failed ${shellBin} -n check — backup at ${backup}\n`
+      );
+    }
+  }
+}
+
+/**
+ * Remove any prior Claws shell hook block from content.
+ * Handles both formats:
+ *   - Canonical (install.sh): "# CLAWS terminal hook" marker + following source line
+ *   - Legacy (old Node installer): "# >>> claws-code shell hook >>>" ... "# <<< ... <<<"
+ * Mirrors the awk cleanup pattern in install.sh's inject_hook():
+ *   /# CLAWS terminal hook/ { skip = 1; next }
+ *   skip && /source.*shell-hook\.sh/ { skip = 0; next }
+ *   skip { skip = 0; print }
+ *   { print }
+ * @param {string} content
+ * @returns {string}
+ */
+function _removePriorBlock(content) {
+  // Step 1: one-time migration — strip legacy >>>...<<< block if present.
+  content = _removeLegacyBlock(content);
+
+  // Step 2: strip canonical format — marker line + following source line.
+  const lines = content.split('\n');
+  const out = [];
+  let skip = false;
+  for (const line of lines) {
+    if (/# CLAWS terminal hook/.test(line)) {
+      skip = true;
+      continue;
+    }
+    if (skip && /shell-hook\.(sh|ps1)/.test(line)) {
+      skip = false;
+      continue;
+    }
+    if (skip) {
+      // Marker found but next line is not a source line — keep it, stop skipping.
+      skip = false;
+      out.push(line);
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join('\n').replace(/\n+$/, '');
+}
+
+/**
+ * Strip the legacy Node-installer >>>...<<< block from content.
+ * @param {string} content
+ * @returns {string}
+ */
+function _removeLegacyBlock(content) {
+  const beginRe = /^# >>> claws-code shell hook >>>$/m;
+  const endRe   = /^# <<< claws-code shell hook <<<$/m;
+
+  const beginIdx = content.search(beginRe);
+  if (beginIdx === -1) return content;
+
+  const afterBegin = content.slice(beginIdx);
+  const endMatch   = afterBegin.match(endRe);
+  if (!endMatch) return content;
+
+  const endIdx = beginIdx + afterBegin.indexOf(endMatch[0]) + endMatch[0].length;
+  return content.slice(0, beginIdx).replace(/\n+$/, '') + content.slice(endIdx);
+}
+
+module.exports = {
+  injectShellHook, removeShellHook,
+  _getStandardRcFiles, _getValidatorShell,
+  _injectFishHook, _injectNushellHook, _injectPowershellHook,
+  _injectIntoFile, _removePriorBlock, _removeLegacyBlock,
+};

package/lib/uninstall.js

@@ -0,0 +1,162 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const { spawnSync } = require('child_process');
+
+const { findCodeCli, getDefaultShellRcFile, dryRunLog } = require('./platform.js');
+const { sweepCommands, sweepSkills }  = require('./capabilities.js');
+const { removeShellHook }             = require('./shell-hook.js');
+const { removeMcpEntry }              = require('./mcp-setup.js');
+
+const HOME      = os.homedir();
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+function _step(label) { process.stdout.write(`\n\x1b[1m${label}\x1b[0m\n`); }
+function _ok(msg)     { process.stdout.write(`  \x1b[32m✓\x1b[0m ${msg}\n`); }
+function _warn(msg)   { process.stdout.write(`  \x1b[33m!\x1b[0m ${msg}\n`); }
+
+/**
+ * Reverse of install: remove all Claws artifacts from the current project and ~/.claude/.
+ * @param {object} [opts]
+ * @param {boolean} [opts.dryRun]
+ */
+function run(opts = {}) {
+  const { dryRun = false } = opts;
+  const projectRoot = process.cwd();
+  const claudeDir   = path.join(HOME, '.claude');
+
+  process.stdout.write('\nUninstalling Claws...\n');
+
+  // 1. VS Code extension
+  _step('Uninstall VS Code extension');
+  _uninstallExtension(dryRun);
+
+  // 2. .claws-bin/
+  _step('Remove .claws-bin/');
+  const clawsBin = path.join(projectRoot, '.claws-bin');
+  if (dryRun) {
+    dryRunLog(`rm -rf ${clawsBin}`);
+  } else if (fs.existsSync(clawsBin)) {
+    fs.rmSync(clawsBin, { recursive: true });
+    _ok('.claws-bin/ removed');
+  }
+
+  // 3. .mcp.json claws entry
+  _step('Remove claws entry from .mcp.json');
+  removeMcpEntry(projectRoot, dryRun);
+  if (!dryRun) _ok('.mcp.json updated');
+
+  // 4. CLAUDE.md CLAWS:BEGIN block (project)
+  _step('Remove CLAWS:BEGIN block from CLAUDE.md');
+  _removeClawsBlock(
+    path.join(projectRoot, 'CLAUDE.md'),
+    /<!-- CLAWS:BEGIN(?:[^>]*)-->/,
+    /<!-- CLAWS:END(?:[^>]*)-->/,
+    dryRun
+  );
+
+  // 5. ~/.claude/CLAUDE.md CLAWS-GLOBAL:BEGIN block
+  _step('Remove CLAWS-GLOBAL:BEGIN block from ~/.claude/CLAUDE.md');
+  _removeClawsBlock(
+    path.join(HOME, '.claude', 'CLAUDE.md'),
+    /<!-- CLAWS-GLOBAL:BEGIN(?:[^>]*)-->/,
+    /<!-- CLAWS-GLOBAL:END(?:[^>]*)-->/,
+    dryRun
+  );
+
+  // 6. Hooks from settings.json
+  _step('Remove hooks from ~/.claude/settings.json');
+  _removeHooks(dryRun);
+
+  // 7. claws-default-behavior.md rule
+  _step('Remove claws-default-behavior.md');
+  const rulePath = path.join(claudeDir, 'rules', 'claws-default-behavior.md');
+  if (dryRun) {
+    dryRunLog(`rm ${rulePath}`);
+  } else if (fs.existsSync(rulePath)) {
+    fs.rmSync(rulePath);
+    _ok('claws-default-behavior.md removed');
+  }
+
+  // 8. Commands + skills (global)
+  _step('Remove commands and skills from ~/.claude/');
+  sweepCommands(path.join(claudeDir, 'commands'), dryRun);
+  sweepSkills(path.join(claudeDir, 'skills'),    dryRun);
+  if (!dryRun) _ok('Commands and skills removed');
+
+  // 9. Shell hook
+  _step('Remove shell hook');
+  const rcFile = getDefaultShellRcFile();
+  removeShellHook(rcFile, dryRun);
+  if (!dryRun) _ok(`Shell hook removed from ${rcFile}`);
+
+  process.stdout.write('\n  \x1b[32m✓ Claws uninstalled\x1b[0m\n\n');
+}
+
+function _uninstallExtension(dryRun) {
+  const codeCli = findCodeCli();
+  if (!codeCli) {
+    _warn('VS Code CLI not found — extension may still be installed; remove manually');
+    return;
+  }
+
+  if (dryRun) { dryRunLog(`${codeCli} --uninstall-extension neunaha.claws`); return; }
+
+  const r = spawnSync(codeCli, ['--uninstall-extension', 'neunaha.claws'], {
+    stdio: 'inherit', encoding: 'utf8',
+  });
+  if (r.status === 0) { _ok('VS Code extension uninstalled'); return; }
+
+  // CLI failed — remove extension directory directly
+  const extDirs = [
+    path.join(HOME, '.vscode', 'extensions'),
+    path.join(HOME, '.cursor', 'extensions'),
+  ];
+  let removed = false;
+  for (const dir of extDirs) {
+    if (!fs.existsSync(dir)) continue;
+    for (const entry of fs.readdirSync(dir).filter(f => f.startsWith('neunaha.claws-'))) {
+      fs.rmSync(path.join(dir, entry), { recursive: true });
+      removed = true;
+    }
+  }
+  if (removed) { _ok('Extension directory removed'); } else { _warn('Extension not found in extensions dirs'); }
+}
+
+function _removeClawsBlock(filePath, beginRe, endRe, dryRun) {
+  if (!fs.existsSync(filePath)) return;
+
+  if (dryRun) { dryRunLog(`remove claws block from ${filePath}`); return; }
+
+  let content = fs.readFileSync(filePath, 'utf8');
+  const beginMatch = content.match(beginRe);
+  if (!beginMatch) return;
+
+  const beginIdx = content.indexOf(beginMatch[0]);
+  const endMatch  = content.match(endRe);
+  if (!endMatch) return;
+
+  const endIdx = content.lastIndexOf(endMatch[0]) + endMatch[0].length;
+  content = (content.slice(0, beginIdx) + content.slice(endIdx)).replace(/\n{3,}/g, '\n\n');
+
+  const tmp = filePath + '.claws-tmp.' + process.pid;
+  fs.writeFileSync(tmp, content, 'utf8');
+  fs.renameSync(tmp, filePath);
+  _ok(`CLAWS block removed from ${path.basename(filePath)}`);
+}
+
+function _removeHooks(dryRun) {
+  const script    = path.join(REPO_ROOT, 'scripts', 'inject-settings-hooks.js');
+  const hooksDir  = path.join(REPO_ROOT, 'scripts');
+  const extraArgs = dryRun ? [hooksDir, '--dry-run', '--remove'] : [hooksDir, '--remove'];
+
+  if (!fs.existsSync(script)) { _warn('inject-settings-hooks.js not found — hooks not removed'); return; }
+
+  spawnSync(process.execPath, [script, ...extraArgs], {
+    cwd: REPO_ROOT, stdio: 'inherit', encoding: 'utf8',
+  });
+}
+
+module.exports = { run };

package/lib/verify.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const { spawnSync, spawn } = require('child_process');
+
+/**
+ * Post-install verification. Returns array of failure strings (empty = OK).
+ * All checks use project-local paths under projectRoot/.claude/ — matching
+ * where lib/install.js (W7-6) places skills and rules.
+ * @param {string} projectRoot
+ * @returns {string[]}
+ */
+function verify(projectRoot) {
+  const failures = [];
+
+  if (!fs.existsSync(path.join(projectRoot, '.claws-bin', 'mcp_server.js'))) {
+    failures.push('.claws-bin/mcp_server.js missing');
+  }
+  if (!fs.existsSync(path.join(projectRoot, '.mcp.json'))) {
+    failures.push('.mcp.json missing');
+  }
+  if (!fs.existsSync(path.join(projectRoot, '.claude', 'commands', 'claws.md'))) {
+    failures.push('claws commands missing from .claude/commands/');
+  }
+  if (!fs.existsSync(path.join(projectRoot, '.claude', 'skills', 'claws-prompt-templates'))) {
+    failures.push('claws skills missing from .claude/skills/');
+  }
+  if (!fs.existsSync(path.join(projectRoot, '.claude', 'rules', 'claws-default-behavior.md'))) {
+    failures.push('claws rule missing from .claude/rules/');
+  }
+
+  // W7h-28: Live MCP server handshake test (matches install.sh:1540-1557).
+  // Spawns mcp_server.js, sends an initialize JSON-RPC request, expects
+  // a response containing "claws" within 3s.
+  const mcpServer = path.join(projectRoot, '.claws-bin', 'mcp_server.js');
+  if (fs.existsSync(mcpServer)) {
+    const handshakeResult = _mcpHandshake(mcpServer);
+    if (!handshakeResult) {
+      failures.push(`MCP server failed to respond — run: node ${mcpServer}`);
+    }
+  }
+
+  // W7h-29: Hook registration check (matches install.sh:1508-1528).
+  // Parse ~/.claude/settings.json and assert PreToolUse + PostToolUse hooks
+  // are registered with Claws _source.
+  const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    const hookFailures = _checkHooksRegistered(settingsPath);
+    for (const f of hookFailures) failures.push(f);
+  }
+
+  return failures;
+}
+
+/**
+ * Spawn mcp_server.js, send initialize JSON-RPC, expect response with "claws" in 3s.
+ * Returns true if handshake succeeded, false otherwise.
+ * @param {string} mcpServerPath
+ * @returns {boolean}
+ */
+function _mcpHandshake(mcpServerPath) {
+  try {
+    const req = JSON.stringify({
+      jsonrpc: '2.0', id: 1, method: 'initialize',
+      params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'claws-verify', version: '1' } },
+    }) + '\n';
+
+    // Run the handshake in a synchronous subprocess via a self-contained node -e script.
+    const script = `
+const {spawn} = require('child_process');
+const mcp = spawn('node', [process.argv[1]], {stdio:['pipe','pipe','ignore']});
+let buf = '';
+const done = (ok) => { try{mcp.kill()}catch{} process.exit(ok ? 0 : 1); };
+const timer = setTimeout(() => done(false), 3000);
+mcp.stdout.on('data', d => {
+  buf += d.toString();
+  if (buf.includes('claws')) { clearTimeout(timer); done(true); }
+});
+mcp.on('error', () => { clearTimeout(timer); done(false); });
+mcp.stdin.write(${JSON.stringify(req)});
+`;
+    const r = spawnSync(process.execPath, ['-e', script, mcpServerPath],
+      { encoding: 'utf8', timeout: 5000 });
+    return r.status === 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Parse ~/.claude/settings.json and check that PreToolUse + PostToolUse
+ * spawn-class hooks are registered (W7h-29). Matches install.sh:1508-1528.
+ * @param {string} settingsPath
+ * @returns {string[]} array of failure strings
+ */
+function _checkHooksRegistered(settingsPath) {
+  const failures = [];
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (_) {
+    return [];
+  }
+
+  const hooks   = settings.hooks || {};
+  const preHooks = Array.isArray(hooks.PreToolUse)  ? hooks.PreToolUse  : [];
+  const postHooks = Array.isArray(hooks.PostToolUse) ? hooks.PostToolUse : [];
+
+  const hasClawsPre  = preHooks.some(h => h.matcher && h.matcher.includes('mcp__claws__claws_worker'));
+  const hasClawsPost = postHooks.some(h => h.matcher && h.matcher.includes('mcp__claws__claws_worker'));
+
+  if (!hasClawsPre) {
+    failures.push('MCP spawn-class PreToolUse hooks missing — re-run: node scripts/inject-settings-hooks.js');
+  }
+  if (!hasClawsPost) {
+    failures.push('PostToolUse spawn-class hooks missing — re-run: node scripts/inject-settings-hooks.js');
+  }
+  return failures;
+}
+
+/**
+ * Print a human-readable status dashboard for the current project.
+ * Sets process.exitCode = 1 when any check fails.
+ * All path checks are project-local (cwd-relative), matching install.sh behavior.
+ */
+function status() {
+  const cwd = process.cwd();
+  process.stdout.write('\nClaws installation status\n\n');
+
+  const checks = [
+    ['Node.js ≥ 18',             _nodeOk()],
+    ['git in PATH',              _gitOk()],
+    ['.claws-bin/ present',      fs.existsSync(path.join(cwd, '.claws-bin'))],
+    ['.mcp.json present',        fs.existsSync(path.join(cwd, '.mcp.json'))],
+    ['mcp_server.js in .claws-bin', fs.existsSync(path.join(cwd, '.claws-bin', 'mcp_server.js'))],
+    ['commands present',         fs.existsSync(path.join(cwd, '.claude', 'commands', 'claws.md'))],
+    ['skills present',           fs.existsSync(path.join(cwd, '.claude', 'skills', 'claws-prompt-templates'))],
+    ['behavior rule present',    fs.existsSync(path.join(cwd, '.claude', 'rules', 'claws-default-behavior.md'))],
+  ];
+
+  let passing = 0;
+  for (const [label, pass] of checks) {
+    const icon  = pass ? '✓' : '✗';
+    const color = pass ? '\x1b[32m' : '\x1b[31m';
+    process.stdout.write(`  ${color}${icon}\x1b[0m ${label}\n`);
+    if (pass) passing++;
+  }
+
+  process.stdout.write(`\n  ${passing}/${checks.length} checks passing\n\n`);
+  if (passing < checks.length) {
+    process.stdout.write('  Run: claws-code install\n\n');
+    process.exitCode = 1;
+  }
+}
+
+function _nodeOk() {
+  return Number(process.versions.node.split('.')[0]) >= 18;
+}
+
+function _gitOk() {
+  return spawnSync('git', ['--version'], { stdio: 'pipe' }).status === 0;
+}
+
+module.exports = { verify, status };