@alphafox/cli 0.3.11 → 0.3.13

package/README.md

@@ -54,6 +54,32 @@ Locally modified Skills are reported and preserved; use
 `alphafox skills sync --force --yes` only when you intend to replace them.
 Restart the AI tool after a sync.
 
+## Uninstall
+
+This is **not** an `alphafox` subcommand. The script removes the global npm
+package, Agent Skills (including Claude / Cursor / Codex / Grok links), local
+config, login tokens, and Engine backtest caches. It does **not** delete
+server-side traders or account data.
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/alphafoxai/alphafox-cli/main/scripts/uninstall.cjs | node -- --yes
+```
+
+Preview first:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/alphafoxai/alphafox-cli/main/scripts/uninstall.cjs | node -- --dry-run
+```
+
+From a git checkout:
+
+```bash
+node scripts/uninstall.cjs --dry-run
+node scripts/uninstall.cjs --yes
+```
+
+Restart AI tools afterwards so Skills unload.
+
 ## Quick start
 
 After Method 1 or 2:
@@ -86,10 +112,11 @@ skills then use public `operationId`s; an explicit local-execution skill may
 call its co-versioned built-in command.
 
 `alphafox install` (and the [Agent install guide](docs/alphafox-cli-installation-guide.md))
-verify the packaged Skills manifest and sync managed files into Agent skill
-directories (`.cursor/skills`, `.claude/skills`, `~/.agents/skills`, …).
-Use `alphafox skills status` to inspect missing, stale, or modified Skills and
-`alphafox skills sync` to repair safe drift.
+verify the packaged Skills manifest, copy it into `~/.agents/skills`, and link
+each Skill into `~/.claude/skills` (plus `~/.cursor/skills` / `~/.codex/skills`
+when those agents exist). Use `alphafox skills status` to inspect missing,
+stale, modified, or unlinked Skills and `alphafox skills sync` to repair safe
+drift — including Claude Code links when the canonical bundle is already current.
 
 ## Docs
 

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export { parseRequestBodyFlags, loadJsonArg } from "./commands/request-body";
 export { parseInstallArgs, runInstallWizard, semverLessThan, skillsListHasAlphafox, } from "./install/wizard";
 export { AGENT_INSTALL_GUIDE_BLOB_URL, AGENT_INSTALL_GUIDE_URL, SKILLS_GITHUB_SOURCE, } from "./install/types";
 export { buildSkillsManifest, inspectSkills, loadAndVerifySkillsManifest, loadSkillsState, syncSkills, writeSkillsManifest, } from "./skills/manager";
+export type { AgentSkillLinkStatus } from "./skills/manager";
 export { inspectCurrentSkills, installedSkillsRoot, skillsStatePath, syncCurrentSkills, } from "./skills/run-command";
 export { executeCliUpdate, parseUpdateArgs, } from "./update/run-command";
 export { formatUpdateNotice, maybeNotifyCliUpdate, shouldSkipUpdateCheck, } from "./update/notify";

package/dist/install/types.d.ts

@@ -1,3 +1,4 @@
+import type { AgentSkillLinkStatus } from "../skills/manager";
 /** @deprecated AlphaFox Skills updates must use the verified npm package bundle. */
 export declare const SKILLS_GITHUB_SOURCE = "alphafoxai/alphafox-cli";
 export declare const SKILLS_NAME_PREFIX = "alphafox-";
