@haposoft/cafekit 0.16.0-rc.8 → 0.16.1

package/src/claude/hooks/__tests__/statusline.test.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const STATUS_PATH = path.resolve(__dirname, '..', '..', 'status.cjs');
+const GOLDEN_PATH = path.join(__dirname, 'fixtures', 'statusline-default.golden');
+const NBSP = / /g;
+
+const cleanupDirs = [];
+process.on('exit', () => {
+  for (const dir of cleanupDirs) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+function basePayload(overrides = {}) {
+  return {
+    model: { display_name: 'TestModel' },
+    workspace: { current_dir: '/fixture/dir' },
+    cwd: '/fixture/dir',
+    context_window: {
+      context_window_size: 200000,
+      current_usage: {
+        input_tokens: 40000,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 20000,
+      },
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Spawn status.cjs as a child process under a fully pinned environment:
+ * - cwd: a fixture root carrying its own .claude/runtime.json
+ * - TMPDIR/TEMP/TMP: an isolated per-case temp root (git + usage + context caches)
+ * - NO_COLOR/FORCE_COLOR scrubbed unless the case provides them
+ * - COLUMNS pinned so responsive wrapping is deterministic
+ */
+function runStatus({ runtime = { statusline: 'full', statuslineColors: true }, payload = basePayload(), envExtra = {}, tmpFiles = {} } = {}) {
+  const caseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sl-case-'));
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sl-tmp-'));
+  try {
+    fs.mkdirSync(path.join(caseDir, '.claude'));
+    fs.writeFileSync(path.join(caseDir, '.claude', 'runtime.json'), JSON.stringify(runtime));
+    for (const [name, content] of Object.entries(tmpFiles)) {
+      fs.writeFileSync(path.join(tmpDir, name), JSON.stringify(content));
+    }
+    const env = {
+      PATH: process.env.PATH,
+      HOME: process.env.HOME,
+      TMPDIR: tmpDir,
+      TEMP: tmpDir,
+      TMP: tmpDir,
+      COLUMNS: '200',
+      ...envExtra,
+    };
+    const result = spawnSync(process.execPath, [STATUS_PATH], {
+      cwd: caseDir,
+      env,
+      input: Buffer.from(JSON.stringify(payload)),
+    });
+    return {
+      status: result.status,
+      stdoutBuffer: result.stdout,
+      stdout: result.stdout.toString('utf8'),
+      stderr: result.stderr.toString('utf8'),
+      readTmpFile(name) {
+        const p = path.join(tmpDir, name);
+        return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+      },
+    };
+  } finally {
+    // Defer cleanup so readTmpFile still works after the spawn returns.
+    cleanupDirs.push(caseDir, tmpDir);
+  }
+}
+
+function freshUsageCache(now = Date.now()) {
+  return {
+    status: 'available',
+    timestamp: now,
+    data: {
+      five_hour: { utilization: 20, resets_at: new Date(now + 2 * 3600 * 1000 + 29 * 60 * 1000).toISOString() },
+      seven_day: { utilization: 45, resets_at: new Date(now + (2 * 86400 + 5 * 3600) * 1000).toISOString() },
+    },
+  };
+}
+
+test('statusline default output is byte-identical to the golden fixture when no layout is configured', () => {
+  const golden = fs.readFileSync(GOLDEN_PATH);
+  const run = runStatus();
+  assert.equal(run.status, 0, run.stderr);
+  assert.ok(run.stdoutBuffer.equals(golden),
+    `default output drifted from golden\nexpected: ${JSON.stringify(golden.toString('utf8'))}\nactual:   ${JSON.stringify(run.stdout)}`);
+});
+
+test('statusline custom layout renders named sections in order per line', () => {
+  const run = runStatus({
+    runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['directory', 'model']] } },
+  });
+  assert.equal(run.status, 0, run.stderr);
+  const dirIndex = run.stdout.indexOf('📁');
+  const modelIndex = run.stdout.indexOf('🤖');
+  assert.ok(dirIndex >= 0 && modelIndex >= 0, run.stdout);
+  assert.ok(dirIndex < modelIndex, `directory must precede model: ${JSON.stringify(run.stdout)}`);
+});
+
+test('statusline ignores unknown section ids without crashing or rendering placeholders', () => {
+  const run = runStatus({
+    runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['model', 'bogus']] } },
+  });
+  assert.equal(run.status, 0, run.stderr);
+  assert.match(run.stdout, /🤖/);
+  assert.doesNotMatch(run.stdout, /bogus/);
+});
+
+test('statusline modes slice the layout line count (minimal renders only the first line)', () => {
+  const run = runStatus({
+    runtime: { statusline: 'minimal', statuslineColors: true, statuslineLayout: { lines: [['model'], ['directory']] } },
+  });
+  assert.equal(run.status, 0, run.stderr);
+  assert.match(run.stdout, /🤖/);
+  assert.doesNotMatch(run.stdout, /📁/);
+});
+
+test('statusline empty or invalid layout falls back to the default renderers', () => {
+  const golden = fs.readFileSync(GOLDEN_PATH);
+  for (const layout of [{}, { lines: [] }, { lines: [['bogus']] }, 'nonsense']) {
+    const run = runStatus({
+      runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: layout },
+    });
+    assert.equal(run.status, 0, run.stderr);
+    assert.ok(run.stdoutBuffer.equals(golden), `fallback drifted for layout ${JSON.stringify(layout)}: ${JSON.stringify(run.stdout)}`);
+  }
+});
+
+test('statusline shows five-hour and weekly windows with countdowns when the cache is fresh', () => {
+  const run = runStatus({ tmpFiles: { 'ck-usage-limits-cache.json': freshUsageCache() } });
+  assert.equal(run.status, 0, run.stderr);
+  const plain = run.stdout.replace(NBSP, ' ');
+  assert.match(plain, /⌛ \d+h \d+m left \(20% used\)/, plain);
+  assert.match(plain, /wk 45% \(\d+d \d+h\)/, plain);
+});
+
+test('statusline hides the quota area when the cache is stale', () => {
+  const stale = freshUsageCache(Date.now() - 10 * 60 * 1000);
+  stale.timestamp = Date.now() - 10 * 60 * 1000;
+  const run = runStatus({ tmpFiles: { 'ck-usage-limits-cache.json': stale } });
+  assert.equal(run.status, 0, run.stderr);
+  assert.doesNotMatch(run.stdout, /⌛/);
+  assert.doesNotMatch(run.stdout, /wk /);
+});
+
+test('statusline cost renders only when the layout enables it, billing is api, and data exists', () => {
+  const costLayout = { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['model', 'cost']] } };
+  const withCost = basePayload({ cost: { total_cost_usd: '1.2345' } });
+
+  const enabled = runStatus({ runtime: costLayout, payload: withCost, envExtra: { CLAUDE_BILLING_MODE: 'api' } });
+  assert.equal(enabled.status, 0, enabled.stderr);
+  const plain = enabled.stdout.replace(NBSP, ' ');
+  assert.match(plain, /💵 \$1\.23(?!\d)/, plain);
+
+  const wrongBilling = runStatus({ runtime: costLayout, payload: withCost, envExtra: { CLAUDE_BILLING_MODE: 'subscription' } });
+  assert.equal(wrongBilling.status, 0, wrongBilling.stderr);
+  assert.doesNotMatch(wrongBilling.stdout, /💵/);
+
+  const noData = runStatus({ runtime: costLayout, envExtra: { CLAUDE_BILLING_MODE: 'api' } });
+  assert.equal(noData.status, 0, noData.stderr);
+  assert.doesNotMatch(noData.stdout, /💵/);
+
+  const noLayout = runStatus({ payload: withCost, envExtra: { CLAUDE_BILLING_MODE: 'api' } });
+  assert.equal(noLayout.status, 0, noLayout.stderr);
+  assert.doesNotMatch(noLayout.stdout, /💵/);
+});
+
+test('statusline writes the ck-context session file regardless of layout', () => {
+  const run = runStatus({
+    runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['model']] } },
+    payload: basePayload({ session_id: 'ctxcase' }),
+  });
+  assert.equal(run.status, 0, run.stderr);
+  const contextFile = run.readTmpFile('ck-context-ctxcase.json');
+  assert.ok(contextFile, 'ck-context-ctxcase.json must be written even under a custom layout');
+  assert.equal(typeof contextFile.percent, 'number');
+  assert.equal(typeof contextFile.tokens, 'number');
+});
+
+test('statusline honors NO_COLOR with no ANSI escapes in output', () => {
+  const run = runStatus({ envExtra: { NO_COLOR: '1' } });
+  assert.equal(run.status, 0, run.stderr);
+  assert.doesNotMatch(run.stdout, /\[/);
+});

package/src/claude/hooks/agent.cjs

@@ -15,19 +15,23 @@ try {
   const fs   = require('fs');
   const path = require('path');
 
-  /** Read .claude/runtime.json */
+  /** Read <runtime>/runtime.json */
+  const { runtimeDirName, runtimeDir, runtimePath } = require('./lib/runtime-dir.cjs');
   function readRuntime(cwd) {
     try {
-      const p = path.join(cwd, '.claude', 'runtime.json');
+      const p = runtimePath(cwd, 'runtime.json');
       return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
     } catch { return null; }
   }
 
+  // Skills live beside the runtime only on Claude; Codex and omp read `.agents/skills`.
+  function skillsDir() { return runtimeDirName() === '.claude' ? '.claude/skills' : '.agents/skills'; }
+
   /** Resolve Python venv executable path if it exists */
   function resolveVenv(cwd) {
     const candidates = [
-      path.join(cwd, '.claude', 'skills', '.venv', 'bin', 'python3'),
-      path.join(cwd, '.claude', 'skills', '.venv', 'Scripts', 'python.exe'),
+      path.join(cwd, skillsDir(), '.venv', 'bin', 'python3'),
+      path.join(cwd, skillsDir(), '.venv', 'Scripts', 'python.exe'),
     ];
     return candidates.find(p => fs.existsSync(p)) || null;
   }
@@ -37,7 +41,8 @@ try {
   const stdin = fs.readFileSync(0, 'utf8').trim();
   if (!stdin) process.exit(0);
 
-  const payload    = JSON.parse(stdin);
+  const { normalizeHookPayload } = require('./lib/hook-payload.cjs');
+  const payload    = normalizeHookPayload(JSON.parse(stdin));
   // Use payload.cwd for monorepo support — subagent may run in a different dir
   const payloadCwd = typeof payload.cwd === 'string' ? payload.cwd.trim() : '';
   const agentCwd   = payloadCwd || process.env.PROJECT_ROOT || process.cwd();
@@ -67,13 +72,13 @@ try {
     lines.push('');
   }
 
-  // Python venv (optional — if .claude/skills/.venv exists)
+  // Python venv (optional — if <skills>/.venv exists)
   const venv = resolveVenv(agentCwd);
 
   lines.push('## Rules');
   lines.push(`- Plans → ${plansPath}/ | Docs → ${docsPath}/`);
   if (venv) {
-    lines.push(`- Python in .claude/skills/: use \`${venv}\``);
+    lines.push(`- Python in ${skillsDir()}/: use \`${venv}\``);
     lines.push('- Never use global pip install');
   }
 
@@ -90,7 +95,7 @@ try {
 } catch (e) {
   try {
     const fs = require('fs'), p = require('path');
-    const d = p.join(__dirname, '.logs');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'agent', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/completion-authority.cjs

@@ -3,6 +3,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { runtimeDirName, runtimeDir, runtimePath } = require('./lib/runtime-dir.cjs');
 let STATE;
 let evaluateCloseout;
 
@@ -27,7 +28,7 @@ function projectRoot(payload = {}) {
   }
 
   const installedRoot = path.resolve(__dirname, '..', '..');
-  const installedHook = path.join(installedRoot, '.claude', 'hooks', path.basename(__filename));
+  const installedHook = runtimePath(installedRoot, 'hooks', path.basename(__filename));
   if (fs.existsSync(installedHook)) return installedRoot;
 
   const sourceFixture = typeof process.env.PROJECT_ROOT === 'string'
@@ -50,7 +51,7 @@ function sessionId(payload) {
 
 function readRuntime(root) {
   try {
-    const file = path.join(root, '.claude', 'runtime.json');
+    const file = runtimePath(root, 'runtime.json');
     return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : {};
   } catch { return {}; }
 }
@@ -135,9 +136,14 @@ function stop(payload) {
 
 let mode = process.argv[2] || null;
 try {
-  const payload = readPayload();
+  const raw = readPayload();
+  // Read the loop guard before normalization: the catch below answers a block, so a
+  // reader failure must not be able to reach it. Both spellings are accepted here.
+  const hostLoop = raw.stop_hook_active === true || raw.stopHookActive === true;
+  const { normalizeHookPayload } = require('./lib/hook-payload.cjs');
+  const payload = normalizeHookPayload(raw);
   mode = mode || (payload.hook_event_name === 'UserPromptSubmit' ? '--approve' : '--stop');
-  if (mode === '--stop' && payload.stop_hook_active === true) {
+  if (mode === '--stop' && hostLoop) {
     // Host loop prevention is always silent, including when dependencies are unavailable.
   } else {
     const dependencyError = loadAuthority();

package/src/claude/hooks/docs-sync.cjs

@@ -14,16 +14,20 @@
 try {
   const fs = require('fs');
   const path = require('path');
-  const { execSync } = require('child_process');
+  const { execFileSync } = require('child_process');
   const { loadConfig } = require('./lib/config.cjs');
 
   // Đọc stdin theo chuẩn hook
   const stdin = fs.readFileSync(0, 'utf8').trim();
-  const payload = stdin ? JSON.parse(stdin) : {};
+  const { normalizeHookPayload } = require('./lib/hook-payload.cjs');
+  const payload = stdin ? normalizeHookPayload(JSON.parse(stdin)) : {};
   const cwd = payload.cwd || process.cwd();
   const config = loadConfig({ cwd, includeProject: false, includeAssertions: false, includeLocale: false });
 
   const docsDir = path.join(cwd, config.paths?.docs || 'docs');
+  const specsDir = path.join(cwd, config.paths?.specs || 'specs');
+  const docsRelative = path.relative(cwd, docsDir).replace(/\\/g, '/');
+  const specsRelative = path.relative(cwd, specsDir).replace(/\\/g, '/');
   
   // Xác định dự án đã có cốt lõi code hay chưa?
   const hasCode = fs.existsSync(path.join(cwd, 'src')) ||
@@ -46,16 +50,18 @@ try {
     lines.push('> Source exists but `docs/` does not. Create baseline docs first:');
     lines.push('> 1. `docs/system-architecture.md` — system architecture and flows');
     lines.push('> 2. `docs/project-overview-pdr.md` — overview, goals, features');
-    lines.push('> 3. Write current hash to `docs/.sync_hash` via `git log -1 --format="%H" -- . ":(exclude)docs"`');
+    lines.push('> 3. Write the latest non-docs/non-Specs source hash to `docs/.sync_hash`.');
     lines.push('');
   }
   // Case 2: docs exist — check continuous sync vs source-only git hash
   else {
     try {
       // Latest SOURCE-only hash (ignore docs-only commits)
-      const currentHash = execSync('git log -1 --format="%H" -- . ":(exclude)docs"', { 
-        cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] 
-      }).trim();
+      const currentHash = execFileSync('git', [
+        'log', '-1', '--format=%H', '--', '.',
+        `:(exclude,literal)${docsRelative}`,
+        `:(exclude,literal)${specsRelative}`,
+      ], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
 
       if (currentHash) {
         const syncTrackingFile = path.join(docsDir, '.sync_hash');
@@ -87,11 +93,8 @@ try {
 } catch (e) {
   // Ghi log lỗi ẩn danh nếu sập hook
   try {
-    const fs = require('fs'), p = require('path'), os = require('os');
-    const isSourceTree = __dirname.includes(`${p.sep}packages${p.sep}spec${p.sep}src`);
-    const d = isSourceTree
-      ? p.join(os.tmpdir(), 'cafekit-hook-logs', 'claude-docs-sync')
-      : p.join(__dirname, '.logs');
+    const fs = require('fs'), p = require('path');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'docs-sync', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/inspect-block.cjs

@@ -8,7 +8,7 @@
  * Blocks access to heavy directories that would flood the LLM context window.
  * Also warns on overly-broad glob patterns.
  *
- * Disable: set "inspect": { "enabled": false } in .claude/runtime.json
+ * Disable: set "inspect": { "enabled": false } in <runtime>/runtime.json
  *
  * Exit: 0 = allow, 2 = block
  */
@@ -60,19 +60,41 @@ try {
     return out.filter(Boolean);
   }
 
+  const { runtimeDirName, runtimeDir, runtimePath } = require('./lib/runtime-dir.cjs');
   function readRuntime(cwd) {
     try {
-      const p = path.join(cwd, '.claude', 'runtime.json');
+      const p = runtimePath(cwd, 'runtime.json');
       return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : {};
     } catch { return {}; }
   }
 
   // ── Main ──────────────────────────────────────────────────────────────────
 
+/**
+ * Deny the call with a reason every host can read.
+ *
+ * The reason is the JSON `permissionDecisionReason`, which Claude Code reads natively and
+ * grok honours "regardless of exit code"; the same text also goes to stderr, because on
+ * an exit-2 denial that is the channel Claude Code feeds back, and grok reads only the
+ * first stderr line. Exit 2 stays so a host that reads neither still blocks.
+ */
+function denyWithReason(reason) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason
+    }
+  }) + '\n');
+  process.stderr.write(reason + '\n');
+  process.exit(2);
+}
+
   const stdin   = fs.readFileSync(0, 'utf8').trim();
   if (!stdin) process.exit(0);
 
-  const data      = JSON.parse(stdin);
+  const { normalizeHookPayload } = require('./lib/hook-payload.cjs');
+  const data      = normalizeHookPayload(JSON.parse(stdin));
   const toolName  = data.tool_name  || '';
   const toolInput = data.tool_input || {};
   const cwd       = data.cwd        || process.cwd();
@@ -88,12 +110,11 @@ try {
 
   // Broad glob check
   if (toolInput.pattern && isBroadGlob(toolInput.pattern)) {
-    console.log(
+    denyWithReason(
       `SCOPE LIMIT EXCEEDED: Glob pattern is excessively broad\n` +
       `Requested Pattern: ${toolInput.pattern}\n\n` +
       `Please narrow your scope (e.g., src/**/*.ts rather than **/*.ts).`
     );
-    process.exit(2);
   }
 
   // Blocked directory check
@@ -101,12 +122,11 @@ try {
   for (const p of paths) {
     if (isBlockedPath(p)) {
       const blocked = p.replace(/\\/g, '/').split('/').find(s => BLOCKED_DIRS.includes(s));
-      console.log(
+      denyWithReason(
         `SCOPE LIMIT EXCEEDED: Directory "${blocked}/" is explicitly forbidden\n` +
         `Requested Path: ${p}\n` +
         `Restricted zones: ${BLOCKED_DIRS.join(', ')}`
       );
-      process.exit(2);
     }
   }
 
@@ -115,7 +135,7 @@ try {
 } catch (e) {
   try {
     const fs = require('fs'), p = require('path');
-    const d = p.join(__dirname, '.logs');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'inspect-block', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/lib/config.cjs

@@ -9,7 +9,10 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const RUNTIME_CONFIG_PATH = '.claude/runtime.json';
+const { runtimeDirName } = require('./runtime-dir.cjs');
+
+// Derived from this library's own location so an install under .omp/ or .codex/ reads its own file.
+const RUNTIME_CONFIG_PATH = `${runtimeDirName()}/runtime.json`;
 
 const CONFIG_PATH = RUNTIME_CONFIG_PATH;
 
@@ -461,7 +464,7 @@ function sanitizeConfig(config, projectRoot) {
  *
  * Resolution order (each layer overrides the previous):
  *   1. DEFAULT_CONFIG (hardcoded defaults)
- *   2. Runtime config (./.claude/runtime.json) - installed CafeKit runtime config
+ *   2. Runtime config (<runtime-dir>/runtime.json, derived by lib/runtime-dir.cjs) - installed CafeKit runtime config
  *
  * @param {Object} options - Options for config loading
  * @param {boolean} options.includeProject - Include project section (default: true)
@@ -520,6 +523,9 @@ function loadConfig(options = {}) {
     // Statusline mode
     result.statusline = merged.statusline || 'full';
     result.statuslineColors = merged.statuslineColors !== false;
+    if (merged.statuslineLayout && typeof merged.statuslineLayout === 'object') {
+      result.statuslineLayout = merged.statuslineLayout;
+    }
 
     return sanitizeConfig(result, projectRoot);
   } catch (e) {

package/src/claude/hooks/lib/counter.cjs

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { runtimeDir } = require('./runtime-dir.cjs');
 
 function getMcpServerNames(filePath) {
   if (!fs.existsSync(filePath)) return new Set();
@@ -83,16 +84,17 @@ function countConfigs(cwd) {
 
   // Project scope
   if (cwd) {
+    const projectRuntime = runtimeDir(cwd);
     if (fs.existsSync(path.join(cwd, 'CLAUDE.md'))) claudeMdCount++;
     if (fs.existsSync(path.join(cwd, 'CLAUDE.local.md'))) claudeMdCount++;
-    if (fs.existsSync(path.join(cwd, '.claude', 'CLAUDE.md'))) claudeMdCount++;
-    if (fs.existsSync(path.join(cwd, '.claude', 'CLAUDE.local.md'))) claudeMdCount++;
-    rulesCount += countRulesInDir(path.join(cwd, '.claude', 'rules'));
+    if (fs.existsSync(path.join(projectRuntime, 'CLAUDE.md'))) claudeMdCount++;
+    if (fs.existsSync(path.join(projectRuntime, 'CLAUDE.local.md'))) claudeMdCount++;
+    rulesCount += countRulesInDir(path.join(projectRuntime, 'rules'));
     mcpCount += countMcpServersInFile(path.join(cwd, '.mcp.json'));
-    const projectSettings = path.join(cwd, '.claude', 'settings.json');
+    const projectSettings = path.join(projectRuntime, 'settings.json');
     mcpCount += countMcpServersInFile(projectSettings);
     hooksCount += countHooksInFile(projectSettings);
-    const localSettings = path.join(cwd, '.claude', 'settings.local.json');
+    const localSettings = path.join(projectRuntime, 'settings.local.json');
     mcpCount += countMcpServersInFile(localSettings);
     hooksCount += countHooksInFile(localSettings);
   }

package/src/claude/hooks/lib/hook-payload.cjs

@@ -0,0 +1,160 @@
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * Hook payload normalization.
+ *
+ * The gate hooks were written against Claude Code's stdin envelope: snake_case keys and
+ * capitalised tool names. Two other hosts run the very same scripts with a different
+ * spelling. Grok CLI loads `.claude/settings.json` through its Claude-compatibility layer
+ * but sends camelCase keys (`toolName`, `stopHookActive`) and its own tool names
+ * (`run_terminal_command`, `read_file`, `search_replace`). Oh My Pi's bridge sends
+ * Claude-shaped keys with lowercase tool names (`bash`, `read`).
+ *
+ * A hook that reads `data.tool_name` on a grok payload gets `undefined`, extracts no
+ * paths, and allows the call: the gate looks installed and is open. This module is the
+ * one place that reconciles those spellings, so every hook keeps a single code path.
+ *
+ * Two rules earn their keep:
+ *
+ *   1. The tool name is aliased by VALUE, under any key. omp already sends `tool_name`,
+ *      so a key-only translation would silently skip its lowercase names.
+ *   2. Every name that can reach a `Bash` matcher must map to `Bash`. Grok expands
+ *      matchers by alias, so a shell call can arrive under a name the hook does not
+ *      recognise; an unmapped name skips the command scan and a secret-bearing command
+ *      is never examined.
+ *
+ * The reader is total: it never throws. Callers include two fail-closed hooks whose final
+ * catch emits a block, so an exception here would block the Stop gate on Claude too.
+ */
+
+'use strict';
+
+/** Grok's event values are snake_case; the hooks compare against Claude's PascalCase. */
+const EVENT_NAMES = Object.freeze({
+  pre_tool_use: 'PreToolUse',
+  post_tool_use: 'PostToolUse',
+  post_tool_use_failure: 'PostToolUseFailure',
+  permission_denied: 'PermissionDenied',
+  user_prompt_submit: 'UserPromptSubmit',
+  session_start: 'SessionStart',
+  session_end: 'SessionEnd',
+  stop: 'Stop',
+  stop_failure: 'StopFailure',
+  stop_cancelled: 'StopCancelled',
+  subagent_start: 'SubagentStart',
+  subagent_stop: 'SubagentStop',
+  pre_compact: 'PreCompact',
+  post_compact: 'PostCompact',
+  notification: 'Notification',
+});
+
+/**
+ * Foreign tool names to the Claude names the rules were authored against.
+ *
+ * Grok's registry and matcher aliases come first, then omp's lowercase registry. Where
+ * both hosts use a spelling (`write`, `grep`) they agree on the destination. `write` is
+ * grok's file-creating tool and maps to `Write`, while `search_replace` edits an existing
+ * file and maps to `Edit`; conflating them would make the scaffold guard reject ordinary
+ * edits. `delete_file` maps to `Write` so a delete is gated like any other file write.
+ */
+const TOOL_ALIASES = Object.freeze({
+  // grok — every spelling that reaches a Bash matcher
+  run_terminal_command: 'Bash',
+  run_terminal_cmd: 'Bash',
+  PowerShell: 'Bash',
+  // grok — file and search tools
+  read_file: 'Read',
+  hashline_read: 'Read',
+  search_replace: 'Edit',
+  hashline_edit: 'Edit',
+  write: 'Write',
+  delete_file: 'Write',
+  grep: 'Grep',
+  grep_search: 'Grep',
+  hashline_grep: 'Grep',
+  list_dir: 'Glob',
+  web_search: 'WebSearch',
+  web_fetch: 'WebFetch',
+  spawn_subagent: 'Task',
+  todo_write: 'TodoWrite',
+  // omp — lowercase registry
+  bash: 'Bash',
+  read: 'Read',
+  edit: 'Edit',
+  glob: 'Glob',
+  find: 'Glob',
+  ls: 'Glob',
+  webfetch: 'WebFetch',
+  websearch: 'WebSearch',
+});
+
+/**
+ * Camel-cased foreign key to the snake_case key the hooks read.
+ *
+ * `transcriptPath` is deliberately absent: grok stores sessions in its own format, and
+ * mapping it would make `state.cjs` stream a file it cannot parse. The last three pairs
+ * cover fields whose grok spelling is unverified, so both spellings are accepted.
+ */
+const KEY_ALIASES = Object.freeze({
+  hookEventName: 'hook_event_name',
+  sessionId: 'session_id',
+  stopHookActive: 'stop_hook_active',
+  lastAssistantMessage: 'last_assistant_message',
+  toolName: 'tool_name',
+  toolInput: 'tool_input',
+  toolUseId: 'tool_use_id',
+  toolResult: 'tool_response',
+  subagentType: 'agent_type',
+  subagentId: 'agent_id',
+  permissionMode: 'permission_mode',
+  workspaceRoot: 'workspace_root',
+  userPrompt: 'prompt',
+  startSource: 'source',
+  compactTrigger: 'trigger',
+});
+
+const owns = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+
+/** The Claude name for a foreign tool, or the input unchanged when unknown. */
+function normalizeToolName(name) {
+  if (typeof name !== 'string' || name === '') return name;
+  return owns(TOOL_ALIASES, name) ? TOOL_ALIASES[name] : name;
+}
+
+/** The Claude name for an event value, or the input unchanged (already PascalCase). */
+function normalizeEventName(value) {
+  if (typeof value !== 'string' || value === '') return value;
+  return owns(EVENT_NAMES, value) ? EVENT_NAMES[value] : value;
+}
+
+/**
+ * A hook payload in the shape the gate scripts read, whatever host sent it.
+ *
+ * Anything that is not a plain object is returned as-is rather than coerced, so a caller
+ * that already guards on shape keeps its own behaviour. The input is never mutated.
+ */
+function normalizeHookPayload(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return payload;
+
+  const out = { ...payload };
+
+  // A snake_case key already present wins: the host that sent it meant it.
+  for (const [foreign, native] of Object.entries(KEY_ALIASES)) {
+    if (owns(out, foreign) && !owns(out, native)) out[native] = out[foreign];
+  }
+
+  if (owns(out, 'hook_event_name')) out.hook_event_name = normalizeEventName(out.hook_event_name);
+  // By value, under whichever key carried it — omp sends `tool_name` with a lowercase value.
+  if (owns(out, 'tool_name')) out.tool_name = normalizeToolName(out.tool_name);
+
+  // grok's `read_file` carries its argument as `path`; the hooks read `file_path`.
+  const input = out.tool_input;
+  if (input && typeof input === 'object' && !Array.isArray(input)
+      && owns(input, 'path') && !owns(input, 'file_path')) {
+    out.tool_input = { ...input, file_path: input.path };
+  }
+
+  return out;
+}
+
+module.exports = { normalizeHookPayload, normalizeToolName, TOOL_ALIASES, KEY_ALIASES, EVENT_NAMES };