specmem-hardwicksoftware 3.7.30 → 3.7.32

package/claude-hooks/specmem-search-enforcer.cjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+/**
+ * SPECMEM SEARCH ENFORCER - PreToolUse Hook
+ * ==========================================
+ *
+ * HARD BLOCKS agents that skip SpecMem semantic search.
+ *
+ * Rules:
+ * 1. Agents CANNOT do ANYTHING until they've called find_memory or find_code_pointers at least once
+ * 2. Every 3 searches (Grep/Glob/Read), agents MUST call find_code_pointers again
+ * 3. After find_code_pointers, agents MUST drill_down before continuing
+ * 4. 2nd search in a cycle: WARNING injected
+ * 5. 3rd search in a cycle: HARD BLOCK (deny)
+ * 6. Tool calls and other non-search tools DO NOT reset the counter
+ * 7. Main session (non-agent) gets suggestions, not blocks
+ *
+ * State: /tmp/specmem-search-enforcer-{session}.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// --- Agent detection (inline, no require chain issues) ---
+function isAgent() {
+  const markers = [
+    process.env.CLAUDE_AGENT === 'true',
+    process.env.CLAUDE_AGENT_TYPE,
+    process.env.TASK_ID,
+    (process.env.CLAUDE_WORKTREE || '').length > 0,
+    (process.env.CLAUDE_SESSION_ID || '').includes('task-'),
+  ];
+  return markers.some(Boolean);
+}
+
+// --- Config ---
+const SEARCH_TOOLS = ['Grep', 'Glob', 'Read', 'Bash'];
+const WRITE_TOOLS = ['Edit', 'Write'];
+const ALL_BLOCKED_TOOLS = [...SEARCH_TOOLS, ...WRITE_TOOLS];
+
+const SPECMEM_SEARCH_TOOLS = [
+  'mcp__specmem__find_memory',
+  'mcp__specmem__find_code_pointers',
+  'mcp__specmem__smart_search',
+];
+
+const SPECMEM_DRILLDOWN_TOOLS = [
+  'mcp__specmem__drill_down',
+  'mcp__specmem__get_memory',
+  'mcp__specmem__get_memory_by_id',
+  'mcp__specmem__getMemoryFull',
+];
+
+const SPECMEM_CODE_POINTER_TOOLS = [
+  'mcp__specmem__find_code_pointers',
+];
+
+const SEARCH_CYCLE_LIMIT = 3; // block on 3rd search
+const WARN_AT = 2; // warn on 2nd search
+
+// --- State management ---
+function getStateFile() {
+  const sessionId = process.env.CLAUDE_SESSION_ID || process.env.TASK_ID || 'default';
+  const sanitized = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return `/tmp/specmem-search-enforcer-${sanitized}.json`;
+}
+
+function getState() {
+  try {
+    const f = getStateFile();
+    if (fs.existsSync(f)) {
+      const data = JSON.parse(fs.readFileSync(f, 'utf-8'));
+      // Expire after 30 min
+      if (data.timestamp && (Date.now() - data.timestamp > 30 * 60 * 1000)) {
+        return freshState();
+      }
+      return data;
+    }
+  } catch (e) {
+    try { fs.unlinkSync(getStateFile()); } catch (_) {}
+  }
+  return freshState();
+}
+
+function freshState() {
+  return {
+    hasUsedSpecmemSearch: false,
+    searchesSinceLastCodePointers: 0,
+    pendingDrilldown: false,
+    lastCodePointersQuery: null,
+    timestamp: Date.now(),
+  };
+}
+
+function saveState(state) {
+  try {
+    state.timestamp = Date.now();
+    fs.writeFileSync(getStateFile(), JSON.stringify(state, null, 2));
+  } catch (e) { /* silent */ }
+}
+
+// --- stdin reader with timeout ---
+function readStdinWithTimeout(timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    let input = '';
+    const timer = setTimeout(() => {
+      process.stdin.destroy();
+      resolve(input);
+    }, timeoutMs);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { input += chunk; });
+    process.stdin.on('end', () => { clearTimeout(timer); resolve(input); });
+    process.stdin.on('error', () => { clearTimeout(timer); resolve(input); });
+  });
+}
+
+// --- Main ---
+async function main() {
+  const inputData = await readStdinWithTimeout(5000);
+
+  try {
+    const hookData = JSON.parse(inputData);
+    const toolName = hookData.tool_name || '';
+    const toolInput = hookData.tool_input || {};
+    const state = getState();
+
+    // --- SpecMem search tool used (find_memory, find_code_pointers, smart_search) ---
+    if (SPECMEM_SEARCH_TOOLS.includes(toolName)) {
+      state.hasUsedSpecmemSearch = true;
+
+      // find_code_pointers resets the search counter AND sets drilldown pending
+      if (SPECMEM_CODE_POINTER_TOOLS.includes(toolName)) {
+        state.searchesSinceLastCodePointers = 0;
+        state.pendingDrilldown = true;
+        state.lastCodePointersQuery = toolInput.query || '(unknown)';
+      }
+
+      saveState(state);
+      process.exit(0); // allow
+    }
+
+    // --- Drilldown tool used (drill_down, get_memory, etc) ---
+    if (SPECMEM_DRILLDOWN_TOOLS.includes(toolName)) {
+      state.pendingDrilldown = false;
+      saveState(state);
+      process.exit(0); // allow
+    }
+
+    // --- Non-agent: suggest only, never block ---
+    if (!isAgent()) {
+      process.exit(0); // allow everything for main session
+    }
+
+    // === AGENT ENFORCEMENT BELOW ===
+
+    // --- Rule 1: Agent hasn't used ANY specmem search yet -> HARD BLOCK everything ---
+    if (!state.hasUsedSpecmemSearch && ALL_BLOCKED_TOOLS.includes(toolName)) {
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: `BLOCKED: You MUST call find_memory or find_code_pointers BEFORE using ${toolName}. No Read/Write/Grep/Glob/Edit/Bash allowed until you search SpecMem first. Run: mcp__specmem__find_code_pointers({query: "your task description"})`
+        }
+      };
+      console.log(JSON.stringify(output));
+      process.exit(0);
+    }
+
+    // --- Rule 3: Pending drilldown after find_code_pointers -> BLOCK until drilled ---
+    if (state.pendingDrilldown && ALL_BLOCKED_TOOLS.includes(toolName)) {
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: `BLOCKED: You ran find_code_pointers("${state.lastCodePointersQuery}") but haven't drilled down into the results yet. You MUST call drill_down({drilldownID: N}) or get_memory({id: "ID"}) before using ${toolName}. Drill into the results first!`
+        }
+      };
+      console.log(JSON.stringify(output));
+      process.exit(0);
+    }
+
+    // --- Count searches for cycle enforcement ---
+    if (SEARCH_TOOLS.includes(toolName)) {
+      state.searchesSinceLastCodePointers++;
+      saveState(state);
+
+      // Rule 5: 3rd search -> HARD BLOCK
+      if (state.searchesSinceLastCodePointers >= SEARCH_CYCLE_LIMIT) {
+        const output = {
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'deny',
+            permissionDecisionReason: `BLOCKED: You've done ${state.searchesSinceLastCodePointers} searches without calling find_code_pointers. Every 3 searches you MUST call mcp__specmem__find_code_pointers to refresh your semantic context. Do it now before continuing.`
+          }
+        };
+        console.log(JSON.stringify(output));
+        process.exit(0);
+      }
+
+      // Rule 4: 2nd search -> WARNING
+      if (state.searchesSinceLastCodePointers >= WARN_AT) {
+        const output = {
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'allow',
+            permissionDecisionReason: `WARNING: ${state.searchesSinceLastCodePointers}/${SEARCH_CYCLE_LIMIT} searches used. You MUST call find_code_pointers before your next search or you'll be blocked. Consider running it now.`,
+            additionalContext: `\u26a0\ufe0f SEARCH LIMIT WARNING: ${state.searchesSinceLastCodePointers}/${SEARCH_CYCLE_LIMIT} searches since last find_code_pointers. Next search WILL BE BLOCKED. Run mcp__specmem__find_code_pointers now.`
+          }
+        };
+        console.log(JSON.stringify(output));
+        process.exit(0);
+      }
+    }
+
+    // --- Write tools increment search counter too (they shouldn't write blind) ---
+    if (WRITE_TOOLS.includes(toolName)) {
+      // Don't count writes toward search limit, but they're allowed if we passed the checks above
+      saveState(state);
+    }
+
+    // Allow everything else (Task, ToolSearch, MCP tools, etc)
+    process.exit(0);
+
+  } catch (error) {
+    // Parse failure = allow (don't break the session)
+    process.exit(0);
+  }
+}
+
+main().catch(() => process.exit(0));

