flockbay 0.10.21 → 0.10.23

package/dist/{index-By332wvJ.mjs → index-CRGcIpET.mjs}

@@ -1,14 +1,14 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir } from 'node:os';
 import { randomUUID, createCipheriv, randomBytes } from 'node:crypto';
-import { l as logger, p as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as readDaemonState, g as clearDaemonState, b as packageJson, r as readSettings, h as readCredentials, u as updateSettings, w as writeCredentials, i as unrealMcpPythonDir, j as acquireDaemonLock, k as writeDaemonState, m as ApiMachineClient, n as releaseDaemonLock, s as sendUnrealMcpTcpCommand, A as ApiClient, o as clearCredentials, q as clearMachineId, t as installUnrealMcpPluginToEngine, v as getLatestDaemonLog, x as normalizeServerUrlForNode } from './types-mXJc7o0P.mjs';
+import { l as logger, p as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as readDaemonState, g as clearDaemonState, b as packageJson, r as readSettings, h as readCredentials, u as updateSettings, w as writeCredentials, i as unrealMcpPythonDir, j as acquireDaemonLock, k as writeDaemonState, m as ApiMachineClient, n as releaseDaemonLock, s as sendUnrealMcpTcpCommand, A as ApiClient, o as clearCredentials, q as clearMachineId, t as installUnrealMcpPluginToEngine, v as buildAndInstallUnrealMcpPlugin, x as getLatestDaemonLog, y as normalizeServerUrlForNode } from './types-CNn15BaT.mjs';
 import { spawn, execFileSync, execSync } from 'node:child_process';
 import path, { resolve, join, dirname } from 'node:path';
 import { createInterface } from 'node:readline';
 import * as fs from 'node:fs';
 import fs__default, { existsSync, readFileSync, mkdirSync, readdirSync, accessSync, constants, statSync, createReadStream, writeFileSync, unlinkSync } from 'node:fs';
 import process$1 from 'node:process';
-import fs$1, { readFile, access as access$1, mkdir, readdir, stat } from 'node:fs/promises';
+import fs$1, { readFile, access as access$1, mkdir, readdir, stat, rename, open as open$1 } from 'node:fs/promises';
 import fs$2, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
