@alphafox/cli 0.3.3 → 0.3.4

package/dist/resolve-symbols/match.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSymbolSearchKey = normalizeSymbolSearchKey;
+exports.parseCatalogSymbol = parseCatalogSymbol;
+exports.indexCatalogSymbols = indexCatalogSymbols;
+exports.resolveQueryAgainstCatalog = resolveQueryAgainstCatalog;
+exports.levenshtein = levenshtein;
+const LINEAR_PERP_PATTERN = /^([\p{L}\p{N}]+(?:-[\p{L}\p{N}]+)*)\/(USDT|USDC|USD):\2$/u;
+const QUOTE_ASSETS = ["USDT", "USDC", "BUSD", "USD"];
+const EXACT_REASONS = new Set([
+    "exact_canonical",
+    "exact_compact",
+    "exact_pair",
+    "exact_base",
+]);
+function normalizeSymbolSearchKey(value) {
+    return value
+        .trim()
+        .toUpperCase()
+        .replace(/[^\p{L}\p{N}]/gu, "");
+}
+function parseCatalogSymbol(symbol) {
+    const trimmed = symbol.trim();
+    if (!trimmed)
+        return null;
+    const upper = trimmed.toUpperCase();
+    const linear = LINEAR_PERP_PATTERN.exec(upper);
+    if (linear) {
+        const base = linear[1];
+        const quote = linear[2];
+        const canonical = `${base}/${quote}:${quote}`;
+        const compact = `${base}${quote}`;
+        return {
+            symbol: canonical,
+            base,
+            quote,
+            pair: `${base}/${quote}`,
+            compact,
+            searchKey: normalizeSymbolSearchKey(canonical),
+            baseKey: normalizeSymbolSearchKey(base),
+            compactKey: normalizeSymbolSearchKey(compact),
+        };
+    }
+    const slash = upper.indexOf("/");
+    const colon = upper.lastIndexOf(":");
+    if (slash > 0) {
+        const base = upper.slice(0, slash);
+        const quote = colon > slash ? upper.slice(slash + 1, colon) : upper.slice(slash + 1);
+        const compact = `${base}${quote}`;
+        return {
+            symbol: upper,
+            base,
+            quote,
+            pair: `${base}/${quote}`,
+            compact,
+            searchKey: normalizeSymbolSearchKey(upper),
+            baseKey: normalizeSymbolSearchKey(base),
+            compactKey: normalizeSymbolSearchKey(compact),
+        };
+    }
+    return {
+        symbol: upper,
+        base: upper,
+        quote: "",
+        pair: upper,
+        compact: upper,
+        searchKey: normalizeSymbolSearchKey(upper),
+        baseKey: normalizeSymbolSearchKey(upper),
+        compactKey: normalizeSymbolSearchKey(upper),
+    };
+}
+function indexCatalogSymbols(symbols) {
+    const seen = new Set();
+    const indexed = [];
+    for (const raw of symbols) {
+        const parsed = parseCatalogSymbol(raw);
+        if (!parsed)
+            continue;
+        if (seen.has(parsed.symbol))
+            continue;
+        seen.add(parsed.symbol);
+        indexed.push(parsed);
+    }
+    return indexed;
+}
+function resolveQueryAgainstCatalog(query, catalog, limit = 8) {
+    const trimmed = query.trim();
+    const matches = rankMatches(trimmed, catalog);
+    const exact = matches.filter((item) => EXACT_REASONS.has(item.reason));
+    const close = matches.filter((item) => !EXACT_REASONS.has(item.reason));
+    const capped = (items) => items.slice(0, Math.max(1, limit));
+    if (exact.length === 1) {
+        return {
+            query: trimmed,
+            status: "exact",
+            resolved: exact[0].symbol,
+            needsConfirmation: false,
+            matches: exact,
+            matchCount: exact.length,
+        };
+    }
+    if (exact.length > 1) {
+        return {
+            query: trimmed,
+            status: "ambiguous",
+            resolved: null,
+            needsConfirmation: true,
+            matches: capped(exact),
+            matchCount: exact.length,
+        };
+    }
+    if (close.length === 1) {
+        return {
+            query: trimmed,
+            status: "close",
+            resolved: close[0].symbol,
+            needsConfirmation: true,
+            matches: close,
+            matchCount: 1,
+        };
+    }
+    if (close.length > 1) {
+        return {
+            query: trimmed,
+            status: "ambiguous",
+            resolved: null,
+            needsConfirmation: true,
+            matches: capped(close),
+            matchCount: close.length,
+        };
+    }
+    return {
+        query: trimmed,
+        status: "none",
+        resolved: null,
+        needsConfirmation: false,
+        matches: [],
+        matchCount: 0,
+    };
+}
+function rankMatches(query, catalog) {
+    const canonicalQuery = query.trim().toUpperCase();
+    const queryKey = normalizeSymbolSearchKey(query);
+    if (!canonicalQuery || !queryKey)
+        return [];
+    if (isQuoteAssetKey(queryKey))
+        return [];
+    const queryBaseKey = queryBaseSearchKey(canonicalQuery, queryKey);
+    const scored = [];
+    for (const item of catalog) {
+        const ranked = rankCatalogSymbol(item, canonicalQuery, queryKey, queryBaseKey);
+        if (ranked)
+            scored.push(ranked);
+    }
+    scored.sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        return left.symbol.localeCompare(right.symbol);
+    });
+    return scored;
+}
+function rankCatalogSymbol(item, canonicalQuery, queryKey, queryBaseKey) {
+    if (item.symbol === canonicalQuery) {
+        return match(item.symbol, "exact_canonical", 100);
+    }
+    if (item.pair === canonicalQuery) {
+        return match(item.symbol, "exact_pair", 96);
+    }
+    if (item.compactKey === queryKey || item.searchKey === queryKey) {
+        return match(item.symbol, "exact_compact", 98);
+    }
+    if (item.baseKey === queryKey || item.baseKey === queryBaseKey) {
+        return match(item.symbol, "exact_base", 95);
+    }
+    let best = null;
+    const consider = (reason, score) => {
+        if (!best || score > best.score) {
+            best = match(item.symbol, reason, score);
+        }
+    };
+    if (queryBaseKey.length >= 2 && item.baseKey.startsWith(queryBaseKey)) {
+        consider("prefix", clampScore(80 - (item.baseKey.length - queryBaseKey.length)));
+    }
+    if (queryBaseKey.length >= 3 && queryBaseKey.startsWith(item.baseKey)) {
+        consider("prefix", clampScore(74 - (queryBaseKey.length - item.baseKey.length)));
+    }
+    if (queryBaseKey.length >= 3 && item.baseKey.includes(queryBaseKey)) {
+        consider("contains", 55);
+    }
+    const distance = levenshtein(queryBaseKey, item.baseKey);
+    if (isCloseDistance(queryBaseKey, item.baseKey, distance)) {
+        consider("close", clampScore(48 - distance * 8));
+    }
+    return best;
+}
+function queryBaseSearchKey(canonicalQuery, queryKey) {
+    const linear = LINEAR_PERP_PATTERN.exec(canonicalQuery);
+    if (linear)
+        return normalizeSymbolSearchKey(linear[1]);
+    const slash = canonicalQuery.indexOf("/");
+    if (slash > 0) {
+        return normalizeSymbolSearchKey(canonicalQuery.slice(0, slash));
+    }
+    for (const quote of QUOTE_ASSETS) {
+        if (queryKey.length > quote.length && queryKey.endsWith(quote)) {
+            return queryKey.slice(0, -quote.length);
+        }
+    }
+    return queryKey;
+}
+function isQuoteAssetKey(queryKey) {
+    return QUOTE_ASSETS.includes(queryKey);
+}
+function isCloseDistance(left, right, distance) {
+    const shortest = Math.min(left.length, right.length);
+    if (shortest < 2 || distance <= 0)
+        return false;
+    if (shortest <= 4)
+        return distance === 1;
+    return distance <= 2;
+}
+function match(symbol, reason, score) {
+    return { symbol, reason, score };
+}
+function clampScore(score) {
+    return Math.max(1, Math.min(94, score));
+}
+function levenshtein(left, right) {
+    if (left === right)
+        return 0;
+    if (left.length === 0)
+        return right.length;
+    if (right.length === 0)
+        return left.length;
+    const prev = new Array(right.length + 1);
+    const next = new Array(right.length + 1);
+    for (let j = 0; j <= right.length; j += 1)
+        prev[j] = j;
+    for (let i = 1; i <= left.length; i += 1) {
+        next[0] = i;
+        const leftCh = left.charCodeAt(i - 1);
+        for (let j = 1; j <= right.length; j += 1) {
+            const cost = leftCh === right.charCodeAt(j - 1) ? 0 : 1;
+            next[j] = Math.min((prev[j] ?? 0) + 1, (next[j - 1] ?? 0) + 1, (prev[j - 1] ?? 0) + cost);
+        }
+        for (let j = 0; j <= right.length; j += 1)
+            prev[j] = next[j] ?? 0;
+    }
+    return prev[right.length] ?? Math.max(left.length, right.length);
+}

