@hasna/skills 0.2.1 → 0.4.0

package/dist/lib/portable-skills-files.d.ts

@@ -22,10 +22,14 @@ export declare function parseSkillKind(value: string | undefined): SkillKind | u
 export declare function readDeclaredSkillVersion(skillPath: string): string | undefined;
 export declare function createInstructionManifest(name: string, options: {
     description: string;
+    category?: string;
+    tags?: string[];
 }): PortableSkillManifest;
 export declare function writeInstructionSkillTemplate(skillPath: string, manifest: PortableSkillManifest): void;
 export declare function createPortableManifest(name: string, options: {
     description: string;
+    category?: string;
+    tags?: string[];
 }): PortableSkillManifest;
 export declare function writePortableSkillTemplate(skillPath: string, manifest: PortableSkillManifest): void;
 /**

package/dist/lib/portable-skills-types.d.ts

@@ -98,6 +98,8 @@ export interface PortableSkillOptions {
 }
 export interface ScaffoldPortableSkillOptions extends PortableSkillOptions {
     description?: string;
+    category?: string;
+    tags?: string[];
     overwrite?: boolean;
     kind?: SkillKind;
 }

package/dist/lib/remote-account.d.ts

@@ -0,0 +1,42 @@
+import type { RemoteInputFileDescriptor } from "./remote-files.js";
+/** Optional account APIs supplied by a configured Skills server. No local prices or provider policy. */
+export interface RemoteRunQuote {
+    skill: string;
+    pricing: {
+        costCents: number;
+        formattedCost: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface RemoteRunApproval {
+    /** Preferred public spelling: maximum integer credits approved by the caller. */
+    maxCredits?: number;
+    /** Maximum integer credits approved by the caller (legacy wire spelling). */
+    maxCostCents?: number;
+    idempotencyKey?: string;
+    inputFiles?: RemoteInputFileDescriptor[];
+}
+export interface RemoteCreditPack {
+    id: string;
+    credits: number;
+    expiresInDays?: number;
+}
+export declare class RemoteCreditApprovalError extends Error {
+    readonly requiredCredits: number;
+    readonly maximumCredits: number;
+    readonly code = "CREDIT_APPROVAL_REQUIRED";
+    constructor(requiredCredits: number, maximumCredits: number);
+}
+export declare function creditCount(value: unknown): number;
+export declare function parseRemoteRunQuote(value: unknown): RemoteRunQuote;
+export declare function parseRemoteCreditPacks(value: unknown): RemoteCreditPack[];
+export declare function parseRemoteBillingStatus(value: unknown): {
+    hasPaymentMethod?: boolean | undefined;
+    plan?: string | undefined;
+    creditBalance: number;
+    formattedCreditBalance: string;
+};
+export declare function parseRemoteCheckout(value: unknown): {
+    url: string;
+};

package/dist/lib/remote-auth.d.ts

@@ -0,0 +1,32 @@
+export declare class HostedApiError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly detail?: string;
+    readonly endpoint?: string;
+    readonly apiUrl?: string;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        detail?: string;
+        endpoint?: string;
+        apiUrl?: string;
+    });
+}
+/** Passwordless auth transport for an explicitly selected instance. It never writes credentials. */
+export declare class RemoteSkillsAuthClient {
+    readonly apiOrigin: string;
+    constructor(apiUrl: string);
+    requestCode(email: string): Promise<any>;
+    verifyCode(email: string, code: string): Promise<any>;
+    startDevice(): Promise<any>;
+    pollDevice(deviceCode: string): Promise<any>;
+    private sessionClient;
+    createApiKey(email: string, code: string, name: string, scopes?: string[]): Promise<{
+        [field: string]: unknown;
+        key: string;
+    }>;
+    listApiKeys(email: string, code: string): Promise<Record<string, unknown>[]>;
+    revokeApiKey(email: string, code: string, keyId: string): Promise<Record<string, unknown>>;
+    /** Common auth transport used by CLI login, preserving the selected instance through awaits. */
+    request(path: string, options?: RequestInit): Promise<any>;
+}

package/dist/lib/remote-client.d.ts

@@ -1,4 +1,6 @@
 import { type RemoteSkillRunContract } from "./remote-run-contract.js";
