@lazyingart/agintiflow 0.20.174 → 0.20.176

package/README.md

@@ -54,7 +54,7 @@ Most agent tools are either a chat box with hidden state or an expensive one-mod
 | Disciplined by default | `AGINTI.md` starts with a behavior contract: surface ambiguity, keep edits surgical, avoid speculative complexity, verify outcomes, and respect permission blockers. |
 | Role-based models | Route, main, spare, wrapper, and auxiliary image roles are separate. You can use cheap route models, stronger main models, optional OpenAI/Qwen/Venice routes, and GRS AI/Venice image tools. |
 | Writing without agent noise | `writing_specialist` drafts novels, books, scripts, essays, and paper prose in an isolated writing-only context, then the main agent handles files, formatting, citations, checks, and artifacts. |
-| Visual and web evidence | `read_image` reads screenshots/figures with typed perception artifacts, `web_research` saves sourced research artifacts, and `research_wrapper` can ask Codex `gpt-5.4-mini` medium for a strict-JSON second opinion. |
+| Visual and web evidence | `read_image` reads screenshots/figures with typed JSON and Markdown perception artifacts, uses OpenAI vision when configured, and falls back to `codex exec --image` when Codex is available. `web_research` saves sourced research artifacts, and `research_wrapper` can ask Codex `gpt-5.4-mini` medium for a strict-JSON second opinion. |
 | Scouts before big work | Parallel scouts can cheaply map architecture, tests, risks, symbols, and integration points before the main executor edits anything. |
 | SCS by default | Student-Committee-Supervisor mode adds a typed gate: committee drafts, student approves/monitors, supervisor executes. Use `/scs off` or `--no-scs` only when speed matters more than validation. |
 | AAPS for large workflows | AAPS describes top-down agentic pipeline scripts; AgInTiFlow can act as the interactive backend that validates, compiles, and executes those workflows. |
@@ -239,7 +239,7 @@ The website keeps the visual walkthrough in a carousel so this README can stay f
 | Writing specialist | A dedicated writing-only LLM call for prose, chapters, scripts, books, essays, research-paper sections, and revisions, with formatter handoff notes for Markdown/LaTeX/Final Draft. |
 | Patch workflow | Codex-style patch envelopes, unified diffs, exact replacements, hashes, compact diffs, and path guardrails. |
 | Parallel scouts | Optional scout calls for architecture, implementation, review, tests, git flow, research, symbol tracing, and dependency risk. |
-| Image reading and web research | `read_image` uses OpenAI vision for workspace images when `OPENAI_API_KEY` is configured. `web_research` preserves source lists, and optional OpenAI hosted web search or `research_wrapper` can be used for higher-confidence research. |
+| Image reading and web research | `read_image` uses OpenAI vision for workspace images when `OPENAI_API_KEY` is configured, otherwise it can fall back to Codex CLI image attachments when available. It saves JSON and Markdown reports and can surface the report in the canvas. `web_research` preserves source lists, and optional OpenAI hosted web search or `research_wrapper` can be used for higher-confidence research. |
 | SCS mode | Default Student-Committee-Supervisor quality gate with independent planning, execution, and validation roles. |
 | AAPS adapter | Optional `@lazyingart/aaps` integration for `.aaps` workflow init, validate, parse, compile, dry-run, and run commands. |
 | Image generation | Optional GRS AI and Venice image tools with saved manifests and canvas artifact previews. |

package/docs/perception-and-web-research.md

@@ -6,7 +6,7 @@ AgInTiFlow separates visual understanding, web search, and wrapper advice so eac
 
 | Tool | Purpose | Evidence |
 | --- | --- | --- |
-| `read_image` | Read workspace screenshots, plots, scanned text, diagrams, or allowed remote image URLs. | Saves `artifacts/perception/*-read-image.json` in the central session store with image hashes, MIME type, size, model, prompt, and typed result. |
+| `read_image` | Read workspace screenshots, plots, scanned text, diagrams, or allowed remote image URLs. | Saves JSON and Markdown reports under `artifacts/perception/`, records image hashes, and sends the Markdown report to the canvas when used by an agent run. |
 | `web_search` | Cheap raw search snippets. | Returns compact titles, URLs, snippets, and fallback search URL. |
 | `web_research` | Sourced research unit for current or external information. | Saves `artifacts/research/*-web-research.json` with query, mode, source list, and answer. |
 | `research_wrapper` | Read-only strict-JSON second opinion from the selected wrapper. | Saves `artifacts/wrappers/*-research-wrapper.json` with wrapper, model, reasoning, metadata, result, and raw fallback output. |
