termify-agent 1.0.39 → 1.0.41

package/scripts/postinstall.js

@@ -7,7 +7,11 @@
  * 1. Rebuild node-pty native module for the current platform
  * 2. Install termify-daemon binary (bundled first, download as fallback)
  * 3. Install stats-agent binary (bundled first, download as fallback)
- * 4. Install termify-mcp and configure Claude Code / Codex MCP settings
+ * 4. Install wireguard-go binary (bundled first, download as fallback)
+ * 5. Create global symlink for sudo access
+ *
+ * CLI tool installation and MCP/hooks configuration is deferred to
+ * `termify-agent start` for faster npm install times. See src/setup.ts.
  */
 
 import { execSync, execFileSync } from 'child_process';
@@ -29,8 +33,6 @@ const TERMIFY_DIR = join(homedir(), '.termify');
 const DAEMON_PATH = join(TERMIFY_DIR, `termify-daemon${EXE}`);
 const STATS_AGENT_PATH = join(TERMIFY_DIR, `stats-agent${EXE}`);
 const WG_GO_PATH = join(TERMIFY_DIR, 'wireguard-go');
-const MCP_DIR = join(TERMIFY_DIR, 'termify-mcp');
-const MCP_BUNDLE_PATH = join(MCP_DIR, 'index.mjs');
 
 // Marker: skip node-pty test on repeated installs if it already works for this ABI
 const NODE_PTY_OK_MARKER = join(TERMIFY_DIR, `.node-pty-ok-${process.versions.modules}`);