+import { type RemoteCreditPack, type RemoteRunApproval, type RemoteRunQuote } from "./remote-account.js";
+import { type RemoteInputFile } from "./remote-files.js";
 /**
  * A server that predates this client's pin/tag/incremental-sync routes answered
  * 404/405 for them. The caller must never mistake that for "no pins" or "empty
@@ -55,6 +57,7 @@ export interface UpdatedSincePage {
 export declare class RemoteSkillsClient {
     private apiUrl;
     private apiKey;
+    private capabilities?;
     constructor(apiKey: string, apiUrl?: string);
     private request;
     /**
@@ -88,12 +91,64 @@ export declare class RemoteSkillsClient {
         status: number;
         body: unknown;
     }>;
-    submitRun(slug: string, input?: Record<string, unknown>, args?: string[]): Promise<RemoteSkillRunContract>;
+    /** Low-level admission transport; interactive surfaces use submitQuotedRun. */
+    submitRun(slug: string, input?: Record<string, unknown>, args?: string[], approval?: RemoteRunApproval): Promise<RemoteSkillRunContract>;
+    quoteRun(slug: string, input?: Record<string, unknown>, args?: string[]): Promise<RemoteRunQuote>;
+    getCapabilities(): Promise<{
+        contractVersion: 1;
+        apiVersion: 1;
+        capabilities: string[];
+        billing?: {
+            boundedRunApproval?: boolean;
+            unit?: string;
+        };
+    }>;
+    /** Quote first and fail closed when the caller has not approved the required credits. */
+    submitQuotedRun(slug: string, input?: Record<string, unknown>, args?: string[], approval?: RemoteRunApproval): Promise<RemoteSkillRunContract>;
+    getIdentity(): Promise<Record<string, unknown>>;
+    listApiKeys(): Promise<Record<string, unknown>[]>;
+    createApiKey(name: string, scopes?: string[]): Promise<{
+        key: string;
+        [field: string]: unknown;
+    }>;
+    revokeApiKey(keyId: string): Promise<Record<string, unknown>>;
+    getBillingStatus(): Promise<{
+        hasPaymentMethod?: boolean | undefined;
+        plan?: string | undefined;
+        creditBalance: number;
+        formattedCreditBalance: string;
+    }>;
+    listCreditPacks(): Promise<RemoteCreditPack[]>;
+    createCreditCheckout(packId: string): Promise<{
+        url: string;
+    }>;
+    getUsage(): Promise<Record<string, unknown>[]>;
+    listInvoices(): Promise<Record<string, unknown>[]>;
+    createBillingCheckout(): Promise<{
+        url: string;
+    }>;
+    createBillingPortal(): Promise<{
+        url: string;
+    }>;
+    cancelRun(runId: string): Promise<RemoteSkillRunContract>;
+    resumeRun(runId: string): Promise<RemoteSkillRunContract>;
+    private controlRun;
+    private checkoutResponse;
+    private arrayResponse;
     getRun(runId: string): Promise<RemoteSkillRunContract | null>;
     getRunLogs(runId: string): Promise<any[]>;
     listRuns(limit?: number): Promise<any[]>;
     getRunArtifacts(runId: string): Promise<any[]>;
     downloadRunArtifact(runId: string, artifactId: string): Promise<Response>;
