brainclaw 0.21.0 → 0.22.1

package/dist/commands/session-start.js

@@ -11,6 +11,7 @@ import { nowISO, generateId } from '../core/ids.js';
 import { appendAuditEntry } from '../core/audit.js';
 import { SessionSnapshotSchema } from '../core/schema.js';
 import { auditLocalAgentWorkspaceFiles } from '../core/agent-files.js';
+import { buildAgentInventory, loadAgentInventory, saveAgentInventory, diffInventory } from '../core/agent-inventory.js';
 function sessionsDir(cwd) {
     return resolveEntityDir('sessions', cwd ?? process.cwd(), 'read');
 }
@@ -47,6 +48,11 @@ export function runSessionStart(options = {}) {
                 console.warn('  After fixing .gitignore, untrack them with `git rm --cached <path>` as needed.');
             }
         }
+        if (snapshot.inventory_advisory) {
+            for (const line of snapshot.inventory_advisory) {
+                console.warn(`⚠ ${line}`);
+            }
+        }
     }
     catch (e) {
         console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
@@ -121,6 +127,25 @@ export function startSession(options = {}) {
     }, options.cwd);
     appendAuditEntry({ action: 'session_start', actor: actor.agent, actor_id: actor.agent_id, item_id: snapshot.session_id, item_type: 'session' }, options.cwd);
     const agentGitHygiene = auditLocalAgentWorkspaceFiles(options.cwd ?? process.cwd());
+    // Inventory reconciliation — detect new/disappeared agents on this machine
+    let inventoryAdvisory;
+    try {
+        const previousInventory = loadAgentInventory();
+        const currentInventory = buildAgentInventory();
+        const diff = diffInventory(previousInventory, currentInventory);
+        saveAgentInventory(currentInventory);
+        const lines = [];
+        if (diff.appeared.length > 0)
+            lines.push(`New agents detected: ${diff.appeared.join(', ')}`);
+        if (diff.disappeared.length > 0)
+            lines.push(`Agents no longer detected: ${diff.disappeared.join(', ')}`);
+        for (const vc of diff.version_changed) {
+            lines.push(`${vc.name} version changed: ${vc.from ?? '?'} → ${vc.to ?? '?'}`);
+        }
+        if (lines.length > 0)
+            inventoryAdvisory = lines;
+    }
+    catch { /* non-fatal — inventory scan failure should not block session start */ }
     return {
         ...snapshot,
         ...(agentGitHygiene.isGitRepo && (agentGitHygiene.missingGitignorePaths.length > 0 || agentGitHygiene.trackedPaths.length > 0)
@@ -131,6 +156,7 @@ export function startSession(options = {}) {
                 },
             }
             : {}),
+        ...(inventoryAdvisory ? { inventory_advisory: inventoryAdvisory } : {}),
     };
 }
 export function loadSessionSnapshot(sessionId, cwd) {

package/dist/core/agent-inventory.js

@@ -398,4 +398,32 @@ export function renderAgentInventorySummary(inventory) {
     lines.push(`Inventory generated: ${inventory.generated_at}`);
     return lines.join('\n');
 }
+/**
+ * Compare two agent inventories and return what changed.
+ * Only considers agents that are `installed` in either snapshot.
+ */
+export function diffInventory(previous, current) {
+    const prevMap = new Map((previous?.agents ?? []).filter(a => a.installed).map(a => [a.name, a]));
+    const currMap = new Map(current.agents.filter(a => a.installed).map(a => [a.name, a]));
+    const appeared = [];
+    const disappeared = [];
+    const version_changed = [];
+    for (const [name, entry] of currMap) {
+        if (!prevMap.has(name)) {
+            appeared.push(name);
+        }
+        else {
+            const prev = prevMap.get(name);
+            if (prev.version !== entry.version && (prev.version || entry.version)) {
+                version_changed.push({ name, from: prev.version, to: entry.version });
+            }
+        }
+    }
+    for (const name of prevMap.keys()) {
+        if (!currMap.has(name)) {
+            disappeared.push(name);
+        }
+    }
+    return { appeared, disappeared, version_changed };
+}
 //# sourceMappingURL=agent-inventory.js.map

package/dist/core/agent-registry.js

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { detectAiAgent } from './ai-agent-detection.js';
 import { loadConfig, saveConfig } from './config.js';
 import { nowISO } from './ids.js';
 import { MEMORY_DIR, resolveEntityDir } from './io.js';
@@ -205,6 +206,15 @@ export function resolveCurrentAgentIdentity(cwd, preferredDirName) {
         if (byEnvName)
             return byEnvName;
     }
+    // Auto-detect from native agent env vars (e.g. CLAUDECODE, CURSOR_TRACE_ID).
+    // Falls through to config if the detected agent is not registered.
+    const detected = detectAiAgent();
+    if (detected) {
+        const byDetected = findAgentIdentityByName(detected.name, cwd, preferredDirName);
+        if (byDetected)
+            return byDetected;
+    }
+    // Config fallback (last resort — may not reflect the actual calling agent)
     const config = loadConfig(cwd, preferredDirName);
     if (config.current_agent_id) {
         const byId = findAgentIdentityById(config.current_agent_id, cwd, preferredDirName);

package/dist/core/ai-agent-detection.js

@@ -32,13 +32,17 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
         };
     }
     // Claude Code — tested BEFORE Copilot because both can be present in VS Code.
