okengine 0.9.0 → 0.10.0

package/src/cli/ai-setup/recommend.test.ts

@@ -1,76 +1,99 @@
 /**
- * Smart Ollama recommendation scoring + RAM tier rules.
+ * Smart Ollama recommendation — RAM tiers (no needs quiz).
  */
 
 import { describe, expect, test } from "bun:test";
-import { recommendChatModel } from "./catalog.ts";
+import {
+  LLAMA_CPP_CHAT_MODELS,
+  llamaCppModelsForTier,
+  modelsForTier,
+  recommendChatModel,
+  recommendForTier,
+  recommendLlamaCppForTier,
+} from "./catalog.ts";
 import {
   fittingChatModels,
-  formatMachineSummary,
+  formatLlamaCppBanner,
+  formatModelRow,
+  formatModelTableHeader,
+  formatOllamaBanner,
   isTightFit,
   modelFitsComfortably,
   modelFitsOnMachine,
   recommendChatForNeeds,
-  type AiNeeds,
+  suggestTierForRam,
+  usableRamGb,
 } from "./recommend.ts";
 
-const balanced: AiNeeds = {
-  useCase: "balanced",
-  priority: "balanced",
-  wantVision: false,
-};
-
 describe("modelFitsOnMachine", () => {
   test("catalog ramGb is machine tier, not download size", () => {
-    expect(modelFitsOnMachine({ id: "x", label: "x", hint: "", role: "chat", ramGb: 16 }, 24)).toBe(
-      true,
-    );
-    expect(modelFitsOnMachine({ id: "x", label: "x", hint: "", role: "chat", ramGb: 32 }, 24)).toBe(
-      false,
-    );
+    expect(
+      modelFitsOnMachine(
+        {
+          id: "x",
+          label: "x",
+          hint: "",
+          role: "chat",
+          ramGb: 16,
+          tier: "balanced",
+          modalities: ["text"],
+        },
+        24,
+      ),
+    ).toBe(true);
+    expect(
+      modelFitsOnMachine(
+        {
+          id: "x",
+          label: "x",
+          hint: "",
+          role: "chat",
+          ramGb: 32,
+          tier: "smart",
+          modalities: ["text"],
+        },
+        24,
+      ),
+    ).toBe(false);
   });
 });
 
