@hasna/skills 0.5.3 → 0.5.5

package/dist/sdk/index.js

@@ -23115,6 +23115,7 @@ import { spawn } from "child_process";
 import { request as nodeHttpRequest } from "http";
 import { request as nodeHttpsRequest } from "https";
 import { randomUUID as randomUUID22 } from "crypto";
+import { createRequire as createRequire2 } from "module";
 function getPathValue(input, path) {
   return path.split(".").reduce((value, part) => {
     if (value && typeof value === "object" && part in value) {
@@ -24330,7 +24331,7 @@ function normalizeRetryPolicy(policy) {
 }
 var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE2, HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR", HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME", EVENTS_STORE_SENTINEL_FILE = "events.json", LOCAL_JSON_EVENT_CURSOR_PREFIX = "local-json-v1:", DEFAULT_EVENT_PAGE_LIMIT = 100, MAX_EVENT_PAGE_LIMIT = 1000, DEFAULT_SIGNATURE_TOLERANCE_MS, DEFAULT_MAX_REDIRECTS = 5, IPV4_PRIVATE_RANGES, IPV6_SPECIAL_PREFIXES, defaultTargetLookup = async (hostname) => {
   return dnsLookup(hostname, { all: true, verbatim: false });
-}, EventValidationError, defaultEventTypeCatalog, APP_EVENT_V1_MAX_DATA_BYTES;
+}, EventValidationError, defaultEventTypeCatalog, APP_EVENT_V1_MAX_DATA_BYTES, MAX_CREDENTIAL_FILE_BYTES2, INSPECT_CUSTOM2, CREDENTIAL_SEAL2, AMBIENT_ENVIRONMENT2, SECRETS_PACKAGE_SPECIFIER2, requireSecretsSdk2, IDEMPOTENT_METHODS2, AUTHORITY_OVERRIDE_HEADERS2, MAX_ENVELOPE_BYTES, MAX_REQUEST_BYTES;
 var init_dist = __esm(() => {
   PATHS_RESOLVER_KIND_ENV = {
     config: "HASNA_CONFIG_HOME",
@@ -24386,6 +24387,22 @@ var init_dist = __esm(() => {
   };
   defaultEventTypeCatalog = new EventTypeCatalog;
   APP_EVENT_V1_MAX_DATA_BYTES = 32 * 1024;
+  MAX_CREDENTIAL_FILE_BYTES2 = 64 * 1024;
+  INSPECT_CUSTOM2 = Symbol.for("nodejs.util.inspect.custom");
+  CREDENTIAL_SEAL2 = Symbol.for("hasna:contracts:sealedCredential");
+  AMBIENT_ENVIRONMENT2 = Symbol.for("hasna:contracts:ambientClientEnvironment");
+  SECRETS_PACKAGE_SPECIFIER2 = "@hasna/" + "secrets";
+  requireSecretsSdk2 = createRequire2(import.meta.url);
+  IDEMPOTENT_METHODS2 = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+  AUTHORITY_OVERRIDE_HEADERS2 = new Set([
+    "host",
+    ":authority",
+    "forwarded",
+    "x-forwarded-host",
+    "x-original-host"
+  ]);
+  MAX_ENVELOPE_BYTES = 256 * 1024;
+  MAX_REQUEST_BYTES = MAX_ENVELOPE_BYTES * 2 + 8192;
 });
 
 // src/sdk/event-sink.ts
@@ -25237,7 +25254,9 @@ function normalizeSkillsApiOrigin(apiUrl) {
     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") {
+  if (url.origin === "https://api.hasna.com" && pathname === "/skills/v1") {
+    url.pathname = "/skills";
+  } else if (pathname === "/api" || pathname === "/api/v1") {
     url.pathname = "/";
   } else if (pathname.endsWith("/api/v1")) {
     url.pathname = pathname.slice(0, -"/api/v1".length) || "/";
@@ -25246,6 +25265,21 @@ function normalizeSkillsApiOrigin(apiUrl) {
   }
   return url.toString().replace(/\/+$/, "");
 }
+function skillsApiRequestUrl(apiUrl, route) {
+  const origin = normalizeSkillsApiOrigin(apiUrl);
+  if (!route.startsWith("/api/") || route.includes("#") || route.includes("\\")) {
+    throw new SkillsFleetCredentialError("Invalid Skills API route", "INVALID_API_URL");
+  }
+  if (origin === "https://api.hasna.com/skills") {
+    if (route === "/api/auth/whoami")
+      return `${origin}/v1/auth/whoami`;
+    if (!route.startsWith("/api/v1/")) {
+      throw new SkillsFleetCredentialError("The internal Skills gateway has no established login contract yet. Select an explicitly configured instance with supported authentication.", "GATEWAY_AUTH_UNAVAILABLE");
+    }
+    return `${origin}${route.slice("/api".length)}`;
+  }
+  return `${origin}${route}`;
+}
 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) {
@@ -25462,7 +25496,7 @@ class MissingSkillsFleetError extends Error {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.5.3",
+  version: "0.5.5",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -37097,10 +37131,16 @@ class SqliteSkillsStore {
     const orgId = input.principal.orgId;
     const now = nowIso();
     return this.db.transaction(() => {
-      const previous = this.get("SELECT revision_id, revision_number, bundle_sha256, bundle_byte_size, skill_md, tombstoned_at FROM skills_registry WHERE org_id = ? AND slug = ?", [orgId, input.slug]);
+      const previous = this.get("SELECT revision_id, revision_number, bundle_sha256, bundle_byte_size, skill_md, tombstoned_at, source FROM skills_registry WHERE org_id = ? AND slug = ?", [orgId, input.slug]);
       const previousSha = typeof previous?.bundle_sha256 === "string" ? previous.bundle_sha256 : null;
       const previousRevisionId = typeof previous?.revision_id === "string" && previous.revision_id ? previous.revision_id : null;
       const tombstoned = previous?.tombstoned_at != null;
+      if (input.seedBundledOnly && input.expectedRevisionId && !previous) {
+        throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, null);
+      }
+      if (input.seedBundledOnly && previous && (tombstoned || previous.source !== "bundled")) {
+        throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, previousRevisionId);
+      }
       const carriedSkillMd = typeof input.skillMd === "string" ? input.skillMd : typeof previous?.skill_md === "string" ? previous.skill_md : null;
       if (previous && !tombstoned && input.expectedRevisionId !== previousRevisionId) {
         throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, previousRevisionId);
@@ -37174,8 +37214,9 @@ class SqliteSkillsStore {
            tombstoned_at = NULL,
            tombstone_purge_after = NULL,
            updated_at = excluded.updated_at
-         WHERE skills_registry.tombstoned_at IS NOT NULL
-            OR skills_registry.revision_id = ?
+         WHERE (skills_registry.tombstoned_at IS NOT NULL OR skills_registry.revision_id = ?)
+           AND (? = 0 OR (skills_registry.tombstoned_at IS NULL AND skills_registry.source = 'bundled'
+             AND skills_registry.revision_id = ?))
          RETURNING *`, [
         orgId,
         input.slug,
@@ -37193,6 +37234,8 @@ class SqliteSkillsStore {
         revisionId,
         now,
         now,
+        input.expectedRevisionId ?? NO_REVISION_SENTINEL,
+        input.seedBundledOnly ? 1 : 0,
         input.expectedRevisionId ?? NO_REVISION_SENTINEL
       ]);
       if (!row) {
@@ -42238,6 +42281,12 @@ async function storePublishedSkill(store, artifactStorage, principal, parsed, ex
     principal,
     ...expectedRevisionId ? { expectedRevisionId } : {}
   };
+  if (input.seedBundledOnly && expectedRevisionId && !current) {
+    throw new SkillRevisionConflictError(input.slug, expectedRevisionId, null);
+  }
+  if (input.seedBundledOnly && current && (current.tombstonedAt || current.source !== "bundled")) {
+    throw new SkillRevisionConflictError(input.slug, expectedRevisionId, current.revisionId);
+  }
   if (current && !current.tombstonedAt && expectedRevisionId !== current.revisionId) {
     throw new SkillRevisionConflictError(input.slug, expectedRevisionId, current.revisionId);
   }
@@ -42487,6 +42536,15 @@ async function seedBundledCorpus(options) {
         result.skipped.push(slug);
         continue;
       }
+      const current = await options.store.getSkill(options.principal, slug);
+      if (current) {
+        const previousVersion = current.version ? await options.store.getSkillVersion(options.principal, slug, current.version) : null;
+        const provenance = previousVersion?.manifest.provenance;
+        if (current.tombstonedAt || current.source !== "bundled" || provenance?.seededFrom !== "bundled-corpus" || provenance.seededRevisionId !== current.revisionId) {
+          result.skipped.push(slug);
+          continue;
+        }
+      }
       const dir = getSkillPath(slug);
       if (!existsSync15(dir)) {
         result.skipped.push(slug);
@@ -42496,32 +42554,40 @@ async function seedBundledCorpus(options) {
       const packed = packSkillBundle(dir, { maxUnpackedBytes: 50000000 });
       const skillMdPath = join19(dir, "SKILL.md");
       const skillMd = existsSync15(skillMdPath) ? readFileSync16(skillMdPath, "utf-8") : undefined;
-      const current = await options.store.getSkill(options.principal, slug);
+      const content = {
+        slug,
+        displayName: manifest.displayName ?? skill.displayName ?? slug,
+        description: manifest.description ?? skill.description ?? slug,
+        category: manifest.category ?? skill.category ?? "Development Tools",
+        tags: manifest.tags ?? skill.tags ?? [],
+        source: "bundled",
+        kind: manifest.kind ?? "instruction",
+        version: version2,
+        ...skillMd ? { skillMd } : {},
+        bundleSha256: packed.sha256,
+        bundleByteSize: packed.bytes.byteLength
+      };
       const { record } = await storePublishedSkill(options.store, options.artifactStorage, options.principal, {
         input: {
-          slug,
-          displayName: manifest.displayName ?? skill.displayName ?? slug,
-          description: manifest.description ?? skill.description ?? slug,
-          category: manifest.category ?? skill.category ?? "Development Tools",
-          tags: manifest.tags ?? skill.tags ?? [],
-          source: "bundled",
-          kind: manifest.kind ?? "instruction",
-          version: version2,
-          ...skillMd ? { skillMd } : {},
+          ...content,
+          seedBundledOnly: true,
           bundle: { sha256: packed.sha256, byteSize: packed.bytes.byteLength, contentType: "application/gzip", storageKind: "db" },
           versionManifest: {
             files: packed.paths,
             fileCount: packed.fileCount,
             unpackedByteSize: packed.unpackedByteSize,
             bundleSha256: packed.sha256,
-            provenance: { seededFrom: "bundled-corpus", packageVersion: package_default.version }
+            provenance: { seededFrom: "bundled-corpus", packageVersion: package_default.version, seededRevisionId: revisionIdOfRecord(content) }
           }
         },
         bundleBytes: packed.bytes
       }, current?.revisionId);
       result.seeded.push(`${record.slug}@${version2}`);
     } catch (error) {
-      result.failed.push({ slug, error: error.message });
+      if (error instanceof SkillRevisionConflictError)
+        result.skipped.push(slug);
+      else
+        result.failed.push({ slug, error: error.message });
     }
   }
   log(`skills: bundled corpus seed v${version2}: ${result.seeded.length} seeded, ${result.skipped.length} skipped, ${result.failed.length} failed`);
@@ -42731,6 +42797,12 @@ class MemorySkillsStore {
     const key = skillKey(input.principal.orgId, input.slug);
     const now = nowIso();
     const previous = this.skills.get(key);
+    if (input.seedBundledOnly && input.expectedRevisionId && !previous) {
+      throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, null);
+    }
+    if (input.seedBundledOnly && previous && (previous.tombstonedAt || previous.source !== "bundled")) {
+      throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, previous.revisionId);
+    }
     if (previous && !previous.tombstonedAt && input.expectedRevisionId !== previous.revisionId) {
       throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, previous.revisionId);
     }
@@ -43184,13 +43256,19 @@ class PostgresSkillsStore {
     const orgId = input.principal.orgId;
     return await this.sql.begin(async (tx) => {
       const previousRows = await tx`
-        SELECT revision_id, revision_number, bundle_sha256, bundle_byte_size, skill_md, tombstoned_at
+        SELECT revision_id, revision_number, bundle_sha256, bundle_byte_size, skill_md, tombstoned_at, source
         FROM skills_registry WHERE org_id = ${orgId} AND slug = ${input.slug} LIMIT 1
       `;
       const previous = previousRows[0];
       const previousSha = typeof previous?.bundle_sha256 === "string" ? String(previous.bundle_sha256) : null;
       const previousRevisionId = typeof previous?.revision_id === "string" && previous.revision_id ? String(previous.revision_id) : null;
       const tombstoned = previous?.tombstoned_at != null;
+      if (input.seedBundledOnly && input.expectedRevisionId && !previous) {
+        throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, null);
+      }
+      if (input.seedBundledOnly && previous && (tombstoned || previous.source !== "bundled")) {
+        throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, previousRevisionId);
+      }
       const carriedSkillMd = typeof input.skillMd === "string" ? input.skillMd : typeof previous?.skill_md === "string" ? String(previous.skill_md) : null;
       if (previous && !tombstoned && input.expectedRevisionId !== previousRevisionId) {
         throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, previousRevisionId);
@@ -43231,6 +43309,12 @@ class PostgresSkillsStore {
             body_blob = EXCLUDED.body_blob
         `;
       }
+      if (input.seedBundledOnly) {
+        const seedRows = await tx`SELECT revision_id FROM skills_registry WHERE org_id = ${orgId} AND slug = ${input.slug} FOR UPDATE`;
+        if (input.expectedRevisionId && !seedRows[0]) {
+          throw new SkillRevisionConflictError(input.slug, input.expectedRevisionId, null);
+        }
+      }
       const rows = await tx`
         INSERT INTO skills_registry (org_id, slug, display_name, description, category, tags_json, source, kind, version, skill_md,
                                      bundle_sha256, bundle_byte_size, published_by_user_id, revision_id, revision_number, updated_at)
@@ -43259,8 +43343,11 @@ class PostgresSkillsStore {
           tombstoned_at = NULL,
           tombstone_purge_after = NULL,
           updated_at = EXCLUDED.updated_at
-        WHERE skills_registry.tombstoned_at IS NOT NULL
-           OR skills_registry.revision_id = ${input.expectedRevisionId ?? NO_REVISION_SENTINEL2}
+        WHERE (skills_registry.tombstoned_at IS NOT NULL
+           OR skills_registry.revision_id = ${input.expectedRevisionId ?? NO_REVISION_SENTINEL2})
+          AND (NOT ${Boolean(input.seedBundledOnly)} OR
+            (skills_registry.tombstoned_at IS NULL AND skills_registry.source = 'bundled'
+             AND skills_registry.revision_id = ${input.expectedRevisionId ?? NO_REVISION_SENTINEL2}))
         RETURNING *
       `;
       if (!rows[0]) {
@@ -43675,6 +43762,15 @@ async function createSkillsFetchHandler(options = {}) {
   }
   return async function fetch2(request) {
     const url = new URL(request.url);
+    const versionedAliases = {
+      "/v1/health": "/health",
+      "/v1/auth/whoami": "/api/auth/whoami"
+    };
+    const alias = versionedAliases[url.pathname] ?? (url.pathname === "/v1" || url.pathname.startsWith("/v1/") ? `/api${url.pathname}` : undefined);
+    if (alias) {
+      url.pathname = alias;
+      request = new Request(url, request);
+    }
     const segments = pathSegments(url.pathname);
     try {
       if (request.method === "GET" && url.pathname === "/health") {
@@ -52098,7 +52194,13 @@ class StopTaskCommand extends command3(_ep03, _mw03, "StopTask", StopTask$) {
 
 // src/sdk/execution/dispatchers/ecs.ts
 var CLIENT_TOKEN_BYTES = 16;
-var TERMINAL_TASK_STATUSES = new Set(["STOPPED"]);
+var LIVE_TASK_STATUSES = new Set(["PROVISIONING", "PENDING", "ACTIVATING", "RUNNING", "DEACTIVATING", "STOPPING", "DEPROVISIONING"]);
+function observedTask(states, taskArn) {
+  if (states.length !== 1 || states[0]?.taskArn !== taskArn)
+    return;
+  const state = states[0];
+  return state.lastStatus === "STOPPED" || LIVE_TASK_STATUSES.has(state.lastStatus) ? state : undefined;
+}
 function clientTokenFor(runId2, attemptId) {
   return createHash11("sha256").update(`${runId2}\x00${attemptId}`).digest("hex").slice(0, CLIENT_TOKEN_BYTES * 2);
 }
@@ -52150,28 +52252,47 @@ class EcsDispatcher {
     const run = await this.store.getRun(runId2);
     if (!run)
       return { accepted: false, detail: "no such run" };
-    if (run.status === "cancelled")
-      return { accepted: true, detail: "already cancelled" };
     if (run.status === "succeeded" || run.status === "failed") {
       return { accepted: false, detail: `run already ${run.status}` };
     }
     const attempts = await this.store.listAttempts(runId2);
     const current = attempts[attempts.length - 1];
     if (!current) {
-      const cancelled2 = await this.stateMachine.cancel(runId2);
-      return cancelled2.ok ? { accepted: true, detail: "cancelled (no attempt launched)" } : { accepted: false, detail: cancelled2.reason };
+      if (run.status === "cancelled")
+        return { accepted: true, detail: "already cancelled (no attempt launched)" };
+      const cancelled = await this.stateMachine.cancel(runId2);
+      return cancelled.ok ? { accepted: true, detail: "cancelled (no attempt launched)" } : { accepted: false, detail: cancelled.reason };
+    }
+    if (!this.cancellationReceipt(await this.receipts.get(runId2, current.attemptId), run.admission, current)) {
+      return { accepted: false, detail: "matching cancellation receipt is unavailable or contradictory" };
     }
-    const taskArn = await this.resolveTaskArn(run.admission, current);
-    if (taskArn) {
+    const observation = await this.reconcile(run.admission, current);
+    if (observation.kind !== "already-launched" && observation.kind !== "previous-terminal") {
+      return { accepted: false, detail: "task state unknown; cancellation is not yet confirmed" };
+    }
+    const taskArn = observation.kind === "already-launched" ? observation.taskId : (await this.store.listAttempts(runId2)).find((row) => row.attemptId === current.attemptId)?.taskId ?? null;
+    if (!taskArn)
+      return { accepted: false, detail: "stopped task identity is not confirmed" };
+    if (observation.kind === "already-launched") {
       try {
-        await this.client.stopTask(taskArn);
+        await this.client.stopTask(observation.taskId);
       } catch {}
+      const stopped = await this.reconcile(run.admission, { ...current, taskId: observation.taskId });
+      if (stopped.kind !== "previous-terminal") {
+        return { accepted: false, target: observation.taskId, detail: "task stop is not yet confirmed; reconcile before retrying cancellation" };
+      }
     }
-    const cancelled = await this.stateMachine.cancel(runId2);
-    if (!cancelled.ok)
-      return { accepted: false, detail: cancelled.reason };
-    await this.writeCancellationReceipt(run.admission, current, taskArn);
-    return { accepted: true, target: taskArn ?? undefined, detail: "cancelled and fenced" };
+    if (run.status !== "cancelled") {
+      const cancelled = await this.stateMachine.cancel(runId2);
+      if (!cancelled.ok)
+        return { accepted: false, detail: cancelled.reason };
+    }
+    try {
+      await this.writeCancellationReceipt(run.admission, current, taskArn);
+    } catch {
+      return { accepted: false, target: taskArn, detail: "task stopped; cancellation receipt is not yet confirmed" };
+    }
+    return { accepted: true, target: taskArn, detail: "cancelled after confirmed task stop and receipt" };
   }
   async launchAttempt(runId2) {
     const run = await this.store.getRun(runId2);
@@ -52182,16 +52303,10 @@ class EcsDispatcher {
     }
     const attempts = await this.store.listAttempts(runId2);
     const previous = attempts[attempts.length - 1];
-    if (previous && previous.status !== "terminal" && !isProvenAbsentOrTerminal(previous.launchState)) {
-      const reconciled = await this.reconcile(run.admission, previous);
-      if (reconciled.kind === "already-launched" || reconciled.kind === "previous-terminal") {
-        return reconciled;
-      }
-      if (reconciled.kind === "ambiguous") {
-        return reconciled;
-      }
+    if (previous) {
+      return this.reconcile(run.admission, previous);
     }
-    const attemptNumber = previous ? previous.attemptNumber + 1 : 1;
+    const attemptNumber = 1;
     const attempt = await this.store.createAttempt({ runId: runId2, attemptNumber });
     const claimed = await this.stateMachine.claim({
       runId: runId2,
@@ -52226,68 +52341,43 @@ class EcsDispatcher {
     } catch {
       await this.store.recordLaunchState({ runId: runId2, attemptId: attempt.attemptId, launchState: "ambiguous" });
       const reconciled = await this.reconcile(run.admission, intent.attempt);
-      if (reconciled.kind === "already-launched")
-        return reconciled;
-      return reconciled.kind === "previous-terminal" ? reconciled : { kind: "launch-failed-absent", attemptId: attempt.attemptId };
+      return reconciled;
     }
     await this.store.recordLaunchState({ runId: runId2, attemptId: attempt.attemptId, launchState: "launched", taskId: result.taskArn });
     return { kind: "launched", attemptId: attempt.attemptId, taskId: result.taskArn };
   }
   async reconcile(admission, attempt) {
-    if (attempt.taskId) {
-      let states2;
+    const ambiguous = () => ({ kind: "ambiguous", attemptId: attempt.attemptId });
+    let taskArn = attempt.taskId;
+    if (!taskArn) {
+      if (!attempt.startedBy)
+        return ambiguous();
+      let taskArns;
       try {
-        states2 = await this.client.describeTasks([attempt.taskId]);
+        taskArns = await this.client.listTasksByStartedBy(attempt.startedBy);
       } catch {
-        return { kind: "ambiguous", attemptId: attempt.attemptId };
+        return ambiguous();
       }
-      const live2 = states2.filter((state) => !TERMINAL_TASK_STATUSES.has(state.lastStatus));
-      if (live2.length > 0) {
-        return { kind: "already-launched", attemptId: attempt.attemptId, taskId: attempt.taskId };
-      }
-      await this.store.recordLaunchState({ runId: admission.runId, attemptId: attempt.attemptId, launchState: "terminal" });
-      return { kind: "previous-terminal", attemptId: attempt.attemptId };
-    }
-    const token = attempt.startedBy;
-    if (!token) {
-      await this.store.recordLaunchState({ runId: admission.runId, attemptId: attempt.attemptId, launchState: "absent" });
-      return { kind: "launch-failed-absent", attemptId: attempt.attemptId };
-    }
-    let taskArns;
-    try {
-      taskArns = await this.client.listTasksByStartedBy(token);
-    } catch {
-      return { kind: "ambiguous", attemptId: attempt.attemptId };
-    }
-    if (taskArns.length === 0) {
-      await this.store.recordLaunchState({ runId: admission.runId, attemptId: attempt.attemptId, launchState: "absent" });
-      return { kind: "launch-failed-absent", attemptId: attempt.attemptId };
+      if (taskArns.length !== 1 || !taskArns[0])
+        return ambiguous();
+      taskArn = taskArns[0];
     }
     let states;
     try {
-      states = await this.client.describeTasks(taskArns);
+      states = await this.client.describeTasks([taskArn]);
     } catch {
-      return { kind: "ambiguous", attemptId: attempt.attemptId };
+      return ambiguous();
     }
-    const live = states.filter((state) => !TERMINAL_TASK_STATUSES.has(state.lastStatus));
-    if (live.length > 0) {
-      const taskId = live[0].taskArn;
-      await this.store.recordLaunchState({ runId: admission.runId, attemptId: attempt.attemptId, launchState: "launched", taskId });
-      return { kind: "already-launched", attemptId: attempt.attemptId, taskId };
+    const state = observedTask(states, taskArn);
+    if (!state)
+      return ambiguous();
+    if (state.lastStatus !== "STOPPED") {
+      await this.store.recordLaunchState({ runId: admission.runId, attemptId: attempt.attemptId, launchState: "launched", taskId: taskArn });
+      return { kind: "already-launched", attemptId: attempt.attemptId, taskId: taskArn };
     }
-    await this.store.recordLaunchState({ runId: admission.runId, attemptId: attempt.attemptId, launchState: "terminal", taskId: taskArns[0] });
+    await this.store.recordLaunchState({ runId: admission.runId, attemptId: attempt.attemptId, launchState: "terminal", taskId: taskArn });
     return { kind: "previous-terminal", attemptId: attempt.attemptId };
   }
-  async resolveTaskArn(admission, attempt) {
-    if (attempt.taskId)
-      return attempt.taskId;
-    if (attempt.launchState === "launching" || attempt.launchState === "ambiguous") {
-      const outcome = await this.reconcile(admission, attempt);
-      if (outcome.kind === "already-launched")
-        return outcome.taskId;
-    }
-    return null;
-  }
   runTaskInput(admission, attempt, clientToken, startedBy, requestDigest) {
     const limits = admission.limits;
     const cpuUnits = Math.max(256, Math.round(limits.maxCpuUnits / 256) * 256);
@@ -52312,81 +52402,103 @@ class EcsDispatcher {
       ]
     };
   }
-  async writeCancellationReceipt(admission, attempt, taskArn) {
-    const launch = await this.receipts.get(admission.runId, attempt.attemptId);
-    if (!launch) {
-      await this.receipts.recordLaunch({
-        admission,
-        attempt: { ...attempt, clientToken: attempt.clientToken ?? clientTokenFor(admission.runId, attempt.attemptId), requestDigest: attempt.requestDigest ?? "", startedBy: attempt.startedBy ?? "" },
-        taskId: taskArn,
-        launchedAt: this.now().toISOString()
-      });
+  cancellationReceipt(receipt, admission, attempt) {
+    try {
+      return !!receipt && receipt.runId === admission.runId && receipt.attemptId === attempt.attemptId && !!attempt.clientToken && receipt.clientToken === attempt.clientToken && !!attempt.requestDigest && receipt.requestDigest === attempt.requestDigest && !!attempt.startedBy && receipt.startedBy === attempt.startedBy && receipt.bundleDigest === admission.bundleDigest && receipt.runtimeImageDigest === admission.runtimeImageDigest && receipt.dependencyLayerTag === admission.dependencyLayerTag && canonicalJson(receipt.policy) === canonicalJson(admission.policy) && canonicalJson(receipt.limits) === canonicalJson(admission.limits) && (receipt.taskId === null || receipt.taskId === attempt.taskId) && (receipt.status === null && receipt.completedAt === null || receipt.status === "cancelled" && typeof receipt.completedAt === "string" && Number.isFinite(Date.parse(receipt.completedAt)));
+    } catch {
+      return false;
     }
-    await this.receipts.finalize({
-      runId: admission.runId,
-      attemptId: attempt.attemptId,
-      status: "cancelled",
-      exitCode: null,
-      completedAt: this.now().toISOString()
-    });
   }
-}
-function isProvenAbsentOrTerminal(launchState) {
-  return launchState === "absent" || launchState === "terminal";
-}
-function createAwsEcsClient(region) {
-  const client = new ECSClient({ region });
+  async writeCancellationReceipt(admission, attempt, taskArn) {
+    const existing = await this.receipts.get(admission.runId, attempt.attemptId);
+    if (!this.cancellationReceipt(existing, admission, { ...attempt, taskId: taskArn }))
+      throw Error("Cancellation receipt authority unavailable");
+    const completedAt = existing.completedAt ?? this.now().toISOString();
+    const expected = { ...existing, status: "cancelled", completedAt, exitCode: existing.status === "cancelled" ? existing.exitCode : null };
+    const run = await this.store.getRun(admission.runId);
+    if (existing.status !== "cancelled" || run?.status !== "cancelled" || run.terminalReceiptId !== attempt.attemptId) {
+      await this.receipts.finalize({ runId: admission.runId, attemptId: attempt.attemptId, status: "cancelled", exitCode: expected.exitCode, completedAt });
+    }
+    const persisted = await this.receipts.get(admission.runId, attempt.attemptId);
+    const finalized = await this.store.getRun(admission.runId);
+    if (!persisted || canonicalJson(persisted) !== canonicalJson(expected) || finalized?.status !== "cancelled" || finalized.terminalReceiptId !== attempt.attemptId) {
+      throw Error("Cancellation receipt persistence is unconfirmed");
+    }
+  }
+}
+function createAwsEcsClient(region, options = {}) {
+  if (options.cluster !== undefined && !validText(options.cluster))
+    throw Error("An explicit nonempty ECS cluster is required");
+  const client = options.transport ?? new ECSClient({ region });
+  let boundCluster = options.cluster;
+  const cluster = (requested) => {
+    const next = requested ?? boundCluster ?? "default";
+    if (!validText(next) || boundCluster !== undefined && next !== boundCluster)
+      throw Error("ECS client cluster binding changed");
+    return boundCluster ??= next;
+  };
+  const response = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw Error("Incomplete ECS response");
+    const result = value;
+    if (result.failures !== undefined && (!Array.isArray(result.failures) || result.failures.length > 0))
+      throw Error("ECS response contains failures");
+    return result;
+  };
   return {
     async runTask(input) {
-      const response = await client.send(new RunTaskCommand({
-        cluster: input.cluster,
+      const result = response(await client.send(new RunTaskCommand({
+        cluster: cluster(input.cluster),
         taskDefinition: input.taskDefinition,
         launchType: input.launchType,
         clientToken: input.clientToken,
         startedBy: input.startedBy,
-        networkConfiguration: {
-          awsvpcConfiguration: {
-            subnets: input.subnets,
-            securityGroups: input.securityGroups,
-            assignPublicIp: "DISABLED"
-          }
-        },
-        overrides: {
-          containerOverrides: [
-            {
-              name: input.containerName,
-              environment: input.environment,
-              cpu: Number(input.cpu),
-              memory: Number(input.memory)
-            }
-          ]
-        }
-      }));
-      const taskArn = response.tasks?.[0]?.taskArn ?? null;
-      if (!taskArn) {
-        const failure = response.failures?.[0];
-        throw new Error(`RunTask refused: ${failure?.reason ?? "no task and no failure detail"}`);
-      }
-      return { taskArn };
+        networkConfiguration: { awsvpcConfiguration: { subnets: input.subnets, securityGroups: input.securityGroups, assignPublicIp: "DISABLED" } },
+        overrides: { containerOverrides: [{ name: input.containerName, environment: input.environment, cpu: Number(input.cpu), memory: Number(input.memory) }] }
+      })));
+      if (!Array.isArray(result.tasks) || result.tasks.length !== 1 || !validText(result.tasks[0]?.taskArn))
+        throw Error("RunTask did not return one exact task");
+      return { taskArn: result.tasks[0].taskArn };
     },
     async listTasksByStartedBy(startedBy) {
-      const response = await client.send(new ListTasksCommand({ startedBy }));
-      return response.taskArns ?? [];
+      const configuredCluster = cluster(), arns = [], tokens = new Set;
+      let nextToken;
+      for (let page = 0;page < 20; page++) {
+        const result = response(await client.send(new ListTasksCommand({ cluster: configuredCluster, startedBy, ...nextToken ? { nextToken } : {} })));
+        if (!Array.isArray(result.taskArns) || result.taskArns.length > 100 || !result.taskArns.every(validText))
+          throw Error("Incomplete ECS task listing");
+        arns.push(...result.taskArns);
+        if (new Set(arns).size !== arns.length)
+          throw Error("Repeated ECS task identity in listing");
+        if (result.nextToken === undefined)
+          return arns;
+        if (!validText(result.nextToken) || tokens.has(result.nextToken))
+          throw Error("Invalid ECS pagination cursor");
+        tokens.add(result.nextToken);
+        nextToken = result.nextToken;
+      }
+      throw Error("ECS task listing exceeded the bounded page limit");
     },
     async describeTasks(taskArns) {
-      const response = await client.send(new DescribeTasksCommand({ tasks: taskArns }));
-      return (response.tasks ?? []).map((task) => ({
-        taskArn: task.taskArn ?? "",
-        lastStatus: task.lastStatus ?? "UNKNOWN",
-        stopCode: task.stopCode ?? null,
-        exitCode: task.containers?.[0]?.exitCode ?? null
-      }));
+      if (!taskArns.length || taskArns.length > 100 || !taskArns.every(validText) || new Set(taskArns).size !== taskArns.length)
+        throw Error("Invalid ECS task identities");
+      const result = response(await client.send(new DescribeTasksCommand({ cluster: cluster(), tasks: taskArns })));
+      if (!Array.isArray(result.tasks) || result.tasks.length !== taskArns.length || new Set(result.tasks.map((task) => task?.taskArn)).size !== taskArns.length || result.tasks.some((task) => !taskArns.includes(task?.taskArn) || !validText(task?.lastStatus)))
+        throw Error("Incomplete ECS task descriptions");
+      return result.tasks.map((task) => ({ taskArn: task.taskArn, lastStatus: task.lastStatus, stopCode: task.stopCode ?? null, exitCode: task.containers?.[0]?.exitCode ?? null }));
     },
     async stopTask(taskArn) {
-      await client.send(new StopTaskCommand({ task: taskArn }));
+      if (!validText(taskArn))
+        throw Error("Invalid ECS task identity");
+      const result = response(await client.send(new StopTaskCommand({ cluster: cluster(), task: taskArn })));
+      if (result.task?.taskArn !== taskArn || !validText(result.task?.lastStatus))
+        throw Error("Incomplete ECS stop response");
     }
   };
 }
+function validText(value) {
+  return typeof value === "string" && value.length > 0 && value.trim() === value && value.length <= 2048;
+}
 // src/sdk/execution/dispatchers/e2b.ts
 var E2B_LANE_STATUS = "e2b-lane-todo-infinity";
 
@@ -53078,8 +53190,17 @@ function creditCount(value) {
   }
   return value;
 }
+function runQuoteReceipt(value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || !value.length || Buffer.byteLength(value, "utf8") > 4096) {
+    throw new Error("Invalid quote receipt");
+  }
+  return value;
+}
 function parseRemoteRunQuote(value) {
   const quote = object(value);
+  runQuoteReceipt(quote.quoteReceipt);
   const pricing = object(quote.pricing);
   if (typeof quote.skill !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(quote.skill))
     throw new Error("Invalid quoted skill");
@@ -53226,6 +53347,69 @@ function parseUpdatedWorkspace(value) {
   return { organization: { id: organization2.id, slug: organization2.slug, name: organization2.name } };
 }
 
+// src/lib/remote-quote-errors.ts
+var quoteUnavailableMessages = Object.freeze({
+  HOSTED_PROVIDER_UNAVAILABLE: "Hosted execution is temporarily unavailable on this Skills instance.",
+  HOSTED_CONNECTORS_UNAVAILABLE: "Hosted connector execution is unavailable on this Skills instance.",
+  SKILL_IMPLEMENTATION_UNAVAILABLE: "This skill has no hosted execution implementation.",
+  HOSTED_PRICING_UNAVAILABLE: "Hosted execution is unavailable while this skill's pricing is reviewed.",
+  RUNTIME_ALLOWLIST_REQUIRED: "Hosted execution is unavailable until this Skills instance enables its skill catalog.",
+  RUNTIME_SKILL_NOT_ALLOWED: "This skill is not enabled for hosted execution on this Skills instance."
+});
+async function readQuoteUnavailableCode(response) {
+  const maximum = 16 * 1024;
+  const length = response.headers.get("content-length");
+  if (response.status !== 503 || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json" || length !== null && (!/^\d+$/.test(length) || Number(length) > maximum)) {
+    response.body?.cancel().catch(() => {});
+    return null;
+  }
+  const reader = response.body?.getReader();
+  if (!reader)
+    return null;
+  let timer;
+  let deadlineExceeded = false;
+  const expired = Symbol("quote body deadline");
+  const deadline = new Promise((resolve4) => {
+    timer = setTimeout(() => {
+      deadlineExceeded = true;
+      resolve4(expired);
+      reader.cancel().catch(() => {});
+    }, 1500);
+  });
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const next = await Promise.race([reader.read(), deadline]);
+      if (next === expired || deadlineExceeded)
+        return null;
+      if (next.done)
+        break;
+      size += next.value.byteLength;
+      if (size > maximum)
+        return null;
+      chunks.push(next.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return null;
+    const code = value.code;
+    return typeof code === "string" && Object.hasOwn(quoteUnavailableMessages, code) ? code : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
 // src/lib/remote-client.ts
 class RemoteRouteUnsupportedError extends Error {
   path;
@@ -53251,6 +53435,18 @@ class RemoteRequestError extends Error {
   }
 }
 
+class RemoteQuoteUnavailableError extends RemoteRequestError {
+  code;
+  constructor(path, code) {
+    super(path, 503);
+    this.code = code;
+    if (!Object.hasOwn(quoteUnavailableMessages, code))
+      throw new Error("Unknown quote refusal code");
+    this.name = "RemoteQuoteUnavailableError";
+    this.message = quoteUnavailableMessages[code];
+  }
+}
+
 class RemoteWorkspaceMemberError extends RemoteRequestError {
   code;
   constructor(path, code) {
@@ -53289,7 +53485,7 @@ class RemoteSkillsClient {
     this.apiUrl = normalizeSkillsApiOrigin(apiUrl);
   }
   async request(path, options) {
-    return fetch(`${this.apiUrl}${path}`, {
+    return fetch(skillsApiRequestUrl(this.apiUrl, path), {
       ...options,
       redirect: "error",
       credentials: "omit",
@@ -53312,6 +53508,11 @@ class RemoteSkillsClient {
       throw new RemoteRouteUnsupportedError(routePath, response.status, this.apiUrl);
     }
     if (!response.ok) {
+      if (opts.quoteRefusal && options?.method === "POST" && /^\/api\/v1\/skills\/[^/?#]+\/quote$/.test(routePath) && response.status === 503) {
+        const code = await readQuoteUnavailableCode(response);
+        if (code)
+          throw new RemoteQuoteUnavailableError(routePath, code);
+      }
       if (path === "/api/v1/billing/checkout" && options?.method === "POST" && response.status === 503 && await responseBodyCarriesCode(response, ["SUBSCRIPTION_CHECKOUT_UNAVAILABLE"])) {
         throw new RemoteCapabilityUnavailableError;
       }
@@ -53344,6 +53545,7 @@ class RemoteSkillsClient {
     return { status: res.status, body };
   }
   async submitRun(slug, input, args, approval = {}) {
+    const quoteReceipt = runQuoteReceipt(approval.quoteReceipt);
     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)
@@ -53360,16 +53562,21 @@ class RemoteSkillsClient {
         ...approval.maxCredits !== undefined ? { maxCredits: approval.maxCredits } : {},
         ...approval.maxCostCents !== undefined ? { maxCostCents: approval.maxCostCents } : {},
         ...approval.idempotencyKey !== undefined ? { idempotencyKey: approval.idempotencyKey } : {},
-        ...approval.inputFiles !== undefined ? { files: approval.inputFiles } : {}
+        ...approval.inputFiles !== undefined ? { files: approval.inputFiles } : {},
+        ...quoteReceipt !== undefined ? { quoteReceipt } : {}
       })
     });
+    if (!res.ok) {
+      res.body?.cancel().catch(() => {});
+      throw new RemoteRequestError(`/api/v1/runs/${encodeURIComponent(slug)}`, res.status);
+    }
     return normalizeRemoteSkillRunContract(await res.json(), slug);
   }
-  async quoteRun(slug, input = {}, args = []) {
+  async quoteRun(slug, input = {}, args = [], files) {
     const response = await this.requestNewRoute(`/api/v1/skills/${encodeURIComponent(slug)}/quote`, {
       method: "POST",
-      body: JSON.stringify({ input, args })
-    });
+      body: JSON.stringify({ input, args, ...files === undefined ? {} : { files } })
+    }, { quoteRefusal: true });
     return parseRemoteRunQuote(await response.json());
   }
   getCapabilities() {
@@ -53384,17 +53591,24 @@ class RemoteSkillsClient {
     return this.capabilities;
   }
   async submitQuotedRun(slug, input = {}, args = [], approval = {}) {
+    runQuoteReceipt(approval.quoteReceipt);
+    ({ input, args, approval } = JSON.parse(JSON.stringify({ 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)
+    const quote = approval.quoteReceipt === undefined ? await this.quoteRun(slug, input, args, approval.inputFiles?.length ? approval.inputFiles : undefined) : undefined;
+    if (quote && 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 });
+    return this.submitRun(quote?.skill ?? slug, input, args, {
+      ...approval,
+      maxCredits: maximum,
+      maxCostCents: maximum,
+      ...(quote?.quoteReceipt ?? approval.quoteReceipt) === undefined ? {} : { quoteReceipt: quote?.quoteReceipt ?? approval.quoteReceipt }
+    });
   }
   async getIdentity() {
     return (await this.requestNewRoute("/api/auth/whoami")).json();
@@ -53682,6 +53896,10 @@ class RemoteSkillsClient {
     return { id: artifactId2, fileName: String(artifact.fileName ?? artifactId2), bytes, byteSize: bytes.byteLength, sha256: artifact.sha256 };
   }
   async submitQuotedRunWithFiles(slug, input, args, files, approval = {}) {
+    runQuoteReceipt(approval.quoteReceipt);
+    ({ input, args, approval } = JSON.parse(JSON.stringify({ input, args, approval })));
+    describeRemoteFiles(files);
+    files = files.map((file) => ({ name: file.name, contentType: file.contentType, bytes: new Uint8Array(file.bytes) }));
     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");
@@ -53745,7 +53963,7 @@ class RemoteSkillsClient {
     const headers = { Authorization: `Bearer ${this.apiKey}` };
     if (ifMatch)
       headers["If-Match"] = ifMatch;
-    return fetch(`${this.apiUrl}/api/v1/skills`, {
+    return fetch(skillsApiRequestUrl(this.apiUrl, "/api/v1/skills"), {
       method: "POST",
       headers,
       body: form,
@@ -54030,7 +54248,7 @@ async function requestInvitationEmail(origin, action, input) {
   }
   const body = JSON.stringify({ invitationId: value.invitationId, token: value.token, challengeId: value.challengeId, ...action === "accept" ? { code: value.code } : {} });
   try {
-    const response = await fetch(`${target}/api/v1/account/invitations/email-${action}`, {
+    const response = await fetch(skillsApiRequestUrl(target, `/api/v1/account/invitations/email-${action}`), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body,
@@ -54061,6 +54279,312 @@ async function requestInvitationEmail(origin, action, input) {
   throw new RemoteInvitationEmailUnconfirmedError(action);
 }
 
+// src/lib/remote-private-publications.ts
+import { createHash as createHash14 } from "crypto";
+var PRIVATE_PUBLICATION_MAX_BYTES = 16 * 1024 * 1024;
+var failures = {
+  INVALID_REQUEST: [400, "The publication request is invalid."],
+  SESSION_EXPIRED: [401, "Sign in again to manage this publication."],
+  ACCOUNT_UNAVAILABLE: [403, "The account is unavailable."],
+  INTERACTIVE_SESSION_REQUIRED: [403, "An interactive account session is required."],
+  PUBLICATION_FORBIDDEN: [403, "This session cannot manage the publication."],
+  PUBLICATION_ENTITLEMENT_REQUIRED: [403, "The workspace is not entitled to publish private skills."],
+  PUBLICATION_UNAVAILABLE: [404, "The publication is unavailable to this session."],
+  MANIFEST_NAME_MISMATCH: [409, "The manifest name does not match the selected skill."],
+  IDEMPOTENCY_CONFLICT: [409, "This request key already identifies different publication bytes. Use the saved recovery directory."],
+  CURRENT_VERSION_CHANGED: [409, "The current version changed. Inspect it before explicitly starting another publication."],
+  VERSION_EXISTS: [409, "This version already exists."],
+  VERSION_RESERVED: [409, "This version is reserved by another publication."],
+  PUBLICATION_COMMITTED: [409, "The publication is already committed."],
+  PUBLICATION_UPLOAD_UNAVAILABLE: [409, "This publication cannot receive another upload."],
+  PUBLICATION_LIMIT: [429, "The workspace publication limit has been reached."],
+  PUBLICATION_BUSY: [503, "The publication is busy. Reconcile the saved intent before retrying."],
+  PUBLICATION_UNCERTAIN: [503, "The publication outcome is uncertain. Reconcile the saved intent."],
+  PUBLICATION_CAPABILITY_UNAVAILABLE: [503, "Private publishing is not enabled on this server."],
+  PUBLICATION_SIGNING_UNAVAILABLE: [503, "Upload authorization is temporarily unavailable. Keep the same intent."]
+};
+
+class PrivatePublicationError extends Error {
+  code;
+  uncertain;
+  status;
+  constructor(code, message, uncertain = false, status) {
+    super(message);
+    this.code = code;
+    this.uncertain = uncertain;
+    this.status = status;
+    this.name = "PrivatePublicationError";
+  }
+}
+var bad = () => {
+  throw new PrivatePublicationError("INVALID_PUBLICATION_INPUT", "Invalid publication input or recovery data.");
+};
+var invalid3 = () => {
+  throw new PrivatePublicationError("INVALID_PUBLICATION_RESPONSE", "The server returned an invalid publication result.");
+};
+var publicationUuid = (v2) => typeof v2 === "string" && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(v2);
+var hash = (v2) => typeof v2 === "string" && /^[a-f0-9]{64}$/.test(v2);
+var record5 = (v2) => !!v2 && typeof v2 === "object" && !Array.isArray(v2);
+var exact = (v2, keys) => record5(v2) && Object.keys(v2).sort().join(",") === keys.sort().join(",");
+var date = (v2) => typeof v2 === "string" && /^\d{4}-\d\d-\d\dT[0-9:.]+(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(v2) && Number.isFinite(Date.parse(v2));
+var publicationSha256 = (bytes) => createHash14("sha256").update(bytes).digest("hex");
+function checkedPublicationDeclaration(value) {
+  if (!exact(value, ["idempotencyKey", "version", "expectedCurrentVersionId", "manifestText", "archiveSha256", "archiveByteSize"]) || !publicationUuid(value.idempotencyKey) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || typeof value.manifestText !== "string" || Buffer.byteLength(value.manifestText) > 16384 || !hash(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES)
+    return bad();
+  try {
+    const manifest = JSON.parse(value.manifestText);
+    if (!record5(manifest) || manifest.version !== value.version || validatePortableManifestContract(manifest, { strict: true }).length || !hash(manifest.provenance?.content_hash))
+      return bad();
+  } catch {
+    return bad();
+  }
+  return Object.freeze({ ...value });
+}
+function checkedPublicationView(value, skillId, intentId, declaration) {
+  if (!exact(value, ["id", "skillId", "version", "expectedCurrentVersionId", "archiveSha256", "archiveByteSize", "state", "expiresAt", "createdAt", "versionId"]) || !publicationUuid(value.id) || value.skillId !== skillId || intentId !== undefined && value.id !== intentId || typeof value.version !== "string" || !value.version || value.version.length > 128 || /[\p{Cc}\p{Cs}]/u.test(value.version) || !(value.expectedCurrentVersionId === null || publicationUuid(value.expectedCurrentVersionId)) || !hash(value.archiveSha256) || !Number.isSafeInteger(value.archiveByteSize) || Number(value.archiveByteSize) < 1 || Number(value.archiveByteSize) > PRIVATE_PUBLICATION_MAX_BYTES || typeof value.state !== "string" || !["awaiting_upload", "queued", "verifying", "needs_attention", "committed", "rejected", "cancelled", "expired"].includes(value.state) || !date(value.expiresAt) || !date(value.createdAt) || !(value.versionId === null || publicationUuid(value.versionId)) || value.state === "committed" && value.versionId === null)
+    return invalid3();
+  if (declaration && ["version", "expectedCurrentVersionId", "archiveSha256", "archiveByteSize"].some((k4) => value[k4] !== declaration[k4]))
+    return invalid3();
+  return Object.freeze({ ...value });
+}
+async function boundedJson(url, init, token, mutation, budget = 15000, signal) {
+  const controller = new AbortController;
+  let reader;
+  let response;
+  const timeout = new PrivatePublicationError("PUBLICATION_UNCONFIRMED", "No confirmed publication result. Inspect the saved intent before retrying.", mutation);
+  let timer;
+  let abort;
+  try {
+    return await Promise.race([(async () => {
+      if (signal?.aborted)
+        throw timeout;
+      response = await fetch(url, {
+        ...init,
+        redirect: "error",
+        credentials: "omit",
+        signal: controller.signal,
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` }
+      });
+      const length = response.headers.get("content-length");
+      if (length !== null && (!/^\d+$/.test(length) || Number(length) > 65536))
+        return invalid3();
+      reader = response.body?.getReader();
+      const chunks = [];
+      let size = 0;
+      if (reader)
+        while (true) {
+          const part = await reader.read();
+          if (part.done)
+            break;
+          size += part.value.byteLength;
+          if (size > 65536)
+            return invalid3();
+          chunks.push(part.value);
+        }
+      if (controller.signal.aborted)
+        throw timeout;
+      const bytes = Buffer.concat(chunks);
+      let body;
+      try {
+        body = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+      } catch {
+        return invalid3();
+      }
+      if (!response.ok) {
+        const code = record5(body) && typeof body.code === "string" && Object.hasOwn(failures, body.code) ? body.code : null;
+        if (code && failures[code][0] === response.status)
+          throw new PrivatePublicationError(code, failures[code][1], mutation && code === "PUBLICATION_UNCERTAIN", response.status);
+        throw new PrivatePublicationError("PUBLICATION_REQUEST_FAILED", "The publication request was refused. Inspect its status before retrying.", mutation && response.status >= 500, response.status);
+      }
+      return body;
+    })(), new Promise((_, reject) => {
+      abort = () => {
+        controller.abort();
+        reject(timeout);
+      };
+      timer = setTimeout(abort, Math.max(1, Math.min(15000, budget)));
+      signal?.addEventListener("abort", abort, { once: true });
+    })]);
+  } catch (error) {
+    if (error instanceof PrivatePublicationError) {
+      if (mutation && error.code === "INVALID_PUBLICATION_RESPONSE")
+        throw timeout;
+      throw error;
+    }
+    throw timeout;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    if (abort)
+      signal?.removeEventListener("abort", abort);
+    controller.abort();
+    if (reader)
+      reader.cancel().catch(() => {});
+    else
+      response?.body?.cancel().catch(() => {});
+  }
+}
+
+class RemotePrivatePublicationsClient {
+  apiOrigin;
+  organizationId;
+  userId;
+  membershipId;
+  #token;
+  constructor(apiUrl, session) {
+    const checked = parseWorkspaceSession(session, { userId: session?.user?.id, membershipId: session?.user?.membershipId });
+    if (checked.user.role === "viewer")
+      throw new PrivatePublicationError("PUBLICATION_FORBIDDEN", failures.PUBLICATION_FORBIDDEN[1]);
+    this.apiOrigin = normalizeSkillsApiOrigin(apiUrl);
+    this.#token = checked.token;
+    this.organizationId = checked.organization.id;
+    this.userId = checked.user.id;
+    this.membershipId = checked.user.membershipId;
+    Object.freeze(this);
+  }
+  async getCapability(options = {}) {
+    if (options.timeoutMs !== undefined && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 15000))
+      return bad();
+    const response = await boundedJson(skillsApiRequestUrl(this.apiOrigin, "/api/v1/capabilities"), {}, this.#token, false, options.timeoutMs, options.signal);
+    const p2 = record5(response) && response.privatePublishing;
+    if (!record5(response) || response.contractVersion !== 1 || response.apiVersion !== 1 || !exact(p2, ["contractVersion", "enabled", "authentication", "maxArchiveBytes", "uploadMaxTtlSeconds", "executionEnabled"]) || p2.contractVersion !== 1 || typeof p2.enabled !== "boolean" || p2.authentication !== "interactive-session" || p2.maxArchiveBytes !== PRIVATE_PUBLICATION_MAX_BYTES || p2.uploadMaxTtlSeconds !== 300 || p2.executionEnabled !== false)
+      throw new PrivatePublicationError("PUBLICATION_CONTRACT_UNAVAILABLE", "This server does not support the hosted private publication contract.");
+    return Object.freeze({ ...p2 });
+  }
+  async#gate(enabled, options = {}) {
+    if (!(await this.getCapability(options)).enabled && enabled)
+      throw new PrivatePublicationError("PUBLICATION_CAPABILITY_UNAVAILABLE", failures.PUBLICATION_CAPABILITY_UNAVAILABLE[1]);
+  }
+  #path(skillId, intentId) {
+    if (!publicationUuid(skillId) || intentId !== undefined && !publicationUuid(intentId))
+      return bad();
+    return skillsApiRequestUrl(this.apiOrigin, `/api/v1/skills/${skillId}/publication-uploads${intentId ? `/${intentId}` : ""}`);
+  }
+  async#view(path, method, skillId, intentId, declaration, options = {}) {
+    const value = await boundedJson(path, { method, ...method === "GET" ? {} : { body: JSON.stringify(declaration ?? {}) } }, this.#token, method !== "GET", options.timeoutMs, options.signal);
+    try {
+      if (!record5(value) || !Object.keys(value).every((k4) => k4 === "upload" || k4 === "changed") || value.changed !== undefined && typeof value.changed !== "boolean")
+        return invalid3();
+      return checkedPublicationView(value.upload, skillId, intentId, declaration);
+    } catch (error) {
+      if (method !== "GET")
+        throw new PrivatePublicationError("PUBLICATION_UNCONFIRMED", "The publication result could not be confirmed. Reconcile the saved intent before another action.", true);
+      throw error;
+    }
+  }
+  async begin(skillId, input) {
+    const path = this.#path(skillId), declaration = checkedPublicationDeclaration(input);
+    await this.#gate(true);
+    return this.#view(path, "POST", skillId, undefined, declaration);
+  }
+  async get(skillId, intentId, options = {}) {
+    const path = this.#path(skillId, intentId), until = Date.now() + (options.timeoutMs ?? 15000);
+    await this.#gate(false, options);
+    return this.#view(path, "GET", skillId, intentId, undefined, { ...options, timeoutMs: Math.max(1, until - Date.now()) });
+  }
+  async finalize(skillId, intentId) {
+    const path = this.#path(skillId, intentId);
+    await this.#gate(true);
+    return this.#view(`${path}/finalize`, "POST", skillId, intentId);
+  }
+  async cancel(skillId, intentId) {
+    const path = this.#path(skillId, intentId);
+    await this.#gate(false);
+    return this.#view(path, "DELETE", skillId, intentId);
+  }
+  async upload(skillId, intent, bytes) {
+    const captured = checkedPublicationView(intent, skillId), path = this.#path(skillId, captured.id);
+    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== captured.archiveByteSize)
+      return bad();
+    const owned = Buffer.from(bytes);
+    if (captured.state !== "awaiting_upload" || owned.byteLength !== captured.archiveByteSize || publicationSha256(owned) !== captured.archiveSha256)
+      return bad();
+    await this.#gate(true);
+    const value = await boundedJson(`${path}/upload-url`, { method: "POST", body: "{}" }, this.#token, false);
+    const upload = this.#upload(value, captured);
+    const controller = new AbortController;
+    let timer;
+    const uncertain = () => new PrivatePublicationError("PUBLICATION_UPLOAD_UNCONFIRMED", "Upload acceptance is uncertain. Resume this saved intent to finalize and inspect it; do not upload again.", true);
+    try {
+      await Promise.race([(async () => {
+        const response = await fetch(upload.uploadUrl, { method: "PUT", headers: upload.headers, body: owned, redirect: "error", credentials: "omit", signal: controller.signal });
+        response.body?.cancel().catch(() => {});
+        if (response.status !== 200 || controller.signal.aborted)
+          throw uncertain();
+      })(), new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          reject(uncertain());
+        }, 30000);
+      })]);
+    } catch {
+      throw uncertain();
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+      controller.abort();
+    }
+  }
+  #upload(value, intent) {
+    if (!exact(value, ["upload"]) || !exact(value.upload, ["method", "uploadUrl", "headers", "expiresAt"]))
+      return invalid3();
+    const p2 = value.upload;
+    if (p2.method !== "PUT" || typeof p2.uploadUrl !== "string" || p2.uploadUrl.length > 8192 || /[\x00-\x20\x7f]/.test(p2.uploadUrl) || !date(p2.expiresAt) || Date.parse(p2.expiresAt) - Date.now() < 1000 || Date.parse(p2.expiresAt) - Date.now() > 300000 || Date.parse(p2.expiresAt) > Date.parse(intent.expiresAt) || !exact(p2.headers, ["content-type", "content-length", "x-amz-checksum-sha256", "x-amz-expected-bucket-owner"]) || p2.headers["content-type"] !== "application/gzip" || p2.headers["content-length"] !== String(intent.archiveByteSize) || p2.headers["x-amz-checksum-sha256"] !== Buffer.from(intent.archiveSha256, "hex").toString("base64") || typeof p2.headers["x-amz-expected-bucket-owner"] !== "string" || !/^\d{12}$/.test(p2.headers["x-amz-expected-bucket-owner"]))
+      return invalid3();
+    let url;
+    try {
+      url = new URL(p2.uploadUrl);
+    } catch {
+      return invalid3();
+    }
+    if (url.protocol !== "https:" || url.port || url.username || url.password || url.hash || !/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]\.s3\.[a-z]{2}(?:-[a-z]+)+-[1-9]\.amazonaws\.com$/.test(url.hostname) || url.pathname !== `/private-publication-staging/${this.organizationId}/${intent.id}/bundle.tgz` || !url.search || url.searchParams.get("X-Amz-Algorithm") !== "AWS4-HMAC-SHA256" || url.searchParams.get("X-Amz-SignedHeaders") !== "content-length;content-type;host;x-amz-checksum-sha256;x-amz-expected-bucket-owner" || !/^[a-f0-9]{64}$/.test(url.searchParams.get("X-Amz-Signature") ?? ""))
+      return invalid3();
+    const queryKeys = ["X-Amz-Algorithm", "X-Amz-Credential", "X-Amz-Date", "X-Amz-Expires", "X-Amz-Security-Token", "X-Amz-Signature", "X-Amz-SignedHeaders"];
+    if ([...url.searchParams.keys()].sort().join(",") !== queryKeys.sort().join(","))
+      return invalid3();
+    const issued = url.searchParams.get("X-Amz-Date"), ttl = url.searchParams.get("X-Amz-Expires"), credential = url.searchParams.get("X-Amz-Credential");
+    const timestamp3 = /^(\d{4})(\d\d)(\d\d)T(\d\d)(\d\d)(\d\d)Z$/.exec(issued);
+    const region = url.hostname.split(".s3.")[1].split(".amazonaws.com")[0];
+    if (!timestamp3 || !/^[1-9]\d{0,2}$/.test(ttl) || Number(ttl) > 300 || !/^[A-Z0-9]{16,128}\//.test(credential) || credential.split("/").slice(1).join("/") !== `${issued.slice(0, 8)}/${region}/s3/aws4_request` || !/^[\x21-\x7e]{1,4096}$/.test(url.searchParams.get("X-Amz-Security-Token")))
+      return invalid3();
+    const issuedAt = Date.parse(`${timestamp3[1]}-${timestamp3[2]}-${timestamp3[3]}T${timestamp3[4]}:${timestamp3[5]}:${timestamp3[6]}Z`);
+    if (!Number.isFinite(issuedAt) || issuedAt > Date.now() + 1000 || issuedAt + Number(ttl) * 1000 !== Date.parse(p2.expiresAt))
+      return invalid3();
+    return { method: "PUT", uploadUrl: url.href, expiresAt: p2.expiresAt, headers: Object.freeze({ ...p2.headers }) };
+  }
+  async wait(skillId, intentId, options = {}) {
+    const timeout = options.timeoutMs ?? 60000;
+    if (!Number.isSafeInteger(timeout) || timeout < 0 || timeout > 300000)
+      return bad();
+    const until = Date.now() + timeout;
+    let previous;
+    while (true) {
+      if (options.signal?.aborted)
+        throw new PrivatePublicationError("PUBLICATION_WAIT_ABORTED", "Stopped waiting. The server publication continues; inspect the saved intent.");
+      let view;
+      try {
+        view = await this.get(skillId, intentId, { timeoutMs: timeout === 0 ? 15000 : Math.max(1, Math.min(15000, until - Date.now())), signal: options.signal });
+      } catch (error) {
+        if (previous && Date.now() >= until && !options.signal?.aborted)
+          return previous;
+        throw error;
+      }
+      previous = view;
+      if (!["queued", "verifying"].includes(view.state) || Date.now() >= until)
+        return view;
+      await new Promise((resolve4) => {
+        const timer = setTimeout(done, Math.min(1000, until - Date.now()));
+        function done() {
+          clearTimeout(timer);
+          options.signal?.removeEventListener("abort", done);
+          resolve4();
+        }
+        options.signal?.addEventListener("abort", done, { once: true });
+      });
+    }
+  }
+}
+
 // src/lib/remote-auth.ts
 var MAX_ERROR_DETAIL_LENGTH = 200;
 
@@ -54083,10 +54607,11 @@ class HostedApiError extends Error {
 async function requestAuthApi(instance, path, options) {
   const url = normalizeSkillsApiOrigin(instance);
   const safeUrl = url;
-  const endpoint = `${(options?.method || "GET").toUpperCase()} ${safeUrl}${path}`;
+  const requestUrl = skillsApiRequestUrl(url, path);
+  const endpoint = `${(options?.method || "GET").toUpperCase()} ${requestUrl}`;
   let res;
   try {
-    res = await fetch(`${url}${path}`, {
+    res = await fetch(requestUrl, {
       ...options,
       redirect: "error",
       signal: options?.signal ?? AbortSignal.timeout(15000),
@@ -54101,10 +54626,10 @@ async function requestAuthApi(instance, path, options) {
   const text2 = await res.text();
   const body = text2 ? parseJsonBody(text2) : {};
   if (!res.ok) {
-    const record5 = isRecord6(body) ? body : {};
-    const detail = typeof record5.detail === "string" ? record5.detail : undefined;
-    const error = typeof record5.error === "string" ? record5.error : undefined;
-    const code = typeof record5.code === "string" ? record5.code : undefined;
+    const record6 = isRecord6(body) ? body : {};
+    const detail = typeof record6.detail === "string" ? record6.detail : undefined;
+    const error = typeof record6.error === "string" ? record6.error : undefined;
+    const code = typeof record6.code === "string" ? record6.code : undefined;
     throw new HostedApiError(detail || error || `${res.status} ${res.statusText}`, {
       status: res.status,
       code,
@@ -54138,6 +54663,10 @@ class RemoteSkillsAuthClient {
   constructor(apiUrl) {
     this.apiOrigin = normalizeSkillsApiOrigin(apiUrl);
   }
+  async openPrivatePublications(email2, code, context) {
+    const origin = this.apiOrigin, captured = workspaceContext(context);
+    return new RemotePrivatePublicationsClient(origin, await this.switchWorkspace(email2, code, captured));
+  }
   requestInvitationEmailChallenge(input) {
     return requestInvitationEmail(this.apiOrigin, "challenge", input);
   }
@@ -54185,9 +54714,10 @@ class RemoteSkillsAuthClient {
     const apiOrigin = this.apiOrigin;
     if (typeof email2 !== "string" || !email2.includes("@") || typeof code !== "string" || !/^\d{6}$/.test(code))
       throw new Error("Fresh email and six-digit verification code are required to manage this account");
+    const requestUrl = skillsApiRequestUrl(apiOrigin, "/api/auth/verify");
     let response;
     try {
-      response = await fetch(`${apiOrigin}/api/auth/verify`, {
+      response = await fetch(requestUrl, {
         method: "POST",
         redirect: "error",
         credentials: "omit",
@@ -54278,6 +54808,242 @@ class RemoteSkillsAuthClient {
     return requestAuthApi(this.apiOrigin, path, options);
   }
 }
+// src/lib/private-publication-recovery.ts
+import { constants as constants2, closeSync as closeSync3, fsyncSync, fstatSync as fstatSync3, lstatSync as lstatSync5, mkdirSync as mkdirSync8, openSync as openSync3, readSync as readSync2, realpathSync as realpathSync2, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname10, isAbsolute as isAbsolute5, join as join21, resolve as resolve4 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+var fail = () => {
+  throw new PrivatePublicationError("PUBLICATION_RECOVERY_INVALID", "The recovery directory is invalid or changed. Preserve it and inspect the existing intent; do not start a replacement automatically.");
+};
+function safeDirectory(directory) {
+  if (!isAbsolute5(directory) || directory !== resolve4(directory) || realpathSync2(directory) !== directory)
+    return fail();
+  for (let path = directory;; path = dirname10(path)) {
+    const stat = lstatSync5(path);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+      return fail();
+    if (path === dirname10(path))
+      break;
+  }
+  const own = lstatSync5(directory);
+  if ((own.mode & 63) !== 0 || process.getuid && own.uid !== process.getuid())
+    return fail();
+  return { dev: own.dev, ino: own.ino };
+}
+function unchangedDirectory(directory, identity) {
+  const now2 = safeDirectory(directory);
+  if (now2.dev !== identity.dev || now2.ino !== identity.ino)
+    return fail();
+}
+function readOwned(directory, name, max) {
+  const identity = safeDirectory(directory), file = join21(directory, name);
+  const fd = openSync3(file, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    const stat = fstatSync3(fd);
+    if (!stat.isFile() || stat.nlink !== 1 || stat.size > max || stat.size < 1 || (stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid())
+      return fail();
+    const buffer = Buffer.alloc(Math.min(max, stat.size) + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const count = readSync2(fd, buffer, length, buffer.length - length, length);
+      if (count === 0)
+        break;
+      length += count;
+    }
+    const bytes = buffer.subarray(0, length), after = fstatSync3(fd);
+    unchangedDirectory(directory, identity);
+    if (bytes.length !== stat.size || stat.size !== after.size || stat.mtimeMs !== after.mtimeMs || stat.ctimeMs !== after.ctimeMs)
+      return fail();
+    return bytes;
+  } finally {
+    closeSync3(fd);
+  }
+}
+function writeOwned(directory, name, bytes) {
+  const fd = openSync3(join21(directory, name), constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  try {
+    writeFileSync6(fd, bytes);
+    fsyncSync(fd);
+  } finally {
+    closeSync3(fd);
+  }
+}
+function save(directory, value) {
+  const identity = safeDirectory(directory), temporary = `.receipt-${randomUUID6()}.json`;
+  writeOwned(directory, temporary, JSON.stringify(value) + `
+`);
+  unchangedDirectory(directory, identity);
+  renameSync3(join21(directory, temporary), join21(directory, "receipt.json"));
+  const fd = openSync3(directory, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync3(fd);
+  }
+}
+function bind(client, receipt) {
+  if (["apiOrigin", "organizationId", "userId", "membershipId"].some((k4) => client[k4] !== receipt[k4]))
+    throw new PrivatePublicationError("PUBLICATION_IDENTITY_CHANGED", "The fresh session does not match the recovery directory's server, account and membership.");
+}
+async function locked(directory, action) {
+  const identity = safeDirectory(directory), file = join21(directory, "operation.lock");
+  let fd;
+  try {
+    fd = openSync3(file, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+  } catch {
+    throw new PrivatePublicationError("PUBLICATION_RECOVERY_BUSY", "Another operation holds this recovery directory. If it crashed, confirm that process has stopped before explicitly removing operation.lock and resuming.");
+  }
+  const lock = fstatSync3(fd);
+  try {
+    writeFileSync6(fd, JSON.stringify({ pid: process.pid }) + `
+`);
+    fsyncSync(fd);
+    return await action();
+  } finally {
+    closeSync3(fd);
+    unchangedDirectory(directory, identity);
+    const now2 = lstatSync5(file);
+    if (now2.dev !== lock.dev || now2.ino !== lock.ino || !now2.isFile() || now2.isSymbolicLink())
+      fail();
+    unlinkSync(file);
+  }
+}
+function readPrivatePublicationRecovery(directory) {
+  try {
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(readOwned(directory, "receipt.json", 65536)));
+    if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== ["contractVersion", "apiOrigin", "organizationId", "userId", "membershipId", "skillId", "declaration", "phase", "intent"].sort().join(",") || value.contractVersion !== 1 || ![value.organizationId, value.userId, value.membershipId, value.skillId].every(publicationUuid) || typeof value.apiOrigin !== "string" || normalizeSkillsApiOrigin(value.apiOrigin) !== value.apiOrigin || !["prepared", "begin_uncertain", "awaiting_upload", "upload_uncertain", "uploaded", "finalize_uncertain", "observed"].includes(value.phase))
+      return fail();
+    value.declaration = checkedPublicationDeclaration(value.declaration);
+    if (value.intent !== null)
+      value.intent = checkedPublicationView(value.intent, value.skillId, undefined, value.declaration);
+    if (value.intent === null && !["prepared", "begin_uncertain"].includes(value.phase))
+      return fail();
+    const bytes = readOwned(directory, "bundle.tgz", PRIVATE_PUBLICATION_MAX_BYTES);
+    if (bytes.length !== value.declaration.archiveByteSize || publicationSha256(bytes) !== value.declaration.archiveSha256)
+      return fail();
+    return { receipt: value, bytes };
+  } catch {
+    return fail();
+  }
+}
+async function preparePrivatePublication(client, sourceDirectory, recoveryDirectory, input) {
+  if (!publicationUuid(input.skillId) || !(input.expectedCurrentVersionId === null || publicationUuid(input.expectedCurrentVersionId)) || input.idempotencyKey !== undefined && !publicationUuid(input.idempotencyKey))
+    return fail();
+  const packed = packSkillBundle(sourceDirectory, { maxUnpackedBytes: 32 * 1024 * 1024 });
+  const inspected = await inspectSkillBundle(packed.bytes, { limits: { compressedBytes: PRIVATE_PUBLICATION_MAX_BYTES } });
+  const manifest = inspected.entries.find((entry) => entry.path === "skill.json");
+  if (!manifest || manifest.bytes.length > 16384 || !(await verifyContentHashFromEntries(inspected.entries)).valid)
+    throw new PrivatePublicationError("PUBLICATION_BUNDLE_INVALID", "The skill must have a valid skill.json with its current content hash. Validate the skill before publishing.");
+  const manifestText = new TextDecoder("utf-8", { fatal: true }).decode(manifest.bytes);
+  const declaration = checkedPublicationDeclaration({
+    idempotencyKey: input.idempotencyKey ?? randomUUID6(),
+    version: JSON.parse(manifestText).version,
+    expectedCurrentVersionId: input.expectedCurrentVersionId,
+    manifestText,
+    archiveSha256: inspected.sha256,
+    archiveByteSize: packed.bytes.length
+  });
+  const receipt = {
+    contractVersion: 1,
+    apiOrigin: client.apiOrigin,
+    organizationId: client.organizationId,
+    userId: client.userId,
+    membershipId: client.membershipId,
+    skillId: input.skillId,
+    declaration,
+    phase: "prepared",
+    intent: null
+  };
+  if (!isAbsolute5(recoveryDirectory) || resolve4(recoveryDirectory) !== recoveryDirectory || realpathSync2(dirname10(recoveryDirectory)) !== dirname10(recoveryDirectory))
+    return fail();
+  mkdirSync8(recoveryDirectory, { mode: 448 });
+  safeDirectory(recoveryDirectory);
+  const parent = openSync3(dirname10(recoveryDirectory), constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    fsyncSync(parent);
+  } finally {
+    closeSync3(parent);
+  }
+  writeOwned(recoveryDirectory, "bundle.tgz", packed.bytes);
+  save(recoveryDirectory, receipt);
+  return receipt;
+}
+function privatePublicationResult(directory, receipt) {
+  const state = receipt.intent?.state ?? receipt.phase, committed = state === "committed";
+  const nextAction = committed ? "The version is published. Private execution remains unavailable." : ["rejected", "cancelled", "expired"].includes(state) ? "This intent is terminal. Inspect the result before explicitly preparing another version." : state === "needs_attention" ? "Keep this intent and contact the service operator; do not create a replacement or upload again." : receipt.phase === "upload_uncertain" ? "Run publication resume with this recovery directory to finalize the same intent without another upload." : receipt.intent ? "Run publication status or resume with this recovery directory; cancel explicitly if you want to stop." : "Run publication resume with this recovery directory to reconcile the identical request key and declaration.";
+  return {
+    recoveryDirectory: directory,
+    skillId: receipt.skillId,
+    intentId: receipt.intent?.id ?? null,
+    state,
+    versionId: receipt.intent?.versionId ?? null,
+    committed,
+    executionEnabled: false,
+    nextAction
+  };
+}
+async function continuePrivatePublication(client, directory, options) {
+  if (options.confirm !== true)
+    throw new PrivatePublicationError("PUBLICATION_CONFIRM_REQUIRED", "Explicit upload confirmation is required.");
+  if (options.waitMs !== undefined && (!Number.isSafeInteger(options.waitMs) || options.waitMs < 0 || options.waitMs > 300000))
+    return fail();
+  return locked(directory, () => continueLocked(client, directory, options));
+}
+async function continueLocked(client, directory, options) {
+  const { receipt, bytes } = readPrivatePublicationRecovery(directory);
+  bind(client, receipt);
+  if (!receipt.intent) {
+    receipt.phase = "begin_uncertain";
+    save(directory, receipt);
+    receipt.intent = await client.begin(receipt.skillId, receipt.declaration);
+    receipt.phase = "awaiting_upload";
+    save(directory, receipt);
+  } else {
+    receipt.intent = checkedPublicationView(await client.get(receipt.skillId, receipt.intent.id), receipt.skillId, receipt.intent.id, receipt.declaration);
+    save(directory, receipt);
+  }
+  if (receipt.intent.state === "awaiting_upload") {
+    if (receipt.phase === "awaiting_upload") {
+      receipt.phase = "upload_uncertain";
+      save(directory, receipt);
+      try {
+        await client.upload(receipt.skillId, receipt.intent, bytes);
+      } catch (error) {
+        if (error instanceof PrivatePublicationError && !error.uncertain) {
+          receipt.phase = "awaiting_upload";
+          save(directory, receipt);
+        }
+        throw error;
+      }
+      receipt.phase = "uploaded";
+      save(directory, receipt);
+    }
+    receipt.phase = "finalize_uncertain";
+    save(directory, receipt);
+    receipt.intent = checkedPublicationView(await client.finalize(receipt.skillId, receipt.intent.id), receipt.skillId, receipt.intent.id, receipt.declaration);
+    receipt.phase = "observed";
+    save(directory, receipt);
+  }
+  if (options.waitMs !== undefined && options.waitMs > 0 && ["queued", "verifying"].includes(receipt.intent.state)) {
+    receipt.intent = checkedPublicationView(await client.wait(receipt.skillId, receipt.intent.id, { timeoutMs: options.waitMs }), receipt.skillId, receipt.intent.id, receipt.declaration);
+    receipt.phase = "observed";
+    save(directory, receipt);
+  }
+  return privatePublicationResult(directory, receipt);
+}
+async function inspectPrivatePublication(client, directory, cancel = false) {
+  return locked(directory, () => inspectLocked(client, directory, cancel));
+}
+async function inspectLocked(client, directory, cancel) {
+  const { receipt } = readPrivatePublicationRecovery(directory);
+  bind(client, receipt);
+  if (receipt.intent) {
+    receipt.intent = checkedPublicationView(await (cancel ? client.cancel(receipt.skillId, receipt.intent.id) : client.get(receipt.skillId, receipt.intent.id)), receipt.skillId, receipt.intent.id, receipt.declaration);
+    save(directory, receipt);
+  } else if (cancel)
+    throw new PrivatePublicationError("PUBLICATION_INTENT_UNKNOWN", "Reconcile the saved begin request with publication resume before cancelling its intent.");
+  return privatePublicationResult(directory, receipt);
+}
 export {
   verifyContentHashFromEntries,
   validateRunLifecycleEvent,
@@ -54307,7 +55073,9 @@ export {
   registerRoutes,
   redactRunOutput,
   receiptId,
+  readPrivatePublicationRecovery,
   protocolStateOf,
+  preparePrivatePublication,
   packSkillBundle,
   noticeLocalSkillsMode,
   normalizeSkillsApiOrigin,
@@ -54321,6 +55089,7 @@ export {
   isSkillsLocalOptIn,
   isActiveStatus,
   inspectSkillBundle,
+  inspectPrivatePublication,
   getServerSkillMd,
   getServerSkill,
   expiresAtFor,
@@ -54345,6 +55114,7 @@ export {
   createGovernanceStore,
   createCancelService,
   createAwsEcsClient,
+  continuePrivatePublication,
   configuredSkillsApiUrl,
   computeContentHashFromEntries,
   clientTokenFor,
@@ -54381,6 +55151,8 @@ export {
   RemoteSkillsAuthClient,
   RemoteRouteUnsupportedError,
   RemoteRequestError,
+  RemoteQuoteUnavailableError,
+  RemotePrivatePublicationsClient,
   RemoteInvitationEmailUnconfirmedError,
   RemoteInvitationEmailError,
   RemoteCreditApprovalError,
@@ -54390,8 +55162,10 @@ export {
   RUN_LIFECYCLE_EVENT_TYPES,
   RUN_LIFECYCLE_EVENT_FIELDS,
   REMOTE_SKILL_RUN_CONTRACT_VERSION,
+  PrivatePublicationError,
   PostgresSkillsStore,
   PostgresGovernanceStore,
+  PRIVATE_PUBLICATION_MAX_BYTES,
   MissingSkillsFleetError,
   MemorySkillsStore,
   MemoryRunExecutionStore,