brainclaw 1.5.4 → 1.5.5

package/README.md

@@ -108,28 +108,52 @@ If you want the least surprising setup today, use Linux first. If you are on Win
 
 ---
 
-## Get Started
-
-### 1. Install
-
-```bash
-npm install -g brainclaw
-```
-
-### 2. Initialize a project
-
-```bash
-cd your-project
-brainclaw init
-```
-
-This creates `.brainclaw/` in your repo, detects your coding agent, writes MCP config and instruction files, and sets up session hooks. It takes about 10 seconds.
-
-### 3. Restart your agent
-
-Restart your coding agent (or reload MCP servers) so it picks up the new configuration. After that, brainclaw tools are available.
-
-### 4. Start working
+## Get Started
+
+### 1. Let your coding agent lead
+
+The smoothest first-run path is agent-first:
+
+1. ask your coding agent to inspect the package and explain what brainclaw does
+2. ask it to install brainclaw and initialize or join the project you're working on
+3. use the CLI yourself when you need an explicit operator or fallback path
+
+If you want to drive setup manually, use the steps below.
+
+### 2. Install
+
+```bash
+npm install -g brainclaw
+```
+
+### 3. Bootstrap this machine
+
+```bash
+brainclaw setup-machine --yes
+```
+
+This detects the installed agents on the current machine, writes the machine-level MCP and user config Brainclaw manages, and does **not** scan or initialize repositories.
+
+### 4. Initialize or refresh the current project
+
+```bash
+cd your-project
+brainclaw init
+```
+
+`brainclaw init` is now safe to rerun. It creates `.brainclaw/` when the project is new, or refreshes the managed Brainclaw and agent integration files when the project already has memory.
+
+If you are explicitly adding another agent to an existing Brainclaw project, use:
+
+```bash
+brainclaw enable-agent <agent-name>
+```
+
+### 5. Restart your agent
+
+Restart your coding agent (or reload MCP servers) so it picks up the new configuration. After that, brainclaw tools are available.
+
+### 6. Start working
 
 Pick one of the canonical entry points depending on what you're doing:
 
@@ -161,7 +185,7 @@ For agents without MCP (e.g. Copilot reads `.github/copilot-instructions.md`), r
 brainclaw export --detect --write
 ```
 
-### 5. Verify it works
+### 7. Verify it works
 
 ```bash
 brainclaw status          # see active sessions, claims, plans
@@ -172,11 +196,11 @@ brainclaw agent-board     # see what each agent is doing
 
 To configure brainclaw for all your repos and agents at once:
 
-```bash
-brainclaw setup --yes
-```
-
-This scans your projects, detects installed agents (Claude Code, Codex, Cursor, Copilot, Cline, Mistral Vibe, etc.), and writes MCP configs for each.
+```bash
+brainclaw setup --yes
+```
+
+This is the broader multi-repo wizard. It bootstraps the machine, scans your project roots, and initializes selected repositories in one pass.
 
 ### Existing projects
 

package/dist/cli.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import { Command } from 'commander';
 import { runInit } from './commands/init.js';
-import { runSetup } from './commands/setup.js';
+import { runSetup, runSetupMachine } from './commands/setup.js';
 import { runUpgrade } from './commands/upgrade.js';
 import { patchAllMcpConfigs } from './core/agent-files.js';
 import { runReconcile } from './commands/reconcile.js';
@@ -47,6 +47,7 @@ import { cleanupStaleCandidates } from './core/candidates.js';
 import { runListClaims } from './commands/list-claims.js';
 import { runReleaseClaim } from './commands/release-claim.js';
 import { runClaimResource } from './commands/claim-resource.js';
+import { runAssignmentResource } from './commands/assignment-resource.js';
 import { runMemoryCommand } from './commands/memory.js';
 import { runReleaseClaims } from './commands/release-claims.js';
 import { runAgentBoard } from './commands/agent-board.js';
@@ -161,7 +162,7 @@ program
     initLogLevel({ verbose: root.verbose, debug: root.debug });
     // Skip effective cwd resolution for commands that create the store
     const cmdName = actionCommand.name();
-    const skipResolution = cmdName === 'init' || cmdName === 'setup';
+    const skipResolution = cmdName === 'init' || cmdName === 'setup' || cmdName === 'setup-machine';
     // pln#359 phase 1c — `--project <name>` resolves a linked project to an
     // absolute path via resolveProjectCwd, then feeds the same chdir flow
     // as --cwd. Mutually exclusive with --cwd to avoid ambiguity.
