monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/init/helpers-generator.js

@@ -1,1335 +0,0 @@
-/**
- * Helpers Generator
- * Creates utility scripts in .claude/helpers/
- */
-import { generateStatuslineScript, generateStatuslineHook } from './statusline-generator.js';
-/**
- * Generate pre-commit hook script
- */
-export function generatePreCommitHook() {
-    return `#!/bin/bash
-# Monomind Pre-Commit Hook
-# Validates code quality before commit
-
-set -e
-
-echo "🔍 Running Monomind pre-commit checks..."
-
-# Get staged files
-STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)
-
-# Run validation for each staged file
-for FILE in $STAGED_FILES; do
-  if [[ "$FILE" =~ \\.(ts|js|tsx|jsx)$ ]]; then
-    echo "  Validating: $FILE"
-    npx @monomind/cli hooks pre-edit --file "$FILE" --validate-syntax 2>/dev/null || true
-  fi
-done
-
-# Run tests if available
-if [ -f "package.json" ] && grep -q '"test"' package.json; then
-  echo "🧪 Running tests..."
-  npm test --if-present 2>/dev/null || echo "  Tests skipped or failed"
-fi
-
-echo "✅ Pre-commit checks complete"
-`;
-}
-/**
- * Generate post-commit hook script
- */
-export function generatePostCommitHook() {
-    return `#!/bin/bash
-# Monomind Post-Commit Hook
-# Records commit metrics and trains patterns
-
-COMMIT_HASH=$(git rev-parse HEAD)
-COMMIT_MSG=$(git log -1 --pretty=%B)
-
-echo "📊 Recording commit metrics..."
-
-# Notify monomind of commit
-npx monomind@latest hooks notify \\
-  --message "Commit: $COMMIT_MSG" \\
-  --level info \\
-  --metadata '{"hash": "'$COMMIT_HASH'"}' 2>/dev/null || true
-
-echo "✅ Commit recorded"
-`;
-}
-/**
- * Generate session manager script
- */
-export function generateSessionManager() {
-    return `#!/usr/bin/env node
-/**
- * Monomind Session Manager
- * Handles session lifecycle: start, restore, end
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const SESSION_DIR = path.join(process.cwd(), '.monomind', 'sessions');
-const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
-
-const commands = {
-  start: () => {
-    const sessionId = \`session-\${Date.now()}\`;
-    const session = {
-      id: sessionId,
-      startedAt: new Date().toISOString(),
-      cwd: process.cwd(),
-      context: {},
-      metrics: {
-        edits: 0,
-        commands: 0,
-        tasks: 0,
-        errors: 0,
-      },
-    };
-
-    fs.mkdirSync(SESSION_DIR, { recursive: true });
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
-
-    console.log(\`Session started: \${sessionId}\`);
-    return session;
-  },
-
-  restore: () => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      console.log('No session to restore');
-      return null;
-    }
-
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    session.restoredAt = new Date().toISOString();
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
-
-    console.log(\`Session restored: \${session.id}\`);
-    return session;
-  },
-
-  end: () => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      console.log('No active session');
-      return null;
-    }
-
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    session.endedAt = new Date().toISOString();
-    session.duration = Date.now() - new Date(session.startedAt).getTime();
-
-    // Archive session
-    const archivePath = path.join(SESSION_DIR, \`\${session.id}.json\`);
-    fs.writeFileSync(archivePath, JSON.stringify(session, null, 2));
-    fs.unlinkSync(SESSION_FILE);
-
-    console.log(\`Session ended: \${session.id}\`);
-    console.log(\`Duration: \${Math.round(session.duration / 1000 / 60)} minutes\`);
-    console.log(\`Metrics: \${JSON.stringify(session.metrics)}\`);
-
-    return session;
-  },
-
-  status: () => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      console.log('No active session');
-      return null;
-    }
-
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    const duration = Date.now() - new Date(session.startedAt).getTime();
-
-    console.log(\`Session: \${session.id}\`);
-    console.log(\`Started: \${session.startedAt}\`);
-    console.log(\`Duration: \${Math.round(duration / 1000 / 60)} minutes\`);
-    console.log(\`Metrics: \${JSON.stringify(session.metrics)}\`);
-
-    return session;
-  },
-
-  update: (key, value) => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      console.log('No active session');
-      return null;
-    }
-
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    session.context[key] = value;
-    session.updatedAt = new Date().toISOString();
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
-
-    return session;
-  },
-
-  metric: (name) => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      return null;
-    }
-
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    if (session.metrics[name] !== undefined) {
-      session.metrics[name]++;
-      fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
-    }
-
-    return session;
-  },
-};
-
-// CLI
-const [,, command, ...args] = process.argv;
-
-if (command && commands[command]) {
-  commands[command](...args);
-} else {
-  console.log('Usage: session.js <start|restore|end|status|update|metric> [args]');
-}
-
-module.exports = commands;
-`;
-}
-/**
- * Generate agent router script
- */
-export function generateAgentRouter() {
-    return `#!/usr/bin/env node
-/**
- * Monomind Agent Router
- * Routes tasks to optimal agents based on learned patterns
- */
-
-const AGENT_CAPABILITIES = {
-  coder: ['code-generation', 'refactoring', 'debugging', 'implementation'],
-  tester: ['unit-testing', 'integration-testing', 'coverage', 'test-generation'],
-  reviewer: ['code-review', 'security-audit', 'quality-check', 'best-practices'],
-  researcher: ['web-search', 'documentation', 'analysis', 'summarization'],
-  architect: ['system-design', 'architecture', 'patterns', 'scalability'],
-  'backend-dev': ['api', 'database', 'server', 'authentication'],
-  'frontend-dev': ['ui', 'react', 'css', 'components'],
-  devops: ['ci-cd', 'docker', 'deployment', 'infrastructure'],
-};
-
-const TASK_PATTERNS = {
-  // Code patterns
-  'implement|create|build|add|write code': 'coder',
-  'test|spec|coverage|unit test|integration': 'tester',
-  'review|audit|check|validate|security': 'reviewer',
-  'research|find|search|documentation|explore': 'researcher',
-  'design|architect|structure|plan': 'architect',
-
-  // Domain patterns
-  'api|endpoint|server|backend|database': 'backend-dev',
-  'ui|frontend|component|react|css|style': 'frontend-dev',
-  'deploy|docker|ci|cd|pipeline|infrastructure': 'devops',
-};
-
-function routeTask(task) {
-  const taskLower = task.toLowerCase();
-
-  // Check patterns
-  for (const [pattern, agent] of Object.entries(TASK_PATTERNS)) {
-    const regex = new RegExp(pattern, 'i');
-    if (regex.test(taskLower)) {
-      return {
-        agent,
-        confidence: 0.8,
-        reason: \`Matched pattern: \${pattern}\`,
-      };
-    }
-  }
-
-  // Default to coder for unknown tasks
-  return {
-    agent: 'coder',
-    confidence: 0.5,
-    reason: 'Default routing - no specific pattern matched',
-  };
-}
-
-// CLI
-const task = process.argv.slice(2).join(' ');
-
-if (task) {
-  const result = routeTask(task);
-  console.log(JSON.stringify(result, null, 2));
-} else {
-  console.log('Usage: router.js <task description>');
-  console.log('\\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));
-}
-
-module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS };
-`;
-}
-/**
- * Generate memory helper script
- */
-export function generateMemoryHelper() {
-    return `#!/usr/bin/env node
-/**
- * Monomind Memory Helper
- * Simple key-value memory for cross-session context
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const MEMORY_DIR = path.join(process.cwd(), '.monomind', 'data');
-const MEMORY_FILE = path.join(MEMORY_DIR, 'memory.json');
-
-function loadMemory() {
-  try {
-    if (fs.existsSync(MEMORY_FILE)) {
-      return JSON.parse(fs.readFileSync(MEMORY_FILE, 'utf-8'));
-    }
-  } catch (e) {
-    // Ignore
-  }
-  return {};
-}
-
-function saveMemory(memory) {
-  fs.mkdirSync(MEMORY_DIR, { recursive: true });
-  fs.writeFileSync(MEMORY_FILE, JSON.stringify(memory, null, 2));
-}
-
-const commands = {
-  get: (key) => {
-    const memory = loadMemory();
-    const value = key ? memory[key] : memory;
-    console.log(JSON.stringify(value, null, 2));
-    return value;
-  },
-
-  set: (key, value) => {
-    if (!key) {
-      console.error('Key required');
-      return;
-    }
-    // Reject prototype-pollution keys: \`memory[key] = value\` with key='__proto__'
-    // performs a prototype-set, polluting Object.prototype for the process.
-    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
-      console.error('Forbidden key');
-      process.exit(2);
-    }
-    const memory = loadMemory();
-    Object.defineProperty(memory, key, { value, enumerable: true, configurable: true, writable: true });
-    memory._updated = new Date().toISOString();
-    saveMemory(memory);
-    console.log(\`Set: \${key}\`);
-  },
-
-  delete: (key) => {
-    if (!key) {
-      console.error('Key required');
-      return;
-    }
-    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
-      console.error('Forbidden key');
-      process.exit(2);
-    }
-    const memory = loadMemory();
-    delete memory[key];
-    saveMemory(memory);
-    console.log(\`Deleted: \${key}\`);
-  },
-
-  clear: () => {
-    saveMemory({});
-    console.log('Memory cleared');
-  },
-
-  keys: () => {
-    const memory = loadMemory();
-    const keys = Object.keys(memory).filter(k => !k.startsWith('_'));
-    console.log(keys.join('\\n'));
-    return keys;
-  },
-};
-
-// CLI
-const [,, command, key, ...valueParts] = process.argv;
-const value = valueParts.join(' ');
-
-if (command && commands[command]) {
-  commands[command](key, value);
-} else {
-  console.log('Usage: memory.js <get|set|delete|clear|keys> [key] [value]');
-}
-
-module.exports = commands;
-`;
-}
-/**
- * Generate hook-handler.cjs (cross-platform hook dispatcher)
- * This is the inline fallback when file copy from the package fails.
- * Uses string concatenation instead of template literals to avoid escaping issues.
- */
-export function generateHookHandler() {
-    // Build as array of lines to avoid template-in-template escaping nightmares
-    const lines = [
-        '#!/usr/bin/env node',
-        '/**',
-        ' * Monomind Hook Handler (Cross-Platform)',
-        ' * Dispatches hook events to the appropriate helper modules.',
-        ' */',
-        '',
-        "const path = require('path');",
-        "const fs = require('fs');",
-        '',
-        'const helpersDir = __dirname;',
-        '',
-        'function safeRequire(modulePath) {',
-        '  try {',
-        '    if (fs.existsSync(modulePath)) {',
-        '      const origLog = console.log;',
-        '      const origError = console.error;',
-        '      console.log = () => {};',
-        '      console.error = () => {};',
-        '      try {',
-        '        const mod = require(modulePath);',
-        '        return mod;',
-        '      } finally {',
-        '        console.log = origLog;',
-        '        console.error = origError;',
-        '      }',
-        '    }',
-        '  } catch (e) {',
-        '    // silently fail',
-        '  }',
-        '  return null;',
-        '}',
-        '',
-        "const router = safeRequire(path.join(helpersDir, 'router.cjs'));",
-        "const session = safeRequire(path.join(helpersDir, 'session.cjs'));",
-        "const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));",
-        "const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));",
-        '',
-        'const [,, command, ...args] = process.argv;',
-        '',
-        '// Read stdin with timeout — Claude Code sends hook data as JSON via stdin.',
-        '// Timeout prevents hanging when stdin is in an ambiguous state (not TTY, not pipe).',
-        'async function readStdin() {',
-        '  if (process.stdin.isTTY) return "";',
-        '  return new Promise((resolve) => {',
-        '    let data = "";',
-        '    const timer = setTimeout(() => {',
-        '      process.stdin.removeAllListeners();',
-        '      process.stdin.pause();',
-        '      resolve(data);',
-        '    }, 500);',
-        '    process.stdin.setEncoding("utf8");',
-        '    process.stdin.on("data", (chunk) => { data += chunk; });',
-        '    process.stdin.on("end", () => { clearTimeout(timer); resolve(data); });',
-        '    process.stdin.on("error", () => { clearTimeout(timer); resolve(data); });',
-        '    process.stdin.resume();',
-        '  });',
-        '}',
-        '',
-        'async function main() {',
-        '  let stdinData = "";',
-        '  try { stdinData = await readStdin(); } catch (e) { /* ignore */ }',
-        '  let hookInput = {};',
-        '  if (stdinData.trim()) {',
-        '    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore */ }',
-        '  }',
-        '  // Prefer stdin fields, then env, then argv',
-        "  var prompt = hookInput.prompt || hookInput.command || hookInput.toolInput || process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';",
-        '',
-        'const handlers = {',
-        "  'route': () => {",
-        '    if (intelligence && intelligence.getContext) {',
-        '      try {',
-        '        const ctx = intelligence.getContext(prompt);',
-        '        if (ctx) console.log(ctx);',
-        '      } catch (e) { /* non-fatal */ }',
-        '    }',
-        '    if (router && router.routeTask) {',
-        '      const result = router.routeTask(prompt);',
-        '      var output = [];',
-        "      output.push('[INFO] Routing task: ' + (prompt.substring(0, 80) || '(no prompt)'));",
-        "      output.push('');",
-        "      output.push('+------------ monomind | Primary Recommendation -------------+');",
-        "      output.push('| Agent: ' + result.agent.padEnd(53) + '|');",
-        "      output.push('| Confidence: ' + (result.confidence * 100).toFixed(1) + '%' + ' '.repeat(44) + '|');",
-        "      output.push('| Reason: ' + result.reason.substring(0, 53).padEnd(53) + '|');",
-        "      output.push('+--------------------------------------------------------------+');",
-        "      console.log(output.join('\\n'));",
-        '      // Graphify knowledge graph suggestion for architecture/understanding tasks',
-        '      try {',
-        "        var archKeywords = ['understand', 'architecture', 'how does', 'what calls', 'dependency', 'depends on', 'flow', 'how is', 'explain codebase', 'project structure', 'what is the relationship', 'graph', 'knowledge'];",
-        '        var promptLower = prompt.toLowerCase();',
-        '        var isArchQuery = archKeywords.some(function(k) { return promptLower.includes(k); });',
-        "        var graphJson = require('path').join(process.cwd(), '.monomind', 'monograph.db');",
-        "        var hasGraph = require('fs').existsSync(graphJson);",
-        '        if (isArchQuery) {',
-        "          var gfOutput = [];",
-        "          gfOutput.push('');",
-        "          gfOutput.push('+------- monograph | Knowledge Graph Available ---------------+');",
-        '          if (hasGraph) {',
-        "            gfOutput.push('| Graph: .monomind/monograph.db                               |');",
-        "            gfOutput.push('| Use: mcp__monomind__monograph_god_nodes                    |');",
-        "            gfOutput.push('|      mcp__monomind__monograph_query                        |');",
-        "            gfOutput.push('|      mcp__monomind__monograph_shortest_path                |');",
-        "            gfOutput.push('| Tip: Call monograph_god_nodes first for architecture overview|');",
-        '          } else {',
-        "            gfOutput.push('| No graph found. Build with:                                 |');",
-        "            gfOutput.push('|   mcp__monomind__monograph_build                            |');",
-        '          }',
-        "          gfOutput.push('+--------------------------------------------------------------+');",
-        "          console.log(gfOutput.join('\\n'));",
-        '        }',
-        '      } catch (e) { /* non-fatal */ }',
-        '    } else {',
-        "      console.log('[INFO] Router not available, using default routing');",
-        '    }',
-        '  },',
-        '',
-        "  'pre-bash': () => {",
-        '    var cmd = (hookInput.toolInput || hookInput.tool_input || {}).command || hookInput.command || "";',
-        '    if (typeof cmd !== "string") cmd = "";',
-        '    var isGrep = /\\b(?:grep|rg|ag|find|fd)\\b/.test(cmd);',
-        '    if (!isGrep) return;',
-        '    // Graph gate: remind to use monograph before grep',
-        '    var dbPath = path.join(process.cwd(), ".monomind", "monograph.db");',
-        '    if (fs.existsSync(dbPath)) {',
-        '      var stateFile = path.join(process.cwd(), ".monomind", "graph-gate-state.json");',
-        '      var gateState = {};',
-        '      try { gateState = JSON.parse(fs.readFileSync(stateFile, "utf-8")); } catch(e) {}',
-        '      var sessions = (gateState && typeof gateState.sessions === "object") ? gateState.sessions : {};',
-        '      var sessId = hookInput.sessionId || hookInput.session_id || "";',
-        '      if (sessId) {',
-        '        var s = sessions[sessId] || { queried: false, blockedOnce: false };',
-        '        if (!s.queried && !s.blockedOnce) {',
-        '          s.blockedOnce = true; s.ts = Date.now(); sessions[sessId] = s;',
-        '          try { fs.mkdirSync(path.join(process.cwd(), ".monomind"), { recursive: true }); fs.writeFileSync(stateFile, JSON.stringify({ sessions: sessions })); } catch(e) {}',
-        '          process.stderr.write(JSON.stringify({ decision: "block", reason: "[graph-gate] Call mcp__monomind__monograph_query or monograph_suggest before grep/find. This blocks once per session." }) + "\\n");',
-        '          process.exitCode = 2; return;',
-        '        }',
-        '        if (!s.queried) {',
-        '          console.log("[MONOGRAPH_REMINDER] monograph_query/suggest not yet called this session — try monograph first for faster results.");',
-        '        }',
-        '      }',
-        '    }',
-        '    // Graph-assisted grep: resolve patterns via monograph DB',
-        '    try {',
-        '      if (!fs.existsSync(dbPath)) return;',
-        '      var Database;',
-        '      try { Database = require("better-sqlite3"); } catch(e) {',
-        '        try { Database = require(path.join(process.cwd(), "node_modules/.pnpm/node_modules/better-sqlite3")); } catch(e2) {',
-        '          try { Database = require(path.join(process.cwd(), "node_modules/better-sqlite3")); } catch(e3) { return; }',
-        '        }',
-        '      }',
-        '      var db = new Database(dbPath, { readonly: true });',
-        '      try {',
-        "        // Extract bare words (identifiers or filenames) from the command",
-        '        var words = cmd.match(/[a-zA-Z_$][a-zA-Z0-9_$]{3,}/g) || [];',
-        '        var stop = {import:1,export:1,from:1,require:1,return:1,function:1,const:1,let:1,var:1,class:1,type:1,error:1,string:1,number:1,object:1,boolean:1,value:1,result:1,data:1,name:1,path:1,file:1,node:1,config:1,index:1,module:1,handler:1,default:1,grep:1,include:1,exclude:1};',
-        '        for (var wi = 0; wi < words.length; wi++) {',
-        '          var w = words[wi];',
-        '          if (stop[w.toLowerCase()]) continue;',
-        "          var row = db.prepare(\"SELECT name, file_path, start_line FROM nodes WHERE name = ? COLLATE NOCASE AND label NOT IN ('Concept','Community','Folder','Variable') AND file_path IS NOT NULL AND file_path NOT LIKE '%.md' LIMIT 1\").get(w);",
-        '          if (row) {',
-        '            console.log("[MONOGRAPH_HINT] " + row.name + " found at " + row.file_path + (row.start_line != null ? ":" + row.start_line : ""));',
-        '            break;',
-        '          }',
-        '        }',
-        '      } finally { try { db.close(); } catch(e) {} }',
-        '    } catch (e) { /* non-fatal */ }',
-        '  },',
-        '',
-        "  'pre-search': () => {",
-        '    // Graph gate for Grep/Glob tools (same logic as pre-bash)',
-        '    var dbPath = path.join(process.cwd(), ".monomind", "monograph.db");',
-        '    if (!fs.existsSync(dbPath)) return;',
-        '    var stateFile = path.join(process.cwd(), ".monomind", "graph-gate-state.json");',
-        '    var gateState = {};',
-        '    try { gateState = JSON.parse(fs.readFileSync(stateFile, "utf-8")); } catch(e) {}',
-        '    var sessions = (gateState && typeof gateState.sessions === "object") ? gateState.sessions : {};',
-        '    var sessId = hookInput.sessionId || hookInput.session_id || "";',
-        '    if (sessId) {',
-        '      var s = sessions[sessId] || { queried: false, blockedOnce: false };',
-        '      if (!s.queried && !s.blockedOnce) {',
-        '        s.blockedOnce = true; s.ts = Date.now(); sessions[sessId] = s;',
-        '        try { fs.writeFileSync(stateFile, JSON.stringify({ sessions: sessions })); } catch(e) {}',
-        '        process.stderr.write(JSON.stringify({ decision: "block", reason: "[graph-gate] Call mcp__monomind__monograph_query or monograph_suggest before Grep/Glob. This blocks once per session." }) + "\\n");',
-        '        process.exitCode = 2; return;',
-        '      }',
-        '      if (!s.queried) {',
-        '        console.log("[MONOGRAPH_REMINDER] monograph_query/suggest not yet called this session.");',
-        '      }',
-        '    }',
-        '  },',
-        '',
-        "  'pre-write': () => {",
-        '    // Stub — real implementation in the full hook-handler.cjs',
-        '  },',
-        '',
-        "  'post-edit': () => {",
-        '    if (session && session.metric) {',
-        "      try { session.metric('edits'); } catch (e) { /* no active session */ }",
-        '    }',
-        '    if (intelligence && intelligence.recordEdit) {',
-        '      try {',
-        "        var file = process.env.TOOL_INPUT_file_path || args[0] || '';",
-        '        intelligence.recordEdit(file);',
-        '      } catch (e) { /* non-fatal */ }',
-        '    }',
-        '    // Auto-rebuild monograph knowledge graph for code file changes',
-        '    try {',
-        "      var editedFile = process.env.TOOL_INPUT_file_path || args[0] || '';",
-        "      var isCode = /\\.(ts|js|tsx|jsx|py|go|rs|java|c|cpp|h|cs|rb|php|swift|kt|scala)$/.test(editedFile);",
-        "      var dbFile = require('path').join(process.cwd(), '.monomind', 'monograph.db');",
-        "      if (isCode && require('fs').existsSync(dbFile)) {",
-        "        var s = `import { buildAsync } from '@monoes/monograph'; buildAsync(${JSON.stringify(process.cwd())}).catch(()=>{});`;",
-        "        require('child_process').spawn(process.execPath, ['--input-type=module', '--eval', s], {",
-        "          detached: true, stdio: 'ignore'",
-        '        }).unref();',
-        "        console.log('[MONOGRAPH] Queued graph rebuild for: ' + require('path').basename(editedFile));",
-        '      }',
-        '    } catch (e) { /* non-fatal — monograph may not be installed */ }',
-        "    console.log('[OK] Edit recorded');",
-        '  },',
-        '',
-        "  'session-restore': () => {",
-        '    if (session) {',
-        '      var existing = session.restore && session.restore();',
-        '      if (!existing) {',
-        '        session.start && session.start();',
-        '      }',
-        '    } else {',
-        "      console.log('[OK] Session restored: session-' + Date.now());",
-        '    }',
-        '    if (intelligence && intelligence.init) {',
-        '      try {',
-        '        var result = intelligence.init();',
-        '        if (result && result.nodes > 0) {',
-        "          console.log('[INTELLIGENCE] Loaded ' + result.nodes + ' patterns, ' + result.edges + ' edges');",
-        '        }',
-        '      } catch (e) { /* non-fatal */ }',
-        '    }',
-        '  },',
-        '',
-        "  'post-graph-tool': () => {",
-        '    // Clear the graph gate when a real monograph tool is called',
-        '    var sessId = hookInput.sessionId || hookInput.session_id || "";',
-        '    if (!sessId) return;',
-        '    var stateFile = path.join(process.cwd(), ".monomind", "graph-gate-state.json");',
-        '    try {',
-        '      var gateState = {};',
-        '      try { gateState = JSON.parse(fs.readFileSync(stateFile, "utf-8")); } catch(e) {}',
-        '      var sessions = (gateState && typeof gateState.sessions === "object") ? gateState.sessions : {};',
-        '      var s = sessions[sessId] || { blockedOnce: false };',
-        '      s.queried = true; s.ts = Date.now(); sessions[sessId] = s;',
-        '      fs.writeFileSync(stateFile, JSON.stringify({ sessions: sessions }));',
-        '    } catch(e) {}',
-        '  },',
-        '',
-        "  'session-end': () => {",
-        '    if (intelligence && intelligence.consolidate) {',
-        '      try {',
-        '        var result = intelligence.consolidate();',
-        '        if (result && result.entries > 0) {',
-        "          var msg = '[INTELLIGENCE] Consolidated: ' + result.entries + ' entries, ' + result.edges + ' edges';",
-        "          if (result.newEntries > 0) msg += ', ' + result.newEntries + ' new';",
-        "          msg += ', PageRank recomputed';",
-        '          console.log(msg);',
-        '        }',
-        '      } catch (e) { /* non-fatal */ }',
-        '    }',
-        '    if (session && session.end) {',
-        '      session.end();',
-        '    } else {',
-        "      console.log('[OK] Session ended');",
-        '    }',
-        '  },',
-        '',
-        "  'pre-task': () => {",
-        '    if (session && session.metric) {',
-        "      try { session.metric('tasks'); } catch (e) { /* no active session */ }",
-        '    }',
-        '    if (router && router.routeTask && prompt) {',
-        '      var result = router.routeTask(prompt);',
-        "      console.log('[INFO] Task routed to: ' + result.agent + ' (confidence: ' + result.confidence + ')');",
-        '    } else {',
-        "      console.log('[OK] Task started');",
-        '    }',
-        '  },',
-        '',
-        "  'post-task': () => {",
-        '    if (intelligence && intelligence.feedback) {',
-        '      try {',
-        '        intelligence.feedback(true);',
-        '      } catch (e) { /* non-fatal */ }',
-        '    }',
-        "    console.log('[OK] Task completed');",
-        '  },',
-        '',
-        "  'compact-manual': () => {",
-        "    console.log('PreCompact Guidance:');",
-        "    console.log('IMPORTANT: Review CLAUDE.md in project root for:');",
-        "    console.log('   - Available agents and concurrent usage patterns');",
-        "    console.log('   - Swarm coordination strategies (hierarchical, mesh, adaptive)');",
-        "    console.log('   - Critical concurrent execution rules (1 MESSAGE = ALL OPERATIONS)');",
-        "    console.log('Ready for compact operation');",
-        '  },',
-        '',
-        "  'compact-auto': () => {",
-        "    console.log('Auto-Compact Guidance (Context Window Full):');",
-        "    console.log('CRITICAL: Before compacting, ensure you understand:');",
-        "    console.log('   - All agents available in .claude/agents/ directory');",
-        "    console.log('   - Concurrent execution patterns from CLAUDE.md');",
-        "    console.log('   - Swarm coordination strategies for complex tasks');",
-        "    console.log('Apply GOLDEN RULE: Always batch operations in single messages');",
-        "    console.log('Auto-compact proceeding with full agent context');",
-        '  },',
-        '',
-        "  'status': () => {",
-        "    console.log('[OK] Status check');",
-        '  },',
-        '',
-        "  'stats': () => {",
-        '    if (intelligence && intelligence.stats) {',
-        "      intelligence.stats(args.includes('--json'));",
-        '    } else {',
-        "      console.log('[WARN] Intelligence module not available. Run session-restore first.');",
-        '    }',
-        '  },',
-        '};',
-        '',
-        'if (command && handlers[command]) {',
-        '  try {',
-        '    handlers[command]();',
-        '  } catch (e) {',
-        "    console.log('[WARN] Hook ' + command + ' encountered an error: ' + e.message);",
-        '  }',
-        '} else if (command) {',
-        "  console.log('[OK] Hook: ' + command);",
-        '} else {',
-        "  console.log('Usage: hook-handler.cjs <route|pre-bash|post-edit|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|status|stats>');",
-        '}',
-        '} // end main',
-        '',
-        'process.exitCode = 0;',
-        'main().catch(() => {}).finally(() => { process.exit(0); });',
-    ];
-    return lines.join('\n') + '\n';
-}
-/**
- * Generate a minimal intelligence.cjs stub for fallback installs.
- * Provides the same API as the full intelligence.cjs but with simplified logic.
- * Gets overwritten when source copy succeeds (full version has PageRank, Jaccard, etc.)
- */
-export function generateIntelligenceStub() {
-    const lines = [
-        '#!/usr/bin/env node',
-        '/**',
-        ' * Intelligence Layer Stub (ADR-050)',
-        ' * Minimal fallback — full version is copied from package source.',
-        ' * Provides: init, getContext, recordEdit, feedback, consolidate',
-        ' */',
-        "'use strict';",
-        '',
-        "const fs = require('fs');",
-        "const path = require('path');",
-        "const os = require('os');",
-        '',
-        "const DATA_DIR = path.join(process.cwd(), '.monomind', 'data');",
-        "const STORE_PATH = path.join(DATA_DIR, 'auto-memory-store.json');",
-        "const RANKED_PATH = path.join(DATA_DIR, 'ranked-context.json');",
-        "const PENDING_PATH = path.join(DATA_DIR, 'pending-insights.jsonl');",
-        "const SESSION_DIR = path.join(process.cwd(), '.monomind', 'sessions');",
-        "const SESSION_FILE = path.join(SESSION_DIR, 'current.json');",
-        '',
-        'function ensureDir(dir) {',
-        '  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });',
-        '}',
-        '',
-        'function readJSON(p) {',
-        '  try { return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, "utf-8")) : null; }',
-        '  catch { return null; }',
-        '}',
-        '',
-        'function writeJSON(p, data) {',
-        '  ensureDir(path.dirname(p));',
-        '  fs.writeFileSync(p, JSON.stringify(data, null, 2), "utf-8");',
-        '}',
-        '',
-        '// Read session context key',
-        'function sessionGet(key) {',
-        '  var session = readJSON(SESSION_FILE);',
-        '  if (!session) return null;',
-        '  return key ? (session.context || {})[key] : session.context;',
-        '}',
-        '',
-        '// Write session context key',
-        'function sessionSet(key, value) {',
-        '  var session = readJSON(SESSION_FILE);',
-        '  if (!session) return;',
-        '  if (!session.context) session.context = {};',
-        '  session.context[key] = value;',
-        '  writeJSON(SESSION_FILE, session);',
-        '}',
-        '',
-        '// Tokenize text into words',
-        'function tokenize(text) {',
-        '  if (!text) return [];',
-        '  return text.toLowerCase().replace(/[^a-z0-9\\s]/g, " ").split(/\\s+/).filter(function(w) { return w.length > 2; });',
-        '}',
-        '',
-        '// Bootstrap entries from MEMORY.md files when store is empty.',
-        '// SECURITY: ONLY walk the current project. Walking ~/.claude/projects',
-        '// previously caused cross-project memory leakage — entries from project A',
-        '// (potentially containing secrets) would surface in prompts in project B.',
-        'function bootstrapFromMemoryFiles() {',
-        '  var entries = [];',
-        '  var candidates = [',
-        '    path.join(process.cwd(), ".monomind", "memory"),',
-        '    path.join(process.cwd(), ".claude", "memory"),',
-        '  ];',
-        '  for (var i = 0; i < candidates.length; i++) {',
-        '    try {',
-        '      if (!fs.existsSync(candidates[i])) continue;',
-        '      var files = [];',
-        '      try {',
-        '        var items = fs.readdirSync(candidates[i], { withFileTypes: true, recursive: true });',
-        '        for (var j = 0; j < items.length; j++) {',
-        '          if (items[j].name === "MEMORY.md") {',
-        '            var parentDir = items[j].parentPath || items[j].path || candidates[i];',
-        '            var fp = path.join(parentDir, items[j].name);',
-        '            files.push(fp);',
-        '          }',
-        '        }',
-        '      } catch (e) { continue; }',
-        '      for (var k = 0; k < files.length; k++) {',
-        '        try {',
-        '          var content = fs.readFileSync(files[k], "utf-8");',
-        '          var sections = content.split(/^##\\s+/m).filter(function(s) { return s.trim().length > 20; });',
-        '          for (var s = 0; s < sections.length; s++) {',
-        '            var lines2 = sections[s].split("\\n");',
-        '            var title = lines2[0] ? lines2[0].trim() : "section-" + s;',
-        '            entries.push({',
-        '              id: "mem-" + entries.length,',
-        '              content: sections[s].substring(0, 500),',
-        '              summary: title.substring(0, 100),',
-        '              category: "memory",',
-        '              confidence: 0.5,',
-        '              sourceFile: files[k],',
-        '              words: tokenize(sections[s].substring(0, 500)),',
-        '            });',
-        '          }',
-        '        } catch (e) { /* skip */ }',
-        '      }',
-        '    } catch (e) { /* skip */ }',
-        '  }',
-        '  return entries;',
-        '}',
-        '',
-        '// Load entries from auto-memory-store or bootstrap from MEMORY.md',
-        'function loadEntries() {',
-        '  var store = readJSON(STORE_PATH);',
-        '  // Support both formats: flat array or { entries: [...] }',
-        '  var entries = null;',
-        '  if (store) {',
-        '    if (Array.isArray(store) && store.length > 0) {',
-        '      entries = store;',
-        '    } else if (store.entries && store.entries.length > 0) {',
-        '      entries = store.entries;',
-        '    }',
-        '  }',
-        '  if (entries) {',
-        '    return entries.map(function(e, i) {',
-        '      return {',
-        '        id: e.id || ("entry-" + i),',
-        '        content: e.content || e.value || "",',
-        '        summary: e.summary || e.key || "",',
-        '        category: e.category || e.namespace || "default",',
-        '        confidence: e.confidence || 0.5,',
-        '        sourceFile: e.sourceFile || (e.metadata && e.metadata.sourceFile) || "",',
-        '        words: tokenize((e.content || e.value || "") + " " + (e.summary || e.key || "")),',
-        '      };',
-        '    });',
-        '  }',
-        '  return bootstrapFromMemoryFiles();',
-        '}',
-        '',
-        '// Simple keyword match score',
-        'function matchScore(promptWords, entryWords) {',
-        '  if (!promptWords.length || !entryWords.length) return 0;',
-        '  var entrySet = {};',
-        '  for (var i = 0; i < entryWords.length; i++) entrySet[entryWords[i]] = true;',
-        '  var overlap = 0;',
-        '  for (var j = 0; j < promptWords.length; j++) {',
-        '    if (entrySet[promptWords[j]]) overlap++;',
-        '  }',
-        '  var union = Object.keys(entrySet).length + promptWords.length - overlap;',
-        '  return union > 0 ? overlap / union : 0;',
-        '}',
-        '',
-        'var cachedEntries = null;',
-        '',
-        'module.exports = {',
-        '  init: function() {',
-        '    cachedEntries = loadEntries();',
-        '    var ranked = cachedEntries.map(function(e) {',
-        '      return { id: e.id, content: e.content, summary: e.summary, category: e.category, confidence: e.confidence, words: e.words };',
-        '    });',
-        '    writeJSON(RANKED_PATH, { version: 1, computedAt: Date.now(), entries: ranked });',
-        '    return { nodes: cachedEntries.length, edges: 0 };',
-        '  },',
-        '',
-        '  getContext: function(prompt) {',
-        '    if (!prompt) return null;',
-        '    var ranked = readJSON(RANKED_PATH);',
-        '    var entries = (ranked && ranked.entries) || (cachedEntries || []);',
-        '    if (!entries.length) return null;',
-        '    var promptWords = tokenize(prompt);',
-        '    if (!promptWords.length) return null;',
-        '    var scored = entries.map(function(e) {',
-        '      return { entry: e, score: matchScore(promptWords, e.words || tokenize(e.content + " " + e.summary)) };',
-        '    }).filter(function(s) { return s.score > 0.05; });',
-        '    scored.sort(function(a, b) { return b.score - a.score; });',
-        '    var top = scored.slice(0, 5);',
-        '    if (!top.length) return null;',
-        '    var prevMatched = sessionGet("lastMatchedPatterns");',
-        '    var matchedIds = top.map(function(s) { return s.entry.id; });',
-        '    sessionSet("lastMatchedPatterns", matchedIds);',
-        '    if (prevMatched && Array.isArray(prevMatched)) {',
-        '      var newSet = {};',
-        '      for (var i = 0; i < matchedIds.length; i++) newSet[matchedIds[i]] = true;',
-        '    }',
-        '    var lines2 = ["[INTELLIGENCE] Relevant patterns for this task:"];',
-        '    for (var j = 0; j < top.length; j++) {',
-        '      var e = top[j];',
-        '      var conf = e.entry.confidence || 0.5;',
-        '      var summary = (e.entry.summary || e.entry.content || "").substring(0, 80);',
-        '      lines2.push("  * (" + conf.toFixed(2) + ") " + summary);',
-        '    }',
-        '    return lines2.join("\\n");',
-        '  },',
-        '',
-        '  recordEdit: function(file) {',
-        '    if (!file) return;',
-        '    ensureDir(DATA_DIR);',
-        '    var line = JSON.stringify({ type: "edit", file: file, timestamp: Date.now() }) + "\\n";',
-        '    fs.appendFileSync(PENDING_PATH, line, "utf-8");',
-        '  },',
-        '',
-        '  feedback: function(success) {',
-        '    // Stub: no-op in minimal version',
-        '  },',
-        '',
-        '  consolidate: function() {',
-        '    var count = 0;',
-        '    if (fs.existsSync(PENDING_PATH)) {',
-        '      try {',
-        '        var content = fs.readFileSync(PENDING_PATH, "utf-8").trim();',
-        '        count = content ? content.split("\\n").length : 0;',
-        '        fs.writeFileSync(PENDING_PATH, "", "utf-8");',
-        '      } catch (e) { /* skip */ }',
-        '    }',
-        '    return { entries: count, edges: 0, newEntries: 0 };',
-        '  },',
-        '};',
-    ];
-    return lines.join('\n') + '\n';
-}
-/**
- * Generate a minimal auto-memory-hook.mjs fallback for fresh installs.
- * This ESM script handles import/sync/status commands gracefully when
- * @monomind/memory is not installed. Gets overwritten when source copy succeeds.
- */
-export function generateAutoMemoryHook() {
-    return `#!/usr/bin/env node
-/**
- * Auto Memory Bridge Hook (ADR-048/049) — Minimal Fallback
- * Full version is copied from package source when available.
- *
- * Usage:
- *   node auto-memory-hook.mjs import   # SessionStart
- *   node auto-memory-hook.mjs sync     # SessionEnd / Stop
- *   node auto-memory-hook.mjs status   # Show bridge status
- */
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '../..');
-const DATA_DIR = join(PROJECT_ROOT, '.monomind', 'data');
-const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
-
-const DIM = '\\x1b[2m';
-const RESET = '\\x1b[0m';
-const dim = (msg) => console.log(\`  \${DIM}\${msg}\${RESET}\`);
-
-// Ensure data dir
-if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
-
-async function loadMemoryPackage() {
-  // Strategy 1: Use createRequire for CJS-style resolution (handles nested node_modules
-  // when installed as a transitive dependency via npx monomind / npx monomind)
-  try {
-    const { createRequire } = await import('module');
-    const require = createRequire(join(PROJECT_ROOT, 'package.json'));
-    return require('@monoes/memory');
-  } catch { /* fall through */ }
-
-  // Strategy 2: ESM import (works when @monomind/memory is a direct dependency)
-  try { return await import('@monoes/memory'); } catch { /* fall through */ }
-
-  // Strategy 3: Walk up from PROJECT_ROOT looking for the package in any node_modules
-  let searchDir = PROJECT_ROOT;
-  const { parse } = await import('path');
-  while (searchDir !== parse(searchDir).root) {
-    const candidate = join(searchDir, 'node_modules', '@monoes', 'memory', 'dist', 'index.js');
-    if (existsSync(candidate)) {
-      try { return await import(\`file://\${candidate}\`); } catch { /* fall through */ }
-    }
-    searchDir = dirname(searchDir);
-  }
-
-  return null;
-}
-
-async function doImport() {
-  dim('Auto memory import skipped — AutoMemoryBridge removed');
-}
-
-async function doSync() {
-  dim('Auto memory sync skipped — AutoMemoryBridge removed');
-}
-
-function doStatus() {
-  console.log('\\n=== Auto Memory Bridge Status ===\\n');
-  console.log('  Package:        Fallback mode (run init --upgrade for full)');
-  console.log(\`  Store:          \${existsSync(STORE_PATH) ? 'Initialized' : 'Not initialized'}\`);
-  console.log('');
-}
-
-// Suppress unhandled rejection warnings ONLY for genuine module-not-found from
-// optional dynamic imports. Previously this swallowed any error whose message
-// contained "Cannot find" (e.g. "Cannot find user with id ..."), masking real
-// failures and security regressions.
-process.on('unhandledRejection', (reason) => {
-  const code = reason && typeof reason === 'object' ? reason.code : undefined;
-  if (code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND') return;
-  if (reason instanceof Error) throw reason;
-  throw new Error(String(reason));
-});
-
-const command = process.argv[2] || 'status';
-
-try {
-  switch (command) {
-    case 'import': await doImport(); break;
-    case 'sync': await doSync(); break;
-    case 'status': doStatus(); break;
-    default:
-      console.log('Usage: auto-memory-hook.mjs <import|sync|status>');
-      process.exit(1);
-  }
-} catch (err) {
-  // Hooks must never crash Claude Code - fail silently
-  dim(\`Error (non-critical): \${err.message}\`);
-}
-// Ensure clean exit for Claude Code hooks (exit 0 = success)
-process.exit(0);
-`;
-}
-/**
- * Generate Windows PowerShell daemon manager
- */
-export function generateWindowsDaemonManager() {
-    return `# Monomind Daemon Manager for Windows
-# PowerShell script for managing background processes
-
-param(
-    [Parameter(Position=0)]
-    [ValidateSet('start', 'stop', 'status', 'restart')]
-    [string]$Action = 'status'
-)
-
-$ErrorActionPreference = 'SilentlyContinue'
-$MonomindDir = Join-Path $PWD '.monomind'
-$PidDir = Join-Path $MonomindDir 'pids'
-
-# Ensure directories exist
-if (-not (Test-Path $PidDir)) {
-    New-Item -ItemType Directory -Path $PidDir -Force | Out-Null
-}
-
-function Get-DaemonStatus {
-    param([string]$Name, [string]$PidFile)
-
-    if (Test-Path $PidFile) {
-        $pid = Get-Content $PidFile
-        $process = Get-Process -Id $pid -ErrorAction SilentlyContinue
-        if ($process) {
-            return @{ Running = $true; Pid = $pid }
-        }
-    }
-    return @{ Running = $false; Pid = $null }
-}
-
-function Start-SwarmMonitor {
-    $pidFile = Join-Path $PidDir 'swarm-monitor.pid'
-    $status = Get-DaemonStatus -Name 'swarm-monitor' -PidFile $pidFile
-
-    if ($status.Running) {
-        Write-Host "Swarm monitor already running (PID: $($status.Pid))" -ForegroundColor Yellow
-        return
-    }
-
-    Write-Host "Starting swarm monitor..." -ForegroundColor Cyan
-    $process = Start-Process -FilePath 'node' -ArgumentList @(
-        '-e',
-        'setInterval(() => { require("fs").writeFileSync(".monomind/metrics/swarm-activity.json", JSON.stringify({swarm:{active:true,agent_count:0},timestamp:Date.now()})) }, 5000)'
-    ) -PassThru -WindowStyle Hidden
-
-    $process.Id | Out-File $pidFile
-    Write-Host "Swarm monitor started (PID: $($process.Id))" -ForegroundColor Green
-}
-
-function Stop-SwarmMonitor {
-    $pidFile = Join-Path $PidDir 'swarm-monitor.pid'
-    $status = Get-DaemonStatus -Name 'swarm-monitor' -PidFile $pidFile
-
-    if (-not $status.Running) {
-        Write-Host "Swarm monitor not running" -ForegroundColor Yellow
-        return
-    }
-
-    Stop-Process -Id $status.Pid -Force
-    Remove-Item $pidFile -Force
-    Write-Host "Swarm monitor stopped" -ForegroundColor Green
-}
-
-function Show-Status {
-    Write-Host ""
-    Write-Host "Monomind Daemon Status" -ForegroundColor Cyan
-    Write-Host "=============================" -ForegroundColor Cyan
-
-    $swarmPid = Join-Path $PidDir 'swarm-monitor.pid'
-    $swarmStatus = Get-DaemonStatus -Name 'swarm-monitor' -PidFile $swarmPid
-
-    if ($swarmStatus.Running) {
-        Write-Host "  Swarm Monitor: RUNNING (PID: $($swarmStatus.Pid))" -ForegroundColor Green
-    } else {
-        Write-Host "  Swarm Monitor: STOPPED" -ForegroundColor Red
-    }
-    Write-Host ""
-}
-
-switch ($Action) {
-    'start' {
-        Start-SwarmMonitor
-        Show-Status
-    }
-    'stop' {
-        Stop-SwarmMonitor
-        Show-Status
-    }
-    'restart' {
-        Stop-SwarmMonitor
-        Start-Sleep -Seconds 1
-        Start-SwarmMonitor
-        Show-Status
-    }
-    'status' {
-        Show-Status
-    }
-}
-`;
-}
-/**
- * Generate Windows batch file wrapper
- */
-export function generateWindowsBatchWrapper() {
-    return `@echo off
-REM Monomind - Windows Batch Wrapper
-REM Routes to PowerShell daemon manager
-
-PowerShell -ExecutionPolicy Bypass -File "%~dp0daemon-manager.ps1" %*
-`;
-}
-/**
- * Generate cross-platform session manager
- */
-export function generateCrossPlatformSessionManager() {
-    return `#!/usr/bin/env node
-/**
- * Monomind Cross-Platform Session Manager
- * Works on Windows, macOS, and Linux
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Platform-specific paths
-const platform = os.platform();
-const homeDir = os.homedir();
-
-// Get data directory based on platform
-function getDataDir() {
-  const localDir = path.join(process.cwd(), '.monomind', 'sessions');
-  if (fs.existsSync(path.dirname(localDir))) {
-    return localDir;
-  }
-
-  switch (platform) {
-    case 'win32':
-      return path.join(process.env.APPDATA || homeDir, 'monomind', 'sessions');
-    case 'darwin':
-      return path.join(homeDir, 'Library', 'Application Support', 'monomind', 'sessions');
-    default:
-      return path.join(homeDir, '.monomind', 'sessions');
-  }
-}
-
-const SESSION_DIR = getDataDir();
-const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
-
-// Ensure directory exists
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-const commands = {
-  start: () => {
-    ensureDir(SESSION_DIR);
-    const sessionId = \`session-\${Date.now()}\`;
-    const session = {
-      id: sessionId,
-      startedAt: new Date().toISOString(),
-      platform: platform,
-      cwd: process.cwd(),
-      context: {},
-      metrics: { edits: 0, commands: 0, tasks: 0, errors: 0 }
-    };
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
-    console.log(\`Session started: \${sessionId}\`);
-    return session;
-  },
-
-  restore: () => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      console.log('No session to restore');
-      return null;
-    }
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    session.restoredAt = new Date().toISOString();
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
-    console.log(\`Session restored: \${session.id}\`);
-    return session;
-  },
-
-  end: () => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      console.log('No active session');
-      return null;
-    }
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    session.endedAt = new Date().toISOString();
-    session.duration = Date.now() - new Date(session.startedAt).getTime();
-
-    const archivePath = path.join(SESSION_DIR, \`\${session.id}.json\`);
-    fs.writeFileSync(archivePath, JSON.stringify(session, null, 2));
-    fs.unlinkSync(SESSION_FILE);
-
-    console.log(\`Session ended: \${session.id}\`);
-    console.log(\`Duration: \${Math.round(session.duration / 1000 / 60)} minutes\`);
-    return session;
-  },
-
-  status: () => {
-    if (!fs.existsSync(SESSION_FILE)) {
-      console.log('No active session');
-      return null;
-    }
-    const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
-    const duration = Date.now() - new Date(session.startedAt).getTime();
-    console.log(\`Session: \${session.id}\`);
-    console.log(\`Platform: \${session.platform}\`);
-    console.log(\`Started: \${session.startedAt}\`);
-    console.log(\`Duration: \${Math.round(duration / 1000 / 60)} minutes\`);
-    return session;
-  }
-};
-
-// CLI
-const [,, command, ...args] = process.argv;
-if (command && commands[command]) {
-  commands[command](...args);
-} else {
-  console.log('Usage: session.js <start|restore|end|status>');
-  console.log(\`Platform: \${platform}\`);
-  console.log(\`Data dir: \${SESSION_DIR}\`);
-}
-
-module.exports = commands;
-`;
-}
-export const HELPER_FILES = {
-    'hook-handler.cjs': { forceSync: true, doctorTracked: true, generate: generateHookHandler },
-    'intelligence.cjs': { forceSync: true, generate: generateIntelligenceStub },
-    'auto-memory-hook.mjs': { forceSync: true, generate: generateAutoMemoryHook },
-    'statusline.cjs': { forceSync: true, doctorTracked: true },
-    'graphify-freshen.cjs': { forceSync: true, doctorTracked: true },
-    'router.cjs': { forceSync: true, doctorTracked: true, generate: generateAgentRouter },
-    // Regenerates skill-registry.json (which router.cjs's matchSkills reads) from
-    // the live .claude/commands + .claude/skills trees. No fallback generator:
-    // if it can't be copied there is nothing to regenerate the registry with, and
-    // router.cjs degrades to its built-in FALLBACK_SKILLS rather than breaking.
-    'build-skill-registry.cjs': { forceSync: true, doctorTracked: true },
-    'memory.cjs': { generate: generateMemoryHelper },
-    'session.cjs': { generate: generateSessionManager },
-    'pre-commit': { generate: generatePreCommitHook },
-    'post-commit': { generate: generatePostCommitHook },
-};
-export const FORCE_SYNC_HELPERS = Object.keys(HELPER_FILES).filter((name) => HELPER_FILES[name].forceSync);
-export const DOCTOR_TRACKED_HELPERS = Object.keys(HELPER_FILES).filter((name) => HELPER_FILES[name].doctorTracked);
-// Fallback generators for force-synced helpers (used when source is missing
-// the file entirely). Previously duplicated by hand as two separate maps
-// that disagreed on membership — the "source found but file missing" path
-// lacked a router.cjs fallback that the "source not found" path had, so a
-// corrupted/incomplete source copy could silently ship without router.cjs.
-export const FORCE_SYNC_GENERATORS = Object.fromEntries(Object.entries(HELPER_FILES)
-    .filter(([, spec]) => spec.forceSync && spec.generate)
-    .map(([name, spec]) => [name, spec.generate]));
-// Broader fallback-if-missing-after-copy step (used during a fresh `init`,
-// not `init upgrade`) — includes non-force-synced scaffold files too
-// (pre-commit/post-commit/session/memory).
-export const INIT_FALLBACK_HELPERS = Object.fromEntries(Object.entries(HELPER_FILES)
-    .filter(([, spec]) => spec.generate)
-    .map(([name, spec]) => [name, spec.generate]));
-/**
- * Generate all helper files
- */
-export function generateHelpers(options) {
-    const helpers = {};
-    if (options.components.helpers) {
-        // Unix/macOS shell scripts
-        helpers['pre-commit'] = generatePreCommitHook();
-        helpers['post-commit'] = generatePostCommitHook();
-        // Cross-platform Node.js scripts
-        helpers['session.js'] = generateCrossPlatformSessionManager();
-        helpers['router.js'] = generateAgentRouter();
-        helpers['memory.js'] = generateMemoryHelper();
-        // Windows-specific scripts
-        helpers['daemon-manager.ps1'] = generateWindowsDaemonManager();
-        helpers['daemon-manager.cmd'] = generateWindowsBatchWrapper();
-    }
-    if (options.components.statusline) {
-        helpers['statusline.cjs'] = generateStatuslineScript(options); // .cjs for ES module compatibility
-        helpers['statusline-hook.sh'] = generateStatuslineHook(options);
-    }
-    return helpers;
-}
-//# sourceMappingURL=helpers-generator.js.map