@@ -22,6 +23,7 @@ export interface InstallSkillsStep {
     readonly removed?: readonly string[];
     readonly blocked?: readonly string[];
     readonly backupDir?: string;
+    readonly agentLinks?: readonly AgentSkillLinkStatus[];
     readonly restartRequired?: boolean;
 }
 export interface InstallAuthStep {

package/dist/install/wizard.js

@@ -17,7 +17,6 @@ const exec_1 = require("./exec");
 const package_root_1 = require("./package-root");
 const types_1 = require("./types");
 const NPM_TIMEOUT_MS = 120_000;
-const SKILLS_TIMEOUT_MS = 120_000;
 function parseInstallArgs(args) {
     let noAuth = false;
     let help = false;
@@ -58,7 +57,7 @@ function nextSteps(input) {
     if (input.auth.action === "skipped" || input.auth.action === "planned") {
         steps.push("alphafox auth login --browser --format json --no-input", "alphafox auth login --no-wait --format json --no-input");
     }
-    steps.push("alphafox doctor --format json --no-input", `Agent 安装指南：${types_1.AGENT_INSTALL_GUIDE_BLOB_URL}`);
+    steps.push("alphafox doctor --format json --no-input", `Agent 安装指南：${types_1.AGENT_INSTALL_GUIDE_BLOB_URL}`, "登录并重启后，按 alphafox skill 的 After install 向用户展示新人引导。");
     if (input.dryRun) {
         steps.unshift("这是 --dry-run，去掉该参数再运行才会真正安装。");
     }
@@ -218,30 +217,7 @@ async function stepInstallSkills(flags, runner) {
         ? `将同步 Skills ${manifest.packageVersion}（${source}）`
         : `正在同步 AI Skills ${manifest.packageVersion}…`);
     try {
-        const result = await (0, manager_1.syncSkills)({
-            manifest,
-            packageRoot: source,
-            installedRoot: (0, run_command_1.installedSkillsRoot)(runner.env),
-            statePath: (0, run_command_1.skillsStatePath)(runner.env),
-            dryRun: flags.dryRun,
-            force: false,
-        }, {
-            install: async (names) => {
-                await runner.exec("npx", [
-                    "-y",
-                    "skills",
-                    "add",
-                    source,
-                    "-y",
-                    "-g",
-                    "--skill",
-                    ...names,
-                ], { timeoutMs: SKILLS_TIMEOUT_MS });
-            },
-            remove: async (names) => {
-                await runner.exec("npx", ["-y", "skills", "remove", ...names, "-y", "-g"], { timeoutMs: SKILLS_TIMEOUT_MS });
-            },
-        });
+        const result = await (0, run_command_1.syncCurrentSkills)({ force: false, dryRun: flags.dryRun }, runner.env, { runner, packageRoot: source });
         const action = result.blocked.length > 0
             ? "blocked"
             : result.action === "planned"
@@ -268,6 +244,7 @@ async function stepInstallSkills(flags, runner) {
             removed: result.removed,
             blocked: result.blocked,
             backupDir: result.backupDir,
+            agentLinks: result.status.agentLinks,
             restartRequired: result.restartRequired,
         };
     }

package/dist/skills/agent-links.d.ts

@@ -0,0 +1,29 @@
+import { type AgentSkillLinkStatus, type SkillsStatus, type SkillsSyncResult } from "./manager";
+export interface AgentSkillTarget {
+    readonly id: "claude-code" | "cursor" | "codex";
+    readonly required: boolean;
+    readonly home: string;
+    readonly skillsDir: string;
+}
+export interface AgentLinkChange {
+    readonly agent: AgentSkillTarget["id"];
+    readonly name: string;
+}
+export interface AgentLinkInput {
+    readonly canonicalRoot: string;
+    readonly skillNames: readonly string[];
+    readonly homeDir: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export declare function agentHomeDir(env?: NodeJS.ProcessEnv): string;
+export declare function resolveAgentSkillTargets(homeDir: string, env?: NodeJS.ProcessEnv): readonly AgentSkillTarget[];
+export declare function inspectAgentLinks(input: AgentLinkInput): readonly AgentSkillLinkStatus[];
+export declare function ensureAgentLinks(input: AgentLinkInput): readonly AgentLinkChange[];
+export declare function removeAgentLinks(input: AgentLinkInput): void;
+export declare function attachAgentLinks(status: SkillsStatus, env?: NodeJS.ProcessEnv): SkillsStatus;
+export declare function applyAgentLinkPass(result: SkillsSyncResult, input: {
+    readonly dryRun: boolean;
+    readonly env: NodeJS.ProcessEnv;
+    readonly canonicalRoot: string;
+}): SkillsSyncResult;
+export declare function agentLinksNeedWork(agentLinks: readonly AgentSkillLinkStatus[]): boolean;

package/dist/skills/agent-links.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentHomeDir = agentHomeDir;
+exports.resolveAgentSkillTargets = resolveAgentSkillTargets;
+exports.inspectAgentLinks = inspectAgentLinks;
+exports.ensureAgentLinks = ensureAgentLinks;
+exports.removeAgentLinks = removeAgentLinks;
+exports.attachAgentLinks = attachAgentLinks;
+exports.applyAgentLinkPass = applyAgentLinkPass;
+exports.agentLinksNeedWork = agentLinksNeedWork;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const manager_1 = require("./manager");
+function agentHomeDir(env = process.env) {
+    return env.ALPHAFOX_AGENT_HOME?.trim() || (0, node_os_1.homedir)();
+}
+function resolveAgentSkillTargets(homeDir, env = process.env) {
+    const claudeHome = env.CLAUDE_CONFIG_DIR?.trim() || (0, node_path_1.join)(homeDir, ".claude");
+    const cursorHome = (0, node_path_1.join)(homeDir, ".cursor");
+    const codexHome = env.CODEX_HOME?.trim() || (0, node_path_1.join)(homeDir, ".codex");
+    return [
+        {
+            id: "claude-code",
+            required: true,
+            home: claudeHome,
+            skillsDir: (0, node_path_1.join)(claudeHome, "skills"),
+        },
+        {
+            id: "cursor",
+            required: false,
+            home: cursorHome,
+            skillsDir: (0, node_path_1.join)(cursorHome, "skills"),
+        },
+        {
+            id: "codex",
+            required: false,
+            home: codexHome,
+            skillsDir: (0, node_path_1.join)(codexHome, "skills"),
+        },
+    ];
+}
+function inspectAgentLinks(input) {
+    return activeTargets(input).map((target) => classifyTarget(target, input));
+}
+function ensureAgentLinks(input) {
+    const created = [];
+    for (const status of inspectAgentLinks(input)) {
+        if (status.missing.length === 0)
+            continue;
+        (0, node_fs_1.mkdirSync)(status.skillsDir, { recursive: true });
+        for (const name of status.missing) {
+            linkSkillDir((0, node_path_1.join)(input.canonicalRoot, name), (0, node_path_1.join)(status.skillsDir, name));
+            created.push({ agent: status.id, name });
+        }
+    }
+    return created;
+}
+function removeAgentLinks(input) {
+    for (const target of activeTargets(input)) {
+        for (const name of input.skillNames) {
+            const dest = (0, node_path_1.join)(target.skillsDir, name);
+            if (!lexists(dest))
+                continue;
+            if (!isOurAgentLink(dest, (0, node_path_1.join)(input.canonicalRoot, name)))
+                continue;
+            (0, node_fs_1.unlinkSync)(dest);
+        }
+    }
+}
+function attachAgentLinks(status, env = process.env) {
+    const skillNames = status.skills
+        .filter((skill) => skill.status !== "missing")
+        .map((skill) => skill.name);
+    const agentLinks = inspectAgentLinks({
+        canonicalRoot: status.installedRoot,
+        skillNames,
+        homeDir: agentHomeDir(env),
+        env,
+    });
+    return {
+        ...status,
+        agentLinks,
+        restartRequired: status.restartRequired || agentLinksNeedWork(agentLinks),
+    };
+}
+function applyAgentLinkPass(result, input) {
+    const skillNames = result.status.skills
+        .filter((skill) => skill.status !== "missing")
+        .map((skill) => skill.name);
+    const linkInput = {
+        canonicalRoot: input.canonicalRoot,
+        skillNames,
+        homeDir: agentHomeDir(input.env),
+        env: input.env,
+    };
+    const created = input.dryRun ? [] : ensureAgentLinks(linkInput);
+    const status = attachAgentLinks(result.status, input.env);
+    if (!input.dryRun && agentLinksNeedWork(status.agentLinks)) {
+        throw Object.assign(new Error(`Failed to link Skills into Agent directories: ${missingAgentSummary(status.agentLinks)}`), {
+            type: "install",
+            subtype: "skills_agent_link_failed",
+            details: status.agentLinks.filter((item) => item.missing.length > 0),
+        });
+    }
+    const linked = created.length > 0 || agentLinksNeedWork(status.agentLinks);
+    return {
+        ...result,
+        status,
+        action: nextSyncAction(result.action, linked, input.dryRun),
+        restartRequired: result.restartRequired || linked,
+    };
+}
+function agentLinksNeedWork(agentLinks) {
+    return agentLinks.some((item) => item.missing.length > 0);
+}
+function activeTargets(input) {
+    return resolveAgentSkillTargets(input.homeDir, input.env ?? {}).filter((target) => target.required || (0, node_fs_1.existsSync)(target.home));
+}
+function classifyTarget(target, input) {
+    const linked = [];
+    const missing = [];
+    const blocked = [];
+    for (const name of input.skillNames) {
+        const state = classifyLink((0, node_path_1.join)(input.canonicalRoot, name), (0, node_path_1.join)(target.skillsDir, name));
+        if (state === "linked")
+            linked.push(name);
+        else if (state === "blocked")
+            blocked.push(name);
+        else
+            missing.push(name);
+    }
+    return {
+        id: target.id,
+        skillsDir: target.skillsDir,
+        linked,
+        missing,
+        blocked,
+    };
+}
+function classifyLink(canonical, dest) {
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(canonical, "SKILL.md")))
+        return "missing";
+    if ((0, node_path_1.resolve)(canonical) === (0, node_path_1.resolve)(dest))
+        return "linked";
+    if (!lexists(dest) || isBrokenSymlink(dest))
+        return "missing";
+    if (isOurAgentLink(dest, canonical))
+        return "linked";
+    return "blocked";
+}
+function isOurAgentLink(dest, canonical) {
+    if (pointsAtCanonical(dest, canonical))
+        return true;
+    try {
+        const stat = (0, node_fs_1.lstatSync)(dest);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            return false;
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(dest, "SKILL.md")))
+            return false;
+        return (0, manager_1.hashSkillDirectory)(dest) === (0, manager_1.hashSkillDirectory)(canonical);
+    }
+    catch {
+        return false;
+    }
+}
+function pointsAtCanonical(dest, canonical) {
+    try {
+        if ((0, node_fs_1.lstatSync)(dest).isSymbolicLink()) {
+            const resolved = (0, node_path_1.resolve)((0, node_path_1.dirname)(dest), (0, node_fs_1.readlinkSync)(dest));
+            if ((0, node_path_1.resolve)(resolved) === (0, node_path_1.resolve)(canonical))
+                return true;
+        }
+    }
+    catch {
+        // Compare real paths below when the symlink metadata is unreadable.
+    }
+    try {
+        return (0, node_fs_1.realpathSync)(dest) === (0, node_fs_1.realpathSync)(canonical);
+    }
+    catch {
+        return false;
+    }
+}
+function linkSkillDir(canonical, dest) {
+    if (isBrokenSymlink(dest))
+        (0, node_fs_1.unlinkSync)(dest);
+    (0, node_fs_1.symlinkSync)(canonical, dest, process.platform === "win32" ? "junction" : undefined);
+}
+function lexists(path) {
+    try {
+        (0, node_fs_1.lstatSync)(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBrokenSymlink(path) {
+    try {
+        return (0, node_fs_1.lstatSync)(path).isSymbolicLink() && !(0, node_fs_1.existsSync)(path);
+    }
+    catch {
+        return false;
+    }
+}
+function nextSyncAction(action, linked, dryRun) {
+    if (!linked || action !== "skipped")
+        return action;
+    return dryRun ? "planned" : "synced";
+}
+function missingAgentSummary(agentLinks) {
+    return agentLinks
+        .filter((item) => item.missing.length > 0)
+        .map((item) => `${item.id} (${item.missing.join(", ")})`)
+        .join("; ");
+}

package/dist/skills/manager.d.ts

@@ -39,6 +39,13 @@ export interface InspectedSkill {
     readonly status: SkillStatus;
     readonly managed: boolean;
 }
+export interface AgentSkillLinkStatus {
+    readonly id: "claude-code" | "cursor" | "codex";
+    readonly skillsDir: string;
+    readonly linked: readonly string[];
+    readonly missing: readonly string[];
+    readonly blocked: readonly string[];
+}
 export interface SkillsStatus {
     readonly bundleVersion: string;
     readonly contractVersion: string;
@@ -52,6 +59,7 @@ export interface SkillsStatus {
         readonly modified: boolean;
     }[];
     readonly summary: Readonly<Record<SkillStatus, number>>;
+    readonly agentLinks: readonly AgentSkillLinkStatus[];
     readonly restartRequired: boolean;
 }
 export interface SkillsSyncResult {

package/dist/skills/manager.js

@@ -183,6 +183,7 @@ function inspectSkills(input) {
         skills,
         orphans,
         summary,
+        agentLinks: [],
         restartRequired: summary.missing + summary.stale + summary.modified + orphans.length > 0,
     };
 }

package/dist/skills/run-command.js

@@ -12,6 +12,7 @@ const profiles_1 = require("../config/profiles");
 const envelope_1 = require("../envelope");
 const exec_1 = require("../install/exec");
 const package_root_1 = require("../install/package-root");
+const agent_links_1 = require("./agent-links");
 const manager_1 = require("./manager");
 const SKILLS_TIMEOUT_MS = 120_000;
 function installedSkillsRoot(env = process.env) {
@@ -33,25 +34,34 @@ function resolveCurrentSkillsPackageRoot(searchDirs = [__dirname, process.cwd()]
 }
 function inspectCurrentSkills(env = process.env, packageRoot = resolveCurrentSkillsPackageRoot()) {
     const manifest = (0, manager_1.loadAndVerifySkillsManifest)(packageRoot);
-    return (0, manager_1.inspectSkills)({
+    return (0, agent_links_1.attachAgentLinks)((0, manager_1.inspectSkills)({
         manifest,
         installedRoot: installedSkillsRoot(env),
         state: (0, manager_1.loadSkillsState)(skillsStatePath(env)),
-    });
+    }), env);
 }
 async function syncCurrentSkills(input, env = process.env, deps = {}) {
     const packageRoot = deps.packageRoot ?? resolveCurrentSkillsPackageRoot();
     const runner = deps.runner ??
         (0, exec_1.createDefaultInstallRunner)(env, [__dirname, process.cwd()]);
+    const canonicalRoot = installedSkillsRoot(env);
     const manifest = (0, manager_1.loadAndVerifySkillsManifest)(packageRoot);
-    return await (0, manager_1.syncSkills)({
+    const result = await (0, manager_1.syncSkills)({
         manifest,
         packageRoot,
-        installedRoot: installedSkillsRoot(env),
+        installedRoot: canonicalRoot,
         statePath: skillsStatePath(env),
         dryRun: input.dryRun,
         force: input.force,
-    }, {
+    }, skillsBundleDeps(runner, packageRoot, canonicalRoot, env));
+    return (0, agent_links_1.applyAgentLinkPass)(result, {
+        dryRun: input.dryRun,
+        env,
+        canonicalRoot,
+    });
+}
+function skillsBundleDeps(runner, packageRoot, canonicalRoot, env) {
+    return {
         install: async (names) => {
             await runner.exec("npx", [
                 "-y",
@@ -66,8 +76,14 @@ async function syncCurrentSkills(input, env = process.env, deps = {}) {
         },
         remove: async (names) => {
             await runner.exec("npx", ["-y", "skills", "remove", ...names, "-y", "-g"], { timeoutMs: SKILLS_TIMEOUT_MS });
+            (0, agent_links_1.removeAgentLinks)({
+                canonicalRoot,
+                skillNames: names,
+                homeDir: (0, agent_links_1.agentHomeDir)(env),
+                env,
+            });
         },
-    });
+    };
 }
 async function cmdSkills(args, flags, env = process.env, deps = {}) {
     const parsed = parseSkillsArgs(args);
@@ -81,6 +97,7 @@ async function cmdSkills(args, flags, env = process.env, deps = {}) {
             ],
             notes: [
                 "Skills are synced only from the verified bundle inside the installed @alphafox/cli package",
+                "Sync also links Skills into ~/.claude/skills (and ~/.cursor/skills, ~/.codex/skills when those agents are present)",
                 "Modified Skills are preserved unless --force --yes is explicit",
                 "Restart the AI tool after a successful sync",
             ],

package/dist/skills-manifest.json

@@ -1,153 +1,153 @@
 {
   "schemaVersion": 1,
   "packageName": "@alphafox/cli",
-  "packageVersion": "0.3.11",
+  "packageVersion": "0.3.13",
   "contractVersion": "2026-08-13",
-  "bundleHash": "10abd3fc0d5bbd4a260f42a02bff35899e829543419cf0f678077546a7bebcc6",
+  "bundleHash": "6957fd9e293dff1afdc94922f9947590398cff0743f99eba5a2b2abb215df12c",
   "skills": [
     {
       "name": "alphafox",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "ebc6138b666514ef543cf5b444d3ff293bd439eae5c39a231fada5b4dae27b11",
-          "size": 4408
+          "sha256": "9662240fd4497442711c155723e94ae60a9de84d2f433bbfac81a25d11caf9bd",
+          "size": 7426
         }
       ],
-      "hash": "c4c73d98a0ad828e66fccb406294ab3533530b1d003c71eebd9e569895cbf305"
+      "hash": "8d4578a474c6063ff13ea22c45f9e2d75c1ab518567e077d838bd1bef6ec566e"
     },
     {
       "name": "alphafox-account",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "714b3f0094a67bc08764ae26f900e3f61463950b2a031f4b46a478a968deea74",
+          "sha256": "74fa3573aa94a54d995f8f78412a06269fc3ef903009f8b7b590f87a23ef2271",
           "size": 784
         }
       ],
-      "hash": "94085eb4ec63d15a217df97878282c7f0c1e59c93dfd34e26279113cdcc7b625"
+      "hash": "3f2644be04b0e3b1b4f4bc9c6f47708cb7576c715d50a8ac6d3ccc7143c75565"
     },
     {
       "name": "alphafox-admin",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "dcdd0cdd11e6c4160e314766b7150b70fb0b0b6b52b4ad65723853c0ccefdd93",
+          "sha256": "7fe8f8aa9f0031c46e3b0f5989eb5964fe0d64fc4be3d3ea187ebd11f8fde729",
           "size": 788
         }
       ],
-      "hash": "38f9a8eff99035a55e40e96bd156d407282aa09adcf0c08b7713b18508c112dc"
+      "hash": "c0bf71914f23455168a3d7e0471a107f8d92de8c2edb958c4749d61ed413d418"
     },
     {
       "name": "alphafox-auth",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "1cc9b91b9f3994d3f0fde453fba4c08c0ff18849692518c1a73182cfc6267066",
+          "sha256": "f76da1d4e97f3bc7d71afe9487de0e87258afc0e5de85e3cee588b656dfcfef7",
           "size": 2371
         }
       ],
-      "hash": "f14d148e80c7c25b9306e57039e10b341b04c06fbe8c0602b60d49033436a149"
+      "hash": "d2fafe541e2be36e4672ad9ee9473113d8f4f4649247148ff5daacc2dfaefd21"
     },
     {
       "name": "alphafox-cache",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "292e0075bd55f5036a6bcb3afbc6184f5e010e4840b80c1940bbaa51bf8f2a9e",
+          "sha256": "da4cd692abb0e5a62a892b8e8c30cb39c0c77c14ec5f388bdfccf3a692a06d0b",
           "size": 1530
         }
       ],
-      "hash": "4baa604211122515fa189bb5830d4b4b0633a92b585fd91b918879828d221740"
+      "hash": "bb6ee2004dc699d0392fedefd046520db202fffae856bc665bf6d79b21c2d26f"
     },
     {
       "name": "alphafox-engine-backtest",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "a0e00cdd48c4c4da1bbbe0d54f2b08dda273e6b6d7160e5a37485e7002218d05",
+          "sha256": "fbdf4e90837243fa7c4385e2078b4b80f6a8e0b1df97f5477ef69a9dfb340fef",
           "size": 8278
         }
       ],
