greprag 5.61.0 → 5.62.0

package/dist/opencode-plugin.bundle.js

@@ -1746,13 +1746,14 @@ function crushMessages(messages, opts) {
 }
 
 // src/commands/os-primer-reminder.ts
-function buildOsPrimer() {
+function buildOsPrimer(env) {
+  const spawnEntry = env?.platform === "codex" ? "codex-chip-spawn" : "chip-spawn";
   return [
     "[grepragOS \u2014 the operating laws. Full doctrine: `greprag load os`.]",
     '\u2022 Doctrine vs state: methods ship in the CLI (`greprag load`); live state lives in the repo. A skill that depends on repo state carries a "STATE \u2014 read these first" block naming exact paths.',
     "\u2022 Discoverability: every durable artifact must be findable next session \u2014 docs auto-register, skills auto-mirror, decisions get a dated ADR/decision-log entry, everything else gets its path named in the owning skill/doc. If nothing points at it, you didn't finish.",
     "\u2022 Pull before derive: `greprag memory search` / `corpus search` / `load` BEFORE asking the operator or re-deriving what the project already knows.",
-    '\u2022 Friction \u21D2 fix NOW: one unit of friction \u21D2 `greprag fix spawn "<unit>"` \u2014 one chip per unit; it investigates, then confidence \u226590 repairs autonomously / <90 parks for operator co-design. Never queue friction.',
+    `\u2022 Friction \u21D2 fix NOW: one unit of friction \u21D2 \`greprag fix spawn "<unit>"\`. It PRINTS a fix-chip mission (a chip = a spawned child task/session) \u2014 YOU then create the child task with that mission as its first message (how: \`greprag load ${spawnEntry}\`, or your harness's native task tool). One unit per chip; the chip investigates, then confidence \u226590 repairs autonomously / <90 parks for operator co-design. Never queue friction.`,
     "\u2022 Teach the system, not the chat: explained twice by the operator \u21D2 it belongs in a skill / load entry / STATE block / ADR, not the conversation."
   ].join("\n");
 }
@@ -1760,7 +1761,7 @@ var osPrimerModule = {
   id: "os-primer",
   detect: (_env) => ({ tier: "silent" }),
   // never a per-turn nag
-  announce: () => buildOsPrimer(),
+  announce: (env) => buildOsPrimer(env),
   reminder: () => null
 };
 
@@ -2500,6 +2501,588 @@ function activeProcedureAnnounces(store) {
   return lines;
 }
 
+// src/archive/glyph-font.ts
+var GLYPH_W = 8;
+var GLYPH_H = 8;
+var FIRST_CODE = 32;
+var LAST_CODE = 126;
+var FONT_HEX = [
+  "0000000000000000",
+  "183c3c1818001800",
+  "3636000000000000",
+  "36367f367f363600",
+  "0c3e031e301f0c00",
+  "006333180c666300",
+  "1c361c6e3b336e00",
+  "0606030000000000",
+  "180c0606060c1800",
+  "060c1818180c0600",
+  "00663cff3c660000",
+  "000c0c3f0c0c0000",
+  "00000000000c0c06",
+  "0000003f00000000",
+  "00000000000c0c00",
+  "6030180c06030100",
+  "3e63737b6f673e00",
+  "0c0e0c0c0c0c3f00",
+  "1e33301c06333f00",
+  "1e33301c30331e00",
+  "383c36337f307800",
+  "3f031f3030331e00",
+  "1c06031f33331e00",
+  "3f3330180c0c0c00",
+  "1e33331e33331e00",
+  "1e33333e30180e00",
+  "000c0c00000c0c00",
+  "000c0c00000c0c06",
+  "180c0603060c1800",
+  "00003f00003f0000",
+  "060c1830180c0600",
+  "1e3330180c000c00",
+  "3e637b7b7b031e00",
+  "0c1e33333f333300",
+  "3f66663e66663f00",
+  "3c66030303663c00",
+  "1f36666666361f00",
+  "7f46161e16467f00",
+  "7f46161e16060f00",
+  "3c66030373667c00",
+  "3333333f33333300",
+  "1e0c0c0c0c0c1e00",
+  "7830303033331e00",
+  "6766361e36666700",
+  "0f06060646667f00",
+  "63777f7f6b636300",
+  "63676f7b73636300",
+  "1c36636363361c00",
+  "3f66663e06060f00",
+  "1e3333333b1e3800",
+  "3f66663e36666700",
+  "1e33070e38331e00",
+  "3f2d0c0c0c0c1e00",
+  "3333333333333f00",
+  "33333333331e0c00",
+  "6363636b7f776300",
+  "6363361c1c366300",
+  "3333331e0c0c1e00",
+  "7f6331184c667f00",
+  "1e06060606061e00",
+  "03060c1830604000",
+  "1e18181818181e00",
+  "081c366300000000",
+  "00000000000000ff",
+  "0c0c180000000000",
+  "00001e303e336e00",
+  "0706063e66663b00",
+  "00001e3303331e00",
+  "3830303e33336e00",
+  "00001e333f031e00",
+  "1c36060f06060f00",
+  "00006e33333e301f",
+  "0706366e66666700",
+  "0c000e0c0c0c1e00",
+  "300030303033331e",
+  "070666361e366700",
+  "0e0c0c0c0c0c1e00",
+  "0000337f7f6b6300",
+  "00001f3333333300",
+  "00001e3333331e00",
+  "00003b66663e060f",
+  "00006e33333e3078",
+  "00003b6e66060f00",
+  "00003e031e301f00",
+  "080c3e0c0c2c1800",
+  "0000333333336e00",
+  "00003333331e0c00",
+  "0000636b7f7f3600",
+  "000063361c366300",
+  "00003333333e301f",
+  "00003f190c263f00",
+  "380c0c070c0c3800",
+  "1818180018181800",
+  "070c0c380c0c0700",
+  "6e3b000000000000"
+];
+function glyphRows(code) {
+  if (code < FIRST_CODE || code > LAST_CODE)
+    return null;
+  const hex = FONT_HEX[code - FIRST_CODE];
+  const out = [];
+  for (let i = 0; i < 8; i++)
+    out.push(parseInt(hex.slice(i * 2, i * 2 + 2), 16));
+  return out;
+}
+var reverse = null;
+function codeForSignature(sigHex) {
+  if (!reverse) {
+    reverse = /* @__PURE__ */ new Map();
+    for (let c = FIRST_CODE; c <= LAST_CODE; c++)
+      reverse.set(FONT_HEX[c - FIRST_CODE], c);
+  }
+  return reverse.get(sigHex) ?? null;
+}
+function signatureForRows(bytes) {
+  return bytes.map((b) => (b & 255).toString(16).padStart(2, "0")).join("");
+}
+
+// src/archive/png-codec.ts
+var zlib = __toESM(require("zlib"));
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var crcTable = null;
+function getCrcTable() {
+  if (crcTable)
+    return crcTable;
+  crcTable = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    crcTable[n] = c >>> 0;
+  }
+  return crcTable;
+}
+function crc32(buf) {
+  const table = getCrcTable();
+  let c = 4294967295;
+  for (let i = 0; i < buf.length; i++) {
+    c = table[(c ^ buf[i]) & 255] ^ c >>> 8;
+  }
+  return (c ^ 4294967295) >>> 0;
+}
+function chunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length, 0);
+  const typeAndData = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(typeAndData), 0);
+  return Buffer.concat([len, typeAndData, crc]);
+}
+function encodePng(img) {
+  const { width, height, pixels } = img;
+  if (pixels.length !== width * height) {
+    throw new Error(`pixel buffer ${pixels.length} != ${width}x${height}`);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 0;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const raw = Buffer.alloc(height * (width + 1));
+  for (let y = 0; y < height; y++) {
+    raw[y * (width + 1)] = 0;
+    pixels.copy(raw, y * (width + 1) + 1, y * width, (y + 1) * width);
+  }
+  const idat = zlib.deflateSync(raw, { level: 9 });
+  return Buffer.concat([
+    PNG_SIGNATURE,
+    chunk("IHDR", ihdr),
+    chunk("IDAT", idat),
+    chunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function paeth(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc)
+    return a;
+  if (pb <= pc)
+    return b;
+  return c;
+}
+function decodePng(buf) {
+  if (buf.length < 8 || !buf.subarray(0, 8).equals(PNG_SIGNATURE)) {
+    throw new Error("not a PNG (bad signature)");
+  }
+  let width = 0;
+  let height = 0;
+  const idatParts = [];
+  let off = 8;
+  while (off + 8 <= buf.length) {
+    const len = buf.readUInt32BE(off);
+    const type = buf.toString("ascii", off + 4, off + 8);
+    const data = buf.subarray(off + 8, off + 8 + len);
+    if (type === "IHDR") {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      const bitDepth = data[8];
+      const colorType = data[9];
+      const interlace = data[12];
+      if (bitDepth !== 8 || colorType !== 0 || interlace !== 0) {
+        throw new Error(`unsupported PNG (bitDepth=${bitDepth} colorType=${colorType} interlace=${interlace})`);
+      }
+    } else if (type === "IDAT") {
+      idatParts.push(data);
+    } else if (type === "IEND") {
+      break;
+    }
+    off += 8 + len + 4;
+  }
+  if (!width || !height)
+    throw new Error("PNG missing IHDR");
+  if (idatParts.length === 0)
+    throw new Error("PNG missing IDAT");
+  const raw = zlib.inflateSync(Buffer.concat(idatParts));
+  const stride = width + 1;
+  if (raw.length < height * stride) {
+    throw new Error(`PNG data short: ${raw.length} < ${height * stride}`);
+  }
+  const pixels = Buffer.alloc(width * height);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * stride];
+    const rowIn = raw.subarray(y * stride + 1, y * stride + 1 + width);
+    const rowOut = pixels.subarray(y * width, (y + 1) * width);
+    for (let x = 0; x < width; x++) {
+      const a = x > 0 ? rowOut[x - 1] : 0;
+      const b = y > 0 ? pixels[(y - 1) * width + x] : 0;
+      const c = x > 0 && y > 0 ? pixels[(y - 1) * width + x - 1] : 0;
+      let v;
+      switch (filter) {
+        case 0:
+          v = rowIn[x];
+          break;
+        case 1:
+          v = rowIn[x] + a;
+          break;
+        case 2:
+          v = rowIn[x] + b;
+          break;
+        case 3:
+          v = rowIn[x] + (a + b >> 1);
+          break;
+        case 4:
+          v = rowIn[x] + paeth(a, b, c);
+          break;
+        default:
+          throw new Error(`unsupported PNG filter ${filter} on row ${y}`);
+      }
+      rowOut[x] = v & 255;
+    }
+  }
+  return { width, height, pixels };
+}
+
+// src/archive/page-renderer.ts
+var PAGE_SIZE = 1568;
+var CELL_W = GLYPH_W;
+var CELL_H = 10;
+var COLS = Math.floor(PAGE_SIZE / CELL_W);
+var ROWS = Math.floor(PAGE_SIZE / CELL_H);
+var CHARS_PER_PAGE = COLS * ROWS;
+var BG = 255;
+var FG = 0;
+function sanitizeForGrid(text) {
+  const out = [];
+  for (const ch of text.replace(/\r\n/g, "\n").replace(/\r/g, "\n")) {
+    const code = ch.codePointAt(0);
+    if (ch === "\n") {
+      out.push("\n");
+    } else if (ch === "	") {
+      out.push("\\t");
+    } else if (code >= 32 && code <= 126) {
+      out.push(ch);
+    } else if (code <= 65535) {
+      out.push("\\u" + code.toString(16).padStart(4, "0"));
+    } else {
+      out.push("\\u{" + code.toString(16) + "}");
+    }
+  }
+  return out.join("");
+}
+function layoutRows(sanitized, cols = COLS) {
+  const rows = [];
+  let offset = 0;
+  for (const line of sanitized.split("\n")) {
+    if (line.length === 0) {
+      rows.push({ text: " ".repeat(cols), charStart: offset });
+    } else {
+      for (let i = 0; i < line.length; i += cols) {
+        const slice = line.slice(i, i + cols);
+        rows.push({ text: slice.padEnd(cols, " "), charStart: offset + i });
+      }
+    }
+    offset += line.length + 1;
+  }
+  return rows;
+}
+function renderPage(pageRows, cols = COLS, rows = ROWS) {
+  const rowCount = Math.max(1, Math.min(pageRows.length, rows));
+  const width = cols * CELL_W;
+  const height = rowCount * CELL_H;
+  const pixels = Buffer.alloc(width * height, BG);
+  for (let r = 0; r < Math.min(pageRows.length, rowCount); r++) {
+    const row = pageRows[r];
+    for (let c = 0; c < cols; c++) {
+      const glyph = glyphRows(row.text.charCodeAt(c));
+      if (!glyph)
+        continue;
+      const px = c * CELL_W;
+      const py = r * CELL_H;
+      for (let gy = 0; gy < GLYPH_H; gy++) {
+        const bits = glyph[gy];
+        if (bits === 0)
+          continue;
+        const base = (py + gy) * width + px;
+        for (let gx = 0; gx < GLYPH_W; gx++) {
+          if (bits & 1 << gx)
+            pixels[base + gx] = FG;
+        }
+      }
+    }
+  }
+  const img = { width, height, pixels };
+  const charStart = pageRows.length ? pageRows[0].charStart : 0;
+  const last = pageRows[pageRows.length - 1];
+  const charEnd = last ? last.charStart + last.text.trimEnd().length : charStart;
+  return {
+    png: encodePng(img),
+    gridText: pageRows.map((r) => r.text).join("\n"),
+    charStart,
+    charEnd
+  };
+}
+function paginate(rowsIn, rowsPerPage = ROWS) {
+  const pages = [];
+  for (let i = 0; i < rowsIn.length; i += rowsPerPage) {
+    pages.push(rowsIn.slice(i, i + rowsPerPage));
+  }
+  return pages;
+}
+function decodePageText(png, cols = COLS) {
+  const img = decodePng(png);
+  const rows = Math.floor(img.height / CELL_H);
+  const usableCols = Math.min(cols, Math.floor(img.width / CELL_W));
+  const lines = [];
+  for (let r = 0; r < rows; r++) {
+    const chars = [];
+    for (let c = 0; c < usableCols; c++) {
+      const bytes = [];
+      for (let gy = 0; gy < GLYPH_H; gy++) {
+        let b = 0;
+        const base = (r * CELL_H + gy) * img.width + c * CELL_W;
+        for (let gx = 0; gx < GLYPH_W; gx++) {
+          if (img.pixels[base + gx] < 128)
+            b |= 1 << gx;
+        }
+        bytes.push(b);
+      }
+      const code = codeForSignature(signatureForRows(bytes));
+      chars.push(code === null ? "\uFFFD" : String.fromCharCode(code));
+    }
+    lines.push(chars.join(""));
+  }
+  return lines.join("\n");
+}
+function verifyRoundTrip(page) {
+  const decoded = decodePageText(page.png);
+  if (decoded === page.gridText)
+    return null;
+  const a = page.gridText;
+  const b = decoded;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    if (a[i] !== b[i]) {
+      return `mismatch at char ${i}: rendered ${JSON.stringify(a[i])} decoded ${JSON.stringify(b[i])}`;
+    }
+  }
+  return `length mismatch: rendered ${a.length} decoded ${b.length}`;
+}
+
+// src/opencode-plugin-png.ts
+var CCR_MARKER_HASH_LEN2 = 16;
+function ccrPngMarker(hash) {
+  return `<<ccr:${hash.slice(0, CCR_MARKER_HASH_LEN2)}>>`;
+}
+var CCR_MARKER_RE2 = /<<ccr:/;
+var DEFAULT_THRESHOLD_CHARS = 4e5;
+var DEFAULT_MIN_PART_CHARS = 4e3;
+var DEFAULT_LIVE_TAIL_MESSAGES = 1;
+var DEFAULT_VISION_MODEL_SUBSTRINGS = [
+  "gpt-4o",
+  "gpt-4.1",
+  "gpt-4-turbo",
+  "gpt-5",
+  "o1",
+  "o3",
+  "o4",
+  "claude-3",
+  "claude-4",
+  "claude-opus",
+  "claude-sonnet",
+  "claude-haiku",
+  "claude-fable",
+  "gemini",
+  "llama-3.2-vision",
+  "llama-4",
+  "qwen2.5-vl",
+  "qwen2-vl",
+  "qwen3-vl",
+  "pixtral",
+  "mistral-small-3",
+  "grok-vision",
+  "grok-4",
+  "internvl",
+  "-vl",
+  "vision"
+];
+function inputModalities(modalities) {
+  if (!modalities)
+    return null;
+  if (Array.isArray(modalities))
+    return modalities.map((m) => String(m));
+  if (typeof modalities === "object" && Array.isArray(modalities.input)) {
+    return modalities.input.map((m) => String(m));
+  }
+  return null;
+}
+function isVisionCapable(opts) {
+  const mods = inputModalities(opts.modalities);
+  if (mods) {
+    return mods.some((m) => m.toLowerCase() === "image");
+  }
+  const id = (opts.modelId || "").toLowerCase();
+  if (!id)
+    return false;
+  const allow = [...DEFAULT_VISION_MODEL_SUBSTRINGS, ...opts.visionAllowlist || []];
+  return allow.some((sub) => sub && id.includes(String(sub).toLowerCase()));
+}
+function renderTextToImageParts(text, hash) {
+  const sanitized = sanitizeForGrid(text);
+  const pages = paginate(layoutRows(sanitized));
+  const parts = [];
+  let pngBytes = 0;
+  let selfTestError = null;
+  for (let i = 0; i < pages.length; i++) {
+    const rendered = renderPage(pages[i]);
+    const err = verifyRoundTrip(rendered);
+    if (err && !selfTestError)
+      selfTestError = `page ${i + 1}: ${err}`;
+    pngBytes += rendered.png.length;
+    parts.push({
+      type: "file",
+      mime: "image/png",
+      url: `data:image/png;base64,${rendered.png.toString("base64")}`,
+      filename: `greprag-png-${hash.slice(0, CCR_MARKER_HASH_LEN2)}-p${String(i + 1).padStart(3, "0")}.png`
+    });
+  }
+  return { parts, pages: pages.length, pngBytes, selfTestError };
+}
+function partsOf(msg) {
+  if (!msg || typeof msg !== "object")
+    return null;
+  const parts = msg.parts;
+  return Array.isArray(parts) ? parts : null;
+}
+function partCharLen(p) {
+  if (!p || typeof p !== "object")
+    return 0;
+  const part = p;
+  if (part.type === "text" && typeof part.text === "string")
+    return part.text.length;
+  if (part.type === "file" && typeof part.url === "string")
+    return part.url.length;
+  if (part.type === "tool" && part.state && typeof part.state === "object") {
+    const out = part.state.output;
+    if (typeof out === "string")
+      return out.length;
+  }
+  return 0;
+}
+function maybeRecodePart(p, minPartChars, stash) {
+  if (!p || typeof p !== "object")
+    return null;
+  const part = p;
+  if (part.type !== "text" || typeof part.text !== "string")
+    return null;
+  const text = part.text;
+  if (CCR_MARKER_RE2.test(text))
+    return null;
+  if (text.length < minPartChars)
+    return null;
+  const hash = stash(text);
+  const { parts: fileParts, pages, pngBytes, selfTestError } = renderTextToImageParts(text, hash);
+  const breadcrumb = {
+    type: "text",
+    text: `[greprag-png-recode: ${pages} page(s) of prior history rendered as pixel-text image(s) above; verbatim original ${ccrPngMarker(hash)} (greprag retrieve ${hash.slice(0, CCR_MARKER_HASH_LEN2)})]`
+  };
+  return { fileParts, breadcrumb, pages, pngBytes, selfTestError };
+}
+function recodeMessagesToPng(messages, opts) {
+  const thresholdChars = opts.thresholdChars ?? DEFAULT_THRESHOLD_CHARS;
+  const minPartChars = opts.minPartChars ?? DEFAULT_MIN_PART_CHARS;
+  const liveTail = opts.liveTailMessages ?? DEFAULT_LIVE_TAIL_MESSAGES;
+  const stats = {
+    fired: false,
+    visionCapable: false,
+    totalChars: 0,
+    thresholdChars,
+    partsRecoded: 0,
+    pagesRendered: 0,
+    pngBytes: 0,
+    selfTestError: null,
+    reason: ""
+  };
+  if (!Array.isArray(messages)) {
+    stats.reason = "messages not an array";
+    return stats;
+  }
+  for (const msg of messages) {
+    const parts = partsOf(msg);
+    if (!parts)
+      continue;
+    for (const p of parts)
+      stats.totalChars += partCharLen(p);
+  }
+  const vision = isVisionCapable(opts);
+  stats.visionCapable = vision;
+  if (!vision) {
+    stats.reason = `model not vision-capable (modelId=${opts.modelId || "?"}) \u2014 pass-through`;
+    return stats;
+  }
+  if (stats.totalChars < thresholdChars) {
+    stats.reason = `below threshold (${stats.totalChars} < ${thresholdChars} chars)`;
+    return stats;
+  }
+  const lastRecodableIdx = Math.max(0, messages.length - Math.max(0, liveTail));
+  for (let mi = 0; mi < lastRecodableIdx; mi++) {
+    const msg = messages[mi];
+    const parts = partsOf(msg);
+    if (!parts)
+      continue;
+    let changed = false;
+    const newParts = [];
+    for (const p of parts) {
+      let rec = null;
+      try {
+        rec = maybeRecodePart(p, minPartChars, opts.stash);
+      } catch {
+        rec = null;
+      }
+      if (rec) {
+        newParts.push(...rec.fileParts, rec.breadcrumb);
+        changed = true;
+        stats.partsRecoded++;
+        stats.pagesRendered += rec.pages;
+        stats.pngBytes += rec.pngBytes;
+        if (rec.selfTestError && !stats.selfTestError)
+          stats.selfTestError = rec.selfTestError;
+      } else {
+        newParts.push(p);
+      }
+    }
+    if (changed)
+      msg.parts = newParts;
+  }
+  stats.fired = stats.partsRecoded > 0;
+  stats.reason = stats.fired ? `recoded ${stats.partsRecoded} part(s) -> ${stats.pagesRendered} page(s), ${stats.pngBytes} png bytes` : "threshold crossed but no recodable text parts (all below per-part floor or already marked)";
+  return stats;
+}
+
 // src/opencode-plugin.ts
 var DEBUG_LOG_PATH = path3.join(os.homedir(), ".greprag", "opencode-plugin-debug.log");
 var _debugLogReady = false;
