brainclaw 0.19.2

package/dist/commands/memory.js

@@ -0,0 +1,283 @@
+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 { scanText } from '../core/security.js';
+import { validateCliInput } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+import { runConstraint } from './constraint.js';
+import { runDecision } from './decision.js';
+import { runHandoff } from './handoff.js';
+import { runTrap } from './trap.js';
+export function runMemoryCommand(subcommand, args, options = {}) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    const normalized = subcommand.trim().toLowerCase();
+    if (normalized === 'create') {
+        const kind = args[0];
+        const text = args.slice(1).join(' ').trim();
+        if (!kind || !isMemoryKind(kind)) {
+            console.error('Error: memory create requires <type> where type is decision, constraint, trap, or handoff');
+            process.exit(1);
+        }
+        if (!text) {
+            console.error('Error: memory create requires <text>');
+            process.exit(1);
+        }
+        runMemoryCreate(kind, text, { ...options, cwd });
+        return;
+    }
+    if (normalized === 'list') {
+        runMemoryList({ ...options, cwd });
+        return;
+    }
+    if (normalized === 'update') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: memory update requires <id>');
+            process.exit(1);
+        }
+        runMemoryUpdate(id, { ...options, cwd });
+        return;
+    }
+    if (normalized === 'delete') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: memory delete requires <id>');
+            process.exit(1);
+        }
+        runMemoryDelete(id, cwd);
+        return;
+    }
+    console.error(`Error: unknown memory subcommand '${subcommand}'. Use create, list, update, or delete.`);
+    process.exit(1);
+}
+function runMemoryCreate(kind, text, options) {
+    switch (kind) {
+        case 'decision':
+            runDecision(text, options);
+            return;
+        case 'constraint':
+            runConstraint(text, options);
+            return;
+        case 'trap':
+            runTrap(text, {
+                status: options.status,
+                severity: options.severity,
+                tag: options.tag,
+                path: options.path,
+                author: options.author,
+                visibility: options.visibility,
+                host: options.host,
+                ttl: options.ttl,
+                cwd: options.cwd,
+                store: options.store,
+                plan: options.plan,
+            });
+            return;
+        case 'handoff': {
+            if (!options.from || !options.to) {
+                console.error('Error: memory create handoff requires --from <from> and --to <to>');
+                process.exit(1);
+            }
+            runHandoff(text, {
+                from: options.from,
+                to: options.to,
+                tag: options.tag,
+                path: options.path,
+                project: options.project,
+                plan: options.plan,
+                author: options.author,
+                captureDiff: options.captureDiff,
+                cwd: options.cwd,
+                store: options.store,
+            });
+        }
+    }
+}
+function runMemoryList(options) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const state = loadState(options.cwd);
+    let items = collectMemoryItems(state);
+    if (options.type) {
+        items = items.filter((entry) => entry.kind === options.type);
+    }
+    if (options.status) {
+        items = items.filter(({ kind, item }) => {
+            if (kind === 'constraint' || kind === 'handoff' || kind === 'trap') {
+                return 'status' in item && item.status === options.status;
+            }
+            return false;
+        });
+    }
+    items.sort((a, b) => a.item.created_at.localeCompare(b.item.created_at));
+    if (options.json) {
+        console.log(JSON.stringify({
+            total: items.length,
+            items: items.map(({ kind, item }) => ({ type: kind, ...item })),
+        }, null, 2));
+        return;
+    }
+    if (items.length === 0) {
+        console.log('No memory items found.');
+        return;
+    }
+    console.log(`${items.length} memory item(s):`);
+    console.log('');
+    for (const { kind, item } of items) {
+        const tags = item.tags.length ? ` [${item.tags.join(', ')}]` : '';
+        const meta = renderMemoryMeta(kind, item);
+        console.log(`  [${item.id}] <${kind}> ${item.text}${meta}${tags}`);
+    }
+}
+function runMemoryUpdate(id, options) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const state = loadState(options.cwd);
+    const resolved = resolveMemoryItem(state, id);
+    if (!resolved) {
+        console.error(`Error: Memory item '${id}' not found.`);
+        process.exit(1);
+    }
+    if (options.text !== undefined || options.tag !== undefined) {
+        validateCliInput(options.text ?? resolved.item.text, options.tag ?? resolved.item.tags);
+        const config = loadConfig(options.cwd);
+        const warnings = scanText(options.text ?? resolved.item.text, config);
+        for (const warning of warnings) {
+            console.warn(`⚠ ${warning.message}`);
+            if (warning.level === 'block') {
+                console.error('Blocked: strict redaction is enabled. Entry not updated.');
+                process.exit(1);
+            }
+        }
+    }
+    if (options.text !== undefined) {
+        resolved.item.text = options.text;
+    }
+    if (options.tag !== undefined) {
+        resolved.item.tags = options.tag;
+    }
+    if (options.path !== undefined) {
+        resolved.item.related_paths = options.path;
+    }
+    switch (resolved.kind) {
+        case 'decision':
+            {
+                const item = resolved.item;
+                if (options.outcome !== undefined) {
+                    item.outcome = options.outcome;
+                }
+                if (options.plan !== undefined) {
+                    item.plan_id = options.plan;
+                }
+                break;
+            }
+        case 'constraint':
+            {
+                const item = resolved.item;
+                if (options.status !== undefined) {
+                    item.status = options.status;
+                }
+                if (options.category !== undefined) {
+                    item.category = options.category;
+                }
+                break;
+            }
+        case 'trap':
+            {
+                const item = resolved.item;
+                if (options.status !== undefined) {
+                    item.status = options.status;
+                }
+                if (options.severity !== undefined) {
+                    item.severity = options.severity;
+                }
+                if (options.plan !== undefined) {
+                    item.plan_id = options.plan;
+                }
+                break;
+            }
+        case 'handoff':
+            {
+                const item = resolved.item;
+                if (options.status !== undefined) {
+                    item.status = options.status;
+                }
+                if (options.from !== undefined) {
+                    item.from = options.from;
+                }
+                if (options.to !== undefined) {
+                    item.to = options.to;
+                }
+                if (options.project !== undefined) {
+                    item.project = options.project;
+                }
+                if (options.plan !== undefined) {
+                    item.plan_id = options.plan;
+                }
+                break;
+            }
+    }
+    saveState(state, options.cwd);
+    writeFileAtomic(memoryPath('project.md', options.cwd), generateMarkdown(state, options.cwd));
+    console.log(`✔ Memory item updated: [${resolved.item.id}] ${resolved.item.text}`);
+}
+function runMemoryDelete(id, cwd) {
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const state = loadState(cwd);
+    const arrays = [
+        state.recent_decisions,
+        state.active_constraints,
+        state.known_traps,
+        state.open_handoffs,
+    ];
+    let deleted;
+    for (const items of arrays) {
+        const index = items.findIndex((item) => item.id === id || item.short_label === id);
+        if (index >= 0) {
+            [deleted] = items.splice(index, 1);
+            break;
+        }
+    }
+    if (!deleted) {
+        console.error(`Error: Memory item '${id}' not found.`);
+        process.exit(1);
+    }
+    saveState(state, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+    console.log(`✔ Memory item deleted: [${deleted.id}] ${deleted.text}`);
+}
+function collectMemoryItems(state) {
+    return [
+        ...state.recent_decisions.map((item) => ({ kind: 'decision', item })),
+        ...state.active_constraints.map((item) => ({ kind: 'constraint', item })),
+        ...state.known_traps.map((item) => ({ kind: 'trap', item })),
+        ...state.open_handoffs.map((item) => ({ kind: 'handoff', item })),
+    ];
+}
+function resolveMemoryItem(state, id) {
+    return collectMemoryItems(state).find(({ item }) => item.id === id || item.short_label === id);
+}
+function renderMemoryMeta(kind, item) {
+    switch (kind) {
+        case 'decision':
+            return item.outcome ? ` (${item.outcome})` : '';
+        case 'constraint':
+            return ` (${item.status}${item.category ? ` · ${item.category}` : ''})`;
+        case 'trap':
+            return ` (${item.severity} · ${item.status})`;
+        case 'handoff':
+            return ` (${item.from} -> ${item.to} · ${item.status})`;
+    }
+}
+function isMemoryKind(value) {
+    return value === 'decision' || value === 'constraint' || value === 'trap' || value === 'handoff';
+}
+//# sourceMappingURL=memory.js.map

package/dist/commands/metrics.js

@@ -0,0 +1,175 @@
+import { memoryExists } from '../core/io.js';
+import { loadState } from '../core/state.js';
+import { listCandidates } from '../core/candidates.js';
+import { listRuntimeNotes } from '../core/runtime.js';
+import { listClaims } from '../core/claims.js';
+import { readAuditLog } from '../core/audit.js';
+import { loadConfig } from '../core/config.js';
+export function runMetrics(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const slaHours = config.governance?.review_sla_hours ?? 24;
+    const now = new Date();
+    const report = buildMetricsReport(slaHours, options.since);
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`Memory Health Dashboard — ${report.snapshot_at}`);
+    console.log('');
+    console.log('═ Memory');
+    console.log(`  Constraints active:  ${report.memory.constraints_active}`);
+    console.log(`  Decisions:           ${report.memory.decisions_total}`);
+    console.log(`  Traps:               ${report.memory.traps_total}`);
+    console.log(`  Plans:               ${report.memory.plans_total} (${report.memory.plans_in_progress} in-progress, ${report.memory.plans_done} done)`);
+    console.log(`  Handoffs open:       ${report.memory.handoffs_open}`);
+    console.log('');
+    console.log('═ Reflective Memory');
+    console.log(`  Pending candidates:  ${report.reflective.candidates_pending}`);
+    console.log(`  Accepted:            ${report.reflective.candidates_accepted}`);
+    console.log(`  Rejected:            ${report.reflective.candidates_rejected}`);
+    if (report.reflective.oldest_pending_hours > 0) {
+        console.log(`  Oldest pending:      ${report.reflective.oldest_pending_hours}h`);
+    }
+    console.log('');
+    console.log('═ Runtime');
+    console.log(`  Notes:               ${report.runtime.notes_total} (${report.runtime.notes_shared} shared)`);
+    console.log(`  Active claims:       ${report.runtime.claims_active}`);
+    console.log('');
+    if (report.audit.total_events > 0) {
+        console.log('═ Audit Log');
+        console.log(`  Events:              ${report.audit.total_events}`);
+        const byAction = Object.entries(report.audit.events_by_action)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5);
+        for (const [action, count] of byAction) {
+            console.log(`    ${action}: ${count}`);
+        }
+        const topActors = report.audit.top_actors.slice(0, 3);
+        if (topActors.length > 0) {
+            console.log(`  Top actors:          ${topActors.map(a => `${a.actor}(${a.count})`).join(', ')}`);
+        }
+        console.log('');
+    }
+    console.log('═ Health');
+    console.log(`  Score:               ${report.health.score}/100`);
+    if (report.health.issues.length === 0) {
+        console.log(`  Status:              ✔ No issues detected`);
+    }
+    else {
+        for (const issue of report.health.issues) {
+            console.log(`  ⚠ ${issue}`);
+        }
+    }
+}
+function buildMetricsReport(slaHours, since) {
+    const now = new Date();
+    const snapshotAt = now.toISOString();
+    let state;
+    try {
+        state = loadState();
+    }
+    catch {
+        state = null;
+    }
+    let candidates = [];
+    try {
+        candidates = listCandidates();
+    }
+    catch { /* empty */ }
+    let notes = [];
+    try {
+        notes = listRuntimeNotes();
+    }
+    catch { /* empty */ }
+    let claims = [];
+    try {
+        claims = listClaims();
+    }
+    catch { /* empty */ }
+    let auditEntries = [];
+    try {
+        auditEntries = readAuditLog(since ? { since } : {});
+    }
+    catch { /* empty */ }
+    // Memory metrics
+    const memory = {
+        constraints_active: state?.active_constraints.filter(c => c.status === 'active').length ?? 0,
+        decisions_total: state?.recent_decisions.length ?? 0,
+        traps_total: state?.known_traps.length ?? 0,
+        plans_total: state?.plan_items.length ?? 0,
+        plans_in_progress: state?.plan_items.filter(p => p.status === 'in_progress').length ?? 0,
+        plans_done: state?.plan_items.filter(p => p.status === 'done').length ?? 0,
+        handoffs_open: state?.open_handoffs.filter(h => h.status === 'open').length ?? 0,
+    };
+    // Reflective memory metrics
+    const pending = candidates.filter(c => c.status === 'pending');
+    const accepted = candidates.filter(c => c.status === 'accepted');
+    const rejected = candidates.filter(c => c.status === 'rejected');
+    let oldestPendingHours = 0;
+    if (pending.length > 0) {
+        const oldestMs = Math.min(...pending.map(c => Date.parse(c.created_at)));
+        oldestPendingHours = Math.floor((now.getTime() - oldestMs) / (1000 * 60 * 60));
+    }
+    // Runtime metrics
+    const runtime = {
+        notes_total: notes.length,
+        notes_shared: notes.filter(n => n.visibility === 'shared').length,
+        claims_active: claims.filter(c => c.status === 'active').length,
+    };
+    // Audit metrics
+    const eventsByAction = {};
+    const actorCounts = {};
+    for (const entry of auditEntries) {
+        eventsByAction[entry.action] = (eventsByAction[entry.action] ?? 0) + 1;
+        actorCounts[entry.actor] = (actorCounts[entry.actor] ?? 0) + 1;
+    }
+    const topActors = Object.entries(actorCounts)
+        .map(([actor, count]) => ({ actor, count }))
+        .sort((a, b) => b.count - a.count);
+    // Health score
+    const issues = [];
+    let score = 100;
+    if (memory.handoffs_open > 5) {
+        score -= 5;
+        issues.push(`${memory.handoffs_open} open handoffs`);
+    }
+    if (pending.length > 20) {
+        score -= 10;
+        issues.push(`${pending.length} pending candidates backlog`);
+    }
+    if (oldestPendingHours > slaHours * 2) {
+        score -= 10;
+        issues.push(`oldest pending candidate: ${oldestPendingHours}h (SLA: ${slaHours}h)`);
+    }
+    if (runtime.claims_active > 10) {
+        score -= 5;
+        issues.push(`${runtime.claims_active} active claims — possible stale locks`);
+    }
+    if (memory.constraints_active === 0 && memory.decisions_total === 0) {
+        score -= 5;
+        issues.push('no constraints or decisions recorded yet');
+    }
+    score = Math.max(0, score);
+    return {
+        snapshot_at: snapshotAt,
+        memory,
+        reflective: {
+            candidates_pending: pending.length,
+            candidates_accepted: accepted.length,
+            candidates_rejected: rejected.length,
+            oldest_pending_hours: oldestPendingHours,
+        },
+        runtime,
+        audit: {
+            total_events: auditEntries.length,
+            events_by_action: eventsByAction,
+            top_actors: topActors,
+        },
+        health: { score, issues },
+    };
+}
+//# sourceMappingURL=metrics.js.map

