byterover-cli 2.5.2 → 3.0.0

package/dist/tui/features/commands/definitions/vc-remote.d.ts

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

package/dist/tui/features/commands/definitions/vc-remote.js

@@ -0,0 +1,57 @@
+import React from 'react';
+import { isVcRemoteSubcommand } from '../../../../shared/transport/events/vc-events.js';
+import { getGitRemoteBaseUrl } from '../../../lib/environment.js';
+import { VcRemoteFlow } from '../../vc/remote/components/vc-remote-flow.js';
+import { Args, parseReplArgs } from '../utils/arg-parser.js';
+/* eslint-disable perfectionist/sort-objects -- positional order matters: subcommand, name, url */
+const vcRemoteArgs = {
+    subcommand: Args.string({ description: 'Subcommand: add | set-url (omit to show current remote)' }),
+    name: Args.string({ description: 'Remote name (e.g. origin)' }),
+    url: Args.string({ description: `Remote URL (e.g. ${getGitRemoteBaseUrl()}/<team>/<space>.git)` }),
+};
+/* eslint-enable perfectionist/sort-objects */
+export const vcRemoteSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcRemoteArgs, strict: false });
+        const { name, subcommand: rawSubcommand, url } = parsed.args;
+        if (!rawSubcommand) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcRemoteFlow, { onCancel, onComplete, subcommand: 'show' }),
+            };
+        }
+        if (!isVcRemoteSubcommand(rawSubcommand)) {
+            const errorMsg = {
+                content: `Unknown subcommand '${rawSubcommand}'. Usage: /vc remote [add|set-url] <name> <url>`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        if (!name || !url) {
+            const errorMsg = {
+                content: `Usage: /vc remote ${rawSubcommand} <name> <url>`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        if (name !== 'origin') {
+            const errorMsg = {
+                content: `Only 'origin' remote is currently supported.`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcRemoteFlow, { onCancel, onComplete, subcommand: rawSubcommand, url }),
+        };
+    },
+    args: [
+        { description: 'Subcommand: add | set-url (omit to show current remote)', name: 'subcommand' },
+        { description: 'Remote name (e.g. origin)', name: 'name' },
+        { description: 'Remote URL', name: 'url' },
+    ],
+    description: 'Manage remote origin for ByteRover version control',
+    name: 'remote',
+};

package/dist/tui/features/commands/definitions/vc-reset.d.ts

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

package/dist/tui/features/commands/definitions/vc-reset.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import { VcResetFlow } from '../../vc/reset/components/vc-reset-flow.js';
+import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcResetFlags = {
+    hard: Flags.boolean({ description: 'Reset HEAD, index, and working tree', exclusive: ['soft'] }),
+    soft: Flags.boolean({ description: 'Reset HEAD only, keep changes staged', exclusive: ['hard'] }),
+};
+export const vcResetSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { flags: vcResetFlags, strict: false });
+        const { hard, soft } = parsed.flags;
+        const args = parsed.argv.filter((a) => typeof a === 'string');
+        // When --soft or --hard is set, first arg is the optional ref (default HEAD)
+        const mode = soft ? 'soft' : hard ? 'hard' : undefined;
+        const ref = mode ? args[0] : undefined;
+        const filePaths = mode ? undefined : (args.length > 0 ? args : undefined);
+        if (filePaths) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcResetFlow, { filePaths, onCancel, onComplete }),
+            };
+        }
+        if (mode) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcResetFlow, { mode, onCancel, onComplete, ref }),
+            };
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcResetFlow, { onCancel, onComplete }),
+        };
+    },
+    args: [{ description: 'File paths to unstage', name: 'files', required: false }],
+    description: 'Unstage files or undo commits',
+    flags: toCommandFlags(vcResetFlags),
+    name: 'reset',
+};

package/dist/tui/features/commands/definitions/vc-status.d.ts

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

package/dist/tui/features/commands/definitions/vc-status.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { VcStatusFlow } from '../../vc/status/components/vc-status-flow.js';
+export const vcStatusSubCommand = {
+    action() {
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcStatusFlow, { onCancel, onComplete }),
+        };
+    },
+    description: 'Show ByteRover version control status',
+    name: 'status',
+};

