chatroom-cli 1.135.0 → 1.137.0

package/dist/index.js

@@ -2140,7 +2140,156 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// src/commands/generate/model-capabilities.ts
+function getModelCapability(id) {
+  return Object.prototype.hasOwnProperty.call(MODEL_CAPABILITIES, id) ? MODEL_CAPABILITIES[id] : undefined;
+}
+function describeKey(capability, key, source) {
+  const support = capability.params[key];
+  if (support === undefined) {
+    return [
+      {
+        kind: "unknown",
+        key,
+        message: `not in the CLI's capability data for ${capability.id}; not checked.`
+      }
+    ];
+  }
+  if (support.support === "unsupported") {
+    return [{ kind: "unsupported", key, source, message: support.reason }];
+  }
+  return [];
+}
+function describeInputKeys(capability, input) {
+  const disclosures = [];
+  for (const key of Object.keys(input)) {
+    if (key === "aspect_ratio")
+      continue;
+    disclosures.push(...describeKey(capability, key, "input"));
+  }
+  return disclosures;
+}
+function describeFlagKeys(capability, flags) {
+  return flags.aspectRatio === undefined ? [] : describeKey(capability, "aspect_ratio", "flag");
+}
+function describeDefaults(capability, input) {
+  return Object.entries(capability.params).flatMap(([key, support]) => {
+    if (support.support !== "supported" || support.default === undefined)
+      return [];
+    if (input[key] !== undefined)
+      return [];
+    return [
+      {
+        kind: "default",
+        key,
+        message: `${key} is not set; the model default ${support.default} applies. Set one explicit value for every call of a set.`
+      }
+    ];
+  });
+}
+function describeNotes(capability) {
+  return capability.notes.map((message) => ({ kind: "note", message }));
+}
+function describeConstraints(model, input, flags) {
+  const capability = getModelCapability(model);
+  if (capability === undefined) {
+    return [
+      {
+        kind: "note",
+        message: `The CLI has no capability data for ${model}; no constraints were checked.`
+      }
+    ];
+  }
+  return [
+    ...describeInputKeys(capability, input),
+    ...describeFlagKeys(capability, flags),
+    ...describeDefaults(capability, input),
+    ...describeNotes(capability)
+  ];
+}
+var FLUX_2_FLASH_MODEL = "fal-ai/flux-2/flash", FLUX_2_FLASH_EDIT_MODEL = "fal-ai/flux-2/flash/edit", FLASH_SOURCE = "https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=fal-ai/flux-2/flash (read 2026-10-24); no negative prompt: https://help.bfl.ai/articles/7734566352-does-flux-2-support-negative-prompting (read 2026-10-24)", EDIT_SOURCE = "https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=fal-ai/flux-2/flash/edit (read 2026-10-24); no negative prompt: https://help.bfl.ai/articles/7734566352-does-flux-2-support-negative-prompting (read 2026-10-24)", MODEL_CAPABILITIES;
+var init_model_capabilities = __esm(() => {
+  MODEL_CAPABILITIES = {
+    [FLUX_2_FLASH_MODEL]: {
+      id: FLUX_2_FLASH_MODEL,
+      name: "FLUX 2 Flash",
+      task: "text-to-image",
+      params: {
+        prompt: { support: "supported" },
+        seed: { support: "supported" },
+        output_format: { support: "supported" },
+        image_size: {
+          support: "supported",
+          default: "landscape_4_3",
+          note: "set one explicit value for every call of a set"
+        },
+        aspect_ratio: {
+          support: "unsupported",
+          reason: `FLUX 2 Flash sizes output with image_size. Pass --input '{"image_size":"landscape_4_3"}' instead.`
+        },
+        negative_prompt: {
+          support: "unsupported",
+          reason: "FLUX 2 Flash has no negative prompt; describe what you want in --prompt instead."
+        },
+        image_urls: {
+          support: "unsupported",
+          reason: "Text-to-image only; use --model fal-ai/flux-2/flash/edit with --input-image."
+        }
+      },
+      notes: [
+        "FLUX 2 Flash has no camera or perspective parameter; perspective comes only from the prompt.",
+        "Same-seed reproducibility is not documented by fal.",
+        "Returns PNG without an alpha channel by default."
+      ],
+      source: FLASH_SOURCE
+    },
+    [FLUX_2_FLASH_EDIT_MODEL]: {
+      id: FLUX_2_FLASH_EDIT_MODEL,
+      name: "FLUX 2 Flash (edit)",
+      task: "image-edit",
+      params: {
+        prompt: { support: "supported" },
+        seed: { support: "supported" },
+        image_urls: {
+          support: "supported",
+          note: "set by --input-image; the CLI sends one image"
+        },
+        image_size: {
+          support: "supported",
+          default: "square_hd",
+          note: "set one explicit value for every call of a set"
+        },
+        aspect_ratio: {
+          support: "unsupported",
+          reason: `FLUX 2 Flash (edit) sizes output with image_size. Pass --input '{"image_size":"square_hd"}' instead.`
+        },
+        negative_prompt: {
+          support: "unsupported",
+          reason: "FLUX 2 Flash has no negative prompt; describe what you want in --prompt instead."
+        }
+      },
+      notes: [
+        "FLUX 2 Flash has no camera or perspective parameter; perspective comes only from the prompt.",
+        "Not documented to carry a reference image's perspective over to new content; it may return a modified copy of the input.",
+        "Same-seed reproducibility is not documented by fal."
+      ],
+      source: EDIT_SOURCE
+    }
+  };
+});
+
 // src/commands/generate/image.ts
+var exports_image = {};
+__export(exports_image, {
+  planGenerateImage: () => planGenerateImage,
+  parseInputJson: () => parseInputJson,
+  generateImage: () => generateImage,
+  formatGenerateImagePlan: () => formatGenerateImagePlan,
+  GenerateImageError: () => GenerateImageError,
+  GENERATE_IMAGE_PLATFORMS: () => GENERATE_IMAGE_PLATFORMS,
+  FAL_API_KEY_MISSING_MESSAGE: () => FAL_API_KEY_MISSING_MESSAGE,
+  DEFAULT_GENERATE_IMAGE_PLATFORM: () => DEFAULT_GENERATE_IMAGE_PLATFORM
+});
 import { createHash } from "node:crypto";
 import { extname, resolve } from "node:path";
 function resolvePlatform(platform) {
@@ -2163,6 +2312,14 @@ function requireNonEmpty(value, message) {
   }
   return trimmed;
 }