@@ -2748,11 +3331,11 @@ function startCaptureWatcher() {
       fs3.writeFileSync(WATCHER_LOCK, String(child.pid));
     } catch {
     }
-    child.stderr?.on("data", (chunk) => {
-      process.stderr.write(`[greprag-watch] ${chunk.toString("utf-8")}`);
+    child.stderr?.on("data", (chunk2) => {
+      process.stderr.write(`[greprag-watch] ${chunk2.toString("utf-8")}`);
     });
-    child.stdout?.on("data", (chunk) => {
-      process.stderr.write(`[greprag-watch] ${chunk.toString("utf-8")}`);
+    child.stdout?.on("data", (chunk2) => {
+      process.stderr.write(`[greprag-watch] ${chunk2.toString("utf-8")}`);
     });
     child.on("exit", (code, signal) => {
       dlog(`startCaptureWatcher: child pid=${child.pid ?? "<none>"} exited code=${code} signal=${signal || "none"}`);
@@ -2957,11 +3540,11 @@ function startSessionRelay(sessionId, serverUrl) {
       fs3.writeFileSync(lockPath, String(child.pid));
     } catch {
     }
-    child.stderr?.on("data", (chunk) => {
-      process.stderr.write(`[greprag-relay] ${chunk.toString("utf-8")}`);
+    child.stderr?.on("data", (chunk2) => {
+      process.stderr.write(`[greprag-relay] ${chunk2.toString("utf-8")}`);
     });
-    child.stdout?.on("data", (chunk) => {
-      process.stderr.write(`[greprag-relay] ${chunk.toString("utf-8")}`);
+    child.stdout?.on("data", (chunk2) => {
+      process.stderr.write(`[greprag-relay] ${chunk2.toString("utf-8")}`);
     });
     child.on("exit", (code, signal) => {
       try {
@@ -3051,6 +3634,39 @@ function inlineCrushEnabled() {
   const v = process.env.GREPRAG_OPENCODE_CRUSH;
   return v === "true" || v === "1";
 }
+function pngRecodeEnabled() {
+  const v = process.env.GREPRAG_OPENCODE_PNG;
+  return v === "true" || v === "1";
+}
+function intEnv(name, allowZero = false) {
+  const n = parseInt(process.env[name] || "", 10);
+  if (!Number.isFinite(n))
+    return void 0;
+  return n > 0 || allowZero && n === 0 ? n : void 0;
+}
+function runPngRecode(input, msgs) {
+  const model = input?.model;
+  const modelId = model?.modelID || model?.id || model?.name || null;
+  const modalities = model?.modalities || model?.info?.modalities || null;
+  const allowEnv = (process.env.GREPRAG_OPENCODE_PNG_VISION_MODELS || "").split(",").map((s) => s.trim()).filter(Boolean);
+  const stash = makeCcrStash();
+  const stats = recodeMessagesToPng(msgs, {
+    stash: (original) => stash(original, "log"),
+    modelId,
+    modalities,
+    thresholdChars: intEnv("GREPRAG_OPENCODE_PNG_THRESHOLD"),
+    minPartChars: intEnv("GREPRAG_OPENCODE_PNG_MIN_PART"),
+    liveTailMessages: intEnv("GREPRAG_OPENCODE_PNG_TAIL", true),
+    visionAllowlist: allowEnv.length ? allowEnv : void 0
+  });
+  if (stats.partsRecoded > 0) {
+    dlog(
+      `messages.transform png: recoded=${stats.partsRecoded} pages=${stats.pagesRendered} pngBytes=${stats.pngBytes} totalChars=${stats.totalChars} vision=${stats.visionCapable}` + (stats.selfTestError ? ` selfTestError=${stats.selfTestError}` : "")
+    );
+  } else {
+    dlog(`messages.transform png: no-op (${stats.reason})`);
+  }
+}
 function makeCcrStash() {
   return (original, sourceType) => {
     const hash = crypto2.createHash("sha256").update(original, "utf8").digest("hex").slice(0, 16);
@@ -3189,7 +3805,16 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
     // Contract: we mutate ONLY this request-scoped `output.messages` copy,
     // never opencode's persisted session history. adr:
     // adr/opencode-context-compressor.md
-    "experimental.chat.messages.transform": async (_input, output) => {
+    "experimental.chat.messages.transform": async (input, output) => {
+      try {
+        if (pngRecodeEnabled()) {
+          const msgs0 = output && output.messages;
+          if (Array.isArray(msgs0))
+            runPngRecode(input, msgs0);
+        }
+      } catch (e) {
+        dlog(`messages.transform png: swallowed error (turn unaffected): ${e.message}`);
+      }
       try {
         if (!inlineCrushEnabled())
           return;