brainclaw 0.19.2

package/dist/commands/accept.js

@@ -0,0 +1,149 @@
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { loadCandidate, archiveCandidate, resolveIdOrAlias } from '../core/candidates.js';
+import { loadState, saveState } from '../core/state.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { generateIdWithLabel, nowISO } from '../core/ids.js';
+import { generateTrapIdWithLabel } from '../core/traps.js';
+import { requireMinimumTrustLevel, requireRegisteredAgentIdentity } from '../core/agent-registry.js';
+import { appendAuditEntry } from '../core/audit.js';
+export function runAccept(id, by, cwd) {
+    try {
+        const result = acceptCandidate(id, by, cwd);
+        console.log(`✔ Promoted to ${result.candidate_type} [${result.promoted_item_id}]`);
+        console.log(`✔ Candidate [${id}] accepted and archived.`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+}
+export function acceptCandidate(id, 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 '${id}' is already ${candidate.status}.`);
+    }
+    const actorIdentity = requireRegisteredAgentIdentity({
+        agentName: by,
+        agentId: byId,
+        cwd,
+        allowCurrent: true,
+        allowEnv: true,
+    });
+    requireMinimumTrustLevel(actorIdentity, 'trusted');
+    const actor = actorIdentity.agent_name;
+    const state = loadState(cwd);
+    let promotedItemId = '';
+    // Promote candidate into canonical state based on type
+    switch (candidate.type) {
+        case 'constraint': {
+            const { id: entryId, short_label } = generateIdWithLabel('active_constraints', cwd);
+            const entry = {
+                id: entryId,
+                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 = entryId;
+            break;
+        }
+        case 'decision': {
+            const { id: entryId, short_label } = generateIdWithLabel('recent_decisions', cwd);
+            const entry = {
+                id: entryId,
+                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,
+                plan_id: candidate.plan_id,
+                tags: candidate.tags,
+            };
+            state.recent_decisions.push(entry);
+            promotedItemId = entryId;
+            break;
+        }
+        case 'trap': {
+            const { id: entryId, short_label } = generateTrapIdWithLabel(cwd);
+            const entry = {
+                id: entryId,
+                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,
+                plan_id: candidate.plan_id,
+                visibility: 'shared',
+            };
+            state.known_traps.push(entry);
+            promotedItemId = entryId;
+            break;
+        }
+        case 'handoff': {
+            const { id: entryId, short_label } = generateIdWithLabel('open_handoffs', cwd);
+            const entry = {
+                id: entryId,
+                short_label,
+                from: candidate.from ?? 'unknown',
+                to: candidate.to ?? 'unknown',
+                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: 'open',
+                tags: candidate.tags,
+            };
+            state.open_handoffs.push(entry);
+            promotedItemId = entryId;
+            break;
+        }
+    }
+    saveState(state, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state, cwd));
+    // Archive candidate (use resolved hash ID)
+    candidate.status = 'accepted';
+    candidate.resolved_at = nowISO();
+    candidate.resolved_by = actor;
+    archiveCandidate(candidate, 'accepted', cwd);
+    appendAuditEntry({
+        actor,
+        actor_id: actorIdentity.agent_id,
+        action: 'accept',
+        item_id: resolvedId,
+        item_type: candidate.type,
+        after: { type: candidate.type, text: candidate.text },
+        reason: 'trusted-agent',
+    }, cwd);
+    return {
+        candidate_id: resolvedId,
+        candidate_type: candidate.type,
+        promoted_item_id: promotedItemId,
+        actor,
+    };
+}
+//# sourceMappingURL=accept.js.map

package/dist/commands/adapter-openclaw-import.js

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import { memoryExists } from '../core/io.js';
+import { runReflect } from './reflect.js';
+import { RuntimeEventSchema } from '../core/schema.js';
+import { listRuntimeEventsBySession } from '../core/events.js';
+import { logger } from '../core/logger.js';
+export function runAdapterOpenclawImport(file, options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    if (!file && !options.session) {
+        console.error('Error: provide either <file> or --session <id>.');
+        process.exit(1);
+    }
+    if (options.dryRun) {
+        const events = options.session
+            ? listRuntimeEventsBySession(options.session)
+            : listRuntimeEventsFromFile(file);
+        printDryRunSummary(events, options.session);
+        return;
+    }
+    runReflect(undefined, {
+        batch: file,
+        session: options.session,
+        source: options.source ?? 'openclaw',
+        author: options.author,
+    });
+}
+function listRuntimeEventsFromFile(file) {
+    if (!fs.existsSync(file)) {
+        throw new Error(`batch file not found: ${file}`);
+    }
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    const rawEvents = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === 'object' && Array.isArray(parsed.events)
+            ? parsed.events
+            : [parsed];
+    const events = [];
+    for (const raw of rawEvents) {
+        try {
+            events.push(RuntimeEventSchema.parse(raw));
+        }
+        catch (err) {
+            logger.debug('Ignoring malformed OpenClaw event record:', err);
+        }
+    }
+    return events;
+}
+function printDryRunSummary(events, session) {
+    const byType = new Map();
+    for (const event of events) {
+        byType.set(event.event_type, (byType.get(event.event_type) ?? 0) + 1);
+    }
+    if (session) {
+        console.log(`Dry-run for OpenClaw session '${session}':`);
+    }
+    else {
+        console.log('Dry-run for OpenClaw file import:');
+    }
+    console.log(`  events: ${events.length}`);
+    for (const [type, count] of [...byType.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        console.log(`  - ${type}: ${count}`);
+    }
+    if (events.length > 0) {
+        console.log('  sample:');
+        for (const event of events.slice(0, 3)) {
+            console.log(`    [${event.id}] ${event.event_type} :: ${event.text}`);
+        }
+    }
+    console.log('  note: actual import enforces strict mode — sensitive content blocks candidate creation.');
+    console.log('No candidates were created (dry-run).');
+}
+//# sourceMappingURL=adapter-openclaw-import.js.map

package/dist/commands/add-step.js

@@ -0,0 +1,35 @@
+import { loadState, saveState } from '../core/state.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { generateId, nowISO } from '../core/ids.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { validateCliInput } from '../core/input-validation.js';
+export function runAddStep(planId, text, options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    validateCliInput(text);
+    const state = loadState();
+    const plan = state.plan_items.find((p) => p.id === planId || p.short_label === planId);
+    if (!plan) {
+        console.error(`Error: Plan '${planId}' not found.`);
+        process.exit(1);
+    }
+    const step = {
+        id: generateId('plan_steps'),
+        text,
+        status: 'todo',
+        assignee: options.assignee,
+        created_at: nowISO(),
+        updated_at: nowISO(),
+    };
+    plan.steps = [...(plan.steps ?? []), step];
+    plan.updated_at = nowISO();
+    saveState(state);
+    writeFileAtomic(memoryPath('project.md'), generateMarkdown(state));
+    const total = plan.steps.length;
+    const done = plan.steps.filter((s) => s.status === 'done').length;
+    console.log(`✔ Step added: [${step.id}] ${text}`);
+    console.log(`  Plan [${plan.id}] progress: ${done}/${total} steps done`);
+}
+//# sourceMappingURL=add-step.js.map

package/dist/commands/agent-board.js

@@ -0,0 +1,106 @@
+import { buildCoordinationSnapshot } from '../core/coordination.js';
+import { listAgentIdentities } from '../core/agent-registry.js';
+import { memoryExists } from '../core/io.js';
+export function runAgentBoard(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const board = buildCoordinationSnapshot({
+        agent: options.agent,
+        project: options.project,
+        target: options.for,
+        host: options.host,
+        allHosts: options.allHosts,
+        includeReputation: options.withReputation,
+        includeSessionMeta: options.includeSessionMeta,
+    });
+    if (options.json) {
+        console.log(JSON.stringify(board, null, 2));
+        return;
+    }
+    console.log(`Agent board${board.agent ? ` for ${board.agent}` : ''}${board.project ? ` (${board.project})` : ''}`);
+    console.log('');
+    console.log(`Current host: ${board.current_host}`);
+    if (board.all_hosts) {
+        console.log('Host filter: all-hosts');
+    }
+    else if (board.host_filter) {
+        console.log(`Host filter: ${board.host_filter}`);
+    }
+    if (options.withReputation && board.reputation_summary) {
+        console.log(`Reputation: tracked=${board.reputation_summary.tracked_agents}, avg_trust=${board.reputation_summary.avg_internal_trust}`);
+        if (board.agent_reputation) {
+            console.log(`Agent trust: ${board.agent_reputation.internal_trust} (cq=${board.agent_reputation.contribution_quality}, rv=${board.agent_reputation.review_reliability}, ct=${board.agent_reputation.continuity_hygiene})`);
+        }
+    }
+    console.log('');
+    console.log(`Active plans: ${board.active_plans.length}`);
+    for (const plan of board.active_plans.slice(0, 10)) {
+        const claims = plan.claims.length ? ` claims=${plan.claims.map((claim) => claim.agent).join(',')}` : '';
+        console.log(`  [${plan.id}] ${plan.text} (${plan.status}, ${plan.priority})${claims}`);
+    }
+    console.log('');
+    console.log(`Active claims: ${board.active_claims.length}`);
+    for (const claim of board.active_claims.slice(0, 10)) {
+        console.log(`  [${claim.id}] ${claim.agent} -> ${claim.scope}${claim.plan_id ? ` (plan ${claim.plan_id})` : ''}`);
+    }
+    console.log('');
+    const sessionMetaHint = board.session_meta_hidden > 0 ? ` (+${board.session_meta_hidden} session lifecycle notes hidden — use --include-session-meta to show)` : '';
+    console.log(`Runtime notes: ${board.runtime_notes.length}${sessionMetaHint}`);
+    for (const note of board.runtime_notes.slice(-10)) {
+        const scope = note.visibility === 'shared' ? 'shared' : `${note.visibility}:${note.host_id ?? 'unknown-host'}`;
+        console.log(`  [${note.id}] ${note.agent}: ${note.text}${note.plan_id ? ` (plan ${note.plan_id})` : ''} [${scope}]`);
+    }
+    console.log('');
+    console.log(`Open handoffs: ${board.open_handoffs.length}`);
+    for (const handoff of board.open_handoffs.slice(0, 10)) {
+        console.log(`  [${handoff.id}] ${handoff.from} -> ${handoff.to}: ${handoff.text}${handoff.plan_id ? ` (plan ${handoff.plan_id})` : ''}`);
+    }
+    console.log('');
+    console.log(`Resolved instructions: ${board.resolved_instructions.length}`);
+    for (const instruction of board.resolved_instructions.slice(0, 10)) {
+        console.log(`  [${instruction.id}] <${instruction.layer}${instruction.scope ? `:${instruction.scope}` : ''}> ${instruction.text}`);
+    }
+    // Capability routing
+    if (options.capabilities || options.suggest) {
+        const agents = listAgentIdentities();
+        if (agents.length === 0) {
+            console.log('');
+            console.log('No agents registered.');
+            return;
+        }
+        if (options.suggest) {
+            const query = options.suggest.toLowerCase();
+            const scored = agents
+                .map(a => ({
+                name: a.agent_name,
+                capabilities: a.capabilities ?? [],
+                score: (a.capabilities ?? []).filter(c => c.toLowerCase().includes(query)).length,
+                trust_level: a.trust_level ?? 'contributor',
+            }))
+                .filter(a => a.score > 0)
+                .sort((a, b) => b.score - a.score);
+            console.log('');
+            if (scored.length === 0) {
+                console.log(`No agents have capabilities matching '${options.suggest}'.`);
+            }
+            else {
+                console.log(`Suggested agents for '${options.suggest}':`);
+                for (const a of scored) {
+                    console.log(`  ${a.name} (${a.trust_level}) — ${a.capabilities.join(', ')}`);
+                }
+            }
+        }
+        else {
+            console.log('');
+            console.log(`Registered agents: ${agents.length}`);
+            for (const a of agents) {
+                const caps = (a.capabilities ?? []).length > 0 ? ` — ${a.capabilities.join(', ')}` : '';
+                const fingerprint = a.identity_key?.fingerprint ? ` fp=${a.identity_key.fingerprint.slice(0, 12)}` : '';
+                console.log(`  ${a.agent_name} (${a.trust_level ?? 'contributor'})${caps}${fingerprint}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=agent-board.js.map

package/dist/commands/audit.js

@@ -0,0 +1,35 @@
+import { readAuditLog } from '../core/audit.js';
+import { memoryExists } from '../core/io.js';
+export function runAuditCommand(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const entries = readAuditLog({
+        since: options.since,
+        actor: options.actor,
+        action: options.action,
+    });
+    const limited = options.limit ? entries.slice(-options.limit) : entries;
+    if (options.json) {
+        console.log(JSON.stringify(limited, null, 2));
+        return;
+    }
+    if (limited.length === 0) {
+        console.log('No audit entries found.');
+        return;
+    }
+    console.log(`Audit log — ${limited.length} entries:`);
+    console.log('');
+    for (const entry of limited) {
+        const parts = [entry.timestamp, `[${entry.actor}]`, entry.action];
+        if (entry.item_id)
+            parts.push(`→ ${entry.item_id}`);
+        if (entry.item_type)
+            parts.push(`(${entry.item_type})`);
+        if (entry.reason)
+            parts.push(`| ${entry.reason}`);
+        console.log(parts.join(' '));
+    }
+}
+//# sourceMappingURL=audit.js.map

package/dist/commands/bootstrap.js

@@ -0,0 +1,34 @@
+import { memoryExists } from '../core/io.js';
+import { renderBootstrapSummary, runBootstrapProfile } from '../core/bootstrap.js';
+export function runBootstrap(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    try {
+        const result = runBootstrapProfile({
+            target: options.for,
+            refresh: options.refresh,
+            cwd,
+        });
+        if (options.json) {
+            console.log(JSON.stringify({
+                summary: result.profile.summary,
+                target: result.profile.target,
+                repo_fingerprint: result.profile.repo_fingerprint,
+                sources_scanned: result.profile.sources_scanned,
+                seed_count: result.profile.seed_count,
+                seeds: result.seeds,
+                reused_profile: result.reusedProfile,
+            }, null, 2));
+            return;
+        }
+        console.log(renderBootstrapSummary(result));
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/commands/capability.js

@@ -0,0 +1,104 @@
+import { loadState, saveState } 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 { generateIdWithLabel, nowISO } from '../core/ids.js';
+import { loadConfig } from '../core/config.js';
+import { scanText } from '../core/security.js';
+import { validateCliInput } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+export function runCapability(subcommand, args, 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);
+    }
+    if (subcommand === 'list') {
+        runCapabilityList(cwd);
+    }
+    else if (subcommand === 'add') {
+        const name = args[0];
+        const description = args[1];
+        if (!name || !description) {
+            console.error('Error: capability add requires <name> <description>');
+            process.exit(1);
+        }
+        runCapabilityAdd(name, description, options, cwd);
+    }
+    else if (subcommand === 'describe') {
+        const capId = args[0];
+        if (!capId) {
+            console.error('Error: capability describe requires <id>');
+            process.exit(1);
+        }
+        runCapabilityDescribe(capId, cwd);
+    }
+    else {
+        console.error(`Unknown capability subcommand: ${subcommand}`);
+        process.exit(1);
+    }
+}
+function runCapabilityList(cwd) {
+    const state = loadState(cwd);
+    const capabilities = state.active_constraints
+        .filter((c) => c.tags.includes('capability'))
+        .map((c) => ({ id: c.id, name: c.text.split('\n')[0], tags: c.tags }));
+    if (capabilities.length === 0) {
+        console.log('No capabilities registered yet.');
+        return;
+    }
+    console.log(`\n${capabilities.length} capability(ies):\n`);
+    capabilities.forEach((cap) => {
+        console.log(`  [${cap.id}] ${cap.name}`);
+        if (cap.tags.length > 1) {
+            console.log(`      tags: ${cap.tags.filter((t) => t !== 'capability').join(', ')}`);
+        }
+    });
+    console.log('');
+}
+function runCapabilityAdd(name, description, options, cwd) {
+    validateCliInput(name + ' ' + description, options.tag);
+    const config = loadConfig(cwd);
+    const warnings = scanText(name + ': ' + description, 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);
+        }
+    }
+    const state = loadState(cwd);
+    const { id, short_label } = generateIdWithLabel('recent_decisions');
+    const entry = {
+        id,
+        short_label,
+        text: name,
+        created_at: nowISO(),
+        author: options.author ?? resolveCurrentAgentName(cwd),
+        tags: ['capability', ...(options.tag ?? [])],
+    };
+    // For now, store as decision to avoid schema migration
+    // Will migrate to separate capability storage in v0.16
+    state.recent_decisions.push(entry);
+    saveState(state, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(state));
+    console.log(`✔ Capability added: [${id}] ${name}`);
+    console.log('  (Stored in decisions for now; will move to dedicated registry in v0.16)');
+}
+function runCapabilityDescribe(capId, cwd) {
+    const state = loadState(cwd);
+    const decision = state.recent_decisions.find((d) => d.id === capId || d.short_label === capId);
+    if (!decision) {
+        console.error(`Error: capability '${capId}' not found`);
+        process.exit(1);
+    }
+    console.log(`\nCapability: ${decision.text}`);
+    console.log(`ID: ${decision.id}`);
+    console.log(`Author: ${decision.author}`);
+    console.log(`Created: ${decision.created_at}`);
+    if (decision.tags.length > 1) {
+        console.log(`Tags: ${decision.tags.filter((t) => t !== 'capability').join(', ')}`);
+    }
+    console.log('');
+}
+//# sourceMappingURL=capability.js.map

package/dist/commands/changes.js

@@ -0,0 +1,112 @@
+import { memoryExists } from '../core/io.js';
+import { getVisibleMemoryVersion, readContextMarker, writeContextMarker } from '../core/freshness.js';
+import { loadState } from '../core/state.js';
+import { listCandidates, listArchivedCandidates } from '../core/candidates.js';
+import { nowISO } from '../core/ids.js';
+import { logger } from '../core/logger.js';
+export function runDiff(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const usingMarker = !options.since;
+    let since;
+    const marker = usingMarker ? readContextMarker() : undefined;
+    if (options.since) {
+        since = new Date(options.since);
+        if (isNaN(since.getTime())) {
+            console.error(`Error: invalid date '${options.since}'. Use ISO 8601 format, e.g. 2026-03-14T10:00:00Z`);
+            process.exit(1);
+        }
+    }
+    else {
+        if (!marker) {
+            console.error('Error: no --since date provided and no .last-context marker found.');
+            console.error('Hint: Run `brainclaw context` first to set the marker, or use:');
+            console.error('  brainclaw diff --since <ISO date>');
+            process.exit(1);
+        }
+        since = new Date(marker.read_at);
+        if (isNaN(since.getTime())) {
+            console.error('Error: invalid date in .last-context marker.');
+            process.exit(1);
+        }
+    }
+    const sinceISO = since.toISOString();
+    const state = loadState();
+    const makeEntry = (section, type) => (e) => ({
+        id: e.id, entry_type: type, section, text: e.text, created_at: e.created_at,
+    });
+    const stateEntries = [
+        ...state.active_constraints.filter(e => e.created_at > sinceISO).map(makeEntry('active_constraints', 'constraint')),
+        ...state.recent_decisions.filter(e => e.created_at > sinceISO).map(makeEntry('recent_decisions', 'decision')),
+        ...state.known_traps.filter(e => e.created_at > sinceISO).map(makeEntry('known_traps', 'trap')),
+        ...state.open_handoffs.filter(e => e.created_at > sinceISO).map(makeEntry('open_handoffs', 'handoff')),
+    ].sort((a, b) => a.created_at.localeCompare(b.created_at));
+    const newPending = listCandidates('pending').filter(c => c.created_at > sinceISO);
+    const newAccepted = listArchivedCandidates('accepted').filter(c => (c.resolved_at ?? c.created_at) > sinceISO);
+    const total = stateEntries.length + newPending.length + newAccepted.length;
+    if (options.json) {
+        console.log(JSON.stringify({
+            since: sinceISO,
+            checked_at: new Date().toISOString(),
+            total_changes: total,
+            state_entries: stateEntries,
+            new_candidates: newPending,
+            accepted_candidates: newAccepted,
+        }, null, 2));
+    }
+    else {
+        if (total === 0) {
+            console.log(`No changes in .brainclaw/ since ${sinceISO}`);
+        }
+        else {
+            console.log(`Changes since ${sinceISO}:`);
+            if (marker?.memory_version) {
+                const currentVersion = getVisibleMemoryVersion();
+                if (marker.memory_version !== currentVersion) {
+                    console.log(`Visible memory version changed: ${marker.memory_version} -> ${currentVersion}`);
+                    console.log('');
+                }
+            }
+            console.log('');
+            if (stateEntries.length > 0) {
+                console.log(`New canonical entries (${stateEntries.length}):`);
+                for (const e of stateEntries) {
+                    console.log(`  + [${e.id}] (${e.entry_type}) ${e.text}`);
+                }
+            }
+            if (newPending.length > 0) {
+                if (stateEntries.length > 0)
+                    console.log('');
+                console.log(`New candidates pending review (${newPending.length}):`);
+                for (const c of newPending) {
+                    console.log(`  ? [${c.id}] (${c.type}) ${c.text}`);
+                }
+            }
+            if (newAccepted.length > 0) {
+                console.log('');
+                console.log(`Candidates accepted into memory (${newAccepted.length}):`);
+                for (const c of newAccepted) {
+                    console.log(`  \u2714 [${c.id}] (${c.type}) ${c.text}`);
+                }
+            }
+        }
+    }
+    if (usingMarker) {
+        try {
+            writeContextMarker({
+                read_at: nowISO(),
+                memory_version: getVisibleMemoryVersion(),
+                host_id: marker?.host_id,
+                target: marker?.target,
+                project: marker?.project,
+                all_hosts: marker?.all_hosts,
+            });
+        }
+        catch (err) {
+            logger.debug('Failed to write context marker:', err);
+        }
+    }
+}
+//# sourceMappingURL=changes.js.map