@ask-llm/plugin 0.13.0

package/scripts/lib/stop-gate.mjs

@@ -0,0 +1,134 @@
+// scripts/lib/stop-gate.mjs
+// Pure, I/O-free gate logic for the codex-pair Stop hook (#142, ADR-118).
+// No workspace imports — the hook ships without node_modules.
+
+import { isAbsolute, join, relative } from "node:path";
+import { hashConcernBody } from "./state.mjs";
+
+// Parse `git status --porcelain=v1 -z` into a Set of ABSOLUTE paths that are
+// modified or untracked relative to HEAD. repoRoot = `git rev-parse
+// --show-toplevel`. NUL mode disables git's C-style path quoting and reverses
+// rename fields: the first record is the destination path, followed by a second
+// source-path record. Only the destination is dirty on disk.
+export function parseGitPorcelain(stdout, repoRoot) {
+  const dirty = new Set();
+  const records = stdout.split("\0");
+  for (let i = 0; i < records.length; i++) {
+    const record = records[i];
+    if (record.length < 4) continue;
+    const status = record.slice(0, 2);
+    const path = record.slice(3);
+    dirty.add(isAbsolute(path) ? path : join(repoRoot, path));
+    // In -z mode, rename/copy source paths are the next bare NUL record.
+    if (status.includes("R") || status.includes("C")) i++;
+  }
+  return dirty;
+}
+
+// Verdicts that don't carry a trustworthy final-state review. `skipped`/`error`
+// carry a `file` field, so they can be a file's latest entry → [C] fail-opens on
+// them. `retried`/`broker_fallback` are logged WITHOUT a `file` (transient
+// per-attempt markers), so selectLatestEntries already excludes them and the
+// file's true latest review (concerns/none/cached) is used — they're listed here
+// for completeness/future-proofing, not because they're currently reachable.
+const INDETERMINATE = new Set(["skipped", "error", "retried", "broker_fallback"]);
+
+// Reconcile latest-per-file entries against present reality, returning the
+// unacked HIGH findings that should block turn-end.
+//   entries   Map<file, latestEntry>      (from selectLatestEntries)
+//   acks      { [hash]: {reason, ts} }     (from readAcks)
+//   existsFn  (absFile) => boolean         (injected fs.existsSync)
+//   gitDirty  Set<absPath> | null          (null = no git filter)
+//   markerDir project root for relPath ack identity
+export function collectBlockingHighs({ entries, acks, existsFn, gitDirty, markerDir }) {
+  const blocking = [];
+  for (const [file, entry] of entries) {
+    if (!existsFn(file)) continue; // [A] deleted/renamed
+    if (INDETERMINATE.has(entry.verdict)) continue; // [C] indeterminate latest → fail-open
+    if (gitDirty && !gitDirty.has(file)) continue; // [B] clean vs HEAD
+    const highs = Array.isArray(entry.concerns?.high) ? entry.concerns.high : [];
+    for (const text of highs) {
+      const hash = hashConcernBody(`${relative(markerDir, file)}:${text}`); // [E] file-scoped
+      if (!acks[hash]) blocking.push({ file, text, hash });
+    }
+  }
+  return blocking;
+}
+
+// Build the Stop-hook block reason. Short hashes (first 6) are the ack ids.
+export function formatBlockMessage(blocking, markerDir) {
+  const lines = blocking.map((b) => {
+    const rel = relative(markerDir, b.file);
+    return `  [${b.hash}] ${rel}\n    ${b.text}`;
+  });
+  return (
+    `🚫 codex-pair: ${blocking.length} unaddressed HIGH finding(s) (blockOn: HIGH). ` +
+    `Fix them, or defer each with /codex-pair-ack.\n\n` +
+    `${lines.join("\n")}\n\n` +
+    `To defer a finding (stale / pre-existing / out-of-scope), run /codex-pair-ack with its [hash] from the list above — e.g.:\n` +
+    `  /codex-pair-ack ${blocking[0].hash} "<reason>"\n` +
+    `(If you fixed a finding by editing a DIFFERENT file, make a real edit to the ` +
+    `flagged file so it gets re-reviewed — an identical re-touch hits the review cache.)`
+  );
+}
+
+// In-flight review detection (2026-07-02 seamless-pairing design). A turn can
+// end while a debounce worker is still settling (record.reviewedGen <
+// record.generation) or a codex call is mid-review (fresh inflight lock) —
+// the log-based gate would pass and the verdict would land after "done".
+// Pure over pre-read inputs; the script does the I/O.
+//   records    parsed debounce-record JSONs (malformed entries tolerated)
+//   lockMtimes mtimeMs of files under state/inflight/
+//   now        clock
+//   freshMs    lock age beyond which a lock is crash junk, not a live review
+//   staleMs    burst age beyond which an unconsumed record is a crashed
+//              worker's orphan (sweepStaleDebounce fodder), not a live settle
+export function collectInFlight({ records, lockMtimes, now, freshMs, staleMs = 600_000 }) {
+  const settling = [];
+  for (const r of records) {
+    if (!r || typeof r !== "object" || typeof r.file !== "string") continue;
+    if (!(typeof r.generation === "number" && typeof r.reviewedGen === "number")) continue;
+    if (r.reviewedGen >= r.generation) continue;
+    if (Number.isFinite(r.burstStartedAt) && now - r.burstStartedAt > staleMs) continue;
+    settling.push(r.file);
+  }
+  const reviewing = lockMtimes.filter((m) => Number.isFinite(m) && now - m < freshMs).length;
+  return { settling, reviewing, any: settling.length > 0 || reviewing > 0 };
+}
+
+// Block reason for the in-flight case: tell Claude HOW to wait productively
+// instead of just refusing the stop.
+const MAX_SETTLING_LISTED = 5;
+export function formatInFlightMessage({ settling, reviewing }, markerDir) {
+  const parts = [];
+  if (settling.length > 0) {
+    const listed = settling.slice(0, MAX_SETTLING_LISTED).map((f) => relative(markerDir, f));
+    const extra = settling.length > MAX_SETTLING_LISTED ? ` (+${settling.length - MAX_SETTLING_LISTED} more)` : "";
+    parts.push(`${settling.length} edited file(s) awaiting review: ${listed.join(", ")}${extra}`);
+  }
+  if (reviewing > 0) parts.push(`${reviewing} review(s) running`);
+  return (
+    `⏳ codex-pair: review(s) still in flight — ${parts.join("; ")}. ` +
+    `Verdicts land in ${join(markerDir, ".codex-pair", "log.jsonl")}. ` +
+    `Wait for them (e.g. \`sleep 45\`), read the newest entries for the files you edited, ` +
+    `address any HIGH findings, then end the turn.`
+  );
+}
+
+// Parse log.jsonl text → Map<file, latestEntry>. Last write per file wins
+// (the log is append-only; the final entry is the file's latest review).
+export function selectLatestEntries(logText) {
+  const latest = new Map();
+  for (const line of logText.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    let entry;
+    try {
+      entry = JSON.parse(t);
+    } catch {
+      continue;
+    }
+    if (entry && typeof entry.file === "string") latest.set(entry.file, entry);
+  }
+  return latest;
+}