package/dist/commands/plan-resource.js

@@ -0,0 +1,62 @@
+import { runPlan } from './plan.js';
+import { runListPlans } from './list-plans.js';
+import { runUpdatePlan } from './update-plan.js';
+import { runDeletePlan } from './delete-plan.js';
+export function runPlanResource(subcommand, args, options = {}) {
+    const normalized = subcommand.trim().toLowerCase();
+    if (normalized === 'create') {
+        const text = args.join(' ').trim();
+        if (!text) {
+            console.error('Error: plan create requires <text>');
+            process.exit(1);
+        }
+        runPlan(text, options);
+        return;
+    }
+    if (normalized === 'list' || normalized === 'ls') {
+        runListPlans({
+            json: options.json,
+            status: options.status,
+            type: options.type,
+            assignee: options.assignee,
+            project: options.project,
+            all: options.all,
+        });
+        return;
+    }
+    if (normalized === 'update') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: plan update requires <id>.');
+            console.error('  Usage: brainclaw plan update <id> --status <status>');
+            process.exit(1);
+        }
+        runUpdatePlan(id, {
+            status: options.status,
+            assignee: options.assignee,
+            project: options.project,
+            priority: options.priority,
+            actualEffort: options.actualEffort,
+            cwd: options.cwd,
+        });
+        return;
+    }
+    if (normalized === 'delete') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: plan delete requires <id>.');
+            console.error('  Usage: brainclaw plan delete <id>');
+            process.exit(1);
+        }
+        runDeletePlan(id, { cwd: options.cwd });
+        return;
+    }
+    // Compatibility path: `brainclaw plan "text"` still creates a plan.
+    const legacyText = [subcommand, ...args].join(' ').trim();
+    if (!legacyText) {
+        console.error('Error: missing plan subcommand or description.');
+        process.exit(1);
+    }
+    runPlan(legacyText, options);
+}
+//# sourceMappingURL=plan-resource.js.map

package/dist/commands/plan.js

@@ -0,0 +1,76 @@
+import { loadState, saveState } 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 { validateCliInput } from '../core/input-validation.js';
+import { runListPlans } from './list-plans.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+// Known plan subcommands that should not be accepted as plan text
+const PLAN_SUBCOMMAND_ALIASES = new Set(['list', 'ls']);
+const PLAN_SUBCOMMAND_ERRORS = new Set(['update']);
+export function runPlan(text, options = {}) {
+    const cwd = resolveTargetStore(options.cwd ?? process.cwd(), options.store ?? 'local');
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const normalized = text.trim().toLowerCase();
+    if (PLAN_SUBCOMMAND_ALIASES.has(normalized)) {
+        runListPlans({});
+        return;
+    }
+    if (PLAN_SUBCOMMAND_ERRORS.has(normalized)) {
+        console.error(`Error: '${text}' looks like a subcommand, not a plan description.`);
+        console.error('  To update a plan, use: brainclaw plan update <id> --status <status>');
+        process.exit(1);
+    }
+    validateCliInput(text, options.tag);
+    const config = loadConfig(cwd);
+    const warnings = scanText(text, config);
+    for (const w of warnings) {
+        console.warn(`⚠ ${w.message}`);
+        if (w.level === 'block') {
+            console.error('Blocked: strict redaction is enabled. Entry not added.');
+            process.exit(1);
+        }
+    }
+    // Validate and normalise --estimate: must be a positive integer (minutes)
+    let estimatedEffort;
+    if (options.estimate !== undefined) {
+        const n = typeof options.estimate === 'number' ? options.estimate : parseInt(String(options.estimate), 10);
+        if (!Number.isInteger(n) || n <= 0) {
+            console.error('Error: --estimate must be a positive integer representing minutes (e.g. --estimate 30)');
+            process.exit(1);
+        }
+        estimatedEffort = n;
+    }
+    const state = loadState(cwd);
+    const { id, short_label } = generateIdWithLabel('plan_items');
+    const timestamp = nowISO();
+    const entry = {
+        id,
+        short_label,
+        text,
+        type: options.type,
+        created_at: timestamp,
+        updated_at: timestamp,
+        author: options.author ?? resolveCurrentAgentName(cwd),
+        status: 'todo',
+        priority: options.priority ?? 'medium',
+        assignee: options.assignee,
+        project: options.project,
+        tags: options.tag ?? [],
+        related_paths: options.path,
+        depends_on: options.dependsOn ?? [],
+        estimated_effort: estimatedEffort,
+    };
+    state.plan_items.push(entry);
+    saveState(state, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+    const storeLabel = options.store && options.store !== 'local' ? ` [store:${options.store}]` : '';
+    console.log(`✔ Plan item added: [${id}] ${text}${storeLabel}`);
+}
+//# sourceMappingURL=plan.js.map

package/dist/commands/prune-candidates.js

@@ -0,0 +1,36 @@
+import { memoryExists } from '../core/io.js';
+import { loadConfig } from '../core/config.js';
+import { listArchivedCandidates, deleteArchivedCandidate } from '../core/candidates.js';
+export function runPruneCandidates(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const maxDays = options.days ?? config.reflective_memory?.prune_rejected_after_days ?? 30;
+    const cutoff = new Date(Date.now() - maxDays * 24 * 60 * 60 * 1000).toISOString();
+    const rejected = listArchivedCandidates('rejected');
+    const toPrune = rejected.filter(c => {
+        const date = c.resolved_at ?? c.created_at;
+        return date < cutoff;
+    });
+    if (toPrune.length === 0) {
+        console.log(`No rejected candidates older than ${maxDays} days to prune.`);
+        return;
+    }
+    if (options.dryRun) {
+        console.log(`Would prune ${toPrune.length} rejected candidate(s):`);
+        for (const c of toPrune) {
+            console.log(`  [${c.id}] ${c.text}`);
+        }
+        return;
+    }
+    let pruned = 0;
+    for (const c of toPrune) {
+        if (deleteArchivedCandidate(c.id, 'rejected')) {
+            pruned++;
+        }
+    }
+    console.log(`✔ Pruned ${pruned} rejected candidate(s) older than ${maxDays} days.`);
+}
+//# sourceMappingURL=prune-candidates.js.map

package/dist/commands/prune.js

@@ -0,0 +1,48 @@
+import { loadState, saveState } from '../core/state.js';
+import { memoryExists } from '../core/io.js';
+import { deleteRuntimeNote, listRuntimeNotes } from '../core/runtime.js';
+import { expireStaleActiveClaims } from '../core/claims.js';
+export function runPrune(options = {}) {
+    const cwd = process.cwd();
+    if (!memoryExists(cwd)) {
+        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 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++;
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    if (options.expired) {
+        console.log(`✔ Pruned ${prunedCount} expired constraints, ${expiredNotesCount} expired runtime notes, ${expiredClaimsCount} expired claims.`);
+    }
+    else {
+        console.log(`✔ Pruned ${prunedCount} expired constraints, ${expiredClaimsCount} expired claims.`);
+    }
+}
+//# sourceMappingURL=prune.js.map