brainclaw 0.19.2

package/dist/commands/pull.js

@@ -0,0 +1,25 @@
+import { memoryExists } from '../core/io.js';
+import { pullRemoteMemory } from '../core/sync-remote.js';
+export function runPull(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const result = pullRemoteMemory({ remote: options.remote });
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.success)
+            process.exit(1);
+        return;
+    }
+    if (result.success) {
+        console.log(`✔ ${result.message}`);
+        if (result.details)
+            console.log(result.details);
+    }
+    else {
+        console.error(`✗ ${result.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=pull.js.map

package/dist/commands/push.js

@@ -0,0 +1,28 @@
+import { memoryExists } from '../core/io.js';
+import { pushRemoteMemory } from '../core/sync-remote.js';
+export function runPush(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const result = pushRemoteMemory({
+        remote: options.remote,
+        message: options.message,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.success)
+            process.exit(1);
+        return;
+    }
+    if (result.success) {
+        console.log(`✔ ${result.message}`);
+        if (result.details)
+            console.log(result.details);
+    }
+    else {
+        console.error(`✗ ${result.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=push.js.map

package/dist/commands/rebuild.js

@@ -0,0 +1,14 @@
+import { loadState } from '../core/state.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+export function runRebuild() {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const state = loadState();
+    const md = generateMarkdown(state);
+    writeFileAtomic(memoryPath('project.md'), md);
+    console.log('✔ project.md rebuilt from canonical memory state');
+}
+//# sourceMappingURL=rebuild.js.map

package/dist/commands/reflect-runtime-note.js

@@ -0,0 +1,74 @@
+import { memoryExists } from '../core/io.js';
+import { findRuntimeNoteById } from '../core/runtime.js';
+import { createCandidateFromInput } from './reflect.js';
+export function runReflectRuntimeNote(id, text, options) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const note = findRuntimeNoteById(id, {
+        hostId: options.host,
+        includeAllHosts: options.allHosts,
+    });
+    if (!note) {
+        console.error(`Error: runtime note '${id}' not found in visible runtime memory.`);
+        process.exit(1);
+    }
+    const suggestions = suggestCandidateTypes(note.text, note.tags);
+    if (!options.type || options.suggest) {
+        if (options.json) {
+            console.log(JSON.stringify({ runtime_note: note, suggestions }, null, 2));
+        }
+        else {
+            console.log(`Promotion suggestions for runtime note [${note.id}] (${note.visibility}${note.host_id ? `:${note.host_id}` : ''}):`);
+            for (const suggestion of suggestions) {
+                console.log(`  - ${suggestion.type} (${suggestion.score}) ${suggestion.reason}`);
+            }
+            if (!options.type) {
+                return;
+            }
+            console.log('');
+        }
+    }
+    if (!options.type) {
+        return;
+    }
+    const candidateText = text?.trim() || note.text;
+    const mergedTags = uniqueTags([...(note.tags ?? []), ...(options.tag ?? [])]);
+    const reflectOptions = {
+        ...options,
+        tag: mergedTags,
+        author: options.author ?? note.agent,
+        authorId: note.agent_id,
+        projectId: note.project_id,
+        hostId: note.host_id,
+        sessionId: note.session_id,
+        source: options.source ?? `runtime-note:${note.agent}:${note.id}`,
+    };
+    createCandidateFromInput(candidateText, options.type, reflectOptions);
+}
+function uniqueTags(tags) {
+    return [...new Set(tags.filter((tag) => tag.trim().length > 0))];
+}
+export function suggestCandidateTypes(text, tags) {
+    const haystack = `${text.toLowerCase()} ${tags.join(' ').toLowerCase()}`;
+    const suggestions = [];
+    let trapScore = 1;
+    if (/(error|fail|flaky|broken|missing|workaround|retry|blocked|not on path|requires)/.test(haystack)) {
+        trapScore += 3;
+    }
+    suggestions.push({ type: 'trap', score: trapScore, reason: 'Operational friction, workaround, or failure mode' });
+    let constraintScore = 1;
+    if (/(must|required|cannot|blocked|frozen|until|only)/.test(haystack)) {
+        constraintScore += 3;
+    }
+    suggestions.push({ type: 'constraint', score: constraintScore, reason: 'Active limitation or operating boundary' });
+    let decisionScore = 1;
+    if (/(use |prefer|standard|go through|convention|policy)/.test(haystack)) {
+        decisionScore += 3;
+    }
+    suggestions.push({ type: 'decision', score: decisionScore, reason: 'Reusable convention, policy, or chosen approach' });
+    suggestions.push({ type: 'handoff', score: 1, reason: 'Use only if the note should become an explicit transfer of work' });
+    return suggestions.sort((a, b) => b.score - a.score);
+}
+//# sourceMappingURL=reflect-runtime-note.js.map

package/dist/commands/reflect.js

@@ -0,0 +1,286 @@
+import fs from 'node:fs';
+import { memoryExists, memoryPath, writeFileAtomic } 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 { scanText } from '../core/security.js';
+import { nowISO, generateIdWithLabel } from '../core/ids.js';
+import { saveCandidate, generateCandidateIdWithLabel, listCandidates } from '../core/candidates.js';
+import { detectDuplicates } from '../core/duplicates.js';
+import { RuntimeEventSchema } from '../core/schema.js';
+import { listRuntimeEventsBySession } from '../core/events.js';
+import { agentCanWriteDirect, requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { generateTrapIdWithLabel } from '../core/traps.js';
+import { evaluateReflectionSafety } from '../core/reflection-safety.js';
+export function runReflect(text, options) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    if (options.batch) {
+        runReflectBatchFromFile(options.batch, options);
+        return;
+    }
+    if (options.session) {
+        runReflectBatchFromSession(options.session, options);
+        return;
+    }
+    if (!text || !options.type) {
+        console.error('Error: single reflect mode requires <text> and --type.');
+        process.exit(1);
+    }
+    createCandidateFromInput(text, options.type, options);
+}
+function runReflectBatchFromFile(filepath, baseOptions) {
+    if (!fs.existsSync(filepath)) {
+        console.error(`Error: batch file not found: ${filepath}`);
+        process.exit(1);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filepath, 'utf-8'));
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: invalid JSON batch file: ${msg}`);
+        process.exit(1);
+    }
+    const rawEvents = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === 'object' && Array.isArray(parsed.events)
+            ? parsed.events
+            : [parsed];
+    let created = 0;
+    for (const rawEvent of rawEvents) {
+        try {
+            const event = RuntimeEventSchema.parse(rawEvent);
+            const candidateType = event.candidate_type ?? mapEventTypeToCandidateType(event.event_type);
+            createCandidateFromInput(event.text, candidateType, {
+                ...baseOptions,
+                type: candidateType,
+                tag: event.tags.length ? event.tags : baseOptions.tag,
+                authorId: baseOptions.authorId ?? event.agent_id,
+                projectId: baseOptions.projectId ?? event.project_id,
+                hostId: baseOptions.hostId ?? event.host_id,
+                sessionId: baseOptions.sessionId ?? event.session_id,
+                source: baseOptions.source ?? event.agent,
+                severity: baseOptions.severity ?? event.severity,
+                from: baseOptions.from ?? event.from,
+                to: baseOptions.to ?? event.to,
+                path: baseOptions.path ?? event.related_paths?.[0],
+            }, false, true, true);
+            created++;
+        }
+        catch {
+            // skip malformed event records
+        }
+    }
+    console.log(`✔ Created ${created} candidate(s) from batch file`);
+}
+function runReflectBatchFromSession(session, baseOptions) {
+    const events = listRuntimeEventsBySession(session);
+    if (events.length === 0) {
+        console.error(`Error: no runtime events found for session '${session}'.`);
+        process.exit(1);
+    }
+    let created = 0;
+    for (const event of events) {
+        const candidateType = event.candidate_type ?? mapEventTypeToCandidateType(event.event_type);
+        createCandidateFromInput(event.text, candidateType, {
+            ...baseOptions,
+            type: candidateType,
+            tag: event.tags.length ? event.tags : baseOptions.tag,
+            authorId: baseOptions.authorId ?? event.agent_id,
+            projectId: baseOptions.projectId ?? event.project_id,
+            hostId: baseOptions.hostId ?? event.host_id,
+            sessionId: baseOptions.sessionId ?? event.session_id,
+            source: baseOptions.source ?? event.agent,
+            severity: baseOptions.severity ?? event.severity,
+            from: baseOptions.from ?? event.from,
+            to: baseOptions.to ?? event.to,
+            path: baseOptions.path ?? event.related_paths?.[0],
+        }, false, true, true);
+        created++;
+    }
+    console.log(`✔ Created ${created} candidate(s) from session '${session}'`);
+}
+export function createCandidateFromInput(text, type, options, printSuccess = true, forceStrict = false, automation = false) {
+    const config = loadConfig(options.cwd);
+    const explicitAuthor = options.author?.trim();
+    const explicitAuthorId = options.authorId?.trim();
+    const registeredAuthor = requireRegisteredAgentIdentity({
+        agentName: explicitAuthor,
+        agentId: explicitAuthorId,
+        cwd: options.cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    requireMinimumTrustLevel(registeredAuthor, 'contributor');
+    const actorIdentity = buildOperationalIdentity(registeredAuthor.agent_name, options.cwd, {
+        agentId: registeredAuthor.agent_id,
+        sessionId: options.sessionId,
+    });
+    // Security scan — batch/automated imports always block on sensitive content
+    const rawWarnings = scanText(text, config);
+    const warnings = forceStrict
+        ? rawWarnings.map(w => ({ ...w, level: 'block' }))
+        : rawWarnings;
+    for (const w of warnings) {
+        console.warn(`⚠ ${w.message}`);
+        if (w.level === 'block') {
+            console.error(forceStrict
+                ? 'Blocked: sensitive content in automated import. Candidate not created.'
+                : 'Blocked: strict redaction is enabled. Candidate not created.');
+            process.exit(1);
+        }
+    }
+    // Duplicate detection
+    const state = loadState(options.cwd);
+    const pending = listCandidates('pending', options.cwd);
+    const dupes = detectDuplicates(text, type, state, pending);
+    if (dupes.length > 0) {
+        console.warn('⚠ Possible duplicates detected:');
+        for (const d of dupes) {
+            console.warn(`  - [${d.id}] (${d.source}) ${d.reason}: "${d.text}"`);
+        }
+    }
+    const { id, short_label } = generateCandidateIdWithLabel(options.cwd);
+    const candidate = {
+        id,
+        short_label,
+        type,
+        text,
+        created_at: nowISO(),
+        author: options.author ?? actorIdentity.agent,
+        author_id: options.authorId ?? actorIdentity.agent_id,
+        project_id: options.projectId ?? actorIdentity.project_id,
+        host_id: options.hostId ?? actorIdentity.host_id,
+        session_id: options.sessionId ?? actorIdentity.session_id,
+        source: options.source,
+        tags: options.tag ?? [],
+        status: 'pending',
+        severity: type === 'trap' ? options.severity ?? 'medium' : undefined,
+        from: type === 'handoff' ? options.from : undefined,
+        to: type === 'handoff' ? options.to : undefined,
+        related_paths: options.path ? [options.path] : undefined,
+        star_count: 0,
+        starred_by: [],
+        usage_count: 0,
+        usage_events: [],
+    };
+    const safety = evaluateReflectionSafety({
+        text,
+        type,
+        tags: candidate.tags,
+        relatedPaths: candidate.related_paths,
+        projectId: candidate.project_id,
+        cwd: options.cwd,
+        automation,
+    });
+    if (safety.contradiction_summary) {
+        console.warn(`⚠ ${safety.contradiction_summary}`);
+    }
+    const candidateWithSafety = {
+        ...candidate,
+        contradictions_detected: safety.contradictions_detected,
+        contradiction_summary: safety.contradiction_summary,
+        promotion_blocked_reason: safety.promotion_blocked_reason,
+    };
+    // Write-through for trusted/curator agents — bypass pending inbox
+    if (!forceStrict) {
+        try {
+            if (!safety.promotion_blocked_reason && agentCanWriteDirect(candidate.author_id ?? candidate.author, options.cwd)) {
+                const promotedItemId = promoteCandidateToState(candidateWithSafety, options.cwd);
+                appendAuditEntry({
+                    actor: candidate.author,
+                    actor_id: candidate.author_id,
+                    action: 'promote_direct',
+                    item_id: id,
+                    item_type: type,
+                    after: candidate,
+                });
+                if (printSuccess) {
+                    console.log(`✔ Direct write: [${id}] (${type}) ${text} (trusted agent — bypassed inbox)`);
+                }
+                return {
+                    candidateId: id,
+                    type,
+                    writeThrough: true,
+                    promotedItemId,
+                    contradictionsDetected: safety.contradictions_detected,
+                    contradictionSummary: safety.contradiction_summary,
+                };
+            }
+        }
+        catch { /* trust check failed — fall through to pending */ }
+    }
+    saveCandidate(candidateWithSafety, options.cwd);
+    if (printSuccess) {
+        console.log(`✔ Candidate created: [${id}] (${type}) ${text}`);
+        if (safety.promotion_blocked_reason) {
+            console.log(`  Auto-promotion blocked: ${safety.promotion_blocked_reason}`);
+        }
+    }
+    return {
+        candidateId: id,
+        type,
+        writeThrough: false,
+        contradictionsDetected: safety.contradictions_detected,
+        contradictionSummary: safety.contradiction_summary,
+        promotionBlockedReason: safety.promotion_blocked_reason,
+    };
+}
+function promoteCandidateToState(candidate, cwd) {
+    const state = loadState(cwd);
+    let promotedItemId = '';
+    switch (candidate.type) {
+        case 'constraint': {
+            const { id: cId, short_label } = generateIdWithLabel('active_constraints', cwd);
+            const entry = { id: cId, short_label, text: candidate.text, created_at: candidate.created_at, author: candidate.author, author_id: candidate.author_id, project_id: candidate.project_id, host_id: candidate.host_id, session_id: candidate.session_id, status: 'active', tags: candidate.tags };
+            state.active_constraints.push(entry);
+            promotedItemId = entry.id;
+            break;
+        }
+        case 'decision': {
+            const { id: dId, short_label } = generateIdWithLabel('recent_decisions', cwd);
+            const entry = { id: dId, short_label, text: candidate.text, created_at: candidate.created_at, author: candidate.author, author_id: candidate.author_id, project_id: candidate.project_id, host_id: candidate.host_id, session_id: candidate.session_id, related_paths: candidate.related_paths, tags: candidate.tags };
+            state.recent_decisions.push(entry);
+            promotedItemId = entry.id;
+            break;
+        }
+        case 'trap': {
+            const { id: tId, short_label } = generateTrapIdWithLabel(cwd);
+            const entry = { id: tId, short_label, text: candidate.text, created_at: candidate.created_at, author: candidate.author, author_id: candidate.author_id, project_id: candidate.project_id, host_id: candidate.host_id, session_id: candidate.session_id, status: 'active', severity: candidate.severity ?? 'medium', tags: candidate.tags, visibility: 'shared' };
+            state.known_traps.push(entry);
+            promotedItemId = entry.id;
+            break;
+        }
+        case 'handoff': {
+            const { id: hId, short_label } = generateIdWithLabel('open_handoffs', cwd);
+            const entry = { id: hId, short_label, text: candidate.text, created_at: candidate.created_at, author: candidate.author, author_id: candidate.author_id, project_id: candidate.project_id, host_id: candidate.host_id, session_id: candidate.session_id, from: candidate.from ?? '', to: candidate.to ?? '', status: 'open', tags: candidate.tags, related_paths: candidate.related_paths };
+            state.open_handoffs.push(entry);
+            promotedItemId = entry.id;
+            break;
+        }
+    }
+    saveState(state, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state));
+    return promotedItemId;
+}
+export function mapEventTypeToCandidateType(eventType) {
+    switch (eventType) {
+        case 'risk_detected':
+            return 'trap';
+        case 'handoff_requested':
+            return 'handoff';
+        case 'task_started':
+        case 'task_finished':
+            return 'constraint';
+        case 'observation':
+        default:
+            return 'decision';
+    }
+}
+//# sourceMappingURL=reflect.js.map

package/dist/commands/register-agent.js

@@ -0,0 +1,29 @@
+import { registerAgentIdentity, setCurrentAgentIdentity } from '../core/agent-registry.js';
+import { memoryExists } from '../core/io.js';
+export function runRegisterAgent(agentName, options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const resolvedTrust = options.curator ? 'curator' : options.trustLevel;
+    const agent = registerAgentIdentity({
+        agentName,
+        kind: options.kind ?? 'unknown',
+        capabilities: options.capability,
+        replaceCapabilities: options.replaceCapabilities,
+        generateFingerprint: options.generateFingerprint,
+        trustLevel: resolvedTrust,
+    });
+    if (options.setCurrent) {
+        setCurrentAgentIdentity(agent);
+    }
+    if (options.json) {
+        console.log(JSON.stringify({ ...agent, current: options.setCurrent ?? false }, null, 2));
+        return;
+    }
+    const currentLabel = options.setCurrent ? ' [current]' : '';
+    const capabilitiesLabel = agent.capabilities.length > 0 ? `, capabilities=${agent.capabilities.join(',')}` : '';
+    const fingerprintLabel = agent.identity_key ? `, fp=${agent.identity_key.fingerprint.slice(0, 12)}` : '';
+    console.log(`✔ Agent registered: ${agent.agent_name} (${agent.agent_id}, kind=${agent.kind}${capabilitiesLabel}${fingerprintLabel})${currentLabel}`);
+}
+//# sourceMappingURL=register-agent.js.map

package/dist/commands/reject.js

@@ -0,0 +1,52 @@
+import { memoryExists } from '../core/io.js';
+import { loadCandidate, archiveCandidate, resolveIdOrAlias } from '../core/candidates.js';
+import { nowISO } from '../core/ids.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+export function runReject(id, reason, by, cwd) {
+    try {
+        rejectCandidate(id, reason, by, cwd);
+        console.log(`✔ Candidate [${id}] rejected and archived.`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+}
+export function rejectCandidate(id, reason, by, cwd, byId) {
+    if (!memoryExists(cwd)) {
+        throw new Error('.brainclaw/ not found. Run `brainclaw init` first.');
+    }
+    const resolvedId = resolveIdOrAlias(id, cwd);
+    const candidate = loadCandidate(resolvedId, cwd);
+    if (candidate.status !== 'pending') {
+        throw new Error(`Candidate '${resolvedId}' is already ${candidate.status}.`);
+    }
+    const actorIdentity = requireRegisteredAgentIdentity({
+        agentName: by,
+        agentId: byId,
+        cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    requireMinimumTrustLevel(actorIdentity, 'trusted');
+    const actor = actorIdentity.agent_name;
+    candidate.status = 'rejected';
+    candidate.resolved_at = nowISO();
+    candidate.resolved_by = actor;
+    if (reason) {
+        candidate.resolution_reason = reason;
+    }
+    archiveCandidate(candidate, 'rejected', cwd);
+    appendAuditEntry({
+        actor,
+        actor_id: actorIdentity.agent_id,
+        action: 'reject',
+        item_id: resolvedId,
+        item_type: candidate.type,
+        reason,
+    }, cwd);
+    return { candidate_id: resolvedId, actor };
+}
+//# sourceMappingURL=reject.js.map

package/dist/commands/release-claim.js

@@ -0,0 +1,41 @@
+import { memoryExists } from '../core/io.js';
+import { memoryPath, 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';
+export function runReleaseClaim(id, options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        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;
+                }
+                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));
+        console.log(`✔ Claim [${id}] released (was: ${claim.agent} → ${claim.scope})`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=release-claim.js.map

package/dist/commands/release-claims.js

@@ -0,0 +1,67 @@
+import { execSync } from 'node:child_process';
+import { memoryExists, memoryPath, 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';
+function normPath(p) {
+    return p.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+function scopeMatchesFile(scope, file) {
+    const f = normPath(file);
+    return scope.split(/\s+/).some((s) => {
+        const sp = normPath(s).replace(/\/$/, '');
+        return f === sp || f.startsWith(sp + '/');
+    });
+}
+export function runReleaseClaims(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        process.exit(0); // silent — called from git hook
+    }
+    let changedFiles = [];
+    if (options.fromGitDiff) {
+        const ref1 = options.ref1 ?? 'ORIG_HEAD';
+        const ref2 = options.ref2 ?? 'HEAD';
+        try {
+            const output = execSync(`git diff --name-only ${ref1} ${ref2}`, { encoding: 'utf-8' });
+            changedFiles = output.split('\n').map((f) => f.trim()).filter(Boolean);
+        }
+        catch {
+            process.exit(0); // not in git or no diff — skip silently
+        }
+    }
+    if (changedFiles.length === 0)
+        process.exit(0);
+    const claims = listClaims(options.cwd).filter((c) => c.status === 'active');
+    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);
+                    }
+                }
+            }
+            console.log(`✔ Auto-released claim [${claim.id}]: ${claim.scope}`);
+        }
+        catch { /* skip individual failures */ }
+    }
+    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.`);
+    }
+}
+//# sourceMappingURL=release-claims.js.map