-      "hash": "49f17cdd45fef3c600ee954bb089b239609228dd205f12edad8973c6e2a13fba"
+      "hash": "d0222abf0dbced2551c049483d8381ff85f8ab36e9b89f44dca65adbaaf301d9"
     },
     {
       "name": "alphafox-exchange",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "e883d53ce237ecec682555c9171519bf16139fee0db968825a47d8cfc4ccb25b",
+          "sha256": "a82200ac4fd9b1ebb07f2be560f484e4cc39a5b6365b1cf8f09da237206b3b9f",
           "size": 744
         }
       ],
-      "hash": "087f26e565876d66709fb303cc6e379648a1b7de6f9f54c4015e973b8398fcb8"
+      "hash": "49168e1b6cf992d1a357dd2e86a1cc2a41466aa3cb0c17cc058ef75027d309bb"
     },
     {
       "name": "alphafox-market",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "d37df5d1498d201abd9206f5536ffbbf35fa20ec7f47aa20da40f07abcd3f847",
+          "sha256": "a824b1a49a29cb36f0a9c1d74187420f570137566f3a74f1685a38f7c1023032",
           "size": 3079
         }
       ],
-      "hash": "dc57e16172f577410f80922436593ab5ac5d1d2ab62402fb2c8ee7d8bac84cbd"
+      "hash": "4d5fb1a2e765811c504decf024ab6260969486776b42da1534f977e238ca399b"
     },
     {
       "name": "alphafox-notification",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "0fdcc37a21deaee5195c2576ce563b895dc7aac2af2e269a38b2506860fbb5fc",
+          "sha256": "2425c81589f89db06eb361f61d3bcf817ed862a42d00174d31005385b736b681",
           "size": 699
         }
       ],