@@ -386,7 +386,7 @@ const PLATFORM_SYSTEM_PROMPT = trimIdent(`
 
   # Policy blocks (not user rejections)
 
-  If a tool call is **blocked by policy** (e.g. a \`FlockbayPolicy\` card, or a denial reason like \u201CBlocked by policy \u2026\u201D), this is automatic enforcement by the platform \u2014 it is **not** the user rejecting your tool call. Follow the provided next-step instructions (read docs/ledger, claim files, etc) and then retry.
+  If a tool call is **blocked by Policy** (e.g. a \`FlockbayPolicy\` card, or a denial reason like \u201CBlocked by Policy \u2026\u201D), this is automatic enforcement by the platform \u2014 it is **not** the user rejecting your tool call. Follow the provided next-step instructions (read docs/ledger, claim files, etc) and then retry.
 
   # Documentation Library (server-stored docs)
 
@@ -2523,7 +2523,7 @@ class PermissionHandler {
     const decision = args.decision;
     const reason = args.reason;
     const kind = decision === "approved" || decision === "approved_for_session" ? "policy_allow" : decision === "abort" && reason === "permission_prompt_required" ? "policy_prompt" : "policy_block";
-    const summary = kind === "policy_allow" ? "Allowed." : kind === "policy_prompt" ? "Waiting for permission to run this tool." : reason ? `Blocked: ${reason}` : "Blocked by policy.";
+    const summary = kind === "policy_allow" ? "Allowed." : kind === "policy_prompt" ? "Waiting for permission to run this tool." : reason ? `Blocked: ${reason}` : "Blocked by Policy.";
     const callId = `policy:${args.toolCallId}:${randomUUID().slice(0, 8)}`;
     const payload = {
       kind,
@@ -2588,13 +2588,13 @@ class PermissionHandler {
     if (args.reason === "docs_index_read_required") {
       return {
         uiReason: "read the game Documentation index before making edits.",
-        modelMessage: "Blocked by policy: read the game Documentation index before making edits.\nNext: call `mcp__flockbay__docs_index_read`, then retry the edit."
+        modelMessage: "Blocked by Policy: read the game Documentation index before making edits.\nNext: call `mcp__flockbay__docs_index_read`, then retry the edit."
       };
     }
     if (args.reason === "ledger_read_required") {
       return {
         uiReason: "read the ledger before making file edits.",
-        modelMessage: "Blocked by policy: read the ledger before making file edits.\nNext: call `mcp__flockbay__ledger_read` (or `mcp__flockbay__coordination_ledger_snapshot`), then retry the edit."
+        modelMessage: "Blocked by Policy: read the ledger before making file edits.\nNext: call `mcp__flockbay__ledger_read` (or `mcp__flockbay__coordination_ledger_snapshot`), then retry the edit."
       };
     }
     if (args.reason === "file_claim_required") {
@@ -2602,13 +2602,13 @@ class PermissionHandler {
       const next = file ? `Next: claim it via \`mcp__flockbay__ledger_claim\` (files: ["${file}"]) or \`mcp__flockbay__coordination_claim_files\`, then retry the edit.` : "Next: claim the file via `mcp__flockbay__ledger_claim` (or `mcp__flockbay__coordination_claim_files`), then retry the edit.";
       return {
         uiReason: display,
-        modelMessage: `Blocked by policy: ${display}
+        modelMessage: `Blocked by Policy: ${display}
 ${next}`
       };
     }
     return {
       uiReason: "this session is in read-only mode.",
-      modelMessage: "Blocked by policy: this session is in read-only mode.\nNext: switch permission mode to allow edits, then retry."
+      modelMessage: "Blocked by Policy: this session is in read-only mode.\nNext: switch permission mode to allow edits, then retry."
     };
   }
   enforceCoordinationGate(toolName, input) {
@@ -7173,7 +7173,7 @@ async function uploadScreenshotViewsForSession(args) {
     const buf = await readFile(v.path);
     const filename = path.basename(v.path);
     const contentType = (() => {
-      const mime = detectImageMimeTypeFromBuffer(buf);
+      const mime = detectImageMimeTypeFromBuffer$1(buf);
       if (mime) return mime;
       throw new Error(`Unsupported screenshot format (expected PNG/JPEG): ${v.path}`);
     })();
@@ -7217,7 +7217,7 @@ async function uploadScreenshotViewsForSession(args) {
   }
   return out;
 }
-function detectImageMimeTypeFromBuffer(buf) {
+function detectImageMimeTypeFromBuffer$1(buf) {
   if (!buf || buf.length < 12) return null;
   if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71 && buf[4] === 13 && buf[5] === 10 && buf[6] === 26 && buf[7] === 10) {
     return "image/png";
@@ -7233,6 +7233,48 @@ function detectImageMimeTypeFromBuffer(buf) {
   }
   return null;
 }
+async function readFileHeader(filePath, bytes) {
+  const fh = await open$1(filePath, "r");
+  try {
+    const maxBytes = Math.max(1, Math.floor(bytes));
+    const buf = Buffer.allocUnsafe(maxBytes);
+    const { bytesRead } = await fh.read(buf, 0, maxBytes, 0);
+    return buf.subarray(0, bytesRead);
+  } finally {
+    try {
+      await fh.close();
+    } catch {
+    }
+  }
+}
+async function normalizeScreenshotPathExtensionToMatchBytes(filePath) {
+  const abs = String(filePath || "").trim();
+  if (!abs) return { path: abs, changed: false };
+  if (!existsSync(abs)) return { path: abs, changed: false };
+  const lower = abs.toLowerCase();
+  const header = await readFileHeader(abs, 16);
+  const mime = detectImageMimeTypeFromBuffer$1(header);
+  if (!mime) {
+    return { path: abs, changed: false, detail: "unknown_image_format" };
+  }
+  if (mime === "image/jpeg" && lower.endsWith(".png")) {
+    const next = abs.replace(/\.png$/i, ".jpg");
+    if (existsSync(next)) {
+      throw new Error(`Screenshot already exists at normalized path: ${next}`);
+    }
+    await rename(abs, next);
+    return { path: next, changed: true, detail: "renamed_png_to_jpg" };
+  }
+  if (mime === "image/png" && (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))) {
+    const next = abs.replace(/\.(jpg|jpeg)$/i, ".png");
+    if (existsSync(next)) {
+      throw new Error(`Screenshot already exists at normalized path: ${next}`);
+    }
+    await rename(abs, next);
+    return { path: next, changed: true, detail: "renamed_jpg_to_png" };
+  }
+  return { path: abs, changed: false };
+}
 async function startFlockbayServer(client, options) {
   const handler = async (title) => {
     logger.debug("[flockbayMCP] Changing title to:", title);
@@ -8829,7 +8871,7 @@ ${String(st.stdout || "").trim()}`
               throw new Error(`Image too large (${st.size} bytes) to embed: ${abs}`);
             }
             const buf = await readFile(abs);
-            const mime = detectImageMimeTypeFromBuffer(buf);
+            const mime = detectImageMimeTypeFromBuffer$1(buf);
             if (!mime) {
               throw new Error(`Unsupported image format (expected PNG/JPEG): ${abs}`);
             }
@@ -8879,7 +8921,7 @@ ${String(st.stdout || "").trim()}`
   );
   mcp.registerTool("unreal_latest_screenshots", {
     title: "Latest Unreal Screenshots (Validation)",
-    description: "Fetch the latest PNG screenshots from `Saved/Screenshots/Flockbay/` (for validation) and return a `{ views: [...] }` payload so the app can display them.",
+    description: "Fetch the latest screenshots (PNG/JPG) from `Saved/Screenshots/Flockbay/` (for validation) and return a `{ views: [...] }` payload so the app can display them.",
     inputSchema: {
       uprojectPath: z.string().describe("Absolute path to the .uproject file."),
       limit: z.number().int().positive().optional().describe("Max number of screenshots to return (default 12)."),
@@ -8916,7 +8958,7 @@ ${String(st.stdout || "").trim()}`
         };
       }
       const files = await readdir(outDir);
