okengine 0.11.0 → 0.11.2

package/src/cli/dev.ts

@@ -38,6 +38,7 @@ import {
   formatServiceLine,
   formatStackSummary,
   formatStatusLine,
+  termColorEnabled,
   type BootProgress,
   type DevStatus,
   type StackSummaryService,
@@ -358,8 +359,14 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     });
   try {
     await syncAdoptBarrel(cwd);
-  } catch {
-    /* best-effort — boot-time assertAdoptBarrelFresh (rootDir opt-in) is the real gate */
+  } catch (err) {
+    // Best-effort: boot-time assertAdoptBarrelFresh (rootDir opt-in) is the real gate.
+    // Still surface so a broken generator is not fully silent in the boot log.
+    write(
+      formatStatusLine(
+        `.adopt() barrel sync skipped — ${err instanceof Error ? err.message : String(err)}`,
+      ),
+    );
   }
 
   const preferredApp = options.appPort ?? Number(Bun.env.PORT ?? APP_PORT);
@@ -425,7 +432,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     };
     if (typeof pkg.version === "string") okeVersion = pkg.version;
   } catch {
-    // shipped binary may not sit next to package.json
+    // Inconsequential: banner version only — shipped binaries may not sit next to package.json.
   }
   const earlyProfile = resolveDevProfile({ docker: true, nodeEnv: "development" });
   write(
@@ -473,8 +480,13 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
   let loadedConfig: Awaited<ReturnType<typeof loadOkeConfig>>["config"] | null = null;
   try {
     loadedConfig = (await loadOkeConfig(cwd)).config;
-  } catch {
+  } catch (err) {
     loadedConfig = null;
+    const msg = err instanceof Error ? err.message : String(err);
+    // Missing config is common for injectable/`--images` trees; surface parse bugs only.
+    if (!/no oke\.config\.ts found/i.test(msg)) {
+      write(formatStatusLine(`oke.config.ts load skipped — ${msg}`));
+    }
   }
 
   {
@@ -496,8 +508,12 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     } else if (!loadedConfig) {
       try {
         loadedConfig = (await loadOkeConfig(cwd)).config;
-      } catch {
+      } catch (err) {
         loadedConfig = null;
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!/no oke\.config\.ts found/i.test(msg)) {
+          write(formatStatusLine(`oke.config.ts load skipped — ${msg}`));
+        }
       }
     }
     if (Array.isArray(options.docker)) {
@@ -1003,11 +1019,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
         });
       }
     } catch (err) {
-      write(
-        formatStatusLine(
-          `oke db push (dev) skipped — ${err instanceof Error ? err.message : String(err)}`,
-        ),
-      );
+      write(await formatDevSchemaSyncFailure(cwd, err, "boot"));
     }
   }
 
@@ -1054,7 +1066,8 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
       const next = await extractManifest({ rootDir: cwd });
       feedManifest(state, next);
     } catch {
-      // Source may be mid-edit — keep the last good Manifest.
+      // Inconsequential while watching: mid-edit parse failures are expected on every
+      // keystroke — keep the last good Manifest. Logging here would flood the Logs pane.
     }
   }
 
@@ -1130,8 +1143,13 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
           out: resolve(cwd, "oke-client.d.ts"),
         });
         write(formatStatusLine("regenerated oke-client.d.ts"));
-      } catch {
-        // App may not be ready yet — ignore until next save.
+      } catch (err) {
+        // App may not be ready yet on first tick — still surface so a stuck regen is visible.
+        write(
+          formatStatusLine(
+            `oke-client.d.ts regen skipped — ${err instanceof Error ? err.message : String(err)}`,
+          ),
+        );
       }
     });
 
@@ -1196,8 +1214,9 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     write(formatStatusLine("oke db push (schema change)"));
     try {
       await dbPush(cwd);
-    } catch {
-      // Mid-edit / kit unavailable — next save retries.
+    } catch (err) {
+      // Dev-loop stays up (next save retries) — but definition errors must not look like a quiet skip.
+      write(await formatDevSchemaSyncFailure(cwd, err, "watch"));
     }
   });
 
