brainclaw 0.19.2

package/dist/core/ids.js

@@ -0,0 +1,56 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { withLock } from './lock.js';
+const PREFIXES = {
+    active_constraints: 'cst',
+    bootstrap_seeds: 'bsd',
+    recent_decisions: 'dec',
+    known_traps: 'trp',
+    open_handoffs: 'hnd',
+    plan_items: 'pln',
+    plan_steps: 'stp',
+    instruction_entries: 'ins',
+};
+const ID_COUNTER_FILE = '.id-counter.json';
+function counterPath(cwd) {
+    return path.join(cwd ?? process.cwd(), '.brainclaw', ID_COUNTER_FILE);
+}
+/** Generate a concurrence-safe prefixed ID using 4 random bytes. */
+export function generateId(section) {
+    const prefix = PREFIXES[section] ?? section.slice(0, 3);
+    const rand = crypto.randomBytes(4).toString('hex');
+    return `${prefix}_${rand}`;
+}
+/**
+ * Atomically increment the per-prefix counter and return the next short label.
+ * Best-effort: if the counter file is unavailable the call still succeeds.
+ */
+export function getNextShortLabel(prefix, cwd) {
+    const fp = counterPath(cwd);
+    return withLock(fp, () => {
+        let counter = {};
+        try {
+            counter = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+        }
+        catch { /* first use or missing file */ }
+        const next = (counter[prefix] ?? 0) + 1;
+        counter[prefix] = next;
+        fs.writeFileSync(fp, JSON.stringify(counter), 'utf-8');
+        return `${prefix}#${next}`;
+    });
+}
+/**
+ * Generate both a concurrence-safe hash ID and a human-readable short label.
+ * The hash ID is the canonical storage key; the short label is for display and aliased lookups.
+ */
+export function generateIdWithLabel(section, cwd) {
+    const id = generateId(section);
+    const prefix = PREFIXES[section] ?? section.slice(0, 3);
+    const short_label = getNextShortLabel(prefix, cwd);
+    return { id, short_label };
+}
+export function nowISO() {
+    return new Date().toISOString();
+}
+//# sourceMappingURL=ids.js.map

