gencow 0.1.193 → 0.1.194

package/bin/gencow.mjs

@@ -38,6 +38,7 @@ import {
   updateEnvLocalUrl,
 } from "../lib/cli-project-runtime.mjs";
 import { createCodegenCommand } from "../lib/codegen-command.mjs";
+import { runCliCommand } from "../lib/cli-command-runner.mjs";
 import { createDoctorCommand } from "../lib/doctor-command.mjs";
 import { maybeCheckCliVersion } from "../lib/cli-version-check.mjs";
 import { updateComponentReadme } from "../lib/component-readme.mjs";
@@ -579,13 +580,10 @@ maybeCheckCliVersion({
   warnImpl: warn,
 });
 
-if (commands[cmd]) {
-  Promise.resolve(commands[cmd](...args)).catch((e) => {
-    error(e.message || String(e));
-    process.exit(1);
-  });
-} else {
-  error(`Unknown command: ${cmd}`);
-  commands.help();
-  process.exit(1);
-}
+process.exitCode = await runCliCommand({
+  args,
+  command: cmd,
+  commands,
+  errorImpl: error,
+  helpImpl: commands.help,
+});

package/lib/app-command.mjs

@@ -24,6 +24,14 @@ import { updateEnvLocalUrl } from "./cli-project-runtime.mjs";
 // Covers the 60s runtime-observer restart grace plus multiple 5s reconciliation scans.
 const DEFAULT_DELETE_POLL_ATTEMPTS = 75;
 const DELETE_POLL_INTERVAL_MS = 1_000;