@@ -201,9 +202,9 @@ program
 // --- init ---
 program
     .command('init')
-    .description('Initialize project memory in .brainclaw/ storage directory')
+    .description('Initialize or refresh project memory in .brainclaw/ storage directory')
     .option('-y, --yes', 'Skip interactive wizard and use defaults')
-    .option('--force', 'Overwrite existing project memory directory')
+    .option('--force', 'Rebuild managed Brainclaw config and generated files from defaults')
     .option('--compact', 'Enable compact markdown mode')
     .option('--topology <mode>', 'Topology mode: embedded, sidecar, local-only')
     .option('--project-mode <mode>', 'Project mode: single-project, multi-project, auto')
@@ -217,7 +218,7 @@ program
 // --- setup ---
 program
     .command('setup')
-    .description('Interactive onboarding wizard — global agent install + multi-repo init')
+    .description('Interactive onboarding wizard — machine bootstrap plus multi-repo init')
     .option('--roots <paths>', 'Comma-separated root directories to scan (skips interactive prompt)')
     .option('--agents <agents>', 'Agents to configure: all, detected, or comma-separated names')
     .option('--repos <mode>', 'Repo selection: all, current, or comma-separated numbers')
@@ -225,6 +226,15 @@ program
     .action(async (options) => {
     await runSetup(options);
 });
+// --- setup-machine ---
+program
+    .command('setup-machine')
+    .description('Machine-only onboarding — detect/configure agents and MCP without scanning or initializing repositories')
+    .option('--agents <agents>', 'Agents to configure: all, detected, or comma-separated names')
+    .option('-y, --yes', 'Accept all defaults non-interactively')
+    .action(async (options) => {
+    await runSetupMachine(options);
+});
 // --- memory-log ---
 program
     .command('memory-log')
@@ -1039,6 +1049,26 @@ program
     .action((subcommand, args, options) => {
     runClaimResource(subcommand, args, { ...options, planStatus: options.planStatus, localOnly: options.localOnly });
 });
+// --- assignment ---
+program
+    .command('assignment <subcommand> [args...]')
+    .description('Manage work assignments (list, show, update, cancel)')
+    .option('--json', 'Output as JSON for list/show')
+    .option('--all', 'Include terminal assignments in list')
+    .option('--status <status>', 'Status filter for list or target status for update')
+    .option('--agent <agent>', 'Filter by agent name')
+    .option('--claim <id>', 'Filter by linked claim ID')
+    .option('--plan <id>', 'Filter by linked plan ID')
+    .option('--sequence <id>', 'Filter by linked sequence ID')
+    .option('--reason <text>', 'Optional status reason for update/cancel')
+    .action((subcommand, args, options) => {
+    runAssignmentResource(subcommand, args, {
+        ...options,
+        claim: options.claim,
+        plan: options.plan,
+        sequence: options.sequence,
+    });
+});
 // --- list-claims ---
 program
     .command('list-claims')

package/dist/commands/assignment-resource.js

