@jsonstudio/rcc 0.89.164 → 0.89.333

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/token-file-scanner.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const TOKEN_FILE_PATTERN = /^([a-z0-9_-]+)-oauth-(\d+)(?:-(.+))?\.json$/i;
+/**
+ * 扫描本地 RouteCodex auth 目录中的 OAuth token 文件。
+ *
+ * 约定:
+ * - 目录: ~/.routecodex/auth
+ * - 文件名: <provider>-oauth-<sequence>[-<alias>].json
+ *
+ * 仅在 Node 环境下使用；如果环境不满足，返回空列表。
+ */
+export function scanOAuthTokenFiles(oauthProviderId, authDir) {
+    if (!isNodeEnvironment()) {
+        return [];
+    }
+    const provider = oauthProviderId.trim().toLowerCase();
+    if (!provider) {
+        return [];
+    }
+    const baseDir = authDir && authDir.trim()
+        ? authDir.trim()
+        : path.join(os.homedir(), '.routecodex', 'auth');
+    let entries;
+    try {
+        entries = fs.readdirSync(baseDir);
+    }
+    catch {
+        return [];
+    }
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const match = entry.match(TOKEN_FILE_PATTERN);
+        if (!match)
+            continue;
+        const [, providerPrefix, sequenceStr, alias] = match;
+        if (providerPrefix.toLowerCase() !== provider)
+            continue;
+        const sequence = parseInt(sequenceStr, 10);
+        if (!Number.isFinite(sequence) || sequence <= 0)
+            continue;
+        matches.push({
+            filePath: path.join(baseDir, entry),
+            sequence,
+            alias: alias || 'default'
+        });
+    }
+    matches.sort((a, b) => a.sequence - b.sequence);
+    return matches;
+}
+function isNodeEnvironment() {
+    return typeof process !== 'undefined' && !!process.release && process.release.name === 'node';
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/tool-signals.d.ts

@@ -0,0 +1,13 @@
+import type { StandardizedMessage, StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export type ToolCategory = 'read' | 'write' | 'search' | 'other';
+export type ToolClassification = {
+    category: ToolCategory;
+    name: string;
+    commandSnippet?: string;
+};
+export declare function detectVisionTool(request: StandardizedRequest): boolean;
+export declare function detectCodingTool(request: StandardizedRequest): boolean;
+export declare function detectWebTool(request: StandardizedRequest): boolean;
+export declare function extractMeaningfulDeclaredToolNames(tools: StandardizedRequest['tools'] | undefined): string[];
+export declare function detectLastAssistantToolCategory(messages: StandardizedMessage[]): ToolClassification | undefined;
+export declare function canonicalizeToolName(rawName: string): string;

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/tool-signals.js

@@ -0,0 +1,403 @@
+const WEB_TOOL_KEYWORDS = ['websearch', 'web_search', 'web-search', 'webfetch', 'web_fetch', 'web_request', 'search_web', 'internet_search'];
+const READ_TOOL_EXACT = new Set([
+    'read_file',
+    'read_text',
+    'view_file',
+    'view_code',
+    'view_document',
+    'open_file',
+    'get_file',
+    'download_file',
+    'describe_current_request',
+    'list_dir',
+    'list_directory',
+    'list_files',
+    'list_documents',
+    'list_resources',
+    'search_files',
+    'find_files'
+]);
+const WRITE_TOOL_EXACT = new Set([
+    'apply_patch',
+    'write_file',
+    'create_file',
+    'modify_file',
+    'edit_file',
+    'update_file',
+    'save_file',
+    'append_file',
+    'replace_file',
+    'delete_file',
+    'remove_file',
+    'rename_file',
+    'move_file',
+    'copy_file',
+    'mkdir',
+    'rmdir'
+]);
+const SEARCH_TOOL_EXACT = new Set(['websearch', 'web_search', 'search_web', 'internet_search', 'webfetch', 'web_fetch']);
+const READ_TOOL_KEYWORDS = ['read', 'list', 'view', 'download', 'open', 'show', 'fetch', 'inspect'];
+const WRITE_TOOL_KEYWORDS = ['write', 'patch', 'modify', 'edit', 'create', 'update', 'append', 'replace', 'delete', 'remove'];
+const SEARCH_TOOL_KEYWORDS = ['search', 'websearch', 'web_fetch', 'webfetch', 'web-request', 'web_request', 'internet'];
+const SHELL_TOOL_NAMES = new Set(['shell_command', 'shell', 'bash']);
+const DECLARED_TOOL_IGNORE = new Set(['exec_command']);
+const SHELL_HEREDOC_PATTERN = /<<\s*['"]?[a-z0-9_-]+/i;
+const SHELL_WRITE_PATTERNS = [
+    'apply_patch',
+    'sed -i',
+    'perl -pi',
+    'tee ',
+    'cat <<',
+    'cat >',
+    'printf >',
+    'touch ',
+    'truncate',
+    'mkdir',
+    'mktemp',
+    'rmdir',
+    'rm ',
+    'rm-',
+    'unlink',
+    'mv ',
+    'cp ',
+    'ln -',
+    'chmod',
+    'chown',
+    'chgrp',
+    'tar ',
+    'git add',
+    'git commit',
+    'git apply',
+    'git am',
+    'git rebase',
+    'git checkout',
+    'git merge',
+    'patch <<',
+    'npm install',
+    'pnpm install',
+    'yarn add',
+    'yarn install',
+    'pip install',
+    'pip3 install',
+    'brew install',
+    'cargo add',
+    'cargo install',
+    'go install',
+    'make install'
+];
+const SHELL_SEARCH_PATTERNS = [
+    'rg ',
+    'rg-',
+    'grep ',
+    'grep-',
+    'ripgrep',
+    'find ',
+    'fd ',
+    'locate ',
+    'search ',
+    'ack ',
+    'ag ',
+    'where ',
+    'which ',
+    'codesearch'
+];
+const SHELL_READ_PATTERNS = [
+    'ls',
+    'dir ',
+    'pwd',
+    'cat ',
+    'type ',
+    'head ',
+    'tail ',
+    'stat',
+    'tree',
+    'wc ',
+    'du ',
+    'printf "',
+    'python - <<',
+    'python -c',
+    'node - <<',
+    'node -e'
+];
+export function detectVisionTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        return /vision|image|picture|photo/i.test(functionName) || /vision|image|picture|photo/i.test(description || '');
+    });
+}
+export function detectCodingTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool).toLowerCase();
+        const description = (extractToolDescription(tool) || '').toLowerCase();
+        if (!functionName && !description) {
+            return false;
+        }
+        if (WRITE_TOOL_EXACT.has(functionName)) {
+            return true;
+        }
+        return WRITE_TOOL_KEYWORDS.some((keyword) => functionName.includes(keyword.toLowerCase()) || description.includes(keyword.toLowerCase()));
+    });
+}
+export function detectWebTool(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const description = extractToolDescription(tool);
+        const normalizedName = functionName.toLowerCase();
+        const normalizedDesc = (description || '').toLowerCase();
+        return (WEB_TOOL_KEYWORDS.some((keyword) => normalizedName.includes(keyword)) ||
+            WEB_TOOL_KEYWORDS.some((keyword) => normalizedDesc.includes(keyword)));
+    });
+}
+export function extractMeaningfulDeclaredToolNames(tools) {
+    if (!Array.isArray(tools) || tools.length === 0) {
+        return [];
+    }
+    const names = [];
+    for (const tool of tools) {
+        const rawName = extractToolName(tool);
+        if (!rawName) {
+            continue;
+        }
+        const canonical = canonicalizeToolName(rawName).toLowerCase();
+        if (!canonical || DECLARED_TOOL_IGNORE.has(canonical)) {
+            continue;
+        }
+        names.push(rawName);
+    }
+    return names;
+}
+export function detectLastAssistantToolCategory(messages) {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const msg = messages[idx];
+        if (!msg || !Array.isArray(msg.tool_calls) || msg.tool_calls.length === 0) {
+            continue;
+        }
+        let fallback;
+        for (const call of msg.tool_calls) {
+            const classification = classifyToolCall(call);
+            if (!classification) {
+                continue;
+            }
+            if (!fallback) {
+                fallback = classification;
+            }
+            if (classification.category !== 'other') {
+                return classification;
+            }
+        }
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return undefined;
+}
+function classifyToolCall(call) {
+    if (!call || typeof call !== 'object') {
+        return undefined;
+    }
+    const functionName = typeof call?.function?.name === 'string' && call.function.name.trim()
+        ? canonicalizeToolName(call.function.name)
+        : '';
+    if (!functionName) {
+        return undefined;
+    }
+    const argsObject = parseToolArguments(call?.function?.arguments);
+    const commandText = extractCommandText(argsObject);
+    const nameCategory = categorizeToolName(functionName);
+    const snippet = buildCommandSnippet(commandText);
+    if (nameCategory === 'write' || nameCategory === 'read' || nameCategory === 'search') {
+        return { category: nameCategory, name: functionName, commandSnippet: snippet };
+    }
+    if (SHELL_TOOL_NAMES.has(functionName)) {
+        const shellCategory = classifyShellCommand(commandText);
+        return { category: shellCategory, name: functionName, commandSnippet: snippet };
+    }
+    if (commandText) {
+        const derivedCategory = classifyShellCommand(commandText);
+        if (derivedCategory !== 'other') {
+            return { category: derivedCategory, name: functionName, commandSnippet: snippet };
+        }
+    }
+    return { category: 'other', name: functionName, commandSnippet: snippet };
+}
+function extractToolName(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.name === 'string' && fromFunction.name.trim()) {
+        return fromFunction.name;
+    }
+    if (typeof candidate.name === 'string' && candidate.name.trim()) {
+        return candidate.name;
+    }
+    return '';
+}
+function extractToolDescription(tool) {
+    if (!tool || typeof tool !== 'object') {
+        return '';
+    }
+    const candidate = tool;
+    const fromFunction = candidate.function;
+    if (fromFunction && typeof fromFunction.description === 'string' && fromFunction.description.trim()) {
+        return fromFunction.description;
+    }
+    if (typeof candidate.description === 'string' && candidate.description.trim()) {
+        return candidate.description;
+    }
+    return '';
+}
+export function canonicalizeToolName(rawName) {
+    const trimmed = rawName.trim();
+    const markerIndex = trimmed.indexOf('arg_');
+    if (markerIndex > 0) {
+        return trimmed.slice(0, markerIndex);
+    }
+    return trimmed;
+}
+function parseToolArguments(rawArguments) {
+    if (!rawArguments) {
+        return undefined;
+    }
+    if (typeof rawArguments === 'string') {
+        try {
+            return JSON.parse(rawArguments);
+        }
+        catch {
+            return rawArguments;
+        }
+    }
+    if (typeof rawArguments === 'object') {
+        return rawArguments;
+    }
+    return undefined;
+}
+function extractCommandText(args) {
+    if (!args) {
+        return '';
+    }
+    if (typeof args === 'string') {
+        return args;
+    }
+    if (Array.isArray(args)) {
+        return args.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+    }
+    if (typeof args === 'object') {
+        const record = args;
+        const stringKeys = ['command', 'cmd', 'input', 'code', 'script', 'text', 'prompt'];
+        for (const key of stringKeys) {
+            const value = record[key];
+            if (typeof value === 'string' && value.trim()) {
+                return value;
+            }
+            if (Array.isArray(value)) {
+                const joined = value.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+                if (joined.trim()) {
+                    return joined;
+                }
+            }
+        }
+        const nestedArgs = record.args;
+        if (typeof nestedArgs === 'string' && nestedArgs.trim()) {
+            return nestedArgs;
+        }
+        if (Array.isArray(nestedArgs)) {
+            const joined = nestedArgs.map((item) => (typeof item === 'string' ? item : '')).filter(Boolean).join(' ');
+            if (joined.trim()) {
+                return joined;
+            }
+        }
+    }
+    return '';
+}
+function buildCommandSnippet(commandText) {
+    if (!commandText) {
+        return undefined;
+    }
+    const collapsed = commandText.replace(/\s+/g, ' ').trim();
+    if (!collapsed) {
+        return undefined;
+    }
+    const limit = 80;
+    if (collapsed.length <= limit) {
+        return collapsed;
+    }
+    return `${collapsed.slice(0, limit)}…`;
+}
+function categorizeToolName(name) {
+    const normalized = name.toLowerCase();
+    if (SEARCH_TOOL_EXACT.has(normalized) ||
+        SEARCH_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'search';
+    }
+    if (READ_TOOL_EXACT.has(normalized) ||
+        READ_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'read';
+    }
+    if (WRITE_TOOL_EXACT.has(normalized) ||
+        WRITE_TOOL_KEYWORDS.some((keyword) => normalized.includes(keyword.toLowerCase()))) {
+        return 'write';
+    }
+    return 'other';
+}
+function classifyShellCommand(command) {
+    if (!command) {
+        return 'other';
+    }
+    if (SHELL_HEREDOC_PATTERN.test(command)) {
+        return 'write';
+    }
+    const segments = splitCommandSegments(command).map(stripShellWrapper);
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_WRITE_PATTERNS))) {
+        return 'write';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_SEARCH_PATTERNS))) {
+        return 'search';
+    }
+    if (segments.some((segment) => matchesAnyPattern(segment, SHELL_READ_PATTERNS))) {
+        return 'read';
+    }
+    const stripped = stripShellWrapper(command);
+    if (matchesAnyPattern(stripped, SHELL_WRITE_PATTERNS)) {
+        return 'write';
+    }
+    if (matchesAnyPattern(stripped, SHELL_SEARCH_PATTERNS)) {
+        return 'search';
+    }
+    if (matchesAnyPattern(stripped, SHELL_READ_PATTERNS)) {
+        return 'read';
+    }
+    return 'other';
+}
+function splitCommandSegments(command) {
+    return command
+        .split(/(?:\r?\n|&&|\|\||;)/)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function stripShellWrapper(command) {
+    if (!command) {
+        return '';
+    }
+    const wrappers = ['bash -lc', 'sh -c', 'zsh -c'];
+    for (const wrapper of wrappers) {
+        if (command.startsWith(wrapper)) {
+            return command.slice(wrapper.length).trim();
+        }
+    }
+    return command.trim();
+}
+function matchesAnyPattern(command, patterns) {
+    return patterns.some((pattern) => command.includes(pattern));
+}

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/types.d.ts

@@ -2,9 +2,11 @@
  * Virtual Router 类型定义
  */
 import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare const DEFAULT_MODEL_CONTEXT_TOKENS = 200000;
 export declare const DEFAULT_ROUTE = "default";
 export declare const ROUTE_PRIORITY: string[];
 export type RoutingPools = Record<string, string[]>;
+export type StreamingPreference = 'auto' | 'always' | 'never';
 export interface ProviderAuthConfig {
     type: 'apiKey' | 'oauth';
     secretRef?: string;
@@ -32,6 +34,8 @@ export interface ProviderProfile {
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    maxContextTokens?: number;
 }
 export interface ProviderRuntimeProfile {
     runtimeKey: string;
@@ -46,6 +50,11 @@ export interface ProviderRuntimeProfile {
     modelId?: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    modelStreaming?: Record<string, StreamingPreference>;
+    modelContextTokens?: Record<string, number>;
+    defaultContextTokens?: number;
+    maxContextTokens?: number;
 }
 export interface VirtualRouterClassifierConfig {
     longContextThresholdTokens?: number;
@@ -69,6 +78,12 @@ export interface VirtualRouterConfig {
     classifier: VirtualRouterClassifierConfig;
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
+    contextRouting?: VirtualRouterContextRoutingConfig;
+}
+export interface VirtualRouterContextRoutingConfig {
+    warnRatio: number;
+    hardLimit?: boolean;
+    fallbackRoute?: string;
 }
 export type VirtualRouterProviderDefinition = Record<string, unknown>;
 export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
@@ -78,6 +93,7 @@ export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
     classifier?: VirtualRouterClassifierConfig;
     loadBalancing?: LoadBalancingPolicy;
     health?: ProviderHealthConfig;
+    contextRouting?: VirtualRouterContextRoutingConfig;
 }
 export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
 export interface VirtualRouterBootstrapResult {
@@ -117,7 +133,9 @@ export interface RoutingFeatures {
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
     lastAssistantToolCategory?: 'read' | 'write' | 'search' | 'other';
-    lastAssistantToolName?: string;
+    lastAssistantToolSnippet?: string;
+    lastAssistantToolLabel?: string;
+    latestMessageFromUser?: boolean;
     metadata: RouterMetadataInput;
 }
 export interface ClassificationResult {
@@ -144,6 +162,8 @@ export interface TargetMetadata {
     modelId: string;
     processMode?: 'chat' | 'passthrough';
     responsesConfig?: ResponsesProviderConfig;
+    streaming?: StreamingPreference;
+    maxContextTokens?: number;
 }
 export interface ResponsesProviderConfig {
     toolCallIdStyle?: 'fc' | 'preserve';

package/node_modules/@jsonstudio/llms/dist/router/virtual-router/types.js

@@ -1,6 +1,7 @@
 /**
  * Virtual Router 类型定义
  */
+export const DEFAULT_MODEL_CONTEXT_TOKENS = 200_000;
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
     'vision',

package/node_modules/@jsonstudio/llms/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.104",
+  "version": "0.6.203",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -25,7 +25,7 @@
     "test:looprt:gemini": "npm run build && node scripts/tests/loop-rt-gemini.mjs",
     "replay:responses:chat-sse": "node scripts/exp3-responses-sse-to-chat-sse.mjs",
     "replay:responses:loop": "node scripts/exp4-responses-sse-loop.mjs",
-    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-dry-run.mjs",
+    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs",
     "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs"
   },
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/rcc",
-  "version": "0.89.164",
+  "version": "0.89.333",
   "description": "Multi-provider OpenAI proxy server with anthropic/responses/chat support (dev)",
   "type": "module",
   "main": "dist/index.js",
@@ -39,13 +39,14 @@
     "build:watch": "tsc --watch",
     "start": "npm run -s start:bg",
     "dev": "tsx watch src/index.ts",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:integration": "jest --testPathPattern=integration",
-    "test:e2e": "jest --testPathPattern=e2e",
-    "test:performance": "jest --testPathPattern=performance",
-    "test:protocol": "jest --testPathPattern=protocol-tools-e2e.spec.ts --runInBand --detectOpenHandles --forceExit",
+    "jest:run": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
+    "test": "npm run jest:run",
+    "test:watch": "npm run jest:run -- --watch",
+    "test:coverage": "npm run jest:run -- --coverage",
+    "test:integration": "npm run jest:run -- --testPathPattern=integration",
+    "test:e2e": "npm run jest:run -- --testPathPattern=e2e",
+    "test:performance": "npm run jest:run -- --testPathPattern=performance",
+    "test:protocol": "npm run jest:run -- --testPathPattern=protocol-tools-e2e.spec.ts --runInBand --detectOpenHandles --forceExit",
     "test:dry-run": "node tests/basic-dry-run.mjs",
     "test:lmstudio-dryrun": "node tests/lmstudio-tools-bidir-dry-run.mjs",
     "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
@@ -83,7 +84,7 @@
     "start:verify:fg": "node scripts/start-verify.mjs --mode fg --timeout 90",
     "rc-config": "node scripts/rc-config.mjs",
     "config:validate:providers": "node scripts/validate-config-providers.mjs",
-    "verify:e2e-toolcall": "node scripts/verify-e2e-toolcall.mjs",
+    "verify:e2e-toolcall": "node scripts/verify-e2e-toolcall.mjs && node scripts/verify-client-headers.mjs",
     "test:anthropic-roundtrip": "node scripts/tests/anthropic-roundtrip.mjs",
     "replay:codex-sample": "node scripts/replay-codex-sample.mjs",
     "config:update:providers": "node scripts/update-config-providers.mjs",
@@ -120,11 +121,12 @@
     "sync:ci-goldens": "node scripts/tools/sync-ci-goldens.mjs",
     "mock:extract": "node scripts/mock-provider/extract.mjs",
     "mock:validate": "node scripts/mock-provider/validate.mjs",
-    "mock:clean": "node scripts/mock-provider/clean.mjs"
+    "mock:clean": "node scripts/mock-provider/clean.mjs",
+    "publish:rcc": "node scripts/publish-rcc.mjs"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.65.0",
-    "@jsonstudio/llms": "^0.6.104",
+    "@jsonstudio/llms": "^0.6.203",
     "@lmstudio/sdk": "^1.5.0",
     "@radix-ui/react-switch": "^1.2.6",
     "@types/socket.io": "^3.0.1",

package/scripts/README.md

@@ -1,20 +1,34 @@
-# RouteCodex 构建和安装脚本
+# Build & Install Scripts
 
-本目录包含用于自动构建和安装 RouteCodex 的脚本。
+> **AGENTS.md rules apply** – always build shared modules first, never skip verification, never mix dev/release modes.
 
-## 唯一安装脚本
-
-### install-user-global.sh（推荐）
+## Dev CLI (routecodex)
 
 ```bash
-# 一键构建并全局安装（使用 npm 默认全局路径，不修改前缀）
+# 1. build sharedmodule first
+npm --prefix sharedmodule/llmswitch-core run build
+
+# 2. build host
+cd - && npm run build:dev
+
+# 3. install globally
 npm run install:global
 ```
 
-脚本流程：
-- 构建 sharedmodule/llmswitch-core 与根包
-- npm pack 生成 tgz
-- 卸载全局旧版 routecodex
-- npm install -g 安装新版本
+## Release CLI (rcc)
+
+```bash
+# 1. build sharedmodule first
+npm --prefix sharedmodule/llmswitch-core run build
+
+# 2. build release variant
+npm run build:release
+
+# 3. install globally
+npm run install:release
+```
+
+## Verification
 
-> 说明：其余安装脚本已移除，请统一使用上述命令。
+- Never use `ROUTECODEX_VERIFY_SKIP=1`; golden samples are up-to-date.
+- CI runs `npm run build:dev && npm run build:release` with full verification.