+function inputImageContentType(path) {
+  const extension = extname(path).toLowerCase();
+  const contentType = INPUT_IMAGE_CONTENT_TYPES[extension];
+  if (contentType === undefined) {
+    throw new GenerateImageError(`Unsupported --input-image extension ${extension || "(none)"}. Use one of: ${Object.keys(INPUT_IMAGE_CONTENT_TYPES).join(", ")}.`);
+  }
+  return contentType;
+}
 function validateInputObject(input) {
   if ("sync_mode" in input && input.sync_mode !== undefined) {
     throw new GenerateImageError('--input must not contain "sync_mode": it returns data URIs that this command cannot download. Omit it.');
@@ -2176,6 +2333,9 @@ function validateInputObject(input) {
     }
   }
 }
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function parseInputJson(text) {
   let parsed;
   try {
@@ -2183,28 +2343,30 @@ function parseInputJson(text) {
   } catch {
     throw new GenerateImageError("--input must be valid JSON.");
   }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+  if (!isPlainObject(parsed)) {
     throw new GenerateImageError("--input must be a JSON object.");
   }
-  const input = parsed;
-  validateInputObject(input);
-  return input;
+  validateInputObject(parsed);
+  return parsed;
 }
-function buildInput(prompt, opts) {
-  if (opts.input !== undefined) {
-    if (typeof opts.input !== "object" || opts.input === null || Array.isArray(opts.input)) {
-      throw new GenerateImageError("--input must be a JSON object.");
-    }
-    validateInputObject(opts.input);
-  }
+function buildInput(prompt, opts, imageUrl) {
   return {
     prompt,
     ...opts.input ?? {},
     ...opts.aspectRatio !== undefined ? { aspect_ratio: opts.aspectRatio } : {},
     ...opts.outputFormat !== undefined ? { output_format: opts.outputFormat } : {},
-    ...opts.seed !== undefined ? { seed: opts.seed } : {}
+    ...opts.seed !== undefined ? { seed: opts.seed } : {},
+    ...imageUrl !== undefined ? { image_urls: [imageUrl] } : {}
   };
 }
+function validateInputOption(opts) {
+  if (opts.input === undefined)
+    return;
+  if (!isPlainObject(opts.input)) {
+    throw new GenerateImageError("--input must be a JSON object.");
+  }
+  validateInputObject(opts.input);
+}
 function requireImage(images, model) {
   const image = images[0];
   if (!image?.url) {
@@ -2243,6 +2405,12 @@ async function saveImage(deps, outPath, bytes, requestId, url) {
     throw new GenerateImageError(recoveryMessage("save", err, requestId, url));
   }
 }
+function requireSupportedExtension(outPath) {
+  const extension = extname(outPath).toLowerCase();
+  if (!UNSUPPORTED_OUTPUT_EXTENSIONS.has(extension))
+    return;
+  throw new GenerateImageError(`Unsupported output extension ${extension}. Use .png or .webp (transparency-capable).`);
+}
 function requireFormatMatchesExtension(outPath, format) {
   const extension = extname(outPath).toLowerCase();
   const expected = EXTENSION_FORMATS[extension];
@@ -2260,6 +2428,7 @@ function buildManifest(args) {
     sdk: `@fal-ai/client@${args.sdkVersion}`,
     model: args.model,
     input: args.input,
+    inputImage: args.inputImage,
     requestId: args.requestId ?? null,
     seed: resolveSeed(args.resultSeed, args.requestedSeed),
     output: {
@@ -2272,20 +2441,118 @@ function buildManifest(args) {
     licensing: LICENSING
   };
 }
-async function generateImage(opts, deps) {
+function requireTaskPairing(capability, model, inputImage) {
+  if (capability.task === "image-edit" && inputImage === undefined) {
+    throw new GenerateImageError(`${model} edits an image; pass --input-image <path-or-url>.`);
+  }
+  if (capability.task === "text-to-image" && inputImage !== undefined) {
+    throw new GenerateImageError(`${model} does not take an input image; use --model ${FLUX_2_FLASH_EDIT_MODEL} with --input-image.`);
+  }
+}
+function requireAspectRatioSupport(capability, model, aspectRatio) {
+  if (aspectRatio === undefined)
+    return;
+  const support = capability.params.aspect_ratio;
+  if (support?.support !== "unsupported")
+    return;
+  throw new GenerateImageError(`--aspect-ratio is not supported by ${model}. ${support.reason}`);
+}
+function requireModelPairing(model, inputImage, aspectRatio) {
+  const capability = getModelCapability(model);
+  if (capability === undefined)
+    return;
+  requireTaskPairing(capability, model, inputImage);
+  requireAspectRatioSupport(capability, model, aspectRatio);
+}
+function resolveInputImageOption(opts) {
+  return opts.inputImage === undefined ? undefined : requireNonEmpty(opts.inputImage, "--input-image must not be empty.");
+}
+async function validateInputImage(deps, inputImage) {
+  if (inputImage === undefined)
+    return;
+  if (HTTP_URL_PATTERN.test(inputImage))
+    return { kind: "url", url: inputImage };
+  const localPath = resolve(inputImage);
+  const contentType = inputImageContentType(localPath);
+  const status = await deps.pathStatus(localPath);
+  if (status !== "file") {
+    throw new GenerateImageError(`--input-image is not a file: ${localPath}`);
+  }
+  return { kind: "file", path: localPath, contentType };
+}
+function planInputImageUrl(target) {
+  if (target === undefined)
+    return;
+  return target.kind === "url" ? target.url : `<fal storage URL for ${target.path}>`;
+}
+async function uploadInputImage(deps, target) {
+  if (target === undefined)
+    return { url: undefined, record: null };
+  if (target.kind === "url") {
+    return { url: target.url, record: { source: target.url, url: target.url } };
+  }
+  const url = await deps.uploadFile(target.path, target.contentType);
+  return { url, record: { source: target.path, url } };
+}
+async function planGenerateImage(opts, deps) {
   const platform = resolvePlatform(opts.platform);
   requireSupportedPlatform(platform);
-  requireFalKey(deps);
+  const model = requireNonEmpty(opts.model, "--model must not be empty.");
   const prompt = requireNonEmpty(opts.prompt, "--prompt must not be empty.");
   const outPath = resolve(requireNonEmpty(opts.out, "--out must not be empty."));
+  requireSupportedExtension(outPath);
   if (opts.outputFormat !== undefined) {
     requireFormatMatchesExtension(outPath, opts.outputFormat);
   }
+  const inputImage = resolveInputImageOption(opts);
+  requireModelPairing(model, inputImage, opts.aspectRatio);
+  validateInputOption(opts);
+  const inputTarget = await validateInputImage(deps, inputImage);
   const manifestPath = `${outPath}.json`;
   await requireWritableOutput(deps, outPath, manifestPath, opts.force === true);
-  await deps.ensureParentDir(outPath);
-  const model = opts.model ?? DEFAULT_IMAGE_MODEL;
-  const input = buildInput(prompt, opts);
+  const input = buildInput(prompt, opts, planInputImageUrl(inputTarget));
+  return {
+    platform,
+    model,
+    outPath,
+    manifestPath,
+    input,
+    inputTarget,
+    disclosures: describeConstraints(model, input, { aspectRatio: opts.aspectRatio })
+  };
+}
+function disclosureFlag(key) {
+  return key === "aspect_ratio" ? "--aspect-ratio" : "--input";
+}
+function formatDisclosure(disclosure) {
+  if (disclosure.kind === "unsupported" || disclosure.kind === "unknown") {
+    return `- ${disclosure.kind}: ${disclosure.key} (${disclosureFlag(disclosure.key)}) — ${disclosure.message}`;
+  }
+  return `- ${disclosure.kind}: ${disclosure.message}`;
+}
+function formatInputImageLine(target) {
+  if (target === undefined)
+    return;
+  return target.kind === "url" ? `Input image ${target.url} (passed through)` : `Input image ${target.path} (would be uploaded to fal storage, 1-day lifetime)`;
+}
+function formatGenerateImagePlan(plan) {
+  const capability = getModelCapability(plan.model);
+  const lines = [
+    `Would generate ${plan.outPath}`,
+    `Manifest ${plan.manifestPath}`,
+    capability === undefined ? `Model ${plan.model} (no capability data)` : `Model ${plan.model} (${capability.name}, ${capability.task})`
+  ];
+  const inputLine = formatInputImageLine(plan.inputTarget);
+  if (inputLine !== undefined)
+    lines.push(inputLine);
+  lines.push("Request:", JSON.stringify(plan.input, null, 2), "Constraints:");
+  for (const disclosure of plan.disclosures)
+    lines.push(formatDisclosure(disclosure));
+  lines.push("No upload or fal call was made.");
+  return lines.join(`
+`);
+}
+async function generateAndSave(deps, model, input, outPath) {
   const result = await deps.falSubscribe(model, input);
   if (result.data.images.length > 1) {
     deps.warn(`⚠️ fal returned ${result.data.images.length} images; only the first is saved.`);
@@ -2293,25 +2560,46 @@ async function generateImage(opts, deps) {
   const image = requireImage(result.data.images, model);
   const bytes = await downloadImage(deps, result.requestId, image.url);
   await saveImage(deps, outPath, bytes, result.requestId, image.url);
-  const sha256 = createHash("sha256").update(bytes).digest("hex");
-  await deps.writeJson(manifestPath, buildManifest({
-    platform,
-    model,
-    input,
+  return {
+    image,
+    bytes,
+    sha256: createHash("sha256").update(bytes).digest("hex"),
     requestId: result.requestId,
-    resultSeed: result.data.seed,
+    seed: result.data.seed
+  };
+}
+async function generateImage(opts, deps) {
+  requireFalKey(deps);
+  const plan = await planGenerateImage(opts, deps);
+  for (const disclosure of plan.disclosures) {
+    if (disclosure.kind === "unsupported") {
+      deps.warn(`⚠️ ${disclosure.key}: ${disclosure.message}`);
+    }
+  }
+  await deps.ensureParentDir(plan.outPath);
+  const preparedInput = await uploadInputImage(deps, plan.inputTarget);
+  const input = preparedInput.url === undefined ? plan.input : { ...plan.input, image_urls: [preparedInput.url] };
+  const saved = await generateAndSave(deps, plan.model, input, plan.outPath);
+  await deps.writeJson(plan.manifestPath, buildManifest({
+    platform: plan.platform,
+    model: plan.model,
+    input,
+    inputImage: preparedInput.record,
+    requestId: saved.requestId,
+    resultSeed: saved.seed,
     requestedSeed: opts.seed,
-    outPath,
-    sha256,
-    contentType: image.content_type,
-    byteLength: bytes.byteLength,
+    outPath: plan.outPath,
+    sha256: saved.sha256,
+    contentType: saved.image.content_type,
+    byteLength: saved.bytes.byteLength,
     generatedAt: deps.now().toISOString(),
     sdkVersion: deps.sdkVersion
   }));
-  return { outPath, manifestPath, sha256 };
+  return { outPath: plan.outPath, manifestPath: plan.manifestPath, sha256: saved.sha256 };
 }
-var DEFAULT_IMAGE_MODEL = "fal-ai/flux-2/flash", GENERATE_IMAGE_PLATFORMS, DEFAULT_GENERATE_IMAGE_PLATFORM = "fal", GenerateImageError, LICENSING = "unverified", FAL_API_KEY_MISSING_MESSAGE = "FAL_API_KEY is not set. Set FAL_API_KEY in your environment to generate images with fal. (FAL_KEY_ID/FAL_KEY_SECRET are not supported by this command.)", EXTENSION_FORMATS, INPUT_DEDICATED_FLAGS;
+var GENERATE_IMAGE_PLATFORMS, DEFAULT_GENERATE_IMAGE_PLATFORM = "fal", GenerateImageError, LICENSING = "unverified", FAL_API_KEY_MISSING_MESSAGE = "FAL_API_KEY is not set. Set FAL_API_KEY in your environment to generate images with fal. (FAL_KEY_ID/FAL_KEY_SECRET are not supported by this command.)", EXTENSION_FORMATS, UNSUPPORTED_OUTPUT_EXTENSIONS, INPUT_DEDICATED_FLAGS, INPUT_IMAGE_CONTENT_TYPES, HTTP_URL_PATTERN;
 var init_image = __esm(() => {
+  init_model_capabilities();
   GENERATE_IMAGE_PLATFORMS = ["fal"];
   GenerateImageError = class GenerateImageError extends Error {
     constructor(message) {
@@ -2321,16 +2609,103 @@ var init_image = __esm(() => {
   };
   EXTENSION_FORMATS = {
     ".png": "png",
-    ".jpg": "jpeg",
-    ".jpeg": "jpeg",
     ".webp": "webp"
   };
+  UNSUPPORTED_OUTPUT_EXTENSIONS = new Set([".jpg", ".jpeg"]);
   INPUT_DEDICATED_FLAGS = {
     prompt: "--prompt",
     seed: "--seed",
     output_format: "--output-format",
-    aspect_ratio: "--aspect-ratio"
+    aspect_ratio: "--aspect-ratio",
+    image_urls: "--input-image"
   };
+  INPUT_IMAGE_CONTENT_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif"
+  };
+  HTTP_URL_PATTERN = /^https?:\/\//i;
+});
+
+// src/commands/generate/local-image-common.ts
+import { createHash as createHash2 } from "node:crypto";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function sha256(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 1)
+    return sorted[middle] ?? 0;
+  return Math.round(((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2);
+}
+function hasPngMagic(bytes) {
+  if (bytes.length < PNG_MAGIC.length)
+    return false;
+  return PNG_MAGIC.every((byte, index) => bytes[index] === byte);
+}
+function readPngDimensions(bytes) {
+  if (bytes.length < 24)
+    return null;
+  if (bytes[12] !== 73 || bytes[13] !== 72 || bytes[14] !== 68 || bytes[15] !== 82) {
+    return null;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+function formatConflicts(conflicts) {
+  const shown = conflicts.slice(0, 10);
+  const lines = shown.map((conflict) => `- ${conflict.path}: ${conflict.reason}`);
+  if (conflicts.length > shown.length) {
+    lines.push(`- and ${conflicts.length - shown.length} more`);
+  }
+  return `Refusing to write ${conflicts.length} output file(s):
+${lines.join(`
+`)}
+Pass --force to overwrite.`;
+}
+async function findOutputConflicts(deps, paths, sourcePaths, sourceIdentities, force) {
+  const matchesSourceIdentity = (identity) => sourceIdentities.some((source) => source !== null && source.dev === identity.dev && source.ino === identity.ino);
+  const conflicts = [];
+  for (const path of paths) {
+    if (sourcePaths.has(path)) {
+      conflicts.push({ path, reason: "this is the source sheet or its manifest" });
+      continue;
+    }
+    if (await deps.isSymlink(path)) {
+      conflicts.push({ path, reason: "this is a symbolic link" });
+      continue;
+    }
+    const status = await deps.pathStatus(path);
+    if (status === "directory") {
+      conflicts.push({ path, reason: "a directory is in the way" });
+      continue;
+    }
+    const identity = await deps.fileIdentity(path);
+    if (identity !== null && matchesSourceIdentity(identity)) {
+      conflicts.push({ path, reason: "this resolves to the source sheet or its manifest" });
+      continue;
+    }
+    if (status === "file" && !force) {
+      conflicts.push({ path, reason: "already exists" });
+    }
+  }
+  return conflicts;
+}
+var SAFE_NAME, MAX_SOURCE_PIXELS = 1e8, MAX_SOURCE_BYTES, MAX_SIDECAR_BYTES, PNG_MAGIC;
+var init_local_image_common = __esm(() => {
+  SAFE_NAME = /^[A-Za-z0-9_][A-Za-z0-9_-]{0,63}$/;
+  MAX_SOURCE_BYTES = 64 * 1024 * 1024;
+  MAX_SIDECAR_BYTES = 1024 * 1024;
+  PNG_MAGIC = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
 });
 
 // ../../node_modules/.pnpm/@fal-ai+client@1.10.1/node_modules/@fal-ai/client/src/middleware.js
@@ -2590,7 +2965,7 @@ var require_utils = __commonJS((exports) => {
   exports.isValidUrl = isValidUrl;
   exports.throttle = throttle;
   exports.isReact = isReact;
-  exports.isPlainObject = isPlainObject;
+  exports.isPlainObject = isPlainObject2;
   exports.sleep = sleep;
   function ensureEndpointIdFormat(id) {
     const parts = id.split("/");
@@ -2666,7 +3041,7 @@ var require_utils = __commonJS((exports) => {
     }
     return isRunningInReact;
   }
-  function isPlainObject(value) {
+  function isPlainObject2(value) {
     return !!value && Object.getPrototypeOf(value) === Object.prototype;
   }
   function sleep(ms) {
@@ -6413,9 +6788,11 @@ var init_package_version = () => {};
 // src/commands/generate/deps.ts
 var exports_deps = {};
 __export(exports_deps, {
+  fetchBytes: () => fetchBytes,
+  createFalRawSubscribe: () => createFalRawSubscribe,
   createDefaultGenerateImageDeps: () => createDefaultGenerateImageDeps
 });
-import { mkdir } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
@@ -6518,16 +6895,18 @@ function describeFalError(err) {
     return formatApiError(err);
   return err instanceof Error ? err.message : String(err);
 }
-function createFalSubscribe(env) {
+function configureFal(env) {
+  const credentials = env.FAL_API_KEY;
+  if (!credentials) {
+    throw new GenerateImageError(FAL_API_KEY_MISSING_MESSAGE);
+  }
+  import_client.fal.config({ credentials });
+}
+function createFalRawSubscribe(env) {
   return async (model, input) => {
-    const credentials = env.FAL_API_KEY;
-    if (!credentials) {
-      throw new GenerateImageError(FAL_API_KEY_MISSING_MESSAGE);
-    }
-    import_client.fal.config({ credentials });
-    let raw;
+    configureFal(env);
     try {
-      raw = await import_client.fal.subscribe(model, {
+      return await import_client.fal.subscribe(model, {
         input,
         logs: false,
         startTimeout: SUBSCRIBE_TIMEOUT_SECONDS
@@ -6535,7 +6914,22 @@ function createFalSubscribe(env) {
     } catch (err) {
       throw new GenerateImageError(describeFalError(err));
     }
-    return validateFalResult(raw);
+  };
+}
+function createFalSubscribe(env) {
+  const subscribe = createFalRawSubscribe(env);
+  return async (model, input) => validateFalResult(await subscribe(model, input));
+}
+function createFalUploadFile(env) {
+  return async (path, contentType) => {
+    configureFal(env);
+    try {
+      const bytes = await readFile(path);
+      const blob = new Blob([new Uint8Array(bytes)], { type: contentType });
+      return await import_client.fal.storage.upload(blob, { lifecycle: { expiresIn: "1d" } });
+    } catch (err) {
+      throw new GenerateImageError(`Failed to upload input image ${path}: ${describeFalError(err)}`);
+    }
   };
 }
 async function ensureParentDir(path) {
@@ -6560,6 +6954,7 @@ function createDefaultGenerateImageDeps() {
   return {
     env,
     falSubscribe: createFalSubscribe(env),
+    uploadFile: createFalUploadFile(env),
     fetchBytes,
     writeFile: writeFileBytes,
     writeJson: writeJsonFile,
@@ -8470,7 +8865,7 @@ var exports_slice_deps = {};
 __export(exports_slice_deps, {
   createDefaultSliceImageDeps: () => createDefaultSliceImageDeps
 });
-import { lstat, mkdir as mkdir2, readFile as readFile2, stat as stat3 } from "node:fs/promises";
+import { lstat, mkdir as mkdir2, readFile as readFile3, stat as stat3 } from "node:fs/promises";
 function decodePng(bytes) {
   const png = PNG.sync.read(Buffer.from(bytes));
   return { width: png.width, height: png.height, data: png.data };
@@ -8500,7 +8895,7 @@ async function statInput(path) {
 async function readJsonIfExists(path) {
   let text;
   try {
-    text = await readFile2(path, "utf8");
+    text = await readFile3(path, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return;
@@ -8537,7 +8932,7 @@ function createDefaultSliceImageDeps() {
   return {
     pathStatus,
     statInput,
-    readFile: readFile2,
+    readFile: readFile3,
     readJsonIfExists,
     decodePng,
     encodePng,
@@ -8574,15 +8969,254 @@ var init_remove_background_deps = __esm(() => {
   init_slice_deps();
 });
 
+// src/commands/generate/remove-background-fal.ts
+import { basename as basename2, resolve as resolve3 } from "node:path";
+function validateBackgroundResult(raw, model) {
+  const unexpected = new RemoveBackgroundFalError(`fal returned no image for ${model}`);
+  if (!isRecord(raw))
+    throw unexpected;
+  const { requestId, data } = raw;
+  if (typeof requestId !== "string" || requestId.length === 0)
+    throw unexpected;
+  if (!isRecord(data) || !isRecord(data.image))
+    throw unexpected;
+  const { url } = data.image;
+  if (typeof url !== "string" || !url.startsWith("https://"))
+    throw unexpected;
+  return { requestId, data: { image: { url } } };
+}
+async function requireSource(path, deps) {
+  const stats = await deps.statInput(path);
+  if (stats.kind === "missing")
+    throw new RemoveBackgroundFalError(`Input not found: ${path}`);
+  if (stats.kind === "directory") {
+    throw new RemoveBackgroundFalError(`Input is a directory: ${path}. Pass a PNG file path.`);
+  }
+  if (stats.kind !== "file") {
+    throw new RemoveBackgroundFalError(`Input is not a regular file: ${path}.`);
+  }
+  if (stats.size > MAX_FAL_INPUT_BYTES) {
+    throw new RemoveBackgroundFalError(`${path} is ${stats.size} bytes; the maximum fal input is ${MAX_FAL_INPUT_BYTES} bytes (8 MiB).`);
+  }
+  const bytes = await deps.readInput(path);
+  if (bytes.byteLength > MAX_FAL_INPUT_BYTES) {
+    throw new RemoveBackgroundFalError(`${path} is ${bytes.byteLength} bytes; the maximum fal input is ${MAX_FAL_INPUT_BYTES} bytes (8 MiB).`);
+  }
+  if (!hasPngMagic(bytes))
+    throw new RemoveBackgroundFalError(`${path} is not a PNG.`);
+  const dimensions = readPngDimensions(bytes);
+  if (dimensions === null || dimensions.width === 0 || dimensions.height === 0) {
+    throw new RemoveBackgroundFalError(`Could not decode ${path}: missing or invalid IHDR.`);
+  }
+  if (dimensions.width * dimensions.height > MAX_SOURCE_PIXELS) {
+    throw new RemoveBackgroundFalError(`${path} is ${dimensions.width}x${dimensions.height}; the maximum is ${MAX_SOURCE_PIXELS} pixels.`);
+  }
+  return { bytes, width: dimensions.width, height: dimensions.height };
+}
+function requireMatchingDimensions(args) {
+  const result = readPngDimensions(args.bytes);
+  const recovery = `The result can still be recovered from that URL.`;
+  const hint = `Re-run with --engine birefnet, or resize the sheet so the engine accepts it.`;
+  if (result === null) {
+    throw new RemoveBackgroundFalError(`Failed to use image for request ${args.requestId} (${args.imageUrl}): could not read the result PNG dimensions; the input is ${args.input.width}x${args.input.height} and ${args.outPath} was not written. ${hint} ${recovery}`);
+  }
+  if (result.width !== args.input.width || result.height !== args.input.height) {
+    throw new RemoveBackgroundFalError(`Failed to use image for request ${args.requestId} (${args.imageUrl}): result is ${result.width}x${result.height}, but the input is ${args.input.width}x${args.input.height}; ${args.outPath} was not written. ${hint} ${recovery}`);
+  }
+  return result;
+}
+async function requireWritablePath2(path, label, force, deps) {
+  const status = await deps.pathStatus(path);
+  if (status === "directory") {
+    throw new RemoveBackgroundFalError(`${label} is a directory: ${path}. Pass a file path.`);
+  }
+  if (status === "file" && !force) {
+    throw new RemoveBackgroundFalError(`${label} already exists: ${path}. Pass --force to overwrite.`);
+  }
+}
+async function requireWritableOutputs(outPath, manifestPath, force, deps) {
+  await requireWritablePath2(outPath, "--out", force, deps);
+  await requireWritablePath2(manifestPath, "Manifest", force, deps);
+}
+function manifestSaveMessage(err, requestId, outPath, manifestPath) {
+  const detail = err instanceof Error ? err.message : String(err);
+  return `Failed to save manifest ${manifestPath} for request ${requestId} (output ${outPath}): ${detail}. The image was written but its manifest is missing.`;
+}
+function recoveryMessage2(action, err, requestId, url) {
+  const detail = err instanceof Error ? err.message : String(err);
+  return `Failed to ${action} image for request ${requestId} (${url}): ${detail}. The result can still be recovered from that URL.`;
+}
+async function removeBackgroundFal(options, deps) {
+  if (!deps.env.FAL_API_KEY) {
+    throw new RemoveBackgroundFalError(FAL_API_KEY_MISSING_MESSAGE);
+  }
+  const engine = options.engine ?? DEFAULT_BACKGROUND_ENGINE;
+  const spec = BACKGROUND_ENGINES[engine];
+  const inPath = resolve3(options.in);
+  const outPath = resolve3(options.out);
+  const manifestPath = `${outPath}.json`;
+  if (inPath === outPath) {
+    throw new RemoveBackgroundFalError(`--in and --out are the same file: ${inPath}. Choose a different output path.`);
+  }
+  const source = await requireSource(inPath, deps);
+  await requireWritableOutputs(outPath, manifestPath, options.force === true, deps);
+  const dataUri = `data:image/png;base64,${Buffer.from(source.bytes).toString("base64")}`;
+  const raw = await deps.falSubscribe(spec.model, spec.buildInput(dataUri));
+  const result = validateBackgroundResult(raw, spec.model);
+  const imageUrl = result.data.image.url;
+  let bytes;
+  try {
+    bytes = await deps.fetchBytes(imageUrl);
+  } catch (err) {
+    throw new RemoveBackgroundFalError(recoveryMessage2("download", err, result.requestId, imageUrl));
+  }
+  if (bytes.byteLength > MAX_FAL_RESULT_BYTES) {
+    throw new RemoveBackgroundFalError(`Downloaded image is ${bytes.byteLength} bytes; the maximum is ${MAX_FAL_RESULT_BYTES} bytes (32 MiB).`);
+  }
+  if (!hasPngMagic(bytes)) {
+    throw new RemoveBackgroundFalError(`Downloaded file is not a PNG (request ${result.requestId}, ${imageUrl}).`);
+  }
+  const outputDimensions = requireMatchingDimensions({
+    bytes,
+    input: source,
+    requestId: result.requestId,
+    imageUrl,
+    outPath
+  });
+  const outputSha256 = sha256(bytes);
+  const manifest = {
+    platform: "fal",
+    tool: TOOL2,
+    sdk: `@fal-ai/client@${deps.sdkVersion}`,
+    engine,
+    model: spec.model,
+    input: {
+      ...engine === "birefnet" ? { mode: "Matting", output_format: "png" } : {},
+      source: basename2(inPath),
+      sourceBytes: source.bytes.byteLength,
+      sourceSha256: sha256(source.bytes),
+      width: source.width,
+      height: source.height
+    },
+    requestId: result.requestId,
+    output: {
+      path: outPath,
+      sha256: outputSha256,
+      bytes: bytes.byteLength,
+      contentType: "image/png",
+      width: outputDimensions.width,
+      height: outputDimensions.height
+    },
+    generatedAt: deps.now().toISOString(),
+    licensing: LICENSING2
+  };
+  try {
+    await deps.ensureParentDir(outPath);
+    await deps.writeFile(outPath, bytes);
+  } catch (err) {
+    throw new RemoveBackgroundFalError(recoveryMessage2("save", err, result.requestId, imageUrl));
+  }
+  try {
+    await deps.writeJson(manifestPath, manifest);
+  } catch (err) {
+    throw new RemoveBackgroundFalError(manifestSaveMessage(err, result.requestId, outPath, manifestPath));
+  }
+  return {
+    outPath,
+    manifestPath,
+    requestId: result.requestId,
+    bytes: bytes.byteLength,
+    sha256: outputSha256
+  };
+}
+var DEFAULT_BACKGROUND_ENGINE = "bria", BACKGROUND_ENGINES, MAX_FAL_INPUT_BYTES, MAX_FAL_RESULT_BYTES, TOOL2 = "chatroom remove-image-background-fal", LICENSING2 = "unverified", RemoveBackgroundFalError;
+var init_remove_background_fal = __esm(() => {
+  init_image();
+  init_local_image_common();
+  BACKGROUND_ENGINES = {
+    bria: {
+      model: "fal-ai/bria/background/remove",
+      buildInput: (image_url) => ({ image_url })
+    },
+    birefnet: {
+      model: "fal-ai/birefnet/v2",
+      buildInput: (image_url) => ({ image_url, model: "Matting", output_format: "png" })
+    }
+  };
+  MAX_FAL_INPUT_BYTES = 8 * 1024 * 1024;
+  MAX_FAL_RESULT_BYTES = 32 * 1024 * 1024;
+  RemoveBackgroundFalError = class RemoveBackgroundFalError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "RemoveBackgroundFalError";
+    }
+  };
+});
+
+// src/commands/generate/remove-background-fal-deps.ts
+var exports_remove_background_fal_deps = {};
+__export(exports_remove_background_fal_deps, {
+  createDefaultRemoveBackgroundFalDeps: () => createDefaultRemoveBackgroundFalDeps
+});
+import { dirname as dirname4 } from "node:path";
+function mebibytes(bytes) {
+  return Math.round(bytes / (1024 * 1024));
+}
+function requireDeclaredSize(declared, maxBytes) {
+  if (declared === null)
+    return;
+  const size = Number(declared);
+  if (!Number.isFinite(size) || size <= maxBytes)
+    return;
+  throw new Error(`Downloaded image is ${size} bytes; the maximum is ${maxBytes} bytes (${mebibytes(maxBytes)} MiB).`);
+}
+function requireImageContentType2(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.toLowerCase().startsWith("image/"))
+    return;
+  throw new Error(`Downloaded file is not an image (HTTP ${response.status}, content-type: ${contentType || "missing"})`);
+}
+async function fetchCappedBytes(url, maxBytes) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download image (HTTP ${response.status} ${response.statusText})`);
+  }
+  requireDeclaredSize(response.headers.get("content-length"), maxBytes);
+  requireImageContentType2(response);
+  return new Uint8Array(await response.arrayBuffer());
+}
+function createDefaultRemoveBackgroundFalDeps() {
+  const slice = createDefaultSliceImageDeps();
+  return {
+    env: process.env,
+    falSubscribe: createFalRawSubscribe(process.env),
+    fetchBytes: (url) => fetchCappedBytes(url, MAX_FAL_RESULT_BYTES),
+    readInput: slice.readFile,
+    statInput: slice.statInput,
+    pathStatus: slice.pathStatus,
+    writeFile: slice.writeFile,
+    writeJson: slice.writeJson,
+    ensureParentDir: (path) => slice.ensureDir(dirname4(path)),
+    now: () => new Date,
+    sdkVersion: readInstalledPackageVersion("@fal-ai/client")
+  };
+}
+var init_remove_background_fal_deps = __esm(() => {
+  init_deps();
+  init_package_version();
+  init_remove_background_fal();
+  init_slice_deps();
+});
+
 // src/utils/file-content.ts
 var exports_file_content = {};
 __export(exports_file_content, {
   readFileContent: () => readFileContent
 });
 import { readFileSync as readFileSync2 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 function readFileContent(filePath, optionName) {
-  const absolutePath = resolve4(process.cwd(), filePath);
+  const absolutePath = resolve5(process.cwd(), filePath);
   try {
     return readFileSync2(absolutePath, "utf-8");
   } catch (err) {
@@ -8663,12 +9297,12 @@ var init_stdin_heredoc = __esm(() => {
 
 // src/version.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { dirname as dirname5, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getVersion() {
   try {
     const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname4(__filename2);
+    const __dirname2 = dirname5(__filename2);
     const possiblePaths = [
       join4(__dirname2, "..", "package.json"),
       join4(__dirname2, "..", "..", "package.json")
@@ -10094,11 +10728,11 @@ class RequestManager {
     this.requestsOlderThanRestart = /* @__PURE__ */ new Set;
   }
   request(message, sent) {
-    const result = new Promise((resolve5) => {
+    const result = new Promise((resolve6) => {
       const status = sent ? "Requested" : "NotSent";
       this.inflightRequests.set(message.requestId, {
         message,
-        status: { status, requestedAt: /* @__PURE__ */ new Date, onResult: resolve5 }
+        status: { status, requestedAt: /* @__PURE__ */ new Date, onResult: resolve6 }
       });
       if (message.type === "Mutation") {
         this.inflightMutationsCount++;
@@ -12603,10 +13237,10 @@ class ConvexClient {
     const value = this.client.localQueryResult(getFunctionName(query), args);
     if (value !== undefined)
       return Promise.resolve(value);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const { unsubscribe } = this.onUpdate(query, args, (value2) => {
         unsubscribe();
-        resolve5(value2);
+        resolve6(value2);
       }, (e) => {
         unsubscribe();
         reject(e);
@@ -12716,10 +13350,10 @@ var init_simple_client_node = __esm(() => {
           if (debug)
             return debug;
         }
-        var prebuild = resolve5(dir);
+        var prebuild = resolve6(dir);
         if (prebuild)
           return prebuild;
-        var nearby = resolve5(path.dirname(process.execPath));
+        var nearby = resolve6(path.dirname(process.execPath));
         if (nearby)
           return nearby;
         var target = [
@@ -12737,7 +13371,7 @@ var init_simple_client_node = __esm(() => {
         throw new Error("No native build was found for " + target + `
     loaded from: ` + dir + `
 `);
-        function resolve5(dir2) {
+        function resolve6(dir2) {
           var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
           var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
           if (!tuple)
@@ -15962,10 +16596,10 @@ class ConvexHttpClient {
     }
     this.isProcessingQueue = true;
     while (this.mutationQueue.length > 0) {
-      const { mutation, args, resolve: resolve5, reject } = this.mutationQueue.shift();
+      const { mutation, args, resolve: resolve6, reject } = this.mutationQueue.shift();
       try {
         const result = await this.mutationInner(mutation, args);
-        resolve5(result);
+        resolve6(result);
       } catch (error) {
         reject(error);
       }
@@ -15973,8 +16607,8 @@ class ConvexHttpClient {
     this.isProcessingQueue = false;
   }
   enqueueMutation(mutation, args) {
-    return new Promise((resolve5, reject) => {
-      this.mutationQueue.push({ mutation, args, resolve: resolve5, reject });
+    return new Promise((resolve6, reject) => {
+      this.mutationQueue.push({ mutation, args, resolve: resolve6, reject });
       this.processMutationQueue();
     });
   }
@@ -16606,7 +17240,7 @@ async function retryValidation(sessionId, convexUrl, retryIntervalMs) {
       } else {
         console.log(`❌ Backend still unreachable (attempt ${consecutiveNetworkFailures}, retrying in ${retrySec}s)`);
       }
-      await new Promise((resolve5) => setTimeout(resolve5, retryIntervalMs));
+      await new Promise((resolve6) => setTimeout(resolve6, retryIntervalMs));
     }
   }
 }
@@ -20369,8 +21003,8 @@ ${prefix}}`;
   const runFork2 = runForkWith(context2);
   return (effect, options) => {
     const fiber2 = runFork2(effect, options);
-    return new Promise((resolve5) => {
-      fiber2.addObserver((exit2) => resolve5(exit2));
+    return new Promise((resolve6) => {
+      fiber2.addObserver((exit2) => resolve6(exit2));
     });
   };
 }, runPromiseExit, runPromiseWith = (context2) => {
@@ -25261,7 +25895,7 @@ var init_clock = __esm(() => {
   };
   ClockServiceLive = exports_Layer.succeed(ClockService, {
     now: () => exports_Effect.sync(() => Date.now()),
-    delay: (ms) => exports_Effect.promise(() => new Promise((resolve5) => setTimeout(resolve5, ms)))
+    delay: (ms) => exports_Effect.promise(() => new Promise((resolve6) => setTimeout(resolve6, ms)))
   });
 });
 
@@ -25368,7 +26002,7 @@ function createDefaultDeps() {
     },
     clock: {
       now: () => Date.now(),
-      delay: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms))
+      delay: (ms) => new Promise((resolve6) => setTimeout(resolve6, ms))
     },
     process: {
       env: process.env,
@@ -25933,7 +26567,7 @@ class BaseCLIAgentService {
       } catch {
         return;
       }
-      await new Promise((resolve5) => setTimeout(resolve5, POLL_INTERVAL_MS));
+      await new Promise((resolve6) => setTimeout(resolve6, POLL_INTERVAL_MS));
     }
     try {
       this.deps.kill(-pid, "SIGKILL");
@@ -25969,7 +26603,7 @@ class BaseCLIAgentService {
     return buildAgentSpawnEnv(resolvedConvexUrl);
   }
   async assertChildProcessStarted(childProcess) {
-    await new Promise((resolve5) => setTimeout(resolve5, SPAWN_READY_DELAY_MS));
+    await new Promise((resolve6) => setTimeout(resolve6, SPAWN_READY_DELAY_MS));
     if (childProcess.killed || childProcess.exitCode !== null) {
       throw new Error(`Agent process exited immediately (exit code: ${childProcess.exitCode})`);
     }
@@ -26411,7 +27045,7 @@ function applyAgentConfigOverrides(input) {
   };
 }
 function waitForSlotChange(execution, input, remainingMs) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let settled = false;
     const finish = (error) => {
       if (settled)
@@ -26425,7 +27059,7 @@ function waitForSlotChange(execution, input, remainingMs) {
       if (error !== undefined)
         reject(error);
       else
-        resolve5();
+        resolve6();
     };
     const matches = (event) => event.chatroomId === input.chatroomId && event.role.toLowerCase() === input.role.toLowerCase();
     const onStarted = async (event) => {
@@ -26513,8 +27147,8 @@ function createAgentProcessManagerService(deps) {
   });
   const submit = (commandFactory) => {
     const operationId = randomUUID();
-    const completion = new Promise((resolve5, reject) => {
-      pendingOperations.set(operationId, { resolve: resolve5, reject });
+    const completion = new Promise((resolve6, reject) => {
+      pendingOperations.set(operationId, { resolve: resolve6, reject });
     });
     const command = commandFactory(operationId);
     const message = commandMessage(command);
@@ -27058,7 +27692,7 @@ __export(exports_util, {
   jsonStringifyReplacer: () => jsonStringifyReplacer,
   joinValues: () => joinValues,
   issue: () => issue,
-  isPlainObject: () => isPlainObject,
+  isPlainObject: () => isPlainObject2,
   isObject: () => isObject,
   hexToUint8Array: () => hexToUint8Array,
   getSizableOrigin: () => getSizableOrigin,
@@ -27223,7 +27857,7 @@ function slugify(input) {
 function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-function isPlainObject(o) {
+function isPlainObject2(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -27240,7 +27874,7 @@ function isPlainObject(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject(o))
+  if (isPlainObject2(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -27380,7 +28014,7 @@ function omit2(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -27403,7 +28037,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs(schema._zod.def, {
@@ -28886,7 +29520,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject(a) && isPlainObject(b)) {
+  if (isPlainObject2(a) && isPlainObject2(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -30143,7 +30777,7 @@ var init_schemas = __esm(() => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
       const input = payload.value;
-      if (!isPlainObject(input)) {
+      if (!isPlainObject2(input)) {
         payload.issues.push({
           expected: "record",
           code: "invalid_type",
@@ -42954,7 +43588,7 @@ var init_parse_session_augmentation = __esm(() => {
 
 // src/daemon/services/task-service/service/native-cold-session-before-inject.ts
 function sleep3(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function waitForHarnessSessionId(agentMgr, chatroomId, role, signal) {
   const deadline = Date.now() + HARNESS_SESSION_READY_TIMEOUT_MS;
@@ -43485,8 +44119,8 @@ class AgentWorkManager {
     if (existing)
       return existing.drainPromise;
     let resolveCompletion;
-    const completion = new Promise((resolve5) => {
-      resolveCompletion = resolve5;
+    const completion = new Promise((resolve6) => {
+      resolveCompletion = resolve6;
     });
     getRoleDeliveryState().resetDeliveryState(args2.chatroomId, args2.role);
     const drainPromise = this.nativeTaskDeliveryQueue.invalidateRole(args2.chatroomId, args2.role);
@@ -44478,7 +45112,7 @@ class InMemoryCommandQueueStore {
 // src/daemon/services/agent-process-service/infrastructure/components/command-queue/consumer/command-queue-consumer.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 function defaultSleep(milliseconds) {
-  return new Promise((resolve5) => setTimeout(resolve5, milliseconds));
+  return new Promise((resolve6) => setTimeout(resolve6, milliseconds));
 }
 
 class CommandQueueConsumer {
@@ -48083,7 +48717,7 @@ var init_task_service = __esm(() => {
 
 // src/daemon/services/task-service/infrastructure/repository/task-handoff-repository.ts
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname6 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 function normalizeRole(role) {
   return role.toLowerCase();
@@ -48103,7 +48737,7 @@ function mapRow(row) {
   };
 }
 function createTaskHandoffRepository(dbPath) {
-  mkdirSync2(dirname5(dbPath), { recursive: true });
+  mkdirSync2(dirname6(dbPath), { recursive: true });
   const db = new DatabaseSync(dbPath);
   db.exec(`
     CREATE TABLE IF NOT EXISTS task_handoffs (
@@ -50032,7 +50666,7 @@ function isCatalogueStable(state, key, now) {
   return now - state.stableSince >= WARMUP_STABLE_WINDOW_MS;
 }
 function sleep4(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, Math.max(0, ms)));
+  return new Promise((resolve6) => setTimeout(resolve6, Math.max(0, ms)));
 }
 async function readCatalogueKey(client2, directory, timeoutMs) {
   let timer;
@@ -50067,7 +50701,7 @@ function serverAuthHeaders(password) {
   };
 }
 async function waitForListeningUrl(child, options) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const buffers = { stdout: "", stderr: "" };
     let url2;
     let password;
@@ -50084,7 +50718,7 @@ async function waitForListeningUrl(child, options) {
       if (url2 === undefined)
         return;
       cleanup();
-      resolve5({ url: url2, ...password !== undefined ? { password } : {} });
+      resolve6({ url: url2, ...password !== undefined ? { password } : {} });
     };
     const tryMatch = (key, chunk) => {
       buffers[key] += typeof chunk === "string" ? chunk : chunk.toString("utf8");
@@ -50217,7 +50851,7 @@ async function stopServeProcess(deps, child) {
     } catch {
       return;
     }
-    await new Promise((resolve5) => setTimeout(resolve5, SERVE_KILL_POLL_INTERVAL_MS));
+    await new Promise((resolve6) => setTimeout(resolve6, SERVE_KILL_POLL_INTERVAL_MS));
   }
   try {
     deps.kill(-pid, "SIGKILL");
@@ -50762,27 +51396,27 @@ var init_pi_agent_service = __esm(() => {
       return childProcess;
     }
     writePrompt(child, prompt) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         if (!child.stdin) {
           reject(new Error("Pi RPC process has no stdin"));
           return;
         }
         const message = JSON.stringify({ type: "prompt", message: prompt }) + `
 `;
-        child.stdin.write(message, (err) => err ? reject(err) : resolve5());
+        child.stdin.write(message, (err) => err ? reject(err) : resolve6());
       });
     }
     async querySessionId(reader, stdin) {
       if (!stdin) {
         throw new Error("Pi RPC process has no stdin");
       }
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         const timer = setTimeout(() => {
           reject(new Error(`get_state timed out after ${GET_STATE_TIMEOUT_MS}ms`));
         }, GET_STATE_TIMEOUT_MS);
         reader.onStateResponse((sessionId) => {
           clearTimeout(timer);
-          resolve5(sessionId);
+          resolve6(sessionId);
         });
         stdin.write(JSON.stringify({ type: "get_state" }) + `
 `);
@@ -51128,12 +51762,12 @@ var init_model_provider = () => {};
 // src/daemon/infrastructure/local/harness/services/cursor-sdk/cursor-sdk-package.ts
 import { existsSync as existsSync2, readFileSync as readFileSync5 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { dirname as dirname7, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 function resolveChatroomCliRoot(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath2(moduleRef) : moduleRef;
-  let dir = dirname6(filePath);
-  while (dir !== dirname6(dir)) {
+  let dir = dirname7(filePath);
+  while (dir !== dirname7(dir)) {
     const packageJsonPath = join9(dir, "package.json");
     if (existsSync2(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
@@ -51141,7 +51775,7 @@ function resolveChatroomCliRoot(moduleRef = import.meta.url) {
         return dir;
       }
     }
-    dir = dirname6(dir);
+    dir = dirname7(dir);
   }
   throw new CursorSdkPackageError(`Could not locate chatroom-cli package root while resolving @cursor/sdk. ${REINSTALL_HINT}`);
 }
@@ -51156,7 +51790,7 @@ function readPinnedSdkVersion(chatroomCliRoot) {
   return match5[1];
 }
 function readInstalledSdkVersion(entryPath) {
-  const packageJsonPath = join9(dirname6(entryPath), "..", "..", "package.json");
+  const packageJsonPath = join9(dirname7(entryPath), "..", "..", "package.json");
   const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
   return pkg.version;
 }
@@ -52077,12 +52711,12 @@ import {
 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname7, join as join10 } from "node:path";
+import { basename as basename4, dirname as dirname8, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
 function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath3(moduleRef) : moduleRef;
-  let dir = dirname7(filePath);
-  while (dir !== dirname7(dir)) {
+  let dir = dirname8(filePath);
+  while (dir !== dirname8(dir)) {
     const packageJsonPath = join10(dir, "package.json");
     if (existsSync3(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
@@ -52090,7 +52724,7 @@ function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
         return realpathSync(dir);
       }
     }
-    dir = dirname7(dir);
+    dir = dirname8(dir);
   }
   throw new ClaudeSdkPackageError(`Could not locate chatroom-cli package root while resolving ${CLAUDE_AGENT_SDK_PKG}. ${REINSTALL_HINT2}`);
 }
@@ -52105,7 +52739,7 @@ function readPinnedSdkVersion2(chatroomCliRoot) {
   return match5[1];
 }
 function readInstalledSdkVersion2(entryPath) {
-  const packageJsonPath = join10(dirname7(entryPath), "package.json");
+  const packageJsonPath = join10(dirname8(entryPath), "package.json");
   const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
   return pkg.version;
 }
@@ -52131,7 +52765,7 @@ function resolveNativeCliBinaryPath(sdkEntryPath) {
   const binaryName = process.platform === "win32" ? "claude.exe" : "claude";
   let pkgDir;
   try {
-    pkgDir = dirname7(require3.resolve(`${platformPkg}/package.json`));
+    pkgDir = dirname8(require3.resolve(`${platformPkg}/package.json`));
   } catch {
     throw new ClaudeSdkPackageError(`Native CLI binary package ${platformPkg} is not installed. ${REINSTALL_HINT2}`);
   }
@@ -52143,7 +52777,7 @@ function resolveNativeCliBinaryPath(sdkEntryPath) {
 }
 function pinNativeBinary(sourcePath, sdkVersion, pinRoot) {
   const dir = join10(pinRoot, sdkVersion);
-  const pinnedPath = join10(dir, basename3(sourcePath));
+  const pinnedPath = join10(dir, basename4(sourcePath));
   if (existsSync3(pinnedPath))
     return pinnedPath;
   mkdirSync3(dir, { recursive: true, mode: 448 });
@@ -52226,8 +52860,8 @@ function createTurnCompletion(turnId = randomUUID3()) {
   let resolveResult;
   let value;
   const listeners = new Set;
-  const result3 = new Promise((resolve5) => {
-    resolveResult = resolve5;
+  const result3 = new Promise((resolve6) => {
+    resolveResult = resolve6;
   });
   return {
     turnId,
@@ -52599,18 +53233,18 @@ function waitForResumeOrAbort(session2) {
     return Promise.resolve(queued);
   }
   return Promise.race([
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.resumeResolve = (prompt) => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
       };
     }),
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.abortResolve = () => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(null);
+        resolve6(null);
       };
     })
   ]);
@@ -52694,10 +53328,10 @@ var init_claude_sdk_agent_service = __esm(() => {
         throw new Error(`No claude-sdk session for pid=${pid}`);
       }
       if (session2.resumeResolve) {
-        const resolve5 = session2.resumeResolve;
+        const resolve6 = session2.resumeResolve;
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
         return;
       }
       session2.pendingResumePrompt = prompt;
@@ -53065,12 +53699,12 @@ var init_codex_sdk_model_variants = __esm(() => {
 // src/daemon/infrastructure/local/harness/services/codex-sdk/codex-sdk-package.ts
 import { existsSync as existsSync4, readFileSync as readFileSync7, realpathSync as realpathSync2, statSync } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { dirname as dirname8, join as join11 } from "node:path";
+import { dirname as dirname9, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
 function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath4(moduleRef) : moduleRef;
-  let dir = dirname8(filePath);
-  while (dir !== dirname8(dir)) {
+  let dir = dirname9(filePath);
+  while (dir !== dirname9(dir)) {
     const packageJsonPath = join11(dir, "package.json");
     if (existsSync4(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
@@ -53078,7 +53712,7 @@ function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
         return dir;
       }
     }
-    dir = dirname8(dir);
+    dir = dirname9(dir);
   }
   throw new CodexSdkPackageError(`Could not locate chatroom-cli package root while resolving @openai/codex-sdk. ${REINSTALL_HINT3}`);
 }
@@ -53145,7 +53779,7 @@ function addPlatformPackageJsonCandidate(candidates, candidate) {
 }
 function resolvePlatformPackageJsonCandidates(platformPkg, chatroomCliRoot, codexPackageJson, chatroomRequire, codexRequire) {
   const candidates = [];
-  const codexPackageDir = realpathSync2(dirname8(codexPackageJson));
+  const codexPackageDir = realpathSync2(dirname9(codexPackageJson));
   const platformPkgBaseName = platformPkg.includes("/") ? platformPkg.slice(platformPkg.indexOf("/") + 1) : platformPkg;
   try {
     addPlatformPackageJsonCandidate(candidates, codexRequire.resolve(`${platformPkg}/package.json`));
@@ -53189,7 +53823,7 @@ function resolveCodexExecutablePath(moduleRef = import.meta.url) {
     throw new CodexSdkPackageError(`Native Codex CLI package ${platformPkg} is not installed. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies. ${REINSTALL_HINT3}`);
   }
   for (const platformPackageJson of platformPackageJsonCandidates) {
-    const vendorRoot = join11(dirname8(platformPackageJson), "vendor");
+    const vendorRoot = join11(dirname9(platformPackageJson), "vendor");
     const binaryPath = resolveNativeCodexBinary(vendorRoot, targetTriple, codexBinaryName);
     if (binaryPath) {
       return binaryPath;
@@ -53205,7 +53839,7 @@ async function importBundledCodexSdk(moduleRef = import.meta.url) {
   if (installedVersion !== pinnedVersion) {
     throw new CodexSdkPackageError(`@openai/codex-sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT3}`);
   }
-  const distEntryPath = join11(dirname8(packageJsonPath), "dist", "index.js");
+  const distEntryPath = join11(dirname9(packageJsonPath), "dist", "index.js");
   if (!existsSync4(distEntryPath)) {
     throw new CodexSdkPackageError(`@openai/codex-sdk entry file is missing: ${distEntryPath}. ${REINSTALL_HINT3}`);
   }
@@ -53497,18 +54131,18 @@ function waitForResumeOrAbort2(session2) {
     return Promise.resolve(queued);
   }
   return Promise.race([
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.resumeResolve = (prompt) => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
       };
     }),
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.abortResolve = () => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(null);
+        resolve6(null);
       };
     })
   ]);
@@ -53589,10 +54223,10 @@ var init_codex_sdk_agent_service = __esm(() => {
         throw new Error(`No codex-sdk session for pid=${pid}`);
       }
       if (session2.resumeResolve) {
-        const resolve5 = session2.resumeResolve;
+        const resolve6 = session2.resumeResolve;
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
         return;
       }
       session2.pendingResumePrompt = prompt;
@@ -54468,18 +55102,18 @@ function waitForResumeOrAbort3(session2) {
     return Promise.resolve(queued);
   }
   return Promise.race([
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.resumeResolve = (prompt) => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
       };
     }),
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.abortResolve = () => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(null);
+        resolve6(null);
       };
     })
   ]);
@@ -54552,10 +55186,10 @@ var init_cursor_sdk_agent_service = __esm(() => {
         throw new Error(`No cursor-sdk session for pid=${pid}`);
       }
       if (session2.resumeResolve) {
-        const resolve5 = session2.resumeResolve;
+        const resolve6 = session2.resumeResolve;
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
         return;
       }
       session2.pendingResumePrompt = prompt;
@@ -54955,8 +55589,8 @@ function startSessionEventForwarder(client2, options) {
   const agentEndCallbacks = [];
   const recentLogLines = [];
   let retryIdleTimeout;
-  const donePromise = new Promise((resolve5) => {
-    doneResolve = resolve5;
+  const donePromise = new Promise((resolve6) => {
+    doneResolve = resolve6;
   });
   function recordRecentLogLine(line) {
     recentLogLines.push(line);
@@ -55298,7 +55932,7 @@ var init_session_event_forwarder = __esm(() => {
 // src/daemon/infrastructure/local/harness/services/opencode-sdk/session-metadata-store.ts
 import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname9, join as join12 } from "node:path";
+import { dirname as dirname10, join as join12 } from "node:path";
 
 class FileSessionMetadataStore {
   filePath;
@@ -55315,7 +55949,7 @@ class FileSessionMetadataStore {
   }
   save(sessions) {
     try {
-      const dir = dirname9(this.filePath);
+      const dir = dirname10(this.filePath);
       if (!existsSync5(dir)) {
         mkdirSync4(dir, { recursive: true, mode: 448 });
       }
@@ -55898,12 +56532,12 @@ var init_opencode_sdk = __esm(() => {
 
 // src/daemon/infrastructure/local/harness/services/pi-sdk/pi-sdk-package.ts
 import { existsSync as existsSync6, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname10, join as join13 } from "node:path";
+import { dirname as dirname11, join as join13 } from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL4 } from "node:url";
 function resolveChatroomCliRoot4(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath5(moduleRef) : moduleRef;
-  let dir = dirname10(filePath);
-  while (dir !== dirname10(dir)) {
+  let dir = dirname11(filePath);
+  while (dir !== dirname11(dir)) {
     const packageJsonPath = join13(dir, "package.json");
     if (existsSync6(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
@@ -55911,7 +56545,7 @@ function resolveChatroomCliRoot4(moduleRef = import.meta.url) {
         return dir;
       }
     }
-    dir = dirname10(dir);
+    dir = dirname11(dir);
   }
   throw new PiSdkPackageError(`Could not locate chatroom-cli package root while resolving ${PI_CODING_AGENT_PKG}. ${REINSTALL_HINT4}`);
 }
@@ -55926,18 +56560,18 @@ function readPinnedSdkVersion4(chatroomCliRoot) {
   return match5[1];
 }
 function readInstalledSdkVersion4(entryPath) {
-  const packageJsonPath = join13(dirname10(entryPath), "..", "package.json");
+  const packageJsonPath = join13(dirname11(entryPath), "..", "package.json");
   const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
   return pkg.version;
 }
 function resolvePiSdkEntryPathFromNodeModules(chatroomCliRoot) {
   let dir = chatroomCliRoot;
-  while (dir !== dirname10(dir)) {
+  while (dir !== dirname11(dir)) {
     const entryPath = join13(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
     if (existsSync6(entryPath)) {
       return entryPath;
     }
-    dir = dirname10(dir);
+    dir = dirname11(dir);
   }
   return;
 }
@@ -56156,18 +56790,18 @@ function waitForResumeOrAbort4(session2) {
     return Promise.resolve(queued);
   }
   return Promise.race([
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.resumeResolve = (prompt) => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
       };
     }),
-    new Promise((resolve5) => {
+    new Promise((resolve6) => {
       session2.abortResolve = () => {
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(null);
+        resolve6(null);
       };
     })
   ]);
@@ -56271,10 +56905,10 @@ var init_pi_sdk_agent_service = __esm(() => {
         throw new Error(`No pi-sdk session for pid=${pid}`);
       }
       if (session2.resumeResolve) {
-        const resolve5 = session2.resumeResolve;
+        const resolve6 = session2.resumeResolve;
         session2.resumeResolve = undefined;
         session2.abortResolve = undefined;
-        resolve5(prompt);
+        resolve6(prompt);
         return;
       }
       session2.pendingResumePrompt = prompt;
@@ -63399,9 +64033,9 @@ var init_socket2 = __esm(() => {
       this.acks[id] = fn3;
     }
     emitWithAck(ev, ...args2) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         const fn3 = (arg1, arg2) => {
-          return arg1 ? reject(arg1) : resolve5(arg2);
+          return arg1 ? reject(arg1) : resolve6(arg2);
         };
         fn3.withError = true;
         args2.push(fn3);
@@ -64080,10 +64714,10 @@ async function requestLocalDaemon(port, event, payload) {
     timeout: 2000
   });
   try {
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const onConnect = () => {
         cleanup();
-        resolve5();
+        resolve6();
       };
       const onError3 = (error51) => {
         cleanup();
@@ -64339,10 +64973,10 @@ var init_log_schema = __esm(() => {
 
 // src/infrastructure/log-server/open-log-database.ts
 import { mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function openLogDatabase(dbPath) {
-  mkdirSync5(dirname11(dbPath), { recursive: true });
+  mkdirSync5(dirname12(dbPath), { recursive: true });
   const db = new DatabaseSync2(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
@@ -64612,7 +65246,7 @@ function signalBestEffort(pid, signal, send) {
 async function stopExistingDaemons(options) {
   const isRunning = options?.isRunning ?? isProcessRunning;
   const send = options?.signal ?? defaultSignal;
-  const sleep5 = options?.sleep ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
+  const sleep5 = options?.sleep ?? ((ms) => new Promise((resolve6) => setTimeout(resolve6, ms)));
   const log3 = options?.log ?? ((message) => console.error(message));
   const waitMs = options?.waitMs ?? STOP_EXISTING_WAIT_MS;
   const listPids = options?.listMatchingDaemonPids ?? listMatchingDaemonPids;
@@ -64671,7 +65305,7 @@ async function waitForLockOrTimeout(deadline, intervalMs, sleep5) {
 async function acquireLockWithRetry(options) {
   const intervalMs = options?.intervalMs ?? LOCK_RETRY_INTERVAL_MS;
   const maxWaitMs = options?.maxWaitMs ?? LOCK_RETRY_MAX_WAIT_MS;
-  const sleep5 = options?.sleep ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
+  const sleep5 = options?.sleep ?? ((ms) => new Promise((resolve6) => setTimeout(resolve6, ms)));
   await stopExistingDaemons({
     listMatchingDaemonPids: options?.listMatchingDaemonPids,
     isRunning: options?.isRunning,
@@ -65176,26 +65810,26 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run = async (function_, resolve5, arguments_) => {
+  const run = async (function_, resolve6, arguments_) => {
     const result3 = (async () => function_(...arguments_))();
-    resolve5(result3);
+    resolve6(result3);
     try {
       await result3;
     } catch {}
     next2();
   };
-  const enqueue = (function_, resolve5, reject, arguments_) => {
+  const enqueue = (function_, resolve6, reject, arguments_) => {
     const queueItem = { reject };
     new Promise((internalResolve) => {
       queueItem.run = internalResolve;
       queue.enqueue(queueItem);
-    }).then(run.bind(undefined, function_, resolve5, arguments_));
+    }).then(run.bind(undefined, function_, resolve6, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve5, reject) => {
-    enqueue(function_, resolve5, reject, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve6, reject) => {
+    enqueue(function_, resolve6, reject, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -65274,11 +65908,11 @@ var init_config2 = __esm(() => {
 // ../../node_modules/.pnpm/@hyzyla+pdfium@2.1.13/node_modules/@hyzyla/pdfium/dist/index.esm.js
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value2) {
-    return value2 instanceof P ? value2 : new P(function(resolve5) {
-      resolve5(value2);
+    return value2 instanceof P ? value2 : new P(function(resolve6) {
+      resolve6(value2);
     });
   }
-  return new (P || (P = Promise))(function(resolve5, reject) {
+  return new (P || (P = Promise))(function(resolve6, reject) {
     function fulfilled(value2) {
       try {
         step(generator.next(value2));
@@ -65294,7 +65928,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result3) {
-      result3.done ? resolve5(result3.value) : adopt(result3.value).then(fulfilled, rejected);
+      result3.done ? resolve6(result3.value) : adopt(result3.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -65954,13 +66588,13 @@ var init_index_esm = __esm(() => {
           }
           readAsync = async (url3) => {
             if (isFileURI(url3)) {
-              return new Promise((resolve5, reject) => {
+              return new Promise((resolve6, reject) => {
                 var xhr = new XMLHttpRequest;
                 xhr.open("GET", url3, true);
                 xhr.responseType = "arraybuffer";
                 xhr.onload = () => {
                   if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                    resolve5(xhr.response);
+                    resolve6(xhr.response);
                     return;
                   }
                   reject(xhr.status);
@@ -66294,10 +66928,10 @@ var init_index_esm = __esm(() => {
         }
         var info = getWasmImports();
         if (Module["instantiateWasm"]) {
-          return new Promise((resolve5, reject) => {
+          return new Promise((resolve6, reject) => {
             try {
               Module["instantiateWasm"](info, (mod, inst) => {
-                resolve5(receiveInstance(mod, inst));
+                resolve6(receiveInstance(mod, inst));
               });
             } catch (e) {
               err(`Module.instantiateWasm callback failed with error: ${e}`);
@@ -70979,8 +71613,8 @@ var init_index_esm = __esm(() => {
       if (runtimeInitialized) {
         moduleRtn = Module;
       } else {
-        moduleRtn = new Promise((resolve5, reject) => {
-          readyPromiseResolve = resolve5;
+        moduleRtn = new Promise((resolve6, reject) => {
+          readyPromiseResolve = resolve6;
           readyPromiseReject = reject;
         });
       }
@@ -71103,14 +71737,14 @@ var require_filesystem = __commonJS((exports, module) => {
     fs6.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile6 = (path2) => new Promise((resolve5, reject) => {
+  var readFile7 = (path2) => new Promise((resolve6, reject) => {
     fs6.open(path2, "r", (err, fd) => {
       if (err) {
         reject(err);
       } else {
         const buffer = Buffer.alloc(MAX_LENGTH);
         fs6.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
-          resolve5(buffer.subarray(0, bytesRead));
+          resolve6(buffer.subarray(0, bytesRead));
           fs6.close(fd, () => {});
         });
       }
@@ -71120,7 +71754,7 @@ var require_filesystem = __commonJS((exports, module) => {
     LDD_PATH,
     SELF_PATH,
     readFileSync: readFileSync12,
-    readFile: readFile6
+    readFile: readFile7
   };
 });
 
@@ -71162,7 +71796,7 @@ var require_elf = __commonJS((exports, module) => {
 var require_detect_libc = __commonJS((exports, module) => {
   var childProcess = __require("child_process");
   var { isLinux, getReport } = require_process();
-  var { LDD_PATH, SELF_PATH, readFile: readFile6, readFileSync: readFileSync12 } = require_filesystem();
+  var { LDD_PATH, SELF_PATH, readFile: readFile7, readFileSync: readFileSync12 } = require_filesystem();
   var { interpreterPath } = require_elf();
   var cachedFamilyInterpreter;
   var cachedFamilyFilesystem;
@@ -71171,10 +71805,10 @@ var require_detect_libc = __commonJS((exports, module) => {
   var commandOut = "";
   var safeCommand = () => {
     if (!commandOut) {
-      return new Promise((resolve5) => {
+      return new Promise((resolve6) => {
         childProcess.exec(command, (err, out) => {
           commandOut = err ? " " : out;
-          resolve5(commandOut);
+          resolve6(commandOut);
         });
       });
     }
@@ -71242,7 +71876,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = await readFile6(LDD_PATH);
+      const lddContent = await readFile7(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e) {}
     return cachedFamilyFilesystem;
@@ -71264,7 +71898,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyInterpreter = null;
     try {
-      const selfContent = await readFile6(SELF_PATH);
+      const selfContent = await readFile7(SELF_PATH);
       const path2 = interpreterPath(selfContent);
       cachedFamilyInterpreter = familyFromInterpreterPath(path2);
     } catch (e) {}
@@ -71324,7 +71958,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = await readFile6(LDD_PATH);
+      const lddContent = await readFile7(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -73752,14 +74386,14 @@ var require_input = __commonJS((exports, module) => {
       return this;
     } else {
       if (this._isStreamInput()) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const finished = () => {
             this._flattenBufferIn();
             sharp.metadata(this.options, (err, metadata2) => {
               if (err) {
                 reject(is.nativeError(err, stack));
               } else {
-                resolve5(metadata2);
+                resolve6(metadata2);
               }
             });
           };
@@ -73770,12 +74404,12 @@ var require_input = __commonJS((exports, module) => {
           }
         });
       } else {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           sharp.metadata(this.options, (err, metadata2) => {
             if (err) {
               reject(is.nativeError(err, stack));
             } else {
-              resolve5(metadata2);
+              resolve6(metadata2);
             }
           });
         });
@@ -73808,25 +74442,25 @@ var require_input = __commonJS((exports, module) => {
       return this;
     } else {
       if (this._isStreamInput()) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           this.on("finish", function() {
             this._flattenBufferIn();
             sharp.stats(this.options, (err, stats2) => {
               if (err) {
                 reject(is.nativeError(err, stack));
               } else {
-                resolve5(stats2);
+                resolve6(stats2);
               }
             });
           });
         });
       } else {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           sharp.stats(this.options, (err, stats2) => {
             if (err) {
               reject(is.nativeError(err, stack));
             } else {
-              resolve5(stats2);
+              resolve6(stats2);
             }
           });
         });
@@ -77228,7 +77862,7 @@ var require_output = __commonJS((exports, module) => {
       return this;
     } else {
       if (this._isStreamInput()) {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           this.once("finish", () => {
             this._flattenBufferIn();
             sharp.pipeline(this.options, (err, data, info) => {
@@ -77236,24 +77870,24 @@ var require_output = __commonJS((exports, module) => {
                 reject(is.nativeError(err, stack));
               } else {
                 if (this.options.resolveWithObject) {
-                  resolve5({ data, info });
+                  resolve6({ data, info });
                 } else {
-                  resolve5(data);
+                  resolve6(data);
                 }
               }
             });
           });
         });
       } else {
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           sharp.pipeline(this.options, (err, data, info) => {
             if (err) {
               reject(is.nativeError(err, stack));
             } else {
               if (this.options.resolveWithObject) {
-                resolve5({ data, info });
+                resolve6({ data, info });
               } else {
-                resolve5(data);
+                resolve6(data);
               }
             }
           });
@@ -77555,11 +78189,11 @@ var init_pdfium_renderer = __esm(() => {
 
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/engines/pdf/pdfjsImporter.js
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 async function importPdfJs() {
   const pdfUrl = new URL("../../vendor/pdfjs/pdf.mjs", import.meta.url);
   const pdfjs = await import(pdfUrl.href);
-  const dirPath = dirname12(fileURLToPath6(pdfUrl));
+  const dirPath = dirname13(fileURLToPath6(pdfUrl));
   return {
     fn: pdfjs.getDocument,
     dir: dirPath
@@ -78327,7 +78961,7 @@ var require_runtime2 = __commonJS((exports, module) => {
       return { __await: arg };
     };
     function AsyncIterator(generator, PromiseImpl) {
-      function invoke(method, arg, resolve5, reject) {
+      function invoke(method, arg, resolve6, reject) {
         var record2 = tryCatch(generator[method], generator, arg);
         if (record2.type === "throw") {
           reject(record2.arg);
@@ -78336,24 +78970,24 @@ var require_runtime2 = __commonJS((exports, module) => {
           var value2 = result3.value;
           if (value2 && typeof value2 === "object" && hasOwn.call(value2, "__await")) {
             return PromiseImpl.resolve(value2.__await).then(function(value3) {
-              invoke("next", value3, resolve5, reject);
+              invoke("next", value3, resolve6, reject);
             }, function(err) {
-              invoke("throw", err, resolve5, reject);
+              invoke("throw", err, resolve6, reject);
             });
           }
           return PromiseImpl.resolve(value2).then(function(unwrapped) {
             result3.value = unwrapped;
-            resolve5(result3);
+            resolve6(result3);
           }, function(error51) {
-            return invoke("throw", error51, resolve5, reject);
+            return invoke("throw", error51, resolve6, reject);
           });
         }
       }
       var previousPromise;
       function enqueue(method, arg) {
         function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function(resolve5, reject) {
-            invoke(method, arg, resolve5, reject);
+          return new PromiseImpl(function(resolve6, reject) {
+            invoke(method, arg, resolve6, reject);
           });
         }
         return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
@@ -78773,13 +79407,13 @@ var require_createScheduler = __commonJS((exports, module) => {
         }
       }
     };
-    const queue = (action, payload) => new Promise((resolve5, reject) => {
+    const queue = (action, payload) => new Promise((resolve6, reject) => {
       const job = createJob({ action, payload });
       jobQueue.push(async (w) => {
         jobQueue.shift();
         runningWorkers[w.id] = job;
         try {
-          resolve5(await w[action].apply(exports, [...payload, job.id]));
+          resolve6(await w[action].apply(exports, [...payload, job.id]));
         } catch (err) {
           reject(err);
         } finally {
@@ -80913,7 +81547,7 @@ var require_lib3 = __commonJS((exports, module) => {
     let accum = [];
     let accumBytes = 0;
     let abort = false;
-    return new Body.Promise(function(resolve5, reject) {
+    return new Body.Promise(function(resolve6, reject) {
       let resTimeout;
       if (_this4.timeout) {
         resTimeout = setTimeout(function() {
@@ -80947,7 +81581,7 @@ var require_lib3 = __commonJS((exports, module) => {
         }
         clearTimeout(resTimeout);
         try {
-          resolve5(Buffer.concat(accum, accumBytes));
+          resolve6(Buffer.concat(accum, accumBytes));
         } catch (err) {
           reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err));
         }
@@ -81546,7 +82180,7 @@ var require_lib3 = __commonJS((exports, module) => {
       throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
     }
     Body.Promise = fetch2.Promise;
-    return new fetch2.Promise(function(resolve5, reject) {
+    return new fetch2.Promise(function(resolve6, reject) {
       const request3 = new Request3(url3, opts);
       const options = getNodeRequestOptions(request3);
       const send = (options.protocol === "https:" ? https : http).request;
@@ -81681,7 +82315,7 @@ var require_lib3 = __commonJS((exports, module) => {
                 requestOpts.body = undefined;
                 requestOpts.headers.delete("content-length");
               }
-              resolve5(fetch2(new Request3(locationURL, requestOpts)));
+              resolve6(fetch2(new Request3(locationURL, requestOpts)));
               finalize2();
               return;
           }
@@ -81703,7 +82337,7 @@ var require_lib3 = __commonJS((exports, module) => {
         const codings = headers.get("Content-Encoding");
         if (!request3.compress || request3.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) {
           response = new Response2(body, response_options);
-          resolve5(response);
+          resolve6(response);
           return;
         }
         const zlibOptions = {
@@ -81713,7 +82347,7 @@ var require_lib3 = __commonJS((exports, module) => {
         if (codings == "gzip" || codings == "x-gzip") {
           body = body.pipe(zlib.createGunzip(zlibOptions));
           response = new Response2(body, response_options);
-          resolve5(response);
+          resolve6(response);
           return;
         }
         if (codings == "deflate" || codings == "x-deflate") {
@@ -81725,12 +82359,12 @@ var require_lib3 = __commonJS((exports, module) => {
               body = body.pipe(zlib.createInflateRaw());
             }
             response = new Response2(body, response_options);
-            resolve5(response);
+            resolve6(response);
           });
           raw.on("end", function() {
             if (!response) {
               response = new Response2(body, response_options);
-              resolve5(response);
+              resolve6(response);
             }
           });
           return;
@@ -81738,11 +82372,11 @@ var require_lib3 = __commonJS((exports, module) => {
         if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
           body = body.pipe(zlib.createBrotliDecompress());
           response = new Response2(body, response_options);
-          resolve5(response);
+          resolve6(response);
           return;
         }
         response = new Response2(body, response_options);
-        resolve5(response);
+        resolve6(response);
       });
       writeToStream(req, request3);
     });
@@ -81819,7 +82453,7 @@ var require_loadImage = __commonJS((exports, module) => {
   var fs8 = __require("fs");
   var fetch2 = global.fetch || require_lib3();
   var isURL = require_is_url();
-  var readFile6 = util.promisify(fs8.readFile);
+  var readFile7 = util.promisify(fs8.readFile);
   module.exports = async (image) => {
     let data = image;
     if (typeof image === "undefined") {
@@ -81832,7 +82466,7 @@ var require_loadImage = __commonJS((exports, module) => {
       } else if (/data:image\/([a-zA-Z]*);base64,([^"]*)/.test(image)) {
         data = Buffer.from(image.split(",")[1], "base64");
       } else {
-        data = await readFile6(image);
+        data = await readFile7(image);
       }
     } else if (Buffer.isBuffer(image)) {
       data = image;
@@ -81892,8 +82526,8 @@ var require_createWorker = __commonJS((exports, module) => {
     const lstmOnlyCore = [OEM.DEFAULT, OEM.LSTM_ONLY].includes(oem) && !options.legacyCore;
     let workerResReject;
     let workerResResolve;
-    const workerRes = new Promise((resolve5, reject) => {
-      workerResResolve = resolve5;
+    const workerRes = new Promise((resolve6, reject) => {
+      workerResResolve = resolve6;
       workerResReject = reject;
     });
     const workerError = (event) => {
@@ -81902,10 +82536,10 @@ var require_createWorker = __commonJS((exports, module) => {
     let worker = spawnWorker(options);
     worker.onerror = workerError;
     workerCounter += 1;
-    const startJob = ({ id: jobId, action, payload }) => new Promise((resolve5, reject) => {
+    const startJob = ({ id: jobId, action, payload }) => new Promise((resolve6, reject) => {
       log3(`[${id}]: Start ${jobId}, action=${action}`);
       const promiseId = `${action}-${jobId}`;
-      promises[promiseId] = { resolve: resolve5, reject };
+      promises[promiseId] = { resolve: resolve6, reject };
       send(worker, {
         workerId: id,
         jobId,
@@ -82432,9 +83066,9 @@ function merge5(...objs) {
     }
     const targetKey = caseless && typeof key === "string" && findKey(result3, key) || key;
     const existing = hasOwnProperty(result3, targetKey) ? result3[targetKey] : undefined;
-    if (isPlainObject2(existing) && isPlainObject2(val)) {
+    if (isPlainObject3(existing) && isPlainObject3(val)) {
       result3[targetKey] = merge5(existing, val);
-    } else if (isPlainObject2(val)) {
+    } else if (isPlainObject3(val)) {
       result3[targetKey] = merge5({}, val);
     } else if (isArray2(val)) {
       result3[targetKey] = val.slice();
@@ -82537,7 +83171,7 @@ var toString2, getPrototypeOf, iterator, toStringTag, hasOwnProperty, isUnsafeOb
 }, kindOf, kindOfTest = (type) => {
   type = type.toLowerCase();
   return (thing) => kindOf(thing) === type;
-}, typeOfTest = (type) => (thing) => typeof thing === type, isArray2, isUndefined2, isArrayBuffer, isString2, isFunction2, isNumber2, isObject3 = (thing) => thing !== null && typeof thing === "object", isBoolean = (thing) => thing === true || thing === false, isPlainObject2 = (val) => {
+}, typeOfTest = (type) => (thing) => typeof thing === type, isArray2, isUndefined2, isArrayBuffer, isString2, isFunction2, isNumber2, isObject3 = (thing) => thing !== null && typeof thing === "object", isBoolean = (thing) => thing === true || thing === false, isPlainObject3 = (val) => {
   if (!isObject3(val)) {
     return false;
   }
@@ -82813,7 +83447,7 @@ var init_utils = __esm(() => {
     isNumber: isNumber2,
     isBoolean,
     isObject: isObject3,
-    isPlainObject: isPlainObject2,
+    isPlainObject: isPlainObject3,
     isEmptyObject,
     isReadableStream,
     isRequest,
@@ -94264,10 +94898,10 @@ var init_CanceledError = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/axios@1.20.0/node_modules/axios/lib/core/settle.js
-function settle(resolve5, reject, response) {
+function settle(resolve6, reject, response) {
   const validateStatus2 = response.config.validateStatus;
   if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
-    resolve5(response);
+    resolve6(response);
   } else {
     reject(new AxiosError_default("Request failed with status code " + response.status, response.status >= 400 && response.status < 500 ? AxiosError_default.ERR_BAD_REQUEST : AxiosError_default.ERR_BAD_RESPONSE, response.config, response.request, response));
   }
@@ -94430,12 +95064,12 @@ var require_promisify = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   function promisify2(fn3) {
     return function(req, opts) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         fn3.call(this, req, opts, (err, rtn) => {
           if (err) {
             reject(err);
           } else {
-            resolve5(rtn);
+            resolve6(rtn);
           }
         });
       });
@@ -94629,7 +95263,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
   var debug_1 = __importDefault(require_src2());
   var debug12 = debug_1.default("https-proxy-agent:parse-proxy-response");
   function parseProxyResponse(socket) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       let buffersLength = 0;
       const buffers = [];
       function read() {
@@ -94672,7 +95306,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
 `));
         const statusCode = +firstLine.split(" ")[1];
         debug12("got proxy server response: %o", firstLine);
-        resolve5({
+        resolve6({
           statusCode,
           buffered
         });
@@ -94690,11 +95324,11 @@ var require_parse_proxy_response = __commonJS((exports) => {
 var require_agent = __commonJS((exports) => {
   var __awaiter2 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
     function adopt(value2) {
-      return value2 instanceof P ? value2 : new P(function(resolve5) {
-        resolve5(value2);
+      return value2 instanceof P ? value2 : new P(function(resolve6) {
+        resolve6(value2);
       });
     }
-    return new (P || (P = Promise))(function(resolve5, reject) {
+    return new (P || (P = Promise))(function(resolve6, reject) {
       function fulfilled(value2) {
         try {
           step(generator.next(value2));
@@ -94710,7 +95344,7 @@ var require_agent = __commonJS((exports) => {
         }
       }
       function step(result3) {
-        result3.done ? resolve5(result3.value) : adopt(result3.value).then(fulfilled, rejected);
+        result3.done ? resolve6(result3.value) : adopt(result3.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -96509,7 +97143,7 @@ var import_https_proxy_agent, import_follow_redirects, zlibOptions, brotliOption
   stream4.on("end", flush).on("error", flush);
   return throttled;
 }, http2Sessions, isHttpAdapterSupported, wrapAsync = (asyncExecutor) => {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let onDone;
     let isDone3;
     const done3 = (value2, isRejected) => {
@@ -96520,7 +97154,7 @@ var import_https_proxy_agent, import_follow_redirects, zlibOptions, brotliOption
     };
     const _resolve = (value2) => {
       done3(value2);
-      resolve5(value2);
+      resolve6(value2);
     };
     const _reject = (reason) => {
       done3(reason, true);
@@ -96645,7 +97279,7 @@ var init_http = __esm(() => {
     }
   };
   http_default = isHttpAdapterSupported && function httpAdapter(config3) {
-    return wrapAsync(async function dispatchHttpRequest(resolve5, reject, onDone) {
+    return wrapAsync(async function dispatchHttpRequest(resolve6, reject, onDone) {
       const own2 = (key) => utils_default.getSafeProp(config3, key);
       const transitional = own2("transitional") || transitional_default;
       let data = own2("data");
@@ -96756,7 +97390,7 @@ var init_http = __esm(() => {
         }
         let convertedData;
         if (method !== "GET") {
-          return settle(resolve5, reject, {
+          return settle(resolve6, reject, {
             status: 405,
             statusText: "method not allowed",
             headers: {},
@@ -96778,7 +97412,7 @@ var init_http = __esm(() => {
         } else if (responseType === "stream") {
           convertedData = stream3.Readable.from(convertedData);
         }
-        return settle(resolve5, reject, {
+        return settle(resolve6, reject, {
           data: convertedData,
           status: 200,
           statusText: "OK",
@@ -97050,7 +97684,7 @@ var init_http = __esm(() => {
             });
           }
           response.data = responseStream;
-          settle(resolve5, reject, response);
+          settle(resolve6, reject, response);
         } else {
           const responseBuffer = [];
           let totalResponseBytes = 0;
@@ -97089,7 +97723,7 @@ var init_http = __esm(() => {
             } catch (err) {
               return reject(AxiosError_default.from(err, null, config3, response.request, response));
             }
-            settle(resolve5, reject, response);
+            settle(resolve6, reject, response);
           });
         }
         abortEmitter.once("abort", (err) => {
@@ -97462,7 +98096,7 @@ var init_xhr = __esm(() => {
   init_sanitizeHeaderValue();
   isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
   xhr_default = isXHRAdapterSupported && function(config3) {
-    return new Promise(function dispatchXhrRequest(resolve5, reject) {
+    return new Promise(function dispatchXhrRequest(resolve6, reject) {
       const _config = resolveConfig_default(config3);
       let requestData = _config.data;
       const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
@@ -97514,7 +98148,7 @@ var init_xhr = __esm(() => {
           request: request3
         };
         settle(function _resolve(value2) {
-          resolve5(value2);
+          resolve6(value2);
           done3();
         }, function _reject(err) {
           reject(err);
@@ -98037,8 +98671,8 @@ var DEFAULT_CHUNK_SIZE, DEFAULT_REQUEST_OPTIONS, isFunction3, encodeUTF82 = (str
         }
       }
       !isStreamResponse && unsubscribe && unsubscribe();
-      return await new Promise((resolve5, reject) => {
-        settle(resolve5, reject, {
+      return await new Promise((resolve6, reject) => {
+        settle(resolve6, reject, {
           data: responseData,
           headers: AxiosHeaders_default.from(response.headers),
           status: response.status,
@@ -98512,8 +99146,8 @@ class CancelToken {
       throw new TypeError("executor must be a function.");
     }
     let resolvePromise;
-    this.promise = new Promise(function promiseExecutor(resolve5) {
-      resolvePromise = resolve5;
+    this.promise = new Promise(function promiseExecutor(resolve6) {
+      resolvePromise = resolve6;
     });
     const token = this;
     this.promise.then((cancel) => {
@@ -98527,9 +99161,9 @@ class CancelToken {
     });
     this.promise.then = (onfulfilled) => {
       let _resolve;
-      const promise4 = new Promise((resolve5) => {
-        token.subscribe(resolve5);
-        _resolve = resolve5;
+      const promise4 = new Promise((resolve6) => {
+        token.subscribe(resolve6);
+        _resolve = resolve6;
       }).then(onfulfilled);
       promise4.cancel = function reject() {
         token.unsubscribe(_resolve);
@@ -99210,7 +99844,7 @@ function applyMarkupTags(markup, text) {
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.5.3/node_modules/@llamaindex/liteparse/dist/src/processing/gridDebugLogger.js
 import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "fs";
 import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 
 class GridDebugLogger {
   config;
@@ -99537,14 +100171,14 @@ class GridDebugLogger {
   flushSync() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    mkdirSync7(dirname13(this.config.outputPath), { recursive: true });
+    mkdirSync7(dirname14(this.config.outputPath), { recursive: true });
     writeFileSync4(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
   async flush() {
     if (!this.config.outputPath || this.entries.length === 0)
       return;
-    await mkdir6(dirname13(this.config.outputPath), { recursive: true });
+    await mkdir6(dirname14(this.config.outputPath), { recursive: true });
     await writeFile6(this.config.outputPath, this.formatEntries(), "utf-8");
     this.entries = [];
   }
@@ -101269,9 +101903,9 @@ class Deferred2 {
   constructor() {
     this.resolve = () => null;
     this.reject = () => null;
-    this.promise = new Promise((resolve5, reject) => {
+    this.promise = new Promise((resolve6, reject) => {
       this.reject = reject;
-      this.resolve = resolve5;
+      this.resolve = resolve6;
     });
   }
 }
@@ -103335,7 +103969,7 @@ function readByobReaderWithSignal(reader, buffer, signal) {
     return reader.read(buffer);
   }
   signal.throwIfAborted();
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const cleanup = () => {
       signal.removeEventListener("abort", onAbort);
     };
@@ -103354,7 +103988,7 @@ function readByobReaderWithSignal(reader, buffer, signal) {
       try {
         const result3 = await reader.read(buffer);
         cleanup();
-        resolve5(result3);
+        resolve6(result3);
       } catch (error51) {
         cleanup();
         reject(error51);
@@ -105225,7 +105859,7 @@ var init_file_type = __esm(() => {
       const { signal } = this.options;
       const normalizedSampleSize = normalizeSampleSize(sampleSize);
       signal?.throwIfAborted();
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         let isSettled = false;
         const cleanup = () => {
           readableStream.off("error", onError3);
@@ -105264,7 +105898,7 @@ var init_file_type = __esm(() => {
                   settle2(reject, error51);
                 }
               }
-              settle2(resolve5, outputStream);
+              settle2(resolve6, outputStream);
             } catch (error51) {
               settle2(reject, error51);
             }
@@ -105298,7 +105932,7 @@ async function guessFileExtension(filePath) {
   return null;
 }
 async function executeCommand(command, args2, timeoutMs = 60000) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const proc = spawn2(command, args2, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -105317,7 +105951,7 @@ async function executeCommand(command, args2, timeoutMs = 60000) {
     proc.on("close", (code2) => {
       clearTimeout(timeout3);
       if (code2 === 0) {
-        resolve5(stdout);
+        resolve6(stdout);
       } else {
         reject(new Error(`Command failed with code ${code2}: ${stderr}`));
       }
@@ -105953,8 +106587,8 @@ var exports_parse_pdf = {};
 __export(exports_parse_pdf, {
   parsePdf: () => parsePdf
 });
-import { access, readFile as readFile6, writeFile as writeFile7, mkdir as mkdir7, appendFile } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { access, readFile as readFile7, writeFile as writeFile7, mkdir as mkdir7, appendFile } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
 function isUrl(input) {
   return input.startsWith("http://") || input.startsWith("https://");
 }
@@ -105963,9 +106597,9 @@ function createDefaultDeps6() {
     fs: {
       access: (p) => access(p),
       mkdir: (p, opts) => mkdir7(p, opts).then(() => {}),
-      readFile: (p, enc) => readFile6(p, { encoding: enc }).then((b) => b.toString()),
+      readFile: (p, enc) => readFile7(p, { encoding: enc }).then((b) => b.toString()),
       appendFile: (p, content) => appendFile(p, content),
-      readFileAsBuffer: (p) => readFile6(p),
+      readFileAsBuffer: (p) => readFile7(p),
       writeFile: (p, content, enc) => writeFile7(p, content, enc)
     },
     parser: {
@@ -106011,7 +106645,7 @@ function createDefaultDeps6() {
   };
 }
 async function resolvePdfPath(input, workingDir, d) {
-  const absolutePath = resolve5(workingDir, input);
+  const absolutePath = resolve6(workingDir, input);
   try {
     await d.fs.access(absolutePath);
   } catch {
@@ -107593,7 +108227,7 @@ function formatProofOfPrinciples() {
 var GAME_ASSET_RULES;
 var init_game_asset_designer_workflow = __esm(() => {
   GAME_ASSET_RULES = [
-    "Generate only with `chatroom generate-image --platform=fal`, using the CLI default model unless the brief names one.",
+    "Generate only with `chatroom generate-image --platform=fal --model <Model>`, where <Model> is the brief's Model: `fal-ai/flux-2/flash` (FLUX 2 Flash), or `fal-ai/flux-2/flash/edit` with --input-image for reference edits.",
     "Process images only with `chatroom slice-image` and `chatroom remove-image-background`; no other tool, script, or remote service.",
     "A sheet is at most the brief's `Sheet grid` (default 2x2); a larger grid needs a user request quoted in the brief.",
     "Names come from looking at each tile, never from cell order or prompt order.",
@@ -107602,20 +108236,20 @@ var init_game_asset_designer_workflow = __esm(() => {
     "Mark `pass` or `fail` only with `measured` or `inspected` evidence (labels below).",
     "Run `<command> --help` before first use of `slice-image` or `remove-image-background`.",
     "Always pass `--trim` to `chatroom remove-image-background`; use `--trim-padding` only when the brief names a padding.",
-    "Positioned sheets use exact layout JSON for the model that supports it (currently `fal-ai/moss-image`): the layout goes in `--prompt`, and `image_size` must equal the canvas the coordinates use. Bboxes are `[y_min,x_min,y_max,x_max]` in pixels from the canvas centre, y down, x right. `enable_prompt_expansion` is false for positioned layouts. Use `--output-format png`. Never pass `--aspect-ratio` to moss. Do not add model-specific values that the brief does not name.",
     "If `generate-image` is missing, `FAL_API_KEY` is not set, or it fails, stop generation, deliver `spec only`, quote the exact error in Summary, and list it under Open questions. Do not retry in a loop.",
     "Do not install or run any remote tool, script, or skill, and do not fetch generator code.",
     "Never switch generators.",
     "Describe generated output as production-ready only when every checklist item for it passes with `measured` or `inspected` evidence.",
     "Commit only when the brief names the paths and the commit message.",
-    "Generate only when the brief names an output location and allowed tools."
+    "Generate only when the brief names an output location and allowed tools.",
+    "Before the first real call of each command shape (sheet, per-asset, or reference edit), run the same command with --dry-run and apply every constraint it prints; take model-specific constraints only from the dry run, never from memory."
   ];
 });
 
 // ../../services/backend/prompts/teams/game-asset-designer-handoff-templates.ts
 function getEntryPointToGameAssetDesignerHandoffTemplate(query) {
   const entryPoint = query.fromRole;
-  return `Instructions (not part of the message): Pass the asset request as a brief the designer can act on without guessing. Provide every field below; write \`Not specified.\` for a field you cannot fill and the designer will ask or apply a stated default. Give each asset a stable ID (\`A01\`, \`A02\`…). Use \`spec only\` only when you want a specification with no files; the default is \`spec and generate\`. The \`## Allowed tools\` value is fixed: \`chatroom generate-image --platform=fal (default model), chatroom slice-image, chatroom remove-image-background\`. Do not name any other generator.
+  return `Instructions (not part of the message): Pass the asset request as a brief the designer can act on without guessing. Provide every field below; write \`Not specified.\` for a field you cannot fill and the designer will ask or apply a stated default. Give each asset a stable ID (\`A01\`, \`A02\`…). Use \`spec only\` only when you want a specification with no files; the default is \`spec and generate\`. The \`## Allowed tools\` value is fixed: \`chatroom generate-image --platform=fal --model <Model> (dry run first), chatroom slice-image, chatroom remove-image-background\`. Do not name any other generator.
 
 ## Asset request
 <one to three sentences: what the assets are for and the user-visible goal>
@@ -107632,11 +108266,14 @@ function getEntryPointToGameAssetDesignerHandoffTemplate(query) {
 ## Style reference
 <repository paths, URLs, or a written style sheet; or \`Not specified.\`>
 
+## Perspective
+<one camera perspective shared by every asset in the set, for example \`orthographic front view\`, \`orthographic isometric\`, \`dimetric 2:1\`, or \`side view\`; optionally \`reference: <repository path>\` of an existing asset to match (requires \`## Model\` = \`fal-ai/flux-2/flash/edit\`); a reference makes every asset an individual edit, with no sheets; \`Not applicable.\` for 3D models and audio; or \`Not specified.\`>
+
 ## Model
-<the CLI default \`fal-ai/flux-2/flash\`, or \`fal-ai/moss-image\` when the brief names it>
+<\`fal-ai/flux-2/flash\` (FLUX 2 Flash), passed as --model; \`fal-ai/flux-2/flash/edit\` only when \`## Perspective\` names a reference asset>
 
 ## Model parameters
-<a JSON object as text passed to \`generate-image --input\`; \`Not specified.\` if none>
+<a JSON object as text passed to \`generate-image --input\`; one object for every call of a set; its keys must pass the model's --dry-run check; \`Not specified.\` if none>
 
 ## Spec consumer
 <who integrates these assets from the spec: \`builder\` (application code) or \`user\`; asset files themselves are generated only by \`game-asset-designer\`>
@@ -107648,7 +108285,7 @@ function getEntryPointToGameAssetDesignerHandoffTemplate(query) {
 <\`spec and generate\` (default when you name an output location and allowed tools) or \`spec only\`>
 
 ## Allowed tools
-\`chatroom generate-image --platform=fal (default model), chatroom slice-image, chatroom remove-image-background\`
+\`chatroom generate-image --platform=fal --model <Model> (dry run first), chatroom slice-image, chatroom remove-image-background\`
 
 ## Allowed edit paths
 <repository-relative paths the designer may edit; \`None.\` for none>
@@ -107708,7 +108345,7 @@ ${PROOF_OF_PRINCIPLES_REPORT}
 <each assumption you made and why; each deviation from the planner's target or budgets; or \`None.\`>
 
 ## Asset manifest
-<one entry per asset, keyed by the planner's stable ID (\`A01\`…): name, category, file format, path (or \`Specified only.\`), dimensions/units/scale, pivot, naming, LOD list with triangle budgets, texture set with resolution, color space and channel packing, atlas/pixel grid/frame data, audio format and loudness target, import settings, dependencies and variants; for each budget, the acceptance check (exact command and expected value); for each generated file, the generator command line (\`chatroom generate-image\` with its \`--platform\`, \`--model\`, and \`--seed\` values), the sheet and tile manifests, and the isolated asset manifest path>
+<one entry per asset, keyed by the planner's stable ID (\`A01\`…): name, category, file format, path (or \`Specified only.\`), dimensions/units/scale, pivot, naming, LOD list with triangle budgets, texture set with resolution, color space and channel packing, atlas/pixel grid/frame data, audio format and loudness target, import settings, dependencies and variants; for each budget, the acceptance check (exact command and expected value); for each generated file, the generator command line (\`chatroom generate-image\` with its \`--platform\`, \`--model\`, \`--seed\`, \`--input\`, and \`--input-image\` values), the sheet and tile manifests, and the isolated asset manifest path>
 
 ## Quality checklist results
 <per asset: each applicable checklist item as \`pass\`, \`fail\`, \`n/a\`, or \`not checked\`, with its evidence label and, for \`measured\`, the command and value; write exactly \`None failed.\` after the list if no item failed>
@@ -109660,7 +110297,7 @@ P1 Recover the brief. IF engine, tier, style, or budgets are missing and the rep
 P2 Inspect assets, names, folders, engine config; cite paths.
 P3 Classify each asset; one manifest entry per ID (\`A01\`…).
 P4 IF \`Deliverable mode\` = \`spec only\` OR \`Output location\`/\`Allowed tools\` missing/ambiguous THEN no files, deliver \`Specified only.\`, GOTO P10.
-P5 Count N. IF N=1 or styles differ THEN per-asset \`generate-image\`, GOTO P8. ELSE use ceil(N / (C×R)) sheets of ≤(C×R) items per \`Sheet grid\` (2x2 default). Prompt: one item per cell, CxR grid, no lines/borders/frames/duplicates. Generate \`generate-image --platform=fal --prompt "<prompt>" --out <Output location>/_work/<sheet>.png\`. IF \`## Model\` = \`fal-ai/moss-image\` THEN follow R10: layout JSON in \`--prompt\`, \`--input\` \`{image_size:{width:W,height:H},enable_prompt_expansion:false}\` plus \`## Model parameters\`, \`--model fal-ai/moss-image --output-format png\`; ELSE default.
+P5 Count N. IF N=1 or styles differ THEN per-asset \`generate-image\`, GOTO P8. ELSE use ceil(N / (C×R)) sheets of ≤(C×R) items per \`Sheet grid\` (2x2 default). Prompt: one item per cell, CxR grid, no lines/borders/frames/duplicates. Generate \`generate-image --platform=fal --model <Model> --prompt "<prompt>" --out <Output location>/_work/<sheet>.png\`.
 P6 \`chatroom slice-image --in <sheet> --out-dir <Output location>/_work/tiles --cols C --rows R\`. IF refused regenerate once; IF still refused one \`generate-image\` per asset (P5).
 P7 View each tile. IF any tile has 0/2+ items, a cut item, or count differs from the brief's requested count (extra cells OK) THEN regenerate once; IF still bad THEN one \`generate-image\` per asset (P5). Name from sight.
 P8 IF \`remove-image-background --help\` succeeds THEN run \`remove-image-background --in-dir <tiles> --out-dir <Output location> --map <stem>=<name>,... --trim\` (single: \`--in <image> --out <Output location>/<name>.png --trim\`); view results. IF warnings/halo THEN rerun with \`--tolerance\`/\`--force\` max twice, ELSE accept. ELSE rerun \`slice-image --names\`; record trimming not delivered as a failed item/open question.
@@ -109699,11 +110336,20 @@ P11 Hand off to \`{ENTRY_POINT_ROLE}\`, then stop.
 - Animation: uniform frame size per clip, frame count, frame rate, loop flag, and pivot per clip.
 - Atlas: padding of at least the engine default (Unity default 4 px), atlas size within the platform max, filter mode Point for pixel art and no mip maps.
 - Export PNG (lossless with alpha); name states size and frame count where relevant.
+- Camera perspective matches the perspective chosen for the set (the brief's \`Perspective\`, or the one recorded under assumptions) and every other asset in the set (compare them side by side); \`n/a\` for a single asset.
 
 **Audio**
 - Loudness measured against the platform target stated in the request (for example console -24 LUFS, mobile -18 LUFS, true peak at or below -1 dBTP); no clipping. Measure with a tool: \`ffmpeg -i <file> -af ebur128=peak=true -f null -\` for integrated loudness and true peak; \`ffprobe <file>\` for sample rate, bit depth and channels; for glTF, \`gltf-transform inspect <file>\` (quote the command's actual output). Cite the platform source. If the request does not state the target, mark the loudness target \`unverified\` and name the source. Mobile targets vary (-18 vs -16 LUFS).
 - Sample rate, bit depth, channel count, loop points, and format stated; short noisy SFX use PCM or ADPCM, long audio uses compressed or streamed formats, per the engine's guidance.
 
+### Perspective consistency (generated 2D sets)
+Assets used together must share one camera perspective. The model's constraints (unsupported parameters, size defaults, what it does not guarantee) come only from \`generate-image --dry-run\` (R16); apply them, and never add a parameter the dry run reports as unsupported.
+- Repeat the perspective term from the brief's \`Perspective\` word for word in every prompt of the set (never the \`reference:\` path), and add the same flattening terms to every prompt: \`flat 2D game asset, orthographic, centered, plain background, even lighting\`. Suggested perspective terms (\`unverified\`): side view, front view, orthographic top-down, orthographic isometric, dimetric 2:1, three-quarter view. If the field names only a reference, describe that reference's view in words and record the description under assumptions. If \`Perspective\` is \`Not specified.\`, pick one, record it under assumptions, and use it for the whole set. If the \`Style reference\` asks for a lighting style these terms contradict (for example dramatic lighting), keep the perspective term and drop only the conflicting flattening term.
+- Use one \`--input\` JSON (from \`Model parameters\`) on every call of the set; if the dry run reports a size parameter as defaulted, set it once in that JSON and reuse it. Add \`--input '<JSON>'\` and the seed to every P5 command.
+- Use one shared \`--seed\` for the first call of each item or sheet. For every regeneration (P6, P7, or a perspective mismatch), use a new seed and record it (P9). A shared seed does not keep perspective across different prompts.
+- Pass \`--input-image <path>\` with \`--model fal-ai/flux-2/flash/edit\` only when the brief's \`Model\` is \`fal-ai/flux-2/flash/edit\` and \`Perspective\` names a reference path. In this mode generate every asset individually (the P5 per-asset path, one \`--input-image\` per asset); never use a sheet.
+- Inspect the set side by side. A mismatched item is regenerated individually (the P5 per-asset path, with a new seed), at most twice per item, separately from the sheet regenerations of P6 and P7. If it still differs, mark the perspective checklist item \`fail\` with \`inspected\` evidence.
+
 ### Scope boundary
 You may specify, name, organize, generate, validate, and integrate assets within the paths the brief allows. You must not claim fidelity you did not establish. If you cannot open or measure a file, write \`unverified\`. Do not present alternative art directions beyond what the request needs; recommend one.
 
@@ -118639,7 +119285,7 @@ function parseYaml(text) {
   }
 }
 function validateFields(data, body) {
-  if (!isPlainObject3(data))
+  if (!isPlainObject4(data))
     return fail6("invalid-frontmatter", "frontmatter is not a mapping");
   const name = data.name;
   if (!isValidName(name))
@@ -118649,7 +119295,7 @@ function validateFields(data, body) {
     return fail6("invalid-description");
   return { ok: true, name, description, body };
 }
-function isPlainObject3(value2) {
+function isPlainObject4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function isValidName(value2) {
@@ -118669,7 +119315,7 @@ var init_parse_skill_file = __esm(() => {
 });
 
 // src/infrastructure/external-skills/discover-external-skills.ts
-import { lstat as lstat2, readdir as readdir2, readFile as readFile8, realpath, stat as stat6 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir2, readFile as readFile9, realpath, stat as stat6 } from "node:fs/promises";
 import os2 from "node:os";
 import { join as join20 } from "node:path";
 function errorCode(err) {
@@ -118777,7 +119423,7 @@ async function isSymlink2(path3) {
 }
 async function readSkillFile(sourcePath, issues) {
   try {
-    return await readFile8(join20(sourcePath, SKILL_FILE_NAME), "utf8");
+    return await readFile9(join20(sourcePath, SKILL_FILE_NAME), "utf8");
   } catch (err) {
     issues.push(issue2(sourcePath, "unreadable", errorCode(err)));
     return;
@@ -120637,10 +121283,10 @@ var init_durable_fifo_queue_schema = __esm(() => {
 
 // src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
 import { mkdirSync as mkdirSync9 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 function openDurableFifoQueueStore(dbPath) {
-  mkdirSync9(dirname14(dbPath), { recursive: true });
+  mkdirSync9(dirname15(dbPath), { recursive: true });
   const db = new DatabaseSync3(dbPath);
   for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
     db.exec(sql);
@@ -120841,9 +121487,9 @@ function createFifoBatchedOutbox(o) {
   const enqueue = async (item) => {
     persist(item);
   };
-  const enqueueAndWait = (item) => new Promise((resolve7, reject) => {
+  const enqueueAndWait = (item) => new Promise((resolve8, reject) => {
     const id = persist(item);
-    waiters.set(id, { resolve: resolve7, reject });
+    waiters.set(id, { resolve: resolve8, reject });
   });
   const flushNow = async () => {
     if (stopped)
@@ -121268,7 +121914,7 @@ var init_orphan_tracker = __esm(() => {
 });
 
 // src/daemon/entry/handlers/process/output-store.ts
-import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile9, rm as rm2 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile10, rm as rm2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as join23 } from "node:path";
 
@@ -121301,7 +121947,7 @@ class TempFileOutputStore {
   async getLastNLines(maxLines) {
     let source;
     try {
-      source = await readFile9(this.state.filePath, "utf-8");
+      source = await readFile10(this.state.filePath, "utf-8");
     } catch {
       source = this.state.inMemory;
     }
@@ -121318,7 +121964,7 @@ class TempFileOutputStore {
   }
   async getFullOutput() {
     try {
-      return await readFile9(this.state.filePath, "utf-8");
+      return await readFile10(this.state.filePath, "utf-8");
     } catch {
       return this.state.inMemory;
     }
@@ -121471,10 +122117,10 @@ var init_durable_coalescing_state_schema = __esm(() => {
 
 // src/daemon/infrastructure/outbox/lib/durable-coalescing-state-store.ts
 import { mkdirSync as mkdirSync10 } from "node:fs";
-import { dirname as dirname15 } from "node:path";
+import { dirname as dirname16 } from "node:path";
 import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 function openDurableCoalescingStateStore(path3) {
-  mkdirSync10(dirname15(path3), { recursive: true });
+  mkdirSync10(dirname16(path3), { recursive: true });
   const db = new DatabaseSync4(path3);
   for (const sql of DURABLE_COALESCING_STATE_MIGRATIONS)
     db.exec(sql);
@@ -121624,8 +122270,8 @@ function createCoalescingStateOutbox(options) {
   const enqueue = async (state) => {
     accept(state);
   };
-  const enqueueAndWait = (state) => new Promise((resolve7, reject) => {
-    accept(state, { resolve: resolve7, reject });
+  const enqueueAndWait = (state) => new Promise((resolve8, reject) => {
+    accept(state, { resolve: resolve8, reject });
   });
   const flushNow = async () => {
     if (stopped)
@@ -122948,7 +123594,7 @@ var init_workspace_visibility_policy = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-ignore.ts
 import { promises as fsPromises } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
 import path3 from "node:path";
 function normalizeRelativePath(relativePath) {
@@ -123013,7 +123659,7 @@ async function loadGitExtraExcludeRuleSets(rootDir) {
 }
 async function readIgnoreFile(filePath) {
   try {
-    return await readFile10(filePath, "utf-8");
+    return await readFile11(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -123250,7 +123896,7 @@ function enqueueGit(cwd, task) {
 }
 function runCommandSpawn(command, args2, cwd, options) {
   const successExitCodes = options?.successExitCodes ?? [0];
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn3(command, args2, {
       cwd,
       env: options?.env ?? DEFAULT_GIT_ENV,
@@ -123276,9 +123922,9 @@ function runCommandSpawn(command, args2, cwd, options) {
       if (timer)
         clearTimeout(timer);
       if (successExitCodes.includes(code2 ?? -1))
-        resolve7({ stdout, stderr });
+        resolve8({ stdout, stderr });
       else {
-        resolve7({
+        resolve8({
           error: Object.assign(new Error(stderr || stdout || `exit ${code2}`), {
             code: code2 ?? undefined
           })
@@ -123288,7 +123934,7 @@ function runCommandSpawn(command, args2, cwd, options) {
     child.on("error", (err) => {
       if (timer)
         clearTimeout(timer);
-      resolve7({ error: err });
+      resolve8({ error: err });
     });
   });
 }
@@ -124170,9 +124816,9 @@ var init_readdirp = __esm(() => {
       return { files, depth, path: path6 };
     }
     _formatEntry(dirent, path6) {
-      const basename4 = this._isDirent ? dirent.name : dirent;
-      const fullPath = pjoin(path6, basename4);
-      const entry = { path: fullPath.slice(this._relStart), fullPath, basename: basename4 };
+      const basename5 = this._isDirent ? dirent.name : dirent;
+      const fullPath = pjoin(path6, basename5);
+      const entry = { path: fullPath.slice(this._relStart), fullPath, basename: basename5 };
       if (this._isDirent) {
         entry.dirent = dirent;
         return entry;
@@ -124268,9 +124914,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path6, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path6);
-    const basename5 = sp.basename(path6);
+    const basename6 = sp.basename(path6);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename5);
+    parent.add(basename6);
     const absolutePath = sp.resolve(path6);
     const options = {
       persistent: opts.persistent
@@ -124280,7 +124926,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path6, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -124298,11 +124944,11 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname17 = sp.dirname(file2);
-    const basename5 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname17);
+    const dirname18 = sp.dirname(file2);
+    const basename6 = sp.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname18);
     let prevStats = stats;
-    if (parent.has(basename5))
+    if (parent.has(basename6))
       return;
     const listener = async (path6, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -124327,9 +124973,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname17, basename5);
+          this.fsw._remove(dirname18, basename6);
         }
-      } else if (parent.has(basename5)) {
+      } else if (parent.has(basename6)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -124416,7 +125062,7 @@ class NodeFsHandler {
         this._addToNodeFs(path6, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       if (!stream4)
         return reject();
       stream4.once(STR_END, () => {
@@ -124425,7 +125071,7 @@ class NodeFsHandler {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve8(undefined);
+        resolve9(undefined);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -125643,8 +126289,8 @@ function createWorkspaceFsWatcher(options) {
     awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 25 }
   });
   watcher.on("add", (filePath) => enqueue("add", filePath)).on("addDir", (filePath) => enqueue("addDir", filePath)).on("change", (filePath) => enqueue("change", filePath)).on("unlink", (filePath) => enqueue("unlink", filePath)).on("unlinkDir", (filePath) => enqueue("unlinkDir", filePath)).on("error", (error51) => options.onError?.(error51));
-  const ready = new Promise((resolve9) => {
-    watcher.once("ready", resolve9);
+  const ready = new Promise((resolve10) => {
+    watcher.once("ready", resolve10);
   });
   return {
     ready,
@@ -127608,8 +128254,8 @@ function parseMakefileTargets(content) {
 var MAX_NAME_LENGTH2 = 256;
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
-import { readFile as readFile12, readdir as readdir5, stat as stat10 } from "node:fs/promises";
-import { join as join28, basename as basename6, resolve as resolve9 } from "node:path";
+import { readFile as readFile13, readdir as readdir5, stat as stat10 } from "node:fs/promises";
+import { join as join28, basename as basename7, resolve as resolve10 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
   const parentDir2 = join28(rootDir, cleaned.slice(0, -2));
   try {
@@ -127619,7 +128265,7 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
       if (!entry.isDirectory())
         continue;
       const dirPath = join28(parentDir2, entry.name);
-      if (resolve9(dirPath).startsWith(resolve9(rootDir))) {
+      if (resolve10(dirPath).startsWith(resolve10(rootDir))) {
         dirs.push(dirPath);
       }
     }
@@ -127631,7 +128277,7 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
 async function resolveLiteralPath(rootDir, cleaned) {
   const dir = join28(rootDir, cleaned);
   try {
-    if (!resolve9(dir).startsWith(resolve9(rootDir)))
+    if (!resolve10(dir).startsWith(resolve10(rootDir)))
       return [];
     const s = await stat10(dir);
     if (s.isDirectory())
@@ -127649,10 +128295,10 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile12(join28(dir, "package.json"), "utf-8");
+    const content = await readFile13(join28(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
-      name: pkg.name || basename6(dir),
+      name: pkg.name || basename7(dir),
       scripts: pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : {}
     };
   } catch {
@@ -127661,7 +128307,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile12(join28(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile13(join28(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -127688,7 +128334,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile12(join28(rootDir, "package.json"), "utf-8");
+    const content = await readFile13(join28(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -127736,8 +128382,8 @@ async function resolveSubWorkspaces(rootDir, pm) {
 var init_workspace_resolver = () => {};
 
 // src/infrastructure/services/workspace/command-discovery.ts
-import { access as access2, readFile as readFile13 } from "node:fs/promises";
-import { join as join29, relative as relative3, basename as basename7 } from "node:path";
+import { access as access2, readFile as readFile14 } from "node:fs/promises";
+import { join as join29, relative as relative3, basename as basename8 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file: file2, manager } of LOCKFILE_MAP) {
     try {
@@ -127785,7 +128431,7 @@ function isValidScriptEntry(name, script) {
 }
 async function readJsonFile(filePath, label) {
   try {
-    const content = await readFile13(filePath, "utf-8");
+    const content = await readFile14(filePath, "utf-8");
     return parseJsonc2(content);
   } catch (error51) {
     if (error51.code !== "ENOENT") {
@@ -127809,7 +128455,7 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
   return commands;
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
-  let rootPackageName = basename7(workingDir);
+  let rootPackageName = basename8(workingDir);
   const pkg = await readJsonFile(join29(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
@@ -127842,7 +128488,7 @@ async function readDenoJson(workingDir) {
     const deno = await readJsonFile(join29(workingDir, fileName), fileName);
     if (!deno?.tasks || typeof deno.tasks !== "object")
       continue;
-    const pkgName = deno.name ?? basename7(workingDir);
+    const pkgName = deno.name ?? basename8(workingDir);
     const subWorkspace = { type: "deno", path: ".", name: pkgName };
     for (const [taskName, taskCommand] of Object.entries(deno.tasks)) {
       if (!isValidScriptEntry(taskName, taskCommand))
@@ -127862,14 +128508,14 @@ async function readMakefile(workingDir) {
   const commands = [];
   for (const fileName of ["Makefile", "makefile"]) {
     try {
-      const content = await readFile13(join29(workingDir, fileName), "utf-8");
+      const content = await readFile14(join29(workingDir, fileName), "utf-8");
       const targets = parseMakefileTargets(content);
       if (targets.length === 0)
         continue;
       const subWorkspace = {
         type: "make",
         path: ".",
-        name: basename7(workingDir)
+        name: basename8(workingDir)
       };
       for (const target of targets) {
         commands.push({
@@ -129455,7 +130101,7 @@ function createDefaultDeps22() {
     },
     clock: {
       now: () => Date.now(),
-      delay: (ms) => new Promise((resolve10) => setTimeout(resolve10, ms))
+      delay: (ms) => new Promise((resolve11) => setTimeout(resolve11, ms))
     },
     spawning: new HarnessSpawningService({ rateLimiter: new SpawnRateLimiter }),
     agentProcessManager: null
@@ -130952,14 +131598,14 @@ var init_sse_event_buffer = __esm(() => {
     }
     _wake() {
       if (this._waiter) {
-        const resolve10 = this._waiter;
+        const resolve11 = this._waiter;
         this._waiter = null;
-        resolve10();
+        resolve11();
       }
     }
     _waitForData() {
-      return new Promise((resolve10) => {
-        this._waiter = resolve10;
+      return new Promise((resolve11) => {
+        this._waiter = resolve11;
       });
     }
     [Symbol.asyncIterator]() {
@@ -131030,8 +131676,8 @@ class OpencodeSdkSession {
   async prompt(input) {
     if (this.closed)
       throw new Error("Session is closed");
-    const turnPromise = new Promise((resolve10, reject) => {
-      this._turnDoneResolve = resolve10;
+    const turnPromise = new Promise((resolve11, reject) => {
+      this._turnDoneResolve = resolve11;
       this._turnDoneReject = reject;
     });
     turnPromise.catch(() => {});
@@ -131379,14 +132025,14 @@ class OpencodeSdkHarness {
     }
     this.sessionListeners.clear();
     this.childProcess.kill("SIGTERM");
-    await new Promise((resolve10) => {
+    await new Promise((resolve11) => {
       const timeout3 = setTimeout(() => {
         this.childProcess.kill("SIGKILL");
-        resolve10();
+        resolve11();
       }, 5000);
       this.childProcess.once("exit", () => {
         clearTimeout(timeout3);
-        resolve10();
+        resolve11();
       });
     });
   }
@@ -132278,10 +132924,10 @@ class BufferedJournalFactory {
     const waitForInProgress = () => {
       if (!flushInProgress)
         return Promise.resolve();
-      return new Promise((resolve10) => {
+      return new Promise((resolve11) => {
         const check2 = () => {
           if (!flushInProgress)
-            resolve10();
+            resolve11();
           else
             setTimeout(check2, 10);
         };
@@ -132507,7 +133153,7 @@ async function emitPhase(deps, event, phase, detail) {
   }, now));
 }
 function sleep5(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 async function waitForHarnessSessionId2(deps, event) {
   const initial = deps.agentMgr.getSlot(event.chatroomId, event.role, event.workingDir);
@@ -132876,19 +133522,19 @@ class ProcessManager {
     this.pendingStops.clear();
   }
   waitForExit(runId, ms) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve11) => {
       const interval = 100;
       let elapsed = 0;
       const timer = setInterval(() => {
         if (!this.runningProcesses.has(runId)) {
           clearInterval(timer);
-          resolve10(true);
+          resolve11(true);
           return;
         }
         elapsed += interval;
         if (elapsed >= ms) {
           clearInterval(timer);
-          resolve10(false);
+          resolve11(false);
         }
       }, interval);
     });
@@ -133019,10 +133665,10 @@ function resolveWhichCommand(name) {
   return process.platform === "win32" ? `where ${name}` : `which ${name}`;
 }
 function isCliAvailable(cliName) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const child = spawn5(resolveWhichCommand(cliName), [], DETACHED_SHELL_SPAWN_OPTIONS);
-    child.on("error", () => resolve10(false));
-    child.on("close", (code2) => resolve10(code2 === 0));
+    child.on("error", () => resolve11(false));
+    child.on("close", (code2) => resolve11(code2 === 0));
     child.unref();
   });
 }
@@ -133354,7 +134000,7 @@ function gitCloneEnv() {
 function spawnGitClone(repoUrl, cloneTarget, opts) {
   const spawnFn = opts.spawnFn ?? spawn6;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     let settled = false;
     const stderr = createStderrReader(opts.onProgress);
     const child = spawnFn("git", ["clone", "--progress", "--", repoUrl, cloneTarget], {
@@ -133370,7 +134016,7 @@ function spawnGitClone(repoUrl, cloneTarget, opts) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve10(outcome);
+      resolve11(outcome);
     };
     child.stderr?.setEncoding("utf8");
     child.stderr?.on("data", (text) => stderr.push(text));
@@ -133455,7 +134101,7 @@ async function reportResultWithRetry(deps, result3) {
         warn(`Git clone result report failed after retries: ${getErrorMessage(error51)}`);
         return;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, delayMs));
+      await new Promise((resolve11) => setTimeout(resolve11, delayMs));
     }
   }
 }
@@ -133877,7 +134523,7 @@ var init_assert_registered_working_dir = () => {};
 
 // src/infrastructure/services/workspace/workspace-path-security.ts
 import { realpath as realpath3 } from "node:fs/promises";
-import { dirname as dirname18, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve10, sep } from "node:path";
+import { dirname as dirname19, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve11, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 function validateRelativePathSegments(filePath) {
   if (filePath.includes("\x00"))
@@ -133905,7 +134551,7 @@ function assertContained(workspaceRoot, targetPath) {
   return { ok: true };
 }
 async function resolveNonExistentTarget(workspaceRoot, candidate) {
-  let current = dirname18(candidate);
+  let current = dirname19(candidate);
   for (;; ) {
     try {
       const ancestorReal = await realpath3(current);
@@ -133913,7 +134559,7 @@ async function resolveNonExistentTarget(workspaceRoot, candidate) {
       if (!ancestorCheck.ok)
         return ancestorCheck;
       const suffix = relative4(current, candidate);
-      const resolved = resolve10(ancestorReal, suffix);
+      const resolved = resolve11(ancestorReal, suffix);
       const resolvedCheck = assertContained(workspaceRoot, resolved);
       if (!resolvedCheck.ok)
         return resolvedCheck;
@@ -133923,7 +134569,7 @@ async function resolveNonExistentTarget(workspaceRoot, candidate) {
       if (code2 !== "ENOENT") {
         return { ok: false, error: "Invalid file path" };
       }
-      const parent = dirname18(current);
+      const parent = dirname19(current);
       if (parent === current) {
         return { ok: false, error: "Path escapes workspace" };
       }
@@ -133937,11 +134583,11 @@ async function resolvePathWithinWorkspace(workingDir, filePath) {
     return basic;
   let workspaceRoot;
   try {
-    workspaceRoot = await realpath3(resolve10(workingDir));
+    workspaceRoot = await realpath3(resolve11(workingDir));
   } catch {
     return { ok: false, error: "Working directory not found" };
   }
-  const candidate = resolve10(workspaceRoot, filePath);
+  const candidate = resolve11(workspaceRoot, filePath);
   if (!isPathInsideRoot(workspaceRoot, candidate)) {
     return { ok: false, error: "Path escapes workspace" };
   }
@@ -133982,7 +134628,7 @@ function gunzipBase64Payload(base643, maxBytes) {
 var init_workspace_path_security = () => {};
 
 // src/daemon/entry/files/file-content-fulfillment.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import { gzipSync as gzipSync3 } from "node:zlib";
 function getErrorCause(error51) {
   if (typeof error51 === "object" && error51 !== null && "cause" in error51 && error51.cause !== undefined) {
@@ -134057,7 +134703,7 @@ var init_file_content_fulfillment = __esm(() => {
         continue;
       }
       let fileNotFound = false;
-      const buffer = yield* exports_Effect.catch(exports_Effect.tryPromise(() => readFile14(absolutePath)), (error51) => {
+      const buffer = yield* exports_Effect.catch(exports_Effect.tryPromise(() => readFile15(absolutePath)), (error51) => {
         if (isENOENT(error51)) {
           fileNotFound = true;
           return exports_Effect.succeed(Buffer.alloc(0));
@@ -134122,7 +134768,7 @@ function getOrCreateState(key) {
   return state;
 }
 function sleep6(ms) {
-  return new Promise((resolve11) => setTimeout(resolve11, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 async function drainQueue(state, key, debounceMs) {
   try {
@@ -134154,9 +134800,9 @@ function kickDrain(state, key, debounceMs) {
   if (state.scheduled || state.drainPromise)
     return;
   state.scheduled = true;
-  state.drainPromise = new Promise((resolve11, reject) => {
+  state.drainPromise = new Promise((resolve12, reject) => {
     queueMicrotask(() => {
-      drainQueue(state, key, debounceMs).then(resolve11, reject);
+      drainQueue(state, key, debounceMs).then(resolve12, reject);
     });
   });
 }
@@ -134302,10 +134948,10 @@ function parseAttachmentFileName(remainder) {
   if (underscore <= 0)
     return false;
   const uuid3 = remainder.slice(0, underscore);
-  const basename8 = remainder.slice(underscore + 1);
-  if (!UUID_V4_RE.test(uuid3) || !basename8)
+  const basename9 = remainder.slice(underscore + 1);
+  if (!UUID_V4_RE.test(uuid3) || !basename9)
     return false;
-  return sanitizeChatAttachmentFileName(basename8) === basename8;
+  return sanitizeChatAttachmentFileName(basename9) === basename9;
 }
 function getInvalidChatAttachmentUploadPathReason(relativePath) {
   if (relativePath.includes("\\"))
@@ -134334,14 +134980,14 @@ function normalizeSegments(relativePath) {
 function hasBlockedSegment(lowerSegments) {
   return lowerSegments.some((segment) => BLOCKED_SEGMENT_NAMES.has(segment));
 }
-function hasBlockedBasename(basename8) {
-  return /^\.env(?:\.|$)/.test(basename8) || /\.(?:pem|key)$/.test(basename8) || basename8 === "id_rsa" || basename8 === "credentials.json";
+function hasBlockedBasename(basename9) {
+  return /^\.env(?:\.|$)/.test(basename9) || /\.(?:pem|key)$/.test(basename9) || basename9 === "id_rsa" || basename9 === "credentials.json";
 }
 function isBlockedUploadTargetPath(relativePath) {
   if (!relativePath)
     return false;
-  const { lowerSegments, basename: basename8 } = normalizeSegments(relativePath);
-  return hasBlockedSegment(lowerSegments) || hasBlockedBasename(basename8);
+  const { lowerSegments, basename: basename9 } = normalizeSegments(relativePath);
+  return hasBlockedSegment(lowerSegments) || hasBlockedBasename(basename9);
 }
 function getBlockedUploadTargetReason(relativePath) {
   if (!isBlockedUploadTargetPath(relativePath))
@@ -134392,7 +135038,7 @@ var init_file_write_request_priority = __esm(() => {
 
 // src/daemon/entry/files/file-write-fulfillment.ts
 import { access as access4, mkdir as mkdir12, rename as rename4, rm as rm4, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname19 } from "node:path";
+import { dirname as dirname20 } from "node:path";
 function isTerminalFileWriteError(errorMessage3) {
   const terminalMessages = new Set([
     "Invalid file path",
@@ -134491,7 +135137,7 @@ async function validateWriteOperation(operation, absolutePath) {
 }
 async function writePayloadToDisk(absolutePath, operation, content) {
   if (operation === "create") {
-    await mkdir12(dirname19(absolutePath), { recursive: true });
+    await mkdir12(dirname20(absolutePath), { recursive: true });
     await writeFile11(absolutePath, content, { flag: "wx" });
     return;
   }
@@ -134569,7 +135215,7 @@ async function fulfillOneFileWriteRequest(session2, request3) {
         });
         return;
       }
-      await mkdir12(dirname19(targetResolved.absolutePath), { recursive: true });
+      await mkdir12(dirname20(targetResolved.absolutePath), { recursive: true });
       await rename4(resolved.absolutePath, targetResolved.absolutePath);
       await completeWriteRequest(session2, claimed._id, claimed.revision, { status: "done" });
       const elapsed2 = Date.now() - startTime;
@@ -135178,8 +135824,8 @@ var init_command_runner = __esm(() => {
     }).catch((err) => {
       console.warn(`[${formatTimestamp()}] ⚠️ Failed to mark run as killed on shutdown: ${getErrorMessage(err)}`);
     })));
-    yield* exports_Effect.promise(() => new Promise((resolve11) => {
-      const t = setTimeout(resolve11, 3000);
+    yield* exports_Effect.promise(() => new Promise((resolve12) => {
+      const t = setTimeout(resolve12, 3000);
       t.unref?.();
     }));
     for (const [, tracked] of trackedEntries) {
@@ -135191,8 +135837,8 @@ var init_command_runner = __esm(() => {
     clearTrackedPids();
     yield* exports_Effect.promise(() => Promise.race([
       statusUpdates,
-      new Promise((resolve11) => {
-        const t = setTimeout(resolve11, 2000);
+      new Promise((resolve12) => {
+        const t = setTimeout(resolve12, 2000);
         t.unref?.();
       })
     ]));
@@ -135723,8 +136369,8 @@ function createDaemonRuntime(deps) {
   const withTimeout2 = async (p, ms) => {
     await Promise.race([
       Promise.resolve(p).catch(() => {}),
-      new Promise((resolve11) => {
-        const t = setTimeout(resolve11, ms);
+      new Promise((resolve12) => {
+        const t = setTimeout(resolve12, ms);
         t.unref?.();
       })
     ]);
@@ -135895,8 +136541,8 @@ Listening for commands...`);
   return {
     async run() {
       await exports_Effect.runPromise(startRuntimeEffect.pipe(exports_Effect.provide(deps.layers)));
-      await new Promise((resolve11) => {
-        runResolve = resolve11;
+      await new Promise((resolve12) => {
+        runResolve = resolve12;
       });
     },
     shutdown
@@ -136861,10 +137507,10 @@ var init_schema = __esm(() => {
 
 // src/daemon/infrastructure/persistence/open-database.ts
 import { mkdirSync as mkdirSync11 } from "node:fs";
-import { dirname as dirname20 } from "node:path";
+import { dirname as dirname21 } from "node:path";
 import { DatabaseSync as DatabaseSync5 } from "node:sqlite";
 function openDatabase(dbPath) {
-  mkdirSync11(dirname20(dbPath), { recursive: true });
+  mkdirSync11(dirname21(dbPath), { recursive: true });
   const db = new DatabaseSync5(dbPath);
   for (const sql of MIGRATIONS2) {
     db.exec(sql);
@@ -136928,10 +137574,10 @@ var init_persistence = __esm(() => {
 // src/daemon/local-web/client/lib/socket.ts
 async function ensureConnected(s) {
   if (!s.connected) {
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       const onConnect = () => {
         cleanup();
-        resolve11();
+        resolve12();
       };
       const onError3 = (err) => {
         cleanup();
@@ -141913,13 +142559,13 @@ var require_broadcast_operator = __commonJS((exports) => {
       return true;
     }
     emitWithAck(ev, ...args2) {
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve12, reject) => {
         args2.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve11(responses);
+            return resolve12(responses);
           }
         });
         this.emit(ev, ...args2);
@@ -142107,12 +142753,12 @@ var require_socket2 = __commonJS((exports) => {
     }
     emitWithAck(ev, ...args2) {
       const withErr = this.flags.timeout !== undefined;
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve12, reject) => {
         args2.push((arg1, arg2) => {
           if (withErr) {
-            return arg1 ? reject(arg1) : resolve11(arg2);
+            return arg1 ? reject(arg1) : resolve12(arg2);
           } else {
-            return resolve11(arg1);
+            return resolve12(arg1);
           }
         });
         this.emit(ev, ...args2);
@@ -142567,13 +143213,13 @@ var require_namespace = __commonJS((exports) => {
       return true;
     }
     serverSideEmitWithAck(ev, ...args2) {
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve12, reject) => {
         args2.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve11(responses);
+            return resolve12(responses);
           }
         });
         this.serverSideEmit(ev, ...args2);
@@ -143257,7 +143903,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId3 = randomId();
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve12, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.requests.get(requestId3);
           if (storedRequest2) {
@@ -143267,7 +143913,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve11,
+          resolve: resolve12,
           timeout: timeout3,
           current: 0,
           expected: expectedResponseCount,
@@ -143477,7 +144123,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId3 = randomId();
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve12, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.customRequests.get(requestId3);
           if (storedRequest2) {
@@ -143487,7 +144133,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve11,
+          resolve: resolve12,
           timeout: timeout3,
           missingUids: new Set([...this.nodesMap.keys()]),
           responses: localSockets
@@ -144216,13 +144862,13 @@ var require_dist5 = __commonJS((exports, module) => {
       this.engine.close();
       (0, uws_1.restoreAdapter)();
       if (this.httpServer) {
-        return new Promise((resolve11) => {
+        return new Promise((resolve12) => {
           this.httpServer.close((err) => {
             fn3 && fn3(err);
             if (err) {
               debug13("server was not running");
             }
-            resolve11();
+            resolve12();
           });
         });
       } else {
@@ -144360,7 +145006,7 @@ function routeRequest(req, res, deps) {
 
 // src/daemon/local-web/server/serve-static.ts
 import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname21, join as join31 } from "node:path";
+import { dirname as dirname22, join as join31 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function clientDistCandidates(here) {
   return [
@@ -144369,7 +145015,7 @@ function clientDistCandidates(here) {
     join31(here, "../src/daemon/local-web/client/build")
   ];
 }
-function resolveClientDistDir(here = dirname21(fileURLToPath7(import.meta.url))) {
+function resolveClientDistDir(here = dirname22(fileURLToPath7(import.meta.url))) {
   const candidates = clientDistCandidates(here);
   for (const dir of candidates) {
     if (existsSync10(join31(dir, "index.html")))
@@ -144805,9 +145451,9 @@ async function startLocalWebServer(config4, deps = {}) {
     routeRequest(req, res, { persistence: deps.persistence, streamHub });
   });
   const port = config4.port ?? 0;
-  await new Promise((resolve11, reject) => {
+  await new Promise((resolve12, reject) => {
     server.once("error", reject);
-    server.listen(port, config4.host, () => resolve11());
+    server.listen(port, config4.host, () => resolve12());
   });
   const address = server.address();
   if (!address || typeof address === "string") {
@@ -144835,13 +145481,13 @@ async function startLocalWebServer(config4, deps = {}) {
     port: boundPort,
     streamHub,
     stop() {
-      return new Promise((resolve11, reject) => {
+      return new Promise((resolve12, reject) => {
         io2.close((err) => {
           if (err) {
             reject(err);
             return;
           }
-          resolve11();
+          resolve12();
         });
         server.closeAllConnections();
       });
@@ -144962,8 +145608,8 @@ var init_cli_gateway_service = __esm(() => {
 // src/daemon/entry/start-daemon.ts
 async function startDaemon() {
   let resolveBoundPort;
-  const localWebPortReady = new Promise((resolve11) => {
-    resolveBoundPort = resolve11;
+  const localWebPortReady = new Promise((resolve12) => {
+    resolveBoundPort = resolve12;
   });
   const logStreamHub = createLogStreamHub();
   const eventStreamHub = createEventStreamHub();
@@ -145714,7 +146360,7 @@ async function withRetry(fn3, opts) {
         return;
       }
       const delay3 = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
-      await new Promise((resolve11) => setTimeout(resolve11, delay3));
+      await new Promise((resolve12) => setTimeout(resolve12, delay3));
     }
   }
   return;
@@ -145766,81 +146412,11 @@ var {
 } = import__.default;
 
 // src/commands/generate/index.ts
-import { readFile, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 init_image();
-
-// src/commands/generate/local-image-common.ts
-import { createHash as createHash2 } from "node:crypto";
-var SAFE_NAME = /^[A-Za-z0-9_][A-Za-z0-9_-]{0,63}$/;
-var MAX_SOURCE_PIXELS = 1e8;
-var MAX_SOURCE_BYTES = 64 * 1024 * 1024;
-var MAX_SIDECAR_BYTES = 1024 * 1024;
-var PNG_MAGIC = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function sha256(bytes) {
-  return createHash2("sha256").update(bytes).digest("hex");
-}
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function hasPngMagic(bytes) {
-  if (bytes.length < PNG_MAGIC.length)
-    return false;
-  return PNG_MAGIC.every((byte, index) => bytes[index] === byte);
-}
-function readPngDimensions(bytes) {
-  if (bytes.length < 24)
-    return null;
-  if (bytes[12] !== 73 || bytes[13] !== 72 || bytes[14] !== 68 || bytes[15] !== 82) {
-    return null;
-  }
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  return { width: view.getUint32(16), height: view.getUint32(20) };
-}
-function formatConflicts(conflicts) {
-  const shown = conflicts.slice(0, 10);
-  const lines = shown.map((conflict) => `- ${conflict.path}: ${conflict.reason}`);
-  if (conflicts.length > shown.length) {
-    lines.push(`- and ${conflicts.length - shown.length} more`);
-  }
-  return `Refusing to write ${conflicts.length} output file(s):
-${lines.join(`
-`)}
-Pass --force to overwrite.`;
-}
-async function findOutputConflicts(deps, paths, sourcePaths, sourceIdentities, force) {
-  const matchesSourceIdentity = (identity) => sourceIdentities.some((source) => source !== null && source.dev === identity.dev && source.ino === identity.ino);
-  const conflicts = [];
-  for (const path of paths) {
-    if (sourcePaths.has(path)) {
-      conflicts.push({ path, reason: "this is the source sheet or its manifest" });
-      continue;
-    }
-    if (await deps.isSymlink(path)) {
-      conflicts.push({ path, reason: "this is a symbolic link" });
-      continue;
-    }
-    const status = await deps.pathStatus(path);
-    if (status === "directory") {
-      conflicts.push({ path, reason: "a directory is in the way" });
-      continue;
-    }
-    const identity = await deps.fileIdentity(path);
-    if (identity !== null && matchesSourceIdentity(identity)) {
-      conflicts.push({ path, reason: "this resolves to the source sheet or its manifest" });
-      continue;
-    }
-    if (status === "file" && !force) {
-      conflicts.push({ path, reason: "already exists" });
-    }
-  }
-  return conflicts;
-}
-
-// src/commands/generate/index.ts
-var OUTPUT_FORMATS = ["png", "jpeg", "webp"];
+init_local_image_common();
+init_model_capabilities();
+var OUTPUT_FORMATS = ["png", "webp"];
 function parsePlatform(value) {
   if (!GENERATE_IMAGE_PLATFORMS.includes(value)) {
     throw new InvalidArgumentError(`must be one of ${GENERATE_IMAGE_PLATFORMS.join(", ")}`);
@@ -145865,7 +146441,7 @@ async function readInputOption(value) {
   if (stats.size > MAX_SIDECAR_BYTES) {
     throw new Error(`--input file is ${stats.size} bytes; the maximum is ${MAX_SIDECAR_BYTES} bytes (1 MiB).`);
   }
-  return parseInputJson(await readFile(path, "utf8"));
+  return parseInputJson(await readFile2(path, "utf8"));
 }
 function parseSeed(value) {
   const seed = Number(value);
@@ -145876,38 +146452,49 @@ function parseSeed(value) {
 }
 var HELP_AFTER = `
 Examples:
-  chatroom generate-image --platform=fal --prompt "a hero" --out hero.png
-  chatroom generate-image --platform=fal --model fal-ai/moss-image --prompt '{"summary":{"canvas":"single"},"items":[]}' --input '{"image_size":{"width":1024,"height":768},"enable_prompt_expansion":false}' --output-format png --out sheet.png
+  chatroom generate-image --platform=fal --model ${FLUX_2_FLASH_MODEL} --prompt "a hero" --out hero.png
+  chatroom generate-image --platform=fal --model ${FLUX_2_FLASH_MODEL} --prompt 'pixel-art potion, transparent-friendly flat background' --output-format png --out potion.png
+  chatroom generate-image --platform=fal --model ${FLUX_2_FLASH_EDIT_MODEL} --prompt "make the sky stormy" --input-image ./hero.png --out hero-stormy.png
 `;
-function registerGenerateImageCommand(program2) {
-  program2.command("generate-image").description("Generate one image with a fal model and write a JSON manifest next to it").requiredOption("--prompt <text>", "Text prompt describing the image").requiredOption("--out <path>", "Output image path (manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform, DEFAULT_GENERATE_IMAGE_PLATFORM).option("--model <id>", `fal model id. Recommended and default: ${DEFAULT_IMAGE_MODEL}`, DEFAULT_IMAGE_MODEL).option("--aspect-ratio <ratio>", `Aspect ratio, e.g. 1:1, 4:3, 16:9, 9:16 (omitted = model default). Not supported by the default model ${DEFAULT_IMAGE_MODEL}, which uses its own image size`).option("--output-format <format>", "Output format: png, jpeg, or webp (omitted = model default)", parseOutputFormat).option("--seed <n>", "Seed for the random number generator", parseSeed).option("--input <json|@file>", "Model-specific JSON input object merged into the fal request; @file reads JSON from a file").option("--force", "Overwrite existing output and manifest files").addHelpText("after", HELP_AFTER).action(async (options) => {
-    try {
-      const input = options.input === undefined ? undefined : await readInputOption(options.input);
-      const { createDefaultGenerateImageDeps: createDefaultGenerateImageDeps2 } = await Promise.resolve().then(() => (init_deps(), exports_deps));
-      const result = await generateImage({
-        prompt: options.prompt,
-        out: options.out,
-        platform: options.platform,
-        model: options.model,
-        aspectRatio: options.aspectRatio,
-        outputFormat: options.outputFormat,
-        seed: options.seed,
-        input,
-        force: options.force
-      }, createDefaultGenerateImageDeps2());
-      console.log(`Generated ${result.outPath}`);
-      console.log(`Manifest ${result.manifestPath}`);
-    } catch (err) {
-      console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
-      process.exitCode = 1;
+async function runGenerateImage(options) {
+  try {
+    const input = options.input === undefined ? undefined : await readInputOption(options.input);
+    const { createDefaultGenerateImageDeps: createDefaultGenerateImageDeps2 } = await Promise.resolve().then(() => (init_deps(), exports_deps));
+    const deps = createDefaultGenerateImageDeps2();
+    const generateOptions = {
+      prompt: options.prompt,
+      out: options.out,
+      platform: options.platform,
+      model: options.model,
+      aspectRatio: options.aspectRatio,
+      outputFormat: options.outputFormat,
+      seed: options.seed,
+      input,
+      inputImage: options.inputImage,
+      force: options.force
+    };
+    if (options.dryRun === true) {
+      const { formatGenerateImagePlan: formatGenerateImagePlan2, planGenerateImage: planGenerateImage2 } = await Promise.resolve().then(() => (init_image(), exports_image));
+      console.log(formatGenerateImagePlan2(await planGenerateImage2(generateOptions, deps)));
+      return;
     }
-  });
+    const result = await generateImage(generateOptions, deps);
+    console.log(`Generated ${result.outPath}`);
+    console.log(`Manifest ${result.manifestPath}`);
+  } catch (err) {
+    console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
+  }
+}
+function registerGenerateImageCommand(program2) {
+  program2.command("generate-image").description("Generate one image with a fal model and write a JSON manifest next to it").requiredOption("--prompt <text>", "Text prompt describing the image").requiredOption("--out <path>", "Output image path (manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform, DEFAULT_GENERATE_IMAGE_PLATFORM).requiredOption("--model <id>", `fal model id (required), for example ${FLUX_2_FLASH_MODEL}, or ${FLUX_2_FLASH_EDIT_MODEL} with --input-image`).option("--aspect-ratio <ratio>", "Aspect ratio for models that take one, e.g. 1:1, 16:9 (omitted = model default). Rejected for models the CLI knows do not support it").option("--output-format <format>", "Output format: png or webp (omitted = model default)", parseOutputFormat).option("--seed <n>", "Seed for the random number generator", parseSeed).option("--input <json|@file>", "Model-specific JSON input object merged into the fal request; @file reads JSON from a file").option("--input-image <path-or-url>", `Image to edit: a local .png, .jpg, .jpeg, .webp, or .gif (uploaded to fal) or an http(s) URL. Requires an edit model such as ${FLUX_2_FLASH_EDIT_MODEL}`).option("--force", "Overwrite existing output and manifest files").option("--dry-run", "Validate and print the request and the model constraints the CLI knows, without uploading or calling fal (FAL_API_KEY not needed)").addHelpText("after", HELP_AFTER).action(runGenerateImage);
 }
 
 // src/commands/generate/remove-background.ts
 import { basename, dirname as dirname3, extname as extname2, join as join2, resolve as resolve2 } from "node:path";
 
 // src/commands/generate/background-key.ts
+init_local_image_common();
 var DEFAULT_TOLERANCE = 24;
 var DEFAULT_MIN_AREA_PERCENT = 0.5;
 var BORDER_NOISE_REFUSAL_RATIO = 0.02;
@@ -145925,13 +146512,6 @@ function borderCoordinates(width, height) {
   }
   return coordinates;
 }
-function median(values) {
-  const sorted = [...values].sort((a, b) => a - b);
-  const middle = Math.floor(sorted.length / 2);
-  if (sorted.length % 2 === 1)
-    return sorted[middle] ?? 0;
-  return Math.round(((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2);
-}
 function forEachNeighbour(index, width, height, visit) {
   const x = index % width;
   const y = Math.floor(index / width);
@@ -146229,6 +146809,9 @@ function keyBackground(image, opts) {
   });
 }
 
+// src/commands/generate/remove-background.ts
+init_local_image_common();
+
 // src/commands/generate/trim-crop.ts
 var MAX_TRIM_PADDING = 64;
 function trimRect(contentBox, canvasWidth, canvasHeight, padding) {
@@ -146812,12 +147395,71 @@ function registerRemoveImageBackgroundCommand(program2) {
   });
 }
 
+// src/commands/generate/remove-background-fal-command.ts
+init_remove_background_fal();
+var ENGINES = ["bria", "birefnet"];
+function parseEngine(value) {
+  if (!ENGINES.includes(value)) {
+    throw new InvalidArgumentError(`must be one of ${ENGINES.join(", ")}`);
+  }
+  return value;
+}
+var HELP_AFTER3 = `
+Usage:
+  chatroom remove-image-background-fal --in <png> --out <png>
+    [--engine <bria|birefnet>] [--force]
+
+Purpose:
+  Cut the subject out of one PNG with fal.ai and write a PNG with alpha. For
+  the offline colour-key pass, use chatroom remove-image-background.
+
+Model:
+  Background model: bria (default, fal-ai/bria/background/remove) or birefnet
+  (previous BiRefNet Matting backend, fal-ai/birefnet/v2). The input is sent as
+  a base64 data URI, so no separate upload step is needed. Both engines return
+  a PNG with alpha.
+
+Billing:
+  bria is billed per call (about $0.018 at the time of writing). birefnet is
+  billed per compute-second.
+
+Refusals:
+  A missing FAL_API_KEY, a missing or non-PNG input, an input over 8 MiB, an
+  image over 100,000,000 pixels, and an existing output or manifest without
+  --force are all refused before the paid fal call.
+
+Limits:
+  One image per invocation; there is no directory mode and no --model switch.
+  The downloaded result must be a PNG no larger than 32 MiB.
+  The output PNG must match the input's width and height. A mismatch fails
+  without writing anything.
+
+Examples:
+  chatroom remove-image-background-fal --in tiles/potion.png --out assets/potion.png
+  chatroom remove-image-background-fal --in tiles/potion.png --out assets/potion.png --engine birefnet
+`;
+function registerRemoveImageBackgroundFalCommand(program2) {
+  program2.command("remove-image-background-fal").description("Remove an image background with fal.ai and write a transparent PNG").requiredOption("--in <png>", "Input PNG to cut out").requiredOption("--out <png>", "Output PNG path for the image with alpha").option("--engine <engine>", "Background model: bria (default, fal-ai/bria/background/remove) or birefnet (previous BiRefNet Matting backend, fal-ai/birefnet/v2)", parseEngine, DEFAULT_BACKGROUND_ENGINE).option("--force", "Overwrite an existing output and manifest").addHelpText("after", HELP_AFTER3).action(async (options) => {
+    try {
+      const { createDefaultRemoveBackgroundFalDeps: createDefaultRemoveBackgroundFalDeps2 } = await Promise.resolve().then(() => (init_remove_background_fal_deps(), exports_remove_background_fal_deps));
+      const result = await removeBackgroundFal({ in: options.in, out: options.out, engine: options.engine, force: options.force }, createDefaultRemoveBackgroundFalDeps2());
+      console.log(`Removed background ${result.outPath} (${result.bytes} bytes)`);
+      console.log(`Manifest ${result.manifestPath}`);
+      console.log(`Request ${result.requestId}`);
+    } catch (err) {
+      console.error(`❌ ${err instanceof Error ? err.message : String(err)}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/commands/generate/slice.ts
-import { basename as basename2, extname as extname3, join as join3, resolve as resolve3 } from "node:path";
+init_local_image_common();
+import { basename as basename3, extname as extname3, join as join3, resolve as resolve4 } from "node:path";
 var SLICE_TOOL = "chatroom slice-image";
 var MAX_TILES = 256;
 var MAX_GRID_DIMENSION = 64;
-var LICENSING2 = "unverified";
+var LICENSING3 = "unverified";
 
 class SliceImageError extends Error {
   constructor(message) {
@@ -147002,14 +147644,7 @@ function mostFrequentBorderColor(image) {
   }
   if (red.length === 0)
     return null;
-  const median2 = (values) => {
-    const sorted = [...values].sort((a, b) => a - b);
-    const middle = Math.floor(sorted.length / 2);
-    if (sorted.length % 2 === 1)
-      return sorted[middle] ?? 0;
-    return Math.round(((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2);
-  };
-  return [median2(red), median2(green), median2(blue)];
+  return [median(red), median(green), median(blue)];
 }
 function countCellEdgeForeground(image, cell, background) {
   const { width, height, data } = image;
@@ -147075,8 +147710,8 @@ async function sliceImage(opts, deps) {
   if (opts.names !== undefined && opts.prefix !== undefined) {
     throw new SliceImageError("--names and --prefix are mutually exclusive.");
   }
-  const inPath = resolve3(requireNonEmptyPath(opts.in, "--in"));
-  const outDir = resolve3(requireNonEmptyPath(opts.outDir, "--out-dir"));
+  const inPath = resolve4(requireNonEmptyPath(opts.in, "--in"));
+  const outDir = resolve4(requireNonEmptyPath(opts.outDir, "--out-dir"));
   const force = opts.force === true;
   const dryRun = opts.dryRun === true;
   const inputStat = await deps.statInput(inPath);
@@ -147097,7 +147732,7 @@ async function sliceImage(opts, deps) {
     throw new SliceImageError(`--in is ${bytes.byteLength} bytes; the maximum is ${MAX_SOURCE_BYTES} bytes (64 MiB).`);
   }
   if (!hasPngMagic(bytes)) {
-    throw new SliceImageError("--in is not a PNG. slice-image only reads PNG sheets; regenerate with 'chatroom generate-image --output-format png' (the default model returns PNG).");
+    throw new SliceImageError("--in is not a PNG. slice-image only reads PNG sheets; regenerate with 'chatroom generate-image --model <id> --output-format png'.");
   }
   const dimensions = readPngDimensions(bytes);
   if (dimensions === null) {
@@ -147131,7 +147766,7 @@ async function sliceImage(opts, deps) {
     gutter,
     allowRemainder: opts.allowRemainder === true
   });
-  const sheetStem = basename2(inPath, extname3(inPath));
+  const sheetStem = basename3(inPath, extname3(inPath));
   const names = resolveTileNames({
     cols,
     rows,
@@ -147279,7 +147914,7 @@ async function sliceImage(opts, deps) {
         hasAlpha: tile.hasAlpha
       },
       slicedAt,
-      licensing: LICENSING2
+      licensing: LICENSING3
     };
     await write(tile.path, () => deps.writeFile(tile.path, tile.encodedBytes, writeOptions));
     await write(tile.manifestPath, () => deps.writeJson(tile.manifestPath, manifest, writeOptions));
@@ -147309,7 +147944,7 @@ async function sliceImage(opts, deps) {
     })),
     skipped,
     slicedAt,
-    licensing: LICENSING2
+    licensing: LICENSING3
   };
   await write(indexPath, () => deps.writeJson(indexPath, index, writeOptions));
   return result;
@@ -147317,7 +147952,7 @@ async function sliceImage(opts, deps) {
 
 // src/commands/generate/slice-command.ts
 var DECIMAL_INTEGER2 = /^\d+$/;
-var HELP_AFTER3 = `
+var HELP_AFTER4 = `
 Usage:
   chatroom slice-image --in <path> --out-dir <dir> --cols <n> --rows <n> [--margin <px>] [--gutter <px>] [--names <a,b,,c,...> | --prefix <text>] [--allow-remainder] [--allow-edge-content] [--force] [--dry-run]
 
@@ -147389,7 +148024,7 @@ function printResult2(result, options) {
   }
 }
 function registerSliceImageCommand(program2) {
-  program2.command("slice-image").description("Cut a PNG sprite sheet into a grid of named PNG tiles with manifests").requiredOption("--in <path>", "Source PNG sprite sheet").requiredOption("--out-dir <dir>", "Directory for tile images and manifests").requiredOption("--cols <n>", "Grid columns (1-64)", parsePositiveInt).requiredOption("--rows <n>", "Grid rows (1-64)", parsePositiveInt).option("--margin <px>", "Pixels skipped on all four sides", parseNonNegativeInt, 0).option("--gutter <px>", "Pixels between adjacent cells on both axes", parseNonNegativeInt, 0).option("--names <a,b,...>", "Comma-separated row-major tile names; an empty entry skips that cell", parseNames).option("--prefix <text>", "Prefix for default names (default: sheet file stem)").option("--allow-remainder", "Drop leftover pixels on the right/bottom instead of refusing").option("--allow-edge-content", "Skip the check that refuses sheets whose artwork crosses cell borders (for full-bleed or tileable art)").option("--force", "Overwrite existing tile images and manifests").option("--dry-run", "Report the tiles without writing anything").addHelpText("after", HELP_AFTER3).action(async (options) => {
+  program2.command("slice-image").description("Cut a PNG sprite sheet into a grid of named PNG tiles with manifests").requiredOption("--in <path>", "Source PNG sprite sheet").requiredOption("--out-dir <dir>", "Directory for tile images and manifests").requiredOption("--cols <n>", "Grid columns (1-64)", parsePositiveInt).requiredOption("--rows <n>", "Grid rows (1-64)", parsePositiveInt).option("--margin <px>", "Pixels skipped on all four sides", parseNonNegativeInt, 0).option("--gutter <px>", "Pixels between adjacent cells on both axes", parseNonNegativeInt, 0).option("--names <a,b,...>", "Comma-separated row-major tile names; an empty entry skips that cell", parseNames).option("--prefix <text>", "Prefix for default names (default: sheet file stem)").option("--allow-remainder", "Drop leftover pixels on the right/bottom instead of refusing").option("--allow-edge-content", "Skip the check that refuses sheets whose artwork crosses cell borders (for full-bleed or tileable art)").option("--force", "Overwrite existing tile images and manifests").option("--dry-run", "Report the tiles without writing anything").addHelpText("after", HELP_AFTER4).action(async (options) => {
     try {
       const { createDefaultSliceImageDeps: createDefaultSliceImageDeps2 } = await Promise.resolve().then(() => (init_slice_deps(), exports_slice_deps));
       const sliceOptions = {
@@ -147430,13 +148065,13 @@ function collectMultiValueOption(value, previous) {
 
 // src/utils/stdin.ts
 async function readStdin() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => {
       chunks.push(Buffer.from(chunk));
     });
     process.stdin.on("end", () => {
-      resolve4(Buffer.concat(chunks).toString("utf8"));
+      resolve5(Buffer.concat(chunks).toString("utf8"));
     });
     process.stdin.on("error", (err) => {
       reject(new Error(`Failed to read stdin: ${err.message}`));
@@ -147539,6 +148174,7 @@ toolCommand.command("parse-pdf").description("Parse a PDF file and extract text
 registerGenerateImageCommand(program2);
 registerSliceImageCommand(program2);
 registerRemoveImageBackgroundCommand(program2);
+registerRemoveImageBackgroundFalCommand(program2);
 program2.command("register-agent").description("Register agent type for a chatroom role").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Role to register as (e.g., builder, planner)").requiredOption("--type <type>", "Agent type: remote or custom").option("--allow-type-change", "Required for --type=custom when the role is currently bound to a remote machine; explicitly opts into clearing the existing binding.").action(async (options) => {
   await maybeRequireAuth();
   if (options.type !== "remote" && options.type !== "custom") {
@@ -148057,4 +148693,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=6A6B81E7BB204BFD64756E2164756E21
+//# debugId=0C6C6A8595C191FE64756E2164756E21