byterover-cli 3.3.0 → 3.5.0

package/dist/agent/infra/tools/implementations/curate-tool.d.ts

@@ -14,7 +14,7 @@ type OperationType = z.infer<typeof OperationType>;
 export declare const CurateInputSchema: z.ZodObject<{
     basePath: z.ZodDefault<z.ZodString>;
     operations: z.ZodArray<z.ZodObject<{
-        confidence: z.ZodEnum<["high", "low"]>;
+        confidence: z.ZodDefault<z.ZodEnum<["high", "low"]>>;
         content: z.ZodOptional<z.ZodObject<{
             facts: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 category: z.ZodOptional<z.ZodEnum<["personal", "project", "preference", "convention", "team", "environment", "other"]>>;
@@ -24,12 +24,12 @@ export declare const CurateInputSchema: z.ZodObject<{
             }, "strip", z.ZodTypeAny, {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }, {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }>, "many">>;
             keywords: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -130,7 +130,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             facts?: {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }[] | undefined;
             narrative?: {
@@ -166,7 +166,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             facts?: {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }[] | undefined;
             narrative?: {
@@ -227,7 +227,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             usage?: string | undefined;
             ownership?: string | undefined;
         }>>;
-        impact: z.ZodEnum<["high", "low"]>;
+        impact: z.ZodDefault<z.ZodEnum<["high", "low"]>>;
         mergeTarget: z.ZodOptional<z.ZodString>;
         mergeTargetTitle: z.ZodOptional<z.ZodString>;
         path: z.ZodString;
@@ -273,7 +273,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             facts?: {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }[] | undefined;
             narrative?: {
@@ -327,8 +327,6 @@ export declare const CurateInputSchema: z.ZodObject<{
         path: string;
         type: "ADD" | "DELETE" | "MERGE" | "UPDATE" | "UPSERT";
         reason: string;
-        confidence: "high" | "low";
-        impact: "high" | "low";
         summary?: string | undefined;
         title?: string | undefined;
         content?: {
@@ -338,7 +336,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             facts?: {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }[] | undefined;
             narrative?: {
@@ -368,6 +366,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             } | undefined;
             snippets?: string[] | undefined;
         } | undefined;
+        confidence?: "high" | "low" | undefined;
         domainContext?: {
             scope: {
                 included: string[];
@@ -377,6 +376,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             usage?: string | undefined;
             ownership?: string | undefined;
         } | undefined;
+        impact?: "high" | "low" | undefined;
         mergeTarget?: string | undefined;
         mergeTargetTitle?: string | undefined;
         subtopicContext?: {
@@ -406,7 +406,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             facts?: {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }[] | undefined;
             narrative?: {
@@ -462,8 +462,6 @@ export declare const CurateInputSchema: z.ZodObject<{
         path: string;
         type: "ADD" | "DELETE" | "MERGE" | "UPDATE" | "UPSERT";
         reason: string;
-        confidence: "high" | "low";
-        impact: "high" | "low";
         summary?: string | undefined;
         title?: string | undefined;
         content?: {
@@ -473,7 +471,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             facts?: {
                 statement: string;
                 value?: string | undefined;
-                category?: "environment" | "convention" | "other" | "personal" | "preference" | "project" | "team" | undefined;
+                category?: "personal" | "environment" | "convention" | "other" | "preference" | "project" | "team" | undefined;
                 subject?: string | undefined;
             }[] | undefined;
             narrative?: {
@@ -503,6 +501,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             } | undefined;
             snippets?: string[] | undefined;
         } | undefined;
+        confidence?: "high" | "low" | undefined;
         domainContext?: {
             scope: {
                 included: string[];
@@ -512,6 +511,7 @@ export declare const CurateInputSchema: z.ZodObject<{
             usage?: string | undefined;
             ownership?: string | undefined;
         } | undefined;
+        impact?: "high" | "low" | undefined;
         mergeTarget?: string | undefined;
         mergeTargetTitle?: string | undefined;
         subtopicContext?: {

package/dist/agent/infra/tools/implementations/curate-tool.js

@@ -162,11 +162,13 @@ const SubtopicContextSchema = z.object({
 const OperationSchema = z.object({
     confidence: z
         .enum(['high', 'low'])
+        .default('low')
         .describe('Your confidence in the accuracy and completeness of this operation. Use "high" when you have direct evidence from the source material; use "low" when the information is inferred, uncertain, or incomplete.'),
     content: ContentSchema.optional().describe('Content for ADD/UPDATE operations'),
     domainContext: DomainContextSchema.optional().describe('Domain-level context for new domains. When creating content in a NEW domain, provide this to auto-generate domain/context.md with purpose, scope, ownership, and usage. Only needed when the domain does not exist yet.'),
     impact: z
         .enum(['high', 'low'])
+        .default('high')
         .describe('Estimated scope of impact of this knowledge change. "high": Changes that alter core decisions, strategies, tools, or established approaches. Any change that contradicts or reverses previously curated knowledge. Updates to existing knowledge that change its core substance. Deletions are always high impact. "low": New additions to previously undocumented topics, minor corrections, supplementary details like examples and clarifications, or updates that extend existing knowledge without changing its core substance.'),
     mergeTarget: z.string().optional().describe('Target path for MERGE operation'),
     mergeTargetTitle: z.string().optional().describe('Title of the target file for MERGE operation'),

package/dist/agent/infra/tools/implementations/swarm-query-tool.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } from '../../../core/domain/tools/types.js';
+import type { ISwarmCoordinator } from '../../../core/interfaces/i-swarm-coordinator.js';
+/**
+ * Creates the swarm_query tool for the agent to search across memory providers.
+ *
+ * @param coordinator - The swarm coordinator instance
+ * @returns Configured swarm query tool
+ */
+export declare function createSwarmQueryTool(coordinator: ISwarmCoordinator): Tool;

package/dist/agent/infra/tools/implementations/swarm-query-tool.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { ToolName } from '../../../core/domain/tools/constants.js';
+const SwarmQueryInputSchema = z
+    .object({
+    maxResults: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Maximum number of results to return (default: 10)'),
+    query: z
+        .string()
+        .min(1)
+        .describe('Natural language query to search across all active memory providers'),
+    scope: z
+        .string()
+        .optional()
+        .describe('Optional scope to restrict search (e.g., "auth", "architecture")'),
+})
+    .strict();
+/**
+ * Creates the swarm_query tool for the agent to search across memory providers.
+ *
+ * @param coordinator - The swarm coordinator instance
+ * @returns Configured swarm query tool
+ */
+export function createSwarmQueryTool(coordinator) {
+    return {
+        description: 'Search across all active memory providers in the memory swarm. ' +
+            'Routes the query to relevant providers based on query type classification, ' +
+            'executes in parallel, and returns fused, ranked results. ' +
+            'Use this when you need information that may be spread across multiple knowledge sources.',
+        async execute(input, _context) {
+            const parsed = SwarmQueryInputSchema.parse(input);
+            return coordinator.execute({
+                maxResults: parsed.maxResults,
+                query: parsed.query,
+                scope: parsed.scope,
+            });
+        },
+        id: ToolName.SWARM_QUERY,
+        inputSchema: SwarmQueryInputSchema,
+    };
+}

package/dist/agent/infra/tools/implementations/swarm-store-tool.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } from '../../../core/domain/tools/types.js';
+import type { ISwarmCoordinator } from '../../../core/interfaces/i-swarm-coordinator.js';
+/**
+ * Creates the swarm_store tool for the agent to write knowledge to swarm providers.
+ *
+ * @param coordinator - The swarm coordinator instance
+ * @returns Configured swarm store tool
+ */
+export declare function createSwarmStoreTool(coordinator: ISwarmCoordinator): Tool;

package/dist/agent/infra/tools/implementations/swarm-store-tool.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { ToolName } from '../../../core/domain/tools/constants.js';
+const SwarmStoreInputSchema = z
+    .object({
+    content: z
+        .string()
+        .min(1)
+        .describe('Knowledge content to store in a swarm provider'),
+    contentType: z
+        .enum(['entity', 'general', 'note'])
+        .optional()
+        .describe('Content type hint for routing: entity (people/companies), note (drafts/meetings), general'),
+    provider: z
+        .string()
+        .optional()
+        .describe('Explicit target provider ID (e.g., gbrain, local-markdown:notes). Auto-routed if omitted.'),
+})
+    .strict();
+/**
+ * Creates the swarm_store tool for the agent to write knowledge to swarm providers.
+ *
+ * @param coordinator - The swarm coordinator instance
+ * @returns Configured swarm store tool
+ */
+export function createSwarmStoreTool(coordinator) {
+    return {
+        description: 'Store knowledge in a swarm provider (GBrain, local markdown). ' +
+            'Routes by content type: entities (people, companies) go to GBrain, ' +
+            'notes and drafts go to local markdown. Use the provider parameter to ' +
+            'target a specific provider. Use the curate tool for project-specific ' +
+            'knowledge that belongs in the context tree.',
+        async execute(input, _context) {
+            const parsed = SwarmStoreInputSchema.parse(input);
+            return coordinator.store({
+                content: parsed.content,
+                contentType: parsed.contentType,
+                provider: parsed.provider,
+            });
+        },
+        id: ToolName.SWARM_STORE,
+        inputSchema: SwarmStoreInputSchema,
+    };
+}

package/dist/agent/infra/tools/tool-provider.js

@@ -29,6 +29,7 @@ export class ToolProvider {
         memoryManager: 0,
         processService: 0,
         sandboxService: 0,
+        swarmCoordinator: 0,
         todoStorage: 0,
         tokenizer: 0,
     }));

package/dist/agent/infra/tools/tool-registry.d.ts

@@ -7,6 +7,7 @@ import type { IFileSystem } from '../../core/interfaces/i-file-system.js';
 import type { ILogger } from '../../core/interfaces/i-logger.js';
 import type { IProcessService } from '../../core/interfaces/i-process-service.js';
 import type { ISandboxService } from '../../core/interfaces/i-sandbox-service.js';
+import type { ISwarmCoordinator } from '../../core/interfaces/i-swarm-coordinator.js';
 import type { ITodoStorage } from '../../core/interfaces/i-todo-storage.js';
 import type { ITokenizer } from '../../core/interfaces/i-tokenizer.js';
 import type { AbstractGenerationQueue } from '../map/abstract-queue.js';
@@ -43,6 +44,8 @@ export interface ToolServices {
     processService?: IProcessService;
     /** Sandbox service for code execution */
     sandboxService?: ISandboxService;
+    /** Swarm coordinator for cross-provider memory queries */
+    swarmCoordinator?: ISwarmCoordinator;
     /** Todo storage service for session-based todo persistence */
     todoStorage?: ITodoStorage;
     /** Tokenizer for ContextTreeStore token counting */

package/dist/agent/infra/tools/tool-registry.js

@@ -12,6 +12,8 @@ import { createLlmMapTool } from './implementations/llm-map-tool.js';
 import { createReadFileTool } from './implementations/read-file-tool.js';
 import { createSearchKnowledgeService } from './implementations/search-knowledge-service.js';
 import { createSearchKnowledgeTool } from './implementations/search-knowledge-tool.js';
+import { createSwarmQueryTool } from './implementations/swarm-query-tool.js';
+import { createSwarmStoreTool } from './implementations/swarm-store-tool.js';
 import { createWriteFileTool } from './implementations/write-file-tool.js';
 import { ToolMarker } from './tool-markers.js';
 /**
@@ -55,7 +57,7 @@ export const TOOL_REGISTRY = {
     },
     [ToolName.CODE_EXEC]: {
         descriptionFile: 'code_exec',
-        factory({ abstractQueue, environmentContext, fileSystemService, sandboxService }) {
+        factory({ abstractQueue, environmentContext, fileSystemService, sandboxService, swarmCoordinator }) {
             const sandbox = getRequiredService(sandboxService, 'sandboxService');
             // Inject file system service into sandbox for Tools SDK
             if (fileSystemService && sandbox.setFileSystem) {
@@ -75,6 +77,10 @@ export const TOOL_REGISTRY = {
             if (environmentContext && sandbox.setEnvironmentContext) {
                 sandbox.setEnvironmentContext(environmentContext);
             }
+            // Inject swarm coordinator into sandbox for tools.swarmQuery/swarmStore
+            if (swarmCoordinator && sandbox.setSwarmCoordinator) {
+                sandbox.setSwarmCoordinator(swarmCoordinator);
+            }
             return createCodeExecTool(sandbox);
         },
         markers: [ToolMarker.Execution],
@@ -142,6 +148,24 @@ export const TOOL_REGISTRY = {
         markers: [ToolMarker.ContextBuilding, ToolMarker.Discovery],
         requiredServices: ['fileSystemService'],
     },
+    [ToolName.SWARM_QUERY]: {
+        descriptionFile: 'swarm_query',
+        factory(services) {
+            const coordinator = getRequiredService(services.swarmCoordinator, 'swarmCoordinator');
+            return createSwarmQueryTool(coordinator);
+        },
+        markers: [ToolMarker.Discovery],
+        requiredServices: ['swarmCoordinator'],
+    },
+    [ToolName.SWARM_STORE]: {
+        descriptionFile: 'swarm_store',
+        factory(services) {
+            const coordinator = getRequiredService(services.swarmCoordinator, 'swarmCoordinator');
+            return createSwarmStoreTool(coordinator);
+        },
+        markers: [ToolMarker.Modification],
+        requiredServices: ['swarmCoordinator'],
+    },
     [ToolName.WRITE_FILE]: {
         descriptionFile: 'write_file',
         factory: (services) => createWriteFileTool(getRequiredService(services.fileSystemService, 'fileSystemService'), services.environmentContext),

package/dist/agent/resources/tools/code_exec.txt

@@ -156,6 +156,8 @@ All methods are async and require the async IIFE wrapper.
 - **tools.curate(operations[], options?)** — Curate knowledge (ADD/UPDATE/UPSERT/MERGE/DELETE)
 - **tools.searchKnowledge(query, options?)** — Search curated knowledge
 - **tools.detectDomains(domains[])** — Detect domains from text
+- **tools.swarmQuery(query, {limit?, scope?})** — Search across all swarm memory providers (when configured)
+- **tools.swarmStore({content, contentType?, provider?})** — Store knowledge in GBrain/local markdown (when configured)
 
 ## Available Globals
 

package/dist/agent/resources/tools/swarm_query.txt

@@ -0,0 +1,38 @@
+Search across all active memory providers in the memory swarm.
+
+This tool routes your query to multiple knowledge sources (ByteRover context tree, Obsidian vaults, local markdown folders, and cloud providers), executes them in parallel, and returns fused, ranked results using Reciprocal Rank Fusion.
+
+**When to use:**
+- When information may be spread across multiple knowledge sources
+- When you need a broader search than `search_knowledge` (which only searches `.brv/context-tree/`)
+- When you want results from Obsidian vaults, local markdown folders, or cloud memory providers
+
+**Parameters:**
+- `query` (required): Natural language query to search across providers
+- `maxResults` (optional): Maximum results to return (default: 10)
+- `scope` (optional): Restrict search to a namespace/subtree
+
+**Returns:**
+- `results`: Array of ranked results with:
+  - `content`: The matching content
+  - `provider`: Which provider returned this result
+  - `score`: Fused relevance score (higher is better)
+  - `metadata.source`: Source file or identifier
+  - `metadata.matchType`: How the match was found (keyword, semantic, graph, temporal)
+- `meta`: Execution metadata with:
+  - `queryType`: How the query was classified (factual, temporal, personal, relational)
+  - `providers`: Per-provider latency and result counts
+  - `totalLatencyMs`: End-to-end latency
+  - `costCents`: Total cost for cloud providers
+
+**Query routing:**
+- Queries are automatically classified and routed to relevant providers
+- "yesterday", "last week" → temporal providers
+- "I prefer", "my style" → personal/user-modeling providers
+- "related to", "depends on" → relational/graph providers
+- General queries → factual providers (all local sources)
+
+**Examples:**
+- Query: "auth tokens" → searches ByteRover + Obsidian + local markdown
+- Query: "what changed yesterday" → routes to temporal-capable providers
+- Query: "how do I usually handle errors" → routes to personal memory providers

package/dist/agent/resources/tools/swarm_store.txt

@@ -0,0 +1,35 @@
+Store knowledge in a swarm provider (GBrain, local markdown).
+
+This tool writes knowledge to external memory providers. It auto-routes based on content type, or you can target a specific provider.
+
+**When to use:**
+- Storing structured entities (people, companies, concepts) → routes to GBrain
+- Storing notes, drafts, meeting summaries → routes to local markdown
+- When knowledge belongs outside the project context tree
+
+**When NOT to use:**
+- For project-specific knowledge (architecture, decisions, code patterns) → use `curate` instead
+- The `curate` tool writes to .brv/context-tree with FinMem scoring and domain structure
+
+**Parameters:**
+- `content` (required): The knowledge to store
+- `provider` (optional): Target provider ID (e.g., "gbrain", "local-markdown:notes"). Auto-routed if omitted.
+- `contentType` (optional): Hint for routing — "entity", "note", or "general"
+
+**Returns:**
+- `success`: Whether the store succeeded
+- `provider`: Which provider stored the content
+- `id`: ID assigned by the provider (slug for GBrain, filename for local markdown)
+- `latencyMs`: Store latency
+- `error`: Error message if store failed
+
+**Routing logic:**
+- Content mentioning people, companies, roles → "entity" → GBrain
+- Content with meeting notes, TODOs, drafts → "note" → local markdown
+- Ambiguous content → first available writable provider
+- Explicit `provider` parameter overrides all routing
+
+**Examples:**
+- Store entity: `swarm_store({ content: "Dario Amodei is CEO of Anthropic" })`
+- Store note: `swarm_store({ content: "Meeting: decided to use JWT refresh rotation" })`
+- Explicit target: `swarm_store({ content: "...", provider: "gbrain" })`

package/dist/oclif/commands/connectors/install.d.ts

@@ -15,13 +15,13 @@ export default class ConnectorsInstall extends Command {
         agentId: string;
         connectorType?: string;
     }, options?: DaemonClientOptions): Promise<{
-        agentId: "Amp" | "Antigravity" | "Auggie CLI" | "Augment Code" | "Claude Code" | "Cline" | "Codex" | "Cursor" | "Gemini CLI" | "Github Copilot" | "Junie" | "Kilo Code" | "Kiro" | "OpenClaw" | "OpenCode" | "Qoder" | "Qwen Code" | "Roo Code" | "Trae.ai" | "Warp" | "Windsurf" | "Zed";
+        agentId: "Amp" | "Antigravity" | "Auggie CLI" | "Augment Code" | "Claude Code" | "Claude Desktop" | "Cline" | "Codex" | "Cursor" | "Gemini CLI" | "Github Copilot" | "Junie" | "Kilo Code" | "Kiro" | "OpenClaw" | "OpenCode" | "Qoder" | "Qwen Code" | "Roo Code" | "Trae.ai" | "Warp" | "Windsurf" | "Zed";
         alreadySameType: boolean;
         connectorType: "rules" | "hook" | "mcp" | "skill";
         fromType?: undefined;
         result?: undefined;
     } | {
-        agentId: "Amp" | "Antigravity" | "Auggie CLI" | "Augment Code" | "Claude Code" | "Cline" | "Codex" | "Cursor" | "Gemini CLI" | "Github Copilot" | "Junie" | "Kilo Code" | "Kiro" | "OpenClaw" | "OpenCode" | "Qoder" | "Qwen Code" | "Roo Code" | "Trae.ai" | "Warp" | "Windsurf" | "Zed";
+        agentId: "Amp" | "Antigravity" | "Auggie CLI" | "Augment Code" | "Claude Code" | "Claude Desktop" | "Cline" | "Codex" | "Cursor" | "Gemini CLI" | "Github Copilot" | "Junie" | "Kilo Code" | "Kiro" | "OpenClaw" | "OpenCode" | "Qoder" | "Qwen Code" | "Roo Code" | "Trae.ai" | "Warp" | "Windsurf" | "Zed";
         alreadySameType: boolean;
         connectorType: "rules" | "hook" | "mcp" | "skill";
         fromType: "rules" | "hook" | "mcp" | "skill" | undefined;

package/dist/oclif/commands/connectors/install.js

@@ -2,7 +2,7 @@ import { select } from '@inquirer/prompts';
 import { Args, Command, Flags } from '@oclif/core';
 import { AGENT_CONNECTOR_CONFIG } from '../../../server/core/domain/entities/agent.js';
 import { ConnectorEvents, } from '../../../shared/transport/events/connector-events.js';
-import { AGENT_VALUES } from '../../../shared/types/agent.js';
+import { AGENT_VALUES, CLAUDE_DESKTOP } from '../../../shared/types/agent.js';
 import { isConnectorType, requiresAgentRestart } from '../../../shared/types/connector-type.js';
 import { getConnectorName } from '../../../tui/features/connectors/utils/get-connector-name.js';
 import { withDaemonRetry } from '../../lib/daemon-client.js';
@@ -70,7 +70,10 @@ ${agentTable}`;
                 return { agentId: matchedAgent.id, alreadySameType: true, connectorType: resolvedType };
             }
             // 5. Install or switch
-            const result = await client.requestWithAck(ConnectorEvents.INSTALL, { agentId: matchedAgent.id, connectorType: resolvedType });
+            const result = await client.requestWithAck(ConnectorEvents.INSTALL, {
+                agentId: matchedAgent.id,
+                connectorType: resolvedType,
+            });
             if (!result.success) {
                 throw new Error(result.message);
             }
@@ -132,10 +135,12 @@ ${agentTable}`;
                         configPath: installResult.result?.configPath,
                         connectorType: installResult.connectorType,
                         ...(installResult.alreadySameType ? { message: 'Already using this connector type' } : {}),
-                        ...(installResult.result?.requiresManualSetup ? {
-                            manualInstructions: installResult.result.manualInstructions,
-                            requiresManualSetup: true,
-                        } : {}),
+                        ...(installResult.result?.requiresManualSetup
+                            ? {
+                                manualInstructions: installResult.result.manualInstructions,
+                                requiresManualSetup: true,
+                            }
+                            : {}),
                     },
                     success: true,
                 });
@@ -167,7 +172,10 @@ ${agentTable}`;
                 this.log(`Location: ${installResult.result.configPath}`);
             }
             if (requiresAgentRestart(installResult.connectorType)) {
-                this.log(`\nPlease restart ${installResult.agentId} to apply the new ${getConnectorName(installResult.connectorType)}.`);
+                const hint = installResult.agentId === CLAUDE_DESKTOP
+                    ? `\nQuit ${installResult.agentId} from the system tray (Win) or menu bar (Mac), then reopen it.`
+                    : `\nPlease restart ${installResult.agentId} to apply the new ${getConnectorName(installResult.connectorType)}.`;
+                this.log(hint);
             }
         }
         catch (error) {

package/dist/oclif/commands/swarm/curate.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class SwarmCurate extends Command {
+    static args: {
+        content: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/oclif/commands/swarm/curate.js

@@ -0,0 +1,81 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { FileSystemService } from '../../../agent/infra/file-system/file-system-service.js';
+import { loadSwarmConfig } from '../../../agent/infra/swarm/config/swarm-config-loader.js';
+import { buildProvidersFromConfig } from '../../../agent/infra/swarm/provider-factory.js';
+import { SwarmCoordinator } from '../../../agent/infra/swarm/swarm-coordinator.js';
+import { validateSwarmProviders } from '../../../agent/infra/swarm/validation/config-validator.js';
+import { createSearchKnowledgeService } from '../../../agent/infra/tools/implementations/search-knowledge-service.js';
+export default class SwarmCurate extends Command {
+    static args = {
+        content: Args.string({ description: 'Knowledge content to store in a swarm provider', required: true }),
+    };
+    static description = 'Store knowledge in a swarm provider (GBrain, local markdown)';
+    static examples = [
+        '<%= config.bin %> swarm curate "Dario Amodei is CEO of Anthropic"',
+        '<%= config.bin %> swarm curate "meeting notes: decided on JWT" --provider local-markdown:notes',
+        '<%= config.bin %> swarm curate "Architecture uses event sourcing" --provider gbrain',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            default: 'text',
+            description: 'Output format',
+            options: ['text', 'json'],
+        }),
+        provider: Flags.string({
+            char: 'p',
+            description: 'Target provider ID (e.g., gbrain, local-markdown:notes)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SwarmCurate);
+        const isJson = flags.format === 'json';
+        try {
+            const config = await loadSwarmConfig(process.cwd());
+            // Validate enrichment topology only (provider errors handled by health checks)
+            const validation = await validateSwarmProviders(config);
+            const topologyErrors = validation.errors.filter((e) => e.provider === 'enrichment');
+            if (topologyErrors.length > 0) {
+                const messages = topologyErrors.map((e) => e.message);
+                throw new Error(`Invalid enrichment topology:\n  ${messages.join('\n  ')}`);
+            }
+            const workingDirectory = process.cwd();
+            const fileSystemService = new FileSystemService({ workingDirectory });
+            await fileSystemService.initialize();
+            const searchService = createSearchKnowledgeService(fileSystemService, {
+                baseDirectory: workingDirectory,
+            });
+            const providers = buildProvidersFromConfig(config, { searchService });
+            const coordinator = new SwarmCoordinator(providers, config);
+            await coordinator.refreshHealth();
+            const result = await coordinator.store({
+                content: args.content,
+                provider: flags.provider,
+            });
+            if (isJson) {
+                this.log(JSON.stringify(result, undefined, 2));
+            }
+            else if (result.success && result.fallback) {
+                const idPart = result.id ? ` as ${result.id}` : '';
+                this.log(`Stored to ${result.provider} (fallback — no external providers available)${idPart}`);
+            }
+            else if (result.success) {
+                this.log(`Stored to ${result.provider} as ${result.id}`);
+            }
+            else {
+                this.logToStderr(`Error: ${result.error ?? 'Store failed'}`);
+                this.exit(2);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (isJson) {
+                this.log(JSON.stringify({ error: message, success: false }));
+            }
+            else {
+                this.logToStderr(`Error: ${message}`);
+                this.exit(2);
+            }
+        }
+    }
+}

package/dist/oclif/commands/swarm/onboard.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class SwarmOnboard extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}