byterover-cli 3.1.0 → 3.2.0

package/dist/server/infra/transport/handlers/index.js

@@ -11,6 +11,8 @@ export { PullHandler } from './pull-handler.js';
 export { PushHandler } from './push-handler.js';
 export { ResetHandler } from './reset-handler.js';
 export { ReviewHandler } from './review-handler.js';
+export { SourceHandler } from './source-handler.js';
 export { SpaceHandler } from './space-handler.js';
 export { StatusHandler } from './status-handler.js';
 export { VcHandler } from './vc-handler.js';
+export { WorktreeHandler } from './worktree-handler.js';

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

@@ -0,0 +1,12 @@
+import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import { type ProjectPathResolver } from './handler-types.js';
+export interface SourceHandlerDeps {
+    resolveProjectPath: ProjectPathResolver;
+    transport: ITransportServer;
+}
+export declare class SourceHandler {
+    private readonly resolveProjectPath;
+    private readonly transport;
+    constructor(deps: SourceHandlerDeps);
+    setup(): void;
+}

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

@@ -0,0 +1,37 @@
+import { SourceEvents, } from '../../../../shared/transport/events/source-events.js';
+import { addSource, listSourceStatuses, removeSource } from '../../../core/domain/source/source-operations.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+export class SourceHandler {
+    resolveProjectPath;
+    transport;
+    constructor(deps) {
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(SourceEvents.ADD, async (data, clientId) => {
+            const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+            const result = addSource(projectPath, data.targetPath, data.alias);
+            return {
+                message: result.message,
+                success: result.success,
+            };
+        });
+        this.transport.onRequest(SourceEvents.REMOVE, async (data, clientId) => {
+            const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+            const result = removeSource(projectPath, data.aliasOrPath);
+            return {
+                message: result.message,
+                success: result.success,
+            };
+        });
+        this.transport.onRequest(SourceEvents.LIST, async (_data, clientId) => {
+            const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+            const result = listSourceStatuses(projectPath);
+            return {
+                error: result.error,
+                statuses: result.statuses,
+            };
+        });
+    }
+}

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

@@ -2,6 +2,8 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { StatusEvents } from '../../../../shared/transport/events/status-events.js';
 import { BRV_DIR, CONTEXT_TREE_DIR } from '../../../constants.js';
