gencow 0.1.244 → 0.1.246

package/lib/app-command.mjs

@@ -164,7 +164,7 @@ async function confirmDelete(name) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const answer = await new Promise((resolveAnswer) =>
     rl.question(
-      `\n  ${RED}!${RESET} Remove "${BOLD}${name}${RESET}" from your account? An administrator will stop it and permanently delete its data. The name remains unavailable until then.\n  Type the app name to confirm: `,
+      `\n  ${RED}!${RESET} Remove "${BOLD}${name}${RESET}" from your account? An administrator will stop it and permanently delete its data. Redeploying this project can create a new app ID with the same display name.\n  Type the app name to confirm: `,
       resolveAnswer,
     ),
   );
@@ -408,7 +408,7 @@ ${dashboardLine}
         saveCredsImpl({ ...currentCreds, currentApp: undefined });
       }
 
-      successImpl(`App "${name}" removed from your account. An administrator will permanently delete it. The name remains unavailable until then.`);
+      successImpl(`App "${name}" removed from your account. An administrator will stop it and permanently delete it. Redeploying this project can create a new app ID with the same display name.`);
       if (delData.stopErrorCode) {
         warnImpl(`App stop needs administrator review. Code: ${delData.stopErrorCode}. Handoff ID: ${delData.handoffId}`);
       }

package/lib/deploy-admission-boundary.mjs

@@ -0,0 +1,52 @@
+const DEFAULT_ADMISSION_TIMEOUT_MS = 5 * 60 * 1000;
+
+function pendingResponse({ requestId, appName, resumeCommand = null }) {
+  const response = new Response(
+    JSON.stringify({
+      error: "Deployment admission is still running. The server request was not cancelled.",
+      code: "PLATFORM_DEPLOYMENT_ADMISSION_PENDING",
+      stage: "admission",
+      retryClass: "retryable-infra",
+      userAction: "VIEW_STATUS",
+      requestId,
+      appName,
+      statusCommand: "gencow deploy status",
+      resumeCommand,
+      serverOperationContinues: "UNKNOWN",
+      databaseState: "UNKNOWN",
+      incumbentServing: "UNKNOWN",
+      operationState: "UNKNOWN",
+    }),
+    { status: 503, headers: { "Content-Type": "application/json", "Retry-After": "5" } },
+  );
+  // The caller must surface this state without replaying the same admission
+  // request as a new deployment. Keep this marker private to the in-process
+  // response path; the public body carries the stable diagnostic contract.
+  response.deploymentAdmissionPending = true;
+  return response;
+}
+
+export async function postDeploymentAdmissionWithTimeout({
+  send,
+  requestId = null,
+  appName,
+  resumeCommand = requestId ? `gencow deploy --resume ${requestId}` : null,
+  timeoutMs = DEFAULT_ADMISSION_TIMEOUT_MS,
+  setTimeoutImpl = setTimeout,
+  clearTimeoutImpl = clearTimeout,
+}) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new Error("DEPLOYMENT_ADMISSION_TIMEOUT_INVALID");
+  const controller = new AbortController();
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeoutImpl(() => {
+      resolve(pendingResponse({ requestId, appName, resumeCommand }));
+    }, timeoutMs);
+    timer?.unref?.();
+  });
+  try {
+    return await Promise.race([send({ signal: controller.signal }), deadline]);
+  } finally {
+    if (timer !== undefined) clearTimeoutImpl(timer);
+  }
+}

package/lib/deploy-app-creation.mjs

