brainclaw 0.24.0 → 0.27.0

package/dist/core/project-discovery.js

@@ -0,0 +1,236 @@
+/**
+ * Project discovery — unified workspace inventory that composes existing
+ * scan functions into a single structured profile.
+ *
+ * Boundary: discovery describes what exists in the workspace RIGHT NOW.
+ * It is NOT canonical memory (decisions, traps, plans). It is NOT
+ * machine profile (shells, SSH keys, WSL distros). It is the project-level
+ * answer to "what MCP servers, skills, hooks, instruction files, and
+ * agent integrations are available in this workspace?"
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildAgentToolingContext } from './agent-context.js';
+import { assessAgentIntegrationReadiness } from './agent-integrations.js';
+import { loadConfig } from './config.js';
+import { memoryDir } from './io.js';
+import { nowISO } from './ids.js';
+// --- Native instruction file discovery (extracted from bootstrap.ts) ---
+const NATIVE_INSTRUCTION_FILES = [
+    'AGENTS.md',
+    'CLAUDE.md',
+    'GEMINI.md',
+    '.windsurfrules',
+    '.github/copilot-instructions.md',
+];
+const NATIVE_INSTRUCTION_DIRS = [
+    '.cursor/rules',
+    '.roo/rules',
+    '.continue/rules',
+    '.clinerules',
+];
+// MCP config files that agents use
+const MCP_CONFIG_FILES = [
+    '.mcp.json',
+    'opencode.json',
+    '.cursor/mcp.json',
+    '.roo/mcp.json',
+    '.continue/config.json',
+];
+// Hook config files
+const HOOK_CONFIG_FILES = [
+    '.claude/settings.local.json',
+    '.cursor/rules/brainclaw-session.mdc',
+];
+export function buildProjectDiscovery(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    // 1. Agent tooling (AGENTS.md, skills, MCP servers)
+    const agentTooling = buildAgentToolingContext({ cwd, env });
+    // 2. Native instruction files
+    const instructionFiles = discoverFiles(cwd, NATIVE_INSTRUCTION_FILES, NATIVE_INSTRUCTION_DIRS);
+    // 3. MCP config files
+    const mcpConfigs = discoverStaticFiles(cwd, MCP_CONFIG_FILES);
+    // 4. Hook config files
+    const hookConfigs = discoverStaticFiles(cwd, HOOK_CONFIG_FILES);
+    // 5. Integration readiness
+    let integrations = [];
+    try {
+        const config = loadConfig(cwd);
+        integrations = assessAgentIntegrationReadiness(config, cwd, env);
+    }
+    catch {
+        // config may not exist yet
+    }
+    const foundInstructions = instructionFiles.filter(f => f.exists);
+    const foundMcpConfigs = mcpConfigs.filter(f => f.exists);
+    const foundHookConfigs = hookConfigs.filter(f => f.exists);
+    return {
+        discovered_at: nowISO(),
+        workspace_root: cwd,
+        agent_tooling: agentTooling,
+        instruction_files: foundInstructions,
+        mcp_configs: foundMcpConfigs,
+        hook_configs: foundHookConfigs,
+        integrations,
+        summary: {
+            total_instruction_files: foundInstructions.length,
+            total_mcp_servers: agentTooling.mcp_servers.length,
+            total_skills: agentTooling.skills.length,
+            total_mcp_configs: foundMcpConfigs.length,
+            total_hook_configs: foundHookConfigs.length,
+            integrations_ready: integrations.filter(i => i.ready).length,
+            integrations_total: integrations.length,
+        },
+    };
+}
+// --- Persistence ---
+const DISCOVERY_PROFILE_FILE = 'discovery-profile.json';
+export function saveDiscoveryProfile(profile, cwd) {
+    const dir = path.join(memoryDir(cwd), 'discovery');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const filePath = path.join(dir, DISCOVERY_PROFILE_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(profile, null, 2), 'utf-8');
+}
+export function loadDiscoveryProfile(cwd) {
+    const filePath = path.join(memoryDir(cwd), 'discovery', DISCOVERY_PROFILE_FILE);
+    if (!fs.existsSync(filePath))
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+// --- Rendering ---
+export function renderDiscoverySummary(profile) {
+    const lines = [];
+    const s = profile.summary;
+    lines.push('# Project Discovery');
+    lines.push(`Discovered at: ${profile.discovered_at}`);
+    lines.push('');
+    // Instruction files
+    if (profile.instruction_files.length > 0) {
+        lines.push(`## Instruction Files (${s.total_instruction_files})`);
+        for (const f of profile.instruction_files) {
+            const managed = f.managed_by_brainclaw ? ' (managed)' : '';
+            lines.push(`  ${f.path}${managed}`);
+        }
+        lines.push('');
+    }
+    // MCP configs
+    if (profile.mcp_configs.length > 0) {
+        lines.push(`## MCP Configs (${s.total_mcp_configs})`);
+        for (const f of profile.mcp_configs) {
+            lines.push(`  ${f.path}`);
+        }
+        lines.push('');
+    }
+    // MCP servers (from agent tooling)
+    if (s.total_mcp_servers > 0) {
+        lines.push(`## MCP Servers (${s.total_mcp_servers})`);
+        for (const server of profile.agent_tooling.mcp_servers) {
+            lines.push(`  ${server.name} (${server.transport}, ${server.availability})`);
+        }
+        lines.push('');
+    }
+    // Skills
+    if (s.total_skills > 0) {
+        lines.push(`## Skills (${s.total_skills})`);
+        for (const skill of profile.agent_tooling.skills.slice(0, 10)) {
+            lines.push(`  ${skill.name}${skill.description ? `: ${skill.description}` : ''}`);
+        }
+        if (s.total_skills > 10) {
+            lines.push(`  ... and ${s.total_skills - 10} more`);
+        }
+        lines.push('');
+    }
+    // Hook configs
+    if (profile.hook_configs.length > 0) {
+        lines.push(`## Hook Configs (${s.total_hook_configs})`);
+        for (const f of profile.hook_configs) {
+            lines.push(`  ${f.path}`);
+        }
+        lines.push('');
+    }
+    // Integrations
+    if (profile.integrations.length > 0) {
+        lines.push(`## Agent Integrations (${s.integrations_ready}/${s.integrations_total} ready)`);
+        for (const integ of profile.integrations) {
+            const status = integ.ready ? '✔' : '✗';
+            const missing = integ.missing_surfaces.length > 0
+                ? ` — missing: ${integ.missing_surfaces.map(s => s.kind).join(', ')}`
+                : '';
+            lines.push(`  ${status} ${integ.agent_name}${missing}`);
+        }
+        lines.push('');
+    }
+    if (s.total_instruction_files + s.total_mcp_servers + s.total_skills === 0) {
+        lines.push('No integration surfaces detected.');
+    }
+    return lines.join('\n');
+}
+// --- Helpers ---
+function discoverStaticFiles(cwd, files) {
+    const results = [];
+    for (const relativePath of files) {
+        const fullPath = path.join(cwd, relativePath);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+            const stat = fs.statSync(fullPath);
+            results.push({
+                path: relativePath,
+                exists: true,
+                size: stat.size,
+                managed_by_brainclaw: isManagedByBrainclaw(fullPath),
+            });
+        }
+    }
+    return results;
+}
+function discoverFiles(cwd, files, dirs) {
+    const results = [];
+    for (const relativePath of files) {
+        const fullPath = path.join(cwd, relativePath);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+            results.push({
+                path: relativePath,
+                exists: true,
+                size: fs.statSync(fullPath).size,
+                managed_by_brainclaw: isManagedByBrainclaw(fullPath),
+            });
+        }
+    }
+    for (const relativeDir of dirs) {
+        const dir = path.join(cwd, relativeDir);
+        if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory())
+            continue;
+        for (const entry of fs.readdirSync(dir).sort()) {
+            if (!/\.(md|mdc)$/i.test(entry))
+                continue;
+            const relativePath = path.posix.join(relativeDir.replace(/\\/g, '/'), entry);
+            const fullPath = path.join(cwd, relativePath);
+            results.push({
+                path: relativePath,
+                exists: true,
+                size: fs.statSync(fullPath).size,
+                managed_by_brainclaw: isManagedByBrainclaw(fullPath),
+            });
+        }
+    }
+    return results;
+}
+function isManagedByBrainclaw(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8').slice(0, 200);
+        return content.includes('brainclaw') && (content.includes('Managed by brainclaw') ||
+            content.includes('BRAINCLAW_SECTION') ||
+            content.includes('brainclaw export'));
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=project-discovery.js.map

package/dist/core/registries.js

@@ -0,0 +1,120 @@
+/**
+ * Dedicated registries for project capabilities and tools.
+ *
+ * Replaces the legacy hack of storing capabilities/tools as decisions
+ * with 'capability'/'tool' tags. Items are now persisted as individual
+ * JSON files under discovery/capabilities/ and discovery/tools/.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveEntityDir } from './io.js';
+import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
+import { ProjectCapabilitySchema, ProjectToolSchema } from './schema.js';
+import { generateIdWithLabel, nowISO } from './ids.js';
+import { appendEvent } from './event-log.js';
+// --- Capabilities ---
+export function listCapabilities(cwd) {
+    const dir = resolveEntityDir('capabilities', cwd, 'read');
+    if (!dir || !fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    const items = [];
+    for (const file of files) {
+        try {
+            const result = loadVersionedJsonFile('capability', path.join(dir, file));
+            items.push(ProjectCapabilitySchema.parse(result.document));
+        }
+        catch {
+            // skip invalid
+        }
+    }
+    return items;
+}
+export function saveCapability(cap, cwd) {
+    const dir = resolveEntityDir('capabilities', cwd, 'write');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    saveVersionedJsonFile('capability', path.join(dir, `${cap.id}.json`), cap);
+}
+export function deleteCapability(id, cwd) {
+    const dir = resolveEntityDir('capabilities', cwd, 'read');
+    if (!dir)
+        return false;
+    const fp = path.join(dir, `${id}.json`);
+    if (!fs.existsSync(fp))
+        return false;
+    fs.unlinkSync(fp);
+    return true;
+}
+export function createCapability(opts, cwd) {
+    const idObj = generateIdWithLabel('cap');
+    const cap = {
+        id: idObj.id,
+        name: opts.name,
+        description: opts.description,
+        category: opts.category ?? 'general',
+        tags: opts.tags ?? [],
+        status: 'stable',
+        created_at: nowISO(),
+        author: opts.author,
+        author_id: opts.authorId,
+        model: opts.model,
+    };
+    saveCapability(cap, cwd);
+    appendEvent({ action: 'create', item_type: 'decision', item_id: cap.id, agent: opts.author, agent_id: opts.authorId, summary: `capability: ${opts.name}` }, cwd);
+    return cap;
+}
+// --- Tools ---
+export function listTools(cwd) {
+    const dir = resolveEntityDir('tools', cwd, 'read');
+    if (!dir || !fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+    const items = [];
+    for (const file of files) {
+        try {
+            const result = loadVersionedJsonFile('tool', path.join(dir, file));
+            items.push(ProjectToolSchema.parse(result.document));
+        }
+        catch {
+            // skip invalid
+        }
+    }
+    return items;
+}
+export function saveTool(tool, cwd) {
+    const dir = resolveEntityDir('tools', cwd, 'write');
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    saveVersionedJsonFile('tool', path.join(dir, `${tool.id}.json`), tool);
+}
+export function deleteTool(id, cwd) {
+    const dir = resolveEntityDir('tools', cwd, 'read');
+    if (!dir)
+        return false;
+    const fp = path.join(dir, `${id}.json`);
+    if (!fs.existsSync(fp))
+        return false;
+    fs.unlinkSync(fp);
+    return true;
+}
+export function createTool(opts, cwd) {
+    const idObj = generateIdWithLabel('tol');
+    const tool = {
+        id: idObj.id,
+        name: opts.name,
+        description: opts.description,
+        type: (opts.type ?? 'utility'),
+        implementation: opts.implementation ?? '',
+        tags: opts.tags ?? [],
+        status: 'stable',
+        created_at: nowISO(),
+        author: opts.author,
+        author_id: opts.authorId,
+        model: opts.model,
+    };
+    saveTool(tool, cwd);
+    appendEvent({ action: 'create', item_type: 'decision', item_id: tool.id, agent: opts.author, agent_id: opts.authorId, summary: `tool: ${opts.name}` }, cwd);
+    return tool;
+}
+//# sourceMappingURL=registries.js.map

package/dist/core/schema.js

@@ -42,6 +42,7 @@ export const PrioritySchema = z.enum(['low', 'medium', 'high']);
 export const MemoryVisibilitySchema = z.enum(['shared', 'machine', 'private']);
 export const HandoffStatusSchema = z.enum(['open', 'accepted', 'closed']);
 export const DecisionOutcomeSchema = z.enum(['approved', 'rejected', 'deferred', 'pending']);
+export const MemoryScopeSchema = z.enum(['project', 'machine', 'user']).default('project');
 export const ConstraintSchema = z.object({
     schema_version: z.number().int().positive().optional(),
     id: z.string(),
@@ -56,6 +57,7 @@ export const ConstraintSchema = z.object({
     session_id: z.string().optional(),
     status: ConstraintStatusSchema,
     category: ConstraintCategorySchema.optional(),
+    scope: MemoryScopeSchema.optional(),
     tags: z.array(z.string()),
     related_paths: z.array(z.string()).optional(),
     expires_at: z.string().optional(),
@@ -73,6 +75,7 @@ export const DecisionSchema = z.object({
     host_id: z.string().optional(),
     session_id: z.string().optional(),
     outcome: DecisionOutcomeSchema.optional(),
+    scope: MemoryScopeSchema.optional(),
     related_paths: z.array(z.string()).optional(),
     plan_id: z.string().optional(),
     tags: z.array(z.string()),
@@ -90,6 +93,7 @@ export const TrapSchema = z.object({
     session_id: z.string().optional(),
     status: TrapStatusSchema.default('active'),
     severity: SeveritySchema,
+    scope: MemoryScopeSchema.optional(),
     tags: z.array(z.string()),
     related_paths: z.array(z.string()).optional(),
     plan_id: z.string().optional(),
@@ -122,10 +126,11 @@ export const HandoffSchema = z.object({
     }).optional(),
 });
 export const PlanStatusSchema = z.enum(['todo', 'in_progress', 'blocked', 'done', 'dropped']);
+export const PlanStepStatusSchema = z.enum(['todo', 'in_progress', 'testing', 'done', 'blocked']);
 export const PlanStepSchema = z.object({
     id: z.string(),
     text: z.string(),
-    status: z.enum(['todo', 'done']),
+    status: PlanStepStatusSchema.default('todo'),
     assignee: z.string().optional(),
     created_at: z.string(),
     updated_at: z.string(),
@@ -164,6 +169,7 @@ export const InstructionEntrySchema = z.object({
     created_at: z.string(),
     updated_at: z.string(),
     author: z.string(),
+    model: z.string().optional(),
     tags: z.array(z.string()).default([]),
     active: z.boolean().default(true),
     supersedes: z.string().optional(),
@@ -184,6 +190,7 @@ export const ProjectCapabilitySchema = z.object({
     created_at: z.string(),
     author: z.string(),
     author_id: z.string().optional(),
+    model: z.string().optional(),
 });
 export const ToolTypeSchema = z.enum(['workflow', 'validator', 'generator', 'utility', 'explorer']);
 export const ProjectToolSchema = z.object({
@@ -204,6 +211,7 @@ export const ProjectToolSchema = z.object({
     created_at: z.string(),
     author: z.string(),
     author_id: z.string().optional(),
+    model: z.string().optional(),
 });
 // --- State schema ---
 export const StateSchema = z.object({
@@ -258,6 +266,7 @@ export const CandidateSchema = z.object({
     created_at: z.string(),
     author: z.string(),
     author_id: z.string().optional(),
+    model: z.string().optional(),
     project_id: z.string().optional(),
     host_id: z.string().optional(),
     session_id: z.string().optional(),
@@ -326,6 +335,7 @@ export const ClaimSchema = z.object({
     status: ClaimStatusSchema,
     released_at: z.string().optional(),
     expires_at: z.string().optional(),
+    model: z.string().optional(),
 });
 // --- Runtime notes schemas ---
 export const RuntimeNoteSchema = z.object({
@@ -344,6 +354,7 @@ export const RuntimeNoteSchema = z.object({
     host_id: z.string().optional(),
     expires_at: z.string().optional(),
     note_type: z.enum(['observation', 'session_start', 'session_end']).default('observation'),
+    model: z.string().optional(),
 });
 // --- AI surface task request schemas ---
 export const AiSurfaceTaskStatusSchema = z.enum(['queued', 'in_progress', 'completed', 'cancelled', 'failed']);
@@ -369,6 +380,7 @@ export const AiSurfaceTaskRequestSchema = z.object({
     claimed_at: z.string().optional(),
     completed_at: z.string().optional(),
     result_note: z.string().optional(),
+    model: z.string().optional(),
 });
 // --- Runtime event schemas ---
 export const RuntimeEventTypeSchema = z.enum([
@@ -398,6 +410,7 @@ export const RuntimeEventSchema = z.object({
     to: z.string().optional(),
     related_paths: z.array(z.string()).optional(),
     metadata: z.record(z.unknown()).optional(),
+    model: z.string().optional(),
 });
 // --- Profile schema ---
 export const ProfileSchema = z.enum(['dev', 'openclaw', 'ops', 'research']);

package/docs/cli.md

@@ -86,7 +86,7 @@ brainclaw setup --roots ~/Projects,~/work --agents all  # all agents, multiple r
 
 ### `brainclaw init`
 
-Initialize workspace state for the current project root. Detects the AI agent environment and writes to its native instruction file. `brainclaw setup` must have been run first on this machine. Do not run `init` from inside `.brainclaw/`; that directory is Brainclaw's own memory store, not a project root.
+Initialize workspace state for the current project root. Detects the AI agent environment, writes to its native instruction file, and installs a git post-merge hook for automatic claim release. `brainclaw setup` must have been run first on this machine. Do not run `init` from inside `.brainclaw/`; that directory is Brainclaw's own memory store, not a project root.
 
 | Option | Description |
 |---|---|
@@ -993,13 +993,13 @@ brainclaw context --since-session --max-items 20
 
 ### `brainclaw context-diff`
 
-Show what has changed in shared memory since a reference point.
+Hybrid context view for subsequent prompts: always includes **critical anchors** (active claims, resolved instructions, top 5 traps) plus the memory delta since a reference point. Used by the Claude Code UserPromptSubmit hook after the first prompt.
 
 | Option | Description |
 |---|---|
 | `--since <date>` | Start date for the diff |
 | `--session <id>` | Compare against a specific session start |
-| `--json` | Output as JSON |
+| `--json` | Output as JSON (includes anchors + changed items) |
 
 ```bash
 brainclaw context-diff --session sess_42
@@ -1127,6 +1127,7 @@ Export memory as a native agent instruction file.
 |---|---|
 | `--format <format>` | Target format: `copilot-instructions`, `cursor-rules`, `agents-md`, `claude-md`, `gemini-md`, `windsurf`, `cline`, `roo`, or `continue` |
 | `--detect` | Auto-detect the running agent and write to its native file |
+| `--all` | Write all known agent instruction files at once (deduplicates by format) |
 | `--write` | Write output to the native file path (instead of stdout); generated workspace files are treated as local and added to `.gitignore` |
 | `--shared` | Keep the main exported instruction file versionable when used with `--write`; companion MCP/settings files stay local |
 | `--output <path>` | Write to a custom output path |
@@ -1146,6 +1147,7 @@ brainclaw export --format roo --write                    # .roo/rules/brainclaw.
 brainclaw export --format continue --write               # .continue/rules/brainclaw.md
 brainclaw export --format claude-md --write --shared     # publish CLAUDE.md intentionally
 brainclaw export --format claude-md                      # stdout
+brainclaw export --all                                   # all 9 agent files at once
 ```
 
 `brainclaw export --write` is local-first by default: the generated workspace file and any companion MCP/settings files are added to `.gitignore`. Use `--shared` only when you intentionally want the main instruction file to be committed. `brainclaw export --detect` also writes companion MCP config where relevant, including `opencode.json` for OpenCode and `.gemini/antigravity/mcp_config.json` for Antigravity/Gemini when the local environment is available.
@@ -1174,7 +1176,7 @@ See [adapters/openclaw.md](adapters/openclaw.md).
 
 ### `brainclaw install-hooks`
 
-Install Git hooks for constraint checking.
+Install Git hooks: pre-commit (constraint checking, sensitive content detection) and post-merge (auto-release of claims whose scope overlaps merged files).
 
 | Option | Description |
 |---|---|
@@ -1391,7 +1393,7 @@ brainclaw mcp
 | `bclaw_get_agent_board` | Live plan + claim board with active sessions |
 | `bclaw_search` | Full-text BM25 search across all memory items |
 | `bclaw_estimation_report` | Estimation accuracy report for completed plans |
-| `bclaw_list_plans` | List plan items with the same filters as `brainclaw plan list` |
+| `bclaw_list_plans` | List plan items with filters, pagination (`limit`/`offset`), `compact` mode, and direct `id` lookup |
 | `bclaw_list_claims` | List claims with the same filters as `brainclaw claim list` |
 | `bclaw_list_agents` | List registered agents, optionally with bounded reputation summaries |
 | `bclaw_list_instructions` | List raw or resolved shared instructions |

package/docs/concepts/plans-and-claims.md

@@ -106,6 +106,16 @@ brainclaw claim release <id>
 
 `claim list` shows who holds each claim and whether it is still active. If a claim has a `session_id`, the last 8 characters are shown so you can correlate with the agent session that created it.
 
+### Automatic claim release
+
+Claims are automatically released after a `git merge` if the post-merge hook is installed (default since `brainclaw init` v0.25.3+). The hook matches merged file paths against active claim scopes and releases overlapping claims.
+
+You can also install or reinstall the hook manually:
+
+```bash
+brainclaw install-hooks
+```
+
 ## Why claims matter
 
 Without claims, multiple agents can easily touch the same area at once and generate conflicting changes.

package/docs/integrations/agents.md

@@ -83,7 +83,8 @@ brainclaw export --detect --write          # auto-detect and write all formats
 When brainclaw memory changes (new constraints, resolved traps, updated plans), regenerate instruction files:
 
 ```bash
-brainclaw export --detect --write
+brainclaw export --all              # all 9 agent formats at once
+brainclaw export --detect --write   # only the detected agent
 ```
 
 For agents without MCP (Copilot), this is especially important — the instruction file is their only source of project context.

package/docs/integrations/mcp.md

@@ -42,7 +42,7 @@ This keeps session continuity inside Brainclaw instead of pushing the agent back
 | `bclaw_write_note` | Record a runtime note, supports `autoReflect: true` |
 | `bclaw_read_handoff` | Read active handoffs |
 | `bclaw_get_agent_board` | Coordination snapshot |
-| `bclaw_list_plans` | Structured plan listing with CLI-equivalent filters |
+| `bclaw_list_plans` | Structured plan listing with filters, pagination (`limit`/`offset`), `compact` mode, and `id` lookup |
 | `bclaw_list_claims` | Structured claim listing with CLI-equivalent filters |
 | `bclaw_list_agents` | Registered agent inventory, optionally with bounded reputation |
 | `bclaw_list_instructions` | Raw or resolved instruction listing |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainclaw",
-  "version": "0.24.0",
+  "version": "0.27.0",
   "description": "Shared project memory for humans and coding agents.",
   "type": "module",
   "bin": {
@@ -13,6 +13,12 @@
     "README.md",
     "LICENSE"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "scripts": {
     "build": "tsc",
     "dev": "tsc && node dist/cli.js",