brainclaw 0.23.1 → 0.25.3

package/dist/cli.js

@@ -963,6 +963,7 @@ program
     .description('Export memory as instructions for IDE/AI tools')
     .option('--format <format>', 'Format: copilot-instructions, cursor-rules, agents-md, claude-md, gemini-md, windsurf, cline, roo, continue')
     .option('--detect', 'Auto-detect agent environment and write to its native file')
+    .option('--all', 'Write all known agent instruction files at once (claude-md, agents-md, copilot-instructions, cursor-rules, etc.)')
     .option('--write', 'Write to canonical file path instead of stdout (when --format is given); local files are gitignored by default')
     .option('--shared', 'Keep the main exported instruction file versionable instead of auto-ignoring it (companions remain local)')
     .option('--output <file>', 'Write to a specific file path instead of stdout')

package/dist/commands/accept.js

@@ -1,4 +1,6 @@
-import { memoryExists, withStoreLock } from '../core/io.js';
+import { memoryExists } from '../core/io.js';
+import { mutate } from '../core/mutation-pipeline.js';
+import { rebuildProjectMd } from '../core/markdown.js';
 import { loadCandidate, archiveCandidate, resolveIdOrAlias } from '../core/candidates.js';
 import { loadState, persistState } from '../core/state.js';
 import { generateIdWithLabel, nowISO } from '../core/ids.js';
