swarmdo 1.58.18 → 1.58.24

package/.claude/agents/base-template-generator.md

@@ -1,6 +1,6 @@
 ---
 name: base-template-generator
-description: Use this agent when you need to create foundational templates, boilerplate code, or starter configurations for new projects, components, or features. This agent excels at generating clean, well-structured base templates that follow best practices and can be easily customized. Examples: <example>Context: User needs to start a new React component and wants a solid foundation. user: 'I need to create a new user profile component' assistant: 'I'll use the base-template-generator agent to create a comprehensive React component template with proper structure, TypeScript definitions, and styling setup.' <commentary>Since the user needs a foundational template for a new component, use the base-template-generator agent to create a well-structured starting point.</commentary></example> <example>Context: User is setting up a new API endpoint and needs a template. user: 'Can you help me set up a new REST API endpoint for user management?' assistant: 'I'll use the base-template-generator agent to create a complete API endpoint template with proper error handling, validation, and documentation structure.' <commentary>The user needs a foundational template for an API endpoint, so use the base-template-generator agent to provide a comprehensive starting point.</commentary></example>
+description: "Use this agent when you need to create foundational templates, boilerplate code, or starter configurations for new projects, components, or features. This agent excels at generating clean, well-structured base templates that follow best practices and can be easily customized. Examples: <example>Context: User needs to start a new React component and wants a solid foundation. user: 'I need to create a new user profile component' assistant: 'I'll use the base-template-generator agent to create a comprehensive React component template with proper structure, TypeScript definitions, and styling setup.' <commentary>Since the user needs a foundational template for a new component, use the base-template-generator agent to create a well-structured starting point.</commentary></example> <example>Context: User is setting up a new API endpoint and needs a template. user: 'Can you help me set up a new REST API endpoint for user management?' assistant: 'I'll use the base-template-generator agent to create a complete API endpoint template with proper error handling, validation, and documentation structure.' <commentary>The user needs a foundational template for an API endpoint, so use the base-template-generator agent to provide a comprehensive starting point.</commentary></example>"
 ---
 
 You are a Base Template Generator, an expert architect specializing in creating clean, well-structured foundational templates and boilerplate code. Your expertise lies in establishing solid starting points that follow industry best practices, maintain consistency, and provide clear extension paths.

package/.claude/agents/goal/code-goal-planner.md

@@ -1,6 +1,6 @@
 ---
 name: code-goal-planner
-description: Code-centric Goal-Oriented Action Planning specialist that creates intelligent plans for software development objectives. Excels at breaking down complex coding tasks into achievable milestones with clear success criteria. Examples: <example>Context: User needs to implement a new authentication system. user: 'I need to add OAuth2 authentication to our API' assistant: 'I'll use the code-goal-planner agent to create a comprehensive implementation plan with milestones for OAuth2 integration, including provider setup, token management, and security considerations.' <commentary>Since this is a complex feature implementation, the code-goal-planner will break it down into testable milestones.</commentary></example> <example>Context: User wants to improve application performance. user: 'Our app is slow, we need to optimize database queries' assistant: 'I'll use the code-goal-planner agent to develop a performance optimization plan with measurable targets for query optimization, including profiling, indexing strategies, and caching implementation.' <commentary>Performance optimization requires systematic planning with clear metrics, perfect for code-goal-planner.</commentary></example>
+description: "Code-centric Goal-Oriented Action Planning specialist that creates intelligent plans for software development objectives. Excels at breaking down complex coding tasks into achievable milestones with clear success criteria. Examples: <example>Context: User needs to implement a new authentication system. user: 'I need to add OAuth2 authentication to our API' assistant: 'I'll use the code-goal-planner agent to create a comprehensive implementation plan with milestones for OAuth2 integration, including provider setup, token management, and security considerations.' <commentary>Since this is a complex feature implementation, the code-goal-planner will break it down into testable milestones.</commentary></example> <example>Context: User wants to improve application performance. user: 'Our app is slow, we need to optimize database queries' assistant: 'I'll use the code-goal-planner agent to develop a performance optimization plan with measurable targets for query optimization, including profiling, indexing strategies, and caching implementation.' <commentary>Performance optimization requires systematic planning with clear metrics, perfect for code-goal-planner.</commentary></example>"
 ---
 
 You are a Code-Centric Goal-Oriented Action Planning (GOAP) specialist integrated with SPARC methodology, focused exclusively on software development objectives. You excel at transforming vague development requirements into concrete, achievable coding milestones using the systematic SPARC approach (Specification, Pseudocode, Architecture, Refinement, Completion) with clear success criteria and measurable outcomes.

