brainclaw 0.19.6 → 0.19.10

package/dist/commands/mcp.js

@@ -8,9 +8,8 @@ import { buildCoordinationSnapshot } from '../core/coordination.js';
 import { buildContext, renderContextMarkdown, renderContextPromptTemplate } from '../core/context.js';
 import { buildExecutionContext, renderExecutionContextSummary } from '../core/execution-context.js';
 import { loadConfig } from '../core/config.js';
-import { loadState, saveState } from '../core/state.js';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { loadState, persistState } from '../core/state.js';
+import { memoryExists } from '../core/io.js';
 import { generateCandidateIdWithLabel, listArchivedCandidates, listCandidates, saveCandidate } from '../core/candidates.js';
 import { generateClaimId, listClaims, loadClaim, saveClaim } from '../core/claims.js';
 import { createRuntimeNote } from './runtime-note.js';
@@ -62,7 +61,7 @@ export const MCP_READ_TOOLS = [
     },
     {
         name: 'bclaw_bootstrap',
-        description: 'Derive brownfield bootstrap signals from repository docs, manifests, and git history.',
+        description: 'Derive brownfield bootstrap signals, adaptive interview prompts for CLI or IDE chat agents, and an import proposal from repository docs, manifests, native agent files, and git history.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -1053,8 +1052,14 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
                 target: result.profile.target,
                 repo_fingerprint: result.profile.repo_fingerprint,
                 sources_scanned: result.profile.sources_scanned,
+                workspace_kind: result.profile.workspace_kind,
+                confidence: result.profile.confidence,
+                native_instruction_files: result.profile.native_instruction_files,
+                gaps: result.profile.gaps,
                 seed_count: result.profile.seed_count,
                 seeds: result.seeds,
+                import_plan: result.importPlan,
+                last_application: result.lastApplication,
                 reused_profile: result.reusedProfile,
             },
         };
@@ -1808,8 +1813,7 @@ export async function executeMcpToolCall(payload) {
                     if (releasePlanStatus === 'done' && !releasePlan.completed_at)
                         releasePlan.completed_at = ts;
                     releasePlan.updated_at = ts;
-                    saveState(releaseState, cwd);
-                    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(releaseState, cwd));
+                    persistState(releaseState, cwd);
                     releasePlanUpdated = true;
                 }
             }
@@ -1957,8 +1961,7 @@ export async function executeMcpToolCall(payload) {
                 estimated_effort: estimatedEffort,
             };
             state.plan_items.push(entry);