@@ -0,0 +1,71 @@
+import { resolveCreatedAppResponse } from "./app-create-response.mjs";
+import { resolveDeployAppId } from "./deploy-app-target.mjs";
+import { writeProjectMetadata } from "./deploy-project-metadata.mjs";
+import { readJsonObjectResponse } from "./http-response-json.mjs";
+import { DIM, RESET } from "./output.mjs";
+
+export function createCloudAppIfNeeded({
+  platformFetchImpl,
+  rpcMutationImpl,
+  errorImpl,
+  infoImpl,
+  exitImpl,
+  successImpl,
+  setTimeoutImpl,
+  writeFileSyncImpl,
+}) {
+  return async function createAppIfNeeded({
+    creds,
+    appId,
+    displayName,
+    envTarget = "dev",
+    gencowJsonPath,
+    allowMissingAppReplacement = true,
+  }) {
+    const resolvedAppId = await resolveDeployAppId({
+      creds,
+      appId,
+      displayName,
+      environment: envTarget,
+      platformFetchImpl,
+      allowMissingAppReplacement,
+      infoImpl,
+      errorImpl,
+      exitImpl,
+    });
+    if (resolvedAppId === false) return null;
+    if (resolvedAppId) return resolvedAppId;
+
+    infoImpl("Creating app (auto-generating ID)...");
+    const createRes = await rpcMutationImpl(creds, "apps.create", { name: displayName });
+    if (!createRes.ok) {
+      const createErr = await readJsonObjectResponse(createRes);
+      errorImpl(`App creation failed: ${createErr?.error || createRes.statusText}`);
+      exitImpl(1);
+      return null;
+    }
+
+    const createData = await readJsonObjectResponse(createRes);
+    let nextAppId;
+    try {
+      nextAppId = resolveCreatedAppResponse(createData, { platformUrl: creds.platformUrl }).appId;
+    } catch (caught) {
+      errorImpl(`App creation failed: ${caught.message}`);
+      exitImpl(1);
+      return null;
+    }
+
+    successImpl(`App "${nextAppId}" created. Waiting for provisioning...`);
+    writeProjectMetadata({
+      appId: nextAppId,
+      displayName,
+      envTarget,
+      platformUrl: creds.platformUrl,
+      gencowJsonPath,
+      writeFileSyncImpl,
+    });
+    infoImpl(`${DIM}gencow.json created (appId: ${nextAppId})${RESET}`);
+    await new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, 3000));
+    return nextAppId;
+  };
+}

package/lib/deploy-app-target.mjs