@@ -0,0 +1,182 @@
+import { memoryExists } from '../core/io.js';
+import { listAssignments, loadAssignment, transitionAssignment } from '../core/assignments.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+import { AssignmentStatusSchema } from '../core/schema.js';
+const TERMINAL_STATUSES = new Set(['completed', 'cancelled', 'expired', 'rerouted']);
+const KNOWN_SUBCOMMANDS = new Set(['list', 'ls', 'show', 'get', 'update', 'cancel']);
+export function runAssignmentResource(subcommand, args, options = {}) {
+    const normalized = subcommand.trim().toLowerCase();
+    if (normalized === 'list' || normalized === 'ls') {
+        runListAssignmentsCommand(options);
+        return;
+    }
+    if (normalized === 'show' || normalized === 'get') {
+        const id = args[0];
+        if (!id) {
+            console.error(`Error: assignment ${normalized} requires <id>.`);
+            process.exit(1);
+        }
+        runShowAssignmentCommand(id, options);
+        return;
+    }
+    if (normalized === 'update') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: assignment update requires <id>.');
+            process.exit(1);
+        }
+        const status = options.status;
+        if (!status) {
+            console.error('Error: assignment update requires --status <status>.');
+            process.exit(1);
+        }
+        runTransitionAssignmentCommand(id, status, options);
+        return;
+    }
+    if (normalized === 'cancel') {
+        const id = args[0];
+        if (!id) {
+            console.error('Error: assignment cancel requires <id>.');
+            process.exit(1);
+        }
+        runTransitionAssignmentCommand(id, 'cancelled', options);
+        return;
+    }
+    if (normalized.startsWith('asgn_') || KNOWN_SUBCOMMANDS.has(normalized)) {
+        console.error(`Error: unknown assignment subcommand "${subcommand}".`);
+        console.error('  Available: list, show, get, update, cancel');
+        process.exit(1);
+    }
+    console.error('Error: missing assignment subcommand.');
+    console.error('  Available: list, show, get, update, cancel');
+    process.exit(1);
+}
+function runListAssignmentsCommand(options) {
+    ensureInitialized(options.cwd);
+    const requestedStatus = parseAssignmentStatus(options.status);
+    let assignments = listAssignments(options.cwd, {
+        status: requestedStatus,
+        agent: options.agent,
+        claim_id: options.claim,
+        plan_id: options.plan,
+        sequence_id: options.sequence,
+    });
+    if (!options.all && !requestedStatus) {
+        assignments = assignments.filter((assignment) => !TERMINAL_STATUSES.has(assignment.status));
+    }
+    if (options.json) {
+        console.log(JSON.stringify(assignments, null, 2));
+        return;
+    }
+    if (assignments.length === 0) {
+        console.log(options.all ? 'No assignments.' : 'No active assignments.');
+        return;
+    }
+    console.log(`${assignments.length} ${options.all ? 'assignment(s)' : 'active assignment(s)'}:`);
+    console.log('');
+    for (const assignment of assignments) {
+        const extras = [];
+        if (assignment.plan_id)
+            extras.push(`plan ${assignment.plan_id}`);
+        if (assignment.claim_id)
+            extras.push(`claim ${assignment.claim_id}`);
+        if (assignment.sequence_id)
+            extras.push(`sequence ${assignment.sequence_id}`);
+        if (assignment.worktree_path)
+            extras.push(`worktree ${assignment.worktree_path}`);
+        const suffix = extras.length > 0 ? ` [${extras.join(', ')}]` : '';
+        console.log(`  [${assignment.id}] ${assignment.agent} (${assignment.status}) -> ${assignment.scope}: ${assignment.description}${suffix}`);
+    }
+}
+function runShowAssignmentCommand(id, options) {
+    ensureInitialized(options.cwd);
+    const assignment = requireAssignment(id, options.cwd);
+    if (options.json) {
+        console.log(JSON.stringify(assignment, null, 2));
+        return;
+    }
+    console.log(`Assignment: ${assignment.id}`);
+    console.log(`  Agent:        ${assignment.agent}`);
+    console.log(`  Status:       ${assignment.status}`);
+    console.log(`  Scope:        ${assignment.scope}`);
+    console.log(`  Description:  ${assignment.description}`);
+    console.log(`  Claim:        ${assignment.claim_id}`);
+    if (assignment.message_id)
+        console.log(`  Message:      ${assignment.message_id}`);
+    if (assignment.plan_id)
+        console.log(`  Plan:         ${assignment.plan_id}`);
+    if (assignment.sequence_id)
+        console.log(`  Sequence:     ${assignment.sequence_id}`);
+    if (assignment.session_id)
+        console.log(`  Session:      ${assignment.session_id}`);
+    if (assignment.status_reason)
+        console.log(`  Reason:       ${assignment.status_reason}`);
+    if (assignment.worktree_path)
+        console.log(`  Worktree:     ${assignment.worktree_path}`);
+    console.log(`  Created:      ${assignment.created_at}`);
+    if (assignment.updated_at)
+        console.log(`  Updated:      ${assignment.updated_at}`);
+    if (assignment.offered_at)
+        console.log(`  Offered:      ${assignment.offered_at}`);
+    if (assignment.accepted_at)
+        console.log(`  Accepted:     ${assignment.accepted_at}`);
+    if (assignment.started_at)
+        console.log(`  Started:      ${assignment.started_at}`);
+    if (assignment.completed_at)
+        console.log(`  Completed:    ${assignment.completed_at}`);
+    if (assignment.cancelled_at)
+        console.log(`  Cancelled:    ${assignment.cancelled_at}`);
+    if (assignment.failed_at)
+        console.log(`  Failed:       ${assignment.failed_at}`);
+    if (assignment.blocked_at)
+        console.log(`  Blocked:      ${assignment.blocked_at}`);
+    if (assignment.timed_out_at)
+        console.log(`  Timed out:    ${assignment.timed_out_at}`);
+    if (assignment.expired_at)
+        console.log(`  Expired:      ${assignment.expired_at}`);
+    if (assignment.rerouted_at)
+        console.log(`  Rerouted:     ${assignment.rerouted_at}`);
+}
+function runTransitionAssignmentCommand(id, statusInput, options) {
+    ensureInitialized(options.cwd);
+    const nextStatus = parseAssignmentStatus(statusInput, 'status');
+    const actor = resolveCurrentAgentName(options.cwd);
+    try {
+        const result = transitionAssignment(id, nextStatus, {
+            actor,
+            status_reason: options.reason,
+        }, options.cwd);
+        const verb = nextStatus === 'cancelled' ? 'cancelled' : 'updated';
+        console.log(`✔ Assignment ${verb}: [${result.assignment.id}] ${result.previous_status} -> ${result.assignment.status}`);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+function ensureInitialized(cwd) {
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+}
+function requireAssignment(id, cwd) {
+    const assignment = loadAssignment(id, cwd);
+    if (!assignment) {
+        console.error(`Error: assignment not found: ${id}`);
+        process.exit(1);
+    }
+    return assignment;
+}
+function parseAssignmentStatus(value, label = 'filter') {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = AssignmentStatusSchema.safeParse(value);
+    if (!parsed.success) {
+        console.error(`Error: invalid ${label} '${value}'. Expected one of: ${AssignmentStatusSchema.options.join(', ')}`);
+        process.exit(1);
+    }
+    return parsed.data;
+}
+//# sourceMappingURL=assignment-resource.js.map

package/dist/commands/init.js

@@ -4,7 +4,7 @@ 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 { defaultConfig, loadConfig, 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';
@@ -18,6 +18,7 @@ import { buildAiSurfaceInventory, renderAiSurfaceUsageHints } from '../core/ai-s
 import { ensureUserStore, hasCompletedSetup } from '../core/setup-state.js';
 import { writeDetectedAgentExport } from './export.js';
 import { writeDetectedAgentHooks } from './hooks.js';
+import { ConfigSchema } from '../core/schema.js';
 export async function runInit(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const containingMemoryStore = resolveContainingMemoryStore(cwd);
@@ -58,22 +59,20 @@ export async function runInit(options = {}) {
     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 projectMemoryExists = memoryExists(cwd);
+    const existingConfig = projectMemoryExists ? loadExistingConfig(cwd, storageDir) : undefined;
+    const topology = resolveTopology(options.topology, existingConfig?.topology);
+    const ignoreStrategy = resolveIgnoreStrategy(topology, existingConfig?.ignore_strategy);
     const skipAgentBootstrap = options.skipAgentBootstrap === true || process.env.BRAINCLAW_SKIP_AGENT_BOOTSTRAP === '1';
     const testMode = process.env.BRAINCLAW_TEST_MODE === '1';
     const skipAiSurfaceScan = testMode || options.noAiScan === true || options.aiScan === false;
-    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);
+    const projectMode = await resolveProjectMode(options, analysis, existingConfig?.project_mode);
+    const projectStrategy = await resolveProjectStrategy(options, projectMode, existingConfig?.projects?.strategy);
     ensureMemoryDir(cwd, storageDir);
     const currentAgent = registerAgentIdentity({
         agentName: existingCurrentAgent?.agent_name ?? resolveDefaultAgentName(),
@@ -112,19 +111,21 @@ export async function runInit(options = {}) {
         storageDir,
         topology,
     });
-    const config = defaultConfig(projectName, {
-        projectId: projectIdentity.project_id,
-        currentAgent: currentAgent.agent_name,
-        currentAgentId: currentAgent.agent_id,
+    const config = buildInitConfig({
+        projectName,
+        projectIdentity,
+        currentAgent: {
+            name: currentAgent.agent_name,
+            id: currentAgent.agent_id,
+        },
         projectMode,
         projectStrategy,
         storageDir,
         topology,
         ignoreStrategy,
+        existingConfig: options.force ? undefined : existingConfig,
+        compact: options.compact === true,
     });
-    if (options.compact) {
-        config.markdown = { max_items_per_section: 20, compact_mode: true };
-    }
     if (detectedAi && isAgentIntegrationName(detectedAi.name)) {
         upsertAgentIntegrationDeclaration(config, detectedAi.name, 'detected');
     }
@@ -173,8 +174,19 @@ export async function runInit(options = {}) {
             .filter((item) => !item.startsWith('.codeium/'));
         ensureGitignoreEntries(cwd, ['AGENTS.md', '.github/copilot-instructions.md', ...generatedWorkspacePaths, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES]);
     }
-    console.log(`✔ Initialized project memory in ${storageDir}/`);
-    console.log('✔ Created project.md, config.yaml, and split state directories');
+    if (projectMemoryExists) {
+        console.log(`✔ Refreshed existing project memory in ${storageDir}/`);
+        if (options.force) {
+            console.log('✔ Existing memory preserved; rebuilt managed configuration and agent integration files from defaults');
+        }
+        else {
+            console.log('✔ Existing memory preserved; refreshed managed configuration and agent integration files');
+        }
+    }
+    else {
+        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) {
@@ -275,6 +287,12 @@ export async function runInit(options = {}) {
         }
     }
     console.log('');
+    if (projectMemoryExists) {
+        console.log(`Tip: run 'brainclaw enable-agent <agent-name>' when you want to explicitly add another agent to this existing project.`);
+    }
+    else {
+        console.log(`Tip: run 'brainclaw init' again later to refresh the detected agent's integration files on this project.`);
+    }
     console.log(`Tip: run 'brainclaw context --json' to load the shared memory into your agent session.`);
 }
 function installPostMergeHookIfMissing(cwd) {
@@ -342,8 +360,19 @@ function looksLikeBrainclawStore(storePath) {
         || fs.existsSync(path.join(storePath, 'project.identity.json'))
         || fs.existsSync(path.join(storePath, '.git'));
 }
-function resolveTopology(topology) {
-    return topology ?? 'embedded';
+function resolveTopology(topology, existingTopology) {
+    return topology ?? existingTopology ?? 'embedded';
+}
+function resolveIgnoreStrategy(topology, existingIgnoreStrategy) {
+    return existingIgnoreStrategy ?? (topology === 'embedded' ? 'none' : 'project-gitignore');
+}
+function loadExistingConfig(cwd, storageDir) {
+    try {
+        return loadConfig(cwd, storageDir);
+    }
+    catch {
+        return undefined;
+    }
 }
 function ensureProjectGitignore(cwd, storageDir) {
     const gitignorePath = path.join(cwd, '.gitignore');
@@ -358,10 +387,13 @@ function ensureProjectGitignore(cwd, storageDir) {
         : `${current.replace(/\s*$/, '')}\n${ignoreLine}\n`;
     fs.writeFileSync(gitignorePath, next, 'utf-8');
 }
-async function resolveProjectMode(options, analysis) {
+async function resolveProjectMode(options, analysis, existingProjectMode) {
     if (options.projectMode) {
         return options.projectMode;
     }
+    if (existingProjectMode) {
+        return existingProjectMode;
+    }
     if (options.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
         return 'auto';
     }
@@ -384,13 +416,16 @@ async function resolveProjectMode(options, analysis) {
         rl.close();
     }
 }
-async function resolveProjectStrategy(options, projectMode) {
+async function resolveProjectStrategy(options, projectMode, existingProjectStrategy) {
     if (options.projectStrategy) {
         return options.projectStrategy;
     }
     if (projectMode !== 'multi-project') {
         return 'manual';
     }
+    if (existingProjectStrategy) {
+        return existingProjectStrategy;
+    }
     if (options.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
         return 'manual';
     }
@@ -438,4 +473,105 @@ function parseProjectStrategy(value) {
             return undefined;
     }
 }
+function buildInitConfig(input) {
+    const fallbackConfig = defaultConfig(input.projectName, {
+        projectId: input.projectIdentity.project_id,
+        currentAgent: input.currentAgent.name,
+        currentAgentId: input.currentAgent.id,
+        projectMode: input.projectMode,
+        projectStrategy: input.projectStrategy,
+        storageDir: input.storageDir,
+        topology: input.topology,
+        ignoreStrategy: input.ignoreStrategy,
+    });
+    const config = input.existingConfig
+        ? mergeConfigWithDefaults(input.existingConfig, fallbackConfig)
+        : fallbackConfig;
+    const projects = config.projects ?? fallbackConfig.projects;
+    config.project_name = input.projectName;
+    config.project_id = input.projectIdentity.project_id;
+    config.current_agent = input.currentAgent.name;
+    config.current_agent_id = input.currentAgent.id;
+    config.storage_dir = input.storageDir;
+    config.topology = input.topology;
+    config.ignore_strategy = input.ignoreStrategy;
+    config.project_mode = input.projectMode;
+    config.projects = {
+        ...projects,
+        strategy: input.projectStrategy,
+        known: projects.known ?? fallbackConfig.projects.known,
+    };
+    if (input.compact) {
+        const markdown = config.markdown ?? fallbackConfig.markdown ?? {
+            max_items_per_section: 20,
+            compact_mode: false,
+        };
+        config.markdown = {
+            ...markdown,
+            compact_mode: true,
+            max_items_per_section: Math.min(markdown.max_items_per_section, 20),
+        };
+    }
+    return config;
+}
+function mergeConfigWithDefaults(existingConfig, fallbackConfig) {
+    return ConfigSchema.parse({
+        ...fallbackConfig,
+        ...existingConfig,
+        projects: {
+            ...fallbackConfig.projects,
+            ...(existingConfig.projects ?? {}),
+            known: existingConfig.projects?.known ?? fallbackConfig.projects.known,
+        },
+        redaction: {
+            ...fallbackConfig.redaction,
+            ...(existingConfig.redaction ?? {}),
+            patterns: existingConfig.redaction?.patterns ?? fallbackConfig.redaction.patterns,
+        },
+        security: existingConfig.security
+            ? {
+                ...fallbackConfig.security,
+                ...existingConfig.security,
+            }
+            : fallbackConfig.security,
+        markdown: existingConfig.markdown
+            ? {
+                ...fallbackConfig.markdown,
+                ...existingConfig.markdown,
+            }
+            : fallbackConfig.markdown,
+        reflective_memory: existingConfig.reflective_memory
+            ? {
+                ...fallbackConfig.reflective_memory,
+                ...existingConfig.reflective_memory,
+            }
+            : fallbackConfig.reflective_memory,
+        governance: fallbackConfig.governance
+            ? {
+                ...fallbackConfig.governance,
+                ...existingConfig.governance,
+                curators: existingConfig.governance?.curators ?? fallbackConfig.governance.curators,
+            }
+            : existingConfig.governance,
+        reputation: existingConfig.reputation
+            ? {
+                ...fallbackConfig.reputation,
+                ...existingConfig.reputation,
+            }
+            : fallbackConfig.reputation,
+        agent_integrations: {
+            ...fallbackConfig.agent_integrations,
+            ...(existingConfig.agent_integrations ?? {}),
+            declarations: existingConfig.agent_integrations?.declarations ?? fallbackConfig.agent_integrations.declarations,
+        },
+        claims: existingConfig.claims
+            ? {
+                ...fallbackConfig.claims,
+                ...existingConfig.claims,
+            }
+            : fallbackConfig.claims,
+        sensitive_paths: existingConfig.sensitive_paths ?? fallbackConfig.sensitive_paths,
+        cross_project_links: existingConfig.cross_project_links ?? fallbackConfig.cross_project_links,
+    });
+}
 //# sourceMappingURL=init.js.map

package/dist/commands/mcp-read-handlers.js

@@ -68,20 +68,24 @@ function getReviewAssignee(tags) {
     return undefined;
 }
 export function handleMcpReadToolCall(name, args = {}, context = {}) {
-    let cwd = context.cwd ?? resolveEffectiveCwd();
+    const baseCwd = context.cwd ?? process.cwd();
+    let cwd = name === 'bclaw_switch'
+        ? baseCwd
+        : resolveEffectiveCwd({ baseCwd });
     // If a project param is provided, resolve it to an actual cwd override.
     // resolveProjectCwd unifies cross_project_links (siblings/peers) AND
     // workspace store-chain children. Throws on unknown project — surfaces
     // visibly as a tool error rather than silently falling back to the
     // current project, which would mislead the caller.
     const projectArg = args.project;
-    if (projectArg) {
-        cwd = resolveProjectCwd(projectArg, cwd);
+    const targetProjectArg = name === 'bclaw_switch' ? undefined : projectArg;
+    if (targetProjectArg) {
+        cwd = resolveProjectCwd(targetProjectArg, cwd);
     }
     if (name === 'bclaw_get_context') {
         const result = buildContext({
             target: args.path,
-            project: projectArg,
+            project: targetProjectArg,
             agent: args.agent,
             host: args.host,
             allHosts: args.allHosts,