-    // CLAUDE_CODE_VERSION is set by Claude Code itself, not by VS Code passively.
-    if (env.CLAUDE_CODE_VERSION || env.ANTHROPIC_AI_PRODUCT === 'claude-code') {
+    // CLAUDE_CODE_VERSION is set by Claude Code CLI; CLAUDECODE is set by the VS Code extension.
+    if (env.CLAUDE_CODE_VERSION || env.CLAUDECODE || env.ANTHROPIC_AI_PRODUCT === 'claude-code') {
         return {
             name: 'claude-code',
             kind: 'agent',
             trust_level: 'trusted',
-            detection_source: env.CLAUDE_CODE_VERSION ? 'CLAUDE_CODE_VERSION env var' : 'ANTHROPIC_AI_PRODUCT env var',
+            detection_source: env.CLAUDE_CODE_VERSION
+                ? 'CLAUDE_CODE_VERSION env var'
+                : env.CLAUDECODE
+                    ? 'CLAUDECODE env var'
+                    : 'ANTHROPIC_AI_PRODUCT env var',
         };
     }
     // Cursor IDE
@@ -73,7 +77,7 @@ export function detectAiAgent(env = process.env, homeDir = os.homedir()) {
     // whenever the Copilot extension is installed, even when another agent is active.
     // We only match if no higher-priority agent was detected above.
     if (env.GITHUB_COPILOT_PRODUCT ||
-        (env.GITHUB_COPILOT_TOKEN && !env.CLAUDE_CODE_VERSION && !env.CURSOR_TRACE_ID && !env.WINDSURF_SESSION_ID) ||
+        (env.GITHUB_COPILOT_TOKEN && !env.CLAUDE_CODE_VERSION && !env.CLAUDECODE && !env.CURSOR_TRACE_ID && !env.WINDSURF_SESSION_ID) ||
         (env.VSCODE_GIT_IPC_HANDLE && (env.AGENT_NAME?.toLowerCase().includes('copilot') || env.GH_COPILOT_AGENT))) {
         return {
             name: 'github-copilot',

package/dist/core/repo-analysis.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import YAML from 'yaml';
 import { MEMORY_DIR } from './io.js';
 const MULTI_PROJECT_MARKERS = [
     'pnpm-workspace.yaml',
@@ -11,6 +12,32 @@ const MULTI_PROJECT_MARKERS = [
 const MULTI_PROJECT_DIRS = ['apps', 'packages', 'services'];
 export function analyzeRepository(cwd) {
     const reasons = [];
+    // ── Signal 1: Existing brainclaw config already declares multi-project ──
+    const configPath = path.join(cwd, MEMORY_DIR, 'config.yaml');
+    if (fs.existsSync(configPath)) {
+        try {
+            const raw = YAML.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (raw) {
+                const mode = raw.project_mode;
+                const projects = raw.projects;
+                const strategy = projects?.strategy ?? 'manual';
+                const knownCount = Array.isArray(projects?.known) ? projects.known.length : 0;
+                if (mode === 'multi-project' || strategy === 'folder' || knownCount > 0) {
+                    reasons.push(`Existing brainclaw config: project_mode=${mode ?? 'auto'}, strategy=${strategy}` +
+                        (knownCount > 0 ? `, ${knownCount} known project(s)` : ''));
+                }
+            }
+        }
+        catch {
+            // Config unreadable — fall through to heuristic detection.
+        }
+    }
+    // ── Signal 2: Child brainclaw stores (subdirectories with .brainclaw/) ──
+    const scan = scanChildStoresShallow(cwd);
+    if (scan.length > 0) {
+        reasons.push(`Found ${scan.length} child brainclaw store(s): ${scan.join(', ')}`);
+    }
+    // ── Signal 3: Classic monorepo / workspace markers ──
     for (const marker of MULTI_PROJECT_MARKERS) {
         if (fs.existsSync(path.join(cwd, marker))) {
             reasons.push(`Found workspace marker: ${marker}`);
@@ -46,6 +73,33 @@ export function analyzeRepository(cwd) {
         reasons: ['No monorepo or multi-project markers detected'],
     };
 }
+/**
+ * Quick depth-1 scan for subdirectories that contain a .brainclaw/ store.
+ * Returns relative paths of child stores found.
+ */
+function scanChildStoresShallow(cwd) {
+    const childStores = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(cwd, { withFileTypes: true });
+    }
+    catch {
+        return childStores;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        if (entry.name.startsWith('.'))
+            continue;
+        const childBrainclaw = path.join(cwd, entry.name, MEMORY_DIR);
+        if (fs.existsSync(childBrainclaw)) {
+            childStores.push(entry.name);
+        }
+    }
+    return childStores;
+}
 /** Markers whose presence indicates a service/project boundary worth initialising. */
 const SERVICE_MARKERS = [
     'package.json',

package/dist/core/store-resolution.js

@@ -104,6 +104,13 @@ export function resolveContextStoreCwd(cwd = process.cwd(), target) {
     if (!absoluteTarget) {
         return cwd;
     }
+    // ── Fast path: walk from target upward to cwd looking for a child store ──
+    // This works regardless of project_mode or strategy configuration.
+    const childStore = findClosestStoreBelow(absoluteTarget, primary.cwd);
+    if (childStore) {
+        return childStore;
+    }
+    // ── Fallback: use workspace project discovery (folder mode, registry, etc.) ──
     let config;
     try {
         config = loadConfig(primary.cwd);
@@ -127,6 +134,37 @@ export function resolveContextStoreCwd(cwd = process.cwd(), target) {
     }
     return cwd;
 }
+/**
+ * Walk from `target` upward toward `ceiling` (exclusive), returning the first
+ * directory that contains a `.brainclaw/config.yaml`.  Returns undefined when
+ * no child store is found between target and ceiling.
+ *
+ * This deliberately bypasses workspace project discovery so that child stores
+ * are resolved even when the parent config is set to auto/manual mode.
+ */
+function findClosestStoreBelow(target, ceiling) {
+    const resolvedCeiling = path.resolve(ceiling);
+    // If target is a file, start from its parent directory
+    let current;
+    try {
+        current = fs.statSync(target).isDirectory() ? path.resolve(target) : path.resolve(path.dirname(target));
+    }
+    catch {
+        // Target doesn't exist on disk — try its parent as a directory
+        current = path.resolve(path.dirname(target));
+    }
+    while (current !== resolvedCeiling) {
+        const configPath = path.join(current, MEMORY_DIR, 'config.yaml');
+        if (fs.existsSync(configPath)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break; // filesystem root
+        current = parent;
+    }
+    return undefined;
+}
 /**
  * Return true if `dir` is at or below `ancestor` in the filesystem hierarchy.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "bin": {