package/skills/antigravity-review/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: antigravity-review
+description: Get a second opinion from Google Antigravity (agy) on your current code changes. Analyzes staged/unstaged diffs and returns prioritized findings. Use when the user asks to "review with Antigravity", "Antigravity code review", or "ask agy to check my code".
+---
+
+<!-- PORTABLE-CONTRACT:START -->
+## Portable contract
+
+Gather the relevant staged, unstaged, and untracked code changes; build a bounded context brief; request an Antigravity review; verify each reported finding against source; and return only prioritized, source-supported findings. Preserve read-only intent, provider authentication errors, timeout behavior, and explicit failure disclosure.
+<!-- PORTABLE-CONTRACT:END -->
+
+## Host adapters
+
+### Pi adapter
+
+Call the native `ask-antigravity` tool and apply only the `Portable contract` section of `../../agents/antigravity-reviewer.md`; ignore that file's frontmatter and Claude Code adapter.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:START -->
+### Claude Code adapter
+
+The existing detailed workflow below is the Claude Code adapter. Its Agent, MCP, hook, `CLAUDE_PLUGIN_ROOT`, and `AskUserQuestion` mechanics apply only on Claude Code; they do not override the Pi adapter above.
+
+
+
+# Antigravity Code Review
+
+Review current code changes by delegating to the `antigravity-reviewer` agent — a subscription-backed second opinion via Google's Antigravity CLI (`agy`).
+
+## Prerequisites
+
+This skill is **experimental** and requires:
+
+- `agy` installed and **logged in once** (run `agy` interactively to complete Google Sign-In).
+- The Antigravity MCP server registered, e.g. `claude mcp add antigravity -- npx -y @ask-llm/antigravity-mcp`.
+
+It is one-shot (no multi-turn) and **subscription-backed** — it uses your Google AI Pro/Ultra plan, not per-token API billing. For routine review on a paid OpenAI/Gemini setup, prefer [`codex-review`](../codex-review/SKILL.md) or [`gemini-review`](../gemini-review/SKILL.md). To compare several providers at once, use [`multi-review`](../multi-review/SKILL.md).
+
+## Instructions
+
+1. Gather the diff to review:
+   - Run `git diff` to get unstaged changes
+   - Run `git diff --cached` to get staged changes
+   - Combine both into a single diff
+
+2. If the diff is empty, inform the user there are no changes to review.
+
+3. Launch the `antigravity-reviewer` agent with the diff content. The agent handles the Antigravity prompt structure, confidence filtering, and output formatting. If the `mcp__antigravity__ask-antigravity` tool is unavailable, the agent will tell the user to register the Antigravity MCP server rather than failing silently.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/skills/brainstorm/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: brainstorm
+description: Send a topic to multiple LLM providers concurrently after the current host model forms an independent view, then synthesize all findings. Usage /brainstorm [providers] <topic>. External providers default to antigravity,codex. Example /brainstorm antigravity,codex,ollama "review this architecture"
+---
+
+<!-- PORTABLE-CONTRACT:START -->
+## Portable contract
+
+The current host model must form and record an independent analysis before seeing external answers. Then send the same bounded topic and Context Brief concurrently to the selected providers, cross-check claims against source where possible, and synthesize consensus, unique insights, contradictions, rejected false positives, and confidence. Report the actual host model/providers and disclose possible same-family overlap.
+<!-- PORTABLE-CONTRACT:END -->
+
+## Host adapters
+
+### Pi adapter
+
+The current Pi host model completes its independent view first, records its actual provider/model, and only then calls native `ask-multi`. Do not claim the host is Claude Opus or that the coordinator has an isolated context.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:START -->
+### Claude Code adapter
+
+The existing detailed workflow below is the Claude Code adapter. Its Agent, MCP, hook, `CLAUDE_PLUGIN_ROOT`, and `AskUserQuestion` mechanics apply only on Claude Code; they do not override the Pi adapter above.
+
+
+
+# Multi-LLM Brainstorm
+
+Consult multiple external LLM providers simultaneously on a topic while Claude Opus performs its own independent research in parallel, then synthesize the findings from all participants.
+
+## Instructions
+
+### Phase 1: Parse arguments
+
+- If the first argument looks like a comma-separated provider list (e.g., `antigravity,codex` or `gemini,codex,ollama`), use those as the external providers
+- If no provider list is given, default to `antigravity,codex`
+- Valid external providers: `gemini`, `codex`, `ollama`, `antigravity`
+- `antigravity` requires `agy` installed + logged in; if it's unavailable the coordinator surfaces that and continues with the other providers
+- Everything after the provider list (or all args if no list) is the topic
+- Claude Opus is always a participant — it's not in the provider list because it runs inside the coordinator
+
+### Phase 2: Determine and prepare the brainstorm topic
+
+- If the user provided a topic directly, use it
+- If the context is about code changes, gather the relevant diff:
+  - `git status --short` first to see what's modified/added/deleted
+  - `git add -N <new-files>` for untracked files the user wants included
+  - `git diff` + `git diff --cached` combined
+  - **Filter noise**: exclude `:!docs/` `:!apps/docs/` `:!*.md` `:!yarn.lock` `:!*.lock` `:!*.png` from the pathspec — providers don't need to review your ADR/doc additions
+  - **Size-check**: if combined diff > 150KB, ask the user before sending (the providers will take 5–15 min on payloads that large)
+- If the context is a design/plan, gather the relevant documentation or conversation context
+- If no topic is clear, ask the user what they'd like to brainstorm about
+- Create a compact **Context Brief** before launching the coordinator. Keep it tiny for simple topics; add detail when the request is architecture/design/security/concurrency/migration related, spans packages, references external specs, or depends on conversation context external providers cannot see.
+
+```markdown
+## Context Brief
+
+Intent:
+- User request:
+- Brainstorm mode:
+- Providers: <list the selected providers for this run>
+
+Scope:
+- Changed/referenced files:
+- Included files/docs:
+- Excluded files/docs and reason:
+- Diff bytes:
+
+Repository signals:
+- Relevant package/workspace:
+- CLAUDE.md files read:
+- ADRs/docs read:
+
+Risk focus:
+- Security:
+- Data loss:
+- Concurrency/state:
+- API/contract:
+- Tests/build:
+
+Open questions:
+- Items not verified before dispatch:
+```
+
+### Phase 3: Launch the brainstorm-coordinator agent
+
+Launch with: the topic, the selected external providers list, the Context Brief, and any gathered context (diff/files/docs).
+
+The coordinator handles:
+- Phase 3B: its own Claude Opus research (reads actual files, traces code, uses WebFetch/WebSearch on referenced external docs) — runs FIRST so Claude doesn't anchor on external responses
+- Context Brief update: after Phase 3B, records verified files/docs and unverified assumptions before external dispatch
+- Phase 3A: external provider dispatch via a single blocking foreground Bash call (ADR-050 dispatch pattern)
+- Phase 4: synthesis — consensus, unique insights, contradictions across all participants
+- Verified findings (backed by Claude's file reads) are weighted higher than inferred ones
+- Failed providers are surfaced inline with their stderr, not silently dropped
+
+### Phase 4: Present the coordinator's synthesis
+
+Pass through the coordinator's structured output. If the coordinator returned a partial result (some providers failed), present what landed and explicitly note what's missing — don't paraphrase or hide compromises.
+
+## Important — verification matters
+
+Confidence scores are not an oracle. The coordinator's Phase 3B exists specifically because external LLMs can return high-confidence findings that turn out to be factually wrong (a real example from 2026-04-17: Gemini returned 95/100-confidence claims that were contradicted by the actual `.d.ts` file). Claude's "Verified" findings carry more weight than external "Inferred" findings precisely for this reason.
+
+If you want a code-review-specific version of this with explicit per-finding source verification, use `/multi-review` instead.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/skills/brainstorm-all/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: brainstorm-all
+description: Send a topic to all external providers (Gemini, Codex, Ollama, Antigravity) concurrently after the current host model forms an independent view. Use when the user wants an all-provider brainstorm with synthesis and explicit unavailable-provider reporting.
+---
+
+<!-- PORTABLE-CONTRACT:START -->
+## Portable contract
+
+Apply the brainstorm contract with all four external providers: Gemini, Codex, Ollama, and Antigravity. The current host model forms its independent view first; unavailable providers are reported, not silently omitted; synthesis distinguishes verified evidence from inference.
+<!-- PORTABLE-CONTRACT:END -->
+
+## Host adapters
+
+### Pi adapter
+
+Follow `/skill:brainstorm` semantics with `ask-multi` providers `gemini,codex,ollama,antigravity`, after the current Pi host model has committed its independent view.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:START -->
+### Claude Code adapter
+
+The existing detailed workflow below is the Claude Code adapter. Its Agent, MCP, hook, `CLAUDE_PLUGIN_ROOT`, and `AskUserQuestion` mechanics apply only on Claude Code; they do not override the Pi adapter above.
+
+
+
+# Multi-LLM Brainstorm (All Providers)
+
+Consult all available external LLM providers (Gemini, Codex, Ollama, Antigravity) simultaneously while Claude Opus performs its own independent research on the topic, then synthesize perspectives from all five participants.
+
+## Instructions
+
+1. Determine the brainstorm topic:
+   - If the user provided a topic directly, use it
+   - If the context is about code changes, gather the relevant diff with `git diff` and `git diff --cached`
+   - If the context is a design/plan, gather the relevant documentation or conversation context
+
+2. If no topic is clear, ask the user what they'd like to brainstorm about.
+
+3. Launch the `brainstorm-coordinator` agent with the topic, external providers set to `gemini,codex,ollama,antigravity`, and any gathered context. The coordinator will:
+   - Run its own Claude Opus research phase in parallel with the external dispatches (Phase 3B — reads actual files, traces code, uses WebFetch/WebSearch on referenced external docs)
+   - Dispatch the topic to the four external providers in parallel (Phase 3A)
+   - Synthesize all findings with Claude's verified findings weighted higher than inferred ones
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:END -->

package/skills/codex-image/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: codex-image
+description: Generate an image via OpenAI's gpt-image-2 model through the Codex CLI. Use when user asks to "generate an image", "create an image", "make a picture of", "render a graphic", "draw something", or wants visual content via Codex. Requires codex-cli >= 0.125.0 with the `image_generation` feature flag enabled (stable + on-by-default since 0.125).
+---
+
+<!-- PORTABLE-CONTRACT:START -->
+## Portable contract
+
+Refine the requested image prompt without changing intent, select an explicit output path, invoke Codex with `sandbox: "workspace-write"` so its image tool may create the file, verify the resulting file on disk, and report the path and provider response. Surface feature, policy, timeout, and filesystem failures verbatim.
+<!-- PORTABLE-CONTRACT:END -->
+
+## Host adapters
+
+### Pi adapter
+
+Call native `ask-codex` with `sandbox: "workspace-write"`. After it returns, use Pi's read-only filesystem tools to verify the output file. Do not claim automatic inline rendering in print mode.
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:START -->
+### Claude Code adapter
+
+The existing detailed workflow below is the Claude Code adapter. Its Agent, MCP, hook, `CLAUDE_PLUGIN_ROOT`, and `AskUserQuestion` mechanics apply only on Claude Code; they do not override the Pi adapter above.
+
+
+
+# Codex Image Generation
+
+Generate an image by delegating to the `ask-codex` MCP tool with a prompt-engineered template that triggers Codex's built-in `image_generation` tool. The result is saved to disk and the path is returned to the user.
+
+## Model capabilities (gpt-image-2)
+
+Codex's `image_generation` tool selects the image model server-side; as of 2026-04-21 that is **gpt-image-2**. Three capabilities are worth accounting for when building prompts:
+
+- **Legible in-image text** — per OpenAI's launch materials, gpt-image-2 renders text at ~99% accuracy across many scripts, so captions, labels, and UI copy are now reliable. gpt-image-1's weak text is no longer a reason to avoid asking for it.
+- **High resolution** — up to 4K and custom dimensions; ask for it explicitly in the prompt body when you need it. Default square renders observed in testing varied (1024×1024 and 1254×1254), so don't hard-code an expected size — read it back from the file if it matters.
+- **Provenance + watermark** — every render embeds a C2PA provenance manifest and an invisible AI-origin watermark. Flag this to the user when the image is destined for a context sensitive to AI-generated-content metadata.
+
+## Prerequisites
+
+- `codex-cli` >= 0.125.0 installed and authenticated
+- `image_generation` feature flag enabled (default: stable + true). Verify with `codex features list | grep image_generation`
+- The `ask-codex` MCP tool available (from `@ask-llm/codex-mcp` or the `@ask-llm/mcp` orchestrator)
+
+## Instructions
+
+### Phase 1: Build the image prompt
+
+Take the user's natural-language ask and prepare it for image generation. Rules:
+
+- **Keep the user's intent intact** — do not change meaning. Refine, don't replace.
+- **If the prompt is sparse** (e.g., "an apple") AND the surrounding conversation has design context (e.g., a LinkedIn post, an article), enrich with that context: aspect ratio, style cues, what to avoid.
+- **If the prompt is already detailed**, send it through verbatim — the user knows what they want.
+- **Default exclusions worth adding**: "no humanoid figures, no glowing brains, no chatbot iconography" if the topic is AI / LLM-related (these are diffusion-model failure modes and the user will almost certainly want them excluded).
+
+If you significantly enrich the prompt, briefly tell the user what you added and let them push back before dispatching.
+
+### Phase 2: Determine output path
+
+Convention:
+
+- **Default path**: `/tmp/codex-images/$(date +%Y-%m-%d)/<slug>.png` where `<slug>` is a short kebab-case derivation from the user's prompt (max 40 chars).
+- **Override**: if the user explicitly provided an output path (absolute or relative), use that exactly.
+- **Ensure parent directory exists** — `mkdir -p <parent>` before dispatching. Codex's image tool will fail if the directory doesn't exist.
+
+Example slug derivation:
+- "Generate an image of a dark terminal with two reviewers" → `dark-terminal-with-two-reviewers.png`
+- "Make me a cat picture" → `cat-picture.png`
+
+### Phase 3: Dispatch to ask-codex
+
+Call the `ask-codex` MCP tool (NOT raw `codex exec` — that bypasses ADR-044 quota fallback, ADR-042 stdin handling, and ADR-047 PATH resolution). Use this prompt template:
+
+```
+Use your image_generation tool to create the following image and save it as a PNG file.
+
+Image description:
+<the user's prompt, refined per Phase 1>
+
+Save the file to this absolute path: <path from Phase 2>
+
+After saving, confirm the absolute path of the created file and its byte size in your reply. If image_generation fails or the file cannot be written, explain what went wrong and do not invent a fake path.
+```
+
+**Sandbox:** pass `sandbox: "workspace-write"` on this `ask-codex` call. `ask-codex` defaults to the read-only review sandbox (ADR-136), under which Codex cannot write the PNG to disk; image generation is the sanctioned exception that needs Codex to write the output file itself.
+
+**Default model:** let `ask-codex` use its default (`gpt-5.6-sol`). The image_generation tool is invoked by the model regardless of which Codex chat model is selected — model selection here is about the orchestrating agent, not the image model itself.
+
+**Wall time expectation:** with gpt-image-2, simple images typically render in **under a minute** end-to-end; complex prompts or high-resolution (up to 4K) renders can take a **few minutes** because gpt-image-2's thinking mode plans layout and self-checks before generating. This is normal; do not retry assuming a hang. The first call in a session is slowest because the image_generation tool definitions aren't cached yet; subsequent calls in the same session are faster (Codex CLI prompt-caches aggressively).
+
+### Phase 4: Verify and present
+
+After `ask-codex` returns:
+
+1. **Run `ls -la <path>`** to confirm the file was created. Do not trust the agent's textual claim alone.
+2. **If file exists**: report the absolute path, byte size, and Codex's response footer (model, sessionId, usage). If the user's environment supports inline image rendering (most Claude Code clients do via the Read tool), Read the image so the user can see it.
+3. **If file missing**: surface Codex's reply verbatim (it usually contains the failure reason — e.g., "image generation rejected the prompt for policy reasons", "feature flag disabled", "quota exceeded"). Do NOT silently retry — tell the user and let them decide.
+
+### Phase 5: Failure modes worth catching specifically
+
+- **`image_generation` flag disabled**: `codex features list | grep image_generation` shows `false`. Tell the user to enable it: `codex features enable image_generation` or `codex --enable image_generation [PROMPT]`.
+- **Codex CLI version too old**: `codex --version` < 0.125.0. Tell the user to update: `npm i -g @openai/codex` (or whichever install method they use).
+- **Prompt rejected by content policy**: Codex's reply will include policy language. Show it verbatim — do not paraphrase or apologize. Let the user revise.
+- **Disk full / permission denied on output path**: report the path and the OS error verbatim; suggest a different `outputPath`.
+
+## Example interaction
+
+User: `/codex-image generate a minimalist illustration of a cat reading a book`
+
+Phase 1 — refined prompt: *minimalist illustration of a cat reading a book, flat vector style, two-tone palette, no human figures, square framing, transparent background*
+
+Phase 2 — output: `/tmp/codex-images/2026-04-24/cat-reading-a-book.png`
+
+Phase 3 — `ask-codex` is called with the prompt template above.
+
+Phase 4 — `ls -la /tmp/codex-images/2026-04-24/cat-reading-a-book.png` shows a 248KB file. Skill returns:
+
+> Generated **/tmp/codex-images/2026-04-24/cat-reading-a-book.png** (248 KB) via gpt-image-2. Used Codex (gpt-5.6-sol) as orchestrator. Refined prompt: *minimalist illustration of a cat reading a book, flat vector style, two-tone palette, no human figures, square framing, transparent background*. Reading inline below.
+
+[image renders]
+
+<!-- HOST-ADAPTER:CLAUDE-CODE:END -->