-      const candidates = files.filter((f) => f.toLowerCase().endsWith(".png"));
+      const candidates = files.filter((f) => /\.(png|jpg|jpeg)$/i.test(f));
       if (candidates.length === 0) {
         return {
           content: [
@@ -9171,10 +9213,26 @@ ${String(st.stdout || "").trim()}`
       const pluginInfoWasCached = Boolean(unrealMcpPluginInfoCache);
       const pluginInfo = type !== "get_plugin_info" ? await getUnrealMcpPluginInfoBestEffort(timeoutMs) : null;
       const response = await sendUnrealMcpTcpCommand({ type, params, timeoutMs });
+      let screenshotNormalizationNote = null;
+      if (type === "take_screenshot") {
+        const responseObj = response && typeof response === "object" ? response : null;
+        const candidate = responseObj && typeof responseObj.filepath === "string" ? responseObj : responseObj && responseObj.result && typeof responseObj.result === "object" && typeof responseObj.result.filepath === "string" ? responseObj.result : null;
+        if (candidate && typeof candidate.filepath === "string") {
+          const before = String(candidate.filepath || "").trim();
+          if (before) {
+            const normalized = await normalizeScreenshotPathExtensionToMatchBytes(before);
+            if (normalized.changed) {
+              candidate.filepath = normalized.path;
+              screenshotNormalizationNote = `Normalized screenshot path (${normalized.detail || "extension_fixed"}): ${before} \u2192 ${normalized.path}`;
+            }
+          }
+        }
+      }
       unrealEditorSupervisor.noteUnrealReachable();
       return {
         content: [
           { type: "text", text: `UnrealMCP command ok: ${type}` },
+          ...screenshotNormalizationNote ? [{ type: "text", text: screenshotNormalizationNote }] : [],
           { type: "text", text: JSON.stringify(response, null, 2) },
           ...pluginInfo && !pluginInfoWasCached ? [{ type: "text", text: formatUnrealMcpCapabilities(pluginInfo) }] : []
         ],
@@ -11834,6 +11892,269 @@ async function handleConnectVendor(vendor, displayName, flags) {
   }
 }
 
+function readArgValue$1(args, key) {
+  const idx = args.indexOf(key);
+  if (idx === -1) return null;
+  const value = args[idx + 1];
+  if (!value || value.startsWith("-")) return null;
+  return value;
+}
+function splitList(value) {
+  if (!value) return [];
+  return value.split(/[;,]/g).map((v) => v.trim()).filter(Boolean);
+}
+function ensureDir(dir) {
+  fs__default.mkdirSync(dir, { recursive: true });
+}
+function detectImageMimeTypeFromBuffer(buf) {
+  if (!buf || buf.length < 12) return null;
+  if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71 && buf[4] === 13 && buf[5] === 10 && buf[6] === 26 && buf[7] === 10) {
+    return "image/png";
+  }
+  if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "image/jpeg";
+  if (buf[0] === 71 && buf[1] === 73 && buf[2] === 70 && buf[3] === 56) return "image/gif";
+  if (buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) {
+    return "image/webp";
+  }
+  return null;
+}
+async function waitForUnreal(options) {
+  const startedAt = Date.now();
+  let lastErr = null;
+  while (Date.now() - startedAt < options.timeoutMs) {
+    try {
+      const res = await sendUnrealMcpTcpCommand({ type: "ping", host: options.host, port: options.port, timeoutMs: 2e3 });
+      const msg = typeof res?.message === "string" ? res.message : null;
+      if (msg === "pong") return { ok: true };
+    } catch (err) {
+      lastErr = err instanceof Error ? err.message : String(err);
+    }
+    await new Promise((r) => setTimeout(r, 750));
+  }
+  return {
+    ok: false,
+    error: `Timed out waiting for UnrealMCP ping after ${options.timeoutMs}ms.${lastErr ? ` Last error: ${lastErr}` : ""}`
+  };
+}
+function resolveUnrealEditorExe(engineRoot) {
+  const exe = process.platform === "win32" ? path.join(engineRoot, "Engine", "Binaries", "Win64", "UnrealEditor.exe") : path.join(engineRoot, "Engine", "Binaries", process.platform === "darwin" ? "Mac" : "Linux", "UnrealEditor");
+  return exe;
+}
+async function runRuntimeSmoke(options) {
+  const editorExe = resolveUnrealEditorExe(options.engineRoot);
+  if (!fs__default.existsSync(editorExe)) {
+    return { ok: false, error: `Missing UnrealEditor executable: ${editorExe}` };
+  }
+  if (!fs__default.existsSync(options.projectPath)) {
+    return { ok: false, error: `Missing .uproject: ${options.projectPath}` };
+  }
+  let child = null;
+  const ping = await waitForUnreal({ host: options.host, port: options.port, timeoutMs: 2e3 }).catch((e) => ({ ok: false, error: String(e) }));
+  if (!ping.ok && options.launchIfNeeded) {
+    const args = [
+      options.projectPath,
+      "-NoSplash",
+      "-NoSound",
+      "-nop4"
+    ];
+    child = spawn(editorExe, args, {
+      stdio: "ignore",
+      detached: false
+    });
+  }
+  const ready = await waitForUnreal({ host: options.host, port: options.port, timeoutMs: options.connectTimeoutMs });
+  if (!ready.ok) {
+    try {
+      child?.kill();
+    } catch {
+    }
+    return ready;
+  }
+  try {
+    const pluginInfo = await sendUnrealMcpTcpCommand({ type: "get_plugin_info", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
+    const createdBy = String(pluginInfo?.createdBy || "").trim();
+    const friendlyName = String(pluginInfo?.friendlyName || "").trim();
+    const baseDir = String(pluginInfo?.baseDir || "").trim();
+    const schemaVersion = Number(pluginInfo?.schemaVersion);
+    const commands = Array.isArray(pluginInfo?.commands) ? pluginInfo.commands.filter((c) => typeof c === "string") : [];
+    if (friendlyName !== "Flockbay MCP" || createdBy !== "Respaced Inc.") {
+      return {
+        ok: false,
+        error: `Unexpected plugin identity loaded by Unreal.
+friendlyName=${friendlyName || "(missing)"} createdBy=${createdBy || "(missing)"}
+baseDir=${baseDir || "(missing)"}
+Expected FriendlyName="Flockbay MCP" CreatedBy="Respaced Inc."`
+      };
+    }
+    if (!Number.isFinite(schemaVersion) || schemaVersion <= 0) {
+      return { ok: false, error: `Invalid schemaVersion from get_plugin_info: ${String(pluginInfo?.schemaVersion)}` };
+    }
+    const requireCommands = [
+      "ping",
+      "get_plugin_info",
+      "list_capabilities",
+      "get_command_schema",
+      "get_play_in_editor_status",
+      "play_in_editor_windowed",
+      "stop_play_in_editor",
+      "take_screenshot",
+      "create_blueprint",
+      "compile_blueprint",
+      "map_check"
+    ];
+    const missing = requireCommands.filter((c) => !commands.includes(c));
+    if (missing.length > 0) {
+      return { ok: false, error: `Missing required commands in this UnrealMCP build: ${missing.join(", ")}` };
+    }
+    const playStatus0 = await sendUnrealMcpTcpCommand({ type: "get_play_in_editor_status", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
+    const isPlaying = Boolean(playStatus0?.isPlaySessionInProgress);
+    if (isPlaying) {
+      await sendUnrealMcpTcpCommand({ type: "stop_play_in_editor", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
+    }
+    await sendUnrealMcpTcpCommand({ type: "play_in_editor_windowed", host: options.host, port: options.port, timeoutMs: Math.max(options.timeoutMs, 2e4) });
+    await new Promise((r) => setTimeout(r, 1e3));
+    await sendUnrealMcpTcpCommand({ type: "stop_play_in_editor", host: options.host, port: options.port, timeoutMs: Math.max(options.timeoutMs, 2e4) });
+    const projectDir = path.dirname(options.projectPath);
+    const shotsDir = path.join(projectDir, "Saved", "Screenshots", "Flockbay");
+    ensureDir(shotsDir);
+    const shotPath = path.join(shotsDir, `smoke_${Date.now()}.png`);
+    await sendUnrealMcpTcpCommand({
+      type: "take_screenshot",
+      params: { filepath: shotPath },
+      host: options.host,
+      port: options.port,
+      timeoutMs: options.timeoutMs
+    });
+    if (!fs__default.existsSync(shotPath)) return { ok: false, error: `Screenshot did not exist on disk after take_screenshot: ${shotPath}` };
+    const bytes = fs__default.readFileSync(shotPath);
+    const mime = detectImageMimeTypeFromBuffer(bytes);
+    if (mime !== "image/png") {
+      return { ok: false, error: `Screenshot bytes do not match .png extension (detected ${mime || "unknown"}): ${shotPath}` };
+    }
+    const bpName = `BP_Smoke_${Date.now()}`;
+    await sendUnrealMcpTcpCommand({
+      type: "create_blueprint",
+      params: { name: bpName, path: "/Game/FlockbaySmoke/", parent_class: "Actor" },
+      host: options.host,
+      port: options.port,
+      timeoutMs: Math.max(options.timeoutMs, 2e4)
+    });
+    await sendUnrealMcpTcpCommand({
+      type: "compile_blueprint",
+      params: { blueprint_name: bpName },
+      host: options.host,
+      port: options.port,
+      timeoutMs: Math.max(options.timeoutMs, 6e4)
+    });
+    await sendUnrealMcpTcpCommand({
+      type: "map_check",
+      host: options.host,
+      port: options.port,
+      timeoutMs: Math.max(options.timeoutMs, 3e4)
+    });
+    return { ok: true };
+  } finally {
+    if (options.killAfter && child) {
+      try {
+        if (process.platform === "win32") {
+          spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+        } else {
+          child.kill();
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function runUnrealMcpMatrixSmoke(args) {
+  const engineRoots = splitList(readArgValue$1(args, "--engine-roots")) || [];
+  const engineRootSingle = readArgValue$1(args, "--engine-root");
+  if (engineRootSingle) engineRoots.push(engineRootSingle.trim());
+  const project = readArgValue$1(args, "--project");
+  const host = (readArgValue$1(args, "--host") || "127.0.0.1").trim() || "127.0.0.1";
+  const port = Number(readArgValue$1(args, "--port") || "55557");
+  const connectTimeoutMs = Number(readArgValue$1(args, "--connect-timeout-ms") || "180000");
+  const timeoutMs = Number(readArgValue$1(args, "--timeout-ms") || "30000");
+  const doBuild = !args.includes("--runtime-only");
+  const doRuntime = !args.includes("--build-only");
+  const launch = args.includes("--launch-editor");
+  const killAfter = args.includes("--kill-editor");
+  if (engineRoots.length === 0) {
+    console.error(chalk.red("Missing --engine-root or --engine-roots."));
+    console.error(chalk.gray('Example: flockbay doctor unreal-mcp-smoke --engine-roots "C:\\\\Epic\\\\UE_5.5;C:\\\\Epic\\\\UE_5.6" --project "C:\\\\Projects\\\\MyProj\\\\MyProj.uproject" --launch-editor --kill-editor'));
+    process.exit(1);
+  }
+  if (doRuntime && !project) {
+    console.error(chalk.red("Missing --project (required for runtime smoke)."));
+    process.exit(1);
+  }
+  console.log(chalk.bold("\nUnrealMCP Matrix Smoke\n"));
+  console.log(chalk.gray(`Platform: ${process.platform}`));
+  console.log(chalk.gray(`Host:     ${host}:${port}`));
+  console.log(chalk.gray(`Engines:  ${engineRoots.join(", ")}`));
+  if (project) console.log(chalk.gray(`Project:  ${project}`));
+  console.log(chalk.gray(`Build:    ${doBuild ? "yes" : "no"}  Runtime: ${doRuntime ? "yes" : "no"}  Launch: ${launch ? "yes" : "no"}  Kill: ${killAfter ? "yes" : "no"}`));
+  console.log("");
+  const failures = [];
+  for (const engineRootRaw of engineRoots) {
+    const engineRoot = engineRootRaw.trim();
+    if (!engineRoot) continue;
+    console.log(chalk.bold(`== Engine: ${engineRoot} ==`));
+    if (doBuild) {
+      console.log(chalk.cyan("Build: installing UnrealMCP plugin sources..."));
+      const installed = installUnrealMcpPluginToEngine(engineRoot);
+      if (!installed.ok) {
+        failures.push({ engineRoot, phase: "build", error: installed.errorMessage });
+        console.log(chalk.red(`Build: failed (install)
+${installed.errorMessage}
+`));
+        if (!doRuntime) continue;
+      } else {
+        console.log(chalk.green(`Build: sources installed to ${installed.destDir}`));
+        console.log(chalk.cyan("Build: compiling plugin via RunUAT BuildPlugin..."));
+        const built = await buildAndInstallUnrealMcpPlugin({ engineRoot, flockbayHomeDir: configuration.flockbayHomeDir });
+        if (!built.ok) {
+          failures.push({ engineRoot, phase: "build", error: built.errorMessage });
+          console.log(chalk.red(`Build: failed
+${built.errorMessage}
+`));
+        } else {
+          console.log(chalk.green(`Build: ok (log: ${built.buildLogPath})`));
+        }
+      }
+    }
+    if (doRuntime) {
+      console.log(chalk.cyan("Runtime: running command smoke..."));
+      const res = await runRuntimeSmoke({
+        engineRoot,
+        projectPath: project,
+        host,
+        port,
+        connectTimeoutMs,
+        timeoutMs,
+        launchIfNeeded: launch,
+        killAfter
+      });
+      if (!res.ok) {
+        failures.push({ engineRoot, phase: "runtime", error: res.error });
+        console.log(chalk.red(`Runtime: failed
+${res.error}
+`));
+      } else {
+        console.log(chalk.green("Runtime: ok\n"));
+      }
+    }
+  }
+  if (failures.length > 0) {
+    console.error(chalk.red("\nMatrix smoke failed.\n"));
+    for (const f of failures) {
+      console.error(chalk.red(`- ${f.engineRoot} (${f.phase}): ${f.error}`));
+    }
+    process.exit(1);
+  }
+  console.log(chalk.green("\nMatrix smoke passed.\n"));
+}
+
 function readTailUtf8(filePath, maxBytes) {
   try {
     const stat = fs.statSync(filePath);
@@ -12194,6 +12515,16 @@ async function authAndSetupMachineIfNeeded() {
   }
   if (!args.includes("--version")) ;
   if (subcommand === "doctor") {
+    if (args[1] === "unreal-mcp-smoke") {
+      try {
+        await runUnrealMcpMatrixSmoke(args.slice(2));
+      } catch (error) {
+        console.error(chalk.red("UnrealMCP smoke failed:"), error instanceof Error ? error.message : String(error));
+        if (process.env.DEBUG) console.error(error);
+        process.exit(1);
+      }
+      return;
+    }
     if (args[1] === "clean") {
       const result = await killRunawayFlockbayProcesses();
       console.log(`Cleaned up ${result.killed} runaway processes`);
@@ -12305,7 +12636,7 @@ ${engineRoot}`, {
   } else if (subcommand === "codex") {
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runCodex } = await import('./runCodex-d2KQX2mn.mjs');
+      const { runCodex } = await import('./runCodex-BC3IImzm.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {
@@ -12331,7 +12662,13 @@ ${engineRoot}`, {
     const geminiSubcommand = args[1];
     if (geminiSubcommand === "model" && args[2] === "set" && args[3]) {
       const modelName = args[3];
-      const validModels = ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-lite"];
+      const validModels = [
+        "gemini-2.5-pro",
+        "gemini-2.5-flash",
+        "gemini-2.5-flash-lite",
+        "gemini-3-pro-preview",
+        "gemini-3-flash-preview"
+      ];
       if (!validModels.includes(modelName)) {
         console.error(`Invalid model: ${modelName}`);
         console.error(`Available models: ${validModels.join(", ")}`);
@@ -12400,7 +12737,7 @@ ${engineRoot}`, {
     }
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runGemini } = await import('./runGemini-Cn0C7MS1.mjs');
+      const { runGemini } = await import('./runGemini-C43IKGUU.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {
@@ -12731,4 +13068,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ElicitationHub as E, MessageQueue2 as M, PLATFORM_SYSTEM_PROMPT as P, setLatestUserImages as a, MessageBuffer as b, consumeToolQuota as c, startFlockbayServer as d, detectUnrealProject as e, formatQuotaDeniedReason as f, buildProjectCapsule as g, hashObject as h, initialMachineMetadata as i, autoFinalizeCoordinationWorkItem as j, detectScreenshotsForGate as k, applyCoordinationSideEffectsFromMcpToolResult as l, stopCaffeinate as m, notifyDaemonSessionStarted as n, extractUserImagesMarker as o, getLatestUserImages as p, registerKillSessionHandler as r, shouldCountToolCall as s, trimIdent as t, withUserImagesMarker as w };
+export { ElicitationHub as E, MessageQueue2 as M, PLATFORM_SYSTEM_PROMPT as P, setLatestUserImages as a, MessageBuffer as b, consumeToolQuota as c, startFlockbayServer as d, buildProjectCapsule as e, formatQuotaDeniedReason as f, autoFinalizeCoordinationWorkItem as g, hashObject as h, initialMachineMetadata as i, detectScreenshotsForGate as j, applyCoordinationSideEffectsFromMcpToolResult as k, stopCaffeinate as l, extractUserImagesMarker as m, notifyDaemonSessionStarted as n, getLatestUserImages as o, registerKillSessionHandler as r, shouldCountToolCall as s, trimIdent as t, withUserImagesMarker as w };

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 require('chalk');
-require('./index-Bhkn02hu.cjs');
-require('./types-DeH24uWs.cjs');
+require('./index-BtB1Sqpy.cjs');
+require('./types-DvlwEGpS.cjs');
 require('zod');
 require('node:child_process');
 require('node:fs');

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import 'chalk';
-import './index-By332wvJ.mjs';
-import './types-mXJc7o0P.mjs';
+import './index-CRGcIpET.mjs';
+import './types-CNn15BaT.mjs';
 import 'zod';
 import 'node:child_process';
 import 'node:fs';

package/dist/lib.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var types = require('./types-DeH24uWs.cjs');
+var types = require('./types-DvlwEGpS.cjs');
 require('axios');
 require('node:fs');
 require('node:os');

package/dist/lib.mjs

@@ -1,4 +1,4 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-mXJc7o0P.mjs';
+export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-CNn15BaT.mjs';
 import 'axios';
 import 'node:fs';
 import 'node:os';

package/dist/{runCodex-d2KQX2mn.mjs → runCodex-BC3IImzm.mjs}

@@ -1,6 +1,6 @@
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
-import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, b as packageJson } from './types-mXJc7o0P.mjs';
+import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, b as packageJson } from './types-CNn15BaT.mjs';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { z } from 'zod';
@@ -10,7 +10,7 @@ import fs__default from 'node:fs';
 import os from 'node:os';
 import path, { resolve, join } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { s as shouldCountToolCall, c as consumeToolQuota, f as formatQuotaDeniedReason, h as hashObject, i as initialMachineMetadata, E as ElicitationHub, n as notifyDaemonSessionStarted, M as MessageQueue2, P as PLATFORM_SYSTEM_PROMPT, a as setLatestUserImages, w as withUserImagesMarker, r as registerKillSessionHandler, b as MessageBuffer, d as startFlockbayServer, e as detectUnrealProject, g as buildProjectCapsule, t as trimIdent, j as autoFinalizeCoordinationWorkItem, k as detectScreenshotsForGate, l as applyCoordinationSideEffectsFromMcpToolResult, m as stopCaffeinate } from './index-By332wvJ.mjs';
+import { s as shouldCountToolCall, c as consumeToolQuota, f as formatQuotaDeniedReason, h as hashObject, i as initialMachineMetadata, E as ElicitationHub, n as notifyDaemonSessionStarted, M as MessageQueue2, P as PLATFORM_SYSTEM_PROMPT, a as setLatestUserImages, w as withUserImagesMarker, r as registerKillSessionHandler, b as MessageBuffer, d as startFlockbayServer, e as buildProjectCapsule, t as trimIdent, g as autoFinalizeCoordinationWorkItem, j as detectScreenshotsForGate, k as applyCoordinationSideEffectsFromMcpToolResult, l as stopCaffeinate } from './index-CRGcIpET.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
@@ -250,18 +250,18 @@ function buildMcpElicitationResult(decision, requestedSchemaRaw, options) {
     if (!raw) return "";
     if (/^Blocked\b/.test(raw)) return raw;
     if (raw === "ledger_read_required") {
-      return "Blocked by policy (automatic; not the user): read the ledger before making file edits. Next: call mcp__flockbay__ledger_read, then retry the edit.";
+      return "Blocked by Policy (automatic; not the user): read the ledger before making file edits. Next: call mcp__flockbay__ledger_read, then retry the edit.";
     }
     if (raw === "docs_index_read_required") {
-      return "Blocked by policy (automatic; not the user): read the game Documentation index before making edits. Next: call mcp__flockbay__docs_index_read, then retry the edit.";
+      return "Blocked by Policy (automatic; not the user): read the game Documentation index before making edits. Next: call mcp__flockbay__docs_index_read, then retry the edit.";
     }
     if (raw.startsWith("file_claim_required:")) {
       const withoutPrefix = raw.slice("file_claim_required:".length);
       const file = withoutPrefix.split("(")[0]?.trim() || "the file";
-      return `Blocked by policy (automatic; not the user): claim ${file} before editing it. Next: claim the file via mcp__flockbay__ledger_claim (or mcp__flockbay__coordination_claim_files), then retry the edit.`;
+      return `Blocked by Policy (automatic; not the user): claim ${file} before editing it. Next: claim the file via mcp__flockbay__ledger_claim (or mcp__flockbay__coordination_claim_files), then retry the edit.`;
     }
     if (raw === "read_only_mode") {
-      return "Blocked by policy (automatic; not the user): this session is in read-only mode. Next: switch permission mode to allow edits, then retry.";
+      return "Blocked by Policy (automatic; not the user): this session is in read-only mode. Next: switch permission mode to allow edits, then retry.";
     }
     return `Blocked: ${raw}`;
   };
@@ -1740,7 +1740,7 @@ function buildPolicyHint(reason, decision, gate) {
       };
     }
     return {
-      summary: "Blocked by policy.",
+      summary: "Blocked by Policy.",
       nextSteps: []
     };
   }
