byterover-cli 2.6.0 → 3.0.1

package/dist/tui/features/vc/push/api/execute-vc-push.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 executeVcPush = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.PUSH, request);
+};
+export const useExecuteVcPush = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcPush,
+});

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcPushFlowProps = CustomDialogCallbacks & {
+    branch?: string;
+    setUpstream?: boolean;
+};
+export declare function VcPushFlow({ branch, onCancel, onComplete, setUpstream }: VcPushFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { VcErrorCode } from '../../../../../shared/transport/events/vc-events.js';
+import { InlineInput } from '../../../../components/inline-prompts/inline-input.js';
+import { useTheme } from '../../../../hooks/index.js';
+import { getWebAppUrl } from '../../../../lib/environment.js';
+import { formatTransportError, getTransportErrorCode } from '../../../../utils/error-messages.js';
+import { useExecuteVcRemote } from '../../remote/api/execute-vc-remote.js';
+import { useExecuteVcPush } from '../api/execute-vc-push.js';
+function validateRemoteUrl(value) {
+    if (!value)
+        return 'URL is required';
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'https:') {
+            return 'URL must start with https://';
+        }
+        return true;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+export function VcPushFlow({ branch, onCancel, onComplete, setUpstream }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState('pushing');
+    const pushMutation = useExecuteVcPush();
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !pushMutation.isPending && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const executePush = useCallback((overrideSetUpstream) => {
+        pushMutation.mutate({ branch, setUpstream: overrideSetUpstream ?? setUpstream }, {
+            onError(error) {
+                if (getTransportErrorCode(error) === VcErrorCode.NO_REMOTE) {
+                    setStep('configuring_remote');
+                    return;
+                }
+                onComplete(`Failed to push: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.alreadyUpToDate) {
+                    onComplete('Everything up-to-date.');
+                }
+                else if (result.upstreamSet) {
+                    onComplete(`Pushed to origin/${result.branch} and set upstream.`);
+                }
+                else {
+                    onComplete(`Pushed to origin/${result.branch}.`);
+                }
+            },
+        });
+    }, [branch, onComplete, pushMutation, setUpstream]);
+    const fired = useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        executePush();
+    }, []);
+    const handleUrlSubmit = useCallback((url) => {
+        remoteMutation.mutate({ subcommand: 'add', url }, {
+            onError(error) {
+                onComplete(`Failed to add remote: ${formatTransportError(error)}`);
+            },
+            onSuccess() {
+                setStep('pushing');
+                executePush(true);
+            },
+        });
+    }, [executePush, onComplete, remoteMutation]);
+    if (step === 'configuring_remote') {
+        if (remoteMutation.isPending) {
+            return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Adding remote..."] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.warning, children: "No remote configured." }), _jsx(Text, {}), _jsx(Text, { children: "To connect to cloud:" }), _jsxs(Text, { children: ["  Go to ", _jsx(Text, { bold: true, children: getWebAppUrl() }), " \u2192 create or open a Space"] }), _jsx(Text, { children: "  and copy the remote URL." })] }), _jsx(InlineInput, { message: "Paste your remote URL:", onSubmit: handleUrlSubmit, validate: validateRemoteUrl })] }));
+    }
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", branch ? `Pushing to origin/${branch}...` : 'Pushing...'] }));
+}

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

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

package/dist/tui/features/vc/remote/api/execute-vc-remote.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 executeVcRemote = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.REMOTE, request);
+};
+export const useExecuteVcRemote = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcRemote,
+});

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { VcRemoteSubcommand } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcRemoteFlowProps = CustomDialogCallbacks & {
+    subcommand: VcRemoteSubcommand;
+    url?: string;
+};
+export declare function VcRemoteFlow({ onCancel, onComplete, subcommand, url }: VcRemoteFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,42 @@
+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 { useExecuteVcRemote } from '../api/execute-vc-remote.js';
+const LABELS = {
+    add: 'Adding remote...',
+    'set-url': 'Updating remote...',
+    show: 'Fetching remote...',
+};
+export function VcRemoteFlow({ onCancel, onComplete, subcommand, url }) {
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        remoteMutation.mutate({ subcommand, url }, {
+            onError(error) {
+                onComplete(`Failed: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.action === 'show') {
+                    onComplete(result.url ? `origin: ${result.url}` : 'No remote configured.');
+                }
+                else if (result.action === 'add') {
+                    onComplete(`Remote 'origin' set to ${result.url}.`);
+                }
+                else {
+                    onComplete(`Remote 'origin' updated to ${result.url}.`);
+                }
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", LABELS[subcommand]] }));
+}

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

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

package/dist/tui/features/vc/reset/api/execute-vc-reset.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 executeVcReset = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.RESET, request);
+};
+export const useExecuteVcReset = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcReset,
+});

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { VcResetMode } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcResetFlowProps = CustomDialogCallbacks & {
+    filePaths?: string[];
+    mode?: VcResetMode;
+    ref?: string;
+};
+export declare function VcResetFlow({ filePaths, mode, onCancel, onComplete, ref }: VcResetFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } 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 { useExecuteVcReset } from '../api/execute-vc-reset.js';
+export function VcResetFlow({ filePaths, mode, onCancel, onComplete, ref }) {
+    const needsConfirm = mode === 'hard';
+    const [step, setStep] = useState(needsConfirm ? 'confirm' : 'executing');
+    const resetMutation = useExecuteVcReset();
+    useInput((_, key) => {
+        if (key.escape && !resetMutation.isPending) {
+            onCancel();
+        }
+    });
+    useEffect(() => {
+        if (step !== 'executing')
+            return;
+        const request = filePaths
+            ? { filePaths }
+            : { mode: mode ?? 'mixed', ref };
+        resetMutation.mutate(request, {
+            onError(error) {
+                onComplete(`Failed to reset: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.filesUnstaged === undefined) {
+                    if (result.headSha) {
+                        onComplete(`HEAD is now at ${result.headSha.slice(0, 7)}`);
+                    }
+                    else {
+                        onComplete(''); // Empty repo — silent no-op, matches git
+                    }
+                }
+                else if (result.filesUnstaged === 0) {
+                    onComplete('Nothing to unstage.');
+                }
+                else {
+                    onComplete(`Unstaged ${result.filesUnstaged} file(s).`);
+                }
+            },
+        });
+    }, [step]);
+    if (step === 'confirm') {
+        return (_jsx(InlineConfirm, { default: false, message: `This will discard all changes and reset to ${ref ?? 'HEAD'}. Continue`, onConfirm: (confirmed) => {
+                if (confirmed) {
+                    setStep('executing');
+                }
+                else {
+                    onComplete('Reset cancelled.');
+                }
+            } }));
+    }
+    const label = filePaths
+        ? `Unstaging ${filePaths.join(' ')}...`
+        : mode === 'soft'
+            ? `Soft resetting to ${ref ?? 'HEAD'}...`
+            : mode === 'hard'
+                ? `Hard resetting to ${ref ?? 'HEAD'}...`
+                : 'Unstaging all files...';
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", label] }));
+}

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

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcStatusResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcStatus: () => Promise<IVcStatusResponse>;
+type UseExecuteVcStatusOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcStatus>;
+};
+export declare const useExecuteVcStatus: ({ mutationConfig }?: UseExecuteVcStatusOptions) => import("@tanstack/react-query").UseMutationResult<IVcStatusResponse, Error, undefined, unknown>;
+export {};

package/dist/tui/features/vc/status/api/execute-vc-status.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 executeVcStatus = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.STATUS, {});
+};
+export const useExecuteVcStatus = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcStatus,
+});

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

@@ -0,0 +1,10 @@
+/**
+ * VcStatusFlow Component
+ *
+ * Shows git status of the context tree via VcHandler.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcStatusFlowProps = CustomDialogCallbacks;
+export declare function VcStatusFlow({ onCancel, onComplete }: VcStatusFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,133 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * VcStatusFlow Component
+ *
+ * Shows git status of the context tree via VcHandler.
+ */
+import chalk from 'chalk';
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcStatus } from '../api/execute-vc-status.js';
+// eslint-disable-next-line complexity
+function formatVcStatus(result) {
+    if (!result.initialized) {
+        return chalk.yellow('Git repository not initialized — run `/vc init` to initialize');
+    }
+    const lines = [chalk.bold(`On branch ${result.branch ?? '(detached HEAD)'}`)];
+    if (result.hasCommits === false) {
+        lines.push(chalk.yellow('No commits yet'));
+    }
+    if (result.trackingBranch) {
+        const ahead = result.ahead ?? 0;
+        const behind = result.behind ?? 0;
+        if (ahead > 0 && behind > 0) {
+            lines.push(`Your branch and '${result.trackingBranch}' have diverged,\n` +
+                `and have ${ahead} and ${behind} different commits each, respectively.`);
+        }
+        else if (ahead > 0) {
+            lines.push(`Your branch is ahead of '${result.trackingBranch}' by ${ahead} commit${ahead === 1 ? '' : 's'}.`);
+        }
+        else if (behind > 0) {
+            lines.push(`Your branch is behind '${result.trackingBranch}' by ${behind} commit${behind === 1 ? '' : 's'}.`);
+        }
+    }
+    const { staged, unstaged, untracked } = result;
+    const hasChanges = staged.added.length > 0 ||
+        staged.modified.length > 0 ||
+        staged.deleted.length > 0 ||
+        unstaged.modified.length > 0 ||
+        unstaged.deleted.length > 0 ||
+        untracked.length > 0;
+    if (result.mergeInProgress) {
+        const hasUnmerged = result.unmerged && result.unmerged.length > 0;
+        if (hasUnmerged) {
+            lines.push(chalk.yellow('You have unmerged paths.'));
+            // eslint-disable-next-line unicorn/no-array-push-push
+            lines.push(chalk.yellow('  (fix conflicts and run "/vc add", then "/vc merge --continue")'));
+            // eslint-disable-next-line unicorn/no-array-push-push
+            lines.push('');
+            // eslint-disable-next-line unicorn/no-array-push-push
+            lines.push(chalk.bold('Unmerged paths:'));
+            for (const f of result.unmerged) {
+                const label = f.type === 'deleted_modified'
+                    ? 'deleted by them'
+                    : f.type === 'both_added'
+                        ? 'both added'
+                        : 'both modified';
+                lines.push(chalk.red(`   ${label}:   ${f.path}`));
+            }
+        }
+        else {
+            lines.push(chalk.yellow('All conflicts fixed but you are still merging.'));
+            // eslint-disable-next-line unicorn/no-array-push-push
+            lines.push(chalk.yellow('  (use "/vc merge --continue" to conclude merge)'));
+            if (!hasChanges)
+                return lines.join('\n');
+        }
+    }
+    else if (!hasChanges && !(result.conflictMarkerFiles && result.conflictMarkerFiles.length > 0)) {
+        lines.push('Nothing to commit, working tree clean');
+        return lines.join('\n');
+    }
+    if (result.conflictMarkerFiles && result.conflictMarkerFiles.length > 0) {
+        lines.push(chalk.yellow('Files with conflict markers:'));
+        // eslint-disable-next-line unicorn/no-array-push-push
+        lines.push(chalk.yellow('  (resolve conflicts and run "/vc add" before pushing)'));
+        // eslint-disable-next-line unicorn/no-array-push-push
+        lines.push('');
+        for (const f of result.conflictMarkerFiles) {
+            lines.push(chalk.red(`   ${f} (conflict)`));
+        }
+    }
+    if (staged.added.length > 0 || staged.modified.length > 0 || staged.deleted.length > 0) {
+        lines.push(chalk.bold('Changes to be committed:'));
+        for (const f of staged.added)
+            lines.push(chalk.green(`   new file:   ${f}`));
+        for (const f of staged.modified)
+            lines.push(chalk.green(`   modified:   ${f}`));
+        for (const f of staged.deleted)
+            lines.push(chalk.green(`   deleted:    ${f}`));
+    }
+    if (unstaged.modified.length > 0 || unstaged.deleted.length > 0) {
+        lines.push(chalk.bold('Changes not staged for commit:'));
+        // eslint-disable-next-line unicorn/no-array-push-push
+        lines.push(chalk.bold('(use "/vc add ‹file>..." to include in what will be committed)'));
+        for (const f of unstaged.modified)
+            lines.push(chalk.red(`   modified:   ${f}`));
+        for (const f of unstaged.deleted)
+            lines.push(chalk.red(`   deleted:    ${f}`));
+    }
+    if (untracked.length > 0) {
+        lines.push(chalk.bold('Untracked files:'));
+        // eslint-disable-next-line unicorn/no-array-push-push
+        lines.push(chalk.bold('(use "/vc add ‹file>..." to include in what will be committed)'));
+        for (const f of untracked)
+            lines.push(chalk.red(`   ${f}`));
+    }
+    return lines.join('\n');
+}
+export function VcStatusFlow({ onCancel, onComplete }) {
+    const statusMutation = useExecuteVcStatus();
+    useInput((_, key) => {
+        if (key.escape && !statusMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        statusMutation.mutate(undefined, {
+            onError(error) {
+                onComplete(`Failed to get vc status: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                onComplete(formatVcStatus(result));
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Getting vc status..."] }));
+}

package/dist/tui/lib/environment.d.ts

@@ -16,3 +16,11 @@ export declare const BRV_DIR = ".brv";
  * Directory for conflict review files created during space switch merge.
  */
 export declare const CONTEXT_TREE_CONFLICT_DIR = "context-tree-conflicts";
+/**
+ * Web app URL for the current environment.
+ */
+export declare const getWebAppUrl: () => string;
+/**
+ * Git remote base URL for the current environment.
+ */
+export declare const getGitRemoteBaseUrl: () => string;

package/dist/tui/lib/environment.js

@@ -16,3 +16,11 @@ export const BRV_DIR = '.brv';
  * Directory for conflict review files created during space switch merge.
  */
 export const CONTEXT_TREE_CONFLICT_DIR = 'context-tree-conflicts';
+/**
+ * Web app URL for the current environment.
+ */
+export const getWebAppUrl = () => isDevelopment() ? 'https://dev-beta-app.byterover.dev' : 'https://app.byterover.dev';
+/**
+ * Git remote base URL for the current environment.
+ */
+export const getGitRemoteBaseUrl = () => process.env.BRV_GIT_REMOTE_BASE_URL ?? (isDevelopment() ? 'https://dev-beta.byterover.dev' : 'https://byterover.dev');

package/dist/tui/utils/error-messages.d.ts

@@ -10,10 +10,14 @@
  * Format a task error (from task:error events) into a user-friendly message.
  * Falls back to the raw error message if no mapping exists.
  */
-export declare function formatTaskError(error: undefined | {
+export declare function formatTaskError(error?: {
     code?: string;
     message: string;
 }): string;
+/**
+ * Extract the error code from a transport error, if present.
+ */
+export declare function getTransportErrorCode(error: unknown): string | undefined;
 /**
  * Format a transport error (from request/response calls) into a user-friendly message.
  * Checks for a `code` property on the error and looks up a friendly message.

package/dist/tui/utils/error-messages.js

@@ -17,6 +17,26 @@ const USER_FRIENDLY_MESSAGES = {
     ERR_PROVIDER_NOT_CONFIGURED: 'No provider connected. Run /providers connect byterover to use the free built-in provider, or connect another provider.',
     ERR_SPACE_NOT_CONFIGURED: 'No space configured. Run /space switch to select a space first.',
     ERR_SPACE_NOT_FOUND: 'Space not found. Check your configuration.',
+    ERR_VC_AUTH_FAILED: 'Authentication failed. Run /login.',
+    ERR_VC_BRANCH_ALREADY_EXISTS: 'Branch already exists.',
+    ERR_VC_CANNOT_DELETE_CURRENT_BRANCH: 'Cannot delete the currently checked-out branch.',
+    ERR_VC_CONFIG_KEY_NOT_SET: 'Config key is not set.',
+    ERR_VC_CONFLICT_MARKERS_PRESENT: 'Conflict markers detected. Run /vc conflicts to view them. Resolve conflicts and run /vc add before pushing.',
+    ERR_VC_GIT_INITIALIZED: 'ByteRover version control is active. Use /vc commands instead of legacy sync commands.',
+    ERR_VC_GIT_NOT_INITIALIZED: 'ByteRover version control not initialized. Run /vc init first.',
+    ERR_VC_INVALID_ACTION: 'Invalid action.',
+    // ERR_VC_INVALID_BRANCH_NAME intentionally omitted: fall through to server's message with actual branch name
+    ERR_VC_INVALID_CONFIG_KEY: 'Invalid config key. Allowed: user.name, user.email.',
+    ERR_VC_NETWORK_ERROR: 'Network error. Check your connection and try again.',
+    ERR_VC_NO_BRANCH_RESOLVED: 'Cannot determine branch. Check out a branch first.',
+    ERR_VC_NO_COMMITS: 'No commits yet. Run /vc add and /vc commit first.',
+    ERR_VC_NON_FAST_FORWARD: 'Remote has changes. Run /vc pull first.',
+    ERR_VC_NOTHING_STAGED: 'Nothing staged. Run /vc add first.',
+    ERR_VC_NOTHING_TO_PUSH: 'No commits to push. Run /vc add and /vc commit first.',
+    ERR_VC_REMOTE_ALREADY_EXISTS: "Remote 'origin' already exists. Use /vc remote set-url <url> to update.",
+    // ERR_VC_UNCOMMITTED_CHANGES intentionally omitted: fall through to server's detailed message with file paths
+    ERR_VC_UNRELATED_HISTORIES: 'Cannot merge unrelated histories. Use --allow-unrelated-histories to force.',
+    // ERR_VC_USER_NOT_CONFIGURED intentionally omitted: fall through to server's specific hint with actual values
 };
 /**
  * Format a task error (from task:error events) into a user-friendly message.
@@ -30,6 +50,15 @@ export function formatTaskError(error) {
     }
     return error.message;
 }
+/**
+ * Extract the error code from a transport error, if present.
+ */
+export function getTransportErrorCode(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    const errorRecord = error;
+    return 'code' in error && typeof errorRecord.code === 'string' ? errorRecord.code : undefined;
+}
 /**
  * Format a transport error (from request/response calls) into a user-friendly message.
  * Checks for a `code` property on the error and looks up a friendly message.
@@ -38,13 +67,13 @@ export function formatTaskError(error) {
 export function formatTransportError(error) {
     if (!(error instanceof Error))
         return String(error);
-    const errorRecord = error;
-    const code = 'code' in error && typeof errorRecord.code === 'string' ? errorRecord.code : undefined;
+    const code = getTransportErrorCode(error);
     if (code && code in USER_FRIENDLY_MESSAGES) {
         return USER_FRIENDLY_MESSAGES[code];
     }
     if (error.name === 'TransportRequestTimeoutError') {
         return 'Request timed out. Please try again.';
     }
-    return error.message.replace(/ for event '[^']+'(?: after \d+ms)?$/, '');
+    // Strip transport suffix and rewrite CLI-style hints (brv vc ...) to TUI slash commands (/vc ...)
+    return error.message.replace(/ for event '[^']+'(?: after \d+ms)?$/, '').replaceAll(/\bbrv\s+/g, '/');
 }