-      "hash": "c4acd5b245e6c1f21f1d35d96a33ffe8c1a4754c8405c92c54180765f14072ea"
+      "hash": "1d2d4243dba2410517c0d5add310709f20a3642bc5206e777bccd200d2fcb7ad"
     },
     {
       "name": "alphafox-shared",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "cfd0716870fb6bcadbb20c7cad1999f32f8f237cfebb1fa143f6a49687256568",
-          "size": 5386
+          "sha256": "895d98df84caa7813ed4083d23124bbb9572a93036578fdbaacb02574c29317d",
+          "size": 5960
         }
       ],
-      "hash": "939e048cd4243a13a341d0405a13f40d82dd6553a2db5e42765d90dae909331d"
+      "hash": "df50ec696f3b3e4f58cc2f66b2ded0d4dd5b898e2a6aa822eb779f978d04062d"
     },
     {
       "name": "alphafox-strategy",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "be35901e6d5c3766f73274552e5403e172a9c3ce9d560fbfd78cb68fd1c894c1",
-          "size": 1827
+          "sha256": "ebf636f9d4656f98e9c5ba3ba7c00f0816d5e564dece2fbab3242ccd1138f325",
+          "size": 4398
         }
       ],
-      "hash": "e031e199ee2c1013e2bc39d2fc2a72b9f734ede86b3ca93d2a3ca53ace1c65cf"
+      "hash": "4b4fcc5c20337ab2c50499bd58c33c5c0bf3eb167c48f2a53aa48ab06cedba5a"
     },
     {
       "name": "alphafox-trading",
-      "version": "0.3.11",
+      "version": "0.3.13",
       "files": [
         {
           "path": "SKILL.md",
-          "sha256": "2bac318aae54820edf6454c98e8ce4a16b350fce8e0e29c936ea434a72a0857d",
+          "sha256": "da1c8504eafcd201b8b0d6a06ab2c3ac19185c03a60c723ef8cb7e1d06213ca8",
           "size": 3123
         }
       ],
-      "hash": "2da4c6f7a381472f1d82118d5e44e3c52a1a6e7185b2f9e5a16181aa5f1c89bd"
+      "hash": "154e7456e7abceacff29feeb082365fd81ed528004ebcb7899485a2dfef37f51"
     }
   ]
 }