package/dist/tui/features/commands/definitions/vc.d.ts

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

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

@@ -0,0 +1,36 @@
+import { vcAddSubCommand } from './vc-add.js';
+import { vcBranchSubCommand } from './vc-branch.js';
+import { vcCheckoutSubCommand } from './vc-checkout.js';
+import { vcCloneSubCommand } from './vc-clone.js';
+import { vcCommitSubCommand } from './vc-commit.js';
+import { vcConfigSubCommand } from './vc-config.js';
+import { vcFetchSubCommand } from './vc-fetch.js';
+import { vcInitSubCommand } from './vc-init.js';
+import { vcLogSubCommand } from './vc-log.js';
+import { vcMergeSubCommand } from './vc-merge.js';
+import { vcPullSubCommand } from './vc-pull.js';
+import { vcPushSubCommand } from './vc-push.js';
+import { vcRemoteSubCommand } from './vc-remote.js';
+import { vcResetSubCommand } from './vc-reset.js';
+import { vcStatusSubCommand } from './vc-status.js';
+export const vcCommand = {
+    description: 'Version control commands for ByteRover',
+    name: 'vc',
+    subCommands: [
+        vcCloneSubCommand,
+        vcInitSubCommand,
+        vcAddSubCommand,
+        vcCommitSubCommand,
+        vcResetSubCommand,
+        vcFetchSubCommand,
+        vcPullSubCommand,
+        vcPushSubCommand,
+        vcStatusSubCommand,
+        vcLogSubCommand,
+        vcMergeSubCommand,
+        vcBranchSubCommand,
+        vcCheckoutSubCommand,
+        vcConfigSubCommand,
+        vcRemoteSubCommand,
+    ],
+};

package/dist/tui/features/commands/hooks/use-slash-command-processor.js

@@ -96,14 +96,14 @@ export function useSlashCommandProcessor(context, commands) {
                 type: 'message',
             };
         }
-        // Extract file and folder references from args
-        const { args: argsWithoutFiles, files, folders } = splitArgs(args);
-        const cleanArgs = argsWithoutFiles.join(' ');
+        // Extract file and folder references from args for context metadata.
+        // Pass the original args string to the action — parseReplArgs handles quote-aware splitting internally.
+        const { files, folders } = splitArgs(args);
         // Build execution context with invocation details
         const execContext = {
             ...context,
             invocation: {
-                args: cleanArgs,
+                args,
                 files,
                 folders,
                 name: commandNameForContext,
@@ -112,7 +112,7 @@ export function useSlashCommandProcessor(context, commands) {
         };
         setIsProcessing(true);
         try {
-            const result = await actionToExecute(execContext, cleanArgs);
+            const result = await actionToExecute(execContext, args);
             return result;
         }
         catch (error) {

package/dist/tui/features/log/api/execute-log.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../lib/react-query.js';
+import { type IVcLogRequest, type IVcLogResponse } from '../../../../shared/transport/events/vc-events.js';
+export declare const executeLog: (req: IVcLogRequest) => Promise<IVcLogResponse>;
+type UseExecuteLogOptions = {
+    mutationConfig?: MutationConfig<typeof executeLog>;
+};
+export declare const useExecuteLog: ({ mutationConfig }?: UseExecuteLogOptions) => import("@tanstack/react-query").UseMutationResult<IVcLogResponse, Error, IVcLogRequest, unknown>;
+export {};

package/dist/tui/features/log/api/execute-log.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents } from '../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const executeLog = (req) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.LOG, req);
+};
+export const useExecuteLog = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeLog,
+});

package/dist/tui/features/log/components/log-flow.d.ts