@@ -44,6 +46,7 @@ function testNodePty() {
   if (existsSync(NODE_PTY_OK_MARKER)) return true;
 
   try {
+    // Safe: hardcoded command, no user input — needs shell for quoting
     execSync('node -e "require(\'node-pty\').spawn(\'/bin/sh\',[],{cols:80,rows:24}).kill()"', {
       stdio: 'pipe',
       timeout: 5000,
@@ -95,7 +98,7 @@ function rebuildNodePty() {
   console.log(`[termify-agent] node-pty resolved at: ${nodePtyDir}`);
   console.log('[termify-agent] node-pty prebuilt not working, attempting source rebuild...');
 
-  // Try rebuild from package root first
+  // Safe: hardcoded npm commands, no user input — needs shell for npm
   try {
     execSync('npm rebuild node-pty', {
       stdio: 'pipe',
@@ -205,7 +208,6 @@ async function installDaemon() {
   const plat = platform();
   const ar = arch();
 
-  // Map Node.js platform/arch to our binary names
   const platformMap = {
     'darwin-arm64': 'darwin-arm64',
     'darwin-x64': 'darwin-x64',
@@ -223,16 +225,13 @@ async function installDaemon() {
     return false;
   }
 
-  // Skip if already exists (user can delete to force re-download)
   if (existsSync(DAEMON_PATH)) {
     console.log('[termify-agent] termify-daemon binary already exists, skipping.');
     return true;
   }
 
-  // Ensure ~/.termify directory exists
   mkdirSync(TERMIFY_DIR, { recursive: true });
 
-  // Try bundled binary first
   const bundledPath = join(__dirname, '..', 'binaries', `termify-daemon-${binaryName}${EXE}`);
   if (existsSync(bundledPath)) {
     try {
@@ -245,7 +244,6 @@ async function installDaemon() {
     }
   }
 
-  // Fallback: download from server
   console.log(`[termify-agent] Downloading termify-daemon for ${binaryName}...`);
   const url = `${DOWNLOAD_BASE_URL}/termify-daemon/${binaryName}`;
 
@@ -268,7 +266,6 @@ async function installStatsAgent() {
   const plat = platform();
   const ar = arch();
 
-  // Map Node.js platform/arch to our binary names
   const platformMap = {
     'darwin-arm64': 'darwin-arm64',
     'darwin-x64': 'darwin-x64',
@@ -286,16 +283,13 @@ async function installStatsAgent() {
     return;
   }
 
-  // Skip if already exists
   if (existsSync(STATS_AGENT_PATH)) {
     console.log('[termify-agent] stats-agent binary already exists, skipping.');
     return;
   }
 
-  // Ensure ~/.termify directory exists
   mkdirSync(TERMIFY_DIR, { recursive: true });
 
-  // Try bundled binary first
   const bundledPath = join(__dirname, '..', 'binaries', `stats-agent-${binaryName}${EXE}`);
   if (existsSync(bundledPath)) {
     try {
@@ -308,7 +302,6 @@ async function installStatsAgent() {
     }
   }
 
-  // Fallback: download from server
   console.log(`[termify-agent] Downloading stats-agent for ${binaryName}...`);
   const url = `${DOWNLOAD_BASE_URL}/stats-agent/${binaryName}`;
 
@@ -325,18 +318,10 @@ async function installStatsAgent() {
 /**
  * Step 4: Install wireguard-go binary (bundled first, download as fallback)
  *
- * Bundling wireguard-go eliminates the need for `brew install wireguard-tools`
- * on macOS and provides a userspace WireGuard implementation for all platforms.
- * Combined with the UAPI socket client, this means the agent has zero external
- * WireGuard dependencies (same model as Tailscale).
- *
  * Not installed on Windows (uses native WireGuard service).
  */
 async function installWireguardGo() {
-  if (IS_WIN) {
-    // Windows uses native WireGuard service, not wireguard-go
-    return;
-  }
+  if (IS_WIN) return;
 
   const plat = platform();
   const ar = arch();
@@ -357,16 +342,13 @@ async function installWireguardGo() {
     return;
   }
 
-  // Skip if already exists
   if (existsSync(WG_GO_PATH)) {
     console.log('[termify-agent] wireguard-go binary already exists, skipping.');
     return;
   }
 
-  // Ensure ~/.termify directory exists
   mkdirSync(TERMIFY_DIR, { recursive: true });
 
-  // Try bundled binary first
   const bundledPath = join(__dirname, '..', 'binaries', `wireguard-go-${binaryName}`);
   if (existsSync(bundledPath)) {
     try {
@@ -379,7 +361,6 @@ async function installWireguardGo() {
     }
   }
 
-  // Fallback: download from server
   console.log(`[termify-agent] Downloading wireguard-go for ${binaryName}...`);
   const url = `${DOWNLOAD_BASE_URL}/wireguard-go/${binaryName}`;
 
@@ -403,7 +384,6 @@ function downloadFile(url, dest, redirects = 0) {
     }
 
     const request = get(url, (response) => {
-      // Handle redirects
       if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
         return downloadFile(response.headers.location, dest, redirects + 1)
           .then(resolve)
@@ -422,7 +402,6 @@ function downloadFile(url, dest, redirects = 0) {
       });
       file.on('error', (err) => {
         file.close();
-        // Clean up partial download
         try { unlinkSync(dest); } catch {}
         reject(err);
       });
@@ -436,436 +415,18 @@ function downloadFile(url, dest, redirects = 0) {
   });
 }
 
-/**
- * Step 4: Install termify-mcp bundle and configure Claude Code / Codex / Gemini
- *
- * The MCP server allows AI tools to report their working state to Termify.
- * Hooks sync conversations (prompts, responses, tool use, thinking) to Termify chat.
- */
-function installTermifyMcp() {
-  // Find the bundled MCP file
-  const bundledMcp = join(__dirname, '..', 'mcp', 'termify-mcp-bundle.mjs');
-  if (!existsSync(bundledMcp)) {
-    console.warn('[termify-agent] Warning: termify-mcp bundle not found, skipping MCP setup.');
-    return;
-  }
-
-  // Copy bundle to ~/.termify/termify-mcp/index.mjs
-  mkdirSync(MCP_DIR, { recursive: true });
-  try {
-    copyFileSync(bundledMcp, MCP_BUNDLE_PATH);
-    console.log(`[termify-agent] termify-mcp installed to ${MCP_BUNDLE_PATH}`);
-  } catch (err) {
-    console.warn(`[termify-agent] Warning: Failed to copy termify-mcp bundle: ${err.message}`);
-    return;
-  }
-
-  // Configure Claude Code
-  configureClaudeCode(MCP_BUNDLE_PATH);
-
-  // Configure Codex
-  configureCodex(MCP_BUNDLE_PATH);
-
-  // Configure Gemini
-  configureGemini();
-}
-
-// ---------------------------------------------------------------------------
-// Hook definitions: which hooks go to which CLI event
-// ---------------------------------------------------------------------------
-
-const HOOKS_DIR_NAME = 'hooks';
-
-/**
- * All Termify hooks and their CLI event mappings.
- * Each hook file is copied to ~/.termify/hooks/ and registered in the CLI config.
- */
-const HOOK_DEFINITIONS = {
-  // Claude Code hooks
-  claude: {
-    UserPromptSubmit: ['termify-sync.js'],
-    Stop: ['termify-response.js'],
-    PreToolUse: [
-      { file: 'termify-tool-hook.js' },
-      { file: 'termify-question-hook.js', matcher: 'AskUserQuestion' },
-      { file: 'termify-needs-input-hook.js', matcher: 'ExitPlanMode' },
-      { file: 'termify-needs-input-hook.js', matcher: 'EnterPlanMode' },
-    ],
-    PostToolUse: ['termify-tool-hook.js'],
-  },
-  // Gemini CLI hooks
-  gemini: {
-    BeforeAgent: ['termify-sync.js'],
-    AfterAgent: ['termify-response.js'],
-  },
-  // Codex CLI hooks (notify, not event-based)
-  codex: {
-    notify: ['termify-codex-notify.js'],
-  },
-};
-
-/**
- * Copy all hook files to ~/.termify/hooks/
- */
-function installHookFiles() {
-  const srcDir = join(__dirname, '..', HOOKS_DIR_NAME);
-  const destDir = join(TERMIFY_DIR, 'hooks');
-  mkdirSync(destDir, { recursive: true });
-
-  const hookFiles = [
-    'termify-sync.js',
-    'termify-response.js',
-    'termify-tool-hook.js',
-    'termify-question-hook.js',
-    'termify-needs-input-hook.js',
-    'termify-codex-notify.js',
-  ];
-
-  for (const file of hookFiles) {
-    const src = join(srcDir, file);
-    const dest = join(destDir, file);
-    if (existsSync(src)) {
-      copyFileSync(src, dest);
-    } else {
-      console.warn(`[termify-agent] Warning: Hook file ${file} not found in package.`);
-    }
-  }
-
-  // Clean up old hook from previous versions
-  const oldHook = join(destDir, 'termify-auto-working.js');
-  if (existsSync(oldHook)) {
-    try { unlinkSync(oldHook); } catch {}
-  }
-
-  console.log(`[termify-agent] Hook files installed to ${destDir}`);
-  return destDir;
-}
-
-/**
- * Register a hook command in a Claude Code settings.json hooks section.
- * Avoids duplicates by checking if the hook filename (basename) is already
- * registered under ANY path — prevents the same hook from being registered
- * from both ~/.claude/hooks/ and ~/.termify/hooks/.
- */
-function registerClaudeHook(settings, eventName, hookCommand, identifierStr) {
-  if (!settings.hooks) settings.hooks = {};
-
-  // Extract the hook filename from the command (e.g., "termify-sync.js" from "node /path/to/termify-sync.js")
-  const hookFilename = hookCommand.split('/').pop()?.split('\\').pop() || hookCommand;
-
-  const hookEntry = {
-    hooks: [{ type: 'command', command: hookCommand }],
-  };
-
-  if (!settings.hooks[eventName]) {
-    settings.hooks[eventName] = [hookEntry];
-  } else {
-    // Remove any existing entries with the same hook filename (from any path)
-    settings.hooks[eventName] = settings.hooks[eventName].filter(
-      (h) => !h.hooks || !h.hooks.some((hh) => hh.command && hh.command.includes(hookFilename))
-    );
-    settings.hooks[eventName].push(hookEntry);
-  }
-}
-
-/**
- * Configure Claude Code: MCP + all hooks in ~/.claude/settings.json
- */
-function configureClaudeCode(mcpPath) {
-  try {
-    const claudeDir = join(homedir(), '.claude');
-    const settingsPath = join(claudeDir, 'settings.json');
-    mkdirSync(claudeDir, { recursive: true });
-
-    let settings = {};
-    if (existsSync(settingsPath)) {
-      settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
-    }
-
-    // Configure MCP server (clean up old 'termify' key if it exists)
-    if (!settings.mcpServers) settings.mcpServers = {};
-    delete settings.mcpServers['termify'];
-    settings.mcpServers['termify-status'] = {
-      command: 'node',
-      args: [mcpPath],
-    };
-
-    // Install hook files
-    const hooksDestDir = installHookFiles();
-
-    // Clean up ALL existing termify hooks from any path (prevents duplicates
-    // when hooks were previously installed to ~/.claude/hooks/ or ~/.termify/hooks/)
-    if (settings.hooks) {
-      for (const eventName of Object.keys(settings.hooks)) {
-        if (Array.isArray(settings.hooks[eventName])) {
-          settings.hooks[eventName] = settings.hooks[eventName].filter(
-            (h) => !h.hooks || !h.hooks.some((hh) => hh.command && /termify-/.test(hh.command))
-          );
-          if (settings.hooks[eventName].length === 0) {
-            delete settings.hooks[eventName];
-          }
-        }
-      }
-    }
-
-    // Register Claude Code hooks (fresh, no duplicates possible after cleanup above)
-    if (!settings.hooks) settings.hooks = {};
-    const claudeHooks = HOOK_DEFINITIONS.claude;
-    for (const [eventName, hooks] of Object.entries(claudeHooks)) {
-      if (!settings.hooks[eventName]) settings.hooks[eventName] = [];
-
-      for (const hook of hooks) {
-        const file = typeof hook === 'string' ? hook : hook.file;
-        const matcher = typeof hook === 'object' ? hook.matcher : null;
-        const hookPath = join(hooksDestDir, file);
-        const hookCommand = `node ${hookPath}`;
-
-        const entry = {
-          hooks: [{ type: 'command', command: hookCommand }],
-        };
-        if (matcher) {
-          entry.matcher = matcher;
-        }
-
-        settings.hooks[eventName].push(entry);
-      }
-    }
-
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-    console.log('[termify-agent] Claude Code MCP + hooks configured in ~/.claude/settings.json');
-  } catch (err) {
-    console.warn(`[termify-agent] Warning: Failed to configure Claude Code: ${err.message}`);
-  }
-}
-
-/**
- * Configure Gemini CLI: hooks in ~/.gemini/settings.json
- */
-function configureGemini() {
-  try {
-    const geminiDir = join(homedir(), '.gemini');
-    if (!existsSync(geminiDir)) {
-      console.log('[termify-agent] Gemini CLI not found, skipping Gemini hooks.');
-      return;
-    }
-
-    const settingsPath = join(geminiDir, 'settings.json');
-    let settings = {};
-    if (existsSync(settingsPath)) {
-      settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
-    }
-
-    const hooksDir = join(TERMIFY_DIR, 'hooks');
-
-    // Register Gemini hooks
-    if (!settings.hooks) settings.hooks = {};
-
-    const geminiHooks = HOOK_DEFINITIONS.gemini;
-    for (const [eventName, hooks] of Object.entries(geminiHooks)) {
-      for (const file of hooks) {
-        const hookPath = join(hooksDir, file);
-        const hookCommand = `node ${hookPath}`;
-
-        const hookEntry = {
-          hooks: [{ type: 'command', command: hookCommand }],
-        };
-
-        if (!settings.hooks[eventName]) {
-          settings.hooks[eventName] = [hookEntry];
-        } else {
-          const already = settings.hooks[eventName].some(
-            (h) => h.hooks && h.hooks.some((hh) => hh.command && hh.command.includes(file))
-          );
-          if (!already) {
-            settings.hooks[eventName].push(hookEntry);
-          }
-        }
-      }
-    }
-
-    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
-    console.log('[termify-agent] Gemini CLI hooks configured in ~/.gemini/settings.json');
-  } catch (err) {
-    console.warn(`[termify-agent] Warning: Failed to configure Gemini CLI: ${err.message}`);
-  }
-}
-
-/**
- * Configure Codex CLI: MCP + notify hook in ~/.codex/config.toml
- */
-function configureCodex(mcpPath) {
-  try {
-    const codexDir = join(homedir(), '.codex');
-    const configPath = join(codexDir, 'config.toml');
-
-    let content = '';
-    if (existsSync(configPath)) {
-      content = readFileSync(configPath, 'utf8');
-    }
-
-    const hooksDir = join(TERMIFY_DIR, 'hooks');
-    const notifyHookPath = join(hooksDir, 'termify-codex-notify.js');
-
-    // Escape backslashes in paths for TOML (Windows)
-    const escapedMcpPath = mcpPath.replace(/\\/g, '\\\\');
-    const escapedNotifyPath = notifyHookPath.replace(/\\/g, '\\\\');
-
-    // Remove existing termify-status MCP section
-    content = content.replace(/\[mcp_servers\.termify-status\]\n(?:(?!\[)[^\n]*\n?)*/g, '');
-
-    // Update or add notify line
-    const notifyValue = `["node", "${escapedNotifyPath}"]`;
-    if (content.includes('notify =')) {
-      // Replace existing notify line
-      content = content.replace(/notify\s*=\s*\[.*\]/, `notify = ${notifyValue}`);
-    } else {
-      // Add notify at the top (after any existing first line)
-      const lines = content.split('\n');
-      // Insert after first non-empty line or at top
-      let insertIdx = 0;
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].trim() && !lines[i].startsWith('#') && !lines[i].startsWith('[')) {
-          insertIdx = i + 1;
-          break;
-        }
-      }
-      lines.splice(insertIdx, 0, `notify = ${notifyValue}`);
-      content = lines.join('\n');
-    }
-
-    content = content.trimEnd();
-
-    // Append MCP section
-    const section = `\n\n[mcp_servers.termify-status]\ncommand = "node"\nargs = ["${escapedMcpPath}"]\n`;
-    content = content + section;
-
-    mkdirSync(codexDir, { recursive: true });
-    writeFileSync(configPath, content);
-    console.log('[termify-agent] Codex MCP + notify hook configured in ~/.codex/config.toml');
-  } catch (err) {
-    console.warn(`[termify-agent] Warning: Failed to configure Codex: ${err.message}`);
-  }
-}
-
-/**
- * Ensure ~/.claude/CLAUDE.md contains termify_status instructions.
- * Adds the section if missing, updates it if outdated.
- */
-function ensureClaudeInstructions() {
-  try {
-    const claudeMdPath = join(homedir(), '.claude', 'CLAUDE.md');
-    const marker = '## Termify Status';
-    const instructions = `## Termify Status (OBLIGATORIO)
-
-**DEBES** usar el MCP tool \`termify_status\` para reportar tu estado a Termify. Los hooks reportan \`working\` automáticamente al recibir un prompt, pero TU eres responsable de reportar los demás estados:
-
-- \`working\`: los hooks lo ponen automáticamente al inicio. Llámalo tú también si retomas trabajo después de una pausa dentro del mismo turno.
-- \`finished\`: **SIEMPRE** llamar cuando termines la tarea actual. Es lo último que haces antes de responder.
-- \`idle\`: cuando estés esperando input libre del usuario (prompt normal).
-- \`needs_input\`: cuando estés bloqueado esperando que el usuario elija una opción, confirme \`y/n\`, o responda una pregunta concreta. Incluye \`needsInputPrompt\` con la pregunta exacta.
-- \`error\`: si algo falla irrecuperablemente.
-
-**Reglas**:
-1. **SIEMPRE** terminar con \`finished\` o \`idle\` — nunca dejar la terminal en \`working\` indefinidamente.
-2. No spamees: llama al tool solo cuando cambie el estado.
-3. Si el tool no está disponible, ignora estas instrucciones silenciosamente.`;
-
-    let content = '';
-    if (existsSync(claudeMdPath)) {
-      content = readFileSync(claudeMdPath, 'utf8');
-
-      // Check if section already exists
-      if (content.includes(marker)) {
-        // Replace existing section (from marker to next ## or end)
-        const regex = new RegExp(
-          `${marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[\\s\\S]*?(?=\\n## [^T]|\\n---\\n|$)`,
-          ''
-        );
-        content = content.replace(regex, instructions);
-      } else {
-        // Find insertion point: after the first header/intro section
-        const firstSectionIdx = content.indexOf('\n## ');
-        if (firstSectionIdx >= 0) {
-          content = content.slice(0, firstSectionIdx) + '\n\n' + instructions + '\n' + content.slice(firstSectionIdx);
-        } else {
-          content = content + '\n\n' + instructions + '\n';
-        }
-      }
-    } else {
-      content = '# Claude Code Configuration\n\n' + instructions + '\n';
-    }
-
-    const claudeDir = join(homedir(), '.claude');
-    mkdirSync(claudeDir, { recursive: true });
-    writeFileSync(claudeMdPath, content);
-    console.log('[termify-agent] Termify status instructions added to ~/.claude/CLAUDE.md');
-  } catch (err) {
-    console.warn(`[termify-agent] Warning: Failed to update CLAUDE.md: ${err.message}`);
-  }
-}
-
-/**
- * Ensure Codex has termify_status instructions.
- */
-function ensureCodexInstructions() {
-  try {
-    const codexDir = join(homedir(), '.codex');
-    if (!existsSync(codexDir)) return;
-
-    const instructionsPath = join(codexDir, 'instructions.md');
-    const marker = '## Termify Status';
-    const instructions = `## Termify Status (OBLIGATORIO)
-
-**DEBES** usar el MCP tool \`termify_status\` para reportar tu estado a Termify en CADA interacción:
-
-1. \`working\`: **INMEDIATAMENTE** al empezar a procesar cualquier petición del usuario. Es lo PRIMERO que haces.
-2. \`finished\`: **SIEMPRE** al terminar la tarea. Es lo ÚLTIMO que haces antes de responder.
-3. \`idle\`: cuando estés esperando input libre del usuario.
-4. \`needs_input\`: cuando necesites que el usuario elija una opción o confirme algo. Incluye \`needsInputPrompt\`.
-5. \`error\`: si algo falla irrecuperablemente.
-
-**Reglas**:
-- **NUNCA** omitir el \`working\` inicial — sin esto, la terminal no muestra indicador de actividad.
-- **SIEMPRE** terminar con \`finished\` o \`idle\` — nunca dejar la terminal en \`working\`.
-- Solo llama al tool cuando cambie el estado (no repetir el mismo estado).`;
-
-    let content = '';
-    if (existsSync(instructionsPath)) {
-      content = readFileSync(instructionsPath, 'utf8');
-      if (content.includes(marker)) {
-        console.log('[termify-agent] Codex instructions already contain Termify status section.');
-        return;
-      }
-      content = content + '\n\n' + instructions + '\n';
-    } else {
-      content = '# Codex Instructions\n\n' + instructions + '\n';
-    }
-
-    writeFileSync(instructionsPath, content);
-    console.log('[termify-agent] Termify status instructions added to ~/.codex/instructions.md');
-  } catch (err) {
-    console.warn(`[termify-agent] Warning: Failed to update Codex instructions: ${err.message}`);
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Symlink in /usr/local/bin for sudo access
 // ---------------------------------------------------------------------------
 
 /**
  * Create /usr/local/bin/termify-agent so `sudo termify-agent` works.
- *
- * npm puts the binary in a user-local path (e.g. ~/.nvm/.../bin/) that
- * sudo's sanitized PATH does not include. This symlink fixes that.
- *
- * Best-effort: if we can't create it (permissions), just log a hint.
  */
 function ensureGlobalSymlink() {
   if (IS_WIN) return;
 
   const target = '/usr/local/bin/termify-agent';
 
-  // Don't touch if already exists
   try {
     lstatSync(target);
     console.log('[termify-agent] /usr/local/bin/termify-agent already exists, skipping.');
@@ -874,12 +435,10 @@ function ensureGlobalSymlink() {
     // Doesn't exist — good, we'll create it
   }
 
-  // Find the npm-installed binary (execFileSync to avoid shell injection)
   let npmBinPath = null;
   try {
     npmBinPath = execFileSync('which', ['termify-agent'], { stdio: 'pipe', encoding: 'utf8' }).trim();
   } catch {
-    // Not in PATH (local install) — compute from package
     npmBinPath = join(__dirname, '..', 'bin', 'termify-agent.js');
     if (!existsSync(npmBinPath)) {
       console.log('[termify-agent] Could not locate termify-agent binary for symlink.');
@@ -891,9 +450,8 @@ function ensureGlobalSymlink() {
 
   try {
     symlinkSync(npmBinPath, target);
-    console.log(`[termify-agent] Symlink created: ${target} → ${npmBinPath}`);
+    console.log(`[termify-agent] Symlink created: ${target} \u2192 ${npmBinPath}`);
   } catch {
-    // Permission denied — not critical, log a hint
     console.log(`[termify-agent] Tip: run 'sudo ln -sf "${npmBinPath}" ${target}' to enable sudo access`);
   }
 }
@@ -908,9 +466,9 @@ const YELLOW = '\x1b[33m';
 const DIM = '\x1b[2m';
 const BOLD = '\x1b[1m';
 const RESET = '\x1b[0m';
-const CHECK = `${GREEN}✔${RESET}`;
-const WARN = `${YELLOW}⚠${RESET}`;
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const CHECK = `${GREEN}\u2714${RESET}`;
+const WARN = `${YELLOW}\u26A0${RESET}`;
+const SPINNER_FRAMES = ['\u280B', '\u2819', '\u2839', '\u2838', '\u283C', '\u2834', '\u2826', '\u2827', '\u2807', '\u280F'];
 
 function createSpinner(text) {
   let i = 0;
@@ -924,7 +482,6 @@ function createSpinner(text) {
   };
 }
 
-// Suppress verbose internal logs — only spinner UI shows
 const _log = console.log;
 const _warn = console.warn;
 const _err = console.error;
@@ -932,12 +489,12 @@ function muteConsole() { console.log = () => {}; console.warn = () => {}; consol
 function unmuteConsole() { console.log = _log; console.warn = _warn; console.error = _err; }
 
 /**
- * Main
+ * Main — only binaries and native modules. CLI config is deferred to `start`.
  */
 async function main() {
   console.log('');
   console.log(`  ${BOLD}${CYAN}Termify Agent${RESET} ${DIM}postinstall${RESET}`);
-  console.log(`  ${DIM}${platform()}-${arch()} · Node ${process.version}${RESET}`);
+  console.log(`  ${DIM}${platform()}-${arch()} \u00B7 Node ${process.version}${RESET}`);
   console.log('');
 
   muteConsole();
@@ -946,7 +503,7 @@ async function main() {
   const s1 = createSpinner('Checking node-pty...');
   const ptyOk = rebuildNodePty();
   if (ptyOk) s1.succeed('node-pty ready');
-  else s1.warn('node-pty skipped ${DIM}(optional)${RESET}');
+  else s1.warn(`node-pty skipped ${DIM}(optional)${RESET}`);
 
   // Step 2+3+4: Binaries in parallel
   const s2 = createSpinner('Installing binaries...');
@@ -962,42 +519,23 @@ async function main() {
   if (parts.length) s2.succeed(`Binaries ready ${DIM}(${parts.join(', ')})${RESET}`);
   else s2.warn('Binaries skipped');
 
-  // Step: Global symlink for sudo access
-  const s2b = createSpinner('Creating global symlink...');
+  // Step 5: Global symlink
+  const s3 = createSpinner('Creating global symlink...');
   try {
     ensureGlobalSymlink();
     if (existsSync('/usr/local/bin/termify-agent')) {
-      s2b.succeed('Global symlink ready');
+      s3.succeed('Global symlink ready');
     } else {
-      s2b.warn(`Symlink skipped ${DIM}(run: sudo ln -sf $(which termify-agent) /usr/local/bin/)${RESET}`);
+      s3.warn(`Symlink skipped ${DIM}(run: sudo ln -sf $(which termify-agent) /usr/local/bin/)${RESET}`);
     }
   } catch {
-    s2b.warn('Symlink skipped');
-  }
-
-  // Step 3: MCP + hooks
-  const s3 = createSpinner('Configuring hooks & MCP...');
-  try {
-    installTermifyMcp();
-    s3.succeed(`Hooks & MCP configured ${DIM}(Claude · Gemini · Codex)${RESET}`);
-  } catch (err) {
-    s3.warn(`Hooks & MCP: ${err.message}`);
-  }
-
-  // Step 4: Instructions
-  const s4 = createSpinner('Updating AI instructions...');
-  try {
-    ensureClaudeInstructions();
-    ensureCodexInstructions();
-    s4.succeed('AI instructions updated');
-  } catch (err) {
-    s4.warn(`Instructions: ${err.message}`);
+    s3.warn('Symlink skipped');
   }
 
   unmuteConsole();
 
   console.log('');
-  console.log(`  ${GREEN}${BOLD}Done!${RESET} ${DIM}Termify Agent is ready.${RESET}`);
+  console.log(`  ${GREEN}${BOLD}Done!${RESET} ${DIM}Run \`termify-agent start\` to finish setup.${RESET}`);
   console.log('');
 }