gencow 0.1.190 → 0.1.192

package/lib/app-command.mjs

@@ -8,13 +8,14 @@ import {
 } from "./app-diagnostics.mjs";
 import { resolveCreatedAppId, resolveCreatedAppResponse } from "./app-create-response.mjs";
 import {
+  appNotFoundDiagnostic,
   isExactAppDeleteResponse,
   parseAppListResponse,
   parseAppLookupResponse,
 } from "./app-response-contract.mjs";
 import { pollAppDeleteOperation } from "./app-delete-operation.mjs";
 import { appResponseError } from "./app-response-error.mjs";
-import { readJsonObjectResponse } from "./http-response-json.mjs";
+import { readJsonObjectResponse, readJsonValueResponse } from "./http-response-json.mjs";
 import { BOLD, CYAN, DIM, GREEN, RED, RESET, error, info, log, success, warn } from "./output.mjs";
 import { loadCreds, rpcMutation, rpcQuery, saveCreds, requireCreds } from "./platform-client.mjs";
 import { resolveProjectMetadataPath, resolveProjectSelection } from "./project-context.mjs";
@@ -32,10 +33,6 @@ function invalidAppResponse(operation, response, kind) {
   return `CLI_APP_RESPONSE_INVALID: ${operation} returned an invalid ${kind} response (${appResponseStatus(response)})`;
 }
 
-function appNotFoundError() {
-  return "App not found or not owned by you.\nCode: APP_NOT_FOUND";
-}
-
 export function formatAppDeployedAgo(dateStr, now = Date.now()) {
   if (!dateStr) return `${DIM}never${RESET}`;
   const diff = now - new Date(dateStr).getTime();
@@ -324,19 +321,25 @@ ${dashboardLine}
         return;
       }
       const res = await rpcQueryImpl(creds, "apps.get", { name });
-      const body = await readJsonObjectResponse(res);
+      const decoded = await readJsonValueResponse(res);
+      const body = decoded.parsed ? decoded.value : null;
       if (!res.ok) {
         errorImpl(
           res.status === 404
-            ? appNotFoundError()
+            ? appNotFoundDiagnostic()
             : appResponseError(body, invalidAppResponse("app status", res, "error")),
         );
         processRef.exit(1);
         return;
       }
+      if (!decoded.parsed) {
+        errorImpl(invalidAppResponse("app status", res, "success"));
+        processRef.exit(1);
+        return;
+      }
       const lookup = parseAppLookupResponse(body, name);
       if (lookup.kind === "not_found") {
-        errorImpl(appNotFoundError());
+        errorImpl(appNotFoundDiagnostic());
         processRef.exit(1);
         return;
       }

package/lib/app-delete-operation.mjs

@@ -16,6 +16,7 @@ const APP_DELETE_ACTIVE_STATES = new Set([
   "failed_tenant_db_cleanup",
   "failed_catalog_cleanup",
 ]);
+const APP_DELETE_TERMINAL_FAILURE_STATES = new Set(["blocked_catalog_outcome_unknown"]);
 const CORRELATION_ID_PATTERN = /^[A-Za-z0-9_-]{8,128}$/u;
 const DIAGNOSTIC_CODE_PATTERN = /^[A-Za-z][A-Za-z0-9_]{2,127}$/u;
 const APP_ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+){2}$/u;
@@ -74,6 +75,20 @@ function isMatchingTerminalResponse(value, accepted, expectedAppId) {
   );
 }
 
