byterover-cli 3.0.1 → 3.2.0

package/dist/agent/infra/tools/implementations/search-knowledge-tool.js

@@ -4,11 +4,11 @@ import { SearchKnowledgeService } from './search-knowledge-service.js';
 const SearchKnowledgeInputSchema = z
     .object({
     excludeKinds: z
-        .array(z.enum(['archive_stub', 'context', 'domain', 'subtopic', 'topic']))
+        .array(z.enum(['archive_stub', 'context', 'domain', 'subtopic', 'summary', 'topic']))
         .optional()
         .describe('Symbol kinds to exclude from results'),
     includeKinds: z
-        .array(z.enum(['archive_stub', 'context', 'domain', 'subtopic', 'topic']))
+        .array(z.enum(['archive_stub', 'context', 'domain', 'subtopic', 'summary', 'topic']))
         .optional()
         .describe('Symbol kinds to include in results (filters out others)'),
     limit: z

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

@@ -1,3 +1,4 @@
+import type { EnvironmentContext } from '../../../core/domain/environment/types.js';
 import type { Tool } from '../../../core/domain/tools/types.js';
 import type { IFileSystem } from '../../../core/interfaces/i-file-system.js';
 /**
@@ -9,4 +10,4 @@ import type { IFileSystem } from '../../../core/interfaces/i-file-system.js';
  * @param fileSystemService - File system service dependency
  * @returns Configured write file tool
  */
-export declare function createWriteFileTool(fileSystemService: IFileSystem): Tool;
+export declare function createWriteFileTool(fileSystemService: IFileSystem, environmentContext?: EnvironmentContext): Tool;

package/dist/agent/infra/tools/implementations/write-file-tool.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { sanitizeFolderName } from '../../../../server/utils/file-helpers.js';
 import { ToolName } from '../../../core/domain/tools/constants.js';
+import { validateWriteTarget } from '../write-guard.js';
 /**
  * Input schema for write file tool.
  */
@@ -29,13 +30,26 @@ const WriteFileInputSchema = z
  * @param fileSystemService - File system service dependency
  * @returns Configured write file tool
  */
-export function createWriteFileTool(fileSystemService) {
+export function createWriteFileTool(fileSystemService, environmentContext) {
     return {
         description: 'Write content to a file. Overwrites existing files. Can optionally create parent directories.',
         async execute(input, _context) {
             const { content, createDirs, encoding, filePath } = input;
+            const sanitizedPath = sanitizeFolderName(filePath);
+            // Write guard: block writes to shared source context trees
+            if (environmentContext?.workingDirectory) {
+                const writeError = validateWriteTarget(sanitizedPath, environmentContext.workingDirectory);
+                if (writeError) {
+                    return {
+                        bytesWritten: 0,
+                        error: writeError,
+                        path: sanitizedPath,
+                        success: false,
+                    };
+                }
+            }
             // Call file system service
-            const result = await fileSystemService.writeFile(sanitizeFolderName(filePath), content, {
+            const result = await fileSystemService.writeFile(sanitizedPath, content, {
                 createDirs,
                 encoding: encoding,
             });

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

@@ -18,6 +18,7 @@ export class ToolProvider {
      * TypeScript ensures this object matches ToolServices keys at compile time.
      */
     static VALID_SERVICE_KEYS = new Set(Object.keys({
+        abstractQueue: 0,
         agentInstance: 0,
         contentGenerator: 0,
         environmentContext: 0,

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

@@ -9,6 +9,7 @@ import type { IProcessService } from '../../core/interfaces/i-process-service.js
 import type { ISandboxService } from '../../core/interfaces/i-sandbox-service.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';
 import type { MemoryManager } from '../memory/memory-manager.js';
 import type { ToolProviderGetter } from './tool-provider-getter.js';
 import { ToolMarker } from './tool-markers.js';
@@ -17,6 +18,8 @@ import { ToolMarker } from './tool-markers.js';
  * Tools declare which services they need via requiredServices.
  */
 export interface ToolServices {
+    /** Abstract generation queue for background L0/L1 abstract file generation */
+    abstractQueue?: AbstractGenerationQueue;
     /** Agent instance for creating sub-sessions (used by agentic_map) */
     agentInstance?: ICipherAgent;
     /** Content generator for stateless LLM calls (used by llm_map) */

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

@@ -6,6 +6,7 @@ import { createCurateTool } from './implementations/curate-tool.js';
 import { createExpandKnowledgeTool } from './implementations/expand-knowledge-tool.js';
 import { createGlobFilesTool } from './implementations/glob-files-tool.js';
 import { createGrepContentTool } from './implementations/grep-content-tool.js';
+import { createIngestResourceTool } from './implementations/ingest-resource-tool.js';
 import { createListDirectoryTool } from './implementations/list-directory-tool.js';
 import { createLlmMapTool } from './implementations/llm-map-tool.js';
 import { createReadFileTool } from './implementations/read-file-tool.js';
@@ -54,7 +55,7 @@ export const TOOL_REGISTRY = {
     },
     [ToolName.CODE_EXEC]: {
         descriptionFile: 'code_exec',
-        factory({ environmentContext, fileSystemService, sandboxService }) {
+        factory({ abstractQueue, environmentContext, fileSystemService, sandboxService }) {
             const sandbox = getRequiredService(sandboxService, 'sandboxService');
             // Inject file system service into sandbox for Tools SDK
             if (fileSystemService && sandbox.setFileSystem) {
@@ -67,7 +68,7 @@ export const TOOL_REGISTRY = {
             }
             // Inject curate service into sandbox for Tools SDK
             if (sandbox.setCurateService) {
-                const curateService = createCurateService(environmentContext?.workingDirectory);
+                const curateService = createCurateService(environmentContext?.workingDirectory, abstractQueue);
                 sandbox.setCurateService(curateService);
             }
             // Inject environment context into sandbox for env.* access
@@ -81,10 +82,10 @@ export const TOOL_REGISTRY = {
     },
     [ToolName.CURATE]: {
         descriptionFile: 'curate',
-        factory: ({ environmentContext }) => createCurateTool(environmentContext?.workingDirectory),
+        factory: ({ abstractQueue, environmentContext }) => createCurateTool(environmentContext?.workingDirectory, abstractQueue),
         markers: [ToolMarker.ContextBuilding, ToolMarker.Modification],
         outputGuidance: 'curate',
-        requiredServices: [], // Uses DirectoryManager and MarkdownWriter for file operations
+        requiredServices: [],
     },
     [ToolName.EXPAND_KNOWLEDGE]: {
         descriptionFile: 'expand_knowledge',
@@ -104,6 +105,16 @@ export const TOOL_REGISTRY = {
         markers: [ToolMarker.Core, ToolMarker.Discovery],
         requiredServices: ['fileSystemService'],
     },
+    [ToolName.INGEST_RESOURCE]: {
+        factory: ({ abstractQueue, contentGenerator, environmentContext, fileSystemService }) => createIngestResourceTool({
+            abstractQueue,
+            baseDirectory: environmentContext?.workingDirectory,
+            contentGenerator,
+            fileSystem: fileSystemService,
+        }),
+        markers: [ToolMarker.ContextBuilding, ToolMarker.Modification],
+        requiredServices: ['contentGenerator', 'fileSystemService'],
+    },
     [ToolName.LIST_DIRECTORY]: {
         descriptionFile: 'list_directory',
         factory: (services) => createListDirectoryTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
@@ -133,7 +144,7 @@ export const TOOL_REGISTRY = {
     },
     [ToolName.WRITE_FILE]: {
         descriptionFile: 'write_file',
-        factory: (services) => createWriteFileTool(getRequiredService(services.fileSystemService, 'fileSystemService')),
+        factory: (services) => createWriteFileTool(getRequiredService(services.fileSystemService, 'fileSystemService'), services.environmentContext),
         markers: [ToolMarker.Modification],
         requiredServices: ['fileSystemService'],
     },

package/dist/agent/infra/tools/write-guard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Validates that a write target path is within the local project's context tree,
+ * not inside any shared knowledge source's context tree.
+ *
+ * Shared sources are read-only — agents must never write to them.
+ *
+ * @param targetPath - Absolute path being written to
+ * @param projectRoot - The local project root (owns .brv/)
+ * @returns null if write is allowed, or an error message string if blocked
+ */
+export declare function validateWriteTarget(targetPath: string, projectRoot: string): null | string;

package/dist/agent/infra/tools/write-guard.js

@@ -0,0 +1,48 @@
+import { realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../../server/constants.js';
+import { loadSources } from '../../../server/core/domain/source/source-schema.js';
+import { isDescendantOf } from '../../../server/utils/path-utils.js';
+const canonicalize = (path) => {
+    try {
+        return realpathSync(resolve(path));
+    }
+    catch {
+        // For non-existent files, try canonicalizing the parent
+        try {
+            const parent = dirname(resolve(path));
+            return join(realpathSync(parent), basename(path));
+        }
+        catch {
+            return resolve(path);
+        }
+    }
+};
+/**
+ * Validates that a write target path is within the local project's context tree,
+ * not inside any shared knowledge source's context tree.
+ *
+ * Shared sources are read-only — agents must never write to them.
+ *
+ * @param targetPath - Absolute path being written to
+ * @param projectRoot - The local project root (owns .brv/)
+ * @returns null if write is allowed, or an error message string if blocked
+ */
+export function validateWriteTarget(targetPath, projectRoot) {
+    const localContextTree = resolve(projectRoot, BRV_DIR, CONTEXT_TREE_DIR);
+    const canonicalLocalContextTree = canonicalize(localContextTree);
+    const canonicalTarget = canonicalize(targetPath);
+    if (isDescendantOf(canonicalTarget, canonicalLocalContextTree)) {
+        return null;
+    }
+    // Load sources to get shared context tree roots
+    const loaded = loadSources(projectRoot);
+    for (const origin of loaded?.origins ?? []) {
+        const canonicalSharedRoot = canonicalize(origin.contextTreeRoot);
+        if (isDescendantOf(canonicalTarget, canonicalSharedRoot)) {
+            const alias = origin.alias ?? origin.originKey;
+            return `Cannot write to shared source "${alias}" — sources are read-only. Only the local context tree (${localContextTree}) is writable.`;
+        }
+    }
+    return `Cannot write outside the local context tree. Only the local context tree (${localContextTree}) is writable.`;
+}

package/dist/agent/resources/prompts/system-prompt.yml

@@ -38,6 +38,15 @@ prompt: |
   - Maximum depth: 2 levels (domain → topic → subtopic)
   </DIRECTORIES>
 
+  <KNOWLEDGE_SOURCES>
+  This project may have knowledge sources pointing to other projects' context trees (read-only).
+  - Search results may include `origin: "shared"` results from shared sources
+  - Shared results include `originContextTreeRoot` — use `join(originContextTreeRoot, path)` for `readFile`
+  - Local results get a slight relevance boost over shared results
+  - You CANNOT curate, write, or modify shared source context trees — they are read-only
+  - Only the local `.brv/context-tree/` is writable
+  </KNOWLEDGE_SOURCES>
+
   <TOOL_QUICK_REFERENCE>
   **Queries:** `code_exec` with `tools.*` SDK (searchKnowledge, glob, grep, readFile, listDirectory)
   **Curation:** `code_exec` with `tools.curate()` using UPSERT (preferred), ADD, UPDATE, MERGE, DELETE

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

@@ -14,6 +14,10 @@ When searching the knowledge base, you may encounter results with `symbolKind: "
 - `fullContent`: Complete original content of the archived entry
 - `tokenCount`: Estimated token count of the full content
 
+**Shared-source results:**
+- For shared results (`origin: "shared"`), the `stubPath` is relative to the shared context tree
+- Use `originContextTreeRoot` from the search result to resolve the full path
+
 **Example:**
 - Search returns: `{ path: "_archived/auth/jwt-tokens/refresh-flow.stub.md", symbolKind: "archive_stub" }`
 - Call: `expand_knowledge({ stubPath: "_archived/auth/jwt-tokens/refresh-flow.stub.md" })`

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

@@ -17,14 +17,24 @@ This tool enables semantic/fuzzy search across all curated knowledge without nee
   - `title`: Topic title
   - `excerpt`: Relevant content snippet
   - `score`: Relevance score (higher is better)
+  - `origin`: `"local"` or `"shared"` (shared = from a knowledge source pointing at another project)
+  - `originAlias`: Alias of the shared source (only for shared results)
+  - `originContextTreeRoot`: Absolute path to the shared context tree (only for shared results). Use `join(originContextTreeRoot, path)` to read full content.
 - `totalFound`: Total number of matches
 - `message`: Status message
 
+**Knowledge sources:**
+- Results may include entries from shared knowledge sources (read-only)
+- Shared results have `origin: "shared"` and `originContextTreeRoot` for reading
+- Local results are boosted slightly in relevance scoring
+- You cannot curate or write to shared source context trees
+
 **Usage tips:**
 - Use descriptive queries: "authentication flow" works better than "auth"
 - Search is fuzzy: minor typos are tolerated
 - Results are ranked by relevance to your query
-- Use `read_file` on returned paths to view full content
+- For local results, use `read_file` on returned paths to view full content
+- For shared results, use `read_file` on `join(originContextTreeRoot, path)`
 
 **Examples:**
 - Query: "API authentication" - finds topics about auth design

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

@@ -85,7 +85,7 @@ Bad examples:
         const taskType = flags.folder?.length ? 'curate-folder' : 'curate';
         let providerContext;
         try {
-            await withDaemonRetry(async (client, projectRoot) => {
+            await withDaemonRetry(async (client, projectRoot, worktreeRoot) => {
                 const active = await client.requestWithAck(TransportStateEventNames.GET_PROVIDER_CONFIG);
                 providerContext = { activeModel: active.activeModel, activeProvider: active.activeProvider };
                 if (!active.activeProvider) {
@@ -94,7 +94,7 @@ Bad examples:
                 if (active.providerKeyMissing) {
                     throw new Error(providerMissingMessage(active.activeProvider, active.authMethod));
                 }
-                await this.submitTask({ client, content: resolvedContent, flags, format, projectRoot, taskType });
+                await this.submitTask({ client, content: resolvedContent, flags, format, projectRoot, taskType, worktreeRoot });
             }, {
                 ...this.getDaemonClientOptions(),
                 onRetry: format === 'text'
@@ -221,7 +221,7 @@ Bad examples:
         }
     }
     async submitTask(props) {
-        const { client, content, flags, format, projectRoot, taskType } = props;
+        const { client, content, flags, format, projectRoot, taskType, worktreeRoot } = props;
         const hasFolders = Boolean(flags.folder?.length);
         const taskId = randomUUID();
         const taskPayload = {
@@ -232,6 +232,7 @@ Bad examples:
             ...(projectRoot ? { projectPath: projectRoot } : {}),
             taskId,
             type: taskType,
+            ...(worktreeRoot ? { worktreeRoot } : {}),
         };
         if (flags.detach) {
             const ack = await client.requestWithAck(TaskEvents.CREATE, taskPayload);

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

@@ -1,5 +1,5 @@
-import { findProjectRoot } from '@campfirein/brv-transport-client';
 import { Args, Command, Flags } from '@oclif/core';
+import { resolveProject } from '../../../server/infra/project/resolve-project.js';
 import { FileCurateLogStore } from '../../../server/infra/storage/file-curate-log-store.js';
 import { CurateLogUseCase } from '../../../server/infra/usecase/curate-log-use-case.js';
 import { getProjectDataDir } from '../../../server/utils/path-utils.js';
@@ -77,7 +77,7 @@ export default class CurateView extends Command {
         const after = flags.since ? this.parseTime(flags.since, '--since') : undefined;
         const before = flags.before ? this.parseTime(flags.before, '--before') : undefined;
         const format = flags.format === 'json' ? 'json' : 'text';
-        const projectRoot = (await findProjectRoot(process.cwd())) ?? process.cwd();
+        const projectRoot = resolveProject()?.projectRoot ?? process.cwd();
         const baseDir = getProjectDataDir(projectRoot);
         const store = new FileCurateLogStore({ baseDir });
         const useCase = new CurateLogUseCase({

package/dist/oclif/commands/main.js

@@ -1,5 +1,6 @@
 import { ensureDaemonRunning } from '@campfirein/brv-transport-client';
 import { Command } from '@oclif/core';
+import { resolveProject } from '../../server/infra/project/resolve-project.js';
 import { resolveLocalServerMainPath } from '../../server/utils/server-main-resolver.js';
 import { startRepl } from '../../tui/repl-startup.js';
 /**
@@ -31,9 +32,21 @@ export default class Main extends Command {
             const detail = daemonResult.spawnError ? `: ${daemonResult.spawnError}` : '';
             this.error(`Failed to start daemon: timed out waiting for daemon to become ready${detail}\n\nRun 'brv restart' to force a clean restart.`);
         }
+        // Resolve project (workspace-link-aware) before starting TUI.
+        // Gracefully handle broken/malformed workspace links so TUI still starts
+        // (user can fix via /worktree remove from within the REPL).
+        let resolution = null;
+        try {
+            resolution = resolveProject();
+        }
+        catch {
+            // Broken workspace link — start TUI without resolved project (falls back to cwd)
+        }
         // Start the interactive REPL (TUI connects via connectToDaemon internally)
         await startRepl({
+            projectPath: resolution?.projectRoot,
             version: this.config.version,
+            worktreeRoot: resolution?.worktreeRoot,
         });
         this.exit(0);
     }

package/dist/oclif/commands/query.js

@@ -47,7 +47,7 @@ Bad:
             return;
         let providerContext;
         try {
-            await withDaemonRetry(async (client, projectRoot) => {
+            await withDaemonRetry(async (client, projectRoot, worktreeRoot) => {
                 const active = await client.requestWithAck(TransportStateEventNames.GET_PROVIDER_CONFIG);
                 providerContext = { activeModel: active.activeModel, activeProvider: active.activeProvider };
                 if (!active.activeProvider) {
@@ -56,7 +56,7 @@ Bad:
                 if (active.providerKeyMissing) {
                     throw new Error(providerMissingMessage(active.activeProvider, active.authMethod));
                 }
-                await this.submitTask({ client, format, projectRoot, query: args.query });
+                await this.submitTask({ client, format, projectRoot, query: args.query, worktreeRoot });
             }, {
                 ...this.getDaemonClientOptions(),
                 onRetry: format === 'text'
@@ -82,7 +82,7 @@ Bad:
         }
     }
     async submitTask(props) {
-        const { client, format, projectRoot, query } = props;
+        const { client, format, projectRoot, query, worktreeRoot } = props;
         const taskId = randomUUID();
         const taskPayload = {
             clientCwd: process.cwd(),
@@ -90,6 +90,7 @@ Bad:
             ...(projectRoot ? { projectPath: projectRoot } : {}),
             taskId,
             type: 'query',
+            ...(worktreeRoot ? { worktreeRoot } : {}),
         };
         let finalResult;
         const completionPromise = waitForTaskCompletion({

package/dist/oclif/commands/source/add.d.ts

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

package/dist/oclif/commands/source/add.js

@@ -0,0 +1,42 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { resolve } from 'node:path';
+import { SourceEvents } from '../../../shared/transport/events/source-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class SourceAdd extends Command {
+    static args = {
+        path: Args.string({
+            description: 'Path to the target project containing .brv/',
+            required: true,
+        }),
+    };
+    static description = "Add a read-only knowledge source from another project's context tree";
+    static examples = [
+        '<%= config.bin %> <%= command.id %> /path/to/shared-lib',
+        '<%= config.bin %> <%= command.id %> /path/to/shared-lib --alias shared',
+    ];
+    static flags = {
+        alias: Flags.string({
+            description: 'Custom alias for the source (defaults to directory name)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SourceAdd);
+        const targetPath = resolve(args.path);
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(SourceEvents.ADD, {
+                alias: flags.alias,
+                targetPath,
+            }), { projectPath: process.cwd() });
+            if (result.success) {
+                this.log(result.message);
+            }
+            else {
+                this.error(result.message, { exit: 1 });
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error), { exit: 1 });
+        }
+    }
+}

package/dist/oclif/commands/source/index.d.ts

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

package/dist/oclif/commands/source/index.js

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Source extends Command {
+    static description = 'Manage knowledge sources (read-only references to other projects)';
+    static examples = ['<%= config.bin %> <%= command.id %> --help'];
+    async run() {
+        await this.config.runCommand('help', ['source']);
+    }
+}

package/dist/oclif/commands/source/list.d.ts

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

package/dist/oclif/commands/source/list.js

@@ -0,0 +1,32 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { SourceEvents } from '../../../shared/transport/events/source-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class SourceList extends Command {
+    static description = 'List all knowledge sources and their status';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(SourceEvents.LIST), { projectPath: process.cwd() });
+            if (result.error) {
+                this.error(result.error, { exit: 1 });
+            }
+            if (result.statuses.length === 0) {
+                this.log('No knowledge sources configured.');
+                return;
+            }
+            this.log('Knowledge Sources:');
+            for (const source of result.statuses) {
+                if (source.valid) {
+                    this.log(`   ${source.alias} → ${source.projectRoot} ${chalk.green('(valid)')}`);
+                }
+                else {
+                    this.log(`   ${source.alias} → ${source.projectRoot} ${chalk.red(`[BROKEN - run brv source remove ${source.alias}]`)}`);
+                }
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error), { exit: 1 });
+        }
+    }
+}

package/dist/oclif/commands/source/remove.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class SourceRemove extends Command {
+    static args: {
+        aliasOrPath: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/source/remove.js

@@ -0,0 +1,33 @@
+import { Args, Command } from '@oclif/core';
+import { SourceEvents } from '../../../shared/transport/events/source-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class SourceRemove extends Command {
+    static args = {
+        aliasOrPath: Args.string({
+            description: 'Alias or path of the knowledge source to remove',
+            required: true,
+        }),
+    };
+    static description = 'Remove a knowledge source';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> shared-lib',
+        '<%= config.bin %> <%= command.id %> /path/to/shared-lib',
+    ];
+    async run() {
+        const { args } = await this.parse(SourceRemove);
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(SourceEvents.REMOVE, {
+                aliasOrPath: args.aliasOrPath,
+            }), { projectPath: process.cwd() });
+            if (result.success) {
+                this.log(result.message);
+            }
+            else {
+                this.error(result.message, { exit: 1 });
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error), { exit: 1 });
+        }
+    }
+}

package/dist/oclif/commands/status.d.ts

@@ -6,8 +6,12 @@ export default class Status extends Command {
     static examples: string[];
     static flags: {
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'project-root': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    protected fetchStatus(options?: DaemonClientOptions): Promise<StatusDTO>;
+    protected fetchStatus(options?: DaemonClientOptions & {
+        projectRootFlag?: string;
+    }): Promise<StatusDTO>;
     run(): Promise<void>;
     private formatTextOutput;
     private logVcHint;