flockbay 0.10.20 → 0.10.22

package/dist/{index-D_mglYG0.cjs → index-DQTqwzYd.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var types = require('./types-BYHCKlu_.cjs');
+var types = require('./types-Z2OYpI8c.cjs');
 var node_child_process = require('node:child_process');
 var path = require('node:path');
 var node_readline = require('node:readline');
@@ -408,7 +408,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)
 
@@ -1258,7 +1258,8 @@ function buildDaemonSafeEnv(baseEnv, binPath) {
     if (!p) return;
     if (!prepend.includes(p) && !existingParts.includes(p)) prepend.push(p);
   };
-  if (binPath && binPath.includes("/") && !binPath.startsWith("\\\\")) {
+  const isPathLike = typeof binPath === "string" && binPath.length > 0 && (binPath.includes("/") || binPath.includes("\\")) && !binPath.startsWith("\\\\");
+  if (isPathLike) {
     add(path.dirname(binPath));
   }
   add(path.dirname(process$1.execPath));
@@ -1272,12 +1273,12 @@ function buildDaemonSafeEnv(baseEnv, binPath) {
   env[pathKey] = [...prepend, ...existingParts].join(pathSep);
   return env;
 }
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-D_mglYG0.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DQTqwzYd.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion(claudeExecutable) {
   try {
     const cleanEnv = buildDaemonSafeEnv(getCleanEnv(), claudeExecutable);
-    const output = claudeExecutable.includes("/") && !claudeExecutable.startsWith("\\\\") ? node_child_process.execFileSync(claudeExecutable, ["--version"], {
+    const output = (claudeExecutable.includes("/") || claudeExecutable.includes("\\")) && !claudeExecutable.startsWith("\\\\") ? node_child_process.execFileSync(claudeExecutable, ["--version"], {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],
       cwd: os.homedir(),
@@ -1295,6 +1296,35 @@ function getGlobalClaudeVersion(claudeExecutable) {
     return null;
   }
 }
+function tryReadBundledClaudeVersion(nodeModulesCliPath) {
+  try {
+    const pkgPath = path.join(path.dirname(path.dirname(nodeModulesCliPath)), "package.json");
+    if (!fs.existsSync(pkgPath)) return null;
+    const raw = fs.readFileSync(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const v = typeof parsed?.version === "string" ? parsed.version.trim() : "";
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+function parseSemver3(v) {
+  const m = String(v || "").trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!m) return null;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  const c = Number(m[3]);
+  if (!Number.isFinite(a) || !Number.isFinite(b) || !Number.isFinite(c)) return null;
+  return [a, b, c];
+}
+function compareSemver(a, b) {
+  const pa = parseSemver3(a);
+  const pb = parseSemver3(b);
+  if (!pa || !pb) return null;
+  if (pa[0] !== pb[0]) return pa[0] - pb[0];
+  if (pa[1] !== pb[1]) return pa[1] - pb[1];
+  return pa[2] - pb[2];
+}
 function getCleanEnv() {
   const env = { ...process$1.env };
   const cwd = process$1.cwd();
@@ -1414,11 +1444,22 @@ function getDefaultClaudeCodePath() {
     return nodeModulesPath;
   }
   const globalVersion = getGlobalClaudeVersion(globalPath);
+  const bundledVersion = tryReadBundledClaudeVersion(nodeModulesPath);
   types.logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
-  if (!globalVersion) {
+  types.logger.debug(`[Claude SDK] Bundled version: ${bundledVersion || "unknown"}`);
+  if (!globalVersion || !bundledVersion) {
     types.logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
     return globalPath;
   }
+  const cmp = compareSemver(bundledVersion, globalVersion);
+  if (cmp === null) {
+    types.logger.debug(`[Claude SDK] Cannot parse versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  if (cmp > 0) {
+    types.logger.debug(`[Claude SDK] Bundled Claude is newer (${bundledVersion} > ${globalVersion}), using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
   return globalPath;
 }
 function logDebug(message) {
@@ -1693,8 +1734,9 @@ function query(config) {
     stdio: ["pipe", "pipe", "pipe"],
     signal: config.options?.abort,
     env: spawnEnv,
-    // Use shell on Windows for global binaries and command-only mode
-    shell: !isJsFile && process$1.platform === "win32"
+    // Only use a shell on Windows when spawning a bare command (e.g. "claude").
+    // Passing large `--allowedTools` lists through cmd.exe can hit the ~8k command line limit.
+    shell: isCommandOnly && process$1.platform === "win32"
   });
   let childStdin = null;
   if (typeof prompt === "string") {
@@ -2470,6 +2512,21 @@ async function consumeToolQuota(args) {
   return { ok: true, allowed: true, unlimited: true };
 }
 
+function canonicalizeToolNameForMatching(name) {
+  if (name === "ExitPlanMode") return "exit_plan_mode";
+  return name;
+}
+function stripUndefinedDeep(value) {
+  if (value === null || value === void 0) return value;
+  if (Array.isArray(value)) return value.map(stripUndefinedDeep);
+  if (typeof value !== "object") return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (child === void 0) continue;
+    out[key] = stripUndefinedDeep(child);
+  }
+  return out;
+}
 class PermissionHandler {
   toolCalls = [];
   responses = /* @__PURE__ */ new Map();
@@ -2488,7 +2545,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}:${node_crypto.randomUUID().slice(0, 8)}`;
     const payload = {
       kind,
@@ -2553,13 +2610,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") {
@@ -2567,13 +2624,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) {
@@ -2753,8 +2810,13 @@ ${next}`
     }
     let toolCallId = this.resolveToolCallId(toolName, input);
     if (!toolCallId) {
-      await types.delay(1e3);
-      toolCallId = this.resolveToolCallId(toolName, input);
+      const isPlanMode = toolName === "exit_plan_mode" || toolName === "ExitPlanMode";
+      const timeoutMs = isPlanMode ? 3e3 : 1e3;
+      const deadline = Date.now() + timeoutMs;
+      while (!toolCallId && Date.now() < deadline) {
+        await types.delay(100);
+        toolCallId = this.resolveToolCallId(toolName, input);
+      }
       if (!toolCallId) {
         throw new Error(`Could not resolve tool call ID for ${toolName}`);
       }
@@ -2835,9 +2897,12 @@ ${next}`
    * Resolves tool call ID based on tool name and input
    */
   resolveToolCallId(name, args) {
+    const normalizedName = canonicalizeToolNameForMatching(name);
+    const normalizedArgs = stripUndefinedDeep(args);
     for (let i = this.toolCalls.length - 1; i >= 0; i--) {
       const call = this.toolCalls[i];
-      if (call.name === name && deepEqual(call.input, args)) {
+      const callName = canonicalizeToolNameForMatching(call.name);
+      if (callName === normalizedName && deepEqual(stripUndefinedDeep(call.input), normalizedArgs)) {
         if (call.used) {
           return null;
         }
@@ -2845,6 +2910,18 @@ ${next}`
         return call.id;
       }
     }
+    const candidates = [];
+    for (let i = this.toolCalls.length - 1; i >= 0; i--) {
+      const call = this.toolCalls[i];
+      if (call.used) continue;
+      const callName = canonicalizeToolNameForMatching(call.name);
+      if (callName === normalizedName) candidates.push(call);
+      if (candidates.length > 1) break;
+    }
+    if (candidates.length === 1) {
+      candidates[0].used = true;
+      return candidates[0].id;
+    }
     return null;
   }
   /**
@@ -7117,7 +7194,11 @@ async function uploadScreenshotViewsForSession(args) {
   for (const v of args.views) {
     const buf = await fs$2.readFile(v.path);
     const filename = path.basename(v.path);
-    const contentType = filename.toLowerCase().endsWith(".png") ? "image/png" : "application/octet-stream";
+    const contentType = (() => {
+      const mime = detectImageMimeTypeFromBuffer$1(buf);
+      if (mime) return mime;
+      throw new Error(`Unsupported screenshot format (expected PNG/JPEG): ${v.path}`);
+    })();
     const blob = new Blob([buf], { type: contentType });
     form.append(`file:${v.id}`, blob, filename);
   }
@@ -7158,6 +7239,64 @@ async function uploadScreenshotViewsForSession(args) {
   }
   return out;
 }
+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";
+  }
+  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 && (buf[4] === 55 || buf[4] === 57) && buf[5] === 97) {
+    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 readFileHeader(filePath, bytes) {
+  const fh = await fs$2.open(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 (!fs.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 (fs.existsSync(next)) {
+      throw new Error(`Screenshot already exists at normalized path: ${next}`);
+    }
+    await fs$2.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 (fs.existsSync(next)) {
+      throw new Error(`Screenshot already exists at normalized path: ${next}`);
+    }
+    await fs$2.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) => {
     types.logger.debug("[flockbayMCP] Changing title to:", title);
@@ -8687,13 +8826,13 @@ ${String(st.stdout || "").trim()}`
     "read_images",
     {
       title: "Read Images",
-      description: "Read one or more local PNG images by path and return a `{ views: [...] }` payload so the app can render them as a gallery.",
+      description: "Read one or more local images by path (PNG/JPEG) and return a `{ views: [...] }` payload so the app can render them as a gallery.",
       inputSchema: {
-        paths: z.z.array(z.z.string()).describe("Image paths (absolute or relative to the session directory). PNG only."),
+        paths: z.z.array(z.z.string()).describe("Image paths (absolute or relative to the session directory). PNG/JPG only."),
         limit: z.z.number().int().positive().optional().describe("Max number of images to include (default 10)."),
         upload: z.z.boolean().optional().describe("Upload images to the session screenshots store and return HTTPS URLs (default true)."),
         includeBase64: z.z.boolean().optional().describe("Include base64 data in the payload (default false)."),
-        includeToolImages: z.z.boolean().optional().describe("Include MCP image blocks so vision models can see the PNGs (default false)."),
+        includeToolImages: z.z.boolean().optional().describe("Include MCP image blocks so vision models can see the images (default false)."),
         maxBytesPerImage: z.z.number().int().positive().optional().describe("Max bytes per image when includeBase64=true (default 2500000).")
       }
     },
@@ -8725,14 +8864,16 @@ ${String(st.stdout || "").trim()}`
             const home = process.env.HOME || process.env.USERPROFILE || "";
             if (home) return path.join(home, p.slice(2));
           }
-          return path.isAbsolute(p) ? p : path.resolve(process.cwd(), p);
+          const baseDir = readSessionWorkingDirectory();
+          return path.isAbsolute(p) ? p : path.resolve(baseDir, p);
         };
         const idsSeen = /* @__PURE__ */ new Set();
         const viewsLocal = [];
         for (const inputPath of paths) {
           const abs = resolvePath(inputPath);
-          if (!abs.toLowerCase().endsWith(".png")) {
-            throw new Error(`Only PNG images are supported: ${abs}`);
+          const lower = abs.toLowerCase();
+          if (!lower.endsWith(".png") && !lower.endsWith(".jpg") && !lower.endsWith(".jpeg")) {
+            throw new Error(`Only PNG/JPG images are supported: ${abs}`);
           }
           if (!fs.existsSync(abs)) {
             throw new Error(`Image not found: ${abs}`);
@@ -8752,7 +8893,11 @@ ${String(st.stdout || "").trim()}`
               throw new Error(`Image too large (${st.size} bytes) to embed: ${abs}`);
             }
             const buf = await fs$2.readFile(abs);
-            viewsLocal.push({ id: unique, path: abs, base64: buf.toString("base64") });
+            const mime = detectImageMimeTypeFromBuffer$1(buf);
+            if (!mime) {
+              throw new Error(`Unsupported image format (expected PNG/JPEG): ${abs}`);
+            }
+            viewsLocal.push({ id: unique, path: abs, base64: buf.toString("base64"), mimeType: mime });
           } else {
             viewsLocal.push({ id: unique, path: abs });
           }
@@ -8777,7 +8922,7 @@ ${String(st.stdout || "").trim()}`
           viewsLocal.forEach((v, idx) => {
             if (!v.base64) return;
             content.push({ type: "text", text: `Image ${idx + 1}: ${v.id}` });
-            content.push({ type: "image", data: v.base64, mimeType: "image/png" });
+            content.push({ type: "image", data: v.base64, mimeType: v.mimeType || "image/png" });
           });
         }
         return {
@@ -8789,7 +8934,7 @@ ${String(st.stdout || "").trim()}`
         return {
           content: [
             { type: "text", text: `Failed to read images: ${error instanceof Error ? error.message : String(error)}` },
-            { type: "text", text: `Tip: pass absolute PNG paths, or relative paths from the session folder.` }
+            { type: "text", text: `Tip: pass absolute PNG/JPG paths, or relative paths from the session folder.` }
           ],
           isError: true
         };
@@ -8798,7 +8943,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.z.string().describe("Absolute path to the .uproject file."),
       limit: z.z.number().int().positive().optional().describe("Max number of screenshots to return (default 12)."),
@@ -8835,7 +8980,7 @@ ${String(st.stdout || "").trim()}`
         };
       }
       const files = await fs$2.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: [
@@ -9090,10 +9235,26 @@ ${String(st.stdout || "").trim()}`
       const pluginInfoWasCached = Boolean(unrealMcpPluginInfoCache);
       const pluginInfo = type !== "get_plugin_info" ? await getUnrealMcpPluginInfoBestEffort(timeoutMs) : null;
       const response = await types.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) }] : []
         ],
@@ -11753,6 +11914,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.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 types.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.existsSync(editorExe)) {
+    return { ok: false, error: `Missing UnrealEditor executable: ${editorExe}` };
+  }
+  if (!fs.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 = node_child_process.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 types.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 types.sendUnrealMcpTcpCommand({ type: "get_play_in_editor_status", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
+    const isPlaying = Boolean(playStatus0?.isPlaySessionInProgress);
+    if (isPlaying) {
+      await types.sendUnrealMcpTcpCommand({ type: "stop_play_in_editor", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
+    }
+    await types.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 types.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 types.sendUnrealMcpTcpCommand({
+      type: "take_screenshot",
+      params: { filepath: shotPath },
+      host: options.host,
+      port: options.port,
+      timeoutMs: options.timeoutMs
+    });
+    if (!fs.existsSync(shotPath)) return { ok: false, error: `Screenshot did not exist on disk after take_screenshot: ${shotPath}` };
+    const bytes = fs.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 types.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 types.sendUnrealMcpTcpCommand({
+      type: "compile_blueprint",
+      params: { blueprint_name: bpName },
+      host: options.host,
+      port: options.port,
+      timeoutMs: Math.max(options.timeoutMs, 6e4)
+    });
+    await types.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") {
+          node_child_process.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 = types.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 types.buildAndInstallUnrealMcpPlugin({ engineRoot, flockbayHomeDir: types.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__namespace.statSync(filePath);
@@ -12113,6 +12537,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`);
@@ -12224,7 +12658,7 @@ ${engineRoot}`, {
   } else if (subcommand === "codex") {
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-CXJW0tzo.cjs'); });
+      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-CaWagdzG.cjs'); });
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {
@@ -12250,7 +12684,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(", ")}`);
@@ -12319,7 +12759,7 @@ ${engineRoot}`, {
     }
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-FOBXtEU6.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-8w5P093W.cjs'); });
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {