brainclaw 0.19.2

package/dist/commands/setup.js

@@ -0,0 +1,446 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { spawnSync } from 'node:child_process';
+import { runInit } from './init.js';
+import { detectAiAgent } from '../core/ai-agent-detection.js';
+import { buildMachineProfile, saveMachineProfile, loadMachineProfile } from '../core/machine-profile.js';
+import { buildAgentInventory, saveAgentInventory, loadAgentInventory } from '../core/agent-inventory.js';
+import { ensureClaudeCodeUserSettings, ensureClaudeCodeUserCommand, ensureCursorMcpConfig, ensureWindsurfMcpConfig, ensureAntigravityMcpConfig, ensureContinueUserMcpConfig, ensureCodexMcpConfig, writeDetectedAgentAutoConfig, describeAutoConfigWrite, ensureGitignoreEntries, collectWorkspaceGitignoreEntries, } from '../core/agent-files.js';
+import { MEMORY_DIR, memoryExists, ensureMemoryDir } from '../core/io.js';
+import { saveConfig, defaultConfig } from '../core/config.js';
+import { readSetupState, resolveHomeDir, writeSetupState } from '../core/setup-state.js';
+import { writeDetectedAgentHooks } from './hooks.js';
+export { readSetupState } from '../core/setup-state.js';
+// ─── Constants ────────────────────────────────────────────────────────────────
+export const ALL_KNOWN_AGENTS = [
+    'claude-code',
+    'cursor',
+    'windsurf',
+    'github-copilot',
+    'cline',
+    'codex',
+    'opencode',
+    'antigravity',
+    'continue',
+    'roo',
+];
+const BRAINCLAW_ASCII = [
+    '',
+    '    ╔╗ ┬─┐┌─┐┬┌┐┌╔═╗╦  ╔═╗╦ ╦',
+    '    ╠╩╗├┬┘├─┤││││║  ║  ╠═╣║║║',
+    '    ╚═╝┴└─┴ ┴┴┘└┘╚═╝╩═╝╴ ╴╚╩╝',
+    '',
+].join('\n');
+// ─── Step 0: Git check ────────────────────────────────────────────────────────
+export function checkGitPresence() {
+    const result = spawnSync('git', ['--version'], { encoding: 'utf-8' });
+    return !result.error && result.status === 0;
+}
+// ─── Step 1: Roots ────────────────────────────────────────────────────────────
+function getDefaultRoots(env = process.env) {
+    const home = resolveHomeDir(env) ?? '';
+    const candidates = ['Projects', 'dev', 'code', 'repos'].map((d) => path.join(home, d));
+    const existing = candidates.filter((p) => {
+        try {
+            return fs.statSync(p).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    return existing.length > 0 ? existing.join(',') : '';
+}
+export function parseRoots(input, env = process.env) {
+    const home = resolveHomeDir(env) ?? '';
+    const results = [];
+    for (const raw of input.split(',')) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        const resolved = trimmed.startsWith('~') ? trimmed.replace(/^~/, home) : trimmed;
+        try {
+            if (fs.statSync(resolved).isDirectory()) {
+                results.push(resolved);
+            }
+            else {
+                console.warn(`  ⚠ Not a directory: ${resolved}`);
+            }
+        }
+        catch {
+            console.warn(`  ⚠ Path not found: ${resolved}`);
+        }
+    }
+    return results;
+}
+// ─── Step 2: Scan repos ───────────────────────────────────────────────────────
+export function scanGitRepos(roots) {
+    const repos = [];
+    const seen = new Set();
+    for (const root of roots) {
+        const candidates = [root];
+        try {
+            const entries = fs.readdirSync(root, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                candidates.push(path.join(root, entry.name));
+            }
+        }
+        catch {
+            // skip unreadable dirs
+        }
+        for (const candidate of candidates) {
+            const repoPath = path.resolve(candidate);
+            if (seen.has(repoPath))
+                continue;
+            if (isBrainclawInternalPath(repoPath))
+                continue;
+            if (!fs.existsSync(path.join(repoPath, '.git')))
+                continue;
+            seen.add(repoPath);
+            repos.push({
+                path: repoPath,
+                name: path.basename(repoPath) || repoPath,
+                alreadyInitialised: memoryExists(repoPath),
+            });
+        }
+    }
+    return repos;
+}
+function isBrainclawInternalPath(candidate) {
+    const parts = path.resolve(candidate).split(path.sep).filter(Boolean);
+    return parts.includes(MEMORY_DIR);
+}
+// ─── Step 3: Repo selection ───────────────────────────────────────────────────
+export function parseRepoSelection(choice, repos, cwd = process.cwd()) {
+    const c = choice.trim().toLowerCase();
+    if (c === 'a' || c === 'all')
+        return repos;
+    if (c === 'c' || c === 'current') {
+        const curr = repos.find((r) => r.path === cwd)
+            ?? repos.find((r) => cwd.startsWith(r.path + path.sep));
+        return curr ? [curr] : [];
+    }
+    const indices = c
+        .split(',')
+        .map((n) => parseInt(n.trim(), 10) - 1)
+        .filter((i) => !isNaN(i) && i >= 0 && i < repos.length);
+    return indices.map((i) => repos[i]);
+}
+// ─── Step 4: Agent selection ──────────────────────────────────────────────────
+export function parseAgentSelection(choice, detected) {
+    const c = choice.trim().toLowerCase();
+    if (c === 'a' || c === 'all')
+        return [...ALL_KNOWN_AGENTS];
+    if (c === 'd' || c === 'detected')
+        return detected ? [detected] : [];
+    return c.split(',').map((a) => a.trim()).filter((a) => ALL_KNOWN_AGENTS.includes(a));
+}
+// ─── Step 5: Global install ───────────────────────────────────────────────────
+export function initUserStore(home, env = process.env) {
+    if (!home)
+        return [];
+    const written = [];
+    // Ensure ~/.brainclaw/ directory and subdirs exist
+    const userStorePath = path.join(home, '.brainclaw');
+    ensureMemoryDir(home);
+    // Check if config.yaml already exists (idempotent)
+    const configPath = path.join(userStorePath, 'config.yaml');
+    if (fs.existsSync(configPath)) {
+        return [];
+    }
+    try {
+        // Write a minimal config.yaml for the user store
+        const defaultCfg = defaultConfig('user-global');
+        saveConfig(defaultCfg, home);
+        // Append store_type: user to the config.yaml (pattern already used in tests)
+        fs.appendFileSync(configPath, 'store_type: user\n');
+        written.push(configPath);
+    }
+    catch (err) {
+        // Non-fatal: if user store init fails, continue with agent setup
+        console.warn(`Warning: failed to initialize user store at ${configPath}:`, err instanceof Error ? err.message : String(err));
+    }
+    return written;
+}
+export function runGlobalInstall(selectedAgents, env = process.env) {
+    const home = resolveHomeDir(env);
+    const written = [];
+    // Initialize user-global store first
+    if (home) {
+        written.push(...initUserStore(home, env));
+    }
+    // Generate machine profile if missing
+    try {
+        const existing = loadMachineProfile();
+        if (!existing) {
+            const profile = buildMachineProfile();
+            const profilePath = saveMachineProfile(profile);
+            written.push(profilePath);
+        }
+    }
+    catch {
+        // Non-fatal: machine profile is optional
+    }
+    // Generate agent inventory if missing
+    try {
+        const existingInv = loadAgentInventory();
+        if (!existingInv) {
+            const inventory = buildAgentInventory();
+            const inventoryPath = saveAgentInventory(inventory);
+            written.push(inventoryPath);
+        }
+    }
+    catch {
+        // Non-fatal: agent inventory is optional
+    }
+    if (selectedAgents.includes('claude-code')) {
+        const s = ensureClaudeCodeUserSettings(home, env);
+        if (s && (s.created || s.updated))
+            written.push(s.filePath);
+        const c = ensureClaudeCodeUserCommand(home);
+        if (c && (c.created || c.updated))
+            written.push(c.filePath);
+    }
+    if (selectedAgents.includes('cursor')) {
+        const r = ensureCursorMcpConfig(home);
+        if (r && (r.created || r.updated))
+            written.push(r.filePath);
+    }
+    if (selectedAgents.includes('windsurf')) {
+        const r = ensureWindsurfMcpConfig(home);
+        if (r && (r.created || r.updated))
+            written.push(r.filePath);
+    }
+    if (selectedAgents.includes('antigravity')) {
+        const r = ensureAntigravityMcpConfig(home);
+        if (r && (r.created || r.updated))
+            written.push(r.filePath);
+    }
+    if (selectedAgents.includes('continue')) {
+        const r = ensureContinueUserMcpConfig(home);
+        if (r && (r.created || r.updated))
+            written.push(r.filePath);
+    }
+    if (selectedAgents.includes('codex')) {
+        const r = ensureCodexMcpConfig(home, env);
+        if (r && (r.created || r.updated))
+            written.push(r.filePath);
+    }
+    return written;
+}
+// ─── Step 6: Init repos + configure agents ────────────────────────────────────
+export async function initReposAndConfigureAgents(selectedRepos, selectedAgents, env = process.env) {
+    const initialisedRepos = [];
+    const configActions = [];
+    for (const repo of selectedRepos) {
+        if (repo.alreadyInitialised) {
+            console.log(`  [skip] ${repo.name} — already initialised`);
+            continue;
+        }
+        console.log(`  → Initialising ${repo.name}...`);
+        await runInit({ yes: true, skipAgentBootstrap: true, skipSetupRequirement: true, cwd: repo.path });
+        initialisedRepos.push(repo.path);
+    }
+    for (const repo of selectedRepos) {
+        const gitignoreEntries = new Set();
+        for (const agentName of selectedAgents) {
+            const configs = writeDetectedAgentAutoConfig(agentName, repo.path, env);
+            for (const entry of collectWorkspaceGitignoreEntries(repo.path, configs)) {
+                gitignoreEntries.add(entry);
+            }
+            for (const config of configs) {
+                const msg = describeAutoConfigWrite(config);
+                if (msg) {
+                    console.log(`  ${msg}`);
+                    configActions.push(msg);
+                }
+            }
+            const hooks = writeDetectedAgentHooks(agentName, repo.name, repo.path);
+            for (const hook of hooks) {
+                gitignoreEntries.add(hook.relativePath);
+            }
+            for (const hook of hooks) {
+                if (hook.created) {
+                    const msg = `✔ Created hook at ${hook.relativePath}`;
+                    console.log(`  ${msg}`);
+                    configActions.push(msg);
+                }
+            }
+        }
+        if (gitignoreEntries.size > 0) {
+            ensureGitignoreEntries(repo.path, [...gitignoreEntries]);
+            console.log(`  ✔ Updated .gitignore with generated agent files (${[...gitignoreEntries].join(', ')})`);
+        }
+    }
+    return { initialisedRepos, configActions };
+}
+// ─── Step 7: Reload reminder ──────────────────────────────────────────────────
+export function printReloadReminder(detectedAgent) {
+    console.log('');
+    console.log('✔ Setup complete! Reload your AI agent session to activate brainclaw MCP tools.');
+    if (detectedAgent === 'claude-code') {
+        console.log('  → In VS Code: Cmd/Ctrl+Shift+P → "Claude: Reload MCP Servers"');
+    }
+    else if (detectedAgent === 'cursor') {
+        console.log('  → In Cursor: restart the editor');
+    }
+    else if (detectedAgent === 'windsurf') {
+        console.log('  → In Windsurf: restart the editor');
+    }
+    else if (detectedAgent === 'continue') {
+        console.log('  → In VS Code: reload the Continue extension');
+    }
+    else {
+        console.log('  → Restart your AI coding agent to pick up the new MCP configuration.');
+    }
+}
+// ─── Main CLI wizard ──────────────────────────────────────────────────────────
+export async function runSetup(options = {}) {
+    const env = process.env;
+    // Step 0: Git check
+    if (!checkGitPresence()) {
+        console.error(BRAINCLAW_ASCII);
+        console.error('brainclaw needs git to work.');
+        console.error('Install git from https://git-scm.com and try again.');
+        process.exit(1);
+    }
+    // Check if already run
+    const existingState = readSetupState(env);
+    if (existingState && !options.yes && process.stdin.isTTY) {
+        const date = new Date(existingState.completed_at).toLocaleDateString();
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question(`Setup already run on ${date}. Re-run? [y/N]: `)).trim().toLowerCase();
+            if (answer !== 'y' && answer !== 'yes') {
+                console.log('Aborted.');
+                return;
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    // Step 1: Project roots
+    let rootsInput;
+    if (options.roots) {
+        rootsInput = options.roots;
+    }
+    else if (options.yes || !process.stdin.isTTY) {
+        rootsInput = process.cwd();
+    }
+    else {
+        const defaultRoots = getDefaultRoots(env);
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const prompt = defaultRoots
+                ? `Where are your projects? [${defaultRoots}]: `
+                : 'Where are your projects? Enter one or more root directories (comma-separated): ';
+            const answer = (await rl.question(prompt)).trim();
+            rootsInput = answer || defaultRoots || process.cwd();
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const roots = parseRoots(rootsInput, env);
+    if (roots.length === 0) {
+        console.error('No valid project root directories found. Aborting.');
+        process.exit(1);
+    }
+    // Step 2: Scan repos
+    console.log('\nScanning for git repositories...');
+    const repos = scanGitRepos(roots);
+    if (repos.length === 0) {
+        console.log('No git repositories found in the specified roots.');
+        console.log('Tip: run `brainclaw init` from within a project directory.');
+        return;
+    }
+    console.log(`Found ${repos.length} repository candidate(s):`);
+    repos.forEach((r, i) => {
+        const status = r.alreadyInitialised ? '[✔ init]' : '[      ]';
+        console.log(`  ${i + 1}) ${status} ${r.name}  (${r.path})`);
+    });
+    // Step 3: Repo selection
+    let repoChoice;
+    if (options.repos) {
+        repoChoice = options.repos;
+    }
+    else if (options.yes || !process.stdin.isTTY) {
+        repoChoice = 'all';
+    }
+    else {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            repoChoice = (await rl.question('\nInitialise: (a)ll, (c)urrent dir, or enter numbers e.g. 1,3 [all]: ')).trim() || 'all';
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const selectedRepos = parseRepoSelection(repoChoice, repos);
+    if (selectedRepos.length === 0) {
+        console.log('No repositories selected. Aborting.');
+        return;
+    }
+    console.log(`\nSelected ${selectedRepos.length} repository(s).`);
+    // Step 4: Agent detection & selection
+    const detectedAi = detectAiAgent(env);
+    const detectedName = detectedAi?.name;
+    console.log('');
+    if (detectedName) {
+        console.log(`Detected AI agent: ${detectedName}`);
+    }
+    else {
+        console.log('No AI agent detected automatically.');
+    }
+    console.log('Supported agents:');
+    ALL_KNOWN_AGENTS.forEach((a, i) => {
+        const tag = a === detectedName ? ' ← detected' : '';
+        console.log(`  ${i + 1}) ${a}${tag}`);
+    });
+    let agentChoice;
+    if (options.agents) {
+        agentChoice = options.agents;
+    }
+    else if (options.yes || !process.stdin.isTTY) {
+        agentChoice = detectedName ? 'detected' : 'all';
+    }
+    else {
+        const defaultChoice = detectedName ? 'detected' : 'all';
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            agentChoice = (await rl.question(`Configure agents: (d)etected, (a)ll, or numbers e.g. 1,3 [${defaultChoice}]: `)).trim() || defaultChoice;
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const selectedAgents = parseAgentSelection(agentChoice, detectedName);
+    console.log(`Selected agents: ${selectedAgents.length === 0 ? '(none)' : selectedAgents.join(', ')}`);
+    // Step 5: Global install
+    console.log('\n→ Installing global brainclaw prerequisites...');
+    const written = runGlobalInstall(selectedAgents, env);
+    if (written.length > 0) {
+        for (const f of written)
+            console.log(`  ✔ ${f}`);
+    }
+    else {
+        console.log('  (all global prerequisites already up to date)');
+    }
+    // Step 6: Init repos + configure agents
+    console.log('\n→ Initialising repositories and configuring agents...');
+    const { initialisedRepos, configActions } = await initReposAndConfigureAgents(selectedRepos, selectedAgents, env);
+    // Save state
+    writeSetupState({
+        completed_at: new Date().toISOString(),
+        roots,
+        initialised_repos: initialisedRepos,
+        global_configs_written: selectedAgents,
+    }, env);
+    // Step 7: Reload reminder
+    printReloadReminder(detectedName);
+    void configActions;
+}
+//# sourceMappingURL=setup.js.map

package/dist/commands/show-candidate.js

@@ -0,0 +1,31 @@
+import { memoryExists } from '../core/io.js';
+import { loadCandidate, listCandidates } from '../core/candidates.js';
+export function runShowCandidate(id, options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    try {
+        const candidate = loadCandidate(id);
+        if (!options.related) {
+            console.log(JSON.stringify(candidate, null, 2));
+            return;
+        }
+        // Find related candidates by shared tags or related_paths
+        const allPending = listCandidates('pending').filter(c => c.id !== id);
+        const cTags = new Set(candidate.tags ?? []);
+        const cPaths = new Set(candidate.related_paths ?? []);
+        const related = allPending.filter(c => {
+            const sharedTag = (c.tags ?? []).some(t => cTags.has(t));
+            const sharedPath = (c.related_paths ?? []).some(p => cPaths.has(p));
+            return sharedTag || sharedPath;
+        });
+        console.log(JSON.stringify({ ...candidate, related_candidates: related }, null, 2));
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=show-candidate.js.map

package/dist/commands/star-candidate.js

@@ -0,0 +1,28 @@
+import { memoryExists } from '../core/io.js';
+import { addCandidateStar } from '../core/candidates.js';
+import { loadConfig } from '../core/config.js';
+export function runStarCandidate(id, options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const actor = options.by ?? process.env.USER ?? process.env.USERNAME ?? 'unknown';
+    try {
+        const { candidate, added } = addCandidateStar(id, actor);
+        const threshold = loadConfig().reflective_memory?.promotion_stars_threshold ?? 3;
+        if (!added) {
+            console.log(`✔ Candidate [${id}] was already starred by ${actor} (${candidate.star_count} star(s))`);
+            return;
+        }
+        const recommendation = candidate.star_count >= threshold
+            ? ' Promotion is now recommended.'
+            : '';
+        console.log(`✔ Candidate [${id}] starred by ${actor} (${candidate.star_count}/${threshold})${recommendation}`);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=star-candidate.js.map

package/dist/commands/status.js

@@ -0,0 +1,133 @@
+import { listAgentIdentities } from '../core/agent-registry.js';
+import { loadConfig } from '../core/config.js';
+import { resolveCurrentHostId } from '../core/host.js';
+import { listClaims } from '../core/claims.js';
+import { loadInstructions } from '../core/instructions.js';
+import { buildReputationSnapshot } from '../core/reputation.js';
+import { listRuntimeNotes } from '../core/runtime.js';
+import { loadState } from '../core/state.js';
+import { isTrapActive, listOperationalTraps } from '../core/traps.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { memoryExists } from '../core/io.js';
+function printHumanStatus(state, config) {
+    const activePlans = state.plan_items.filter((plan) => plan.status !== 'done' && plan.status !== 'dropped');
+    const activeInstructions = loadInstructions().filter((entry) => entry.active);
+    const activeClaims = listClaims().filter((claim) => claim.status === 'active');
+    const registeredAgents = listAgentIdentities();
+    const currentHost = resolveCurrentHostId();
+    const sharedRuntimeNotes = listRuntimeNotes({ visibility: 'shared' });
+    const machineRuntimeNotes = listRuntimeNotes({ visibility: 'machine' });
+    const machineTraps = listOperationalTraps({ visibility: 'machine' });
+    const activeSharedTraps = state.known_traps.filter((trap) => isTrapActive(trap));
+    const resolvedSharedTraps = state.known_traps.filter((trap) => trap.status === 'resolved');
+    const activeMachineTraps = machineTraps.filter((trap) => isTrapActive(trap));
+    const counts = {
+        instructions: activeInstructions.length,
+        claims: activeClaims.length,
+        runtime: sharedRuntimeNotes.length + machineRuntimeNotes.length,
+        plans: activePlans.length,
+        constraints: state.active_constraints.length,
+        decisions: state.recent_decisions.length,
+        traps: activeSharedTraps.length + activeMachineTraps.length,
+        handoffs: state.open_handoffs.length,
+    };
+    const total = counts.instructions + counts.claims + counts.runtime + counts.plans + counts.constraints + counts.decisions + counts.traps + counts.handoffs;
+    console.log(`Project memory: ${total} item(s)`);
+    console.log('');
+    console.log(`  Project ID  : ${config.project_id ?? 'unknown'}`);
+    console.log(`  Current agent: ${config.current_agent ?? 'unknown'}${config.current_agent_id ? ` (${config.current_agent_id})` : ''}`);
+    console.log(`  Registered  : ${registeredAgents.length} agent(s)`);
+    console.log(`  Storage dir : ${config.storage_dir}`);
+    console.log(`  Topology    : ${config.topology}`);
+    console.log(`  Project mode: ${config.project_mode}`);
+    console.log(`  Strategy    : ${config.projects.strategy}`);
+    console.log(`  Instructions: ${counts.instructions}`);
+    console.log(`  Claims      : ${counts.claims}`);
+    console.log(`  Runtime     : ${sharedRuntimeNotes.length} shared, ${machineRuntimeNotes.length} machine-local (${currentHost})`);
+    console.log(`  Plans       : ${counts.plans}`);
+    console.log(`  Constraints : ${counts.constraints}`);
+    console.log(`  Decisions   : ${counts.decisions}`);
+    console.log(`  Traps       : ${activeSharedTraps.length} active shared, ${resolvedSharedTraps.length} resolved shared, ${activeMachineTraps.length} active machine-local (${currentHost})`);
+    console.log(`  Handoffs    : ${counts.handoffs}`);
+    if (config.project_mode === 'multi-project') {
+        console.log(`  Projects    : ${config.projects.known.length}`);
+    }
+    // Show recent items (last 3 per section)
+    const sections = [
+        { label: 'Shared instructions', items: activeInstructions },
+        { label: 'Active claims', items: activeClaims },
+        { label: 'Shared plan', items: activePlans },
+        { label: 'Active constraints', items: state.active_constraints },
+        { label: 'Recent decisions', items: state.recent_decisions },
+        { label: 'Known traps', items: activeSharedTraps },
+        { label: 'Open handoffs', items: state.open_handoffs },
+    ];
+    for (const section of sections) {
+        if (section.items.length > 0) {
+            console.log('');
+            console.log(`  ${section.label}:`);
+            const recent = section.items.slice(-3);
+            for (const item of recent) {
+                const text = 'text' in item ? item.text : '';
+                console.log(`    [${item.id}] ${text}`);
+            }
+            if (section.items.length > 3) {
+                console.log(`    ... and ${section.items.length - 3} more`);
+            }
+        }
+    }
+    // Warnings
+    const openHandoffs = state.open_handoffs.filter(h => h.status === 'open');
+    if (openHandoffs.length > 0) {
+        console.log('');
+        console.log(`  ⚠ ${openHandoffs.length} open handoff(s) pending`);
+    }
+}
+export function runStatus(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const state = loadState();
+    const currentHost = resolveCurrentHostId();
+    const sharedRuntimeNotes = listRuntimeNotes({ visibility: 'shared' });
+    const machineRuntimeNotes = listRuntimeNotes({ visibility: 'machine' });
+    const machineTraps = listOperationalTraps({ visibility: 'machine' });
+    const activeSharedTraps = state.known_traps.filter((trap) => isTrapActive(trap));
+    const resolvedSharedTraps = state.known_traps.filter((trap) => trap.status === 'resolved');
+    const activeMachineTraps = machineTraps.filter((trap) => isTrapActive(trap));
+    const registeredAgents = listAgentIdentities();
+    const reputation = buildReputationSnapshot();
+    if (options.json) {
+        console.log(JSON.stringify({
+            config,
+            agents: {
+                current_name: config.current_agent,
+                current_id: config.current_agent_id,
+                registered: registeredAgents,
+            },
+            state,
+            runtime: {
+                current_host: currentHost,
+                shared: sharedRuntimeNotes.length,
+                machine_local: machineRuntimeNotes.length,
+            },
+            traps: {
+                shared_active: activeSharedTraps.length,
+                shared_resolved: resolvedSharedTraps.length,
+                machine_local_active: activeMachineTraps.length,
+                total_shared: state.known_traps.length,
+                total_machine_local: machineTraps.length,
+            },
+            reputation,
+        }, null, 2));
+        return;
+    }
+    if (options.markdown) {
+        console.log(generateMarkdown(state));
+        return;
+    }
+    printHumanStatus(state, config);
+}
+//# sourceMappingURL=status.js.map