@@ -1752,7 +1752,7 @@ function buildPolicyHint(reason, decision, gate) {
   }
   if (raw === "ledger_read_required") {
     return {
-      summary: "Blocked by policy (automatic; not the user): read the ledger before making file edits.",
+      summary: "Blocked by Policy (automatic; not the user): read the ledger before making file edits.",
       nextSteps: [
         "Call `mcp__flockbay__ledger_read` (or `mcp__flockbay__coordination_ledger_snapshot`).",
         "Then retry the file edit."
@@ -1761,7 +1761,7 @@ function buildPolicyHint(reason, decision, gate) {
   }
   if (raw === "docs_index_read_required") {
     return {
-      summary: "Blocked by policy (automatic; not the user): read the game Documentation index before making edits.",
+      summary: "Blocked by Policy (automatic; not the user): read the game Documentation index before making edits.",
       nextSteps: [
         "Call `mcp__flockbay__docs_index_read`.",
         "Then retry the edit."
@@ -1772,7 +1772,7 @@ function buildPolicyHint(reason, decision, gate) {
     const withoutPrefix = raw.slice("file_claim_required:".length);
     const file = withoutPrefix.split("(")[0]?.trim() || "the file";
     return {
-      summary: `Blocked by policy (automatic; not the user): claim \`${file}\` before editing it.`,
+      summary: `Blocked by Policy (automatic; not the user): claim \`${file}\` before editing it.`,
       nextSteps: [
         `Claim the file via \`mcp__flockbay__ledger_claim\` or \`mcp__flockbay__coordination_claim_files\` (files: ["${file}"]).`,
         "Then retry the file edit."
@@ -1781,7 +1781,7 @@ function buildPolicyHint(reason, decision, gate) {
   }
   if (raw === "read_only_mode") {
     return {
-      summary: "Blocked by policy (automatic; not the user): this session is in read-only mode.",
+      summary: "Blocked by Policy (automatic; not the user): this session is in read-only mode.",
       nextSteps: [
         "Switch permission mode to allow edits (disable read-only).",
         "Then retry the action."
@@ -2381,7 +2381,6 @@ async function runCodex(opts) {
       appendSystemPrompt: PLATFORM_SYSTEM_PROMPT
     });
   }
-  const bypassUeGates = String(process.env.FLOCKBAY_DEV_BYPASS_UE_GATES || "") === "1";
   let currentPermissionMode = void 0;
   let currentModel = void 0;
   const defaultAppendSystemPrompt = PLATFORM_SYSTEM_PROMPT;
@@ -3449,22 +3448,6 @@ Error: ${message}`,
       try {
         resetScreenshotGateForTurn();
         const overrides = { approvalPolicy: "untrusted", sandbox: "workspace-write" };
-        if (!bypassUeGates) {
-          const detection = await detectUnrealProject(process.cwd());
-          if (!detection.ok) {
-            session.sendCodexMessage({
-              type: "message",
-              message: "Select an Unreal project folder (the folder containing a *.uproject) to continue.",
-              id: randomUUID()
-            });
-            if (wasCreated) {
-              client.clearSession();
-              wasCreated = false;
-              currentModeHash = null;
-            }
-            continue;
-          }
-        }
         if (!wasCreated) {
           const projectCapsule = await buildProjectCapsule({ startDir: process.cwd() });
           const modelOverride = resolveCodexModelOverride(message.mode.model);