greprag 5.61.1 → 5.63.0

package/dist/opencode-plugin.bundle.js

@@ -1747,7 +1747,7 @@ function crushMessages(messages, opts) {
 
 // src/commands/os-primer-reminder.ts
 function buildOsPrimer(env) {
-  const spawnEntry = env?.platform === "codex" ? "codex-chip-spawn" : "chip-spawn";
+  const spawnEntry = env?.platform === "codex" ? "codex-chip-spawn" : env?.platform === "opencode" ? "chip-bootloader" : "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.',
@@ -1776,14 +1776,18 @@ function armMonitorCommand(short, ownerPid, assistant = false, mechanic = false)
 // src/commands/inbox-primer-reminder.ts
 function buildInboxPrimer(env) {
   const codex = env.platform === "codex";
+  const opencode = env.platform === "opencode";
   const arm = armMonitorCommand(env.short, env.ownerPid, env.assistant, env.mechanic);
   return [
     // LEAD — the forcing function (restored 2026-06-22). ARM is an ALARM, not reference:
     // you are unreachable until you do it, and it must be re-done every time the watcher
     // drops. It leads the announce and is loud by design — folding it into a buried bullet
     // (v5.49.6) softened it into banner-blindness (fix 16a29a8b's failure mode).
-    codex ? "[CODEX INBOX \u2014 greprag is your agent-to-agent mesh. Codex-to-Codex: use native task messaging. Reaching ANY non-Codex peer (Claude Code / opencode / another tenant's agent): `greprag send` IS the live primary path \u2014 native Codex messaging cannot reach them.]" : "[\u26A0 ARM YOUR INBOX WATCHER NOW \u2014 you are UNREACHABLE until you do. Peers are live in your mesh trying to coordinate with this session, and the operator can DM you \u2014 but they reach you ONLY while armed. Unarmed, you are invisible and their messages silently pile up. The watcher can DROP ANYTIME (crash / reload / OOM) \u2014 EVERY turn you are flagged unarmed you MUST re-arm, or coordination breaks.]",
-    codex ? "CODEX: Native task/thread messaging is the normal live Codex-to-Codex path. Install the GrepRAG startup watcher with `greprag init --codex --tenant-id <handle> --install-watcher` or `greprag codex startup install` \u2014 it is how messages from non-Codex peers (Claude Code / opencode) reach you; without it they pile up unread. Turn hooks are boundary fallback: if hooks exist but do not fire, open Codex Desktop Settings -> Settings -> Hooks, trust the GrepRAG commands, and start a fresh Codex session. Then drain what is waiting: `greprag inbox`." : `ARM: Monitor is a deferred tool \u2014 \`ToolSearch select:Monitor\`, then call Monitor with persistent:true, timeout_ms:3600000, description:"greprag inbox ${env.short}", command: \`${arm}\`. The \`--session ${env.short}\` is REQUIRED \u2014 a bare \`greprag inbox watch\` writes no pidfile, so the arm-check reads you unarmed forever. NEVER run it bare also because it is a foreground stream and hangs the turn. Then drain what is waiting: \`greprag inbox\`.`,
+    // opencode gets NO alarm: its relay self-arms in the plugin (startSessionRelay) —
+    // "ToolSearch select:Monitor" is unactionable there (neither tool exists) and an
+    // un-followable alarm decays into banner-blindness for the announces around it.
+    codex ? "[CODEX INBOX \u2014 greprag is your agent-to-agent mesh. Codex-to-Codex: use native task messaging. Reaching ANY non-Codex peer (Claude Code / opencode / another tenant's agent): `greprag send` IS the live primary path \u2014 native Codex messaging cannot reach them.]" : opencode ? "[OPENCODE INBOX \u2014 greprag is your agent-to-agent mesh. Inbound delivery is AUTOMATIC here: the greprag plugin arms a relay for this session (nothing to arm or re-arm) and inbound peer messages arrive as injected turns.]" : "[\u26A0 ARM YOUR INBOX WATCHER NOW \u2014 you are UNREACHABLE until you do. Peers are live in your mesh trying to coordinate with this session, and the operator can DM you \u2014 but they reach you ONLY while armed. Unarmed, you are invisible and their messages silently pile up. The watcher can DROP ANYTIME (crash / reload / OOM) \u2014 EVERY turn you are flagged unarmed you MUST re-arm, or coordination breaks.]",
+    codex ? "CODEX: Native task/thread messaging is the normal live Codex-to-Codex path. Install the GrepRAG startup watcher with `greprag init --codex --tenant-id <handle> --install-watcher` or `greprag codex startup install` \u2014 it is how messages from non-Codex peers (Claude Code / opencode) reach you; without it they pile up unread. Turn hooks are boundary fallback: if hooks exist but do not fire, open Codex Desktop Settings -> Settings -> Hooks, trust the GrepRAG commands, and start a fresh Codex session. Then drain what is waiting: `greprag inbox`." : opencode ? "DELIVERY: the relay arms itself on this session's first turn and injects inbound messages as they land \u2014 treat an injected `Message from <handle> (session <8hex>):` turn as async peer mail, not the operator typing. Drain anything already waiting: `greprag inbox`." : `ARM: Monitor is a deferred tool \u2014 \`ToolSearch select:Monitor\`, then call Monitor with persistent:true, timeout_ms:3600000, description:"greprag inbox ${env.short}", command: \`${arm}\`. The \`--session ${env.short}\` is REQUIRED \u2014 a bare \`greprag inbox watch\` writes no pidfile, so the arm-check reads you unarmed forever. NEVER run it bare also because it is a foreground stream and hangs the turn. Then drain what is waiting: \`greprag inbox\`.`,
     "",
     // The facts + directives — a flat list (no MODEL/RULES scaffolding; the labels were
     // human doc-structure, dead weight to an agent). Everything that helps the agent DECIDE
@@ -1818,6 +1822,10 @@ var CHIP_SPAWN_POINTER = [
   "[greprag chips \u2014 agent coordination is built in (messaging plumbing in the inbox primer).]",
   "\u2022 About to spawn a chip (`spawn_task`)? \u2192 run `greprag load chip-spawn` FIRST for the method (Block 1 worktree + Block 2 report-back); it carries the multi-chip upgrade path inline. Non-negotiable \u2014 the spawn validator rejects an unstructured chip."
 ].join("\n");
+var OPENCODE_CHIP_SPAWN_POINTER = [
+  "[greprag chips \u2014 agent coordination is built in (messaging plumbing in the inbox primer).]",
+  "\u2022 Delegating a component of a plan to an isolated chip session, or `greprag fix spawn` just printed a FIX-chip mission? \u2192 run `greprag load chip-bootloader` FIRST for the method: OpenCode chips spawn natively via `greprag opencode chip goal create` + `greprag opencode chip spawn` (HTTP child session; manual paste only when the API is down). \u22652 chips at one objective \u2192 `greprag load chip-leader-opencode` BEFORE the first spawn."
+].join("\n");
 var CODEX_CHIP_SPAWN_POINTER = [
   "[greprag Codex delegation \u2014 internal subagent, 1\u20132-chip quick path with the initiator as LEAD, or a separate LEAD for larger/seamed missions.]",
   "\u2022 About to delegate a Codex task? \u2192 run `greprag load codex-chip-spawn` FIRST. Use exact first-line titles `LEAD: <Mission>` and `Chip A/B/C: <Specific Purview>`. Chips are ordinary writable native tasks; completion is a native Codex task reply to the LEAD after committing. A `MECHANIC: <Mission>` task loads `greprag load mechanic` first."
@@ -1833,7 +1841,18 @@ var chipSpawnPointerModule = {
   // Says "greprag load chip-spawn" → the agent must already know the loader exists.
   dependsOn: ["load-primer"],
   detect: (_env) => ({ tier: "silent" }),
-  announce: (env) => env.platform === "codex" ? null : CHIP_SPAWN_POINTER,
+  // Per-platform payload, ONE module: codex has its own sibling module below;
+  // opencode gets the native HTTP-spawn pointer (spawn_task doesn't exist there);
+  // claude-code keeps the spawn_task pointer. Gating INSIDE the module (not a
+  // per-harness registry fork) is what lets harnessModules() stay a pure
+  // exclusion filter.
+  announce: (env) => {
+    if (env.platform === "codex")
+      return null;
+    if (env.platform === "opencode")
+      return OPENCODE_CHIP_SPAWN_POINTER;
+    return CHIP_SPAWN_POINTER;
+  },
   reminder: () => null
 };
 var codexChipSpawnPointerModule = {
@@ -1969,6 +1988,11 @@ function buildArmReminder(d, env) {
 }
 var watcherArmModule = {
   id: "watcher-arm",
+  // The arm poke rides Claude Code's Monitor tool (ToolSearch select:Monitor); codex
+  // keeps its historical full-registry behavior. opencode is EXCLUDED: its inbox
+  // delivery is the plugin-armed relay (startSessionRelay), so "arm your Monitor"
+  // is unactionable noise there.
+  harnesses: ["claude-code", "codex"],
   detect: armDetect,
   announce: () => null,
   reminder: (d, env) => buildArmReminder(d, env)
@@ -2298,6 +2322,7 @@ var REGISTRY = [
   collisionMatchModule
   // source: 'command' — evaluated at PreToolUse, not UserPromptSubmit
 ];
+var harnessModules = (harness, registry = REGISTRY) => registry.filter((m) => !m.harnesses || m.harnesses.includes(harness));
 function collectReminders(env, registry = REGISTRY) {
   const out = [];
   for (const m of registry) {
@@ -2358,26 +2383,22 @@ function collectAnnounces(env, registry = REGISTRY) {
 }
 
 // src/commands/opencode-interrupt.ts
-var OPENCODE_MODULE_IDS = /* @__PURE__ */ new Set([
-  "inbox-primer",
-  "load-primer",
-  "corpus-announce",
-  "setup-warning",
-  "version-upgrade",
-  "memory-primer",
-  "procedure-announce",
-  "collision"
-]);
-var opencodeRegistry = REGISTRY.filter(
-  (m) => OPENCODE_MODULE_IDS.has(m.id)
-);
+var opencodeRegistry = harnessModules("opencode");
 function buildOpenCodeEnv(params) {
   return {
     short: params.short,
     turnCount: params.turnCount,
+    // No opencode-native friction detector is wired yet: Claude Code's stress /
+    // bootstrap-friction signals come from state-trigger.ts reading the
+    // transcript in hook.ts, and opencode has no equivalent source plumbed.
+    // 0 = calm keeps the mechanic-friction REMINDER silent while its ANNOUNCE
+    // (the fix-spawn doctrine) still lands every session. Detector design is
+    // parked with scored options in the chip report
+    // (chip/opencode-fix-chip-system-parity).
     stress: 0,
-    armed: false,
+    armed: params.armed ?? false,
     sessionUnread: 0,
+    platform: "opencode",
     projectName: params.projectName,
     setupWarning: params.setupWarning ?? null,
     corpusApiDocs: params.corpusApiDocs ?? [],
@@ -2385,9 +2406,8 @@ function buildOpenCodeEnv(params) {
     procedureAnnounces: params.procedureAnnounces ?? []
   };
 }
-var OPENCODE_CHIP_BOOTLOADER_POINTER = '[greprag chips \u2014 agent coordination is built in (messaging plumbing in the inbox primer).]\n\u2022 Delegating a component of a plan to an isolated sub-session (a "chip") for focused, efficient work? \u2192 run `greprag load chip-bootloader` for the copyable bootloader template (Block 1 setup + Block 2 report-back).';
 function getOpenCodeAnnounces(env) {
-  return [...collectAnnounces(env, opencodeRegistry), OPENCODE_CHIP_BOOTLOADER_POINTER];
+  return collectAnnounces(env, opencodeRegistry);
 }
 function getOpenCodeReminders(env) {
   return collectReminders(env, opencodeRegistry);
@@ -2501,6 +2521,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;
@@ -2749,11 +3351,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"}`);
@@ -2958,11 +3560,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 {
@@ -3052,6 +3654,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);
@@ -3147,6 +3782,13 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
         );
         dlog(`pushed session-id awareness for sid=${sid82}`);
       }
+      if (inlineCrushEnabled()) {
+        pushSystemPrompt(
+          output,
+          "Context compression: when you see a `<<ccr:HASH>>` marker, the text immediately before it was losslessly compressed to save tokens. To recover the original verbatim, run `greprag retrieve <HASH>` in your shell (HASH = the 16 hex chars in the marker). Retrieve only when you actually need the elided detail."
+        );
+        dlog(`pushed CCR retrieve instruction for sid=${sidShort}`);
+      }
       const sid8 = sid && sidShort && sidShort !== "<none>" ? sidShort : sid ? sid.slice(0, 8) : "";
       if (sid8) {
         const turnCount = (turnCountBySession.get(sid8) ?? 0) + 1;
@@ -3155,6 +3797,9 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
           short: sid8,
           turnCount,
           projectName: anchor.projectName,
+          // The relay IS opencode's watcher: armed the moment startSessionRelay
+          // committed the arm for this session (earlier in this same fire).
+          armed: sid ? relayArmedBySession.has(sid) : false,
           procedureAnnounces: (() => {
             try {
               return activeProcedureAnnounces(readProcedureStore(anchor.projectId));
@@ -3190,7 +3835,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;