package/dist/resolve-symbols/parse-args.d.ts

@@ -0,0 +1,5 @@
+import type { ResolveSymbolsRunArgs } from "./types";
+export declare const RESOLVE_SYMBOLS_DEFAULT_LIMIT = 8;
+export declare const RESOLVE_SYMBOLS_MAX_LIMIT = 25;
+export declare const RESOLVE_SYMBOLS_USAGE: string[];
+export declare function parseResolveSymbolsArgs(args: readonly string[]): ResolveSymbolsRunArgs;

package/dist/resolve-symbols/parse-args.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOLVE_SYMBOLS_USAGE = exports.RESOLVE_SYMBOLS_MAX_LIMIT = exports.RESOLVE_SYMBOLS_DEFAULT_LIMIT = void 0;
+exports.parseResolveSymbolsArgs = parseResolveSymbolsArgs;
+const errors_1 = require("./errors");
+const exchanges_1 = require("./exchanges");
+exports.RESOLVE_SYMBOLS_DEFAULT_LIMIT = 8;
+exports.RESOLVE_SYMBOLS_MAX_LIMIT = 25;
+exports.RESOLVE_SYMBOLS_USAGE = [
+    "alphafox resolve-symbols <query...> [--exchange binance] [--limit 8]",
+    "alphafox resolve-symbols --query BTC --query ETH --exchange okx",
+];
+function usage(message, subtype = "invalid_args") {
+    throw new errors_1.ResolveSymbolsError({
+        type: "usage",
+        subtype,
+        message,
+        hint: exports.RESOLVE_SYMBOLS_USAGE[0],
+        status: 400,
+    });
+}
+function takeValue(args, i, flag) {
+    const next = args[i + 1];
+    if (next === undefined || next.startsWith("--")) {
+        usage(`Missing value for ${flag}`, "missing_flag_value");
+    }
+    return { value: next, next: i + 1 };
+}
+function parseResolveSymbolsArgs(args) {
+    const queries = [];
+    let exchange = exchanges_1.RESOLVE_SYMBOLS_DEFAULT_EXCHANGE;
+    let limit = exports.RESOLVE_SYMBOLS_DEFAULT_LIMIT;
+    let help = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--help" || a === "-h") {
+            help = true;
+            continue;
+        }
+        if (!a.startsWith("--")) {
+            queries.push(a);
+            continue;
+        }
+        const eq = a.indexOf("=");
+        const flag = eq >= 0 ? a.slice(0, eq) : a;
+        const inline = eq >= 0 ? a.slice(eq + 1) : undefined;
+        const read = () => {
+            if (inline !== undefined)
+                return inline;
+            const taken = takeValue(args, i, flag);
+            i = taken.next;
+            return taken.value;
+        };
+        switch (flag) {
+            case "--query":
+            case "--symbol":
+                queries.push(read());
+                break;
+            case "--exchange":
+                exchange = read();
+                break;
+            case "--limit": {
+                const n = Number(read());
+                if (!Number.isInteger(n) || n <= 0 || n > exports.RESOLVE_SYMBOLS_MAX_LIMIT) {
+                    usage(`--limit must be an integer 1..${exports.RESOLVE_SYMBOLS_MAX_LIMIT}`, "invalid_limit");
+                }
+                limit = n;
+                break;
+            }
+            default:
+                usage(`Unknown flag: ${flag}`, "unknown_flag");
+        }
+    }
+    if (help) {
+        return { help: true, queries: [], exchange, limit };
+    }
+    const normalizedQueries = queries.map((item) => item.trim()).filter(Boolean);
+    if (normalizedQueries.length === 0) {
+        usage("Provide at least one symbol query", "missing_query");
+    }
+    let resolvedExchange;
+    try {
+        resolvedExchange = (0, exchanges_1.resolveSymbolsExchangeId)(exchange).id;
+    }
+    catch (err) {
+        usage(err instanceof Error ? err.message : String(err), "invalid_exchange");
+    }
+    return {
+        help: false,
+        queries: uniqueQueries(normalizedQueries),
+        exchange: resolvedExchange,
+        limit,
+    };
+}
+function uniqueQueries(queries) {
+    const seen = new Set();
+    const out = [];
+    for (const query of queries) {
+        const key = query.toUpperCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(query);
+    }
+    return out;
+}

