byterover-cli 3.1.0 → 3.3.0

package/dist/server/core/domain/errors/task-error.d.ts

@@ -7,6 +7,7 @@ export declare const TaskErrorCode: {
     readonly AGENT_NOT_AVAILABLE: "ERR_AGENT_NOT_AVAILABLE";
     readonly AGENT_NOT_INITIALIZED: "ERR_AGENT_NOT_INITIALIZED";
     readonly CONTEXT_TREE_NOT_INITIALIZED: "ERR_CONTEXT_TREE_NOT_INIT";
+    readonly LEGACY_SYNC_UNAVAILABLE: "ERR_LEGACY_SYNC_UNAVAILABLE";
     readonly LLM_ERROR: "ERR_LLM_ERROR";
     readonly LLM_RATE_LIMIT: "ERR_LLM_RATE_LIMIT";
     readonly LOCAL_CHANGES_EXIST: "ERR_LOCAL_CHANGES_EXIST";
@@ -15,7 +16,6 @@ export declare const TaskErrorCode: {
     readonly OAUTH_TOKEN_EXPIRED: "ERR_OAUTH_TOKEN_EXPIRED";
     readonly PROJECT_NOT_INIT: "ERR_PROJECT_NOT_INIT";
     readonly PROVIDER_NOT_CONFIGURED: "ERR_PROVIDER_NOT_CONFIGURED";
-    readonly SPACE_NOT_CONFIGURED: "ERR_SPACE_NOT_CONFIGURED";
     readonly SPACE_NOT_FOUND: "ERR_SPACE_NOT_FOUND";
     readonly TASK_CANCELLED: "ERR_TASK_CANCELLED";
     readonly TASK_EXECUTION: "ERR_TASK_EXECUTION";
@@ -73,7 +73,7 @@ export declare class FileValidationError extends Error {
 export declare class LocalChangesExistError extends TaskError {
     constructor(message?: string);
 }
-export declare class SpaceNotConfiguredError extends TaskError {
+export declare class LegacySyncUnavailableError extends TaskError {
     constructor();
 }
 export declare class GitVcInitializedError extends TaskError {

package/dist/server/core/domain/errors/task-error.js

@@ -9,6 +9,8 @@ export const TaskErrorCode = {
     AGENT_NOT_INITIALIZED: 'ERR_AGENT_NOT_INITIALIZED',
     // Context tree errors
     CONTEXT_TREE_NOT_INITIALIZED: 'ERR_CONTEXT_TREE_NOT_INIT',
+    // Legacy sync (brv push/pull) no longer available because project has no team+space configured
+    LEGACY_SYNC_UNAVAILABLE: 'ERR_LEGACY_SYNC_UNAVAILABLE',
     // LLM errors
     LLM_ERROR: 'ERR_LLM_ERROR',
     LLM_RATE_LIMIT: 'ERR_LLM_RATE_LIMIT',
@@ -21,7 +23,6 @@ export const TaskErrorCode = {
     // Execution errors
     PROJECT_NOT_INIT: 'ERR_PROJECT_NOT_INIT',
     PROVIDER_NOT_CONFIGURED: 'ERR_PROVIDER_NOT_CONFIGURED',
-    SPACE_NOT_CONFIGURED: 'ERR_SPACE_NOT_CONFIGURED',
     SPACE_NOT_FOUND: 'ERR_SPACE_NOT_FOUND',
     TASK_CANCELLED: 'ERR_TASK_CANCELLED',
     TASK_EXECUTION: 'ERR_TASK_EXECUTION',
@@ -153,10 +154,10 @@ export class LocalChangesExistError extends TaskError {
         this.name = 'LocalChangesExistError';
     }
 }
-export class SpaceNotConfiguredError extends TaskError {
+export class LegacySyncUnavailableError extends TaskError {
     constructor() {
-        super('No space configured. Run "brv space list" to see available spaces, then "brv space switch --team <team> --name <space>" to select one.', TaskErrorCode.SPACE_NOT_CONFIGURED);
-        this.name = 'SpaceNotConfiguredError';
+        super('Command brv push and brv pull are deprecated. Run `brv vc init` to start using Byterover version control.', TaskErrorCode.LEGACY_SYNC_UNAVAILABLE);
+        this.name = 'LegacySyncUnavailableError';
     }
 }
 export class GitVcInitializedError extends TaskError {

package/dist/server/core/domain/project/worktrees-schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+/**
+ * Schema for the `.brv` pointer file (when .brv is a FILE, not a directory).
+ * Like git's `.git` file in worktrees: contains a single `projectRoot` field
+ * pointing to the parent project's absolute path.
+ */
+export declare const WorktreePointerSchema: z.ZodObject<{
+    projectRoot: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectRoot: string;
+}, {
+    projectRoot: string;
+}>;
+export type WorktreePointer = z.infer<typeof WorktreePointerSchema>;
+/**
+ * Schema for `.brv/worktrees/<name>/link.json` — metadata about a registered worktree.
+ * Stored in the parent project's `.brv/worktrees/` directory (like `.git/worktrees/`).
+ */
+export declare const WorktreeLinkMetadataSchema: z.ZodObject<{
+    addedAt: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    worktreePath: string;
+    addedAt?: string | undefined;
+}, {
+    worktreePath: string;
+    addedAt?: string | undefined;
+}>;
+export type WorktreeLinkMetadata = z.infer<typeof WorktreeLinkMetadataSchema>;

package/dist/server/core/domain/project/worktrees-schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * Schema for the `.brv` pointer file (when .brv is a FILE, not a directory).
+ * Like git's `.git` file in worktrees: contains a single `projectRoot` field
+ * pointing to the parent project's absolute path.
+ */
+export const WorktreePointerSchema = z.object({
+    projectRoot: z.string().min(1),
+});
+/**
+ * Schema for `.brv/worktrees/<name>/link.json` — metadata about a registered worktree.
+ * Stored in the parent project's `.brv/worktrees/` directory (like `.git/worktrees/`).
+ */
+export const WorktreeLinkMetadataSchema = z.object({
+    addedAt: z.string().optional(),
+    worktreePath: z.string().min(1),
+});

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

@@ -0,0 +1,31 @@
+import { type SourceStatus } from './source-schema.js';
+export interface OperationResult {
+    message: string;
+    success: boolean;
+}
+/**
+ * Adds a read-only knowledge source from another project's context tree.
+ *
+ * Validates: target is a brv project, not self, not duplicate, not circular.
+ * Writes to `.brv/sources.json`.
+ */
+export declare function addSource(projectRoot: string, targetPath: string, alias?: string): OperationResult;
+/**
+ * Removes a knowledge source by alias or path.
+ */
+export declare function removeSource(projectRoot: string, aliasOrPath: string): OperationResult;
+export interface ListSourcesResult {
+    error?: string;
+    statuses: SourceStatus[];
+}
+/**
+ * Returns status for all sources in the project.
+ * Surfaces malformed file errors instead of silently returning empty.
+ */
+export declare function listSourceStatuses(projectRoot: string): ListSourcesResult;
+/**
+ * Checks if adding projectRoot → targetRoot would create a circular dependency.
+ * A circular reference exists if the target project already has a source pointing
+ * back to the current project (direct cycle only — no transitive check in v1).
+ */
+export declare function detectCircularSource(projectRoot: string, targetRoot: string): boolean;

package/dist/server/core/domain/source/source-operations.js

@@ -0,0 +1,201 @@
+import { existsSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { BRV_DIR, PROJECT_CONFIG_FILE, SOURCES_FILE } from '../../../constants.js';
+import { getSourceStatuses, loadSources, SourcesFileSchema, } from './source-schema.js';
+// ============================================================================
+// Add source
+// ============================================================================
+/**
+ * Adds a read-only knowledge source from another project's context tree.
+ *
+ * Validates: target is a brv project, not self, not duplicate, not circular.
+ * Writes to `.brv/sources.json`.
+ */
+export function addSource(projectRoot, targetPath, alias) {
+    // 1. Local project must have .brv/
+    const localConfigPath = join(projectRoot, BRV_DIR, PROJECT_CONFIG_FILE);
+    if (!existsSync(localConfigPath)) {
+        return { message: `Current project has no .brv/ — run 'brv' first to initialize.`, success: false };
+    }
+    // 2. Resolve target to canonical path
+    let targetRoot;
+    try {
+        targetRoot = realpathSync(targetPath);
+    }
+    catch {
+        return { message: `Target path does not exist: ${targetPath}`, success: false };
+    }
+    // 3. Target must be a brv project
+    const targetConfigPath = join(targetRoot, BRV_DIR, PROJECT_CONFIG_FILE);
+    if (!existsSync(targetConfigPath)) {
+        return { message: `Target "${targetRoot}" is not a ByteRover project (no .brv/config.json).`, success: false };
+    }
+    // 4. Not self
+    let canonicalProjectRoot;
+    try {
+        canonicalProjectRoot = realpathSync(projectRoot);
+    }
+    catch {
+        canonicalProjectRoot = projectRoot;
+    }
+    if (targetRoot === canonicalProjectRoot) {
+        return { message: 'Cannot add a source pointing to the current project.', success: false };
+    }
+    // 5. Read existing file — refuse to mutate if malformed
+    const existing = readSourcesFile(projectRoot);
+    if (existing.error) {
+        return { message: existing.error, success: false };
+    }
+    // 6. Not duplicate
+    const isDuplicate = existing.data.sources.some((source) => {
+        try {
+            return realpathSync(source.projectRoot) === targetRoot;
+        }
+        catch {
+            return source.projectRoot === targetRoot;
+        }
+    });
+    if (isDuplicate) {
+        return { message: `Source "${targetRoot}" already added.`, success: false };
+    }
+    // 7. Not circular
+    if (detectCircularSource(canonicalProjectRoot, targetRoot)) {
+        return {
+            message: `Circular source detected: "${basename(targetRoot)}" already references this project as a source.`,
+            success: false,
+        };
+    }
+    // 8. Derive alias — reject empty/whitespace-only
+    if (alias !== undefined && alias.trim() === '') {
+        return { message: 'Alias must not be empty.', success: false };
+    }
+    const derivedAlias = alias ?? basename(targetRoot);
+    // 9. Ensure alias uniqueness — append suffix if collision
+    const finalAlias = ensureUniqueAlias(derivedAlias, existing.data.sources);
+    // 10. Append and write
+    const newSource = {
+        addedAt: new Date().toISOString(),
+        alias: finalAlias,
+        projectRoot: targetRoot,
+        readOnly: true,
+    };
+    existing.data.sources.push(newSource);
+    writeSourcesFile(projectRoot, existing.data);
+    return { message: `Added source "${targetRoot}" as "${finalAlias}".`, success: true };
+}
+// ============================================================================
+// Remove source
+// ============================================================================
+/**
+ * Removes a knowledge source by alias or path.
+ */
+export function removeSource(projectRoot, aliasOrPath) {
+    const existing = readSourcesFile(projectRoot);
+    if (existing.error) {
+        return { message: existing.error, success: false };
+    }
+    if (existing.data.sources.length === 0) {
+        return { message: 'No knowledge sources configured.', success: false };
+    }
+    // Try match by alias first, then by canonical path
+    let matchIndex = existing.data.sources.findIndex((source) => source.alias === aliasOrPath);
+    if (matchIndex === -1) {
+        // Try matching by path
+        let canonicalTarget;
+        try {
+            canonicalTarget = realpathSync(aliasOrPath);
+        }
+        catch {
+            canonicalTarget = aliasOrPath;
+        }
+        matchIndex = existing.data.sources.findIndex((source) => {
+            try {
+                return realpathSync(source.projectRoot) === canonicalTarget;
+            }
+            catch {
+                return source.projectRoot === canonicalTarget;
+            }
+        });
+    }
+    if (matchIndex === -1) {
+        return { message: `No source found matching "${aliasOrPath}".`, success: false };
+    }
+    const removed = existing.data.sources.splice(matchIndex, 1)[0];
+    writeSourcesFile(projectRoot, existing.data);
+    return { message: `Removed source "${removed.alias}" (${removed.projectRoot}).`, success: true };
+}
+/**
+ * Returns status for all sources in the project.
+ * Surfaces malformed file errors instead of silently returning empty.
+ */
+export function listSourceStatuses(projectRoot) {
+    const existing = readSourcesFile(projectRoot);
+    if (existing.error) {
+        return { error: existing.error, statuses: [] };
+    }
+    if (existing.data.sources.length === 0) {
+        return { statuses: [] };
+    }
+    return { statuses: getSourceStatuses(existing.data.sources) };
+}
+// ============================================================================
+// Circular source detection
+// ============================================================================
+/**
+ * Checks if adding projectRoot → targetRoot would create a circular dependency.
+ * A circular reference exists if the target project already has a source pointing
+ * back to the current project (direct cycle only — no transitive check in v1).
+ */
+export function detectCircularSource(projectRoot, targetRoot) {
+    const targetSources = loadSources(targetRoot);
+    if (!targetSources) {
+        return false;
+    }
+    return targetSources.sources.some((source) => {
+        try {
+            return realpathSync(source.projectRoot) === projectRoot;
+        }
+        catch {
+            return source.projectRoot === projectRoot;
+        }
+    });
+}
+function readSourcesFile(projectRoot) {
+    const filePath = join(projectRoot, BRV_DIR, SOURCES_FILE);
+    if (!existsSync(filePath)) {
+        return { data: { sources: [], version: 1 } };
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return {
+            data: { sources: [], version: 1 },
+            error: `Malformed ${SOURCES_FILE}: file is not valid JSON. Back up or delete the file to recover.`,
+        };
+    }
+    const result = SourcesFileSchema.safeParse(raw);
+    if (!result.success) {
+        return {
+            data: { sources: [], version: 1 },
+            error: `Malformed ${SOURCES_FILE}: schema validation failed. Back up or delete the file to recover.`,
+        };
+    }
+    return { data: result.data };
+}
+function writeSourcesFile(projectRoot, data) {
+    const filePath = join(projectRoot, BRV_DIR, SOURCES_FILE);
+    writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+function ensureUniqueAlias(baseAlias, existingSources) {
+    const existingAliases = new Set(existingSources.map((source) => source.alias));
+    if (!existingAliases.has(baseAlias)) {
+        return baseAlias;
+    }
+    let counter = 2;
+    while (existingAliases.has(`${baseAlias}-${counter}`)) {
+        counter++;
+    }
+    return `${baseAlias}-${counter}`;
+}

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

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export declare const SourceSchema: z.ZodObject<{
+    addedAt: z.ZodString;
+    alias: z.ZodString;
+    projectRoot: z.ZodString;
+    readOnly: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    addedAt: string;
+    alias: string;
+    projectRoot: string;
+    readOnly: true;
+}, {
+    addedAt: string;
+    alias: string;
+    projectRoot: string;
+    readOnly: true;
+}>;
+export declare const SourcesFileSchema: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
+        addedAt: z.ZodString;
+        alias: z.ZodString;
+        projectRoot: z.ZodString;
+        readOnly: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        addedAt: string;
+        alias: string;
+        projectRoot: string;
+        readOnly: true;
+    }, {
+        addedAt: string;
+        alias: string;
+        projectRoot: string;
+        readOnly: true;
+    }>, "many">;
+    version: z.ZodLiteral<1>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    sources: {
+        addedAt: string;
+        alias: string;
+        projectRoot: string;
+        readOnly: true;
+    }[];
+}, {
+    version: 1;
+    sources: {
+        addedAt: string;
+        alias: string;
+        projectRoot: string;
+        readOnly: true;
+    }[];
+}>;
+export type Source = z.infer<typeof SourceSchema>;
+export type SourcesFile = z.infer<typeof SourcesFileSchema>;
+export interface SearchOrigin {
+    alias?: string;
+    contextTreeRoot: string;
+    origin: 'local' | 'shared';
+    originKey: string;
+}
+/**
+ * Derives a stable, short origin key from a canonical path.
+ * Uses first 12 hex chars of SHA-256 to avoid alias-based collisions.
+ */
+export declare function deriveOriginKey(canonicalPath: string): string;
+export interface LoadedSources {
+    mtime: number;
+    /** Search origins derived from valid sources (callers can search them) */
+    origins: SearchOrigin[];
+    /** All configured sources (including broken ones — for status display) */
+    sources: Source[];
+}
+/**
+ * Loads and validates `.brv/sources.json` from a project root.
+ *
+ * Returns null if the file does not exist.
+ * Broken sources (target `.brv/` missing) are included in `sources` but excluded
+ * from `origins` — callers decide how to surface them (status vs search).
+ */
+export declare function loadSources(projectRoot: string): LoadedSources | null;
+export interface SourceStatus {
+    alias: string;
+    contextTreeSize?: number;
+    projectRoot: string;
+    valid: boolean;
+}
+/**
+ * Validates each source and returns status for display.
+ *
+ * A source is valid only when both `.brv/config.json` AND `.brv/context-tree/`
+ * exist — matching what loadSources() requires before including a source in
+ * search origins. When valid, `contextTreeSize` counts `.md` files.
+ */
+export declare function getSourceStatuses(sources: Source[]): SourceStatus[];

package/dist/server/core/domain/source/source-schema.js

@@ -0,0 +1,121 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { BRV_DIR, CONTEXT_TREE_DIR, PROJECT_CONFIG_FILE, SOURCES_FILE } from '../../../constants.js';
+// ============================================================================
+// Schema
+// ============================================================================
+export const SourceSchema = z.object({
+    addedAt: z.string(),
+    alias: z.string().min(1),
+    projectRoot: z.string().min(1),
+    readOnly: z.literal(true),
+});
+export const SourcesFileSchema = z.object({
+    sources: z.array(SourceSchema),
+    version: z.literal(1),
+});
+/**
+ * Derives a stable, short origin key from a canonical path.
+ * Uses first 12 hex chars of SHA-256 to avoid alias-based collisions.
+ */
+export function deriveOriginKey(canonicalPath) {
+    return createHash('sha256').update(canonicalPath).digest('hex').slice(0, 12);
+}
+/**
+ * Loads and validates `.brv/sources.json` from a project root.
+ *
+ * Returns null if the file does not exist.
+ * Broken sources (target `.brv/` missing) are included in `sources` but excluded
+ * from `origins` — callers decide how to surface them (status vs search).
+ */
+export function loadSources(projectRoot) {
+    const filePath = join(projectRoot, BRV_DIR, SOURCES_FILE);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    const mtime = statSync(filePath).mtimeMs;
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return { mtime, origins: [], sources: [] };
+    }
+    const result = SourcesFileSchema.safeParse(raw);
+    if (!result.success) {
+        return { mtime, origins: [], sources: [] };
+    }
+    const origins = [];
+    for (const source of result.data.sources) {
+        const targetConfigPath = join(source.projectRoot, BRV_DIR, PROJECT_CONFIG_FILE);
+        if (!existsSync(targetConfigPath)) {
+            // Broken source — skip from origins but keep in sources for status display
+            continue;
+        }
+        let canonicalRoot;
+        try {
+            canonicalRoot = realpathSync(source.projectRoot);
+        }
+        catch {
+            continue;
+        }
+        const contextTreeRoot = join(canonicalRoot, BRV_DIR, CONTEXT_TREE_DIR);
+        if (!existsSync(contextTreeRoot)) {
+            continue;
+        }
+        origins.push({
+            alias: source.alias,
+            contextTreeRoot,
+            origin: 'shared',
+            originKey: deriveOriginKey(canonicalRoot),
+        });
+    }
+    return { mtime, origins, sources: result.data.sources };
+}
+/**
+ * Validates each source and returns status for display.
+ *
+ * A source is valid only when both `.brv/config.json` AND `.brv/context-tree/`
+ * exist — matching what loadSources() requires before including a source in
+ * search origins. When valid, `contextTreeSize` counts `.md` files.
+ */
+export function getSourceStatuses(sources) {
+    return sources.map((source) => {
+        const targetConfigPath = join(source.projectRoot, BRV_DIR, PROJECT_CONFIG_FILE);
+        const targetContextTree = join(source.projectRoot, BRV_DIR, CONTEXT_TREE_DIR);
+        const valid = existsSync(targetConfigPath) && existsSync(targetContextTree);
+        let contextTreeSize;
+        if (valid) {
+            contextTreeSize = countMarkdownFiles(targetContextTree);
+        }
+        return {
+            alias: source.alias,
+            contextTreeSize,
+            projectRoot: source.projectRoot,
+            valid,
+        };
+    });
+}
+/**
+ * Recursively counts .md files in a directory.
+ */
+function countMarkdownFiles(dir) {
+    let count = 0;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                count += countMarkdownFiles(join(dir, entry.name));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                count++;
+            }
+        }
+    }
+    catch {
+        // Directory unreadable — return 0
+    }
+    return count;
+}

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

@@ -514,9 +514,11 @@ export declare const TaskExecuteSchema: z.ZodObject<{
     /** Unique task identifier */
     taskId: z.ZodString;
     /** Task type */
-    type: z.ZodEnum<["curate", "curate-folder", "query"]>;
+    type: z.ZodEnum<["curate", "curate-folder", "query", "search"]>;
+    /** Workspace root for scoped query/curate */
+    worktreeRoot: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    type: "curate" | "query" | "curate-folder";
+    type: "curate" | "query" | "search" | "curate-folder";
     content: string;
     taskId: string;
     clientId: string;
@@ -524,8 +526,9 @@ export declare const TaskExecuteSchema: z.ZodObject<{
     clientCwd?: string | undefined;
     folderPath?: string | undefined;
     projectPath?: string | undefined;
+    worktreeRoot?: string | undefined;
 }, {
-    type: "curate" | "query" | "curate-folder";
+    type: "curate" | "query" | "search" | "curate-folder";
     content: string;
     taskId: string;
     clientId: string;
@@ -533,6 +536,7 @@ export declare const TaskExecuteSchema: z.ZodObject<{
     clientCwd?: string | undefined;
     folderPath?: string | undefined;
     projectPath?: string | undefined;
+    worktreeRoot?: string | undefined;
 }>;
 /**
  * task:cancel - Transport tells Agent to cancel a task
@@ -683,16 +687,16 @@ export declare const TaskCreatedSchema: z.ZodObject<{
     /** Unique task identifier */
     taskId: z.ZodString;
     /** Task type */
-    type: z.ZodEnum<["curate", "curate-folder", "query"]>;
+    type: z.ZodEnum<["curate", "curate-folder", "query", "search"]>;
 }, "strip", z.ZodTypeAny, {
-    type: "curate" | "query" | "curate-folder";
+    type: "curate" | "query" | "search" | "curate-folder";
     content: string;
     taskId: string;
     files?: string[] | undefined;
     clientCwd?: string | undefined;
     folderPath?: string | undefined;
 }, {
-    type: "curate" | "query" | "curate-folder";
+    type: "curate" | "query" | "search" | "curate-folder";
     content: string;
     taskId: string;
     files?: string[] | undefined;
@@ -941,7 +945,7 @@ export type TaskStartedEvent = z.infer<typeof TaskStartedEventSchema>;
 export type TaskCompletedEvent = z.infer<typeof TaskCompletedEventSchema>;
 export type TaskErrorData = z.infer<typeof TaskErrorDataSchema>;
 export type TaskErrorEvent = z.infer<typeof TaskErrorEventSchema>;
-export declare const TaskTypeSchema: z.ZodEnum<["curate", "curate-folder", "query"]>;
+export declare const TaskTypeSchema: z.ZodEnum<["curate", "curate-folder", "query", "search"]>;
 /**
  * Request to create a new task
  */
@@ -959,23 +963,27 @@ export declare const TaskCreateRequestSchema: z.ZodObject<{
     /** Task ID - generated by Client UseCase (UUID v4) */
     taskId: z.ZodString;
     /** Task type */
-    type: z.ZodEnum<["curate", "curate-folder", "query"]>;
+    type: z.ZodEnum<["curate", "curate-folder", "query", "search"]>;
+    /** Workspace root for scoped query/curate (stable linked root or projectRoot if unlinked) */
+    worktreeRoot: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    type: "curate" | "query" | "curate-folder";
+    type: "curate" | "query" | "search" | "curate-folder";
     content: string;
     taskId: string;
     files?: string[] | undefined;
     clientCwd?: string | undefined;
     folderPath?: string | undefined;
     projectPath?: string | undefined;
+    worktreeRoot?: string | undefined;
 }, {
-    type: "curate" | "query" | "curate-folder";
+    type: "curate" | "query" | "search" | "curate-folder";
     content: string;
     taskId: string;
     files?: string[] | undefined;
     clientCwd?: string | undefined;
     folderPath?: string | undefined;
     projectPath?: string | undefined;
+    worktreeRoot?: string | undefined;
 }>;
 /**
  * Response after task creation

package/dist/server/core/domain/transport/schemas.js

@@ -314,7 +314,9 @@ export const TaskExecuteSchema = z.object({
     /** Unique task identifier */
     taskId: z.string(),
     /** Task type */
-    type: z.enum(['curate', 'curate-folder', 'query']),
+    type: z.enum(['curate', 'curate-folder', 'query', 'search']),
+    /** Workspace root for scoped query/curate */
+    worktreeRoot: z.string().optional(),
 });
 /**
  * task:cancel - Transport tells Agent to cancel a task
@@ -372,7 +374,7 @@ export const TaskCreatedSchema = z.object({
     /** Unique task identifier */
     taskId: z.string(),
     /** Task type */
-    type: z.enum(['curate', 'curate-folder', 'query']),
+    type: z.enum(['curate', 'curate-folder', 'query', 'search']),
 });
 /**
  * task:started - Agent begins processing the task
@@ -473,7 +475,7 @@ export const LlmToolResultEventSchema = z.object({
 // ============================================================================
 // Request/Response Schemas (for client → server commands)
 // ============================================================================
-export const TaskTypeSchema = z.enum(['curate', 'curate-folder', 'query']);
+export const TaskTypeSchema = z.enum(['curate', 'curate-folder', 'query', 'search']);
 /**
  * Request to create a new task
  */
@@ -492,6 +494,8 @@ export const TaskCreateRequestSchema = z.object({
     taskId: z.string().uuid('Invalid taskId format - must be UUID'),
     /** Task type */
     type: TaskTypeSchema,
+    /** Workspace root for scoped query/curate (stable linked root or projectRoot if unlinked) */
+    worktreeRoot: z.string().optional(),
 });
 /**
  * Response after task creation