specmem-hardwicksoftware 3.7.42 → 3.7.43

package/claude-hooks/is-agent.cjs

@@ -24,10 +24,21 @@ function isAgent() {
   if (process.env.CLAUDE_SUBAGENT === '1') return true;
   if (process.env.CLAUDE_AGENT_ID) return true;
 
+  // CLAUDE_CODE_ENTRYPOINT=task is set by Agent tool when spawning subagents
+  if (process.env.CLAUDE_CODE_ENTRYPOINT === 'task') return true;
+
   // Check if this is a team member screen session (has specmem-tm- prefix)
-  // Regular  screens are claude-<project>, not specmem-tm-
+  // Regular Claude screens are claude-<project>, not specmem-tm-
   if (process.env.STY && process.env.STY.includes('specmem-tm-')) return true;
 
+  // Debug: log env vars for troubleshooting
+  const relevantEnvVars = Object.keys(process.env)
+    .filter(k => k.includes('AGENT') || k.includes('SUBAGENT') || k.includes('TASK') || k.includes('ENTRYPOINT'))
+    .reduce((acc, k) => ({ ...acc, [k]: process.env[k] }), {});
+  if (Object.keys(relevantEnvVars).length > 0) {
+    console.error('[is-agent] Relevant env vars found:', relevantEnvVars);
+  }
+
   // Check working directory for agent-specific paths
   try {
     const cwd = process.cwd();
@@ -37,7 +48,7 @@ function isAgent() {
     }
   } catch (e) {}
 
-  // Default: NOT an agent (main  session gets unrestricted access)
+  // Default: NOT an agent (main session gets unrestricted access)
   return false;
 }
 
