okengine 0.13.0 → 0.15.2

package/src/cli/dev.ts

@@ -31,8 +31,8 @@ import {
   createAnchoredBoard,
   createBootProgress,
   devStatusFromAiPhase,
-  formatAppReadyLine,
   formatBootWarn,
+  formatBoundSurfaces,
   formatClaimNote,
   formatCliChrome,
   formatDevBanner,
@@ -83,7 +83,7 @@ export interface DevSurfaceHandle {
 
 /** App surface returned by {@link DevOptions.startApp}. */
 export interface DevAppHandle {
-  readonly stop: () => void;
+  readonly stop: () => void | Promise<void>;
   /** Bound listen port (set when serve chooses an ephemeral port). */
   readonly port?: number;
   /** Base URL of the app server. */
@@ -181,12 +181,9 @@ export interface DevOptions {
   /**
    * Injectable `.adopt()` barrel regeneration (tests). Default: real
    * `generateAdoptBarrel` + atomic write to `<cwd>/src/flows/generated.ts`
-   * (`generated.ts.tmp` → rename). Runs once per `oke dev` session, before
-   * the entry is resolved/imported — a real file on disk, so `oke dev`'s
-   * runtime `import()` and `oke build`'s `Bun.build()` resolve it
-   * identically (unlike a virtual-module Bun plugin, which does not — see
-   * `compiler/generate-adopt.ts`). Atomic so a concurrent import during
-   * `bun --hot` never sees a torn mid-write file.
+   * (`generated.ts.tmp` → rename). Runs at session start and again on
+   * `src/flows/**` changes except `generated.ts` itself. Write-if-changed
+   * so the `src/` watcher + bun `--hot` do not loop.
    *
    * @param cwd - Project root
    */
@@ -481,6 +478,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     files: readonly string[];
     cwd: string;
     env: Record<string, string>;
+    aiServiceName?: string;
   } | null = null;
   let stackSqlDriver = "postgres";
   let stackKvDriver = "redis";
@@ -658,6 +656,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
           files: composeFiles,
           cwd: dockerOut,
           env: { ...stackEnv! },
+          aiServiceName: derived.specs.find((s) => s.role === "ai")?.serviceName,
         };
 
         // Stream compose health until infra is up (AI may stay pending — model load).
@@ -942,7 +941,9 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     return { code: 0, plan };
   }
 
+  let boardPaused = false;
   const repaintBoard = (aiStatus?: DevStatus): void => {
+    if (boardPaused) return;
     bootBoard.paint(paintBootBoard(aiStatus ?? heroAiStatus));
   };
 
@@ -1026,15 +1027,6 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
           `oke db push (dev · ${result.dialect}) ${result.code === 0 ? "ok" : "failed"}`,
         ),
       );
-      if (result.code === 0) {
-        const { maybeAskSeed } = await import("./ask-seed.ts");
-        await maybeAskSeed({
-          cwd,
-          env: configEnv,
-          write,
-          stdinIsTTY: options.stdinIsTTY ?? process.stdin.isTTY,
-        });
-      }
     } catch (err) {
       write(await formatDevSchemaSyncFailure(cwd, err, "boot"));
     }
@@ -1323,14 +1315,14 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
       write(formatBootWarn(notice));
     }
     bootNotices.length = 0;
-    write(formatAppReadyLine(`http://127.0.0.1:${boundAppPort}`));
-    write(formatServiceLine("Console", `http://127.0.0.1:${boundConsolePort}`));
-    if (mcpServer) {
-      write(formatServiceLine("MCP", `http://127.0.0.1:${boundMcpPort}`));
-    }
-    if (docsMcpServer) {
-      write(formatServiceLine("Docs MCP", `http://127.0.0.1:${boundDocsMcpPort}`));
-    }
+    write(
+      formatBoundSurfaces({
+        appUrl: `http://127.0.0.1:${boundAppPort}`,
+        consoleUrl: `http://127.0.0.1:${boundConsolePort}`,
+        mcpUrl: mcpServer ? `http://127.0.0.1:${boundMcpPort}` : null,
+        docsMcpUrl: docsMcpServer ? `http://127.0.0.1:${boundDocsMcpPort}` : null,
+      }),
+    );
     write(formatDevLogSeparator());
     chromeReady = true;
   };
