gramatr 0.3.0

package/bin/install.ts

@@ -0,0 +1,756 @@
+#!/usr/bin/env node
+/**
+ * gramatr installer — pure TypeScript, no bash dependency.
+ * Runs via node (with tsx loader), bun, or npx tsx.
+ *
+ * Usage:
+ *   npx tsx install.ts                # Universal (Node + tsx)
+ *   bun install.ts                    # If bun is available
+ *   GMTR_TOKEN=xxx npx tsx install.ts # Headless with token
+ *   npx tsx install.ts --yes          # Non-interactive (auto-accept defaults)
+ */
+
+import {
+  existsSync, readFileSync, writeFileSync, mkdirSync, cpSync,
+  readdirSync, statSync, chmodSync, appendFileSync, rmSync,
+} from 'fs';
+import { join, dirname, basename, resolve } from 'path';
+import { execSync, spawnSync } from 'child_process';
+import { createInterface } from 'readline';
+import { buildClaudeHooksFile, detectTsRunner } from '../core/install.ts';
+import { VERSION } from '../core/version.ts';
+
+// ── Constants ──
+
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+const CLAUDE_DIR = join(HOME, '.claude');
+const CLAUDE_SETTINGS = join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_JSON = join(HOME, '.claude.json');
+const CLIENT_DIR = join(HOME, 'gmtr-client');
+const GMTR_JSON = join(HOME, '.gmtr.json');
+const GMTR_BIN = join(HOME, '.gmtr', 'bin');
+const SCRIPT_DIR = dirname(dirname(resolve(import.meta.filename || __filename)));
+const DEFAULT_URL = 'https://api.gramatr.com/mcp';
+
+const args = process.argv.slice(2);
+const YES = args.includes('--yes') || args.includes('-y');
+const isInteractive = process.stdin.isTTY && !YES;
+
+// ── Helpers ──
+
+function log(msg: string): void { process.stdout.write(`${msg}\n`); }
+
+function readJson(path: string): Record<string, any> {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return {}; }
+}
+
+function writeJson(path: string, data: Record<string, any>): void {
+  writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+
+function mergeJson(path: string, fn: (data: Record<string, any>) => Record<string, any>): void {
+  const data = readJson(path);
+  writeJson(path, fn(data));
+}
+
+async function prompt(msg: string, defaultVal?: string): Promise<string> {
+  if (!isInteractive) return defaultVal || '';
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    const display = defaultVal ? `${msg} [${defaultVal}]: ` : `${msg}: `;
+    rl.question(display, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultVal || '');
+    });
+  });
+}
+
+async function confirm(msg: string, defaultYes = true): Promise<boolean> {
+  if (YES) return defaultYes;
+  if (!isInteractive) return defaultYes;
+  const answer = await prompt(`${msg} [${defaultYes ? 'Y/n' : 'y/N'}]`);
+  if (!answer) return defaultYes;
+  return answer.toLowerCase() === 'y';
+}
+
+function countFiles(dir: string, pattern?: RegExp): number {
+  try {
+    return readdirSync(dir).filter(f => !pattern || pattern.test(f)).length;
+  } catch { return 0; }
+}
+
+function countFilesRecursive(dir: string): number {
+  let count = 0;
+  try {
+    for (const f of readdirSync(dir)) {
+      const p = join(dir, f);
+      const s = statSync(p);
+      if (s.isDirectory()) count += countFilesRecursive(p);
+      else count++;
+    }
+  } catch { /* ignore */ }
+  return count;
+}
+
+function copyDir(src: string, dest: string): void {
+  mkdirSync(dest, { recursive: true });
+  cpSync(src, dest, { recursive: true, force: true });
+}
+
+function dirSize(dir: string): string {
+  let total = 0;
+  const walk = (d: string) => {
+    try {
+      for (const f of readdirSync(d)) {
+        const p = join(d, f);
+        const s = statSync(p);
+        if (s.isDirectory()) walk(p); else total += s.size;
+      }
+    } catch { /* ignore */ }
+  };
+  walk(dir);
+  if (total > 1048576) return `${(total / 1048576).toFixed(1)}M`;
+  if (total > 1024) return `${(total / 1024).toFixed(0)}K`;
+  return `${total}B`;
+}
+
+function which(cmd: string): string | null {
+  try {
+    return execSync(`command -v ${cmd}`, { encoding: 'utf8' }).trim() || null;
+  } catch { return null; }
+}
+
+function copyFileIfExists(src: string, dest: string, executable = false): boolean {
+  if (!existsSync(src)) return false;
+  mkdirSync(dirname(dest), { recursive: true });
+  cpSync(src, dest, { force: true });
+  if (executable) chmodSync(dest, 0o755);
+  return true;
+}
+
+function timestamp(): string {
+  return new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+}
+
+// ── Prerequisites ──
+
+async function checkPrereqs(): Promise<{ tsRunner: string }> {
+  // Node.js
+  const nodeVer = process.versions.node;
+  const major = parseInt(nodeVer.split('.')[0], 10);
+  if (major < 20) {
+    log(`X Node.js 20+ required (found: ${nodeVer})`);
+    process.exit(1);
+  }
+  log(`OK Node.js v${nodeVer}`);
+
+  // Detect best TypeScript runner
+  const tsRunner = detectTsRunner();
+  if (tsRunner === 'bun') {
+    try {
+      const ver = execSync('bun --version', { encoding: 'utf8' }).trim();
+      log(`OK TS runner: bun ${ver}`);
+    } catch {
+      log(`OK TS runner: bun`);
+    }
+  } else {
+    log(`OK TS runner: npx tsx (install bun for faster hooks)`);
+  }
+
+  // Ensure ~/.gmtr/bin exists and is on PATH
+  mkdirSync(GMTR_BIN, { recursive: true });
+  const pathLine = 'export PATH="$HOME/.gmtr/bin:$PATH"';
+  for (const rc of ['.zshrc', '.bashrc']) {
+    const rcPath = join(HOME, rc);
+    if (existsSync(rcPath)) {
+      const content = readFileSync(rcPath, 'utf8');
+      if (!content.includes('.gmtr/bin')) {
+        appendFileSync(rcPath, `\n# gramatr — local tool binaries\n${pathLine}\n`);
+      }
+    }
+  }
+
+  // Claude Code
+  if (!existsSync(CLAUDE_DIR)) {
+    log('X Claude Code not found (~/.claude/ does not exist)');
+    process.exit(1);
+  }
+  log('OK Claude Code directory exists');
+
+  return { tsRunner };
+}
+
+// ── Legacy Detection ──
+
+async function handleLegacy(): Promise<{ legacyToken: string }> {
+  let legacyToken = '';
+
+  // Check for aios MCP server
+  if (existsSync(CLAUDE_JSON)) {
+    const claudeJson = readJson(CLAUDE_JSON);
+    const aiosUrl = claudeJson.mcpServers?.aios?.url;
+    const aiosAuth = claudeJson.mcpServers?.aios?.headers?.Authorization;
+    const aiosToken = aiosAuth?.replace('Bearer ', '') || '';
+
+    if (aiosUrl) {
+      log('━━━ Legacy Installation Detected ━━━');
+      log('');
+      log(`  Found: aios MCP server`);
+      log(`  URL:   ${aiosUrl}`);
+      if (aiosToken) log(`  Token: ${aiosToken.slice(0, 20)}... (present)`);
+      log('');
+
+      if (await confirm('  Migrate to gramatr? This removes aios config and reuses your auth token.')) {
+        if (aiosToken) {
+          legacyToken = aiosToken;
+          log('  OK Extracted auth token from aios config');
+        }
+        delete claudeJson.mcpServers.aios;
+        writeJson(CLAUDE_JSON, claudeJson);
+        log('  OK Removed aios MCP server from ~/.claude.json');
+
+        const oldClient = join(HOME, 'aios-v2-client');
+        if (existsSync(oldClient)) {
+          rmSync(oldClient, { recursive: true, force: true });
+          log('  OK Removed ~/aios-v2-client/');
+        }
+        log('');
+      }
+    }
+  }
+
+  // Check for PAI
+  const paiDir = join(CLAUDE_DIR, 'skills', 'PAI');
+  if (existsSync(paiDir)) {
+    log('━━━ PAI Installation Detected ━━━');
+    log(`  Size: ${dirSize(paiDir)}`);
+    log('');
+    if (await confirm('  Remove PAI? gramatr provides all PAI capabilities server-side.')) {
+      rmSync(paiDir, { recursive: true, force: true });
+      log('  OK Removed ~/.claude/skills/PAI/');
+    }
+    log('');
+  }
+
+  // Check for Fabric
+  const fabricDir = join(CLAUDE_DIR, 'skills', 'Fabric');
+  if (existsSync(fabricDir)) {
+    log('━━━ Fabric Installation Detected ━━━');
+    log(`  Size: ${dirSize(fabricDir)}`);
+    log('');
+    if (await confirm('  Remove Fabric skill directory? (CLI tool preserved)')) {
+      rmSync(fabricDir, { recursive: true, force: true });
+      log('  OK Removed ~/.claude/skills/Fabric/');
+    }
+    log('');
+  }
+
+  return { legacyToken };
+}
+
+// ── Step 1: Copy client files ──
+
+function installClientFiles(): void {
+  log('━━━ Step 1: Installing client files ━━━');
+  log('');
+
+  // Create directory structure
+  for (const sub of ['hooks/lib', 'bin', 'core']) {
+    mkdirSync(join(CLIENT_DIR, sub), { recursive: true });
+  }
+
+  // Hooks (7 core + utils)
+  let hookCount = 0;
+  const hooksSrc = join(SCRIPT_DIR, 'hooks');
+  if (existsSync(hooksSrc)) {
+    for (const f of readdirSync(hooksSrc)) {
+      const src = join(hooksSrc, f);
+      if (statSync(src).isFile() && (f.endsWith('.hook.ts') || f.endsWith('-utils.ts'))) {
+        cpSync(src, join(CLIENT_DIR, 'hooks', f));
+        chmodSync(join(CLIENT_DIR, 'hooks', f), 0o755);
+        hookCount++;
+      }
+    }
+
+    // Hook lib (paths, identity, notify, gmtr-hook-utils, transcript-parser)
+    const libHookSrc = join(hooksSrc, 'lib');
+    if (existsSync(libHookSrc)) {
+      const libs = readdirSync(libHookSrc).filter(f => f.endsWith('.ts') && !f.endsWith('.test.ts'));
+      for (const f of libs) cpSync(join(libHookSrc, f), join(CLIENT_DIR, 'hooks/lib', f));
+      log(`OK Installed ${hookCount} hooks + ${libs.length} lib modules`);
+    }
+  }
+
+  // Bin files
+  copyFileIfExists(join(SCRIPT_DIR, 'bin/statusline.ts'), join(CLIENT_DIR, 'bin/statusline.ts'), true);
+  copyFileIfExists(join(SCRIPT_DIR, 'bin/gmtr-login.ts'), join(CLIENT_DIR, 'bin/gmtr-login.ts'), true);
+  copyFileIfExists(join(SCRIPT_DIR, 'bin/render-claude-hooks.ts'), join(CLIENT_DIR, 'bin/render-claude-hooks.ts'), true);
+  log('OK Installed bin (statusline, gmtr-login, render-claude-hooks)');
+
+  // Core dependencies (routing.ts required by GMTRPromptEnricher hook)
+  for (const f of ['install.ts', 'version.ts', 'types.ts', 'routing.ts']) {
+    copyFileIfExists(join(SCRIPT_DIR, 'core', f), join(CLIENT_DIR, 'core', f));
+  }
+  log('OK Installed core modules');
+
+  // CLAUDE.md
+  copyFileIfExists(join(SCRIPT_DIR, 'CLAUDE.md'), join(CLIENT_DIR, 'CLAUDE.md'));
+  log('OK Installed CLAUDE.md (minimal — server delivers behavioral rules)');
+
+  log('');
+  log(`  Thin client: ${hookCount} hooks, server delivers everything else`);
+  log('');
+}
+
+// ── Step 1b: CLAUDE.md behavioral framework ──
+
+function installClaudeMd(): void {
+  log('━━━ Step 1b: Installing gramatr behavioral framework ━━━');
+  log('');
+
+  const claudeMd = join(HOME, '.claude', 'CLAUDE.md');
+  const gmtrSource = join(CLIENT_DIR, 'CLAUDE.md');
+  const GMTR_START = '<!-- GMTR-START';
+  const GMTR_END = '<!-- GMTR-END -->';
+
+  if (!existsSync(gmtrSource)) {
+    log('X CLAUDE.md source not found');
+    return;
+  }
+
+  const sourceContent = readFileSync(gmtrSource, 'utf8');
+
+  if (existsSync(claudeMd)) {
+    let content = readFileSync(claudeMd, 'utf8');
+
+    // Clean PAI directives
+    if (content.includes('read skills/PAI')) {
+      content = content.split('\n')
+        .filter(l => !l.includes('read skills/PAI') && !l.includes('# Read the PAI system'))
+        .join('\n');
+    }
+    if (content.startsWith('This file does nothing.')) {
+      content = content.replace(/^This file does nothing\.\n?/, '');
+    }
+
+    if (content.includes(GMTR_START)) {
+      // Replace existing GMTR section
+      const startIdx = content.indexOf(GMTR_START);
+      const endIdx = content.indexOf(GMTR_END);
+      if (endIdx > startIdx) {
+        content = content.slice(0, startIdx) + sourceContent + content.slice(endIdx + GMTR_END.length);
+      }
+      log('OK Updated GMTR section in existing CLAUDE.md');
+    } else {
+      content += '\n' + sourceContent;
+      log('OK Appended GMTR section to existing CLAUDE.md');
+    }
+    writeFileSync(claudeMd, content);
+  } else {
+    writeFileSync(claudeMd, sourceContent);
+    log('OK Created CLAUDE.md with gramatr behavioral framework');
+  }
+  log('');
+}
+
+// ── Step 2: (removed — skills/agents now server-side) ──
+
+// ── Step 3: Auth ──
+
+async function handleAuth(legacyToken: string, tsRunner: string): Promise<{ url: string; token: string }> {
+  log('━━━ Step 3: Configuring gramatr MCP server ━━━');
+  log('');
+
+  const url = await prompt('gramatr server URL', DEFAULT_URL) || DEFAULT_URL;
+
+  // Token priority: env > ~/.gmtr.json > legacy > login
+  let token = process.env.GMTR_TOKEN || '';
+
+  if (token) {
+    log('OK Using GMTR_TOKEN from environment');
+  }
+
+  if (!token && existsSync(GMTR_JSON)) {
+    const existing = readJson(GMTR_JSON);
+    if (existing.token) {
+      token = existing.token;
+      log('OK Found existing auth token in ~/.gmtr.json');
+    }
+  }
+
+  if (!token && legacyToken) {
+    token = legacyToken;
+    log('OK Reusing auth token from legacy aios installation');
+  }
+
+  // No token — run gmtr-login directly (imported, not subprocess)
+  if (!token && isInteractive) {
+    log('');
+    log('  No auth token found. Starting gramatr login...');
+    log('');
+
+    const loginScript = join(CLIENT_DIR, 'bin', 'gmtr-login.ts');
+    if (existsSync(loginScript)) {
+      // Run gmtr-login as subprocess but with proper stdio handling
+      // Use spawnSync so stdin is properly passed through (no stall)
+      const result = spawnSync(tsRunner, [loginScript], {
+        stdio: 'inherit',
+        env: { ...process.env },
+      });
+
+      // Re-read token after login
+      if (existsSync(GMTR_JSON)) {
+        const data = readJson(GMTR_JSON);
+        if (data.token) token = data.token;
+      }
+    }
+
+    if (!token) {
+      log('  Authentication skipped — run /gmtr-login later to authenticate');
+    }
+    log('');
+  } else if (!token) {
+    log('');
+    log('Non-interactive: no auth token. Set GMTR_TOKEN env var or run gmtr-login after install.');
+    log('');
+  }
+
+  return { url, token };
+}
+
+// ── Step 3b: Identity config ──
+
+async function configureIdentity(): Promise<void> {
+  log('━━━ Step 3b: Creating gramatr identity config ━━━');
+  log('');
+
+  const settingsPath = join(CLIENT_DIR, 'settings.json');
+
+  if (!existsSync(settingsPath)) {
+    writeJson(settingsPath, {
+      daidentity: {
+        name: 'gramatr',
+        fullName: 'gramatr — Personal AI',
+        displayName: 'gramatr',
+        color: '#3B82F6',
+      },
+      principal: {
+        name: 'User',
+        timezone: 'UTC',
+      },
+    });
+    log(`OK Created ${settingsPath}`);
+  } else {
+    log('OK gramatr settings.json exists — preserving identity');
+  }
+
+  const settings = readJson(settingsPath);
+  const currentName = settings.principal?.name || 'User';
+
+  if (currentName === 'User' && isInteractive) {
+    const name = await prompt('  What is your name? (shown in gramatr responses)');
+    if (name) {
+      settings.principal = settings.principal || {};
+      settings.principal.name = name;
+      log(`  OK Set principal.name to "${name}"`);
+    }
+
+    const tz = await prompt('  Your timezone?', 'America/Chicago');
+    settings.principal = settings.principal || {};
+    settings.principal.timezone = tz;
+    log(`  OK Set timezone to "${tz}"`);
+
+    writeJson(settingsPath, settings);
+  }
+
+  log('');
+}
+
+// ── Step 4: Settings merge ──
+
+function updateClaudeSettings(tsRunner: string, url: string, token: string): void {
+  log('━━━ Step 4: Updating Claude Code settings ━━━');
+  log('');
+
+  if (!existsSync(CLAUDE_SETTINGS)) {
+    writeJson(CLAUDE_SETTINGS, {});
+  }
+
+  // Backup
+  const backup = `${CLAUDE_SETTINGS}.backup-${timestamp()}`;
+  cpSync(CLAUDE_SETTINGS, backup);
+  log(`OK Backed up settings to ${basename(backup)}`);
+
+  const includeOptionalUx = process.env.GMTR_ENABLE_OPTIONAL_CLAUDE_UX === '1';
+  const hooksConfig = buildClaudeHooksFile(CLIENT_DIR, { includeOptionalUx, tsRunner });
+
+  const settings = readJson(CLAUDE_SETTINGS);
+
+  // Env vars
+  settings.env = settings.env || {};
+  settings.env.GMTR_DIR = CLIENT_DIR;
+  settings.env.GMTR_URL = url;
+  settings.env.PATH = `${HOME}/.gmtr/bin:/usr/local/bin:/usr/bin:/bin`;
+  if (token) settings.env.AIOS_MCP_TOKEN = token;
+
+  // Identity defaults (don't overwrite)
+  if (!settings.daidentity) {
+    settings.daidentity = {
+      name: 'gramatr',
+      fullName: 'gramatr — AI Intelligence Layer',
+      displayName: 'gramatr',
+      color: '#3B82F6',
+    };
+  }
+  if (!settings.principal) {
+    settings.principal = { name: 'User', timezone: 'UTC' };
+  }
+
+  // Hooks
+  settings.hooks = hooksConfig.hooks;
+  log('OK Wired managed gramatr hooks from shared install manifest');
+  if (includeOptionalUx) {
+    log('OK   Optional Claude UX hooks enabled');
+  } else {
+    log('OK   Thin-client hook set (set GMTR_ENABLE_OPTIONAL_CLAUDE_UX=1 for optional hooks)');
+  }
+
+  // Status line
+  settings.statusLine = {
+    type: 'command',
+    command: `${tsRunner} ${CLIENT_DIR}/bin/statusline.ts`,
+  };
+  log('OK Configured status line');
+
+  writeJson(CLAUDE_SETTINGS, settings);
+  log('');
+}
+
+// ── Step 4b: MCP server registration ──
+
+function registerMcpServer(url: string, token: string): void {
+  log('━━━ Step 4b: Registering MCP server in ~/.claude.json ━━━');
+  log('');
+
+  if (!existsSync(CLAUDE_JSON)) writeJson(CLAUDE_JSON, {});
+
+  const backup = `${CLAUDE_JSON}.backup-${timestamp()}`;
+  cpSync(CLAUDE_JSON, backup);
+
+  // Store token in ~/.gmtr.json
+  if (token) {
+    mergeJson(GMTR_JSON, (data) => ({
+      ...data,
+      token,
+      token_updated_at: new Date().toISOString(),
+    }));
+    try { chmodSync(GMTR_JSON, 0o600); } catch { /* ok */ }
+    log('OK Token stored in ~/.gmtr.json (canonical source)');
+  }
+
+  // Write tool paths to ~/.gmtr.json
+  mergeJson(GMTR_JSON, (data) => ({
+    ...data,
+    jq_binary: which('jq') || '',
+    bun_binary: which('bun') || '',
+  }));
+
+  // Register in ~/.claude.json
+  mergeJson(CLAUDE_JSON, (data) => {
+    data.env = data.env || {};
+    if (token) data.env.GMTR_TOKEN = token;
+    delete data.env.AIOS_MCP_TOKEN;
+
+    data.mcpServers = data.mcpServers || {};
+    data.mcpServers.gramatr = {
+      type: 'http',
+      url,
+      headers: { Authorization: 'Bearer ${GMTR_TOKEN}' },
+      autoApprove: true,
+    };
+    return data;
+  });
+
+  log(`OK Registered MCP server 'gramatr' in ~/.claude.json -> ${url}`);
+  log('');
+}
+
+// ── Step 4c: Additional CLIs ──
+
+function installAdditionalClis(tsRunner: string): void {
+  log('━━━ Step 4c: Additional CLI platforms ━━━');
+  log('');
+
+  // Codex
+  const codexDir = join(HOME, '.codex');
+  if (existsSync(codexDir) || which('codex')) {
+    log('  Codex CLI detected — installing gramatr hooks...');
+    const codexInstall = join(SCRIPT_DIR, 'codex', 'install.ts');
+    if (existsSync(codexInstall)) {
+      const result = spawnSync(tsRunner, [codexInstall], { stdio: 'inherit' });
+      if (result.status === 0) {
+        log('  OK Codex hooks installed');
+      } else {
+        log('  X Codex install failed (non-fatal)');
+      }
+    }
+    log('');
+  } else {
+    log('  -- Codex CLI not detected (skipping)');
+  }
+
+  // Gemini
+  const geminiDir = join(HOME, '.gemini');
+  if (existsSync(geminiDir) || which('gemini')) {
+    log('  Gemini CLI detected — installing gramatr extension...');
+    const geminiInstall = join(SCRIPT_DIR, 'gemini', 'install.ts');
+    if (existsSync(geminiInstall)) {
+      const result = spawnSync(tsRunner, [geminiInstall], { stdio: 'inherit' });
+      if (result.status === 0) {
+        log('  OK Gemini extension installed');
+      } else {
+        log('  X Gemini install failed (non-fatal)');
+      }
+    }
+    log('');
+  } else {
+    log('  -- Gemini CLI not detected (skipping)');
+  }
+
+  log('');
+}
+
+// ── Step 5: Verification ──
+
+function verify(url: string, token: string): boolean {
+  log('━━━ Step 5: Verification ━━━');
+  log('');
+
+  let allOk = true;
+  const check = (condition: boolean, ok: string, fail: string) => {
+    if (condition) {
+      log(`OK ${ok}`);
+    } else {
+      log(`X ${fail}`);
+      allOk = false;
+    }
+  };
+
+  // Critical files
+  for (const f of [
+    'hooks/GMTRToolTracker.hook.ts',
+    'hooks/GMTRPromptEnricher.hook.ts',
+    'hooks/GMTRRatingCapture.hook.ts',
+    'hooks/GMTRSecurityValidator.hook.ts',
+    'hooks/lib/notify.ts',
+    'core/routing.ts',
+    'bin/statusline.ts',
+    'bin/gmtr-login.ts',
+    'CLAUDE.md',
+  ]) {
+    check(existsSync(join(CLIENT_DIR, f)), f, `${f} MISSING`);
+  }
+
+  // Hook lib
+  for (const f of ['hooks/lib/identity.ts', 'hooks/lib/paths.ts']) {
+    check(existsSync(join(CLIENT_DIR, f)), f, `${f} MISSING`);
+  }
+
+  // Settings hooks
+  const settings = readJson(CLAUDE_SETTINGS);
+  const hookCounts = {
+    PreToolUse: (settings.hooks?.PreToolUse || []).length,
+    PostToolUse: (settings.hooks?.PostToolUse || []).length,
+    UserPromptSubmit: (settings.hooks?.UserPromptSubmit || []).length,
+    SessionStart: (settings.hooks?.SessionStart || []).length,
+    SessionEnd: (settings.hooks?.SessionEnd || []).length,
+    Stop: (settings.hooks?.Stop || []).length,
+  };
+  check(hookCounts.PreToolUse >= 4, `PreToolUse: ${hookCounts.PreToolUse} hooks`, `PreToolUse hooks missing (got ${hookCounts.PreToolUse}, need 4)`);
+  check(hookCounts.PostToolUse >= 1, `PostToolUse: ${hookCounts.PostToolUse} hooks`, `PostToolUse hooks missing (got ${hookCounts.PostToolUse}, need 1)`);
+  check(hookCounts.UserPromptSubmit >= 2, `UserPromptSubmit: ${hookCounts.UserPromptSubmit} groups`, `UserPromptSubmit hooks missing (got ${hookCounts.UserPromptSubmit}, need 2)`);
+  check(hookCounts.SessionStart >= 1, `SessionStart: ${hookCounts.SessionStart}`, `SessionStart hooks missing`);
+  check(hookCounts.SessionEnd >= 1, `SessionEnd: ${hookCounts.SessionEnd}`, `SessionEnd hooks missing`);
+  check(hookCounts.Stop >= 1, `Stop: ${hookCounts.Stop}`, `Stop hooks missing`);
+
+  // MCP server
+  const claudeJson = readJson(CLAUDE_JSON);
+  check(!!claudeJson.mcpServers?.gramatr, "MCP server 'gramatr' registered", 'MCP server missing');
+
+  // Status line
+  check(!!settings.statusLine?.command, 'Status line configured', 'Status line missing');
+
+  // No stale paths
+  const settingsStr = JSON.stringify(settings);
+  check(
+    !settingsStr.includes('PAI_DIR') && !settingsStr.includes('aios-v2-client'),
+    'No stale PAI_DIR or aios-v2-client paths',
+    'Stale PAI/AIOS paths found',
+  );
+
+  // CLAUDE.md
+  const claudeMd = join(HOME, '.claude', 'CLAUDE.md');
+  check(
+    existsSync(claudeMd) && readFileSync(claudeMd, 'utf8').includes('GMTR-START'),
+    'CLAUDE.md contains gramatr behavioral framework',
+    'CLAUDE.md missing GMTR section',
+  );
+
+  log('');
+  return allOk;
+}
+
+// ── Main ──
+
+async function main(): Promise<void> {
+  log('');
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log(`  gramatr v${VERSION} — Intelligence Layer`);
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  log('');
+
+  const { tsRunner } = await checkPrereqs();
+  log('');
+
+  const { legacyToken } = await handleLegacy();
+
+  installClientFiles();
+  installClaudeMd();
+
+  const { url, token } = await handleAuth(legacyToken, tsRunner);
+  await configureIdentity();
+  updateClaudeSettings(tsRunner, url, token);
+  registerMcpServer(url, token);
+  installAdditionalClis(tsRunner);
+
+  const allOk = verify(url, token);
+
+  const totalFiles = countFilesRecursive(CLIENT_DIR);
+
+  if (allOk) {
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    log('  gramatr Client installed successfully!');
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    log('');
+    log(`  Installed to: ${CLIENT_DIR} (${totalFiles} files)`);
+    log(`  MCP server:   ${url}`);
+    log('');
+    log('  Next steps:');
+    log('    1. Restart Claude Code to pick up MCP server config');
+    if (!token) {
+      log('    2. Run /gmtr-login in Claude Code to authenticate');
+    } else {
+      log('    2. Already authenticated (token found in ~/.gmtr.json)');
+    }
+    log('');
+  } else {
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    log('  Install completed with warnings');
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  }
+}
+
+main().catch((err) => {
+  log(`\nX Install failed: ${err.message}\n`);
+  process.exit(1);
+});