omp-fabric 1.25.34 → 1.26.0

package/dist/fabric-runtime-state.js

@@ -33,7 +33,7 @@ import {
   repairFabricGuestCode,
   resolveFabricIdentity,
   runFabricHandoffAtBoundary
-} from "./chunks/chunk-OLFP7R5J.js";
+} from "./chunks/chunk-Z3KAY6S7.js";
 import "./chunks/chunk-7VIQNUPS.js";
 import {
   AgentTranscriptReader,
@@ -97,7 +97,7 @@ import {
   resolveAgentCwd,
   resolveOmpBinary,
   validateAgentCwdRequest
-} from "./chunks/chunk-HOKJTRI4.js";
+} from "./chunks/chunk-3OQKG7H6.js";
 import "./chunks/chunk-VPPIJRNZ.js";
 import {
   executeFile,
@@ -107,7 +107,7 @@ import {
 import "./chunks/chunk-CT2AJ2UI.js";
 import {
   checkedHandoffCompaction
-} from "./chunks/chunk-5CW2S6EB.js";
+} from "./chunks/chunk-Q2LRXHPR.js";
 import {
   DEFAULT_FABRIC_CONFIG,
   FUZZY_RESOLUTION_MARKERS,
@@ -117,7 +117,7 @@ import {
   resolveAgentDir,
   resolveAvailableOmpModel,
   resolveFabricModel
-} from "./chunks/chunk-JWC7B67Z.js";
+} from "./chunks/chunk-66H3QSMR.js";
 import {
   FABRIC_ACTOR_HOST_EVENTS,
   isFabricActorHostEvent,
@@ -157,7 +157,7 @@ import {
 import {
   estimateTokens,
   fabricExecTitleHintCached
-} from "./chunks/chunk-TRM76YFF.js";
+} from "./chunks/chunk-CEDP5WMR.js";
 import "./chunks/chunk-3J7BKUNG.js";
 import {
   MAX_COMPACTION_INSTRUCTIONS_CHARS,
@@ -182,7 +182,7 @@ import {
 } from "./chunks/chunk-ATTYOQSI.js";
 
 // src/fabric-runtime-state.ts
-import path19 from "node:path";
+import path20 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/actors/global-registry.ts
@@ -2235,10 +2235,10 @@ var FabricComponentSupervisor = class {
       adjacent.set(edge.from, targets);
     }
     const cycles = /* @__PURE__ */ new Map();
-    const visit = (node, path20, positions) => {
+    const visit = (node, path21, positions) => {
       const position = positions.get(node);
       if (position !== void 0) {
-        const cycle = path20.slice(position);
+        const cycle = path21.slice(position);
         const rotations = cycle.map((_, index) => [
           ...cycle.slice(index),
           ...cycle.slice(0, index)
@@ -2248,10 +2248,10 @@ var FabricComponentSupervisor = class {
         cycles.set(canonical.join("\0"), canonical);
         return;
       }
-      if (path20.length > this.#components.size) return;
-      const nextPositions = new Map(positions).set(node, path20.length);
+      if (path21.length > this.#components.size) return;
+      const nextPositions = new Map(positions).set(node, path21.length);
       for (const target of adjacent.get(node) ?? []) {
-        visit(target, [...path20, node], nextPositions);
+        visit(target, [...path21, node], nextPositions);
       }
     };
     for (const id of this.#components.keys()) visit(id, [], /* @__PURE__ */ new Map());
@@ -7060,9 +7060,9 @@ var CapturedToolsProvider = class {
   #allowedTools = readChildToolAllowlist();
   async list(request, _context) {
     const query = request.query?.trim().toLowerCase();
-    const descriptors8 = this.catalog.list().filter((entry) => !this.#allowedTools || this.#allowedTools.has(entry.name)).map(descriptorFrom);
-    if (!query) return descriptors8;
-    return descriptors8.filter(
+    const descriptors9 = this.catalog.list().filter((entry) => !this.#allowedTools || this.#allowedTools.has(entry.name)).map(descriptorFrom);
+    if (!query) return descriptors9;
+    return descriptors9.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description} ${descriptor.namespace ?? ""}`.toLowerCase().includes(query)
     );
   }
@@ -8498,6 +8498,650 @@ var CodemapProvider = class {
   }
 };
 
+// src/providers/image-provider.ts
+import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path10 from "node:path";
+var IMAGE_MODEL_API = /image|imagen|dall-e|flux|stable-diffusion|sdxl|seedream|kolors|wanx|cogview|recraft|ideogram|midjourney|horde|banana/i;
+var generateSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["prompt"],
+  properties: {
+    prompt: { type: "string", description: "Full image description; the only required argument." },
+    model: {
+      type: "string",
+      description: 'Optional provider/id to try first, e.g. "sub2api-agy/gemini-3.1-flash-image". Falls back to the configured chain.'
+    },
+    aspectRatio: {
+      type: "string",
+      description: "Aspect ratio forwarded as aspect_ratio or imageConfig.aspectRatio, e.g. 1:1, 16:9, 9:16."
+    },
+    size: {
+      type: "string",
+      enum: ["1024x1024", "1536x1024", "1024x1536"],
+      description: "Pixel size for gateways that accept an images-API size field."
+    },
+    count: { type: "number", description: "Images to request from one model; only the images API honours more than one." },
+    saveTo: { type: "string", description: "Absolute or cwd-relative file path for a single image." }
+  }
+};
+var editSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["prompt", "images"],
+  properties: {
+    prompt: { type: "string", description: "What to change in the source images." },
+    images: {
+      type: "array",
+      minItems: 1,
+      description: "Source images as file paths or data URLs.",
+      items: { type: "string" }
+    },
+    model: { type: "string", description: "Optional provider/id to try first." },
+    aspectRatio: { type: "string", description: "Aspect ratio forwarded to the backend." },
+    size: {
+      type: "string",
+      enum: ["1024x1024", "1536x1024", "1024x1536"],
+      description: "Pixel size for gateways that accept an images-API size field."
+    },
+    saveTo: { type: "string", description: "Absolute or cwd-relative file path for a single image." }
+  }
+};
+var modelsSchema = { type: "object", additionalProperties: false, properties: {} };
+var descriptors2 = [
+  {
+    name: "generate",
+    description: "Generate an image from a prompt. Tries each configured model in priority order and returns the first success with its path, bytes, model, and dialect. Returns { ok: false, reason, failures } instead of throwing when every model fails.",
+    inputSchema: generateSchema,
+    risk: "network"
+  },
+  {
+    name: "edit",
+    description: "Edit existing images with a prompt. Tries each configured model in priority order and returns the first success or { ok: false, reason, failures }. Source images travel in the shape each dialect expects: input_references or image/images for the images API, image_url parts for chat, input_image for responses, inlineData for gemini.",
+    inputSchema: editSchema,
+    risk: "network"
+  },
+  {
+    name: "models",
+    description: "Show the resolved priority chain: each entry's provider, model id, api, inferred or overridden dialect, and whether credentials resolve. No network call.",
+    inputSchema: modelsSchema,
+    risk: "read"
+  }
+];
+var splitModelSelector = (selector) => {
+  const trimmed = selector.trim();
+  const separator = trimmed.indexOf("/");
+  if (separator <= 0 || separator === trimmed.length - 1) return void 0;
+  return { provider: trimmed.slice(0, separator), id: trimmed.slice(separator + 1) };
+};
+var inferImageDialect = (api, modelId) => {
+  if (api === "openai-images" || api === "openrouter-images") return "images";
+  if (api === "google-generative-ai") return "gemini";
+  if (api === "openai-responses" || api === "openai-codex-responses") {
+    return IMAGE_MODEL_API.test(modelId) ? "images" : "responses";
+  }
+  return "chat";
+};
+var GPT_IMAGE_FAMILY = /gpt-image|chatgpt-image/i;
+var mimeFromMagic = (bytes) => {
+  if (bytes.length > 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+  if (bytes.length > 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return "image/png";
+  if (bytes.length > 6 && bytes.subarray(0, 3).toString("latin1") === "GIF") return "image/gif";
+  if (bytes.length > 12 && bytes.subarray(0, 4).toString("latin1") === "RIFF" && bytes.subarray(8, 12).toString("latin1") === "WEBP") {
+    return "image/webp";
+  }
+  return void 0;
+};
+var extensionForMime = (mimeType) => {
+  if (mimeType === "image/jpeg") return "jpg";
+  if (mimeType === "image/webp") return "webp";
+  if (mimeType === "image/gif") return "gif";
+  return "png";
+};
+var MAGIC_SNIFF_BASE64_CHARS = 64;
+var decodeImage = (value) => {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  let base64 = value;
+  if (value.startsWith("data:")) {
+    const comma = value.indexOf(",");
+    if (comma < 0) return void 0;
+    base64 = value.slice(comma + 1);
+  }
+  const head = Buffer.from(base64.slice(0, MAGIC_SNIFF_BASE64_CHARS), "base64");
+  if (head.length < 16) return void 0;
+  const mimeType = mimeFromMagic(head);
+  if (mimeType === void 0) return void 0;
+  return { data: base64, mimeType };
+};
+var collectFromUrlList = (value) => {
+  if (!Array.isArray(value)) return [];
+  const images = [];
+  for (const entry of value) {
+    if (typeof entry === "string") {
+      const decoded2 = decodeImage(entry);
+      if (decoded2) images.push(decoded2);
+      continue;
+    }
+    if (typeof entry !== "object" || entry === null) continue;
+    const record2 = entry;
+    const nested = record2.image_url;
+    const url = typeof nested === "string" ? nested : typeof nested === "object" && nested !== null ? nested.url : record2.url;
+    const decoded = decodeImage(url);
+    if (decoded) images.push(decoded);
+  }
+  return images;
+};
+var DATA_URL_PATTERN = /data:(image\/[a-z+]+);base64,([A-Za-z0-9+/=]+)/gi;
+var parseImagesApiPayload = (payload) => {
+  const data = payload?.data;
+  if (!Array.isArray(data)) return [];
+  const images = [];
+  for (const entry of data) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const record2 = entry;
+    const decoded = decodeImage(record2.b64_json) ?? decodeImage(record2.url);
+    if (decoded) images.push(decoded);
+  }
+  return images;
+};
+var parseResponsesPayload = (payload) => {
+  const output = payload?.output;
+  if (!Array.isArray(output)) return [];
+  const images = [];
+  for (const entry of output) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const record2 = entry;
+    if (record2.type !== "image_generation_call") continue;
+    const decoded = decodeImage(record2.result);
+    if (decoded) images.push(decoded);
+  }
+  return images;
+};
+var parseChatPayload = (payload) => {
+  const choices = payload?.choices;
+  if (!Array.isArray(choices) || choices.length === 0) return [];
+  const message2 = choices[0]?.message;
+  if (!message2) return [];
+  const direct = collectFromUrlList(message2.images);
+  if (direct.length > 0) return direct;
+  const content = message2.content;
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.map(
+    (part) => typeof part === "object" && part !== null && typeof part.text === "string" ? String(part.text) : ""
+  ).join("\n") : "";
+  const images = [];
+  for (const match of text.matchAll(DATA_URL_PATTERN)) {
+    const decoded = decodeImage(match[0]);
+    if (decoded) images.push(decoded);
+  }
+  if (images.length > 0) return images;
+  return collectFromUrlList(
+    Array.isArray(content) ? content.filter(
+      (part) => typeof part === "object" && part !== null && part.type === "image_url"
+    ) : []
+  );
+};
+var parseGeminiPayload = (payload) => {
+  const candidates = payload?.candidates;
+  if (!Array.isArray(candidates)) return [];
+  const images = [];
+  for (const candidate of candidates) {
+    const parts = candidate?.content?.parts;
+    if (!Array.isArray(parts)) continue;
+    for (const part of parts) {
+      if (typeof part !== "object" || part === null) continue;
+      const inline = part.inlineData ?? part.inline_data;
+      if (typeof inline !== "object" || inline === null) continue;
+      const record2 = inline;
+      const decoded = decodeImage(record2.data);
+      if (decoded) images.push(decoded);
+    }
+  }
+  return images;
+};
+var joinUrl = (baseUrl, suffix) => `${baseUrl.replace(/\/+$/, "")}${suffix.startsWith("/") ? suffix : "/" + suffix}`;
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var MAX_RESPONSE_BYTES = 96 * 1024 * 1024;
+var postJson = async (env, url, body, extraHeaders = {}) => {
+  const response = await env.fetchImpl(url, {
+    method: "POST",
+    headers: { ...env.headers, "Content-Type": "application/json", ...extraHeaders },
+    body: JSON.stringify(body),
+    ...env.signal ? { signal: env.signal } : {}
+  });
+  const declared = Number(response.headers.get("content-length") ?? "");
+  if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES) {
+    throw Object.assign(new Error(`${url} declared ${declared} bytes, over the ${MAX_RESPONSE_BYTES} ceiling`), {
+      status: 413
+    });
+  }
+  const text = await response.text();
+  if (!response.ok) {
+    throw Object.assign(new Error(`${url} returned ${response.status}: ${text.slice(0, 400)}`), {
+      status: response.status
+    });
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("text/event-stream")) {
+    return { payload: parseSsePayload(text), status: response.status, contentType };
+  }
+  try {
+    return { payload: JSON.parse(text), status: response.status, contentType };
+  } catch {
+    throw new Error(`${url} returned non-JSON: ${text.slice(0, 200)}`);
+  }
+};
+var parseSsePayload = (text) => {
+  let last;
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice(5).trim();
+    if (data.length === 0 || data === "[DONE]") continue;
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      continue;
+    }
+    if (!isRecord3(event)) continue;
+    const nested = event.response;
+    if (isRecord3(nested) && Array.isArray(nested.output)) {
+      last = nested;
+      continue;
+    }
+    if (Array.isArray(event.output)) last = event;
+  }
+  if (last === void 0) throw new Error("event stream carried no response payload");
+  return last;
+};
+var dataUrl = (image) => `data:${image.mimeType};base64,${image.data}`;
+var requestImages = async (env, model, options) => {
+  const openrouter = model.api === "openrouter-images";
+  const body = { model: model.id, prompt: options.prompt, n: options.count };
+  if (!model.gptImage) body.response_format = "b64_json";
+  if (options.size !== void 0) {
+    if (openrouter) body.image_size = options.size;
+    else body.size = options.size;
+  }
+  if (options.aspectRatio !== void 0) body.aspect_ratio = options.aspectRatio;
+  const references = options.inputImages.map((image) => ({ type: "image_url", url: dataUrl(image) }));
+  if (options.inputImages.length === 0) {
+    const url2 = joinUrl(env.baseUrl, openrouter ? "/images" : "/images/generations");
+    const { payload } = await postJson(env, url2, body);
+    return parseImagesApiPayload(payload);
+  }
+  if (model.provider === "openai") {
+    const form = new FormData();
+    form.set("model", model.id);
+    form.set("prompt", options.prompt);
+    form.set("n", String(options.count));
+    if (!model.gptImage) form.set("response_format", "b64_json");
+    if (options.size !== void 0) form.set("size", options.size);
+    for (const image of options.inputImages) {
+      form.append("image", new File([Buffer.from(image.data, "base64")], "image", { type: image.mimeType }));
+    }
+    const response = await env.fetchImpl(joinUrl(env.baseUrl, "/images/edits"), {
+      method: "POST",
+      headers: env.headers,
+      body: form,
+      ...env.signal ? { signal: env.signal } : {}
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw Object.assign(new Error(`images edit returned ${response.status}: ${text.slice(0, 400)}`), {
+        status: response.status
+      });
+    }
+    return parseImagesApiPayload(JSON.parse(text));
+  }
+  if (model.xai) {
+    body.image = references[0];
+    if (references.length > 1) body.images = references;
+  } else {
+    body.input_references = references;
+  }
+  const url = joinUrl(env.baseUrl, openrouter ? "/images" : "/images/edits");
+  try {
+    const { payload } = await postJson(env, url, body);
+    return parseImagesApiPayload(payload);
+  } catch (error) {
+    if (error.status !== 404) throw error;
+    const { payload } = await postJson(env, joinUrl(env.baseUrl, "/images/generations"), body);
+    return parseImagesApiPayload(payload);
+  }
+};
+var requestResponses = async (env, model, options) => {
+  const content = [{ type: "input_text", text: options.prompt }];
+  for (const image of options.inputImages) {
+    content.push({ type: "input_image", image_url: dataUrl(image) });
+  }
+  const body = {
+    model: model.id,
+    input: [{ role: "user", content }],
+    tools: [{ type: "image_generation" }],
+    tool_choice: { type: "image_generation" },
+    store: false
+  };
+  const url = model.codex ? joinUrl(env.baseUrl, "/codex/responses") : joinUrl(env.baseUrl, "/responses");
+  if (model.codex) body.stream = true;
+  const { payload } = await postJson(env, url, body, model.codex ? { Accept: "text/event-stream" } : {});
+  const status = payload?.status;
+  const images = parseResponsesPayload(payload);
+  if (images.length === 0 && status === "failed") {
+    const error = payload?.error;
+    throw new Error(
+      `responses backend reported status=failed${error ? `: ${JSON.stringify(error).slice(0, 200)}` : ""}`
+    );
+  }
+  return images;
+};
+var requestChat = async (env, model, options) => {
+  const content = [{ type: "text", text: options.prompt }];
+  for (const image of options.inputImages) {
+    content.push({ type: "image_url", image_url: { url: `data:${image.mimeType};base64,${image.data}` } });
+  }
+  const body = {
+    model: model.id,
+    messages: [{ role: "user", content }],
+    modalities: ["image", "text"]
+  };
+  const { payload } = await postJson(env, joinUrl(env.baseUrl, "/chat/completions"), body);
+  return parseChatPayload(payload);
+};
+var requestGemini = async (env, model, options) => {
+  const parts = [{ text: options.prompt }];
+  for (const image of options.inputImages) {
+    parts.push({ inlineData: { mimeType: image.mimeType, data: image.data } });
+  }
+  const imageConfig = {};
+  if (options.aspectRatio !== void 0) imageConfig.aspectRatio = options.aspectRatio;
+  if (options.size !== void 0) imageConfig.imageSize = options.size;
+  const body = {
+    contents: [{ role: "user", parts }],
+    generationConfig: {
+      responseModalities: ["IMAGE"],
+      candidateCount: 1,
+      ...Object.keys(imageConfig).length > 0 ? { imageConfig } : {}
+    }
+  };
+  const base = env.baseUrl.replace(/\/+$/, "");
+  const root = /\/v1beta\d*$/.test(base) ? base : `${base}/v1beta`;
+  const { payload } = await postJson(env, `${root}/models/${model.id}:generateContent`, body);
+  return parseGeminiPayload(payload);
+};
+var geminiHeaders = (apiKey) => ({ "x-goog-api-key": apiKey });
+var callDialect = (dialect, env, model, options) => {
+  switch (dialect) {
+    case "images":
+      return requestImages(env, model, options);
+    case "responses":
+      return requestResponses(env, model, options);
+    case "chat":
+      return requestChat(env, model, options);
+    case "gemini":
+      return requestGemini(env, model, options);
+  }
+};
+var readSourceImage = async (source, cwd) => {
+  if (source.startsWith("data:")) {
+    const decoded = decodeImage(source);
+    if (!decoded) throw new Error(`image source is not a usable data URL: ${source.slice(0, 40)}`);
+    return decoded;
+  }
+  const resolved = path10.isAbsolute(source) ? source : path10.resolve(cwd, source);
+  const bytes = await readFile2(resolved);
+  const mimeType = mimeFromMagic(bytes);
+  if (!mimeType) throw new Error(`unsupported or missing image file: ${resolved}`);
+  return { data: bytes.toString("base64"), mimeType };
+};
+var transient = (error) => {
+  const status = error?.status;
+  if (typeof status === "number") return status >= 500 || status === 408 || status === 409 || status === 429;
+  return true;
+};
+var describeError = (error) => error instanceof Error ? error.message : String(error);
+var ImageProvider = class {
+  constructor(config, options = {}) {
+    this.config = config;
+    this.options = options;
+  }
+  name = "image";
+  description = "Image generation and editing across a configurable priority chain of image models";
+  async list(request, _context) {
+    const query = request.query?.toLowerCase();
+    if (!query) return descriptors2;
+    return descriptors2.filter(
+      (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
+    );
+  }
+  async describe(actionName, _context) {
+    return descriptors2.find((descriptor) => descriptor.name === actionName);
+  }
+  async invoke(actionName, args, context) {
+    switch (actionName) {
+      case "generate":
+        return this.run("generate", args, context);
+      case "edit":
+        return this.run("edit", args, context);
+      case "models":
+        return this.chain(context);
+      default:
+        throw new Error(`Unknown image action: ${actionName}`);
+    }
+  }
+  registry(context) {
+    const registry = context.extensionContext.modelRegistry;
+    if (!registry) throw new Error("image provider needs a model registry on the extension context");
+    return registry;
+  }
+  resolveModel(registry, selector) {
+    const parsed = splitModelSelector(selector);
+    if (!parsed) return void 0;
+    const found = registry.find(parsed.provider, parsed.id);
+    if (!isRecord3(found)) return void 0;
+    const api = typeof found.api === "string" ? found.api : "";
+    const baseUrl = typeof found.baseUrl === "string" ? found.baseUrl : "";
+    if (api.length === 0 || baseUrl.length === 0) return void 0;
+    return {
+      provider: parsed.provider,
+      id: parsed.id,
+      api,
+      baseUrl,
+      gptImage: GPT_IMAGE_FAMILY.test(parsed.id),
+      codex: api === "openai-codex-responses",
+      xai: parsed.provider === "xai" || parsed.provider === "xai-oauth" || parsed.provider.startsWith("xai-")
+    };
+  }
+  dialectFor(model) {
+    const override = this.config().dialects[`${model.provider}/${model.id}`];
+    return override ?? inferImageDialect(model.api, model.id);
+  }
+  chainSelectors(args) {
+    const preferred = typeof args.model === "string" ? args.model.trim() : "";
+    const configured = this.config().models;
+    const selectors = preferred.length > 0 ? [preferred, ...configured] : [...configured];
+    const seen = /* @__PURE__ */ new Set();
+    return selectors.filter((selector) => {
+      if (seen.has(selector)) return false;
+      seen.add(selector);
+      return true;
+    });
+  }
+  async chain(context) {
+    const registry = this.registry(context);
+    const sessionId = context.extensionContext.sessionManager.getSessionId() ?? void 0;
+    const entries = [];
+    for (const selector of this.config().models) {
+      const model = this.resolveModel(registry, selector);
+      if (!model) {
+        entries.push({ selector, resolved: false, reason: "no matching model in the registry" });
+        continue;
+      }
+      let credentials = false;
+      try {
+        const apiKey = await registry.getApiKey(model, sessionId);
+        credentials = typeof apiKey === "string" && apiKey.length > 0;
+      } catch {
+        credentials = false;
+      }
+      entries.push({
+        selector,
+        resolved: true,
+        provider: model.provider,
+        id: model.id,
+        api: model.api,
+        baseUrl: model.baseUrl,
+        dialect: this.dialectFor(model),
+        credentials
+      });
+    }
+    return {
+      enabled: this.config().enabled,
+      timeoutMs: this.config().timeoutMs,
+      retries: this.config().retries,
+      outputDir: this.config().outputDir || os.tmpdir(),
+      models: entries
+    };
+  }
+  async run(action, args, context) {
+    const config = this.config();
+    if (!config.enabled) {
+      return { ok: false, reason: "image provider is disabled (image.enabled=false)" };
+    }
+    const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
+    if (prompt.length === 0) return { ok: false, reason: "prompt must be a non-empty string" };
+    const selectors = this.chainSelectors(args);
+    if (selectors.length === 0) {
+      return { ok: false, reason: "no image models configured (image.models is empty)" };
+    }
+    const count = typeof args.count === "number" && Number.isFinite(args.count) && args.count > 0 ? Math.min(Math.floor(args.count), 4) : 1;
+    const aspectRatio = typeof args.aspectRatio === "string" ? args.aspectRatio : void 0;
+    const size = typeof args.size === "string" ? args.size : void 0;
+    const saveTo = typeof args.saveTo === "string" && args.saveTo.trim().length > 0 ? args.saveTo.trim() : void 0;
+    const sources = action === "edit" ? Array.isArray(args.images) ? args.images.filter((entry) => typeof entry === "string") : [] : [];
+    if (action === "edit" && sources.length === 0) {
+      return { ok: false, reason: "edit needs at least one image path or data URL" };
+    }
+    let inputImages = [];
+    try {
+      inputImages = await Promise.all(sources.map((source) => readSourceImage(source, context.cwd)));
+    } catch (error) {
+      return { ok: false, reason: describeError(error) };
+    }
+    const registry = this.registry(context);
+    const sessionId = context.extensionContext.sessionManager.getSessionId() ?? void 0;
+    const fetchImpl = this.options.fetchImpl ?? fetch;
+    const now = this.options.now ?? Date.now;
+    const started = now();
+    const failures = [];
+    const attemptsPerModel = Math.max(1, Math.min(config.retries + 1, 5));
+    for (const selector of selectors) {
+      const model = this.resolveModel(registry, selector);
+      if (!model) {
+        failures.push({ model: selector, dialect: "images", error: "no matching model in the registry" });
+        continue;
+      }
+      const dialect = this.dialectFor(model);
+      let apiKey;
+      let extraHeaders = {};
+      try {
+        apiKey = await registry.getApiKey(model, sessionId);
+        extraHeaders = await registry.resolveModelHeaders?.(model, context.signal) ?? {};
+      } catch (error) {
+        failures.push({ model: selector, dialect, error: `credential lookup failed: ${describeError(error)}` });
+        continue;
+      }
+      if (typeof apiKey !== "string" || apiKey.length === 0) {
+        failures.push({ model: selector, dialect, error: "no credential for this model" });
+        continue;
+      }
+      const authHeaders = model.api === "google-generative-ai" ? geminiHeaders(apiKey) : { Authorization: `Bearer ${apiKey}` };
+      for (let attempt = 1; attempt <= attemptsPerModel; attempt += 1) {
+        context.signal?.throwIfAborted();
+        const signals = [AbortSignal.timeout(config.timeoutMs)];
+        if (context.signal) signals.push(context.signal);
+        const env = {
+          baseUrl: model.baseUrl,
+          apiKey,
+          headers: { ...authHeaders, ...extraHeaders },
+          signal: AbortSignal.any(signals),
+          fetchImpl
+        };
+        try {
+          const images = await callDialect(dialect, env, model, {
+            prompt,
+            aspectRatio,
+            size,
+            count,
+            inputImages,
+            signal: env.signal
+          });
+          if (images.length === 0) throw new Error("backend returned no image data");
+          let written;
+          try {
+            written = await this.write(images, saveTo, context.cwd);
+          } catch (error) {
+            return {
+              ok: false,
+              reason: `${model.provider}/${model.id} returned ${images.length} image(s) but the write failed: ${describeError(error)}`,
+              model: `${model.provider}/${model.id}`,
+              dialect,
+              failures,
+              elapsedMs: Math.max(0, now() - started)
+            };
+          }
+          context.attachMedia?.(
+            written.map((entry) => ({ type: "image", data: entry.data, mimeType: entry.mimeType })),
+            `Generated ${written.length} image(s) with ${model.provider}/${model.id} (${dialect}):
+${written.map((entry) => `  ${entry.path} (${entry.bytes} bytes)`).join("\n")}`
+          );
+          return {
+            ok: true,
+            model: `${model.provider}/${model.id}`,
+            dialect,
+            images: written.map((entry) => ({ path: entry.path, bytes: entry.bytes, mimeType: entry.mimeType })),
+            attempts: attempt,
+            elapsedMs: Math.max(0, now() - started),
+            failures
+          };
+        } catch (error) {
+          const status = error?.status;
+          failures.push({
+            model: `${model.provider}/${model.id}`,
+            dialect,
+            error: describeError(error),
+            ...typeof status === "number" ? { status } : {}
+          });
+          if (context.signal?.aborted) throw error;
+          if (attempt < attemptsPerModel && transient(error)) continue;
+          break;
+        }
+      }
+    }
+    return {
+      ok: false,
+      reason: `every configured image model failed (${failures.length} attempt${failures.length === 1 ? "" : "s"})`,
+      failures,
+      elapsedMs: Math.max(0, now() - started)
+    };
+  }
+  async write(images, saveTo, cwd) {
+    const configured = this.config().outputDir;
+    const directory = configured.length > 0 ? path10.isAbsolute(configured) ? configured : path10.resolve(cwd, configured) : os.tmpdir();
+    await mkdir(directory, { recursive: true, mode: 448 });
+    const written = [];
+    for (const [index, image] of images.entries()) {
+      const extension = extensionForMime(image.mimeType);
+      const target = saveTo !== void 0 && images.length === 1 ? path10.isAbsolute(saveTo) ? saveTo : path10.resolve(cwd, saveTo) : path10.join(directory, `fabric-image-${Date.now()}-${index}.${extension}`);
+      await mkdir(path10.dirname(target), { recursive: true, mode: 448 });
+      const bytes = Buffer.from(image.data, "base64");
+      await writeFile(target, bytes, { mode: 384 });
+      written.push({ path: target, bytes: bytes.length, mimeType: image.mimeType, data: image.data });
+    }
+    return written;
+  }
+};
+
 // src/providers/judgment-provider.ts
 import { Type as Type2 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 import { validateJsonSchemaValue as validateJsonSchemaValue2 } from "@oh-my-pi/pi-ai/utils/schema";
@@ -8510,7 +9154,7 @@ var askSchema = Type2.Object({
   })
 }, { additionalProperties: false });
 var statsSchema = Type2.Object({}, { additionalProperties: false });
-var descriptors2 = [
+var descriptors3 = [
   {
     name: "ask",
     description: "Answer typed questions about one state with calibrated probabilities: choice (one label plus its distribution), bool (probability of yes), score (weighted position on ordered levels). Questions asked about the same state within the coalesce window travel as one backend request. Returns { ok: false, reason } instead of throwing when no backend is configured, the budget refuses, or the request fails.",
@@ -8524,8 +9168,8 @@ var descriptors2 = [
     risk: "read"
   }
 ];
-var normalizeJudgmentArgs = actionArgNormalizer(() => descriptors2);
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeJudgmentArgs = actionArgNormalizer(() => descriptors3);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var instructionsOf = (id, value) => {
   if (typeof value !== "string" || value.length === 0) {
     throw new Error(`judgment.ask question "${id}" needs non-empty string instructions`);
@@ -8534,7 +9178,7 @@ var instructionsOf = (id, value) => {
 };
 var parseChoice = (id, value) => {
   const instructions = instructionsOf(id, value.instructions);
-  if (!isRecord3(value.criteria)) {
+  if (!isRecord4(value.criteria)) {
     throw new Error(`judgment.ask choice question "${id}" needs criteria: { label: rubric | null }`);
   }
   const criteria = {};
@@ -8553,7 +9197,7 @@ var parseChoice = (id, value) => {
 var parseBool = (id, value) => {
   const instructions = instructionsOf(id, value.instructions);
   if (value.criteria === void 0) return { type: "noul", instructions };
-  if (!isRecord3(value.criteria)) {
+  if (!isRecord4(value.criteria)) {
     throw new Error(`judgment.ask bool question "${id}" criteria must be { true?: string, false?: string }`);
   }
   const criteria = {};
@@ -8580,7 +9224,7 @@ var parseScore = (id, value) => {
   return { type: "score", instructions, criteria: [lowest, second, ...rest] };
 };
 var parseQuestion = (id, value) => {
-  if (!isRecord3(value)) throw new Error(`judgment.ask question "${id}" must be an object`);
+  if (!isRecord4(value)) throw new Error(`judgment.ask question "${id}" must be an object`);
   switch (value.type) {
     case "choice":
       return parseChoice(id, value);
@@ -8597,7 +9241,7 @@ var parseState = (value) => {
     if (value.length === 0) throw new Error("judgment.ask state must not be empty");
     return value;
   }
-  if (Array.isArray(value) || isRecord3(value)) return value;
+  if (Array.isArray(value) || isRecord4(value)) return value;
   throw new Error("judgment.ask state must be a string, a JSON object, or a JSON array");
 };
 var checked2 = (action, schema, args) => {
@@ -8616,12 +9260,12 @@ var JudgmentProvider = class {
   description = "Typed judgments over one state: calibrated choice, bool, and score answers batched into one backend request";
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors2.filter(
+    return query ? descriptors3.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors2;
+    ) : descriptors3;
   }
   async describe(actionName, _context) {
-    return descriptors2.find((descriptor) => descriptor.name === actionName);
+    return descriptors3.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeJudgmentArgs(actionName, args);
@@ -8933,7 +9577,7 @@ var emptySchema = {
   properties: {},
   additionalProperties: false
 };
-var descriptors3 = [
+var descriptors4 = [
   {
     name: "request",
     description: "Request an advisory compaction of the host session's context at the next safe boundary (agent_end). The host commits it only between turns, never mid-turn. A new request replaces any pending one.",
@@ -8956,7 +9600,7 @@ var descriptors3 = [
     risk: "write"
   }
 ];
-var normalizeCompactArgs = actionArgNormalizer(() => descriptors3);
+var normalizeCompactArgs = actionArgNormalizer(() => descriptors4);
 var CompactProvider = class {
   constructor(controller) {
     this.controller = controller;
@@ -8965,12 +9609,12 @@ var CompactProvider = class {
   description = "Programmatic, advisory-then-committed context compaction for the host OMP session";
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors3.filter(
+    return query ? descriptors4.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors3;
+    ) : descriptors4;
   }
   async describe(actionName, _context) {
-    return descriptors3.find((descriptor) => descriptor.name === actionName);
+    return descriptors4.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeCompactArgs(actionName, args);
@@ -9010,7 +9654,7 @@ var CompactProvider = class {
 };
 
 // src/providers/components-provider.ts
-var descriptors4 = [
+var descriptors5 = [
   {
     name: "list",
     description: "List registered component definitions and configured component instances.",
@@ -9057,13 +9701,13 @@ var ComponentsProvider = class {
   description = "Supervised component lifecycle, exact capability dependencies, effect cleanup, and reload diagnostics.";
   async list(request, _context) {
     const query = request.query?.normalize("NFKC").trim().toLowerCase();
-    const filtered = query ? descriptors4.filter(
+    const filtered = query ? descriptors5.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors4;
+    ) : descriptors5;
     return filtered.slice(0, Math.max(1, Math.min(request.limit ?? 100, 100)));
   }
   async describe(actionName, _context) {
-    return descriptors4.find((descriptor) => descriptor.name === actionName);
+    return descriptors5.find((descriptor) => descriptor.name === actionName);
   }
   async invoke(actionName, args, _context) {
     switch (actionName) {
@@ -9097,37 +9741,37 @@ var ComponentsProvider = class {
 // src/providers/mcp-descriptor-cache.ts
 import fs5 from "node:fs/promises";
 import fsSync from "node:fs";
-import os from "node:os";
-import path10 from "node:path";
+import os2 from "node:os";
+import path11 from "node:path";
 var MCP_DESCRIPTOR_CACHE_VERSION = 1;
 var homeDir = () => {
   const home = process.env.HOME;
-  return home && home.trim().length > 0 ? home : os.homedir();
+  return home && home.trim().length > 0 ? home : os2.homedir();
 };
 var expandHome = (input) => {
   if (!input.startsWith("~")) return input;
   const home = homeDir();
   if (input === "~") return home;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path10.join(home, input.slice(2));
+    return path11.join(home, input.slice(2));
   }
   return input;
 };
-var legacyMcporterDir = () => path10.join(homeDir(), ".mcporter");
+var legacyMcporterDir = () => path11.join(homeDir(), ".mcporter");
 var mcporterConfigDir = () => {
   const raw = process.env.XDG_CONFIG_HOME;
   if (raw && raw.trim().length > 0) {
     const resolved = expandHome(raw.trim());
-    if (path10.isAbsolute(resolved)) return path10.join(resolved, "mcporter");
+    if (path11.isAbsolute(resolved)) return path11.join(resolved, "mcporter");
   }
   return legacyMcporterDir();
 };
 var mcporterConfigCandidates = () => {
   const base = mcporterConfigDir();
-  const candidates = [path10.join(base, "mcporter.json"), path10.join(base, "mcporter.jsonc")];
+  const candidates = [path11.join(base, "mcporter.json"), path11.join(base, "mcporter.jsonc")];
   const legacy = legacyMcporterDir();
   if (base !== legacy) {
-    candidates.push(path10.join(legacy, "mcporter.json"), path10.join(legacy, "mcporter.jsonc"));
+    candidates.push(path11.join(legacy, "mcporter.json"), path11.join(legacy, "mcporter.jsonc"));
   }
   return candidates;
 };
@@ -9142,12 +9786,12 @@ var pathExists = (filePath) => {
 var mcpConfigLayerPaths = (rootDir, configPath) => {
   const explicitRaw = configPath ?? process.env.MCPORTER_CONFIG;
   if (explicitRaw && explicitRaw.trim().length > 0) {
-    return [path10.resolve(expandHome(explicitRaw.trim()))];
+    return [path11.resolve(expandHome(explicitRaw.trim()))];
   }
   const paths = [];
   const home = mcporterConfigCandidates().find(pathExists);
   if (home) paths.push(home);
-  const projectPath = path10.resolve(rootDir, "config", "mcporter.json");
+  const projectPath = path11.resolve(rootDir, "config", "mcporter.json");
   if (pathExists(projectPath)) paths.push(projectPath);
   return paths;
 };
@@ -9169,11 +9813,11 @@ var sameConfigLayers = (left, right) => left.length === right.length && left.eve
   return other !== void 0 && layer.path === other.path && layer.size === other.size && Math.abs(layer.mtimeMs - other.mtimeMs) <= 1;
 });
 var hashServerDefinition = (definition) => stableJsonHash(definition);
-var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var parseCachedServer = (value) => {
-  if (!isRecord4(value)) return void 0;
+  if (!isRecord5(value)) return void 0;
   const tools = Array.isArray(value.tools) ? value.tools.filter(
-    (tool) => isRecord4(tool) && typeof tool.name === "string"
+    (tool) => isRecord5(tool) && typeof tool.name === "string"
   ) : void 0;
   if (typeof value.definitionHash !== "string" || tools === void 0) return void 0;
   return {
@@ -9186,10 +9830,10 @@ var parseCachedServer = (value) => {
   };
 };
 var parseCacheFile = (value) => {
-  if (!isRecord4(value) || value.version !== MCP_DESCRIPTOR_CACHE_VERSION) return void 0;
-  if (!Array.isArray(value.layers) || !isRecord4(value.servers)) return void 0;
+  if (!isRecord5(value) || value.version !== MCP_DESCRIPTOR_CACHE_VERSION) return void 0;
+  if (!Array.isArray(value.layers) || !isRecord5(value.servers)) return void 0;
   const layers = value.layers.filter(
-    (layer) => isRecord4(layer) && typeof layer.path === "string" && typeof layer.mtimeMs === "number" && typeof layer.size === "number"
+    (layer) => isRecord5(layer) && typeof layer.path === "string" && typeof layer.mtimeMs === "number" && typeof layer.size === "number"
   );
   return {
     version: MCP_DESCRIPTOR_CACHE_VERSION,
@@ -9198,8 +9842,8 @@ var parseCacheFile = (value) => {
     servers: value.servers
   };
 };
-var projectMcpCachePath = (projectRoot) => path10.join(projectRoot, ".omp", "fabric", "mcp-cache.json");
-var globalMcpCachePath = (agentDir) => path10.join(agentDir, "fabric", "mcp-descriptors.json");
+var projectMcpCachePath = (projectRoot) => path11.join(projectRoot, ".omp", "fabric", "mcp-cache.json");
+var globalMcpCachePath = (agentDir) => path11.join(agentDir, "fabric", "mcp-descriptors.json");
 var tempCounter = 0;
 var McpDescriptorCacheStore = class {
   constructor(filePath) {
@@ -9216,9 +9860,9 @@ var McpDescriptorCacheStore = class {
   // Atomic-ish write: temp file then rename, so a concurrent reader either
   // sees the previous cache or the next one, never a torn document.
   async save(file) {
-    const directory = path10.dirname(this.filePath);
+    const directory = path11.dirname(this.filePath);
     await fs5.mkdir(directory, { recursive: true });
-    const tempPath = path10.join(
+    const tempPath = path11.join(
       directory,
       `.mcp-cache-${process.pid}-${Date.now()}-${tempCounter++}.tmp`
     );
@@ -9233,7 +9877,7 @@ var McpDescriptorCacheStore = class {
 };
 
 // src/providers/mcp-provider.ts
-import path11 from "node:path";
+import path12 from "node:path";
 var TOOL_METADATA_TTL_MS = 6e4;
 var REVALIDATE_CONCURRENCY = 3;
 var REVALIDATE_SERVER_TIMEOUT_MS = 2e4;
@@ -9394,9 +10038,9 @@ var McpProvider = class {
     this.#kickRevalidation();
     if (!request.namespace) await this.#awaitColdEnumeration(context.signal);
     const query = request.query?.toLowerCase();
-    const filterQuery = (descriptors8) => query ? descriptors8.filter(
+    const filterQuery = (descriptors9) => query ? descriptors9.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors8;
+    ) : descriptors9;
     if (request.namespace) {
       const server = await this.#resolveKnownServer(request.namespace);
       if (!server) return [];
@@ -9551,11 +10195,11 @@ var McpProvider = class {
   // Provider-fidelity descriptors for everything currently known, cached or
   // ephemeral.
   sliceDescriptors() {
-    const descriptors8 = [];
+    const descriptors9 = [];
     for (const [server, entry] of this.#servers) {
-      for (const tool of entry.tools) descriptors8.push(this.#toolDescriptor(server, tool));
+      for (const tool of entry.tools) descriptors9.push(this.#toolDescriptor(server, tool));
     }
-    return descriptors8;
+    return descriptors9;
   }
   // Test/ops hook: await hydration and any in-flight background revalidation,
   // then flush pending persistence and notifications.
@@ -9957,7 +10601,7 @@ var McpProvider = class {
           kind: "stdio",
           command: args.command,
           args: commandArgs,
-          cwd: path11.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
+          cwd: path12.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
         },
         ...env ? { env } : {}
       };
@@ -10022,13 +10666,13 @@ var McpProvider = class {
         return tools.map((tool) => this.#toolDescriptor(server, tool));
       })
     );
-    const descriptors8 = settled.flatMap(
+    const descriptors9 = settled.flatMap(
       (entry) => entry.status === "fulfilled" ? entry.value : []
     );
     const query = request.query?.toLowerCase();
-    const filtered = query ? descriptors8.filter(
+    const filtered = query ? descriptors9.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors8;
+    ) : descriptors9;
     return request.namespace ? filtered : [...managementDescriptors, ...filtered];
   }
   async #describeLegacy(actionName, _context) {
@@ -10100,7 +10744,7 @@ var assertReadableStateKey = (key) => {
     throw new Error(`Fabric mesh key is private host state: ${key}`);
   }
 };
-var descriptors5 = [
+var descriptors6 = [
   {
     name: "self",
     description: "Return this Fabric participant's mesh identity",
@@ -10227,7 +10871,7 @@ var descriptors5 = [
     namespace: "coordination"
   }
 ];
-var normalizeMeshArgs = actionArgNormalizer(() => descriptors5);
+var normalizeMeshArgs = actionArgNormalizer(() => descriptors6);
 var MeshProvider = class {
   constructor(store, identity, participants) {
     this.store = store;
@@ -10238,12 +10882,12 @@ var MeshProvider = class {
   description = "Durable topics and compare-and-swap shared state for emergent agent coordination";
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors5.filter(
+    return query ? descriptors6.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors5;
+    ) : descriptors6;
   }
   async describe(actionName, _context) {
-    return descriptors5.find((descriptor) => descriptor.name === actionName);
+    return descriptors6.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeMeshArgs(actionName, args);
@@ -10337,7 +10981,7 @@ var MeshProvider = class {
 // src/providers/omp-tools-provider.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync as statSync4, writeFileSync as writeFileSync2 } from "node:fs";
 import { AsyncLocalStorage } from "node:async_hooks";
-import path14 from "node:path";
+import path15 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { BashTool } from "@oh-my-pi/pi-coding-agent/tools/bash";
 import { EditTool } from "@oh-my-pi/pi-coding-agent/edit";
@@ -10356,7 +11000,7 @@ import {
 
 // src/agents/bash-worktree-add.ts
 import fs6 from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 var BARE_SAFE = /^[A-Za-z0-9_./:@%+=,-]+$/;
 var parseGitWorktreeAdd = (command) => {
   const trimmed = command.trim();
@@ -10419,8 +11063,8 @@ var tryExecuteGitWorktreeAdd = async (args, sessionCwd) => {
   if (typeof command !== "string") return void 0;
   const parsed = parseGitWorktreeAdd(command);
   if (!parsed) return void 0;
-  const gitCwd = parsed.gitCwd ? path12.resolve(sessionCwd, parsed.gitCwd) : typeof args.cwd === "string" ? args.cwd : sessionCwd;
-  const dest = path12.resolve(gitCwd, parsed.dest);
+  const gitCwd = parsed.gitCwd ? path13.resolve(sessionCwd, parsed.gitCwd) : typeof args.cwd === "string" ? args.cwd : sessionCwd;
+  const dest = path13.resolve(gitCwd, parsed.dest);
   let gitRoot;
   try {
     const root = await executeFile("git", ["rev-parse", "--show-toplevel"], {
@@ -10449,7 +11093,7 @@ var tryExecuteGitWorktreeAdd = async (args, sessionCwd) => {
 
 // src/providers/omp-bash-cwd.ts
 import { accessSync, constants, statSync as statSync3 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import { createBashToolDefinition } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-pi-coding-agent-shim";
 import { Type as Type4 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 var OMP_BASH_CWD_KEY = "cwd";
@@ -10459,7 +11103,7 @@ var resolveOmpShellCwd = (toolName, sessionCwd, requested) => {
       `Invalid omp.${toolName} cwd ${JSON.stringify(requested)}: path must be a non-empty string`
     );
   }
-  const resolved = path13.isAbsolute(requested) ? path13.resolve(requested) : path13.resolve(sessionCwd, requested);
+  const resolved = path14.isAbsolute(requested) ? path14.resolve(requested) : path14.resolve(sessionCwd, requested);
   try {
     if (!statSync3(resolved).isDirectory()) throw new Error("path is not a directory");
     accessSync(resolved, constants.R_OK | constants.X_OK);
@@ -10481,23 +11125,23 @@ var resolveShellCwdArgument = (toolName, sessionCwd, args) => Object.hasOwn(args
 } : args;
 var CWD_DESCRIPTION = "Execution directory for this command; relative paths resolve from the session cwd.";
 var CWD_PROPERTY = Type4.Optional(Type4.String({ description: CWD_DESCRIPTION }));
-var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var SHELL_FIELD_DESCRIPTIONS = {
   command: "command to execute",
   [OMP_BASH_CWD_KEY]: CWD_DESCRIPTION,
   pty: "run in pty mode"
 };
 var schemaDocument2 = (schema) => {
-  if (isRecord5(schema)) return schema;
+  if (isRecord6(schema)) return schema;
   if (typeof schema !== "function" || !("toJsonSchema" in schema)) return void 0;
   const toJsonSchema = schema.toJsonSchema;
   if (typeof toJsonSchema !== "function") return void 0;
   const document = toJsonSchema.call(schema);
-  return isRecord5(document) ? document : void 0;
+  return isRecord6(document) ? document : void 0;
 };
 var withShellCwdSchema = (schema) => {
   const document = schemaDocument2(schema);
-  if (!document || !isRecord5(document.properties)) return schema;
+  if (!document || !isRecord6(document.properties)) return schema;
   const properties = { ...document.properties };
   let changed = false;
   const cwdSchema = Object.hasOwn(properties, OMP_BASH_CWD_KEY) ? void 0 : schemaDocument2(CWD_PROPERTY);
@@ -10507,7 +11151,7 @@ var withShellCwdSchema = (schema) => {
   }
   for (const [field, description] of Object.entries(SHELL_FIELD_DESCRIPTIONS)) {
     const property = properties[field];
-    if (!isRecord5(property) || typeof property.description === "string") continue;
+    if (!isRecord6(property) || typeof property.description === "string") continue;
     properties[field] = { ...property, description };
     changed = true;
   }
@@ -10544,23 +11188,23 @@ var BashCwdDefinitions = class extends ShellCwdDefinitions {
 // src/providers/write-preview.ts
 import { homedir } from "node:os";
 import { dirname, isAbsolute, resolve, win32 } from "node:path";
-import { mkdir, readFile as readFile2, stat, writeFile } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { Type as Type5 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 import { WriteTool } from "@oh-my-pi/pi-coding-agent/tools/write";
 var mutationQueues = /* @__PURE__ */ new Map();
-var withFileMutationQueue = async (path20, operation) => {
-  const previous = mutationQueues.get(path20) ?? Promise.resolve();
+var withFileMutationQueue = async (path21, operation) => {
+  const previous = mutationQueues.get(path21) ?? Promise.resolve();
   let release;
   const current = new Promise((resolve2) => {
     release = resolve2;
   });
-  mutationQueues.set(path20, current);
+  mutationQueues.set(path21, current);
   await previous;
   try {
     return await operation();
   } finally {
     release();
-    if (mutationQueues.get(path20) === current) mutationQueues.delete(path20);
+    if (mutationQueues.get(path21) === current) mutationQueues.delete(path21);
   }
 };
 var URI_LIKE_WRITE_TARGET_RE = /^([a-z][a-z0-9+.-]*):\/{1,2}/i;
@@ -10605,7 +11249,7 @@ var readExistingFileForPreview = async (filePath, cwd, nextContent) => {
     return skipped("previous file too large", fileStat.size, true);
   }
   try {
-    const content = await readFile2(absolutePath, "utf8");
+    const content = await readFile3(absolutePath, "utf8");
     const bytes = Buffer.byteLength(content, "utf8");
     return bytes > MAX_WRITE_DIFF_BYTES ? skipped("previous file too large", bytes, true) : { kind: "content", content };
   } catch {
@@ -10623,11 +11267,11 @@ var createPreviewWriteToolDefinition = (cwd, session) => {
   return {
     ...original,
     async execute(_toolCallId, params, signal) {
-      const { path: path20, content } = params;
-      if (isUriLikeWriteTarget(path20)) {
+      const { path: path21, content } = params;
+      if (isUriLikeWriteTarget(path21)) {
         if (session === void 0) {
           throw new Error(
-            `Refusing to write '${path20}': URI-like targets need a host session to resolve. Prefix the path with './' to create a literal file by that name.`
+            `Refusing to write '${path21}': URI-like targets need a host session to resolve. Prefix the path with './' to create a literal file by that name.`
           );
         }
         return await new WriteTool(session).execute(
@@ -10639,23 +11283,23 @@ var createPreviewWriteToolDefinition = (cwd, session) => {
           { signal }
         );
       }
-      const absolutePath = resolvePreviewPath(path20, cwd);
+      const absolutePath = resolvePreviewPath(path21, cwd);
       return withFileMutationQueue(absolutePath, async () => {
         const throwIfAborted2 = () => {
           if (signal?.aborted) throw new Error("Operation aborted");
         };
         throwIfAborted2();
-        const before = await readExistingFileForPreview(path20, cwd, content);
+        const before = await readExistingFileForPreview(path21, cwd, content);
         throwIfAborted2();
-        await mkdir(dirname(absolutePath), { recursive: true });
+        await mkdir2(dirname(absolutePath), { recursive: true });
         throwIfAborted2();
-        await writeFile(absolutePath, content, "utf8");
+        await writeFile2(absolutePath, content, "utf8");
         throwIfAborted2();
         return {
           content: [
             {
               type: "text",
-              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path20}`
+              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path21}`
             }
           ],
           details: { codePreviewBeforeWrite: before }
@@ -10782,7 +11426,7 @@ var createNativeSession = (cwd, {
         try {
           mkdirSync2(artifacts.root, { recursive: true, mode: 448 });
           const id = randomUUID3();
-          const artifactPath = path14.join(artifacts.root, `${toolType}-${id}.log`);
+          const artifactPath = path15.join(artifacts.root, `${toolType}-${id}.log`);
           writeFileSync2(artifactPath, "", { mode: 384 });
           artifacts.paths.set(id, artifactPath);
           artifactAllocations.getStore()?.push(artifactPath);
@@ -10950,7 +11594,7 @@ var normalizeEditArguments = (args, replaceAll, cwd) => {
       ...replaceAll || record2.all === true || record2.replace_all === true ? { replace_all: true } : {}
     };
   });
-  const resolvedPath = path14.resolve(cwd, filePath.startsWith("@") ? filePath.slice(1) : filePath);
+  const resolvedPath = path15.resolve(cwd, filePath.startsWith("@") ? filePath.slice(1) : filePath);
   const current = readFileSync2(resolvedPath, "utf8");
   if (current.length > MAX_REPLACE_ALL_FILE_CHARS) {
     throw new Error(`omp.edit refuses files over ${MAX_REPLACE_ALL_FILE_CHARS} characters`);
@@ -11425,10 +12069,10 @@ var OmpToolsProvider = class _OmpToolsProvider {
   }
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    const descriptors8 = await Promise.all(
+    const descriptors9 = await Promise.all(
       OMP_GUEST_TOOL_NAMES.map((name) => this.describe(name, _context))
     );
-    return descriptors8.filter((descriptor) => descriptor !== void 0).filter(
+    return descriptors9.filter((descriptor) => descriptor !== void 0).filter(
       (descriptor) => query ? `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query) : true
     );
   }
@@ -11834,7 +12478,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
 import { spawn } from "node:child_process";
 import { createHash as createHash3, randomBytes, randomUUID as randomUUID4 } from "node:crypto";
 import fs8 from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // src/schema/types.ts
 var stateBinding = (head) => head ? { transitionId: head.transitionId, version: head.version, to: head.to } : null;
@@ -11843,7 +12487,7 @@ var stateBinding = (head) => head ? { transitionId: head.transitionId, version:
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import fs7 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 var SNAPSHOT_MAX_FILES = 2e4;
 var SNAPSHOT_MAX_BYTES = 512 * 1024 * 1024;
 var FALLBACK_SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -11861,10 +12505,10 @@ var git = (cwd, args) => execFileSync("git", ["-C", cwd, ...args], {
   stdio: ["ignore", "pipe", "ignore"]
 });
 var nulPaths = (buffer) => buffer.toString("utf8").split("\0").filter((item) => item.length > 0);
-var normalizeRelative = (value) => value.split(path15.sep).join("/");
+var normalizeRelative = (value) => value.split(path16.sep).join("/");
 var isInside = (root, candidate) => {
-  const relative = path15.relative(root, candidate);
-  return relative === "" || !path15.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path15.sep}`);
+  const relative = path16.relative(root, candidate);
+  return relative === "" || !path16.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path16.sep}`);
 };
 var excluded = (absolute, exclusions) => exclusions.some((root) => isInside(root, absolute));
 var entryDigest = (absolute) => {
@@ -11890,12 +12534,12 @@ var buildSnapshot = (cwd, paths, metadata, exclusions) => {
   let bytes = 0;
   const unique = [...new Set(paths)].sort((left, right) => left.localeCompare(right));
   for (const relativeInput of unique) {
-    const absolute = path15.resolve(cwd, relativeInput);
+    const absolute = path16.resolve(cwd, relativeInput);
     if (!isInside(cwd, absolute) || excluded(absolute, exclusions)) continue;
     if (Object.keys(entries).length >= SNAPSHOT_MAX_FILES) {
       throw new Error(`Schema workspace snapshot exceeds ${SNAPSHOT_MAX_FILES} files`);
     }
-    const relative = normalizeRelative(path15.relative(cwd, absolute));
+    const relative = normalizeRelative(path16.relative(cwd, absolute));
     const entry = entryDigest(absolute);
     bytes += entry.bytes;
     if (bytes > SNAPSHOT_MAX_BYTES) {
@@ -11924,9 +12568,9 @@ var fallbackPaths = (cwd, exclusions) => {
     const entries = fs7.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
       if (FALLBACK_SKIPPED_DIRECTORIES.has(entry.name)) continue;
-      const absolute = path15.join(directory, entry.name);
+      const absolute = path16.join(directory, entry.name);
       if (excluded(absolute, exclusions)) continue;
-      const relative = normalizeRelative(path15.relative(cwd, absolute));
+      const relative = normalizeRelative(path16.relative(cwd, absolute));
       if (entry.isDirectory()) visit(absolute);
       else paths.push(relative);
       if (paths.length > SNAPSHOT_MAX_FILES) {
@@ -11940,7 +12584,7 @@ var fallbackPaths = (cwd, exclusions) => {
 var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   const cwd = fs7.realpathSync(cwdInput);
   const exclusions = excludedRoots.map((root) => {
-    const absolute = path15.resolve(root);
+    const absolute = path16.resolve(root);
     try {
       return fs7.realpathSync(absolute);
     } catch {
@@ -11978,18 +12622,18 @@ var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   );
 };
 var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
-  if (!requestedPath.trim() || path15.isAbsolute(requestedPath)) {
+  if (!requestedPath.trim() || path16.isAbsolute(requestedPath)) {
     throw new Error(`Schema paths must be non-empty project-relative paths: ${requestedPath}`);
   }
   const cwd = fs7.realpathSync(cwdInput);
-  const absolute = path15.resolve(cwd, requestedPath);
+  const absolute = path16.resolve(cwd, requestedPath);
   if (!isInside(cwd, absolute) || absolute === cwd) {
     throw new Error(`Schema path escapes the project workspace: ${requestedPath}`);
   }
-  const relativeParts = path15.relative(cwd, absolute).split(path15.sep);
+  const relativeParts = path16.relative(cwd, absolute).split(path16.sep);
   let cursor = cwd;
   for (let index = 0; index < relativeParts.length; index++) {
-    cursor = path15.join(cursor, relativeParts[index]);
+    cursor = path16.join(cursor, relativeParts[index]);
     let stat2;
     try {
       stat2 = fs7.lstatSync(cursor);
@@ -11998,9 +12642,9 @@ var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
         if (index !== relativeParts.length - 1 || !options.allowAbsent) {
           throw new Error(`Schema path does not exist: ${requestedPath}`);
         }
-        const parentReal = fs7.realpathSync(path15.dirname(cursor));
+        const parentReal = fs7.realpathSync(path16.dirname(cursor));
         if (!isInside(cwd, parentReal)) throw new Error(`Schema path parent escapes the workspace: ${requestedPath}`);
-        return { absolute, relative: normalizeRelative(path15.relative(cwd, absolute)), exists: false };
+        return { absolute, relative: normalizeRelative(path16.relative(cwd, absolute)), exists: false };
       }
       throw error;
     }
@@ -12012,7 +12656,7 @@ var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
       throw new Error(`Schema transaction paths must name regular files: ${requestedPath}`);
     }
   }
-  return { absolute, relative: normalizeRelative(path15.relative(cwd, absolute)), exists: true };
+  return { absolute, relative: normalizeRelative(path16.relative(cwd, absolute)), exists: true };
 };
 var sha256File = (absolute) => `sha256:${digest(fs7.readFileSync(absolute))}`;
 
@@ -12063,8 +12707,8 @@ var SchemaController = class {
     this.identity = identity;
     this.state = state;
     this.cwd = fs8.realpathSync(cwd);
-    this.#journalRoot = path16.join(mesh.root, "schema-transactions");
-    this.#lockPath = path16.join(this.#journalRoot, ".commit.lock");
+    this.#journalRoot = path17.join(mesh.root, "schema-transactions");
+    this.#lockPath = path17.join(this.#journalRoot, ".commit.lock");
     this.#recoverJournals();
   }
   #activeHypotheses = /* @__PURE__ */ new Map();
@@ -12263,7 +12907,7 @@ var SchemaController = class {
     this.#assertPayloadBound(input);
     const release = this.#acquireCommitLock();
     const transactionId = randomUUID4();
-    const journalPath = path16.join(this.#journalRoot, `${transactionId}.json`);
+    const journalPath = path17.join(this.#journalRoot, `${transactionId}.json`);
     let journal;
     let consumed = false;
     let committed = false;
@@ -12744,7 +13388,7 @@ ${Date.now()}
     }
     for (const name of fs8.readdirSync(this.#journalRoot)) {
       if (!name.endsWith(".json")) continue;
-      const filePath = path16.join(this.#journalRoot, name);
+      const filePath = path17.join(this.#journalRoot, name);
       try {
         const journal = JSON.parse(fs8.readFileSync(filePath, "utf8"));
         if (journal.format !== 1 || journal.status !== "applying" || !Array.isArray(journal.before)) continue;
@@ -12864,7 +13508,7 @@ var operationSchema = {
     }
   ]
 };
-var descriptors6 = [
+var descriptors7 = [
   {
     name: "status",
     description: "Read the fixed session Schema mode, transaction bounds, generation, and invocation hypotheses",
@@ -12934,7 +13578,7 @@ var descriptors6 = [
     namespace: "schema"
   }
 ];
-var normalizeSchemaArgs = actionArgNormalizer(() => descriptors6);
+var normalizeSchemaArgs = actionArgNormalizer(() => descriptors7);
 var SchemaProvider = class {
   constructor(controller) {
     this.controller = controller;
@@ -12943,12 +13587,12 @@ var SchemaProvider = class {
   description = "Host-owned, opt-in Schema verification and bounded local-file transaction control plane";
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors6.filter(
+    return query ? descriptors7.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors6;
+    ) : descriptors7;
   }
   async describe(actionName, _context) {
-    return descriptors6.find((descriptor) => descriptor.name === actionName);
+    return descriptors7.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeSchemaArgs(actionName, args);
@@ -12998,11 +13642,11 @@ var SchemaProvider = class {
 
 // src/state/store.ts
 import { createHash as createHash5 } from "node:crypto";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // src/state/complexity.ts
 import fs9 from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 var isWordStart = (character) => character !== void 0 && (character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character === "_" || character === "$");
 var isWordPart = (character) => isWordStart(character) || character !== void 0 && character >= "0" && character <= "9";
 var regularExpressionPrefixWords = /* @__PURE__ */ new Set([
@@ -13234,7 +13878,7 @@ var languageComplexities = [
   typeScriptJavaScriptComplexity
 ];
 var complexityForFile = (file, languages = languageComplexities) => {
-  const extension = path17.extname(file).toLowerCase();
+  const extension = path18.extname(file).toLowerCase();
   return languages.find((language) => language.extensions.includes(extension));
 };
 var countFileComplexity = (file) => {
@@ -14125,7 +14769,7 @@ var StateStore = class {
     const files = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(requestedFiles, input.cwd)) {
-      const measured = countFileComplexity(path18.resolve(input.cwd, file));
+      const measured = countFileComplexity(path19.resolve(input.cwd, file));
       if (!measured) {
         files.push({ file, supported: false });
         continue;
@@ -14152,7 +14796,7 @@ var StateStore = class {
     const updates = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(files, cwd)) {
-      const measured = countFileComplexity(path18.resolve(cwd, file));
+      const measured = countFileComplexity(path19.resolve(cwd, file));
       if (!measured) {
         deltas.push({ file, supported: false });
         continue;
@@ -14202,11 +14846,11 @@ var StateStore = class {
     const normalized = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (!file.trim()) continue;
-      const relative = path18.relative(cwd, path18.resolve(cwd, file));
-      if (relative === ".." || relative.startsWith(`..${path18.sep}`) || path18.isAbsolute(relative)) {
+      const relative = path19.relative(cwd, path19.resolve(cwd, file));
+      if (relative === ".." || relative.startsWith(`..${path19.sep}`) || path19.isAbsolute(relative)) {
         throw new Error(`State complexity file must be inside the project cwd: ${file}`);
       }
-      normalized.add(relative.split(path18.sep).join("/"));
+      normalized.add(relative.split(path19.sep).join("/"));
     }
     return [...normalized];
   }
@@ -14648,7 +15292,7 @@ var checkGoalSchema = {
   additionalProperties: false
 };
 var emptySchema3 = { type: "object", properties: {}, additionalProperties: false };
-var descriptors7 = [
+var descriptors8 = [
   {
     name: "transition",
     description: "Append a labeled, validated state transition and compare-and-swap advance the head",
@@ -14699,7 +15343,7 @@ var descriptors7 = [
     namespace: "state"
   }
 ];
-var normalizeStateArgs = actionArgNormalizer(() => descriptors7);
+var normalizeStateArgs = actionArgNormalizer(() => descriptors8);
 var StateProvider = class {
   name = "state";
   description = "Schema-style labeled transition layer: an append-only timeline of validated transitions with a compare-and-swap head and evidence-based certification over mesh storage";
@@ -14714,12 +15358,12 @@ var StateProvider = class {
   }
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors7.filter(
+    return query ? descriptors8.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors7;
+    ) : descriptors8;
   }
   async describe(actionName, _context) {
-    return descriptors7.find((descriptor) => descriptor.name === actionName);
+    return descriptors8.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeStateArgs(actionName, args);
@@ -15227,7 +15871,7 @@ var FabricRuntimeState = class {
     const projectRoot = process.env.OMP_FABRIC_PROJECT_ROOT ?? context.cwd;
     await ensureFabricStateExclude(projectRoot).catch(() => void 0);
     const configuredMeshRoot = this.#config.mesh.root;
-    const meshRoot = process.env.OMP_FABRIC_MESH_ROOT ?? (configuredMeshRoot ? path19.resolve(projectRoot, configuredMeshRoot) : path19.join(projectRoot, ".omp", "fabric", "mesh"));
+    const meshRoot = process.env.OMP_FABRIC_MESH_ROOT ?? (configuredMeshRoot ? path20.resolve(projectRoot, configuredMeshRoot) : path20.join(projectRoot, ".omp", "fabric", "mesh"));
     this.#mesh = new MeshStore(
       meshRoot,
       this.#config.mesh.maxEventBytes,
@@ -15323,6 +15967,19 @@ var FabricRuntimeState = class {
         'disabled by configuration (judgment.enabled=false); set "judgment": { "enabled": true } in .omp/fabric.json or the agent fabric.json to enable judgment.* actions'
       );
     }
+    if (this.#config.image.enabled) {
+      const imageConfig = () => this.#config?.image ?? DEFAULT_FABRIC_CONFIG.image;
+      await installBuiltin(createProviderComponent({
+        provider: "image",
+        description: "Image generation and editing across a configured priority chain",
+        create: () => new ImageProvider(imageConfig)
+      }));
+    } else {
+      this.#registry.markUnavailable(
+        "image",
+        'disabled by configuration (image.enabled=false); set "image": { "enabled": true } in .omp/fabric.json or the agent fabric.json to enable image.* actions'
+      );
+    }
     const agentConfig = enforceSchema ? { ...this.#config.agents, enabled: false } : this.#config.agents;
     const modelsConfig = this.#config.models;
     const visibleOmpModels = () => {
@@ -15421,8 +16078,8 @@ var FabricRuntimeState = class {
     };
     const lineageAlive = (rootId) => this.#participants?.get(rootId) !== void 0;
     const actorRoots = {
-      project: path19.join(meshRoot, "actors"),
-      session: path19.join(meshRoot, "actors", fabricSessionId)
+      project: path20.join(meshRoot, "actors"),
+      session: path20.join(meshRoot, "actors", fabricSessionId)
     };
     const acquireActorCapabilityView = (requirements, signal) => this.#registry.acquireCapabilityView(requirements, {
       cwd: context.cwd,
@@ -15626,6 +16283,7 @@ ${escapeXmlText(text)}
       "compact",
       ...this.#config.codemap.enabled ? ["codemap"] : [],
       ...this.#config.judgment.enabled ? ["judgment"] : [],
+      ...this.#config.image.enabled ? ["image"] : [],
       "agents",
       ...this.#config.memory.enabled ? ["memory"] : []
     ]);