brainclaw 0.19.2

package/dist/commands/init.js

@@ -0,0 +1,356 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { registerAgentIdentity, resolveDefaultAgentName, resolveExistingCurrentAgent } from '../core/agent-registry.js';
+import { MEMORY_DIR, memoryExists, ensureMemoryDir, memoryPath, writeFileAtomic } from '../core/io.js';
+import { emptyState, loadState, saveState } from '../core/state.js';
+import { defaultConfig, saveConfig } from '../core/config.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { initMemoryRepo } from '../core/memory-git.js';
+import { buildProjectIdentity, resolveExistingProjectIdentity, saveProjectIdentity } from '../core/project-registry.js';
+import { scanProject, upsertProject } from '../core/global-registry.js';
+import { analyzeRepository, scanWorkspaceBoundaries } from '../core/repo-analysis.js';
+import { isAgentIntegrationName, upsertAgentIntegrationDeclaration } from '../core/agent-integrations.js';
+import { describeAutoConfigWrite, ensureAgentFiles, ensureGitignoreEntries, writeDetectedAgentAutoConfig } from '../core/agent-files.js';
+import { detectAiAgent, detectWslEnvironment } from '../core/ai-agent-detection.js';
+import { hasCompletedSetup } from '../core/setup-state.js';
+import { writeDetectedAgentExport } from './export.js';
+import { writeDetectedAgentHooks } from './hooks.js';
+export async function runInit(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const containingMemoryStore = resolveContainingMemoryStore(cwd);
+    const skipSetupRequirement = options.skipSetupRequirement === true || process.env.BRAINCLAW_SKIP_SETUP_REQUIREMENT === '1';
+    if (!skipSetupRequirement && !hasCompletedSetup()) {
+        console.error('Error: global brainclaw setup has not been completed on this machine.');
+        console.error('Run `brainclaw setup` first, then retry `brainclaw init` from your project root.');
+        process.exit(1);
+    }
+    if (containingMemoryStore) {
+        console.error(`Error: cannot run \`brainclaw init\` from inside an existing project memory store (${containingMemoryStore}).`);
+        console.error('Run `brainclaw init` from the project root directory instead.');
+        process.exit(1);
+    }
+    // --scan: detect service boundaries and suggest init targets, then exit
+    if (options.scan) {
+        const { suggestions, alreadyInitialised } = scanWorkspaceBoundaries(cwd);
+        if (alreadyInitialised.length > 0) {
+            console.log(`Already initialised (${alreadyInitialised.length}):`);
+            for (const { relativePath } of alreadyInitialised) {
+                console.log(`  ✔ ./${relativePath}`);
+            }
+            console.log('');
+        }
+        if (suggestions.length === 0) {
+            console.log('No service boundaries detected in subdirectories.');
+        }
+        else {
+            console.log(`Detected ${suggestions.length} service boundary candidate(s):`);
+            for (const { relativePath, markers } of suggestions) {
+                console.log(`  → ./${relativePath}  [${markers.join(', ')}]`);
+                console.log(`    cd ${relativePath} && brainclaw init -y`);
+            }
+        }
+        return;
+    }
+    const existingIdentity = resolveExistingProjectIdentity(cwd);
+    const existingCurrentAgent = resolveExistingCurrentAgent(cwd);
+    const storageDir = resolveStorageDir(options.storageDir);
+    const topology = resolveTopology(options.topology);
+    const ignoreStrategy = topology === 'embedded' ? 'none' : 'project-gitignore';
+    const skipAgentBootstrap = options.skipAgentBootstrap === true || process.env.BRAINCLAW_SKIP_AGENT_BOOTSTRAP === '1';
+    if (memoryExists(cwd) && !options.force) {
+        console.error('Error: project memory already exists. Use --force to overwrite.');
+        process.exit(1);
+    }
+    // Derive project name from directory
+    const projectName = path.basename(cwd);
+    const shouldAnalyzeRepo = options.analyzeRepo !== false
+        && process.env.BRAINCLAW_SKIP_REPO_ANALYSIS !== '1';
+    const analysis = shouldAnalyzeRepo ? analyzeRepository(cwd) : undefined;
+    const projectMode = await resolveProjectMode(options, analysis);
+    const projectStrategy = await resolveProjectStrategy(options, projectMode);
+    ensureMemoryDir(cwd, storageDir);
+    const currentAgent = registerAgentIdentity({
+        agentName: existingCurrentAgent?.agent_name ?? resolveDefaultAgentName(),
+        kind: existingCurrentAgent?.kind ?? 'human',
+        trustLevel: 'curator',
+        cwd,
+        preferredDirName: storageDir,
+    });
+    // Auto-detect and register the AI coding agent running in this environment
+    const detectedAi = skipAgentBootstrap ? undefined : detectAiAgent();
+    let registeredAiAgent = detectedAi
+        ? registerAgentIdentity({
+            agentName: detectedAi.name,
+            kind: detectedAi.kind,
+            trustLevel: detectedAi.trust_level,
+            cwd,
+            preferredDirName: storageDir,
+        })
+        : undefined;
+    // Only write empty state if no data exists yet.
+    // When --force is used on an existing project, preserve the data
+    // and only refresh config/agent registration/directory structure.
+    const existingState = loadState(cwd);
+    const hasExistingData = existingState.active_constraints.length > 0 ||
+        existingState.recent_decisions.length > 0 ||
+        existingState.known_traps.length > 0 ||
+        existingState.open_handoffs.length > 0 ||
+        existingState.plan_items.length > 0;
+    if (!hasExistingData) {
+        saveState(emptyState(), cwd);
+    }
+    // Create config
+    const projectIdentity = buildProjectIdentity({
+        existing: existingIdentity,
+        projectName,
+        storageDir,
+        topology,
+    });
+    const config = defaultConfig(projectName, {
+        projectId: projectIdentity.project_id,
+        currentAgent: currentAgent.agent_name,
+        currentAgentId: currentAgent.agent_id,
+        projectMode,
+        projectStrategy,
+        storageDir,
+        topology,
+        ignoreStrategy,
+    });
+    if (options.compact) {
+        config.markdown = { max_items_per_section: 20, compact_mode: true };
+    }
+    if (detectedAi && isAgentIntegrationName(detectedAi.name)) {
+        upsertAgentIntegrationDeclaration(config, detectedAi.name, 'detected');
+    }
+    saveConfig(config, cwd, storageDir);
+    saveProjectIdentity(projectIdentity, cwd, storageDir);
+    // Write to the detected agent's native instruction file after config exists.
+    const detectedExport = detectedAi ? writeDetectedAgentExport(detectedAi.name, cwd) : undefined;
+    // Write deterministic session-trigger hooks for Cursor / Windsurf
+    const detectedHooks = detectedAi
+        ? (detectedAi.name === 'windsurf'
+            ? []
+            : writeDetectedAgentHooks(detectedAi.name, projectName, cwd)
+                .filter((hook) => hook.relativePath !== detectedExport?.relativePath))
+        : [];
+    const detectedAutoConfig = detectedAi ? writeDetectedAgentAutoConfig(detectedAi.name, cwd) : [];
+    // Register in global project registry
+    try {
+        const entry = scanProject(cwd);
+        if (entry)
+            upsertProject(entry);
+    }
+    catch {
+        // Non-fatal: global registry is optional
+    }
+    // Create project.md
+    const md = generateMarkdown(loadState(cwd));
+    writeFileAtomic(memoryPath('project.md', cwd, storageDir), md);
+    if (ignoreStrategy === 'project-gitignore') {
+        ensureProjectGitignore(cwd, storageDir);
+    }
+    // Create or update AGENTS.md and .github/copilot-instructions.md
+    const agentFiles = skipAgentBootstrap
+        ? {
+            agentsMdCreated: false,
+            agentsMdUpdated: false,
+            copilotInstructionsCreated: false,
+            copilotInstructionsUpdated: false,
+        }
+        : ensureAgentFiles(cwd, storageDir);
+    // Add agent instruction files to .gitignore (they are generated, not source)
+    if (!skipAgentBootstrap) {
+        const generatedWorkspacePaths = detectedAutoConfig
+            .map((item) => item.relativePath)
+            .filter((item) => item !== undefined)
+            .filter((item) => !item.startsWith('.codeium/'));
+        ensureGitignoreEntries(cwd, ['AGENTS.md', '.github/copilot-instructions.md', ...generatedWorkspacePaths]);
+    }
+    console.log(`✔ Initialized project memory in ${storageDir}/`);
+    console.log('✔ Created project.md, config.yaml, and split state directories');
+    console.log(`✔ Project ID: ${projectIdentity.project_id}`);
+    console.log(`✔ Current agent: ${currentAgent.agent_name} (${currentAgent.agent_id})`);
+    if (registeredAiAgent) {
+        console.log(`✔ AI agent detected: ${registeredAiAgent.agent_name} [${detectedAi.detection_source}] (${registeredAiAgent.agent_id})`);
+    }
+    if (detectedExport) {
+        console.log(`\u2714 Agent instructions written to ${detectedExport.relativePath} (${detectedExport.created ? 'created' : 'updated'})`);
+    }
+    for (const hook of detectedHooks) {
+        console.log(`\u2714 Session hook written to ${hook.relativePath} (${hook.created ? 'created' : 'updated'})`);
+    }
+    console.log(`\u2714 Topology: ${topology}`);
+    console.log(`✔ Storage dir: ${storageDir}`);
+    console.log(`✔ Project mode: ${projectMode}`);
+    if (projectMode === 'multi-project') {
+        console.log(`✔ Project strategy: ${projectStrategy}`);
+    }
+    if (ignoreStrategy === 'project-gitignore') {
+        console.log(`✔ Added ${storageDir}/ to .gitignore`);
+    }
+    if (agentFiles.agentsMdCreated) {
+        console.log('✔ Created AGENTS.md with brainclaw bootstrap section');
+    }
+    else if (agentFiles.agentsMdUpdated) {
+        console.log('✔ Updated AGENTS.md with brainclaw bootstrap section');
+    }
+    if (agentFiles.copilotInstructionsCreated) {
+        console.log('✔ Created .github/copilot-instructions.md with brainclaw bootstrap section');
+    }
+    else if (agentFiles.copilotInstructionsUpdated) {
+        console.log('✔ Updated .github/copilot-instructions.md with brainclaw bootstrap section');
+    }
+    for (const autoConfig of detectedAutoConfig) {
+        const message = describeAutoConfigWrite(autoConfig);
+        if (message) {
+            console.log(message);
+        }
+    }
+    if (!skipAgentBootstrap) {
+        console.log('✔ Added generated agent files to .gitignore');
+    }
+    if (analysis) {
+        console.log('');
+        console.log(`Recommended project mode: ${analysis.recommendedMode}`);
+        for (const reason of analysis.reasons) {
+            console.log(`  - ${reason}`);
+        }
+    }
+    const wsl = detectWslEnvironment();
+    if (wsl) {
+        console.log('');
+        console.log(`⚠  WSL detected (${wsl.distro}). brainclaw is installed in this WSL environment only.`);
+        console.log(`   To use brainclaw from a Windows terminal (PowerShell/cmd), run inside this project:`);
+        console.log(`     npm link    (in PowerShell, with Node.js for Windows)`);
+    }
+    // Initialize internal git repo for memory versioning
+    if (initMemoryRepo(cwd)) {
+        console.log('✔ Initialized memory git repo for versioning');
+    }
+    console.log('');
+    console.log(`Tip: run 'brainclaw context --json' to load the shared memory into your agent session.`);
+}
+function resolveStorageDir(storageDir) {
+    const candidate = (storageDir ?? MEMORY_DIR).trim();
+    if (candidate !== MEMORY_DIR) {
+        console.error(`Error: custom storage directories are no longer supported. Use "${MEMORY_DIR}".`);
+        process.exit(1);
+    }
+    return candidate;
+}
+function resolveContainingMemoryStore(cwd) {
+    let current = path.resolve(cwd);
+    while (true) {
+        if (path.basename(current) === MEMORY_DIR && looksLikeBrainclawStore(current)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+function looksLikeBrainclawStore(storePath) {
+    return fs.existsSync(path.join(storePath, 'config.yaml'))
+        || fs.existsSync(path.join(storePath, 'project.identity.json'))
+        || fs.existsSync(path.join(storePath, '.git'));
+}
+function resolveTopology(topology) {
+    return topology ?? 'embedded';
+}
+function ensureProjectGitignore(cwd, storageDir) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const ignoreLine = `${storageDir}/`;
+    const current = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf-8') : '';
+    const lines = current.split(/\r?\n/).filter((line) => line.length > 0);
+    if (lines.includes(ignoreLine)) {
+        return;
+    }
+    const next = current.length === 0
+        ? `${ignoreLine}\n`
+        : `${current.replace(/\s*$/, '')}\n${ignoreLine}\n`;
+    fs.writeFileSync(gitignorePath, next, 'utf-8');
+}
+async function resolveProjectMode(options, analysis) {
+    if (options.projectMode) {
+        return options.projectMode;
+    }
+    if (options.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
+        return 'auto';
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        console.log('How is this repository organized?');
+        console.log('  1) single-project - Use one shared memory space for the whole repository.');
+        console.log('  2) multi-project  - Segment memory across multiple projects or domains in this repository.');
+        console.log('  3) auto           - Start simple now and allow project segmentation later.');
+        if (analysis) {
+            console.log(`Suggested mode: ${analysis.recommendedMode}`);
+        }
+        const answer = (await rl.question('Select project mode [auto]: ')).trim().toLowerCase();
+        return parseProjectMode(answer) ?? 'auto';
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveProjectStrategy(options, projectMode) {
+    if (options.projectStrategy) {
+        return options.projectStrategy;
+    }
+    if (projectMode !== 'multi-project') {
+        return 'manual';
+    }
+    if (options.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
+        return 'manual';
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        console.log('How should project boundaries be managed?');
+        console.log('  1) manual - Projects are named explicitly and assigned later.');
+        console.log('  2) folder - Use folder paths as the default way to infer project boundaries.');
+        const answer = (await rl.question('Select project strategy [manual]: ')).trim().toLowerCase();
+        return parseProjectStrategy(answer) ?? 'manual';
+    }
+    finally {
+        rl.close();
+    }
+}
+function parseProjectMode(value) {
+    switch (value) {
+        case '1':
+        case 'single-project':
+        case 'single':
+            return 'single-project';
+        case '2':
+        case 'multi-project':
+        case 'multi':
+            return 'multi-project';
+        case '3':
+        case 'auto':
+            return 'auto';
+        default:
+            return undefined;
+    }
+}
+function parseProjectStrategy(value) {
+    switch (value) {
+        case '1':
+        case 'manual':
+            return 'manual';
+        case '2':
+        case 'folder':
+            return 'folder';
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/install-hooks.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { memoryExists } from '../core/io.js';
+export function runInstallHooks(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const gitRoot = findGitRoot(process.cwd());
+    if (!gitRoot) {
+        console.error('Error: no .git/ directory found. Is this a Git repository?');
+        process.exit(1);
+    }
+    const hooksDir = path.join(gitRoot, '.git', 'hooks');
+    if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+    }
+    const hookPath = path.join(hooksDir, 'pre-commit');
+    if (fs.existsSync(hookPath) && !options.force) {
+        console.error(`Error: pre-commit hook already exists at ${hookPath}`);
+        console.error('Use --force to overwrite.');
+        process.exit(1);
+    }
+    fs.writeFileSync(hookPath, generateHookScript(), { encoding: 'utf-8', mode: 0o755 });
+    console.log(`✔ pre-commit hook installed at ${hookPath}`);
+    console.log('  Checks: sensitive content in .brainclaw/ + active constraint violations.');
+    console.log('  To bypass (not recommended): git commit --no-verify');
+    const postMergePath = path.join(hooksDir, 'post-merge');
+    if (!fs.existsSync(postMergePath) || options.force) {
+        fs.writeFileSync(postMergePath, generatePostMergeScript(), { encoding: 'utf-8', mode: 0o755 });
+        console.log(`✔ post-merge hook installed at ${postMergePath}`);
+        console.log('  Auto-releases claims whose scope was touched by the merge.');
+    }
+}
+function generatePostMergeScript() {
+    return `#!/bin/sh
+# brainclaw post-merge hook
+# Auto-releases claims whose scope overlaps with files changed by the merge
+# Generated by: brainclaw install-hooks
+
+BCLAW_CMD=""
+if command -v brainclaw >/dev/null 2>&1; then
+  BCLAW_CMD="brainclaw"
+elif command -v bclaw >/dev/null 2>&1; then
+  BCLAW_CMD="bclaw"
+else
+  BCLAW_CMD="npx --no brainclaw"
+fi
+
+$BCLAW_CMD release-claims --from-git-diff 2>/dev/null || true
+`;
+}
+function findGitRoot(cwd) {
+    let dir = cwd;
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.git')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function generateHookScript() {
+    return `#!/bin/sh
+# brainclaw pre-commit hook
+# 1. Blocks commits if sensitive content is detected in .brainclaw/
+# 2. Blocks commits if staged files are covered by an active constraint
+# Generated by: brainclaw install-hooks
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "brainclaw hook: node not found, skipping check."
+  exit 0
+fi
+
+BCLAW_CMD=""
+if command -v brainclaw >/dev/null 2>&1; then
+  BCLAW_CMD="brainclaw"
+elif command -v bclaw >/dev/null 2>&1; then
+  BCLAW_CMD="bclaw"
+else
+  BCLAW_CMD="npx --no brainclaw"
+fi
+
+# Check 1: sensitive content in .brainclaw/
+RESULT=$($BCLAW_CMD doctor --json 2>/dev/null) || {
+  echo "brainclaw hook: could not run doctor check, skipping."
+  exit 0
+}
+
+echo "$RESULT" | node -e "
+const chunks = [];
+process.stdin.on('data', d => chunks.push(d));
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(chunks.join(''));
+    const issues = (data.checks || []).filter(c =>
+      (c.name === 'state_security' || c.name === 'candidate_security') &&
+      c.status !== 'ok'
+    );
+    if (issues.length > 0) {
+      process.stderr.write('\\nbrainclaw: sensitive content in .brainclaw/ — commit blocked.\\n');
+      issues.forEach(c => process.stderr.write('  ⚠  ' + c.message + '\\n'));
+      process.stderr.write('  Fix: review with \`brainclaw doctor\`\\n\\n');
+      process.exit(1);
+    }
+  } catch (_) { /* skip parse errors */ }
+});
+" || exit 1
+
+# Check 2: active constraint violations on staged files
+$BCLAW_CMD check-constraints --staged 2>&1 || exit 1
+`;
+}
+//# sourceMappingURL=install-hooks.js.map

package/dist/commands/instruction.js

@@ -0,0 +1,56 @@
+import { resolveAgentScope, resolveCurrentAgentName } from '../core/agent-registry.js';
+import { loadConfig } from '../core/config.js';
+import { createInstruction } from '../core/instructions.js';
+import { memoryExists, memoryPath, writeFileAtomic } from '../core/io.js';
+import { generateMarkdown } from '../core/markdown.js';
+import { loadState } from '../core/state.js';
+import { scanText } from '../core/security.js';
+import { validateCliInput } from '../core/input-validation.js';
+import { resolveTargetStore } from '../core/store-resolution.js';
+export function runInstruction(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);
+    }
+    validateCliInput(text, options.tag);
+    const layer = options.layer ?? 'global';
+    const scope = resolveScope(layer, options, cwd);
+    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);
+        }
+    }
+    const entry = createInstruction(text, {
+        layer,
+        scope,
+        tags: options.tag,
+        author: options.author ?? resolveCurrentAgentName(cwd),
+        supersedes: options.supersedes,
+    }, cwd);
+    writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(loadState(cwd)));
+    console.log(`✔ Instruction added: [${entry.id}] <${entry.layer}${entry.scope ? `:${entry.scope}` : ''}> ${entry.text}`);
+}
+function resolveScope(layer, options, cwd) {
+    if (layer === 'global') {
+        return undefined;
+    }
+    if (layer === 'project') {
+        if (!options.project) {
+            console.error('Error: --project is required when --layer project is used.');
+            process.exit(1);
+        }
+        return options.project;
+    }
+    const agentScope = resolveAgentScope(options.agent, cwd);
+    if (!agentScope) {
+        console.error('Error: no agent scope available. Use --agent or configure a current agent with `brainclaw register-agent <name> --set-current`.');
+        process.exit(1);
+    }
+    return agentScope;
+}
+//# sourceMappingURL=instruction.js.map

