byterover-cli 3.3.0 → 3.5.0

package/dist/server/constants.js

@@ -88,12 +88,13 @@ export const OVERVIEW_EXTENSION = '.overview.md';
 export const MANIFEST_FILE = '_manifest.json';
 export const ARCHIVE_IMPORTANCE_THRESHOLD = 35;
 export const DEFAULT_GHOST_CUE_MAX_TOKENS = 220;
-/** .gitignore content for the context tree — ignore derived artifacts only */
-export const CONTEXT_TREE_GITIGNORE = `# Derived artifacts — do not track
-.gitignore
-.snapshot.json
-_manifest.json
-_index.md
-*.abstract.md
-*.overview.md
-`;
+/** Patterns the context-tree .gitignore must contain (derived artifacts only). */
+export const CONTEXT_TREE_GITIGNORE_PATTERNS = [
+    '.gitignore',
+    '.snapshot.json',
+    '_manifest.json',
+    '_index.md',
+    '*.abstract.md',
+    '*.overview.md',
+];
+export const CONTEXT_TREE_GITIGNORE_HEADER = '# Derived artifacts — do not track';

package/dist/server/core/domain/entities/agent.js

@@ -30,6 +30,10 @@ export const AGENT_CONNECTOR_CONFIG = {
         default: 'skill',
         supported: ['rules', 'hook', 'mcp', 'skill'],
     },