package/dist/resolve-symbols/run-command.d.ts

@@ -0,0 +1,21 @@
+import type { ApiRequestOptions, ApiResponse } from "../http/client";
+import type { ResolveSymbolsRunArgs, ResolveSymbolsSuccess } from "./types";
+export interface ResolveSymbolsCliFlags {
+    readonly profile?: string;
+    readonly format: "json" | "jsonl" | "text";
+    readonly yes: boolean;
+    readonly dryRun: boolean;
+    readonly noInput: boolean;
+    readonly unsafeCustomEndpoint?: string;
+    readonly jq?: string;
+}
+export interface ResolveSymbolsRunDeps {
+    readonly apiRequest?: (options: ApiRequestOptions, env?: NodeJS.ProcessEnv) => Promise<ApiResponse>;
+}
+export declare function resolveSymbolsHelpData(): {
+    readonly name: string;
+    readonly usage: string[];
+    readonly notes: string[];
+};
+export declare function executeResolveSymbols(args: ResolveSymbolsRunArgs, flags: ResolveSymbolsCliFlags, env?: NodeJS.ProcessEnv, deps?: ResolveSymbolsRunDeps): Promise<ResolveSymbolsSuccess>;
+export declare function cmdResolveSymbols(args: string[], flags: ResolveSymbolsCliFlags, env?: NodeJS.ProcessEnv, deps?: ResolveSymbolsRunDeps): Promise<number>;

