byterover-cli 3.2.0 → 3.4.0

package/dist/agent/infra/swarm/wizard/config-scaffolder.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Answers collected from the onboarding wizard.
+ */
+export type WizardAnswers = {
+    budget?: {
+        globalMonthlyCents: number;
+    };
+    /** Whether to enable enrichment edges between providers (default: true when 2+ providers) */
+    enrichment?: boolean;
+    providers: {
+        config: Record<string, unknown>;
+        enabled: boolean;
+        id: string;
+    }[];
+};
+/**
+ * Result from scaffoldConfig — YAML string plus any warnings.
+ */
+export type ScaffoldResult = {
+    /** Warnings about dropped duplicate entries (e.g. multiple obsidian vaults) */
+    warnings: string[];
+    /** YAML config string ready to write to `.brv/swarm/config.yaml` */
+    yaml: string;
+};
+/**
+ * Pure function: transforms wizard answers into a YAML config string.
+ * No side effects — fully testable.
+ *
+ * When multiple entries share the same provider ID:
+ * - `local-markdown`: folders arrays are merged (schema supports multiple folders)
+ * - All others: last entry wins, earlier entries produce a warning
+ *
+ * @param answers - Wizard answers with provider selections and config
+ * @returns ScaffoldResult with YAML string and any warnings
+ */
+export declare function scaffoldConfig(answers: WizardAnswers): ScaffoldResult;

package/dist/agent/infra/swarm/wizard/config-scaffolder.js

@@ -0,0 +1,96 @@
+import { dump } from 'js-yaml';
+/**
+ * Providers whose config schema supports only a single instance.
+ * Duplicates produce a warning and the last entry wins.
+ */
+const SINGLE_INSTANCE_PROVIDERS = new Set(['byterover', 'gbrain', 'hindsight', 'honcho', 'obsidian']);
+/**
+ * Map provider IDs to their YAML key names.
+ */
+const PROVIDER_YAML_KEYS = {
+    'byterover': 'byterover',
+    'gbrain': 'gbrain',
+    'hindsight': 'hindsight',
+    'honcho': 'honcho',
+    'local-markdown': 'local_markdown',
+    'obsidian': 'obsidian',
+};
+/**
+ * Pure function: transforms wizard answers into a YAML config string.
+ * No side effects — fully testable.
+ *
+ * When multiple entries share the same provider ID:
+ * - `local-markdown`: folders arrays are merged (schema supports multiple folders)
+ * - All others: last entry wins, earlier entries produce a warning
+ *
+ * @param answers - Wizard answers with provider selections and config
+ * @returns ScaffoldResult with YAML string and any warnings
+ */
+export function scaffoldConfig(answers) {
+    const config = {};
+    const warnings = [];
+    // Build providers section, merging duplicate entries
+    const providers = {};
+    for (const provider of answers.providers) {
+        if (!provider.enabled)
+            continue;
+        const yamlKey = PROVIDER_YAML_KEYS[provider.id] ?? provider.id;
+        const existing = providers[yamlKey];
+        if (existing && provider.config.folders && existing.folders) {
+            // Merge folders arrays for local_markdown (multiple folder entries)
+            existing.folders = [
+                ...existing.folders,
+                ...provider.config.folders,
+            ];
+        }
+        else if (existing && SINGLE_INSTANCE_PROVIDERS.has(provider.id)) {
+            // Single-instance provider: last entry wins, warn about earlier
+            const droppedDetail = existing.vault_path ?? existing.repo_path ?? existing.connection_string ?? provider.id;
+            warnings.push(`Multiple ${provider.id} entries selected — config only supports one. ` +
+                `Keeping the last selection; dropped earlier entry (${droppedDetail}).`);
+            Object.assign(existing, provider.config);
+        }
+        else if (existing) {
+            Object.assign(existing, provider.config);
+        }
+        else {
+            providers[yamlKey] = {
+                enabled: true,
+                ...provider.config,
+            };
+        }
+    }
+    config.providers = providers;
+    // Build enrichment section when user opted in (or default true for 2+ providers)
+    if (answers.enrichment !== false) {
+        const enabledIds = new Set(answers.providers.filter((p) => p.enabled).map((p) => p.id));
+        if (enabledIds.size >= 2 && enabledIds.has('byterover')) {
+            // ByteRover is the master — it feeds context to all other providers
+            const edges = [];
+            if (enabledIds.has('obsidian'))
+                edges.push({ from: 'byterover', to: 'obsidian' });
+            if (enabledIds.has('local-markdown'))
+                edges.push({ from: 'byterover', to: 'local-markdown' });
+            if (enabledIds.has('gbrain'))
+                edges.push({ from: 'byterover', to: 'gbrain' });
+            if (edges.length > 0) {
+                config.enrichment = { edges };
+            }
+        }
+    }
+    // Build budget section (only if specified)
+    if (answers.budget) {
+        config.budget = {
+            // eslint-disable-next-line camelcase -- YAML budget key
+            global_monthly_cap_cents: answers.budget.globalMonthlyCents,
+        };
+    }
+    const header = '# Memory Swarm Configuration for ByteRover-CLI\n# Generated by `brv swarm onboard`\n\n';
+    const body = dump(config, {
+        indent: 2,
+        lineWidth: 120,
+        noRefs: true,
+        sortKeys: false,
+    });
+    return { warnings, yaml: header + body };
+}

