claude-memory-agent 3.0.2 → 3.1.0

package/dashboard.html

@@ -466,6 +466,31 @@
             top: 0; left: 0; right: 0;
             height: 3px;
         }
+        .agent-badges {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 6px;
+            margin-bottom: 12px;
+        }
+        .agent-badge {
+            padding: 3px 10px;
+            border-radius: 12px;
+            font-size: 11px;
+            font-weight: 600;
+            letter-spacing: 0.3px;
+        }
+        .agent-badge.scope-global {
+            background: rgba(88, 166, 255, 0.15);
+            color: #58a6ff;
+        }
+        .agent-badge.scope-project {
+            background: rgba(63, 185, 80, 0.15);
+            color: #3fb950;
+        }
+        .agent-badge.category-badge {
+            background: var(--bg-tertiary);
+            color: var(--text-secondary);
+        }
         /* Config Cards */
         .config-card {
             background: var(--bg-card);
@@ -2205,6 +2230,10 @@
 
         <!-- Agents Tab -->
         <div class="tab-content active" id="agents-tab">
+            <div style="background: rgba(88,166,255,0.08); border: 1px solid rgba(88,166,255,0.2); border-radius: 12px; padding: 12px 20px; margin-bottom: 20px; display: flex; align-items: center; gap: 12px; font-size: 13px; color: var(--text-secondary);">
+                <i class="fas fa-info-circle" style="color: #58a6ff; font-size: 16px;"></i>
+                <span>Agents discovered from <code style="background: var(--bg-tertiary); padding: 2px 6px; border-radius: 4px;">~/.claude/agents/</code>. Toggle moves files between <code style="background: var(--bg-tertiary); padding: 2px 6px; border-radius: 4px;">agents/</code> and <code style="background: var(--bg-tertiary); padding: 2px 6px; border-radius: 4px;">agents/_disabled/</code>. Global agents are available across all projects.</span>
+            </div>
             <div class="section-header">
                 <div class="search-bar">
                     <i class="fas fa-search"></i>
@@ -3056,8 +3085,9 @@
 
         async function loadAgentData() {
             try {
+                const agentParams = currentProject ? `?project_path=${encodeURIComponent(currentProject)}` : '';
                 const [agentsRes, mcpsRes, hooksRes] = await Promise.all([
-                    fetch(`${API_URL}/api/agents`),
+                    fetch(`${API_URL}/api/agents${agentParams}`),
                     fetch(`${API_URL}/api/mcps`),
                     fetch(`${API_URL}/api/hooks`)
                 ]);
@@ -3071,12 +3101,14 @@
                 document.getElementById('agentsTabCount').textContent = allAgents.length;
                 document.getElementById('mcpsTabCount').textContent = allMcps.length;
                 document.getElementById('hooksTabCount').textContent = allHooks.length;
+                // Update agent stats from discovery
+                const enabledCount = allAgents.filter(a => a.enabled).length;
+                document.getElementById('enabledAgentsCount').textContent = enabledCount;
+                document.getElementById('agentsTotalCount').textContent = `/ ${allAgents.length} total`;
                 renderCategoryFilter();
-                if (projectConfig) {
-                    renderAgents();
-                    renderMcps();
-                    renderHooks();
-                }
+                renderAgents();
+                renderMcps();
+                renderHooks();
             } catch (e) {
                 console.error('Error loading agent data:', e);
             }
@@ -3107,21 +3139,26 @@
         // Rendering
         function renderCategoryFilter() {
             const container = document.getElementById('categoryFilter');
-            container.innerHTML = `<div class="category-chip active" data-category="all" onclick="filterByCategory('all')"><i class="fas fa-th"></i> All</div>`;
+            const allCount = allAgents.length;
+            container.innerHTML = `<div class="category-chip active" data-category="all" onclick="filterByCategory('all')"><i class="fas fa-th"></i> All (${allCount})</div>`;
+            // Count agents per category
+            const catCounts = {};
+            allAgents.forEach(a => { catCounts[a.category] = (catCounts[a.category] || 0) + 1; });
             Object.entries(categories).forEach(([key, cat]) => {
+                const count = catCounts[key] || 0;
                 const chip = document.createElement('div');
                 chip.className = 'category-chip';
                 chip.dataset.category = key;
-                chip.style.setProperty('--chip-color', cat.color);
+                chip.style.setProperty('--chip-color', cat.color || '#8b949e');
                 chip.onclick = () => filterByCategory(key);
-                chip.innerHTML = `<i class="fas fa-${getIconForCategory(cat.icon)}"></i> ${cat.name}`;
+                chip.innerHTML = `<i class="fas fa-${getIconForCategory(cat.icon)}"></i> ${cat.name} (${count})`;
                 container.appendChild(chip);
             });
         }
 
         function getIconForCategory(icon) {
-            const iconMap = { 'code': 'code', 'shield-check': 'shield-alt', 'palette': 'palette', 'lightbulb': 'lightbulb', 'megaphone': 'bullhorn', 'settings': 'cog', 'chart-bar': 'chart-bar', 'cube': 'cube', 'search': 'search' };
-            return iconMap[icon] || 'circle';
+            const iconMap = { 'code': 'code', 'shield-check': 'shield-alt', 'palette': 'palette', 'lightbulb': 'lightbulb', 'megaphone': 'bullhorn', 'settings': 'cog', 'chart-bar': 'chart-bar', 'cube': 'cube', 'search': 'search', 'tasks': 'tasks', 'star': 'star', 'headset': 'headset', 'vial': 'vial', 'bullhorn': 'bullhorn', 'circle': 'circle' };
+            return iconMap[icon] || icon || 'circle';
         }
 
         function renderAgents() {
@@ -3129,25 +3166,31 @@
             const searchTerm = document.getElementById('agentSearch').value.toLowerCase();
             let filteredAgents = allAgents;
             if (activeCategory !== 'all') filteredAgents = filteredAgents.filter(a => a.category === activeCategory);
-            if (searchTerm) filteredAgents = filteredAgents.filter(a => a.name.toLowerCase().includes(searchTerm) || a.description.toLowerCase().includes(searchTerm) || a.tags.some(t => t.includes(searchTerm)));
+            if (searchTerm) filteredAgents = filteredAgents.filter(a => a.name.toLowerCase().includes(searchTerm) || (a.description || '').toLowerCase().includes(searchTerm) || a.category.includes(searchTerm));
             if (!filteredAgents.length) {
-                grid.innerHTML = '<div style="grid-column: 1/-1; text-align: center; padding: 60px; color: var(--text-secondary);">No agents found</div>';
+                grid.innerHTML = '<div style="grid-column: 1/-1; text-align: center; padding: 60px; color: var(--text-secondary);"><i class="fas fa-robot" style="font-size: 48px; margin-bottom: 16px; display: block; opacity: 0.3;"></i>No agents found</div>';
                 return;
             }
             grid.innerHTML = filteredAgents.map(agent => {
-                const config = projectConfig?.agents?.[agent.id] || { enabled: agent.default_enabled };
-                const category = categories[agent.category] || {};
-                const isEnabled = config.enabled;
+                const isEnabled = agent.enabled;
+                const catMeta = categories[agent.category] || {};
+                const catColor = catMeta.color || agent.color || '#8b949e';
+                const scopeClass = agent.scope === 'global' ? 'scope-global' : 'scope-project';
+                const scopeLabel = agent.scope === 'global' ? 'Global' : 'Project';
+                const catLabel = (catMeta.name || agent.category || '').replace(/-/g, ' ');
                 return `
                     <div class="agent-card ${isEnabled ? '' : 'disabled'}">
-                        <div class="agent-category-label" style="background: ${category.color || '#58a6ff'}"></div>
+                        <div class="agent-category-label" style="background: ${catColor}"></div>
                         <div class="agent-card-header">
-                            <div class="agent-icon" style="background: ${category.color}20; color: ${category.color}"><i class="fas fa-${getIconForCategory(category.icon)}"></i></div>
+                            <div class="agent-icon" style="background: ${catColor}20; color: ${catColor}"><i class="fas fa-${getIconForCategory(catMeta.icon)}"></i></div>
                             <div class="agent-toggle ${isEnabled ? 'active' : ''}" onclick="toggleAgent('${agent.id}', ${!isEnabled})"></div>
                         </div>
                         <div class="agent-name">${agent.name}</div>
-                        <div class="agent-description">${agent.description}</div>
-                        <div class="agent-tags">${agent.tags.slice(0, 4).map(tag => `<span class="agent-tag">${tag}</span>`).join('')}</div>
+                        <div class="agent-description">${agent.description || 'No description'}</div>
+                        <div class="agent-badges">
+                            <span class="agent-badge ${scopeClass}">${scopeLabel}</span>
+                            <span class="agent-badge category-badge">${catLabel}</span>
+                        </div>
                     </div>
                 `;
             }).join('');
@@ -3197,18 +3240,18 @@
 
         // Toggle actions
         async function toggleAgent(agentId, enabled) {
-            if (!currentProject) return;
             try {
-                const response = await fetch(`${API_URL}/api/project/${encodeURIComponent(currentProject)}/agent/${agentId}`, {
+                const response = await fetch(`${API_URL}/api/agents/${agentId}/toggle`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ enabled })
+                    body: JSON.stringify({ enabled, project_path: currentProject || undefined })
                 });
                 const result = await response.json();
                 if (result.success) {
-                    await loadProjectConfig();
-                    renderAgents();
+                    await loadAgentData();
                     showToast(`${agentId} ${enabled ? 'enabled' : 'disabled'}`, 'success');
+                } else {
+                    showToast(result.error || 'Failed to toggle agent', 'error');
                 }
             } catch (e) {
                 showToast('Failed to update agent', 'error');
@@ -3254,21 +3297,28 @@
         }
 
         async function enableAllAgents(enabled) {
-            if (!currentProject) return;
-            const updates = {};
-            allAgents.forEach(agent => { updates[agent.id] = enabled; });
+            // Filter to only agents that need toggling
+            const toToggle = allAgents.filter(a => a.enabled !== enabled);
+            if (!toToggle.length) {
+                showToast(`All agents already ${enabled ? 'enabled' : 'disabled'}`, 'info');
+                return;
+            }
             try {
-                const response = await fetch(`${API_URL}/api/project/${encodeURIComponent(currentProject)}/agents/bulk`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ updates })
-                });
-                const result = await response.json();
-                if (result.success) {
-                    await loadProjectConfig();
-                    renderAgents();
-                    showToast(`All agents ${enabled ? 'enabled' : 'disabled'}`, 'success');
+                let succeeded = 0;
+                // Toggle in batches of 5 for reasonable concurrency
+                for (let i = 0; i < toToggle.length; i += 5) {
+                    const batch = toToggle.slice(i, i + 5);
+                    const results = await Promise.all(batch.map(agent =>
+                        fetch(`${API_URL}/api/agents/${agent.id}/toggle`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ enabled, project_path: currentProject || undefined })
+                        }).then(r => r.json())
+                    ));
+                    succeeded += results.filter(r => r.success).length;
                 }