+import { listSourceStatuses } from '../../../core/domain/source/source-operations.js';
+import { BrokenWorktreePointerError, MalformedWorktreePointerError, resolveProject } from '../../project/resolve-project.js';
 import { resolveRequiredProjectPath } from './handler-types.js';
 /**
  * Handles status:get event.
@@ -25,18 +27,45 @@ export class StatusHandler {
         this.transport = deps.transport;
     }
     setup() {
-        this.transport.onRequest(StatusEvents.GET, async (_data, clientId) => {
+        this.transport.onRequest(StatusEvents.GET, async (data, clientId) => {
             const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
-            const status = await this.collectStatus(projectPath);
+            const request = data;
+            const cwd = request?.cwd;
+            const projectRootFlag = request?.projectRootFlag;
+            const status = await this.collectStatus(projectPath, cwd, projectRootFlag);
             return { status };
         });
     }
-    async collectStatus(projectPath) {
+    async collectStatus(projectPath, clientCwd, projectRootFlag) {
         const result = {
             authStatus: 'unknown',
             contextTreeStatus: 'unknown',
             currentDirectory: projectPath,
+            projectRoot: projectPath,
         };
+        // Resolve workspace awareness from client cwd (if provided)
+        // Use resolved projectRoot for all downstream checks to avoid inconsistency
+        let effectiveProjectPath = projectPath;
+        if (clientCwd || projectRootFlag) {
+            try {
+                const resolution = resolveProject({ cwd: clientCwd, projectRootFlag });
+                if (resolution) {
+                    result.projectRoot = resolution.projectRoot;
+                    result.worktreeRoot = resolution.worktreeRoot;
+                    result.resolutionSource = resolution.source;
+                    effectiveProjectPath = resolution.projectRoot;
+                }
+            }
+            catch (error) {
+                // Surface broken/malformed link errors as actionable status info
+                if (error instanceof BrokenWorktreePointerError || error instanceof MalformedWorktreePointerError) {
+                    result.resolverError = error.message;
+                }
+                // Fall through with projectPath defaults for config/context checks
+            }
+        }
+        // Preserve actual client working directory for backward compat
+        result.currentDirectory = clientCwd ?? projectPath;
         // Auth status
         try {
             const token = await this.tokenStore.load();
@@ -54,11 +83,11 @@ export class StatusHandler {
         catch {
             result.authStatus = 'unknown';
         }
-        // Project status
+        // Project status — use effectiveProjectPath for consistency with resolved root
         try {
-            const isInitialized = await this.projectConfigStore.exists(projectPath);
+            const isInitialized = await this.projectConfigStore.exists(effectiveProjectPath);
             if (isInitialized) {
-                const config = await this.projectConfigStore.read(projectPath);
+                const config = await this.projectConfigStore.read(effectiveProjectPath);
                 if (config) {
                     result.teamName = config.teamName;
                     result.spaceName = config.spaceName;
@@ -75,22 +104,22 @@ export class StatusHandler {
         catch {
             // File doesn't exist yet — no queue running
         }
-        // Context tree status
+        // Context tree status — use effectiveProjectPath for consistency with resolved root
         try {
-            const contextTreeExists = await this.contextTreeService.exists(projectPath);
+            const contextTreeExists = await this.contextTreeService.exists(effectiveProjectPath);
             if (contextTreeExists) {
-                const hasGitVc = await this.contextTreeService.hasGitRepo(projectPath);
+                const hasGitVc = await this.contextTreeService.hasGitRepo(effectiveProjectPath);
                 if (hasGitVc) {
                     result.contextTreeStatus = 'git_vc';
                 }
                 else {
-                    result.contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
+                    result.contextTreeDir = join(effectiveProjectPath, BRV_DIR, CONTEXT_TREE_DIR);
                     result.contextTreeRelativeDir = join(BRV_DIR, CONTEXT_TREE_DIR);
-                    const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(projectPath);
+                    const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(effectiveProjectPath);
                     if (!hasSnapshot) {
-                        await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
+                        await this.contextTreeSnapshotService.initEmptySnapshot(effectiveProjectPath);
                     }
-                    const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+                    const changes = await this.contextTreeSnapshotService.getChanges(effectiveProjectPath);
                     const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
                     if (hasChanges) {
                         result.contextTreeStatus = 'has_changes';
@@ -139,6 +168,19 @@ export class StatusHandler {
         catch {
             // Best-effort — if the log is unavailable, skip review info
         }
+        // Knowledge sources status
+        try {
+            const sourcesResult = listSourceStatuses(effectiveProjectPath);
+            if (sourcesResult.error) {
+                result.sourcesError = sourcesResult.error;
+            }
+            else if (sourcesResult.statuses.length > 0) {
+                result.sources = sourcesResult.statuses;
+            }
+        }
+        catch {
+            // Best-effort — swallow errors
+        }
         return result;
     }
 }

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

@@ -0,0 +1,12 @@
+import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import { type ProjectPathResolver } from './handler-types.js';
+export interface WorktreeHandlerDeps {
+    resolveProjectPath: ProjectPathResolver;
+    transport: ITransportServer;
+}
+export declare class WorktreeHandler {
+    private readonly resolveProjectPath;
+    private readonly transport;
+    constructor(deps: WorktreeHandlerDeps);
+    setup(): void;
+}

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

@@ -0,0 +1,67 @@
+import { WorktreeEvents, } from '../../../../shared/transport/events/worktree-events.js';
+import { addWorktree, findParentProject, listWorktrees, removeWorktree, resolveProject } from '../../project/resolve-project.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+export class WorktreeHandler {
+    resolveProjectPath;
+    transport;
+    constructor(deps) {
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(WorktreeEvents.ADD, async (data, clientId) => {
+            // Resolve the parent project from client registration
+            let projectPath;
+            try {
+                projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+            }
+            catch {
+                // Client not associated — fall through to auto-detect
+            }
+            // Auto-detect: if no project resolved, or client's project IS the worktree path
+            // (user ran `brv worktree add` from a child dir with no args), walk up to find parent
+            if (!projectPath || projectPath === data.worktreePath) {
+                const parent = findParentProject(data.worktreePath);
+                if (parent) {
+                    projectPath = parent;
+                }
+                else if (!projectPath) {
+                    return { message: 'No parent project found for the target directory.', success: false };
+                }
+            }
+            const result = addWorktree(projectPath, data.worktreePath, { force: data.force });
+            return {
+                backedUp: result.backedUp,
+                message: result.message,
+                success: result.success,
+            };
+        });
+        this.transport.onRequest(WorktreeEvents.REMOVE, async (data) => {
+            const targetPath = data.worktreePath;
+            const result = removeWorktree(targetPath);
+            return {
+                message: result.message,
+                success: result.success,
+            };
+        });
+        this.transport.onRequest(WorktreeEvents.LIST, async (_data, clientId) => {
+            const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+            const resolution = resolveProject({ cwd: projectPath });
+            if (!resolution) {
+                return {
+                    projectRoot: projectPath,
+                    source: 'direct',
+                    worktreeRoot: projectPath,
+                    worktrees: [],
+                };
+            }
+            const worktrees = listWorktrees(resolution.projectRoot);
+            return {
+                projectRoot: resolution.projectRoot,
+                source: resolution.source,
+                worktreeRoot: resolution.worktreeRoot,
+                worktrees,
+            };
+        });
+    }
+}

package/dist/server/infra/transport/transport-connector.d.ts

@@ -1,13 +1,19 @@
 import { type ConnectionResult } from '@campfirein/brv-transport-client';
-/** Function type for transport connection (for DI/testing in use cases). */
-export type TransportConnector = (fromDir?: string) => Promise<ConnectionResult>;
+/**
+ * Function type for transport connection (for DI/testing in use cases).
+ *
+ * Callers must pass an explicit resolved projectPath. This avoids silently
+ * falling back to the transport library's own walk-up discovery, which is
+ * not workspace-link-aware.
+ */
+export type TransportConnector = (fromDir: string | undefined, projectPath: string) => Promise<ConnectionResult>;
 /**
  * Creates a transport connector that auto-starts the daemon if needed.
  *
  * Thin wrapper around connectToDaemon() for DI compatibility with use cases
  * (QueryUseCase, CurateUseCase, StatusUseCase).
  *
- * projectPath is auto-filled by the transport library from the discovered
- * project root (walks up from fromDir to find .brv/).
+ * When an explicit projectPath is provided it takes priority over the
+ * transport library's walk-up discovery, making the connector workspace-link-aware.
  */
 export declare function createDaemonAwareConnector(projectPath?: string): TransportConnector;