@@ -0,0 +1,14 @@
+/**
+ * LogFlow Component
+ *
+ * Fetches and displays git commit history for the context-tree via VcHandler.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../types/commands.js';
+type LogFlowProps = CustomDialogCallbacks & {
+    all: boolean;
+    branch: string | undefined;
+    limit: number;
+};
+export declare function LogFlow({ all, branch, limit, onComplete }: LogFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/log/components/log-flow.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * LogFlow Component
+ *
+ * Fetches and displays git commit history for the context-tree via VcHandler.
+ */
+import { Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useEffect } from 'react';
+import { useExecuteLog } from '../api/execute-log.js';
+import { formatCommitLog } from '../utils/format-log.js';
+export function LogFlow({ all, branch, limit, onComplete }) {
+    const logMutation = useExecuteLog();
+    useEffect(() => {
+        logMutation.mutate({ all, limit, ref: branch }, {
+            onError(error) {
+                onComplete(`Failed to get log: ${error.message.replace(/ for event '[^']+'$/, '')}`);
+            },
+            onSuccess(result) {
+                if (result.commits.length === 0) {
+                    onComplete('No commits found.');
+                    return;
+                }
+                onComplete(formatCommitLog(result.commits, result.currentBranch));
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Loading commit history..."] }));
+}

package/dist/tui/features/log/utils/format-log.d.ts

@@ -0,0 +1,3 @@
+import type { IVcLogResponse } from '../../../../shared/transport/events/vc-events.js';
+export declare function formatRelativeDate(date: Date): string;
+export declare function formatCommitLog(commits: IVcLogResponse['commits'], currentBranch?: string): string;

package/dist/tui/features/log/utils/format-log.js

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+export function formatRelativeDate(date) {
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    const diffSec = Math.floor(diffMs / 1000);
+    if (diffSec < 60)
+        return `${diffSec} second${diffSec === 1 ? '' : 's'} ago`;
+    const diffMin = Math.floor(diffSec / 60);
+    if (diffMin < 60)
+        return `${diffMin} minute${diffMin === 1 ? '' : 's'} ago`;
+    const diffHour = Math.floor(diffMin / 60);
+    if (diffHour < 24)
+        return `${diffHour} hour${diffHour === 1 ? '' : 's'} ago`;
+    const diffDay = Math.floor(diffHour / 24);
+    if (diffDay < 30)
+        return `${diffDay} day${diffDay === 1 ? '' : 's'} ago`;
+    const diffMonth = Math.floor(diffDay / 30);
+    if (diffMonth < 12)
+        return `${diffMonth} month${diffMonth === 1 ? '' : 's'} ago`;
+    const diffYear = Math.floor(diffMonth / 12);
+    return `${diffYear} year${diffYear === 1 ? '' : 's'} ago`;
+}
+export function formatCommitLog(commits, currentBranch) {
+    if (commits.length === 0)
+        return '';
+    return commits
+        .map((commit, index) => {
+        const shortSha = chalk.yellow(commit.sha.slice(0, 7));
+        const headMarker = index === 0
+            ? currentBranch
+                ? ` ${chalk.yellow.bold(`(HEAD -> ${currentBranch})`)}`
+                : ` ${chalk.yellow.bold('(HEAD)')}`
+            : '';
+        const relativeDate = formatRelativeDate(new Date(commit.timestamp));
+        return [
+            `* ${shortSha}${headMarker} ${commit.message}`,
+            `  Author: ${commit.author.name} <${commit.author.email}>`,
+            `  ${relativeDate}`,
+        ].join('\n');
+    })
+        .join('\n\n');
+}

package/dist/tui/features/onboarding/hooks/use-app-view-mode.d.ts

@@ -5,10 +5,12 @@
  * This is the single source of truth for determining what UI to show.
  */
 /**
- * The valid application view modes as a discriminated union.
+ * Application view modes as a discriminated union.
  */
 export type AppViewMode = {
     type: 'config-provider';
+} | {
+    type: 'init-project';
 } | {
     type: 'loading';
 } | {
@@ -20,6 +22,7 @@ export type AppViewMode = {
 export type DeriveAppViewModeParams = {
     activeModel?: string;
     activeProviderId?: string;
+    contextTreeStatus?: string;
     isAuthorized: boolean;
     isLoading: boolean;
 };
@@ -29,10 +32,11 @@ export type DeriveAppViewModeParams = {
  *
  * Decision tree:
  * 1. Loading → 'loading'
- * 2. ByteRover + unauthenticated → 'config-provider'
- * 3. ByteRover + authenticated → 'ready'
- * 4. Non-byterover + no active model → 'config-provider'
- * 5. Otherwise → 'ready'
+ * 2. Project not initialized → 'init-project'
+ * 3. ByteRover + unauthenticated → 'config-provider'
+ * 4. ByteRover + authenticated → 'ready'
+ * 5. Non-byterover + no active model → 'config-provider'
+ * 6. Otherwise → 'ready'
  */
 export declare function deriveAppViewMode(params: DeriveAppViewModeParams): AppViewMode;
 /**

package/dist/tui/features/onboarding/hooks/use-app-view-mode.js

@@ -6,21 +6,26 @@
  */
 import { useAuthStore } from '../../auth/stores/auth-store.js';
 import { useGetActiveProviderConfig } from '../../provider/api/get-active-provider-config.js';
+import { useGetStatus } from '../../status/api/get-status.js';
 /**
  * Pure decision logic for determining the app view mode.
  * Extracted from useAppViewMode for testability.
  *
  * Decision tree:
  * 1. Loading → 'loading'
- * 2. ByteRover + unauthenticated → 'config-provider'
- * 3. ByteRover + authenticated → 'ready'
- * 4. Non-byterover + no active model → 'config-provider'
- * 5. Otherwise → 'ready'
+ * 2. Project not initialized → 'init-project'
+ * 3. ByteRover + unauthenticated → 'config-provider'
+ * 4. ByteRover + authenticated → 'ready'
+ * 5. Non-byterover + no active model → 'config-provider'
+ * 6. Otherwise → 'ready'
  */
 export function deriveAppViewMode(params) {
     if (params.isLoading) {
         return { type: 'loading' };
     }
+    // if (['not_initialized', 'unknown'].includes(params.contextTreeStatus || '')) {
+    //   return {type: 'init-project'}
+    // }
     if (params.activeProviderId === 'byterover' && !params.isAuthorized) {
         return { type: 'config-provider' };
     }
@@ -38,11 +43,13 @@ export function deriveAppViewMode(params) {
  */
 export function useAppViewMode() {
     const { isAuthorized, isLoadingInitial: isLoadingAuth } = useAuthStore();
+    const { data: statusData, isLoading: isLoadingStatus } = useGetStatus();
     const { data: activeData, isLoading: isLoadingActive } = useGetActiveProviderConfig();
     return deriveAppViewMode({
         activeModel: activeData?.activeModel,
         activeProviderId: activeData?.activeProviderId,
+        contextTreeStatus: statusData?.status.contextTreeStatus,
         isAuthorized,
-        isLoading: isLoadingAuth || isLoadingActive,
+        isLoading: isLoadingAuth || isLoadingStatus || isLoadingActive,
     });
 }

package/dist/tui/features/push/components/push-flow.js

@@ -27,7 +27,14 @@ export function PushFlow({ branch, onComplete, skipConfirm }) {
             return;
         }
         if (prepareData && !prepareData.hasChanges) {
-            onComplete('No context changes to push.');
+            if (prepareData.excludedReviewCount > 0) {
+                const fileLabel = prepareData.excludedReviewCount === 1 ? 'file is' : 'files are';
+                onComplete(`No pushable changes. ${prepareData.excludedReviewCount} ${fileLabel} pending review.` +
+                    (prepareData.reviewUrl ? `\n  Review: ${prepareData.reviewUrl}` : ''));
+            }
+            else {
+                onComplete('No context changes to push.');
+            }
             return;
         }
         if (prepareData) {
@@ -70,7 +77,7 @@ export function PushFlow({ branch, onComplete, skipConfirm }) {
         return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Checking for Context Tree changes..."] }));
     }
     if (step === 'confirm' && prepareData) {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: `Changes found: ${prepareData.summary} (${prepareData.fileCount} files)` }), _jsx(Text, { children: `\nYou are about to push to ByteRover memory storage:` }), _jsx(Text, { children: `  Branch: ${branch}` }), _jsx(InlineConfirm, { default: false, message: "Push to ByteRover", onConfirm: (confirmed) => {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: `Changes found: ${prepareData.summary} (${prepareData.fileCount} files)` }), prepareData.excludedReviewCount > 0 && (_jsxs(Text, { color: "yellow", children: [`⚠ ${prepareData.excludedReviewCount} file(s) excluded from push (pending/rejected review).`, prepareData.reviewUrl ? `\n  Review: ${prepareData.reviewUrl}` : ''] })), _jsx(Text, { children: `\nYou are about to push to ByteRover memory storage:` }), _jsx(Text, { children: `  Branch: ${branch}` }), _jsx(InlineConfirm, { default: false, message: "Push to ByteRover", onConfirm: (confirmed) => {
                         if (confirmed) {
                             setStep('executing');
                         }

package/dist/tui/features/reset/components/reset-flow.js

@@ -8,6 +8,7 @@ import { Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { useEffect, useState } from 'react';
 import { InlineConfirm } from '../../../components/inline-prompts/inline-confirm.js';
+import { formatTransportError } from '../../../utils/error-messages.js';
 import { useExecuteReset } from '../api/execute-reset.js';
 export function ResetFlow({ onComplete, skipConfirm }) {
     const [step, setStep] = useState(skipConfirm ? 'executing' : 'confirm');
@@ -18,7 +19,7 @@ export function ResetFlow({ onComplete, skipConfirm }) {
             return;
         resetMutation.mutate(undefined, {
             onError(error) {
-                onComplete(`Failed to reset context tree: ${error.message}`);
+                onComplete(`Failed to reset context tree: ${formatTransportError(error)}`);
             },
             onSuccess(result) {
                 if (result.success) {

package/dist/tui/features/status/components/status-view.js

@@ -7,6 +7,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { useEffect } from 'react';
+import { formatTransportError } from '../../../utils/error-messages.js';
 import { useGetStatus } from '../api/get-status.js';
 import { formatStatus } from '../utils/format-status.js';
 export function StatusView({ onComplete, version }) {
@@ -16,7 +17,7 @@ export function StatusView({ onComplete, version }) {
             onComplete(formatStatus(data.status, version));
         }
         if (error) {
-            onComplete(`Failed to get status: ${error.message}`);
+            onComplete(`Failed to get status: ${formatTransportError(error)}`);
         }
     }, [data, error, onComplete, version]);
     if (isLoading) {

package/dist/tui/features/status/utils/format-status.js

@@ -30,6 +30,10 @@ export function formatStatus(status, version) {
         lines.push('Space: Not connected');
     }
     switch (status.contextTreeStatus) {
+        case 'git_vc': {
+            lines.push('Context Tree: Byterover version control (use /vc commands)');
+            break;
+        }
         case 'has_changes': {
             if (status.contextTreeChanges && status.contextTreeRelativeDir) {
                 const { added, deleted, modified } = status.contextTreeChanges;
@@ -58,5 +62,10 @@ export function formatStatus(status, version) {
             lines.push('Context Tree: Unable to check status');
         }
     }
+    if (status.pendingReviewCount && status.pendingReviewCount > 0) {
+        const fileLabel = status.pendingReviewCount === 1 ? 'file' : 'files';
+        lines.push(chalk.yellow(`Pending Reviews: ${status.pendingReviewCount} ${fileLabel} need review`) +
+            (status.reviewUrl ? `\n  Review: ${chalk.blue(status.reviewUrl)}` : ''));
+    }
     return lines.join('\n');
 }

package/dist/tui/features/tasks/hooks/use-task-subscriptions.js

@@ -3,6 +3,7 @@
  * Call this once from a top-level component to wire up task lifecycle events.
  */
 import { useEffect } from 'react';
+import { ReviewEvents } from '../../../../shared/transport/events/review-events.js';
 import { useTransportStore } from '../../../stores/transport-store.js';
 import { useTasksStore } from '../stores/tasks-store.js';
 export function useTaskSubscriptions() {
@@ -65,6 +66,16 @@ export function useTaskSubscriptions() {
                 taskId: data.taskId,
                 type: data.type === 'reasoning' ? 'reasoning' : 'text',
             });
+        }), client.on(ReviewEvents.NOTIFY, (data) => {
+            if (data.pendingCount === 0) {
+                store.clearReviewNotification(data.taskId);
+            }
+            else {
+                store.setReviewNotification(data.taskId, {
+                    pendingCount: data.pendingCount,
+                    reviewUrl: data.reviewUrl,
+                });
+            }
         }));
         return () => {
             for (const unsub of unsubscribers)

package/dist/tui/features/tasks/stores/tasks-store.d.ts

@@ -26,6 +26,10 @@ export interface TaskErrorData {
     code?: string;
     message: string;
 }
+export interface ReviewNotification {
+    pendingCount: number;
+    reviewUrl: string;
+}
 export interface Task {
     completedAt?: number;
     content: string;
@@ -37,6 +41,8 @@ export interface Task {
     isStreaming?: boolean;
     reasoningContents?: ReasoningContentItem[];
     result?: string;
+    /** Set when curate completes with pending HITL review operations. */
+    reviewNotification?: ReviewNotification;
     sessionId?: string;
     startedAt?: number;
     status: TaskStatus;
@@ -62,6 +68,8 @@ export interface TasksActions {
         taskId: string;
         type: 'reasoning' | 'text';
     }) => void;
+    /** Clear the review notification on a task (called after approve/reject) */
+    clearReviewNotification: (taskId: string) => void;
     /** Clear all tasks */
     clearTasks: () => void;
     /** Create a new task */
@@ -76,6 +84,8 @@ export interface TasksActions {
     setError: (taskId: string, error: TaskErrorData) => void;
     /** Set task LLM response (final) */
     setResponse: (taskId: string, content: string, sessionId?: string) => void;
+    /** Set review notification on a completed curate task */
+    setReviewNotification: (taskId: string, notification: ReviewNotification) => void;
     /** Set task to started */
     setStarted: (taskId: string) => void;
     /** Update a tool call result */

package/dist/tui/features/tasks/stores/tasks-store.js

@@ -103,6 +103,14 @@ export const useTasksStore = create()((set, get) => ({
         }
         return { stats: computeStats(tasks), tasks };
     }),
+    clearReviewNotification: (taskId) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task?.reviewNotification)
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, { ...task, reviewNotification: undefined });
+        return { stats: computeStats(tasks), tasks };
+    }),
     clearTasks: () => set({ stats: { created: 0, started: 0 }, tasks: new Map() }),
     createTask: (taskId, type, content, files) => set((state) => {
         const tasks = new Map(state.tasks);
@@ -218,6 +226,14 @@ export const useTasksStore = create()((set, get) => ({
         });
         return { stats: computeStats(tasks), tasks };
     }),
+    setReviewNotification: (taskId, notification) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, { ...task, reviewNotification: notification });
+        return { stats: computeStats(tasks), tasks };
+    }),
     setStarted: (taskId) => set((state) => {
         const task = state.tasks.get(taskId);
         if (!task)

package/dist/tui/features/vc/add/api/execute-vc-add.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcAddRequest, type IVcAddResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcAdd: (request: IVcAddRequest) => Promise<IVcAddResponse>;
+type UseExecuteVcAddOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcAdd>;
+};
+export declare const useExecuteVcAdd: ({ mutationConfig }?: UseExecuteVcAddOptions) => import("@tanstack/react-query").UseMutationResult<IVcAddResponse, Error, IVcAddRequest, unknown>;
+export {};

package/dist/tui/features/vc/add/api/execute-vc-add.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents } from '../../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../../stores/transport-store.js';
+export const executeVcAdd = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.ADD, request);
+};
+export const useExecuteVcAdd = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcAdd,
+});

package/dist/tui/features/vc/add/components/vc-add-flow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcAddFlowProps = CustomDialogCallbacks & {
+    filePaths: string[];
+};
+export declare function VcAddFlow({ filePaths, onCancel, onComplete }: VcAddFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/add/components/vc-add-flow.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcAdd } from '../api/execute-vc-add.js';
+export function VcAddFlow({ filePaths, onCancel, onComplete }) {
+    const addMutation = useExecuteVcAdd();
+    useInput((_, key) => {
+        if (key.escape && !addMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        addMutation.mutate({ filePaths }, {
+            onError(error) {
+                onComplete(`Failed to stage: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.count === 0) {
+                    onComplete('Nothing to stage.');
+                }
+                else {
+                    onComplete(`Staged ${result.count} file(s).`);
+                }
+            },
+        });
+    }, []);
+    const label = filePaths.length === 1 && filePaths[0] === '.' ? '.' : filePaths.join(' ');
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Staging ", label, "..."] }));
+}