+                await loadAgentData();
+                showToast(`${succeeded} agents ${enabled ? 'enabled' : 'disabled'}`, 'success');
             } catch (e) {
                 showToast('Failed to update agents', 'error');
             }

package/hooks/auto-detect-response.py

@@ -261,12 +261,9 @@ def main():
     if not response_text or len(response_text) < 50:
         sys.exit(0)
 
-    # Load session data (includes current_request_id for causal chain)
-    session_data = load_session_data()
-    if not session_data:
-        sys.exit(0)
-
-    session_id = session_data.get("session_id")
+    # Load session data, prefer session_id from stdin
+    session_data = load_session_data() or {}
+    session_id = hook_input.get("session_id") or session_data.get("session_id")
     if not session_id:
         sys.exit(0)
 

package/hooks/detect-correction.py

@@ -110,8 +110,8 @@ def main():
     except (json.JSONDecodeError, ValueError, EOFError):
         sys.exit(0)
 
-    # Get user message
-    user_message = hook_input.get("user_prompt", "")
+    # Get user message (Claude Code sends "prompt", legacy uses "user_prompt")
+    user_message = hook_input.get("prompt", "") or hook_input.get("user_prompt", "")
     if not user_message:
         session_messages = hook_input.get("session_messages", [])
         if session_messages:
@@ -128,14 +128,15 @@ def main():
     if not is_correction:
         sys.exit(0)
 
-    # Load session data (includes current_request_id for causal chain)
-    session_data = load_session_data()
-    if not session_data:
+    # Load session data, prefer session_id from stdin
+    session_data = load_session_data() or {}
+    stdin_session_id = hook_input.get("session_id")
+    if stdin_session_id and session_data.get("session_id") != stdin_session_id:
+        session_data["session_id"] = stdin_session_id
+    if not session_data.get("session_id"):
         sys.exit(0)
 
     session_id = session_data.get("session_id")
-    if not session_id:
-        sys.exit(0)
 
     # Get the current request ID for causal chain linking
     root_event_id = session_data.get("current_request_id")

package/hooks/grounding-hook.py

@@ -403,8 +403,24 @@ def check_and_trigger_flush(session_id: str, project_path: str):
 
 def main():
     """Main entry point for the hook."""
-    project_path = get_project_path()
-    session_id = get_session_id()
+    # Read hook input from stdin (Claude Code sends session_id, cwd, prompt)
+    hook_input = {}
+    try:
+        hook_input = json.load(sys.stdin)
+    except Exception:
+        pass
+
+    project_path = hook_input.get("cwd") or get_project_path()
+
+    # Get session_id: stdin JSON > env var > .claude_session file
+    session_id = hook_input.get("session_id") or get_session_id()
+
+    # Ensure .claude_session file exists for sibling hooks
+    if session_id:
+        session_data = load_session_data() or {}
+        if session_data.get("session_id") != session_id:
+            session_data["session_id"] = session_id
+            save_session_data(session_data)
 
     # If no session, try to init one
     if not session_id:
