okengine 0.10.0 → 0.10.2

package/src/cli/dev-controls.test.ts

@@ -1,65 +1,42 @@
 import { describe, expect, test } from "bun:test";
 import {
-  controlServicesFromStack,
   createDevControlDispatcher,
   formatDevControlsHelp,
   formatDevControlsHint,
-  formatDevControlsServiceList,
   parseDevControlKey,
 } from "./dev-controls.ts";
 
+const CTRL_C = String.fromCharCode(3);
+
 describe("dev-controls", () => {
   test("parseDevControlKey maps raw keys", () => {
     expect(parseDevControlKey("q")).toBe("q");
-    expect(parseDevControlKey("\u0003")).toBe("q");
     expect(parseDevControlKey("?")).toBe("?");
     expect(parseDevControlKey("h")).toBe("?");
-    expect(parseDevControlKey("c")).toBe("c");
-    expect(parseDevControlKey("l")).toBe("l");
+    expect(parseDevControlKey("r")).toBe("r");
     expect(parseDevControlKey("u")).toBe("u");
     expect(parseDevControlKey("x")).toBe("x");
-    expect(parseDevControlKey("r")).toBe("r");
-    expect(parseDevControlKey("3")).toBe("3");
-    expect(parseDevControlKey("\u001b")).toBe("esc");
+    expect(parseDevControlKey("c")).toBeNull();
+    expect(parseDevControlKey("l")).toBeNull();
+    expect(parseDevControlKey("3")).toBeNull();
+    expect(parseDevControlKey("")).toBeNull();
     expect(parseDevControlKey("z")).toBeNull();
   });
 
+  test("parseDevControlKey maps Ctrl+C to quit", () => {
+    expect(parseDevControlKey(CTRL_C)).toBe("q");
+  });
+
   test("format hint and help are scannable", () => {
     expect(formatDevControlsHint(false)).toContain("keys");
     expect(formatDevControlsHint(false)).toContain("refresh");
     expect(formatDevControlsHint(false)).toContain("quit");
-    expect(formatDevControlsHelp(false)).toContain("select service");
+    expect(formatDevControlsHint(false)).not.toContain("services");
     expect(formatDevControlsHelp(false)).toContain("refresh");
-    expect(formatDevControlsHelp(false)).not.toMatch(/\u001b\[/);
+    expect(formatDevControlsHelp(false)).not.toContain("select service");
   });
 
-  test("controlServicesFromStack dedupes by serviceName", () => {
-    const list = controlServicesFromStack([
-      { label: "ai", serviceName: "ai" },
-      { label: "mail", serviceName: "channel-email" },
-      { label: "mail-ui", serviceName: "channel-email" },
-      { label: "postgres", serviceName: "store-sql" },
-    ]);
-    expect(list.map((s) => s.serviceName)).toEqual(["ai", "channel-email", "store-sql"]);
-  });
-
-  test("formatDevControlsServiceList numbers rows", () => {
-    const out = formatDevControlsServiceList(
-      [
-        { label: "ai", serviceName: "ai" },
-        { label: "postgres", serviceName: "store-sql" },
-      ],
-      (name) => (name === "ai" ? "error" : "ready"),
-      false,
-      1,
-    );
-    expect(out).toContain("1");
-    expect(out).toContain("ai");
-    expect(out).toContain("postgres");
-    expect(out).toContain(">");
-  });
-
-  test("dispatcher select → stop → up stack → quit", async () => {
+  test("dispatcher up -> stop -> refresh -> help -> quit", async () => {
     const calls: string[] = [];
     let quit = false;
     let settled = 0;
@@ -79,29 +56,47 @@ describe("dev-controls", () => {
       onComposeSettled: () => {
         settled += 1;
       },
-      services: () => [
-        { label: "ai", serviceName: "ai" },
-        { label: "postgres", serviceName: "store-sql" },
-      ],
-      composeAction: async (action, names) => {
-        calls.push(`${action}:${names.join(",") || "*"}`);
+      composeAction: async (action) => {
+        calls.push(action);
       },
     });
-    d.handleKey("l");
+    d.handleKey("u");
     await Bun.sleep(10);
-    d.handleKey("1");
     d.handleKey("x");
     await Bun.sleep(10);
-    d.handleKey("u");
+    d.handleKey("r");
     await Bun.sleep(10);
-    d.handleKey("c");
+    d.handleKey("?");
     await Bun.sleep(10);
     d.handleKey("q");
-    expect(calls).toEqual(["stop:ai", "up:*"]);
+    expect(calls).toEqual(["up", "stop"]);
     expect(settled).toBe(2);
     expect(refreshed).toBe(1);
     expect(panels).toBe(1);
     expect(quit).toBe(true);
     d.stop();
   });
+
+  test("busy compose action ignores a concurrent key press", async () => {
+    let running = 0;
+    let maxConcurrent = 0;
+    const calls: string[] = [];
+    const d = createDevControlDispatcher({
+      write: () => {},
+      onQuit: () => {},
+      composeAction: async (action) => {
+        running += 1;
+        maxConcurrent = Math.max(maxConcurrent, running);
+        await Bun.sleep(20);
+        calls.push(action);
+        running -= 1;
+      },
+    });
+    d.handleKey("u");
+    d.handleKey("x");
+    await Bun.sleep(40);
+    expect(calls).toEqual(["up"]);
+    expect(maxConcurrent).toBe(1);
+    d.stop();
+  });
 });

package/src/cli/dev-controls.ts

@@ -1,31 +1,17 @@
 /**
  * Keyboard controls for a live `oke dev` session (TTY raw mode).
  *
- * Keys: `?` help · `q` quit · `c` refresh · `l` list · `u` up all ·
- * `x` stop all · `1`–`9` select service then `u`/`x`/`r`.
+ * Keys: `?` help · `q` quit · `r` refresh · `u` up all · `x` stop all.
  *
- * Compose health / model phase update the status board above Logs — not
- * the log stream. `c` clears the TTY and reprints the latest board.
+ * Compose health / model phase update the status board above Logs — it
+ * already lists every service with a live ● status, so refresh alone is
+ * enough to see the stack; there is no separate services panel.
  */
 
-import {
-  formatStatusDot,
-  formatStatusLine,
-  termColorEnabled,
-  termStyle,
-  type DevStatus,
-} from "../term.ts";
+import { formatStatusLine, termColorEnabled, termStyle } from "../term.ts";
 
-/** One Docker service row addressable by a digit key. */
-export type DevControlService = {
-  /** Human label (`ai`, `postgres`). */
-  readonly label: string;
-  /** Compose service name (`ai`, `store-sql`). */
-  readonly serviceName: string;
-};
-
-/** Compose action against zero or more service names. */
-export type DevComposeControlAction = "up" | "stop" | "restart";
+/** Compose action against the whole stack. */
+export type DevComposeControlAction = "up" | "stop";
 
 /** Options for {@link startDevControls}. */
 export type StartDevControlsOptions = {
@@ -37,30 +23,22 @@ export type StartDevControlsOptions = {
    */
   readonly onRefresh?: () => void | Promise<void>;
   /**
-   * Show help / services in a clean pane (typically refresh chrome first so
-   * the panel is not interleaved with request logs).
+   * Show help in a clean pane (refreshes chrome first so the panel is not
+   * interleaved with request logs).
    *
    * @param body - Formatted panel text
    */
   readonly onShowPanel?: (body: string) => void | Promise<void>;
   /**
-   * After a compose up/stop/restart — sync health into the board (no log lines).
+   * After a compose up/stop — sync health into the board (no log lines).
    */
   readonly onComposeSettled?: () => void | Promise<void>;
-  /** Live service catalogue (unique compose services). */
-  readonly services: () => readonly DevControlService[];
   /**
-   * Run a compose control action.
+   * Run a compose control action against the whole stack.
    *
-   * @param action - up / stop / restart
-   * @param serviceNames - Empty → whole stack
+   * @param action - up / stop
    */
-  readonly composeAction: (
-    action: DevComposeControlAction,
-    serviceNames: readonly string[],
-  ) => Promise<void>;
-  /** Optional live ● status for list view. */
-  readonly statusOf?: (serviceName: string) => DevStatus | undefined;
+  readonly composeAction: (action: DevComposeControlAction) => Promise<void>;
   readonly stdin?: NodeJS.ReadStream;
   readonly isTTY?: boolean;
   readonly color?: boolean;
@@ -81,9 +59,8 @@ export function formatDevControlsHint(color: boolean = termColorEnabled()): stri
   return (
     `${s.dim}│${s.reset}  ${s.dim}keys${s.reset}  ` +
     `${s.cyan}?${s.reset} help · ` +
-    `${s.cyan}c${s.reset} refresh · ` +
+    `${s.cyan}r${s.reset} refresh · ` +
     `${s.cyan}q${s.reset} quit · ` +
-    `${s.cyan}l${s.reset} services · ` +
     `${s.cyan}u${s.reset} up · ` +
     `${s.cyan}x${s.reset} stop` +
     `\n`
@@ -104,63 +81,15 @@ export function formatDevControlsHelp(color: boolean = termColorEnabled()): stri
     "",
     `${s.green}◇${s.reset}  ${s.bold}Keys${s.reset}`,
     k("?", "help"),
-    k("c", "refresh — clear logs, show latest ●"),
+    k("r", "refresh — clear logs, show latest ●"),
     k("q", "quit oke dev"),
-    k("l", "list docker services"),
     k("u", "compose up -d (all)"),
     k("x", "compose stop (all)"),
-    k("1-9", "select service"),
-    k("… u", "start selected"),
-    k("… x", "stop selected"),
-    k("… r", "restart selected"),
-    k("esc", "clear selection"),
     bar,
     "",
   ].join("\n");
 }
 
-/**
- * Format a numbered service list for `l`.
- *
- * @param services - Catalogue
- * @param statusOf - Optional ● lookup
- * @param color - Color on/off
- * @param selected - Highlighted 1-based index
- */
-export function formatDevControlsServiceList(
-  services: readonly DevControlService[],
-  statusOf?: (serviceName: string) => DevStatus | undefined,
-  color: boolean = termColorEnabled(),
-  selected?: number,
-): string {
-  const s = termStyle(color);
-  const bar = `${s.dim}│${s.reset}`;
-  if (services.length === 0) {
-    return `${bar}  ${s.dim}no docker services${s.reset}\n`;
-  }
-  const lines = [
-    "",
-    `${s.green}◇${s.reset}  ${s.bold}Services${s.reset}  ${s.dim}1-9 then u/x/r${s.reset}`,
-  ];
-  const max = Math.min(9, services.length);
-  for (let i = 0; i < max; i++) {
-    const svc = services[i]!;
-    const st = statusOf?.(svc.serviceName) ?? "pending";
-    const dot = formatStatusDot(st, color);
-    const num = `${i + 1}`;
-    const mark = selected === i + 1 ? `${s.cyan}>${s.reset}` : " ";
-    lines.push(
-      `${bar}  ${mark}${s.cyan}${num}${s.reset}  ${dot}  ${svc.label.padEnd(12)}  ${s.dim}${svc.serviceName}${s.reset}`,
-    );
-  }
-  if (services.length > 9) {
-    lines.push(`${bar}  ${s.dim}… ${services.length - 9} more (first 9 only)${s.reset}`);
-  }
-  lines.push(bar);
-  lines.push("");
-  return `${lines.join("\n")}\n`;
-}
-
 /**
  * Parse one raw stdin chunk into a control key (tests / non-TTY inject).
  *
@@ -169,16 +98,12 @@ export function formatDevControlsServiceList(
 export function parseDevControlKey(chunk: string): string | null {
   if (chunk.length === 0) return null;
   if (chunk === "\u0003") return "q"; // Ctrl+C
-  if (chunk === "\u001b") return "esc";
   const ch = chunk[0]!;
   if (ch === "?" || ch === "h" || ch === "H") return "?";
-  if (ch === "c" || ch === "C") return "c";
   if (ch === "q" || ch === "Q") return "q";
-  if (ch === "l" || ch === "L") return "l";
+  if (ch === "r" || ch === "R") return "r";
   if (ch === "u" || ch === "U") return "u";
   if (ch === "x" || ch === "X") return "x";
-  if (ch === "r" || ch === "R") return "r";
-  if (ch >= "1" && ch <= "9") return ch;
   return null;
 }
 
@@ -191,23 +116,18 @@ export type DevControlDispatcher = {
 /**
  * Pure key dispatcher (no stdin) — used by tests and the TTY listener.
  *
- * @param opts - Quit / compose / services
+ * @param opts - Quit / compose actions
  */
 export function createDevControlDispatcher(opts: StartDevControlsOptions): DevControlDispatcher {
   const color = opts.color ?? termColorEnabled();
-  let selected: number | null = null;
   let busy = false;
   let stopped = false;
 
-  const runAction = async (
-    action: DevComposeControlAction,
-    serviceNames: readonly string[],
-    _label: string,
-  ): Promise<void> => {
+  const runAction = async (action: DevComposeControlAction): Promise<void> => {
     if (busy) return;
     busy = true;
     try {
-      await opts.composeAction(action, serviceNames);
+      await opts.composeAction(action);
       await opts.onComposeSettled?.();
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -224,7 +144,7 @@ export function createDevControlDispatcher(opts: StartDevControlsOptions): DevCo
         opts.onQuit();
         return;
       }
-      if (key === "c") {
+      if (key === "r") {
         void Promise.resolve(opts.onRefresh?.()).catch((err: unknown) => {
           const msg = err instanceof Error ? err.message : String(err);
           opts.write(formatStatusLine(`refresh failed — ${msg}`, color, "error"));
@@ -236,58 +156,8 @@ export function createDevControlDispatcher(opts: StartDevControlsOptions): DevCo
         void Promise.resolve(opts.onShowPanel?.(body) ?? opts.write(body));
         return;
       }
-      if (key === "esc") {
-        selected = null;
-        return;
-      }
-      if (key === "l") {
-        const body = formatDevControlsServiceList(
-          opts.services(),
-          opts.statusOf,
-          color,
-          selected ?? undefined,
-        );
-        void Promise.resolve(opts.onShowPanel?.(body) ?? opts.write(body));
-        return;
-      }
-      if (key >= "1" && key <= "9") {
-        const n = Number(key);
-        const list = opts.services();
-        if (n < 1 || n > list.length || n > 9) {
-          opts.write(formatStatusLine(`no service ${n} — press l to list`, color, "pending"));
-          return;
-        }
-        selected = n;
-        const svc = list[n - 1]!;
-        opts.write(
-          formatStatusLine(
-            `selected ${n} ${svc.label} — u start · x stop · r restart · esc`,
-            color,
-            opts.statusOf?.(svc.serviceName) ?? "pending",
-          ),
-        );
-        return;
-      }
-      if (key === "u" || key === "x" || key === "r") {
-        const action: DevComposeControlAction =
-          key === "u" ? "up" : key === "x" ? "stop" : "restart";
-        if (selected !== null) {
-          const list = opts.services();
-          const svc = list[selected - 1];
-          if (!svc) {
-            selected = null;
-            opts.write(formatStatusLine("selection expired — press l", color, "pending"));
-            return;
-          }
-          selected = null;
-          void runAction(action, [svc.serviceName], svc.label);
-          return;
-        }
-        if (key === "r") {
-          opts.write(formatStatusLine("select a service first (l then 1-9)", color, "pending"));
-          return;
-        }
-        void runAction(action, [], "stack");
+      if (key === "u" || key === "x") {
+        void runAction(key === "u" ? "up" : "stop");
       }
     },
     stop() {
@@ -299,7 +169,7 @@ export function createDevControlDispatcher(opts: StartDevControlsOptions): DevCo
 /**
  * Start raw-mode keyboard controls. No-op when stdin is not a TTY.
  *
- * @param opts - Quit / compose / services
+ * @param opts - Quit / compose actions
  */
 export function startDevControls(opts: StartDevControlsOptions): DevControlsHandle {
   const stdin = opts.stdin ?? process.stdin;
@@ -333,22 +203,3 @@ export function startDevControls(opts: StartDevControlsOptions): DevControlsHand
     },
   };
 }
-
-/**
- * Dedupe stack summary rows into control services (first label wins).
- *
- * @param rows - Stack summary services with compose names
- */
-export function controlServicesFromStack(
-  rows: readonly { readonly label: string; readonly serviceName?: string }[],
-): DevControlService[] {
-  const seen = new Set<string>();
-  const out: DevControlService[] = [];
-  for (const row of rows) {
-    const name = row.serviceName?.trim();
-    if (!name || seen.has(name)) continue;
-    seen.add(name);
-    out.push({ label: row.label, serviceName: name });
-  }
-  return out;
-}

package/src/cli/dev.test.ts

@@ -398,13 +398,11 @@ async function writePingApp(dir: string, version: string): Promise<void> {
     join(dir, "src/flows/ping.ts"),
     `import { on, flow, http, gate } from ${JSON.stringify(OKE_INDEX)};
 
-export const ping = on(http.get("/ping").gate(gate.public), flow({
-  name: "ping",
+export const ping = on(http.get("/ping").gate(gate.public), flow("ping", {
   do: () => ({ version: ${JSON.stringify(version)} as const }),
 }));
 
-export const slow = on(http.get("/slow").gate(gate.public), flow({
-  name: "slow",
+export const slow = on(http.get("/slow").gate(gate.public), flow("slow", {
   do: async () => {
     const started = ${JSON.stringify(version)};
     await Bun.sleep(800);

package/src/cli/dev.ts

@@ -47,7 +47,6 @@ import { clientAdd } from "./client-add.ts";
 import { resolveDriverId } from "../config/index.ts";
 import { askDevMode, type AskDevModeFn } from "./ask-dev-mode.ts";
 import {
-  controlServicesFromStack,
   formatDevControlsHint,
   startDevControls,
   type DevComposeControlAction,
@@ -177,6 +176,17 @@ export interface DevOptions {
    * @param filename - Relative path from the watcher
    */
   readonly onDbAutoPush?: (filename: string) => void;
+  /**
+   * Injectable `.adopt()` barrel regeneration (tests). Default: real
+   * `generateAdoptBarrel` + write to `<cwd>/src/flows/generated.ts`. 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`).
+   *
+   * @param cwd - Project root
+   */
+  readonly syncAdoptBarrel?: (cwd: string) => Promise<readonly string[]>;
   /** Watch project source changes (injectable for tests). */
   readonly watchFs?: DevWatchFn;
   readonly images?: Readonly<Record<string, string>>;
@@ -233,6 +243,21 @@ export interface DevOptions {
     readonly env: Record<string, string>;
     readonly onUpdate?: (service: string, status: DevStatus) => void;
   }) => Promise<Map<string, DevStatus>>;
+  /**
+   * Injectable `docker compose ps` runner for live health polls
+   * ({@link startComposeHealthWatch} / keyboard refresh). Default: real
+   * `docker`. When {@link DevOptions.composeHealth} is set and this is
+   * omitted, live polls return empty (unit tests never shell out).
+   *
+   * @param args - Args after `docker` (e.g. `compose -f … ps -a …`)
+   * @param cwd - Compose directory
+   * @param env - Stack env merged into the process env
+   */
+  readonly composeHealthRun?: (
+    args: readonly string[],
+    cwd: string,
+    env: Record<string, string>,
+  ) => Promise<string>;
   /**
    * Regenerate client types (injectable).
    *
@@ -298,6 +323,14 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
   /** Reassigned to {@link createAnchoredBoard} wrap after the status board paints. */
   let write: (text: string) => void = options.write ?? ((t) => process.stdout.write(t));
   const chromeWrite = (t: string) => write(formatCliChrome(t));
+  /**
+   * `docker compose ps` runner for live / default health polls.
+   * Explicit inject wins; otherwise a `composeHealth` inject implies tests —
+   * never shell out to a real `docker` binary.
+   */
+  const composeHealthRun =
+    options.composeHealthRun ??
+    (options.composeHealth ? async (): Promise<string> => "[]" : undefined);
   const previousWarn = console.warn;
   console.warn = (...args: unknown[]) => {
     const msg = args.map(String).join(" ");
@@ -311,6 +344,28 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
     console.warn = previousWarn;
   };
   const cwd = options.cwd ?? process.cwd();
+
+  // One-shot `.adopt()` barrel regen for the session — real file on disk
+  // (`src/flows/generated.ts`), written before the entry is resolved/imported
+  // below so a freshly-added flows unit is adoptable without a hand edit.
+  // Best-effort like `syncDevSchema` below: a project with no `src/flows`
+  // yet (or a synthetic test tree) never blocks the dev session.
+  const syncAdoptBarrel =
+    options.syncAdoptBarrel ??
+    (async (root: string) => {
+      const { generateAdoptBarrel } = await import("../compiler/generate-adopt.ts");
+      const { mkdir, writeFile } = await import("node:fs/promises");
+      const { source, units } = await generateAdoptBarrel({ rootDir: root });
+      await mkdir(resolve(root, "src/flows"), { recursive: true });
+      await writeFile(resolve(root, "src/flows/generated.ts"), source);
+      return units;
+    });
+  try {
+    await syncAdoptBarrel(cwd);
+  } catch {
+    /* best-effort — boot-time assertAdoptBarrelFresh (rootDir opt-in) is the real gate */
+  }
+
   const preferredApp = options.appPort ?? Number(Bun.env.PORT ?? APP_PORT);
   const preferredConsole = options.consolePort ?? CONSOLE_PORT;
   const preferredMcp = options.mcpPort ?? MCP_PORT;
@@ -656,6 +711,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
               files: composeFiles,
               cwd: dockerOut,
               env: dockerStarted.env,
+              run: composeHealthRun,
               timeoutMs: 20_000,
               isDone: (map) => {
                 // Empty ps (compose just-created / injectable gap): do not spin 20s.
@@ -952,6 +1008,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
       files: started.files,
       cwd: started.cwd,
       env: started.env,
+      run: composeHealthRun,
       intervalMs: 2_000,
       onChange: (map) => {
         liveComposeHealth = map;
@@ -1325,6 +1382,7 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
         files: started.files,
         cwd: started.cwd,
         env: started.env,
+        run: composeHealthRun,
       });
       if (liveComposeHealth.get("ai") === "error") heroAiStatus = "error";
       repaintBoard();
@@ -1362,29 +1420,18 @@ export async function runDev(options: DevOptions = {}): Promise<DevResult> {
         process.exit(0);
       },
       onRefresh: () => refreshChrome(),
-      // Refresh first so help/services never sit in the middle of request logs.
+      // Refresh first so help never sits in the middle of request logs.
       onShowPanel: async (body) => {
         await refreshChrome();
         write(body);
       },
       onComposeSettled: () => syncComposeBoard(),
-      services: () => controlServicesFromStack(pendingStackSummary?.services ?? []),
-      statusOf: (serviceName) => liveComposeHealth.get(serviceName),
-      composeAction: async (action: DevComposeControlAction, serviceNames) => {
+      composeAction: async (action: DevComposeControlAction) => {
         const files = started.files;
         const finalArgs =
-          action === "up" && serviceNames.length === 0
+          action === "up"
             ? ["compose", ...files.flatMap((f) => ["-f", f]), "up", "-d"]
-            : action === "up"
-              ? [
-                  "compose",
-                  ...files.flatMap((f) => ["-f", f]),
-                  "up",
-                  "-d",
-                  "--no-deps",
-                  ...serviceNames,
-                ]
-              : ["compose", ...files.flatMap((f) => ["-f", f]), action, ...serviceNames];
+            : ["compose", ...files.flatMap((f) => ["-f", f]), action];
         const proc = Bun.spawn(["docker", ...finalArgs], {
           cwd: started.cwd,
           stdout: "pipe",

package/src/cli/docker-cli.test.ts

@@ -207,6 +207,21 @@ describe("oke start", () => {
     expect(code).toBe(0);
     expect(ran).toBe(entry);
   });
+
+  test("sets OKE_ROOT_DIR so boot() can lazily derive effects for undeclared flows", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-cli-start-rootdir-"));
+    await Bun.write(join(dir, "src/app.ts"), "export {}\n");
+    let seenRootDir: string | undefined;
+    const code = await runStart({
+      cwd: dir,
+      runEntry: async (_e, env) => {
+        seenRootDir = env.OKE_ROOT_DIR;
+      },
+      write: () => {},
+    });
+    expect(code).toBe(0);
+    expect(seenRootDir).toBe(dir);
+  });
 });
 
 describe("oke vault", () => {

package/src/cli/start.ts

@@ -55,7 +55,18 @@ export async function runStart(options: StartOptions = {}): Promise<number> {
   try {
     const entry = await resolveStartEntry(cwd, options.entry);
     const port = String(options.port ?? Number(Bun.env.PORT ?? APP_PORT));
-    const env = { ...process.env, NODE_ENV: "production", PORT: port } as Record<string, string>;
+    const env = {
+      ...process.env,
+      NODE_ENV: "production",
+      PORT: port,
+      // Signal to boot() where to lazily extract effects from when a flow
+      // has no hand-declared `effects` — kernel/boot.ts's mintCapabilities()
+      // reads this (explicit opt-in only). docker/prod hard-fail (OKE1008)
+      // rather than silently open when neither this nor an explicit
+      // `manifest` resolves anything — this just gives that resolution a
+      // real chance to succeed instead of failing every time.
+      OKE_ROOT_DIR: process.env["OKE_ROOT_DIR"] ?? cwd,
+    } as Record<string, string>;
     write(`oke start: ${entry} (port ${port})\n`);
     if (options.runEntry) {
       await options.runEntry(entry, env);

package/src/client/notes-contract.test.ts

@@ -37,7 +37,7 @@ const NotFound = z.object({});
 
 const create = on(
   http.post("/notes"),
-  flow({
+  flow("notes.create", {
     in: NewNote,
     out: NoteId,
     do: (input) => ({ id: `n_${input.title}` }),
@@ -46,7 +46,7 @@ const create = on(
 
 const get = on(
   http.get("/notes/:id"),
-  flow({
+  flow("notes.get", {
     in: NoteId,
     out: Note,
     errors: { NotFound },
@@ -250,8 +250,7 @@ describe("Notes — typeof app carries contracts", () => {
   });
 
   test("untriggered adopted flow is RPC-only on the client", async () => {
-    const stats = flow({
-      name: "notes.stats",
+    const stats = flow("notes.stats", {
       in: NoteId,
       out: z.object({ clicks: z.number() }),
       do: () => ({ clicks: 7 }),

package/src/compiler/aot.test.ts

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