+    'Claude Desktop': {
+        default: 'mcp',
+        supported: ['mcp'],
+    },
     Cline: {
         default: 'mcp',
         supported: ['rules', 'mcp'],

package/dist/server/core/domain/source/source-schema.d.ts

@@ -5,15 +5,15 @@ export declare const SourceSchema: z.ZodObject<{
     projectRoot: z.ZodString;
     readOnly: z.ZodLiteral<true>;
 }, "strip", z.ZodTypeAny, {
+    readOnly: true;
     addedAt: string;
     alias: string;
     projectRoot: string;
-    readOnly: true;
 }, {
+    readOnly: true;
     addedAt: string;
     alias: string;
     projectRoot: string;
-    readOnly: true;
 }>;
 export declare const SourcesFileSchema: z.ZodObject<{
     sources: z.ZodArray<z.ZodObject<{
@@ -22,32 +22,32 @@ export declare const SourcesFileSchema: z.ZodObject<{
         projectRoot: z.ZodString;
         readOnly: z.ZodLiteral<true>;
     }, "strip", z.ZodTypeAny, {
+        readOnly: true;
         addedAt: string;
         alias: string;
         projectRoot: string;
-        readOnly: true;
     }, {
+        readOnly: true;
         addedAt: string;
         alias: string;
         projectRoot: string;
-        readOnly: true;
     }>, "many">;
     version: z.ZodLiteral<1>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
     sources: {
+        readOnly: true;
         addedAt: string;
         alias: string;
         projectRoot: string;
-        readOnly: true;
     }[];
 }, {
     version: 1;
     sources: {
+        readOnly: true;
         addedAt: string;
         alias: string;
         projectRoot: string;
-        readOnly: true;
     }[];
 }>;
 export type Source = z.infer<typeof SourceSchema>;

package/dist/server/core/domain/transport/schemas.d.ts

@@ -755,13 +755,13 @@ export declare const TaskCompletedEventSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     result: string;
     taskId: string;
-    clientId?: string | undefined;
     logId?: string | undefined;
+    clientId?: string | undefined;
 }, {
     result: string;
     taskId: string;
-    clientId?: string | undefined;
     logId?: string | undefined;
+    clientId?: string | undefined;
 }>;
 /**
  * Structured error object
@@ -815,8 +815,8 @@ export declare const TaskErrorEventSchema: z.ZodObject<{
         details?: Record<string, unknown> | undefined;
     };
     taskId: string;
-    clientId?: string | undefined;
     logId?: string | undefined;
+    clientId?: string | undefined;
 }, {
     error: {
         message: string;
@@ -825,8 +825,8 @@ export declare const TaskErrorEventSchema: z.ZodObject<{
         details?: Record<string, unknown> | undefined;
     };
     taskId: string;
-    clientId?: string | undefined;
     logId?: string | undefined;
+    clientId?: string | undefined;
 }>;
 /**
  * llmservice:response - LLM text output

package/dist/server/infra/connectors/mcp/claude-desktop-config-path.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Dependencies for platform detection, injectable for testing.
+ */
+type PlatformDeps = {
+    env: Record<string, string | undefined>;
+    existsSync?: (path: string) => boolean;
+    homedir: () => string;
+    platform: () => NodeJS.Platform;
+};
+/**
+ * Returns the absolute path to the Claude Desktop config file,
+ * following platform conventions:
+ * - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
+ * - Windows: %APPDATA%\Claude\claude_desktop_config.json
+ * - Linux: ~/.config/Claude/claude_desktop_config.json
+ *
+ * @returns Absolute path to the Claude Desktop config file
+ */
+export declare const getClaudeDesktopConfigPath: (deps?: PlatformDeps) => string;
+export {};

package/dist/server/infra/connectors/mcp/claude-desktop-config-path.js

@@ -0,0 +1,47 @@
+import { existsSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+const CLAUDE_DESKTOP_CONFIG_FILE = 'claude_desktop_config.json';
+const CLAUDE_DESKTOP_DIR = 'Claude';
+// Publisher hash is derived from Anthropic's signing certificate — stable per publisher identity
+const MSIX_PACKAGE_DIR = 'Claude_pzs8sxrjxfjjc';
+const defaultDeps = {
+    env: process.env,
+    homedir,
+    platform,
+};
+/**
+ * Returns the absolute path to the Claude Desktop config file,
+ * following platform conventions:
+ * - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
+ * - Windows: %APPDATA%\Claude\claude_desktop_config.json
+ * - Linux: ~/.config/Claude/claude_desktop_config.json
+ *
+ * @returns Absolute path to the Claude Desktop config file
+ */
+export const getClaudeDesktopConfigPath = (deps = defaultDeps) => {
+    const currentPlatform = deps.platform();
+    if (currentPlatform === 'win32') {
+        const checkExists = deps.existsSync ?? existsSync;
+        const localAppData = deps.env.LOCALAPPDATA ?? join(deps.homedir(), 'AppData', 'Local');
+        const msixDir = join(localAppData, 'Packages', MSIX_PACKAGE_DIR, 'LocalCache', 'Roaming', CLAUDE_DESKTOP_DIR);
+        // Check directory, not the config file — file may not exist yet on first launch
+        if (checkExists(msixDir))
+            return join(msixDir, CLAUDE_DESKTOP_CONFIG_FILE);
+        const appData = deps.env.APPDATA;
+        if (appData !== undefined) {
+            return join(appData, CLAUDE_DESKTOP_DIR, CLAUDE_DESKTOP_CONFIG_FILE);
+        }
+        return join(deps.homedir(), 'AppData', 'Roaming', CLAUDE_DESKTOP_DIR, CLAUDE_DESKTOP_CONFIG_FILE);
+    }
+    if (currentPlatform === 'darwin') {
+        return join(deps.homedir(), 'Library', 'Application Support', CLAUDE_DESKTOP_DIR, CLAUDE_DESKTOP_CONFIG_FILE);
+    }
+    // Linux and other platforms: respect XDG_CONFIG_HOME if set
+    const xdgConfigHome = deps.env.XDG_CONFIG_HOME;
+    if (xdgConfigHome !== undefined) {
+        return join(xdgConfigHome, CLAUDE_DESKTOP_DIR, CLAUDE_DESKTOP_CONFIG_FILE);
+    }
+    // Default fallback (Linux and other platforms)
+    return join(deps.homedir(), '.config', CLAUDE_DESKTOP_DIR, CLAUDE_DESKTOP_CONFIG_FILE);
+};

package/dist/server/infra/connectors/mcp/mcp-connector-config.d.ts

@@ -19,6 +19,12 @@ export type McpConfigMode = 'auto' | 'manual';
 type McpConnectorConfigBase = {
     /** Path to the MCP config file (relative to project root). Used when scope is 'project'. */
     configPath?: string;
+    /**
+     * Function that returns an absolute path to the config file.
+     * Takes precedence over configPath when present.
+     * Used when the path varies by platform (e.g., Claude Desktop).
+     */
+    configPathResolver?: () => string;
     /** Config file format */
     format: McpConfigFormat;
     /** Guide URL or instructions for manual setup. Required when mode is 'manual'. */
@@ -106,6 +112,19 @@ export declare const MCP_CONNECTOR_CONFIGS: {
         };
         readonly serverKeyPath: readonly ["mcpServers", "brv"];
     };
+    readonly 'Claude Desktop': {
+        readonly configPathResolver: (deps?: {
+            env: Record<string, string | undefined>;
+            existsSync?: (path: string) => boolean;
+            homedir: () => string;
+            platform: () => NodeJS.Platform;
+        }) => string;
+        readonly format: "json";
+        readonly mode: "auto";
+        readonly scope: "global";
+        readonly serverConfig: McpServerConfig;
+        readonly serverKeyPath: readonly ["mcpServers", "brv"];
+    };
     readonly Cline: {
         readonly format: "json";
         readonly manualGuide: "https://docs.cline.bot/mcp/configuring-mcp-servers#editing-mcp-settings-files";

package/dist/server/infra/connectors/mcp/mcp-connector-config.js

@@ -1,3 +1,4 @@
+import { getClaudeDesktopConfigPath } from './claude-desktop-config-path.js';
 /* eslint-disable perfectionist/sort-objects */
 /** Default MCP server configuration */
 const DEFAULT_SERVER_CONFIG = {
@@ -60,6 +61,14 @@ export const MCP_CONNECTOR_CONFIGS = {
         },
         serverKeyPath: STANDARD_KEY_PATH,
     },
+    'Claude Desktop': {
+        configPathResolver: getClaudeDesktopConfigPath,
+        format: 'json',
+        mode: 'auto',
+        scope: 'global',
+        serverConfig: DEFAULT_SERVER_CONFIG,
+        serverKeyPath: STANDARD_KEY_PATH,
+    },
     Cline: {
         format: 'json',
         manualGuide: 'https://docs.cline.bot/mcp/configuring-mcp-servers#editing-mcp-settings-files',

package/dist/server/infra/connectors/mcp/mcp-connector.js

@@ -198,6 +198,9 @@ export class McpConnector {
      * - Global scope: relative to os.homedir()
      */
     getFullConfigPath(config) {
+        if (config.configPathResolver) {
+            return config.configPathResolver();
+        }
         if (!config.configPath) {
             return '';
         }
@@ -265,7 +268,9 @@ export class McpConnector {
      * Install the rule file with MCP-specific content.
      */
     async installRuleFile(agent) {
-        const rulesConfig = agent in RULES_CONNECTOR_CONFIGS ? RULES_CONNECTOR_CONFIGS[agent] : undefined;
+        const rulesConfig = agent in RULES_CONNECTOR_CONFIGS
+            ? RULES_CONNECTOR_CONFIGS[agent]
+            : undefined;
         if (!rulesConfig) {
             return;
         }
@@ -300,7 +305,9 @@ export class McpConnector {
      * Checks for markers AND MCP-specific tool references (brv-query, brv-curate).
      */
     async statusManual(agent) {
-        const rulesConfig = agent in RULES_CONNECTOR_CONFIGS ? RULES_CONNECTOR_CONFIGS[agent] : undefined;
+        const rulesConfig = agent in RULES_CONNECTOR_CONFIGS
+            ? RULES_CONNECTOR_CONFIGS[agent]
+            : undefined;
         if (!rulesConfig) {
             return {
                 configExists: false,
@@ -330,7 +337,9 @@ export class McpConnector {
      * Uninstall the rule file content.
      */
     async uninstallRuleFile(agent) {
-        const rulesConfig = agent in RULES_CONNECTOR_CONFIGS ? RULES_CONNECTOR_CONFIGS[agent] : undefined;
+        const rulesConfig = agent in RULES_CONNECTOR_CONFIGS
+            ? RULES_CONNECTOR_CONFIGS[agent]
+            : undefined;
         if (!rulesConfig) {
             return;
         }

package/dist/server/infra/http/provider-model-fetchers.js

@@ -121,6 +121,7 @@ export const CODEX_ALLOWED_MODELS = new Set([
     'gpt-5.2-codex',
     'gpt-5.3-codex',
     'gpt-5.4',
+    'gpt-5.4-mini',
 ]);
 /**
  * Fallback Codex models used when models.dev is unreachable and no disk cache exists.

package/dist/server/infra/process/feature-handlers.js

@@ -4,6 +4,7 @@
  * Registers all feature handlers (auth, init, status, etc.) on the transport server.
  * These handlers implement the TUI ↔ Server event contract.
  */
+import { access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ReviewEvents } from '../../../shared/transport/events/review-events.js';
 import { getAuthConfig } from '../../config/auth.config.js';
@@ -106,6 +107,18 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
     new LocationsHandler({
         contextTreeService,
         getActiveProjectPaths,
+        async pathExists(path) {
+            try {
+                await access(path);
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                    return false;
+                }
+                throw error;
+            }
+        },
         projectRegistry,
         resolveProjectPath,
         transport,

package/dist/server/infra/project/project-registry.js

@@ -82,7 +82,19 @@ export class ProjectRegistry {
         return info;
     }
     unregister(projectPath) {
-        const resolved = resolvePath(projectPath);
+        let resolved;
+        try {
+            resolved = resolvePath(projectPath);
+        }
+        catch (error) {
+            // ENOENT — path deleted from disk. Keys are already resolved, so try the raw input.
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                resolved = projectPath;
+            }
+            else {
+                throw error;
+            }
+        }
         if (!this.projects.has(resolved)) {
             return false;
         }

package/dist/server/infra/transport/handlers/locations-handler.d.ts

@@ -5,6 +5,7 @@ import { type ProjectPathResolver } from './handler-types.js';
 export interface LocationsHandlerDeps {
     contextTreeService: IContextTreeService;
     getActiveProjectPaths: () => string[];
+    pathExists: (path: string) => Promise<boolean>;
     projectRegistry: IProjectRegistry;
     resolveProjectPath: ProjectPathResolver;
     transport: ITransportServer;
@@ -16,6 +17,7 @@ export interface LocationsHandlerDeps {
 export declare class LocationsHandler {
     private readonly contextTreeService;
     private readonly getActiveProjectPaths;
+    private readonly pathExists;
     private readonly projectRegistry;
     private readonly resolveProjectPath;
     private readonly transport;

package/dist/server/infra/transport/handlers/locations-handler.js

@@ -9,12 +9,14 @@ import { resolveRequiredProjectPath } from './handler-types.js';
 export class LocationsHandler {
     contextTreeService;
     getActiveProjectPaths;
+    pathExists;
     projectRegistry;
     resolveProjectPath;
     transport;
     constructor(deps) {
         this.contextTreeService = deps.contextTreeService;
         this.getActiveProjectPaths = deps.getActiveProjectPaths;
+        this.pathExists = deps.pathExists;
         this.projectRegistry = deps.projectRegistry;
         this.resolveProjectPath = deps.resolveProjectPath;
         this.transport = deps.transport;
@@ -35,6 +37,18 @@ export class LocationsHandler {
         const all = this.projectRegistry.getAll();
         const activeSet = new Set(this.getActiveProjectPaths());
         const results = await Promise.all([...all.entries()].map(async ([path]) => {
+            try {
+                const exists = await this.pathExists(path);
+                if (!exists) {
+                    this.projectRegistry.unregister(path);
+                    return null;
+                }
+            }
+            catch {
+                // pathExists threw unexpectedly — skip this entry but do NOT unregister,
+                // since the path may still exist (e.g. a transient permission error).
+                return null;
+            }
             let isInitialized = false;
             try {
                 isInitialized = await this.contextTreeService.exists(path);
@@ -50,8 +64,9 @@ export class LocationsHandler {
                 projectPath: path,
             };
         }));
+        const filtered = results.filter((r) => r !== null);
         // Sort: current first → active (has clients) → initialized → rest, all by registeredAt desc
-        return results.sort((a, b) => {
+        return filtered.sort((a, b) => {
             if (a.isCurrent !== b.isCurrent)
                 return a.isCurrent ? -1 : 1;
             if (a.isActive !== b.isActive)

package/dist/server/infra/transport/handlers/vc-handler.d.ts

@@ -41,10 +41,6 @@ export declare class VcHandler {
     setup(): void;
     private buildAuthorHint;
     private buildNoRemoteMessage;
-    /**
-     * Writes a .gitignore to the context-tree directory only if one does not already exist.
-     */
-    private ensureGitignore;
     /**
      * When force is NOT set, checks for uncommitted changes and throws
      * VcError(UNCOMMITTED_CHANGES) if the working tree is dirty.

package/dist/server/infra/transport/handlers/vc-handler.js

@@ -1,13 +1,12 @@
 import fs from 'node:fs';
 import { join } from 'node:path';
 import { VcErrorCode, VcEvents, } from '../../../../shared/transport/events/vc-events.js';
-import { CONTEXT_TREE_GITIGNORE } from '../../../constants.js';
 import { BrvConfig } from '../../../core/domain/entities/brv-config.js';
 import { Space } from '../../../core/domain/entities/space.js';
 import { GitAuthError, GitError } from '../../../core/domain/errors/git-error.js';
 import { NotAuthenticatedError } from '../../../core/domain/errors/task-error.js';
 import { VcError } from '../../../core/domain/errors/vc-error.js';
-import { ensureGitignoreEntries } from '../../../utils/gitignore.js';
+import { ensureContextTreeGitignore, ensureGitignoreEntries } from '../../../utils/gitignore.js';
 import { buildCogitRemoteUrl, isValidBranchName, parseUserFacingUrl } from '../../git/cogit-url.js';
 import { resolveRequiredProjectPath } from './handler-types.js';
 /**
@@ -101,18 +100,6 @@ export class VcHandler {
             `  3. Run: brv vc remote add origin <url>\n` +
             `  4. Then: ${nextStep}`);
     }
-    /**
-     * Writes a .gitignore to the context-tree directory only if one does not already exist.
-     */
-    async ensureGitignore(contextTreeDir) {
-        const gitignorePath = join(contextTreeDir, '.gitignore');
-        try {
-            await fs.promises.access(gitignorePath);
-        }
-        catch {
-            await fs.promises.writeFile(gitignorePath, CONTEXT_TREE_GITIGNORE, 'utf8');
-        }
-    }
     /**
      * When force is NOT set, checks for uncommitted changes and throws
      * VcError(UNCOMMITTED_CHANGES) if the working tree is dirty.
@@ -134,6 +121,7 @@ export class VcHandler {
         if (!gitInitialized) {
             throw new VcError('ByteRover version control not initialized.', VcErrorCode.GIT_NOT_INITIALIZED);
         }
+        await ensureContextTreeGitignore(directory);
         const statusBefore = await this.gitService.status({ directory });
         const stagedBefore = new Set(statusBefore.files.filter((f) => f.staged).map((f) => f.path));
         const hadUnstagedBefore = new Set(statusBefore.files.filter((f) => !f.staged).map((f) => f.path));
@@ -350,7 +338,7 @@ export class VcHandler {
                 await this.projectConfigStore.write(updated, projectPath);
             }
             // Ensure .gitignore exists (remote may not have one)
-            await this.ensureGitignore(contextTreeDir);
+            await ensureContextTreeGitignore(contextTreeDir);
             // Add .brv entries to project .gitignore (prevents `git add .` fatal error from nested .git)
             await ensureGitignoreEntries(projectPath);
         }
@@ -456,7 +444,7 @@ export class VcHandler {
         const reinitialized = await this.gitService.isInitialized({ directory: contextTreeDir });
         await this.gitService.init({ defaultBranch: 'main', directory: contextTreeDir });
         // 3. Ensure .gitignore exists with correct content (idempotent)
-        await this.ensureGitignore(contextTreeDir);
+        await ensureContextTreeGitignore(contextTreeDir);
         // 4. Add .brv entries to project .gitignore (prevents `git add .` fatal error from nested .git)
         await ensureGitignoreEntries(projectPath);
         return {
@@ -818,6 +806,7 @@ export class VcHandler {
                 untracked: [],
             };
         }
+        await ensureContextTreeGitignore(contextTreeDir);
         const branch = await this.gitService.getCurrentBranch({ directory: contextTreeDir });
         const gitStatus = await this.gitService.status({ directory: contextTreeDir });
         // Detect empty repo (no commits yet)

package/dist/server/templates/skill/SKILL.md

@@ -310,6 +310,169 @@ brv vc push -u origin main       # push and set upstream tracking
 brv vc clone https://byterover.dev/<team>/<space>.git
 ```
 
+### 8. Swarm Query
+**Overview:** Search across all active memory providers simultaneously — ByteRover context tree, Obsidian vault, Local Markdown folders, GBrain, and Memory Wiki. Results are fused via Reciprocal Rank Fusion (RRF) and ranked by provider weight and relevance. No LLM call — pure algorithmic search.
+
+**Use this skill when:**
+- You need to search across multiple knowledge sources at once
+- The user has configured multiple memory providers (check with `brv swarm status`)
+- You want results from Obsidian notes, GBrain entities, or wiki pages alongside ByteRover context
+
+**Do NOT use this skill when:**
+- The user only has ByteRover configured — use `brv query` instead (it synthesizes via LLM)
+- You need an LLM-synthesized answer — `brv swarm query` returns raw search results, not synthesized text
+
+```bash
+brv swarm query "How does JWT refresh work?"
+```
+
+Output:
+```
+Swarm Query: "How does JWT refresh work?"
+Type: factual | Providers: 4 queried | Latency: 398ms
+──────────────────────────────────────────────────
+1. [memory-wiki] sources/jwt-token-lifecycle.md    score: 0.0150  [keyword]
+   # JWT Token Lifecycle ...
+2. [obsidian] SwarmTestData/Authentication System.md    score: 0.0142  [keyword]
+   # Authentication System ...
+3. [gbrain] alex-chen    score: 0.0117  [semantic]
+   # Alex Chen — Senior Backend Engineer ...
+```
+
+**With explain mode** (shows classification, provider selection, enrichment):
+```bash
+brv swarm query "authentication patterns" --explain
+```
+
+Output:
+```
+Classification: factual
+Provider selection: 4 of 4 available
+  ✓ byterover    (healthy, selected, 0 results, 14ms)
+  ✓ obsidian    (healthy, selected, 5 results, 91ms)
+  ✓ memory-wiki    (healthy, selected, 2 results, 15ms)
+  ✓ gbrain    (healthy, selected, 1 results, 260ms)
+Enrichment:
+  byterover → obsidian
+  byterover → memory-wiki
+Results: 8 raw → 7 after RRF fusion + precision filtering
+```
+
+**JSON output:**
+```bash
+brv swarm query "rate limiting" --format json
+```
+
+Output:
+```json
+{
+  "meta": {
+    "queryType": "factual",
+    "totalLatencyMs": 340,
+    "providers": {
+      "byterover": { "selected": true, "resultCount": 0 },
+      "obsidian": { "selected": true, "resultCount": 5 },
+      "gbrain": { "selected": true, "resultCount": 1 },
+      "memory-wiki": { "selected": true, "resultCount": 1 }
+    }
+  },
+  "results": [
+    { "provider": "memory-wiki", "providerType": "memory-wiki", "score": 0.015, "content": "# Rate Limiting ..." }
+  ]
+}
+```
+
+**Limit results:**
+```bash
+brv swarm query "testing strategy" -n 5
+```
+
+**Flags:** `--explain` (show routing details), `--format json` (structured output), `-n <value>` (max results).
+
+### 9. Swarm Curate
+**Overview:** Store knowledge in the best available external memory provider. ByteRover automatically classifies the content type and routes accordingly: entities (people, orgs) go to GBrain, notes (meeting notes, TODOs) go to Local Markdown, general content goes to the first writable provider. Falls back to ByteRover context tree if no external providers are available.
+
+**Use this skill when:**
+- You want to store knowledge in an external provider (GBrain, Local Markdown, Memory Wiki)
+- The user has configured writable swarm providers
+
+**Do NOT use this skill when:**
+- You want to store in ByteRover's context tree specifically — use `brv curate` instead
+- No swarm providers are configured — use `brv curate` instead
+
+```bash
+brv swarm curate "Jane Smith is the CTO of TechCorp"
+```
+
+Output:
+```
+Stored to gbrain as concept/jane-smith-cto
+```
+
+**Target a specific provider:**
+```bash
+brv swarm curate "meeting notes: decided on JWT" --provider local-markdown:notes
+```
+
+Output:
+```
+Stored to local-markdown:notes as note-1776052527043.md
+```
+
+```bash
+brv swarm curate "Architecture uses event sourcing" --provider gbrain
+```
+
+Output:
+```
+Stored to gbrain as concept/event-sourcing-architecture
+```
+
+**JSON output:**
+```bash
+brv swarm curate "Test content" --format json
+```
+
+Output:
+```json
+{
+  "id": "note-1776052594462.md",
+  "provider": "local-markdown:project-docs",
+  "success": true,
+  "latencyMs": 1
+}
+```
+
+**Flags:** `--provider <id>` (target specific provider), `--format json` (structured output).
+
+### 10. Swarm Status
+**Overview:** Check provider health and write targets before running swarm query or curate. Use this to verify which providers are available and operational.
+
+**Use this skill when:**
+- Before running `brv swarm query` or `brv swarm curate` to check available providers
+- Diagnosing why swarm results are missing from a specific provider
+
+```bash
+brv swarm status
+```
+
+Output:
+```
+Memory Swarm Health Check
+════════════════════════════════════════
+  ✓ ByteRover       context-tree (always on)
+  ✓ Obsidian        /Users/you/Documents/MyObsidian
+  ✓ Local .md       1 folder(s)
+  ✓ GBrain          /Users/you/workspaces/gbrain
+  ✓ Memory Wiki     /Users/you/.openclaw/wiki/main
+
+Write Targets:
+  gbrain (entity, general)
+  local-markdown:project-docs (note, general)
+
+Swarm is operational (5/5 providers configured).
+```
+
 ## Data Handling
 
 **Storage**: All knowledge is stored as Markdown files in `.brv/context-tree/` within the project directory. Files are human-readable and version-controllable.

package/dist/server/utils/gitignore.d.ts

@@ -7,3 +7,4 @@
  * is a convenience feature that should never block the caller.
  */
 export declare function ensureGitignoreEntries(directory: string): Promise<void>;
+export declare function ensureContextTreeGitignore(contextTreeDir: string): Promise<void>;