+function isMatchingTerminalFailureResponse(value, accepted, expectedAppId) {
+  return (
+    value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    value.success === false &&
+    value.deleted === expectedAppId &&
+    value.operationId === accepted.operationId &&
+    value.correlationId === accepted.correlationId &&
+    APP_DELETE_TERMINAL_FAILURE_STATES.has(value.state) &&
+    DIAGNOSTIC_CODE_PATTERN.test(value.code ?? "")
+  );
+}
+
 export async function pollAppDeleteOperation({
   creds,
   initialBody,
@@ -99,6 +114,9 @@ export async function pollAppDeleteOperation({
       if (!statusRes?.ok || !statusData) return invalidPollResponse(accepted);
       successfulPollResponses += 1;
       if (isMatchingTerminalResponse(statusData, accepted, name)) return statusData;
+      if (isMatchingTerminalFailureResponse(statusData, accepted, name)) {
+        return { ...statusData, error: statusData.code };
+      }
       const operation = parseAppDeleteOperationEnvelope(statusData, name);
       if (
         !operation ||

package/lib/app-response-contract.mjs

@@ -10,6 +10,10 @@ function optionalString(value) {
   return value == null || typeof value === "string";
 }
 
+export function appNotFoundDiagnostic() {
+  return "App not found or not owned by you.\nCode: APP_NOT_FOUND";
+}
+
 export function parseAppListResponse(value) {
   if (!Array.isArray(value)) return null;
   return value.every((row) => {
@@ -26,6 +30,7 @@ export function parseAppListResponse(value) {
 }
 
 export function parseAppLookupResponse(value, expectedAppId) {
+  if (value === null) return { kind: "not_found" };
   const body = record(value);
   if (!body) return { kind: "invalid_response" };
   const hasEnvelope = Object.prototype.hasOwnProperty.call(body, "result");

package/lib/canonical-drizzle-generator-paths.mjs

@@ -0,0 +1,7 @@
+import { posix, win32 } from "node:path";
+
+export function toDrizzleProjectPath(projectRoot, canonicalFile) {
+  const pathApi = win32.isAbsolute(projectRoot) ? win32 : posix;
+  const projectPath = pathApi.relative(projectRoot, canonicalFile).replaceAll("\\", "/");
+  return projectPath.startsWith(".") ? projectPath : `./${projectPath}`;
+}

package/lib/canonical-drizzle-generator.config.mjs

@@ -1,6 +1,8 @@
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 
+import { toDrizzleProjectPath } from "./canonical-drizzle-generator-paths.mjs";
+
 export const GENCOW_DRIZZLE_CONFIG_CONTRACT_VERSION = 1;
 
 function requiredEnvironment(name) {
@@ -38,7 +40,7 @@ function resolveSchemaFiles(projectRoot) {
     }
     if (!seen.has(canonical)) {
       seen.add(canonical);
-      files.push(canonical);
+      files.push(toDrizzleProjectPath(projectRoot, canonical));
     }
   }
   if (files.length === 0) throw new Error("Gencow migration schema list is empty");

package/lib/cli-artifact-guard.mjs

@@ -6,6 +6,7 @@ export const REQUIRED_CLI_TARBALL_FILES = Object.freeze([
   "lib/cron-manifest.mjs",
   "lib/dev-cloud-bundle.mjs",
   "lib/canonical-drizzle-generator.config.mjs",
+  "lib/canonical-drizzle-generator-paths.mjs",
   "runtime/tooling.mjs",
   "runtime/server.mjs",
   "templateFeature/ai/manifest.json",

package/lib/deploy-command.mjs

@@ -5,7 +5,9 @@ import {
   isAppFailureStatus,
   selectAppDiagnosticLogLines,
 } from "./app-diagnostics.mjs";
+import { appNotFoundDiagnostic, parseAppLookupResponse } from "./app-response-contract.mjs";
 import { resolveCloudAppTarget } from "./cloud-targets.mjs";
+import { readJsonValueResponse } from "./http-response-json.mjs";
 
 export function renderDeployHelp() {
   log(`\n${BOLD}${CYAN}gencow deploy${RESET} — Deploy backend or fullstack app to cloud\n`);
@@ -92,20 +94,35 @@ export async function handleDeployReadonlySubcommand(params) {
 
   infoImpl(`Checking "${appId}" status (${envLabel})...`);
   const res = await rpcQueryImpl(creds, "apps.get", { name: appId });
+  const decoded = await readJsonValueResponse(res);
+  const body = decoded.parsed ? decoded.value : null;
   if (!res.ok) {
-    const errData = await res.json().catch(() => ({}));
+    const errData = body && typeof body === "object" && !Array.isArray(body) ? body : {};
     errorImpl(`Failed to fetch status: ${errData.error || res.statusText}`);
     exitImpl(1);
     return true;
   }
-
-  const data = await res.json();
-  const app = data.result || data;
-  if (!app) {
-    errorImpl("App not found.");
+  if (!decoded.parsed) {
+    errorImpl(
+      `CLI_APP_RESPONSE_INVALID: deploy status returned an invalid success response (HTTP ${res.status})`,
+    );
+    exitImpl(1);
+    return true;
+  }
+  const lookup = parseAppLookupResponse(body, appId);
+  if (lookup.kind === "not_found") {
+    errorImpl(appNotFoundDiagnostic());
+    exitImpl(1);
+    return true;
+  }
+  if (lookup.kind === "invalid_response") {
+    errorImpl(
+      `CLI_APP_RESPONSE_INVALID: deploy status returned an invalid success response (HTTP ${res.status})`,
+    );
     exitImpl(1);
     return true;
   }
+  const app = lookup.app;
   logImpl("");
   logImpl(`  ${BOLD}App Status${RESET}`);
   logImpl(`  ──────────────────────`);

package/lib/deploy-failure-diagnostic.mjs

@@ -42,7 +42,12 @@ function readDeployFailureContract(value, expectedAppName) {
   const retryClass = safeText(value.retryClass, 32);
   const userAction = safeText(value.userAction, 32);
   const correlationId = value.correlationId === undefined ? null : safeText(value.correlationId, 128);
-  const operationId = value.operationId === undefined ? null : safeText(value.operationId, 80);
+  const operationId =
+    Number.isSafeInteger(value.operationId) && value.operationId > 0
+      ? String(value.operationId)
+      : value.operationId === undefined
+        ? null
+        : safeText(value.operationId, 80);
   if (
     !code?.match(/^[A-Z][A-Z0-9_]{2,99}$/u) ||
     !stage ||
@@ -120,6 +125,19 @@ export function renderDeployFailureDiagnosticLines(responseBody, statusText, opt
     lines.push(`Next command: gencow app delete ${options.expectedAppName} --force`);
     return lines;
   }
+  if (contract.userAction === "VIEW_STATUS" && contract.operationId?.match(/^[1-9][0-9]*$/u)) {
+    const publicMessage = safeText(responseBody.error, 240) ?? fallbackMessage;
+    const lines = [
+      `Deploy failed: ${publicMessage}`,
+      `Code: ${contract.code}`,
+      `Stage: ${contract.stage}`,
+      `Operation ID: ${contract.operationId}`,
+    ];
+    const correlationLine = formatDeployCorrelationId(contract.correlationId);
+    if (correlationLine) lines.push(correlationLine);
+    lines.push("Next command: gencow deploy status");
+    return lines;
+  }
   const publicMessage = contract.legacySupportAction
     ? PLATFORM_RECOVERY_MESSAGE
     : (safeText(responseBody.error, 240) ?? fallbackMessage);

package/lib/deployment-operation-poll.mjs

@@ -5,6 +5,7 @@ const TERMINAL_STATES = new Set(["succeeded", "failed", "blocked", "cancelled"])
 const OPERATION_ID = /^[1-9][0-9]*$/u;
 const CORRELATION_ID = /^[A-Za-z0-9_-]{8,128}$/u;
 const APP_NAME = /^[a-z0-9][a-z0-9-]{0,62}$/u;
+export const DEFAULT_DEPLOYMENT_OPERATION_POLL_DEADLINE_MS = 12 * 60 * 1000;
 
 function invalidOperationResponse(message) {
   return {
@@ -68,6 +69,10 @@ export async function pollAcceptedDeploymentOperation({
   expectedAppName,
   platformFetch,
   setTimeoutImpl,
+  deadlineSetTimeoutImpl = setTimeout,
+  deadlineClearTimeoutImpl = clearTimeout,
+  nowImpl = () => performance.now(),
+  totalDeadlineMs = DEFAULT_DEPLOYMENT_OPERATION_POLL_DEADLINE_MS,
 }) {
   const expected = {
     operationId: null,
@@ -78,8 +83,53 @@ export async function pollAcceptedDeploymentOperation({
   if (typeof expected.appName !== "string" || !APP_NAME.test(expected.appName)) {
     return invalidOperationResponse("Deployment operation app identity is invalid");
   }
+  if (!Number.isSafeInteger(totalDeadlineMs) || totalDeadlineMs < 1) {
+    return invalidOperationResponse("Deployment operation deadline is invalid");
+  }
   let response = initialResponse;
-  for (let attempt = 0; attempt < 900; attempt += 1) {
+  const startedAtMs = nowImpl();
+  const deadlineMs = startedAtMs + totalDeadlineMs;
+  let lastIdentity = null;
+  const pendingResponse = () => ({
+    ok: false,
+    status: 503,
+    statusText: "Service Unavailable",
+    json: async () => ({
+      error: "Deployment is still running. The server operation was not cancelled.",
+      code: "PLATFORM_DEPLOYMENT_OPERATION_PENDING",
+      stage: "controller",
+      retryClass: "retryable-infra",
+      userAction: "VIEW_STATUS",
+      operationId: lastIdentity?.operationId,
+      correlationId: lastIdentity?.correlationId,
+      appName: lastIdentity?.appName,
+      state: lastIdentity?.state,
+      statusCommand: "gencow deploy status",
+      serverOperationContinues: true,
+    }),
+  });
+  const fetchWithinDeadline = async () => {
+    const remainingMs = Math.max(0, deadlineMs - nowImpl());
+    if (remainingMs === 0) return null;
+    const controller = new AbortController();
+    let timer;
+    const timedOut = new Promise((resolve) => {
+      timer = deadlineSetTimeoutImpl(() => {
+        controller.abort(new Error("PLATFORM_DEPLOYMENT_OPERATION_POLL_DEADLINE_EXCEEDED"));
+        resolve(null);
+      }, remainingMs);
+      timer?.unref?.();
+    });
+    try {
+      return await Promise.race([
+        platformFetch(creds, expected.pollUrl, { method: "GET", signal: controller.signal }),
+        timedOut,
+      ]);
+    } finally {
+      if (timer !== undefined) deadlineClearTimeoutImpl(timer);
+    }
+  };
+  while (true) {
     const body = await readJsonObjectResponse(response);
     const identity = readIdentity(body);
     const nonterminal = isNonterminalResponse(response, body, identity);
@@ -90,11 +140,17 @@ export async function pollAcceptedDeploymentOperation({
       expected.operationId ??= identity.operationId;
       expected.correlationId ??= identity.correlationId;
       expected.pollUrl ??= identity.pollUrl;
+      lastIdentity = identity;
+      if (nowImpl() >= deadlineMs) return pendingResponse();
       const retryAfter = Number(response.headers?.get?.("Retry-After"));
       const retryDelayMs =
         Number.isFinite(retryAfter) && retryAfter >= 1 && retryAfter <= 10 ? retryAfter * 1000 : 1000;
-      await new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, retryDelayMs));
-      response = await platformFetch(creds, expected.pollUrl, { method: "GET" });
+      const remainingMs = Math.max(0, deadlineMs - nowImpl());
+      await new Promise((resolveDelay) => setTimeoutImpl(resolveDelay, Math.min(retryDelayMs, remainingMs)));
+      if (nowImpl() >= deadlineMs) return pendingResponse();
+      const polledResponse = await fetchWithinDeadline();
+      if (!polledResponse) return pendingResponse();
+      response = polledResponse;
       continue;
     }
     if (
@@ -112,16 +168,4 @@ export async function pollAcceptedDeploymentOperation({
       json: async () => body,
     };
   }
-  return {
-    ok: false,
-    status: 503,
-    statusText: "Service Unavailable",
-    json: async () => ({
-      error: "Deployment operation did not reach a terminal state",
-      code: "PLATFORM_DEPLOYMENT_OPERATION_PENDING",
-      stage: "controller",
-      retryClass: "retryable-infra",
-      userAction: "RETRY",
-    }),
-  };
 }

package/lib/doctor-command.mjs

@@ -10,6 +10,7 @@ import {
   formatCheckReport,
   planBomSync,
 } from "./runtime-bom.mjs";
+import { syncStandalonePackageAndLock } from "./project-dependency-lock-sync.mjs";
 import {
   APPROVED_DEPLOY_PACKAGE_MANAGER,
   UNSUPPORTED_DEPLOY_LOCKFILES,
@@ -17,8 +18,7 @@ import {
 
 export function inspectPackageManagerAuthority({ cwd, existsSyncImpl, readFileSyncImpl }) {
   const packagePath = resolve(cwd, "package.json");
-  const legacyLocks = UNSUPPORTED_DEPLOY_LOCKFILES
-    .filter((file) => existsSyncImpl(resolve(cwd, file)));
+  const legacyLocks = UNSUPPORTED_DEPLOY_LOCKFILES.filter((file) => existsSyncImpl(resolve(cwd, file)));
   const hasPnpmLock = existsSyncImpl(resolve(cwd, "pnpm-lock.yaml"));
   let declared = "";
   if (existsSyncImpl(packagePath)) {
@@ -43,8 +43,12 @@ function renderDoctorHelp(deps) {
   );
   deps.logImpl(`  ${deps.BOLD}Usage:${deps.RESET}  gencow doctor [options]\n`);
   deps.logImpl(`  Runs analyzer-backed Doctor checks before local/dev/deploy-style flows.\n`);
-  deps.logImpl(`  Checks include schema graph validation, migration source/history preview, unsafe DB access,`);
-  deps.logImpl(`  forbidden modules, source anti-patterns, deprecated backend APIs, and Runtime BOM drift.\n`);
+  deps.logImpl(
+    `  Checks include schema graph validation, migration source/history preview, unsafe DB access,`,
+  );
+  deps.logImpl(
+    `  forbidden modules, source anti-patterns, deprecated backend APIs, and Runtime BOM drift.\n`,
+  );
   deps.logImpl(`  Deploy authority is ${APPROVED_DEPLOY_PACKAGE_MANAGER} + pnpm-lock.yaml only.\n`);
   deps.logImpl(`  ${deps.BOLD}Options:${deps.RESET}`);
   deps.logImpl(
@@ -133,6 +137,7 @@ async function runRuntimeBomDoctorSection(params) {
     existsSyncImpl,
     readFileSyncImpl,
     writeFileSyncImpl,
+    execFileSyncImpl,
   } = params;
 
   deps.logImpl(`${deps.BOLD}Runtime BOM${deps.RESET}`);
@@ -226,10 +231,17 @@ async function runRuntimeBomDoctorSection(params) {
   }
 
   const applied = applyBomSyncToPackageJson(packageJson, plan);
-  writeFileSyncImpl(pkgPath, `${JSON.stringify(applied.packageJson, null, 2)}\n`, "utf8");
+  const syncResult = syncStandalonePackageAndLock(
+    { cwd, nextPackageJson: applied.packageJson },
+    { existsSyncImpl, readFileSyncImpl, writeFileSyncImpl, execFileSyncImpl },
+  );
   for (const warning of applied.warnings) deps.warnImpl?.(warning);
   deps.successImpl(`Synced managed dependencies in package.json to ${bom.releaseId}`);
-  deps.infoImpl("Run pnpm install to refresh pnpm-lock.yaml.");
+  if (syncResult.synchronizedLock) {
+    deps.successImpl("pnpm-lock.yaml remains deploy-valid.");
+  } else {
+    deps.infoImpl("Run pnpm install to refresh pnpm-lock.yaml.");
+  }
   deps.logImpl("");
   return { blocked: false, synced: true };
 }
@@ -240,6 +252,7 @@ export function createDoctorCommand(deps) {
   const existsSyncImpl = deps.existsSyncImpl ?? existsSync;
   const readFileSyncImpl = deps.readFileSyncImpl ?? readFileSync;
   const writeFileSyncImpl = deps.writeFileSyncImpl ?? writeFileSync;
+  const execFileSyncImpl = deps.execFileSyncImpl;
   const warnImpl = deps.warnImpl ?? deps.infoImpl;
 
   return async function doctor(...doctorArgs) {
@@ -281,17 +294,23 @@ export function createDoctorCommand(deps) {
     deps.infoImpl(`Backend root: ${backendRoot}/`);
     deps.infoImpl(`Schema: ${schemaDisplay}`);
     try {
-      const migrationPreview = (deps.buildSchemaDeploymentPreviewImpl ?? buildProjectSchemaDeploymentPreview)({
-        cwd,
-        backendDir: backendRoot,
-        cliVersion: deps.cliVersion ?? "0.0.0",
-      });
+      const migrationPreview = (deps.buildSchemaDeploymentPreviewImpl ?? buildProjectSchemaDeploymentPreview)(
+        {
+          cwd,
+          backendDir: backendRoot,
+          cliVersion: deps.cliVersion ?? "0.0.0",
+        },
+      );
       deps.infoImpl(`Migration schema source: ${migrationPreview.schemaSource}`);
       deps.infoImpl(`Generator: drizzle-kit ${migrationPreview.generatorVersion}`);
-      deps.infoImpl(`Migration format: ${migrationPreview.migrationFormat} (${migrationPreview.migrationCount})`);
+      deps.infoImpl(
+        `Migration format: ${migrationPreview.migrationFormat} (${migrationPreview.migrationCount})`,
+      );
       deps.infoImpl(`Migration decision preview: ${migrationPreview.decision}`);
       if (migrationPreview.decision === "canonical_check_required") {
-        deps.infoImpl("Canonical generation resolves whether empty history is deployable or requires a v1 migration.");
+        deps.infoImpl(
+          "Canonical generation resolves whether empty history is deployable or requires a v1 migration.",
+        );
       }
       deps.infoImpl(
         `Fix mode: ${
@@ -322,10 +341,15 @@ export function createDoctorCommand(deps) {
         existsSyncImpl,
         readFileSyncImpl,
         writeFileSyncImpl,
+        execFileSyncImpl,
       });
       bomBlocked = bomResult.blocked;
 
-      const bundled = await (deps.loadInternalBundleImpl ?? deps.loadCodegenBundleImpl ?? loadCodegenBundleDefault)();
+      const bundled = await (
+        deps.loadInternalBundleImpl ??
+        deps.loadCodegenBundleImpl ??
+        loadCodegenBundleDefault
+      )();
 
       const result = await bundled.runAppDoctor({
         projectRoot: cwd,

package/lib/http-response-json.mjs

@@ -1,9 +1,14 @@
-export async function readJsonObjectResponse(response) {
-  let value;
+export async function readJsonValueResponse(response) {
   try {
-    value = await response.json();
+    return { parsed: true, value: await response.json() };
   } catch {
-    return null;
+    return { parsed: false };
   }
+}
+
+export async function readJsonObjectResponse(response) {
+  const decoded = await readJsonValueResponse(response);
+  if (!decoded.parsed) return null;
+  const { value } = decoded;
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }

package/lib/init-command.mjs

@@ -1,10 +1,10 @@
-import { execSync } from "child_process";
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, symlinkSync, writeFileSync } from "fs";
 import { basename, dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { getBackendEnvBaseRelativePath, logEnvFileOperationWithType } from "./backend-env-resolver.mjs";
 import { collectFeatureDependencies, installFeatures, loadFeatureCatalog } from "./install-features.mjs";
 import { BOLD, CYAN, DIM, GREEN, RESET, error, info, log, success, warn } from "./output.mjs";
+import { installAndVerifyProjectDependencies } from "./project-dependency-lock-sync.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -200,7 +200,9 @@ function renderInitHelp(logImpl) {
   logImpl(`  ${BOLD}Arguments:${RESET}`);
   logImpl(`    ${CYAN}name${RESET}               Project name (creates directory) or "." for current dir\n`);
   logImpl(`  ${BOLD}Options:${RESET}`);
-  logImpl(`    ${DIM}--template, -t${RESET}     Select template (default, task-app, admin-tool, fullstack, ai-chat)`);
+  logImpl(
+    `    ${DIM}--template, -t${RESET}     Select template (default, task-app, admin-tool, fullstack, ai-chat)`,
+  );
   logImpl(`    ${DIM}--force, -f${RESET}        Initialize in non-empty directory`);
   logImpl(`    ${DIM}--no-install${RESET}       Skip dependency install (CI/canary)\n`);
   logImpl(`  ${BOLD}Examples:${RESET}`);
@@ -284,7 +286,7 @@ export function createInitCommand({
   createInterfaceImpl,
   cwdImpl = () => process.cwd(),
   errorImpl = error,
-  execSyncImpl = execSync,
+  execFileSyncImpl,
   exitImpl = (code) => process.exit(code),
   infoImpl = info,
   logImpl = log,
@@ -471,7 +473,7 @@ export function createInitCommand({
     await installFeatures(template.features, projectDir, {
       catalog,
       templateFeatureDir,
-      installPackages: !noInstall,
+      installPackages: false,
       cwdImpl: () => projectDir,
       existsSyncImpl: existsSync,
       loadConfig: async () => ({ rootDir: "gencow", envFile: "gencow/.env" }),
@@ -581,15 +583,13 @@ export function createInitCommand({
     } else {
       infoImpl("Installing dependencies...");
       try {
-        execSyncImpl("pnpm install", { cwd: projectDir, stdio: ["ignore", "pipe", "pipe"] });
+        installAndVerifyProjectDependencies(projectDir, { execFileSyncImpl });
         successImpl("Dependencies installed");
-      } catch {
+      } catch (caught) {
         installStatus = "failed";
-        warnImpl(
-          "Package install failed — " +
-            (isCwd ? "pnpm install" : "cd " + name + " && pnpm install") +
-            " to install manually",
-        );
+        warnImpl(`${caught?.code ?? "CLI_INIT_DEPENDENCY_INSTALL_FAILED"}: Dependency setup failed.`);
+        exitImpl(1);
+        return;
       }
     }
 

package/lib/project-dependency-lock-sync.mjs

@@ -0,0 +1,122 @@
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { resolve } from "path";
+
+import { APPROVED_DEPLOY_PACKAGE_MANAGER, inspectPnpmDependencyLock } from "@gencow/migration-contract";
+
+const PACKAGE_FILE = "package.json";
+const LOCK_FILE = "pnpm-lock.yaml";
+
+function approvedPnpmSelector() {
+  return APPROVED_DEPLOY_PACKAGE_MANAGER;
+}
+
+function corepackCommand(platform) {
+  return platform === "win32" ? "corepack.cmd" : "corepack";
+}
+
+function readProjectDependencyFiles(projectDir, deps) {
+  const packagePath = resolve(projectDir, PACKAGE_FILE);
+  const lockPath = resolve(projectDir, LOCK_FILE);
+  return {
+    packagePath,
+    lockPath,
+    packageText: deps.readFileSyncImpl(packagePath, "utf8"),
+    lockText: deps.existsSyncImpl(lockPath) ? deps.readFileSyncImpl(lockPath, "utf8") : null,
+  };
+}
+
+function assertDeployValidLock(projectDir, deps, failureCode) {
+  const files = readProjectDependencyFiles(projectDir, deps);
+  const admission = inspectPnpmDependencyLock({
+    packageJsonText: files.packageText,
+    pnpmLockText: files.lockText,
+  });
+  if (!admission.ok) {
+    const error = new Error(failureCode);
+    error.code = failureCode;
+    error.reason = admission.reason;
+    throw error;
+  }
+  return admission;
+}
+
+function hasWorkspaceDependency(packageJson) {
+  return ["dependencies", "devDependencies", "optionalDependencies"].some((group) =>
+    Object.values(packageJson[group] ?? {}).some(
+      (specifier) => typeof specifier === "string" && specifier.startsWith("workspace:"),
+    ),
+  );
+}
+
+function isStandaloneDeployProject(packageJson) {
+  return (
+    packageJson?.packageManager === APPROVED_DEPLOY_PACKAGE_MANAGER && !hasWorkspaceDependency(packageJson)
+  );
+}
+
+function restoreFile(path, previous, deps) {
+  if (previous === null) {
+    if (deps.existsSyncImpl(path)) deps.unlinkSyncImpl(path);
+    return;
+  }
+  deps.writeFileSyncImpl(path, previous, "utf8");
+}
+
+function dependencyIoDeps(overrides = {}) {
+  return {
+    execFileSyncImpl: overrides.execFileSyncImpl ?? execFileSync,
+    existsSyncImpl: overrides.existsSyncImpl ?? existsSync,
+    readFileSyncImpl: overrides.readFileSyncImpl ?? readFileSync,
+    platform: overrides.platform ?? process.platform,
+    unlinkSyncImpl: overrides.unlinkSyncImpl ?? unlinkSync,
+    writeFileSyncImpl: overrides.writeFileSyncImpl ?? writeFileSync,
+  };
+}
+
+export function installAndVerifyProjectDependencies(projectDir, overrides = {}) {
+  const deps = dependencyIoDeps(overrides);
+  try {
+    deps.execFileSyncImpl(
+      corepackCommand(deps.platform),
+      [approvedPnpmSelector(), "install", "--ignore-workspace"],
+      {
+        cwd: projectDir,
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    );
+  } catch {
+    const error = new Error("CLI_INIT_DEPENDENCY_INSTALL_FAILED");
+    error.code = "CLI_INIT_DEPENDENCY_INSTALL_FAILED";
+    throw error;
+  }
+  return assertDeployValidLock(projectDir, deps, "CLI_INIT_LOCK_POSTCONDITION_FAILED");
+}
+
+export function syncStandalonePackageAndLock({ cwd, nextPackageJson }, overrides = {}) {
+  const deps = dependencyIoDeps(overrides);
+  const current = readProjectDependencyFiles(cwd, deps);
+  const nextPackageText = `${JSON.stringify(nextPackageJson, null, 2)}\n`;
+
+  if (!isStandaloneDeployProject(nextPackageJson)) {
+    deps.writeFileSyncImpl(current.packagePath, nextPackageText, "utf8");
+    return { synchronizedLock: false };
+  }
+
+  try {
+    deps.writeFileSyncImpl(current.packagePath, nextPackageText, "utf8");
+    deps.execFileSyncImpl(
+      corepackCommand(deps.platform),
+      [approvedPnpmSelector(), "install", "--lockfile-only", "--ignore-scripts", "--ignore-workspace"],
+      { cwd, stdio: ["ignore", "pipe", "pipe"] },
+    );
+    const admission = assertDeployValidLock(cwd, deps, "CLI_RUNTIME_BOM_LOCK_SYNC_FAILED");
+    return { synchronizedLock: true, admission };
+  } catch {
+    restoreFile(current.packagePath, current.packageText, deps);
+    restoreFile(current.lockPath, current.lockText, deps);
+    const error = new Error("CLI_RUNTIME_BOM_LOCK_SYNC_FAILED");
+    error.code = "CLI_RUNTIME_BOM_LOCK_SYNC_FAILED";
+    throw error;
+  }
+}