brainclaw 0.28.0 → 1.5.3

package/dist/commands/enable-agent.js

@@ -18,6 +18,7 @@ export function runEnableAgent(agentName, options = {}) {
     const agent = registerAgentIdentity({
         agentName,
         kind: options.kind ?? 'agent',
+        contextProfile: options.contextProfile,
         capabilities: options.capability,
         replaceCapabilities: options.replaceCapabilities,
         generateFingerprint: options.generateFingerprint,

package/dist/commands/export.js

@@ -1,15 +1,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { memoryExists } from '../core/io.js';
+import { memoryExists, readProjectVision } from '../core/io.js';
 import { loadState } from '../core/state.js';
 import { loadConfig, saveConfig } from '../core/config.js';
 import { isAgentIntegrationName, upsertAgentIntegrationDeclaration } from '../core/agent-integrations.js';
 import { resolveInstructions, loadInstructions } from '../core/instructions.js';
 import { detectAiAgent } from '../core/ai-agent-detection.js';
-import { AGENT_EXPORT_REGISTRY, resolveExportTarget, resolveExportTargetByFormat, writeExportFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, } from '../core/agent-files.js';
+import { AGENT_EXPORT_REGISTRY, resolveExportTarget, resolveExportTargetByFormat, writeExportFile, writeLiveCompanionFile, buildHygieneSection, describeAutoConfigWrite, writeExportCompanionFiles, collectExportGitignoreEntries, ensureGitignoreEntries, BRAINCLAW_EXCLUSIVE_DIRECTORIES, } from '../core/agent-files.js';
+import { buildCoordinationSnapshot } from '../core/coordination.js';
+import { listClaims } from '../core/claims.js';
+import { listCandidates } from '../core/candidates.js';
 import { logger } from '../core/logger.js';
 import { getAgentCapabilityProfile } from '../core/agent-capability.js';
-import { renderBrainclawSection } from '../core/instruction-templates.js';
+import { renderBrainclawSection, renderLiveSection } from '../core/instruction-templates.js';
 import { getInstalledBrainclawVersion } from '../core/brainclaw-version.js';
 export function runExport(options) {
     const cwd = options.cwd ?? process.cwd();
@@ -17,6 +20,10 @@ export function runExport(options) {
         console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
         process.exit(1);
     }
+    if (options.shared && (!options.write || !options.format || options.all || options.detect || options.output)) {
+        console.error('Error: --shared requires --format <format> --write and cannot be used with --all, --detect, or --output.');
+        process.exit(1);
+    }
     if (options.all) {
         runExportAll(cwd, options);
         return;
@@ -29,6 +36,16 @@ export function runExport(options) {
         runExportDetect(cwd, options);
         return;
     }
+    if (options.includeLive) {
+        if (options.output) {
+            console.error('Error: --include-live cannot be used with --output. Use --write, --detect, or --all.');
+            process.exit(1);
+        }
+        if (!options.write) {
+            console.error('Error: --include-live requires --write, --detect, or --all.');
+            process.exit(1);
+        }
+    }
     if (!options.format) {
         console.error('Error: --format, --detect, or --all is required.');
         process.exit(1);
@@ -37,15 +54,20 @@ export function runExport(options) {
     if (options.write) {
         const target = resolveExportTargetByFormat(options.format);
         const result = writeExportFile(content, target.relativePath, cwd);
+        const liveResult = options.includeLive ? writeLiveCompanionForTarget(target, options, cwd) : undefined;
         const autoConfigs = writeExportCompanionFiles(options.format, cwd);
         const gitignoreEntries = collectExportGitignoreEntries(cwd, target.relativePath, autoConfigs, {
             includeTarget: !options.shared,
         });
-        if (gitignoreEntries.length > 0) {
-            ensureGitignoreEntries(cwd, gitignoreEntries);
-        }
+        if (liveResult)
+            gitignoreEntries.push(liveResult.relativePath);
+        ensureGitignoreEntries(cwd, [...gitignoreEntries, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES]);
         declareAgentIntegrationFromTarget(cwd, target.agentName, 'manual');
         console.log(`✔ Written to ${target.relativePath} (${result.created ? 'created' : 'updated'})`);
+        if (liveResult) {
+            const status = liveResult.created ? 'created' : liveResult.updated ? 'updated' : 'unchanged';
+            console.log(`Written live companion to ${liveResult.relativePath} (${status})`);
+        }
         if (options.shared) {
             console.log(`✔ Left ${target.relativePath} versionable (--shared); local companion config remains gitignored`);
         }
@@ -75,15 +97,20 @@ function runExportDetect(cwd, options) {
     const target = detected ? resolveExportTarget(detected.name) : resolveExportTarget('unknown');
     const content = generateExport(target.format, options, cwd);
     const result = writeExportFile(content, target.relativePath, cwd);
+    const liveResult = options.includeLive ? writeLiveCompanionForTarget(target, options, cwd) : undefined;
     const autoConfigs = writeExportCompanionFiles(target.format, cwd);
     const gitignoreEntries = collectExportGitignoreEntries(cwd, target.relativePath, autoConfigs);
-    if (gitignoreEntries.length > 0) {
-        ensureGitignoreEntries(cwd, gitignoreEntries);
-    }
+    if (liveResult)
+        gitignoreEntries.push(liveResult.relativePath);
+    ensureGitignoreEntries(cwd, [...gitignoreEntries, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES]);
     declareAgentIntegrationFromTarget(cwd, target.agentName, detected ? 'detected' : 'manual');
     const source = detected ? `${detected.name} [${detected.detection_source}]` : 'fallback (no agent detected)';
     console.log(`✔ Detected: ${source}`);
     console.log(`✔ Written to ${target.relativePath} (${result.created ? 'created' : 'updated'})`);
+    if (liveResult) {
+        const status = liveResult.created ? 'created' : liveResult.updated ? 'updated' : 'unchanged';
+        console.log(`Written live companion to ${liveResult.relativePath} (${status})`);
+    }
     if (gitignoreEntries.length > 0) {
         console.log('✔ Added generated local agent files to .gitignore');
     }
@@ -109,11 +136,18 @@ function runExportAll(cwd, options) {
         try {
             const content = generateExport(target.format, options, cwd);
             const result = writeExportFile(content, target.relativePath, cwd);
+            const liveResult = options.includeLive ? writeLiveCompanionForTarget(target, options, cwd) : undefined;
             const autoConfigs = writeExportCompanionFiles(target.format, cwd);
             const gitignoreEntries = collectExportGitignoreEntries(cwd, target.relativePath, autoConfigs);
             allGitignoreEntries.push(...gitignoreEntries);
+            if (liveResult)
+                allGitignoreEntries.push(liveResult.relativePath);
             declareAgentIntegrationFromTarget(cwd, target.agentName, 'manual');
             console.log(`✔ ${target.relativePath} (${result.created ? 'created' : 'updated'})`);
+            if (liveResult) {
+                const status = liveResult.created ? 'created' : liveResult.updated ? 'updated' : 'unchanged';
+                console.log(`Written live companion to ${liveResult.relativePath} (${status})`);
+            }
             written++;
         }
         catch (err) {
@@ -123,11 +157,104 @@ function runExportAll(cwd, options) {
     }
     // Consolidate gitignore entries
     if (allGitignoreEntries.length > 0) {
-        ensureGitignoreEntries(cwd, [...new Set(allGitignoreEntries)]);
+        ensureGitignoreEntries(cwd, [...new Set([...allGitignoreEntries, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES])]);
         console.log('✔ Updated .gitignore');
     }
     console.log(`✔ Exported ${written} agent file(s)`);
 }
+/**
+ * Refresh live companion files for agents that emit a filesystem live view.
+ * These are gitignored files with current state (plans, claims, traps, candidates, handoffs).
+ */
+/**
+ * Refresh live companion files silently. Returns count of files written.
+ * Non-fatal: errors are collected but never thrown. Safe to call from
+ * post-mutation hooks where a refresh failure must not break the mutation.
+ *
+ * Respects `auto_refresh_live` config flag (default: true).
+ */
+export function refreshLiveCompanions(cwd) {
+    const effectiveCwd = cwd ?? process.cwd();
+    if (!memoryExists(effectiveCwd)) {
+        return { written: 0, errors: [] };
+    }
+    try {
+        const config = loadConfig(effectiveCwd);
+        if (config.auto_refresh_live === false) {
+            return { written: 0, errors: [] };
+        }
+        const state = loadState(effectiveCwd);
+        const instructions = getInstructionText({ project: undefined, agent: undefined }, effectiveCwd);
+        const activeClaims = listClaims(effectiveCwd).filter((c) => c.status === 'active');
+        const pendingCandidates = listCandidates('pending', effectiveCwd);
+        const seen = new Set();
+        const targets = AGENT_EXPORT_REGISTRY.filter((t) => {
+            if (seen.has(t.format))
+                return false;
+            seen.add(t.format);
+            return true;
+        });
+        let written = 0;
+        const errors = [];
+        const liveGitignoreEntries = [];
+        for (const target of targets) {
+            try {
+                const profile = getAgentCapabilityProfile(target.agentName);
+                if (!profile)
+                    continue;
+                const input = {
+                    profile,
+                    state,
+                    projectName: config.project_name,
+                    brainclawVersion: getInstalledBrainclawVersion(),
+                    resolvedInstructions: instructions,
+                    projectVision: readProjectVision(effectiveCwd),
+                    activeClaims,
+                    pendingCandidates,
+                };
+                const live = renderLiveSection(input);
+                if (!live)
+                    continue; // Tier A — no live companion needed
+                const writeResult = writeLiveCompanionFile(live.content, target.agentName, target.relativePath, effectiveCwd);
+                if (writeResult.created || writeResult.updated) {
+                    written++;
+                }
+                liveGitignoreEntries.push(writeResult.relativePath);
+            }
+            catch (err) {
+                errors.push(`${target.agentName}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        if (liveGitignoreEntries.length > 0) {
+            ensureGitignoreEntries(effectiveCwd, liveGitignoreEntries);
+        }
+        return { written, errors };
+    }
+    catch (err) {
+        return { written: 0, errors: [err instanceof Error ? err.message : String(err)] };
+    }
+}
+export function runRefresh(cwd) {
+    const effectiveCwd = cwd ?? process.cwd();
+    if (!memoryExists(effectiveCwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const result = refreshLiveCompanions(effectiveCwd);
+    for (const err of result.errors) {
+        console.warn(`⚠ ${err}`);
+    }
+    if (result.written > 0) {
+        console.log(`✔ Refreshed ${result.written} live companion file(s)`);
+    }
+    else {
+        console.log('✔ All live companions are up to date.');
+    }
+}
+/**
+ * Convert a stable export path to its live companion path.
+ * e.g. CLAUDE.md → CLAUDE.live.md, .cursor/rules/brainclaw.md → .cursor/rules/brainclaw.live.md
+ */
 export function writeAgentExportForAgent(agentName, cwd) {
     const rendered = renderAgentExportForAgent(agentName, cwd);
     if (!rendered) {
@@ -166,19 +293,22 @@ function declareAgentIntegrationFromTarget(cwd, agentName, declarationSource) {
         saveConfig(config, cwd);
     }
 }
+/**
+ * Map an export format to the agent name used to look up a capability profile.
+ *
+ * Derived from AGENT_EXPORT_REGISTRY so new formats registered there
+ * automatically get the adaptive generation path. Historically this was a
+ * hand-maintained map that drifted: the 5 autonomous-agent formats
+ * (openclaw, nanoclaw, nemoclaw, picoclaw, zeroclaw) were in the registry
+ * and had capability profiles but were missing here, so `brainclaw export
+ * --all --write` skipped them with "Unknown export format".
+ */
 function formatToAgentName(format) {
-    const map = {
-        'claude-md': 'claude-code',
-        'cursor-rules': 'cursor',
-        'copilot-instructions': 'github-copilot',
-        'agents-md': 'codex',
-        'gemini-md': 'antigravity',
-        'windsurf': 'windsurf',
-        'cline': 'cline',
-        'roo': 'roo',
-        'continue': 'continue',
-    };
-    return map[format];
+    for (const entry of AGENT_EXPORT_REGISTRY) {
+        if (entry.format === format)
+            return entry.agentName;
+    }
+    return undefined;
 }
 function generateExport(format, options, cwd) {
     const agentName = formatToAgentName(format);
@@ -198,6 +328,7 @@ function generateExport(format, options, cwd) {
         case 'roo': return generateRoo(options, cwd);
         case 'continue': return generateContinueRules(options, cwd);
         case 'gemini-md': return generateGeminiMd(options, cwd);
+        case 'board-md': return generateBoardMd(options, cwd);
         default:
             throw new Error(`Unknown export format: ${format}`);
     }
@@ -219,9 +350,36 @@ function generateAdaptiveExport(agentName, options, cwd) {
         projectName: config.project_name,
         brainclawVersion: getInstalledBrainclawVersion(),
         resolvedInstructions: instructions,
+        projectVision: readProjectVision(cwd),
     });
     return result.content;
 }
+function buildLiveTemplateInput(target, options, cwd) {
+    const profile = getAgentCapabilityProfile(target.agentName);
+    if (!profile)
+        return undefined;
+    const config = loadConfig(cwd);
+    return {
+        profile,
+        state: loadState(cwd),
+        projectName: config.project_name,
+        brainclawVersion: getInstalledBrainclawVersion(),
+        resolvedInstructions: getInstructionText(options, cwd),
+        projectVision: readProjectVision(cwd),
+        activeClaims: listClaims(cwd).filter((claim) => claim.status === 'active'),
+        pendingCandidates: listCandidates('pending', cwd),
+    };
+}
+function writeLiveCompanionForTarget(target, options, cwd) {
+    const input = buildLiveTemplateInput(target, options, cwd);
+    if (!input)
+        return undefined;
+    const live = renderLiveSection(input);
+    if (!live)
+        return undefined;
+    const result = writeLiveCompanionFile(live.content, target.agentName, target.relativePath, cwd);
+    return { relativePath: result.relativePath, created: result.created, updated: result.updated };
+}
 function getInstructionText(options, cwd) {
     try {
         const all = loadInstructions(cwd);
@@ -460,4 +618,104 @@ function generateGeminiMd(options, cwd) {
     lines.push(buildHygieneSection());
     return lines.join('\n');
 }
+function generateBoardMd(_options, cwd) {
+    const config = loadConfig(cwd);
+    const board = buildCoordinationSnapshot({ cwd });
+    const state = loadState(cwd);
+    const lines = [
+        `# BOARD.md — ${config.project_name}`,
+        '',
+        `> Live agent board. Generated by brainclaw. Regenerate: \`brainclaw export --format board-md --write\``,
+        `> Last updated: ${new Date().toISOString()}`,
+        '',
+    ];
+    // Active plans
+    if (board.active_plans.length > 0) {
+        lines.push(`## Active Plans (${board.active_plans.length})\n`);
+        for (const plan of board.active_plans.slice(0, 20)) {
+            const tags = plan.tags?.length ? ` [${plan.tags.join(', ')}]` : '';
+            const priority = plan.priority ? ` (${plan.priority})` : '';
+            const assignee = plan.assignee ? ` @${plan.assignee}` : '';
+            const claims = plan.claims?.length ? ` — claimed by: ${plan.claims.map((c) => c.agent ?? 'unknown').join(', ')}` : '';
+            lines.push(`- **[${plan.id}]** [${plan.status}]${priority}${assignee} ${plan.text}${tags}${claims}`);
+        }
+        lines.push('');
+    }
+    else {
+        lines.push('## Active Plans\n\n_No active plans._\n');
+    }
+    // Active claims
+    if (board.active_claims.length > 0) {
+        lines.push(`## Active Claims (${board.active_claims.length})\n`);
+        for (const claim of board.active_claims.slice(0, 20)) {
+            lines.push(`- **[${claim.id}]** ${claim.agent ?? 'unknown'} → \`${claim.scope}\` — ${claim.description ?? ''}`);
+        }
+        lines.push('');
+    }
+    // Other agents activity
+    if (board.other_agents && board.other_agents.length > 0) {
+        lines.push(`## Other Agents Active\n`);
+        for (const agent of board.other_agents) {
+            const scopes = agent.scopes.length > 0 ? ` (scopes: ${agent.scopes.join(', ')})` : '';
+            lines.push(`- **${agent.name}** — ${agent.claim_count} claim(s)${scopes}`);
+        }
+        lines.push('');
+    }
+    // Open handoffs
+    if (board.open_handoffs.length > 0) {
+        lines.push(`## Open Handoffs (${board.open_handoffs.length})\n`);
+        for (const handoff of board.open_handoffs.slice(0, 10)) {
+            lines.push(`- **[${handoff.id}]** ${handoff.from ?? '?'} → ${handoff.to ?? '?'}: ${handoff.text ?? ''}`);
+        }
+        lines.push('');
+    }
+    // Recent decisions
+    const decisions = state.recent_decisions.slice(0, 10);
+    if (decisions.length > 0) {
+        lines.push(`## Recent Decisions (${decisions.length})\n`);
+        for (const d of decisions) {
+            const tags = d.tags?.length ? ` [${d.tags.join(', ')}]` : '';
+            lines.push(`- **[${d.id}]** ${d.text}${tags}`);
+        }
+        lines.push('');
+    }
+    // Known traps
+    const traps = state.known_traps.filter(t => t.visibility === 'shared' && t.status === 'active');
+    if (traps.length > 0) {
+        lines.push(`## Known Traps (${traps.length})\n`);
+        for (const t of traps.slice(0, 10)) {
+            lines.push(`- **[${t.id}]** [${t.severity}] ${t.text}`);
+        }
+        lines.push('');
+    }
+    // Active constraints
+    const constraints = state.active_constraints.filter(c => c.status === 'active');
+    if (constraints.length > 0) {
+        lines.push(`## Active Constraints (${constraints.length})\n`);
+        for (const c of constraints.slice(0, 10)) {
+            lines.push(`- **[${c.id}]** ${c.text}`);
+        }
+        lines.push('');
+    }
+    // Instructions
+    if (board.resolved_instructions.length > 0) {
+        lines.push(`## Active Instructions (${board.resolved_instructions.length})\n`);
+        for (const inst of board.resolved_instructions.slice(0, 10)) {
+            lines.push(`- **[${inst.id}]** ${inst.text}`);
+        }
+        lines.push('');
+    }
+    // Linked projects
+    if (board.linked_projects && board.linked_projects.length > 0) {
+        lines.push(`## Linked Projects (${board.linked_projects.length})\n`);
+        for (const lp of board.linked_projects) {
+            const status = lp.available ? 'available' : 'unavailable';
+            const agents = lp.agents.length > 0 ? ` — agents: ${lp.agents.join(', ')}` : '';
+            lines.push(`- **${lp.name}** (${lp.role}, ${status}) — ${lp.active_plans} plans, ${lp.active_claims} claims${agents}`);
+        }
+        lines.push('');
+    }
+    lines.push(buildHygieneSection());
+    return lines.join('\n');
+}
 //# sourceMappingURL=export.js.map

package/dist/commands/handoff.js

@@ -39,6 +39,7 @@ export function runHandoff(text, options) {
             diff = "Could not capture git diff.";
         }
     }
+    const contract = buildContract(options, diff);
     const entry = {
         id,
         short_label,
@@ -52,10 +53,42 @@ export function runHandoff(text, options) {
         plan_id: options.plan,
         tags: options.tag ?? [],
         related_paths: options.path,
+        contract,
         snapshot: diff ? { diff } : undefined,
     };
     state.open_handoffs.push(entry);
     persistState(state, cwd);
     console.log(`✔ Handoff added: [${id}] ${options.from} → ${options.to}: ${text}`);
 }
+export function extractFilesFromDiff(diff) {
+    const files = new Set();
+    for (const line of diff.split('\n')) {
+        // Match "diff --git a/path b/path" or "+++ b/path" or "--- a/path"
+        const gitDiffMatch = line.match(/^diff --git a\/(.+?) b\//);
+        if (gitDiffMatch) {
+            files.add(gitDiffMatch[1]);
+            continue;
+        }
+        const plusMatch = line.match(/^\+\+\+ b\/(.+)/);
+        if (plusMatch && plusMatch[1] !== '/dev/null') {
+            files.add(plusMatch[1]);
+        }
+    }
+    return [...files].sort();
+}
+function buildContract(options, diff) {
+    const hasExplicit = options.files?.length || options.preCondition?.length ||
+        options.postCondition?.length || options.test?.length || options.linkedPlan?.length;
+    const filesFromDiff = diff ? extractFilesFromDiff(diff) : [];
+    const allFiles = [...new Set([...(options.files ?? []), ...filesFromDiff])].sort();
+    if (!hasExplicit && allFiles.length === 0)
+        return undefined;
+    return {
+        files_touched: allFiles.length > 0 ? allFiles : undefined,
+        pre_conditions: options.preCondition?.length ? options.preCondition : undefined,
+        post_conditions: options.postCondition?.length ? options.postCondition : undefined,
+        tests_to_verify: options.test?.length ? options.test : undefined,
+        linked_plans: options.linkedPlan?.length ? options.linkedPlan : undefined,
+    };
+}
 //# sourceMappingURL=handoff.js.map

package/dist/commands/harvest.js

@@ -0,0 +1,189 @@
+/**
+ * CLI command: brainclaw harvest-candidates
+ *
+ * Scans worktree inboxes for candidates written by agents operating in
+ * --sandbox workspace-write mode (e.g. Codex), and copies them into the
+ * main project store. This is the coordinator-side of the codex-sandbox
+ * bridge: agents write candidates to their worktree's
+ * `.brainclaw/coordination/inbox/cnd_*.json` and the coordinator harvests
+ * them via this command.
+ *
+ * @module
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { CandidateSchema } from '../core/schema.js';
+import { listCandidates, listArchivedCandidates, saveCandidate } from '../core/candidates.js';
+import { createRuntimeEvent } from '../core/events.js';
+import { memoryExists } from '../core/io.js';
+/**
+ * Returns the base directory where brainclaw-managed worktrees are stored
+ * for the given project root: `~/.brainclaw/worktrees/<sha1-hash>/`.
+ */
+function worktreesBaseDir(projectRoot) {
+    const hash = crypto.createHash('sha1').update(projectRoot).digest('hex').slice(0, 12);
+    return path.join(os.homedir(), '.brainclaw', 'worktrees', hash);
+}
+/**
+ * Auto-detect all worktree directories under the brainclaw-managed base dir.
+ * Returns subdirectories that exist on disk (may or may not have an inbox).
+ */
+function autoDetectWorktreePaths(cwd) {
+    const base = worktreesBaseDir(cwd);
+    if (!fs.existsSync(base))
+        return [];
+    return fs.readdirSync(base, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(base, entry.name));
+}
+/**
+ * Collect all `cnd_*.json` files from a worktree's candidate inbox.
+ *
+ * Checks both the entity-model path (`.brainclaw/coordination/inbox/`) and
+ * the legacy flat path (`.brainclaw/inbox/`) for backward compatibility.
+ */
+function collectWorktreeCandidateFiles(worktreePath) {
+    const dirs = [
+        path.join(worktreePath, '.brainclaw', 'coordination', 'inbox'),
+        path.join(worktreePath, '.brainclaw', 'inbox'),
+    ];
+    const files = [];
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isFile() && entry.name.startsWith('cnd_') && entry.name.endsWith('.json')) {
+                files.push(path.join(dir, entry.name));
+            }
+        }
+    }
+    // Dedupe: same filename may appear in both paths (entity + legacy)
+    const seen = new Set();
+    return files.filter((f) => {
+        const key = path.basename(f);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/**
+ * Harvest candidates from worktree inboxes into the main project store.
+ *
+ * This is the coordinator-side fix for gap 5 of E2E test n°1: agents
+ * running under `--sandbox workspace-write` cannot reach the main store
+ * via MCP. They write candidates directly to their worktree inbox; the
+ * coordinator calls `harvestCandidates` to sync them.
+ *
+ * @returns HarvestResult with counts of harvested, skipped, and errors.
+ */
+export function harvestCandidates(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const agent = options.agent ?? 'coordinator';
+    const result = { harvested: [], skipped: [], errors: [] };
+    // Resolve which worktrees to scan
+    const worktreePaths = (options.worktreePaths && options.worktreePaths.length > 0)
+        ? options.worktreePaths
+        : autoDetectWorktreePaths(cwd);
+    if (worktreePaths.length === 0) {
+        return result;
+    }
+    // Build a set of IDs already present in the main store across ALL archives
+    // (pending + accepted + rejected) to prevent re-importing archived items.
+    // (Codex review cnd#564: dedup was only checking pending inbox)
+    const existingIds = new Set([
+        ...listCandidates(undefined, cwd).map((c) => c.id),
+        ...listArchivedCandidates('accepted', cwd).map((c) => c.id),
+        ...listArchivedCandidates('rejected', cwd).map((c) => c.id),
+    ]);
+    for (const worktreePath of worktreePaths) {
+        // Wrap per-worktree scan so a disappeared worktree records an error
+        // instead of aborting the full harvest. (Codex review cnd#564)
+        let files;
+        try {
+            files = collectWorktreeCandidateFiles(worktreePath);
+        }
+        catch (err) {
+            result.errors.push(`Failed to scan worktree ${worktreePath}: ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
+        for (const filePath of files) {
+            let candidate;
+            try {
+                const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                candidate = CandidateSchema.parse(raw);
+            }
+            catch (err) {
+                result.errors.push(`Failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+            if (existingIds.has(candidate.id)) {
+                result.skipped.push(candidate.id);
+                continue;
+            }
+            if (!options.dryRun) {
+                try {
+                    saveCandidate(candidate, cwd);
+                    createRuntimeEvent({
+                        agent,
+                        event_type: 'candidate_harvested',
+                        text: `Harvested candidate [${candidate.id}] from worktree ${path.basename(worktreePath)}`,
+                        tags: ['harvest', 'bridge', 'codex-sandbox'],
+                        metadata: {
+                            candidate_id: candidate.id,
+                            source_worktree: worktreePath,
+                            source_file: filePath,
+                        },
+                    }, cwd);
+                }
+                catch (err) {
+                    result.errors.push(`Failed to save candidate ${candidate.id}: ${err instanceof Error ? err.message : String(err)}`);
+                    continue;
+                }
+            }
+            existingIds.add(candidate.id);
+            result.harvested.push(candidate);
+        }
+    }
+    return result;
+}
+export function runHarvestCandidates(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const result = harvestCandidates({
+        worktreePaths: options.worktree,
+        dryRun: options.dryRun,
+        cwd,
+    });
+    if (options.json) {
+        console.log(JSON.stringify({
+            harvested: result.harvested.length,
+            skipped: result.skipped.length,
+            errors: result.errors,
+            candidates: result.harvested.map((c) => ({ id: c.id, type: c.type, text: c.text.slice(0, 80) })),
+        }, null, 2));
+        return;
+    }
+    const dryTag = options.dryRun ? ' (dry-run)' : '';
+    if (result.harvested.length === 0 && result.skipped.length === 0 && result.errors.length === 0) {
+        console.log('No worktree candidates found.');
+        return;
+    }
+    for (const c of result.harvested) {
+        const verb = options.dryRun ? '  (dry-run) Would harvest' : '  ✔ Harvested';
+        console.log(`${verb} [${c.id}] ${c.type}: ${c.text.slice(0, 80)}`);
+    }
+    for (const id of result.skipped) {
+        console.log(`  ⟳ Skipped (already exists): ${id}`);
+    }
+    for (const err of result.errors) {
+        console.error(`  ✗ ${err}`);
+    }
+    console.log(`\n✔ Harvest complete${dryTag}: ${result.harvested.length} imported, ${result.skipped.length} skipped, ${result.errors.length} error(s).`);
+}
+//# sourceMappingURL=harvest.js.map