byterover-cli 3.1.0 → 3.3.0

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,14 +83,15 @@ export class StatusHandler {
         catch {
             result.authStatus = 'unknown';
         }
-        // Project status
+        // Project status — use effectiveProjectPath for consistency with resolved root
+        let projectConfig;
         try {
-            const isInitialized = await this.projectConfigStore.exists(projectPath);
+            const isInitialized = await this.projectConfigStore.exists(effectiveProjectPath);
             if (isInitialized) {
-                const config = await this.projectConfigStore.read(projectPath);
-                if (config) {
-                    result.teamName = config.teamName;
-                    result.spaceName = config.spaceName;
+                projectConfig = await this.projectConfigStore.read(effectiveProjectPath);
+                if (projectConfig) {
+                    result.teamName = projectConfig.teamName;
+                    result.spaceName = projectConfig.spaceName;
                 }
             }
         }
@@ -75,33 +105,39 @@ 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);
-                    if (!hasSnapshot) {
-                        await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
-                    }
-                    const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
-                    const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
-                    if (hasChanges) {
-                        result.contextTreeStatus = 'has_changes';
-                        result.contextTreeChanges = {
-                            added: changes.added,
-                            deleted: changes.deleted,
-                            modified: changes.modified,
-                        };
+                    const hasLegacySyncConfig = Boolean(projectConfig?.teamId && projectConfig?.spaceId);
+                    if (hasLegacySyncConfig) {
+                        const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(effectiveProjectPath);
+                        if (!hasSnapshot) {
+                            await this.contextTreeSnapshotService.initEmptySnapshot(effectiveProjectPath);
+                        }
+                        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';
+                            result.contextTreeChanges = {
+                                added: changes.added,
+                                deleted: changes.deleted,
+                                modified: changes.modified,
+                            };
+                        }
+                        else {
+                            result.contextTreeStatus = 'no_changes';
+                        }
                     }
                     else {
-                        result.contextTreeStatus = 'no_changes';
+                        result.contextTreeStatus = 'no_vc';
                     }
                 }
             }
@@ -139,6 +175,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/templates/skill/SKILL.md

@@ -34,7 +34,27 @@ Knowledge is stored in `.brv/context-tree/` as human-readable Markdown files.
 brv query "How is authentication implemented?"
 ```
 
-### 2. Curate Context
+### 2. Search Context Tree
+**Overview:** Retrieve a ranked list of matching files from `.brv/context-tree/` via pure BM25 lookup. Unlike `brv query`, this does NOT call an LLM — no synthesis, no token cost, no provider setup needed. Returns structured results with paths, scores, and excerpts.
+
+**Use this skill when:**
+- You need file paths to read rather than a synthesized answer
+- You want fast, cheap retrieval with no LLM overhead
+- You're in an automated pipeline that consumes structured results
+
+**Do NOT use this skill when:**
+- You need a natural-language answer synthesized from multiple files — use `brv query` instead
+- The information is already present in your current context
+
+```bash
+brv search "authentication patterns"
+brv search "JWT tokens" --limit 5 --scope "auth/"
+brv search "auth" --format json
+```
+
+**Flags:** `--limit N` (1-50, default 10), `--scope "domain/"` (path prefix filter), `--format json` (structured output for automation).
+
+### 3. Curate Context
 **Overview:** Analyze and save knowledge to the local knowledge base. Uses a configured LLM provider to categorize and structure the context you provide.
 
 **Use this skill when:**
@@ -79,7 +99,7 @@ brv curate view --since 1h --status completed
 brv curate view --help
 ```
 
-### 3. Review Pending Changes
+### 4. Review Pending Changes
 **Overview:** After a curate operation, some changes may require human review before being applied. Use `brv review` to list, approve, or reject pending operations.
 
 **Use this when:**
@@ -142,7 +162,7 @@ brv review approve <taskId> --format json
 brv review reject <taskId> --format json
 ```
 
-### 4. LLM Provider Setup
+### 5. LLM Provider Setup
 `brv query` and `brv curate` require a configured LLM provider. Connect the default ByteRover provider (no API key needed):
 
 ```bash
@@ -156,7 +176,7 @@ brv providers list
 brv providers connect openai --api-key sk-xxx --model gpt-4.1
 ```
 
-### 5. Project Locations
+### 6. Project Locations
 **Overview:** List registered projects and their context tree paths. Returns project metadata including initialization status and active state. Use `-f json` for machine-readable output.
 
 **Use this when:**
@@ -174,7 +194,7 @@ brv locations -f json
 
 JSON fields: `projectPath`, `contextTreePath`, `isCurrent`, `isActive`, `isInitialized`.
 
-### 6. Version Control
+### 7. Version Control
 **Overview:** `brv vc` provides git-based version control for your context tree. It uses standard git semantics — branching, committing, merging, history, and conflict resolution — all working locally with no authentication required. Remote sync with a team is optional. The legacy `brv push`, `brv pull`, and `brv space` commands are deprecated — use `brv vc push`, `brv vc pull`, and `brv vc clone`/`brv vc remote add` instead.
 
 **Use this when:**

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/search-content.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Encode/decode helpers for search task content payloads.
+ *
+ * The transport layer's TaskCreateRequest has a single `content: string`
+ * field. For search tasks, we pack {query, limit?, scope?} as JSON so
+ * the agent process can reconstruct the structured options.
+ *
+ * Lives in shared/ because both the CLI (encoder) and the daemon
+ * agent-process (decoder) depend on it. Keeping it in oclif/ would
+ * create a circular dependency (server → oclif).
+ */
+/**
+ * Encode search options as JSON content payload for the transport layer.
+ */
+export declare function encodeSearchContent(options: {
+    limit?: number;
+    query: string;
+    scope?: string;
+}): string;
+/**
+ * Parse a JSON-encoded search content payload back into options.
+ * Falls back to treating the entire string as a plain query if parsing fails.
+ */
+export declare function decodeSearchContent(content: string): {
+    limit?: number;
+    query: string;
+    scope?: string;
+};

package/dist/shared/transport/search-content.js

@@ -0,0 +1,38 @@
+/**
+ * Encode/decode helpers for search task content payloads.
+ *
+ * The transport layer's TaskCreateRequest has a single `content: string`
+ * field. For search tasks, we pack {query, limit?, scope?} as JSON so
+ * the agent process can reconstruct the structured options.
+ *
+ * Lives in shared/ because both the CLI (encoder) and the daemon
+ * agent-process (decoder) depend on it. Keeping it in oclif/ would
+ * create a circular dependency (server → oclif).
+ */
+/**
+ * Encode search options as JSON content payload for the transport layer.
+ */
+export function encodeSearchContent(options) {
+    return JSON.stringify({
+        limit: options.limit,
+        query: options.query,
+        scope: options.scope,
+    });
+}
+/**
+ * Parse a JSON-encoded search content payload back into options.
+ * Falls back to treating the entire string as a plain query if parsing fails.
+ */
+export function decodeSearchContent(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return {
+            limit: typeof parsed.limit === 'number' ? parsed.limit : undefined,
+            query: typeof parsed.query === 'string' ? parsed.query : content,
+            scope: typeof parsed.scope === 'string' ? parsed.scope : undefined,
+        };
+    }
+    catch {
+        return { query: content };
+    }
+}