package/dist/resolve-symbols/run-command.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSymbolsHelpData = resolveSymbolsHelpData;
+exports.executeResolveSymbols = executeResolveSymbols;
+exports.cmdResolveSymbols = cmdResolveSymbols;
+const profiles_1 = require("../config/profiles");
+const envelope_1 = require("../envelope");
+const client_1 = require("../http/client");
+const catalog_1 = require("./catalog");
+const errors_1 = require("./errors");
+const exchanges_1 = require("./exchanges");
+const match_1 = require("./match");
+const parse_args_1 = require("./parse-args");
+function extractErrorMessage(json, fallback) {
+    if (json && typeof json === "object") {
+        const o = json;
+        if (typeof o.message === "string")
+            return o.message;
+        if (typeof o.detail === "string")
+            return o.detail;
+        if (typeof o.error === "string")
+            return o.error;
+        if (o.error && typeof o.error === "object") {
+            const e = o.error;
+            if (typeof e.message === "string")
+                return e.message;
+        }
+    }
+    return fallback || "Request failed";
+}
+function extractErrorCode(json) {
+    if (json && typeof json === "object") {
+        const o = json;
+        if (typeof o.code === "string" || typeof o.code === "number")
+            return o.code;
+    }
+    return undefined;
+}
+function resolveSymbolsHelpData() {
+    return {
+        name: "resolve-symbols",
+        usage: parse_args_1.RESOLVE_SYMBOLS_USAGE,
+        notes: [
+            "Resolves user-mentioned tickers against the public linear-perp catalog from market.symbols.list",
+            "Default --exchange is binance (binance_perp_usdt). Aliases: binance|okx|bybit|bitget|hyperliquid|aster",
+            "Do not guess CCXT symbols. Exact match may be used directly; a single close match needs user confirmation; multiple close matches must be chosen by the user",
+            "Catalog CRUD remains alphafox market symbols list --exchange <id>",
+        ],
+    };
+}
+async function executeResolveSymbols(args, flags, env = process.env, deps = {}) {
+    if (args.help) {
+        throw new errors_1.ResolveSymbolsError({
+            type: "usage",
+            message: "internal: help should be handled by the command wrapper",
+        });
+    }
+    const exchange = (0, exchanges_1.resolveSymbolsExchangeId)(args.exchange);
+    const profile = (0, profiles_1.resolveProfile)(flags.profile, env, {
+        unsafeCustomEndpoint: flags.unsafeCustomEndpoint,
+    });
+    const api = deps.apiRequest ?? client_1.apiRequest;
+    const res = await api({
+        method: "GET",
+        path: (0, catalog_1.marketSymbolsPath)(exchange.id),
+        profile,
+    }, env);
+    if (res.status >= 400) {
+        throw new errors_1.ResolveSymbolsError({
+            type: "http",
+            status: res.status,
+            message: extractErrorMessage(res.json, res.bodyText),
+            code: extractErrorCode(res.json),
+            hint: res.status === 401 || res.status === 403
+                ? "Run alphafox auth login. Tokens live in the OS keychain."
+                : undefined,
+            details: res.json,
+        });
+    }
+    const catalog = (0, match_1.indexCatalogSymbols)((0, catalog_1.extractCatalogSymbols)(res.json));
+    return {
+        exchange: exchange.id,
+        exchangeLabel: exchange.label,
+        catalogSize: catalog.length,
+        queries: args.queries.map((query) => (0, match_1.resolveQueryAgainstCatalog)(query, catalog, args.limit)),
+    };
+}
+async function cmdResolveSymbols(args, flags, env = process.env, deps = {}) {
+    let parsed;
+    try {
+        parsed = (0, parse_args_1.parseResolveSymbolsArgs)(args);
+    }
+    catch (err) {
+        if ((0, errors_1.isResolveSymbolsError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+                status: err.status,
+                details: err.details,
+            }, { exitCode: err.status === 401 || err.status === 403 ? 77 : undefined });
+        }
+        throw err;
+    }
+    if (parsed.help) {
+        (0, envelope_1.writeSuccess)(resolveSymbolsHelpData(), {
+            format: flags.format,
+            jq: flags.jq,
+        });
+        return 0;
+    }
+    const exchange = (0, exchanges_1.resolveSymbolsExchangeId)(parsed.exchange);
+    if (flags.dryRun) {
+        (0, envelope_1.writeSuccess)({
+            dryRun: true,
+            operationId: "market.symbols.list",
+            method: "GET",
+            path: (0, catalog_1.marketSymbolsPath)(exchange.id),
+            exchange: exchange.id,
+            exchangeLabel: exchange.label,
+            queries: parsed.queries,
+        }, { format: flags.format, jq: flags.jq });
+        return 0;
+    }
+    try {
+        const result = await executeResolveSymbols(parsed, flags, env, deps);
+        (0, envelope_1.writeSuccess)(result, {
+            format: flags.format,
+            jq: flags.jq,
+            meta: { operationId: "market.symbols.list" },
+        });
+        return 0;
+    }
+    catch (err) {
+        if ((0, errors_1.isResolveSymbolsError)(err)) {
+            (0, envelope_1.writeError)({
+                type: err.type,
+                subtype: err.subtype,
+                message: err.message,
+                hint: err.hint,
+                status: err.status,
+                code: err.code,
+                details: err.details,
+            }, { exitCode: err.status === 401 || err.status === 403 ? 77 : undefined });
+        }
+        throw err;
+    }
+}

