@lazyingart/agintiflow 0.20.173 → 0.20.175

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.173",
+  "version": "0.20.175",
   "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

@@ -1796,6 +1796,105 @@ function renderPlanEvent(entry) {
   `;
 }
 
+function embeddedWorkspaceChangesFromText(value = "") {
+  const lines = String(value || "").split(/\r?\n/);
+  const changes = [];
+  let currentTool = "";
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const toolMatch = lines[index].match(/^\s*Tool:\s*(.+?)\s*$/i);
+    if (toolMatch) {
+      currentTool = toolMatch[1].trim();
+      continue;
+    }
+
+    const pathMatch = lines[index].match(/^\s*Path:\s*(.+?)\s*$/i);
+    if (!pathMatch) continue;
+
+    let cursor = index + 1;
+    while (cursor < lines.length && !/^\s*Diff:\s*$/i.test(lines[cursor]) && !/^\s*(?:Tool|Path):\s*/i.test(lines[cursor])) {
+      cursor += 1;
+    }
+    if (!/^\s*Diff:\s*$/i.test(lines[cursor] || "")) continue;
+
+    const diffLines = [];
+    cursor += 1;
+    while (cursor < lines.length) {
+      if (diffLines.length && /^\s*(?:Tool|Path):\s*/i.test(lines[cursor])) break;
+      if (
+        diffLines.length &&
+        /^\s*(?:Output:|No command output|Blocked by guardrail\.|Mock run complete\.)/i.test(lines[cursor]) &&
+        !/^[-+@ ]/.test(lines[cursor])
+      ) {
+        break;
+      }
+      diffLines.push(lines[cursor]);
+      cursor += 1;
+    }
+    while (diffLines.length && !diffLines[diffLines.length - 1].trim()) diffLines.pop();
+    if (diffLines.length) {
+      changes.push({
+        toolName: currentTool || "write_file",
+        path: pathMatch[1].trim(),
+        diff: diffLines.join("\n"),
+      });
+      index = Math.max(index, cursor - 1);
+    }
+  }
+
+  return changes;
+}
+
+function embeddedWorkspaceSummary(value = "") {
+  const summary = [];
+  let skippingDiff = false;
+  for (const line of String(value || "").split(/\r?\n/)) {
+    if (/^\s*Diff:\s*$/i.test(line)) {
+      skippingDiff = true;
+      continue;
+    }
+    if (skippingDiff && /^\s*(?:Tool|Path):\s*/i.test(line)) skippingDiff = false;
+    if (skippingDiff) continue;
+    if (/^\s*Path:\s*/i.test(line)) continue;
+    summary.push(line);
+  }
+  return summary.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function renderEmbeddedWorkspaceResult(value = "", entry = {}) {
+  const changes = embeddedWorkspaceChangesFromText(value);
+  if (changes.length === 0) return "";
+  const summary = embeddedWorkspaceSummary(value);
+  return `
+    ${summary ? `<div class="event-result-summary markdown-body">${renderMarkdown(summary)}</div>` : ""}
+    <div class="embedded-change-list">
+      ${changes.map((change) => renderWorkspaceChangeEvent({ data: change, at: entry.at, content: change.path })).join("")}
+    </div>
+  `;
+}
+
+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";
@@ -1833,14 +1932,13 @@ function renderToolEvent(entry) {
   const skipped = message === "tool.skipped";
   const toolName = data.toolName || "tool";
   const args = data.args || {};
-  const argPreview =
-    toolName === "run_command" && args.command
-      ? args.command
-      : args.path || args.url || args.query || args.q || (Object.keys(args).length ? JSON.stringify(args) : "");
+  const resultText = String(data.result || args.result || "");
+  const embeddedResult = resultText ? renderEmbeddedWorkspaceResult(resultText, entry) : "";
+  const argPreview = toolArgumentPreview(toolName, args, data);
   const stdout = data.stdout ? outputPreviewText(data.stdout) : null;
   const stderr = data.stderr ? outputPreviewText(data.stderr) : null;
   return `
-    <article class="event-card ${failed ? "event-failed" : skipped ? "event-muted" : "event-tool"}">
+    <article class="event-card ${failed ? "event-failed" : skipped ? "event-muted" : toolName === "finish" ? "event-finish" : "event-tool"}">
       <div class="event-card-meta">
         <span>${escapeHtml(failed ? "tool failed" : skipped ? "tool skipped" : message === "tool.started" ? "tool" : "tool done")}</span>
         <span>${entry.at ? escapeHtml(new Date(entry.at).toLocaleString()) : ""}</span>
@@ -1848,6 +1946,7 @@ function renderToolEvent(entry) {
       <strong class="event-path">${escapeHtml(toolName)}</strong>
       ${argPreview ? `<code class="event-inline-code">${escapeHtml(argPreview)}</code>` : ""}
       ${data.error || data.reason ? `<div class="event-fold-note">${escapeHtml(data.error || data.reason)}</div>` : ""}
+      ${embeddedResult || (toolName === "finish" && resultText ? `<div class="markdown-body">${renderMarkdown(resultText)}</div>` : "")}
       ${stdout ? `<div class="log-stream-title">stdout</div><pre class="event-output">${escapeHtml(stdout.text)}</pre>` : ""}
       ${stdout?.hidden > 0 ? `<div class="event-fold-note">... ${stdout.hidden} more stdout line(s) folded</div>` : ""}
       ${stderr ? `<div class="log-stream-title">stderr</div><pre class="event-output">${escapeHtml(stderr.text)}</pre>` : ""}
@@ -1862,13 +1961,14 @@ function renderStatusEvent(entry) {
   const label = entry.eventLabel || message.replace(/^[^.]+\./, "");
   const content = data.result || data.error || data.reason || entry.content || "";
   const failed = message === "session.failed";
+  const embeddedResult = content ? renderEmbeddedWorkspaceResult(content, entry) : "";
   return `
-    <article class="event-card ${failed ? "event-failed" : "event-muted"}">
+    <article class="event-card ${failed ? "event-failed" : message === "session.finished" && embeddedResult ? "event-finish" : "event-muted"}">
       <div class="event-card-meta">
         <span>${escapeHtml(label)}</span>
         <span>${entry.at ? escapeHtml(new Date(entry.at).toLocaleString()) : ""}</span>
       </div>
-      ${content ? `<div class="chat-content">${escapeHtml(content)}</div>` : ""}
+      ${embeddedResult || (content ? `<div class="chat-content">${escapeHtml(content)}</div>` : "")}
     </article>
   `;
 }
@@ -1907,15 +2007,82 @@ 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 || "" }) : "";
   const parts = [
     `<div class="log-line">${escapeHtml(`status=${run.status} session=${run.sessionId} provider=${run.provider} model=${run.model}`)}</div>`,
-    run.result ? `<div class="log-line">${escapeHtml(`result=${run.result}`)}</div>` : "",
+    structuredRunResult
+      ? `<article class="event-card event-finish"><div class="event-card-meta"><span>result</span></div>${structuredRunResult}</article>`
+      : run.result
+        ? `<div class="log-line">${escapeHtml(`result=${run.result}`)}</div>`
+        : "",
     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);
