gencow 0.1.199 → 0.1.200

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.199",
+  "version": "0.1.200",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {
@@ -33,8 +33,8 @@
   "devDependencies": {
     "@types/node": "^25.9.5",
     "better-auth": "^1.6.23",
-    "@gencow/client": "0.2.6",
     "@gencow/core": "0.1.42",
+    "@gencow/client": "0.2.6",
     "@gencow/react": "0.2.6"
   },
   "scripts": {

package/runtime/server.mjs

@@ -180790,9 +180790,10 @@ function startDeploymentAttemptLeaseHeartbeat(input) {
           ttlMs: input.ttlMs ?? DEPLOYMENT_ATTEMPT_LEASE_TTL_MS
         });
         if (!renewal.claimed && !stopped) {
-          held = false;
           stopped = true;
           clearInterval(timer2);
+          if (await input.isLeaseRetired?.()) return;
+          held = false;
           input.logger?.warn("[deployment-attempt] exact invocation lease was lost");
           try {
             await input.onLeaseLost?.();
@@ -401217,11 +401218,40 @@ var init_tenant_runtime_startup_budget = __esm({
 });
 
 // ../platform/src/direct-runner-health-probe.ts
+import { request as requestHttp } from "node:http";
+function requestLocalHealth(url2, init) {
+  return new Promise((resolve115, reject3) => {
+    const request = requestHttp(
+      url2,
+      {
+        signal: init.signal ?? void 0,
+        agent: false,
+        headers: { connection: "close" }
+      },
+      (response) => {
+        const status = response.statusCode ?? 0;
+        response.once("end", () => resolve115({ ok: status >= 200 && status < 300 }));
+        response.resume();
+      }
+    );
+    request.once("error", reject3);
+    request.end();
+  });
+}
+async function requestLocalHealthWithFallback(url2, init) {
+  try {
+    return await requestLocalHealth(url2, init);
+  } catch {
+    return globalThis.fetch(url2, init);
+  }
+}
 function resolveDirectRunnerHealthTimeoutMs(lifecycleRole, runtimeEnv = {}) {
   return lifecycleRole === "candidate" ? resolveTenantRuntimeStartupBudgetMs(runtimeEnv) : DIRECT_RUNNER_LEGACY_HEALTH_TIMEOUT_MS;
 }
 async function probeDirectRunnerHealth(port, timeoutMs, dependencies = {
-  fetch: (url2, init) => globalThis.fetch(url2, init),
+  // Runtime admission is a localhost control-plane operation. A native local
+  // request keeps admission available if Bun's process-global fetch client stalls.
+  fetch: requestLocalHealthWithFallback,
   scheduleAbort: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
   cancelAbort: (timer2) => globalThis.clearTimeout(timer2)
 }, healthPath = "/") {
@@ -414102,6 +414132,14 @@ async function makeCandidateGenerationTreeWritable(root2) {
     await makeCandidateGenerationTreeWritable(join25(root2, entry));
   }
 }
+async function removeCandidateGenerationTree(root2) {
+  if (process.platform !== "win32" && process.geteuid?.() === 0) {
+    await rm4(root2, { recursive: true, force: false, maxRetries: 2, retryDelay: 50 });
+    return;
+  }
+  await makeCandidateGenerationTreeWritable(root2);
+  await rm4(root2, { recursive: true, force: false, maxRetries: 2, retryDelay: 50 });
+}
 async function verifyOrSealWorkspace(input) {
   const workspacePath = resolve100(input.workspacePath);
   const durableDataDir = resolve100(input.durableDataDir);
@@ -414381,10 +414419,62 @@ function createAppCandidateGenerationStore(options) {
     if (metadata.generationRef !== input.generationRef || metadata.appId !== input.appId || metadata.environment !== input.environment || metadata.deploymentId !== input.deploymentId) {
       return fail9("CANDIDATE_GENERATION_IDENTITY_MISMATCH");
     }
-    await makeCandidateGenerationTreeWritable(target);
-    await rm4(target, { recursive: true, force: false });
+    await removeCandidateGenerationTree(target);
   }
-  return { prepare, finalize: finalize2, readReady, locateReady, quarantine, removeExact };
+  async function list() {
+    const generationsRoot = join25(root2, "v1");
+    const entries = await readdir6(generationsRoot, { withFileTypes: true }).catch((error51) => {
+      if (error51?.code === "ENOENT") return [];
+      throw error51;
+    });
+    const generations = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !SHA2564.test(entry.name)) continue;
+      const path4 = join25(generationsRoot, entry.name);
+      const candidateMetadata = join25(path4, "candidate.json");
+      const metadataExists = await stat9(candidateMetadata).catch((error51) => {
+        if (error51?.code === "ENOENT") return null;
+        throw error51;
+      });
+      if (!metadataExists) {
+        await removeCandidateGenerationTree(path4);
+        continue;
+      }
+      const metadata = await readMetadata(path4);
+      if (generationPath(metadata.generationRef) !== path4) {
+        return fail9("CANDIDATE_GENERATION_IDENTITY_MISMATCH");
+      }
+      generations.push({ ...metadata, generationPath: path4, workspacePath: join25(path4, "workspace") });
+    }
+    return generations;
+  }
+  async function removeForApp(input) {
+    if (!Number.isSafeInteger(input.appId) || input.appId <= 0) {
+      return fail9("CANDIDATE_GENERATION_INPUT_INVALID");
+    }
+    const exactDataDir = input.durableDataDir ? resolve100(input.durableDataDir) : null;
+    const retained = new Set(input.retainGenerationRefs ?? []);
+    for (const generationRef of retained) {
+      if (!GENERATION_REF.test(generationRef)) return fail9("CANDIDATE_GENERATION_REF_INVALID");
+    }
+    let removed = 0;
+    for (const generation of await list()) {
+      if (generation.appId !== input.appId) continue;
+      if (retained.has(generation.generationRef)) continue;
+      if (exactDataDir && resolve100(generation.durableDataDir) !== exactDataDir) {
+        return fail9("CANDIDATE_GENERATION_IDENTITY_MISMATCH");
+      }
+      await removeExact({
+        generationRef: generation.generationRef,
+        appId: generation.appId,
+        environment: generation.environment,
+        deploymentId: generation.deploymentId
+      });
+      removed += 1;
+    }
+    return { removed };
+  }
+  return { prepare, finalize: finalize2, readReady, locateReady, quarantine, removeExact, list, removeForApp };
 }
 var ARTIFACT_REF5, GENERATION_REF, RUNTIME_GENERATION_REF3, SHA2564;
 var init_app_candidate_generation_store = __esm({
@@ -420977,6 +421067,10 @@ async function deployWithRuntimeControlPlane(input) {
       bundleHash: input.attempt.sourceBundleSha256,
       runtimeRecord: input.runtimeRecord,
       callableBackend: true,
+      // A runtime recovery is still a new activation.  Propagate the signed
+      // serving-route publication contract into the activation transaction so
+      // the edge manifest advances together with its replacement backend.
+      servingRoutePublication: input.servingRoutePublication,
       beforeCommit: async (context2) => {
         await input.onExecutorPhase?.("committing");
         await input.beforeActivationCommit?.(context2);
@@ -423758,50 +423852,89 @@ var init_app_serving_route_publication_adapter = __esm({
 });
 
 // ../platform/src/app-release-runtime-env.ts
+function optionalValue(value) {
+  const normalized = value?.trim() ?? "";
+  return normalized || null;
+}
+function positiveInteger4(value) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function releaseMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true") return "all";
+  return normalized === "allowlist" ? "allowlist" : "disabled";
+}
+function parseAppReleaseRuntimeConfig(env2) {
+  return Object.freeze({
+    executor: Object.freeze({
+      appsDir: optionalValue(env2.GENCOW_APPS_DIR),
+      nodeId: optionalValue(env2.GENCOW_NODE_ID)?.toLowerCase() ?? null,
+      spoolDir: optionalValue(env2.GENCOW_DEPLOYMENT_EXECUTOR_SPOOL_DIR)
+    }),
+    staticOrigin: Object.freeze({
+      artifactRoot: optionalValue(env2.GENCOW_STATIC_ORIGIN_ARTIFACT_ROOT),
+      stageEnabled: env2.GENCOW_STATIC_ORIGIN_STAGE_ENABLED === "true"
+    }),
+    release: Object.freeze({
+      mode: releaseMode(env2.GENCOW_RELEASE_VERSIONS_ENABLED),
+      allowlist: Object.freeze(
+        (env2.GENCOW_RELEASE_VERSIONS_ALLOWLIST ?? "").split(",").map((value) => value.trim()).filter(Boolean)
+      ),
+      quotaBytes: positiveInteger4(env2.GENCOW_RELEASE_STORAGE_QUOTA_BYTES),
+      allowFilesystem: env2.GENCOW_RELEASE_STORAGE_ALLOW_FILESYSTEM === "1",
+      objectsDir: optionalValue(env2.GENCOW_RELEASE_OBJECTS_DIR)
+    }),
+    storage: Object.freeze({
+      azureAccountName: optionalValue(env2.GENCOW_PLATFORM_STORAGE_AZURE_ACCOUNT_NAME),
+      azureContainer: optionalValue(env2.GENCOW_PLATFORM_STORAGE_AZURE_CONTAINER),
+      azureEndpoint: optionalValue(env2.GENCOW_PLATFORM_STORAGE_AZURE_ENDPOINT),
+      azureAuth: env2.GENCOW_PLATFORM_STORAGE_AZURE_AUTH === "client_secret" ? "client_secret" : "managed_identity",
+      azureClientId: optionalValue(env2.GENCOW_PLATFORM_STORAGE_AZURE_CLIENT_ID),
+      azureTenantId: optionalValue(env2.GENCOW_PLATFORM_STORAGE_AZURE_TENANT_ID),
+      azurePrefix: optionalValue(env2.GENCOW_PLATFORM_STORAGE_AZURE_PREFIX)?.replace(/\/+$/u, "") || null
+    }),
+    servingRoute: Object.freeze({
+      publicationMode: optionalValue(env2.GENCOW_SERVING_ROUTE_PUBLICATION_MODE) ?? "off",
+      environment: optionalValue(env2.GENCOW_SERVING_ROUTE_PUBLICATION_ENVIRONMENT),
+      appAllowlist: optionalValue(env2.GENCOW_SERVING_ROUTE_PUBLICATION_APP_ALLOWLIST),
+      topologyRevision: optionalValue(env2.GENCOW_SERVING_ROUTE_TOPOLOGY_REVISION),
+      upsertTargetSetId: optionalValue(env2.GENCOW_SERVING_ROUTE_UPSERT_TARGET_SET_ID),
+      tombstoneTargetSetId: optionalValue(env2.GENCOW_SERVING_ROUTE_TOMBSTONE_TARGET_SET_ID),
+      artifactQuotaBytes: positiveInteger4(env2.GENCOW_SERVING_ROUTE_ARTIFACT_QUOTA_BYTES),
+      baseDomain: optionalValue(env2.BASE_DOMAIN)
+    })
+  });
+}
+function parseAppReleaseProtectedSecrets(env2) {
+  return Object.freeze({
+    azureClientSecret: env2.GENCOW_PLATFORM_STORAGE_AZURE_CLIENT_SECRET || null
+  });
+}
+function isReleaseControlPlane(env2) {
+  return env2.IS_PLATFORM === "true" || env2.GENCOW_DEPLOYMENT_EXECUTOR_ENABLED === "true" && env2.GENCOW_DEPLOYMENT_EXECUTOR_MODE === "dedicated";
+}
 function captureAppReleaseRuntimeEnv(env2 = process.env) {
-  const isReleaseControlPlane = env2.IS_PLATFORM === "true" || env2.GENCOW_DEPLOYMENT_EXECUTOR_ENABLED === "true" && env2.GENCOW_DEPLOYMENT_EXECUTOR_MODE === "dedicated";
-  if (!isReleaseControlPlane) return Object.freeze({});
-  const snapshot = {};
-  for (const key of APP_RELEASE_RUNTIME_ENV_KEYS) {
-    if (env2[key] !== void 0) snapshot[key] = env2[key];
-  }
-  const frozen = Object.freeze(snapshot);
-  globalThis[SNAPSHOT_KEY] = frozen;
-  return frozen;
+  const host = globalThis;
+  if (host[SNAPSHOT_KEY]) return host[SNAPSHOT_KEY];
+  if (!isReleaseControlPlane(env2)) return null;
+  const snapshot = Object.freeze({
+    config: parseAppReleaseRuntimeConfig(env2),
+    protectedSecrets: parseAppReleaseProtectedSecrets(env2)
+  });
+  host[SNAPSHOT_KEY] = snapshot;
+  return snapshot;
 }
-function appReleaseRuntimeEnv(explicit) {
-  return explicit ?? globalThis[SNAPSHOT_KEY] ?? process.env;
+function appReleaseRuntimeConfig(explicit) {
+  if (explicit) return parseAppReleaseRuntimeConfig(explicit);
+  return globalThis[SNAPSHOT_KEY]?.config ?? parseAppReleaseRuntimeConfig(process.env);
 }
-var SNAPSHOT_KEY, CAPTURE_SNAPSHOT_KEY, APP_RELEASE_RUNTIME_ENV_KEYS;
+var SNAPSHOT_KEY, CAPTURE_SNAPSHOT_KEY;
 var init_app_release_runtime_env = __esm({
   "../platform/src/app-release-runtime-env.ts"() {
     "use strict";
     SNAPSHOT_KEY = "__gencowAppReleaseRuntimeEnvSnapshot";
     CAPTURE_SNAPSHOT_KEY = "__gencowCaptureAppReleaseRuntimeEnvSnapshot";
-    APP_RELEASE_RUNTIME_ENV_KEYS = Object.freeze([
-      "GENCOW_APPS_DIR",
-      "GENCOW_PLATFORM_STORAGE_AZURE_ACCOUNT_NAME",
-      "GENCOW_PLATFORM_STORAGE_AZURE_CONTAINER",
-      "GENCOW_PLATFORM_STORAGE_AZURE_ENDPOINT",
-      "GENCOW_PLATFORM_STORAGE_AZURE_AUTH",
-      "GENCOW_PLATFORM_STORAGE_AZURE_CLIENT_ID",
-      "GENCOW_PLATFORM_STORAGE_AZURE_TENANT_ID",
-      "GENCOW_PLATFORM_STORAGE_AZURE_CLIENT_SECRET",
-      "GENCOW_PLATFORM_STORAGE_AZURE_PREFIX",
-      "GENCOW_RELEASE_VERSIONS_ENABLED",
-      "GENCOW_RELEASE_VERSIONS_ALLOWLIST",
-      "GENCOW_RELEASE_STORAGE_QUOTA_BYTES",
-      "GENCOW_RELEASE_STORAGE_ALLOW_FILESYSTEM",
-      "GENCOW_RELEASE_OBJECTS_DIR",
-      "GENCOW_SERVING_ROUTE_PUBLICATION_MODE",
-      "GENCOW_SERVING_ROUTE_PUBLICATION_ENVIRONMENT",
-      "GENCOW_SERVING_ROUTE_PUBLICATION_APP_ALLOWLIST",
-      "GENCOW_SERVING_ROUTE_TOPOLOGY_REVISION",
-      "GENCOW_SERVING_ROUTE_UPSERT_TARGET_SET_ID",
-      "GENCOW_SERVING_ROUTE_TOMBSTONE_TARGET_SET_ID",
-      "GENCOW_SERVING_ROUTE_ARTIFACT_QUOTA_BYTES",
-      "BASE_DOMAIN"
-    ]);
     globalThis[CAPTURE_SNAPSHOT_KEY] = captureAppReleaseRuntimeEnv;
   }
 });
@@ -423824,19 +423957,20 @@ function parseAllowlist(raw2) {
   return new Set(decoded);
 }
 function loadAppServingRouteRolloutConfig(input) {
-  const env2 = appReleaseRuntimeEnv(input.env);
-  const mode = env2.GENCOW_SERVING_ROUTE_PUBLICATION_MODE?.trim() || "off";
+  const config2 = input.runtimeConfig ?? appReleaseRuntimeConfig(input.env);
+  const route = config2.servingRoute;
+  const mode = route.publicationMode;
   if (mode === "off") return null;
   if (mode !== "enforce" || !Number.isSafeInteger(input.appId) || input.appId < 1) return fail30();
   const environment = input.deploymentEnvironment;
-  const configuredEnvironment = env2.GENCOW_SERVING_ROUTE_PUBLICATION_ENVIRONMENT?.trim();
-  const topologyRevision = env2.GENCOW_SERVING_ROUTE_TOPOLOGY_REVISION?.trim() ?? "";
-  const upsertTargetSetId = env2.GENCOW_SERVING_ROUTE_UPSERT_TARGET_SET_ID?.trim() ?? "";
-  const tombstoneTargetSetId = env2.GENCOW_SERVING_ROUTE_TOMBSTONE_TARGET_SET_ID?.trim() ?? "";
-  const allowlist3 = parseAllowlist(env2.GENCOW_SERVING_ROUTE_PUBLICATION_APP_ALLOWLIST);
+  const configuredEnvironment = route.environment ?? void 0;
+  const topologyRevision = route.topologyRevision ?? "";
+  const upsertTargetSetId = route.upsertTargetSetId ?? "";
+  const tombstoneTargetSetId = route.tombstoneTargetSetId ?? "";
+  const allowlist3 = parseAllowlist(route.appAllowlist ?? void 0);
   let baseDomain;
   try {
-    baseDomain = normalizeServingRouteHost(env2.BASE_DOMAIN?.trim() ?? "");
+    baseDomain = normalizeServingRouteHost(route.baseDomain ?? "");
   } catch {
     return fail30();
   }
@@ -424255,7 +424389,7 @@ function createRuntimeControlPlaneProductionAdapter(input) {
     getWarmPoolBackendImpl
   });
   async function isDurablySupersededDrainingStop(row) {
-    if (row.reason !== "deploy_replace" || row.state !== "draining" || !Number.isSafeInteger(row.port) || Number(row.port) <= 0) {
+    if (row.reason !== "deploy_replace" || !["serving", "draining"].includes(row.state) || !Number.isSafeInteger(row.port) || Number(row.port) <= 0) {
       return false;
     }
     try {
@@ -457356,6 +457490,10 @@ var SYSTEM_ENV_KEYS = [
   // Platform serving route tombstone target set
   "GENCOW_SERVING_ROUTE_ARTIFACT_QUOTA_BYTES",
   // serving artifact quota
+  "GENCOW_STATIC_ORIGIN_STAGE_ENABLED",
+  // Platform-only Static Origin rollout switch
+  "GENCOW_STATIC_ORIGIN_ARTIFACT_ROOT",
+  // Platform-only protected artifact root
   "GENCOW_BACKUP_RETENTION_V2_MODE",
   // platform backup retention rollout mode
   "GENCOW_BACKUP_RETENTION_V2_EFFECTIVE_AT",

package/templateFeature/memory/manifest.json

@@ -12,6 +12,7 @@
   ],
   "env": {},
   "indexImports": [],
+  "setup": "memory-wiring",
   "guide": [
     "Use gencow/memory.ts through the createMemory({ extractionModel, embeddingProfile }) factory or the default memory singleton.",
     "Pure AI SDK: createMemory({ extractionModel: gencow.languageModel(\"gpt-5.4-mini\"), embeddingProfile: MEMORY_EMBEDDING_PROFILE })",

package/templates/ai-chat/schema.ts

@@ -11,6 +11,8 @@ import { pgTable } from "drizzle-orm/pg-core";
 import { serial, text, timestamp } from "drizzle-orm/pg-core";
 import { account, authRelationsConfig, session, user, verification } from "./schema-auth";
 
+export * from "./schema-memory";
+
 export const conversations = pgTable(
   "conversations",
   {