@@ -36,7 +38,7 @@ export function acceptCandidate(id, by, cwd, byId) {
     requireMinimumTrustLevel(actorIdentity, 'trusted');
     const actor = actorIdentity.agent_name;
     let promotedItemId = '';
-    withStoreLock(cwd, () => {
+    mutate({ cwd }, () => {
         const state = loadState(cwd);
         switch (candidate.type) {
             case 'constraint': {
@@ -136,6 +138,7 @@ export function acceptCandidate(id, by, cwd, byId) {
             after: { type: candidate.type, text: candidate.text },
             reason: 'trusted-agent',
         }, cwd);
+        rebuildProjectMd(loadState(cwd), cwd);
     });
     return {
         candidate_id: resolvedId,

package/dist/commands/claim.js

@@ -1,10 +1,11 @@
 import { buildOperationalIdentity } from '../core/identity.js';
-import { memoryExists, memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
+import { memoryExists } from '../core/io.js';
+import { mutate } from '../core/mutation-pipeline.js';
 import { saveClaim, generateClaimId, listClaims } from '../core/claims.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { rebuildProjectMd } from '../core/markdown.js';
 import { loadState, saveState } from '../core/state.js';
 import { nowISO } from '../core/ids.js';
-import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveCurrentModel } from '../core/agent-registry.js';
 import { validateCliTtl } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
 function parseTtl(ttl) {
@@ -71,8 +72,9 @@ export function runClaim(description, options) {
         plan_id: options.plan,
         status: 'active',
         expires_at: options.ttl ? parseTtl(options.ttl) : undefined,
+        model: resolveCurrentModel(options.cwd),
     };
-    withStoreLock(options.cwd, () => {
+    mutate({ cwd: options.cwd }, () => {
         if (plan) {
             if (!plan.assignee) {
                 plan.assignee = actor.agent;
@@ -84,7 +86,7 @@ export function runClaim(description, options) {
             saveState(state, options.cwd);
         }
         saveClaim(claim, options.cwd);
-        writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(plan ? state : loadState(options.cwd), options.cwd));
+        rebuildProjectMd(plan ? state : loadState(options.cwd), options.cwd);
     });
     const planInfo = claim.plan_id ? ` [plan ${claim.plan_id}]` : '';
     const ttlInfo = claim.expires_at ? ` (expires ${claim.expires_at.slice(0, 16).replace('T', ' ')})` : '';

package/dist/commands/context-diff.js

@@ -1,5 +1,14 @@
 import { buildContextDiff, resolveContextDiffSince } from '../core/context-diff.js';
+import { listClaims, isClaimExpired } from '../core/claims.js';
+import { loadInstructions, resolveInstructions } from '../core/instructions.js';
 import { memoryExists } from '../core/io.js';
+import { loadState } from '../core/state.js';
+import { isTrapActive } from '../core/traps.js';
+/**
+ * Hybrid context-diff: always includes critical anchors (active claims,
+ * top traps, instructions) so the agent stays grounded, plus the memory
+ * delta since last context read.
+ */
 export function runContextDiff(options = {}) {
     if (!memoryExists(options.cwd)) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
@@ -20,13 +29,62 @@ export function runContextDiff(options = {}) {
         process.exit(1);
     }
     if (options.json) {
-        console.log(JSON.stringify(diff, null, 2));
+        const anchors = buildCriticalAnchors(options.cwd);
+        console.log(JSON.stringify({ ...diff, anchors }, null, 2));
         return;
     }
+    const lines = [];
+    // --- Critical anchors (always present) ---
+    const anchors = buildCriticalAnchors(options.cwd);
+    if (anchors.claims.length > 0) {
+        lines.push('Active claims:');
+        for (const c of anchors.claims) {
+            lines.push(`- [${c.id}] ${c.agent} → ${c.scope}: ${c.description}`);
+        }
+        lines.push('');
+    }
+    if (anchors.instructions.length > 0) {
+        lines.push('Instructions:');
+        for (const ins of anchors.instructions) {
+            const scope = ins.scope ? `:${ins.scope}` : '';
+            lines.push(`- [${ins.id}] <${ins.layer}${scope}> ${ins.text}`);
+        }
+        lines.push('');
+    }
+    if (anchors.traps.length > 0) {
+        lines.push('Active traps:');
+        for (const t of anchors.traps) {
+            lines.push(`- [${t.id}] (${t.severity}) ${t.text}`);
+        }
+        lines.push('');
+    }
+    // --- Memory delta ---
     if (diff.counts.total === 0) {
-        console.log(`${diff.summary} since ${diff.since}.`);
-        return;
+        lines.push(`Memory: no changes since ${diff.since?.slice(0, 16).replace('T', ' ')}.`);
     }
-    console.log(`${diff.summary} since ${diff.since}.`);
+    else {
+        lines.push(`Memory delta (${diff.summary}):`);
+        for (const item of diff.changed_items ?? []) {
+            lines.push(`- [${item.section}] [${item.id}] ${item.text}`);
+        }
+    }
+    console.log(lines.join('\n'));
+}
+function buildCriticalAnchors(cwd) {
+    const activeClaims = listClaims(cwd)
+        .filter((c) => c.status === 'active' && !isClaimExpired(c))
+        .map((c) => ({ id: c.id, agent: c.agent, scope: c.scope, description: c.description }));
+    const instructions = resolveInstructions(loadInstructions(cwd))
+        .map((ins) => ({ id: ins.id, layer: ins.layer, scope: ins.scope, text: ins.text }));
+    const state = loadState(cwd);
+    const traps = state.known_traps
+        .filter((t) => isTrapActive(t))
+        .sort((a, b) => {
+        const severityOrder = { high: 0, medium: 1, low: 2 };
+        return (severityOrder[a.severity] ?? 1) - (severityOrder[b.severity] ?? 1);
+    })
+        .slice(0, 5)
+        .map((t) => ({ id: t.id, severity: t.severity, text: t.text }));
+    return { claims: activeClaims, instructions, traps };
 }
 //# sourceMappingURL=context-diff.js.map

package/dist/commands/export.js

@@ -6,7 +6,7 @@ import { loadConfig, saveConfig } from '../core/config.js';
 import { isAgentIntegrationName, upsertAgentIntegrationDeclaration } from '../core/agent-integrations.js';
 import { resolveInstructions, loadInstructions } from '../core/instructions.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
-import { resolveExportTarget, resolveExportTargetByFormat, writeExportFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, } from '../core/agent-files.js';
+import { AGENT_EXPORT_REGISTRY, resolveExportTarget, resolveExportTargetByFormat, writeExportFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, } from '../core/agent-files.js';
 import { logger } from '../core/logger.js';
 import { getAgentCapabilityProfile } from '../core/agent-capability.js';
 import { renderBrainclawSection } from '../core/instruction-templates.js';
@@ -17,6 +17,10 @@ export function runExport(options) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
+    if (options.all) {
+        runExportAll(cwd, options);
+        return;
+    }
     if (options.detect) {
         if (options.shared) {
             console.error('Error: --shared cannot be used with --detect. Use `brainclaw export --format <format> --write --shared` to publish a specific instruction file.');
@@ -26,7 +30,7 @@ export function runExport(options) {
         return;
     }
     if (!options.format) {
-        console.error('Error: --format or --detect is required.');
+        console.error('Error: --format, --detect, or --all is required.');
         process.exit(1);
     }
     const content = generateExport(options.format, options, cwd);
@@ -90,6 +94,40 @@ function runExportDetect(cwd, options) {
         }
     }
 }
+function runExportAll(cwd, options) {
+    // Deduplicate by format (e.g. codex and opencode both use agents-md)
+    const seen = new Set();
+    const targets = AGENT_EXPORT_REGISTRY.filter((t) => {
+        if (seen.has(t.format))
+            return false;
+        seen.add(t.format);
+        return true;
+    });
+    let written = 0;
+    const allGitignoreEntries = [];
+    for (const target of targets) {
+        try {
+            const content = generateExport(target.format, options, cwd);
+            const result = writeExportFile(content, target.relativePath, cwd);
+            const autoConfigs = writeExportCompanionFiles(target.format, cwd);
+            const gitignoreEntries = collectExportGitignoreEntries(cwd, target.relativePath, autoConfigs);
+            allGitignoreEntries.push(...gitignoreEntries);
+            declareAgentIntegrationFromTarget(cwd, target.agentName, 'manual');
+            console.log(`✔ ${target.relativePath} (${result.created ? 'created' : 'updated'})`);
+            written++;
+        }
+        catch (err) {
+            logger.debug(`Failed to export ${target.format}:`, err);
+            console.warn(`⚠ Skipped ${target.format}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Consolidate gitignore entries
+    if (allGitignoreEntries.length > 0) {
+        ensureGitignoreEntries(cwd, [...new Set(allGitignoreEntries)]);
+        console.log('✔ Updated .gitignore');
+    }
+    console.log(`✔ Exported ${written} agent file(s)`);
+}
 export function writeAgentExportForAgent(agentName, cwd) {
     const rendered = renderAgentExportForAgent(agentName, cwd);
     if (!rendered) {

package/dist/commands/init.js

@@ -245,6 +245,8 @@ export async function runInit(options = {}) {
     if (initMemoryRepo(cwd)) {
         console.log('✔ Initialized memory git repo for versioning');
     }
+    // Install post-merge hook for auto-release of claims after merge
+    installPostMergeHookIfMissing(cwd);
     const onboardingPreflight = runBootstrapProfile({ cwd, refresh: true });
     console.log('');
     console.log('Onboarding preflight:');
@@ -268,6 +270,45 @@ export async function runInit(options = {}) {
     console.log('');
     console.log(`Tip: run 'brainclaw context --json' to load the shared memory into your agent session.`);
 }
+function installPostMergeHookIfMissing(cwd) {
+    try {
+        let dir = path.resolve(cwd);
+        let gitRoot;
+        while (true) {
+            if (fs.existsSync(path.join(dir, '.git'))) {
+                gitRoot = dir;
+                break;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        if (!gitRoot)
+            return;
+        const hooksDir = path.join(gitRoot, '.git', 'hooks');
+        const hookPath = path.join(hooksDir, 'post-merge');
+        if (fs.existsSync(hookPath))
+            return; // don't overwrite existing hooks
+        if (!fs.existsSync(hooksDir))
+            fs.mkdirSync(hooksDir, { recursive: true });
+        const script = [
+            '#!/bin/sh',
+            '# brainclaw post-merge hook — auto-release claims on merged files',
+            'BCLAW_CMD=""',
+            'if command -v brainclaw >/dev/null 2>&1; then BCLAW_CMD="brainclaw"',
+            'elif command -v bclaw >/dev/null 2>&1; then BCLAW_CMD="bclaw"',
+            'else BCLAW_CMD="npx --no brainclaw"; fi',
+            '$BCLAW_CMD release-claims --from-git-diff 2>/dev/null || true',
+            '',
+        ].join('\n');
+        fs.writeFileSync(hookPath, script, { encoding: 'utf-8', mode: 0o755 });
+        console.log('✔ Installed post-merge hook for auto-release of claims');
+    }
+    catch {
+        // Non-critical — skip silently
+    }
+}
 function resolveStorageDir(storageDir) {
     const candidate = (storageDir ?? MEMORY_DIR).trim();
     if (candidate !== MEMORY_DIR) {

package/dist/commands/instruction.js

@@ -1,8 +1,9 @@
 import { resolveAgentScope, resolveCurrentAgentName } from '../core/agent-registry.js';
 import { loadConfig } from '../core/config.js';
 import { createInstruction } from '../core/instructions.js';
-import { memoryExists, memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { memoryExists } from '../core/io.js';
+import { mutate } from '../core/mutation-pipeline.js';
+import { rebuildProjectMd } from '../core/markdown.js';
 import { loadState } from '../core/state.js';
 import { scanText } from '../core/security.js';
 import { validateCliInput } from '../core/input-validation.js';
@@ -26,7 +27,7 @@ export function runInstruction(text, options = {}) {
         }
     }
     let entry;
-    withStoreLock(cwd, () => {
+    mutate({ cwd }, () => {
         entry = createInstruction(text, {
             layer,
             scope,
@@ -34,7 +35,7 @@ export function runInstruction(text, options = {}) {
             author: options.author ?? resolveCurrentAgentName(cwd),
             supersedes: options.supersedes,
         }, cwd);
-        writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(loadState(cwd)));
+        rebuildProjectMd(loadState(cwd), cwd);
     });
     if (!entry) {
         console.error('Error: failed to persist instruction.');

package/dist/commands/mcp.js

@@ -18,7 +18,7 @@ import { acceptCandidate } from './accept.js';
 import { rejectCandidate } from './reject.js';
 import { startSession } from './session-start.js';
 import { endSession } from './session-end.js';
-import { agentCanWriteDirect, AgentIdentityResolutionError, AgentTrustError, listAgentIdentities, requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveAgentScope, resolveCurrentAgentIdentity, resolveCurrentAgentName, } from '../core/agent-registry.js';
+import { agentCanWriteDirect, AgentIdentityResolutionError, AgentTrustError, listAgentIdentities, requireMinimumTrustLevel, requireRegisteredAgentIdentity, resolveAgentScope, resolveCurrentAgentIdentity, resolveCurrentAgentName, resolveCurrentModel, } from '../core/agent-registry.js';
 import { appendAuditEntry } from '../core/audit.js';
 import { nowISO, generateIdWithLabel, generateId } from '../core/ids.js';
 import { inferProjectFromTarget, loadInstructions, resolveInstructions } from '../core/instructions.js';
@@ -156,6 +156,10 @@ export const MCP_READ_TOOLS = [
                 type: { type: 'string', description: 'Filter by plan type.' },
                 assignee: { type: 'string', description: 'Filter by assignee name.' },
                 project: { type: 'string', description: 'Filter by project namespace.' },
+                id: { type: 'string', description: 'Get a single plan by ID (exact match).' },
+                limit: { type: 'number', description: 'Maximum number of plans to return (default: 20).' },
+                offset: { type: 'number', description: 'Number of plans to skip (for pagination).' },
+                compact: { type: 'boolean', description: 'Return only key fields (id, short_label, text, status, priority) to reduce output size.' },
             },
         },
     },
@@ -667,6 +671,11 @@ export class McpTaskRunner {
     onInternalError;
     active;
     queue = [];
+    _totalExecuted = 0;
+    _totalCancelled = 0;
+    _peakQueueDepth = 0;
+    _lastDurationMs = 0;
+    _lastWaitMs = 0;
     constructor(options) {
         this.executeTool = options.executeTool;
         this.onResult = options.onResult;
@@ -678,19 +687,35 @@ export class McpTaskRunner {
     get queuedRequestIds() {
         return this.queue.map((task) => task.requestId);
     }
+    /** Current single-writer queue metrics. */
+    get metrics() {
+        return {
+            totalExecuted: this._totalExecuted,
+            totalCancelled: this._totalCancelled,
+            queueDepth: this.queue.length,
+            peakQueueDepth: this._peakQueueDepth,
+            lastDurationMs: this._lastDurationMs,
+            lastWaitMs: this._lastWaitMs,
+        };
+    }
     enqueue(requestId, payload) {
         this.queue.push({
             requestId,
             payload,
             controller: new AbortController(),
             cancelled: false,
+            enqueuedAt: performance.now(),
         });
+        if (this.queue.length > this._peakQueueDepth) {
+            this._peakQueueDepth = this.queue.length;
+        }
         this.drain();
     }
     cancel(requestId) {
         if (this.active && this.active.requestId === requestId) {
             this.active.cancelled = true;
             this.active.controller.abort();
+            this._totalCancelled++;
             return 'active';
         }
         const index = this.queue.findIndex((task) => task.requestId === requestId);
@@ -698,6 +723,7 @@ export class McpTaskRunner {
             const [task] = this.queue.splice(index, 1);
             task.cancelled = true;
             task.controller.abort();
+            this._totalCancelled++;
             return 'queued';
         }
         return 'missing';
@@ -722,6 +748,7 @@ export class McpTaskRunner {
             return;
         }
         if (next.cancelled) {
+            this._totalCancelled++;
             this.drain();
             return;
         }
@@ -729,6 +756,8 @@ export class McpTaskRunner {
         void this.runTask(next);
     }
     async runTask(task) {
+        const startedAt = performance.now();
+        this._lastWaitMs = startedAt - task.enqueuedAt;
         try {
             const outcome = await this.executeTool(task.payload, task.controller.signal);
             if (!task.cancelled) {
@@ -741,6 +770,8 @@ export class McpTaskRunner {
             }
         }
         finally {
+            this._lastDurationMs = performance.now() - startedAt;
+            this._totalExecuted++;
             if (this.active === task) {
                 this.active = undefined;
             }
@@ -1281,6 +1312,18 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
     }
     if (name === 'bclaw_list_plans') {
         let plans = loadState(cwd).plan_items;
+        // Direct lookup by ID
+        if (args.id) {
+            const plan = plans.find((p) => p.id === String(args.id) || p.short_label === String(args.id));
+            if (!plan) {
+                return { content: [{ type: 'text', text: `Plan '${args.id}' not found.` }], structuredContent: { total: 0, plans: [] } };
+            }
+            return {
+                content: [{ type: 'text', text: `[${plan.id}] ${plan.text} (${plan.status}, ${plan.priority})` }],
+                structuredContent: { total: 1, plans: [plan] },
+            };
+        }
+        // Filters
         if (!args.all) {
             plans = plans.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
         }
@@ -1298,11 +1341,16 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             const project = String(args.project).toLowerCase();
             plans = plans.filter((plan) => plan.project?.toLowerCase() === project);
         }
-        const lines = plans.length === 0
+        const totalFiltered = plans.length;
+        // Pagination
+        const offset = Math.max(0, Number(args.offset) || 0);
+        const limit = Math.max(1, Number(args.limit) || 20);
+        const paginated = plans.slice(offset, offset + limit);
+        const lines = paginated.length === 0
             ? ['No plan items found.']
             : [
-                `${plans.length} plan item(s):`,
-                ...plans.map((plan) => {
+                `${totalFiltered} plan(s)${totalFiltered > paginated.length ? ` (showing ${offset + 1}-${offset + paginated.length})` : ''}:`,
+                ...paginated.map((plan) => {
                     const meta = [plan.type ?? 'feat', plan.status, plan.priority];
                     if (plan.assignee)
                         meta.push(`assignee ${plan.assignee}`);
@@ -1314,9 +1362,15 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
                     return `[${plan.id}] ${plan.text} (${meta.join(' · ')})${tags}`;
                 }),
             ];
+        // Compact mode: strip heavy fields
+        const outputPlans = args.compact
+            ? paginated.map(({ id, short_label, text, status, priority, tags, assignee, type }) => ({
+                id, short_label, text, status, priority, tags, assignee, type,
+            }))
+            : paginated;
         return {
             content: [{ type: 'text', text: lines.join('\n') }],
-            structuredContent: { total: plans.length, plans },
+            structuredContent: { total: totalFiltered, offset, limit, plans: outputPlans },
         };
     }
     if (name === 'bclaw_list_claims') {
@@ -1584,6 +1638,8 @@ export async function executeMcpToolCall(payload) {
                 response: toolResponse(handleMcpReadToolCall(name, args, { cwd })),
             };
         }
+        // Resolve model once for all write operations
+        const currentModel = resolveCurrentModel(cwd);
         if (name === 'bclaw_setup') {
             const step = args.step;
             const choice = args.choice ?? '';
@@ -1767,6 +1823,7 @@ export async function executeMcpToolCall(payload) {
                 autoReflect: args.autoReflect,
                 cwd,
                 sessionId: connectionSessionId,
+                model: currentModel,
             }, false);
             return {
                 response: toolResponse({
@@ -1819,6 +1876,7 @@ export async function executeMcpToolCall(payload) {
                 category: type === 'constraint' ? args.category : undefined,
                 outcome: type === 'decision' ? args.outcome : undefined,
                 plan_id: candidatePlanId,
+                model: currentModel,
                 star_count: 0,
                 starred_by: [],
                 usage_count: 0,
@@ -1922,6 +1980,7 @@ export async function executeMcpToolCall(payload) {
                 created_at: nowISO(),
                 status: 'active',
                 plan_id: args.planId,
+                model: currentModel,
             }, claimCwd);
             appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'claim', item_id: claimId, item_type: 'claim' }, claimCwd);
             const postClaimItems = getTriggeredItems('trigger:post-claim', claimCwd);

package/dist/commands/prune.js

@@ -1,6 +1,7 @@
 import { loadState, saveState } from '../core/state.js';
-import { memoryExists, memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { memoryExists } from '../core/io.js';
+import { mutate } from '../core/mutation-pipeline.js';
+import { rebuildProjectMd } from '../core/markdown.js';
 import { deleteRuntimeNote, listRuntimeNotes } from '../core/runtime.js';
 import { expireStaleActiveClaims } from '../core/claims.js';
 export function runPrune(options = {}) {
@@ -13,7 +14,7 @@ export function runPrune(options = {}) {
     let prunedCount = 0;
     let expiredClaimsCount = 0;
     let expiredNotesCount = 0;
-    withStoreLock(cwd, () => {
+    mutate({ cwd }, () => {
         const state = loadState(cwd);
         const originalLength = state.active_constraints.length;
         for (const c of state.active_constraints) {
@@ -38,7 +39,7 @@ export function runPrune(options = {}) {
                 }
             }
         }
-        writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(loadState(cwd), cwd));
+        rebuildProjectMd(loadState(cwd), cwd);
     });
     if (options.expired) {
         console.log(`✔ Pruned ${prunedCount} expired constraints, ${expiredNotesCount} expired runtime notes, ${expiredClaimsCount} expired claims.`);

package/dist/commands/reflect.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import { memoryExists } from '../core/io.js';
+import { rebuildProjectMd } from '../core/markdown.js';
 import { loadConfig } from '../core/config.js';
 import { buildOperationalIdentity } from '../core/identity.js';
 import { loadState, persistState } from '../core/state.js';
@@ -265,6 +266,7 @@ function promoteCandidateToState(candidate, cwd) {
         }
     }
     persistState(state, cwd);
+    rebuildProjectMd(loadState(cwd), cwd);
     return promotedItemId;
 }
 export function mapEventTypeToCandidateType(eventType) {

package/dist/commands/release-claim.js

@@ -1,7 +1,7 @@
 import { memoryExists } from '../core/io.js';
-import { memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
+import { mutate } from '../core/mutation-pipeline.js';
 import { loadClaim, listClaims, releaseClaim } from '../core/claims.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { rebuildProjectMd } from '../core/markdown.js';
 import { loadState, saveState } from '../core/state.js';
 export function runReleaseClaim(id, options = {}) {
     if (!memoryExists(options.cwd)) {
@@ -10,7 +10,7 @@ export function runReleaseClaim(id, options = {}) {
     }
     try {
         let claim = loadClaim(id, options.cwd);
-        withStoreLock(options.cwd, () => {
+        mutate({ cwd: options.cwd }, () => {
             const existing = loadClaim(id, options.cwd);
             claim = releaseClaim(id, options.cwd);
             let state = loadState(options.cwd);
@@ -31,7 +31,7 @@ export function runReleaseClaim(id, options = {}) {
                     saveState(state, options.cwd);
                 }
             }
-            writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+            rebuildProjectMd(state, options.cwd);
         });
         console.log(`✔ Claim [${id}] released (was: ${claim.agent} → ${claim.scope})`);
     }

package/dist/commands/release-claims.js

@@ -1,7 +1,8 @@
 import { execSync } from 'node:child_process';
-import { memoryExists, memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
+import { memoryExists } from '../core/io.js';
+import { mutate } from '../core/mutation-pipeline.js';
 import { listClaims, releaseClaim } from '../core/claims.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { rebuildProjectMd } from '../core/markdown.js';
 import { loadState, saveState } from '../core/state.js';
 function normPath(p) {
     return p.replace(/\\/g, '/').replace(/^\.\//, '');
@@ -36,7 +37,7 @@ export function runReleaseClaims(options = {}) {
     if (toRelease.length === 0)
         process.exit(0);
     let released = 0;
-    withStoreLock(options.cwd, () => {
+    mutate({ cwd: options.cwd }, () => {
         let state = loadState(options.cwd);
         for (const claim of toRelease) {
             try {
@@ -59,7 +60,7 @@ export function runReleaseClaims(options = {}) {
             catch { /* skip individual failures */ }
         }
         state = loadState(options.cwd);
-        writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+        rebuildProjectMd(state, options.cwd);
     });
     if (released > 0) {
         console.log(`brainclaw: ${released} claim(s) auto-released after merge.`);

package/dist/commands/runtime-note.js

@@ -61,6 +61,7 @@ export function createRuntimeNote(text, options, printSuccess = false) {
         host_id: hostId,
         expires_at: expiresAt,
         note_type: 'observation',
+        model: options.model,
     };
     saveRuntimeNote(note, options.cwd);
     const result = maybeAutoReflectRuntimeNote(note, options);

package/dist/core/ai-surface-tasks.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { JsonStore } from './json-store.js';
-import { resolveEntityDir, withStoreLock } from './io.js';
+import { resolveEntityDir } from './io.js';
+import { mutate } from './mutation-pipeline.js';
 import { AiSurfaceTaskRequestSchema } from './schema.js';
 function surfaceTasksDir(cwd, mode = 'read') {
     return resolveEntityDir('surface-tasks', cwd ?? process.cwd(), mode);
@@ -20,7 +21,7 @@ export function ensureAiSurfaceTasksDir(cwd) {
     }
 }
 export function saveAiSurfaceTask(task, cwd) {
-    withStoreLock(cwd, () => {
+    mutate({ cwd }, () => {
         ensureAiSurfaceTasksDir(cwd);
         const writeStore = new JsonStore({
             dirPath: surfaceTasksDir(cwd, 'write'),

package/dist/core/audit.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { memoryDir, withStoreLock } from './io.js';
+import { memoryDir } from './io.js';
+import { mutate } from './mutation-pipeline.js';
 import { nowISO } from './ids.js';
 import { logger } from './logger.js';
 import { appendEvent } from './event-log.js';
@@ -23,7 +24,7 @@ function auditLogPath(cwd) {
 }
 export function appendAuditEntry(entry, cwd) {
     try {
-        withStoreLock(cwd, () => {
+        mutate({ cwd }, () => {
             const full = {
                 timestamp: nowISO(),
                 actor: entry.actor,