package/dist/core/input-validation.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export const TEXT_MAX_LENGTH = 2000;
+export const TAG_MAX_LENGTH = 50;
+export const TAG_MAX_COUNT = 20;
+export const TextInputSchema = z.string().min(1, 'Text cannot be empty').max(TEXT_MAX_LENGTH, `Text cannot exceed ${TEXT_MAX_LENGTH} characters`);
+export const TagArraySchema = z
+    .array(z.string().min(1, 'Tag cannot be empty').max(TAG_MAX_LENGTH, `Tag cannot exceed ${TAG_MAX_LENGTH} characters`))
+    .max(TAG_MAX_COUNT, `Cannot have more than ${TAG_MAX_COUNT} tags`);
+export const TTL_PATTERN = /^(\d+)([mhd])$/;
+export const TtlSchema = z
+    .string()
+    .regex(TTL_PATTERN, 'Invalid TTL format. Use <number><unit> where unit is m (minutes), h (hours), or d (days). Example: 30m, 2h, 7d');
+function formatZodError(error, field) {
+    return error.errors.map((e) => ({ field, message: e.message }));
+}
+/**
+ * Validate CLI mutation inputs. On failure: prints error and calls process.exit(1).
+ */
+export function validateCliInput(text, tags) {
+    const errors = [];
+    const textResult = TextInputSchema.safeParse(text);
+    if (!textResult.success) {
+        errors.push(...formatZodError(textResult.error, 'text'));
+    }
+    if (tags !== undefined && tags.length > 0) {
+        const tagsResult = TagArraySchema.safeParse(tags);
+        if (!tagsResult.success) {
+            errors.push(...formatZodError(tagsResult.error, 'tags'));
+        }
+    }
+    if (errors.length > 0) {
+        for (const e of errors) {
+            console.error(`Error: ${e.message}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Validate CLI TTL argument. On failure: prints error and calls process.exit(1).
+ */
+export function validateCliTtl(ttl) {
+    const result = TtlSchema.safeParse(ttl);
+    if (!result.success) {
+        console.error(`Error: ${result.error.errors[0]?.message ?? 'Invalid TTL'}`);
+        process.exit(1);
+    }
+}
+/**
+ * Validate MCP mutation inputs. Returns { ok: true } or { ok: false, errors }.
+ * Never calls process.exit — callers must handle the error response.
+ */
+export function validateMcpInput(text, tags) {
+    const errors = [];
+    const textResult = TextInputSchema.safeParse(text);
+    if (!textResult.success) {
+        errors.push(...formatZodError(textResult.error, 'text'));
+    }
+    if (tags !== undefined && tags.length > 0) {
+        const tagsResult = TagArraySchema.safeParse(tags);
+        if (!tagsResult.success) {
+            errors.push(...formatZodError(tagsResult.error, 'tags'));
+        }
+    }
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return { ok: true };
+}
+/**
+ * Validate a non-empty string field for MCP (scope, description, from, to).
+ */
+export function validateMcpField(value, fieldName) {
+    if (!value.trim()) {
+        return { ok: false, message: `${fieldName} cannot be empty` };
+    }
+    if (value.length > TEXT_MAX_LENGTH) {
+        return { ok: false, message: `${fieldName} cannot exceed ${TEXT_MAX_LENGTH} characters` };
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=input-validation.js.map

package/dist/core/instructions.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import { resolveEntityDir } from './io.js';
+import { generateId } from './ids.js';
+import { InstructionEntrySchema } from './schema.js';
+import { JsonStore } from './json-store.js';
+function instructionStore(cwd, mode = 'read') {
+    return new JsonStore({
+        dirPath: resolveEntityDir('instructions', cwd ?? process.cwd(), mode),
+        documentType: 'instruction',
+        getId: (entry) => entry.id,
+        sort: (a, b) => a.created_at.localeCompare(b.created_at) || a.id.localeCompare(b.id),
+    });
+}
+export function loadInstructions(cwd) {
+    const dir = resolveEntityDir('instructions', cwd ?? process.cwd(), 'read');
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    return instructionStore(cwd).list();
+}
+export function saveInstruction(entry, cwd) {
+    instructionStore(cwd, 'write').save(InstructionEntrySchema.parse(entry));
+}
+export function createInstruction(text, options, cwd) {
+    const entries = loadInstructions(cwd);
+    const timestamp = new Date().toISOString();
+    const entry = {
+        schema_version: 2,
+        id: generateId('instruction_entries'),
+        layer: options.layer,
+        scope: options.scope,
+        text,
+        created_at: timestamp,
+        updated_at: timestamp,
+        author: options.author,
+        tags: options.tags ?? [],
+        active: true,
+        supersedes: options.supersedes,
+    };
+    saveInstruction(entry, cwd);
+    return entry;
+}
+export function resolveInstructions(entries, options = {}) {
+    const superseded = new Set(entries
+        .filter((entry) => entry.active && entry.supersedes)
+        .map((entry) => entry.supersedes));
+    const active = entries.filter((entry) => entry.active && !superseded.has(entry.id));
+    const scoped = active.filter((entry) => {
+        if (entry.layer === 'global') {
+            return true;
+        }
+        if (entry.layer === 'project') {
+            return entry.scope === options.project;
+        }
+        return entry.scope === options.agent;
+    });
+    const latestByScope = new Map();
+    for (const entry of scoped) {
+        const key = `${entry.layer}:${entry.scope ?? '*'}`;
+        const current = latestByScope.get(key);
+        if (!current || current.updated_at.localeCompare(entry.updated_at) <= 0) {
+            latestByScope.set(key, entry);
+        }
+    }
+    return [...latestByScope.values()].sort((a, b) => {
+        const rank = layerOrder(a.layer) - layerOrder(b.layer);
+        if (rank !== 0)
+            return rank;
+        return a.updated_at.localeCompare(b.updated_at) || a.id.localeCompare(b.id);
+    });
+}
+export function inferProjectFromTarget(target, config) {
+    const trimmed = target?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = trimmed.replace(/\\/g, '/');
+    const known = config.projects?.known ?? [];
+    if (known.includes(normalized)) {
+        return normalized;
+    }
+    return known.find((project) => normalized === project || normalized.startsWith(`${project}/`));
+}
+export function findInstructionConflicts(entries) {
+    const superseded = new Set(entries
+        .filter((entry) => entry.active && entry.supersedes)
+        .map((entry) => entry.supersedes));
+    const groups = new Map();
+    for (const entry of entries.filter((item) => item.active && !superseded.has(item.id))) {
+        const key = `${entry.layer}:${entry.scope ?? ''}`;
+        const bucket = groups.get(key) ?? [];
+        bucket.push(entry);
+        groups.set(key, bucket);
+    }
+    const conflicts = [];
+    for (const group of groups.values()) {
+        if (group.length > 1) {
+            conflicts.push({
+                layer: group[0].layer,
+                scope: group[0].scope,
+                ids: group.map((entry) => entry.id),
+            });
+        }
+    }
+    return conflicts;
+}
+function layerOrder(layer) {
+    switch (layer) {
+        case 'global':
+            return 0;
+        case 'project':
+            return 1;
+        case 'agent':
+            return 2;
+    }
+}
+//# sourceMappingURL=instructions.js.map

package/dist/core/io.js

@@ -0,0 +1,191 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { withLock, cleanStaleLocks } from './lock.js';
+export const MEMORY_DIR = '.brainclaw';
+const RETRYABLE_RENAME_ERROR_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
+const DEFAULT_RENAME_RETRY_ATTEMPTS = 6;
+const DEFAULT_RENAME_RETRY_DELAY_MS = 25;
+/**
+ * Entity-aligned directory mapping.
+ * Maps legacy flat directory names to their entity-partitioned paths.
+ * Used by resolveEntityDir() for backward-compatible reads and forward writes.
+ */
+const ENTITY_DIR_MAP = {
+    // memory/ — Project entity: durable knowledge
+    'constraints': 'memory/constraints',
+    'decisions': 'memory/decisions',
+    'traps': 'memory/traps',
+    'traps-hosts': 'memory/traps-hosts',
+    'traps-private': 'memory/traps-private',
+    'instructions': 'memory/instructions',
+    // coordination/ — Agent↔Project: active work state
+    'plans': 'coordination/plans',
+    'claims': 'coordination/claims',
+    'handoffs': 'coordination/handoffs',
+    'sessions': 'coordination/sessions',
+    'inbox': 'coordination/inbox',
+    'inbox/accepted': 'coordination/inbox/accepted',
+    'inbox/rejected': 'coordination/inbox/rejected',
+    'runtime': 'coordination/runtime',
+    'runtime-hosts': 'coordination/runtime-hosts',
+    'runtime-private': 'coordination/runtime-private',
+    // discovery/ — Project entity: what's available
+    'bootstrap': 'discovery/bootstrap',
+    'bootstrap/seeds': 'discovery/bootstrap/seeds',
+    // agents/ — stays at top level (already entity-aligned)
+    'agents': 'agents',
+};
+/**
+ * Resolve a subdirectory path with entity-model awareness.
+ *
+ * For READS: tries the new entity path first, falls back to legacy flat path.
+ * For WRITES: always uses the new entity path (creates parent dirs as needed).
+ *
+ * @param subdir Legacy subdirectory name (e.g. 'constraints', 'claims')
+ * @param cwd Project root
+ * @param mode 'read' checks both paths, 'write' uses new path only
+ */
+export function resolveEntityDir(subdir, cwd = process.cwd(), mode = 'read', preferredDirName) {
+    const base = memoryDir(cwd, preferredDirName);
+    const newPath = ENTITY_DIR_MAP[subdir];
+    if (!newPath) {
+        // Unknown subdirectory — use as-is
+        return path.join(base, subdir);
+    }
+    const entityPath = path.join(base, newPath);
+    const legacyPath = path.join(base, subdir);
+    if (mode === 'write') {
+        // Always write to new entity path
+        return entityPath;
+    }
+    // Read: prefer entity path if it has content, fall back to legacy
+    if (fs.existsSync(entityPath) && hasContent(entityPath))
+        return entityPath;
+    if (fs.existsSync(legacyPath))
+        return legacyPath;
+    // Neither exists — return entity path (caller will handle missing dir)
+    return entityPath;
+}
+export function memoryDir(cwd = process.cwd(), preferredDirName) {
+    return path.join(cwd, preferredDirName ?? MEMORY_DIR);
+}
+export function memoryPath(filename, cwd, preferredDirName) {
+    return path.join(memoryDir(cwd, preferredDirName), filename);
+}
+export function memoryExists(cwd, preferredDirName) {
+    return fs.existsSync(memoryDir(cwd, preferredDirName));
+}
+export function ensureMemoryDir(cwd, preferredDirName) {
+    const dir = memoryDir(cwd, preferredDirName);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Ensure entity-aligned subdirectories exist
+    const entityDirs = [
+        'memory/constraints', 'memory/decisions', 'memory/traps', 'memory/instructions',
+        'coordination/plans', 'coordination/claims', 'coordination/handoffs', 'coordination/sessions',
+        'coordination/inbox',
+        'discovery',
+        'agents',
+    ];
+    for (const subdir of entityDirs) {
+        const p = path.join(dir, subdir);
+        if (!fs.existsSync(p)) {
+            fs.mkdirSync(p, { recursive: true });
+        }
+    }
+}
+/** Check if a path is a file, or a directory with at least one entry. */
+function hasContent(p) {
+    try {
+        const stat = fs.statSync(p);
+        if (stat.isFile())
+            return true;
+        if (stat.isDirectory())
+            return fs.readdirSync(p).length > 0;
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export function readFileSync(filepath) {
+    return fs.readFileSync(filepath, 'utf-8');
+}
+function syncSleep(ms) {
+    if (ms <= 0)
+        return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function makeTempPath(filepath) {
+    const dir = path.dirname(filepath);
+    const base = path.basename(filepath);
+    const unique = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 10)}`;
+    return path.join(dir, `.${base}.${unique}.tmp`);
+}
+function isRetryableRenameError(error) {
+    if (!(error instanceof Error) || !('code' in error))
+        return false;
+    const code = error.code;
+    return code ? RETRYABLE_RENAME_ERROR_CODES.has(code) : false;
+}
+function renameWithRetry(tmpPath, targetPath, options) {
+    const { fsImpl, maxRenameAttempts, retryDelayMs, sleep } = options;
+    for (let attempt = 0; attempt < maxRenameAttempts; attempt++) {
+        try {
+            fsImpl.renameSync(tmpPath, targetPath);
+            return;
+        }
+        catch (error) {
+            if (!isRetryableRenameError(error) || attempt === maxRenameAttempts - 1) {
+                throw error;
+            }
+            sleep(retryDelayMs * (attempt + 1));
+        }
+    }
+}
+/** Atomic write with advisory file locking: acquire lock, write to a temp file, then rename. */
+export function writeFileAtomic(filepath, content, options = {}) {
+    withLock(filepath, () => {
+        const fsImpl = options.fsImpl ?? fs;
+        const tmp = makeTempPath(filepath);
+        fsImpl.writeFileSync(tmp, content, 'utf-8');
+        renameWithRetry(tmp, filepath, {
+            fsImpl,
+            maxRenameAttempts: options.maxRenameAttempts ?? DEFAULT_RENAME_RETRY_ATTEMPTS,
+            retryDelayMs: options.retryDelayMs ?? DEFAULT_RENAME_RETRY_DELAY_MS,
+            sleep: options.sleep ?? syncSleep,
+        });
+    });
+}
+/**
+ * Remove orphan .tmp and .lock files left by crashed processes.
+ * Call once at CLI startup. Returns count of removed files.
+ */
+export function cleanOrphanFiles(dirPath) {
+    let removed = 0;
+    if (!fs.existsSync(dirPath))
+        return 0;
+    // Clean .tmp files (residual from crashed writeFileAtomic)
+    try {
+        for (const entry of fs.readdirSync(dirPath)) {
+            const full = path.join(dirPath, entry);
+            if (entry.endsWith('.tmp') && fs.statSync(full).isFile()) {
+                try {
+                    fs.unlinkSync(full);
+                    removed++;
+                }
+                catch { /* already gone */ }
+            }
+            // Recurse into subdirectories
+            if (fs.statSync(full).isDirectory()) {
+                removed += cleanOrphanFiles(full);
+            }
+        }
+    }
+    catch { /* dir unreadable — skip */ }
+    // Clean stale .lock files
+    removed += cleanStaleLocks(dirPath);
+    return removed;
+}
+//# sourceMappingURL=io.js.map

package/dist/core/json-store.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from './logger.js';
+import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
+export class JsonStore {
+    dirPath;
+    documentType;
+    getId;
+    sort;
+    constructor(options) {
+        this.dirPath = options.dirPath;
+        this.documentType = options.documentType;
+        this.getId = options.getId;
+        this.sort = options.sort;
+    }
+    list() {
+        if (!fs.existsSync(this.dirPath)) {
+            return [];
+        }
+        const items = [];
+        for (const file of fs.readdirSync(this.dirPath).filter((entry) => entry.endsWith('.json')).sort()) {
+            try {
+                items.push(this.load(file.replace(/\.json$/i, '')));
+            }
+            catch (error) {
+                logger.debug(`Skipping malformed ${this.documentType} file:`, file, error);
+            }
+        }
+        if (this.sort) {
+            items.sort(this.sort);
+        }
+        return items;
+    }
+    load(id) {
+        const filepath = this.pathFor(id);
+        if (!fs.existsSync(filepath)) {
+            throw new Error(`${this.documentType} '${id}' not found`);
+        }
+        return loadVersionedJsonFile(this.documentType, filepath).document;
+    }
+    save(item) {
+        this.ensureDir();
+        saveVersionedJsonFile(this.documentType, this.pathFor(this.getId(item)), item);
+    }
+    delete(id) {
+        const filepath = this.pathFor(id);
+        if (fs.existsSync(filepath)) {
+            fs.unlinkSync(filepath);
+        }
+    }
+    exists(id) {
+        return fs.existsSync(this.pathFor(id));
+    }
+    ensureDir() {
+        if (!fs.existsSync(this.dirPath)) {
+            fs.mkdirSync(this.dirPath, { recursive: true });
+        }
+    }
+    pathFor(id) {
+        return path.join(this.dirPath, `${id}.json`);
+    }
+}
+//# sourceMappingURL=json-store.js.map

package/dist/core/lifecycle.js

@@ -0,0 +1,45 @@
+import { loadState } from './state.js';
+import { loadInstructions } from './instructions.js';
+/**
+ * Returns all memory items tagged with the given trigger tag.
+ * Supports: traps, constraints, decisions, instructions.
+ *
+ * Convention: trigger tags take the form "trigger:<event>"
+ * e.g. "trigger:post-claim", "trigger:pre-session-end", "trigger:post-session-start"
+ */
+export function getTriggeredItems(tag, cwd) {
+    const items = [];
+    const state = loadState(cwd);
+    for (const trap of state.known_traps) {
+        if (trap.tags.includes(tag)) {
+            items.push({ type: 'trap', id: trap.id, text: trap.text });
+        }
+    }
+    for (const constraint of state.active_constraints) {
+        if (constraint.tags.includes(tag)) {
+            items.push({ type: 'constraint', id: constraint.id, text: constraint.text });
+        }
+    }
+    for (const decision of state.recent_decisions) {
+        if (decision.tags.includes(tag)) {
+            items.push({ type: 'decision', id: decision.id, text: decision.text });
+        }
+    }
+    for (const instruction of loadInstructions(cwd)) {
+        if (instruction.tags.includes(tag)) {
+            items.push({ type: 'instruction', id: instruction.id, text: instruction.text });
+        }
+    }
+    return items;
+}
+/**
+ * Renders triggered items as a text block for inclusion in MCP responses.
+ * Returns empty string if no items found.
+ */
+export function renderTriggeredItems(items) {
+    if (items.length === 0)
+        return '';
+    const lines = items.map((item) => `⚡ [${item.type}] ${item.text}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/core/lock.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const DEFAULT_TIMEOUT_MS = 2000;
+const LOCK_RETRY_INTERVAL_MS = 50;
+const LOCK_EXPIRY_MS = 5000;
+function lockFilePath(targetPath) {
+    return targetPath + '.lock';
+}
+function syncSleep(ms) {
+    if (ms <= 0)
+        return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readLockData(lockPath) {
+    try {
+        const raw = fs.readFileSync(lockPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function tryCreateLock(lockPath) {
+    const data = { pid: process.pid, timestamp: Date.now() };
+    try {
+        fs.writeFileSync(lockPath, JSON.stringify(data), { encoding: 'utf-8', flag: 'wx' });
+        return true;
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'EEXIST')
+            return false;
+        throw err;
+    }
+}
+function tryBreakLock(lockPath) {
+    const data = readLockData(lockPath);
+    if (!data)
+        return false;
+    const expired = Date.now() - data.timestamp > LOCK_EXPIRY_MS;
+    const ownerDead = !isProcessAlive(data.pid);
+    if (!expired && !ownerDead)
+        return false;
+    try {
+        fs.unlinkSync(lockPath);
+    }
+    catch {
+        return false;
+    }
+    return tryCreateLock(lockPath);
+}
+export function acquireLock(targetPath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const lockPath = lockFilePath(targetPath);
+    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))
+            return true;
+        if (tryBreakLock(lockPath))
+            return true;
+        syncSleep(Math.min(LOCK_RETRY_INTERVAL_MS, deadline - Date.now()));
+    }
+    return false;
+}
+export function releaseLock(targetPath) {
+    const lockPath = lockFilePath(targetPath);
+    try {
+        if (fs.existsSync(lockPath)) {
+            fs.unlinkSync(lockPath);
+        }
+    }
+    catch {
+        // Ignore errors during release
+    }
+}
+export function withLock(targetPath, fn, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const acquired = acquireLock(targetPath, timeoutMs);
+    if (!acquired) {
+        throw new Error(`Could not acquire lock on ${path.basename(targetPath)} after ${timeoutMs}ms`);
+    }
+    try {
+        return fn();
+    }
+    finally {
+        releaseLock(targetPath);
+    }
+}
+export function cleanStaleLocks(dirPath) {
+    let removed = 0;
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith('.lock'))
+            continue;
+        const lockPath = path.join(dirPath, entry);
+        const data = readLockData(lockPath);
+        if (!data)
+            continue;
+        const expired = Date.now() - data.timestamp > LOCK_EXPIRY_MS;
+        const ownerDead = !isProcessAlive(data.pid);
+        if (expired || ownerDead) {
+            try {
+                fs.unlinkSync(lockPath);
+                removed++;
+            }
+            catch {
+                // Another process may have already cleaned it
+            }
+        }
+    }
+    return removed;
+}
+//# sourceMappingURL=lock.js.map