-describe("recommendChatForNeeds", () => {
-  test("8GB → entry-level only", () => {
-    const pick = recommendChatForNeeds(8, balanced);
-    expect(pick.id).toBe("gemma4:e4b");
-    expect(pick.ramGb).toBeLessThanOrEqual(8);
+describe("tiers", () => {
+  test("each tier exposes up to 10 models", () => {
+    for (const tier of ["ultra-fast", "fast", "balanced", "smart"] as const) {
+      expect(modelsForTier(tier).length).toBeGreaterThan(0);
+      expect(modelsForTier(tier).length).toBeLessThanOrEqual(10);
+    }
   });
 
-  test("16GB → never recommends 27b / 32GB-class", () => {
-    const pick = recommendChatForNeeds(16, { ...balanced, useCase: "coding", priority: "quality" });
-    expect(pick.ramGb).toBeLessThanOrEqual(16);
-    expect(pick.id).not.toBe("qwen3.5:27b");
+  test("suggestTierForRam maps fit budget", () => {
+    expect(suggestTierForRam(4)).toBe("ultra-fast");
+    expect(suggestTierForRam(8)).toBe("fast");
+    expect(suggestTierForRam(16)).toBe("balanced");
+    expect(suggestTierForRam(32)).toBe("smart");
   });
 
-  test("24GB does not treat full RAM as model size", () => {
-    const pick = recommendChatForNeeds(24, balanced);
-    // Must leave headroom — not a fictional "24GB model"
-    expect(pick.ramGb).toBeLessThan(24);
-    expect(pick.ramGb).toBeLessThanOrEqual(16);
-    const summary = formatMachineSummary(24, pick);
-    expect(summary).toContain("Your machine: ~24GB");
-    expect(summary).toContain(`${pick.ramGb}GB-class`);
-    expect(summary).not.toMatch(/download a 24GB/i);
+  test("recommendForTier returns a model in that tier", () => {
+    const pick = recommendForTier("fast", 16);
+    expect(pick.tier).toBe("fast");
+  });
+});
+
+describe("recommendChatForNeeds", () => {
+  test("8GB → ultra-fast or fast entry", () => {
+    const pick = recommendChatForNeeds(8);
+    expect(pick.ramGb).toBeLessThanOrEqual(8);
   });
 
-  test("coding preference leans Qwen when it fits", () => {
-    const pick = recommendChatForNeeds(24, {
-      useCase: "coding",
-      priority: "balanced",
-      wantVision: false,
-    });
-    expect(pick.id.startsWith("qwen")).toBe(true);
+  test("16GB → never recommends 32GB-class", () => {
+    const pick = recommendChatForNeeds(16);
+    expect(pick.ramGb).toBeLessThanOrEqual(16);
+    expect(pick.id).not.toBe("qwen3.5:27b");
   });
 
-  test("reasoning preference leans DeepSeek when it fits", () => {
-    const pick = recommendChatForNeeds(16, {
-      useCase: "reasoning",
-      priority: "balanced",
-      wantVision: false,
-    });
-    expect(pick.id).toContain("deepseek");
+  test("24GB leaves headroom", () => {
+    const pick = recommendChatForNeeds(24);
+    expect(pick.ramGb).toBeLessThanOrEqual(usableRamGb(24));
   });
 });
 
@@ -92,9 +115,86 @@ describe("comfortable vs tight", () => {
 
 describe("recommendChatModel", () => {
   test("respects tiers with headroom preference", () => {
-    expect(recommendChatModel(8).id).toBe("gemma4:e4b");
+    expect(recommendChatModel(8).ramGb).toBeLessThanOrEqual(8);
     expect(recommendChatModel(16).ramGb).toBeLessThanOrEqual(16);
     expect(recommendChatModel(24).ramGb).toBeLessThanOrEqual(16);
-    expect(recommendChatModel(null).recommended).toBe(true);
+  });
+});
+
+describe("formatOllamaBanner", () => {
+  test("shows OS · CPU · RAM · Fit RAM · detected — no comfortable list", () => {
+    const text = formatOllamaBanner({ osName: "macOS", cpuCount: 10, ramGb: 24 }, ["gemma4:e4b"]);
+    expect(text).toContain("OS macOS  ·  CPU 10  ·  RAM ~24GB RAM");
+    expect(text).toContain("Fit RAM ~20GB RAM");
+    expect(text).toContain("Detected local models");
+    expect(text).toContain("gemma4:e4b");
+    expect(text).not.toContain("Fits comfortably");
+    expect(text).toContain("Tiers  ·  Ultra Fast");
+  });
+});
+
+describe("llama.cpp catalog", () => {
+  test("each tier has ≥10 curated Docker Hub ai/ models (UI shows up to 20)", () => {
+    for (const tier of ["ultra-fast", "fast", "balanced", "smart"] as const) {
+      const all = LLAMA_CPP_CHAT_MODELS.filter((m) => m.tier === tier);
+      expect(all.length).toBeGreaterThanOrEqual(10);
+      const list = llamaCppModelsForTier(tier);
+      expect(list.length).toBeGreaterThanOrEqual(10);
+      expect(list.length).toBeLessThanOrEqual(20);
+      expect(list.length).toBe(Math.min(all.length, 20));
+      expect(list.every((m) => !m.id.startsWith("ai/"))).toBe(true);
+      for (let i = 1; i < list.length; i++) {
+        expect(list[i]!.ramGb).toBeGreaterThanOrEqual(list[i - 1]!.ramGb);
+      }
+    }
+  });
+
+  test("recommendLlamaCppForTier returns a model in that tier", () => {
+    expect(recommendLlamaCppForTier("ultra-fast", 8).id).toBe("smollm2");
+    expect(recommendLlamaCppForTier("fast", 16).tier).toBe("fast");
+  });
+
+  test("visible list surfaces Gemma 4 and Qwen", () => {
+    const ids = (tier: "fast" | "balanced" | "smart") =>
+      llamaCppModelsForTier(tier).map((m) => m.id);
+    expect(ids("fast").some((id) => id.startsWith("gemma4:"))).toBe(true);
+    expect(ids("fast").some((id) => id.startsWith("qwen"))).toBe(true);
+    expect(ids("balanced")).toContain("gemma4:e4b");
+    expect(ids("balanced").some((id) => id.startsWith("qwen3"))).toBe(true);
+    expect(ids("smart")).toContain("gemma4:31b");
+    expect(ids("smart").some((id) => id.startsWith("qwen"))).toBe(true);
+  });
+
+  test("formatLlamaCppBanner shows Docker Hub ai/ source — not Ollama detect", () => {
+    const text = formatLlamaCppBanner({ osName: "macOS", cpuCount: 10, ramGb: 24 });
+    expect(text).toContain("OS macOS  ·  CPU 10  ·  RAM ~24GB RAM");
+    expect(text).toContain("Fit RAM ~20GB RAM");
+    expect(text).toContain("Docker Hub ai/");
+    expect(text).not.toContain("Detected local models");
+    expect(text).toContain("Tiers  ·  Ultra Fast");
+  });
+});
+
+describe("formatModelRow", () => {
+  test("aligned Model | RAM | Caps columns", () => {
+    const row = formatModelRow({
+      id: "x",
+      label: "Gemma 4 4B",
+      hint: "",
+      role: "chat",
+      ramGb: 8,
+      tier: "fast",
+      modalities: ["text", "code"],
+    });
+    const header = formatModelTableHeader();
+    expect(header.startsWith("Model")).toBe(true);
+    expect(header).toContain("RAM");
+    expect(header).toContain("Caps");
+    // Caps column starts at the same offset as the header.
+    expect(row.indexOf("text")).toBe(header.indexOf("Caps"));
+    expect(row).toContain("Gemma 4 4B");
+    expect(row).toContain("≈8GB");
+    expect(row).toContain("text · code");
+    expect(row).not.toContain("  ·  ≈");
   });
 });

package/src/cli/ai-setup/recommend.ts

@@ -1,32 +1,21 @@
 /**
- * Smart local-model recommendations — machine-tier fit + use-case scoring.
+ * Machine fit helpers for local Ollama model picks.
  *
  * Catalog `ramGb` is the **recommended machine tier** for that model (not the
- * download size). A 24GB laptop must never be told it will "download a 24GB
- * model" — that number was machine RAM shown in the wrong place.
- *
- * Most dev machines are 8–16GB. Prefer picks that leave ~4GB for OS / IDE /
- * browser when several models fit.
+ * download size). Prefer picks that leave ~4GB for OS / IDE / browser.
  */
 
-import { CHAT_MODELS, VISION_MODELS, type CatalogModel } from "./catalog.ts";
+import {
+  CHAT_MODELS,
+  MODEL_TIERS,
+  type CatalogModel,
+  type ModelTier,
+  recommendForTier,
+} from "./catalog.ts";
 
 /** Reserved for OS + IDE + browser while the model runs. */
 export const OS_HEADROOM_GB = 4;
 
-/** What the developer mainly wants from the local model. */
-export type AiUseCase = "coding" | "general" | "reasoning" | "balanced";
-
-/** Speed vs quality preference. */
-export type AiPriority = "speed" | "balanced" | "quality";
-
-/** Answers from the short Ollama questionnaire. */
-export type AiNeeds = {
-  readonly useCase: AiUseCase;
-  readonly priority: AiPriority;
-  readonly wantVision: boolean;
-};
-
 /**
  * RAM left after reserving OS/IDE headroom.
  *
@@ -60,7 +49,6 @@ export function modelFitsComfortably(model: CatalogModel, totalRamGb: number | n
     return Boolean(model.recommended);
   }
   const smallest = [...CHAT_MODELS].sort((a, b) => a.ramGb - b.ramGb)[0]!;
-  // Always allow the entry-level model on machines that meet its tier.
   if (model.id === smallest.id) return model.ramGb <= totalRamGb;
   return model.ramGb + OS_HEADROOM_GB <= totalRamGb;
 }
@@ -101,103 +89,132 @@ export function comfortableChatModels(totalRamGb: number | null): readonly Catal
 }
 
 /**
- * Score a fitting chat model for the user's needs (higher = better).
+ * Suggest a tier for the machine's fit RAM budget.
  *
- * @param model - Candidate
- * @param needs - Questionnaire answers
- * @param totalRamGb - Machine RAM (tight-fit penalty)
+ * @param totalRamGb - Machine RAM
  */
-export function scoreChatModel(
-  model: CatalogModel,
-  needs: AiNeeds,
-  totalRamGb: number | null = null,
-): number {
-  let score = 0;
-  if (needs.priority === "speed") score += 100 - model.ramGb * 3;
-  else if (needs.priority === "quality") score += model.ramGb * 4;
-  else score += model.ramGb * 2;
-
-  if (needs.useCase === "coding") {
-    if (model.id.startsWith("qwen")) score += 40;
-    if (model.id.includes("deepseek")) score += 15;
-  } else if (needs.useCase === "reasoning") {
-    if (model.id.includes("deepseek") || model.id.includes("r1")) score += 45;
-    if (model.id.startsWith("qwen")) score += 20;
-  } else if (needs.useCase === "general") {
-    if (model.id.includes("llama") || model.id.includes("gemma")) score += 35;
-    if (model.id.startsWith("qwen")) score += 20;
-  } else {
-    if (model.recommended) score += 25;
-    if (model.id.startsWith("qwen3.5:9b")) score += 30;
-    if (model.id.startsWith("gemma")) score += 20;
-  }
-
-  // Prefer leaving OS/IDE headroom unless the user asked for max quality.
-  if (isTightFit(model, totalRamGb) && needs.priority !== "quality") {
-    score -= 35;
-  }
-  return score;
+export function suggestTierForRam(totalRamGb: number | null): ModelTier {
+  if (totalRamGb === null || !Number.isFinite(totalRamGb)) return "fast";
+  const budget = usableRamGb(totalRamGb);
+  if (budget >= 24) return "smart";
+  if (budget >= 8) return "balanced";
+  if (budget >= 4) return "fast";
+  return "ultra-fast";
 }
 
 /**
- * Pick the best chat model for RAM + needs.
+ * Recommend a chat model for host RAM (balanced default — no quiz).
  *
  * @param totalRamGb - Machine RAM
- * @param needs - Questionnaire (defaults to balanced/speed-friendly)
  */
-export function recommendChatForNeeds(
-  totalRamGb: number | null,
-  needs: AiNeeds = { useCase: "balanced", priority: "balanced", wantVision: false },
-): CatalogModel {
-  // Prefer comfortable pool; quality may still score a tight tier-fit higher.
-  const pool =
-    needs.priority === "quality"
-      ? fittingChatModels(totalRamGb)
-      : comfortableChatModels(totalRamGb);
-  let best = pool[0]!;
-  let bestScore = Number.NEGATIVE_INFINITY;
-  for (const m of pool) {
-    const s = scoreChatModel(m, needs, totalRamGb);
-    if (s > bestScore) {
-      best = m;
-      bestScore = s;
-    }
-  }
-  return best;
+export function recommendChatForNeeds(totalRamGb: number | null): CatalogModel {
+  return recommendForTier(suggestTierForRam(totalRamGb), totalRamGb);
 }
 
 /**
- * Vision model that fits; null if user skipped or none fit.
+ * Shared hardware lines for local AI banners.
  *
- * @param totalRamGb - Machine RAM
- * @param wantVision - From questionnaire
+ * @param machine - Detected hardware
  */
-export function recommendVisionForNeeds(
-  totalRamGb: number | null,
-  wantVision: boolean,
-): CatalogModel | null {
-  if (!wantVision) return null;
-  const fits = VISION_MODELS.filter((m) => modelFitsOnMachine(m, totalRamGb));
-  return fits.find((m) => m.recommended) ?? fits[0] ?? null;
+function formatMachineBannerLines(machine: {
+  readonly osName: string;
+  readonly cpuCount: number | null;
+  readonly ramGb: number | null;
+}): readonly string[] {
+  const ram =
+    machine.ramGb !== null && Number.isFinite(machine.ramGb)
+      ? `~${machine.ramGb}GB RAM`
+      : "RAM unknown";
+  const cpu =
+    machine.cpuCount !== null && Number.isFinite(machine.cpuCount) ? String(machine.cpuCount) : "?";
+  const fit =
+    machine.ramGb !== null && Number.isFinite(machine.ramGb)
+      ? `~${usableRamGb(machine.ramGb)}GB RAM`
+      : "unknown";
+  const sep = "  ·  ";
+  return [[`OS ${machine.osName}`, `CPU ${cpu}`, `RAM ${ram}`].join(sep), `Fit RAM ${fit}`];
 }
 
 /**
- * Human summary line for the recommendation panel.
+ * Ollama banner lines — OS · CPU · RAM · fit · detected · tiers.
  *
- * Separates **machine RAM** from **model tier** so "~24GB" is never read as
- * download size.
+ * @param machine - Detected hardware
+ * @param detectedIds - Installed model ids
+ */
+export function formatOllamaBanner(
+  machine: {
+    readonly osName: string;
+    readonly cpuCount: number | null;
+    readonly ramGb: number | null;
+  },
+  detectedIds: readonly string[],
+): string {
+  const sep = "  ·  ";
+  const lines = [
+    ...formatMachineBannerLines(machine),
+    "",
+    "Detected local models",
+    ...(detectedIds.length > 0 ? detectedIds.map((id) => id) : ["(none detected)"]),
+    "",
+    `Tiers${sep}${MODEL_TIERS.map((t) => t.label).join(sep)}`,
+  ];
+  return lines.join("\n");
+}
+
+/**
+ * llama.cpp banner — OS · CPU · RAM · fit · Docker Hub `ai/` source · tiers.
  *
- * @param totalRamGb - Machine RAM
- * @param chat - Chosen chat model
+ * @param machine - Detected hardware
  */
-export function formatMachineSummary(totalRamGb: number | null, chat: CatalogModel): string {
-  if (totalRamGb === null || !Number.isFinite(totalRamGb)) {
-    return `⭐ Suggested: ${chat.label} (≈${chat.ramGb}GB-class machine · not download size)`;
-  }
-  const budget = usableRamGb(totalRamGb);
-  const tight = isTightFit(chat, totalRamGb) ? " · tight on this machine" : "";
-  return [
-    `Your machine: ~${totalRamGb}GB RAM (keep ~${OS_HEADROOM_GB}GB free for OS/IDE → ~${budget}GB model budget)`,
-    `⭐ For you: ${chat.label} — ≈${chat.ramGb}GB-class (Ollama pull is usually much smaller than RAM)${tight}`,
-  ].join("\n");
+export function formatLlamaCppBanner(machine: {
+  readonly osName: string;
+  readonly cpuCount: number | null;
+  readonly ramGb: number | null;
+}): string {
+  const sep = "  ·  ";
+  const lines = [
+    ...formatMachineBannerLines(machine),
+    "",
+    "Model source",
+    "Docker Hub ai/ (curated) — pulled on first container start",
+    "",
+    `Tiers${sep}${MODEL_TIERS.map((t) => t.label).join(sep)}`,
+  ];
+  return lines.join("\n");
+}
+
+/** Model name column width (monospace CLI table). */
+const MODEL_COL_NAME = 26;
+/** RAM column width, right-aligned (`≈32GB`). */
+const MODEL_COL_RAM = 7;
+
+/**
+ * Clip or pad a cell for aligned CLI columns.
+ *
+ * @param value - Cell text
+ * @param width - Fixed width
+ */
+function clipPad(value: string, width: number): string {
+  if (value.length === width) return value;
+  if (value.length < width) return value.padEnd(width);
+  return `${value.slice(0, Math.max(0, width - 1))}…`;
+}
+
+/**
+ * Column header for the model pick list (aligns with {@link formatModelRow}).
+ */
+export function formatModelTableHeader(): string {
+  return `${clipPad("Model", MODEL_COL_NAME)}  ${"RAM".padStart(MODEL_COL_RAM)}  Caps`;
+}
+
+/**
+ * One model row as aligned columns: Model | RAM | Caps.
+ *
+ * @param model - Catalog entry
+ */
+export function formatModelRow(model: CatalogModel): string {
+  const name = clipPad(model.label, MODEL_COL_NAME);
+  const ram = `≈${model.ramGb}GB`.padStart(MODEL_COL_RAM);
+  const caps = model.modalities.join(" · ");
+  return `${name}  ${ram}  ${caps}`;
 }

package/src/cli/ask-seed.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Tests for the one-shot seed prompt after `oke db push`.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+import { maybeAskSeed, SEEDED_MARKER } from "./ask-seed.ts";
+
+describe("maybeAskSeed", () => {
+  test("skips when non-TTY", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "ask-seed-"));
+    try {
+      mkdirSync(join(dir, "src", "db", "seed"), { recursive: true });
+      writeFileSync(join(dir, "src", "db", "seed", "index.ts"), "export default {};\n");
+      let seeded = false;
+      await maybeAskSeed({
+        cwd: dir,
+        env: "local",
+        stdinIsTTY: false,
+        confirmFn: async () => true,
+        seedFn: async () => {
+          seeded = true;
+          return 0;
+        },
+      });
+      expect(seeded).toBe(false);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("asks once then writes marker", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "ask-seed-"));
+    try {
+      mkdirSync(join(dir, "src", "db", "seed"), { recursive: true });
+      writeFileSync(join(dir, "src", "db", "seed", "index.ts"), "export default {};\n");
+      let calls = 0;
+      await maybeAskSeed({
+        cwd: dir,
+        env: "local",
+        stdinIsTTY: true,
+        confirmFn: async () => true,
+        seedFn: async () => {
+          calls += 1;
+          return 0;
+        },
+      });
+      expect(calls).toBe(1);
+      expect(existsSync(join(dir, SEEDED_MARKER))).toBe(true);
+
+      await maybeAskSeed({
+        cwd: dir,
+        env: "local",
+        stdinIsTTY: true,
+        confirmFn: async () => true,
+        seedFn: async () => {
+          calls += 1;
+          return 0;
+        },
+      });
+      expect(calls).toBe(1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/ask-seed.ts

@@ -0,0 +1,79 @@
+/**
+ * One-time interactive prompt: run `oke db seed` after first successful push.
+ */
+
+import { confirm, isCancel } from "@clack/prompts";
+import { resolve } from "node:path";
+import type { ConfigEnv } from "../config/index.ts";
+import { formatCliChrome } from "../term.ts";
+import { resolveSeedModulePath, runSeed } from "./db-seed.ts";
+
+/** Marker written after a successful prompted seed (skip re-ask). */
+export const SEEDED_MARKER = ".oke/seeded";
+
+/** Options for {@link maybeAskSeed}. */
+export interface AskSeedOptions {
+  readonly cwd: string;
+  readonly env: ConfigEnv;
+  readonly write?: (text: string) => void;
+  readonly stdinIsTTY?: boolean;
+  /** Skip prompt (tests / `--yes` / non-interactive). */
+  readonly skip?: boolean;
+  /** Injectable confirm (tests). */
+  readonly confirmFn?: () => Promise<boolean>;
+  /** Injectable seed runner (tests). */
+  readonly seedFn?: (cwd: string, env: ConfigEnv) => Promise<number>;
+}
+
+/**
+ * After a successful `oke db push`, ask once whether to seed sample data.
+ * Skips when non-TTY, already seeded, or no seed module.
+ *
+ * @param options - Project / env / injectables
+ */
+export async function maybeAskSeed(options: AskSeedOptions): Promise<void> {
+  if (options.skip) return;
+  const tty = options.stdinIsTTY ?? Boolean(process.stdin.isTTY);
+  if (!tty) return;
+
+  const cwd = options.cwd;
+  const marker = resolve(cwd, SEEDED_MARKER);
+  if (await Bun.file(marker).exists()) return;
+
+  const seedPath = await resolveSeedModulePath(cwd);
+  if (!(await Bun.file(seedPath).exists())) return;
+
+  const write = options.write ?? ((t) => process.stdout.write(t));
+  const chromeWrite = (t: string) => write(formatCliChrome(t));
+  const ok =
+    options.confirmFn !== undefined
+      ? await options.confirmFn()
+      : await (async () => {
+          const value = await confirm({
+            message: "Run oke db seed (essential + sample data)?",
+            initialValue: true,
+          });
+          if (isCancel(value)) return false;
+          return Boolean(value);
+        })();
+
+  if (!ok) {
+    chromeWrite("oke db seed: skipped (run `oke db seed` later)\n");
+    return;
+  }
+
+  const seed =
+    options.seedFn ??
+    ((projectCwd, env) =>
+      runSeed({
+        cwd: projectCwd,
+        env,
+        write: chromeWrite,
+        force: true,
+        stdinIsTTY: false,
+      }));
+  const code = await seed(cwd, options.env);
+  if (code === 0) {
+    await Bun.write(marker, `${new Date().toISOString()}\n`);
+  }
+}

package/src/cli/db-seed-redact.test.ts

@@ -0,0 +1,25 @@
+/**
+ * Seed display helpers — password redaction must stay human-readable.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { redactConnectionTarget } from "./db-seed.ts";
+
+describe("redactConnectionTarget", () => {
+  test("replaces password with bullets without percent-encoding", () => {
+    const out = redactConnectionTarget("postgres://oke:s3cret@127.0.0.1:5432/oke");
+    expect(out).toBe("postgres://oke:••••@127.0.0.1:5432/oke");
+    expect(out).not.toContain("%E2%80%A2");
+    expect(out).not.toContain("s3cret");
+  });
+
+  test("keeps URLs without passwords", () => {
+    expect(redactConnectionTarget("postgres://oke@127.0.0.1:5432/oke")).toContain(
+      "postgres://oke@",
+    );
+  });
+
+  test("passes through opaque non-URL strings", () => {
+    expect(redactConnectionTarget("not a url at all")).toBe("not a url at all");
+  });
+});