package/dist/server/infra/transport/transport-connector.js

@@ -6,8 +6,8 @@ import { resolveLocalServerMainPath } from '../../utils/server-main-resolver.js'
  * Thin wrapper around connectToDaemon() for DI compatibility with use cases
  * (QueryUseCase, CurateUseCase, StatusUseCase).
  *
- * projectPath is auto-filled by the transport library from the discovered
- * project root (walks up from fromDir to find .brv/).
+ * When an explicit projectPath is provided it takes priority over the
+ * transport library's walk-up discovery, making the connector workspace-link-aware.
  */
 export function createDaemonAwareConnector(projectPath) {
     return (fromDir) => connectToDaemon({

package/dist/server/utils/path-utils.d.ts

@@ -36,3 +36,8 @@ export declare const sanitizeProjectPath: (resolvedPath: string) => string;
  * @returns Absolute path to the project's data directory
  */
 export declare const getProjectDataDir: (cwd: string) => string;
+/**
+ * Checks that candidate is an ancestor of (or equal to) descendant.
+ * Both paths are normalized via resolve() before comparison.
+ */
+export declare function isDescendantOf(descendant: string, ancestor: string): boolean;

package/dist/server/utils/path-utils.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { realpathSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve, sep } from 'node:path';
 import { GLOBAL_PROJECTS_DIR } from '../constants.js';
 import { getGlobalDataDir } from './global-data-path.js';
 /**
@@ -90,3 +90,13 @@ export const getProjectDataDir = (cwd) => {
     const sanitized = sanitizeProjectPath(resolved);
     return join(getGlobalDataDir(), GLOBAL_PROJECTS_DIR, sanitized);
 };
+/**
+ * Checks that candidate is an ancestor of (or equal to) descendant.
+ * Both paths are normalized via resolve() before comparison.
+ */
+export function isDescendantOf(descendant, ancestor) {
+    const normalizedDescendant = resolve(descendant);
+    const normalizedAncestor = resolve(ancestor);
+    const ancestorPrefix = normalizedAncestor.endsWith(sep) ? normalizedAncestor : normalizedAncestor + sep;
+    return normalizedDescendant === normalizedAncestor || normalizedDescendant.startsWith(ancestorPrefix);
+}

package/dist/shared/transport/events/client-events.d.ts

@@ -0,0 +1,3 @@
+export declare const ClientEvents: {
+    readonly ASSOCIATE_PROJECT: "client:associateProject";
+};

package/dist/shared/transport/events/client-events.js

@@ -0,0 +1,3 @@
+export const ClientEvents = {
+    ASSOCIATE_PROJECT: 'client:associateProject',
+};

package/dist/shared/transport/events/index.d.ts

@@ -1,6 +1,7 @@
 export * from '../types/dto.js';
 export * from './agent-events.js';
 export * from './auth-events.js';
+export * from './client-events.js';
 export * from './config-events.js';
 export * from './connector-events.js';
 export * from './hub-events.js';
@@ -15,9 +16,11 @@ export * from './push-events.js';
 export * from './reset-events.js';
 export * from './review-events.js';
 export * from './session-events.js';
+export * from './source-events.js';
 export * from './space-events.js';
 export * from './status-events.js';
 export * from './task-events.js';
+export * from './worktree-events.js';
 /**
  * Array of all event group objects for iteration.
  * Use this to subscribe to all events without key collisions.
@@ -41,6 +44,8 @@ export declare const AllEventGroups: readonly [{
     readonly START_LOGIN: "auth:startLogin";
     readonly STATE_CHANGED: "auth:stateChanged";
     readonly UPDATED: "auth:updated";
+}, {
+    readonly ASSOCIATE_PROJECT: "client:associateProject";
 }, {
     readonly GET_ENVIRONMENT: "config:getEnvironment";
     readonly GET_PROJECT: "config:getProject";
@@ -117,6 +122,10 @@ export declare const AllEventGroups: readonly [{
     readonly SWITCHED: "session:switched";
 }, {
     readonly GET: "locations:get";
+}, {
+    readonly ADD: "source:add";
+    readonly LIST: "source:list";
+    readonly REMOVE: "source:remove";
 }, {
     readonly LIST: "space:list";
     readonly SWITCH: "space:switch";
@@ -130,6 +139,10 @@ export declare const AllEventGroups: readonly [{
     readonly CREATED: "task:created";
     readonly ERROR: "task:error";
     readonly STARTED: "task:started";
+}, {
+    readonly ADD: "worktree:add";
+    readonly LIST: "worktree:list";
+    readonly REMOVE: "worktree:remove";
 }];
 /**
  * Get all unique event values from all event groups.

package/dist/shared/transport/events/index.js

@@ -3,6 +3,7 @@ export * from '../types/dto.js';
 // Event constants and types
 export * from './agent-events.js';
 export * from './auth-events.js';
+export * from './client-events.js';
 export * from './config-events.js';
 export * from './connector-events.js';
 export * from './hub-events.js';
@@ -17,12 +18,15 @@ export * from './push-events.js';
 export * from './reset-events.js';
 export * from './review-events.js';
 export * from './session-events.js';
+export * from './source-events.js';
 export * from './space-events.js';
 export * from './status-events.js';
 export * from './task-events.js';
+export * from './worktree-events.js';
 // Utility exports
 import { AgentEvents } from './agent-events.js';
 import { AuthEvents } from './auth-events.js';
+import { ClientEvents } from './client-events.js';
 import { ConfigEvents } from './config-events.js';
 import { ConnectorEvents } from './connector-events.js';
 import { HubEvents } from './hub-events.js';
@@ -37,9 +41,11 @@ import { PushEvents } from './push-events.js';
 import { ResetEvents } from './reset-events.js';
 import { ReviewEvents } from './review-events.js';
 import { SessionEvents } from './session-events.js';
+import { SourceEvents } from './source-events.js';
 import { SpaceEvents } from './space-events.js';
 import { StatusEvents } from './status-events.js';
 import { TaskEvents } from './task-events.js';
+import { WorktreeEvents } from './worktree-events.js';
 /**
  * Array of all event group objects for iteration.
  * Use this to subscribe to all events without key collisions.
@@ -47,6 +53,7 @@ import { TaskEvents } from './task-events.js';
 export const AllEventGroups = [
     AgentEvents,
     AuthEvents,
+    ClientEvents,
     ConfigEvents,
     ConnectorEvents,
     HubEvents,
@@ -61,9 +68,11 @@ export const AllEventGroups = [
     ReviewEvents,
     SessionEvents,
     LocationsEvents,
+    SourceEvents,
     SpaceEvents,
     StatusEvents,
     TaskEvents,
+    WorktreeEvents,
 ];
 /**
  * Get all unique event values from all event groups.

package/dist/shared/transport/events/source-events.d.ts

@@ -0,0 +1,30 @@
+export declare const SourceEvents: {
+    readonly ADD: "source:add";
+    readonly LIST: "source:list";
+    readonly REMOVE: "source:remove";
+};
+export interface SourceAddRequest {
+    alias?: string;
+    targetPath: string;
+}
+export interface SourceAddResponse {
+    message: string;
+    success: boolean;
+}
+export interface SourceRemoveRequest {
+    aliasOrPath: string;
+}
+export interface SourceRemoveResponse {
+    message: string;
+    success: boolean;
+}
+export type SourceListRequest = void;
+export interface SourceListResponse {
+    error?: string;
+    statuses: Array<{
+        alias: string;
+        contextTreeSize?: number;
+        projectRoot: string;
+        valid: boolean;
+    }>;
+}

package/dist/shared/transport/events/source-events.js

@@ -0,0 +1,5 @@
+export const SourceEvents = {
+    ADD: 'source:add',
+    LIST: 'source:list',
+    REMOVE: 'source:remove',
+};

package/dist/shared/transport/events/status-events.d.ts

@@ -2,6 +2,11 @@ import type { StatusDTO } from '../types/dto.js';
 export declare const StatusEvents: {
     readonly GET: "status:get";
 };
+export interface StatusGetRequest {
+    cwd?: string;
+    projectRootFlag?: string;
+    verbose?: boolean;
+}
 export interface StatusGetResponse {
     status: StatusDTO;
 }

package/dist/shared/transport/events/task-events.d.ts

@@ -11,8 +11,11 @@ export interface TaskCreateRequest {
     clientCwd?: string;
     content: string;
     files?: string[];
+    folderPath?: string;
+    projectPath?: string;
     taskId: string;
-    type: 'curate' | 'query';
+    type: 'curate' | 'curate-folder' | 'query';
+    worktreeRoot?: string;
 }
 export interface TaskAckResponse {
     taskId: string;

package/dist/shared/transport/events/worktree-events.d.ts

@@ -0,0 +1,31 @@
+export declare const WorktreeEvents: {
+    readonly ADD: "worktree:add";
+    readonly LIST: "worktree:list";
+    readonly REMOVE: "worktree:remove";
+};
+export interface WorktreeAddRequest {
+    force?: boolean;
+    worktreePath: string;
+}
+export interface WorktreeAddResponse {
+    backedUp?: boolean;
+    message: string;
+    success: boolean;
+}
+export interface WorktreeRemoveRequest {
+    worktreePath: string;
+}
+export interface WorktreeRemoveResponse {
+    message: string;
+    success: boolean;
+}
+export type WorktreeListRequest = void;
+export interface WorktreeListResponse {
+    projectRoot: string;
+    source: 'direct' | 'flag' | 'linked';
+    worktreeRoot: string;
+    worktrees: Array<{
+        name: string;
+        worktreePath: string;
+    }>;
+}

package/dist/shared/transport/events/worktree-events.js

@@ -0,0 +1,5 @@
+export const WorktreeEvents = {
+    ADD: 'worktree:add',
+    LIST: 'worktree:list',
+    REMOVE: 'worktree:remove',
+};

package/dist/shared/transport/types/dto.d.ts

@@ -102,6 +102,12 @@ export interface HubEntryDTO {
     type: 'agent-skill' | 'bundle';
     version: string;
 }
+export interface SourceStatusDTO {
+    alias: string;
+    contextTreeSize?: number;
+    projectRoot: string;
+    valid: boolean;
+}
 export interface ProjectLocationDTO {
     /** Absolute path to the context tree directory (e.g., '/Users/foo/project/.brv/context-tree') */
     contextTreePath: string;
@@ -128,12 +134,25 @@ export interface StatusDTO {
     /** Relative path to the context tree directory from project root (e.g., '.brv/context-tree') */
     contextTreeRelativeDir?: string;
     contextTreeStatus: 'git_vc' | 'has_changes' | 'no_changes' | 'not_initialized' | 'unknown';
+    /** @deprecated Use projectRoot instead. Kept for backward compatibility. */
     currentDirectory: string;
     /** Number of files with pending HITL review (0 if none or unavailable). */
     pendingReviewCount?: number;
+    /** Absolute path to the project root (directory containing .brv/) */
+    projectRoot?: string;
+    /** How the project root was discovered */
+    resolutionSource?: 'direct' | 'flag' | 'linked';
+    /** Actionable error message when resolver fails (broken/malformed worktree pointer) */
+    resolverError?: string;
     /** URL to the local review UI (only set when pendingReviewCount > 0). */
     reviewUrl?: string;
+    /** Knowledge sources from other projects' context trees (read-only) */
+    sources?: SourceStatusDTO[];
+    /** Error message when sources.json is malformed */
+    sourcesError?: string;
     spaceName?: string;
     teamName?: string;
     userEmail?: string;
+    /** Stable workspace root (link directory), or projectRoot if unlinked */
+    worktreeRoot?: string;
 }

package/dist/tui/features/commands/definitions/index.js

@@ -12,9 +12,11 @@ import { pullCommand } from './pull.js';
 import { pushCommand } from './push.js';
 import { queryCommand } from './query.js';
 import { resetCommand } from './reset.js';
+import { sourceCommand } from './source.js';
 import { spaceCommand } from './space.js';
 import { statusCommand } from './status.js';
 import { vcCommand } from './vc.js';
+import { worktreeCommand } from './worktree.js';
 /**
  * Load all REPL slash commands.
  *
@@ -41,6 +43,10 @@ export const load = () => [
     spaceCommand,
     // Git semantic (vc commands)
     vcCommand,
+    // Workspace management
+    worktreeCommand,
+    // Knowledge sources
+    sourceCommand,
     // Context tree management
     resetCommand,
     // Session management

package/dist/tui/features/commands/definitions/source-add.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const sourceAddSubCommand: SlashCommand;