@@ -0,0 +1,182 @@
+import { readJsonObjectResponse } from "./http-response-json.mjs";
+
+const PUBLIC_LOOKUP_ERROR_CODES = new Set([
+  "ACCOUNT_DELETED",
+  "ACCOUNT_DELETION_PENDING",
+  "ACCOUNT_SUSPENDED",
+  "APP_RELEASE_AUTH_REQUIRED",
+  "APP_RELEASE_CAPABILITY_UNAVAILABLE",
+  "APP_RELEASE_ENVIRONMENT_INVALID",
+  "APP_RELEASE_POLICY_READ_UNAVAILABLE",
+]);
+const SAFE_CORRELATION_ID = /^[A-Za-z0-9_-]{8,128}$/u;
+
+function publicLookupFailure(response, body) {
+  const code = PUBLIC_LOOKUP_ERROR_CODES.has(body?.code)
+    ? body.code
+    : response.status === 401
+      ? "APP_RELEASE_AUTH_REQUIRED"
+      : "APP_DEPLOY_TARGET_LOOKUP_FAILED";
+  return {
+    kind: "error",
+    code,
+    status: response.status,
+    retryable: typeof body?.retryable === "boolean" ? body.retryable : response.status >= 500,
+    ...(typeof body?.correlationId === "string" && SAFE_CORRELATION_ID.test(body.correlationId)
+      ? { correlationId: body.correlationId }
+      : {}),
+  };
+}
+
+function formatLookupFailure(failure, target) {
+  const code = failure?.kind === "error" ? failure.code : "APP_DEPLOY_TARGET_LOOKUP_FAILED";
+  const lines = [
+    `${code}: Could not verify the configured ${target} app. No replacement app was created and gencow.json was unchanged.`,
+  ];
+  if (failure?.status) lines.push(`HTTP status: ${failure.status}`);
+  if (typeof failure?.retryable === "boolean") lines.push(`Retryable: ${failure.retryable ? "yes" : "no"}`);
+  if (failure?.correlationId) lines.push(`Correlation ID: ${failure.correlationId}`);
+  if (code === "APP_RELEASE_AUTH_REQUIRED") {
+    lines.push("Action: run gencow login, or replace/unset the environment credential, then retry.");
+  } else if (code === "ACCOUNT_SUSPENDED" || code === "ACCOUNT_DELETION_PENDING" || code === "ACCOUNT_DELETED") {
+    lines.push("Action: resolve the account status in Platform before retrying.");
+  } else if (failure?.retryable) {
+    lines.push("Action: wait for Platform release capability to recover, then retry.");
+  } else {
+    lines.push("Action: check that the credential can access this app, then retry.");
+  }
+  return lines.join("\n");
+}
+
+export async function lookupOwnedApp({ creds, appId, environment, platformFetchImpl }) {
+  try {
+    const response = await platformFetchImpl(
+      creds,
+      `/platform/apps/${appId}/release-capability?environment=${environment}`,
+      { method: "GET" },
+    );
+    const body = await readJsonObjectResponse(response);
+    if (response.status === 404) {
+      if (body?.code === "APP_RELEASE_APP_NOT_FOUND") return "missing";
+      return body?.code ? publicLookupFailure(response, body) : "unsupported";
+    }
+    if (response.status === 409 && body?.code === "APP_RELEASE_VERSIONS_DISABLED") return "found";
+    if (!response.ok) return publicLookupFailure(response, body);
+    return body?.protocol === "app-release-v1" && typeof body.enabled === "boolean" ? "found" : "error";
+  } catch {
+    return {
+      kind: "error",
+      code: "APP_RELEASE_CAPABILITY_UNAVAILABLE",
+      retryable: true,
+    };
+  }
+}
+
+export async function resolveDeployAppId({
+  creds,
+  appId,
+  displayName,
+  environment = "dev",
+  platformFetchImpl,
+  allowMissingAppReplacement,
+  infoImpl,
+  errorImpl,
+  exitImpl,
+}) {
+  if (!appId || !platformFetchImpl) return appId;
+  const lookup = await lookupOwnedApp({ creds, appId, environment, platformFetchImpl });
+  if (lookup === "found" || lookup === "unsupported") return appId;
+  if (lookup?.kind === "error" || lookup === "error") {
+    errorImpl(formatLookupFailure(lookup, `"${appId}"`));
+    exitImpl(1);
+    return false;
+  }
+  if (!allowMissingAppReplacement) {
+    errorImpl(
+      `APP_NOT_FOUND: The existing app ID "${appId}" is unavailable. This deployment requires the original app; restore access before retrying. No replacement app was created.`,
+    );
+    exitImpl(1);
+    return false;
+  }
+  infoImpl(`Configured app ID is no longer available. Creating a new app named "${displayName}"...`);
+  return null;
+}
+
+export async function reconcileProductionAppTarget({
+  appId,
+  prodAppId,
+  creds,
+  displayName,
+  gencowJsonPath,
+  platformFetchImpl,
+  createCloudAppIfNeeded,
+  infoImpl,
+  errorImpl,
+  exitImpl,
+}) {
+  let productionParentAppId = appId;
+  let existingProdAppId = prodAppId;
+  if (!platformFetchImpl || (!productionParentAppId && !existingProdAppId)) {
+    return { appId: productionParentAppId, prodAppId: existingProdAppId };
+  }
+
+  const failLookup = (failure, target) => {
+    errorImpl(formatLookupFailure(failure, target));
+    exitImpl(1);
+    return null;
+  };
+
+  if (existingProdAppId) {
+    const prodState = await lookupOwnedApp({
+      creds,
+      appId: existingProdAppId,
+      environment: "prod",
+      platformFetchImpl,
+    });
+    if (prodState?.kind === "error" || prodState === "error") return failLookup(prodState, "production");
+    if (prodState === "found" || prodState === "unsupported") {
+      return { appId: productionParentAppId, prodAppId: existingProdAppId };
+    }
+    infoImpl(
+      `Configured production app ID is no longer available. Creating a production app for "${displayName}"...`,
+    );
+    existingProdAppId = null;
+  }
+
+  const parentState = productionParentAppId
+    ? await lookupOwnedApp({
+        creds,
+        appId: productionParentAppId,
+        environment: "dev",
+        platformFetchImpl,
+      })
+    : "missing";
+  if (productionParentAppId && (parentState?.kind === "error" || parentState === "error")) {
+    return failLookup(parentState, "root");
+  }
+
+  if (productionParentAppId && parentState === "missing") {
+    infoImpl(`Configured app ID is no longer available. Creating a new app named "${displayName}"...`);
+    productionParentAppId = await createCloudAppIfNeeded({
+      creds,
+      appId: null,
+      displayName,
+      envTarget: "dev",
+      gencowJsonPath,
+    });
+    if (!productionParentAppId) return null;
+  }
+
+  if (!productionParentAppId) {
+    productionParentAppId = await createCloudAppIfNeeded({
+      creds,
+      appId: null,
+      displayName,
+      envTarget: "dev",
+      gencowJsonPath,
+    });
+    if (!productionParentAppId) return null;
+  }
+
+  return { appId: productionParentAppId, prodAppId: existingProdAppId };
+}