@@ -1394,7 +1413,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
       // Esc / unmount without q — still tear down.
       stop();
     } catch {
-      // Ink optional — fall back to keep-alive without keyboard chrome.
+      // Inconsequential: Ink/TUI is optional chrome — fall back to keep-alive without keyboard.
       await new Promise(() => {});
     }
     return { code: 0, plan: session.plan, session };
@@ -1420,6 +1439,75 @@ function isSparseManifest(manifest: Manifest): boolean {
   return Object.keys(flows).length === 0;
 }
 
+/**
+ * Environmental syncDevSchema throws that are fine to soft-skip in the
+ * compose (`dev`) boot path — no Store / no docker images yet, etc.
+ *
+ * @param message - Caught error message
+ */
+function isBenignDevSchemaEnvSkip(message: string): boolean {
+  return (
+    message.startsWith("docker mode: oke.config.ts not found") ||
+    message.startsWith("docker mode: no images configured")
+  );
+}
+
+/**
+ * Whether a caught sync/push error is a schema.decl definition failure
+ * (import evaluation, emit, duplicate tables, bad `.references()`, …).
+ *
+ * Message text alone is insufficient — emit-time bugs often look like bare
+ * TypeErrors (`target.tableName`) — so also inspect the stack for declare /
+ * emit frames.
+ *
+ * @param err - Caught value
+ * @param declarePath - Resolved schema.decl path for this project
+ */
+function isSchemaDeclDefinitionError(err: unknown, declarePath: string): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  const stack = err instanceof Error ? (err.stack ?? "") : "";
+  const blob = `${msg}\n${stack}`;
+  if (/failed to load schema declare|store schema:|oke schema emit:/i.test(blob)) return true;
+  if (/schema\.decl/i.test(blob)) return true;
+  if (/emit-drizzle|emitColumnSource|emitDrizzleSource|maybeEmitDomainSchema/i.test(blob)) {
+    return true;
+  }
+  return declarePath.length > 0 && blob.includes(declarePath);
+}
+
+/**
+ * Frame a schema-sync failure for the `oke dev` loop: warn loud for developer
+ * bugs, soft-skip only known environmental gaps. Never crashes the session.
+ *
+ * Matches the fail-loud status style used by compose controls (`failed —` +
+ * red ●), and ADOPT_BARREL_STALE's "never silent" posture — without turning
+ * this path into a hard boot failure.
+ *
+ * @param cwd - Project root
+ * @param err - Caught value from {@link syncDevSchema} / watch push
+ * @param context - Boot one-shot vs schema-watch auto-push
+ */
+async function formatDevSchemaSyncFailure(
+  cwd: string,
+  err: unknown,
+  context: "boot" | "watch",
+): Promise<string> {
+  const msg = err instanceof Error ? err.message : String(err);
+  const color = termColorEnabled();
+  if (isBenignDevSchemaEnvSkip(msg)) {
+    return formatStatusLine(`oke db push (dev) skipped — ${msg}`, color);
+  }
+
+  const { resolveEmitPaths } = await import("../elements/store/emit-drizzle.ts");
+  const { declarePath } = resolveEmitPaths(cwd);
+  if (isSchemaDeclDefinitionError(err, declarePath)) {
+    return formatStatusLine(`schema.decl.ts has an error — ${msg}`, color, "error");
+  }
+
+  const label = context === "watch" ? "oke db push (schema change)" : "oke db push (dev)";
+  return formatStatusLine(`${label} failed — ${msg}`, color, "error");
+}
+
 /**
  * Load Manifest — prefer AoT extract from `src/` when it has flows;
  * otherwise on-disk JSON snapshots; otherwise a sparse extract.
@@ -1432,7 +1520,8 @@ async function tryLoadProjectManifest(cwd: string): Promise<Manifest | null | un
     const { extractManifest } = await import("../compiler/extract.ts");
     extracted = await extractManifest({ rootDir: cwd });
   } catch {
-    // Fall through to JSON snapshots.
+    // Inconsequential here: extract is one of two sources — fall through to on-disk JSON
+    // snapshots. A broken source tree still boots Console with the last good Manifest file.
   }
 
   let fromDisk: Manifest | undefined;
@@ -1492,7 +1581,7 @@ async function startAppHot(
       // open (create-oke afterEach `rmSync` otherwise races the child exit).
       proc.kill("SIGKILL");
     } catch {
-      // already exited
+      // Inconsequential: process already exited — kill is idempotent best-effort.
     }
     void unlink(readyPath).catch(() => {});
   };

package/src/cli/project-state.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Tests for durable `.oke/state.json` project markers.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+import {
+  isProjectSeeded,
+  LEGACY_SEEDED_MARKER,
+  markProjectSeeded,
+  PROJECT_STATE_REL,
+  readProjectState,
+} from "./project-state.ts";
+
+describe("project-state", () => {
+  test("markProjectSeeded writes seededAt under .oke/state.json", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "oke-state-"));
+    try {
+      expect(await isProjectSeeded(dir)).toBe(false);
+      await markProjectSeeded(dir, "2026-01-02T03:04:05.000Z");
+      expect(await isProjectSeeded(dir)).toBe(true);
+      const state = await readProjectState(dir);
+      expect(state.seededAt).toBe("2026-01-02T03:04:05.000Z");
+      expect(existsSync(join(dir, PROJECT_STATE_REL))).toBe(true);
+      expect(existsSync(join(dir, LEGACY_SEEDED_MARKER))).toBe(false);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("migrates legacy .oke/seeded into state.json and removes marker", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "oke-state-"));
+    try {
+      mkdirSync(join(dir, ".oke"), { recursive: true });
+      writeFileSync(join(dir, LEGACY_SEEDED_MARKER), "2025-12-01T00:00:00.000Z\n");
+      const state = await readProjectState(dir);
+      expect(state.seededAt).toBe("2025-12-01T00:00:00.000Z");
+      expect(existsSync(join(dir, PROJECT_STATE_REL))).toBe(true);
+      expect(existsSync(join(dir, LEGACY_SEEDED_MARKER))).toBe(false);
+      const raw = JSON.parse(readFileSync(join(dir, PROJECT_STATE_REL), "utf8")) as {
+        seededAt?: string;
+      };
+      expect(raw.seededAt).toBe("2025-12-01T00:00:00.000Z");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/project-state.ts

@@ -0,0 +1,123 @@
+/**
+ * `.oke/state.json` — durable local project markers (survive across `oke dev`
+ * sessions). Distinct from `.oke/dev.json` (live session lock) and
+ * `.oke/console.secret` (Console session signing key).
+ */
+
+import { mkdir, unlink } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+/** Relative path under the project root. */
+export const PROJECT_STATE_REL = ".oke/state.json";
+
+/**
+ * Legacy one-shot seed marker (pre-state.json). Migrated on read then removed.
+ * @deprecated Prefer {@link PROJECT_STATE_REL} `seededAt`.
+ */
+export const LEGACY_SEEDED_MARKER = ".oke/seeded";
+
+/** Durable local project state (gitignored under `.oke/`). */
+export type ProjectState = {
+  /** ISO timestamp when prompted `oke db seed` last succeeded. */
+  readonly seededAt?: string;
+};
+
+/**
+ * Absolute path to `.oke/state.json`.
+ *
+ * @param cwd - Project root
+ */
+export function projectStatePath(cwd: string): string {
+  return resolve(cwd, PROJECT_STATE_REL);
+}
+
+/**
+ * Parse and validate a state object from JSON.
+ *
+ * @param raw - Unknown JSON value
+ */
+export function parseProjectState(raw: unknown): ProjectState {
+  if (raw === null || typeof raw !== "object") return {};
+  const o = raw as Record<string, unknown>;
+  const seededAt = o["seededAt"];
+  if (typeof seededAt === "string" && seededAt.trim().length > 0) {
+    return { seededAt: seededAt.trim() };
+  }
+  return {};
+}
+
+/**
+ * Read project state, migrating a legacy `.oke/seeded` marker when present.
+ *
+ * @param cwd - Project root
+ */
+export async function readProjectState(cwd: string): Promise<ProjectState> {
+  const path = projectStatePath(cwd);
+  let state: ProjectState = {};
+  if (await Bun.file(path).exists()) {
+    try {
+      state = parseProjectState(await Bun.file(path).json());
+    } catch {
+      state = {};
+    }
+  }
+
+  if (state.seededAt) return state;
+
+  const legacy = resolve(cwd, LEGACY_SEEDED_MARKER);
+  if (!(await Bun.file(legacy).exists())) return state;
+
+  let seededAt = new Date().toISOString();
+  try {
+    const text = (await Bun.file(legacy).text()).trim();
+    if (text.length > 0) seededAt = text.split(/\r?\n/, 1)[0]!.trim() || seededAt;
+  } catch {
+    // keep generated timestamp
+  }
+  const migrated: ProjectState = { ...state, seededAt };
+  await writeProjectState(cwd, migrated);
+  try {
+    await unlink(legacy);
+  } catch {
+    // best-effort
+  }
+  return migrated;
+}
+
+/**
+ * Write project state (creates `.oke/` as needed).
+ *
+ * @param cwd - Project root
+ * @param state - Full state payload
+ */
+export async function writeProjectState(cwd: string, state: ProjectState): Promise<void> {
+  const path = projectStatePath(cwd);
+  await mkdir(dirname(path), { recursive: true });
+  const body: Record<string, string> = {};
+  if (state.seededAt) body.seededAt = state.seededAt;
+  await Bun.write(path, `${JSON.stringify(body, null, 2)}\n`);
+}
+
+/**
+ * Whether prompted seed already completed for this project.
+ *
+ * @param cwd - Project root
+ */
+export async function isProjectSeeded(cwd: string): Promise<boolean> {
+  const state = await readProjectState(cwd);
+  return typeof state.seededAt === "string" && state.seededAt.length > 0;
+}
+
+/**
+ * Record a successful prompted seed (ISO timestamp).
+ *
+ * @param cwd - Project root
+ * @param at - Optional timestamp (defaults to now)
+ */
+export async function markProjectSeeded(
+  cwd: string,
+  at: string = new Date().toISOString(),
+): Promise<void> {
+  const prev = await readProjectState(cwd);
+  await writeProjectState(cwd, { ...prev, seededAt: at });
+}