@@ -2174,12 +2341,41 @@ function renderChat(chatEntries) {
           </article>
         `;
       }
+      if (entry.role === "tool") {
+        try {
+          const parsed = JSON.parse(entry.content || "{}");
+          const toolName = parsed.toolName || "tool";
+          return renderToolEvent({
+            role: "event",
+            eventType: parsed.ok === false ? "tool.failed" : "tool.completed",
+            message: parsed.ok === false ? "tool.failed" : "tool.completed",
+            eventLabel: parsed.ok === false ? "tool failed" : "tool done",
+            data: parsed,
+            content: parsed.result || toolName,
+            at: entry.at,
+          });
+        } catch {
+          return `
+            <article class="event-card event-tool">
+              <div class="event-card-meta">tool${entry.at ? ` · ${new Date(entry.at).toLocaleString()}` : ""}</div>
+              <pre class="event-output">${escapeHtml(entry.content || "")}</pre>
+            </article>
+          `;
+        }
+      }
       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

@@ -1264,6 +1264,19 @@ button.danger {
   border-color: rgba(59, 130, 246, 0.28);
 }
 
+.event-finish {
+  border-color: rgba(16, 185, 129, 0.36);
+  background:
+    radial-gradient(circle at 0% 0%, rgba(16, 185, 129, 0.14), transparent 30%),
+    rgba(236, 253, 245, 0.46);
+}
+
+#logs .event-finish {
+  background:
+    radial-gradient(circle at 0% 0%, rgba(16, 185, 129, 0.16), transparent 30%),
+    rgba(6, 78, 59, 0.28);
+}
+
 .event-failed {
   border-color: rgba(248, 113, 113, 0.45);
   background: rgba(127, 29, 29, 0.12);
@@ -1337,6 +1350,31 @@ button.danger {
   font-size: 0.8rem;
 }
 
+.event-result-summary {
+  margin: 4px 0 12px;
+  padding: 10px 12px;
+  border-radius: 12px;
+  background: rgba(15, 118, 110, 0.08);
+}
+
+#logs .event-result-summary {
+  background: rgba(255, 255, 255, 0.08);
+}
+
+.embedded-change-list {
+  display: grid;
+  gap: 8px;
+}
+
+.embedded-change-list > .event-card {
+  margin: 0;
+  box-shadow: none;
+}
+
+.assistant-result-card {
+  margin: 0;
+}
+
 #logs .event-fold-note {
   color: #94a3b8;
 }

package/scripts/smoke-cli-chat.js

@@ -896,6 +896,13 @@ 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 (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-web-ui.js

@@ -209,6 +209,29 @@ try {
     const chatTail = (await page.locator("#chat-thread").innerText().catch(() => "")).slice(-1200);
     throw new Error(`web UI did not render formatted file-change diff event; state=${state}\nlogs tail:\n${logsTail}\nchat tail:\n${chatTail}`);
   }
+  try {
+    await page.waitForFunction(
+      () =>
+        [...document.querySelectorAll(".event-finish .change-diff")].some((node) =>
+          (node.textContent || "").includes("+Created by AgInTiFlow mock mode.")
+        ),
+      null,
+      { timeout: 30000 }
+    );
+  } catch (error) {
+    const state = await page.locator("#run-state").evaluate((node) => node.dataset.status || "").catch(() => "unknown");
+    const logsTail = (await page.locator("#logs").innerText().catch(() => "")).slice(-1200);
+    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]");
@@ -246,6 +269,8 @@ try {
           "new-session-resets-scope",
           "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/interactive-cli.js

@@ -778,6 +778,112 @@ export function formatWorkspaceChange(change = {}) {
   };
 }
 
+function embeddedWorkspaceChangesFromText(value = "") {
+  const lines = String(value || "").split(/\r?\n/);
+  const changes = [];
+  let currentTool = "";
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const toolMatch = lines[index].match(/^\s*Tool:\s*(.+?)\s*$/i);
+    if (toolMatch) {
+      currentTool = toolMatch[1].trim();
+      continue;
+    }
+
+    const pathMatch = lines[index].match(/^\s*Path:\s*(.+?)\s*$/i);
+    if (!pathMatch) continue;
+
+    let cursor = index + 1;
+    while (cursor < lines.length && !/^\s*Diff:\s*$/i.test(lines[cursor]) && !/^\s*(?:Tool|Path):\s*/i.test(lines[cursor])) {
+      cursor += 1;
+    }
+    if (!/^\s*Diff:\s*$/i.test(lines[cursor] || "")) continue;
+
+    const diffLines = [];
+    cursor += 1;
+    while (cursor < lines.length) {
+      if (diffLines.length && /^\s*(?:Tool|Path):\s*/i.test(lines[cursor])) break;
+      if (
+        diffLines.length &&
+        /^\s*(?:Output:|No command output|Blocked by guardrail\.|Mock run complete\.)/i.test(lines[cursor]) &&
+        !/^[-+@ ]/.test(lines[cursor])
+      ) {
+        break;
+      }
+      diffLines.push(lines[cursor]);
+      cursor += 1;
+    }
+    while (diffLines.length && !diffLines[diffLines.length - 1].trim()) diffLines.pop();
+    if (diffLines.length) {
+      changes.push({
+        toolName: currentTool || "write_file",
+        path: pathMatch[1].trim(),
+        diff: diffLines.join("\n"),
+      });
+      index = Math.max(index, cursor - 1);
+    }
+  }
+
+  return changes;
+}
+
+function embeddedWorkspaceSummary(value = "") {
+  const summary = [];
+  let skippingDiff = false;
+  for (const line of String(value || "").split(/\r?\n/)) {
+    if (/^\s*Diff:\s*$/i.test(line)) {
+      skippingDiff = true;
+      continue;
+    }
+    if (skippingDiff && /^\s*(?:Tool|Path):\s*/i.test(line)) skippingDiff = false;
+    if (skippingDiff) continue;
+    if (/^\s*Path:\s*/i.test(line)) continue;
+    summary.push(line);
+  }
+  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);
@@ -787,6 +893,17 @@ function printWorkspaceChange(change = {}) {
   for (const line of formatted.lines) outputLine(`${gutter}${line}`);
 }
 
+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 });
+  if (includeDiffs) {
+    for (const change of changes) printWorkspaceChange(change);
+  }
+  return true;
+}
+
 function printPreviewBlock(role, text, { time = "", bg = ansi.systemBg, maxLines = 5 } = {}) {
   const header = [label(role, bg).trimEnd(), time ? color(time, ansi.dim) : ""].filter(Boolean).join(" ");
   outputLine(header);
@@ -2201,9 +2318,38 @@ async function latestSession() {
 }
 
 function printHistoryEntry(entry) {
+  if (entry.role === "tool") {
+    const time = entry.at ? new Date(entry.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : "";
+    try {
+      const parsed = JSON.parse(entry.content || "{}");
+      if (parsed.toolName === "finish" && printEmbeddedWorkspaceResult(parsed.result || parsed.args?.result || "", { labelName: "finish", time })) {
+        return;
+      }
+      if (parsed.diff) {
+        printWorkspaceChange(parsed);
+        return;
+      }
+      outputLine(`${label(parsed.ok === false ? "fail" : "done", parsed.ok === false ? ansi.red : ansi.systemBg)} ${toolStatusDetails(parsed)}`);
+      return;
+    } catch {
+      printHistoryBlock("tool", entry.content, { time, bg: ansi.systemBg });
+      return;
+    }
+  }
   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 });
 }
 
@@ -2243,16 +2389,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,
@@ -2279,6 +2475,9 @@ function printResumeEvent(event = {}) {
       printWorkspaceChange(data);
       return true;
     }
+    if (data.toolName === "finish" && printEmbeddedWorkspaceResult(data.result || data.args?.result || "", { labelName: "finish" })) {
+      return true;
+    }
     if (data.toolName === "run_command") {
       printCommandOutputLog({
         command: data.args?.command || data.command || "",
@@ -2318,6 +2517,7 @@ function printResumeEvent(event = {}) {
     return true;
   }
   if (type === "session.finished") {
+    if (printEmbeddedWorkspaceResult(data.result || "", { labelName: "finish" })) return true;
     outputLine(`${label("state", ansi.systemBg)} status=finished${data.result ? ` result=${compactLine(data.result, 86)}` : ""}`);
     return true;
   }
@@ -2367,6 +2567,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)}`;
   }
