brainclaw 1.5.3 → 1.5.5

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,

package/dist/commands/mcp-schemas.generated.js

@@ -20,12 +20,207 @@ export const generatedSchemas = {
                     "all",
                     "any"
                 ]
+            },
+            "context_filter": {
+                "minItems": 1,
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": [
+                        "traps",
+                        "feedback",
+                        "runtime_notes",
+                        "decisions",
+                        "constraints",
+                        "handoffs",
+                        "plans",
+                        "candidates",
+                        "project_vision",
+                        "critique_history",
+                        "revision_history",
+                        "synthesis_artifact",
+                        "*"
+                    ]
+                }
+            },
+            "advance_gate": {
+                "$ref": "#/$defs/__schema0"
             }
         },
         "required": [
             "name"
         ],
-        "additionalProperties": false
+        "additionalProperties": false,
+        "$defs": {
+            "__schema0": {
+                "anyOf": [
+                    {
+                        "oneOf": [
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "kind": {
+                                        "type": "string",
+                                        "const": "phase_reached"
+                                    },
+                                    "phase": {
+                                        "type": "string",
+                                        "minLength": 1
+                                    }
+                                },
+                                "required": [
+                                    "kind",
+                                    "phase"
+                                ],
+                                "additionalProperties": false
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "kind": {
+                                        "type": "string",
+                                        "const": "reviewer_green"
+                                    }
+                                },
+                                "required": [
+                                    "kind"
+                                ],
+                                "additionalProperties": false
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "kind": {
+                                        "type": "string",
+                                        "const": "max_iterations"
+                                    },
+                                    "n": {
+                                        "type": "integer",
+                                        "exclusiveMinimum": 0,
+                                        "maximum": 9007199254740991
+                                    }
+                                },
+                                "required": [
+                                    "kind",
+                                    "n"
+                                ],
+                                "additionalProperties": false
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "kind": {
+                                        "type": "string",
+                                        "const": "artifact_produced"
+                                    },
+                                    "phase": {
+                                        "type": "string",
+                                        "minLength": 1
+                                    },
+                                    "type": {
+                                        "type": "string",
+                                        "minLength": 1
+                                    }
+                                },
+                                "required": [
+                                    "kind",
+                                    "phase",
+                                    "type"
+                                ],
+                                "additionalProperties": false
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "kind": {
+                                        "type": "string",
+                                        "const": "min_artifacts_by_type"
+                                    },
+                                    "type": {
+                                        "type": "string",
+                                        "minLength": 1
+                                    },
+                                    "n": {
+                                        "type": "integer",
+                                        "exclusiveMinimum": 0,
+                                        "maximum": 9007199254740991
+                                    },
+                                    "scope": {
+                                        "type": "string",
+                                        "enum": [
+                                            "phase",
+                                            "loop"
+                                        ]
+                                    }
+                                },
+                                "required": [
+                                    "kind",
+                                    "type",
+                                    "n",
+                                    "scope"
+                                ],
+                                "additionalProperties": false
+                            },
+                            {
+                                "type": "object",
+                                "properties": {
+                                    "kind": {
+                                        "type": "string",
+                                        "const": "manual"
+                                    }
+                                },
+                                "required": [
+                                    "kind"
+                                ],
+                                "additionalProperties": false
+                            }
+                        ]
+                    },
+                    {
+                        "type": "object",
+                        "properties": {
+                            "kind": {
+                                "type": "string",
+                                "const": "any"
+                            },
+                            "conditions": {
+                                "minItems": 1,
+                                "type": "array",
+                                "items": {
+                                    "$ref": "#/$defs/__schema0"
+                                }
+                            }
+                        },
+                        "required": [
+                            "kind",
+                            "conditions"
+                        ],
+                        "additionalProperties": false
+                    },
+                    {
+                        "type": "object",
+                        "properties": {
+                            "kind": {
+                                "type": "string",
+                                "const": "all"
+                            },
+                            "conditions": {
+                                "minItems": 1,
+                                "type": "array",
+                                "items": {
+                                    "$ref": "#/$defs/__schema0"
+                                }
+                            }
+                        },
+                        "required": [
+                            "kind",
+                            "conditions"
+                        ],
+                        "additionalProperties": false
+                    }
+                ]
+            }
+        }
     },
     "LoopSlotInput": {
         "type": "object",

package/dist/commands/mcp.js

@@ -54,6 +54,8 @@ export const SCHEMA_VERSION = '1.0.0';
 export const MCP_PROTOCOL_VERSIONS = ['2025-11-25', '2024-11-05'];
 export const MCP_SERVER_NOT_INITIALIZED = -32002;
 const MCP_RUNTIME_REPAIR_COMMAND = 'brainclaw doctor --repair';
+const { $defs: loopPhaseDefs, ...loopPhaseItemSchema } = generatedSchemas.LoopPhase;
+const loopSlotInputItemSchema = generatedSchemas.LoopSlotInput;
 export const MCP_READ_TOOLS = [
     {
         name: 'bclaw_bootstrap',
@@ -917,6 +919,7 @@ const MCP_WRITE_TOOLS = [
         annotations: { tier: 'facade', category: 'loops', headlessApproval: 'auto', experimental: true, schemaSource: 'zod-derived' },
         inputSchema: {
             type: 'object',
+            ...(loopPhaseDefs ? { $defs: loopPhaseDefs } : {}),
             properties: {
                 intent: {
                     type: 'string',
@@ -927,8 +930,8 @@ const MCP_WRITE_TOOLS = [
                 kind: { type: 'string', enum: ['review', 'ideation', 'implementation', 'research', 'debug'], description: 'Loop kind for open / list filter.' },
                 title: { type: 'string', description: 'Human-readable title (open).' },
                 goal: { type: 'string', description: 'Optional goal statement (open).' },
-                phases: { type: 'array', items: generatedSchemas.LoopPhase, description: 'Optional phase list override (open). Items derived from LoopPhaseSchema (zod source) — see mcp-schemas.generated.ts.' },
-                slots: { type: 'array', items: generatedSchemas.LoopSlotInput, description: 'Optional initial slot specs (open). Items derived from LoopSlotInputSchema (zod source). Each item carries at least { role }.' },
+                phases: { type: 'array', items: loopPhaseItemSchema, description: 'Optional phase list override (open). Items derived from LoopPhaseSchema (zod source) — see mcp-schemas.generated.ts.' },
+                slots: { type: 'array', items: loopSlotInputItemSchema, description: 'Optional initial slot specs (open). Items derived from LoopSlotInputSchema (zod source). Each item carries at least { role }.' },
                 linked: { type: 'object', description: 'Optional top-level plan/sequence refs (open).' },
                 stop_condition: { type: 'object', description: 'Optional stop_condition override (open). Composite any/all supported.' },
                 mode: { type: 'string', enum: ['asymmetric', 'symmetric'], description: 'Review mode selector for open (review kind only).' },
@@ -4884,7 +4887,7 @@ async function _executeMcpToolCallInner(payload) {
                 // dispatch analysis / review.
                 const { listAssignments: listAsgn } = await import('../core/assignments.js');
                 const predecessors = listAsgn(dispatchCwd, { claim_id: oldClaim.id })
-                    .filter((a) => a.status !== 'completed' && a.status !== 'expired' && a.status !== 'rerouted');
+                    .filter((a) => a.status !== 'completed' && a.status !== 'cancelled' && a.status !== 'expired' && a.status !== 'rerouted');
                 for (const predecessor of predecessors) {
                     try {
                         transitionAssignment(predecessor.id, 'rerouted', {
@@ -5492,7 +5495,10 @@ async function _executeMcpToolCallInner(payload) {
  * break tool execution.
  */
 export async function executeMcpToolCall(payload) {
-    const { cwd } = payload;
+    const baseCwd = payload.cwd;
+    const cwd = payload.name === 'bclaw_switch'
+        ? baseCwd
+        : resolveEffectiveCwd({ baseCwd });
     const envClaimId = process.env.BRAINCLAW_CLAIM_ID?.trim() || undefined;
     // ── Auto-session ────────────────────────────────────────────────────────────
     let autoSessionId;
@@ -5519,7 +5525,7 @@ export async function executeMcpToolCall(payload) {
                 // no longer show session_id="unknown".
                 try {
                     const { listAssignments: listA, saveAssignment: saveA } = await import('../core/assignments.js');
-                    const active = listA(cwd, { claim_id: envClaimId }).filter((a) => !['completed', 'expired', 'rerouted'].includes(a.status));
+                    const active = listA(cwd, { claim_id: envClaimId }).filter((a) => !['completed', 'cancelled', 'expired', 'rerouted'].includes(a.status));
                     for (const a of active) {
                         if (!a.session_id) {
                             a.session_id = autoSessionId;
@@ -5542,6 +5548,7 @@ export async function executeMcpToolCall(payload) {
     // ── Delegate to inner handler ───────────────────────────────────────────────
     const outcome = await _executeMcpToolCallInner({
         ...payload,
+        cwd,
         connectionSessionId: effectiveConnectionSessionId,
     });
     // Apply legacy deprecation warning uniformly (Phase 3 slice 3g). Read tools