-            saveState(state, cwd);
-            writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+            persistState(state, cwd);
             appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'create', item_id: id, item_type: 'plan' }, cwd);
             return {
                 response: toolResponse({
@@ -1996,8 +1999,7 @@ export async function executeMcpToolCall(payload) {
             if (args.actualEffort)
                 plan.actual_effort = args.actualEffort;
             plan.updated_at = timestamp;
-            saveState(state, cwd);
-            writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+            persistState(state, cwd);
             appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'update', item_id: plan.id, item_type: 'plan' }, cwd);
             return {
                 response: toolResponse({
@@ -2032,8 +2034,7 @@ export async function executeMcpToolCall(payload) {
             };
             plan.steps = [...(plan.steps ?? []), step];
             plan.updated_at = nowISO();
-            saveState(state, cwd);
-            writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+            persistState(state, cwd);
             const total = plan.steps.length;
             const done = plan.steps.filter((s) => s.status === 'done').length;
             return {
@@ -2066,8 +2067,7 @@ export async function executeMcpToolCall(payload) {
             step.status = 'done';
             step.updated_at = nowISO();
             plan.updated_at = nowISO();
-            saveState(state, cwd);
-            writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+            persistState(state, cwd);
             const total = plan.steps.length;
             const done = plan.steps.filter((s) => s.status === 'done').length;
             return {
@@ -2124,8 +2124,7 @@ export async function executeMcpToolCall(payload) {
             else if (itemType === 'trap') {
                 state.known_traps = state.known_traps.filter((t) => t.id !== itemId && t.short_label !== itemId);
             }
-            saveState(state, foundStore.cwd);
-            writeFileAtomic(memoryPath('project.md', foundStore.cwd), generateMarkdown(state, foundStore.cwd));
+            persistState(state, foundStore.cwd);
             appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'delete', item_id: itemId, item_type: itemType }, foundStore.cwd);
             return {
                 response: toolResponse({
@@ -2211,8 +2210,7 @@ export async function executeMcpToolCall(payload) {
                 else if (itemType === 'trap') {
                     sourceState.known_traps = sourceState.known_traps.filter((t) => t.id !== itemId);
                 }
-                saveState(sourceState, sourceStore.cwd);
-                writeFileAtomic(memoryPath('project.md', sourceStore.cwd), generateMarkdown(sourceState, sourceStore.cwd));
+                persistState(sourceState, sourceStore.cwd);
                 // Add to target store
                 const targetState = loadState(targetCwd);
                 if (itemType === 'constraint') {
@@ -2224,8 +2222,7 @@ export async function executeMcpToolCall(payload) {
                 else if (itemType === 'trap') {
                     targetState.known_traps.push(item);
                 }
-                saveState(targetState, targetCwd);
-                writeFileAtomic(memoryPath('project.md', targetCwd), generateMarkdown(targetState, targetCwd));
+                persistState(targetState, targetCwd);
             }
             else {
                 // Just update in place
@@ -2245,8 +2242,7 @@ export async function executeMcpToolCall(payload) {
                     if (idx >= 0)
                         state.known_traps[idx] = item;
                 }
-                saveState(state, sourceStore.cwd);
-                writeFileAtomic(memoryPath('project.md', sourceStore.cwd), generateMarkdown(state, sourceStore.cwd));
+                persistState(state, sourceStore.cwd);
             }
             appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'update', item_id: itemId, item_type: itemType }, sourceStore.cwd);
             return {

package/dist/commands/memory.js

@@ -1,7 +1,6 @@
 import { loadConfig } from '../core/config.js';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
-import { generateMarkdown } from '../core/markdown.js';
-import { loadState, saveState } from '../core/state.js';
+import { memoryExists } from '../core/io.js';
+import { loadState, persistState } from '../core/state.js';
 import { scanText } from '../core/security.js';
 import { validateCliInput } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
@@ -222,8 +221,7 @@ function runMemoryUpdate(id, options) {
                 break;
             }
     }
-    saveState(state, options.cwd);
-    writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+    persistState(state, options.cwd);
     console.log(`✔ Memory item updated: [${resolved.item.id}] ${resolved.item.text}`);
 }
 function runMemoryDelete(id, cwd) {
@@ -250,8 +248,7 @@ function runMemoryDelete(id, cwd) {
         console.error(`Error: Memory item '${id}' not found.`);
         process.exit(1);
     }
-    saveState(state, cwd);
-    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+    persistState(state, cwd);
     console.log(`✔ Memory item deleted: [${deleted.id}] ${deleted.text}`);
 }
 function collectMemoryItems(state) {

package/dist/commands/plan.js

@@ -1,10 +1,9 @@
-import { loadState, saveState } from '../core/state.js';
+import { loadState, persistState } from '../core/state.js';
 import { resolveCurrentAgentName } from '../core/agent-registry.js';
 import { loadConfig } from '../core/config.js';
-import { generateMarkdown } from '../core/markdown.js';
 import { generateIdWithLabel, nowISO } from '../core/ids.js';
 import { scanText } from '../core/security.js';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { memoryExists } from '../core/io.js';
 import { validateCliInput } from '../core/input-validation.js';
 import { runListPlans } from './list-plans.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
@@ -68,8 +67,7 @@ export function runPlan(text, options = {}) {
         estimated_effort: estimatedEffort,
     };
     state.plan_items.push(entry);
-    saveState(state, cwd);
-    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+    persistState(state, cwd);
     const storeLabel = options.store && options.store !== 'local' ? ` [store:${options.store}]` : '';
     console.log(`✔ Plan item added: [${id}] ${text}${storeLabel}`);
 }

package/dist/commands/prune.js

@@ -1,5 +1,6 @@
 import { loadState, saveState } from '../core/state.js';
-import { memoryExists } from '../core/io.js';
+import { memoryExists, memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
+import { generateMarkdown } from '../core/markdown.js';
 import { deleteRuntimeNote, listRuntimeNotes } from '../core/runtime.js';
 import { expireStaleActiveClaims } from '../core/claims.js';
 export function runPrune(options = {}) {
@@ -8,36 +9,37 @@ export function runPrune(options = {}) {
         console.error('Project memory not initialized. Run `brainclaw init` first.');
         process.exit(1);
     }
-    const state = loadState(cwd);
     const now = new Date().toISOString();
-    const originalLength = state.active_constraints.length;
-    // Transition expired constraints to "expired"
-    for (const c of state.active_constraints) {
-        if (c.status === 'active' && c.expires_at && c.expires_at < now) {
-            c.status = 'expired';
-        }
-    }
-    // Filter out constraints that have been expired for a while to keep memory clean
-    // For the MVP, we just remove them if they are expired
-    state.active_constraints = state.active_constraints.filter(c => c.status !== 'expired');
-    const prunedCount = originalLength - state.active_constraints.length;
-    saveState(state, cwd);
-    const expiredClaimsCount = expireStaleActiveClaims(cwd);
+    let prunedCount = 0;
+    let expiredClaimsCount = 0;
     let expiredNotesCount = 0;
-    if (options.expired) {
-        // Prune expired runtime notes
-        const notes = listRuntimeNotes(undefined, cwd);
-        for (const note of notes) {
-            if (note.expires_at && note.expires_at < now) {
-                try {
-                    if (deleteRuntimeNote(note, cwd)) {
-                        expiredNotesCount++;
+    withStoreLock(cwd, () => {
+        const state = loadState(cwd);
+        const originalLength = state.active_constraints.length;
+        for (const c of state.active_constraints) {
+            if (c.status === 'active' && c.expires_at && c.expires_at < now) {
+                c.status = 'expired';
+            }
+        }
+        state.active_constraints = state.active_constraints.filter(c => c.status !== 'expired');
+        prunedCount = originalLength - state.active_constraints.length;
+        saveState(state, cwd);
+        expiredClaimsCount = expireStaleActiveClaims(cwd);
+        if (options.expired) {
+            const notes = listRuntimeNotes(undefined, cwd);
+            for (const note of notes) {
+                if (note.expires_at && note.expires_at < now) {
+                    try {
+                        if (deleteRuntimeNote(note, cwd)) {
+                            expiredNotesCount++;
+                        }
                     }
+                    catch { /* ignore */ }
                 }
-                catch { /* ignore */ }
             }
         }
-    }
+        writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(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,9 +1,8 @@
 import fs from 'node:fs';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { memoryExists } from '../core/io.js';
 import { loadConfig } from '../core/config.js';
 import { buildOperationalIdentity } from '../core/identity.js';
-import { loadState, saveState } from '../core/state.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { loadState, persistState } from '../core/state.js';
 import { scanText } from '../core/security.js';
 import { nowISO, generateIdWithLabel } from '../core/ids.js';
 import { saveCandidate, generateCandidateIdWithLabel, listCandidates } from '../core/candidates.js';
@@ -265,8 +264,7 @@ function promoteCandidateToState(candidate, cwd) {
             break;
         }
     }
-    saveState(state, cwd);
-    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state));
+    persistState(state, cwd);
     return promotedItemId;
 }
 export function mapEventTypeToCandidateType(eventType) {

package/dist/commands/release-claim.js

@@ -1,5 +1,5 @@
 import { memoryExists } from '../core/io.js';
-import { memoryPath, writeFileAtomic } from '../core/io.js';
+import { memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
 import { loadClaim, listClaims, releaseClaim } from '../core/claims.js';
 import { generateMarkdown } from '../core/markdown.js';
 import { loadState, saveState } from '../core/state.js';
@@ -9,27 +9,30 @@ export function runReleaseClaim(id, options = {}) {
         process.exit(1);
     }
     try {
-        const existing = loadClaim(id, options.cwd);
-        const claim = releaseClaim(id, options.cwd);
-        let state = loadState(options.cwd);
-        if (existing.plan_id) {
-            const plan = state.plan_items.find((item) => item.id === existing.plan_id);
-            if (plan) {
-                const otherActiveClaims = listClaims(options.cwd).filter((item) => item.status === 'active' && item.plan_id === existing.plan_id);
-                if (options.planStatus) {
-                    plan.status = options.planStatus;
+        let claim = loadClaim(id, options.cwd);
+        withStoreLock(options.cwd, () => {
+            const existing = loadClaim(id, options.cwd);
+            claim = releaseClaim(id, options.cwd);
+            let state = loadState(options.cwd);
+            if (existing.plan_id) {
+                const plan = state.plan_items.find((item) => item.id === existing.plan_id);
+                if (plan) {
+                    const otherActiveClaims = listClaims(options.cwd).filter((item) => item.status === 'active' && item.plan_id === existing.plan_id);
+                    if (options.planStatus) {
+                        plan.status = options.planStatus;
+                    }
+                    else if (otherActiveClaims.length === 0 && plan.status === 'in_progress') {
+                        plan.status = 'todo';
+                    }
+                    if (otherActiveClaims.length === 0 && plan.assignee === existing.agent) {
+                        plan.assignee = undefined;
+                    }
+                    plan.updated_at = new Date().toISOString();
+                    saveState(state, options.cwd);
                 }
-                else if (otherActiveClaims.length === 0 && plan.status === 'in_progress') {
-                    plan.status = 'todo';
-                }
-                if (otherActiveClaims.length === 0 && plan.assignee === existing.agent) {
-                    plan.assignee = undefined;
-                }
-                plan.updated_at = new Date().toISOString();
-                saveState(state, options.cwd);
             }
-        }
-        writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+            writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+        });
         console.log(`✔ Claim [${id}] released (was: ${claim.agent} → ${claim.scope})`);
     }
     catch (e) {

package/dist/commands/release-claims.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { memoryExists, memoryPath, withStoreLock, writeFileAtomic } from '../core/io.js';
 import { listClaims, releaseClaim } from '../core/claims.js';
 import { generateMarkdown } from '../core/markdown.js';
 import { loadState, saveState } from '../core/state.js';
@@ -35,31 +35,32 @@ export function runReleaseClaims(options = {}) {
     const toRelease = claims.filter((c) => changedFiles.some((f) => scopeMatchesFile(c.scope, f)));
     if (toRelease.length === 0)
         process.exit(0);
-    let state = loadState(options.cwd);
     let released = 0;
-    for (const claim of toRelease) {
-        try {
-            releaseClaim(claim.id, options.cwd);
-            released++;
-            // Revert in_progress plan to todo if no more active claims
-            if (claim.plan_id) {
-                state = loadState(options.cwd);
-                const plan = state.plan_items.find((p) => p.id === claim.plan_id);
-                if (plan) {
-                    const remaining = listClaims(options.cwd).filter((c) => c.status === 'active' && c.plan_id === claim.plan_id);
-                    if (remaining.length === 0 && plan.status === 'in_progress') {
-                        plan.status = 'todo';
-                        plan.updated_at = new Date().toISOString();
-                        saveState(state, options.cwd);
+    withStoreLock(options.cwd, () => {
+        let state = loadState(options.cwd);
+        for (const claim of toRelease) {
+            try {
+                releaseClaim(claim.id, options.cwd);
+                released++;
+                if (claim.plan_id) {
+                    state = loadState(options.cwd);
+                    const plan = state.plan_items.find((p) => p.id === claim.plan_id);
+                    if (plan) {
+                        const remaining = listClaims(options.cwd).filter((c) => c.status === 'active' && c.plan_id === claim.plan_id);
+                        if (remaining.length === 0 && plan.status === 'in_progress') {
+                            plan.status = 'todo';
+                            plan.updated_at = new Date().toISOString();
+                            saveState(state, options.cwd);
+                        }
                     }
                 }
+                console.log(`✔ Auto-released claim [${claim.id}]: ${claim.scope}`);
             }
-            console.log(`✔ Auto-released claim [${claim.id}]: ${claim.scope}`);
+            catch { /* skip individual failures */ }
         }
-        catch { /* skip individual failures */ }
-    }
-    state = loadState(options.cwd);
-    writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+        state = loadState(options.cwd);
+        writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+    });
     if (released > 0) {
         console.log(`brainclaw: ${released} claim(s) auto-released after merge.`);
     }

package/dist/commands/rollback.js

@@ -1,6 +1,6 @@
 import { memoryExists } from '../core/io.js';
 import { readAuditLog } from '../core/audit.js';
-import { loadState, saveState } from '../core/state.js';
+import { loadState, persistState } from '../core/state.js';
 import { loadCandidate, saveCandidate } from '../core/candidates.js';
 import { appendAuditEntry } from '../core/audit.js';
 import { buildOperationalIdentity } from '../core/identity.js';
@@ -128,7 +128,7 @@ function applyRollback(entry, actorName, options) {
                     state.known_traps.push(before);
                 }
             }
-            saveState(state);
+            persistState(state);
         }
         else {
             return { ok: false, message: `Rollback not supported for item_type '${item_type}'.` };

package/dist/commands/tool.js

@@ -1,7 +1,6 @@
-import { loadState, saveState } from '../core/state.js';
+import { loadState, persistState } from '../core/state.js';
 import { resolveCurrentAgentName } from '../core/agent-registry.js';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { memoryExists } from '../core/io.js';
 import { generateIdWithLabel, nowISO } from '../core/ids.js';
 import { loadConfig } from '../core/config.js';
 import { scanText } from '../core/security.js';
@@ -89,8 +88,7 @@ function runToolAdd(name, description, options, cwd) {
     // For now, store as decision to avoid schema migration
     // Will migrate to separate tool storage in v0.16
     state.recent_decisions.push(entry);
-    saveState(state, cwd);
-    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state));
+    persistState(state, cwd);
     console.log(`✔ Tool added: [${id}] ${name}`);
     console.log('  (Stored in decisions for now; will move to dedicated registry in v0.16)');
 }

package/dist/commands/trap.js

@@ -1,11 +1,10 @@
-import { loadState, saveState } from '../core/state.js';
+import { loadState, persistState } from '../core/state.js';
 import { resolveCurrentAgentName } from '../core/agent-registry.js';
 import { resolveCurrentHostId } from '../core/host.js';
 import { loadConfig } from '../core/config.js';
-import { generateMarkdown } from '../core/markdown.js';
 import { nowISO } from '../core/ids.js';
 import { scanText } from '../core/security.js';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { memoryExists } from '../core/io.js';
 import { generateTrapIdWithLabel, saveOperationalTrap } from '../core/traps.js';
 import { validateCliInput, validateCliTtl } from '../core/input-validation.js';
 import { resolveTargetStore } from '../core/store-resolution.js';
@@ -49,8 +48,7 @@ export function runTrap(text, options = {}) {
     };
     if (visibility === 'shared') {
         state.known_traps.push(entry);
-        saveState(state, cwd);
-        writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+        persistState(state, cwd);
     }
     else {
         saveOperationalTrap(entry, cwd);

package/dist/commands/update-handoff.js

@@ -1,6 +1,5 @@
-import { loadState, saveState } from '../core/state.js';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { loadState, persistState } from '../core/state.js';
+import { memoryExists } from '../core/io.js';
 export function runUpdateHandoff(id, options = {}) {
     if (!memoryExists()) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
@@ -16,8 +15,7 @@ export function runUpdateHandoff(id, options = {}) {
         handoff.status = options.status;
     if (options.to !== undefined)
         handoff.to = options.to;
-    saveState(state);
-    writeFileAtomic(memoryPath('project.md'), generateMarkdown(state));
+    persistState(state);
     console.log(`✔ Handoff updated: [${handoff.id}] ${handoff.from} → ${handoff.to} (${handoff.status})`);
 }
 //# sourceMappingURL=update-handoff.js.map

package/dist/commands/update-plan.js

@@ -1,6 +1,5 @@
-import { loadState, saveState } from '../core/state.js';
-import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
-import { generateMarkdown } from '../core/markdown.js';
+import { loadState, persistState } from '../core/state.js';
+import { memoryExists } from '../core/io.js';
 import { nowISO } from '../core/ids.js';
 export function runUpdatePlan(id, options = {}) {
     if (!memoryExists(options.cwd)) {
@@ -30,8 +29,7 @@ export function runUpdatePlan(id, options = {}) {
     if (options.actualEffort)
         plan.actual_effort = options.actualEffort;
     plan.updated_at = timestamp;
-    saveState(state, options.cwd);
-    writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+    persistState(state, options.cwd);
     console.log(`✔ Plan item updated: [${plan.id}] ${plan.text}`);
 }
 //# sourceMappingURL=update-plan.js.map

package/dist/commands/upgrade.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { ensureMemoryDir, memoryDir, memoryExists } from '../core/io.js';
-import { loadState, saveState } from '../core/state.js';
+import { loadState, persistState } from '../core/state.js';
 import { scanMigrationStatus } from '../core/migration.js';
 import { commitMemoryChange, initMemoryRepo } from '../core/memory-git.js';
 import { BRAINCLAW_SECTION_END, BRAINCLAW_SECTION_START, buildBrainclawSection, buildClaudeCodeCommandText, ensureClaudeCodeCommand, hasBrainclawSection, } from '../core/agent-files.js';
@@ -114,7 +114,7 @@ export function runUpgrade(options = {}) {
     // Execute schema migrations by re-saving state (loadState auto-migrates via Zod parse)
     if (outdated.length > 0) {
         const state = loadState(cwd);
-        saveState(state, cwd);
+        persistState(state, cwd);
     }
     const refreshedAgentFiles = refreshManagedWorkspaceAgentFiles(cwd);
     // Clean up empty legacy directories (recursively removes empty subdirs first)

package/dist/core/audit.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { memoryDir } from './io.js';
+import { memoryDir, withStoreLock } from './io.js';
 import { nowISO } from './ids.js';
 import { logger } from './logger.js';
 import { appendEvent } from './event-log.js';
@@ -23,31 +23,31 @@ function auditLogPath(cwd) {
 }
 export function appendAuditEntry(entry, cwd) {
     try {
-        const full = {
-            timestamp: nowISO(),
-            actor: entry.actor,
-            action: entry.action,
-            item_id: entry.item_id,
-            item_type: entry.item_type,
-            before: entry.before,
-            after: entry.after,
-            actor_id: entry.actor_id,
-            reason: entry.reason,
-        };
-        // Remove undefined fields for compactness
-        const line = JSON.stringify(Object.fromEntries(Object.entries(full).filter(([, v]) => v !== undefined)));
-        fs.appendFileSync(auditLogPath(cwd), line + '\n', 'utf-8');
-        // Mirror to structured event log
-        const eventAction = AUDIT_TO_EVENT_ACTION[entry.action];
-        if (eventAction) {
-            appendEvent({
-                action: eventAction,
-                item_type: entry.item_type ?? 'state',
+        withStoreLock(cwd, () => {
+            const full = {
+                timestamp: nowISO(),
+                actor: entry.actor,
+                action: entry.action,
                 item_id: entry.item_id,
-                agent: entry.actor,
-                agent_id: entry.actor_id,
-            }, cwd);
-        }
+                item_type: entry.item_type,
+                before: entry.before,
+                after: entry.after,
+                actor_id: entry.actor_id,
+                reason: entry.reason,
+            };
+            const line = JSON.stringify(Object.fromEntries(Object.entries(full).filter(([, v]) => v !== undefined)));
+            fs.appendFileSync(auditLogPath(cwd), line + '\n', 'utf-8');
+            const eventAction = AUDIT_TO_EVENT_ACTION[entry.action];
+            if (eventAction) {
+                appendEvent({
+                    action: eventAction,
+                    item_type: entry.item_type ?? 'state',
+                    item_id: entry.item_id,
+                    agent: entry.actor,
+                    agent_id: entry.actor_id,
+                }, cwd);
+            }
+        });
     }
     catch (err) {
         logger.debug('Failed to write audit log entry:', err);