@@ -4178,7 +4381,11 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
         } else if (type === "tool.started") {
           printStatusEvent(state, "tool", toolStatusDetails(data));
         } else if (type === "tool.completed" || type === "tool.failed") {
-          printStatusEvent(state, type === "tool.failed" || data.ok === false ? "tool_failed" : "tool_done", toolStatusDetails(data));
+          if (data.toolName === "finish" && printEmbeddedWorkspaceResult(data.result || data.args?.result || "", { labelName: "finish" })) {
+            // The finish tool can recap a workspace diff; render it like the original write/patch event.
+          } else {
+            printStatusEvent(state, type === "tool.failed" || data.ok === false ? "tool_failed" : "tool_done", toolStatusDetails(data));
+          }
         } else if (type === "file.changed") {
           printWorkspaceChange(data);
         } else if (type === "tool.blocked") {

package/web.js

@@ -107,6 +107,124 @@ function compactText(value = "", limit = 120) {
   return text.length <= limit ? text : `${text.slice(0, Math.max(limit - 1, 1)).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 embeddedWorkspaceChangesFromText(value = "") {
+  const lines = String(value || "").split(/\r?\n/);
+  const changes = [];
+  let currentTool = "";
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const toolMatch = lines[index].match(/^\s*Tool:\s*(.+?)\s*$/i);
+    if (toolMatch) {
+      currentTool = toolMatch[1].trim();
+      continue;
+    }
+
+    const pathMatch = lines[index].match(/^\s*Path:\s*(.+?)\s*$/i);
+    if (!pathMatch) continue;
+
+    let cursor = index + 1;
+    while (cursor < lines.length && !/^\s*Diff:\s*$/i.test(lines[cursor]) && !/^\s*(?:Tool|Path):\s*/i.test(lines[cursor])) {
+      cursor += 1;
+    }
+    if (!/^\s*Diff:\s*$/i.test(lines[cursor] || "")) continue;
+
+    const diffLines = [];
+    cursor += 1;
+    while (cursor < lines.length) {
+      if (diffLines.length && /^\s*(?:Tool|Path):\s*/i.test(lines[cursor])) break;
+      if (
+        diffLines.length &&
+        /^\s*(?:Output:|No command output|Blocked by guardrail\.|Mock run complete\.)/i.test(lines[cursor]) &&
+        !/^[-+@ ]/.test(lines[cursor])
+      ) {
+        break;
+      }
+      diffLines.push(lines[cursor]);
+      cursor += 1;
+    }
+    while (diffLines.length && !diffLines[diffLines.length - 1].trim()) diffLines.pop();
+    if (diffLines.length) {
+      changes.push({
+        toolName: currentTool || "write_file",
+        path: pathMatch[1].trim(),
+        diff: diffLines.join("\n"),
+      });
+      index = Math.max(index, cursor - 1);
+    }
+  }
+
+  return changes;
+}
+
+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 shouldSuppressTimelineEvent(event = {}, context = {}) {
+  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" && context.terminalToolKeys.has(toolLifecycleKey(event))) return true;
+  if (type === "tool.started" && toolName === "finish" && resultFingerprint) {
+    return context.chatResultFingerprints.has(resultFingerprint) || context.finishResultFingerprints.has(resultFingerprint);
+  }
+
+  if (["tool.completed", "tool.failed", "tool.skipped"].includes(type)) {
+    if (toolName === "finish" && resultFingerprint && context.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 && context.workspaceChangePaths.has(pathKey)) return true;
+      const changeKey = eventWorkspaceChangeFingerprint(event);
+      if (changeKey && context.workspaceChangeKeys.has(changeKey)) return true;
+    }
+  }
+
+  if (type === "session.finished" && resultFingerprint) {
+    return context.chatResultFingerprints.has(resultFingerprint) || context.finishResultFingerprints.has(resultFingerprint);
+  }
+
+  return false;
+}
+
 function toolTimelineSummary(data = {}) {
   const tool = data.toolName || "unknown";
   const args = data.args || {};
@@ -224,10 +342,44 @@ function timelineEntryForEvent(event = {}) {
 }
 
 function sessionTimelineFromChatAndEvents(chat = [], 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 suppressContext = {
+    chatResultFingerprints,
+    finishResultFingerprints,
+    terminalToolKeys,
+    workspaceChangeKeys,
+    workspaceChangePaths,
+  };
   const chatItems = (Array.isArray(chat) ? chat : [])
     .filter((entry) => entry?.content)
-    .map((entry, index) => ({ ...entry, order: index * 2, sortAt: Date.parse(entry.at || "") || 0 }));
-  const eventItems = (Array.isArray(events) ? events : [])
+    .map((entry, index) => {
+      const embeddedChanges = entry.role === "assistant" ? embeddedWorkspaceChangesFromText(entry.content) : [];
+      const suppressEmbeddedWorkspaceDiffs =
+        embeddedChanges.length > 0 && embeddedChanges.every((change) => workspaceChangeKeys.has(workspaceChangeFingerprint(change)));
+      return { ...entry, suppressEmbeddedWorkspaceDiffs, order: index * 2, sortAt: Date.parse(entry.at || "") || 0 };
+    });
+  const eventItems = eventList
+    .filter((event) => !shouldSuppressTimelineEvent(event, suppressContext))
     .map(timelineEntryForEvent)
     .filter(Boolean)
     .map((entry, index) => ({ ...entry, order: index * 2 + 1, sortAt: Date.parse(entry.at || "") || 0 }));