@@ -14,7 +14,9 @@ AgInTiFlow separates visual understanding, web search, and wrapper advice so eac
 ## Defaults
 
 - `read_image` uses OpenAI Responses vision when `OPENAI_API_KEY` is configured.
-- `read_image` defaults to `AGINTI_PERCEPTION_MODEL=gpt-5.4-mini` and `AGINTI_PERCEPTION_REASONING=medium`, then falls back through `AGINTI_PERCEPTION_FALLBACK_MODELS` or `gpt-4o-mini` if the account lacks access to the preferred model.
+- If OpenAI vision is unavailable, `read_image` falls back to `codex exec --image` when the Codex CLI is installed and wrapper tools are enabled.
+- Wrapper tools default on when Codex is available, and can still be disabled with `/wrapper off` or `--no-wrapper`-style runtime settings.
+- `read_image` defaults to `AGINTI_PERCEPTION_MODEL=gpt-5.4-mini` and `AGINTI_PERCEPTION_REASONING=medium`, then falls back through `AGINTI_PERCEPTION_FALLBACK_MODELS` or `gpt-4o-mini` if the account lacks access to the preferred OpenAI model.
 - `web_research` defaults to lightweight snippet mode; use `mode=openai` only when hosted OpenAI web search is needed and configured.
 - `web_research mode=openai` defaults to `AGINTI_WEB_RESEARCH_MODEL=gpt-5.4-mini` / `medium`, then falls back through `AGINTI_WEB_RESEARCH_FALLBACK_MODELS` or `gpt-4o-mini`.
 - `research_wrapper` defaults to `AGINTI_RESEARCH_WRAPPER_MODEL=gpt-5.4-mini` and `AGINTI_RESEARCH_WRAPPER_REASONING=medium`.
@@ -24,6 +26,7 @@ AgInTiFlow separates visual understanding, web search, and wrapper advice so eac
 
 ```text
 /image-read artifacts/screenshots/app.png what looks wrong?
+/image-read --codex artifacts/screenshots/app.png what looks wrong?
 /web-research latest Android Gradle plugin official docs
 /research-wrapper gpt-5.4-mini medium
 /research-wrapper off

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.174",
+  "version": "0.20.176",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/public/app.js

@@ -1873,6 +1873,28 @@ function renderEmbeddedWorkspaceResult(value = "", entry = {}) {
   `;
 }
 