package/dist/resolve-symbols/types.d.ts

@@ -0,0 +1,37 @@
+export type ResolveSymbolsStatus = "exact" | "close" | "ambiguous" | "none";
+export type ResolveSymbolsMatchReason = "exact_canonical" | "exact_compact" | "exact_pair" | "exact_base" | "prefix" | "contains" | "close";
+export interface ResolveSymbolsMatch {
+    readonly symbol: string;
+    readonly reason: ResolveSymbolsMatchReason;
+    readonly score: number;
+}
+export interface ResolveSymbolsQueryResult {
+    readonly query: string;
+    readonly status: ResolveSymbolsStatus;
+    readonly resolved: string | null;
+    readonly needsConfirmation: boolean;
+    readonly matches: readonly ResolveSymbolsMatch[];
+    readonly matchCount: number;
+}
+export interface ResolveSymbolsSuccess {
+    readonly exchange: string;
+    readonly exchangeLabel: string;
+    readonly catalogSize: number;
+    readonly queries: readonly ResolveSymbolsQueryResult[];
+}
+export interface ResolveSymbolsRunArgs {
+    readonly help: boolean;
+    readonly queries: readonly string[];
+    readonly exchange: string;
+    readonly limit: number;
+}
+export interface CatalogSymbol {
+    readonly symbol: string;
+    readonly base: string;
+    readonly quote: string;
+    readonly pair: string;
+    readonly compact: string;
+    readonly searchKey: string;
+    readonly baseKey: string;
+    readonly compactKey: string;
+}