package/lib/deploy-failure-diagnostic.mjs

@@ -310,6 +310,32 @@ export function renderDeployFailureDiagnosticLines(responseBody, statusText, opt
       Number.isSafeInteger(Number(contract.operationId))
         ? `gencow deploy status --deployment ${contract.operationId}`
         : "gencow deploy status";
+    if (contract.code === "PLATFORM_DEPLOYMENT_ADMISSION_PENDING") {
+      lines.push(
+        `Database state: ${safeText(responseBody.databaseState, 32) ?? "UNKNOWN"}`,
+        `Incumbent serving: ${safeText(responseBody.incumbentServing, 32) ?? "UNKNOWN"}`,
+        `Operation state: ${safeText(responseBody.operationState, 32) ?? "UNKNOWN"}`,
+      );
+      const requestId = safeText(responseBody.requestId, 128);
+      if (requestId && /^[A-Za-z0-9_-]{8,128}$/u.test(requestId)) lines.push(`Request ID: ${requestId}`);
+      lines.push("Server outcome: unknown; inspect the existing request before submitting another deployment.");
+      const resumeCommand = safeText(responseBody.resumeCommand, 240);
+      const resumeMatch = resumeCommand?.match(
+        /^gencow deploy (?:--resume [A-Za-z0-9_-]{8,128}|--static(?: --prod)? --app ([A-Za-z0-9_-]{1,128})(?: --client [A-Za-z0-9_-]{1,128})? --resume [A-Za-z0-9_-]{8,128})$/u,
+      );
+      const resumeToken = resumeCommand?.match(/--resume ([A-Za-z0-9_-]{8,128})$/u)?.[1];
+      const resumeAppName = resumeMatch?.[1];
+      const expectedResumeApp = options.expectedAppName ?? responseBody.appName;
+      if (
+        resumeMatch &&
+        requestId &&
+        resumeToken === requestId &&
+        (!resumeAppName || !expectedResumeApp || resumeAppName === expectedResumeApp)
+      ) {
+        lines.push(`Next command: ${resumeCommand}`);
+        return lines;
+      }
+    }
     lines.push(`Next command: ${selfService?.action.command ?? exactStatusCommand}`);
     if (contract.blockingOperationId && responseBody.retryReadinessReason === "ACTIVE_OWNER" && selfService) {
       lines.push(`Then check retry gate: ${exactStatusCommand}`);

package/lib/deploy-package-runtime.mjs

@@ -3,9 +3,8 @@ import { randomUUID } from "node:crypto";
 import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 import { fetchAppDiagnosticLogsViaRest, normalizeDiagnosticLogLines } from "./app-diagnostics.mjs";
-import { resolveCreatedAppResponse } from "./app-create-response.mjs";
+import { createCloudAppIfNeeded as createCloudAppIfNeededImpl } from "./deploy-app-creation.mjs";
 import { resolveConfiguredAuditorImplementation } from "./auditor-mode.mjs";
-import { writeProjectMetadata } from "./deploy-project-metadata.mjs";
 import {
   loadDeployMigrationGenerationContext,
   prepareDeployCodegenArtifacts,
@@ -21,6 +20,7 @@ import { buildDeployClaimFromArchive } from "./deploy-package-claim.mjs";
 import { renderDeployFailureDiagnosticLines } from "./deploy-failure-diagnostic.mjs";
 import { readJsonObjectResponse } from "./http-response-json.mjs";
 import { pollAcceptedDeploymentOperation } from "./deployment-operation-poll.mjs";
+import { postDeploymentAdmissionWithTimeout } from "./deploy-admission-boundary.mjs";
 import { submitDeploymentWithIdempotentRetry } from "./deployment-admission-retry.mjs";
 import { acquireDeployReceipt, releaseDeployReceipt } from "./deploy-receipt-store.mjs";
 import { CYAN, DIM, RED, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
@@ -155,6 +155,7 @@ export function createDeployPackageRuntime({
 } = {}) {
   let migrationProjectConfig = null;
   let preparedDeployCodegenArtifacts = null;
+  let lastDeployOutcome = "idle";
   function cleanupPreparedDeploySource() {
     preparedDeployCodegenArtifacts?.cleanup?.();
     preparedDeployCodegenArtifacts = null;
@@ -557,41 +558,16 @@ export function createDeployPackageRuntime({
     return { bundleBuffer, bundleSize, deployClaim, tmpBundle };
   }
 
-  async function createCloudAppIfNeeded({ creds, appId, displayName, envTarget = "dev", gencowJsonPath }) {
-    if (appId) return appId;
-
-    infoImpl("Creating app (auto-generating ID)...");
-    const createRes = await rpcMutationImpl(creds, "apps.create", { name: displayName });
-    if (!createRes.ok) {
-      const createErr = await readJsonObjectResponse(createRes);
-      errorImpl(`App creation failed: ${createErr?.error || createRes.statusText}`);
-      exitImpl(1);
-      return null;
-    }
-
-    const createData = await readJsonObjectResponse(createRes);
-    let nextAppId;
-    try {
-      nextAppId = resolveCreatedAppResponse(createData, { platformUrl: creds.platformUrl }).appId;
-    } catch (caught) {
-      errorImpl(`App creation failed: ${caught.message}`);
-      exitImpl(1);
-      return null;
-    }
-
-    successImpl(`App "${nextAppId}" created. Waiting for provisioning...`);
-    writeProjectMetadata({
-      appId: nextAppId,
-      displayName,
-      envTarget,
-      platformUrl: creds.platformUrl,
-      gencowJsonPath,
-      writeFileSyncImpl,
-    });
-    infoImpl(`${DIM}gencow.json created (appId: ${nextAppId})${RESET}`);
-    await new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, 3000));
-    return nextAppId;
-  }
+  const createCloudAppIfNeeded = createCloudAppIfNeededImpl({
+    platformFetchImpl,
+    rpcMutationImpl,
+    errorImpl,
+    infoImpl,
+    exitImpl,
+    successImpl,
+    setTimeoutImpl,
+    writeFileSyncImpl,
+  });
 
   function startSpinner(label) {
     const spinnerFrames = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
@@ -622,6 +598,7 @@ export function createDeployPackageRuntime({
     releaseAttemptId = null,
     clientName = null,
   }) {
+    lastDeployOutcome = "pending";
     const cwd = cwdImpl();
     if (deployClaim?.claim?.migrationBundle?.manifestSha256) {
       emitMigrationResponsibilityNotice(warnImpl);
@@ -638,7 +615,7 @@ export function createDeployPackageRuntime({
       : null;
     let activeBundleBuffer = receipt?.bundleBuffer ?? bundleBuffer;
     let activeDeployClaim = receipt?.deployClaim ?? deployClaim;
-    const deployOnce = async (targetAppId) =>
+    const deployOnce = async (targetAppId, signal) =>
       platformFetchImpl(creds, `/platform/apps/${targetAppId}/deploy?env=${envTarget}`, {
         method: "POST",
         headers: {
@@ -659,6 +636,7 @@ export function createDeployPackageRuntime({
             : {}),
         },
         body: activeBundleBuffer,
+        signal,
       });
     const pollAcceptedDeployment = (initialResponse) =>
       pollAcceptedDeploymentOperation({
@@ -669,11 +647,15 @@ export function createDeployPackageRuntime({
         setTimeoutImpl,
       });
     const submitDeployAdmission = () => {
-      // A legacy request without a deploy claim has no stable pre-receipt
-      // identity. Never retry that request automatically.
-      if (!activeDeployClaim) return deployOnce(targetAppId);
       return submitDeploymentWithIdempotentRetry({
-        submit: () => deployOnce(targetAppId),
+        submit: () =>
+          postDeploymentAdmissionWithTimeout({
+            requestId: activeDeployClaim?.claim?.requestId ?? explicitRequestId,
+            appName: targetAppId,
+            send: ({ signal }) => deployOnce(targetAppId, signal),
+        }),
+        retryOnResponse: Boolean(activeDeployClaim),
+        retryOnTransport: Boolean(activeDeployClaim),
         sleepImpl: (ms) => new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, ms)),
       });
     };
@@ -705,6 +687,9 @@ export function createDeployPackageRuntime({
       if (deployRes.status === 202) {
         deployRes = await pollAcceptedDeployment(deployRes);
       }
+    } catch (error) {
+      lastDeployOutcome = "pending";
+      throw error;
     } finally {
       stopSpinner(spinner);
     }
@@ -753,6 +738,7 @@ export function createDeployPackageRuntime({
         errData?.code === "DEPLOY_REQUEST_IN_PROGRESS" ||
         errData?.code === "CONTROL_PLANE_OBSERVATION_INCOMPLETE" ||
         errData?.retryClass === "retryable-infra";
+      lastDeployOutcome = retryableResponse ? "pending" : "failed";
       if (receipt && !retryableResponse) releaseDeployReceipt(receipt);
       const migrationDiagnostic = isActionableMigrationDiagnostic(errData?.diagnostic)
         ? normalizeRetiredMigrationGateDiagnostic(extractActionableMigrationDiagnostic(errData.diagnostic))
@@ -777,6 +763,7 @@ export function createDeployPackageRuntime({
 
     const deployData = await readJsonObjectResponse(deployRes);
     if (!deployData) {
+      lastDeployOutcome = "unknown";
       errorImpl(
         `Deploy failed: no terminal deployment receipt was returned after packaging.\nCode: CLI_DEPLOY_TERMINAL_RECEIPT_MISSING\nStage: controller\nHTTP status: ${deployRes?.status ?? "unknown"}\nNext action: RETRY`,
       );
@@ -784,6 +771,7 @@ export function createDeployPackageRuntime({
       return null;
     }
     emitMigrationAdvisories(deployData?.warnings, warnImpl);
+    lastDeployOutcome = "completed";
     if (receipt) releaseDeployReceipt(receipt);
     const deployElapsed = ((Date.now() - startTime) / 1000).toFixed(1);
     logImpl("");
@@ -842,5 +830,6 @@ export function createDeployPackageRuntime({
     packageDeployProject,
     createCloudAppIfNeeded,
     deployBundleWithRetry,
+    getLastDeployOutcome: () => lastDeployOutcome,
   };
 }

package/lib/deploy-runtime.mjs

@@ -17,6 +17,7 @@ import {
 } from "./deploy-static-fullstack-runtime.mjs";
 import { detectStaticDeployBackend, preflightStaticDeployArtifact } from "./static-deploy-command.mjs";
 import { readJsonObjectResponse } from "./http-response-json.mjs";
+import { reconcileProductionAppTarget } from "./deploy-app-target.mjs";
 
 export function parseDeployArgs(deployArgs) {
   const parsed = {
@@ -27,10 +28,12 @@ export function parseDeployArgs(deployArgs) {
     isRollback: false,
     region: null,
     requestId: null,
+    resumeRequested: false,
     staticDeploy: false,
     staticDirArg: null,
     unknownArg: null,
   };
+  Object.defineProperty(parsed, "resumeRequested", { value: false, writable: true });
 
   for (let index = 0; index < deployArgs.length; index += 1) {
     const arg = deployArgs[index];
@@ -46,6 +49,7 @@ export function parseDeployArgs(deployArgs) {
         break;
       }
       parsed.requestId = value;
+      if (arg === "--resume") parsed.resumeRequested = true;
       index += 1;
     } else if (arg.startsWith("--request-id=") || arg.startsWith("--resume=")) {
       const value = arg.slice(arg.indexOf("=") + 1);
@@ -54,6 +58,7 @@ export function parseDeployArgs(deployArgs) {
         break;
       }
       parsed.requestId = value;
+      if (arg.startsWith("--resume=")) parsed.resumeRequested = true;
     } else if (arg === "--region") {
       const value = deployArgs[index + 1];
       if (!value || value.startsWith("-")) {
@@ -192,6 +197,8 @@ async function confirmFirstProductionDeploy({ appId, createInterfaceImpl, infoIm
 
 async function ensureProductionDeployTarget({
   appId,
+  displayName,
+  createCloudAppIfNeeded,
   createInterfaceImpl,
   creds,
   deployArgs,
@@ -209,14 +216,28 @@ async function ensureProductionDeployTarget({
   prodAppId = null,
   region = null,
 }) {
-  if (!appId || prodAppId) {
-    return prodAppId ?? appId;
-  }
+  const reconciledTarget = await reconcileProductionAppTarget({
+    appId,
+    prodAppId,
+    creds,
+    displayName,
+    gencowJsonPath,
+    platformFetchImpl,
+    createCloudAppIfNeeded,
+    infoImpl,
+    errorImpl,
+    exitImpl,
+  });
+  if (!reconciledTarget) return null;
+  const productionParentAppId = reconciledTarget.appId;
+  const existingProdAppId = reconciledTarget.prodAppId;
+  if (existingProdAppId) return existingProdAppId;
+  if (!productionParentAppId) return null;
 
   const ciMode = processEnv.CI === "true" || deployArgs.includes("--yes");
   if (!ciMode) {
     const confirmed = await confirmFirstProductionDeploy({
-      appId,
+      appId: productionParentAppId,
       createInterfaceImpl,
       infoImpl,
       logImpl,
@@ -225,11 +246,15 @@ async function ensureProductionDeployTarget({
   }
 
   infoImpl("Creating prod app...");
-  const createProdRes = await platformFetchImpl(creds, `/platform/apps/${appId}/create-prod`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(region ? { region } : {}),
-  });
+  const createProdRes = await platformFetchImpl(
+    creds,
+    `/platform/apps/${productionParentAppId}/create-prod`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(region ? { region } : {}),
+    },
+  );
 
   if (!createProdRes.ok) {
     const errData = await readJsonObjectResponse(createProdRes);
@@ -497,7 +522,7 @@ export function createDeployCommand({
     }
 
     let staticArtifactPreflight = null;
-    if (parsed.staticDeploy) {
+    if (parsed.staticDeploy && !parsed.resumeRequested) {
       try {
         staticArtifactPreflight = preflightStaticDeployArtifactImpl({
           staticDirArg: resolvedStaticDirArg,
@@ -526,6 +551,7 @@ export function createDeployCommand({
       resolvePathImpl,
     });
     let { appId, displayName, gencowJsonPath, prodAppId, projectDir } = context;
+    const rootAppId = appId;
     appId = resolveEnvironmentDeployTarget({ appId, envTarget: parsed.envTarget, prodAppId });
     const backendProjectRoot = projectDir ?? projectRoot;
     const projectConfig = loadConfigImpl
@@ -586,9 +612,11 @@ export function createDeployCommand({
       return;
     }
 
-    if (parsed.envTarget === "prod" && appId && !parsed.existingBundleMode) {
+    if (parsed.envTarget === "prod" && appId && !parsed.existingBundleMode && !parsed.resumeRequested) {
       const prodTarget = await ensureProductionDeployTarget({
-        appId,
+        appId: rootAppId,
+        displayName,
+        createCloudAppIfNeeded: backendDeployRuntime.createCloudAppIfNeeded,
         createInterfaceImpl,
         creds,
         deployArgs,
@@ -625,6 +653,7 @@ export function createDeployCommand({
         envTarget: parsed.envTarget,
         forceDeploy: parsed.forceDeploy,
         requestId: parsed.requestId,
+        resumeStaticOnly: parsed.resumeRequested,
         gencowJsonPath,
         hasDetectedBackend,
         selectedClient,