package/dist/agent/infra/swarm/wizard/provider-detector.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A provider discovered during environment scanning.
+ */
+export type DetectedProvider = {
+    /** Whether this provider was auto-discovered */
+    detected: boolean;
+    /** Environment variable name (for cloud providers) */
+    envVar?: string;
+    /** Unique provider identifier */
+    id: string;
+    /** Number of .md files found (for local providers) */
+    noteCount?: number;
+    /** File system path (for local providers) */
+    path?: string;
+    /** Local or cloud */
+    type: 'cloud' | 'local';
+};
+/**
+ * Options for provider detection.
+ */
+export type DetectProvidersOptions = {
+    /** Override environment variables (defaults to process.env) */
+    env?: Record<string, string | undefined>;
+    /**
+     * Roots to check for a GBrain CLI checkout (`src/cli.ts`).
+     * Defaults to workspace sibling, home, and known workspace paths.
+     * Pass a fixture path in tests; pass `[]` to force undetected.
+     */
+    gbrainCandidatePaths?: string[];
+    /** Explicit markdown folder paths to check */
+    markdownPaths?: string[];
+    /** Directories to scan for Obsidian vaults and .md folders */
+    searchPaths?: string[];
+};
+/**
+ * Return sensible default paths for scanning on the current platform.
+ * Exported for testability.
+ */
+export declare function getDefaultSearchPaths(): {
+    markdownPaths: string[];
+    searchPaths: string[];
+};
+/**
+ * Scan the environment for available memory providers.
+ *
+ * Detects:
+ * - Obsidian vaults (by scanning for `.obsidian/` directories)
+ * - Local markdown folders (by checking explicit paths for .md files)
+ * - Cloud providers (by checking environment variables)
+ *
+ * @param options - Search paths and env var overrides for testability
+ * @returns Array of detected (and undetected) providers
+ */
+export declare function detectProviders(options?: DetectProvidersOptions): Promise<DetectedProvider[]>;

package/dist/agent/infra/swarm/wizard/provider-detector.js

