brainclaw 0.19.6 → 0.19.7

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);

package/dist/core/candidates.js

@@ -2,7 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { CandidateSchema } from './schema.js';
-import { resolveEntityDir } from './io.js';
+import { resolveEntityDir, withStoreLock } from './io.js';
 import { nowISO, getNextShortLabel } from './ids.js';
 import { JsonStore } from './json-store.js';
 function inboxDir(cwd, mode = 'read') {
@@ -35,8 +35,10 @@ function candidateStore(dest = 'pending', cwd) {
     });
 }
 export function saveCandidate(candidate, cwd) {
-    ensureInboxDirs(cwd);
-    candidateStore('pending', cwd).save(CandidateSchema.parse(candidate));
+    withStoreLock(cwd, () => {
+        ensureInboxDirs(cwd);
+        candidateStore('pending', cwd).save(CandidateSchema.parse(candidate));
+    });
 }
 export function loadCandidate(id, cwd) {
     return candidateStore('pending', cwd).load(id);
@@ -49,9 +51,11 @@ export function listCandidates(status, cwd) {
     return status ? candidates.filter((candidate) => candidate.status === status) : candidates;
 }
 export function archiveCandidate(candidate, dest, cwd) {
-    ensureInboxDirs(cwd);
-    candidateStore(dest, cwd).save(CandidateSchema.parse(candidate));
-    candidateStore('pending', cwd).delete(candidate.id);
+    withStoreLock(cwd, () => {
+        ensureInboxDirs(cwd);
+        candidateStore(dest, cwd).save(CandidateSchema.parse(candidate));
+        candidateStore('pending', cwd).delete(candidate.id);
+    });
 }
 export function listArchivedCandidates(dest, cwd) {
     return candidateStore(dest, cwd).list();

package/dist/core/claims.js

@@ -1,7 +1,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import { ClaimSchema } from './schema.js';
-import { resolveEntityDir } from './io.js';
+import { resolveEntityDir, withStoreLock } from './io.js';
 import { nowISO } from './ids.js';
 import { JsonStore } from './json-store.js';
 function claimsDir(cwd, mode = 'read') {
@@ -22,14 +22,16 @@ function claimStore(cwd) {
     });
 }
 export function saveClaim(claim, cwd) {
-    ensureClaimsDir(cwd);
-    const writeStore = new JsonStore({
-        dirPath: claimsDir(cwd, 'write'),
-        documentType: 'claim',
-        getId: (c) => c.id,
-        sort: (a, b) => a.created_at.localeCompare(b.created_at),
+    withStoreLock(cwd, () => {
+        ensureClaimsDir(cwd);
+        const writeStore = new JsonStore({
+            dirPath: claimsDir(cwd, 'write'),
+            documentType: 'claim',
+            getId: (c) => c.id,
+            sort: (a, b) => a.created_at.localeCompare(b.created_at),
+        });
+        writeStore.save(ClaimSchema.parse(claim));
     });
-    writeStore.save(ClaimSchema.parse(claim));
 }
 export function loadClaim(id, cwd) {
     return claimStore(cwd).load(id);

package/dist/core/coordination.js

@@ -5,7 +5,7 @@ import { listClaims } from './claims.js';
 import { inferProjectFromTarget, loadInstructions, resolveInstructions } from './instructions.js';
 import { buildReputationSummary, findAgentReputationSummary } from './reputation.js';
 import { listRuntimeNotes } from './runtime.js';
-import { loadState, saveState } from './state.js';
+import { loadState, persistState } from './state.js';
 export function buildCoordinationSnapshot(options = {}) {
     const config = loadConfig(options.cwd);
     const state = loadState(options.cwd);
@@ -58,7 +58,7 @@ export function buildCoordinationSnapshot(options = {}) {
             }
         }
         if (changed)
-            saveState(state, options.cwd);
+            persistState(state, options.cwd);
     }
     return {
         project_id: config.project_id,

package/dist/core/instructions.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { resolveEntityDir } from './io.js';
+import { resolveEntityDir, withStoreLock } from './io.js';
 import { generateId } from './ids.js';
 import { InstructionEntrySchema } from './schema.js';
 import { JsonStore } from './json-store.js';
@@ -19,7 +19,9 @@ export function loadInstructions(cwd) {
     return instructionStore(cwd).list();
 }
 export function saveInstruction(entry, cwd) {
-    instructionStore(cwd, 'write').save(InstructionEntrySchema.parse(entry));
+    withStoreLock(cwd, () => {
+        instructionStore(cwd, 'write').save(InstructionEntrySchema.parse(entry));
+    });
 }
 export function createInstruction(text, options, cwd) {
     const entries = loadInstructions(cwd);

package/dist/core/io.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { withLock, cleanStaleLocks } from './lock.js';
 export const MEMORY_DIR = '.brainclaw';
+const STORE_LOCK_BASENAME = '.store-mutation';
 const RETRYABLE_RENAME_ERROR_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
 const DEFAULT_RENAME_RETRY_ATTEMPTS = 6;
 const DEFAULT_RENAME_RETRY_DELAY_MS = 25;
@@ -72,6 +73,9 @@ export function memoryDir(cwd = process.cwd(), preferredDirName) {
 export function memoryPath(filename, cwd, preferredDirName) {
     return path.join(memoryDir(cwd, preferredDirName), filename);
 }
+export function storeLockPath(cwd, preferredDirName) {
+    return memoryPath(STORE_LOCK_BASENAME, cwd, preferredDirName);
+}
 export function memoryExists(cwd, preferredDirName) {
     return fs.existsSync(memoryDir(cwd, preferredDirName));
 }
@@ -95,6 +99,10 @@ export function ensureMemoryDir(cwd, preferredDirName) {
         }
     }
 }
+export function withStoreLock(cwd = process.cwd(), fn, preferredDirName) {
+    ensureMemoryDir(cwd, preferredDirName);
+    return withLock(storeLockPath(cwd, preferredDirName), fn);
+}
 /** Check if a path is a file, or a directory with at least one entry. */
 function hasContent(p) {
     try {

package/dist/core/lock.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 const DEFAULT_TIMEOUT_MS = 2000;
 const LOCK_RETRY_INTERVAL_MS = 50;
 const LOCK_EXPIRY_MS = 5000;
+const heldLocks = new Map();
 function lockFilePath(targetPath) {
     return targetPath + '.lock';
 }
@@ -59,22 +60,37 @@ function tryBreakLock(lockPath) {
 }
 export function acquireLock(targetPath, timeoutMs = DEFAULT_TIMEOUT_MS) {
     const lockPath = lockFilePath(targetPath);
+    const heldCount = heldLocks.get(lockPath);
+    if (heldCount) {
+        heldLocks.set(lockPath, heldCount + 1);
+        return true;
+    }
     const deadline = Date.now() + timeoutMs;
     const dir = path.dirname(lockPath);
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
     while (Date.now() < deadline) {
-        if (tryCreateLock(lockPath))
+        if (tryCreateLock(lockPath)) {
+            heldLocks.set(lockPath, 1);
             return true;
-        if (tryBreakLock(lockPath))
+        }
+        if (tryBreakLock(lockPath)) {
+            heldLocks.set(lockPath, 1);
             return true;
+        }
         syncSleep(Math.min(LOCK_RETRY_INTERVAL_MS, deadline - Date.now()));
     }
     return false;
 }
 export function releaseLock(targetPath) {
     const lockPath = lockFilePath(targetPath);
+    const heldCount = heldLocks.get(lockPath);
+    if (heldCount && heldCount > 1) {
+        heldLocks.set(lockPath, heldCount - 1);
+        return;
+    }
+    heldLocks.delete(lockPath);
     try {
         if (fs.existsSync(lockPath)) {
             fs.unlinkSync(lockPath);

package/dist/core/runtime.js

@@ -2,7 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { resolveCurrentHostId, sanitizeHostId } from './host.js';
-import { resolveEntityDir } from './io.js';
+import { resolveEntityDir, withStoreLock } from './io.js';
 import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
 import { RuntimeNoteSchema } from './schema.js';
 import { commitMemoryChange } from './memory-git.js';
@@ -40,13 +40,15 @@ export function saveRuntimeNote(note, cwd) {
     const persistedNote = visibility === 'shared'
         ? { ...note, visibility, host_id: hostId }
         : { ...note, visibility, host_id: hostId };
-    ensureRuntimeDir(note.agent, cwd, visibility, hostId);
-    const filepath = visibility === 'shared'
-        ? path.join(sharedAgentDir(note.agent, cwd, 'write'), `${note.id}.json`)
-        : path.join(hostAgentDir(visibility, hostId, note.agent, cwd, 'write'), `${note.id}.json`);
-    saveVersionedJsonFile('runtime_note', filepath, RuntimeNoteSchema.parse(persistedNote));
-    appendEvent({ action: 'create', item_type: 'runtime_note', item_id: note.id, agent: note.agent, agent_id: note.agent_id }, cwd);
-    commitMemoryChange(`runtime note: ${note.note_type ?? 'note'} (${note.agent})`, cwd);
+    withStoreLock(cwd, () => {
+        ensureRuntimeDir(note.agent, cwd, visibility, hostId);
+        const filepath = visibility === 'shared'
+            ? path.join(sharedAgentDir(note.agent, cwd, 'write'), `${note.id}.json`)
+            : path.join(hostAgentDir(visibility, hostId, note.agent, cwd, 'write'), `${note.id}.json`);
+        saveVersionedJsonFile('runtime_note', filepath, RuntimeNoteSchema.parse(persistedNote));
+        appendEvent({ action: 'create', item_type: 'runtime_note', item_id: note.id, agent: note.agent, agent_id: note.agent_id }, cwd);
+        commitMemoryChange(`runtime note: ${note.note_type ?? 'note'} (${note.agent})`, cwd);
+    });
 }
 export function runtimeNotePath(note, cwd) {
     const visibility = note.visibility ?? 'shared';
@@ -56,12 +58,14 @@ export function runtimeNotePath(note, cwd) {
         : path.join(hostAgentDir(visibility, hostId, note.agent, cwd), `${note.id}.json`);
 }
 export function deleteRuntimeNote(note, cwd) {
-    const filepath = runtimeNotePath(note, cwd);
-    if (!fs.existsSync(filepath)) {
-        return false;
-    }
-    fs.unlinkSync(filepath);
-    return true;
+    return withStoreLock(cwd, () => {
+        const filepath = runtimeNotePath(note, cwd);
+        if (!fs.existsSync(filepath)) {
+            return false;
+        }
+        fs.unlinkSync(filepath);
+        return true;
+    });
 }
 function readAgentNotes(dir, agent) {
     if (!fs.existsSync(dir))