@hasna/skills 0.3.0 → 0.4.0

package/bin/mcp.js

@@ -7608,93 +7608,7 @@ function toV1BaseUrl(apiUrl) {
   url.pathname = `${path}/v1`;
   return url.toString().replace(/\/+$/, "");
 }
-function resolveClientTransportSnapshot(name, env = process.env, options = {}) {
-  env = snapshotClientEnvironment(name, env);
-  const keys = clientTransportEnvKeys(name);
-  const definedUrlEntries = keys.apiUrlKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, raw: String(env[key]) }));
-  const blankUrl = definedUrlEntries.find((entry) => entry.raw.trim().length === 0);
-  if (blankUrl) {
-    throw new ClientTransportConfigurationError(name, `${blankUrl.key} is set but blank; public clients require an explicit HTTPS API URL and never select local storage.`, [blankUrl.key]);
-  }
-  const controlledUrl = definedUrlEntries.find((entry) => ASCII_CONTROL_PATTERN.test(entry.raw));
-  if (controlledUrl) {
-    throw new ClientTransportConfigurationError(name, `${controlledUrl.key} contains ASCII control characters.`, [controlledUrl.key]);
-  }
-  const usableUrlEntries = definedUrlEntries.map((entry) => ({ key: entry.key, value: entry.raw.trim() }));
-  if (usableUrlEntries.length > 1 && new Set(usableUrlEntries.map((entry) => entry.value)).size > 1) {
-    throw new ClientTransportConfigurationError(name, `${usableUrlEntries.map((entry) => entry.key).join(" and ")} disagree; client authority aliases must be identical or only one may be set.`, usableUrlEntries.map((entry) => entry.key));
-  }
-  const envUrlHit = usableUrlEntries[0] ?? null;
-  const keychainUrlHit = keychainConfigValue(name, env, options.credentials?.keychain);
-  const diskConfigUrlHit = appConfigDiskValue(name, env, keys.apiUrlKeys);
-  if (diskConfigUrlHit?.unusable) {
-    throw new ClientTransportConfigurationError(name, `${diskConfigUrlHit.key} in ${diskConfigUrlHit.path} is declared but blank or malformed; public clients require a valid HTTPS service authority.`, [diskConfigUrlHit.path]);
-  }
-  const urlCandidates = [
-    ...envUrlHit ? [envUrlHit] : [],
-    ...keychainUrlHit ? [{ key: keychainUrlHit.source, value: keychainUrlHit.value }] : [],
-    ...diskConfigUrlHit ? [{ key: diskConfigUrlHit.path, value: diskConfigUrlHit.value.trim() }] : []
-  ];
-  const configuredUrl = urlCandidates[0] ?? null;
-  const divergentUrls = urlCandidates.filter((candidate) => candidate.value !== configuredUrl?.value);
-  if (configuredUrl && divergentUrls.length > 0) {
-    throw new ClientTransportConfigurationError(name, `${configuredUrl.key} and ${divergentUrls.map((candidate) => candidate.key).join(" and ")} select different service authorities; refusing to send a credential written for one authority to the other.`, urlCandidates.map((candidate) => candidate.key));
-  }
-  const warnings = [];
-  if (configuredUrl && !envUrlHit) {
-    warnings.push(`No ${keys.apiUrlKeys[0]} in the environment; the server URL in ${configuredUrl.key} was used, so this client connects to the server. ` + `Keep that entry aligned with the intended service authority.`);
-  }
-  const credential = resolveCredential(name, env, options.credentials);
-  if (!credential) {
-    const diskHint = credentialDiskSourcesForMessage(name, env);
-    const lead = configuredUrl ? `${configuredUrl.key} selects the HTTP server for '${name}', but no API key could be resolved` : `${keys.apiUrlKeys[0]} is not set and no API key could be resolved for '${name}'; a credential is required before the default fleet gateway authority applies`;
-    warnings.push(`${lead}; refusing to create an unauthenticated client \u2014 public clients never fall back to SQLite or another local store. ` + `Looked in the Keychain (macOS only), then for a credential file at ${diskHint}, then for ${keys.apiKeyKeys[0]} in the environment.`);
-    throw new ClientTransportConfigurationError(name, warnings.join(" "), [configuredUrl?.key ?? keys.apiUrlKeys[0]]);
-  }
-  if (credential.warning)
-    warnings.push(credential.warning);
-  let urlHit;
-  if (configuredUrl) {
-    urlHit = configuredUrl;
-  } else {
-    try {
-      urlHit = { key: DEFAULT_AUTHORITY_SOURCE, value: defaultFleetGatewayBaseUrl(name) };
-    } catch (error2) {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      throw new ClientTransportConfigurationError(name, `No ${keys.apiUrlKeys[0]} is configured and the default fleet gateway authority cannot be composed for '${name}': ${message}`, [keys.apiUrlKeys[0]]);
-    }
-  }
-  const apiUrlSource = urlHit.key;
-  let baseUrl;
-  try {
-    baseUrl = toV1BaseUrl(urlHit.value);
-  } catch (error2) {
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    throw new ClientTransportConfigurationError(name, `Invalid API URL from ${apiUrlSource}: ${message}`, [apiUrlSource]);
-  }
-  return {
-    resolution: {
-      transport: "http",
-      transportSource: urlHit.key,
-      baseUrl,
-      apiUrlSource,
-      apiKeyPresent: true,
-      apiKeySource: credential.source,
-      apiKeyTier: credential.tier,
-      misconfigured: false,
-      warning: warnings.length > 0 ? warnings.join(" ") : null
-    },
-    credential
-  };
-}
-function resolveClientTransport(name, env = process.env, options = {}) {
-  return resolveClientTransportSnapshot(name, env, options).resolution;
-}
-function credentialDiskSourcesForMessage(name, env) {
-  const paths = credentialDiskSources(name, env);
-  return paths.length > 0 ? paths.join(" or ") : "<no HOME or HASNA_HOME set in this environment, so no credential file was consulted>";
-}
-var CREDENTIAL_PROFILE_ENV_KEY = "HASNA_PROFILE", CredentialResolutionError, CredentialFileUnsafeError, HASNA_HOME_ENV_KEY = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY = "HASNA_STATION", HASNA_HOME_DIR = ".hasna", CONFIG_SUBDIR = "config", CREDENTIALS_FILE = "credentials", KEYCHAIN_SECURITY_BIN = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS = 44, KEYCHAIN_SPAWN_TIMEOUT_MS = 1e4, MAX_CREDENTIAL_FILE_BYTES, SAFE_APP_SLUG, SAFE_PROFILE, ILLEGAL_IN_HEADER_VALUE, VAULT_POINTER_SHAPE, CREDENTIAL_SHAPED_KEY, INSPECT_CUSTOM, CREDENTIAL_SEAL, AMBIENT_ENVIRONMENT, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk, DEFAULT_FLEET_GATEWAY_ORIGIN = "https://api.hasna.com", DEFAULT_AUTHORITY_SOURCE = "default", ASCII_CONTROL_PATTERN, DNS_LABEL_PATTERN, ClientTransportConfigurationError, IDEMPOTENT_METHODS, AUTHORITY_OVERRIDE_HEADERS;
+var CREDENTIAL_PROFILE_ENV_KEY = "HASNA_PROFILE", CredentialResolutionError, CredentialFileUnsafeError, HASNA_HOME_ENV_KEY = "HASNA_HOME", HASNA_CONFIG_HOME_ENV_KEY = "HASNA_CONFIG_HOME", KEYCHAIN_STATION_ENV_KEY = "HASNA_STATION", HASNA_HOME_DIR = ".hasna", CONFIG_SUBDIR = "config", CREDENTIALS_FILE = "credentials", KEYCHAIN_SECURITY_BIN = "/usr/bin/security", KEYCHAIN_SERVICE_PREFIX = "hasna.credentials", KEYCHAIN_ITEM_NOT_FOUND_STATUS = 44, KEYCHAIN_SPAWN_TIMEOUT_MS = 1e4, MAX_CREDENTIAL_FILE_BYTES, SAFE_APP_SLUG, SAFE_PROFILE, ILLEGAL_IN_HEADER_VALUE, VAULT_POINTER_SHAPE, CREDENTIAL_SHAPED_KEY, INSPECT_CUSTOM, CREDENTIAL_SEAL, AMBIENT_ENVIRONMENT, SECRETS_PACKAGE_SPECIFIER, requireSecretsSdk, DEFAULT_FLEET_GATEWAY_ORIGIN = "https://api.hasna.com", ASCII_CONTROL_PATTERN, DNS_LABEL_PATTERN, IDEMPOTENT_METHODS, AUTHORITY_OVERRIDE_HEADERS;
 var init_transport = __esm(() => {
   CredentialResolutionError = class CredentialResolutionError extends Error {
     appName;
@@ -7727,16 +7641,6 @@ var init_transport = __esm(() => {
   requireSecretsSdk = createRequire(import.meta.url);
   ASCII_CONTROL_PATTERN = /[\u0000-\u001f\u007f]/;
   DNS_LABEL_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
-  ClientTransportConfigurationError = class ClientTransportConfigurationError extends Error {
-    appName;
-    sources;
-    constructor(appName, message, sources = []) {
-      super(message);
-      this.name = "ClientTransportConfigurationError";
-      this.appName = appName;
-      this.sources = Object.freeze([...sources]);
-    }
-  };
   IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
   AUTHORITY_OVERRIDE_HEADERS = new Set([
     "host",
@@ -7747,6 +7651,97 @@ var init_transport = __esm(() => {
   ]);
 });
 
+// src/lib/instance-credentials.ts
+import { closeSync as closeSync2, constants, fstatSync as fstatSync2, lstatSync as lstatSync3, openSync as openSync2, readSync } from "fs";
+function selectedSkillsProfile(env, explicit) {
+  const selected = explicit ?? env.HASNA_PROFILE;
+  if (selected === undefined)
+    return null;
+  const profile = selected.trim();
+  if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(profile))
+    throw new Error("Invalid Skills credential profile");
+  return profile;
+}
+function skillsProfileCredentialFiles(env, explicit) {
+  return credentialDiskSourceList("skills", env, selectedSkillsProfile(env, explicit)).map((source) => source.path);
+}
+function fileIdentity(file) {
+  try {
+    return lstatSync3(file);
+  } catch (error2) {
+    if (["ENOENT", "ENOTDIR"].includes(error2.code ?? ""))
+      return null;
+    throw new Error("Cannot inspect Skills instance configuration");
+  }
+}
+function unchanged(before, after) {
+  return before === null || after === null ? before === after : ["dev", "ino", "size", "mtimeMs", "ctimeMs", "mode", "uid"].every((key) => before[key] === after[key]);
+}
+function captureSkillsCredentialFiles(files) {
+  const identities = files.map((file) => [file, fileIdentity(file)]);
+  return () => {
+    if (identities.some(([file, before]) => !unchanged(before, fileIdentity(file)))) {
+      throw new Error("Skills instance configuration changed while resolving credentials; retry without sending a credential");
+    }
+  };
+}
+function readMetadataText(file) {
+  let fd;
+  try {
+    fd = openSync2(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  } catch (error2) {
+    if (["ENOENT", "ENOTDIR"].includes(error2.code ?? ""))
+      return null;
+    throw new Error("Cannot safely read Skills instance configuration");
+  }
+  try {
+    const before = fstatSync2(fd);
+    const uid = process.getuid?.() ?? process.geteuid?.();
+    if (!before.isFile() || ![256, 384].includes(before.mode & 4095) || uid !== undefined && before.uid !== uid || before.size > 64 * 1024) {
+      throw new Error("Unsafe Skills instance configuration; expected a bounded owner-only regular file");
+    }
+    const bytes = Buffer.alloc(64 * 1024 + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = readSync(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    if (length > 64 * 1024 || !unchanged(before, fstatSync2(fd)) || !unchanged(before, fileIdentity(file))) {
+      throw new Error("Skills instance configuration changed while reading");
+    }
+    return bytes.subarray(0, length).toString("utf8");
+  } finally {
+    closeSync2(fd);
+  }
+}
+function readSkillsInstanceMetadata(file) {
+  const text = readMetadataText(file);
+  if (text === null)
+    return {};
+  const values = new Map;
+  for (const line of text.split(/\r?\n/)) {
+    const match = /^\s*(?:export\s+)?(HASNA_SKILLS_API_URL|SKILLS_API_URL|HASNA_SKILLS_BOUND_API_URL)\s*=\s*(.*)$/.exec(line);
+    if (!match)
+      continue;
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))
+      value = value.slice(1, -1);
+    if (!value || /[\x00-\x20\x7f]/.test(value) || values.has(match[1]))
+      throw new Error("Invalid Skills instance configuration");
+    values.set(match[1], value);
+  }
+  const urls = [values.get("HASNA_SKILLS_API_URL"), values.get("SKILLS_API_URL")].filter(Boolean);
+  if (new Set(urls).size > 1)
+    throw new Error("Skills API URL aliases disagree");
+  return { apiUrl: urls[0], binding: values.get(SKILLS_BOUND_API_URL) };
+}
+var SKILLS_BOUND_API_URL = "HASNA_SKILLS_BOUND_API_URL";
+var init_instance_credentials = __esm(() => {
+  init_transport();
+});
+
 // src/lib/fleet-credentials.ts
 var exports_fleet_credentials = {};
 __export(exports_fleet_credentials, {
@@ -7754,6 +7749,7 @@ __export(exports_fleet_credentials, {
   skillsCredentialFiles: () => skillsCredentialFiles,
   skillsCredentialFilePath: () => skillsCredentialFilePath,
   resolveSkillsFleet: () => resolveSkillsFleet,
+  resolveSkillsConnection: () => resolveSkillsConnection,
   resolveSkillsApiOrigin: () => resolveSkillsApiOrigin,
   resolveSkillsApiKey: () => resolveSkillsApiKey,
   resetLocalSkillsModeNotice: () => resetLocalSkillsModeNotice,
@@ -7771,9 +7767,6 @@ __export(exports_fleet_credentials, {
   SKILLS_API_KEY_ENV: () => SKILLS_API_KEY_ENV,
   MissingSkillsFleetError: () => MissingSkillsFleetError
 });
-function isClientTransportConfigurationError(error2) {
-  return error2 instanceof ClientTransportConfigurationError || typeof error2 === "object" && error2 !== null && error2.name === "ClientTransportConfigurationError";
-}
 function isCredentialResolutionError(error2) {
   return error2 instanceof CredentialResolutionError || typeof error2 === "object" && error2 !== null && error2.name === "CredentialResolutionError";
 }
@@ -7784,6 +7777,9 @@ function asSkillsFleetCredentialError(error2) {
 }
 function normalizeSkillsApiOrigin(apiUrl) {
   const url = new URL(apiUrl);
+  if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+    throw new SkillsFleetCredentialError("A Skills API URL must use HTTPS (or loopback HTTP), without credentials, query or fragment", "INVALID_API_URL");
+  }
   const pathname = url.pathname.replace(/\/+$/, "");
   if (pathname === "/api" || pathname === "/api/v1") {
     url.pathname = "/";
@@ -7794,11 +7790,24 @@ function normalizeSkillsApiOrigin(apiUrl) {
   }
   return url.toString().replace(/\/+$/, "");
 }
-function configuredSkillsApiUrl(env = process.env, keychain) {
-  for (const key of SKILLS_API_URL_ENV_KEYS) {
-    const value = env[key]?.trim();
-    if (value)
-      return { value, source: key };
+function configuredSkillsApiUrl(env = process.env, keychain, profile) {
+  const declared = SKILLS_API_URL_ENV_KEYS.filter((key) => env[key] !== undefined).map((key) => ({ key, value: env[key] }));
+  for (const entry of declared) {
+    if (!entry.value.trim() || /[\x00-\x1f\x7f]/.test(entry.value))
+      throw new SkillsFleetCredentialError(`${entry.key} is blank or contains control characters`, "INVALID_API_URL");
+  }
+  const normalized = declared.map((entry) => ({ value: normalizeSkillsApiOrigin(entry.value), source: entry.key }));
+  if (new Set(normalized.map((entry) => entry.value)).size > 1)
+    throw new SkillsFleetCredentialError("Skills API URL aliases disagree", "INVALID_API_URL");
+  if (normalized[0])
+    return normalized[0];
+  if (selectedSkillsProfile(env, profile)) {
+    for (const file of skillsProfileCredentialFiles(env, profile)) {
+      const metadata = readSkillsInstanceMetadata(file);
+      if (metadata.apiUrl || metadata.binding)
+        return { value: metadata.apiUrl ?? metadata.binding, source: file };
+    }
+    return { value: defaultFleetGatewayBaseUrl(SKILLS_APP), source: "default" };
   }
   const fromKeychain = keychainConfigValue(SKILLS_APP, env, keychain);
   if (fromKeychain)
@@ -7812,7 +7821,7 @@ function configuredSkillsApiUrl(env = process.env, keychain) {
   return null;
 }
 function skillsCredentialFiles(env = process.env) {
-  return credentialDiskSources(SKILLS_APP, env);
+  return skillsProfileCredentialFiles(env);
 }
 function skillsCredentialFilePath(env = process.env) {
   const paths = skillsCredentialFiles(env);
@@ -7833,7 +7842,11 @@ function resetLocalSkillsModeNotice() {
 }
 function resolveSkillsFleet(env = process.env, options = {}) {
   try {
-    return resolveSkillsFleetOrThrow(env, options);
+    const snapshot = snapshotSkillsEnvironment(env);
+    const resolved = resolveSkillsFleetOrThrow(snapshot, snapshotSkillsOptions(env, options));
+    if (resolved.mode === "local" && env === process.env)
+      noticeLocalSkillsMode();
+    return resolved;
   } catch (error2) {
     const translated = asSkillsFleetCredentialError(error2);
     if (translated)
@@ -7841,38 +7854,46 @@ function resolveSkillsFleet(env = process.env, options = {}) {
     throw error2;
   }
 }
-function resolveSkillsFleetOrThrow(env, options) {
-  let resolution;
-  try {
-    resolution = resolveClientTransport(SKILLS_APP, env, { credentials: options.credentials });
-  } catch (error2) {
-    if (!isClientTransportConfigurationError(error2))
-      throw error2;
-    const configured2 = configuredSkillsApiUrl(env, options.credentials?.keychain);
-    const credential2 = resolveCredential(SKILLS_APP, env, options.credentials);
-    if (!configured2 && !credential2) {
-      if (env === process.env)
-        noticeLocalSkillsMode();
-      return { mode: "local", apiOrigin: null, apiKey: null };
-    }
-    if (configured2 && !credential2) {
-      throw new SkillsFleetCredentialError(`${configured2.source} points this CLI at a Skills service but no API key resolved \u2014 ` + `refusing to run locally instead. Looked in the Keychain item ` + `hasna.credentials.${SKILLS_APP}.api-key, then ${skillsCredentialFiles(env).join(" or ") || "no credentials file (no HOME)"}, ` + `then ${SKILLS_API_KEY_ENV}. Sign in with: skills auth login`);
+function snapshotSkillsEnvironment(env) {
+  const snapshot = {};
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(env))) {
+    if (!("value" in descriptor)) {
+      if (/^(?:HASNA_|SKILLS_|HOME$|USER$)/.test(key))
+        throw new SkillsFleetCredentialError("Accessor-backed Skills configuration is unsupported");
+      continue;
     }
-    throw error2;
+    snapshot[key] = descriptor.value;
   }
-  const configured = configuredSkillsApiUrl(env, options.credentials?.keychain);
-  const apiOrigin = configured ? normalizeSkillsApiOrigin(configured.value) : stripV1(resolution.baseUrl);
+  return Object.freeze(snapshot);
+}
+function snapshotSkillsOptions(env, options) {
+  if (env !== process.env)
+    return options;
+  return { ...options, credentials: { ...options.credentials, keychain: {
+    ...options.credentials?.keychain,
+    enabled: options.credentials?.keychain?.enabled ?? true
+  } } };
+}
+function resolveSkillsFleetOrThrow(env, options) {
+  const assertFilesUnchanged = captureSkillsCredentialFiles(skillsProfileCredentialFiles(env, options.credentials?.profile));
+  const configured = configuredSkillsApiUrl(env, options.credentials?.keychain, options.credentials?.profile);
   const credential = resolveCredential(SKILLS_APP, env, options.credentials);
   if (!credential) {
-    throw new SkillsFleetCredentialError(`A Skills authority resolved but no API key did. Sign in with: skills auth login`);
+    if (!configured)
+      return { mode: "local", apiOrigin: null, apiKey: null };
+    throw new SkillsFleetCredentialError(`${configured.source} points this CLI at a Skills service but no API key resolved \u2014 refusing to run locally instead. ` + `Looked in hasna.credentials.skills.api-key, ${skillsCredentialFiles(env).join(" or ") || "no credentials file"}, and ${SKILLS_API_KEY_ENV}. Sign in with: skills auth login`);
   }
+  const apiOrigin = normalizeSkillsApiOrigin(configured?.value ?? defaultFleetGatewayBaseUrl(SKILLS_APP));
+  toV1BaseUrl(apiOrigin);
+  assertCredentialInstance(credential, apiOrigin, env, options);
+  assertFilesUnchanged();
   const base = {
     mode: "hosted",
     apiOrigin,
-    apiUrlSource: resolution.apiUrlSource ?? (configured?.source ?? "default"),
-    apiKeySource: resolution.apiKeySource ?? credential.source,
-    apiKeyTier: resolution.apiKeyTier,
-    warning: resolution.warning
+    apiUrlSource: configured?.source ?? "default",
+    apiKeySource: credential.source,
+    apiKeyTier: credential.tier,
+    warning: credential.warning
   };
   if (credential.tier === "pointer") {
     return { ...base, apiKey: null, apiKeyPointer: credential };
@@ -7882,19 +7903,37 @@ function resolveSkillsFleetOrThrow(env, options) {
   }
   return { ...base, apiKey: credential.apiKey, apiKeyPointer: null };
 }
+function assertCredentialInstance(credential, apiOrigin, env, options) {
+  let bound;
+  if (credential.tier === "disk" || credential.tier === "profile") {
+    const metadata = readSkillsInstanceMetadata(credential.source);
+    bound = metadata.binding ?? metadata.apiUrl ?? defaultFleetGatewayBaseUrl(SKILLS_APP);
+  } else if (credential.tier === "keychain") {
+    bound = keychainConfigValue(SKILLS_APP, env, options.credentials?.keychain)?.value ?? defaultFleetGatewayBaseUrl(SKILLS_APP);
+  }
+  if (bound && normalizeSkillsApiOrigin(bound) !== apiOrigin) {
+    throw new SkillsFleetCredentialError("The selected Skills API does not match this credential's instance. Select its profile or sign in to the new instance; no credential was sent.", "INSTANCE_CREDENTIAL_MISMATCH");
+  }
+}
 async function resolveSkillsApiKey(env = process.env, options = {}) {
-  const fleet = resolveSkillsFleet(env, options);
+  return (await resolveSkillsConnection(env, options))?.apiKey ?? null;
+}
+async function resolveSkillsConnection(env = process.env, options = {}) {
+  const snapshotEnv = snapshotSkillsEnvironment(env);
+  const fleet = resolveSkillsFleet(snapshotEnv, snapshotSkillsOptions(env, options));
+  if (fleet.mode === "local" && env === process.env)
+    noticeLocalSkillsMode();
   if (fleet.mode !== "hosted")
     return null;
   if (fleet.apiKey)
-    return fleet.apiKey;
+    return { ...fleet, apiKey: fleet.apiKey };
   const pointer = fleet.apiKeyPointer;
   if (!pointer) {
     throw new SkillsFleetCredentialError(`A Skills authority resolved but no API key did. Sign in with: skills auth login`);
   }
   let completed;
   try {
-    completed = await completePointerCredential(SKILLS_APP, pointer, env);
+    completed = await completePointerCredential(SKILLS_APP, pointer, snapshotEnv);
   } catch (error2) {
     const translated = asSkillsFleetCredentialError(error2);
     if (translated)
@@ -7904,7 +7943,7 @@ async function resolveSkillsApiKey(env = process.env, options = {}) {
   if (!completed.apiKey?.trim()) {
     throw new SkillsFleetCredentialError(`${credentialPointerEnvKey(SKILLS_APP)} names a vault item that produced an empty Skills API key \u2014 ` + `refusing to send an unauthenticated request.`);
   }
-  return completed.apiKey;
+  return { ...fleet, apiKey: completed.apiKey, apiKeyPointer: null };
 }
 async function requireSkillsApiKey(action = "This command", env = process.env, options = {}) {
   const apiKey = await resolveSkillsApiKey(env, options);
@@ -7912,22 +7951,19 @@ async function requireSkillsApiKey(action = "This command", env = process.env, o
     throw new MissingSkillsFleetError(action);
   return apiKey;
 }
-function stripV1(baseUrl) {
-  return baseUrl.replace(/\/v1$/, "").replace(/\/+$/, "");
-}
 async function skillsCredentialOrReason(env = process.env, options = {}) {
   try {
-    const apiKey = await resolveSkillsApiKey(env, options);
-    return apiKey ? { apiKey, reason: null } : { apiKey: null, reason: null };
+    const connection = await resolveSkillsConnection(env, options);
+    return connection ? { apiKey: connection.apiKey, apiOrigin: connection.apiOrigin, reason: null } : { apiKey: null, apiOrigin: null, reason: null };
   } catch (error2) {
     if (error2 instanceof SkillsFleetCredentialError || error2?.name === "SkillsFleetCredentialError") {
-      return { apiKey: null, reason: error2.message };
+      return { apiKey: null, apiOrigin: null, reason: error2.message };
     }
     throw error2;
   }
 }
 function resolveSkillsApiOrigin(env = process.env, options = {}) {
-  const configured = configuredSkillsApiUrl(env, options.credentials?.keychain);
+  const configured = configuredSkillsApiUrl(env, options.credentials?.keychain, options.credentials?.profile);
   if (configured) {
     toV1BaseUrl(configured.value);
     return { origin: normalizeSkillsApiOrigin(configured.value), source: configured.source };
@@ -7950,6 +7986,7 @@ function requireSkillsFleet(action = "This command", env = process.env, options
 var SKILLS_APP = "skills", ENV_KEYS, SKILLS_API_URL_ENV_KEYS, SKILLS_API_KEY_ENV_KEYS, SKILLS_API_URL_ENV, SKILLS_API_KEY_ENV, SkillsFleetCredentialError, localNoticePrinted = false, MissingSkillsFleetError;
 var init_fleet_credentials = __esm(() => {
   init_transport();
+  init_instance_credentials();
   ENV_KEYS = clientTransportEnvKeys(SKILLS_APP);
   SKILLS_API_URL_ENV_KEYS = ENV_KEYS.apiUrlKeys;
   SKILLS_API_KEY_ENV_KEYS = ENV_KEYS.apiKeyKeys;
@@ -8102,15 +8139,181 @@ var init_blog_article = __esm(() => {
   ARTICLE_LENGTHS = ["short", "medium", "long"];
 });
 
+// src/lib/remote-files.ts
+var exports_remote_files = {};
+__export(exports_remote_files, {
+  sha256: () => sha256,
+  readBoundedResponse: () => readBoundedResponse,
+  describeRemoteFiles: () => describeRemoteFiles,
+  decodeRemoteFiles: () => decodeRemoteFiles,
+  MAX_REMOTE_FILE_BYTES: () => MAX_REMOTE_FILE_BYTES
+});
+import { createHash as createHash3 } from "crypto";
+function describeRemoteFiles(files) {
+  if (files.length > 10)
+    throw new Error("At most 10 input files are supported");
+  const names = new Set;
+  let total = 0;
+  return files.map((file) => {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/.test(file.name) || file.name === "." || file.name === ".." || names.has(file.name))
+      throw new Error("Input file names must be unique safe basenames");
+    names.add(file.name);
+    total += file.bytes.byteLength;
+    if (file.bytes.byteLength > 20 * 1024 * 1024 || total > 50 * 1024 * 1024)
+      throw new Error("Input files exceed the supported size limit");
+    return { name: file.name, sizeBytes: file.bytes.byteLength, sha256: sha256(file.bytes), contentType: file.contentType ?? "application/octet-stream" };
+  });
+}
+function sha256(bytes) {
+  return createHash3("sha256").update(bytes).digest("hex");
+}
+async function readBoundedResponse(response, maximum) {
+  if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > MAX_REMOTE_FILE_BYTES)
+    throw new Error("Invalid artifact size limit");
+  const length = response.headers.get("content-length");
+  if (length && (!/^\d+$/.test(length) || Number(length) > maximum)) {
+    await response.body?.cancel();
+    throw new Error("Artifact exceeds its declared size limit");
+  }
+  const reader = response.body?.getReader();
+  if (!reader)
+    return new Uint8Array;
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done)
+        break;
+      size += next.value.byteLength;
+      if (size > maximum)
+        throw new Error("Artifact exceeds its declared size limit");
+      chunks.push(next.value);
+    }
+  } catch (error2) {
+    await reader.cancel().catch(() => {});
+    throw error2;
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function decodeRemoteFiles(files) {
+  let total = 0;
+  const decoded = files.map((file) => {
+    if (file.base64.length > 1398104 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(file.base64))
+      throw new Error("Invalid inline input encoding");
+    const bytes = Buffer.from(file.base64, "base64");
+    total += bytes.byteLength;
+    if (total > 1024 * 1024 || bytes.toString("base64") !== file.base64)
+      throw new Error("Inline inputs must total at most 1 MiB");
+    return { name: file.name, bytes, contentType: file.contentType };
+  });
+  describeRemoteFiles(decoded);
+  return decoded;
+}
+var MAX_REMOTE_FILE_BYTES;
+var init_remote_files = __esm(() => {
+  MAX_REMOTE_FILE_BYTES = 64 * 1024 * 1024;
+});
+
 // src/lib/auth-store.ts
 function getApiUrl(action, env = process.env, options = {}) {
   return requireSkillsApiOrigin(action, env, options);
 }
 var init_auth_store = __esm(() => {
+  init_transport();
+  init_instance_credentials();
   init_fleet_credentials();
+  init_transport();
   init_fleet_credentials();
 });
 
+// src/lib/remote-account.ts
+function creditCount(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 2147483647) {
+    throw new Error("The Skills server returned an invalid credit count");
+  }
+  return value;
+}
+function parseRemoteRunQuote(value) {
+  const quote = object4(value);
+  const pricing = object4(quote.pricing);
+  if (typeof quote.skill !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(quote.skill))
+    throw new Error("Invalid quoted skill");
+  const costCents = creditCount(pricing.costCredits ?? pricing.costCents);
+  if (pricing.costCredits !== undefined && pricing.costCents !== undefined && pricing.costCents !== costCents)
+    throw new Error("Inconsistent quoted credit count");
+  if (quote.availability && object4(quote.availability).status !== "available")
+    throw new Error("This skill is unavailable for remote execution");
+  return { ...quote, skill: quote.skill, pricing: { ...pricing, costCredits: costCents, costCents, formattedCost: `${costCents} credits` } };
+}
+function parseRemoteCreditPacks(value) {
+  if (!Array.isArray(value))
+    throw new Error("Invalid credit pack response");
+  const ids = new Set;
+  return value.map((value2) => {
+    const row = object4(value2);
+    const counts = [row.credits, row.creditsCents, row.amountCents].filter((value3) => value3 !== undefined).map(creditCount);
+    if (!counts.length || counts[0] === 0 || counts.some((count) => count !== counts[0]))
+      throw new Error("Inconsistent credit pack counts");
+    const credits = counts[0];
+    const id = row.id ?? `credits_${credits}`;
+    if (typeof id !== "string" || !/^[a-z0-9][a-z0-9_-]{0,99}$/.test(id) || ids.has(id))
+      throw new Error("Invalid credit pack ID");
+    if (id.startsWith("credits_") && id !== `credits_${credits}`)
+      throw new Error("Inconsistent credit pack ID");
+    ids.add(id);
+    return { id, credits, ...row.expiresInDays === undefined ? {} : { expiresInDays: creditCount(row.expiresInDays) } };
+  });
+}
+function parseRemoteBillingStatus(value) {
+  const row = object4(value);
+  const counts = [row.creditBalance, row.balanceCents].filter((value2) => value2 !== undefined).map(creditCount);
+  if (!counts.length || counts.some((count) => count !== counts[0]))
+    throw new Error("Inconsistent credit balance");
+  return {
+    creditBalance: counts[0],
+    formattedCreditBalance: `${counts[0]} credits`,
+    ...typeof row.plan === "string" ? { plan: row.plan } : {},
+    ...typeof row.hasPaymentMethod === "boolean" ? { hasPaymentMethod: row.hasPaymentMethod } : {}
+  };
+}
+function parseRemoteCheckout(value) {
+  const row = object4(value);
+  if (typeof row.url !== "string")
+    throw new Error("Invalid checkout URL");
+  const url = new URL(row.url);
+  if (url.protocol !== "https:" || url.username || url.password)
+    throw new Error("Invalid checkout URL");
+  return { url: row.url };
+}
+function object4(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid Skills server response");
+  return value;
+}
+var RemoteCreditApprovalError;
+var init_remote_account = __esm(() => {
+  RemoteCreditApprovalError = class RemoteCreditApprovalError extends Error {
+    requiredCredits;
+    maximumCredits;
+    code = "CREDIT_APPROVAL_REQUIRED";
+    constructor(requiredCredits, maximumCredits) {
+      super(`This run requires ${requiredCredits} credits; the approved maximum is ${maximumCredits}. Quote the run and explicitly approve its cost.`);
+      this.requiredCredits = requiredCredits;
+      this.maximumCredits = maximumCredits;
+      this.name = "RemoteCreditApprovalError";
+    }
+  };
+});
+
 // src/lib/remote-client.ts
 var exports_remote_client = {};
 __export(exports_remote_client, {
@@ -8124,13 +8327,16 @@ __export(exports_remote_client, {
 class RemoteSkillsClient {
   apiUrl;
   apiKey;
+  capabilities;
   constructor(apiKey, apiUrl = getApiUrl()) {
     this.apiKey = apiKey;
-    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.apiUrl = normalizeSkillsApiOrigin(apiUrl);
   }
   async request(path, options) {
     return fetch(`${this.apiUrl}${path}`, {
       ...options,
+      redirect: "error",
+      signal: options?.signal ?? AbortSignal.timeout(15000),
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json",
@@ -8153,8 +8359,7 @@ class RemoteSkillsClient {
     return response;
   }
   async listSkills() {
-    const res = await this.request("/api/v1/skills");
-    return res.json();
+    return this.arrayResponse("/api/v1/skills");
   }
   async getSkillMd(slug) {
     const res = await this.request(`/api/v1/skills/${slug}/skill.md`);
@@ -8176,39 +8381,217 @@ class RemoteSkillsClient {
     } catch {}
     return { status: res.status, body };
   }
-  async submitRun(slug, input, args) {
-    const res = await this.request(`/api/v1/runs/${slug}`, {
+  async submitRun(slug, input, args, approval = {}) {
+    if (approval.idempotencyKey !== undefined && !/^[A-Za-z0-9._:-]{1,128}$/.test(approval.idempotencyKey))
+      throw new Error("Idempotency key must be 1-128 URL-safe characters");
+    if (approval.maxCostCents !== undefined)
+      creditCount(approval.maxCostCents);
+    if (approval.maxCredits !== undefined)
+      creditCount(approval.maxCredits);
+    if (approval.maxCredits !== undefined && approval.maxCostCents !== undefined && approval.maxCredits !== approval.maxCostCents)
+      throw new Error("Credit approval fields disagree");
+    const res = await this.request(`/api/v1/runs/${encodeURIComponent(slug)}`, {
       method: "POST",
-      body: JSON.stringify({ input, args })
+      body: JSON.stringify({
+        input,
+        args,
+        ...approval.maxCredits !== undefined ? { maxCredits: approval.maxCredits } : {},
+        ...approval.maxCostCents !== undefined ? { maxCostCents: approval.maxCostCents } : {},
+        ...approval.idempotencyKey !== undefined ? { idempotencyKey: approval.idempotencyKey } : {},
+        ...approval.inputFiles !== undefined ? { files: approval.inputFiles } : {}
+      })
     });
     return normalizeRemoteSkillRunContract(await res.json(), slug);
   }
+  async quoteRun(slug, input = {}, args = []) {
+    const response = await this.requestNewRoute(`/api/v1/skills/${encodeURIComponent(slug)}/quote`, {
+      method: "POST",
+      body: JSON.stringify({ input, args })
+    });
+    return parseRemoteRunQuote(await response.json());
+  }
+  getCapabilities() {
+    if (!this.capabilities)
+      this.capabilities = (async () => {
+        const value = await (await this.requestNewRoute("/api/v1/capabilities")).json();
+        if (value.contractVersion !== 1 || value.apiVersion !== 1 || !Array.isArray(value.capabilities) || value.capabilities.some((item) => typeof item !== "string"))
+          throw new Error("Unsupported Skills server capability contract");
+        const billing = value.billing;
+        return { contractVersion: 1, apiVersion: 1, capabilities: value.capabilities, ...billing ? { billing } : {} };
+      })();
+    return this.capabilities;
+  }
+  async submitQuotedRun(slug, input = {}, args = [], approval = {}) {
+    const maximum = creditCount(approval.maxCredits ?? approval.maxCostCents ?? 0);
+    if (approval.maxCostCents !== undefined && approval.maxCostCents !== maximum)
+      throw new Error("Credit approval fields disagree");
+    const quote = await this.quoteRun(slug, input, args);
+    if (quote.pricing.costCents > maximum)
+      throw new RemoteCreditApprovalError(quote.pricing.costCents, maximum);
+    const capabilities = await this.getCapabilities();
+    if (!capabilities.capabilities.includes("runs.submit") || capabilities.billing?.boundedRunApproval !== true || capabilities.billing.unit !== "credits") {
+      throw new Error("The configured server does not support bounded credit approval; refusing remote submission");
+    }
+    return this.submitRun(quote.skill, input, args, { ...approval, maxCredits: maximum, maxCostCents: maximum });
+  }
+  async getIdentity() {
+    return (await this.requestNewRoute("/api/auth/whoami")).json();
+  }
+  async listApiKeys() {
+    return this.arrayResponse("/api/auth/keys");
+  }
+  async createApiKey(name, scopes) {
+    if (!name.trim() || name.length > 100)
+      throw new Error("API key name must be 1-100 characters");
+    const value = await (await this.requestNewRoute("/api/auth/keys", { method: "POST", body: JSON.stringify({ name, ...scopes ? { scopes } : {} }) })).json();
+    if (!value || typeof value.key !== "string" || !value.key.trim())
+      throw new Error("The server did not return a created API key");
+    return value;
+  }
+  async revokeApiKey(keyId) {
+    return (await this.requestNewRoute(`/api/auth/keys/${encodeURIComponent(keyId)}`, { method: "DELETE" })).json();
+  }
+  async getBillingStatus() {
+    return parseRemoteBillingStatus(await (await this.requestNewRoute("/api/v1/billing/status")).json());
+  }
+  async listCreditPacks() {
+    return parseRemoteCreditPacks(await (await this.requestNewRoute("/api/v1/billing/credits")).json());
+  }
+  async createCreditCheckout(packId) {
+    const packs = await this.listCreditPacks();
+    if (!packs.some((pack) => pack.id === packId))
+      throw new Error("Choose a credit pack returned by skills credits packs");
+    return parseRemoteCheckout(await (await this.requestNewRoute("/api/v1/billing/credits", {
+      method: "POST",
+      body: JSON.stringify({ packId })
+    })).json());
+  }
+  async getUsage() {
+    return this.arrayResponse("/api/v1/billing/usage");
+  }
+  async listInvoices() {
+    return this.arrayResponse("/api/v1/billing/invoices");
+  }
+  async createBillingCheckout() {
+    return this.checkoutResponse("/api/v1/billing/checkout");
+  }
+  async createBillingPortal() {
+    return this.checkoutResponse("/api/v1/billing/portal");
+  }
+  async cancelRun(runId) {
+    return this.controlRun(runId, "cancel");
+  }
+  async resumeRun(runId) {
+    return this.controlRun(runId, "resume");
+  }
+  async controlRun(runId, action) {
+    const response = await this.requestNewRoute(`/api/v1/runs/${encodeURIComponent(runId)}/${action}`, { method: "POST", body: "{}" });
+    return normalizeRemoteSkillRunContract(await response.json());
+  }
+  async checkoutResponse(path) {
+    return parseRemoteCheckout(await (await this.requestNewRoute(path, { method: "POST", body: "{}" })).json());
+  }
+  async arrayResponse(path) {
+    const rows = await (await this.requestNewRoute(path)).json();
+    if (!Array.isArray(rows) || rows.some((row) => !row || typeof row !== "object" || Array.isArray(row)))
+      throw new Error("Invalid Skills server list response");
+    return rows;
+  }
   async getRun(runId) {
-    const res = await this.request(`/api/v1/runs/${runId}`);
-    if (!res.ok)
+    const path = `/api/v1/runs/${encodeURIComponent(runId)}`;
+    const res = await this.request(path);
+    if (res.status === 404)
       return null;
+    if (!res.ok)
+      throw new RemoteRequestError(path, res.status, res.statusText);
     return normalizeRemoteSkillRunContract(await res.json());
   }
   async getRunLogs(runId) {
-    const res = await this.request(`/api/v1/runs/${runId}/logs`);
-    if (!res.ok)
-      return [];
-    const payload = await res.json();
-    return Array.isArray(payload) ? payload : [];
+    return this.arrayResponse(`/api/v1/runs/${encodeURIComponent(runId)}/logs`);
   }
   async listRuns(limit = 20) {
-    const res = await this.request(`/api/v1/runs?limit=${limit}`);
-    return res.json();
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+      throw new Error("Run limit must be an integer from 1 to 100");
+    return this.arrayResponse(`/api/v1/runs?limit=${limit}`);
   }
   async getRunArtifacts(runId) {
-    const res = await this.request(`/api/v1/runs/${runId}/artifacts`);
-    return res.json();
+    return this.arrayResponse(`/api/v1/runs/${encodeURIComponent(runId)}/artifacts`);
   }
   async downloadRunArtifact(runId, artifactId) {
-    return this.request(`/api/v1/runs/${runId}/artifacts/${artifactId}/download`, {
+    return this.request(`/api/v1/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(artifactId)}/download`, {
       method: "GET"
     });
   }
+  async getVerifiedRunArtifact(runId, artifactId, maximumBytes = MAX_REMOTE_FILE_BYTES) {
+    const artifacts = await this.getRunArtifacts(runId);
+    const artifact = artifacts.find((row) => row.id === artifactId);
+    if (!artifact)
+      throw new Error("Run artifact not found");
+    if (!Number.isSafeInteger(artifact.byteSize) || artifact.byteSize < 0 || artifact.byteSize > maximumBytes || typeof artifact.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(artifact.sha256))
+      throw new Error("The server does not provide valid artifact integrity metadata");
+    const response = await this.downloadRunArtifact(runId, artifactId);
+    if (!response.ok)
+      throw new RemoteRequestError("artifact download", response.status, response.statusText);
+    const bytes = await readBoundedResponse(response, artifact.byteSize);
+    if (bytes.byteLength !== artifact.byteSize || sha256(bytes) !== artifact.sha256)
+      throw new Error("Artifact integrity verification failed");
+    return { id: artifactId, fileName: String(artifact.fileName ?? artifactId), bytes, byteSize: bytes.byteLength, sha256: artifact.sha256 };
+  }
+  async submitQuotedRunWithFiles(slug, input, args, files, approval = {}) {
+    const inputFiles = describeRemoteFiles(files);
+    if (files.length && !(await this.getCapabilities()).capabilities.includes("runs.uploads"))
+      throw new Error("The configured server does not support input uploads");
+    const run = await this.submitQuotedRun(slug, input, args, { ...approval, inputFiles });
+    if (run.error || !run.id || !files.length)
+      return run;
+    const pastUploads = (status) => typeof status === "string" && [
+      "running",
+      "completed",
+      "failed",
+      "cancelled",
+      "expired",
+      "pending_approval",
+      "approved",
+      "waiting"
+    ].includes(status);
+    if (pastUploads(run.status))
+      return run;
+    try {
+      await this.uploadRunFiles(run.id, files);
+    } catch {
+      try {
+        const current = await this.getRun(run.id);
+        if (current && pastUploads(current.status))
+          return current;
+      } catch {}
+      let cancellationRequested = false;
+      try {
+        await this.cancelRun(run.id);
+        cancellationRequested = true;
+      } catch {}
+      throw new Error(`Input upload failed for run ${run.id}; ${cancellationRequested ? "cancellation requested" : "check its status and cancel the run"}`);
+    }
+    return run;
+  }
+  async uploadRunFiles(runId, files) {
+    const descriptors = describeRemoteFiles(files);
+    const response = await this.requestNewRoute(`/api/v1/runs/${encodeURIComponent(runId)}/uploads`, { method: "POST", body: JSON.stringify({ files: descriptors }) });
+    const payload = await response.json();
+    if (!Array.isArray(payload.files) || payload.files.length !== files.length || new Set(payload.files.map((file) => file.name)).size !== files.length)
+      throw new Error("Invalid input upload response");
+    for (const file of files) {
+      const upload = payload.files.find((row) => row.name === file.name);
+      if (!upload)
+        throw new Error("Missing input upload URL");
+      const url = new URL(upload.uploadUrl);
+      if (url.username || url.password || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)))
+        throw new Error("Unsafe input upload URL");
+      const uploaded = await fetch(url, { method: "PUT", body: file.bytes, headers: { "Content-Type": file.contentType ?? "application/octet-stream" }, redirect: "error", signal: AbortSignal.timeout(60000) });
+      if (!uploaded.ok)
+        throw new Error("Input upload failed");
+      await uploaded.body?.cancel();
+    }
+  }
   async publishSkill(manifest, bundle, ifMatch) {
     const form = new FormData;
     form.set("manifest", JSON.stringify(manifest));
@@ -8221,7 +8604,9 @@ class RemoteSkillsClient {
     return fetch(`${this.apiUrl}/api/v1/skills`, {
       method: "POST",
       headers,
-      body: form
+      body: form,
+      redirect: "error",
+      signal: AbortSignal.timeout(15000)
     });
   }
   async deleteSkill(slug) {
@@ -8277,12 +8662,13 @@ class RemoteSkillsClient {
     if (!Array.isArray(payload)) {
       throw new Error("Remote tags payload did not match the expected contract (expected an array of tag names)");
     }
-    for (const tag of payload) {
-      if (typeof tag !== "string" || tag.trim().length === 0) {
-        throw new Error("Remote tags payload did not match the expected contract (every element must be a non-empty tag name)");
-      }
+    const isName = (value) => typeof value === "string" && value.trim().length > 0;
+    if (payload.every(isName))
+      return payload;
+    if (payload.every((tag) => tag !== null && typeof tag === "object" && !Array.isArray(tag) && isName(tag.name) && Number.isSafeInteger(tag.count) && tag.count >= 0)) {
+      return payload.map((tag) => tag.name);
     }
-    return payload;
+    throw new Error("Remote tags payload did not match the expected contract (every element must be a non-empty tag name, or every element must be a counted tag record)");
   }
   async skillsByTag(tag) {
     const path = `/api/v1/tags/${encodeURIComponent(tag)}/skills`;
@@ -8385,14 +8771,8 @@ function normalizeUpdatedSincePage(payload) {
   return { skills, nextCursor };
 }
 async function createRemoteSkillsClient(env = process.env) {
-  const fleet = resolveSkillsFleet(env);
-  if (fleet.mode !== "hosted")
-    return null;
-  const apiKey = await resolveSkillsApiKey(env);
-  if (!apiKey) {
-    throw new Error("A Skills authority resolved but no API key did. Sign in with: skills auth login");
-  }
-  return new RemoteSkillsClient(apiKey, fleet.apiOrigin);
+  const connection = await resolveSkillsConnection(env);
+  return connection ? new RemoteSkillsClient(connection.apiKey, connection.apiOrigin) : null;
 }
 function createRemoteSkillsClientReadOnly(env = process.env) {
   return createRemoteSkillsClient(env);
@@ -8401,6 +8781,8 @@ var RemoteRouteUnsupportedError, RemoteRequestError;
 var init_remote_client = __esm(() => {
   init_auth_store();
   init_fleet_credentials();
+  init_remote_account();
+  init_remote_files();
   RemoteRouteUnsupportedError = class RemoteRouteUnsupportedError extends Error {
     path;
     status;
@@ -13941,7 +14323,7 @@ class StdioServerTransport {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.3.0",
+  version: "0.4.0",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -14000,8 +14382,7 @@ var package_default = {
     "verify:release": "bun run scripts/release-guard.ts",
     prepare: "bun run build:js",
     prepack: "bun run build && bun run verify:release",
-    prepublishOnly: "bun run typecheck && bun run test",
-    postinstall: "mkdir -p $HOME/.hasna/skills/custom 2>/dev/null || true"
+    prepublishOnly: "bun run typecheck && bun run test"
   },
   keywords: [
     "skills",
@@ -22993,6 +23374,16 @@ function isHostedMetadataSkill(skillName, frontmatter, registryMeta, packageDecl
     return true;
   return false;
 }
+function frontmatterString(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"')) {
+    try {
+      const decoded = JSON.parse(raw);
+      if (typeof decoded === "string")
+        return decoded;
+    } catch {}
+  }
+  return raw.replace(/^["']|["']$/g, "");
+}
 function parseSkillFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match)
@@ -23012,12 +23403,12 @@ function parseSkillFrontmatter(content) {
       const tags = [];
       while (i + 1 < lines.length && /^\s+-\s+/.test(lines[i + 1])) {
         i++;
-        tags.push(lines[i].replace(/^\s+-\s+/, "").trim());
+        tags.push(frontmatterString(lines[i].replace(/^\s+-\s+/, "").trim()));
       }
       result.tags = tags;
       continue;
     }
-    const value = rawValue.replace(/^["']|["']$/g, "");
+    const value = frontmatterString(rawValue);
     if (!value)
       continue;
     if (key === "name")
@@ -23626,8 +24017,8 @@ function createInstructionManifest(name, options) {
     description: options.description,
     version: PORTABLE_SKILL_DEFAULT_VERSION,
     displayName: displayName(name),
-    category: "Development Tools",
-    tags: ["custom", name],
+    category: options.category ?? "Development Tools",
+    tags: options.tags ?? ["custom", name],
     kind: "instruction",
     inputs: [],
     commands: [],
@@ -23642,16 +24033,16 @@ function writeInstructionSkillTemplate(skillPath, manifest) {
 }
 function renderInstructionSkillMd(manifest) {
   const tags = manifest.tags?.length ? `tags:
-${manifest.tags.map((tag) => `  - ${tag}`).join(`
+${manifest.tags.map((tag) => `  - ${yamlString(tag)}`).join(`
 `)}
 ` : "";
   return `---
 name: ${manifest.name}
-description: ${manifest.description}
+description: ${yamlString(manifest.description)}
 kind: instruction
 version: ${manifest.version}
 source: custom
-category: ${manifest.category ?? "Development Tools"}
+category: ${yamlString(manifest.category ?? "Development Tools")}
 ${tags}---
 
 # ${manifest.displayName ?? displayName(manifest.name)}
@@ -23672,8 +24063,8 @@ function createPortableManifest(name, options) {
     description: options.description,
     version: PORTABLE_SKILL_DEFAULT_VERSION,
     displayName: displayName(name),
-    category: "Development Tools",
-    tags: ["custom", name],
+    category: options.category ?? "Development Tools",
+    tags: options.tags ?? ["custom", name],
     inputs: DEFAULT_INPUTS,
     commands: [{
       name,
@@ -23864,10 +24255,13 @@ function isExcludedCopyEntry(name, isFirstSegment) {
     return true;
   return false;
 }
+function yamlString(value) {
+  return JSON.stringify(value);
+}
 function renderSkillMd(manifest) {
   return `---
 name: ${manifest.name}
-description: ${manifest.description}
+description: ${yamlString(manifest.description)}
 ---
 
 # ${manifest.displayName ?? displayName(manifest.name)}
@@ -24241,11 +24635,11 @@ function scaffoldPortableSkill(name, options = {}) {
   const kind = options.kind ?? "executable";
   const description = options.description ?? `${displayName(skillName)} skill`;
   if (kind === "instruction") {
-    const manifest2 = createInstructionManifest(skillName, { description });
+    const manifest2 = createInstructionManifest(skillName, { description, category: options.category, tags: options.tags });
     writeInstructionSkillTemplate(skillPath, manifest2);
     return { name: skillName, path: skillPath, manifest: manifest2, created: true };
   }
-  const manifest = createPortableManifest(skillName, { description });
+  const manifest = createPortableManifest(skillName, { description, category: options.category, tags: options.tags });
   writePortableSkillTemplate(skillPath, manifest);
   return { name: skillName, path: skillPath, manifest, created: true };
 }
@@ -25265,6 +25659,24 @@ function readIfExists(path) {
   return null;
 }
 
+// src/lib/remote-customer-operations.ts
+var REMOTE_CUSTOMER_OPERATIONS = [
+  { name: "get_account", title: "Get Account Identity", parameter: null, mutates: false, invoke: (client) => client.getIdentity() },
+  { name: "get_server_capabilities", title: "Get Server Capabilities", parameter: null, mutates: false, invoke: (client) => client.getCapabilities() },
+  { name: "list_remote_skills", title: "List Remote Skills", parameter: null, mutates: false, invoke: (client) => client.listSkills() },
+  { name: "get_billing_status", title: "Get Billing Status", parameter: null, mutates: false, invoke: (client) => client.getBillingStatus() },
+  { name: "list_credit_packs", title: "List Credit Packs", parameter: null, mutates: false, invoke: (client) => client.listCreditPacks() },
+  { name: "create_credit_checkout", title: "Create Credit Checkout", parameter: "pack_id", mutates: true, invoke: (client, value) => client.createCreditCheckout(value) },
+  { name: "get_billing_usage", title: "Get Billing Usage", parameter: null, mutates: false, invoke: (client) => client.getUsage() },
+  { name: "list_invoices", title: "List Invoices", parameter: null, mutates: false, invoke: (client) => client.listInvoices() },
+  { name: "create_billing_checkout", title: "Create Billing Checkout", parameter: null, mutates: true, invoke: (client) => client.createBillingCheckout() },
+  { name: "create_billing_portal", title: "Create Billing Portal", parameter: null, mutates: true, invoke: (client) => client.createBillingPortal() },
+  { name: "get_run_logs", title: "Get Run Logs", parameter: "run_id", mutates: false, invoke: (client, value) => client.getRunLogs(value) },
+  { name: "cancel_run", title: "Cancel Run", parameter: "run_id", mutates: true, invoke: (client, value) => client.cancelRun(value) },
+  { name: "resume_run", title: "Resume Run", parameter: "run_id", mutates: true, invoke: (client, value) => client.resumeRun(value) },
+  { name: "list_run_artifacts", title: "List Run Artifacts", parameter: "run_id", mutates: false, invoke: (client, value) => client.getRunArtifacts(value) }
+];
+
 // src/lib/mcp-contracts.ts
 var MCP_CONTRACT_SCHEMA_VERSION = 1;
 var stringSchema = (description) => ({
@@ -25656,11 +26068,44 @@ var toolContracts = [
       dependencies: objectSchema({}, [], "Package dependencies.", true)
     })
   },
+  {
+    name: "list_api_keys",
+    title: "List API Keys",
+    description: "List keys using fresh email OTP reauthentication.",
+    params: ["email", "code"],
+    category: "execution",
+    sideEffects: "local-process-or-remote-run",
+    stable: true,
+    inputSchema: objectSchema({ email: { type: "string", format: "email" }, code: { type: "string", pattern: "^\\d{6}$" } }, ["email", "code"]),
+    outputSchema: arraySchema(objectSchema({}, [], "API key metadata", true))
+  },
+  {
+    name: "revoke_api_key",
+    title: "Revoke API Key",
+    description: "Revoke a key using fresh email OTP reauthentication.",
+    params: ["key_id", "email", "code"],
+    category: "execution",
+    sideEffects: "local-process-or-remote-run",
+    stable: true,
+    inputSchema: objectSchema({ key_id: stringSchema("API key ID"), email: { type: "string", format: "email" }, code: { type: "string", pattern: "^\\d{6}$" } }, ["key_id", "email", "code"]),
+    outputSchema: objectSchema({}, [], "Revocation result", true)
+  },
+  {
+    name: "create_api_key",
+    title: "Create API Key",
+    description: "Create a key with fresh email OTP reauthentication; returns the secret once.",
+    params: ["name", "email", "code", "scopes?"],
+    category: "execution",
+    sideEffects: "local-process-or-remote-run",
+    stable: true,
+    inputSchema: objectSchema({ name: stringSchema("Key name"), email: { type: "string", format: "email" }, code: { type: "string", pattern: "^\\d{6}$" }, scopes: arraySchema(stringSchema("Scope")) }, ["name", "email", "code"]),
+    outputSchema: objectSchema({}, [], "Created key and one-time secret", true)
+  },
   {
     name: "run_skill",
     title: "Run Skill",
     description: "Run a skill locally or through a configured remote runner. Returns compact stdout/stderr previews and run summaries by default; pass detail:true for full records.",
-    params: ["name", "input?", "args?", "detail?"],
+    params: ["name", "input?", "args?", "detail?", "remote?", "maxCredits?", "maxCostCents?", "idempotency_key?", "files?"],
     category: "execution",
     sideEffects: "local-process-or-remote-run",
     stable: true,
@@ -25668,7 +26113,12 @@ var toolContracts = [
       name: skillNameInput,
       input: runInputSchema,
       args: runArgsSchema,
-      detail: { type: "boolean", default: false, description: "Return full stdout/stderr, remote run, and local run metadata." }
+      detail: { type: "boolean", default: false, description: "Return full stdout/stderr, remote run, and local run metadata." },
+      remote: { type: "boolean", description: "Use the configured server catalog." },
+      maxCredits: { type: "integer", minimum: 0, description: "Maximum explicitly approved integer credits; omitted permits only free remote runs." },
+      maxCostCents: { type: "integer", minimum: 0, description: "Legacy alias for maxCredits; both must agree." },
+      idempotency_key: { type: "string", pattern: "^[A-Za-z0-9._:-]{1,128}$", description: "Stable retry key for the same remote submission." },
+      files: { type: "array", maxItems: 10, items: objectSchema({ name: stringSchema("Safe basename"), base64: { type: "string", maxLength: 1398104 }, contentType: stringSchema("MIME type") }, ["name", "base64"]), description: "Inline remote inputs, at most 1 MiB combined." }
     }, ["name"]),
     outputSchema: runOutputSchema
   },
@@ -25935,7 +26385,40 @@ var toolContracts = [
     outputSchema: objectSchema({}, [], "Feedback save result.", true)
   }
 ];
-var contracts = [...toolContracts].sort((a, b) => a.name.localeCompare(b.name));
+var remoteCustomerContracts = REMOTE_CUSTOMER_OPERATIONS.map((operation) => ({
+  name: operation.name,
+  title: operation.title,
+  description: `${operation.title} on the configured server; unavailable capabilities fail explicitly.`,
+  params: operation.parameter ? [operation.parameter] : [],
+  category: "execution",
+  sideEffects: operation.mutates ? "local-process-or-remote-run" : "none",
+  stable: true,
+  inputSchema: objectSchema(operation.parameter ? { [operation.parameter]: stringSchema("Server resource identifier.") } : {}, operation.parameter ? [operation.parameter] : []),
+  outputSchema: { oneOf: [objectSchema({}, [], "Server response.", true), { type: "array", items: objectSchema({}, [], "Server record.", true) }] }
+}));
+remoteCustomerContracts.push({
+  name: "quote_skill",
+  title: "Quote Remote Skill",
+  description: "Get a server credit quote without submitting a run.",
+  params: ["name", "input?", "args?"],
+  category: "execution",
+  sideEffects: "none",
+  stable: true,
+  inputSchema: objectSchema({ name: skillNameInput, input: runInputSchema, args: runArgsSchema }, ["name"]),
+  outputSchema: objectSchema({ skill: stringSchema("Canonical server skill."), pricing: objectSchema({}, [], "Quoted integer credits.", true) }, ["skill", "pricing"], undefined, true)
+});
+remoteCustomerContracts.push({
+  name: "download_run_artifact",
+  title: "Download Verified Run Artifact",
+  description: "Return verified artifact bytes as base64, bounded to 1 MiB.",
+  params: ["run_id", "artifact_id"],
+  category: "execution",
+  sideEffects: "none",
+  stable: true,
+  inputSchema: objectSchema({ run_id: stringSchema("Run identifier."), artifact_id: stringSchema("Artifact identifier.") }, ["run_id", "artifact_id"]),
+  outputSchema: objectSchema({ id: stringSchema("Artifact identifier."), fileName: stringSchema("Artifact file name."), base64: stringSchema("Verified bytes."), sha256: stringSchema("SHA256 digest."), byteSize: { type: "integer", minimum: 0 } }, ["id", "fileName", "base64", "sha256", "byteSize"])
+});
+var contracts = [...toolContracts, ...remoteCustomerContracts].sort((a, b) => a.name.localeCompare(b.name));
 var resourceContracts = [
   {
     uri: "skills://mcp/contracts",
@@ -26869,6 +27352,7 @@ function createSkillRun(params, targetDir = process.cwd()) {
     startedAt: now.toISOString(),
     remote: params.remote ?? false,
     ...params.remoteRunId ? { remoteRunId: params.remoteRunId } : {},
+    ...params.remoteApiOrigin ? { remoteApiOrigin: params.remoteApiOrigin } : {},
     ...params.costCents !== undefined ? { costCents: params.costCents } : {},
     artifacts: [],
     paths: {
@@ -27045,14 +27529,12 @@ function resolveRunRouting(skill, apiKey, apiUrl) {
       error: `${skill.name} is a server-owned skill. Run: skills auth login`
     };
   }
-  return { route: "remote", apiKey };
+  return { route: "remote", apiKey, apiOrigin: apiUrl };
 }
 async function resolveConfiguredRunRouting(skill, env = process.env) {
-  let fleet;
-  let apiKey;
+  let connection;
   try {
-    fleet = resolveSkillsFleet(env);
-    apiKey = fleet.mode === "hosted" ? await resolveSkillsApiKey(env) : null;
+    connection = await resolveSkillsConnection(env);
   } catch (error2) {
     const isMissingCredential = (error2 instanceof SkillsFleetCredentialError || error2?.name === "SkillsFleetCredentialError") && error2.code === "MISSING_API_CREDENTIAL";
     if (!isMissingCredential)
@@ -27063,7 +27545,7 @@ async function resolveConfiguredRunRouting(skill, env = process.env) {
       error: `${skill.name} is a server-owned skill. ${error2.message}`
     };
   }
-  return resolveRunRouting(skill, apiKey, fleet.apiOrigin ?? undefined);
+  return resolveRunRouting(skill, connection?.apiKey, connection?.apiOrigin);
 }
 
 // src/mcp/operation-tools.ts
@@ -27267,10 +27749,15 @@ function registerOperationTools(server) {
       name: exports_external.string(),
       input: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
       args: exports_external.array(exports_external.string()).optional(),
-      detail: exports_external.boolean().optional()
-    }
-  }, async ({ name, input, args, detail }) => {
-    const skill = getSkill(name);
+      detail: exports_external.boolean().optional(),
+      maxCostCents: exports_external.number().int().min(0).max(2147483647).optional().describe("Maximum integer credits explicitly approved by the user for a remote run; omitted permits only free runs"),
+      maxCredits: exports_external.number().int().min(0).max(2147483647).optional(),
+      remote: exports_external.boolean().optional().describe("Use the configured server catalog, including skills not installed locally"),
+      idempotency_key: exports_external.string().regex(/^[A-Za-z0-9._:-]{1,128}$/).optional().describe("Reuse for the same approved submission after an interrupted response"),
+      files: exports_external.array(exports_external.object({ name: exports_external.string(), base64: exports_external.string().max(1398104), contentType: exports_external.string().optional() })).max(10).optional().describe("Inline remote inputs, at most 1 MiB combined; use CLI or SDK for larger files")
+    }
+  }, async ({ name, input, args, detail, maxCostCents, maxCredits, remote, idempotency_key, files }) => {
+    const skill = remote ? { name, serverOwned: true } : getSkill(name);
     if (!skill) {
       return mcpError("SKILL_NOT_FOUND", `Skill '${name}' not found`, findSimilarSkills(name));
     }
@@ -27281,17 +27768,26 @@ function registerOperationTools(server) {
     const skillName = skill.name;
     const runInput = input || {};
     const runArgs = args || [];
-    if (skillName === ARTICLE_GENERATION_SLUG2) {
+    if (!remote && skillName === ARTICLE_GENERATION_SLUG2) {
       const validation = validateBlogArticleRunOptions2(runInput, runArgs, { requireTopic: true });
       if (!validation.ok) {
         return mcpError("INVALID_BLOG_ARTICLE_OPTIONS", validation.errors.join(" "));
       }
     }
     const routing = await resolveConfiguredRunRouting(skill);
+    if (files?.length && routing.route !== "remote")
+      return mcpError("REMOTE_REQUIRED", "Inline inputs require a remote run");
+    let inputFiles;
+    try {
+      inputFiles = (await Promise.resolve().then(() => (init_remote_files(), exports_remote_files))).decodeRemoteFiles(files ?? []);
+    } catch (error2) {
+      return mcpError("INVALID_INPUT_FILES", error2.message);
+    }
     const runContext = createSkillRun({
       skill: skillName,
       args: runArgs,
-      remote: routing.route === "remote"
+      remote: routing.route === "remote",
+      ...routing.route === "remote" ? { remoteApiOrigin: routing.apiOrigin } : {}
     });
     if (routing.route === "error") {
       const error2 = routing.error;
@@ -27304,8 +27800,8 @@ function registerOperationTools(server) {
     if (routing.route === "remote") {
       try {
         const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
-        const client = new RemoteSkillsClient2(routing.apiKey);
-        const run = await client.submitRun(skillName, runInput, runArgs);
+        const client = new RemoteSkillsClient2(routing.apiKey, routing.apiOrigin);
+        const run = await client.submitQuotedRunWithFiles(skillName, runInput, runArgs, inputFiles, { maxCredits, maxCostCents, idempotencyKey: idempotency_key ?? runContext.record.id });
         if (run.error) {
           writeRunLogs(runContext, "", String(run.error) + `
 `);
@@ -27367,7 +27863,7 @@ function registerOperationTools(server) {
     }
   }, async ({ run_id, detail }) => {
     const { skillsCredentialOrReason: skillsCredentialOrReason2 } = await Promise.resolve().then(() => (init_fleet_credentials(), exports_fleet_credentials));
-    const { apiKey, reason } = await skillsCredentialOrReason2();
+    const { apiKey, apiOrigin, reason } = await skillsCredentialOrReason2();
     if (!apiKey) {
       return mcpError("AUTH_REQUIRED", reason ?? "Remote run status requires API access. Run: skills auth login", ["skills auth login"]);
     }
@@ -27378,7 +27874,9 @@ function registerOperationTools(server) {
     }
     try {
       const { RemoteSkillsClient: RemoteSkillsClient2 } = await Promise.resolve().then(() => (init_remote_client(), exports_remote_client));
-      const client = new RemoteSkillsClient2(apiKey);
+      if (localRun?.remoteApiOrigin && localRun.remoteApiOrigin !== apiOrigin)
+        return mcpError("INSTANCE_MISMATCH", "This run belongs to another Skills instance; select its credential profile");
+      const client = new RemoteSkillsClient2(apiKey, apiOrigin);
       const run = await client.getRun(remoteRunId);
       if (!run)
         return mcpError("RUN_NOT_FOUND", `Remote run '${remoteRunId}' not found`);
@@ -27987,7 +28485,7 @@ function registerScheduleTools(server) {
 }
 
 // src/lib/native-storage.ts
-import { createHash as createHash3, createHmac } from "crypto";
+import { createHash as createHash4, createHmac } from "crypto";
 import {
   existsSync as existsSync16,
   mkdirSync as mkdirSync8,
@@ -28099,7 +28597,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
       files.push({
         path: relativePath,
         sizeBytes: bytes.byteLength,
-        sha256: createHash3("sha256").update(bytes).digest("hex"),
+        sha256: createHash4("sha256").update(bytes).digest("hex"),
         ...options.includeFileContents ? { contentBase64: Buffer.from(bytes).toString("base64") } : {}
       });
     }
@@ -28231,6 +28729,194 @@ function registerStorageTools(server) {
   });
 }
 
+// src/lib/remote-auth.ts
+init_remote_client();
+init_fleet_credentials();
+var MAX_ERROR_DETAIL_LENGTH = 200;
+
+class HostedApiError extends Error {
+  status;
+  code;
+  detail;
+  endpoint;
+  apiUrl;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "HostedApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.detail = options.detail;
+    this.endpoint = options.endpoint;
+    this.apiUrl = options.apiUrl;
+  }
+}
+async function requestAuthApi(instance, path, options) {
+  const url = normalizeSkillsApiOrigin(instance);
+  const safeUrl = url;
+  const endpoint = `${(options?.method || "GET").toUpperCase()} ${safeUrl}${path}`;
+  let res;
+  try {
+    res = await fetch(`${url}${path}`, {
+      ...options,
+      redirect: "error",
+      signal: options?.signal ?? AbortSignal.timeout(15000),
+      headers: { "Content-Type": "application/json", ...options?.headers }
+    });
+  } catch (err) {
+    throw new HostedApiError(`Unable to reach the Skills API: ${err.message}`, {
+      endpoint,
+      apiUrl: safeUrl
+    });
+  }
+  const text = await res.text();
+  const body = text ? parseJsonBody(text) : {};
+  if (!res.ok) {
+    const record3 = isRecord4(body) ? body : {};
+    const detail = typeof record3.detail === "string" ? record3.detail : undefined;
+    const error2 = typeof record3.error === "string" ? record3.error : undefined;
+    const code = typeof record3.code === "string" ? record3.code : undefined;
+    throw new HostedApiError(detail || error2 || `${res.status} ${res.statusText}`, {
+      status: res.status,
+      code,
+      detail,
+      endpoint,
+      apiUrl: safeUrl
+    });
+  }
+  return body;
+}
+function parseJsonBody(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { detail: condenseErrorBody(text) };
+  }
+}
+function condenseErrorBody(text) {
+  const stripped = /<[a-z!/]/i.test(text) ? text.replace(/<(script|style)[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]*>/g, " ") : text;
+  const collapsed = stripped.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= MAX_ERROR_DETAIL_LENGTH)
+    return collapsed;
+  return `${collapsed.slice(0, MAX_ERROR_DETAIL_LENGTH - 1).trimEnd()}\u2026`;
+}
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+class RemoteSkillsAuthClient {
+  apiOrigin;
+  constructor(apiUrl) {
+    this.apiOrigin = normalizeSkillsApiOrigin(apiUrl);
+  }
+  requestCode(email2) {
+    return this.request("/api/auth/login", { method: "POST", body: JSON.stringify({ email: email2 }) });
+  }
+  verifyCode(email2, code) {
+    return this.request("/api/auth/verify", { method: "POST", body: JSON.stringify({ email: email2, code }) });
+  }
+  startDevice() {
+    return this.request("/api/auth/device/start", { method: "POST", body: JSON.stringify({ client: "skills-sdk" }) });
+  }
+  pollDevice(deviceCode) {
+    return this.request("/api/auth/device/token", { method: "POST", body: JSON.stringify({ deviceCode }) });
+  }
+  async sessionClient(email2, code) {
+    if (!email2.includes("@") || !/^\d{6}$/.test(code))
+      throw new Error("Fresh email and six-digit verification code are required to manage API keys");
+    const login = await this.verifyCode(email2, code);
+    if (!login || typeof login.token !== "string" || !login.token)
+      throw new Error("The server did not return an authorized account session");
+    return new RemoteSkillsClient(login.token, this.apiOrigin);
+  }
+  async createApiKey(email2, code, name, scopes) {
+    return (await this.sessionClient(email2, code)).createApiKey(name, scopes);
+  }
+  async listApiKeys(email2, code) {
+    return (await this.sessionClient(email2, code)).listApiKeys();
+  }
+  async revokeApiKey(email2, code, keyId) {
+    return (await this.sessionClient(email2, code)).revokeApiKey(keyId);
+  }
+  request(path, options) {
+    if (!["/api/auth/login", "/api/auth/verify", "/api/auth/device/start", "/api/auth/device/token", "/api/auth/keys", "/api/auth/whoami"].includes(path))
+      throw new Error("Unsupported authentication operation");
+    return requestAuthApi(this.apiOrigin, path, options);
+  }
+}
+
+// src/mcp/remote-customer-tools.ts
+init_auth_store();
+init_remote_client();
+function registerRemoteCustomerTools(server) {
+  for (const operation of REMOTE_CUSTOMER_OPERATIONS) {
+    const inputSchema = {};
+    if (operation.parameter)
+      inputSchema[operation.parameter] = exports_external.string().min(1);
+    server.registerTool(operation.name, {
+      title: operation.title,
+      description: `${operation.title} on the explicitly configured Skills server. Missing server capabilities return an error. Checkout links require external customer confirmation.`,
+      inputSchema
+    }, async (input) => callRemote((client) => operation.invoke(client, operation.parameter ? String(input[operation.parameter]) : "")));
+  }
+  server.registerTool("list_api_keys", {
+    title: "List API Keys",
+    description: "List account API keys using fresh email OTP reauthentication.",
+    inputSchema: { email: exports_external.string().email(), code: exports_external.string().regex(/^\d{6}$/) }
+  }, async ({ email: email2, code }) => {
+    try {
+      return mcpJson(await new RemoteSkillsAuthClient(getApiUrl("List API keys")).listApiKeys(email2, code));
+    } catch (error2) {
+      return mcpError("KEY_LIST_FAILED", error2.message);
+    }
+  });
+  server.registerTool("revoke_api_key", {
+    title: "Revoke API Key",
+    description: "Revoke an account API key using fresh email OTP reauthentication.",
+    inputSchema: { key_id: exports_external.string().min(1), email: exports_external.string().email(), code: exports_external.string().regex(/^\d{6}$/) }
+  }, async ({ key_id, email: email2, code }) => {
+    try {
+      return mcpJson(await new RemoteSkillsAuthClient(getApiUrl("Revoke API key")).revokeApiKey(email2, code, key_id));
+    } catch (error2) {
+      return mcpError("KEY_REVOKE_FAILED", error2.message);
+    }
+  });
+  server.registerTool("create_api_key", {
+    title: "Create API Key",
+    description: "Create an API key using fresh email OTP reauthentication; returns its secret once. A stored API key cannot grant this authority.",
+    inputSchema: { name: exports_external.string().min(1), email: exports_external.string().email(), code: exports_external.string().regex(/^\d{6}$/), scopes: exports_external.array(exports_external.string()).optional() }
+  }, async ({ name, email: email2, code, scopes }) => {
+    try {
+      return mcpJson(await new RemoteSkillsAuthClient(getApiUrl("Create API key")).createApiKey(email2, code, name, scopes));
+    } catch (error2) {
+      return mcpError("KEY_CREATION_FAILED", error2.message);
+    }
+  });
+  server.registerTool("quote_skill", {
+    title: "Quote Remote Skill",
+    description: "Get the configured server's credit quote without submitting a run.",
+    inputSchema: { name: exports_external.string(), input: exports_external.record(exports_external.string(), exports_external.unknown()).optional(), args: exports_external.array(exports_external.string()).optional() }
+  }, ({ name, input, args }) => callRemote((client) => client.quoteRun(name, input, args)));
+  server.registerTool("download_run_artifact", {
+    title: "Download Verified Run Artifact",
+    description: "Return verified artifact bytes as base64 (at most 1 MiB); use the CLI for larger files.",
+    inputSchema: { run_id: exports_external.string(), artifact_id: exports_external.string() }
+  }, ({ run_id, artifact_id }) => callRemote(async (client) => {
+    const artifact = await client.getVerifiedRunArtifact(run_id, artifact_id, 1024 * 1024);
+    const { bytes, ...metadata } = artifact;
+    return { ...metadata, base64: Buffer.from(bytes).toString("base64") };
+  }));
+}
+async function callRemote(action) {
+  try {
+    const client = await createRemoteSkillsClient();
+    if (!client)
+      return mcpError("AUTH_REQUIRED", "Configure a Skills API and sign in with skills auth login");
+    return mcpJson(await action(client));
+  } catch (error2) {
+    return mcpError("REMOTE_REQUEST_FAILED", error2 instanceof Error ? error2.message : "Skills server request failed");
+  }
+}
+
 // src/mcp/server.ts
 function buildServer() {
   const server = new McpServer({
@@ -28242,6 +28928,7 @@ function buildServer() {
   registerScheduleTools(server);
   registerStorageTools(server);
   registerResourceMetaTools(server);
+  registerRemoteCustomerTools(server);
   return server;
 }
 var server = buildServer();
@@ -29705,7 +30392,8 @@ MCP server for ${package_default.name}
 Options:
   -V, --version  output the version number
   -h, --help     display help for command
-  --http         run Streamable HTTP transport on 127.0.0.1 (default port 8836)
+  --stdio        run newline-delimited JSON-RPC for agent hosts
+  --http         run Streamable HTTP transport on 127.0.0.1 (default; port 8836)
   --port <n>     HTTP port (--http or MCP_HTTP=1)`);
 }
 if (args.includes("--help") || args.includes("-h")) {