@alphafox/cli 0.3.3 → 0.3.5

package/dist/engine-backtest/sweep-kernel/results.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSweepMetrics = extractSweepMetrics;
+exports.selectBestNonLiquidatedPoint = selectBestNonLiquidatedPoint;
+exports.resolveIslandRiskLevel = resolveIslandRiskLevel;
+exports.analyzeSweepIsland = analyzeSweepIsland;
+function extractSweepMetrics(source) {
+    return {
+        returnPct: source.returnPct,
+        maxDrawdownPct: source.maxDrawdownPct,
+        sharpeRatio: source.sharpeRatio,
+        winRatePct: source.winRatePct,
+        ...(source.maxLeverage === undefined
+            ? {}
+            : { maxLeverage: source.maxLeverage }),
+        liquidationCount: typeof source.liquidationCount === "number" &&
+            Number.isFinite(source.liquidationCount)
+            ? source.liquidationCount
+            : source.liquidated
+                ? 1
+                : 0,
+        netPnl: source.netPnl,
+        finalEquity: source.finalEquity,
+        tradeCount: source.tradeCount,
+    };
+}
+function selectBestNonLiquidatedPoint(points) {
+    const candidates = points.filter(isOkNonLiquidatedPoint);
+    if (candidates.length === 0) {
+        return null;
+    }
+    const best = candidates.reduce((leader, point) => point.metrics.returnPct > leader.metrics.returnPct ? point : leader);
+    return {
+        coordinate: best.coordinate,
+        returnPct: best.metrics.returnPct,
+    };
+}
+function resolveIslandRiskLevel(score) {
+    if (score >= 80) {
+        return "high";
+    }
+    if (score >= 50) {
+        return "medium";
+    }
+    if (score >= 30) {
+        return "low_medium";
+    }
+    return "low";
+}
+/**
+ * Score each swept point by how sharply it deviates from its neighbors, then
+ * flag the point closest to `centerValue` when it sits on a fragile island.
+ */
+function analyzeSweepIsland(points, centerValue) {
+    const rows = [...points].sort((left, right) => left.value - right.value);
+    if (rows.length === 0) {
+        return {
+            points: [],
+            warning: null,
+            overallScore: 0,
+            overallRiskLevel: "low",
+        };
+    }
+    const returnStd = populationStd(rows.map((row) => row.returnPct));
+    const drawdownStd = populationStd(rows.map((row) => row.maxDrawdownPct));
+    const centerIndex = rows.reduce((bestIndex, row, index) => Math.abs(row.value - centerValue) <
+        Math.abs(rows[bestIndex].value - centerValue)
+        ? index
+        : bestIndex, 0);
+    const scored = rows.map((row, index) => {
+        const neighbors = [index - 1, index + 1]
+            .filter((i) => i >= 0 && i < rows.length)
+            .map((i) => rows[i]);
+        const score = scoreNeighborhood(row, neighbors, returnStd, drawdownStd);
+        return {
+            ...row,
+            isCenter: index === centerIndex,
+            islandScore: Number(score.toFixed(2)),
+            riskLevel: resolveIslandRiskLevel(score),
+        };
+    });
+    const center = scored[centerIndex];
+    const centerNeighbors = [centerIndex - 1, centerIndex + 1]
+        .filter((i) => i >= 0 && i < scored.length)
+        .map((i) => scored[i]);
+    const hasLiquidationJump = center.liquidationCount === 0 &&
+        centerNeighbors.some((row) => row.liquidationCount > 0);
+    const warning = hasLiquidationJump || center.islandScore >= 50
+        ? {
+            centerValue: center.value,
+            islandScore: center.islandScore,
+            riskLevel: center.riskLevel,
+            counterexamples: centerNeighbors
+                .filter((row) => row.liquidationCount > center.liquidationCount)
+                .map((row) => ({
+                counterValue: row.value,
+                centerReturnPct: center.returnPct,
+                counterReturnPct: row.returnPct,
+                centerLiquidationCount: center.liquidationCount,
+                counterLiquidationCount: row.liquidationCount,
+            })),
+        }
+        : null;
+    const overallScore = scored.reduce((highest, row) => Math.max(highest, row.islandScore), 0);
+    return {
+        points: scored,
+        warning,
+        overallScore,
+        overallRiskLevel: resolveIslandRiskLevel(overallScore),
+    };
+}
+function isOkNonLiquidatedPoint(point) {
+    return (point.status === "ok" &&
+        point.metrics !== undefined &&
+        Number.isFinite(point.metrics.returnPct) &&
+        Number.isFinite(point.metrics.liquidationCount) &&
+        point.metrics.liquidationCount === 0);
+}
+function scoreNeighborhood(row, neighbors, returnStd, drawdownStd) {
+    if (neighbors.length === 0) {
+        return 0;
+    }
+    const neighborReturn = average(neighbors.map((n) => n.returnPct));
+    const neighborDrawdown = average(neighbors.map((n) => n.maxDrawdownPct));
+    const neighborLiquidations = average(neighbors.map((n) => n.liquidationCount));
+    const returnAdvantage = (Math.min(Math.max(row.returnPct - neighborReturn, 0) / Math.max(returnStd, 0.5), 2) /
+        2) *
+        100;
+    const drawdownAdvantage = (Math.min(Math.max(neighborDrawdown - row.maxDrawdownPct, 0) /
+        Math.max(drawdownStd, 0.1), 2) /
+        2) *
+        100;
+    const liquidationJump = (Math.min(Math.max(neighborLiquidations - row.liquidationCount, 0), 3) /
+        3) *
+        100;
+    return (0.35 * returnAdvantage + 0.3 * drawdownAdvantage + 0.25 * liquidationJump);
+}
+function average(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function populationStd(values) {
+    if (values.length < 2) {
+        return 0;
+    }
+    const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+    return Math.sqrt(values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length);
+}

package/dist/engine-backtest/sweep-kernel/session.d.ts

@@ -0,0 +1,55 @@
+export type SweepExecutionState = {
+    readonly status: "idle";
+} | {
+    readonly status: "running";
+    readonly total: number;
+} | {
+    readonly status: "succeeded";
+    readonly resultId: string;
+} | {
+    readonly status: "failed";
+    readonly message: string;
+} | {
+    readonly status: "cancelled";
+};
+export type SweepCloudSaveState = {
+    readonly status: "idle";
+} | {
+    readonly status: "saving";
+} | {
+    readonly status: "saved";
+    readonly sweepId: string;
+} | {
+    readonly status: "failed";
+    readonly message: string;
+};
+export interface SweepSessionState {
+    readonly execution: SweepExecutionState;
+    readonly cloudSave: SweepCloudSaveState;
+}
+export type SweepSessionEvent = {
+    readonly type: "execution-started";
+    readonly total: number;
+} | {
+    readonly type: "execution-succeeded";
+    readonly resultId: string;
+} | {
+    readonly type: "execution-failed";
+    readonly message: string;
+} | {
+    readonly type: "execution-cancelled";
+} | {
+    readonly type: "execution-reset";
+} | {
+    readonly type: "cloud-save-started";
+} | {
+    readonly type: "cloud-save-succeeded";
+    readonly sweepId: string;
+} | {
+    readonly type: "cloud-save-failed";
+    readonly message: string;
+} | {
+    readonly type: "cloud-save-retry";
+};
+export declare function createSweepSessionState(): SweepSessionState;
+export declare function reduceSweepSession(state: SweepSessionState, event: SweepSessionEvent): SweepSessionState;

package/dist/engine-backtest/sweep-kernel/session.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSweepSessionState = createSweepSessionState;
+exports.reduceSweepSession = reduceSweepSession;
+const IDLE_CLOUD_SAVE = { status: "idle" };
+function createSweepSessionState() {
+    return {
+        execution: { status: "idle" },
+        cloudSave: IDLE_CLOUD_SAVE,
+    };
+}
+function reduceSweepSession(state, event) {
+    switch (event.type) {
+        case "execution-started":
+            return {
+                execution: { status: "running", total: event.total },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-succeeded":
+            return {
+                execution: { status: "succeeded", resultId: event.resultId },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-failed":
+            return {
+                execution: { status: "failed", message: event.message },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-cancelled":
+            return {
+                execution: { status: "cancelled" },
+                cloudSave: IDLE_CLOUD_SAVE,
+            };
+        case "execution-reset":
+            return createSweepSessionState();
+        case "cloud-save-started":
+        case "cloud-save-retry":
+            return applyCloudSave(state, { status: "saving" });
+        case "cloud-save-succeeded":
+            return applyCloudSave(state, {
+                status: "saved",
+                sweepId: event.sweepId,
+            });
+        case "cloud-save-failed":
+            return applyCloudSave(state, {
+                status: "failed",
+                message: event.message,
+            });
+    }
+}
+function applyCloudSave(state, cloudSave) {
+    if (state.execution.status !== "succeeded") {
+        return state;
+    }
+    return { ...state, cloudSave };
+}

package/dist/engine-backtest/sweep-kernel/types.d.ts

@@ -0,0 +1,36 @@
+export type SweepSubscriptionTier = "free" | "pro" | "pro_max";
+export type SweepSearchMode = "standard" | "fast";
+export interface SweepCoordinate {
+    readonly values: readonly number[];
+}
+export interface SweepAxisWindow {
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+}
+/** Explicit values, or a min/max/step window around the current value. */
+export interface SweepAxisInput {
+    readonly path: readonly string[];
+    readonly current: number;
+    readonly isInteger: boolean;
+    readonly min?: number;
+    readonly max?: number;
+    readonly minExclusive?: boolean;
+    readonly maxExclusive?: boolean;
+    readonly values?: readonly number[];
+    readonly window?: SweepAxisWindow;
+}
+export interface SweepPlanAxis {
+    readonly path: readonly string[];
+    readonly current: number;
+    readonly values: readonly number[];
+}
+export interface SweepPlan {
+    readonly axes: readonly SweepPlanAxis[];
+    readonly coordinates: readonly SweepCoordinate[];
+    readonly requestedCombinationCount: number;
+    readonly sampled: boolean;
+}
+export type SweepConfigRecord = {
+    readonly [key: string]: unknown;
+};

package/dist/engine-backtest/sweep-kernel/types.js

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

package/dist/engine-backtest/types.d.ts

@@ -34,6 +34,14 @@ export interface EngineBacktestRunArgs {
     /** Replay/download bar. Defaults to 1m; never finer. */
     readonly replayTimeframe: string;
 }
+export type SweepMode = "neighborhood" | "range";
+export type SweepSearchMode = "standard" | "fast";
+export interface EngineBacktestSweepArgs extends EngineBacktestRunArgs {
+    readonly axesRaw?: string;
+    readonly mode: SweepMode;
+    readonly searchMode: SweepSearchMode;
+    readonly concurrency: number;
+}
 export interface EngineBacktestSeriesRequirement {
     readonly symbol: string;
     readonly timeframe: string;
@@ -105,6 +113,37 @@ export interface EngineBacktestResult {
     }>;
     readonly warnings?: string[];
 }
+export interface EngineBacktestBatchVariant {
+    readonly runId: string;
+    readonly config: unknown;
+}
+export interface EngineBacktestBatchRequest {
+    readonly version: 1;
+    readonly batchId: string;
+    readonly baseScenario: Omit<EngineBacktestScenario, "tape">;
+    readonly variants: readonly EngineBacktestBatchVariant[];
+    readonly tape: EngineBacktestTapeInput;
+}
+export interface EngineBacktestBatchPointResult {
+    readonly runId: string;
+    readonly status: "completed" | "failed";
+    readonly metrics: EngineBacktestMetrics;
+    readonly errors?: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+}
+export interface EngineBacktestBatchResult {
+    readonly batchId: string;
+    readonly status: "completed" | "failed";
+    readonly results: readonly EngineBacktestBatchPointResult[];
+    readonly errors?: Array<{
+        code: string;
+        message: string;
+        path?: string;
+    }>;
+}
 export interface EngineBacktestSupportReason {
     readonly code: string;
     readonly message: string;
@@ -180,6 +219,7 @@ export interface BacktestClientLike {
         readonly config: unknown;
     }): Promise<EngineBacktestPlan | EngineBacktestFailure>;
     runBacktest(scenario: EngineBacktestScenario, buffers: Record<string, ArrayBuffer>, onProgress?: (fraction: number) => void): Promise<EngineBacktestResult>;
+    runBacktestBatch(batch: EngineBacktestBatchRequest, buffers: Record<string, ArrayBuffer>, onProgress?: (fraction: number) => void): Promise<EngineBacktestBatchResult>;
     terminate(): void;
 }
 export interface BacktestWasmModule {
@@ -237,6 +277,8 @@ export interface CreateRunRequestBody {
     readonly metrics: EngineBacktestMetrics;
     readonly engineVersion: string;
     readonly configSchemaVersion: number;
+    /** Compact [[unix_ms, cumulative_return]]; omitted when the local run has no series. */
+    readonly returnCurve?: ReadonlyArray<readonly [number, number]>;
 }
 export interface EngineBacktestRunSuccess {
     readonly metrics: EngineBacktestMetrics;
@@ -247,3 +289,91 @@ export interface EngineBacktestRunSuccess {
     readonly persisted: boolean;
     readonly coverageWarnings: readonly string[];
 }
+export interface EngineBacktestSweepPointRow {
+    readonly coordinate: {
+        readonly values: readonly number[];
+    };
+    readonly status: "ok" | "failed";
+    readonly metrics?: {
+        readonly returnPct: number;
+        readonly maxDrawdownPct: number;
+        readonly sharpeRatio: number;
+        readonly winRatePct: number;
+        readonly maxLeverage?: number;
+        readonly liquidationCount: number;
+        readonly netPnl: number;
+        readonly finalEquity: number;
+        readonly tradeCount: number;
+    };
+    readonly error?: string;
+}
+export interface CreateSweepPointSummary {
+    readonly coordinate: {
+        readonly values: readonly number[];
+    };
+    readonly status: "ok" | "failed";
+    readonly error?: string;
+    readonly metrics?: EngineBacktestSweepPointRow["metrics"];
+}
+export interface CreateSweepRequestBody {
+    readonly clientSweepId: string;
+    readonly baseInputSnapshot: PersistedSnapshot;
+    readonly axes: ReadonlyArray<{
+        readonly path: readonly string[];
+        readonly current: number;
+        readonly values: readonly number[];
+    }>;
+    readonly searchMetadata: {
+        readonly mode: SweepMode;
+        readonly searchMode: SweepSearchMode;
+        readonly concurrency: number;
+        readonly requestedCombinationCount: number;
+        readonly sampled: boolean;
+    };
+    readonly aggregateSummary: {
+        readonly successfulCount: number;
+        readonly failedCount: number;
+        readonly liquidatedCount: number;
+        readonly elapsedMs: number;
+        readonly best: {
+            readonly coordinate: {
+                readonly values: readonly number[];
+            };
+            readonly returnPct: number;
+        } | null;
+    };
+    readonly pointSummaries: readonly CreateSweepPointSummary[];
+    readonly engineVersion: string;
+    readonly configSchemaVersion: number;
+}
+export interface EngineBacktestSweepSuccess {
+    readonly persisted: boolean;
+    readonly sweepId?: string;
+    readonly clientSweepId?: string;
+    readonly mode: SweepMode;
+    readonly searchMode: SweepSearchMode;
+    readonly requestedCombinationCount: number;
+    readonly sampled: boolean;
+    readonly combinationCount: number;
+    readonly successfulCount: number;
+    readonly failedCount: number;
+    readonly liquidatedCount: number;
+    readonly elapsedMs: number;
+    readonly best: {
+        readonly coordinate: {
+            readonly values: readonly number[];
+        };
+        readonly returnPct: number;
+        readonly config: unknown;
+    } | null;
+    readonly points: readonly EngineBacktestSweepPointRow[];
+    readonly engineVersion: string;
+    readonly experimentId?: string;
+    readonly experimentUrl?: string;
+    readonly coverageWarnings: readonly string[];
+    readonly axes: ReadonlyArray<{
+        readonly path: readonly string[];
+        readonly current: number;
+        readonly values: readonly number[];
+    }>;
+}

package/dist/index.d.ts

@@ -17,3 +17,6 @@ export { validateCatalogWriteBody } from "./catalog/validate-body";
 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 { inspectCurrentSkills, installedSkillsRoot, skillsStatePath, syncCurrentSkills, } from "./skills/run-command";
+export { executeCliUpdate, parseUpdateArgs, } from "./update/run-command";

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCatalogWriteBody = exports.CLI_CONTRACT_VERSION = exports.CLI_PACKAGE = exports.CLI_VERSION = exports.checkGeneratedCatalogCompatibility = exports.buildCapabilityManifest = exports.getOperationSchemaDocument = exports.findCatalogOperationByRoute = exports.findCatalogOperation = exports.COMPATIBILITY_RANGE = exports.CATALOG_VERSION = exports.CATALOG_SOURCE = exports.CATALOG_OPERATIONS = exports.startLoopbackCallbackServer = exports.runBrowserPkceLogin = exports.accessTokenNeedsRefresh = exports.refreshStoredTokensOrNull = exports.refreshStoredTokens = exports.requiresHighRiskConfirmation = exports.inferRawApiRisk = exports.assertHighRiskConfirmation = exports.resolveTypedCommand = exports.checkCliCompatibility = exports.pathTemplateMatches = exports.normalizeApiPath = exports.isInternalDisallowedPath = exports.isFacadeAllowlistedPath = exports.WINDOWS_CRED_MAX_BYTES = exports.windowsCredentialTarget = exports.linuxSecretToolBin = exports.linuxSecretServiceArgs = exports.keychainPlatform = exports.probeOsKeychain = exports.getLastTokenSaveResult = exports.tokenFingerprint = exports.deleteTokens = exports.loadTokens = exports.saveTokens = exports.assertNoTokenFields = exports.saveConfigFile = exports.loadConfigFile = exports.resolveProfile = exports.applyJqFilter = exports.writeError = exports.writeSuccess = exports.parseJsonEnvelope = exports.errorEnvelope = exports.successEnvelope = exports.parseGlobalFlags = exports.runCli = void 0;
-exports.SKILLS_GITHUB_SOURCE = exports.AGENT_INSTALL_GUIDE_URL = exports.AGENT_INSTALL_GUIDE_BLOB_URL = exports.skillsListHasAlphafox = exports.semverLessThan = exports.runInstallWizard = exports.parseInstallArgs = exports.loadJsonArg = exports.parseRequestBodyFlags = void 0;
+exports.parseUpdateArgs = exports.executeCliUpdate = exports.syncCurrentSkills = exports.skillsStatePath = exports.installedSkillsRoot = exports.inspectCurrentSkills = exports.writeSkillsManifest = exports.syncSkills = exports.loadSkillsState = exports.loadAndVerifySkillsManifest = exports.inspectSkills = exports.buildSkillsManifest = exports.SKILLS_GITHUB_SOURCE = exports.AGENT_INSTALL_GUIDE_URL = exports.AGENT_INSTALL_GUIDE_BLOB_URL = exports.skillsListHasAlphafox = exports.semverLessThan = exports.runInstallWizard = exports.parseInstallArgs = exports.loadJsonArg = exports.parseRequestBodyFlags = void 0;
 var run_1 = require("./commands/run");
 Object.defineProperty(exports, "runCli", { enumerable: true, get: function () { return run_1.runCli; } });
 Object.defineProperty(exports, "parseGlobalFlags", { enumerable: true, get: function () { return run_1.parseGlobalFlags; } });
@@ -80,3 +80,18 @@ var types_1 = require("./install/types");
 Object.defineProperty(exports, "AGENT_INSTALL_GUIDE_BLOB_URL", { enumerable: true, get: function () { return types_1.AGENT_INSTALL_GUIDE_BLOB_URL; } });
 Object.defineProperty(exports, "AGENT_INSTALL_GUIDE_URL", { enumerable: true, get: function () { return types_1.AGENT_INSTALL_GUIDE_URL; } });
 Object.defineProperty(exports, "SKILLS_GITHUB_SOURCE", { enumerable: true, get: function () { return types_1.SKILLS_GITHUB_SOURCE; } });
+var manager_1 = require("./skills/manager");
+Object.defineProperty(exports, "buildSkillsManifest", { enumerable: true, get: function () { return manager_1.buildSkillsManifest; } });
+Object.defineProperty(exports, "inspectSkills", { enumerable: true, get: function () { return manager_1.inspectSkills; } });
+Object.defineProperty(exports, "loadAndVerifySkillsManifest", { enumerable: true, get: function () { return manager_1.loadAndVerifySkillsManifest; } });
+Object.defineProperty(exports, "loadSkillsState", { enumerable: true, get: function () { return manager_1.loadSkillsState; } });
+Object.defineProperty(exports, "syncSkills", { enumerable: true, get: function () { return manager_1.syncSkills; } });
+Object.defineProperty(exports, "writeSkillsManifest", { enumerable: true, get: function () { return manager_1.writeSkillsManifest; } });
+var run_command_1 = require("./skills/run-command");
+Object.defineProperty(exports, "inspectCurrentSkills", { enumerable: true, get: function () { return run_command_1.inspectCurrentSkills; } });
+Object.defineProperty(exports, "installedSkillsRoot", { enumerable: true, get: function () { return run_command_1.installedSkillsRoot; } });
+Object.defineProperty(exports, "skillsStatePath", { enumerable: true, get: function () { return run_command_1.skillsStatePath; } });
+Object.defineProperty(exports, "syncCurrentSkills", { enumerable: true, get: function () { return run_command_1.syncCurrentSkills; } });
+var run_command_2 = require("./update/run-command");
+Object.defineProperty(exports, "executeCliUpdate", { enumerable: true, get: function () { return run_command_2.executeCliUpdate; } });
+Object.defineProperty(exports, "parseUpdateArgs", { enumerable: true, get: function () { return run_command_2.parseUpdateArgs; } });

package/dist/install/types.d.ts

@@ -1,9 +1,10 @@
+/** @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-";
 export declare const AGENT_INSTALL_GUIDE_URL = "https://raw.githubusercontent.com/alphafoxai/alphafox-cli/main/docs/alphafox-cli-installation-guide.md";
 export declare const AGENT_INSTALL_GUIDE_BLOB_URL = "https://github.com/alphafoxai/alphafox-cli/blob/main/docs/alphafox-cli-installation-guide.md";
 export type InstallCliAction = "installed" | "upgraded" | "skipped" | "planned";
-export type InstallSkillsAction = "installed" | "skipped" | "planned" | "failed";
+export type InstallSkillsAction = "installed" | "updated" | "skipped" | "planned" | "failed" | "blocked";
 export type InstallAuthAction = "completed" | "skipped" | "failed" | "planned";
 export interface InstallCliStep {
     readonly action: InstallCliAction;
@@ -16,6 +17,12 @@ export interface InstallSkillsStep {
     readonly source?: string;
     readonly scope: "global";
     readonly alreadyPresent?: boolean;
+    readonly version?: string;
+    readonly updated?: readonly string[];
+    readonly removed?: readonly string[];
+    readonly blocked?: readonly string[];
+    readonly backupDir?: string;
+    readonly restartRequired?: boolean;
 }
 export interface InstallAuthStep {
     readonly action: InstallAuthAction;

package/dist/install/types.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstallError = exports.AGENT_INSTALL_GUIDE_BLOB_URL = exports.AGENT_INSTALL_GUIDE_URL = exports.SKILLS_NAME_PREFIX = exports.SKILLS_GITHUB_SOURCE = void 0;
 exports.isInstallError = isInstallError;
+/** @deprecated AlphaFox Skills updates must use the verified npm package bundle. */
 exports.SKILLS_GITHUB_SOURCE = "alphafoxai/alphafox-cli";
 exports.SKILLS_NAME_PREFIX = "alphafox-";
 exports.AGENT_INSTALL_GUIDE_URL = "https://raw.githubusercontent.com/alphafoxai/alphafox-cli/main/docs/alphafox-cli-installation-guide.md";