package/dist/commands/list-agents.js

@@ -0,0 +1,44 @@
+import { listAgentIdentities, resolveCurrentAgentIdentity } from '../core/agent-registry.js';
+import { memoryExists } from '../core/io.js';
+import { buildReputationSnapshot, toPublicReputationSummary } from '../core/reputation.js';
+export function runListAgents(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const agents = listAgentIdentities();
+    const current = resolveCurrentAgentIdentity();
+    const reputation = options.withReputation ? buildReputationSnapshot() : undefined;
+    const reputationById = new Map((reputation?.agents ?? []).map((agent) => [agent.agent_id ?? agent.key, toPublicReputationSummary(agent)]));
+    if (options.json) {
+        console.log(JSON.stringify({
+            current_agent_id: current?.agent_id,
+            current_agent: current?.agent_name,
+            agents: options.withReputation
+                ? agents.map((agent) => ({
+                    ...agent,
+                    reputation: reputationById.get(agent.agent_id),
+                }))
+                : agents,
+        }, null, 2));
+        return;
+    }
+    if (agents.length === 0) {
+        console.log('No registered agents.');
+        return;
+    }
+    console.log(`${agents.length} registered agent(s):`);
+    for (const agent of agents) {
+        const currentLabel = current?.agent_id === agent.agent_id ? ' [current]' : '';
+        const reputationLabel = options.withReputation
+            ? (() => {
+                const summary = reputationById.get(agent.agent_id);
+                return summary ? ` trust=${summary.internal_trust} cq=${summary.contribution_quality} rv=${summary.review_reliability} ct=${summary.continuity_hygiene}` : '';
+            })()
+            : '';
+        const capabilitiesLabel = agent.capabilities.length > 0 ? ` caps=${agent.capabilities.join(',')}` : '';
+        const fingerprintLabel = agent.identity_key ? ` fp=${agent.identity_key.fingerprint.slice(0, 12)}` : '';
+        console.log(`  - ${agent.agent_name} (${agent.agent_id}, kind=${agent.kind})${currentLabel}${reputationLabel}${capabilitiesLabel}${fingerprintLabel}`);
+    }
+}
+//# sourceMappingURL=list-agents.js.map