+    getVerifiedRunArtifact(runId: string, artifactId: string, maximumBytes?: number): Promise<{
+        id: string;
+        fileName: string;
+        bytes: Uint8Array<ArrayBufferLike>;
+        byteSize: number;
+        sha256: any;
+    }>;
+    submitQuotedRunWithFiles(slug: string, input: Record<string, unknown>, args: string[], files: RemoteInputFile[], approval?: RemoteRunApproval): Promise<RemoteSkillRunContract>;
+    uploadRunFiles(runId: string, files: RemoteInputFile[]): Promise<void>;
     /**
      * Publish a skill to the configured instance.
      *
@@ -154,16 +209,26 @@ export declare class RemoteSkillsClient {
         limit?: number;
     }): Promise<UpdatedSincePage>;
 }
-export declare function createRemoteSkillsClient(): RemoteSkillsClient | null;
+/**
+ * The client for the configured instance, or null when this install runs on
+ * this machine (no credential and no authority).
+ *
+ * A configured authority with no credential does NOT return null: the shared
+ * ladder throws, so the caller fails loudly instead of quietly reading the
+ * bundled corpus while authentication is unconfigured.
+ *
+ * ASYNC because the credential ladder is: a vault pointer
+ * (`HASNA_SKILLS_API_KEY_REF`) is completed through the secrets vault before a
+ * client is built, so this never hands `RemoteSkillsClient` an empty key to put
+ * behind `Authorization: Bearer `.
+ */
+export declare function createRemoteSkillsClient(env?: Record<string, string | undefined>): Promise<RemoteSkillsClient | null>;
 /**
  * Write-free client resolution for read-only paths (e.g. `sync --dry-run`).
  *
- * createRemoteSkillsClient() resolves the stored credential through
- * getAuthFilePath() and the stored origin through loadConfig() — both route
- * through getDataDir(), which WRITES (mkdirs the app dir, merges legacy ~/.skills
- * content, copies the legacy config). A dry run must resolve the same client a
- * real run would without performing any of that: the credential and the origin
- * are read from the same files at the same computed paths, and the MissingApiUrl
- * failure mode is preserved (a key with no origin still fails loudly).
+ * Identical to createRemoteSkillsClient() now that resolution is the shared
+ * ladder, which reads the Keychain and the credentials file per call and writes
+ * nothing. Kept as a separate name so read-only callers keep reading as
+ * read-only, and so the distinction survives if a write ever creeps back in.
  */
-export declare function createRemoteSkillsClientReadOnly(): RemoteSkillsClient | null;
+export declare function createRemoteSkillsClientReadOnly(env?: Record<string, string | undefined>): Promise<RemoteSkillsClient | null>;

package/dist/lib/remote-customer-operations.d.ts

@@ -0,0 +1,106 @@
+import type { RemoteSkillsClient } from "./remote-client.js";
+/** Shared customer operation declarations for MCP registration and its discovery contract. */
+export declare const REMOTE_CUSTOMER_OPERATIONS: readonly [{
+    readonly name: "get_account";
+    readonly title: "Get Account Identity";
+    readonly parameter: null;
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<Record<string, unknown>>;
+}, {
+    readonly name: "get_server_capabilities";
+    readonly title: "Get Server Capabilities";
+    readonly parameter: null;
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<{
+        contractVersion: 1;
+        apiVersion: 1;
+        capabilities: string[];
+        billing?: {
+            boundedRunApproval?: boolean;
+            unit?: string;
+        };
+    }>;
+}, {
+    readonly name: "list_remote_skills";
+    readonly title: "List Remote Skills";
+    readonly parameter: null;
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<any[]>;
+}, {
+    readonly name: "get_billing_status";
+    readonly title: "Get Billing Status";
+    readonly parameter: null;
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<{
+        hasPaymentMethod?: boolean | undefined;
+        plan?: string | undefined;
+        creditBalance: number;
+        formattedCreditBalance: string;
+    }>;
+}, {
+    readonly name: "list_credit_packs";
+    readonly title: "List Credit Packs";
+    readonly parameter: null;
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<import("./remote-account.js").RemoteCreditPack[]>;
+}, {
+    readonly name: "create_credit_checkout";
+    readonly title: "Create Credit Checkout";
+    readonly parameter: "pack_id";
+    readonly mutates: true;
+    readonly invoke: (client: RemoteSkillsClient, value: string) => Promise<{
+        url: string;
+    }>;
+}, {
+    readonly name: "get_billing_usage";
+    readonly title: "Get Billing Usage";
+    readonly parameter: null;
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<Record<string, unknown>[]>;
+}, {
+    readonly name: "list_invoices";
+    readonly title: "List Invoices";
+    readonly parameter: null;
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<Record<string, unknown>[]>;
+}, {
+    readonly name: "create_billing_checkout";
+    readonly title: "Create Billing Checkout";
+    readonly parameter: null;
+    readonly mutates: true;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<{
+        url: string;
+    }>;
+}, {
+    readonly name: "create_billing_portal";
+    readonly title: "Create Billing Portal";
+    readonly parameter: null;
+    readonly mutates: true;
+    readonly invoke: (client: RemoteSkillsClient) => Promise<{
+        url: string;
+    }>;
+}, {
+    readonly name: "get_run_logs";
+    readonly title: "Get Run Logs";
+    readonly parameter: "run_id";
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient, value: string) => Promise<any[]>;
+}, {
+    readonly name: "cancel_run";
+    readonly title: "Cancel Run";
+    readonly parameter: "run_id";
+    readonly mutates: true;
+    readonly invoke: (client: RemoteSkillsClient, value: string) => Promise<import("./remote-run-contract.js").RemoteSkillRunContract>;
+}, {
+    readonly name: "resume_run";
+    readonly title: "Resume Run";
+    readonly parameter: "run_id";
+    readonly mutates: true;
+    readonly invoke: (client: RemoteSkillsClient, value: string) => Promise<import("./remote-run-contract.js").RemoteSkillRunContract>;
+}, {
+    readonly name: "list_run_artifacts";
+    readonly title: "List Run Artifacts";
+    readonly parameter: "run_id";
+    readonly mutates: false;
+    readonly invoke: (client: RemoteSkillsClient, value: string) => Promise<any[]>;
+}];

