gencow 0.1.199 → 0.1.201

package/lib/add-memory.mjs

@@ -0,0 +1,21 @@
+import { dirname, relative, resolve } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+
+import { patchSchemaEntrySource } from "./add-rag.mjs";
+
+export async function patchMemoryProjectWiring(deps) {
+  const cwd = deps.cwdImpl();
+  const exists = deps.existsSyncImpl ?? existsSync;
+  const projectConfig = await deps.loadConfig();
+  const functionsDir = projectConfig?.rootDir || "gencow";
+  const schemaPath = resolve(cwd, functionsDir, "schema.ts");
+
+  if (!exists(dirname(schemaPath))) mkdirSync(dirname(schemaPath), { recursive: true });
+
+  const schemaSource = exists(schemaPath) ? readFileSync(schemaPath, "utf-8") : "";
+  const nextSchemaSource = patchSchemaEntrySource(schemaSource, "./schema-memory");
+  if (nextSchemaSource !== schemaSource) {
+    writeFileSync(schemaPath, nextSchemaSource);
+    deps.logImpl(`    ${deps.GREEN}✓${deps.RESET} ${relative(cwd, schemaPath)} — exported schema-memory`);
+  }
+}

package/lib/cloud-targets.mjs

@@ -15,17 +15,21 @@ export function readProjectAppTargets(cwd = process.cwd()) {
   }
   const gencowJsonPath = resolveProjectMetadataPath(projectDir, resolve);
   if (!existsSync(gencowJsonPath)) {
-    return { appId: null, prodApp: null };
+    return { appId: null, invalid: false, prodApp: null };
   }
 
   try {
     const gencowJson = JSON.parse(readFileSync(gencowJsonPath, "utf8"));
+    if (!gencowJson || typeof gencowJson !== "object" || Array.isArray(gencowJson)) {
+      return { appId: null, invalid: true, prodApp: null };
+    }
     return {
       appId: gencowJson.appId || gencowJson.appName || null,
+      invalid: false,
       prodApp: gencowJson.prodApp || null,
     };
   } catch {
-    return { appId: null, prodApp: null };
+    return { appId: null, invalid: true, prodApp: null };
   }
 }
 
@@ -52,15 +56,18 @@ export function resolveCloudAppTarget(restArgs, options = {}) {
   }
 
   const projectTargets = readProjectAppTargets(cwd);
