@getpaseo/server 0.11.0-beta.1 → 0.11.0-beta.3

package/dist/server/builtin-plugins/kimi-usage-source/server/usage.ts

@@ -1,11 +1,12 @@
 import type { UsageInput } from "../shared/input.js";
-import { existsSync, promises as fs } from "node:fs";
+import { promises as fs } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import {
   toneFromUsedPct,
-  unavailableUsage,
+  unavailable,
+  type UsageAccount,
   windowFromUsedPct,
   type UsageReport,
   type UsageWindow,
@@ -251,9 +252,6 @@ export async function fetchUsage(
   input: UsageInput,
   fetchApi: typeof fetch = fetch,
 ): Promise<UsageReport> {
-  void input;
-  const homeDir = homedir();
-
   async function callUsageApi(token: string): Promise<Response> {
     return fetchApi(KIMI_USAGE_URL, {
       signal: AbortSignal.timeout(15_000),
@@ -264,52 +262,19 @@ export async function fetchUsage(
     });
   }
 
-  async function readCredentials(): Promise<KimiCredentials | null> {
-    const environmentToken = process.env["KIMI_TOKEN"] || process.env["KIMI_API_KEY"];
-    if (environmentToken) {
-      return { access_token: environmentToken };
-    }
-
-    for (const path of credentialPaths()) {
-      const credentials = await readCredentialFile(path);
-      if (credentials?.access_token) {
-        return { ...credentials, access_token: credentials.access_token };
-      }
-    }
-    return null;
-  }
-
-  function credentialPaths(): string[] {
-    const home = homeDir;
-    return [
-      join(
-        process.env["KIMI_CODE_HOME"] || join(home, ".kimi-code"),
-        "credentials",
-        "kimi-code.json",
-      ),
-      join(home, ".kimi", "credentials", "kimi-code.json"),
-    ];
-  }
-
-  async function readCredentialFile(path: string): Promise<KimiAuth | null> {
-    if (!existsSync(path)) return null;
-    try {
-      return KimiAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
-    } catch {
-      return null;
-    }
-  }
-
-  const credentials = await readCredentials();
-  if (!credentials) return unavailableUsage();
+  const credentials = await readCredentials(input);
+  if (!credentials) throw new Error("Kimi login store no longer exists");
+  if (credentials.expires_at != null && credentials.expires_at * 1000 <= Date.now())
+    return unavailable({
+      kind: "expired",
+      expiresAt: new Date(credentials.expires_at * 1000).toISOString(),
+    });
 
   const res = await callUsageApi(credentials.access_token);
 
-  if (!res.ok) {
-    // Read-only on credentials; the Kimi CLI owns refresh. See docs/providers.md.
-
-    return unavailableUsage();
-  }
+  if (res.status === 401 || res.status === 403)
+    return unavailable({ kind: "rejected", status: res.status });
+  if (!res.ok) throw new Error(`Kimi usage API returned ${res.status}`);
 
   const windows = kimiUsageWindowsFromPayload(await res.json());
 
@@ -322,24 +287,36 @@ export async function fetchUsage(
   };
 }
 
-export async function identify() {
-  if (process.env["KIMI_TOKEN"] || process.env["KIMI_API_KEY"]) return { key: "default" };
-  const home = homedir();
-  const paths = [
-    join(
-      process.env["KIMI_CODE_HOME"] || join(home, ".kimi-code"),
-      "credentials",
-      "kimi-code.json",
-    ),
-    join(home, ".kimi", "credentials", "kimi-code.json"),
-  ];
-  for (const path of paths) {
-    try {
-      const auth = KimiAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
-      if (auth.access_token) return { key: "default" };
-    } catch {
-      continue;
-    }
+async function readCredentials(input: UsageInput): Promise<KimiCredentials | undefined> {
+  if (input.store === "env") {
+    const token = process.env[input.locator];
+    return token ? { access_token: token } : undefined;
   }
-  return null;
+  try {
+    const credentials = KimiAuthSchema.parse(JSON.parse(await fs.readFile(input.locator, "utf8")));
+    return credentials.access_token
+      ? { ...credentials, access_token: credentials.access_token }
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+export async function discover(): Promise<UsageAccount[]> {
+  const candidates: UsageInput[] = ["KIMI_TOKEN", "KIMI_API_KEY"].map((locator) => ({
+    store: "env",
+    locator,
+  }));
+  candidates.push(
+    ...[
+      join(
+        process.env.KIMI_CODE_HOME || join(homedir(), ".kimi-code"),
+        "credentials",
+        "kimi-code.json",
+      ),
+      join(homedir(), ".kimi", "credentials", "kimi-code.json"),
+    ].map((locator) => ({ store: "file" as const, locator })),
+  );
+  for (const input of candidates)
+    if (await readCredentials(input)) return [{ key: "default", input }];
+  return [];
 }

package/dist/server/builtin-plugins/kimi-usage-source/shared/input.ts

@@ -1,4 +1,8 @@
 import { z } from "zod";
-export const inputSchema = z.object({}).strict();
-
+export const inputSchema = z
+  .object({
+    store: z.enum(["env", "file"]),
+    locator: z.string().min(1),
+  })
+  .strict();
 export type UsageInput = z.infer<typeof inputSchema>;

package/dist/server/builtin-plugins/minimax-usage-source/index.server.ts

@@ -1,6 +1,6 @@
 import type { PluginServerContext } from "@getpaseo/plugin/server";
 import { inputSchema } from "./shared/input.js";
-import { fetchUsage, identify } from "./server/usage.js";
+import { fetchUsage, discover } from "./server/usage.js";
 
 export default function contribute(server: PluginServerContext) {
   server.registerUsageSource({
@@ -8,8 +8,7 @@ export default function contribute(server: PluginServerContext) {
     label: "MiniMax",
     icon: "icon.svg",
     input: inputSchema,
-    discover: async () => [{}],
-    identify,
+    discover: () => discover(),
     fetch: fetchUsage,
   });
   return () => {};

package/dist/server/builtin-plugins/minimax-usage-source/server/usage.ts

@@ -1,10 +1,11 @@
 import type { UsageInput } from "../shared/input.js";
-import { existsSync, promises as fs } from "node:fs";
+import { promises as fs } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import {
-  unavailableUsage,
+  unavailable,
+  type UsageAccount,
   windowFromUsedPct,
   type UsageReport,
   type UsageWindow,
@@ -148,83 +149,10 @@ export async function fetchUsage(
   input: UsageInput,
   fetchApi: typeof fetch = fetch,
 ): Promise<UsageReport> {
-  void input;
-  const configPath = join(homedir(), ".mmx", "config.json");
-  const credentialsPath = join(homedir(), ".mmx", "credentials.json");
-  const env = process.env;
-  const now = Date.now;
-
-  async function resolveAuth(): Promise<MiniMaxResolvedAuth | null> {
-    const envToken = env["MINIMAX_API_KEY"];
-    if (envToken) {
-      const envBase = env["MINIMAX_BASE_URL"];
-      return {
-        token: envToken,
-        baseUrl: resolveBaseUrl({ baseUrl: envBase }),
-      };
-    }
-
-    const credentials = await readCredentials();
-    if (credentials?.access_token && !isExpired(credentials.expires_at)) {
-      return {
-        token: credentials.access_token,
-        baseUrl: resolveBaseUrl({ baseUrl: credentials.resource_url }),
-      };
-    }
-
-    const config = await readConfig();
-    if (config?.api_key) {
-      return {
-        token: config.api_key,
-        baseUrl: resolveBaseUrl({
-          baseUrl: config.base_url,
-          region: config.region,
-        }),
-      };
-    }
-
-    if (config?.oauth?.access_token && !isExpired(config.oauth.expires_at)) {
-      return {
-        token: config.oauth.access_token,
-        baseUrl: resolveBaseUrl({
-          baseUrl: config.oauth.resource_url ?? config.base_url,
-          region: config.region,
-        }),
-      };
-    }
-
-    return null;
-  }
-
-  function isExpired(expiresAt: string | null | undefined): boolean {
-    if (!expiresAt) return false;
-    const parsed = Date.parse(expiresAt);
-    if (!Number.isFinite(parsed)) return false;
-    return parsed <= now();
-  }
-
-  async function readCredentials(): Promise<z.infer<typeof MiniMaxCredentialsSchema> | null> {
-    if (!existsSync(credentialsPath)) return null;
-    try {
-      const raw = JSON.parse(await fs.readFile(credentialsPath, "utf8"));
-      return MiniMaxCredentialsSchema.parse(raw);
-    } catch {
-      return null;
-    }
-  }
-
-  async function readConfig(): Promise<z.infer<typeof MiniMaxConfigSchema> | null> {
-    if (!existsSync(configPath)) return null;
-    try {
-      const raw = JSON.parse(await fs.readFile(configPath, "utf8"));
-      return MiniMaxConfigSchema.parse(raw);
-    } catch {
-      return null;
-    }
-  }
-
-  const auth = await resolveAuth();
-  if (!auth) return unavailableUsage();
+  const auth = await readAuth(input);
+  if (!auth) throw new Error("MiniMax login store no longer exists");
+  if (auth.expiresAt && Date.parse(auth.expiresAt) <= Date.now())
+    return unavailable({ kind: "expired", expiresAt: new Date(auth.expiresAt).toISOString() });
 
   const res = await fetchApi(`${auth.baseUrl}/v1/token_plan/remains`, {
     signal: AbortSignal.timeout(15_000),
@@ -234,15 +162,18 @@ export async function fetchUsage(
     },
   });
 
-  if (!res.ok) {
-    return unavailableUsage();
-  }
+  if (res.status === 401 || res.status === 403)
+    return unavailable({ kind: "rejected", status: res.status });
+  if (!res.ok) throw new Error(`MiniMax usage API returned ${res.status}`);
 
   const resp = MiniMaxQuotaResponseSchema.parse(await res.json());
 
   const statusCode = resp.base_resp?.status_code;
   if (typeof statusCode === "number" && statusCode !== 0) {
-    return unavailableUsage();
+    return unavailable({
+      kind: "no_quota",
+      detail: resp.base_resp?.status_msg ?? "No active coding plan",
+    });
   }
 
   const models = resp.model_remains ?? [];
@@ -256,8 +187,10 @@ export async function fetchUsage(
     if (weeklyWindow) windows.push(weeklyWindow);
   }
 
+  if (windows.length === 0)
+    return unavailable({ kind: "no_quota", detail: "No active coding plan" });
   return {
-    status: windows.length > 0 ? "available" : "unavailable",
+    status: "available",
     planLabel: undefined,
     windows,
     balances: [],
@@ -265,24 +198,55 @@ export async function fetchUsage(
   };
 }
 
-export async function identify() {
-  if (process.env["MINIMAX_API_KEY"]) return { key: "default" };
-  const home = join(homedir(), ".mmx");
-  try {
-    const credentials = MiniMaxCredentialsSchema.parse(
-      JSON.parse(await fs.readFile(join(home, "credentials.json"), "utf8")),
-    );
-    if (credentials.access_token) return { key: "default" };
-  } catch {
-    /* Check config next. */
+async function readAuth(
+  input: UsageInput,
+): Promise<(MiniMaxResolvedAuth & { expiresAt?: string }) | undefined> {
+  if (input.store === "env") {
+    const token = process.env[input.locator];
+    return token
+      ? { token, baseUrl: resolveBaseUrl({ baseUrl: process.env.MINIMAX_BASE_URL }) }
+      : undefined;
   }
   try {
-    const config = MiniMaxConfigSchema.parse(
-      JSON.parse(await fs.readFile(join(home, "config.json"), "utf8")),
-    );
-    if (config.api_key || config.oauth?.access_token) return { key: "default" };
+    const raw: unknown = JSON.parse(await fs.readFile(input.locator, "utf8"));
+    if (input.store === "credentials") {
+      const credentials = MiniMaxCredentialsSchema.parse(raw);
+      return credentials.access_token
+        ? {
+            token: credentials.access_token,
+            baseUrl: resolveBaseUrl({ baseUrl: credentials.resource_url }),
+            expiresAt: credentials.expires_at ?? undefined,
+          }
+        : undefined;
+    }
+    const config = MiniMaxConfigSchema.parse(raw);
+    if (config.api_key)
+      return {
+        token: config.api_key,
+        baseUrl: resolveBaseUrl({ baseUrl: config.base_url, region: config.region }),
+      };
+    return config.oauth?.access_token
+      ? {
+          token: config.oauth.access_token,
+          baseUrl: resolveBaseUrl({
+            baseUrl: config.oauth.resource_url ?? config.base_url,
+            region: config.region,
+          }),
+          expiresAt: config.oauth.expires_at ?? undefined,
+        }
+      : undefined;
   } catch {
-    /* No configured account. */
+    return undefined;
   }
-  return null;
+}
+export async function discover(): Promise<UsageAccount[]> {
+  const candidates: UsageInput[] = [
+    { store: "env", locator: "MINIMAX_API_KEY" },
+    { store: "credentials", locator: join(homedir(), ".mmx", "credentials.json") },
+    { store: "config", locator: join(homedir(), ".mmx", "config.json") },
+  ];
+  const accounts: UsageAccount[] = [];
+  for (const input of candidates)
+    if (await readAuth(input)) accounts.push({ key: "default", input });
+  return accounts;
 }

package/dist/server/builtin-plugins/minimax-usage-source/shared/input.ts

@@ -1,4 +1,8 @@
 import { z } from "zod";
-export const inputSchema = z.object({}).strict();
-
+export const inputSchema = z
+  .object({
+    store: z.enum(["env", "credentials", "config"]),
+    locator: z.string().min(1),
+  })
+  .strict();
 export type UsageInput = z.infer<typeof inputSchema>;

package/dist/server/builtin-plugins/muse-provider/server/usage.ts

@@ -5,7 +5,7 @@ import type { UsageSourceRegistration } from "@getpaseo/plugin/server";
 import type { ProviderLaunch } from "@getpaseo/plugin/server/provider";
 import {
   hashAccountKey,
-  unavailableUsage,
+  unavailable,
   windowFromUsedPct,
   toneFromUsedPct,
 } from "@getpaseo/plugin/server/usage";
@@ -59,18 +59,19 @@ export class Usage {
       label: "Muse Code",
       icon: "icon.svg",
       input: inputSchema,
-      discover: async () => [...this.launches.keys()].map((account) => ({ account })),
-      identify: async (input) => {
-        const { account } = inputSchema.parse(input);
-        return this.launches.has(account) ? { key: account, label: "Muse Code" } : null;
-      },
+      discover: async () =>
+        [...this.launches.keys()].map((account) => ({
+          key: account,
+          label: "Muse Code",
+          input: { account },
+        })),
       fetch: async (input) => {
         const { account } = inputSchema.parse(input);
         const launch = this.launches.get(account);
-        if (!launch) return unavailableUsage();
+        if (!launch) throw new Error("Muse login no longer exists");
         try {
           const { usage } = await this.read(account, launch);
-          if (!usage) return unavailableUsage();
+          if (!usage) return unavailable({ kind: "no_quota", detail: "No usage quota reported" });
           return {
             status: "available",
             planLabel: usage.tier,
@@ -105,7 +106,6 @@ export class Usage {
         } catch (error) {
           return {
             status: "error",
-            windows: [],
             error: error instanceof Error ? error.message : String(error),
           };
         }

package/dist/server/builtin-plugins/opencode-go-usage-source/index.server.ts

@@ -1,6 +1,6 @@
 import type { PluginServerContext } from "@getpaseo/plugin/server";
 import { inputSchema } from "./shared/input.js";
-import { discover, fetchUsage, identify } from "./server/usage.js";
+import { discover, fetchUsage } from "./server/usage.js";
 
 export default function contribute(server: PluginServerContext) {
   server.registerUsageSource({
@@ -9,7 +9,6 @@ export default function contribute(server: PluginServerContext) {
     icon: "icon.svg",
     input: inputSchema,
     discover,
-    identify,
     fetch: fetchUsage,
   });
   return () => {};

package/dist/server/builtin-plugins/opencode-go-usage-source/server/usage.ts

@@ -4,6 +4,8 @@ import { join } from "node:path";
 import { z } from "zod";
 import {
   hashAccountKey,
+  unavailable,
+  type UsageAccount,
   toneFromUsedPct,
   windowFromUsedPct,
   type UsageReport,
@@ -44,23 +46,22 @@ export async function readDefaultKey(path = authPath()): Promise<string | null>
   }
 }
 
-export async function discover(path = authPath()): Promise<Array<{}>> {
-  return (await readDefaultKey(path)) ? [{}] : [];
+export async function discover(path = authPath()): Promise<UsageAccount[]> {
+  return (await readDefaultKey(path)) ? [{ key: hashAccountKey(path), input: { path } }] : [];
 }
 
 export async function fetchUsage(
-  _input: Input,
+  input: Input,
   fetchApi: typeof fetch = fetch,
-  path = authPath(),
 ): Promise<UsageReport> {
-  const apiKey = await readDefaultKey(path);
-  if (!apiKey) return { status: "unavailable", windows: [] };
+  const apiKey = await readDefaultKey(input.path);
+  if (!apiKey) throw new Error("OpenCode Go login store no longer exists");
   const response = await fetchApi("https://opencode.ai/zen/go/v1/usage", {
     headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
     signal: AbortSignal.timeout(15_000),
   });
   if (response.status === 401 || response.status === 403)
-    return { status: "unavailable", windows: [] };
+    return unavailable({ kind: "rejected", status: response.status, refreshedBy: "opencode" });
   if (!response.ok) throw new Error(`OpenCode Go usage API returned ${response.status}`);
   const data = responseSchema.parse(await response.json());
   const windows = (
@@ -82,8 +83,3 @@ export async function fetchUsage(
   );
   return { status: "available", planLabel: "Go", windows };
 }
-
-export async function identify(_input: Input, path = authPath()) {
-  const key = await readDefaultKey(path);
-  return key ? { key: hashAccountKey(key) } : null;
-}

package/dist/server/builtin-plugins/opencode-go-usage-source/shared/input.ts

@@ -1,4 +1,3 @@
 import { z } from "zod";
-
-export const inputSchema = z.object({}).strict();
+export const inputSchema = z.object({ path: z.string().min(1) }).strict();
 export type Input = z.infer<typeof inputSchema>;

package/dist/server/builtin-plugins/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/builtin-plugins",
-  "version": "0.11.0-beta.1",
+  "version": "0.11.0-beta.3",
   "private": true,
   "type": "module",
   "scripts": {

package/dist/server/builtin-plugins/zai-usage-source/index.server.ts

@@ -1,6 +1,6 @@
 import type { PluginServerContext } from "@getpaseo/plugin/server";
 import { inputSchema } from "./shared/input.js";
-import { fetchUsage, identify } from "./server/usage.js";
+import { fetchUsage, discover } from "./server/usage.js";
 
 export default function contribute(server: PluginServerContext) {
   server.registerUsageSource({
@@ -8,8 +8,7 @@ export default function contribute(server: PluginServerContext) {
     label: "Z.ai",
     icon: "icon.svg",
     input: inputSchema,
-    discover: async () => [{}],
-    identify,
+    discover: () => discover(),
     fetch: fetchUsage,
   });
   return () => {};

package/dist/server/builtin-plugins/zai-usage-source/server/usage.ts

@@ -1,7 +1,8 @@
 import type { UsageInput } from "../shared/input.js";
 import { z } from "zod";
 import {
-  unavailableUsage,
+  unavailable,
+  type UsageAccount,
   type UsageReport,
   type UsageDetail,
 } from "@getpaseo/plugin/server/usage";
@@ -28,10 +29,8 @@ export async function fetchUsage(
   input: UsageInput,
   fetchApi: typeof fetch = fetch,
 ): Promise<UsageReport> {
-  void input;
-
-  const token = process.env["ZAI_API_KEY"] || process.env["GLM_API_KEY"];
-  if (!token) return unavailableUsage();
+  const token = process.env[input.locator];
+  if (!token) throw new Error("Z.ai login store no longer exists");
 
   const res = await fetchApi("https://api.z.ai/api/biz/subscription/list", {
     signal: AbortSignal.timeout(15_000),
@@ -41,13 +40,13 @@ export async function fetchUsage(
     },
   });
 
-  if (!res.ok) {
-    return unavailableUsage();
-  }
+  if (res.status === 401 || res.status === 403)
+    return unavailable({ kind: "rejected", status: res.status });
+  if (!res.ok) throw new Error(`Z.ai usage API returned ${res.status}`);
 
   const resp = ZaiUsageResponseSchema.parse(await res.json());
   const sub = resp.data?.[0];
-  if (!sub) return unavailableUsage();
+  if (!sub) return unavailable({ kind: "no_quota", detail: "No active coding plan" });
 
   const details: UsageDetail[] = [];
   if (sub.status) details.push({ id: "status", label: "Status", value: sub.status });
@@ -65,6 +64,9 @@ export async function fetchUsage(
   };
 }
 
-export async function identify() {
-  return process.env["ZAI_API_KEY"] || process.env["GLM_API_KEY"] ? { key: "default" } : null;
+export async function discover(): Promise<UsageAccount[]> {
+  for (const locator of ["ZAI_API_KEY", "GLM_API_KEY"]) {
+    if (process.env[locator]) return [{ key: "default", input: { store: "env", locator } }];
+  }
+  return [];
 }

package/dist/server/builtin-plugins/zai-usage-source/shared/input.ts

@@ -1,4 +1,8 @@
 import { z } from "zod";
-export const inputSchema = z.object({}).strict();
-
+export const inputSchema = z
+  .object({
+    store: z.literal("env"),
+    locator: z.string().min(1),
+  })
+  .strict();
 export type UsageInput = z.infer<typeof inputSchema>;

package/dist/server/server/orchestration-skills/internal/operations.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import path from "node:path";
-import { listFilesRecursive, removeSkill, syncSkills } from "./sync.js";
+import { isLegacyCodexCopy, listFilesRecursive, readManagedFilesManifest, removeSkill, syncSkills, } from "./sync.js";
 // Names the bundle used to ship. They are never selectable, but every scan still
 // covers them so an older install's copies get cleaned up.
 export const LEGACY_SKILL_NAMES = [
@@ -110,10 +110,24 @@ export async function getSkillsStatus(targets, selection) {
         hashSkills(targets.claudeDir, names),
         hashSkills(targets.codexDir, names),
     ]);
-    const disks = [agentsDisk, claudeDisk, codexDisk];
-    const ops = diff(bundle, disks, names, resolveDesiredSkills(selection, available));
-    const installed = installedSkillNames(disks, names);
-    if (!hasInstalledPaseoSkill(disks))
+    const disks = [agentsDisk, claudeDisk];
+    const desired = resolveDesiredSkills(selection, available);
+    const ops = diff(bundle, disks, names, desired);
+    for (const name of codexDisk.keys()) {
+        if (ops.some((op) => op.name === name))
+            continue;
+        if (!(await isLegacyCodexCopy(name, targets)))
+            continue;
+        if (!desired.has(name))
+            ops.push({ kind: "delete", name });
+        else if (await readManagedFilesManifest(path.join(targets.codexDir, name))) {
+            ops.push({ kind: "update", name });
+        }
+    }
+    ops.sort((a, b) => compareStrings(a.name, b.name));
+    const allDisks = [...disks, codexDisk];
+    const installed = installedSkillNames(allDisks, names);
+    if (!hasInstalledPaseoSkill(allDisks))
         return { state: "not-installed", ops, available, installed };
     if (ops.length === 0)
         return { state: "up-to-date", ops, available, installed };

package/dist/server/server/orchestration-skills/internal/sync.d.ts

@@ -10,12 +10,24 @@ export interface SkillSyncResult {
     changedFiles: number;
     processedSkills: number;
 }
+interface ManagedFilesManifest {
+    version: 1;
+    files: Record<string, string>;
+}
 export declare function listFilesRecursive(rootDir: string): Promise<string[]>;
+export declare function readManagedFilesManifest(dstDir: string): Promise<ManagedFilesManifest | null>;
 export interface RemoveSkillTargets {
     agentsDir: string;
     claudeDir: string;
     codexDir: string;
 }
 export declare function removeSkill(skillName: string, targets: RemoveSkillTargets): Promise<void>;
+/**
+ * Codex also discovers .agents/skills, so its dedicated copy is a leftover. When
+ * the Codex skill directory resolves to the shared or Claude copy, it is that
+ * copy, and retiring it would delete the install.
+ */
+export declare function isLegacyCodexCopy(skillName: string, targets: RemoveSkillTargets): Promise<boolean>;
 export declare function syncSkills(options: SkillSyncOptions): Promise<SkillSyncResult>;
+export {};
 //# sourceMappingURL=sync.d.ts.map