@@ -475,7 +491,7 @@ def main():
     curator_status = None
 
     # Only fetch curator context if there's user input to contextualize
-    user_input = os.getenv("CLAUDE_USER_INPUT", "")
+    user_input = hook_input.get("prompt", "") or hook_input.get("user_prompt", "") or os.getenv("CLAUDE_USER_INPUT", "")
     if user_input and len(user_input) > 10:
         curator_summary = call_memory_agent("curator_get_summary", {
             "query": user_input[:500],  # Limit query length

package/hooks/log-tool-use.py

@@ -150,12 +150,9 @@ def main():
     if tool_name not in TRACKABLE_TOOLS:
         sys.exit(0)
 
-    # Load session data (includes current_request_id for causal chain)
-    session_data = load_session_data()
-    if not session_data:
-        sys.exit(0)
-
-    session_id = session_data.get("session_id")
+    # Load session data, prefer session_id from stdin
+    session_data = load_session_data() or {}
+    session_id = hook_input.get("session_id") or session_data.get("session_id")
     if not session_id:
         sys.exit(0)
 

package/hooks/log-user-request.py

@@ -143,7 +143,8 @@ def main():
         sys.exit(0)
 
     # Get user message from hook input
-    user_message = hook_input.get("user_prompt", "")
+    # Claude Code sends "prompt", legacy format uses "user_prompt"
+    user_message = hook_input.get("prompt", "") or hook_input.get("user_prompt", "")
     if not user_message:
         # Try alternative format
         session_messages = hook_input.get("session_messages", [])
@@ -155,15 +156,22 @@ def main():
     if not user_message:
         sys.exit(0)
 
-    # Load session data
-    session_data = load_session_data()
-    if not session_data:
-        sys.exit(0)
+    # Get session_id: stdin JSON > env var > .claude_session file
+    session_id = hook_input.get("session_id") or os.getenv("CLAUDE_SESSION_ID")
+    session_data = load_session_data() or {}
+
+    if not session_id:
+        session_id = session_data.get("session_id")
 
-    session_id = session_data.get("session_id")
     if not session_id:
         sys.exit(0)
 
+    # Ensure .claude_session file exists for sibling hooks
+    if not session_data or session_data.get("session_id") != session_id:
+        session_data = session_data or {}
+        session_data["session_id"] = session_id
+        save_session_data(session_data)
+
     # Truncate long messages
     summary = user_message[:200]
     if len(user_message) > 200:

package/hooks/pre-tool-decision.py

@@ -161,12 +161,9 @@ def main():
     if tool_name not in DECISION_WORTHY_TOOLS:
         sys.exit(0)
 
-    # Load session data
-    session_data = load_session_data()
-    if not session_data:
-        sys.exit(0)
-
-    session_id = session_data.get("session_id")
+    # Load session data, prefer session_id from stdin
+    session_data = load_session_data() or {}
+    session_id = hook_input.get("session_id") or session_data.get("session_id")
     if not session_id:
         sys.exit(0)
 

package/hooks/session_end_hook.py

@@ -74,6 +74,15 @@ def main():
                 except ImportError:
                     pass
 
+        # ---------------------------------------------------------------
+        # Step 1.7: Trigger soul integration (merge fragments → soul_state)
+        # ---------------------------------------------------------------
+        if session_id and project_path:
+            try:
+                _trigger_soul_integration(session_id, project_path, timeout=5.0)
+            except Exception as e:
+                print(f"[SessionEnd] Soul integration failed (non-fatal): {e}", file=sys.stderr)
+
         # ---------------------------------------------------------------
         # Step 1.5: Deregister from cross-session awareness
         # ---------------------------------------------------------------
@@ -180,5 +189,33 @@ def _trigger_session_wrapup(session_id: str, project_path: str, timeout: float =
         print(f"[SessionEnd] Flush API call failed: {e}", file=sys.stderr)
 
 
+def _trigger_soul_integration(session_id: str, project_path: str, timeout: float = 5.0):
+    """Trigger soul integration — merges session fragments into persistent soul_state."""
+    import urllib.request
+    import urllib.error
+
+    memory_agent_url = os.getenv("MEMORY_AGENT_URL", "http://localhost:8102")
+
+    payload = json.dumps({
+        "session_id": session_id,
+        "project_path": project_path,
+    }).encode("utf-8")
+
+    try:
+        req = urllib.request.Request(
+            f"{memory_agent_url}/api/soul/integrate",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST"
+        )
+        with urllib.request.urlopen(req, timeout=min(timeout, 5.0)) as resp:
+            if resp.status == 200:
+                result = json.loads(resp.read().decode("utf-8"))
+                integrated = result.get("integrated", 0)
+                print(f"[SessionEnd] Soul integration complete: {integrated} fragments integrated.", file=sys.stderr)
+    except (urllib.error.URLError, urllib.error.HTTPError, OSError, TimeoutError) as e:
+        print(f"[SessionEnd] Soul integration API call failed: {e}", file=sys.stderr)
+
+
 if __name__ == "__main__":
     main()

package/hooks/session_start.py

@@ -86,6 +86,16 @@ async def load_session_context(project_path: str) -> str:
     """Load all relevant context for a session start."""
     context_parts = []
 
+    # ============================================================
+    # SOUL LAYER: Load soul brief (personality + learning context)
+    # ============================================================
+    soul_brief = await call_rest_api("GET", "/api/soul/brief", params={
+        "project_path": project_path,
+    })
+
+    if soul_brief and soul_brief.get("success") and soul_brief.get("brief"):
+        context_parts.append(soul_brief["brief"])
+
     # ============================================================
     # CROSS-SESSION AWARENESS: Register this session + catch-up
     # ============================================================

package/hooks/stop_hook.py

@@ -305,6 +305,122 @@ def _store_memory(extraction: Dict[str, Any], project_path: Optional[str] = None
         return False
 
 
+# ---------------------------------------------------------------------------
+# Soul fragment capture (lightweight regex → HTTP POST)
+# ---------------------------------------------------------------------------
+
+SOUL_PATTERNS = {
+    "decision_made": [
+        re.compile(
+            r"(?:let's|we'll|going to|chose to|decided to)\s+(?:use|go with|implement|try)\s+(.+)",
+            re.IGNORECASE,
+        ),
+        re.compile(
+            r"(?:using|choosing|picked)\s+(\S+)\s+(?:because|since|for)",
+            re.IGNORECASE,
+        ),
+    ],
+    "preference_expressed": [
+        re.compile(
+            r"(?:I prefer|you should always|always use|never use|don't use|I like to)\s+(.+)",
+            re.IGNORECASE,
+        ),
+        re.compile(
+            r"(?:remember to|make sure to|don't forget to)\s+(.+)",
+            re.IGNORECASE,
+        ),
+    ],
+    "error_resolved": [
+        re.compile(
+            r"(?:fixed|resolved|solved|the issue was|root cause)\s*:?\s*(.+)",
+            re.IGNORECASE,
+        ),
+        re.compile(
+            r"(?:the (?:fix|solution) (?:was|is))\s+(.+)",
+            re.IGNORECASE,
+        ),
+    ],
+    "pattern_used": [
+        re.compile(
+            r"(?:same (?:approach|pattern|method) as)\s+(.+)",
+            re.IGNORECASE,
+        ),
+        re.compile(
+            r"(?:like we did (?:for|in|with))\s+(.+)",
+            re.IGNORECASE,
+        ),
+    ],
+    "correction_received": [
+        re.compile(
+            r"(?:no,?\s+(?:actually|that's wrong|not like that)|(?:don't|stop)\s+(?:do|doing)\s+that)\s*[,:]?\s*(.+)",
+            re.IGNORECASE,
+        ),
+    ],
+}
+
+
+def _capture_soul_fragments(
+    text: str, session_id: str, project_path: str
+):
+    """Extract and POST soul fragments from response text.
+
+    Runs regex extraction, then fires HTTP POST for each fragment.
+    Budget: < 200ms total. Non-blocking — failures are silent.
+    """
+    import urllib.request
+    import urllib.error
+
+    fragments = []
+    seen = set()
+
+    for fragment_type, patterns in SOUL_PATTERNS.items():
+        for pattern in patterns:
+            for match in pattern.finditer(text):
+                captured = match.group(1).strip() if match.lastindex else match.group(0).strip()
+                if len(captured) < 10 or len(captured) > 300:
+                    continue
+                key = captured[:50].lower()
+                if key in seen:
+                    continue
+                seen.add(key)
+                fragments.append({
+                    "fragment_type": fragment_type,
+                    "content": captured[:300],
+                })
+
+    if not fragments:
+        return
+
+    # POST each fragment (fire-and-forget, tight timeout)
+    captured_count = 0
+    for frag in fragments[:5]:  # Cap at 5 fragments per response
+        try:
+            payload = json.dumps({
+                "session_id": session_id,
+                "project_path": project_path,
+                "fragment_type": frag["fragment_type"],
+                "content": frag["content"],
+            }).encode("utf-8")
+
+            req = urllib.request.Request(
+                f"{MEMORY_AGENT_URL}/api/soul/capture",
+                data=payload,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=0.5) as resp:
+                if resp.status == 200:
+                    captured_count += 1
+        except (urllib.error.URLError, urllib.error.HTTPError, OSError, TimeoutError):
+            pass  # Silent failure — don't block the hook
+
+    if captured_count > 0:
+        print(
+            f"[Stop] Soul fragments captured: {captured_count}/{len(fragments)}",
+            file=sys.stderr,
+        )
+
+
 # ---------------------------------------------------------------------------
 # Main
 # ---------------------------------------------------------------------------
@@ -353,6 +469,13 @@ def main():
         if stored_hashes:
             _save_cursor_hashes(session_id, stored_hashes)
 
+        # --- Soul fragment capture (lightweight, adds ~100ms) ---
+        elapsed = time.time() - start
+        if elapsed < TOTAL_TIME_BUDGET - 0.2:
+            _capture_soul_fragments(
+                response_text, session_id, project_path
+            )
+
         elapsed_total = round(time.time() - start, 3)
         print(
             f"[Stop] session={session_id} "