brainclaw 1.14.0 → 1.16.0

package/dist/commands/mcp-contract.js

@@ -0,0 +1,33 @@
+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;
+export function toolResponse(response, isError = false) {
+    const structuredContent = response.structuredContent
+        ? { ...response.structuredContent, schema_version: SCHEMA_VERSION }
+        : undefined;
+    return {
+        ...response,
+        structuredContent,
+        isError,
+        schema_version: SCHEMA_VERSION,
+    };
+}
+export function createToolErrorResponse(kind, message, details) {
+    return toolResponse({
+        content: [{ type: 'text', text: `Error: ${message}` }],
+        structuredContent: {
+            error: {
+                kind,
+                message,
+                ...(details !== undefined ? { details } : {}),
+            },
+        },
+    }, true);
+}
+export function normaliseFormat(value) {
+    if (value === 'json' || value === 'template') {
+        return value;
+    }
+    return 'markdown';
+}
+//# sourceMappingURL=mcp-contract.js.map

package/dist/commands/mcp-presentation.js

@@ -0,0 +1,27 @@
+/**
+ * MCP presentation — renderers that turn built context objects into the
+ * strings served over the MCP surface.
+ *
+ * Extracted from mcp.ts (pln#622 PR1). Importing core/ here is the
+ * legitimate downward direction (commands → core); this module must not
+ * import mcp.js (assembly point) — enforced by
+ * tests/unit/mcp-dependency-direction.test.ts.
+ *
+ * @module
+ */
+import { renderContextMarkdown, renderContextPromptTemplate, renderContextBriefing } from '../core/context.js';
+export function renderContextForMcp(result, format, options) {
+    // Briefing profile always uses its own ultra-compact renderer
+    if (result.profile === 'briefing') {
+        return renderContextBriefing(result);
+    }
+    if (format === 'json') {
+        return JSON.stringify(result, null, 2);
+    }
+    if (format === 'template') {
+        const compact = options.compactTemplate || result.profile === 'openclaw';
+        return renderContextPromptTemplate(result, compact);
+    }
+    return renderContextMarkdown(result, options.explain);
+}
+//# sourceMappingURL=mcp-presentation.js.map

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

@@ -4,6 +4,10 @@
  * Extracted from mcp.ts to reduce file size. These handlers do not mutate
  * state — they build context, list items, search, and inspect.
  *
+ * pln#622 PR2: the per-call context (effective cwd, project routing, lazy
+ * config/state/agent-name loads) is resolved once at the entry point and
+ * shared by every handler via {@link ResolvedReadContext}.
+ *
  * @module
  */
 import { applyBootstrapImport, renderBootstrapInterview, renderBootstrapSummary, runBootstrapProfile, uninstallBootstrapImport } from '../core/bootstrap.js';
@@ -44,10 +48,11 @@ import { listAvailableProjectsForSession, switchProject } from './switch.js';
 import { resolveEffectiveCwdInfo } from '../core/store-resolution.js';
 import { resolveProjectCwd } from '../core/cross-project.js';
 import { readUnseenEvents, buildNotificationSummary } from '../core/event-log.js';
-import { boundListResult, DEFAULT_FIND_CHAR_BUDGET } from '../core/entity-operations.js';
+import { boundListResult, DEFAULT_FIND_CHAR_BUDGET, projectAgentForRead } from '../core/entity-operations.js';
 import { handoffDiffPreviewNote } from '../core/handoff-snapshot.js';
 import { BootstrapInterviewAnswerSchema, AssignmentStatusSchema, AgentRunStatusSchema, AgentRunTransportSchema, ActionRequiredStatusSchema, ActionRequiredKindSchema } from '../core/schema.js';
