create-oke 0.18.4 → 0.19.0

package/src/ai-setup/apply.ts

@@ -4,12 +4,17 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { OLLAMA_IMAGE } from "../drivers-catalog.ts";
 import { extractImages, findImagesBlock, replaceImagesBlock } from "../transform.ts";
+import { CLOUD_PROVIDERS } from "./catalog.ts";
 
 /** Choices applied to the project. */
 export type AiSetupApplyInput = {
-  readonly driver: "ollama" | "anthropic" | "openai-compatible" | "mock";
+  readonly driver: "anthropic" | "openai-compatible" | "mock";
+  /**
+   * Name written to `ai.model({ provider })` — registry id (`openrouter`,
+   * `openai`, …), or `openai-compatible` / `local` for self-hosted.
+   */
+  readonly provider?: string;
   readonly baseUrl?: string;
   readonly chatModel?: string;
   readonly visionModel?: string | null;
@@ -17,7 +22,7 @@ export type AiSetupApplyInput = {
   readonly apiKeyEnv?: string;
   /** When set with {@link apiKeyEnv}, writes the token into `.env.local`. */
   readonly apiKey?: string;
-  /** Optional `images.ai` pin (llama.cpp / Ollama / vLLM / SGLang). */
+  /** Optional `images.ai` pin (legacy; cloud / custom / lmstudio leave unset). */
   readonly image?: string;
 };
 
@@ -57,8 +62,9 @@ export function applyAiSetup(
     config = upsertAiDrivers(config, input.driver);
     if (input.image) {
       config = upsertImage(config, "ai", input.image);
-    } else if (input.driver === "ollama") {
-      config = upsertImage(config, "ai", OLLAMA_IMAGE);
+    } else {
+      // Cloud / host-side providers must not leave a leftover `images.ai` pin.
+      config = removeImage(config, "ai");
     }
     writeFileSync(configPath, config, "utf8");
   }
@@ -93,10 +99,135 @@ export function applyAiSetup(
   writeFileSync(envPath, env.endsWith("\n") ? env : `${env}\n`, "utf8");
 
   const aiTsPath = writeAiModels(cwd, input);
+  if (input.apiKeyEnv) {
+    ensureAiApiKeyVaultSecret(cwd, input.apiKeyEnv);
+  }
+
+  if (input.embedModel) {
+    ensureHybridSearchEmbedWiring(cwd);
+  }
 
   return { configPath, envPath, aiTsPath };
 }
 
+/** Default dims for nomic-embed-text (starter / local RAG default). */
+export const DEFAULT_SEARCH_EMBED_DIMS = 768;
+
+/**
+ * When AI setup includes an embed model, wire Notes hybrid search:
+ * - `body: …searchable().embed()` in `schema.decl.ts`
+ * - `oke({ store: { search: { embed: { model: embedModel, dims } } } })` in `app.ts`
+ *
+ * Idempotent — safe to re-run.
+ *
+ * @param cwd - Project root
+ * @param dims - Vector dimensionality (default {@link DEFAULT_SEARCH_EMBED_DIMS})
+ */
+export function ensureHybridSearchEmbedWiring(
+  cwd: string,
+  dims: number = DEFAULT_SEARCH_EMBED_DIMS,
+): void {
+  const declPath = join(cwd, "src", "db", "schema.decl.ts");
+  if (existsSync(declPath)) {
+    const prev = readFileSync(declPath, "utf8");
+    const next = ensureNotesBodyEmbed(prev);
+    if (next !== prev) writeFileSync(declPath, next, "utf8");
+  }
+
+  const appPath = join(cwd, "src", "app.ts");
+  if (existsSync(appPath)) {
+    const prev = readFileSync(appPath, "utf8");
+    const next = ensureAppStoreSearchEmbed(prev, dims);
+    if (next !== prev) writeFileSync(appPath, next, "utf8");
+  }
+}
+
+/**
+ * Ensure the Notes `body` column chains bare `.embed()` after `.searchable()`.
+ *
+ * @param source - `schema.decl.ts` source
+ */
+export function ensureNotesBodyEmbed(source: string): string {
+  if (/\bbody:\s*field\.[\s\S]*?\.embed\s*\(/.test(source)) return source;
+  // Prefer exact Notes starter shapes, then a generic searchable body line.
+  const patterns: RegExp[] = [
+    /(body:\s*field\.text\(\)\.searchable\(\))\s*(\.notNull\(\))?/,
+    /(body:\s*field\.text\(\)\.searchable\(\{[^}]*\}\))\s*(\.notNull\(\))?/,
+    /(body:\s*field\.text\(\))\s*(\.notNull\(\))?/,
+  ];
+  for (const re of patterns) {
+    if (!re.test(source)) continue;
+    return source.replace(re, (_m, head: string, notNull?: string) => {
+      const mid = /\.searchable\s*\(/.test(head)
+        ? `${head}.embed()`
+        : `${head}.searchable().embed()`;
+      return `${mid}${notNull ?? ""}`;
+    });
+  }
+  return source;
+}
+
+/**
+ * Stamp project default `store.search.embed` on `oke({…})` and import `embedModel`.
+ *
+ * @param source - `src/app.ts` source
+ * @param dims - Embedding dimensionality
+ */
+export function ensureAppStoreSearchEmbed(source: string, dims: number): string {
+  if (/store\s*:\s*\{[\s\S]*?search\s*:\s*\{[\s\S]*?embed\s*:/.test(source)) {
+    return source;
+  }
+
+  let next = source;
+  if (!/\bembedModel\b/.test(next)) {
+    if (/import\s*\{([^}]*)\}\s*from\s*["']@\/core["']/.test(next)) {
+      next = ensureNamedImportFrom(next, "@/core", "embedModel");
+    } else {
+      next = `import { embedModel } from "@/core";\n${next}`;
+    }
+  }
+
+  const simple = /oke\(\s*\{\s*name:\s*(["'])([^"']+)\1\s*\}\s*\)/;
+  if (simple.test(next)) {
+    return next.replace(
+      simple,
+      (_m, q: string, name: string) =>
+        `oke({\n  name: ${q}${name}${q},\n  store: {\n    search: {\n      embed: { model: embedModel, dims: ${dims} },\n    },\n  },\n})`,
+    );
+  }
+
+  // oke({ name: "…", …other }) — inject store before the closing `}`.
+  const named = /oke\(\s*\{([\s\S]*?)\}\s*\)/;
+  const m = named.exec(next);
+  if (!m) return next;
+  const body = m[1] ?? "";
+  if (/^\s*store\s*:/m.test(body)) return next;
+  const injected = `${body.trimEnd().replace(/,?\s*$/, "")},\n  store: {\n    search: {\n      embed: { model: embedModel, dims: ${dims} },\n    },\n  },\n`;
+  return next.replace(named, `oke({${injected}})`);
+}
+
+/**
+ * Add a named binding to an existing `import { … } from "<mod>"`.
+ *
+ * @param source - Module source
+ * @param mod - Module specifier
+ * @param name - Binding to add
+ */
+function ensureNamedImportFrom(source: string, mod: string, name: string): string {
+  const re = new RegExp(
+    `import\\s*\\{([^}]*)\\}\\s*from\\s*["']${mod.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*;`,
+  );
+  const m = re.exec(source);
+  if (!m) return `import { ${name} } from "${mod}";\n${source}`;
+  const names = m[1]!
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (names.includes(name)) return source;
+  const sorted = [...names, name].sort((a, b) => a.localeCompare(b));
+  return source.replace(re, `import { ${sorted.join(", ")} } from "${mod}";`);
+}
+
 /**
  * @param source - oke.config.ts
  * @param driver - AI driver id
@@ -140,6 +271,20 @@ export function upsertImage(source: string, key: string, image: string): string
   return replaceImagesBlock(source, images);
 }
 
+/**
+ * Drop one dotted role's image pin (e.g. clear `images.ai` for cloud AI).
+ *
+ * @param source - Config source
+ * @param key - Image role
+ */
+export function removeImage(source: string, key: string): string {
+  if (!findImagesBlock(source)) return source;
+  const images = { ...extractImages(source) };
+  if (!(key in images)) return source;
+  delete images[key];
+  return replaceImagesBlock(source, images);
+}
+
 /** Options for {@link upsertEnv}. */
 export type UpsertEnvOptions = {
   /**
@@ -178,34 +323,39 @@ export function upsertEnv(
  */
 export function renderAiTs(input: AiSetupApplyInput): string {
   const chat = input.chatModel ?? "default";
-  const provider =
-    input.driver === "ollama"
-      ? "ollama"
-      : input.driver === "anthropic"
-        ? "anthropic"
-        : input.driver === "mock"
-          ? "mock"
-          : "openai-compatible";
+  const provider = resolveDeclProvider(input);
+  const apiKeyEnv = input.apiKeyEnv;
+  const registryCloud = isRegistryCloudProvider(provider);
+  const nativeAnthropic = input.driver === "anthropic";
+  const localPrimary = isSelfHostedLocal(input);
 
-  const lines = [
-    `import { ai } from "okengine";`,
-    ``,
-    `/** Cloud OpenAI-compatible binding (OpenAI / Groq / OpenRouter / …). */`,
+  const smartLines = [
     `export const smart = ai.model("smart", {`,
     `  provider: "${provider}",`,
+    ...(nativeAnthropic ? [`  driverId: "anthropic",`] : []),
     `  model: process.env.OKE_AI_CLOUD_MODEL ?? process.env.OKE_AI_MODEL ?? "${chat}",`,
-    `  baseUrl: process.env.OPENAI_BASE_URL?.trim() || "https://api.openai.com/v1",`,
-    `  ...(process.env.OPENAI_API_KEY?.trim()`,
-    `    ? { apiKey: process.env.OPENAI_API_KEY.trim() }`,
-    `    : {}),`,
+    ...smartBaseUrlLines(input, { registryCloud, localPrimary }),
+    ...apiKeySpreadLines(apiKeyEnv),
     `});`,
-    ``,
-    `/** Local inference binding (docker llama.cpp / Ollama via \`OKE_AI_URL\`). */`,
+  ];
+
+  const localDefaultModel = localPrimary ? chat : "local-model";
+  const localLines = [
     `export const local = ai.model("local", {`,
-    `  provider: "${provider === "ollama" ? "ollama" : "openai-compatible"}",`,
-    `  model: process.env.OKE_AI_LOCAL_MODEL ?? "${chat}",`,
+    `  provider: "openai-compatible",`,
+    `  model: process.env.OKE_AI_LOCAL_MODEL ?? "${localDefaultModel}",`,
     `  ...(process.env.OKE_AI_URL?.trim() ? { baseUrl: process.env.OKE_AI_URL.trim() } : {}),`,
     `});`,
+  ];
+
+  const lines = [
+    `import { ai } from "okengine";`,
+    ``,
+    `/** Primary model binding (${provider}). */`,
+    ...smartLines,
+    ``,
+    `/** Local OpenAI-compatible binding (via \`OKE_AI_URL\`). */`,
+    ...localLines,
     ``,
     `/** Advanced Notes summarize — used by \`notes.summarize\` via \`fx.ask\`. */`,
     `export const summarizeNote = smart.prompt("summarize-note", {`,
@@ -219,7 +369,9 @@ export function renderAiTs(input: AiSetupApplyInput): string {
       ``,
       `export const vision = ai.model("vision", {`,
       `  provider: "${provider}",`,
+      ...(nativeAnthropic ? [`  driverId: "anthropic",`] : []),
       `  model: process.env.OKE_AI_VISION_MODEL ?? "${input.visionModel}",`,
+      ...apiKeySpreadLines(apiKeyEnv),
       `});`,
     );
   }
@@ -227,11 +379,14 @@ export function renderAiTs(input: AiSetupApplyInput): string {
   if (input.embedModel) {
     lines.push(
       ``,
+      `/** Embedding model — also the project default via \`oke({ store: { search: { embed } } })\`. */`,
       `export const embedModel = ai.model("embed", {`,
       `  provider: "${provider}",`,
       `  model: process.env.OKE_AI_EMBED_MODEL ?? "${input.embedModel}",`,
+      ...apiKeySpreadLines(apiKeyEnv),
       `});`,
       ``,
+      `/** Index-facet embed pipeline (Meilisearch / pgvector) — separate from SQL \`.embed()\`. */`,
       `export const docsEmbed = ai.embed("docs", { model: embedModel });`,
     );
   }
@@ -240,6 +395,176 @@ export function renderAiTs(input: AiSetupApplyInput): string {
   return `${lines.join("\n")}\n`;
 }
 
+/**
+ * Provider string for generated `ai.model` declarations.
+ *
+ * @param input - Setup choices
+ */
+export function resolveDeclProvider(input: AiSetupApplyInput): string {
+  if (input.provider !== undefined && input.provider.length > 0) return input.provider;
+  if (input.driver === "anthropic") return "anthropic";
+  if (input.driver === "mock") return "mock";
+  return "openai-compatible";
+}
+
+function isRegistryCloudProvider(provider: string): boolean {
+  return CLOUD_PROVIDERS.some(
+    (p) => (p.provider ?? p.value) === provider && p.driver === "openai-compatible" && p.baseUrl,
+  );
+}
+
+function isSelfHostedLocal(input: AiSetupApplyInput): boolean {
+  return input.image !== undefined;
+}
+
+function smartBaseUrlLines(
+  input: AiSetupApplyInput,
+  flags: { readonly registryCloud: boolean; readonly localPrimary: boolean },
+): string[] {
+  if (input.driver === "anthropic") {
+    return [];
+  }
+  if (flags.registryCloud) {
+    return [
+      `  ...(process.env.OPENAI_BASE_URL?.trim() ? { baseUrl: process.env.OPENAI_BASE_URL.trim() } : {}),`,
+    ];
+  }
+  if (flags.localPrimary) {
+    return [
+      `  ...(process.env.OKE_AI_URL?.trim() ? { baseUrl: process.env.OKE_AI_URL.trim() } : {}),`,
+    ];
+  }
+  if (input.baseUrl) {
+    return [`  baseUrl: process.env.OPENAI_BASE_URL?.trim() || ${JSON.stringify(input.baseUrl)},`];
+  }
+  return [
+    `  ...(process.env.OPENAI_BASE_URL?.trim() ? { baseUrl: process.env.OPENAI_BASE_URL.trim() } : {}),`,
+  ];
+}
+
+function apiKeySpreadLines(apiKeyEnv: string | undefined): string[] {
+  if (!apiKeyEnv) return [];
+  return [
+    `  ...(process.env.${apiKeyEnv}?.trim()`,
+    `    ? { apiKey: process.env.${apiKeyEnv}.trim() }`,
+    `    : {}),`,
+  ];
+}
+
+/**
+ * `OPENROUTER_API_KEY` → `openrouterApiKey`.
+ *
+ * @param envName - Env / vault contract name
+ */
+export function envNameToCamelBinding(envName: string): string {
+  const parts = envName
+    .toLowerCase()
+    .split(/_+/g)
+    .filter((p) => p.length > 0);
+  if (parts.length === 0) return "apiKey";
+  return parts
+    .map((part, i) => (i === 0 ? part : `${part[0]!.toUpperCase()}${part.slice(1)}`))
+    .join("");
+}
+
+/**
+ * Human description for a provider API key env.
+ *
+ * @param envName - Env / vault contract name
+ */
+export function apiKeyEnvDescription(envName: string): string {
+  const meta = CLOUD_PROVIDERS.find((p) => p.apiKeyEnv === envName);
+  if (meta) return `${meta.label} API key`;
+  const stem = envName.replace(/_API_KEY$/i, "").replace(/_/g, " ");
+  return `${stem} API key`;
+}
+
+/**
+ * Render a `vault.secret` block for an AI provider key (no `dev:` stub so
+ * missing values become Vault boot gaps on `oke dev`).
+ *
+ * @param apiKeyEnv - Env / contract name
+ */
+export function renderAiApiKeyVaultSecret(apiKeyEnv: string): string {
+  const binding = envNameToCamelBinding(apiKeyEnv);
+  const description = apiKeyEnvDescription(apiKeyEnv);
+  return `/** ${description} — no \`dev:\` stub so first \`oke dev\` asks via Vault gaps. */
+export const ${binding} = vault.secret(${JSON.stringify(apiKeyEnv)}, {
+  description: ${JSON.stringify(description)},
+  rotate: "90d",
+});
+`;
+}
+
+/**
+ * True when `source` already declares `vault.secret("ENV")` (or `vault("ENV")`).
+ *
+ * @param source - TypeScript source
+ * @param apiKeyEnv - Contract name
+ */
+export function hasAiApiKeyVaultSecret(source: string, apiKeyEnv: string): boolean {
+  const lit = apiKeyEnv.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\bvault(?:\\.secret)?\\s*\\(\\s*["']${lit}["']`).test(source);
+}
+
+/**
+ * Merge a vault.secret contract for the AI API key into core / vault sources.
+ *
+ * When a `NOTES_VAULT` / `KEEL_VAULT` array exists, inserts the binding there
+ * too so `oke({ secrets })` keeps the new contract.
+ *
+ * @param existing - Current module source
+ * @param apiKeyEnv - Env / contract name
+ */
+export function mergeAiApiKeyVaultSecret(existing: string, apiKeyEnv: string): string {
+  if (hasAiApiKeyVaultSecret(existing, apiKeyEnv)) return existing;
+  let next = ensureNamedOkengineImport(existing, "vault");
+  const block = renderAiApiKeyVaultSecret(apiKeyEnv);
+  const binding = envNameToCamelBinding(apiKeyEnv);
+  const vaultList = /\bexport const (NOTES_VAULT|KEEL_VAULT)\s*=\s*\[/;
+  if (vaultList.test(next)) {
+    next = next.replace(vaultList, `${block}\n$&`);
+    next = next.replace(
+      /(export const (?:NOTES_VAULT|KEEL_VAULT)\s*=\s*\[\s*\n)/,
+      `$1  ${binding},\n`,
+    );
+    return next;
+  }
+  const vaultHeading = /(\/\/ --- Vault[^\n]*\n)/;
+  if (vaultHeading.test(next)) {
+    return next.replace(vaultHeading, `$1\n${block}`);
+  }
+  const aiHeading = /(\/\/ --- AI[^\n]*\n)/;
+  if (aiHeading.test(next)) {
+    return next.replace(aiHeading, `${block}\n$1`);
+  }
+  return `${next.trimEnd()}\n\n${block}`;
+}
+
+/**
+ * Declare `vault.secret(apiKeyEnv)` in the project so missing keys surface as
+ * Vault gaps (and Console Vault) — never silently optional.
+ *
+ * Prefers `src/core/vault.ts`, then `src/vault.ts`, else merges into `src/core.ts`.
+ *
+ * @param cwd - Project root
+ * @param apiKeyEnv - Env / contract name
+ */
+export function ensureAiApiKeyVaultSecret(cwd: string, apiKeyEnv: string): void {
+  const candidates = [
+    join(cwd, "src", "core", "vault.ts"),
+    join(cwd, "src", "vault.ts"),
+    join(cwd, "src", "core.ts"),
+  ] as const;
+  for (const path of candidates) {
+    if (!existsSync(path)) continue;
+    const prev = readFileSync(path, "utf8");
+    const next = mergeAiApiKeyVaultSecret(prev, apiKeyEnv);
+    if (next !== prev) writeFileSync(path, next, "utf8");
+    return;
+  }
+}
+
 /**
  * Write AI model declarations into `src/core/ai.ts` when that split exists
  * (so a thin `src/core.ts` barrel stays a re-export), else `src/core.ts`,
@@ -257,14 +582,7 @@ function writeAiModels(cwd: string, input: AiSetupApplyInput): string {
 
   if (existsSync(coreAiPath)) {
     const existing = readFileSync(coreAiPath, "utf8");
-    if (hasAiModels(existing)) {
-      const withPrompt = ensureSummarizeNotePrompt(existing);
-      if (withPrompt !== existing) {
-        writeFileSync(coreAiPath, withPrompt, "utf8");
-      }
-    } else {
-      writeFileSync(coreAiPath, mergeAiIntoCore(existing, rendered), "utf8");
-    }
+    writeFileSync(coreAiPath, resolveAiCoreSource(existing, rendered), "utf8");
     ensureCoreBarrelExportsAi(cwd);
     ensureCoreImported(cwd);
     return coreAiPath;
@@ -282,14 +600,7 @@ function writeAiModels(cwd: string, input: AiSetupApplyInput): string {
   mkdirSync(dirname(coreTsPath), { recursive: true });
   if (existsSync(coreTsPath)) {
     const existing = readFileSync(coreTsPath, "utf8");
-    if (hasAiModels(existing)) {
-      const withPrompt = ensureSummarizeNotePrompt(existing);
-      if (withPrompt !== existing) {
-        writeFileSync(coreTsPath, withPrompt, "utf8");
-      }
-      return coreTsPath;
-    }
-    writeFileSync(coreTsPath, mergeAiIntoCore(existing, rendered), "utf8");
+    writeFileSync(coreTsPath, resolveAiCoreSource(existing, rendered), "utf8");
   } else {
     writeFileSync(coreTsPath, rendered, "utf8");
   }
@@ -297,17 +608,82 @@ function writeAiModels(cwd: string, input: AiSetupApplyInput): string {
   return coreTsPath;
 }
 
+/**
+ * Decide whether to merge a full AI module, repair a broken stub, or only
+ * backfill `local` / `summarizeNote` on an already-complete core.
+ *
+ * @param existing - Current core / AI sidecar source
+ * @param rendered - Output of {@link renderAiTs}
+ */
+export function resolveAiCoreSource(existing: string, rendered: string): string {
+  if (isIncompleteAiSetup(existing)) {
+    return mergeAiIntoCore(stripIncompleteAiExports(existing), rendered);
+  }
+  if (hasAiModels(existing)) {
+    return ensureSummarizeNotePrompt(existing);
+  }
+  return mergeAiIntoCore(existing, rendered);
+}
+
 /**
  * @param source - Existing TypeScript
  */
 function hasAiModels(source: string): boolean {
+  // Require real exports — template comments like `//   ai.model("smart", …)`
+  // must not look like an already-configured core.
   return (
-    /\bai\.model\s*\(/.test(source) ||
+    /\bexport\s+const\s+(?:smart|local|vision|embedModel)\s*=\s*ai\.model\s*\(/.test(source) ||
     /from\s+["']\.\/(?:core\/)?ai["']/.test(source) ||
     /import\s+["']\.\/(?:core\/)?ai["']/.test(source)
   );
 }
 
+/**
+ * True when prior AI setup left unusable stubs (e.g. `local` + `summarizeNote`
+ * without `smart` / without an `ai` import — the old comment-as-configured bug).
+ *
+ * @param source - Existing TypeScript
+ */
+export function isIncompleteAiSetup(source: string): boolean {
+  const hasAiImport = /import\s*\{[^}]*\bai\b[^}]*\}\s*from\s*["']okengine["']/.test(source);
+  const hasSmart = /\bexport\s+const\s+smart\s*=\s*ai\.model\s*\(/.test(source);
+  const hasLocal = /\bexport\s+const\s+local\s*=\s*ai\.model\s*\(/.test(source);
+  const hasSummarize = /\bexport\s+const\s+summarizeNote\s*=/.test(source);
+  const hasAnyModel =
+    /\bexport\s+const\s+(?:smart|local|vision|embedModel)\s*=\s*ai\.model\s*\(/.test(source);
+  if (hasAnyModel && !hasAiImport) return true;
+  if ((hasLocal || hasSummarize) && !hasSmart) return true;
+  return false;
+}
+
+/**
+ * Remove partial AI exports so {@link mergeAiIntoCore} can rewrite a full set.
+ *
+ * @param source - Existing TypeScript
+ */
+export function stripIncompleteAiExports(source: string): string {
+  let next = source;
+  next = next.replace(
+    /(?:\/\*\*[^*]*\*+(?:[^/*][^*]*\*+)*\/\s*)?export\s+const\s+local\s*=\s*ai\.model\s*\(\s*["']local["']\s*,\s*\{[\s\S]*?\}\s*\)\s*;\s*/g,
+    "",
+  );
+  next = next.replace(
+    /(?:\/\*\*[^*]*\*+(?:[^/*][^*]*\*+)*\/\s*)?export\s+const\s+summarizeNote\s*=\s*smart\.prompt\s*\([\s\S]*?\}\s*\)\s*;\s*/g,
+    "",
+  );
+  if (!/\bexport\s+const\s+smart\s*=\s*ai\.model\s*\(/.test(next)) {
+    next = next.replace(
+      /(?:\/\*\*[^*]*\*+(?:[^/*][^*]*\*+)*\/\s*)?export\s+const\s+(?:vision|embedModel)\s*=\s*ai\.model\s*\([\s\S]*?\}\s*\)\s*;\s*/g,
+      "",
+    );
+    next = next.replace(
+      /(?:\/\*\*[^*]*\*+(?:[^/*][^*]*\*+)*\/\s*)?export\s+const\s+docsEmbed\s*=\s*ai\.embed\s*\([\s\S]*?\}\s*\)\s*;\s*/g,
+      "",
+    );
+  }
+  return next.replace(/\n{3,}/g, "\n\n");
+}
+
 /**
  * Append the advanced Notes `summarize-note` prompt when a `smart` model
  * exists but the prompt was never declared (common after older `--ai` runs).
@@ -316,24 +692,26 @@ function hasAiModels(source: string): boolean {
  */
 export function ensureSummarizeNotePrompt(source: string): string {
   let next = source;
-  if (
-    !/\bai\.model\s*\(\s*["']local["']/.test(next) &&
-    /\bai\.model\s*\(\s*["']smart["']/.test(next)
-  ) {
+  const hasSmartExport = /\bexport\s+const\s+smart\s*=/.test(next);
+  const hasLocalExport = /\bexport\s+const\s+local\s*=/.test(next);
+  if (!hasLocalExport && hasSmartExport) {
     next = `${next.trimEnd()}
 
-/** Local inference binding (docker llama.cpp / Ollama via \`OKE_AI_URL\`). */
+/** Local OpenAI-compatible binding (via \`OKE_AI_URL\`). */
 export const local = ai.model("local", {
   provider: "openai-compatible",
-  model: process.env.OKE_AI_LOCAL_MODEL ?? "granite3.3:2b",
+  model: process.env.OKE_AI_LOCAL_MODEL ?? "local-model",
   ...(process.env.OKE_AI_URL?.trim() ? { baseUrl: process.env.OKE_AI_URL.trim() } : {}),
 });
 `;
   }
-  if (/summarize-note/.test(next) || /summarizeNote/.test(next)) {
-    return next;
+  const hasSummarizeExport =
+    /\bexport\s+const\s+summarizeNote\s*=/.test(next) ||
+    /\.prompt\s*\(\s*["']summarize-note["']/.test(next);
+  if (hasSummarizeExport) {
+    return next === source ? next : ensureNamedOkengineImport(next, "ai");
   }
-  if (!/\bai\.model\s*\(\s*["']smart["']/.test(next)) {
+  if (!hasSmartExport) {
     return next;
   }
   const prompt = `
@@ -343,7 +721,7 @@ export const summarizeNote = smart.prompt("summarize-note", {
   timeout: "30s",
 });
 `;
-  return `${next.trimEnd()}\n${prompt}\n`;
+  return ensureNamedOkengineImport(`${next.trimEnd()}\n${prompt}\n`, "ai");
 }
 
 /**