@@ -46,7 +57,8 @@ function isAgent() {
  */
 function isSubagent() {
   return process.env.CLAUDE_SUBAGENT === '1' ||
-         process.env.CLAUDE_AGENT_ID !== undefined;
+         process.env.CLAUDE_AGENT_ID !== undefined ||
+         process.env.CLAUDE_CODE_ENTRYPOINT === 'task';
 }
 
 /**
@@ -54,6 +66,7 @@ function isSubagent() {
  */
 function isTeamMember() {
   return process.env.SPECMEM_TEAM_MEMBER_ID !== undefined ||
+         process.env.CLAUDE_CODE_ENTRYPOINT === 'task' ||
          (process.env.STY && process.env.STY.includes('specmem-tm-'));
 }
 

package/claude-hooks/team-comms-enforcer.cjs

@@ -76,10 +76,11 @@ try {
 // ============================================================================
 // CONFIGURATION
 // ============================================================================
-const MAX_SEARCHES_BEFORE_BLOCK = 2;  // Every other search must use find_code_pointers/find_memory
-const TEAM_COMMS_CHECK_INTERVAL = 3;  // MUST send_team_message every 3 tool usages
-const BROADCAST_CHECK_INTERVAL = 5;   // MUST read_team_messages w/ include_broadcasts every 5 tool usages
-const HELP_CHECK_INTERVAL = 8;        // Check help requests every 8 tool usages
+const MAX_SEARCHES_BEFORE_BLOCK = 1;  // STRICT: Every 1 Grep/Glob/Read must use find_code_pointers/find_memory
+const TEAM_COMMS_CHECK_INTERVAL = 3;  // MUST send_team_message every 3 Grep/Glob/Read (not every tool)
+const BROADCAST_CHECK_INTERVAL = 5;   // MUST read_team_messages w/ include_broadcasts every 5 Grep/Glob/Read
+const HELP_CHECK_INTERVAL = 8;        // Check help requests every 8 Grep/Glob/Read
+const MEMORY_USAGE_INTERVAL = 3;     // MUST use memory tools every 3 Grep/Glob/Read
 
 // Tools that count as "announcing"
 const ANNOUNCE_TOOLS = [
@@ -115,8 +116,8 @@ const HELP_CHECK_TOOLS = [
 ];
 
 // Basic search tools (limited before requiring memory tools)
-// NOTE: Read is NOT included — agents abuse Read to reset search counters
-const BASIC_SEARCH_TOOLS = ['Grep', 'Glob'];
+// NOTE: Read IS included now - agents were abusing it to bypass limits
+const BASIC_SEARCH_TOOLS = ['Grep', 'Glob', 'Read'];
 
 // READ + SEARCH combined — forces team msg every 3 reads OR searches
 const READ_SEARCH_TOOLS = ['Read', 'Grep', 'Glob'];
@@ -184,6 +185,7 @@ function getAgentState(tracking, sessionId) {
       commsToolCount: 0,           // Tool calls since last team comms check (every 4)
       broadcastToolCount: 0,       // Tool calls since last broadcast check (every 5)
       helpToolUsageCount: 0,       // Tool calls since last help check (every 8)
+      memoryToolCount: 0,          // Tool calls since last memory tool usage (every 3)
       lastCommsCheck: Date.now(),
       lastBroadcastCheck: Date.now(),
       lastHelpCheck: Date.now(),
@@ -258,6 +260,7 @@ function isSpecmemEnabled() {
 function blockResponse(tool, reason) {
   // Each denial specifies the EXACT tool to call. Framed as team collaboration,
   // not enforcement. "team member" language, never "agent".
+  console.error(`[TEAM COMMS] BLOCKING: ${tool} - ${reason}`);
   const msg = `[TEAM COLLABORATION - call ${tool} then retry] ${reason}`;
   return JSON.stringify({
     hookSpecificOutput: {
@@ -298,19 +301,24 @@ process.stdin.on('end', () => {
     const toolName = data.tool_name;
     const sessionId = data.session_id || 'unknown';
 
+    // DEBUG: Log detection status
+    const runningAsAgent = isRunningAsAgent();
+    const isSpecmem = isSpecmemProject();
+    console.error(`[TEAM COMMS] Tool: ${toolName}, RunningAsAgent: ${runningAsAgent}, IsSpecmemProject: ${isSpecmem}`);
+
     // ========================================================================
     // AGENT DETECTION - ONLY ENFORCE ON AGENT SESSIONS
     // Uses env vars (CLAUDE_SUBAGENT, CLAUDE_AGENT_ID, etc.) + subagent tracking
     // Main Claude window is NEVER blocked, only subagents/team members
     // ========================================================================
-    if (!isRunningAsAgent()) {
+    if (!runningAsAgent) {
       // Not an agent - pass through immediately
       console.log(JSON.stringify({ continue: true }));
       return;
     }
 
     // Verify this is a specmem-enabled project
-    if (!isSpecmemProject()) {
+    if (!isSpecmem) {
       console.log(JSON.stringify({ continue: true }));
       return;
     }
@@ -386,6 +394,7 @@ process.stdin.on('end', () => {
     if (MEMORY_TOOLS.includes(toolName)) {
       state.usedMemoryTools = true;
       state.searchCount = 0;  // Reset search counter — allows next 2 searches
+      state.memoryToolCount = 0;  // Reset memory tool counter - they just used one!
       // usedMemoryTools resets to false after 2 more searches (see BASIC_SEARCH_TOOLS block)
     }
     // Track Read/Search count for team comms cadence
@@ -430,9 +439,25 @@ process.stdin.on('end', () => {
     state.commsToolCount = (state.commsToolCount || 0) + 1;
     state.broadcastToolCount = (state.broadcastToolCount || 0) + 1;
     state.helpToolUsageCount = (state.helpToolUsageCount || 0) + 1;
+    // Count all tools for memory usage enforcement
+    state.memoryToolCount = (state.memoryToolCount || 0) + 1;
+
+    // ========================================================================
+    // HARD BLOCK: Must use memory tools every 3 tool usages
+    // find_code_pointers, find_memory, drill_down satisfy this
+    // ========================================================================
+    if (state.memoryToolCount >= MEMORY_USAGE_INTERVAL && !MEMORY_TOOLS.includes(toolName)) {
+      state.blockedCount++;
+      saveTracking(tracking);
+      console.log(blockResponse(
+        'mcp__specmem__find_code_pointers',
+        `Use semantic search to find context! Call: find_code_pointers({query:"what you need"}) or find_memory({query:"topic from conversation"})`
+      ));
+      return;
+    }
 
     // ========================================================================
-    // HARD BLOCK: Must send team message every 3 tool usages
+    // HARD BLOCK: Must send team message every 4 tool usages
     // send_team_message() or broadcast_to_team() satisfies this
     // ========================================================================
     if (state.commsToolCount >= TEAM_COMMS_CHECK_INTERVAL && !ANNOUNCE_TOOLS.includes(toolName)) {

package/dist/mcp/embeddingServerManager.js

@@ -824,27 +824,50 @@ export class EmbeddingServerManager extends EventEmitter {
     }
     /**
      * Release the file-based start lock
+     * FIX: Use rename-to-temp + unlink for atomic release (prevents race condition)
      */
     releaseStartLock() {
         try {
             if (existsSync(this.startLockPath)) {
                 // FIX 2.14: Verify ownership before releasing - only the lock owner should release
+                // FIX 2.15: Use atomic rename-then-unlink to prevent race conditions
+                let isOwner = false;
                 try {
                     const lockContent = readFileSync(this.startLockPath, 'utf8').trim();
                     const parts = lockContent.split(':');
                     const lockPid = parseInt(parts[1], 10);
-                    if (!isNaN(lockPid) && lockPid !== process.pid) {
+                    if (!isNaN(lockPid) && lockPid === process.pid) {
+                        isOwner = true;
+                    } else if (!isNaN(lockPid) && lockPid !== process.pid) {
                         logger.warn({ lockPid, myPid: process.pid }, '[EmbeddingServerManager] Lock release by non-owner - ignoring');
                         return false;
                     }
+                    // If no valid PID in lock, consider ourselves owner to clean up
+                    isOwner = true;
                 }
                 catch (readErr) {
                     // Can't verify ownership - proceed with release (lock may be corrupt)
                     logger.debug({ error: readErr }, '[EmbeddingServerManager] Cannot read lock for ownership check, releasing anyway');
+                    isOwner = true;
+                }
+
+                if (isOwner) {
+                    // Atomic release: rename to temp path, then unlink
+                    // This prevents race where another process acquires lock between read and delete
+                    const tempPath = this.startLockPath + '.releasing.' + process.pid;
+                    try {
+                        // First, try atomic rename (will fail if lock was taken)
+                        renameSync(this.startLockPath, tempPath);
+                        // If rename succeeded, we own it - now safely unlink
+                        unlinkSync(tempPath);
+                        logger.debug('[EmbeddingServerManager] Released start lock (atomic)');
+                        return true;
+                    } catch (renameErr) {
+                        // Rename failed - another process acquired the lock
+                        logger.debug({ error: renameErr }, '[EmbeddingServerManager] Lock was taken during release, ignoring');
+                        return false;
+                    }
                 }
-                unlinkSync(this.startLockPath);
-                logger.debug('[EmbeddingServerManager] Released start lock');
-                return true;
             }
             return true; // No lock to release
         }

package/dist/mcp/tools/teamComms.js

@@ -731,10 +731,12 @@ Examples:
             storage: isDBAvailable() ? 'postgresql' : 'memory'
         });
         // Human-readable response
+        const typeIcon = { status: '🔄', question: '❓', update: '📝', broadcast: '📢', help_request: '🆘', help_response: '💡' }[type] || '💬';
+        const priIcon = { urgent: ' ‼️URGENT', high: ' ❗', normal: '', low: '' }[priority] || '';
         return {
             content: [{
                     type: 'text',
-                    text: `sent: ${type} → ${channel}\n${message.slice(0, 120)}${message.length > 120 ? '...' : ''}`
+                    text: `✅ ${typeIcon} Message sent to #${channel}${priIcon}\n   "${message.slice(0, 100)}${message.length > 100 ? '...' : ''}"`
                 }]
         };
     }
@@ -1091,28 +1093,28 @@ Returns messages sorted by newest first.`;
             help_request: '🆘',
             help_response: '💡'
         };
-        const priorityTag = { urgent: '‼️', high: '❗', normal: '', low: '' };
+        const priorityTag = { urgent: ' ‼️URGENT', high: ' ❗', normal: '', low: '' };
         const formatTimeAgo = (date) => {
             const now = Date.now();
             const then = new Date(date).getTime();
             const diffSec = Math.floor((now - then) / 1000);
-            if (diffSec < 60) return `${diffSec}s ago`;
+            if (diffSec < 60) return `${diffSec}s`;
             const diffMin = Math.floor(diffSec / 60);
-            if (diffMin < 60) return `${diffMin}m ago`;
+            if (diffMin < 60) return `${diffMin}m`;
             const diffHr = Math.floor(diffMin / 60);
-            if (diffHr < 24) return `${diffHr}h ago`;
-            return `${Math.floor(diffHr / 24)}d ago`;
+            if (diffHr < 24) return `${diffHr}h`;
+            return `${Math.floor(diffHr / 24)}d`;
         };
         const formatMessage = (m) => {
             const emoji = typeEmoji[m.type] || '💬';
-            const unread = m.is_unread ? ' ★NEW' : '';
+            const unread = m.is_unread ? ' ✨' : '';
             const pri = priorityTag[m.priority] || '';
             const time = formatTimeAgo(m.timestamp);
             const from = m.sender_name || m.sender || '?';
             // Content already compressed by verified compressor above
-            const content = m.content.slice(0, 400).replace(/\n/g, ' ');
-            const truncated = m.content.length > 400 ? '…' : '';
-            return `  ${pri}${emoji}${unread} ${from} (${time}): ${content}${truncated}`;
+            const content = m.content.slice(0, 300).replace(/\n/g, ' ');
+            const truncated = m.content.length > 300 ? '…' : '';
+            return `   ${emoji}${unread}${pri} ${from} [${time}]: ${content}${truncated}`;
         };
         // Group messages by channel for sortable output
         const byChannel = {};
@@ -1133,15 +1135,15 @@ Returns messages sorted by newest first.`;
             const msgs = byChannel[ch];
             const chUnread = msgs.filter(m => m.is_unread).length;
             const chLabel = chUnread > 0 ? `#${ch} (${chUnread} new)` : `#${ch}`;
-            msgList += `\n── ${chLabel} ──\n`;
+            msgList += `\n┌─ ${chLabel} ─\n`;
             msgList += msgs.map(m => formatMessage(m)).join('\n');
             msgList += '\n';
         }
-        const header = `[SPECMEM-TEAM-MESSAGES] ${messages.length} msgs • ${unreadCount} unread`;
-        const footer = `[/SPECMEM-TEAM-MESSAGES]`;
+        const header = `📬 Team Messages (${messages.length} total, ${unreadCount} unread)`;
+        const footer = '─────────────────────────';
         const output = messages.length > 0
-            ? `${header}${msgList}${footer}`
-            : `${header}\n  No messages\n${footer}`;
+            ? `${header}${msgList}\n${footer}`
+            : `${header}\n\n   No messages yet\n${footer}`;
         return { content: [{ type: 'text', text: output }] };
     }
 }
@@ -1260,10 +1262,11 @@ Use cross_project: true for system-wide announcements (use sparingly).`;
             storage: isDBAvailable() ? 'postgresql' : 'memory'
         });
         // Human-readable response
+        const bcastIcon = { status: '🔄', update: '📢', alert: '🚨', milestone: '🎉' }[broadcast_type] || '📣';
         return {
             content: [{
                     type: 'text',
-                    text: `[BROADCAST] ${broadcast_type} sent to team (id: ${messageId.slice(0, 8)})`
+                    text: `📣 ${bcastIcon} Broadcast sent to ALL teams\n   "${message.slice(0, 80)}${message.length > 80 ? '...' : ''}"`
                 }]
         };
     }
@@ -1374,17 +1377,17 @@ Best practice: Always claim before starting work on a task.`;
             warnings,
             storage: isDBAvailable() ? 'postgresql' : 'memory'
         });
-        // Ultra-compact return
+        });
+        // Human-readable return
+        const fileList = files && files.length > 0 ? `\n   Files: ${files.join(', ')}` : '';
+        const warningText = warnings && warnings.length > 0 ? `\n   ⚠️ ${warnings.join(' | ')}` : '';
         return {
-            success: true,
-            claimId: claimId.slice(0, 8),
-            description: stripNewlines(description).slice(0, 50),
-            files,
-            timestamp: claimedAt,
-            warnings
+            content: [{
+                type: 'text',
+                text: `✅ Task claimed: ${description.slice(0, 50)}${description.length > 50 ? '...' : ''}\n   ID: ${claimId.slice(0, 8)}${fileList}${warningText}`
+            }]
         };
     }
-}
 export class ReleaseTask {
     name = 'release_task';
     description = `Release files or entire task claims.
@@ -1537,14 +1540,16 @@ Best practice: Release files as you finish them, release entire claim when task
             memberId,
             storage: isDBAvailable() ? 'postgresql' : 'memory'
         });
-        // Ultra-compact
+        // Human-readable
+        const filesMsg = releasedFiles.length > 0 ? ` (${releasedFiles.length} files)` : '';
         const message = releasedClaims.length === 1
-            ? `Released claim ${releasedClaims[0].slice(0, 8)}`
-            : `Released ${releasedClaims.length} claims`;
+            ? `✅ Released: ${releasedClaims[0].slice(0, 8)}${filesMsg}`
+            : `✅ Released ${releasedClaims.length} claims${filesMsg}`;
         return {
-            success: true,
-            releasedClaims: releasedClaims.map(id => id.slice(0, 8)),
-            message
+            content: [{
+                type: 'text',
+                text: message
+            }]
         };
     }
 }
@@ -1737,12 +1742,12 @@ respond using the respond_to_help tool.`;
             skills_needed,
             storage: isDBAvailable() ? 'postgresql' : 'memory'
         });
-        // Ultra-compact
+        // Human-readable
         return {
-            success: true,
-            requestId: requestId.slice(0, 8),
-            timestamp: requestedAt,
-            message: 'Help request broadcasted to team'
+            content: [{
+                type: 'text',
+                text: `🆘 Help request sent to team\n   "${question.slice(0, 60)}${question.length > 60 ? '...' : ''}"`
+            }]
         };
     }
 }
@@ -1859,13 +1864,12 @@ will be notified.`;
             respondedBy,
             storage: isDBAvailable() ? 'postgresql' : 'memory'
         });
-        // Ultra-compact
+        // Human-readable
         return {
-            success: true,
-            responseId: responseId.slice(0, 8),
-            requestId: requestId.slice(0, 8),
-            timestamp: respondedAt,
-            message: `Response sent to ${requester}`
+            content: [{
+                type: 'text',
+                text: `💡 Response sent to @${requester}\n   "${response.slice(0, 60)}${response.length > 60 ? '...' : ''}"`
+            }]
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.7.42",
+  "version": "3.7.43",
   "type": "module",
   "description": "Your Claude Code sessions don't have to start from scratch anymore — SpecMem gives your AI real memory. It won't forget your conversations, your code, or your architecture decisions between sessions. That's the whole point. Semantic code indexing that actually works: TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C, C++, HTML and more. It doesn't just track functions — it gets classes, methods, fields, constants, enums, macros, imports, structs, the whole codebase graph. There's chat memory too, powered by pgvector embeddings. You've also got token compression, team coordination, multi-agent comms, and file watching built in. 74+ MCP tools. Runs on PostgreSQL + Docker. It's kind of a big deal. justcalljon.pro",
   "main": "dist/index.js",

package/scripts/specmem-init.cjs

@@ -9058,6 +9058,18 @@ CREATE INDEX IF NOT EXISTS idx_embedding_queue_project ON embedding_queue (proje
     const claudeDir = path.join(projectPath, '.claude');
     safeMkdir(path.join(claudeDir, 'commands'));
 
+    // Deploy HOW_TO_USE.md to project root
+    const howToUseSrc = path.join(__dirname, '..', 'HOW_TO_USE_SPECMEM_MCP.md');
+    const howToUseDest = path.join(projectPath, 'HOW_TO_USE.md');
+    if (fs.existsSync(howToUseSrc)) {
+      try {
+        fs.copyFileSync(howToUseSrc, howToUseDest);
+        initLog('[SETUP] Deployed HOW_TO_USE.md to project root');
+      } catch (e) {
+        initLog('[SETUP] Failed to deploy HOW_TO_USE.md: ' + e.message);
+      }
+    }
+
     setupUI.setSubProgress(1);
     setupUI.setSubStatus('✓ Project dirs ready');
     await qqms();