package/dist/resolve-symbols/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 export declare const CLI_NAME = "alphafox";
 export declare const CLI_PACKAGE = "@alphafox/cli";
-export declare const CLI_VERSION = "0.3.3";
+export declare const CLI_VERSION = "0.3.4";
 export { CATALOG_VERSION as CLI_CONTRACT_VERSION } from "./catalog/operations";

package/dist/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLI_CONTRACT_VERSION = exports.CLI_VERSION = exports.CLI_PACKAGE = exports.CLI_NAME = void 0;
 exports.CLI_NAME = "alphafox";
 exports.CLI_PACKAGE = "@alphafox/cli";
-exports.CLI_VERSION = "0.3.3";
+exports.CLI_VERSION = "0.3.4";
 var operations_1 = require("./catalog/operations");
 Object.defineProperty(exports, "CLI_CONTRACT_VERSION", { enumerable: true, get: function () { return operations_1.CATALOG_VERSION; } });

package/docs/alphafox-cli-installation-guide.md

@@ -88,8 +88,8 @@ Parse the JSON envelope: `ok === true` means success. Errors land on
 ## Step 4: Tell the user to restart
 
 Ask the user to **restart the AI tool** so the new Skills are loaded.
-Then they can ask the Agent to use Alphafox (auth, catalog, trading,
-engine-backtest, …).
+Then they can ask the Agent to use Alphafox. The entry skill `alphafox` routes
+to auth, market, engine-backtest, strategy, trading, and the rest.
 
 ## Human wizard (do not run this from an Agent)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphafox/cli",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Alphafox CLI — Agent/Human entry for the public Application API.",
   "type": "commonjs",
   "bin": {

package/skills/account/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: alphafox-account
 description: Account, wallet, and subscription read paths.
-version: 0.3.3
+version: 0.3.4
 ---
 
 # Account / wallet

package/skills/admin/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: alphafox-admin
 description: Admin-only operations reusing Web role authorization.
-version: 0.3.3
+version: 0.3.4
 ---
 
 # Admin

package/skills/alphafox/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: alphafox
+description: Alphafox CLI entry router. Use for any Alphafox request — install, login, whoami, 回测, engine backtest, strategy chat, traders, ticker/标的 resolve, market data, exchange connectors, wallet, subscriptions, notifications, or admin. Start here, then open the routed domain skill. Do not guess alphafox-engine-backtest vs alphafox-strategy from memory.
+version: 0.3.4
+---
+
+# Alphafox
+
+This skill only routes. After choosing a row, **read that skill's `SKILL.md` and follow it**. Do not improvise domain procedures from this file.
+
+Also read `alphafox-shared` before any CLI invocation (envelope, auth, risk, schema-first writes). Always `--format json --no-input`. Never `--token`.
+
+Human-mentioned tickers go through `alphafox-market` (`alphafox resolve-symbols`) **before** they enter config, backtest, or writes.
+
+## Route
+
+| User intent | Skill |
+|---|---|
+| Install, doctor, version, catalog, how to call the CLI | `alphafox-shared` |
+| Login, logout, whoami, profile, staging vs production | `alphafox-auth` |
+| Coin / ticker / 标的 / `BTC/USDT:USDT` / resolve a misspelled symbol | `alphafox-market` |
+| Engine WASM backtest, experiment, `engine-backtest run`, persist a local run | `alphafox-engine-backtest` |
+| Strategy chat, compiled strategy | `alphafox-strategy` |
+| List / start / stop traders | `alphafox-trading` |
+| Exchange connectors | `alphafox-exchange` |
+| Account, wallet, subscription | `alphafox-account` |
+| Notification channels | `alphafox-notification` |
+| Admin-only operations | `alphafox-admin` |
+
+If several rows apply, load **all** of them (typical: `alphafox-shared` + `alphafox-market` + one domain skill).
+
+## Do not mix these backtest paths
+
+- Local Engine tape + wasm + optional persist → `alphafox-engine-backtest` (`alphafox engine-backtest run`, hyphen).
+- Experiment catalog CRUD → same skill, underscore catalog `engine_backtest.*`.
+- Chat-attached `/api/v1/backtests` (`backtests.*`) is **not** a CLI surface. Do not call it via typed commands, `schema`, or `alphafox api`.
+
+Ambiguous “帮我回测” → `alphafox-engine-backtest`, after resolving symbols.