package/claude-hooks/specmem-search-tracker.cjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * SPECMEM SEARCH TRACKER - PostToolUse Hook
+ * ===========================================
+ *
+ * Tracks when agents use SpecMem semantic tools (find_memory, find_code_pointers, drill_down)
+ * and resets the search counter so enforcer unblocks.
+ *
+ * Also tracks Grep/Glob calls to increment search counter.
+ *
+ * AGENTS ONLY - main session skipped.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Agent detection
+function isAgent() {
+  const e = process.env;
+  if (e.CLAUDE_AGENT === '1' || e.CLAUDE_AGENT === 'true') return true;
+  if (e.TASK_ID || e.AGENT_ID || e.WORKTREE_PATH) return true;
+  if (e.CLAUDE_CODE_ENTRYPOINT === 'task') return true;
+  const ppid = e.CLAUDE_PARENT_PID || e.PARENT_PID;
+  if (ppid && ppid !== '1' && ppid !== String(process.pid)) return true;
+  return false;
+}
+
+function main() {
+  if (!isAgent()) {
+    console.log(JSON.stringify({ permissionDecision: 'allow' }));
+    return;
+  }
+
+  const toolName = process.env.TOOL_NAME || '';
+  const sessionId = process.env.SESSION_ID || process.env.CLAUDE_SESSION_ID || process.ppid?.toString() || 'unknown';
+  const stateDir = '/tmp/specmem-enforcer';
+  const stateFile = path.join(stateDir, `${sessionId}.json`);
+
+  try { fs.mkdirSync(stateDir, { recursive: true }); } catch {}
+
+  let state = { searchCount: 0, specmemUsed: false, drilldownRequired: false, drilldownDone: false };
+  try { state = JSON.parse(fs.readFileSync(stateFile, 'utf8')); } catch {}
+
+  const isSpecmemSearch = /find_memory|find_code_pointers/i.test(toolName);
+  const isDrilldown = /drill_down/i.test(toolName);
+  const isSearchTool = /^(Grep|Glob)$/i.test(toolName);
+
+  if (isSpecmemSearch) {
+    state.specmemUsed = true;
+    state.searchCount = 0; // Reset search counter
+    // find_code_pointers requires drill_down after
+    if (/find_code_pointers/i.test(toolName)) {
+      state.drilldownRequired = true;
+      state.drilldownDone = false;
+    }
+  }
+
+  if (isDrilldown) {
+    state.drilldownDone = true;
+    state.drilldownRequired = false;
+  }
+
+  if (isSearchTool) {
+    state.searchCount = (state.searchCount || 0) + 1;
+  }
+
+  try { fs.writeFileSync(stateFile, JSON.stringify(state)); } catch {}
+  console.log(JSON.stringify({ permissionDecision: 'allow' }));
+}
+
+main();