package/dist/commands/list-claims.js

@@ -0,0 +1,45 @@
+import { memoryExists } from '../core/io.js';
+import { listClaims } from '../core/claims.js';
+export function runListClaims(options = {}) {
+    if (!memoryExists(options.cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    let claims = listClaims(options.cwd);
+    if (!options.all) {
+        claims = claims.filter(c => c.status === 'active');
+    }
+    if (options.project) {
+        claims = claims.filter(c => c.project === options.project);
+    }
+    if (options.plan) {
+        claims = claims.filter(c => c.plan_id === options.plan);
+    }
+    if (options.agent) {
+        claims = claims.filter(c => c.agent === options.agent);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(claims, null, 2));
+        return;
+    }
+    if (claims.length === 0) {
+        console.log('No active claims.');
+        return;
+    }
+    const label = options.all ? 'claim(s)' : 'active claim(s)';
+    console.log(`${claims.length} ${label}:`);
+    console.log('');
+    for (const c of claims) {
+        const status = c.status !== 'active' ? ` (${c.status})` : '';
+        const extras = [];
+        if (c.session_id)
+            extras.push(`session ${c.session_id.slice(-8)}`);
+        if (c.plan_id)
+            extras.push(`plan ${c.plan_id}`);
+        if (c.project)
+            extras.push(`project ${c.project}`);
+        const suffix = extras.length ? ` [${extras.join(', ')}]` : '';
+        console.log(`  [${c.id}] ${c.agent} → ${c.scope}: ${c.description}${suffix}${status}`);
+    }
+}
+//# sourceMappingURL=list-claims.js.map

package/dist/commands/list-instructions.js

@@ -0,0 +1,50 @@
+import { resolveAgentScope } from '../core/agent-registry.js';
+import { inferProjectFromTarget, loadInstructions, resolveInstructions } from '../core/instructions.js';
+import { loadConfig } from '../core/config.js';
+import { memoryExists } from '../core/io.js';
+export function runListInstructions(options = {}) {
+    if (!memoryExists()) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const inferredProject = options.project ?? inferProjectFromTarget(options.for, config);
+    const resolvedAgent = options.resolved ? resolveAgentScope(options.agent) : options.agent;
+    const source = options.resolved
+        ? resolveInstructions(loadInstructions(), { project: inferredProject, agent: resolvedAgent })
+        : loadInstructions();
+    let entries = source;
+    if (options.active) {
+        entries = entries.filter((entry) => entry.active);
+    }
+    if (options.layer) {
+        entries = entries.filter((entry) => entry.layer === options.layer);
+    }
+    if (inferredProject) {
+        entries = entries.filter((entry) => entry.layer !== 'project' || entry.scope === inferredProject);
+    }
+    if (options.agent) {
+        entries = entries.filter((entry) => entry.layer !== 'agent' || entry.scope === options.agent);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    if (entries.length === 0) {
+        console.log('No instructions found.');
+        return;
+    }
+    console.log(`${entries.length} instruction(s):`);
+    console.log('');
+    for (const entry of entries) {
+        const scope = entry.scope ? `:${entry.scope}` : '';
+        const flags = [entry.layer];
+        if (!entry.active)
+            flags.push('inactive');
+        if (entry.supersedes)
+            flags.push(`supersedes ${entry.supersedes}`);
+        const tags = entry.tags.length ? ` [${entry.tags.join(', ')}]` : '';
+        console.log(`  [${entry.id}] <${entry.layer}${scope}> ${entry.text} (${flags.join(' · ')})${tags}`);
+    }
+}
+//# sourceMappingURL=list-instructions.js.map