package/dist/lib/remote-files.d.ts

@@ -0,0 +1,21 @@
+export declare const MAX_REMOTE_FILE_BYTES: number;
+export interface RemoteInputFile {
+    name: string;
+    bytes: Uint8Array;
+    contentType?: string;
+}
+export interface RemoteInputFileDescriptor {
+    name: string;
+    sizeBytes: number;
+    sha256: string;
+    contentType: string;
+}
+export declare function describeRemoteFiles(files: RemoteInputFile[]): RemoteInputFileDescriptor[];
+export declare function sha256(bytes: Uint8Array): string;
+export declare function readBoundedResponse(response: Response, maximum: number): Promise<Uint8Array>;
+/** Small inline inputs for agent transports; larger files belong in the CLI/SDK. */
+export declare function decodeRemoteFiles(files: Array<{
+    name: string;
+    base64: string;
+    contentType?: string;
+}>): RemoteInputFile[];

package/dist/lib/remote-registry.d.ts

@@ -1,11 +1,11 @@
 /**
  * Remote registry client.
  *
- * Local registry behavior remains the default. These helpers are opt-in and
- * read from SKILLS_API_URL or config.apiUrl so services can expose
- * a compatible registry API without hard-coding deployment details upstream.
+ * Local registry behavior remains the default. These helpers are opt-in: the
+ * authority and the credential both come from the shared fleet ladder
+ * (lib/fleet-credentials.ts), so a service can expose a compatible registry API
+ * without this package hard-coding anything about where it is deployed.
  */