@@ -1358,6 +1350,10 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
   const watchFs: DevWatchFn =
     options.watchFs ?? ((path, watchOptions, listener) => watch(path, watchOptions, listener));
   const watcher = watchFs(resolve(cwd, "src"), { recursive: true }, (_event, filename) => {
+    const rel = (filename?.toString() ?? "").replace(/\\/g, "/");
+    if (isFlowsTreeWatchPath(rel)) {
+      void syncAdoptBarrel(cwd);
+    }
     void regen(appUrl);
     // Only live-extract when the host did not pin a Manifest (tests).
     if (options.manifest === undefined) {
@@ -1388,7 +1384,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     const host = attachedHost;
     attachedHost = null;
     void host?.stop();
-    app.stop();
+    void Promise.resolve(app.stop());
     consoleServer.stop();
     mcpServer?.stop();
     docsMcpServer?.stop();
@@ -1489,6 +1485,25 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
       await syncComposeBoard();
       paintReadyChrome();
     };
+    const waitComposeReady = async (): Promise<void> => {
+      const { watchComposeHealth } = await import("../docker/compose-health.ts");
+      const aiServiceName = started.aiServiceName;
+      liveComposeHealth = await watchComposeHealth({
+        files: started.files,
+        cwd: started.cwd,
+        env: started.env,
+        run: composeHealthRun,
+        timeoutMs: 20_000,
+        isDone: (map) => {
+          if (map.size === 0) return true;
+          return [...map.entries()].every(
+            ([name, s]) => name === aiServiceName || s === "ready" || s === "error",
+          );
+        },
+      });
+      if (liveComposeHealth.get("ai") === "error") heroAiStatus = "error";
+    };
+
     const composeAction = async (action: DevComposeControlAction): Promise<void> => {
       const files = started.files;
       const finalArgs =
@@ -1510,6 +1525,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
         const detail = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
         throw new Error(`docker compose ${action} exited ${code}` + (detail ? `\n${detail}` : ""));
       }
+      if (action === "up") await waitComposeReady();
       await syncComposeBoard();
     };
 
@@ -1517,6 +1533,25 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
       const { launchDevLiveControls } = await import("./tui/DevLive.tsx");
       await launchDevLiveControls({
         onRefresh: () => refreshChrome(),
+        onSeed: async () => {
+          const { runSlashCli } = await import("./tui/slash-run.ts");
+          boardPaused = true;
+          const lines: string[] = [];
+          try {
+            const code = await runSlashCli(cwd, ["db", "seed", "--force"], (line) => {
+              lines.push(line);
+              write(line);
+            });
+            if (code === 0) return;
+            const last = [...lines]
+              .reverse()
+              .map((line) => line.trim())
+              .find((line) => line.length > 0 && !line.startsWith("✗") && !line.startsWith("$"));
+            throw new Error(last || "oke db seed failed");
+          } finally {
+            boardPaused = false;
+          }
+        },
         onComposeUp: () => composeAction("up"),
         onComposeStop: () => composeAction("stop"),
         onQuit: () => {
@@ -1589,6 +1624,20 @@ function isSchemaDeclDefinitionError(err: unknown, declarePath: string): boolean
   return declarePath.length > 0 && blob.includes(declarePath);
 }
 
+/**
+ * True when a `src/` watcher event is a flows tree change that should
+ * regenerate `generated.ts` (never the generated file itself).
+ *
+ * @param rel - Watcher filename (POSIX or Windows)
+ */
+export function isFlowsTreeWatchPath(rel: string): boolean {
+  const posix = rel.replace(/\\/g, "/");
+  if (!posix.includes("flows/")) return false;
+  const base = posix.split("/").pop() ?? posix;
+  if (base === "generated.ts" || base === "generated.ts.tmp") return false;
+  return true;
+}
+
 /**
  * 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.
@@ -1652,6 +1701,29 @@ async function tryLoadProjectManifest(cwd: string): Promise<Manifest | null | un
   return extracted;
 }
 
+/**
+ * SIGKILL a pid and every child (`bun --hot` leaves a worker).
+ *
+ * @param pid - Root pid
+ */
+function killProcessTree(pid: number): void {
+  const listed = Bun.spawnSync(["pgrep", "-P", String(pid)], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (listed.exitCode === 0) {
+    for (const line of listed.stdout.toString().split("\n")) {
+      const child = Number(line.trim());
+      if (Number.isInteger(child) && child > 0) killProcessTree(child);
+    }
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    // Already gone.
+  }
+}
+
 /**
  * Default app boot: `bun --hot` on the shipped runner (socket-preserving).
  *
@@ -1687,17 +1759,18 @@ async function startAppHot(
   });
 
   let stopped = false;
-  const stop = () => {
-    if (stopped) return;
+  const stop = (): Promise<void> => {
+    if (stopped) return proc.exited.then(() => {});
     stopped = true;
     try {
       // SIGKILL so `bun --hot` cannot linger and hold the project directory
       // open (create-oke afterEach `rmSync` otherwise races the child exit).
-      proc.kill("SIGKILL");
+      killProcessTree(proc.pid);
     } catch {
       // Inconsequential: process already exited — kill is idempotent best-effort.
     }
     void unlink(readyPath).catch(() => {});
+    return proc.exited.then(() => {});
   };
 
   try {

package/src/cli/ensure-drizzle-config.ts

@@ -24,7 +24,8 @@ export default defineConfig({
   dialect: "postgresql",
   schema: "./src/db/schema.drizzle.ts",
   out: "./src/db/migrations",
-  // Core runtime tables (oke_crons, …) are created by drivers — not domain schema.
+  // Domain tables live in public. Schema \`oke\` (RLS) and \`oke_console\` are engine-owned.
+  schemaFilter: ["public"],
   tablesFilter: ["!oke_*"],
   dbCredentials: {
     url: process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL!,

package/src/cli/tui/DevLive.tsx

@@ -13,6 +13,7 @@ import { TUI_BRAND, TUI_HINT, TUI_MUTED, TUI_WARN } from "./theme.ts";
 /** Props for {@link DevLiveControls}. */
 export type DevLiveControlsProps = {
   readonly onRefresh: () => void | Promise<void>;
+  readonly onSeed: () => void | Promise<void>;
   readonly onComposeUp: () => void | Promise<void>;
   readonly onComposeStop: () => void | Promise<void>;
   readonly onQuit: () => void;
@@ -49,6 +50,14 @@ export function DevLiveControls(props: DevLiveControlsProps): ReactElement {
         .finally(() => setBusy(false));
       return;
     }
+    if (ctrl === "s") {
+      setBusy(true);
+      void Promise.resolve(props.onSeed())
+        .then(() => setStatus("seeded"))
+        .catch((err: unknown) => setStatus(err instanceof Error ? err.message : String(err)))
+        .finally(() => setBusy(false));
+      return;
+    }
     if (ctrl === "u" || ctrl === "x") {
       setBusy(true);
       const run = ctrl === "u" ? props.onComposeUp : props.onComposeStop;
@@ -66,13 +75,13 @@ export function DevLiveControls(props: DevLiveControlsProps): ReactElement {
           oke dev
         </Text>
         <Text color={TUI_MUTED}> · controls · </Text>
-        <Text color={TUI_HINT}>? help · r refresh · q quit · u up · x stop</Text>
+        <Text color={TUI_HINT}>? help · r refresh · s seed · q quit · u up · x stop</Text>
         {busy ? <Text color={TUI_WARN}> · working…</Text> : null}
         {status ? <Text color={TUI_MUTED}>{` · ${status}`}</Text> : null}
       </Text>
       {help ? (
         <Text color={TUI_MUTED}>
-          r clear/refresh board · q quit · u compose up · x compose stop
+          r clear/refresh board · s oke db seed · q quit · u compose up · x compose stop
         </Text>
       ) : null}
     </Box>
@@ -104,6 +113,7 @@ export async function launchDevLiveControls(props: DevLiveControlsProps): Promis
 
   const bound: DevLiveControlsProps = {
     onRefresh: () => afterStdout(props.onRefresh),
+    onSeed: () => afterStdout(props.onSeed),
     onComposeUp: () => afterStdout(props.onComposeUp),
     onComposeStop: () => afterStdout(props.onComposeStop),
     onQuit: props.onQuit,

package/src/cli/tui/keys.test.ts

@@ -2,10 +2,11 @@ import { describe, expect, test } from "bun:test";
 import { mapDevControlInput } from "./keys.ts";
 
 describe("mapDevControlInput", () => {
-  test("maps ? r q u x and aliases", () => {
+  test("maps ? r s q u x and aliases", () => {
     expect(mapDevControlInput("?", {})).toBe("?");
     expect(mapDevControlInput("h", {})).toBe("?");
     expect(mapDevControlInput("r", {})).toBe("r");
+    expect(mapDevControlInput("s", {})).toBe("s");
     expect(mapDevControlInput("q", {})).toBe("q");
     expect(mapDevControlInput("u", {})).toBe("u");
     expect(mapDevControlInput("x", {})).toBe("x");

package/src/cli/tui/keys.ts

@@ -1,10 +1,10 @@
 /**
  * Shared keyboard mapping for Ink `useInput` and pure tests.
- * Parity with legacy `parseDevControlKey` (`? r q u x`).
+ * Parity with legacy `parseDevControlKey` (`? r s q u x`).
  */
 
 /** Dev control action from a keypress. */
-export type DevControlKey = "?" | "r" | "q" | "u" | "x";
+export type DevControlKey = "?" | "r" | "s" | "q" | "u" | "x";
 
 /**
  * Map Ink input (+ ctrl) to a control key.
@@ -20,6 +20,7 @@ export function mapDevControlInput(
   if (input === "?" || input === "h" || input === "H") return "?";
   if (input === "q" || input === "Q") return "q";
   if (input === "r" || input === "R") return "r";
+  if (input === "s" || input === "S") return "s";
   if (input === "u" || input === "U") return "u";
   if (input === "x" || input === "X") return "x";
   return null;

package/src/compiler/aot.test.ts

@@ -129,7 +129,7 @@ describe("typed error narrowing end-to-end", () => {
     const FlightFull = z.object({ seatsLeft: z.number() });
 
     on(
-      http.post("/bookings").gate.public,
+      http.post("/bookings").public(),
       flow("bookings.create", {
         in: Booking,
         out: z.object({ id: z.string() }),

package/src/compiler/effects-infer.ts

@@ -12,6 +12,7 @@ import type {
   ResourceRef,
   SecretRef,
   SignalRef,
+  SignalResourceRef,
   TemplateRef,
   FlowRef,
 } from "../manifest/types.ts";
@@ -56,6 +57,8 @@ export interface InferBinding {
     | "flow"
     | "embed"
     | "table"
+    | "mcp-server"
+    | "mcp-tool"
     | "unknown";
   /** Resolved resource / name. */
   readonly ref: string;
@@ -142,7 +145,7 @@ const TABLE_ARG_METHODS = new Set([
  * @param options - Handler AST, bindings, and annotation flag
  */
 export function inferEffects(options: InferEffectsOptions): InferredEffects {
-  const reads = new Set<ResourceRef>();
+  const reads = new Set<ResourceRef | SignalResourceRef>();
   const writes = new Set<ResourceRef>();
   const emits = new Set<SignalRef>();
   const sends = new Set<TemplateRef>();
@@ -173,6 +176,12 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       continue;
     }
 
+    if (chain.rootMethod === "deadLetters" && call === chain.rootCall) {
+      const ref = resolveNamed(call.arguments[0], options.bindings, "signal");
+      if (ref) reads.add(`signal:${ref}`);
+      continue;
+    }
+
     if (chain.rootMethod === "send" && call === chain.rootCall) {
       const ref = resolveNamed(call.arguments[0], options.bindings, "template");
       if (ref) sends.add(ref);
@@ -203,7 +212,7 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
     }
 
     if (chain.rootMethod === "call" && call === chain.rootCall) {
-      const ref = resolveNamed(call.arguments[0], options.bindings, "flow");
+      const ref = resolveCallTarget(call.arguments[0], options.bindings);
       if (ref) calls.add(ref);
       continue;
     }
@@ -541,12 +550,58 @@ function toolsFromAskOptions(
   );
   const out: FlowRef[] = [];
   for (const el of els) {
-    const ref = resolveNamed(el, bindings, "flow");
+    const ref = resolveCallTarget(el, bindings);
     if (ref) out.push(ref as FlowRef);
   }
   return out;
 }
 
+/**
+ * Resolve `fx.call` / ask-tools: flow name, `mcp:` ref, or `server.tool("x")`.
+ *
+ * @param node - Argument AST
+ * @param bindings - Known bindings
+ */
+export function resolveCallTarget(
+  node: AstNode | undefined,
+  bindings: ReadonlyMap<string, InferBinding>,
+): string | undefined {
+  const mcp = resolveMcpToolExpr(node, bindings);
+  if (mcp) return mcp;
+  return resolveNamed(node, bindings, "flow");
+}
+
+/**
+ * Resolve `server.tool("name")` or a bound `mcp-tool` identifier.
+ *
+ * @param node - AST
+ * @param bindings - Known bindings
+ */
+export function resolveMcpToolExpr(
+  node: AstNode | undefined,
+  bindings: ReadonlyMap<string, InferBinding>,
+): string | undefined {
+  if (!node) return undefined;
+  if (node.type === "CallExpression") {
+    const callee = (node as CallExpression).callee;
+    if (callee.type === "MemberExpression") {
+      const member = callee as AstNode & { object: AstNode; property: AstNode };
+      const obj = identifierName(member.object);
+      const prop = identifierName(member.property);
+      const tool = stringArg((node as CallExpression).arguments[0]);
+      if (obj && prop === "tool" && tool) {
+        const server = bindings.get(obj);
+        if (server?.kind === "mcp-server") {
+          return `mcp:${server.ref}/${tool}`;
+        }
+      }
+    }
+  }
+  const binding = resolveBinding(node, bindings);
+  if (binding?.kind === "mcp-tool") return binding.ref;
+  return undefined;
+}
+
 /**
  * String literal argument.
  *