package/claude-hooks/specmem-session-start.cjs

@@ -283,10 +283,10 @@ function getLastSessionOutput() {
 
     let sessionContent;
     if (startIdx === -1) {
-      sessionContent = lines.slice(-200).join('\n');
+      sessionContent = lines.slice(-40).join('\n');
     } else {
       const outputLines = lines.slice(startIdx + 2, endIdx > 0 ? endIdx : undefined);
-      sessionContent = outputLines.slice(-200).join('\n');
+      sessionContent = outputLines.slice(-40).join('\n');
     }
 
     // FILTER OUT GARBAGE - Skills, corrupted content, and non-conversation data
@@ -331,6 +331,14 @@ function getLastSessionOutput() {
  * Only includes: last 10 interactions + condensed tool list
  * NO skill injection, NO verbose schemas
  */
+
+/**
+ * Compact tool reminder
+ */
+function getToolReminder() {
+  return '## SpecMem Tools Available\n\n**Memory Search:** `find_memory` | `find_code_pointers` | `drill_down` | `get_memory`\n**Storage:** `save_memory` | `link_the_vibes` | `smush_memories_together`\n**Team:** `send_team_message` | `read_team_messages` | `claim_task` / `release_task`\n**System:** `show_me_the_stats` | `check_sync` | `start_watching`\n\nUse·`/specmem`·令④ⓢ.';
+}
+
 function formatOutput(memories, lastSession, projectPath, sessionId) {
   const sections = [];
 
@@ -338,15 +346,29 @@ function formatOutput(memories, lastSession, projectPath, sessionId) {
   sections.push(`Project: ${projectPath}`);
   sections.push(`Session: ${sessionId}`);
 
-  // Previous session output (if available) - BRIEF version
+  // Previous session output (if available) - compressed
   if (lastSession && lastSession.content) {
     sections.push('');
     sections.push(`## PREVIOUS SESSION OUTPUT (${lastSession.ageMinutes}m ago, reason: ${lastSession.reason})`);
     sections.push('(Previous  session):');
-    sections.push('```');
-    // DON'T compress - just take first 500 chars of clean content
-    sections.push(lastSession.content.slice(0, 500).trim());
-    sections.push('```');
+
+    // Truncate to 40 lines for token efficiency
+    const contentLines = lastSession.content.split('\n');
+    let sessionContent;
+    if (contentLines.length > 40) {
+      sessionContent = contentLines.slice(0, 15).join('\n') +
+        `\n... [${contentLines.length - 25} lines omitted] ...\n` +
+        contentLines.slice(-10).join('\n');
+    } else {
+      sessionContent = lastSession.content;
+    }
+
+    const compressedSession = compressHookOutput(sessionContent, {
+      threshold: 0.60,
+      minLength: 30,
+      includeWarning: false
+    });
+    sections.push(compressedSession.trim());
   }
 
   // Recent memories - last 10 user/claude interactions ONLY
@@ -360,34 +382,9 @@ function formatOutput(memories, lastSession, projectPath, sessionId) {
     });
   }
 
-  // CONDENSED tool reminder - just names, no descriptions
-  sections.push('');
-  sections.push('## SpecMem Tools Available');
-  sections.push('');
-  sections.push('**Memory Search:**');
-  sections.push('- `find_memory` - Semantic search across all memories');
-  sections.push('- `find_code_pointers` - Search code with tracebacks');
-  sections.push('- `drill_down` - Explore memory details');
-  sections.push('- `get_memory` - Get specific memory by ID');
-  sections.push('');
-  sections.push('**Memory Storage:**');
-  sections.push('- `save_memory` - Store new memories');
-  sections.push('- `link_the_vibes` - Connect related memories');
-  sections.push('- `smush_memories_together` - Consolidate similar memories');
-  sections.push('');
-  sections.push('**Team Comms:**');
-  sections.push('- `send_team_message` - Message team members');
-  sections.push('- `read_team_messages` - Check team updates');
-  sections.push('- `claim_task` / `release_task` - Coordinate work');
+  // Compact tool reminder
   sections.push('');
-  sections.push('**System:**');
-  sections.push('- `show_me_the_stats` - Memory statistics');
-  sections.push('- `check_sync` - Verify file sync status');
-  sections.push('- `start_watching` - Enable file watcher');
-  sections.push('');
-  sections.push('Use `/specmem` for all commands.');
-  sections.push('');
-  sections.push('**Chinese compression:** You can read Traditional Chinese compression with 99%+ accuracy.');
+  sections.push(getToolReminder());
   sections.push('[/SPECMEM-SESSION]');
 
   return sections.join('\n');
@@ -476,23 +473,14 @@ async function main() {
   const lastSession = getLastSessionOutput();
 
   // Format output
-  let output = formatOutput(memories, lastSession, projectPath, sessionId);
-
-  // Apply Traditional Chinese compression to final output
-  const compressed = compressHookOutput(output, {
-    threshold: 0.50,
-    minLength: 100,
-    preserveStructure: true,
-    includeWarning: false  // We add our own prefix below
-  });
+  let context = formatOutput(memories, lastSession, projectPath, sessionId);
 
-  // Prepend reminder for  to read the compressed Chinese AND respond in English
-  const prefixedOutput = `[SpecMem Context - Read this for continuity]
-IMPORTANT: You can read Traditional Chinese compression with 99%+ accuracy. ALWAYS respond in English.
-${compressed}`;
-
-  // Output - clean trailing whitespace
-  console.log(prefixedOutput.split('\n').map(l => l.trimEnd()).join('\n').trim());
+  const compressedContext = compressHookOutput(context, {
+    threshold: 0.70,
+    minLength: 50,
+    includeWarning: true
+  });
+  console.log(compressedContext.trim());
 
   process.exit(0);
 }

package/claude-hooks/specmem-session-start.js

@@ -585,7 +585,7 @@ function getLastSessionOutput(projectPath) {
     if (startIdx === -1) {
       // No header found, use whole content but limit to 300 lines
       return {
-        content: lines.slice(-300).join('\n'),
+        content: lines.slice(-40).join('\n'),
         ageMinutes,
         reason: lines.find(l => l.startsWith('# Reason:'))?.replace('# Reason:', '').trim() || 'unknown'
       };
@@ -593,7 +593,7 @@ function getLastSessionOutput(projectPath) {
 
     // Get the actual output between markers, limit to last 300 lines for context efficiency
     const outputLines = lines.slice(startIdx + 2, endIdx > 0 ? endIdx : undefined);
-    const trimmedOutput = outputLines.slice(-300).join('\n');
+    const trimmedOutput = outputLines.slice(-40).join('\n');
 
     return {
       content: trimmedOutput,
@@ -639,32 +639,7 @@ function getCompactionStatus(projectPath) {
  * NOTE: Returns trimmed string with NO leading/trailing whitespace
  */
 function getToolReminder() {
-  return [
-    '## SpecMem Tools Available',
-    '',
-    '**Memory Search:**',
-    '- `find_memory` - Semantic search across all memories',
-    '- `find_code_pointers` - Search code with tracebacks',
-    '- `drill_down` - Explore memory details',
-    '- `get_memory` - Get specific memory by ID',
-    '',
-    '**Memory Storage:**',
-    '- `save_memory` - Store new memories',
-    '- `link_the_vibes` - Connect related memories',
-    '- `smush_memories_together` - Consolidate similar memories',
-    '',
-    '**Team Communication:**',
-    '- `send_team_message` - Message team members',
-    '- `read_team_messages` - Check team updates',
-    '- `claim_task` / `release_task` - Coordinate work',
-    '',
-    '**System:**',
-    '- `show_me_the_stats` - Memory statistics',
-    '- `check_sync` - Verify file sync status',
-    '- `start_watching` - Enable file watcher',
-    '',
-    'Use `/specmem` for quick commands or `/specmem-drilldown` for deep search.'
-  ].join('\n');
+  return '## SpecMem Tools Available\n\n**Memory Search:** `find_memory` | `find_code_pointers` | `drill_down` | `get_memory`\n**Storage:** `save_memory` | `link_the_vibes` | `smush_memories_together`\n**Team:** `send_team_message` | `read_team_messages` | `claim_task` / `release_task`\n**System:** `show_me_the_stats` | `check_sync` | `start_watching`\n\nUse·`/specmem`·令④ⓢ.';
 }
 
 /**
@@ -773,28 +748,21 @@ async function main() {
     // Truncate to ~200 lines for token efficiency but keep the important parts
     const contentLines = lastSession.content.split('\n');
     let sessionContent;
-    if (contentLines.length > 200) {
-      sessionContent = contentLines.slice(0, 50).join('\n') +
-        `\n... [${contentLines.length - 100} lines omitted] ...\n` +
-        contentLines.slice(-50).join('\n');
+    if (contentLines.length > 40) {
+      sessionContent = contentLines.slice(0, 15).join('\n') +
+        `\n... [${contentLines.length - 25} lines omitted] ...\n` +
+        contentLines.slice(-10).join('\n');
     } else {
       sessionContent = lastSession.content;
     }
 
-    // SESSION CONTENT: Output FULL readable content (no compression)
-    // Compression was causing unreadable Chinese output - disabled for readability
-    // Only compress if explicitly requested via SPECMEM_COMPRESS_SESSION=1
     sections.push('```');
-    if (process.env.SPECMEM_COMPRESS_SESSION === '1') {
-      const compressedSession = compressHookOutput(sessionContent, {
-        threshold: 0.60,
-        minLength: 30,
-        includeWarning: false  // Warning already added at top level
-      });
-      sections.push(compressedSession.trim());
-    } else {
-      sections.push(sessionContent.trim());
-    }
+    const compressedSession = compressHookOutput(sessionContent, {
+      threshold: 0.60,
+      minLength: 30,
+      includeWarning: false
+    });
+    sections.push(compressedSession.trim());
     sections.push('```');
   }
 
@@ -857,21 +825,12 @@ async function main() {
     .replace(/\n{3,}/g, '\n\n')   // Collapse 3+ newlines to 2 (one blank line)
     .trim();                       // Remove leading/trailing whitespace
 
-  // SESSION START: Output full context WITHOUT compression
-  // Compression makes debugging hard and context is injected at start when there's room
-  // Only compress if SPECMEM_COMPRESS_SESSION is set
-  if (process.env.SPECMEM_COMPRESS_SESSION === '1') {
-    const compressedContext = compressHookOutput(context, {
-      threshold: 0.70,
-      minLength: 50,
-      includeWarning: true
-    });
-    // Final trim to ensure no trailing whitespace
-    console.log(compressedContext.trim());
-  } else {
-    // Output full readable context (already trimmed above)
-    console.log(context);
-  }
+  const compressedContext = compressHookOutput(context, {
+    threshold: 0.70,
+    minLength: 50,
+    includeWarning: true
+  });
+  console.log(compressedContext.trim());
 
   process.exit(0);
 }

package/dist/config.js

@@ -837,24 +837,19 @@ export function loadConfig() {
     const parsedUrl = parseDatabaseUrl();
     // Priority: DATABASE_URL > ENV VAR > .specmemrc > default
     // Per-project isolation still applies if DATABASE_URL not set
-    // Container mode: use unix socket dir as host for postgres connection
-    // When SPECMEM_CONTAINER_MODE is set, or container run dir has postgres socket
-    // FIX: Try both {projectPath}/specmem/run and {projectPath}/run to handle
-    // the case where projectPath IS the specmem dir (avoids specmem/specmem/run)
+    // Container mode: postgres via unix socket in specmem/run/ (bind-mounted from container /data/run)
+    // Socket appears after container starts PG — dir must exist, socket arrives when PG is ready
     let containerRunDir = path.join(projectPath, 'specmem', 'run');
-    const containerSocketExists = (() => {
-        try {
-            if (fs.existsSync(path.join(containerRunDir, '.s.PGSQL.5432'))) return true;
-            // Fallback: projectPath might BE the specmem dir
-            const altRunDir = path.join(projectPath, 'run');
-            if (fs.existsSync(path.join(altRunDir, '.s.PGSQL.5432'))) {
-                containerRunDir = altRunDir;
-                return true;
-            }
-            return false;
-        } catch { return false; }
-    })();
+    // Also check projectPath/run in case projectPath IS the specmem dir
+    if (!fs.existsSync(containerRunDir) && fs.existsSync(path.join(projectPath, 'run'))) {
+        containerRunDir = path.join(projectPath, 'run');
+    }
+    const containerSocketExists = fs.existsSync(path.join(containerRunDir, '.s.PGSQL.5432'));
     const isContainerMode = process.env['SPECMEM_CONTAINER_MODE'] === 'true' || containerSocketExists;
+    if (isContainerMode) {
+        // Ensure socket directory exists on host — container bind-mounts here
+        try { fs.mkdirSync(containerRunDir, { recursive: true }); } catch (e) { /* may already exist */ }
+    }
     const defaultDbHost = isContainerMode ? containerRunDir : 'localhost';
     const dbHost = parsedUrl?.host || process.env['SPECMEM_DB_HOST'] || getRcValue(rc, 'database.host', defaultDbHost);
     const dbPort = parsedUrl?.port || projectDbPort;

package/dist/db/connectionPoolGoBrrr.js

@@ -17,10 +17,10 @@ types.setTypeParser(20, (val) => {
     return Number.isSafeInteger(n) ? n : BigInt(val);
 }); // bigint - safe for values > 2^53
 const DEFAULT_POOL_SETTINGS = {
-    maxConnections: 20, // safe default - each project creates its own pool, 100 would exhaust PG max_connections
-    minConnections: 5, // keep some warm connections fr
+    maxConnections: 6, // tuned for 4-core 8GB laptop - 20 was exhausting PG under concurrent tool calls
+    minConnections: 2, // keep a couple warm, don't hog connections
     idleTimeoutMs: 30000, // 30 sec timeout on idle connections
-    connectionTimeoutMs: 30000, // 30 sec to establish connection
+    connectionTimeoutMs: 10000, // 10 sec to establish connection - fail fast under load
     statementTimeoutMs: 30000, // 30 sec statement timeout
     queryTimeoutMs: 60000, // 1 min query timeout for thicc queries
     healthCheckIntervalMs: 30000, // health check every 30 sec

package/dist/index.js

@@ -1608,11 +1608,28 @@ class LocalEmbeddingProvider {
      * Runs in background to not block embedding requests
      */
     tryRestartContainer() {
-        // Container mode: brain container manages embedding server — do NOT interfere.
-        // Self-healing attempts override sandboxSocketPath to wrong path (embeddings.sock vs embed.sock)
-        // and try to start conflicting Docker containers, causing CPU/RAM waste and socket confusion.
+        // Container mode: restart the brain container instead of spawning a new process
         if (process.env.SPECMEM_CONTAINER_MODE === 'true') {
-            logger.debug('container mode active — brain manages embedding server, skipping self-heal restart');
+            const now = Date.now();
+            if (now - this.lastRestartAttempt < LocalEmbeddingProvider.RESTART_COOLDOWN_MS) {
+                logger.debug('container restart cooldown active, skipping');
+                return;
+            }
+            this.lastRestartAttempt = now;
+            try {
+                const { getContainerManager } = require('./container/containerManager.js');
+                const projectPath = process.env.SPECMEM_PROJECT_PATH || process.cwd();
+                const cm = getContainerManager(projectPath);
+                logger.info({ projectPath }, '[LocalEmbeddingProvider] Restarting brain container...');
+                cm.start().then(() => {
+                    logger.info('[LocalEmbeddingProvider] Brain container restarted');
+                    this.restartAttempts = 0;
+                }).catch(err => {
+                    logger.error({ error: err?.message }, '[LocalEmbeddingProvider] Brain container restart failed');
+                });
+            } catch (err) {
+                logger.error({ error: err?.message }, '[LocalEmbeddingProvider] Failed to get container manager');
+            }
             return;
         }
         const now = Date.now();