-import { type SkillsConfig } from "./config.js";
 import type { SkillMeta } from "./registry.js";
 export interface RemoteRegistryOptions {
     apiUrl?: string;
@@ -14,7 +14,25 @@ export interface RemoteRegistryOptions {
     authToken?: string | null;
     fetchImpl?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 }
-export declare function getConfiguredApiUrl(config?: SkillsConfig, env?: Record<string, string | undefined>): string | undefined;
+export declare function getConfiguredApiUrl(env?: Record<string, string | undefined>): string | undefined;
+/**
+ * Compose one Skills API request URL from an authority and an endpoint.
+ *
+ * The Skills server serves its API under `/api/v1`, so a bare authority gets
+ * `/api/v1` appended — the SAME composition `RemoteSkillsClient` performs
+ * (`${origin}/api/v1/...`). The two sites must agree: they are handed the same
+ * origin by the same resolver.
+ *
+ * A trailing `/skills` is only stripped when the API prefix precedes it
+ * (`.../api/skills`, `.../api/v1/skills`), i.e. when an operator pasted the
+ * full collection base that this package's own error messages print. A BARE
+ * trailing `/skills` is NOT a collection: the default fleet authority is
+ * `https://api.hasna.com/skills`, where `/skills` is the gateway's per-app PATH
+ * PREFIX. Treating that as "the base already names the collection" collapsed
+ * every remote read onto the gateway app root — which answers 404 — so a
+ * correctly credentialled install on the default authority could not run
+ * `skills list` at all, on the plain merge path as well as `--remote`.
+ */
 export declare function buildSkillsApiUrl(apiUrl: string, endpoint?: string): string;
 export declare function parseRemoteRegistryPayload(payload: unknown): SkillMeta[];
 export declare function parseRemoteSkillPayload(payload: unknown): SkillMeta;
@@ -27,12 +45,14 @@ export declare function loadRemoteRegistry(options?: RemoteRegistryOptions): Pro
  * origin sees the folder UNION cloud in the plain `list`/`search` path, while
  * every other install keeps today's exact local behavior.
  *
- *   - No origin configured  -> the local list is returned unchanged and no
- *     request is attempted. An unconfigured install must stay byte-identical
- *     to the pre-merge output.
- *   - Origin configured but no credential -> the local list is returned
- *     unchanged and nothing throws. Auth-missing must never crash a read.
- *   - Origin + credential -> the remote registry is fetched and merged under
+ *   - Nothing configured (no credential, no authority) -> the local list is
+ *     returned unchanged and no request is attempted. An install running on
+ *     this machine must stay byte-identical to the pre-merge output.
+ *   - An authority configured with NO credential -> this throws, from the
+ *     shared ladder. It used to return the local half silently, which is the
+ *     false green the 2026-09-04 ruling removes: an operator who pointed this
+ *     CLI at an instance and lost the key was shown a healthy local listing.
+ *   - Credential (+ authority, else the fleet gateway) -> the remote registry is fetched and merged under
  *     the precedence in registry-merge.ts (custom > extension > private >
  *     private-hosted > remote > upstream > official), remote rows tagged
  *     `source: "remote"`.

package/dist/lib/run-routing.d.ts

@@ -8,9 +8,11 @@
  *
  * A skill run is REMOTE only when all three hold:
  *
- *   1. an origin is configured (config `apiUrl` or `$SKILLS_API_URL`);
- *   2. a credential is present (`$SKILLS_API_KEY` / `$SKILL_API_KEY` or the
- *      auth store written by `skills auth login`);
+ *   1. a credential resolves on the fleet ladder (an argument, an env pointer,
+ *      the macOS Keychain, `~/.hasna/skills/config/credentials`, or
+ *      `$HASNA_SKILLS_API_KEY`) — see lib/fleet-credentials.ts;
+ *   2. an authority follows from it (`$HASNA_SKILLS_API_URL`, the Keychain
+ *      `api-url` item, the credentials file, else the fleet gateway);
  *   3. the skill carries the server-owned marker from its published contract
  *      (`skills.runtime: "hosted"` or `skills.source: "remote" |
  *      "private-hosted"` in the skill's `package.json` — see
@@ -33,6 +35,7 @@ export type RunRoutingErrorCode = "REMOTE_REQUIRES_ORIGIN" | "REMOTE_REQUIRES_CR
 export type RunRouting = {
     route: "remote";
     apiKey: string;
+    apiOrigin: string;
 } | {
     route: "local";
 } | {
@@ -57,4 +60,4 @@ export declare function resolveRunRouting(skill: Pick<SkillMeta, "name" | "serve
  * validated, so the caller never re-reads (and cannot diverge from) the
  * credential the decision was made with.
  */
-export declare function resolveConfiguredRunRouting(skill: Pick<SkillMeta, "name" | "serverOwned">): RunRouting;
+export declare function resolveConfiguredRunRouting(skill: Pick<SkillMeta, "name" | "serverOwned">, env?: Record<string, string | undefined>): Promise<RunRouting>;

package/dist/lib/run-state.d.ts

@@ -25,6 +25,8 @@ export interface SkillRunRecord {
     durationMs?: number;
     remote: boolean;
     remoteRunId?: string;
+    /** Exact configured instance that owns a remote run; absent on historical records. */
+    remoteApiOrigin?: string;
     costCents?: number;
     error?: string;
     artifacts: SkillRunArtifact[];
@@ -47,6 +49,7 @@ export declare function createSkillRun(params: {
     prompt?: string;
     remote?: boolean;
     remoteRunId?: string;
+    remoteApiOrigin?: string;
     costCents?: number;
     status?: SkillRunStatus;
 }, targetDir?: string): SkillRunContext;

package/dist/lib/vendor-host-policy.d.ts

@@ -29,10 +29,41 @@ export declare const APPROVED_CODE_HOSTS: readonly {
     domain: string;
     reason: string;
 }[];
+/**
+ * The public fleet gateway's host.
+ *
+ * Every Hasna CLI reaches its service through one gateway origin, path-prefixed
+ * by app, and since the credential-ladder ruling of 2026-09-04 (hasna/apps#1720,
+ * #1668) that address is the DEFAULT authority in the shared @hasna/contracts
+ * client — so the string ships inside the bundle, on a domain this policy calls
+ * vendor-controlled. It is listed in VENDOR_HOST_URL_EXCEPTIONS below.
+ *
+ * R1 IS NOT WEAKENED BY THIS, because R1 was never about the hostname. It says
+ * an UNCONFIGURED install must not produce a URL, and that still holds exactly:
+ * the shared resolver composes the gateway only AFTER a credential has resolved
+ * (an argument, an env pointer, the macOS Keychain, the credentials file, or
+ * the API-key variable). With no credential there is no URL — which is what
+ * `unconfigured-client-boundary.test.ts` asserts, against the resolvers rather
+ * than against a hostname, so that test needed no weakening either.
+ *
+ * The exception is scoped to exact strings on this one host. Every other
+ * endpoint on a vendor domain still fails, including other paths on this one.
+ *
+ * Typed as `string` rather than left to inference on purpose: a literal type
+ * would print the host into the emitted `.d.ts`, which ships, and the packed
+ * vendor-domain scan reads shipped bytes without caring that they are types.
+ */
+export declare const FLEET_GATEWAY_HOST: string;
 /**
  * Exact URLs that may appear despite being on a vendor domain. Matched on the
  * full URL, never on the domain, so a real endpoint on the same domain still
  * fails. Keep minimal and justified.
+ *
+ * An entry whose path is empty is allowed ONLY for {@link FLEET_GATEWAY_HOST}:
+ * the shared client holds the gateway ORIGIN as a constant and appends the app
+ * slug at runtime, so the origin and its one-slash folded form are the literals
+ * that actually appear in the bundles. Every other vendor host must name an
+ * exact endpoint, so a bare vendor origin can never be excepted.
  */
 export declare const VENDOR_HOST_URL_EXCEPTIONS: readonly {
     url: string;

package/dist/mcp/remote-customer-tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRemoteCustomerTools(server: McpServer): void;

package/dist/sdk/index.d.ts

@@ -9,7 +9,13 @@
  * implementation with the interface as the contract; nothing here duplicates
  * business logic. The SaaS control plane imports this package directly and
  * never spawns the server binaries.
+ *
+ * The client credential seam is re-exported too, so an SDK consumer resolves the
+ * Skills authority and credential exactly the way the CLI and the MCP server do
+ * — the shared @hasna/contracts ladder — instead of reading an environment
+ * variable of its own. See lib/fleet-credentials.ts.
  */
+export { MissingSkillsFleetError, SkillsFleetCredentialError, SKILLS_API_KEY_ENV, SKILLS_API_URL_ENV, SKILLS_APP, configuredSkillsApiUrl, noticeLocalSkillsMode, normalizeSkillsApiOrigin, requireSkillsApiOrigin, requireSkillsFleet, resolveSkillsApiOrigin, resolveSkillsFleet, skillsCredentialFilePath, skillsCredentialFiles, skillsCredentialOrReason, type HostedSkillsFleet, type LocalSkillsFleet, type SkillsFleet, type SkillsFleetErrorCode, type SkillsFleetOptions, } from "../lib/fleet-credentials.js";
 export * from "./server.js";
 export * from "./registry.js";
 export * from "./runs.js";
@@ -24,3 +30,7 @@ export * from "./events.js";
 export * from "./spend.js";
 export * from "./offline.js";
 export * from "./execution/index.js";
+export { RemoteSkillsClient, createRemoteSkillsClient, RemoteRequestError, RemoteRouteUnsupportedError } from "../lib/remote-client.js";
+export { RemoteCreditApprovalError, type RemoteRunApproval, type RemoteRunQuote, type RemoteCreditPack } from "../lib/remote-account.js";
+export { type RemoteInputFile, type RemoteInputFileDescriptor } from "../lib/remote-files.js";
+export { RemoteSkillsAuthClient, HostedApiError } from "../lib/remote-auth.js";