@claude-flow/cli 3.42.2 → 3.42.3

package/dist/src/init/helpers-generator.js

@@ -65,371 +65,371 @@ const TOOL_FAILURE_EXPR = '(function(hi){' +
  * Generate pre-commit hook script
  */
 export function generatePreCommitHook() {
-    return `#!/bin/bash
-# Ruflo Pre-Commit Hook
-# Validates code quality before commit
-
-set -e
-
-echo "🔍 Running Ruflo 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 @claude-flow/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"
+    return `#!/bin/bash
+# Ruflo Pre-Commit Hook
+# Validates code quality before commit
+
+set -e
+
+echo "🔍 Running Ruflo 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 @claude-flow/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
-# Ruflo 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 ruflo of commit
-npx ruflo@latest hooks notify \\
-  --message "Commit: $COMMIT_MSG" \\
-  --level info \\
-  --metadata '{"hash": "'$COMMIT_HASH'"}' 2>/dev/null || true
-
-echo "✅ Commit recorded"
+    return `#!/bin/bash
+# Ruflo 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 ruflo of commit
+npx ruflo@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
-/**
- * Ruflo Session Manager
- * Handles session lifecycle: start, restore, end
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const SESSION_DIR = path.join(process.cwd(), '.claude-flow', '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;
+    return `#!/usr/bin/env node
+/**
+ * Ruflo Session Manager
+ * Handles session lifecycle: start, restore, end
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SESSION_DIR = path.join(process.cwd(), '.claude-flow', '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
-/**
- * Ruflo Agent Router
- *
- * Static keyword router that suggests an agent for a task description.
- * NOTE: This is *not* a learned model. It is a heuristic table; "confidence"
- * is reported as a heuristic prior, not a calibrated probability.
- *
- * #2257 fix: patterns are now word-boundary-anchored so short tokens like
- * \`cd\`, \`ci\`, \`ui\`, \`add\`, \`structure\` no longer match inside unrelated
- * words (\`decision\`, \`infrastructure\`, \`address\`, \`addendum\`). Default
- * matched-confidence dropped from 0.8 to 0.6, and fall-through from 0.5 to
- * 0.3, to reflect that this is a static heuristic, not a learned classifier.
- */
-
-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'],
-};
-
-// Each entry has a token list. Single tokens get \\b…\\b boundaries so 'cd'
-// won't match inside 'decide'. Phrases (whitespace or '/') match literally —
-// the whitespace acts as a natural boundary.
-const TASK_PATTERNS = [
-  { tokens: ['implement', 'create', 'build', 'add', 'write code', 'refactor', 'debug'], agent: 'coder' },
-  { tokens: ['test', 'tests', 'spec', 'coverage', 'unit test', 'integration test'], agent: 'tester' },
-  { tokens: ['review', 'audit', 'check', 'validate', 'security'], agent: 'reviewer' },
-  { tokens: ['research', 'find', 'search', 'documentation', 'explore'], agent: 'researcher' },
-  { tokens: ['design', 'architect', 'architecture', 'structure', 'plan'], agent: 'architect' },
-  { tokens: ['api', 'endpoint', 'server', 'backend', 'database'], agent: 'backend-dev' },
-  { tokens: ['ui', 'frontend', 'component', 'react', 'css', 'style'], agent: 'frontend-dev' },
-  { tokens: ['deploy', 'docker', 'ci', 'cd', 'ci/cd', 'pipeline', 'infrastructure', 'devops'], agent: 'devops' },
-];
-
-function escapeRegex(s) {
-  return s.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&');
-}
-
-function buildPattern(tokens) {
-  const alternatives = tokens.map((tok) => {
-    const escaped = escapeRegex(tok.toLowerCase());
-    if (/\\s|\\//.test(tok)) return escaped;
-    return \`\\\\b\${escaped}\\\\b\`;
-  });
-  return new RegExp(\`(?:\${alternatives.join('|')})\`, 'i');
-}
-
-const COMPILED_PATTERNS = TASK_PATTERNS.map((entry) => ({
-  agent: entry.agent,
-  tokens: entry.tokens,
-  regex: buildPattern(entry.tokens),
-}));
-
-function routeTask(task) {
-  const taskLower = String(task == null ? '' : task).toLowerCase();
-  for (const entry of COMPILED_PATTERNS) {
-    if (entry.regex.test(taskLower)) {
-      return {
-        agent: entry.agent,
-        confidence: 0.6,
-        reason: \`Matched keyword(s) from: \${entry.tokens.join('|')}\`,
-      };
-    }
-  }
-  return {
-    agent: 'coder',
-    confidence: 0.3,
-    reason: 'Default routing - no specific keyword 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, buildPattern };
+    return `#!/usr/bin/env node
+/**
+ * Ruflo Agent Router
+ *
+ * Static keyword router that suggests an agent for a task description.
+ * NOTE: This is *not* a learned model. It is a heuristic table; "confidence"
+ * is reported as a heuristic prior, not a calibrated probability.
+ *
+ * #2257 fix: patterns are now word-boundary-anchored so short tokens like
+ * \`cd\`, \`ci\`, \`ui\`, \`add\`, \`structure\` no longer match inside unrelated
+ * words (\`decision\`, \`infrastructure\`, \`address\`, \`addendum\`). Default
+ * matched-confidence dropped from 0.8 to 0.6, and fall-through from 0.5 to
+ * 0.3, to reflect that this is a static heuristic, not a learned classifier.
+ */
+
+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'],
+};
+
+// Each entry has a token list. Single tokens get \\b…\\b boundaries so 'cd'
+// won't match inside 'decide'. Phrases (whitespace or '/') match literally —
+// the whitespace acts as a natural boundary.
+const TASK_PATTERNS = [
+  { tokens: ['implement', 'create', 'build', 'add', 'write code', 'refactor', 'debug'], agent: 'coder' },
+  { tokens: ['test', 'tests', 'spec', 'coverage', 'unit test', 'integration test'], agent: 'tester' },
+  { tokens: ['review', 'audit', 'check', 'validate', 'security'], agent: 'reviewer' },
+  { tokens: ['research', 'find', 'search', 'documentation', 'explore'], agent: 'researcher' },
+  { tokens: ['design', 'architect', 'architecture', 'structure', 'plan'], agent: 'architect' },
+  { tokens: ['api', 'endpoint', 'server', 'backend', 'database'], agent: 'backend-dev' },
+  { tokens: ['ui', 'frontend', 'component', 'react', 'css', 'style'], agent: 'frontend-dev' },
+  { tokens: ['deploy', 'docker', 'ci', 'cd', 'ci/cd', 'pipeline', 'infrastructure', 'devops'], agent: 'devops' },
+];
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&');
+}
+
+function buildPattern(tokens) {
+  const alternatives = tokens.map((tok) => {
+    const escaped = escapeRegex(tok.toLowerCase());
+    if (/\\s|\\//.test(tok)) return escaped;
+    return \`\\\\b\${escaped}\\\\b\`;
+  });
+  return new RegExp(\`(?:\${alternatives.join('|')})\`, 'i');
+}
+
+const COMPILED_PATTERNS = TASK_PATTERNS.map((entry) => ({
+  agent: entry.agent,
+  tokens: entry.tokens,
+  regex: buildPattern(entry.tokens),
+}));
+
+function routeTask(task) {
+  const taskLower = String(task == null ? '' : task).toLowerCase();
+  for (const entry of COMPILED_PATTERNS) {
+    if (entry.regex.test(taskLower)) {
+      return {
+        agent: entry.agent,
+        confidence: 0.6,
+        reason: \`Matched keyword(s) from: \${entry.tokens.join('|')}\`,
+      };
+    }
+  }
+  return {
+    agent: 'coder',
+    confidence: 0.3,
+    reason: 'Default routing - no specific keyword 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, buildPattern };
 `;
 }
 /**
  * Generate memory helper script
  */
 export function generateMemoryHelper() {
-    return `#!/usr/bin/env node
-/**
- * Ruflo 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(), '.claude-flow', '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;
-    }
-    const memory = loadMemory();
-    memory[key] = value;
-    memory._updated = new Date().toISOString();
-    saveMemory(memory);
-    console.log(\`Set: \${key}\`);
-  },
-
-  delete: (key) => {
-    if (!key) {
-      console.error('Key required');
-      return;
-    }
-    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;
+    return `#!/usr/bin/env node
+/**
+ * Ruflo 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(), '.claude-flow', '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;
+    }
+    const memory = loadMemory();
+    memory[key] = value;
+    memory._updated = new Date().toISOString();
+    saveMemory(memory);
+    console.log(\`Set: \${key}\`);
+  },
+
+  delete: (key) => {
+    if (!key) {
+      console.error('Key required');
+      return;
+    }
+    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;
 `;
 }
 /**
@@ -992,375 +992,375 @@ export function generateIntelligenceStub() {
  * @claude-flow/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, '.claude-flow', 'data');
-const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
-
-const DIM = '\\x1b[2m';
-const YELLOW = '\\x1b[0;33m';
-const RESET = '\\x1b[0m';
-const dim = (msg) => console.log(\`  \${DIM}\${msg}\${RESET}\`);
-
-// #2545: fail LOUD instead of a silent dim skip when @claude-flow/memory is
-// unresolvable — self-learning imports are a no-op and the user must be told.
-function warnMemoryUnavailable() {
-  const l1 = \`[AutoMemory] @claude-flow/memory not resolvable from \${PROJECT_ROOT} — self-learning imports are DISABLED.\`;
-  const l2 = '             Fix: npm i -D @claude-flow/memory   (or re-run: npx ruflo@latest init, then npx ruflo@latest doctor --fix)';
-  console.log(\`\${YELLOW}\${l1}\${RESET}\`);
-  console.log(\`\${YELLOW}\${l2}\${RESET}\`);
-  process.stderr.write(\`\${l1}\\n\${l2}\\n\`);
-}
-
-// Ensure data dir
-if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
-
-async function loadMemoryPackage() {
-  // Strategy 0 (#2545): sidecar recorded by \`init\` / \`doctor --fix\`. On the npx
-  // path @claude-flow/memory lands in the npx cache (unreachable by walk-up), so
-  // init records its absolute path here — the only strategy that works there.
-  try {
-    const sidecar = join(PROJECT_ROOT, '.claude-flow', 'memory-package.json');
-    if (existsSync(sidecar)) {
-      const rec = JSON.parse(readFileSync(sidecar, 'utf-8'));
-      if (rec && rec.distPath && existsSync(rec.distPath)) {
-        return await import(\`file://\${rec.distPath}\`);
-      }
-    }
-  } catch { /* fall through */ }
-
-  // Strategy 1: Use createRequire for CJS-style resolution (handles nested node_modules
-  // when installed as a transitive dependency via npx ruflo / npx claude-flow)
-  try {
-    const { createRequire } = await import('module');
-    const require = createRequire(join(PROJECT_ROOT, 'package.json'));
-    return require('@claude-flow/memory');
-  } catch { /* fall through */ }
-
-  // Strategy 2: ESM import (works when @claude-flow/memory is a direct dependency)
-  try { return await import('@claude-flow/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', '@claude-flow', 'memory', 'dist', 'index.js');
-    if (existsSync(candidate)) {
-      try { return await import(\`file://\${candidate}\`); } catch { /* fall through */ }
-    }
-    searchDir = dirname(searchDir);
-  }
-
-  return null;
-}
-
-async function doImport() {
-  const memPkg = await loadMemoryPackage();
-
-  if (!memPkg || !memPkg.AutoMemoryBridge) {
-    warnMemoryUnavailable();
-    return;
-  }
-
-  // Full implementation deferred to copied version
-  dim('Auto memory import available — run init --upgrade for full support');
-}
-
-async function doSync() {
-  if (!existsSync(STORE_PATH)) {
-    dim('No entries to sync');
-    return;
-  }
-
-  const memPkg = await loadMemoryPackage();
-
-  if (!memPkg || !memPkg.AutoMemoryBridge) {
-    warnMemoryUnavailable();
-    return;
-  }
-
-  dim('Auto memory sync available — run init --upgrade for full support');
-}
-
-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 from dynamic import() failures
-process.on('unhandledRejection', () => {});
-
-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);
+    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, '.claude-flow', 'data');
+const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
+
+const DIM = '\\x1b[2m';
+const YELLOW = '\\x1b[0;33m';
+const RESET = '\\x1b[0m';
+const dim = (msg) => console.log(\`  \${DIM}\${msg}\${RESET}\`);
+
+// #2545: fail LOUD instead of a silent dim skip when @claude-flow/memory is
+// unresolvable — self-learning imports are a no-op and the user must be told.
+function warnMemoryUnavailable() {
+  const l1 = \`[AutoMemory] @claude-flow/memory not resolvable from \${PROJECT_ROOT} — self-learning imports are DISABLED.\`;
+  const l2 = '             Fix: npm i -D @claude-flow/memory   (or re-run: npx ruflo@latest init, then npx ruflo@latest doctor --fix)';
+  console.log(\`\${YELLOW}\${l1}\${RESET}\`);
+  console.log(\`\${YELLOW}\${l2}\${RESET}\`);
+  process.stderr.write(\`\${l1}\\n\${l2}\\n\`);
+}
+
+// Ensure data dir
+if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+
+async function loadMemoryPackage() {
+  // Strategy 0 (#2545): sidecar recorded by \`init\` / \`doctor --fix\`. On the npx
+  // path @claude-flow/memory lands in the npx cache (unreachable by walk-up), so
+  // init records its absolute path here — the only strategy that works there.
+  try {
+    const sidecar = join(PROJECT_ROOT, '.claude-flow', 'memory-package.json');
+    if (existsSync(sidecar)) {
+      const rec = JSON.parse(readFileSync(sidecar, 'utf-8'));
+      if (rec && rec.distPath && existsSync(rec.distPath)) {
+        return await import(\`file://\${rec.distPath}\`);
+      }
+    }
+  } catch { /* fall through */ }
+
+  // Strategy 1: Use createRequire for CJS-style resolution (handles nested node_modules
+  // when installed as a transitive dependency via npx ruflo / npx claude-flow)
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(join(PROJECT_ROOT, 'package.json'));
+    return require('@claude-flow/memory');
+  } catch { /* fall through */ }
+
+  // Strategy 2: ESM import (works when @claude-flow/memory is a direct dependency)
+  try { return await import('@claude-flow/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', '@claude-flow', 'memory', 'dist', 'index.js');
+    if (existsSync(candidate)) {
+      try { return await import(\`file://\${candidate}\`); } catch { /* fall through */ }
+    }
+    searchDir = dirname(searchDir);
+  }
+
+  return null;
+}
+
+async function doImport() {
+  const memPkg = await loadMemoryPackage();
+
+  if (!memPkg || !memPkg.AutoMemoryBridge) {
+    warnMemoryUnavailable();
+    return;
+  }
+
+  // Full implementation deferred to copied version
+  dim('Auto memory import available — run init --upgrade for full support');
+}
+
+async function doSync() {
+  if (!existsSync(STORE_PATH)) {
+    dim('No entries to sync');
+    return;
+  }
+
+  const memPkg = await loadMemoryPackage();
+
+  if (!memPkg || !memPkg.AutoMemoryBridge) {
+    warnMemoryUnavailable();
+    return;
+  }
+
+  dim('Auto memory sync available — run init --upgrade for full support');
+}
+
+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 from dynamic import() failures
+process.on('unhandledRejection', () => {});
+
+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 `# RuFlo V3 Daemon Manager for Windows
-# PowerShell script for managing background processes
-
-param(
-    [Parameter(Position=0)]
-    [ValidateSet('start', 'stop', 'status', 'restart')]
-    [string]$Action = 'status'
-)
-
-$ErrorActionPreference = 'SilentlyContinue'
-$ClaudeFlowDir = Join-Path $PWD '.claude-flow'
-$PidDir = Join-Path $ClaudeFlowDir '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(".claude-flow/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 "RuFlo V3 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
-    }
-}
+    return `# RuFlo V3 Daemon Manager for Windows
+# PowerShell script for managing background processes
+
+param(
+    [Parameter(Position=0)]
+    [ValidateSet('start', 'stop', 'status', 'restart')]
+    [string]$Action = 'status'
+)
+
+$ErrorActionPreference = 'SilentlyContinue'
+$ClaudeFlowDir = Join-Path $PWD '.claude-flow'
+$PidDir = Join-Path $ClaudeFlowDir '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(".claude-flow/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 "RuFlo V3 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 RuFlo V3 - Windows Batch Wrapper
-REM Routes to PowerShell daemon manager
-
-PowerShell -ExecutionPolicy Bypass -File "%~dp0daemon-manager.ps1" %*
+    return `@echo off
+REM RuFlo V3 - 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
-/**
- * Ruflo 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(), '.claude-flow', 'sessions');
-  if (fs.existsSync(path.dirname(localDir))) {
-    return localDir;
-  }
-
-  switch (platform) {
-    case 'win32':
-      return path.join(process.env.APPDATA || homeDir, 'claude-flow', 'sessions');
-    case 'darwin':
-      return path.join(homeDir, 'Library', 'Application Support', 'claude-flow', 'sessions');
-    default:
-      return path.join(homeDir, '.claude-flow', '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;
+    return `#!/usr/bin/env node
+/**
+ * Ruflo 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(), '.claude-flow', 'sessions');
+  if (fs.existsSync(path.dirname(localDir))) {
+    return localDir;
+  }
+
+  switch (platform) {
+    case 'win32':
+      return path.join(process.env.APPDATA || homeDir, 'claude-flow', 'sessions');
+    case 'darwin':
+      return path.join(homeDir, 'Library', 'Application Support', 'claude-flow', 'sessions');
+    default:
+      return path.join(homeDir, '.claude-flow', '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;
 `;
 }
 /**
@@ -1403,65 +1403,231 @@ export function generateHelpers(options) {
  *   - Both: .claude/helpers/ruflo-hook.cjs available as a canonical cross-platform shim
  */
 export function generateRufloHookCjs() {
-    return `#!/usr/bin/env node
-/**
- * ruflo-hook.cjs — cross-platform Node.js port of ruflo-hook.sh (#2132)
- *
- * Deployed to .claude/helpers/ during ruflo init. On Windows, the
- * generated .claude/settings.json hooks point here instead of the
- * plugin's bash-only ruflo-hook.sh.
- *
- * Always exits 0 — hook subcommands are best-effort telemetry and must
- * never block a Claude Code turn.
- */
-
-'use strict';
-
-const { spawnSync, execSync } = require('child_process');
-const fs = require('fs');
-
-function done() { process.exit(0); }
-
-function commandExists(cmd) {
-  try {
-    const r = execSync(
-      process.platform === 'win32' ? 'where ' + cmd : 'command -v ' + cmd,
-      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
-    );
-    return r.trim().length > 0;
-  } catch { return false; }
-}
-
-function invokeHook(bin, binArgs, hookArgs, stdinData) {
-  const args = [...binArgs, ...hookArgs];
-  const result = spawnSync(bin, args, {
-    shell: process.platform === 'win32',
-    input: stdinData || '',
-    encoding: 'utf8',
-    stdio: ['pipe', 'ignore', 'ignore'],
-    timeout: 30_000,
-  });
-  return result.status === 0;
-}
-
-function main() {
-  const args = process.argv.slice(2);
-  if (args.length === 0) done();
-
-  const [subcommand, ...rest] = args;
-
-  let stdinData = '';
-  try { stdinData = fs.readFileSync(0, 'utf8'); } catch { stdinData = ''; }
-
-  const hookArgs = ['hooks', subcommand, ...rest];
-
-  if (commandExists('ruflo')) { invokeHook('ruflo', [], hookArgs, stdinData); done(); }
-  if (commandExists('claude-flow')) { invokeHook('claude-flow', [], hookArgs, stdinData); done(); }
-  invokeHook('npx', ['--prefer-offline', '--yes', 'ruflo@latest'], hookArgs, stdinData);
-  done();
-}
-
-main();
+    return `#!/usr/bin/env node
+/**
+ * ruflo-hook.cjs — cross-platform Node.js port of ruflo-hook.sh (#2132)
+ *
+ * Deployed to .claude/helpers/ during ruflo init. On Windows, the
+ * generated .claude/settings.json hooks point here instead of the
+ * plugin's bash-only ruflo-hook.sh.
+ *
+ * Always exits 0 — hook subcommands are best-effort telemetry and must
+ * never block a Claude Code turn.
+ *
+ * Windows argv integrity: hook-derived values (a Bash tool's \`command\`, a file path) must
+ * reach the CLI as literal argv and never as shell syntax. Two layers, in
+ * this order:
+ *
+ *   1. resolveInvocation() maps the command to a real executable — and on
+ *      Windows maps npm's .cmd shim to the package's own .js entrypoint —
+ *      so the spawn runs \`node <entry>\` with shell:false and NO cmd.exe in
+ *      the chain at all. Nothing to escape, nothing to re-tokenize, and no
+ *      %VAR% expansion. (The escaped fallback was measured on a real
+ *      windows-latest runner and does pass %VAR% through literally; layer 1
+ *      is still preferred because it removes the parser rather than
+ *      out-guessing it.)
+ *   2. escapeCmdArg() guards the residual Windows path where step 1 cannot
+ *      identify an entrypoint. Escaping is strictly the weaker layer: it is
+ *      only reachable when resolution fails, and it is the one part of this
+ *      file that a non-Windows CI run cannot prove.
+ */
+
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function done() { process.exit(0); }
+
+/** Case-insensitive env lookup — Windows env keys are not case-stable. */
+function envValue(env, name) {
+  const key = Object.keys(env).find((c) => c.toLowerCase() === name.toLowerCase());
+  return key ? env[key] : undefined;
+}
+
+/**
+ * Locate a command on PATH using fs only.
+ *
+ * Deliberately NOT \`execSync('where ...')\` / \`command -v\`: that spawns a
+ * shell on every hook invocation, which is both the thing this file is
+ * trying to get away from and a per-turn cost. Taking \`env\` and \`platform\`
+ * as arguments is what lets the Windows branch be exercised from a
+ * Linux/macOS CI run — see the Windows argv tests.
+ */
+function resolveCommandPath(command, env = process.env, platform = process.platform) {
+  const hasSeparator = command.includes('/') || command.includes('\\\\');
+  const dirs = hasSeparator
+    ? ['']
+    : (envValue(env, 'PATH') || '').split(platform === 'win32' ? ';' : path.delimiter);
+  const hasExtension = path.extname(command) !== '';
+  const extensions = platform === 'win32' && !(hasSeparator && hasExtension)
+    ? (envValue(env, 'PATHEXT') || '.COM;.EXE;.BAT;.CMD').split(';')
+    : [''];
+  for (const dir of dirs) {
+    for (const ext of extensions) {
+      const base = path.resolve(dir || '.', command);
+      const candidates = ext
+        ? [base + ext.toLowerCase(), base + ext.toUpperCase()]
+        : [base];
+      for (const file of candidates) {
+        try {
+          fs.accessSync(file, platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK);
+          if (fs.statSync(file).isFile()) return file;
+        } catch { /* keep searching */ }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Map an npm-generated Windows shim (ruflo.cmd / npx.cmd / …) to the .js
+ * entrypoint it would have run, so it can be executed as \`node <entry>\`
+ * with no shell.
+ *
+ * Handles both npm layouts: a global prefix (\`<prefix>/ruflo.cmd\` beside
+ * \`<prefix>/node_modules/ruflo\`) and a local one (\`node_modules/.bin/ruflo.cmd\`
+ * beside \`node_modules/ruflo\`). \`npx\` lives in the \`npm\` package, hence the
+ * command→package mapping rather than assuming they match.
+ *
+ * The entrypoint comes from the package's own \`bin\` field, never a guessed
+ * filename, and is required to resolve inside the package directory — a
+ * manifest pointing outside it is refused rather than followed.
+ */
+function resolveNpmShim(shimPath) {
+  const command = path.basename(shimPath, path.extname(shimPath)).toLowerCase();
+  const packageName = command === 'npx' ? 'npm' : command;
+  if (!['ruflo', 'claude-flow', 'npm'].includes(packageName)) return null;
+  try {
+    const shimDir = path.dirname(shimPath);
+    const packageDir = path.basename(shimDir).toLowerCase() === '.bin'
+      ? path.resolve(shimDir, '..', packageName)
+      : path.resolve(shimDir, 'node_modules', packageName);
+    const manifest = JSON.parse(fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8'));
+    const declared = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.[command];
+    if (typeof declared !== 'string') return null;
+    const canonicalPackageDir = fs.realpathSync(packageDir);
+    const canonicalEntry = fs.realpathSync(path.resolve(packageDir, declared));
+    const relativeEntry = path.relative(canonicalPackageDir, canonicalEntry);
+    if (relativeEntry.startsWith('..' + path.sep) || path.isAbsolute(relativeEntry)) return null;
+    if (!fs.statSync(canonicalEntry).isFile()) return null;
+    return { command: process.execPath, args: [canonicalEntry] };
+  } catch { return null; }
+}
+
+/**
+ * Decide how to run \`bin\` without a shell. Returns {command, args}, or null
+ * when no shell-free invocation could be identified (Windows shim that is
+ * not an npm package entry) — the caller then falls back to the escaped
+ * cmd.exe path rather than dropping the hook.
+ */
+function resolveInvocation(bin, binArgs, options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const commandPath = resolveCommandPath(bin, env, platform);
+  if (!commandPath) return null;
+  if (platform === 'win32' && /\\.(?:cmd|bat|ps1)$/i.test(commandPath)) {
+    const npmBin = resolveNpmShim(commandPath);
+    return npmBin ? { command: npmBin.command, args: [...npmBin.args, ...binArgs] } : null;
+  }
+  return { command: commandPath, args: binArgs };
+}
+
+/**
+ * Escape one argv element so it survives BOTH parsers a Windows shell:true
+ * spawn puts it through before the target CLI ever sees it:
+ *   1. cmd.exe's own line tokenizer, which still scans for & | < > ^ % ! " ( )
+ *      even inside a per-argument quoted segment — quoting alone does not
+ *      shield cmd.exe metacharacters, and this runs a SECOND time when the
+ *      resolved binary is itself a .cmd shim (npm's \`ruflo\`/\`claude-flow\`/
+ *      \`npx\` global installs on Windows), because launching a .cmd file is
+ *      cmd.exe re-invoking itself on the command line.
+ *   2. The eventual CommandLineToArgvW argv parse in the target process,
+ *      which needs backslash-before-quote sequences doubled and the value
+ *      quoted so it lands as ONE argument.
+ * Without this, a hook-derived value (e.g. a Bash tool's \`command\`, or a
+ * file path) containing a shell metacharacter can be reinterpreted as a
+ * separate command / redirection instead of reaching the CLI as literal
+ * data — this is the class of bug in CVE-2024-27980 (Node's own .bat/.cmd
+ * argument-injection advisory). Algorithm: https://qntm.org/cmd, the same
+ * reference the \`cross-spawn\` package's Windows escaping is built from.
+ *
+ * Byte-identical to plugins/ruflo-core/scripts/ruflo-hook.cjs so the four
+ * copies can be diffed against each other. This is the fallback, not the
+ * primary defence: resolveInvocation() above is preferred because it removes
+ * cmd.exe from the chain entirely rather than out-guessing its tokenizer.
+ */
+function escapeCmdArg(arg) {
+  let s = String(arg);
+  s = s.replace(/(\\\\*)"/g, '$1$1\\\\"').replace(/(\\\\*)$/, '$1$1');
+  s = \`"\${s}"\`;
+  return s.replace(/[()%!^"<>&|;,]/g, '^$&');
+}
+
+function invokeHook(bin, binArgs, hookArgs, stdinData, options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const spawnOpts = {
+    input: stdinData || '',
+    encoding: 'utf8',
+    stdio: ['pipe', 'ignore', 'ignore'],
+    timeout: 30_000,
+    env,
+  };
+
+  // Layer 1: no shell. CreateProcess/execve receives the argv array
+  // verbatim, so nothing in it can be reinterpreted as syntax.
+  const invocation = resolveInvocation(bin, binArgs, { env, platform });
+  if (invocation) {
+    const result = spawnSync(invocation.command, [...invocation.args, ...hookArgs], {
+      ...spawnOpts,
+      shell: false,
+    });
+    return result.status === 0;
+  }
+
+  // Layer 2: Windows shim we could not map to an entrypoint. cmd.exe is
+  // unavoidable here (CreateProcess cannot launch a .cmd, and Node has
+  // refused to since CVE-2024-27980), so every element is escaped. Losing
+  // the hook entirely would be the wrong trade — telemetry is best-effort,
+  // but silently doing nothing hides breakage.
+  const useShell = platform === 'win32';
+  const args = [...binArgs, ...hookArgs];
+  const result = spawnSync(
+    useShell ? escapeCmdArg(bin) : bin,
+    useShell ? args.map(escapeCmdArg) : args,
+    { ...spawnOpts, shell: useShell },
+  );
+  return result.status === 0;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) done();
+
+  const [subcommand, ...rest] = args;
+
+  let stdinData = '';
+  try { stdinData = fs.readFileSync(0, 'utf8'); } catch { stdinData = ''; }
+
+  const hookArgs = ['hooks', subcommand, ...rest];
+
+  // Presence is checked separately from invocation strategy: a command that
+  // exists but cannot be resolved to an entrypoint still runs, via layer 2.
+  if (resolveCommandPath('ruflo')) { invokeHook('ruflo', [], hookArgs, stdinData); done(); }
+  if (resolveCommandPath('claude-flow')) { invokeHook('claude-flow', [], hookArgs, stdinData); done(); }
+  invokeHook('npx', ['--prefer-offline', '--yes', 'ruflo@latest'], hookArgs, stdinData);
+  done();
+}
+
+// Test seam: the Windows argv suite require()s this file to drive resolveInvocation()
+// and invokeHook() with a simulated { platform: 'win32', env } — which is how
+// the Windows branch is proved from a Linux/macOS CI run. hooks.json always
+// invokes this file directly, so main() runs unconditionally otherwise.
+if (!globalThis.__RUFLO_HOOK_IMPORT_ONLY__) main();
+
+module.exports = { invokeHook, resolveCommandPath, resolveInvocation, resolveNpmShim, escapeCmdArg };
 `;
 }
 //# sourceMappingURL=helpers-generator.js.map