package/.claude/helpers/hook-handler.cjs

@@ -144,19 +144,23 @@ const handlers = {
     } else {
       console.log('[INFO] Router not available, using default routing');
     }
-    // Agentic prompts → remind the main agent to actually USE Swarmdo: spawn
-    // Claude Code agents AND bridge them so Swarmdo tracks the work and
-    // auto-forms a swarm. Advisory + fully guarded — never breaks the prompt.
+    // Agentic prompts → suggest spawning a swarm, and which roles. Swarmdo
+    // cannot call Claude Code's Agent tool itself, so this advisory is the only
+    // way it can ask. Fully guarded — never breaks the prompt.
+    //
+    // Deliberately does NOT mention `agent bridge register` (#108): the
+    // SubagentStart hook registers every subagent on spawn, so telling the main
+    // agent to register by hand is both wrong and redundant work. This fires on
+    // every agentic prompt, so it is kept to one line — the three lines of
+    // manual-registration instructions it replaced were pure token cost.
     try {
       if (router && router.classifyAgentic) {
         const intent = router.classifyAgentic(prompt);
         if (intent.requiresAgents) {
           const roles = intent.roles.join(', ');
           console.log('');
-          console.log('[SWARMDO] Agentic task — use the swarm: after you spawn Claude Code agents,');
-          console.log('  register each so Swarmdo tracks them and auto-forms a swarm from your config:');
-          console.log('    swarmdo agent bridge register -n <agent-name> -t <role> -s <session>');
-          console.log('  suggested roles: ' + roles + '   ·   then: swarmdo agent bridge list / swarm status');
+          console.log('[SWARMDO] Agentic task — consider spawning agents: ' + roles
+            + '  (auto-registered on spawn; see `swarmdo swarm status`)');
         }
       }
     } catch (e) { /* advisory only — never break the prompt */ }

package/README.md