+function compactInline(value = "", limit = 180) {
+  return compactMessage(value, limit);
+}
+
+function toolArgumentPreview(toolName = "", args = {}, data = {}) {
+  if (toolName === "finish") return "";
+  if (toolName === "run_command" && (args.command || data.command)) return args.command || data.command;
+  if (["write_file", "apply_patch", "read_file", "open_workspace_file", "preview_workspace"].includes(toolName)) {
+    return args.path || args.file || data.path || "";
+  }
+  if (["send_to_canvas", "create_artifact"].includes(toolName)) {
+    return [args.title || data.title || "canvas artifact", args.kind || data.kind || "", args.selected ? "selected" : ""]
+      .filter(Boolean)
+      .join(" · ");
+  }
+  if (["open_url", "web_research", "web_search"].includes(toolName)) return args.url || args.query || args.q || data.url || "";
+  const scalar = ["title", "path", "file", "query", "q", "url", "kind"]
+    .map((key) => args[key] || data[key])
+    .find(Boolean);
+  return scalar ? compactInline(scalar) : "";
+}
+
 function renderWorkspaceChangeEvent(entry) {
   const data = entry.data || {};
   const toolName = data.toolName || data.action || "file.changed";
@@ -1912,12 +1934,7 @@ function renderToolEvent(entry) {
   const args = data.args || {};
   const resultText = String(data.result || args.result || "");
   const embeddedResult = resultText ? renderEmbeddedWorkspaceResult(resultText, entry) : "";
-  const argPreview =
-    toolName === "finish"
-      ? ""
-      : toolName === "run_command" && args.command
-      ? args.command
-      : args.path || args.url || args.query || args.q || (Object.keys(args).length ? JSON.stringify(args) : "");
+  const argPreview = toolArgumentPreview(toolName, args, data);
   const stdout = data.stdout ? outputPreviewText(data.stdout) : null;
   const stderr = data.stderr ? outputPreviewText(data.stderr) : null;
   return `
@@ -1990,6 +2007,66 @@ function renderStructuredEvent(entry) {
   return "";
 }
 
+function logToolLifecycleKey(data = {}) {
+  const args = data.args || {};
+  const focusedArgs = {
+    path: args.path || args.file || data.path || "",
+    command: args.command || data.command || "",
+    title: args.title || data.title || "",
+    kind: args.kind || data.kind || "",
+    query: args.query || args.q || "",
+    url: args.url || data.url || "",
+  };
+  return `${data.toolName || ""}:${JSON.stringify(focusedArgs)}`;
+}
+
+function logEventDedupContext(entries = [], runResult = "") {
+  const terminalToolKeys = new Set();
+  const finishResultFingerprints = new Set();
+  const workspaceChangePaths = new Set();
+  const runResultFingerprint = compactInline(runResult, 100000);
+
+  for (const entry of entries || []) {
+    const data = entry.data || {};
+    const type = entry.message || entry.eventType || "";
+    if (["tool.completed", "tool.failed", "tool.skipped", "tool.blocked"].includes(type)) {
+      terminalToolKeys.add(logToolLifecycleKey(data));
+    }
+    if (type === "tool.completed" && data.toolName === "finish" && data.result) {
+      finishResultFingerprints.add(compactInline(data.result, 100000));
+    }
+    if (type === "session.finished" && data.result) {
+      finishResultFingerprints.add(compactInline(data.result, 100000));
+    }
+    if (type === "file.changed" && (data.path || data.args?.path)) {
+      workspaceChangePaths.add(String(data.path || data.args?.path || "").replace(/\\/g, "/"));
+    }
+  }
+
+  return { terminalToolKeys, finishResultFingerprints, workspaceChangePaths, runResultFingerprint };
+}
+
+function shouldSuppressLogEntry(entry = {}, context = {}) {
+  const data = entry.data || {};
+  const type = entry.message || entry.eventType || "";
+  const toolName = data.toolName || "";
+  const toolKey = logToolLifecycleKey(data);
+  const resultKey = data.result || data.args?.result ? compactInline(data.result || data.args?.result, 100000) : "";
+  if (type === "tool.started" && context.terminalToolKeys?.has(toolKey)) return true;
+  if (type === "tool.started" && toolName === "finish" && resultKey) {
+    return resultKey === context.runResultFingerprint || context.finishResultFingerprints?.has(resultKey);
+  }
+  if (type === "tool.completed" && toolName === "finish" && resultKey && resultKey === context.runResultFingerprint) return true;
+  if (type === "session.finished" && resultKey) {
+    return resultKey === context.runResultFingerprint || context.finishResultFingerprints?.has(resultKey);
+  }
+  if (type === "tool.completed" && ["write_file", "apply_patch"].includes(toolName)) {
+    const pathKey = String(data.path || data.args?.path || data.args?.file || "").replace(/\\/g, "/");
+    if (pathKey && context.workspaceChangePaths?.has(pathKey)) return true;
+  }
+  return false;
+}
+
 function renderLogs(run) {
   logsEl.dataset.mode = "active";
   const structuredRunResult = run.result ? renderEmbeddedWorkspaceResult(run.result, { at: run.endedAt || run.updatedAt || "" }) : "";
@@ -2003,7 +2080,9 @@ function renderLogs(run) {
     run.error ? `<div class="log-line error">${escapeHtml(`error=${run.error}`)}</div>` : "",
   ];
 
+  const dedupContext = logEventDedupContext(run.logs || [], run.result || "");
   for (const entry of run.logs || []) {
+    if (shouldSuppressLogEntry(entry, dedupContext)) continue;
     const structured = renderStructuredEvent(entry);
     if (structured) {
       parts.push(structured);
@@ -2286,10 +2365,17 @@ function renderChat(chatEntries) {
       }
       const role = entry.role === "assistant" ? "assistant" : "user";
       const label = role === "assistant" ? t("assistantLabel") : t("youLabel");
-      const content =
-        role === "assistant"
-          ? `<div class="markdown-body">${renderMarkdown(entry.content)}</div>`
-          : escapeHtml(entry.content).replace(/\n/g, "<br>");
+      let content = escapeHtml(entry.content).replace(/\n/g, "<br>");
+      if (role === "assistant") {
+        const embeddedResult = renderEmbeddedWorkspaceResult(entry.content, entry);
+        if (embeddedResult && entry.suppressEmbeddedWorkspaceDiffs) {
+          content = `<div class="markdown-body">${renderMarkdown(embeddedWorkspaceSummary(entry.content))}</div>`;
+        } else if (embeddedResult) {
+          content = `<article class="event-card event-finish assistant-result-card">${embeddedResult}</article>`;
+        } else {
+          content = `<div class="markdown-body">${renderMarkdown(entry.content)}</div>`;
+        }
+      }
       return `
         <article class="chat-item ${role}">
           <div class="chat-meta">${label}${entry.at ? ` · ${new Date(entry.at).toLocaleString()}` : ""}</div>

package/public/styles.css

@@ -1371,6 +1371,10 @@ button.danger {
   box-shadow: none;
 }
 
+.assistant-result-card {
+  margin: 0;
+}
+
 #logs .event-fold-note {
   color: #94a3b8;
 }

package/scripts/smoke-cli-chat.js

@@ -896,8 +896,12 @@ try {
   if (!latest.stdout.includes(" write ") || !latest.stdout.includes("+Created by AgInTiFlow mock mode.")) {
     throw new Error("bare aginti resume did not replay formatted file-change diff context");
   }
-  if (!/\bfinish\b/.test(latest.stdout) || latest.stdout.includes('{"result":"Mock run complete')) {
-    throw new Error("bare aginti resume did not render finish-result diffs in formatted mode");
+  if (latest.stdout.includes('{"result":"Mock run complete')) {
+    throw new Error("bare aginti resume rendered raw finish JSON instead of formatted history");
+  }
+  const mockCompleteCount = (latest.stdout.match(/Mock run complete\./g) || []).length;
+  if (mockCompleteCount > 1) {
+    throw new Error(`bare aginti resume duplicated the finish result ${mockCompleteCount} times`);
   }
   if (latest.stdout.includes("resume note=showing chat transcript only")) {
     throw new Error("bare aginti resume regressed to chat-only history");

package/scripts/smoke-perception-research.js

@@ -58,7 +58,28 @@ async function main() {
   assert(image.ok, `read_image dry-run failed: ${image.error || "unknown"}`);
   assert(image.images?.[0]?.sha256, "read_image did not record image hash");
   assert(image.artifactPath, "read_image did not persist a perception artifact");
+  assert(image.markdownArtifactPath, "read_image did not persist a Markdown perception artifact");
+  assert(image.markdownPath, "read_image did not persist a workspace Markdown report");
   await fs.access(image.artifactPath);
+  await fs.access(image.markdownArtifactPath);
+  await fs.access(path.join(workspace, image.markdownPath));
+
+  const codexFallback = await readImage(
+    {
+      path: "artifacts/screenshots/tiny.png",
+      prompt: "Describe this tiny image with the Codex image fallback.",
+      provider: "codex",
+      codexDryRun: true,
+    },
+    {
+      ...config,
+      allowWrapperTools: true,
+    },
+    store
+  );
+  assert(codexFallback.ok, `read_image Codex fallback dry-run failed: ${codexFallback.error || "unknown"}`);
+  assert(codexFallback.provider === "codex-wrapper-dry-run", "read_image did not select the Codex wrapper fallback path");
+  assert(codexFallback.markdownPath, "read_image Codex fallback did not write a Markdown report");
 
   const secretBlock = checkToolUse({
     toolName: "read_image",
@@ -116,6 +137,7 @@ async function main() {
   const runStore = new SessionStore(agentConfig.sessionsDir, run.sessionId);
   const events = await runStore.loadEvents();
   assert(events.some((event) => event.type === "tool.completed" && event.data?.toolName === "read_image"), "mock agent did not call read_image");
+  assert(events.some((event) => event.type === "canvas.item" && event.data?.toolName === "read_image"), "read_image did not send the Markdown report to canvas");
 
   await fs.rm(tempRoot, { recursive: true, force: true });
   console.log("smoke-perception-research ok");

package/scripts/smoke-web-ui.js

@@ -224,6 +224,14 @@ try {
     const chatTail = (await page.locator("#chat-thread").innerText().catch(() => "")).slice(-1200);
     throw new Error(`web UI did not render formatted finish-result diff event; state=${state}\nlogs tail:\n${logsTail}\nchat tail:\n${chatTail}`);
   }
+  const formattedChatText = await page.locator("#chat-thread").innerText();
+  if (formattedChatText.includes('{"result":"Mock run complete')) {
+    throw new Error("web UI rendered raw finish JSON in chat history");
+  }
+  const mockCompleteCount = (formattedChatText.match(/Mock run complete\./g) || []).length;
+  if (mockCompleteCount > 1) {
+    throw new Error(`web UI duplicated the assistant/session finish result ${mockCompleteCount} times`);
+  }
 
   await page.click("#open-settings");
   await page.waitForSelector("#settings-modal[open]");
@@ -262,6 +270,7 @@ try {
           "formatted-plan-event-card",
           "formatted-file-diff-event-card",
           "formatted-finish-result-diff-card",
+          "deduped-finish-history",
           "settings-provider-dropdowns",
           "settings-wrapper-dropdowns",
         ],

package/src/agent-runner.js

@@ -1775,6 +1775,40 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         const eventResult = sanitizeToolResult(result);
         await store.appendEvent(result.ok ? "tool.completed" : "tool.failed", eventResult);
         observers.event(result.ok ? "tool.completed" : "tool.failed", eventResult);
+        if (result.ok && result.markdownPath) {
+          const normalized = normalizeCanvasPayload(
+            {
+              title: "Image reading report",
+              kind: "markdown",
+              path: result.markdownPath,
+              note: result.result?.summary || result.result?.answer || "Image reading report.",
+              selected: true,
+            },
+            config
+          );
+          if (normalized.ok) {
+            const persisted = await persistCanvasPayloadFile(normalized.payload, { config, store });
+            if (persisted.ok) {
+              const canvasItem = {
+                ...persisted.payload,
+                toolName: "read_image",
+                commandCwd: config.commandCwd,
+              };
+              await store.appendEvent("canvas.item", canvasItem);
+              observers.event("canvas.item", canvasItem);
+              await store.appendEvent("canvas.selected", {
+                artifactId: canvasItem.artifactId,
+                title: canvasItem.title,
+                source: "read_image",
+              });
+              observers.event("canvas.selected", {
+                artifactId: canvasItem.artifactId,
+                title: canvasItem.title,
+                source: "read_image",
+              });
+            }
+          }
+        }
         return result;
       }
       case "json_specialist": {

package/src/config.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import crypto from "node:crypto";
 import { getModelRoleDefaults, getProviderDefaults, normalizeRoutingMode, selectModelRoute } from "./model-routing.js";
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
-import { normalizeWrapperName } from "./tool-wrappers.js";
+import { isWrapperAvailable, normalizeWrapperName } from "./tool-wrappers.js";
 import { loadProjectEnv, projectPaths, resolveProjectRoot } from "./project.js";
 import { normalizeTaskProfile } from "./task-profiles.js";
 import { recommendedMaxStepsForTask } from "./engineering-guidance.js";
@@ -113,6 +113,10 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     overrides.allowParallelScouts ?? args.allowParallelScouts ?? process.env.AGINTI_PARALLEL_SCOUTS,
     true
   );
+  const preferredWrapper = normalizeWrapperName(
+    overrides.preferredWrapper ?? args.preferredWrapper ?? process.env.PREFERRED_WRAPPER ?? process.env.AGENT_WRAPPER
+  );
+  const wrapperDefaultEnabled = isWrapperAvailable(preferredWrapper) || isWrapperAvailable("codex");
 
   return {
     ...defaults,
@@ -192,7 +196,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     ),
     allowWrapperTools: parseBoolean(
       overrides.allowWrapperTools ?? args.allowWrapperTools ?? process.env.ALLOW_WRAPPER_TOOLS,
-      false
+      wrapperDefaultEnabled
     ),
     allowAuxiliaryTools: parseBoolean(
       overrides.allowAuxiliaryTools ?? args.allowAuxiliaryTools ?? process.env.ALLOW_AUXILIARY_TOOLS,
@@ -206,9 +210,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
       1,
       10
     ),
-    preferredWrapper: normalizeWrapperName(
-      overrides.preferredWrapper ?? args.preferredWrapper ?? process.env.PREFERRED_WRAPPER ?? process.env.AGENT_WRAPPER
-    ),
+    preferredWrapper,
     wrapperTimeoutMs: parseNumber(overrides.wrapperTimeoutMs ?? process.env.WRAPPER_TIMEOUT_MS, 120000),
     permissionMode,
     sandboxMode,

package/src/interactive-cli.js

@@ -47,6 +47,7 @@ import {
 } from "./permission-modes.js";
 import { ensureAgintiWebApp, readWebAppPreference, stopAgintiWebApp, writeWebAppPreference } from "./web-autostart.js";
 import { mcpCliCommand, formatMcpCliResult } from "./mcp/tool-bridge.js";
+import { isWrapperAvailable } from "./tool-wrappers.js";
 
 const useColor = Boolean(input.isTTY && output.isTTY && process.env.AGINTIFLOW_NO_COLOR !== "1");
 const ansi = {
@@ -843,6 +844,47 @@ function embeddedWorkspaceSummary(value = "") {
   return summary.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
 
+function normalizedTimelineText(value = "") {
+  return String(value || "").replace(/\r\n?/g, "\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function timelineTextFingerprint(value = "") {
+  return normalizedTimelineText(value).replace(/\s+/g, " ").trim();
+}
+
+function workspaceChangeFingerprint(change = {}) {
+  const pathKey = String(change.path || change.args?.path || "").replace(/\\/g, "/").trim();
+  const diffKey = normalizedTimelineText(change.diff || "");
+  return pathKey || diffKey ? `${pathKey}\n${diffKey}` : "";
+}
+
+function eventWorkspaceChangeFingerprint(event = {}) {
+  const data = event.data || {};
+  if (event.type === "file.changed") return workspaceChangeFingerprint(data);
+  if ((event.type === "tool.completed" || event.type === "tool.failed") && data.diff) return workspaceChangeFingerprint(data);
+  return "";
+}
+
+function eventWorkspaceChangePath(event = {}) {
+  const data = event.data || {};
+  if (event.type !== "file.changed" && !data.diff) return "";
+  return String(data.path || data.args?.path || "").replace(/\\/g, "/").trim();
+}
+
+function toolLifecycleKey(event = {}) {
+  const data = event.data || {};
+  const args = data.args || {};
+  const focusedArgs = {
+    path: args.path || args.file || data.path || "",
+    command: args.command || data.command || "",
+    title: args.title || data.title || "",
+    kind: args.kind || data.kind || "",
+    query: args.query || args.q || "",
+    url: args.url || data.url || "",
+  };
+  return `${data.toolName || ""}:${JSON.stringify(focusedArgs)}`;
+}
+
 function printWorkspaceChange(change = {}) {
   if (!change?.diff) return;
   const formatted = formatWorkspaceChange(change);
@@ -852,12 +894,14 @@ function printWorkspaceChange(change = {}) {
   for (const line of formatted.lines) outputLine(`${gutter}${line}`);
 }
 
-function printEmbeddedWorkspaceResult(result = "", { labelName = "finish", time = "" } = {}) {
+function printEmbeddedWorkspaceResult(result = "", { labelName = "finish", time = "", bg = ansi.systemBg, includeDiffs = true } = {}) {
   const changes = embeddedWorkspaceChangesFromText(result);
   if (changes.length === 0) return false;
   const summary = embeddedWorkspaceSummary(result);
-  if (summary) printHistoryBlock(labelName, summary, { time, bg: ansi.systemBg });
-  for (const change of changes) printWorkspaceChange(change);
+  if (summary) printHistoryBlock(labelName, summary, { time, bg });
+  if (includeDiffs) {
+    for (const change of changes) printWorkspaceChange(change);
+  }
   return true;
 }
 
@@ -1069,7 +1113,7 @@ function printHelp() {
       `  ${command("/webapp [port|start|stop|restart|reuse|enable|disable|status]", "Start, reuse, stop, restart, or configure the local webapp.", "helpWebapp")}`,
       `  ${command("/web-search on|off", "Enable or disable the web_search tool.", "helpWebSearch")}`,
       `  ${command("/web-research <query>", "Run a sourced web_research turn with persisted evidence.", "helpWebSearch")}`,
-      `  ${command("/image-read <path> [question]", "Run read_image on a workspace screenshot/image.", "helpWebSearch")}`,
+      `  ${command("/image-read [--codex|--openai] <path> [question]", "Run read_image on a workspace screenshot/image.", "helpWebSearch")}`,
       `  ${command("/research-wrapper [on|off|model reasoning]", "Configure strict JSON wrapper research, default gpt-5.4-mini medium.", "helpWrapper")}`,
       `  ${command("/scs [on|auto|off|status]", "Toggle Student-Committee-Supervisor gated execution.", "helpEnableScs")}`,
       `  ${command("/scouts on|off|<1-10>", "Enable parallel DeepSeek scouts and set scout count.", "helpScouts")}`,
@@ -2296,6 +2340,17 @@ function printHistoryEntry(entry) {
   const role = entry.role === "assistant" ? "aginti>" : entry.role === "user" ? "user>" : String(entry.role || "note");
   const bg = role === "aginti>" ? ansi.agentBg : role === "user>" ? ansi.userBg : ansi.systemBg;
   const time = entry.at ? new Date(entry.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : "";
+  if (
+    entry.role === "assistant" &&
+    printEmbeddedWorkspaceResult(entry.content, {
+      labelName: role,
+      time,
+      bg,
+      includeDiffs: !entry.suppressEmbeddedWorkspaceDiffs,
+    })
+  ) {
+    return;
+  }
   printHistoryBlock(role, entry.content, { time, bg });
 }
 
@@ -2335,16 +2390,66 @@ function isReplayableResumeEvent(event = {}) {
 function resumeTimelineItems(chat = [], events = [], { limit = 0 } = {}) {
   const shownChat = limit > 0 ? chat.slice(-limit) : chat;
   const firstChatTime = limit > 0 && shownChat.length > 0 ? timestampMs(shownChat[0].at) : 0;
-  const chatItems = shownChat.map((entry, index) => ({
-    kind: "chat",
-    entry,
-    order: index * 2,
-    at: timestampMs(entry.at),
-  }));
-  const eventItems = events
+  const eventList = Array.isArray(events) ? events : [];
+  const workspaceChangeKeys = new Set(eventList.map(eventWorkspaceChangeFingerprint).filter(Boolean));
+  const workspaceChangePaths = new Set(eventList.map(eventWorkspaceChangePath).filter(Boolean));
+  const chatResultFingerprints = new Set(
+    (Array.isArray(chat) ? chat : [])
+      .filter((entry) => entry?.role === "assistant" && entry?.content)
+      .map((entry) => timelineTextFingerprint(entry.content))
+      .filter(Boolean)
+  );
+  const finishResultFingerprints = new Set(
+    eventList
+      .filter((event) => (event.type === "tool.completed" && event.data?.toolName === "finish") || event.type === "session.finished")
+      .map((event) => timelineTextFingerprint(event.data?.result || ""))
+      .filter(Boolean)
+  );
+  const terminalToolKeys = new Set(
+    eventList
+      .filter((event) => ["tool.completed", "tool.failed", "tool.skipped", "tool.blocked"].includes(event.type))
+      .map(toolLifecycleKey)
+      .filter(Boolean)
+  );
+  const shouldSuppressEvent = (event = {}) => {
+    const type = String(event.type || "");
+    const data = event.data || {};
+    const toolName = String(data.toolName || "");
+    const resultFingerprint = timelineTextFingerprint(data.result || data.args?.result || "");
+    if (type === "tool.started" && terminalToolKeys.has(toolLifecycleKey(event))) return true;
+    if (type === "tool.started" && toolName === "finish" && resultFingerprint) {
+      return chatResultFingerprints.has(resultFingerprint) || finishResultFingerprints.has(resultFingerprint);
+    }
+    if (["tool.completed", "tool.failed", "tool.skipped"].includes(type)) {
+      if (toolName === "finish" && resultFingerprint && chatResultFingerprints.has(resultFingerprint)) return true;
+      if (["write_file", "apply_patch"].includes(toolName)) {
+        const pathKey = String(data.path || data.args?.path || data.args?.file || "").replace(/\\/g, "/").trim();
+        if (pathKey && workspaceChangePaths.has(pathKey)) return true;
+        const changeKey = eventWorkspaceChangeFingerprint(event);
+        if (changeKey && workspaceChangeKeys.has(changeKey)) return true;
+      }
+    }
+    if (type === "session.finished" && resultFingerprint) {
+      return chatResultFingerprints.has(resultFingerprint) || finishResultFingerprints.has(resultFingerprint);
+    }
+    return false;
+  };
+  const chatItems = shownChat.map((entry, index) => {
+    const embeddedChanges = entry.role === "assistant" ? embeddedWorkspaceChangesFromText(entry.content) : [];
+    const suppressEmbeddedWorkspaceDiffs =
+      embeddedChanges.length > 0 && embeddedChanges.every((change) => workspaceChangeKeys.has(workspaceChangeFingerprint(change)));
+    return {
+      kind: "chat",
+      entry: { ...entry, suppressEmbeddedWorkspaceDiffs },
+      order: index * 2,
+      at: timestampMs(entry.at),
+    };
+  });
+  const eventItems = eventList
     .map((event, index) => ({ event, index }))
     .filter(({ event }) => isReplayableResumeEvent(event))
     .filter(({ event }) => !firstChatTime || timestampMs(event.timestamp) >= firstChatTime)
+    .filter(({ event }) => !shouldSuppressEvent(event))
     .map(({ event, index }) => ({
       kind: "event",
       event,
@@ -2463,6 +2568,9 @@ function toolStatusDetails(data = {}) {
   if ((tool === "write_file" || tool === "apply_patch" || tool === "read_file" || tool === "open_workspace_file") && args.path) {
     return `${tool}: ${compactLine(args.path, 58)}`;
   }
+  if ((tool === "send_to_canvas" || tool === "create_artifact") && (args.title || args.kind)) {
+    return `${tool}: ${compactLine([args.title || "canvas artifact", args.kind || "", args.selected ? "selected" : ""].filter(Boolean).join(" · "), 72)}`;
+  }
   if ((tool === "open_url" || tool === "web_research" || tool === "web_search") && (args.url || args.query || args.q)) {
     return `${tool}: ${compactLine(args.url || args.query || args.q, 58)}`;
   }
@@ -2552,7 +2660,7 @@ function createState(args = {}) {
     allowParallelScouts: args.allowParallelScouts ?? true,
     enableScs: normalizeScsMode(args.enableScs || process.env.AGINTI_SCS_MODE || "on"),
     parallelScoutCount: args.parallelScoutCount || 3,
-    allowWrapperTools: args.allowWrapperTools ?? false,
+    allowWrapperTools: args.allowWrapperTools ?? isWrapperAvailable(args.preferredWrapper || "codex"),
     allowDestructive: args.allowDestructive ?? permissionDefaults.allowDestructive ?? false,
     allowPasswords: args.allowPasswords ?? permissionDefaults.allowPasswords ?? false,
     allowOutsideWorkspaceFileTools:
@@ -3737,21 +3845,27 @@ async function handleCommand(line, state, packageDir) {
     return true;
   }
   if (command === "image-read") {
-    const [target, ...questionParts] = value.split(/\s+/).filter(Boolean);
+    const rawParts = value.split(/\s+/).filter(Boolean);
+    const providerFlag = ["--codex", "--openai"].includes(rawParts[0]) ? rawParts.shift() : "";
+    const provider = providerFlag ? providerFlag.replace(/^--/, "") : "";
+    const [target, ...questionParts] = rawParts;
     if (!target) {
-      printAgentMessage("Usage: /image-read <workspace-image-path-or-url> [question]");
+      printAgentMessage("Usage: /image-read [--codex|--openai] <workspace-image-path-or-url> [question]");
       return true;
     }
     const previousProfile = state.taskProfile;
     const previousMaxSteps = state.maxSteps;
+    const previousWrapperTools = state.allowWrapperTools;
     try {
       state.taskProfile = "image";
       state.maxSteps = Math.max(state.maxSteps, 12);
+      if (provider === "codex") state.allowWrapperTools = true;
       await runPrompt(
         [
           `Use the read_image tool on ${target}.`,
+          provider ? `Use read_image provider=${provider}.` : "Use read_image provider=auto so it can use OpenAI vision or Codex fallback.",
           questionParts.length ? `Question: ${questionParts.join(" ")}` : "Question: describe the image accurately and report visible text, issues, and uncertainty.",
-          "Do not infer from the filename. Report the read_image artifact path.",
+          "Do not infer from the filename. Report the read_image JSON and Markdown artifact paths.",
         ].join("\n"),
         state,
         packageDir
@@ -3759,6 +3873,7 @@ async function handleCommand(line, state, packageDir) {
     } finally {
       state.taskProfile = previousProfile;
       state.maxSteps = previousMaxSteps;
+      state.allowWrapperTools = previousWrapperTools;
     }
     return true;
   }