@@ -0,0 +1,153 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Count .md files in a directory (non-recursive, capped at 10000).
+ */
+function countMarkdownFiles(dirPath) {
+    try {
+        const entries = readdirSync(dirPath);
+        return entries.filter((e) => e.endsWith('.md')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Find Obsidian vaults by scanning for `.obsidian/` directories
+ * in immediate children of the given search paths.
+ */
+function findObsidianVaults(searchPaths) {
+    const results = [];
+    for (const searchPath of searchPaths) {
+        if (!existsSync(searchPath))
+            continue;
+        try {
+            const entries = readdirSync(searchPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const candidate = join(searchPath, entry.name);
+                if (existsSync(join(candidate, '.obsidian'))) {
+                    results.push({
+                        detected: true,
+                        id: 'obsidian',
+                        noteCount: countMarkdownFiles(candidate),
+                        path: candidate,
+                        type: 'local',
+                    });
+                }
+            }
+        }
+        catch {
+            // Skip inaccessible directories
+        }
+    }
+    return results;
+}
+/**
+ * Find markdown folders from explicit paths.
+ */
+function findMarkdownFolders(paths) {
+    const results = [];
+    for (const mdPath of paths) {
+        if (!existsSync(mdPath))
+            continue;
+        const count = countMarkdownFiles(mdPath);
+        if (count > 0) {
+            results.push({
+                detected: true,
+                id: 'local-markdown',
+                noteCount: count,
+                path: mdPath,
+                type: 'local',
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Return sensible default paths for scanning on the current platform.
+ * Exported for testability.
+ */
+export function getDefaultSearchPaths() {
+    const home = homedir();
+    const searchPaths = [
+        join(home, 'Documents'),
+        home,
+    ].filter((p) => existsSync(p));
+    const markdownPaths = [
+        join(home, 'notes'),
+        join(home, 'Notes'),
+        join(home, 'content-skill-graph'),
+        join(home, 'Documents', 'notes'),
+        join(home, 'Documents', 'Notes'),
+    ].filter((p) => existsSync(p));
+    return { markdownPaths, searchPaths };
+}
+/**
+ * Scan the environment for available memory providers.
+ *
+ * Detects:
+ * - Obsidian vaults (by scanning for `.obsidian/` directories)
+ * - Local markdown folders (by checking explicit paths for .md files)
+ * - Cloud providers (by checking environment variables)
+ *
+ * @param options - Search paths and env var overrides for testability
+ * @returns Array of detected (and undetected) providers
+ */
+export async function detectProviders(options) {
+    // const env = options?.env ?? process.env  // Re-enable for honcho/hindsight detection in Phase 3
+    const defaults = options?.searchPaths ? undefined : getDefaultSearchPaths();
+    const searchPaths = options?.searchPaths ?? defaults?.searchPaths ?? [];
+    const markdownPaths = options?.markdownPaths ?? defaults?.markdownPaths ?? [];
+    const providers = [];
+    // ByteRover is always present
+    providers.push({
+        detected: true,
+        id: 'byterover',
+        type: 'local',
+    });
+    // Scan for Obsidian vaults
+    const obsidianVaults = findObsidianVaults(searchPaths);
+    if (obsidianVaults.length > 0) {
+        providers.push(...obsidianVaults);
+    }
+    else {
+        providers.push({
+            detected: false,
+            id: 'obsidian',
+            type: 'local',
+        });
+    }
+    // Check explicit markdown folders
+    const mdFolders = findMarkdownFolders(markdownPaths);
+    if (mdFolders.length > 0) {
+        providers.push(...mdFolders);
+    }
+    // Always include an undetected local-markdown entry so the user can manually add folders
+    // Cloud providers — check env vars
+    providers.push({
+        detected: false,
+        id: 'local-markdown',
+        type: 'local',
+    });
+    // Honcho and Hindsight temporarily disabled — adapters coming in Phase 3.
+    // GBrain — detect local CLI checkout by checking common locations for src/cli.ts
+    // (This path is the tool source tree, not `providers.gbrain.repoPath` / brain data.)
+    const gbrainCandidates = options?.gbrainCandidatePaths === undefined
+        ? [
+            join(process.cwd(), '..', 'gbrain'),
+            join(homedir(), 'gbrain'),
+            join(homedir(), 'Myspace', 'campfire', 'workspace', 'gbrain'),
+        ]
+        : options.gbrainCandidatePaths;
+    const gbrainPath = gbrainCandidates.find((p) => existsSync(join(p, 'src', 'cli.ts')));
+    providers.push({
+        detected: Boolean(gbrainPath),
+        id: 'gbrain',
+        path: gbrainPath,
+        type: 'cloud',
+    });
+    return providers;
+}

package/dist/agent/infra/swarm/wizard/swarm-wizard.d.ts

@@ -0,0 +1,61 @@
+import type { WizardAnswers } from './config-scaffolder.js';
+import type { DetectedProvider } from './provider-detector.js';
+/**
+ * Error thrown when the user cancels the wizard.
+ */
+export declare class WizardCancelledError extends Error {
+    readonly name = "WizardCancelledError";
+    constructor(message?: string);
+}
+/**
+ * Sentinel error thrown by prompt implementations to signal ESC back-navigation.
+ * The wizard catches this and returns to the previous step.
+ */
+export declare class EscBackError extends Error {
+    readonly name = "EscBackError";
+    constructor();
+}
+/**
+ * Injectable prompts interface for the onboarding wizard.
+ * Tests inject mock implementations; production uses real `@inquirer/prompts`.
+ */
+export interface MemoryWizardPrompts {
+    /**
+     * Ask user to configure budget for cloud providers.
+     */
+    configureBudget(): Promise<{
+        globalMonthlyCents: number;
+    }>;
+    /**
+     * Ask user whether to enable enrichment (provider chaining).
+     * Shown when 2+ providers are selected. Returns true to enable, false to skip.
+     */
+    configureEnrichment(providerIds: string[]): Promise<boolean>;
+    /**
+     * Ask user to configure a specific provider (vault path, API key, etc.)
+     */
+    configureProvider(provider: DetectedProvider): Promise<Record<string, unknown>>;
+    /**
+     * Confirm that the wizard should write the config file.
+     */
+    confirmWrite(summary: string): Promise<boolean>;
+    /**
+     * Ask user to select which providers to enable from detected list.
+     * Returns array of indices into the detected array (as strings).
+     * Using indices instead of IDs supports multiple entries with the same provider type.
+     */
+    selectProviders(detected: DetectedProvider[]): Promise<string[]>;
+}
+/**
+ * Run the memory swarm onboarding wizard.
+ *
+ * Orchestrates: select → configure → budget → confirm.
+ * ESC back-navigation: prompts throw `EscBackError` to go back one step.
+ * Ctrl+C propagates as-is (handled by the command).
+ *
+ * @param prompts - Injectable prompt functions
+ * @param detected - Pre-scanned providers from detectProviders()
+ * @returns Wizard answers ready for scaffoldConfig()
+ * @throws WizardCancelledError if user declines to write
+ */
+export declare function runMemoryWizard(prompts: MemoryWizardPrompts, detected: DetectedProvider[]): Promise<WizardAnswers>;

package/dist/agent/infra/swarm/wizard/swarm-wizard.js

@@ -0,0 +1,187 @@
+/**
+ * Error thrown when the user cancels the wizard.
+ */
+export class WizardCancelledError extends Error {
+    name = 'WizardCancelledError';
+    constructor(message = 'Wizard cancelled by user') {
+        super(message);
+    }
+}
+/**
+ * Sentinel error thrown by prompt implementations to signal ESC back-navigation.
+ * The wizard catches this and returns to the previous step.
+ */
+export class EscBackError extends Error {
+    name = 'EscBackError';
+    constructor() {
+        super('ESC back');
+    }
+}
+/**
+ * Providers whose config schema supports only a single instance.
+ * Duplicates produce a warning shown in the summary before confirm.
+ */
+const SINGLE_INSTANCE_PROVIDERS = new Set(['byterover', 'gbrain', 'hindsight', 'honcho', 'obsidian']);
+/**
+ * Detect duplicate single-instance providers and return user-facing warnings.
+ * local-markdown is excluded because its folders array supports merging.
+ */
+function detectDuplicateWarnings(providers) {
+    const warnings = [];
+    const seen = new Map();
+    for (const provider of providers) {
+        if (!provider.enabled)
+            continue;
+        if (!SINGLE_INSTANCE_PROVIDERS.has(provider.id))
+            continue;
+        const previous = seen.get(provider.id);
+        if (previous) {
+            const droppedDetail = previous.vault_path ?? previous.repo_path ?? previous.connection_string ?? provider.id;
+            warnings.push(`Warning: Multiple ${provider.id} entries selected but config only supports one. ` +
+                `Earlier entry (${droppedDetail}) will be dropped; keeping the last.`);
+        }
+        seen.set(provider.id, provider.config);
+    }
+    return warnings;
+}
+/**
+ * Build a summary string for the confirmation step.
+ */
+function buildSummary(providers, _budget, // Temporarily disabled — re-enable in Phase 3
+duplicateWarnings, enrichment) {
+    const localCount = providers.filter((p) => p.enabled).length;
+    const lines = [
+        `Providers: ${localCount}`,
+        ...providers.filter((p) => p.enabled).map((p) => `  - ${p.id}`),
+    ];
+    // Budget temporarily disabled — re-enable in Phase 3 with cloud providers.
+    // if (budget) {
+    //   lines.push(`Budget: $${(budget.globalMonthlyCents / 100).toFixed(2)}/month`)
+    // } else {
+    //   lines.push('Budget: $0/month (local only)')
+    // }
+    lines.push('Strategy: adaptive routing', `Enrichment: ${enrichment === false ? 'off (all parallel)' : 'on (providers feed context to each other)'}`);
+    if (duplicateWarnings && duplicateWarnings.length > 0) {
+        lines.push('', ...duplicateWarnings);
+    }
+    return lines.join('\n');
+}
+/**
+ * Resolve selected keys (indices) to detected provider entries,
+ * ensuring byterover is always included.
+ */
+function resolveSelectedProviders(selectedKeys, detected) {
+    const selected = selectedKeys
+        .map((key) => detected[Number(key)])
+        .filter((p) => p !== undefined);
+    if (!selected.some((p) => p.id === 'byterover')) {
+        const brvEntry = detected.find((p) => p.id === 'byterover');
+        if (brvEntry) {
+            selected.unshift(brvEntry);
+        }
+    }
+    return selected;
+}
+/**
+ * Configure each selected provider, returning wizard provider entries.
+ */
+async function configureProviders(prompts, selectedProviders) {
+    const providers = [];
+    for (const detectedProvider of selectedProviders) {
+        if (detectedProvider.id === 'byterover') {
+            providers.push({ config: {}, enabled: true, id: 'byterover' });
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop -- user-facing prompts must stay sequential
+        const config = await prompts.configureProvider(detectedProvider);
+        providers.push({ config, enabled: true, id: detectedProvider.id });
+    }
+    return providers;
+}
+/**
+ * Run the memory swarm onboarding wizard.
+ *
+ * Orchestrates: select → configure → budget → confirm.
+ * ESC back-navigation: prompts throw `EscBackError` to go back one step.
+ * Ctrl+C propagates as-is (handled by the command).
+ *
+ * @param prompts - Injectable prompt functions
+ * @param detected - Pre-scanned providers from detectProviders()
+ * @returns Wizard answers ready for scaffoldConfig()
+ * @throws WizardCancelledError if user declines to write
+ */
+export async function runMemoryWizard(prompts, detected) {
+    let step = 'select';
+    let selectedProviders = [];
+    let providers = [];
+    let enrichment;
+    /** Whether enrichment step should be shown (2+ providers including byterover) */
+    const shouldAskEnrichment = () => selectedProviders.length >= 2 && selectedProviders.some((p) => p.id === 'byterover');
+    /* eslint-disable no-await-in-loop -- wizard steps are inherently sequential (user-facing prompts) */
+    // Step-based loop with ESC back-navigation
+    // Flow: select → configure → enrichment → confirm
+    // Budget step temporarily disabled — re-enable in Phase 3 with cloud providers.
+    while (true) {
+        try {
+            switch (step) {
+                // Budget temporarily disabled — re-enable when cloud providers are wired.
+                // case 'budget': {
+                //   budget = await prompts.configureBudget()
+                //   step = 'confirm'
+                //   break
+                // }
+                case 'configure': {
+                    providers = await configureProviders(prompts, selectedProviders);
+                    step = shouldAskEnrichment() ? 'enrichment' : 'confirm';
+                    break;
+                }
+                case 'confirm': {
+                    const duplicateWarnings = detectDuplicateWarnings(providers);
+                    const summary = buildSummary(providers, undefined, duplicateWarnings, enrichment);
+                    const confirmed = await prompts.confirmWrite(summary);
+                    if (!confirmed) {
+                        throw new WizardCancelledError();
+                    }
+                    return { enrichment, providers };
+                }
+                case 'enrichment': {
+                    const providerIds = providers.filter((p) => p.enabled).map((p) => p.id);
+                    enrichment = await prompts.configureEnrichment(providerIds);
+                    step = 'confirm';
+                    break;
+                }
+                case 'select': {
+                    const selectedKeys = await prompts.selectProviders(detected);
+                    selectedProviders = resolveSelectedProviders(selectedKeys, detected);
+                    step = 'configure';
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof EscBackError) {
+                // Go back one step
+                switch (step) {
+                    case 'configure': {
+                        step = 'select';
+                        break;
+                    }
+                    case 'confirm': {
+                        step = shouldAskEnrichment() ? 'enrichment' : 'configure';
+                        break;
+                    }
+                    case 'enrichment': {
+                        step = 'configure';
+                        break;
+                    }
+                    default: {
+                        // Already at first step — ignore ESC
+                        break;
+                    }
+                }
+                continue;
+            }
+            throw error;
+        }
+    }
+}

package/dist/agent/infra/system-prompt/contributors/index.d.ts

@@ -11,3 +11,4 @@ export type { FileContributorOptions } from './file-contributor.js';
 export { MemoryContributor } from './memory-contributor.js';
 export type { MemoryContributorOptions } from './memory-contributor.js';
 export { StaticContributor } from './static-contributor.js';
+export { SwarmStateContributor } from './swarm-state-contributor.js';

package/dist/agent/infra/system-prompt/contributors/index.js

@@ -6,3 +6,4 @@ export { EnvironmentContributor } from './environment-contributor.js';
 export { FileContributor } from './file-contributor.js';
 export { MemoryContributor } from './memory-contributor.js';
 export { StaticContributor } from './static-contributor.js';
+export { SwarmStateContributor } from './swarm-state-contributor.js';

package/dist/agent/infra/system-prompt/contributors/swarm-state-contributor.d.ts

@@ -0,0 +1,15 @@
+import type { ContributorContext, SystemPromptContributor } from '../../../core/domain/system-prompt/types.js';
+import type { ISwarmCoordinator } from '../../../core/interfaces/i-swarm-coordinator.js';
+/**
+ * System prompt contributor that injects swarm state information.
+ *
+ * Only contributes when more than 1 provider is registered,
+ * since a single provider (ByteRover) doesn't need swarm awareness.
+ */
+export declare class SwarmStateContributor implements SystemPromptContributor {
+    readonly id: string;
+    readonly priority: number;
+    private readonly coordinator;
+    constructor(id: string, priority: number, coordinator: ISwarmCoordinator);
+    getContent(_context: ContributorContext): Promise<string>;
+}

package/dist/agent/infra/system-prompt/contributors/swarm-state-contributor.js

@@ -0,0 +1,65 @@
+/**
+ * System prompt contributor that injects swarm state information.
+ *
+ * Only contributes when more than 1 provider is registered,
+ * since a single provider (ByteRover) doesn't need swarm awareness.
+ */
+export class SwarmStateContributor {
+    id;
+    priority;
+    coordinator;
+    constructor(id, priority, coordinator) {
+        this.id = id;
+        this.priority = priority;
+        this.coordinator = coordinator;
+    }
+    async getContent(_context) {
+        const providers = this.coordinator.getActiveProviders();
+        // No swarm awareness needed with 0 or 1 provider
+        if (providers.length <= 1) {
+            return '';
+        }
+        const lines = [
+            '<swarm-state>',
+            '## Memory Swarm',
+            '',
+            `${providers.length} memory providers are active. Use the \`swarm_query\` tool to search across all of them.`,
+            '',
+            '### Active Providers',
+        ];
+        for (const p of providers) {
+            const status = p.healthy ? 'healthy' : 'unhealthy';
+            const caps = [];
+            if (p.capabilities.keywordSearch)
+                caps.push('keyword');
+            if (p.capabilities.semanticSearch)
+                caps.push('semantic');
+            if (p.capabilities.graphTraversal)
+                caps.push('graph');
+            if (p.capabilities.temporalQuery)
+                caps.push('temporal');
+            if (p.capabilities.userModeling)
+                caps.push('user-modeling');
+            lines.push(`- **${p.id}** (${p.type}) — ${status} — capabilities: ${caps.join(', ')}`);
+        }
+        // Write guidance — only show if writable providers exist
+        const writableProviders = providers.filter((p) => p.capabilities.writeSupported && p.healthy);
+        if (writableProviders.length > 0) {
+            lines.push('', '### Writing Knowledge', 'Use `swarm_store` to write to external providers:');
+            for (const p of writableProviders) {
+                if (p.type === 'gbrain') {
+                    lines.push(`- **${p.id}**: structured entities (people, companies, concepts)`);
+                }
+                else if (p.type === 'local-markdown') {
+                    lines.push(`- **${p.id}**: notes, drafts, meeting summaries`);
+                }
+                else {
+                    lines.push(`- **${p.id}**: general knowledge`);
+                }
+            }
+            lines.push('Use `curate` for project-specific knowledge (writes to context tree).');
+        }
+        lines.push('', '</swarm-state>');
+        return lines.join('\n');
+    }
+}