@@ -2,7 +2,7 @@
 
 [![swarmdo](swarmdo/assets/brand/logo-full.svg)](https://swarmdo.com)
 
-[![npm version (swarmdo)](https://img.shields.io/badge/npx%20swarmdo-v1.58.18-cb3837?style=for-the-badge&logo=npm&logoColor=white)](https://github.com/SwarmDo/swarmdo/releases)
+[![npm version (swarmdo)](https://img.shields.io/npm/v/swarmdo?style=for-the-badge&logo=npm&logoColor=white&label=npx%20swarmdo&color=cb3837)](https://github.com/SwarmDo/swarmdo/releases)
 [![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](https://github.com/SwarmDo/swarmdo/blob/main/LICENSE)
 [![Website](https://img.shields.io/badge/swarmdo.com-e2a33c?style=for-the-badge&logoColor=black)](https://swarmdo.com)
 [![Star on GitHub](https://img.shields.io/github/stars/SwarmDo/swarmdo?style=for-the-badge&logo=github&color=gold)](https://github.com/SwarmDo/swarmdo)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.58.18",
+  "version": "1.58.24",
   "description": "Swarmdo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@swarmdo/cli/.claude/helpers/agent-bridge-hook.cjs

@@ -0,0 +1,174 @@
+/**
+ * agent-bridge-hook.cjs — bind real Claude Code subagents into Swarmdo's
+ * canonical agent registry, automatically.
+ *
+ * #108. `src/agent-bridge/bridge.ts` was written to solve "a session can run
+ * four Claude Code agents while `swarmdo agent list` stays empty", and is pure
+ * by design because "All fs / MCP / spawning lives in the command + hook
+ * layers". The command layer got built (`swarmdo agent bridge register`); the
+ * hook layer never did. So nothing ever registered a Task/Agent-tool subagent,
+ * `.swarmdo/agents/store.json` stayed `{"agents":{}}`, and the statusline's
+ * `🐝 Swarms N   🤖 Agents M` sat at 0/0 forever. This file is that missing
+ * hook layer.
+ *
+ * Why shell out to the CLI instead of writing the store here: registering is
+ * not just a store write — `agent_bridge_register` also auto-forms a swarm from
+ * config and enrolls the agent (agent-tools.ts:462), which is what makes the
+ * Swarms counter move too. bridge.ts's own rule is to go through the canonical
+ * registerAgent path — "NO parallel store". Reimplementing that in CJS would
+ * fork the registry. The CLI costs ~850ms to boot (it loads ONNX), far too slow
+ * to block every subagent spawn, so calls are fired detached and unref'd: the
+ * hook returns immediately and the registry lands ~1s later. The statusline
+ * polls every 5s, so eventual consistency is invisible here.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+/**
+ * Mirror of src/agent-bridge/bridge.ts `bridgeAgentId` — kept in sync by hand,
+ * because this hook is standalone CommonJS and cannot import the ESM engine
+ * (the same constraint router.cjs already works under for classifyPrompt).
+ * __tests__/agent-bridge-hook.test.ts asserts the two implementations agree.
+ *
+ * Deterministic, so SubagentStart and SubagentStop derive the SAME id from the
+ * same agent_id and the stop reliably terminates the record the start created.
+ */
+function bridgeAgentId(d) {
+  const sess = d.sessionId
+    ? d.sessionId.replace(/[^A-Za-z0-9]/g, '').slice(0, 8) || 'nosess'
+    : 'nosess';
+  const safe = String(d.name || '').replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'agent';
+  return `cc-${sess}-${safe}`;
+}
+
+/**
+ * Locate an installed CLI bin. Mirror of statusline.cjs resolveCliBin() — same
+ * candidate order, same reason (#2337): never `npx @latest` from a hook.
+ * Returns null when nothing is installed, in which case we no-op rather than
+ * pay a registry round-trip on every subagent spawn.
+ */
+function resolveCliBin(cwd) {
+  try {
+    const home = os.homedir();
+    const base = cwd || process.cwd();
+    const candidates = [
+      path.join(home, '.claude', 'plugins', 'marketplaces', 'swarmdo', 'bin', 'cli.js'),
+      path.join(base, 'node_modules', '@swarmdo', 'cli', 'bin', 'cli.js'),
+      path.join(base, 'node_modules', 'swarmdo', 'bin', 'cli.js'),
+      path.join(base, 'v3', '@swarmdo', 'cli', 'bin', 'cli.js'),
+    ];
+    try {
+      const binDir = path.dirname(process.execPath);
+      const globalModuleDirs = [
+        path.join(binDir, '..', 'lib', 'node_modules'),
+        path.join(binDir, 'node_modules'),
+        '/opt/homebrew/lib/node_modules',
+        '/usr/local/lib/node_modules',
+      ];
+      for (const prefix of [process.env.npm_config_prefix, process.env.PREFIX, path.join(home, '.npm-global')]) {
+        if (prefix) globalModuleDirs.push(path.join(prefix, 'lib', 'node_modules'));
+      }
+      for (const gm of globalModuleDirs) {
+        candidates.push(
+          path.join(gm, 'swarmdo', 'bin', 'cli.js'),
+          path.join(gm, '@swarmdo', 'cli', 'bin', 'cli.js'),
+        );
+      }
+    } catch { /* ignore */ }
+    for (const p of candidates) {
+      if (fs.existsSync(p)) return p;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+/**
+ * Is this hook payload a real subagent event we should act on? `agent_id` is
+ * present ONLY when the hook fires for a subagent, so it doubles as the guard
+ * against main-thread invocations. Pure.
+ */
+function isSubagentEvent(hookInput) {
+  const id = hookInput && (hookInput.agent_id || hookInput.agentId);
+  return typeof id === 'string' && id.length > 0;
+}
+
+/**
+ * Build the `agent bridge register` argv for a SubagentStart payload, or null
+ * when the payload is not a subagent event. Pure — the spawn happens in
+ * register(). Registering is idempotent on name+session, so a duplicate
+ * SubagentStart updates the bound record rather than forking a second one.
+ */
+function buildRegisterArgs(hookInput) {
+  if (!isSubagentEvent(hookInput)) return null;
+  const agentId = hookInput.agent_id || hookInput.agentId;
+  const sessionId = hookInput.session_id || hookInput.sessionId || '';
+  const agentType = hookInput.agent_type || hookInput.agentType || 'general-purpose';
+  const args = ['agent', 'bridge', 'register', '-n', agentId, '-t', agentType];
+  if (sessionId) args.push('-s', sessionId);
+  return args;
+}
+
+/**
+ * Build the `agent stop` argv for a SubagentStop payload, or null when the
+ * payload is not a subagent event. `agent stop` sets status='terminated'
+ * (agent-tools.ts:721), which is precisely what computeSwarmStatus filters on,
+ * so the Agents count decrements when a subagent finishes. `-f` because a hook
+ * has no TTY and must not hit the interactive confirm. Pure.
+ */
+function buildTerminateArgs(hookInput) {
+  if (!isSubagentEvent(hookInput)) return null;
+  const id = bridgeAgentId({
+    name: hookInput.agent_id || hookInput.agentId,
+    sessionId: hookInput.session_id || hookInput.sessionId,
+  });
+  return ['agent', 'stop', id, '-f'];
+}
+
+/**
+ * Fire a CLI subcommand and forget it. Detached + unref'd + stdio ignored so
+ * the hook process can exit immediately without waiting on the CLI's ~850ms
+ * boot, and without the child dying alongside it.
+ */
+function spawnDetached(args, cwd) {
+  const cliBin = resolveCliBin(cwd);
+  if (!cliBin) return false;
+  try {
+    const child = spawn(process.execPath, [cliBin, ...args], {
+      cwd: cwd || process.cwd(),
+      detached: true,
+      stdio: 'ignore',
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** SubagentStart → bind the subagent (and auto-form its swarm). */
+function register(hookInput, cwd) {
+  const args = buildRegisterArgs(hookInput);
+  if (!args) return false;
+  return spawnDetached(args, cwd || (hookInput && hookInput.cwd));
+}
+
+/** SubagentStop → mark the bound record terminated. */
+function terminate(hookInput, cwd) {
+  const args = buildTerminateArgs(hookInput);
+  if (!args) return false;
+  return spawnDetached(args, cwd || (hookInput && hookInput.cwd));
+}
+
+module.exports = {
+  bridgeAgentId,
+  resolveCliBin,
+  isSubagentEvent,
+  buildRegisterArgs,
+  buildTerminateArgs,
+  spawnDetached,
+  register,
+  terminate,
+};

package/v3/@swarmdo/cli/.claude/helpers/auto-memory-hook.mjs

@@ -34,9 +34,9 @@ const dim = (msg) => console.log(`  ${DIM}${msg}${RESET}`);
 const DEBUG = !!(process.env.SWARMDO_DEBUG || process.env.DEBUG);
 
 // ── Graceful shutdown (FIX 3) ───────────────────────────────────────────────
-// Track the backend in use so a SIGTERM/SIGINT mid-run can still flush it
-// (the JSON backend persists; a SQLite-backed one closes/flushes WAL) instead
-// of leaving a half-written store or a stale lock behind.
+// Track the backend currently in use so a SIGTERM/SIGINT mid-run can still
+// flush it (the JSON backend persists, a SQLite-backed one closes/flushes WAL)
+// instead of leaving a half-written store or a stale lock behind.
 let activeBackend = null;
 let shuttingDown = false;
 function trackBackend(b) { activeBackend = b; return b; }
@@ -177,16 +177,77 @@ class JsonFileBackend {
 // Resolve memory package path (local dev or npm installed)
 // ============================================================================
 
+/**
+ * Resolve a bundled package file (`<pkg>/<relativeFile>`) by trying, in order:
+ *   1. PROJECT_ROOT/v3/<pkg>/<relativeFile>           (monorepo dev layout)
+ *   2. CWD/node_modules/<pkg>/<relativeFile>          (user's project deps)
+ *   3. node_modules walk-up from PROJECT_ROOT
+ *   4. node_modules walk-up from CWD
+ *   5. Global npm prefix — checks the swarmdo / swarmdo / @swarmdo/cli
+ *      bundles, AND the package installed globally on its own
+ *
+ * Returns the resolved absolute path, or null. See issue #2285.
+ */
+async function resolveBundledFile(pkg, relativeFile) {
+  const monorepo = join(PROJECT_ROOT, 'v3', pkg, relativeFile);
+  if (existsSync(monorepo)) return monorepo;
+
+  const cwd = process.env.SWARMDO_CWD || process.cwd();
+  const inCwd = join(cwd, 'node_modules', pkg, relativeFile);
+  if (existsSync(inCwd)) return inCwd;
+
+  const walkUp = (start) => {
+    let dir = start;
+    while (dir && dir !== dirname(dir)) {
+      const candidate = join(dir, 'node_modules', pkg, relativeFile);
+      if (existsSync(candidate)) return candidate;
+      dir = dirname(dir);
+    }
+    return null;
+  };
+
+  const fromProject = walkUp(PROJECT_ROOT);
+  if (fromProject) return fromProject;
+
+  const fromCwd = walkUp(cwd);
+  if (fromCwd) return fromCwd;
+
+  // Global npm prefix fallback — handles `npm i -g swarmdo` and friends, where
+  // the marketplace clone (PROJECT_ROOT) has no access to the bundled deps.
+  try {
+    const { execSync } = await import('child_process');
+    const npmPrefix = execSync('npm prefix -g', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    if (npmPrefix) {
+      // Both Unix (<prefix>/lib/node_modules) and Windows (<prefix>/node_modules)
+      const roots = [join(npmPrefix, 'lib', 'node_modules'), join(npmPrefix, 'node_modules')];
+      const wrappers = ['swarmdo', 'swarmdo', join('@swarmdo', 'cli')];
+      for (const root of roots) {
+        for (const wrapper of wrappers) {
+          const candidate = join(root, wrapper, 'node_modules', pkg, relativeFile);
+          if (existsSync(candidate)) return candidate;
+        }
+        const direct = join(root, pkg, relativeFile);
+        if (existsSync(direct)) return direct;
+      }
+    }
+  } catch { /* npm not on PATH or no global install */ }
+
+  return null;
+}
+
 async function loadMemoryPackage() {
-  // Strategy 1: Local dev (built dist)
-  const localDist = join(PROJECT_ROOT, 'v3/@swarmdo/memory/dist/index.js');
-  if (existsSync(localDist)) {
+  // Strategy 1-5: locate dist/index.js across dev/installed/global layouts
+  const resolved = await resolveBundledFile('@swarmdo/memory', 'dist/index.js');
+  if (resolved) {
     try {
-      return await import(`file://${localDist}`);
+      return await import(`file://${resolved}`);
     } catch { /* fall through */ }
   }
 
-  // Strategy 2: Use createRequire for CJS-style resolution (handles nested node_modules
+  // Strategy 6: Use createRequire for CJS-style resolution (handles nested node_modules
   // when installed as a transitive dependency via npx swarmdo / npx swarmdo)
   try {
     const { createRequire } = await import('module');
@@ -194,24 +255,11 @@ async function loadMemoryPackage() {
     return require('@swarmdo/memory');
   } catch { /* fall through */ }
 
-  // Strategy 3: ESM import (works when @swarmdo/memory is a direct dependency)
+  // Strategy 7: ESM import (works when @swarmdo/memory is a direct dependency)
   try {
     return await import('@swarmdo/memory');
   } catch { /* fall through */ }
 
-  // Strategy 4: Walk up from PROJECT_ROOT looking for @swarmdo/memory in any node_modules
-  let searchDir = PROJECT_ROOT;
-  const { parse } = await import('path');
-  while (searchDir !== parse(searchDir).root) {
-    const candidate = join(searchDir, 'node_modules', '@swarmdo', 'memory', 'dist', 'index.js');
-    if (existsSync(candidate)) {
-      try {
-        return await import(`file://${candidate}`);
-      } catch { /* fall through */ }
-    }
-    searchDir = dirname(searchDir);
-  }
-
   return null;
 }
 
@@ -270,7 +318,10 @@ async function doImport() {
   await backend.initialize();
 
   const bridgeConfig = {
-    workingDir: PROJECT_ROOT,
+    // Use Claude Code's invocation cwd (the user's project), not PROJECT_ROOT
+    // — PROJECT_ROOT resolves to the plugin clone when this hook runs from
+    // ~/.claude/plugins/marketplaces/swarmdo/. See issue #2284.
+    workingDir: process.env.SWARMDO_CWD || process.cwd(),
     syncMode: 'on-session-end',
   };
 
@@ -302,6 +353,36 @@ async function doImport() {
     dim(`├─ Learning: ${config.learningBridge.enabled ? 'active' : 'disabled'}`);
     dim(`├─ Graph: ${config.memoryGraph.enabled ? 'active' : 'disabled'}`);
     dim(`└─ Agent scopes: ${config.agentScopes.enabled ? 'active' : 'disabled'}`);
+
+    // Bridge to AgentDB: store entries with ONNX vector embeddings for semantic search
+    let vectorized = 0;
+    try {
+      const cliDistPath = await resolveBundledFile('@swarmdo/cli', 'dist/src/memory/memory-initializer.js');
+      if (cliDistPath) {
+        const memInit = await import(`file://${cliDistPath}`);
+        await memInit.initializeMemoryDatabase({ force: false, verbose: false });
+
+        const entries = await backend.query({});
+        for (const entry of entries) {
+          if (!entry.content || entry.content.length < 10) continue;
+          try {
+            await memInit.storeEntry({
+              key: entry.key || entry.id,
+              value: entry.content,
+              namespace: entry.namespace || 'auto-memory',
+              generateEmbeddingFlag: true,
+            });
+            vectorized++;
+          } catch { /* skip entries that fail to embed */ }
+        }
+
+        if (vectorized > 0) {
+          success(`Vectorized ${vectorized} entries into AgentDB (ONNX 384-dim)`);
+        }
+      }
+    } catch (vecErr) {
+      dim(`AgentDB vectorization skipped: ${vecErr.message?.slice(0, 60)}`);
+    }
   } catch (err) {
     dim(`Import failed (non-critical): ${err.message}`);
   }
@@ -330,7 +411,8 @@ async function doSync() {
   }
 
   const bridgeConfig = {
-    workingDir: PROJECT_ROOT,
+    // See doImport — must reflect the user's project, not PROJECT_ROOT (#2284)
+    workingDir: process.env.SWARMDO_CWD || process.cwd(),
     syncMode: 'on-session-end',
   };
 
@@ -360,6 +442,21 @@ async function doSync() {
     // Curate MEMORY.md index with graph-aware ordering
     await bridge.curateIndex();
     success('Curated MEMORY.md index');
+
+    // Flush intelligence patterns to disk (SONA + ReasoningBank)
+    try {
+      const intPath = await resolveBundledFile('@swarmdo/cli', 'dist/src/memory/intelligence.js');
+      if (intPath) {
+        const intelligence = await import(`file://${intPath}`);
+        if (intelligence.flushPatterns) {
+          intelligence.flushPatterns();
+          const stats = intelligence.getIntelligenceStats?.();
+          if (stats && stats.patternsLearned > 0) {
+            success(`Flushed ${stats.patternsLearned} learned patterns to disk`);
+          }
+        }
+      }
+    } catch { /* non-critical */ }
   } catch (err) {
     dim(`Sync failed (non-critical): ${err.message}`);
   }
@@ -386,9 +483,158 @@ async function doStatus() {
     } catch { /* ignore */ }
   }
 
+  // AgentDB vector status
+  try {
+    const dbPath = join(PROJECT_ROOT, '.swarmdo', 'memory', 'memory.db');
+    const swarmDbPath = join(PROJECT_ROOT, '.swarm', 'memory.db');
+    const hasDb = existsSync(dbPath) || existsSync(swarmDbPath);
+    console.log(`  AgentDB:        ${hasDb ? '✅ sql.js database exists' : '⏸ Not initialized'}`);
+
+    const intPath = await resolveBundledFile('@swarmdo/cli', 'dist/src/memory/intelligence.js');
+    if (intPath) {
+      const intelligence = await import(`file://${intPath}`);
+      const stats = intelligence.getIntelligenceStats?.();
+      if (stats) {
+        console.log(`  SONA:           ${stats.sonaEnabled ? '✅ Active' : '⏸ Not initialized'}`);
+        console.log(`  Patterns:       ${stats.patternsLearned} learned`);
+        console.log(`  Trajectories:   ${stats.trajectoriesRecorded} recorded`);
+      }
+    }
+  } catch { /* ignore */ }
+
   console.log('');
 }
 
+// ============================================================================
+// Import ALL Claude Code memories from all projects into AgentDB
+// ============================================================================
+
+async function doImportAll() {
+  log('Importing ALL Claude Code memories into AgentDB...');
+
+  const { homedir } = await import('os');
+  const { readdirSync } = await import('fs');
+  const claudeProjectsDir = join(homedir(), '.claude', 'projects');
+
+  if (!existsSync(claudeProjectsDir)) {
+    dim('No Claude Code projects found at ' + claudeProjectsDir);
+    return;
+  }
+
+  // Find all memory files across all projects
+  const memoryFiles = [];
+  try {
+    const projects = readdirSync(claudeProjectsDir, { withFileTypes: true });
+    for (const project of projects) {
+      if (!project.isDirectory()) continue;
+      const memDir = join(claudeProjectsDir, project.name, 'memory');
+      if (!existsSync(memDir)) continue;
+      const files = readdirSync(memDir).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        memoryFiles.push({
+          path: join(memDir, file),
+          project: project.name,
+          file,
+        });
+      }
+    }
+  } catch (err) {
+    dim('Error scanning projects: ' + err.message);
+    return;
+  }
+
+  if (memoryFiles.length === 0) {
+    dim('No memory files found');
+    return;
+  }
+
+  log(`Found ${memoryFiles.length} memory files across ${new Set(memoryFiles.map(f => f.project)).size} projects`);
+
+  // Load memory-initializer for vectorized storage
+  let memInit = null;
+  try {
+    const cliDistPath = await resolveBundledFile('@swarmdo/cli', 'dist/src/memory/memory-initializer.js');
+    if (cliDistPath) {
+      memInit = await import(`file://${cliDistPath}`);
+      await memInit.initializeMemoryDatabase({ force: false, verbose: false });
+    }
+  } catch (err) {
+    dim('Memory initializer not available: ' + err.message?.slice(0, 60));
+  }
+
+  if (!memInit) {
+    dim('Cannot vectorize without memory-initializer. Run: cd v3/@swarmdo/cli && npm run build');
+    return;
+  }
+
+  let imported = 0;
+  let skipped = 0;
+
+  for (const memFile of memoryFiles) {
+    try {
+      const content = readFileSync(memFile.path, 'utf-8');
+
+      // Parse YAML frontmatter + body
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+      let name = memFile.file.replace('.md', '');
+      let description = '';
+      let type = 'auto-memory';
+      let body = content;
+
+      if (frontmatterMatch) {
+        const yaml = frontmatterMatch[1];
+        body = frontmatterMatch[2].trim();
+        const nameMatch = yaml.match(/^name:\s*(.+)$/m);
+        const descMatch = yaml.match(/^description:\s*(.+)$/m);
+        const typeMatch = yaml.match(/^type:\s*(.+)$/m);
+        if (nameMatch) name = nameMatch[1].trim();
+        if (descMatch) description = descMatch[1].trim();
+        if (typeMatch) type = typeMatch[1].trim();
+      }
+
+      // Split body into sections (## headers) for granular entries
+      const sections = body.split(/^(?=## )/m).filter(s => s.trim().length > 20);
+
+      if (sections.length === 0) {
+        // Store whole file as one entry
+        if (body.length > 10) {
+          await memInit.storeEntry({
+            key: `claude-memory:${memFile.project}:${name}`,
+            value: body.slice(0, 4096),
+            namespace: 'claude-memories',
+            generateEmbeddingFlag: true,
+          });
+          imported++;
+        }
+      } else {
+        // Store each section separately for better search granularity
+        for (const section of sections) {
+          const titleMatch = section.match(/^##\s+(.+)/);
+          const sectionTitle = titleMatch ? titleMatch[1].trim() : name;
+          const sectionBody = section.replace(/^##\s+.+\n/, '').trim();
+          if (sectionBody.length < 10) continue;
+
+          await memInit.storeEntry({
+            key: `claude-memory:${memFile.project}:${name}:${sectionTitle.slice(0, 50)}`,
+            value: sectionBody.slice(0, 4096),
+            namespace: 'claude-memories',
+            generateEmbeddingFlag: true,
+          });
+          imported++;
+        }
+      }
+
+      dim(`  ✓ ${memFile.project}/${memFile.file} (${sections.length || 1} entries)`);
+    } catch (err) {
+      dim(`  ✗ ${memFile.project}/${memFile.file}: ${err.message?.slice(0, 60)}`);
+      skipped++;
+    }
+  }
+
+  success(`Imported ${imported} entries from ${memoryFiles.length} files (${skipped} skipped)`);
+  success('All Claude Code memories now searchable via AgentDB vector search');
+}
+
 // ============================================================================
 // Main
 // ============================================================================
@@ -417,17 +663,18 @@ if (import.meta.url === pathToFileURL(process.argv[1] || '').href) {
   try {
     switch (command) {
       case 'import': await doImport(); break;
+      case 'import-all': await doImportAll(); break;
       case 'sync': await doSync(); break;
       case 'status': await doStatus(); break;
       default:
         console.log('Usage: auto-memory-hook.mjs <import|sync|status>');
-        break;
+        process.exit(1);
     }
   } catch (err) {
     // Hooks must never crash Claude Code - fail silently
-    try { dim(`Error (non-critical): ${err.message}`); } catch (_) {}
+    dim(`Error (non-critical): ${err.message}`);
   }
-  // Force clean exit — process.exitCode alone isn't enough if async errors override it
+  // Ensure clean exit for Claude Code hooks (exit 0 = success, no stderr = no error)
   process.exit(0);
 }