+const DEFAULT_APP_CREATE_TIMEOUT_MS = 60_000;
+
+function resolveAppCreateTimeoutMs(value) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 100 && parsed <= 600_000
+    ? parsed
+    : DEFAULT_APP_CREATE_TIMEOUT_MS;
+}
 
 function appResponseStatus(response) {
   return Number.isSafeInteger(response?.status) ? `HTTP ${response.status}` : "unknown HTTP status";
@@ -105,23 +113,52 @@ async function confirmDelete(name) {
 }
 
 export function createAppCommand({
+  appCreateTimeoutMs = resolveAppCreateTimeoutMs(process.env.GENCOW_APP_CREATE_TIMEOUT_MS),
+  clearTimeoutImpl = clearTimeout,
+  confirmDeleteImpl = confirmDelete,
+  createAbortControllerImpl = () => new AbortController(),
   cwdImpl = () => process.cwd(),
   loadConfig,
   errorImpl = error,
   infoImpl = info,
   loadCredsImpl = loadCreds,
   logImpl = log,
-  processRef = process,
   requireCredsImpl = requireCreds,
   rpcMutationImpl = rpcMutation,
   rpcQueryImpl = rpcQuery,
   saveCredsImpl = saveCreds,
+  setTimeoutImpl = setTimeout,
   sleepImpl = (ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms)),
   deletePollAttempts = DEFAULT_DELETE_POLL_ATTEMPTS,
   successImpl = success,
   updateEnvLocalUrlImpl = updateEnvLocalUrl,
   warnImpl = warn,
 }) {
+  const boundedAppCreateTimeoutMs = resolveAppCreateTimeoutMs(appCreateTimeoutMs);
+
+  async function requestAppCreate(creds, name) {
+    const controller = createAbortControllerImpl();
+    const timeoutError = new Error(
+      `App creation request timed out after ${boundedAppCreateTimeoutMs}ms. Please try again.`,
+    );
+    let timeoutHandle;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+      timeoutHandle = setTimeoutImpl(() => {
+        controller.abort(timeoutError);
+        reject(timeoutError);
+      }, boundedAppCreateTimeoutMs);
+    });
+    try {
+      const request = (async () => {
+        const response = await rpcMutationImpl(creds, "apps.create", { name }, { signal: controller.signal });
+        return { response, data: await readJsonObjectResponse(response) };
+      })();
+      return await Promise.race([request, timeoutPromise]);
+    } finally {
+      clearTimeoutImpl(timeoutHandle);
+    }
+  }
+
   return async function app(subcmd, ...rest) {
     if (subcmd === "--help" || subcmd === "-h" || rest.includes("--help") || rest.includes("-h")) {
       logImpl(`\n${BOLD}${CYAN}gencow app${RESET} — App management\n`);
@@ -131,10 +168,10 @@ export function createAppCommand({
       logImpl(`    ${CYAN}create${RESET}    Create a new app`);
       logImpl(`    ${CYAN}delete${RESET}    Delete an app (confirmation required)`);
       logImpl(`    ${CYAN}status${RESET}    Show app status\n`);
-      return;
+      return 0;
     }
 
-    const creds = requireCredsImpl();
+    const creds = requireCredsImpl({ throwOnMissing: true });
 
     if (!subcmd || subcmd === "list") {
       logImpl(`\n${BOLD}${CYAN}Your Apps${RESET}\n`);
@@ -142,18 +179,16 @@ export function createAppCommand({
       const body = await res.json().catch(() => null);
       if (!res.ok) {
         errorImpl(appResponseError(body, invalidAppResponse("app list", res, "error")));
-        processRef.exit(1);
-        return;
+        return 1;
       }
       const apps = parseAppListResponse(body);
       if (!apps) {
         errorImpl(invalidAppResponse("app list", res, "success"));
-        processRef.exit(1);
-        return;
+        return 1;
       }
       if (!apps.length) {
         infoImpl("No apps yet. Run: gencow app create <name>");
-        return;
+        return 0;
       }
 
       logImpl(`  ${"NAME".padEnd(22)} ${"STATUS".padEnd(12)} ${"URL".padEnd(38)} DEPLOYED`);
@@ -167,29 +202,26 @@ export function createAppCommand({
         );
       }
       logImpl("");
-      return;
+      return 0;
     }
 
     if (subcmd === "create") {
       const name = rest[0];
       if (!name) {
         errorImpl("Usage: gencow app create <name>");
-        processRef.exit(1);
+        return 1;
       }
 
       logImpl(`\n${BOLD}${CYAN}Gencow App Create${RESET}\n`);
       infoImpl(`Creating app "${name}"...`);
-      const res = await rpcMutationImpl(creds, "apps.create", { name });
-      const data = await readJsonObjectResponse(res);
+      const { response: res, data } = await requestAppCreate(creds, name);
       if (!res.ok) {
         errorImpl(appResponseError(data, invalidAppResponse("app create", res, "error")));
-        processRef.exit(1);
-        return;
+        return 1;
       }
       if (!data) {
         errorImpl(invalidAppResponse("app create", res, "success"));
-        processRef.exit(1);
-        return;
+        return 1;
       }
 
       let createdApp;
@@ -197,8 +229,7 @@ export function createAppCommand({
         createdApp = resolveCreatedAppResponse(data, { platformUrl: creds.platformUrl });
       } catch (caught) {
         errorImpl(caught.message);
-        processRef.exit(1);
-        return;
+        return 1;
       }
       const { appId, appUrl } = createdApp;
 
@@ -259,7 +290,7 @@ ${dashboardLine}
 
   ${DIM}pnpm gencow dev   — watch & auto-deploy to cloud + live logs${RESET}
 `);
-      return;
+      return 0;
     }
 
     if (subcmd === "delete") {
@@ -270,15 +301,14 @@ ${dashboardLine}
       const name = rest.find((value) => !value.startsWith("-")) || loadCredsImpl()?.currentApp;
       if (!name || unsupportedOption) {
         errorImpl("Usage: gencow app delete <name> [--force]");
-        processRef.exit(1);
-        return;
+        return 1;
       }
 
       if (!force) {
-        const confirmed = await confirmDelete(name);
+        const confirmed = await confirmDeleteImpl(name);
         if (!confirmed) {
           warnImpl("Cancelled — name did not match.");
-          processRef.exit(0);
+          return 0;
         }
       }
 
@@ -304,8 +334,7 @@ ${dashboardLine}
             invalidAppResponse("app delete", delRes, delRes.ok ? "success" : "error"),
           ),
         );
-        processRef.exit(1);
-        return;
+        return 1;
       }
 
       const currentCreds = loadCredsImpl();
@@ -314,15 +343,14 @@ ${dashboardLine}
       }
 
       successImpl(`App "${name}" deleted`);
-      return;
+      return 0;
     }
 
     if (subcmd === "status") {
       const name = rest[0] || loadCredsImpl()?.currentApp;
       if (!name) {
         errorImpl("Usage: gencow app status <name>");
-        processRef.exit(1);
-        return;
+        return 1;
       }
       const res = await rpcQueryImpl(creds, "apps.get", { name });
       const decoded = await readJsonValueResponse(res);
@@ -333,24 +361,20 @@ ${dashboardLine}
             ? appNotFoundDiagnostic()
             : appResponseError(body, invalidAppResponse("app status", res, "error")),
         );
-        processRef.exit(1);
-        return;
+        return 1;
       }
       if (!decoded.parsed) {
         errorImpl(invalidAppResponse("app status", res, "success"));
-        processRef.exit(1);
-        return;
+        return 1;
       }
       const lookup = parseAppLookupResponse(body, name);
       if (lookup.kind === "not_found") {
         errorImpl(appNotFoundDiagnostic());
-        processRef.exit(1);
-        return;
+        return 1;
       }
       if (lookup.kind === "invalid_response") {
         errorImpl(invalidAppResponse("app status", res, "success"));
-        processRef.exit(1);
-        return;
+        return 1;
       }
       const data = lookup.app;
       logImpl(`\n  ${BOLD}${data.name}${RESET}`);
@@ -377,10 +401,11 @@ ${dashboardLine}
         );
       }
       logImpl("");
-      return;
+      return 0;
     }
 
     errorImpl(`Unknown app subcommand: ${subcmd}`);
     logImpl(`  Usage: gencow app [list|create|delete|status]`);
+    return 1;
   };
 }

package/lib/cli-command-runner.mjs

@@ -0,0 +1,27 @@
+function commandErrorMessage(caught) {
+  if (caught instanceof Error && caught.message) return caught.message;
+  return String(caught);
+}
+
+function normalizeCommandExitCode(exitCode) {
+  if (exitCode === undefined || exitCode === 0) return 0;
+  if (exitCode === 1) return 1;
+  throw new Error("CLI command returned an invalid exit code");
+}
+
+export async function runCliCommand({ args, command, commands, errorImpl, helpImpl }) {
+  const handler = Object.hasOwn(commands, command) ? commands[command] : undefined;
+  if (typeof handler !== "function") {
+    errorImpl(`Unknown command: ${command}`);
+    helpImpl();
+    return 1;
+  }
+
+  try {
+    const exitCode = await Reflect.apply(handler, commands, args);
+    return normalizeCommandExitCode(exitCode);
+  } catch (caught) {
+    errorImpl(commandErrorMessage(caught));
+    return 1;
+  }
+}

package/lib/deploy-runtime.mjs

@@ -468,10 +468,7 @@ export function createDeployCommand({
       const declaredStaticClients = Array.isArray(workspaceConfig?.clients)
         ? workspaceConfig.clients.filter((client) => client?.static?.dir)
         : [];
-      const clientSelection = selectClient(
-        declaredStaticClients,
-        cliSelection?.client ?? null,
-      );
+      const clientSelection = selectClient(declaredStaticClients, cliSelection?.client ?? null);
       if (clientSelection.error) {
         errorImpl(clientSelection.error);
         exitImpl(1);
@@ -541,7 +538,9 @@ export function createDeployCommand({
         resolvePathImpl,
       }) || displayName;
     const backendDeployRuntime =
-      backendProjectRoot === cwd ? deployPackageRuntime : createDeployPackageRuntimeForCwd(() => backendProjectRoot);
+      backendProjectRoot === cwd
+        ? deployPackageRuntime
+        : createDeployPackageRuntimeForCwd(() => backendProjectRoot);
 
     if (parsed.existingBundleMode && !appId) {
       errorImpl("--existing-bundle requires an existing app target.");
@@ -607,7 +606,7 @@ export function createDeployCommand({
     }
 
     if (parsed.staticDeploy) {
-      return runStaticDeployFlow({
+      await runStaticDeployFlow({
         appId,
         backendRoot: backendProjectRoot,
         creds,
@@ -659,6 +658,7 @@ export function createDeployCommand({
               })
           : undefined,
       });
+      return 0;
     }
 
     logImpl(`\n${BOLD}${CYAN}Gencow Deploy${RESET}\n`);

package/lib/platform-client.mjs

@@ -42,9 +42,15 @@ export function resolveCredsFromSources({ env = process.env, loadCredsImpl = loa
   return creds;
 }
 
+export function formatPlatformCredentialsRequiredMessage({ isCi = Boolean(process.env.CI) } = {}) {
+  return isCi
+    ? "CI environment detected but no credentials found. Set GENCOW_TOKEN in your CI/CD settings."
+    : "Not logged in. Run: gencow login";
+}
+
 export class PlatformCredentialsRequiredError extends Error {
-  constructor() {
-    super("Platform credentials are required");
+  constructor(message = "Platform credentials are required") {
+    super(message);
     this.name = "PlatformCredentialsRequiredError";
   }
 }
@@ -52,7 +58,9 @@ export class PlatformCredentialsRequiredError extends Error {
 export function requireCreds({ throwOnMissing = false } = {}) {
   const creds = resolveCredsFromSources();
   if (!creds?.apiKey) {
-    if (throwOnMissing) throw new PlatformCredentialsRequiredError();
+    if (throwOnMissing) {
+      throw new PlatformCredentialsRequiredError(formatPlatformCredentialsRequiredMessage());
+    }
     if (process.env.CI) {
       error("CI environment detected but no credentials found.");
       info(`Set ${CYAN}GENCOW_TOKEN${RESET} secret in your CI/CD settings.`);
@@ -86,10 +94,11 @@ export async function rpcQuery(creds, queryName, args = {}) {
   });
 }
 
-export async function rpcMutation(creds, mutationName, args = {}) {
+export async function rpcMutation(creds, mutationName, args = {}, requestOptions = {}) {
   return platformFetch(creds, "/api/mutation", {
+    ...requestOptions,
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: { ...requestOptions.headers, "Content-Type": "application/json" },
     body: JSON.stringify({ name: mutationName, args }),
   });
 }

package/lib/static-command.mjs

@@ -66,11 +66,13 @@ export function readStaticProjectContext(options = {}) {
       projectRoot = selection.projectDir;
     } else {
       const staticBackend = detectStaticDeployBackendImpl({ cwd, existsSyncImpl, resolvePathImpl });
-      projectRoot = staticBackend.detectedBackend && staticBackend.backendRoot ? staticBackend.backendRoot : cwd;
+      projectRoot =
+        staticBackend.detectedBackend && staticBackend.backendRoot ? staticBackend.backendRoot : cwd;
     }
   } catch {
     const staticBackend = detectStaticDeployBackendImpl({ cwd, existsSyncImpl, resolvePathImpl });
-    projectRoot = staticBackend.detectedBackend && staticBackend.backendRoot ? staticBackend.backendRoot : cwd;
+    projectRoot =
+      staticBackend.detectedBackend && staticBackend.backendRoot ? staticBackend.backendRoot : cwd;
   }
   const gencowJsonPath = resolveProjectMetadataPath(projectRoot, resolvePathImpl);
   let appId = explicitAppId;
@@ -201,15 +203,19 @@ export function createStaticCommand(options = {}) {
 
     const parsed = parseStaticArgs(staticArgs);
     const creds = requireCredsImpl();
-    const { appId, displayName: initialDisplayName, gencowJsonPath, prodAppId, projectRoot } = readStaticProjectContextImpl({
+    const {
+      appId,
+      displayName: initialDisplayName,
+      gencowJsonPath,
+      prodAppId,
+      projectRoot,
+    } = readStaticProjectContextImpl({
       cwd: cwdImpl(),
       explicitAppId: parsed.appId,
     });
     const processEnv = process.env;
     const cliSelection = getCliInvocationSelection();
-    const config = loadConfigImpl
-      ? await loadConfigImpl({ cwd: projectRoot, processEnv })
-      : null;
+    const config = loadConfigImpl ? await loadConfigImpl({ cwd: projectRoot, processEnv }) : null;
     const displayName = config
       ? readProjectDisplayNameImpl({
           config,
@@ -289,7 +295,7 @@ export function createStaticCommand(options = {}) {
       );
     }
 
-    return runStaticDeployRuntimeImpl({
+    await runStaticDeployRuntimeImpl({
       creds,
       appId: deployTarget,
       displayName,
@@ -302,5 +308,6 @@ export function createStaticCommand(options = {}) {
         releaseSourceRoot: projectRoot,
       },
     });
+    return 0;
   };
 }

package/lib/template-marketplace-command.mjs

@@ -53,7 +53,13 @@ async function createSourceBundle({ cwd, staticOutputDir, mkdirSyncImpl = mkdirS
   return out;
 }
 
-async function createStaticBundle({ cwd, outputDir, mkdirSyncImpl = mkdirSync, resolvePathImpl = resolve, tarCreateImpl }) {
+async function createStaticBundle({
+  cwd,
+  outputDir,
+  mkdirSyncImpl = mkdirSync,
+  resolvePathImpl = resolve,
+  tarCreateImpl,
+}) {
   const out = resolve(cwd, ".gencow", "template-static.tar.gz");
   mkdirSyncImpl(resolve(cwd, ".gencow"), { recursive: true });
   await createTarGzipArchive({
@@ -65,12 +71,7 @@ async function createStaticBundle({ cwd, outputDir, mkdirSyncImpl = mkdirSync, r
   return out;
 }
 
-async function extractTemplateArchive({
-  archive,
-  targetDir,
-  mkdirSyncImpl = mkdirSync,
-  tarExtractImpl,
-}) {
+async function extractTemplateArchive({ archive, targetDir, mkdirSyncImpl = mkdirSync, tarExtractImpl }) {
   mkdirSyncImpl(targetDir, { recursive: true });
   const extractImpl = tarExtractImpl ?? (await import("tar")).extract;
   await extractImpl({ file: archive, cwd: targetDir });
@@ -230,7 +231,10 @@ export function createTemplateMarketplaceCommand({
     if (subcommand === "publish") return publish(options);
     if (subcommand === "list") return list();
     if (subcommand === "info") return infoCommand(options._[0]);
-    if (subcommand === "download") return download(options._[0], options);
+    if (subcommand === "download") {
+      await download(options._[0], options);
+      return 0;
+    }
     if (subcommand === "clone") {
       const slug = options._[0];
       const dir = options._[1] || slug;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.193",
+  "version": "0.1.194",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {
@@ -33,9 +33,9 @@
   "devDependencies": {
     "@types/node": "^25.9.5",
     "better-auth": "^1.6.23",
-    "@gencow/react": "0.2.6",
     "@gencow/core": "0.1.42",
-    "@gencow/client": "0.2.6"
+    "@gencow/client": "0.2.6",
+    "@gencow/react": "0.2.6"
   },
   "scripts": {
     "prebuild": "pnpm --filter @gencow/migration-contract run build && pnpm --filter @gencow/server run build",

package/runtime/server.mjs

@@ -184101,6 +184101,15 @@ function resolveGenericDeploymentFailurePolicy(input) {
     };
   }
   if (input.stage === "candidate") {
+    if (code === "BACKEND_CAPABILITY_EMPTY") {
+      return {
+        status: 409,
+        error: "Deploy failed: backend deploy did not expose any query, mutation, or procedure capability; use gencow static for frontend-only deployments",
+        code,
+        retryClass: "terminal-client",
+        userAction: "EDIT_AND_CHECK"
+      };
+    }
     if (code === "APP_DEPENDENCY_INSTALL_FAILED") {
       return retry(
         code,
@@ -184224,6 +184233,7 @@ var init_deployment_failure_contract = __esm({
       "DEPLOYMENT_CONTROL_PLANE_",
       "RUNTIME_COWBOX_",
       "RUNTIME_ABSENCE_",
+      "RUNTIME_DEPLOYMENT_",
       "RUNTIME_GENERATION_",
       "RUNTIME_OPERATION_",
       "RUNTIME_OWNERSHIP_",
@@ -185899,6 +185909,27 @@ async function admitDeploymentExecutorRequest(input) {
     throw new DeploymentExecutorAdmissionError("DEPLOYMENT_EXECUTOR_ADMISSION_UNAVAILABLE", 503);
   }
 }
+async function admitDeploymentExecutorRequestAfterActiveOperation(input, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pollMs = options.pollMs ?? 500;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 6e4 || !Number.isSafeInteger(pollMs) || pollMs < 1 || pollMs > 5e3) {
+    throw new Error("DEPLOYMENT_EXECUTOR_BUSY_RETRY_CONFIG_INVALID");
+  }
+  const sleep6 = options.sleep ?? ((milliseconds) => new Promise((resolveWait) => setTimeout(resolveWait, milliseconds)));
+  const now = options.now ?? Date.now;
+  const admit = options.admit ?? admitDeploymentExecutorRequest;
+  const deadlineMs = now() + timeoutMs;
+  while (true) {
+    try {
+      return await admit(input);
+    } catch (error51) {
+      if (!(error51 instanceof DeploymentExecutorAdmissionError) || error51.code !== "DEPLOYMENT_EXECUTOR_APP_BUSY" || now() >= deadlineMs) {
+        throw error51;
+      }
+      await sleep6(Math.min(pollMs, Math.max(1, deadlineMs - now())));
+    }
+  }
+}
 function deploymentExecutorAdmissionPublicMessage(code) {
   const messages = {
     DEPLOYMENT_EXECUTOR_QUEUE_FULL: "Deployment executor queue capacity is exhausted",
@@ -185968,6 +185999,7 @@ function registerPlatformApiDeployRoutes({
   acquireAdmissionLock: acquireAdmissionLock2,
   maxQueuedOperations,
   maxQueuedBytes,
+  busyRetryTimeoutMs,
   logger: logger3 = console
 }) {
   const deployApp = async (c) => {
@@ -186033,21 +186065,24 @@ function registerPlatformApiDeployRoutes({
       for (const [header, value] of Object.entries(protocolHeaders)) c.header(header, value);
     };
     try {
-      const admission = await admitDeploymentExecutorRequest({
-        db,
-        app: appRow,
-        userId: user2.id,
-        environment,
-        bundle: bundleBuffer,
-        getHeader: (header) => c.req.header(header) || "",
-        currentNodeId,
-        currentSlotId,
-        currentRevision,
-        spoolRoot: executorSpoolRoot2,
-        acquireAdmissionLock: acquireAdmissionLock2,
-        maxQueuedOperations,
-        maxQueuedBytes
-      });
+      const admission = await admitDeploymentExecutorRequestAfterActiveOperation(
+        {
+          db,
+          app: appRow,
+          userId: user2.id,
+          environment,
+          bundle: bundleBuffer,
+          getHeader: (header) => c.req.header(header) || "",
+          currentNodeId,
+          currentSlotId,
+          currentRevision,
+          spoolRoot: executorSpoolRoot2,
+          acquireAdmissionLock: acquireAdmissionLock2,
+          maxQueuedOperations,
+          maxQueuedBytes
+        },
+        { timeoutMs: busyRetryTimeoutMs }
+      );
       protocolHeaders = admission.protocolHeaders;
       applyProtocolHeaders();
       const committedAttempt = admission.attempt;
@@ -411684,6 +411719,20 @@ function isPrepared(dataDir, source) {
     return false;
   }
 }
+function loadVerifiedRuntimeLayout(dataDir, source) {
+  assertVerifiedRuntimeExecutionSource(source);
+  const metadata = readAppRuntimeMetadata(dataDir);
+  if (!metadata || metadata.resolvedReleaseId !== source.releaseId || !isPrepared(dataDir, source)) {
+    throw new Error("RUNTIME_CANDIDATE_LAYOUT_NOT_PREPARED");
+  }
+  return {
+    ...metadata,
+    layout: source.layout,
+    serverEntry: source.serverEntry,
+    runtimeNodeModulesPath: getManagedRuntimeNodeModulesPath(dataDir),
+    publishedReleaseDir: source.runtimeRoot
+  };
+}
 function prepareVerifiedRuntimeLayout(dataDir, source, runtimeCompatibility = source.releaseId) {
   assertVerifiedRuntimeExecutionSource(source);
   const metadata = {
@@ -419268,6 +419317,12 @@ async function createRuntimeControlPlaneProvisionerAdapter(input) {
       });
       preparedRuntimeLayouts.set(workspacePath, runtimeLayout);
     },
+    loadSealedWorkspace(workspacePath) {
+      preparedRuntimeLayouts.set(
+        workspacePath,
+        loadVerifiedRuntimeLayout(workspacePath, runtimeSource)
+      );
+    },
     async allocateCandidateTarget(workspacePath) {
       void workspacePath;
       return {
@@ -419306,6 +419361,7 @@ var init_runtime_control_plane_provisioner_adapter = __esm({
     init_warm_pool_backend();
     init_runtime_process_identity();
     init_provisioner_database_preflight();
+    init_provisioner_verified_runtime_layout();
   }
 });
 
@@ -420223,6 +420279,13 @@ async function probeSlotCapability(input) {
     return "unavailable";
   }
 }
+async function probeCurrentSlotCapabilityWithRetry(input) {
+  let capability2 = await probeSlotCapability(input);
+  for (let attempt = 1; attempt < 3 && capability2 === "unavailable"; attempt += 1) {
+    capability2 = await probeSlotCapability(input);
+  }
+  return capability2;
+}
 async function convergeDeploymentRouteAcrossEligibleSlots(input) {
   const fetchImpl = input.fetchImpl ?? fetch;
   const env2 = input.env ?? process.env;
@@ -420231,13 +420294,14 @@ async function convergeDeploymentRouteAcrossEligibleSlots(input) {
   const eligible = [];
   let siblingBlocked = false;
   for (const port of ports) {
-    const capability2 = await probeSlotCapability({
+    const probeInput = {
       fetchImpl,
       port,
       currentPort,
       expectedNodeId: input.binding.nodeId,
       env: env2
-    });
+    };
+    const capability2 = port === currentPort ? await probeCurrentSlotCapabilityWithRetry(probeInput) : await probeSlotCapability(probeInput);
     if (capability2 === "capable" || capability2 === "legacy") eligible.push(port);
     if (port !== currentPort && capability2 === "blocked") siblingBlocked = true;
   }
@@ -420534,7 +420598,7 @@ async function deployWithRuntimeControlPlane(input) {
             }
           );
           await input.onExecutorPhase?.("runtime_preparing");
-          await provisioner.prepareWorkspace(input.app.name, generation.workspacePath);
+          provisioner.loadSealedWorkspace(generation.workspacePath);
           const identity2 = await prepareIdentity({
             workspacePath: generation.workspacePath,
             artifactRef: input.artifact.artifactRef,