-import { SCHEMA_VERSION, createToolErrorResponse, normaliseFormat, renderContextForMcp, } from './mcp.js';
+import { SCHEMA_VERSION, createToolErrorResponse, normaliseFormat, } from './mcp-contract.js';
+import { renderContextForMcp } from './mcp-presentation.js';
 function normalizeBootstrapInterviewAnswersArg(value) {
     if (!Array.isArray(value)) {
         return [];
@@ -124,25 +129,46 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
     const projectArg = args.project;
     const targetProjectArg = name === 'bclaw_switch' ? undefined : projectArg;
     let projectRoutingApplied = false;
+    let routedConfig;
     if (targetProjectArg) {
         cwd = resolveProjectCwd(targetProjectArg, cwd);
         activeSource = 'explicit';
         try {
-            const config = loadConfig(cwd);
-            resolvedProject = { path: cwd, name: config.project_name };
+            routedConfig = loadConfig(cwd);
+            resolvedProject = { path: cwd, name: routedConfig.project_name };
         }
         catch {
             resolvedProject = { path: cwd };
         }
         projectRoutingApplied = true;
     }
+    // Memoized lazy loads — seeded by the routing probe above and shared across
+    // the bclaw_context delegation, so one tool call never re-reads them.
+    let configCache = routedConfig;
+    let stateCache;
+    let agentNameCache;
+    return dispatchReadTool(name, args, {
+        cwd,
+        activeSource,
+        resolvedProject,
+        projectRoutingApplied,
+        connectionSessionId: context.connectionSessionId,
+        getConfig: () => (configCache ??= loadConfig(cwd)),
+        getState: () => (stateCache ??= loadState(cwd)),
+        getAgentName: () => (agentNameCache ??= resolveCurrentAgentName(cwd)),
+    });
+}
+function dispatchReadTool(name, args, ctx) {
+    const { cwd, activeSource, resolvedProject, projectRoutingApplied } = ctx;
     if (name === 'bclaw_get_context') {
         // pln#542: budget_tokens caps the relevance-ranked fill (~4 chars/token).
         // Explicit maxChars wins when both are given.
         const budgetTokens = typeof args.budget_tokens === 'number' && args.budget_tokens > 0 ? args.budget_tokens : undefined;
         const result = buildContext({
             target: args.path,
-            project: targetProjectArg,
+            // Inside dispatch the name is never 'bclaw_switch', so the raw project
+            // arg is exactly the entry point's targetProjectArg.
+            project: args.project,
             agent: args.agent,
             host: args.host,
             allHosts: args.allHosts,
@@ -200,7 +226,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             unseenEventCount = result.context_diff.unseen_event_count;
         }
         else {
-            const agentName = args.agent ?? resolveCurrentAgentName(cwd);
+            const agentName = args.agent ?? ctx.getAgentName();
             const unseenEvents = readUnseenEvents(agentName, cwd);
             notifications = buildNotificationSummary(unseenEvents);
             unseenEventCount = unseenEvents.length;
@@ -228,7 +254,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         if (!handoffId) {
             throw new Error('Missing required argument: id');
         }
-        const state = loadState(cwd);
+        const state = ctx.getState();
         const handoff = state.open_handoffs.find((item) => item.id === handoffId || item.short_label === handoffId);
         if (!handoff) {
             return {
@@ -401,7 +427,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
     }
     if (name === 'bclaw_get_execution_context') {
         const executionContext = buildExecutionContext({ cwd });
-        const config = loadConfig(cwd);
+        const config = ctx.getConfig();
         const installableUpdate = checkBrainclawInstallableUpdate(config, cwd, { useDefaultNpmSource: true });
         const installableUpdateNotice = renderBrainclawInstallableUpdateNotice(installableUpdate);
         const agentTooling = args.includeAgentTooling ? buildAgentToolingContext({ cwd }) : undefined;
@@ -425,7 +451,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         };
     }
     if (name === 'bclaw_release_notes') {
-        const config = loadConfig(cwd);
+        const config = ctx.getConfig();
         const updateCheck = checkBrainclawInstallableUpdate(config, cwd, { useDefaultNpmSource: true });
         const arn = updateCheck.agent_release_notes;
         const lines = [];
@@ -467,9 +493,9 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         };
     }
     if (name === 'bclaw_get_agent_board_summary') {
-        const config = loadConfig(cwd);
-        const state = loadState(cwd);
-        const agent = args.agent ?? resolveCurrentAgentName(cwd);
+        const config = ctx.getConfig();
+        const state = ctx.getState();
+        const agent = args.agent ?? ctx.getAgentName();
         const currentHost = resolveCurrentHostId();
         const activeClaims = listClaims(cwd).filter((c) => c.status === 'active');
         const pendingActions = listActionRequired(cwd).filter((a) => a.status === 'pending');
@@ -733,7 +759,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         };
     }
     if (name === 'bclaw_list_plans') {
-        let plans = loadState(cwd).plan_items;
+        let plans = ctx.getState().plan_items;
         // Direct lookup by ID
         if (args.id) {
             const plan = plans.find((p) => p.id === String(args.id) || p.short_label === String(args.id));
@@ -1200,25 +1226,32 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         const current = resolveCurrentAgentIdentity(cwd);
         const reputation = args.includeReputation ? buildReputationSnapshot(cwd) : undefined;
         const reputationById = new Map((reputation?.agents ?? []).map((agent) => [agent.agent_id ?? agent.key, toPublicReputationSummary(agent)]));
-        const structuredAgents = args.includeReputation
-            ? agents.map((agent) => ({
-                ...agent,
-                reputation: reputationById.get(agent.agent_id),
-            }))
-            : agents;
+        // pln#625 Phase 2c (ideation loop lop_f8e8d18cb8c27ada) — redact through the
+        // SAME projection as bclaw_find(entity=agent) so there is ONE source of truth
+        // and no key material / invoke.env leaks here. This tool previously spread the
+        // raw identity doc (identity_key.public_key + invoke.env in the clear).
+        // Reputation stays an opt-in add-on.
+        const structuredAgents = agents.map((agent) => {
+            const projected = projectAgentForRead(agent);
+            return args.includeReputation
+                ? { ...projected, reputation: reputationById.get(agent.agent_id) }
+                : projected;
+        });
         const lines = structuredAgents.length === 0
             ? ['No registered agents.']
             : [
                 `${structuredAgents.length} registered agent(s):`,
                 ...structuredAgents.map((agent) => {
                     const reputation = agent.reputation;
-                    const currentLabel = current?.agent_id === agent.agent_id ? ' [current]' : '';
-                    const capabilitiesLabel = agent.capabilities.length > 0 ? ` caps=${agent.capabilities.join(',')}` : '';
-                    const fingerprintLabel = agent.identity_key ? ` fp=${agent.identity_key.fingerprint.slice(0, 12)}` : '';
+                    const capabilities = agent.capabilities ?? [];
+                    const fingerprint = agent.fingerprint;
+                    const currentLabel = current?.agent_id === agent.id ? ' [current]' : '';
+                    const capabilitiesLabel = capabilities.length > 0 ? ` caps=${capabilities.join(',')}` : '';
+                    const fingerprintLabel = fingerprint ? ` fp=${fingerprint.slice(0, 12)}` : '';
                     const reputationLabel = reputation
                         ? ` trust=${reputation.internal_trust} cq=${reputation.contribution_quality} rv=${reputation.review_reliability} ct=${reputation.continuity_hygiene}`
                         : '';
-                    return `- ${agent.agent_name} (${agent.agent_id}, kind=${agent.kind})${currentLabel}${reputationLabel}${capabilitiesLabel}${fingerprintLabel}`;
+                    return `- ${String(agent.name)} (${String(agent.id)}, kind=${String(agent.kind)})${currentLabel}${reputationLabel}${capabilitiesLabel}${fingerprintLabel}`;
                 }),
             ];
         return {
@@ -1231,7 +1264,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         };
     }
     if (name === 'bclaw_list_instructions') {
-        const config = loadConfig(cwd);
+        const config = ctx.getConfig();
         const project = args.project;
         const inferredProject = project ?? inferProjectFromTarget(args.path, config);
         const resolvedAgent = args.resolved ? resolveAgentScope(args.agent) : args.agent;
@@ -1438,7 +1471,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
     if (name === 'bclaw_conflict_check') {
         const agentNameArg = args.agent;
         const agentIdArg = args.agentId;
-        const currentAgentName = agentNameArg ?? resolveCurrentAgentName(cwd);
+        const currentAgentName = agentNameArg ?? ctx.getAgentName();
         const allClaimsForCheck = listClaims(cwd).filter((c) => c.status === 'active');
         const myClaimsForCheck = allClaimsForCheck.filter((c) => agentIdArg ? c.agent_id === agentIdArg : c.agent === currentAgentName);
         const otherClaimsForCheck = allClaimsForCheck.filter((c) => agentIdArg ? c.agent_id !== agentIdArg : c.agent !== currentAgentName);
@@ -1471,7 +1504,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
     if (name === 'bclaw_switch') {
         if (args.list === true) {
             try {
-                const result = listAvailableProjectsForSession(cwd, context.connectionSessionId);
+                const result = listAvailableProjectsForSession(cwd, ctx.connectionSessionId);
                 const lines = result.projects.map(p => {
                     const marker = p.active ? '→' : ' ';
                     const label = p.name ? `${p.name} (${p.relative_path})` : p.relative_path;
@@ -1488,8 +1521,8 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         }
         if (args.clear === true) {
             try {
-                const session = context.connectionSessionId
-                    ? loadSessionById(context.connectionSessionId, cwd)
+                const session = ctx.connectionSessionId
+                    ? loadSessionById(ctx.connectionSessionId, cwd)
                     : loadCurrentSession(cwd);
                 if (session?.active_project) {
                     const { active_project: _removed, ...rest } = session;
@@ -1509,7 +1542,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
             return createToolErrorResponse('validation_error', 'Missing required argument: project (or use list=true / clear=true)');
         }
         try {
-            const result = switchProject(projectRef, { cwd, sessionOnly: true, sessionId: context.connectionSessionId });
+            const result = switchProject(projectRef, { cwd, sessionOnly: true, sessionId: ctx.connectionSessionId });
             const text = `✔ Switched to ${result.name ? `"${result.name}"` : result.path} (${result.scope}-scoped)`;
             return {
                 content: [{ type: 'text', text }],
@@ -1563,7 +1596,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         }
         const result = checkPolicy({
             scope,
-            agent: args.agent ?? resolveCurrentAgentName(cwd),
+            agent: args.agent ?? ctx.getAgentName(),
             agentId: args.agentId,
             action: args.action,
             cwd,
@@ -1768,7 +1801,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         };
     }
     if (name === 'bclaw_read_inbox') {
-        const agentName = args.agent ?? resolveCurrentAgentName(cwd);
+        const agentName = args.agent ?? ctx.getAgentName();
         const markAsRead = args.markAsRead === true; // default: false — reading doesn't imply processing
         const result = readInbox({
             agent: agentName,
@@ -1798,15 +1831,18 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
         // Phase 3 slice 3c — unified dispatcher. See docs/concepts/mcp-governance.md
         // for the stability contract of the advanced tier.
         const kind = String(args.kind ?? '');
+        // Delegation re-enters dispatchReadTool with the SAME resolved context —
+        // store resolution and project routing already happened at the entry
+        // point and must not be recomputed (pln#622 PR2).
         switch (kind) {
             case 'memory':
-                return handleMcpReadToolCall('bclaw_get_context', args, context);
+                return dispatchReadTool('bclaw_get_context', args, ctx);
             case 'execution':
-                return handleMcpReadToolCall('bclaw_get_execution_context', args, context);
+                return dispatchReadTool('bclaw_get_execution_context', args, ctx);
             case 'board':
-                return handleMcpReadToolCall('bclaw_get_agent_board', args, context);
+                return dispatchReadTool('bclaw_get_agent_board', args, ctx);
             case 'board_summary':
-                return handleMcpReadToolCall('bclaw_get_agent_board_summary', args, context);
+                return dispatchReadTool('bclaw_get_agent_board_summary', args, ctx);
             case 'cross_project': {
                 // pln#558 step 3 — lightweight endpoint for the VS Code extension's
                 // SYSTEM section: returns linked_projects + incoming_signals only,
@@ -1823,7 +1859,7 @@ export function handleMcpReadToolCall(name, args = {}, context = {}) {
                 if (typeof since !== 'string' || !since) {
                     throw new Error('bclaw_context(kind="delta") requires `since` (session_id).');
                 }
-                return handleMcpReadToolCall('bclaw_get_context', { ...args, since_session: since }, context);
+                return dispatchReadTool('bclaw_get_context', { ...args, since_session: since }, ctx);
             }
             default:
                 throw new Error(`bclaw_context: unknown kind '${kind}'. Expected memory | execution | board | board_summary | cross_project | delta.`);

package/dist/commands/mcp-write-admin.js

@@ -0,0 +1,328 @@
+/**
+ * MCP admin / provisioning write-tool handlers.
+ *
+ * Extracted from mcp.ts (pln#622 PR4) — mechanical move of the setup wizard,
+ * project init, and capability/tool registration write handlers. Behavior is
+ * unchanged; each handler receives the tool-call payload plus a
+ * {@link McpWriteAdminContext} carrying the model resolved once per write call.
+ *
+ * This module must never import ./mcp.js (dependency-direction guard,
+ * pln#622 PR1).
+ *
+ * @module
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadConfig } from '../core/config.js';
+import { memoryExists } from '../core/io.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { createCapability, createTool as createRegistryTool } from '../core/registries.js';
+import { detectAiAgent } from '../core/ai-agent-detection.js';
+import { checkGitPresence, scanGitRepos, parseRoots, parseRepoSelection, parseAgentSelection, getDetectedSetupAgentNames, getInstalledAgentNames, runGlobalInstall, initReposAndConfigureAgents, readSetupState, ALL_KNOWN_AGENTS, } from './setup.js';
+import { buildAgentInventory } from '../core/agent-inventory.js';
+import { probeForQuickSetup, buildQuickSetupProbeResponse, buildOnboardingPreview, resolveEmptyMemoryRecommendation } from '../core/setup-flow.js';
+import { ensureUserStore, resolveHomeDir } from '../core/setup-state.js';
+import { ensureTrust } from './mcp-write-support.js';
+import { SCHEMA_VERSION, toolResponse, createToolErrorResponse, } from './mcp-contract.js';
+export async function handleBclawSetup(payload, _ctx) {
+    const { args, cwd } = payload;
+    const step = args.step;
+    const choice = args.choice ?? '';
+    const rootsArg = args.roots;
+    const repoSelectionArg = args.repo_selection;
+    const modeArg = args.mode;
+    const env = process.env;
+    if (!checkGitPresence()) {
+        return { response: toolResponse({ content: [{ type: 'text', text: 'Git is not installed or not found in PATH. Install git from https://git-scm.com before running brainclaw setup.' }], structuredContent: { error: 'git_not_found' } }, true) };
+    }
+    // ─── Quick mode: probe current repo ──────────────────────────────
+    if (!step) {
+        // Auto-detect mode: if we're in a git repo, use quick mode unless batch is forced
+        const forceBatch = modeArg === 'batch';
+        if (!forceBatch) {
+            const probe = probeForQuickSetup(cwd);
+            if (probe.isGitRepo || probe.alreadyInitialized) {
+                const response = buildQuickSetupProbeResponse(probe);
+                return { response: toolResponse({ content: [{ type: 'text', text: response.text }], structuredContent: response.structured }) };
+            }
+        }
+        // Fall through to batch mode
+        const existingState = readSetupState(env);
+        const alreadyRun = existingState ? `Setup was previously run on ${new Date(existingState.completed_at).toLocaleDateString()}. You can re-run it.` : undefined;
+        return { response: toolResponse({ content: [{ type: 'text', text: [alreadyRun, "Where are the user's project directories? Please ask the user to provide one or more root paths where their git repositories are located (e.g. ~/Projects, C:\\Users\\user\\code)."].filter(Boolean).join('\n\n') }], structuredContent: { pending_question: 'project_roots', prompt: 'Please ask the user: "Where are your projects? Enter one or more root directories (comma-separated):"', ...(alreadyRun ? { already_run: alreadyRun } : {}) } }) };
+    }
+    // ─── Quick mode step: init with choices ──────────────────────────
+    if (step === 'quick_init') {
+        const projectType = args.project_type ?? 'standalone';
+        const topology = args.topology ?? 'embedded';
+        // Ensure user store exists
+        ensureUserStore(env);
+        // Map choices to init options
+        const projectMode = projectType === 'workspace' ? 'multi-project' : 'auto';
+        const topologyMode = topology === 'sidecar' ? 'sidecar' : 'embedded';
+        // Run init
+        try {
+            const { runInit } = await import('./init.js');
+            await runInit({
+                yes: true,
+                cwd,
+                skipAgentBootstrap: false,
+                projectMode,
+                topology: topologyMode,
+            });
+        }
+        catch (err) {
+            return { response: toolResponse({ content: [{ type: 'text', text: `Init failed: ${err instanceof Error ? err.message : String(err)}` }], structuredContent: { error: 'init_failed', details: err instanceof Error ? err.message : String(err) } }, true) };
+        }
+        // Detect agent and report
+        const detected = detectAiAgent(env);
+        const summary = [
+            `✔ Initialized ${cwd.split(/[\\/]/).pop() ?? cwd} (${projectType}, ${topology})`,
+        ];
+        if (detected) {
+            summary.push(`✔ Agent detected: ${detected.name}`);
+        }
+        summary.push('✔ Full brainclaw MCP catalog activates automatically; reload your agent session only if new tools do not appear.');
+        // Bootstrap route follows the shared empty-memory rule; the preview
+        // already embeds the same recommendation text when memory is empty.
+        const probe = probeForQuickSetup(cwd);
+        const bootstrapAvailable = probe.hasContent;
+        const emptyMemoryRec = resolveEmptyMemoryRecommendation(cwd);
+        const preview = buildOnboardingPreview(cwd);
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: summary.join('\n') + '\n\n' + preview }],
+                structuredContent: {
+                    setup_complete: true,
+                    project_type: projectType,
+                    topology,
+                    detected_agent: detected?.name ?? null,
+                    bootstrap_available: bootstrapAvailable,
+                    bootstrap_route: emptyMemoryRec.route,
+                    next_action: emptyMemoryRec.mcp_next_action,
+                    preview,
+                    summary,
+                },
+            }),
+        };
+    }
+    if (step === 'project_roots') {
+        const roots = parseRoots(choice, env);
+        if (roots.length === 0) {
+            return { response: toolResponse({ content: [{ type: 'text', text: 'No valid directories found from the provided paths. Please ask the user for valid root directories.' }], structuredContent: { error: 'no_valid_roots', provided: choice } }, true) };
+        }
+        const repos = scanGitRepos(roots);
+        const repoList = repos.map((r, i) => `  ${i + 1}) ${r.alreadyInitialised ? '[✔ init]' : '[      ]'} ${r.name}  (${r.path})`).join('\n');
+        return { response: toolResponse({ content: [{ type: 'text', text: `Found ${repos.length} repository candidate(s):\n${repoList}\n\nAsk the user which repositories to initialise.` }], structuredContent: { pending_question: 'repo_selection', roots: roots.join(','), repos: repos.map((r) => ({ path: r.path, name: r.name, alreadyInitialised: r.alreadyInitialised })), prompt: 'Please ask the user: "Which repositories to initialise? Reply: (a)ll, (c)urrent, or numbers like 1,3"' } }) };
+    }
+    if (step === 'repo_selection') {
+        if (!rootsArg) {
+            return { response: toolResponse({ content: [{ type: 'text', text: 'Missing roots parameter. Pass the roots value from the previous step.' }], structuredContent: { error: 'missing_roots' } }, true) };
+        }
+        const roots = parseRoots(rootsArg, env);
+        const repos = scanGitRepos(roots);
+        const selectedRepos = parseRepoSelection(choice, repos, cwd);
+        const detected = detectAiAgent(env);
+        const installedAgents = getInstalledAgentNames(buildAgentInventory(resolveHomeDir(env) ?? os.homedir(), env));
+        const detectedSetupAgents = getDetectedSetupAgentNames(detected?.name, installedAgents);
+        const agentList = ALL_KNOWN_AGENTS.map((a, i) => {
+            const tag = a === detected?.name ? ' ← detected' : installedAgents.includes(a) ? ' ← installed' : '';
+            return `  ${i + 1}) ${a}${tag}`;
+        }).join('\n');
+        const detectedLine = detectedSetupAgents.length > 0 ? `\nDetected install set: ${detectedSetupAgents.join(', ')}\n` : '\n';
+        return { response: toolResponse({ content: [{ type: 'text', text: `Selected ${selectedRepos.length} repo(s). Detected AI agent: ${detected?.name ?? 'none'}.${detectedLine}\nAvailable agents:\n${agentList}\n\nAsk the user which agents to configure.` }], structuredContent: { pending_question: 'agent_selection', roots: rootsArg, repo_selection: choice, selected_repos: selectedRepos.map((r) => ({ path: r.path, name: r.name })), detected_agent: detected?.name ?? null, installed_agents: installedAgents, detected_setup_agents: detectedSetupAgents, all_agents: ALL_KNOWN_AGENTS, prompt: 'Please ask the user: "Which agents to configure? Reply: (d)etected installed, (a)ll, or agent names like claude-code,cursor"' } }) };
+    }
+    if (step === 'agent_selection') {
+        if (!rootsArg || !repoSelectionArg) {
+            return { response: toolResponse({ content: [{ type: 'text', text: 'Missing roots or repo_selection parameter from previous steps.' }], structuredContent: { error: 'missing_params' } }, true) };
+        }
+        const roots = parseRoots(rootsArg, env);
+        const repos = scanGitRepos(roots);
+        const selectedRepos = parseRepoSelection(repoSelectionArg, repos, cwd);
+        const detected = detectAiAgent(env);
+        const installedAgents = getInstalledAgentNames(buildAgentInventory(resolveHomeDir(env) ?? os.homedir(), env));
+        const selectedAgents = parseAgentSelection(choice, detected?.name, installedAgents);
+        const summary = [];
+        const written = runGlobalInstall(selectedAgents, env);
+        for (const f of written)
+            summary.push(`✔ Global config: ${f}`);
+        const { initialisedRepos, configActions } = await initReposAndConfigureAgents(selectedRepos, selectedAgents, env);
+        for (const p of initialisedRepos)
+            summary.push(`✔ Initialised repo: ${p}`);
+        for (const a of configActions)
+            summary.push(a);
+        let reloadMsg = '✔ Setup complete! Reload your AI agent session to activate brainclaw MCP tools.';
+        if (detected?.name === 'claude-code')
+            reloadMsg += '\n  → In VS Code: Cmd/Ctrl+Shift+P → "Claude: Reload MCP Servers"';
+        else if (detected?.name === 'cursor')
+            reloadMsg += '\n  → In Cursor: restart the editor';
+        else if (detected?.name === 'windsurf')
+            reloadMsg += '\n  → In Windsurf: restart the editor';
+        return { response: toolResponse({ content: [{ type: 'text', text: [reloadMsg, '', ...summary].join('\n') }], structuredContent: { setup_complete: true, initialised_repos: initialisedRepos, global_configs_written: written, agent_configs_written: configActions, detected_agent: detected?.name ?? null, summary } }) };
+    }
+    return { response: toolResponse({ content: [{ type: 'text', text: `Unknown step: "${step}". Valid steps: project_roots, repo_selection, agent_selection.` }], structuredContent: { error: 'unknown_step', step } }, true) };
+}
+export async function handleBclawInitProject(payload, _ctx) {
+    const { args, cwd } = payload;
+    const rawPath = typeof args.path === 'string' ? args.path.trim() : '';
+    if (!rawPath) {
+        return { response: createToolErrorResponse('validation_error', 'path is required') };
+    }
+    const force = args.force === true;
+    const projectModeArg = typeof args.project_mode === 'string' ? args.project_mode : undefined;
+    const linkAs = typeof args.link_as === 'string' && args.link_as.trim().length > 0
+        ? args.link_as.trim()
+        : undefined;
+    const resolvedPath = path.isAbsolute(rawPath) ? rawPath : path.resolve(cwd, rawPath);
+    let wasAlreadyInitialized = false;
+    if (memoryExists(resolvedPath) && !force) {
+        wasAlreadyInitialized = true;
+    }
+    else {
+        if (!fs.existsSync(resolvedPath)) {
+            try {
+                fs.mkdirSync(resolvedPath, { recursive: true });
+            }
+            catch (err) {
+                return {
+                    response: createToolErrorResponse('init_project_failed', `Failed to create target directory '${resolvedPath}': ${err instanceof Error ? err.message : String(err)}`),
+                };
+            }
+        }
+        try {
+            const { runInit } = await import('./init.js');
+            await runInit({
+                yes: true,
+                cwd: resolvedPath,
+                force,
+                ...(projectModeArg ? { projectMode: projectModeArg } : {}),
+            });
+        }
+        catch (err) {
+            return {
+                response: createToolErrorResponse('init_project_failed', `runInit failed for '${resolvedPath}': ${err instanceof Error ? err.message : String(err)}`),
+            };
+        }
+    }
+    let projectName;
+    try {
+        projectName = loadConfig(resolvedPath).project_name;
+    }
+    catch {
+        projectName = path.basename(resolvedPath);
+    }
+    let linkName;
+    try {
+        const { addCrossProjectLink } = await import('../core/cross-project.js');
+        const link = addCrossProjectLink({
+            path: resolvedPath,
+            name: linkAs ?? projectName,
+            cwd,
+            force,
+        });
+        linkName = link.name ?? path.basename(resolvedPath);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        // Treat a duplicate link as idempotent success when the caller did
+        // not request --force; the project itself is initialised correctly
+        // and the existing link already points at it.
+        if (/already exists/i.test(message) && !force) {
+            try {
+                const { resolveCrossProjectLinks } = await import('../core/cross-project.js');
+                const existing = resolveCrossProjectLinks(cwd).find((l) => l.absolutePath === resolvedPath || l.path === rawPath);
+                linkName = existing?.name ?? linkAs ?? projectName;
+            }
+            catch {
+                linkName = linkAs ?? projectName;
+            }
+        }
+        else {
+            return {
+                response: createToolErrorResponse('init_project_failed', `Failed to register cross_project_link: ${message}`),
+            };
+        }
+    }
+    const summary = wasAlreadyInitialized
+        ? `✔ ${resolvedPath} already initialised; linked as '${linkName}'.`
+        : `✔ Initialised brainclaw at ${resolvedPath} and linked as '${linkName}'.`;
+    return {
+        response: toolResponse({
+            content: [{ type: 'text', text: summary }],
+            structuredContent: {
+                status: 'ok',
+                project_name: projectName,
+                path: resolvedPath,
+                link_id: linkName,
+                was_already_initialized: wasAlreadyInitialized,
+            },
+        }),
+    };
+}
+export function handleBclawAddCapability(payload, ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const capName = String(args.name ?? '').trim();
+    const capDesc = String(args.description ?? '').trim();
+    if (!capName || !capDesc) {
+        return { response: createToolErrorResponse('validation_error', 'Missing required arguments: name and description') };
+    }
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const resolvedIdentity = resolved.identity;
+    const extraTags = Array.isArray(args.tags) ? args.tags : [];
+    const cap = createCapability({
+        name: capName,
+        description: capDesc,
+        tags: extraTags,
+        author: resolvedIdentity.agent_name,
+        authorId: resolvedIdentity.agent_id,
+        model: ctx.currentModel,
+    }, cwd);
+    appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'create', item_id: cap.id, item_type: 'capability', reason: `capability: ${capName}` }, cwd);
+    return {
+        response: toolResponse({
+            content: [{ type: 'text', text: `✔ Capability registered: [${cap.id}] ${capName}` }],
+            id: cap.id,
+            name: capName,
+            schema_version: SCHEMA_VERSION,
+        }),
+    };
+}
+export function handleBclawAddTool(payload, ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const toolName = String(args.name ?? '').trim();
+    const toolDesc = String(args.description ?? '').trim();
+    if (!toolName || !toolDesc) {
+        return { response: createToolErrorResponse('validation_error', 'Missing required arguments: name and description') };
+    }
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const resolvedIdentity = resolved.identity;
+    const toolType = String(args.type ?? 'utility');
+    const extraTags = Array.isArray(args.tags) ? args.tags : [];
+    const tool = createRegistryTool({
+        name: toolName,
+        description: toolDesc,
+        type: toolType,
+        tags: extraTags,
+        author: resolvedIdentity.agent_name,
+        authorId: resolvedIdentity.agent_id,
+        model: ctx.currentModel,
+    }, cwd);
+    appendAuditEntry({ actor: resolvedIdentity.agent_name, actor_id: resolvedIdentity.agent_id, action: 'create', item_id: tool.id, item_type: 'tool', reason: `tool: ${toolName}` }, cwd);
+    return {
+        response: toolResponse({
+            content: [{ type: 'text', text: `✔ Tool registered: [${tool.id}] ${toolName} (${toolType})` }],
+            id: tool.id,
+            name: toolName,
+            type: toolType,
+            schema_version: SCHEMA_VERSION,
+        }),
+    };
+}
+//# sourceMappingURL=mcp-write-admin.js.map