package/src/cli/vault-cmd.test.ts

@@ -2,12 +2,13 @@
  * `oke vault` builtin loop — init · status · seal/unseal · rotate · audit ·
  * backup/restore.
  *
- * Every case runs against a real PGlite instance shared across the
- * subcommands of one scenario, which is what a live vault looks like: each
- * `oke vault …` is a fresh process that must re-supply the master key.
+ * Logic-only cases (init / status seal-state) use the in-memory Vault SQL
+ * fake so they do not pay PGlite WASM cold-start. Dialect-heavy cases
+ * (rotate, backup, audit purge, …) share one warmed file-scoped PGlite
+ * (cold WASM once; {@link resetVaultTables} between tests).
  */
 
-import { describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -18,8 +19,20 @@ import {
   sqlConnectionAsExec,
   type BuiltinVaultAdapter,
 } from "../elements/vault/builtin-adapter.ts";
+import { createMemoryVaultSql, resetVaultTables } from "../elements/vault/test-helpers.ts";
 import { vaultCli } from "./vault-cmd.ts";
 
+/** File-scoped warmed PGlite for dialect-heavy CLI cases. */
+let sharedPglite: SqlConnection;
+
+beforeAll(async () => {
+  sharedPglite = await connectPglite({ url: "memory://vault-cli-shared" });
+}, 15_000);
+
+afterAll(async () => {
+  await sharedPglite.close();
+});
+
 /** A CLI bound to one in-memory vault, plus its captured stdout. */
 interface Harness {
   readonly sql: SqlConnection;
@@ -31,13 +44,28 @@ interface Harness {
   close(): Promise<void>;
 }
 
+/** Options for {@link harness}. */
+interface HarnessOptions {
+  /** Project root for relative file arguments. */
+  readonly cwd?: string;
+  /**
+   * Pre-opened SQL. Defaults to the file-scoped warmed PGlite. Pass
+   * {@link createMemoryVaultSql} for logic-only cases that must not pay
+   * WASM cold-start.
+   */
+  readonly sql?: SqlConnection;
+}
+
 /**
- * Open a CLI harness over a fresh PGlite instance.
+ * Open a CLI harness over an injected or shared PGlite connection.
  *
- * @param cwd - Project root for relative file arguments
+ * @param options - Cwd / SQL backend
  */
-async function harness(cwd?: string): Promise<Harness> {
-  const sql = await connectPglite({ url: "memory://vault-cli-test" });
+async function harness(options: HarnessOptions = {}): Promise<Harness> {
+  const injected = options.sql !== undefined;
+  if (!injected) await resetVaultTables(sharedPglite);
+  const sql = options.sql ?? sharedPglite;
+  const cwd = options.cwd;
   let captured = "";
   return {
     sql,
@@ -55,7 +83,7 @@ async function harness(cwd?: string): Promise<Harness> {
     reset: () => {
       captured = "";
     },
-    close: () => sql.close(),
+    close: () => (injected ? sql.close() : Promise.resolve()),
   };
 }
 
@@ -84,7 +112,8 @@ async function attach(sql: SqlConnection, masterKey: string): Promise<BuiltinVau
 
 describe("oke vault — builtin lifecycle", () => {
   test("init prints the master key once and status reflects seal state", async () => {
-    const h = await harness();
+    // Logic-only: seal-state + init CLI copy — no Postgres dialect under test.
+    const h = await harness({ sql: createMemoryVaultSql() });
     try {
       // A never-initialized vault reports rather than crashes.
       expect(await h.run(["status"])).toBe(0);
@@ -121,7 +150,7 @@ describe("oke vault — builtin lifecycle", () => {
   });
 
   test("unseal requires a key and seal records the transition", async () => {
-    const h = await harness();
+    const h = await harness({});
     try {
       await h.run(["init"]);
       const masterKey = masterKeyFrom(h.output());
@@ -149,7 +178,7 @@ describe("oke vault — builtin lifecycle", () => {
 
 describe("oke vault rotate", () => {
   test("rotate re-encrypts the current value under a new version", async () => {
-    const h = await harness();
+    const h = await harness({});
     try {
       await h.run(["init"]);
       const masterKey = masterKeyFrom(h.output());
@@ -179,7 +208,7 @@ describe("oke vault rotate", () => {
   });
 
   test("rotate-master issues a new key and retires the old one", async () => {
-    const h = await harness();
+    const h = await harness({});
     try {
       await h.run(["init"]);
       const first = masterKeyFrom(h.output());
@@ -211,7 +240,7 @@ describe("oke vault rotate", () => {
 
 describe("oke vault audit", () => {
   test("lists rows, verifies the chain, and purges by date", async () => {
-    const h = await harness();
+    const h = await harness({});
     try {
       await h.run(["init"]);
       const masterKey = masterKeyFrom(h.output());
@@ -256,7 +285,7 @@ describe("oke vault audit", () => {
 describe("oke vault backup / restore", () => {
   test("round-trips every live secret through an encrypted bundle", async () => {
     const dir = await mkdtemp(join(tmpdir(), "oke-vault-cli-"));
-    const h = await harness(dir);
+    const h = await harness({ cwd: dir });
     try {
       await h.run(["init"]);
       const masterKey = masterKeyFrom(h.output());
@@ -319,7 +348,7 @@ describe("oke vault help", () => {
 
 describe("oke vault secure master-key input", () => {
   test("unseal accepts --key - via injected stdin", async () => {
-    const h = await harness();
+    const h = await harness({});
     try {
       await h.run(["init"]);
       const masterKey = masterKeyFrom(h.output());
@@ -340,7 +369,7 @@ describe("oke vault secure master-key input", () => {
   });
 
   test("unseal accepts an injected interactive prompt", async () => {
-    const h = await harness();
+    const h = await harness({});
     try {
       await h.run(["init"]);
       const masterKey = masterKeyFrom(h.output());
@@ -367,7 +396,7 @@ describe("oke vault secure master-key input", () => {
 
 describe("oke vault purge-expired", () => {
   test("dry-run counts without deleting; live purge removes expired rows", async () => {
-    const h = await harness();
+    const h = await harness({});
     try {
       await h.run(["init"]);
       const masterKey = masterKeyFrom(h.output());

package/src/cli/vault-cmd.ts

@@ -755,7 +755,8 @@ async function runVaultBackup(
     return 1;
   }
   const blob = await withVault(options, flags, key, (a) => a.exportBackup());
-  await Bun.write(resolve(cwd, file), blob);
+  const { writeBackupFileAtomic } = await import("../elements/vault/builtin-adapter.ts");
+  await writeBackupFileAtomic(resolve(cwd, file), blob);
   write(`oke vault: wrote ${blob.byteLength} encrypted byte(s) to ${file}\n`);
   return 0;
 }

package/src/compiler/extract.ts

@@ -803,7 +803,7 @@ function visitDeclarationCall(call: CallExpression, program: AstNode, scope: Pro
       }
     }
 
-    // model.prompt("ticket-triage", { version, evals, budget })
+    // model.prompt("ticket-triage", { version, evals, budget, via, timeout })
     if (prop === "prompt") {
       const promptName = stringArg(call.arguments[0]);
       const opts = objectArg(call.arguments[1]);
@@ -811,6 +811,10 @@ function visitDeclarationCall(call: CallExpression, program: AstNode, scope: Pro
         const version = numberProp(opts, "version");
         const evals = stringProp(opts, "evals");
         const budgetObj = objectProp(opts, "budget");
+        const via = stringArrayProp(opts, "via");
+        const timeoutStr = stringProp(opts, "timeout");
+        const timeoutNum = numberProp(opts, "timeout");
+        const timeout = timeoutStr ?? timeoutNum;
         const prompt: AiPrompt = {
           ...(version !== undefined ? { version } : {}),
           ...(evals ? { evals } : {}),
@@ -822,9 +826,16 @@ function visitDeclarationCall(call: CallExpression, program: AstNode, scope: Pro
                         maxCostPerCall: numberProp(budgetObj, "maxCostPerCall"),
                       }
                     : {}),
+                  ...(numberProp(budgetObj, "maxCostPerRun") !== undefined
+                    ? {
+                        maxCostPerRun: numberProp(budgetObj, "maxCostPerRun"),
+                      }
+                    : {}),
                 },
               }
             : {}),
+          ...(via && via.length > 0 ? { via } : {}),
+          ...(timeout !== undefined ? { timeout } : {}),
         };
         scope.ai.prompts = scope.ai.prompts ?? {};
         scope.ai.prompts[promptName] = prompt;

package/src/console/server/console.test.ts

@@ -323,11 +323,13 @@ describe("console serve security", () => {
       secret: "serve-secret",
       silentClaim: true,
       env: "test",
+      // Security suite is hermetic — do not inherit a host DATABASE_URL.
+      persist: false,
     });
   });
 
   afterAll(() => {
-    server.stop(true);
+    server?.stop(true);
   });
 
   test("rejects unexpected Host", async () => {