+  if (projectTargets.invalid) {
+    return { error: "MIGRATION_PROJECT_CONFIG_INVALID" };
+  }
   if (!appId) {
     appId = envTarget === "prod" ? projectTargets.prodApp : projectTargets.appId;
   }
 
   if (envTarget === "prod") {
-    if (!projectTargets.prodApp) {
+    if (!projectTargets.prodApp && !explicitApp) {
       return { error: missingProdMessage };
     }
-    if (explicitApp && appId !== projectTargets.prodApp) {
+    if (explicitApp && projectTargets.prodApp && appId !== projectTargets.prodApp) {
       return { error: missingProdMessage };
     }
   }

package/lib/codegen-command.mjs

@@ -5,7 +5,11 @@ import {
   formatAuthSchemaConflictMessage,
 } from "./auth-schema-provenance-guard.mjs";
 import { loadToolingRuntime } from "./tooling-runtime.mjs";
-import { getCliInvocationSelection, resolveProjectSelection, selectCodegenClient } from "./project-context.mjs";
+import {
+  getCliInvocationSelection,
+  resolveProjectSelection,
+  selectCodegenClient,
+} from "./project-context.mjs";
 
 export { formatAuthSchemaConflictMessage } from "./auth-schema-provenance-guard.mjs";
 
@@ -187,19 +191,20 @@ export async function runCodegenWithReporting({
   outDir = resolveCodegenArtifactsDir(cwd),
   publishDir = resolveCodegenPublishDir(cwd, config),
   resolvePathImpl = resolve,
-  serverPublishDir = resolveCodegenServerPublishDir(cwd, config),
+  serverPublishDir,
   successImpl,
 }) {
   const bundled = await (loadCodegenBundleImpl ?? loadCodegenBundleDefault)();
 
   const codegenResolved = resolveCodegenConfig(config);
+  const effectiveServerPublishDir = serverPublishDir ?? resolveCodegenServerPublishDir(cwd, config);
   const result = await bundled.runCodegen({
     projectRoot: cwd,
     rootDir: resolveBackendRootDir(config),
     schema: config.schema,
     outDir,
     finalOutDir: publishDir,
-    serverPublishDir: codegenResolved.serverOutDir ?? undefined,
+    serverPublishDir,
     cloudFeatures: config.cloudFeatures,
     authSchema: codegenResolved.authSchema
       ? { emitRelations: codegenResolved.authSchemaEmitRelations }
@@ -213,7 +218,7 @@ export async function runCodegenWithReporting({
     cwd,
     publishDir,
     resolvePathImpl,
-    serverPublishDir,
+    serverPublishDir: effectiveServerPublishDir,
     successImpl,
   });
   logCodegenDiagnostics(logImpl, result.diagnostics, diagnosticsColors);
@@ -288,7 +293,12 @@ export function createCodegenCommand(deps) {
     }
     const declaredCodegenClients = getDeclaredCodegenClients(config);
     const explicitSelection = explicitTarget ?? getCliInvocationSelection()?.target ?? null;
-    if (Array.isArray(config?.clients) && config.clients.length > 0 && declaredCodegenClients.length === 0 && !outdir) {
+    if (
+      Array.isArray(config?.clients) &&
+      config.clients.length > 0 &&
+      declaredCodegenClients.length === 0 &&
+      !outdir
+    ) {
       deps.errorImpl(
         "No declared codegen client found. Add clients[*].codegen.outDir or pass --outdir for a one-off output.",
       );
@@ -336,7 +346,6 @@ export function createCodegenCommand(deps) {
         outDir: artifactsDir,
         publishDir,
         resolvePathImpl: deps.resolvePathImpl,
-        serverPublishDir,
         successImpl: deps.successImpl,
       });
       deps.successImpl("Codegen completed successfully.");

package/lib/db-command.mjs

@@ -36,7 +36,7 @@ export function resolveDbCloudTarget(args, gencowJson = null) {
     platformUrl = gencowJson.platformUrl || null;
     if (isProd) {
       const prodApp = gencowJson.prodApp || null;
-      const appId = prodApp && (!explicitAppId || explicitAppId === prodApp) ? prodApp : null;
+      const appId = prodApp ? (!explicitAppId || explicitAppId === prodApp ? prodApp : null) : explicitAppId;
       return { appId, isProd, platformUrl };
     }
     return { appId: explicitAppId || gencowJson.appId || gencowJson.appName || null, isProd, platformUrl };

package/lib/deploy-bundle-staging.mjs

@@ -17,6 +17,8 @@ export async function writeCanonicalDeployBundle({
   backendRoot,
   dependencyAuditManifest,
   existsSyncImpl,
+  generatedServerPublishDir,
+  generatedServerRelativeDir,
   cpSyncImpl,
   generatorVersion,
   lockfileSelection,
@@ -43,12 +45,13 @@ export async function writeCanonicalDeployBundle({
         canonicalBackendDir: bundleBackendRoot,
       })
     : null;
-  const canonicalBundleProjectConfig = hasSelectedProjectConfigFile && projectConfig
-    ? canonicalizeBundleProjectConfig(projectConfig, {
-        backendDir: backendRoot,
-        canonicalBackendDir: bundleBackendRoot,
-      })
-    : null;
+  const canonicalBundleProjectConfig =
+    hasSelectedProjectConfigFile && projectConfig
+      ? canonicalizeBundleProjectConfig(projectConfig, {
+          backendDir: backendRoot,
+          canonicalBackendDir: bundleBackendRoot,
+        })
+      : null;
   const envExcludes = buildBackendEnvExcludePatterns(
     canonicalBundleProjectConfig ?? canonicalManifestConfig ?? { rootDir: `./${bundleBackendRoot}` },
   );
@@ -58,6 +61,20 @@ export async function writeCanonicalDeployBundle({
     rmSyncImpl(bundleStagingDir, { recursive: true, force: true });
     mkdirSyncImpl(bundleStagingDir, { recursive: true });
     cpSyncImpl(sourceBackendDir, resolvePathImpl(bundleStagingDir, bundleBackendRoot), { recursive: true });
+    if (
+      generatedServerPublishDir &&
+      generatedServerRelativeDir &&
+      existsSyncImpl(generatedServerPublishDir)
+    ) {
+      const generatedServerTarget = resolvePathImpl(
+        bundleStagingDir,
+        bundleBackendRoot,
+        generatedServerRelativeDir,
+      );
+      rmSyncImpl(generatedServerTarget, { recursive: true, force: true });
+      mkdirSyncImpl(dirname(generatedServerTarget), { recursive: true });
+      cpSyncImpl(generatedServerPublishDir, generatedServerTarget, { recursive: true });
+    }
 
     if (canonicalBundleProjectConfig) {
       writeCanonicalBundleProjectConfig({

package/lib/deploy-codegen-preflight.mjs

@@ -0,0 +1,122 @@
+import { isAbsolute, relative, sep } from "path";
+
+import { resolveCodegenServerPublishDir, runCodegenWithReporting } from "./codegen-command.mjs";
+
+const GENERATED_AUTH_SCHEMA_IMPORT =
+  /(?:export\s+\*\s+from|import)\s*["'][^"']*generated\/schema-auth\.gen["']/u;
+
+export function resolveConfiguredBackendRoot(projectConfig) {
+  const pathValue = projectConfig?.rootDir ?? projectConfig?.functionsDir ?? "gencow";
+  if (typeof pathValue !== "string") return "gencow";
+  const normalized = pathValue
+    .trim()
+    .replace(/^\.\/+/, "")
+    .replace(/[\\/]+$/, "");
+  return normalized || "gencow";
+}
+
+export async function loadDeployMigrationGenerationContext({
+  buildEnvImpl,
+  cwd,
+  errorImpl,
+  existsSyncImpl,
+  infoImpl,
+  loadConfigImpl,
+  loadProjectConfigForDeployImpl,
+  readFileSyncImpl,
+  resolvePathImpl,
+  statSyncImpl,
+  warnImpl,
+}) {
+  if (!loadConfigImpl || !buildEnvImpl) {
+    warnImpl("Deploy packaging is using legacy migration generation without a Gencow schema contract.");
+    return { config: null, genEnv: null };
+  }
+  const config = await loadProjectConfigForDeployImpl({
+    cwd,
+    existsSyncImpl,
+    readFileSyncImpl,
+    resolvePathImpl,
+    statSyncImpl,
+    warnImpl,
+    errorImpl,
+    loadConfigImpl,
+    throwOnInvalid: true,
+  });
+  const genEnv = buildEnvImpl(config, { cwd, existsSyncImpl, readFileSyncImpl, resolvePathImpl });
+  infoImpl("Using Gencow-derived schema contract for deploy packaging.");
+  return { config, genEnv };
+}
+
+export async function prepareDeployCodegenArtifacts({
+  backendRoot,
+  config,
+  cwd,
+  diagnosticsColors,
+  errorImpl,
+  existsSyncImpl,
+  infoImpl,
+  logImpl,
+  readFileSyncImpl,
+  relativePathImpl = relative,
+  resolvePathImpl,
+  rmSyncImpl,
+  runCodegenForDeployImpl = runCodegenWithReporting,
+  successImpl,
+}) {
+  const authSchemaPath = resolvePathImpl(cwd, backendRoot, "schema-auth.ts");
+  const serverPublishDir = resolveCodegenServerPublishDir(cwd, config);
+  const authSchemaGeneratedPath = resolvePathImpl(serverPublishDir, "schema-auth.gen.ts");
+  const hasGeneratedAuthSchemaDependency =
+    existsSyncImpl(authSchemaPath) &&
+    GENERATED_AUTH_SCHEMA_IMPORT.test(readFileSyncImpl(authSchemaPath, "utf8"));
+  const shouldGenerate =
+    config.codegen !== undefined ||
+    (hasGeneratedAuthSchemaDependency && !existsSyncImpl(authSchemaGeneratedPath));
+  if (!shouldGenerate) return null;
+
+  const backendRootDir = resolvePathImpl(cwd, backendRoot);
+  const serverPublishRelativeDir = relativePathImpl(backendRootDir, serverPublishDir);
+  if (
+    !serverPublishRelativeDir ||
+    serverPublishRelativeDir === "." ||
+    isAbsolute(serverPublishRelativeDir) ||
+    serverPublishRelativeDir === ".." ||
+    serverPublishRelativeDir.startsWith(`..${sep}`)
+  ) {
+    errorImpl("Deploy codegen server output must be inside the configured backend root.");
+    infoImpl("Code: CODEGEN_SERVER_OUTPUT_OUTSIDE_BACKEND");
+    throw new Error("CODEGEN_SERVER_OUTPUT_OUTSIDE_BACKEND");
+  }
+
+  infoImpl("Generating required auth schema for deploy packaging...");
+  const deployCodegenDir = resolvePathImpl(cwd, ".gencow", "deploy-codegen");
+  const deployCodegenClientDir = resolvePathImpl(cwd, ".gencow", "deploy-codegen-client");
+  const deployCodegenServerDir = resolvePathImpl(cwd, ".gencow", "deploy-codegen-server");
+  const cleanup = () => {
+    rmSyncImpl(deployCodegenDir, { recursive: true, force: true });
+    rmSyncImpl(deployCodegenClientDir, { recursive: true, force: true });
+    rmSyncImpl(deployCodegenServerDir, { recursive: true, force: true });
+  };
+
+  try {
+    await runCodegenForDeployImpl({
+      config,
+      cwd,
+      diagnosticsColors,
+      logImpl,
+      outDir: deployCodegenDir,
+      publishDir: deployCodegenClientDir,
+      serverPublishDir: deployCodegenServerDir,
+      successImpl,
+    });
+  } catch {
+    cleanup();
+    errorImpl("Deploy codegen generation failed.");
+    infoImpl("Code: CODEGEN_GENERATION_FAILED");
+    throw new Error("CODEGEN_GENERATION_FAILED");
+  }
+
+  successImpl("Required auth schema generated for deploy packaging");
+  return { cleanup, serverPublishDir: deployCodegenServerDir, serverPublishRelativeDir };
+}

package/lib/deploy-package-runtime.mjs

@@ -5,6 +5,11 @@ import { fetchAppDiagnosticLogsViaRest, normalizeDiagnosticLogLines } from "./ap
 import { resolveCreatedAppResponse } from "./app-create-response.mjs";
 import { resolveConfiguredAuditorImplementation } from "./auditor-mode.mjs";
 import { writeProjectMetadata } from "./deploy-project-metadata.mjs";
+import {
+  loadDeployMigrationGenerationContext,
+  prepareDeployCodegenArtifacts,
+  resolveConfiguredBackendRoot,
+} from "./deploy-codegen-preflight.mjs";
 import {
   SUPPORTED_DRIZZLE_KIT_GENERATOR_VERSION,
   buildMigrationGenerationError,
@@ -40,18 +45,6 @@ async function loadProjectConfigDefault(options) {
   const { loadConfig } = await import("./cli-project-runtime.mjs");
   return loadConfig(options);
 }
-function normalizeBackendRootDir(pathValue) {
-  if (typeof pathValue !== "string") return "gencow";
-  const normalized = pathValue
-    .trim()
-    .replace(/^\.\/+/, "")
-    .replace(/[\\/]+$/, "");
-  return normalized || "gencow";
-}
-function resolveConfiguredBackendRoot(projectConfig) {
-  return normalizeBackendRootDir(projectConfig?.rootDir ?? projectConfig?.functionsDir ?? "gencow");
-}
-
 export function isExplicitEmptyBackendApi(source) {
   return /\bdefineApi\s*\(\s*\{\s*procedures\s*:\s*\{\s*\}\s*,?\s*\}\s*\)\s*;?\s*$/u.test(source);
 }
@@ -148,8 +141,14 @@ export function createDeployPackageRuntime({
   updateEnvLocalUrlImpl,
   loadInternalBundleImpl,
   loadDeployAuditorImpl,
+  runCodegenForDeployImpl,
 } = {}) {
   let migrationProjectConfig = null;
+  let preparedDeployCodegenArtifacts = null;
+  function cleanupPreparedDeploySource() {
+    preparedDeployCodegenArtifacts?.cleanup?.();
+    preparedDeployCodegenArtifacts = null;
+  }
   async function loadAnalyzerBundleForDeployAudit() {
     try {
       const bundled = await (loadInternalBundleImpl ?? loadInternalToolingDefault)();
@@ -176,35 +175,43 @@ export function createDeployPackageRuntime({
     }
   }
   async function loadMigrationGenerationContext(cwd) {
-    if (loadConfigImpl && buildEnvImpl) {
-      const config = await loadProjectConfigForDeploy({
+    const context = await loadDeployMigrationGenerationContext({
+      buildEnvImpl,
+      cwd,
+      errorImpl,
+      existsSyncImpl,
+      infoImpl: (message) => infoImpl(`${DIM}${message}${RESET}`),
+      loadConfigImpl,
+      loadProjectConfigForDeployImpl: loadProjectConfigForDeploy,
+      readFileSyncImpl,
+      resolvePathImpl,
+      statSyncImpl,
+      warnImpl,
+    });
+    migrationProjectConfig = context.config;
+    return context;
+  }
+  async function runMigrationGenerate() {
+    const cwd = cwdImpl();
+    cleanupPreparedDeploySource();
+    const { config, genEnv } = await loadMigrationGenerationContext(cwd);
+    if (config) {
+      preparedDeployCodegenArtifacts = await prepareDeployCodegenArtifacts({
+        backendRoot: resolveConfiguredBackendRoot(config),
+        config,
         cwd,
-        existsSyncImpl,
-        readFileSyncImpl,
-        resolvePathImpl,
-        statSyncImpl,
-        warnImpl,
+        diagnosticsColors: { CYAN, DIM, RED, RESET, YELLOW },
         errorImpl,
-        loadConfigImpl,
-        throwOnInvalid: true,
-      });
-      migrationProjectConfig = config;
-      const genEnv = buildEnvImpl(config, {
-        cwd,
         existsSyncImpl,
+        infoImpl,
+        logImpl,
         readFileSyncImpl,
         resolvePathImpl,
+        rmSyncImpl,
+        runCodegenForDeployImpl,
+        successImpl,
       });
-      infoImpl(`${DIM}Using Gencow-derived schema contract for deploy packaging.${RESET}`);
-      return { config, genEnv };
     }
-    migrationProjectConfig = null;
-    warnImpl("Deploy packaging is using legacy migration generation without a Gencow schema contract.");
-    return { config: null, genEnv: null };
-  }
-  async function runMigrationGenerate() {
-    const cwd = cwdImpl();
-    const { genEnv } = await loadMigrationGenerationContext(cwd);
     if (
       !hasProjectDatabaseSchemaSource({
         cwd,
@@ -249,6 +256,7 @@ export function createDeployPackageRuntime({
         logImpl(`${DIM}  ok Migrations up-to-date — no new schema changes detected${RESET}`);
         return SUPPORTED_DRIZZLE_KIT_GENERATOR_VERSION;
       }
+      cleanupPreparedDeploySource();
       throw buildMigrationGenerationError(caught);
     }
   }
@@ -370,7 +378,6 @@ export function createDeployPackageRuntime({
       ? preparedGeneratorVersion || SUPPORTED_DRIZZLE_KIT_GENERATOR_VERSION
       : await prepareDeployProjectSource({ existingBundleMode });
     logImpl("");
-
     infoImpl("Packaging project...");
     const tmpBundle = resolvePathImpl(cwd, ".gencow", "deploy-bundle.tar.gz");
     mkdirSyncImpl(dirname(tmpBundle), { recursive: true });
@@ -386,15 +393,12 @@ export function createDeployPackageRuntime({
       throwOnInvalid: false,
     });
     const backendRoot = resolveConfiguredBackendRoot(projectConfig);
-
     if (!existsSyncImpl(resolvePathImpl(cwd, backendRoot))) {
       errorImpl(`${backendRoot}/ directory not found. Run from Gencow project root.`);
       exitImpl(1);
       return null;
     }
-
     const entryPoint = resolvePathImpl(cwd, backendRoot, "index.ts");
-
     await runWorkflowShadowingAudit({ cwd, projectConfig, backendRoot });
 
     let dependencyAuditManifest = null;
@@ -461,6 +465,8 @@ export function createDeployPackageRuntime({
         existsSyncImpl,
         cpSyncImpl,
         generatorVersion,
+        generatedServerPublishDir: preparedDeployCodegenArtifacts?.serverPublishDir,
+        generatedServerRelativeDir: preparedDeployCodegenArtifacts?.serverPublishRelativeDir,
         lockfileSelection,
         migrationProjectConfig,
         mkdirSyncImpl,
@@ -478,8 +484,10 @@ export function createDeployPackageRuntime({
     } catch (caught) {
       errorImpl(`Packaging failed: ${caught.message}`);
       exitImpl(1);
+      cleanupPreparedDeploySource();
       return null;
     }
+    cleanupPreparedDeploySource();
 
     const bundleBuffer = readFileSyncImpl(tmpBundle);
     const bundleSize = statSyncImpl(tmpBundle).size;
@@ -518,7 +526,7 @@ export function createDeployPackageRuntime({
     return { bundleBuffer, bundleSize, deployClaim, tmpBundle };
   }
 
-  async function createCloudAppIfNeeded({ creds, appId, displayName, gencowJsonPath }) {
+  async function createCloudAppIfNeeded({ creds, appId, displayName, envTarget = "dev", gencowJsonPath }) {
     if (appId) return appId;
 
     infoImpl("Creating app (auto-generating ID)...");
@@ -544,6 +552,7 @@ export function createDeployPackageRuntime({
     writeProjectMetadata({
       appId: nextAppId,
       displayName,
+      envTarget,
       platformUrl: creds.platformUrl,
       gencowJsonPath,
       writeFileSyncImpl,
@@ -667,6 +676,7 @@ export function createDeployPackageRuntime({
         creds,
         appId: null,
         displayName,
+        envTarget,
         gencowJsonPath,
       });
       if (activeDeployClaim) {
@@ -782,6 +792,7 @@ export function createDeployPackageRuntime({
     runMigrationGenerate,
     preflightBackendCapability,
     prepareDeployProjectSource,
+    cleanupPreparedDeploySource,
     packageDeployProject,
     createCloudAppIfNeeded,
     deployBundleWithRetry,

package/lib/deploy-project-metadata.mjs

@@ -1,8 +1,35 @@
-import { writeFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+function readExistingProjectMetadata(gencowJsonPath) {
+  if (!existsSync(gencowJsonPath)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(gencowJsonPath, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  } catch {
+    // Fall through to the stable fail-closed diagnostic below.
+  }
+  throw new Error("MIGRATION_PROJECT_CONFIG_INVALID");
+}
+
+export function buildProjectMetadata({
+  appId,
+  displayName,
+  envTarget = "dev",
+  existingMetadata,
+  platformUrl,
+}) {
+  return {
+    ...existingMetadata,
+    displayName,
+    platformUrl,
+    ...(envTarget === "prod" ? { prodApp: appId } : { appId }),
+  };
+}
 
 export function writeProjectMetadata({
   appId,
   displayName,
+  envTarget = "dev",
   platformUrl,
   gencowJsonPath,
   writeFileSyncImpl = writeFileSync,
@@ -10,11 +37,13 @@ export function writeProjectMetadata({
   writeFileSyncImpl(
     gencowJsonPath,
     JSON.stringify(
-      {
+      buildProjectMetadata({
         appId,
         displayName,
+        envTarget,
+        existingMetadata: readExistingProjectMetadata(gencowJsonPath),
         platformUrl,
-      },
+      }),
       null,
       2,
     ),

package/lib/deploy-runtime.mjs

@@ -124,7 +124,7 @@ export function readDeployProjectContext({
 
   if (existsSyncImpl(gencowJsonPath)) {
     const gencowJson = JSON.parse(readFileSyncImpl(gencowJsonPath, "utf8"));
-    if (!appId) appId = gencowJson.appId || gencowJson.appName;
+    if (!appId) appId = gencowJson.appId || gencowJson.appName || null;
     if (typeof gencowJson.displayName === "string" && gencowJson.displayName.trim()) {
       fallbackDisplayName = gencowJson.displayName.trim();
     }

package/lib/deploy-static-fullstack-runtime.mjs

@@ -114,6 +114,7 @@ export async function deployBackendPackage({
       creds,
       appId,
       displayName,
+      envTarget,
       gencowJsonPath,
     });
     if (!activeAppId) return null;
@@ -158,6 +159,7 @@ export async function deployBackendPackage({
         /* ignore */
       }
     }
+    activePackageRuntime.cleanupPreparedDeploySource?.();
   }
 
   if (!deployed) return null;
@@ -169,6 +171,7 @@ export async function deployBackendPackage({
     writeProjectMetadata({
       appId: deployed.appId,
       displayName,
+      envTarget,
       platformUrl: creds.platformUrl,
       gencowJsonPath,
       writeFileSyncImpl,

package/lib/install-features.mjs

@@ -8,10 +8,12 @@ import {
   logEnvFileOperationWithType,
 } from "./backend-env-resolver.mjs";
 import { installGoogleSsoAuthConfig } from "./add-sso.mjs";
+import { patchMemoryProjectWiring } from "./add-memory.mjs";
 import { patchRagProjectWiring } from "./add-rag.mjs";
 import { patchTossPaymentsProjectWiring } from "./add-tosspayments.mjs";
 
 export const SETUP_HOOKS = {
+  "memory-wiring": patchMemoryProjectWiring,
   "rag-wiring": patchRagProjectWiring,
   "sso-auth-config": installGoogleSsoAuthConfig,
   "tosspayments-wiring": patchTossPaymentsProjectWiring,

package/lib/static-deploy-command.mjs

@@ -18,6 +18,7 @@ import { buildDeployClaimFromArchive } from "./deploy-package-claim.mjs";
 import { buildStaticArtifactManifest } from "./static-artifact-manifest.mjs";
 import { getCliInvocationSelection } from "./project-context.mjs";
 import { pollAcceptedDeploymentOperation } from "./deployment-operation-poll.mjs";
+import { writeProjectMetadata } from "./deploy-project-metadata.mjs";
 
 export function resolveStaticDeployDir({
   staticDirArg,
@@ -153,27 +154,6 @@ async function confirmStaticApiReferenceProceed(createInterfaceImpl) {
   });
 }
 
-function writeProjectMetadata({
-  appId,
-  displayName,
-  platformUrl,
-  gencowJsonPath,
-  writeFileSyncImpl = writeFileSync,
-}) {
-  writeFileSyncImpl(
-    gencowJsonPath,
-    JSON.stringify(
-      {
-        appId,
-        displayName,
-        platformUrl,
-      },
-      null,
-      2,
-    ),
-  );
-}
-
 export function createStaticDeployRuntime({
   buildDeployClaimFromArchiveImpl = buildDeployClaimFromArchive,
   cliVersion = "0.0.0",
@@ -303,6 +283,7 @@ export function createStaticDeployRuntime({
       writeProjectMetadata({
         appId,
         displayName,
+        envTarget: opts.envTarget || "dev",
         platformUrl: creds.platformUrl,
         gencowJsonPath,
         writeFileSyncImpl,
@@ -505,6 +486,7 @@ export function createStaticDeployRuntime({
       writeProjectMetadata({
         appId,
         displayName,
+        envTarget: opts.envTarget || "dev",
         platformUrl: creds.platformUrl,
         gencowJsonPath,
         writeFileSyncImpl,

package/package.json

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