From fa75526c13e6ce621b97f14a3e840839d3270b20 Mon Sep 17 00:00:00 2001
From: Ammar <ammar+ai@ammar.io>
Date: Sat, 17 Jan 2026 18:38:34 -0600
Subject: [PATCH 1/4] refactor: centralize tool ui-only output

---
 .../tools/AskUserQuestionToolCall.tsx         |  10 +-
 src/browser/components/tools/BashToolCall.tsx |  13 +-
 .../components/tools/FileEditToolCall.tsx     |  15 +-
 .../tools/shared/ToolPrimitives.tsx           |  32 ++-
 .../components/tools/shared/toolUtils.tsx     |  19 +-
 src/browser/stores/GitStatusStore.ts          |   3 +
 .../messages/StreamingMessageAggregator.ts    |  10 +-
 .../messages/applyToolOutputRedaction.ts      |   6 +-
 .../utils/messages/toolOutputRedaction.ts     | 185 ------------------
 src/common/orpc/schemas/tools.ts              |  83 +++++---
 src/common/types/tools.ts                     |  42 +++-
 .../utils/tools/askUserQuestionSummary.ts     |   9 +
 src/common/utils/tools/toolDefinitions.ts     | 120 +++++++++---
 src/common/utils/tools/toolOutputUiOnly.ts    | 157 +++++++++++++++
 src/node/services/mock/mockAiRouter.ts        |   6 +-
 src/node/services/tools/ask_user_question.ts  |  31 ++-
 src/node/services/tools/bash.ts               |   3 +
 src/node/services/tools/file_edit_insert.ts   |  13 +-
 .../services/tools/file_edit_operation.ts     |  13 +-
 .../services/tools/file_edit_replace_lines.ts |   8 +-
 src/node/services/tools/notify.test.ts        |   6 +-
 src/node/services/tools/notify.ts             |  16 +-
 src/node/services/workspaceService.ts         |  10 +-
 23 files changed, 508 insertions(+), 302 deletions(-)
 delete mode 100644 src/browser/utils/messages/toolOutputRedaction.ts
 create mode 100644 src/common/utils/tools/askUserQuestionSummary.ts
 create mode 100644 src/common/utils/tools/toolOutputUiOnly.ts

diff --git a/src/browser/components/tools/AskUserQuestionToolCall.tsx b/src/browser/components/tools/AskUserQuestionToolCall.tsx
index 14fc7b6c25..a3187a7cd5 100644
--- a/src/browser/components/tools/AskUserQuestionToolCall.tsx
+++ b/src/browser/components/tools/AskUserQuestionToolCall.tsx
@@ -27,9 +27,10 @@ import type {
   AskUserQuestionQuestion,
   AskUserQuestionToolArgs,
   AskUserQuestionToolResult,
-  AskUserQuestionToolSuccessResult,
+  AskUserQuestionUiOnlyPayload,
   ToolErrorResult,
 } from "@/common/types/tools";
+import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 
 const OTHER_VALUE = "__other__";
 
@@ -59,7 +60,7 @@ function unwrapJsonContainer(value: unknown): unknown {
   return value;
 }
 
-function isAskUserQuestionToolSuccessResult(val: unknown): val is AskUserQuestionToolSuccessResult {
+function isAskUserQuestionPayload(val: unknown): val is AskUserQuestionUiOnlyPayload {
   if (!val || typeof val !== "object") {
     return false;
   }
@@ -262,8 +263,11 @@ export function AskUserQuestionToolCall(props: {
     return unwrapJsonContainer(props.result);
   }, [props.result]);
 
+  const uiOnlyPayload = getToolOutputUiOnly(resultUnwrapped)?.ask_user_question;
+
   const successResult =
-    resultUnwrapped && isAskUserQuestionToolSuccessResult(resultUnwrapped) ? resultUnwrapped : null;
+    uiOnlyPayload ??
+    (resultUnwrapped && isAskUserQuestionPayload(resultUnwrapped) ? resultUnwrapped : null);
 
   const errorResult =
     resultUnwrapped && isToolErrorResult(resultUnwrapped) ? resultUnwrapped : null;
diff --git a/src/browser/components/tools/BashToolCall.tsx b/src/browser/components/tools/BashToolCall.tsx
index 2c9c7ee544..7864d23713 100644
--- a/src/browser/components/tools/BashToolCall.tsx
+++ b/src/browser/components/tools/BashToolCall.tsx
@@ -19,6 +19,7 @@ import {
   useToolExpansion,
   getStatusDisplay,
   formatDuration,
+  getToolOutputSeverity,
   type ToolStatus,
 } from "./shared/toolUtils";
 import { cn } from "@/common/lib/utils";
@@ -195,6 +196,7 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
   const showLiveOutput =
     !isBackground && (status === "executing" || (Boolean(liveOutput) && !resultHasOutput));
 
+  const severity = getToolOutputSeverity(result);
   const canSendToBackground = Boolean(
     toolCallId && workspaceId && foregroundBashToolCallIds.has(toolCallId)
   );
@@ -204,7 +206,6 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
           sendToBackground(toolCallId);
         }
       : undefined;
-
   const truncatedInfo = result && "truncated" in result ? result.truncated : undefined;
 
   const handleToggle = () => {
@@ -254,11 +255,13 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
               {result && ` • took ${formatDuration(result.wall_duration_ms)}`}
               {!result && <ElapsedTimeDisplay startedAt={startedAt} isActive={isPending} />}
             </span>
-            {result && <ExitCodeBadge exitCode={result.exitCode} className="ml-2" />}
+            {result && (
+              <ExitCodeBadge exitCode={result.exitCode} className="ml-2" severity={severity} />
+            )}
           </>
         )}
-        <StatusIndicator status={effectiveStatus}>
-          {getStatusDisplay(effectiveStatus)}
+        <StatusIndicator status={effectiveStatus} severity={severity}>
+          {getStatusDisplay(effectiveStatus, severity)}
         </StatusIndicator>
         {/* Show "Background" button when bash is executing and can be sent to background.
             Use invisible when executing but not yet confirmed as foreground to avoid layout flash. */}
@@ -334,7 +337,7 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
               {result.success === false && result.error && (
                 <DetailSection>
                   <DetailLabel>Error</DetailLabel>
-                  <ErrorBox>{result.error}</ErrorBox>
+                  <ErrorBox severity={severity}>{result.error}</ErrorBox>
                 </DetailSection>
               )}
 
diff --git a/src/browser/components/tools/FileEditToolCall.tsx b/src/browser/components/tools/FileEditToolCall.tsx
index c96b9b53ae..dfd648aa83 100644
--- a/src/browser/components/tools/FileEditToolCall.tsx
+++ b/src/browser/components/tools/FileEditToolCall.tsx
@@ -9,6 +9,7 @@ import type {
   FileEditReplaceLinesToolArgs,
   FileEditReplaceLinesToolResult,
 } from "@/common/types/tools";
+import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 import {
   ToolContainer,
   ToolHeader,
@@ -104,6 +105,8 @@ export const FileEditToolCall: React.FC<FileEditToolCallProps> = ({
   const { expanded, toggleExpanded } = useToolExpansion(initialExpanded);
   const [showRaw, setShowRaw] = React.useState(false);
 
+  const uiOnlyDiff = getToolOutputUiOnly(result)?.file_edit?.diff;
+  const diff = result && result.success ? (uiOnlyDiff ?? result.diff) : undefined;
   const filePath = "file_path" in args ? args.file_path : undefined;
 
   // Copy to clipboard with feedback
@@ -111,11 +114,11 @@ export const FileEditToolCall: React.FC<FileEditToolCallProps> = ({
 
   // Build kebab menu items for successful edits with diffs
   const kebabMenuItems: KebabMenuItem[] =
-    result && result.success && result.diff
+    result && result.success && diff
       ? [
           {
             label: copied ? "Copied" : "Copy Patch",
-            onClick: () => void copyToClipboard(result.diff),
+            onClick: () => void copyToClipboard(diff),
           },
           {
             label: showRaw ? "Show Parsed" : "Show Patch",
@@ -139,7 +142,7 @@ export const FileEditToolCall: React.FC<FileEditToolCallProps> = ({
             <span className="font-monospace truncate">{filePath}</span>
           </div>
         </div>
-        {!(result && result.success && result.diff) && (
+        {!(result && result.success && diff) && (
           <StatusIndicator status={status}>{getStatusDisplay(status)}</StatusIndicator>
         )}
         {kebabMenuItems.length > 0 && (
@@ -161,15 +164,15 @@ export const FileEditToolCall: React.FC<FileEditToolCallProps> = ({
               )}
 
               {result.success &&
-                result.diff &&
+                diff &&
                 (showRaw ? (
                   <DiffContainer>
                     <pre className="font-monospace m-0 text-[11px] leading-[1.4] break-words whitespace-pre-wrap">
-                      {result.diff}
+                      {diff}
                     </pre>
                   </DiffContainer>
                 ) : (
-                  renderDiff(result.diff, filePath, onReviewNote)
+                  renderDiff(diff, filePath, onReviewNote)
                 ))}
             </>
           )}
diff --git a/src/browser/components/tools/shared/ToolPrimitives.tsx b/src/browser/components/tools/shared/ToolPrimitives.tsx
index 848f0cdf37..7eeeef737a 100644
--- a/src/browser/components/tools/shared/ToolPrimitives.tsx
+++ b/src/browser/components/tools/shared/ToolPrimitives.tsx
@@ -1,3 +1,4 @@
+import type { ToolOutputSeverity } from "@/common/types/tools";
 import React from "react";
 import { cn } from "@/common/lib/utils";
 import type { LucideIcon } from "lucide-react";
@@ -71,16 +72,17 @@ export const ToolName: React.FC<React.HTMLAttributes<HTMLSpanElement>> = ({
 
 interface StatusIndicatorProps extends React.HTMLAttributes<HTMLSpanElement> {
   status: string;
+  severity?: ToolOutputSeverity;
 }
 
-const getStatusColor = (status: string) => {
+const getStatusColor = (status: string, severity?: ToolOutputSeverity) => {
   switch (status) {
     case "executing":
       return "text-pending";
     case "completed":
       return "text-success";
     case "failed":
-      return "text-danger";
+      return severity === "soft" ? "text-warning" : "text-danger";
     case "interrupted":
       return "text-interrupted";
     case "backgrounded":
@@ -92,6 +94,7 @@ const getStatusColor = (status: string) => {
 
 export const StatusIndicator: React.FC<StatusIndicatorProps> = ({
   status,
+  severity,
   className,
   children,
   ...props
@@ -100,7 +103,7 @@ export const StatusIndicator: React.FC<StatusIndicatorProps> = ({
     className={cn(
       "text-[10px] ml-auto opacity-80 whitespace-nowrap shrink-0",
       "[&_.status-text]:inline [@container(max-width:350px)]:[&_.status-text]:hidden",
-      getStatusColor(status),
+      getStatusColor(status, severity),
       className
     )}
     {...props}
@@ -230,13 +233,17 @@ export const ToolIcon: React.FC<ToolIconProps> = ({ toolName, emoji, className }
 /**
  * Error display box with danger styling
  */
-export const ErrorBox: React.FC<React.HTMLAttributes<HTMLDivElement>> = ({
-  className,
-  ...props
-}) => (
+interface ErrorBoxProps extends React.HTMLAttributes<HTMLDivElement> {
+  severity?: ToolOutputSeverity;
+}
+
+export const ErrorBox: React.FC<ErrorBoxProps> = ({ className, severity, ...props }) => (
   <div
     className={cn(
-      "text-danger bg-danger-overlay border-danger rounded border-l-2 px-2 py-1.5 text-[11px]",
+      "rounded border-l-2 px-2 py-1.5 text-[11px]",
+      severity === "soft"
+        ? "text-warning bg-warning-overlay border-warning"
+        : "text-danger bg-danger-overlay border-danger",
       className
     )}
     {...props}
@@ -249,13 +256,18 @@ export const ErrorBox: React.FC<React.HTMLAttributes<HTMLDivElement>> = ({
 interface ExitCodeBadgeProps {
   exitCode: number;
   className?: string;
+  severity?: ToolOutputSeverity;
 }
 
-export const ExitCodeBadge: React.FC<ExitCodeBadgeProps> = ({ exitCode, className }) => (
+export const ExitCodeBadge: React.FC<ExitCodeBadgeProps> = ({ exitCode, className, severity }) => (
   <span
     className={cn(
       "inline-block shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium whitespace-nowrap",
-      exitCode === 0 ? "bg-success text-on-success" : "bg-danger text-on-danger",
+      exitCode === 0
+        ? "bg-success text-on-success"
+        : severity === "soft"
+          ? "bg-warning text-on-warning"
+          : "bg-danger text-on-danger",
       className
     )}
   >
diff --git a/src/browser/components/tools/shared/toolUtils.tsx b/src/browser/components/tools/shared/toolUtils.tsx
index c8cb26f9f1..9402154f39 100644
--- a/src/browser/components/tools/shared/toolUtils.tsx
+++ b/src/browser/components/tools/shared/toolUtils.tsx
@@ -1,7 +1,8 @@
 import React, { useState } from "react";
 import { AlertTriangle, Check, CircleDot, X } from "lucide-react";
+import type { ToolErrorResult, ToolOutputSeverity } from "@/common/types/tools";
+import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 import { LoadingDots } from "./ToolPrimitives";
-import type { ToolErrorResult } from "@/common/types/tools";
 
 /**
  * Shared utilities and hooks for tool components
@@ -27,7 +28,10 @@ export function useToolExpansion(initialExpanded = false) {
 /**
  * Get display element for tool status
  */
-export function getStatusDisplay(status: ToolStatus): React.ReactNode {
+export function getStatusDisplay(
+  status: ToolStatus,
+  severity?: ToolOutputSeverity
+): React.ReactNode {
   switch (status) {
     case "executing":
       return (
@@ -43,6 +47,13 @@ export function getStatusDisplay(status: ToolStatus): React.ReactNode {
         </>
       );
     case "failed":
+      if (severity === "soft") {
+        return (
+          <>
+            ⚠<span className="status-text"> warning</span>
+          </>
+        );
+      }
       return (
         <>
           <X aria-hidden="true" className="mr-1 inline-block h-3 w-3 align-[-2px]" />
@@ -93,6 +104,10 @@ export function formatDuration(ms: number): string {
   return `${Math.round(ms / 3600000)}h`;
 }
 
+export function getToolOutputSeverity(output: unknown): ToolOutputSeverity | undefined {
+  return getToolOutputUiOnly(output)?.severity;
+}
+
 /**
  * Type guard for ToolErrorResult shape: { success: false, error: string }.
  * Use this when you need type narrowing to access error.
diff --git a/src/browser/stores/GitStatusStore.ts b/src/browser/stores/GitStatusStore.ts
index 4874306367..a7e824d67a 100644
--- a/src/browser/stores/GitStatusStore.ts
+++ b/src/browser/stores/GitStatusStore.ts
@@ -11,6 +11,7 @@ import { STORAGE_KEYS, WORKSPACE_DEFAULTS } from "@/constants/workspaceDefaults"
 import { useSyncExternalStore } from "react";
 import { MapStore } from "./MapStore";
 import { isSSHRuntime } from "@/common/types/runtime";
+import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 import { RefreshController } from "@/browser/utils/RefreshController";
 
 /**
@@ -332,8 +333,10 @@ export class GitStatusStore {
       }
 
       if (!result.data.success) {
+        const uiOnlySeverity = getToolOutputUiOnly(result.data)?.severity;
         // Don't log output overflow errors at all (common in large repos, handled gracefully)
         if (
+          uiOnlySeverity !== "soft" &&
           !result.data.error?.includes("OUTPUT TRUNCATED") &&
           !result.data.error?.includes("OUTPUT OVERFLOW")
         ) {
diff --git a/src/browser/utils/messages/StreamingMessageAggregator.ts b/src/browser/utils/messages/StreamingMessageAggregator.ts
index 137bbb5cde..51cfc1275f 100644
--- a/src/browser/utils/messages/StreamingMessageAggregator.ts
+++ b/src/browser/utils/messages/StreamingMessageAggregator.ts
@@ -23,6 +23,7 @@ import type {
 } from "@/common/types/stream";
 import type { LanguageModelV2Usage } from "@ai-sdk/provider";
 import type { TodoItem, StatusSetToolResult, NotifyToolResult } from "@/common/types/tools";
+import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 
 import type { WorkspaceChatMessage, StreamErrorMessage, DeleteMessage } from "@/common/orpc/types";
 import { isInitStart, isInitOutput, isInitEnd, isMuxMessage } from "@/common/orpc/types";
@@ -1417,8 +1418,13 @@ export class StreamingMessageAggregator {
     // Handle browser notifications when Electron wasn't available
     if (toolName === "notify" && hasSuccessResult(output)) {
       const result = output as Extract<NotifyToolResult, { success: true }>;
-      if (result.notifiedVia === "browser") {
-        this.sendBrowserNotification(result.title, result.message, result.workspaceId);
+      const uiOnlyNotify = getToolOutputUiOnly(output)?.notify;
+      const legacyNotify = output as { notifiedVia?: string; workspaceId?: string };
+      const notifiedVia = uiOnlyNotify?.notifiedVia ?? legacyNotify.notifiedVia;
+      const workspaceId = uiOnlyNotify?.workspaceId ?? legacyNotify.workspaceId;
+
+      if (notifiedVia === "browser") {
+        this.sendBrowserNotification(result.title, result.message, workspaceId);
       }
     }
 
diff --git a/src/browser/utils/messages/applyToolOutputRedaction.ts b/src/browser/utils/messages/applyToolOutputRedaction.ts
index ee3171d61d..bd2290d147 100644
--- a/src/browser/utils/messages/applyToolOutputRedaction.ts
+++ b/src/browser/utils/messages/applyToolOutputRedaction.ts
@@ -1,9 +1,9 @@
 /**
- * Apply centralized tool-output redaction to a list of MuxMessages.
+ * Strip UI-only tool output before sending to providers.
  * Produces a cloned array safe for sending to providers without touching persisted history/UI.
  */
 import type { MuxMessage } from "@/common/types/message";
-import { redactToolOutput } from "./toolOutputRedaction";
+import { stripToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 
 export function applyToolOutputRedaction(messages: MuxMessage[]): MuxMessage[] {
   return messages.map((msg) => {
@@ -15,7 +15,7 @@ export function applyToolOutputRedaction(messages: MuxMessage[]): MuxMessage[] {
 
       return {
         ...part,
-        output: redactToolOutput(part.toolName, part.output),
+        output: stripToolOutputUiOnly(part.output),
       };
     });
 
diff --git a/src/browser/utils/messages/toolOutputRedaction.ts b/src/browser/utils/messages/toolOutputRedaction.ts
deleted file mode 100644
index a30bd72ac7..0000000000
--- a/src/browser/utils/messages/toolOutputRedaction.ts
+++ /dev/null
@@ -1,185 +0,0 @@
-/**
- * Centralized registry for redacting heavy tool outputs before sending to providers.
- *
- * Phase 1 policy:
- * - Keep tool results intact in persisted history and UI.
- * - When building provider requests, redact/compact known heavy fields.
- *
- * Why centralize:
- * - Single source of truth for redaction logic.
- * - Type safety: if a tool's result type changes, these redactors should fail type-checks.
- */
-
-import type {
-  AskUserQuestionToolSuccessResult,
-  FileEditInsertToolResult,
-  FileEditReplaceStringToolResult,
-  FileEditReplaceLinesToolResult,
-  NotifyToolResult,
-} from "@/common/types/tools";
-
-// Tool-output from AI SDK is often wrapped like: { type: 'json', value: <payload> }
-// Keep this helper local so all redactors handle both wrapped and plain objects consistently.
-function unwrapJsonContainer(output: unknown): { wrapped: boolean; value: unknown } {
-  if (output && typeof output === "object" && "type" in output && "value" in output) {
-    const obj = output as { type: unknown; value: unknown };
-    if (obj.type === "json") {
-      return { wrapped: true, value: obj.value };
-    }
-  }
-  return { wrapped: false, value: output };
-}
-
-function rewrapJsonContainer(wrapped: boolean, value: unknown): unknown {
-  if (wrapped) {
-    const result: { type: string; value: unknown } = { type: "json", value };
-    return result;
-  }
-  return value;
-}
-
-function isFileEditInsertResult(v: unknown): v is FileEditInsertToolResult {
-  return (
-    typeof v === "object" &&
-    v !== null &&
-    "success" in v &&
-    typeof (v as { success: unknown }).success === "boolean"
-  );
-}
-// Narrowing helpers for our tool result types
-function isFileEditResult(
-  v: unknown
-): v is FileEditReplaceStringToolResult | FileEditReplaceLinesToolResult {
-  return (
-    typeof v === "object" &&
-    v !== null &&
-    "success" in v &&
-    typeof (v as { success: unknown }).success === "boolean"
-  );
-}
-
-// Redactors per tool - unified for both string and line replace
-function redactFileEditReplace(output: unknown): unknown {
-  const unwrapped = unwrapJsonContainer(output);
-  const val = unwrapped.value;
-
-  if (!isFileEditResult(val)) return output; // unknown structure, leave as-is
-
-  if (val.success && "edits_applied" in val) {
-    // Build base compact result
-    const compact: Record<string, unknown> = {
-      success: true,
-      edits_applied: val.edits_applied,
-      diff: "[diff omitted in context - call file_read on the target file if needed]",
-    };
-
-    // Preserve line metadata for line-based edits (only if present)
-    if ("lines_replaced" in val) {
-      compact.lines_replaced = val.lines_replaced;
-    }
-    if ("line_delta" in val) {
-      compact.line_delta = val.line_delta;
-    }
-
-    return rewrapJsonContainer(unwrapped.wrapped, compact);
-  }
-
-  // Failure payloads are small; pass through unchanged
-  return output;
-}
-
-function redactFileEditInsert(output: unknown): unknown {
-  const unwrapped = unwrapJsonContainer(output);
-  const val = unwrapped.value;
-
-  if (!isFileEditInsertResult(val)) return output;
-
-  if (val.success) {
-    const compact: FileEditInsertToolResult = {
-      success: true,
-      diff: "[diff omitted in context - call file_read on the target file if needed]",
-    };
-    return rewrapJsonContainer(unwrapped.wrapped, compact);
-  }
-
-  return output;
-}
-
-function isAskUserQuestionToolSuccessResult(val: unknown): val is AskUserQuestionToolSuccessResult {
-  if (!val || typeof val !== "object") return false;
-  const record = val as Record<string, unknown>;
-
-  if (!Array.isArray(record.questions)) return false;
-  if (!record.answers || typeof record.answers !== "object") return false;
-
-  // answers is Record<string,string>
-  for (const [k, v] of Object.entries(record.answers as Record<string, unknown>)) {
-    if (typeof k !== "string" || typeof v !== "string") return false;
-  }
-
-  return true;
-}
-
-function redactAskUserQuestion(output: unknown): unknown {
-  const unwrapped = unwrapJsonContainer(output);
-  const val = unwrapped.value;
-
-  if (!isAskUserQuestionToolSuccessResult(val)) {
-    return output;
-  }
-
-  const pairs = Object.entries(val.answers)
-    .map(([question, answer]) => `"${question}"="${answer}"`)
-    .join(", ");
-
-  const summary =
-    pairs.length > 0
-      ? `User has answered your questions: ${pairs}. You can now continue with the user's answers in mind.`
-      : "User has answered your questions. You can now continue with the user's answers in mind.";
-
-  return rewrapJsonContainer(unwrapped.wrapped, summary);
-}
-
-function isNotifyResult(val: unknown): val is NotifyToolResult {
-  return (
-    typeof val === "object" &&
-    val !== null &&
-    "success" in val &&
-    typeof (val as { success: unknown }).success === "boolean"
-  );
-}
-
-/**
- * Redact notify tool output to remove internal routing fields (notifiedVia, workspaceId).
- * The model only needs to know the notification succeeded.
- */
-function redactNotify(output: unknown): unknown {
-  const unwrapped = unwrapJsonContainer(output);
-  const val = unwrapped.value;
-
-  if (!isNotifyResult(val)) return output;
-
-  if (val.success) {
-    return rewrapJsonContainer(unwrapped.wrapped, { success: true });
-  }
-
-  // Failure payloads pass through unchanged
-  return output;
-}
-
-// Public API - registry entrypoint. Add new tools here as needed.
-export function redactToolOutput(toolName: string, output: unknown): unknown {
-  switch (toolName) {
-    case "ask_user_question":
-      return redactAskUserQuestion(output);
-    case "file_edit_replace_string":
-    case "file_edit_replace_lines":
-      return redactFileEditReplace(output);
-    case "file_edit_insert":
-      return redactFileEditInsert(output);
-    case "notify":
-      return redactNotify(output);
-    default:
-      return output;
-  }
-}
diff --git a/src/common/orpc/schemas/tools.ts b/src/common/orpc/schemas/tools.ts
index f8fc19c770..0ab37dc848 100644
--- a/src/common/orpc/schemas/tools.ts
+++ b/src/common/orpc/schemas/tools.ts
@@ -1,33 +1,62 @@
 import { z } from "zod";
 
+const ToolOutputUiOnlySchema = z.object({
+  severity: z.enum(["soft", "hard"]).optional(),
+  ask_user_question: z
+    .object({
+      questions: z.array(z.unknown()),
+      answers: z.record(z.string(), z.string()),
+    })
+    .optional(),
+  file_edit: z
+    .object({
+      diff: z.string(),
+    })
+    .optional(),
+  notify: z
+    .object({
+      notifiedVia: z.enum(["electron", "browser"]),
+      workspaceId: z.string().optional(),
+    })
+    .optional(),
+});
+
+const ToolOutputUiOnlyFieldSchema = {
+  ui_only: ToolOutputUiOnlySchema.optional(),
+};
+
 export const BashToolResultSchema = z.discriminatedUnion("success", [
-  z.object({
-    success: z.literal(true),
-    wall_duration_ms: z.number(),
-    output: z.string(),
-    exitCode: z.literal(0),
-    note: z.string().optional(),
-    truncated: z
-      .object({
-        reason: z.string(),
-        totalLines: z.number(),
-      })
-      .optional(),
-  }),
-  z.object({
-    success: z.literal(false),
-    wall_duration_ms: z.number(),
-    output: z.string().optional(),
-    exitCode: z.number(),
-    error: z.string(),
-    note: z.string().optional(),
-    truncated: z
-      .object({
-        reason: z.string(),
-        totalLines: z.number(),
-      })
-      .optional(),
-  }),
+  z
+    .object({
+      success: z.literal(true),
+      wall_duration_ms: z.number(),
+      output: z.string(),
+      exitCode: z.literal(0),
+      note: z.string().optional(),
+      truncated: z
+        .object({
+          reason: z.string(),
+          totalLines: z.number(),
+        })
+        .optional(),
+    })
+    .extend(ToolOutputUiOnlyFieldSchema),
+  z
+    .object({
+      success: z.literal(false),
+      wall_duration_ms: z.number(),
+      output: z.string().optional(),
+      exitCode: z.number(),
+      error: z.string(),
+      note: z.string().optional(),
+      truncated: z
+        .object({
+          reason: z.string(),
+          totalLines: z.number(),
+        })
+        .optional(),
+    })
+    .extend(ToolOutputUiOnlyFieldSchema),
 ]);
 
 export const FileTreeNodeSchema = z.object({
diff --git a/src/common/types/tools.ts b/src/common/types/tools.ts
index 864362afa5..6531e3b06d 100644
--- a/src/common/types/tools.ts
+++ b/src/common/types/tools.ts
@@ -54,16 +54,45 @@ export type AgentSkillReadFileToolArgs = z.infer<
 >;
 export type AgentSkillReadFileToolResult = z.infer<typeof AgentSkillReadFileToolResultSchema>;
 
+export type ToolOutputSeverity = "soft" | "hard";
+
+export interface AskUserQuestionUiOnlyPayload {
+  questions: AskUserQuestionQuestion[];
+  answers: Record<string, string>;
+}
+
+export interface FileEditUiOnlyPayload {
+  diff: string;
+}
+
+export interface NotifyUiOnlyPayload {
+  notifiedVia: "electron" | "browser";
+  workspaceId?: string;
+}
+
+export interface ToolOutputUiOnly {
+  severity?: ToolOutputSeverity;
+  ask_user_question?: AskUserQuestionUiOnlyPayload;
+  file_edit?: FileEditUiOnlyPayload;
+  notify?: NotifyUiOnlyPayload;
+}
+
+export interface ToolOutputUiOnlyFields {
+  ui_only?: ToolOutputUiOnly;
+}
 // FileReadToolResult derived from Zod schema (single source of truth)
 export type FileReadToolResult = z.infer<typeof FileReadToolResultSchema>;
 
-export interface FileEditDiffSuccessBase {
+export interface FileEditDiffSuccessBase extends ToolOutputUiOnlyFields {
   success: true;
   diff: string;
   warning?: string;
 }
 
-export interface FileEditErrorResult {
+export const FILE_EDIT_DIFF_OMITTED_MESSAGE =
+  "[diff omitted in context - call file_read on the target file if needed]";
+
+export interface FileEditErrorResult extends ToolOutputUiOnlyFields {
   success: false;
   error: string;
   note?: string; // Agent-only message (not displayed in UI)
@@ -147,7 +176,7 @@ export const TOOL_EDIT_WARNING =
   "Always check the tool result before proceeding with other operations.";
 
 // Generic tool error shape emitted via streamManager on tool-error parts.
-export interface ToolErrorResult {
+export interface ToolErrorResult extends ToolOutputUiOnlyFields {
   success: false;
   error: string;
 }
@@ -313,14 +342,11 @@ export type WebFetchToolResult = z.infer<typeof WebFetchToolResultSchema>;
 
 // Notify Tool Types
 export type NotifyToolResult =
-  | {
+  | (ToolOutputUiOnlyFields & {
       success: true;
-      notifiedVia: "electron" | "browser";
       title: string;
       message?: string;
-      /** Workspace ID for navigation on notification click */
-      workspaceId?: string;
-    }
+    })
   | {
       success: false;
       error: string;
diff --git a/src/common/utils/tools/askUserQuestionSummary.ts b/src/common/utils/tools/askUserQuestionSummary.ts
new file mode 100644
index 0000000000..b2f239eab8
--- /dev/null
+++ b/src/common/utils/tools/askUserQuestionSummary.ts
@@ -0,0 +1,9 @@
+export function buildAskUserQuestionSummary(answers: Record<string, string>): string {
+  const pairs = Object.entries(answers)
+    .map(([question, answer]) => `"${question}"="${answer}"`)
+    .join(", ");
+
+  return pairs.length > 0
+    ? `User has answered your questions: ${pairs}. You can now continue with the user's answers in mind.`
+    : "User has answered your questions. You can now continue with the user's answers in mind.";
+}
diff --git a/src/common/utils/tools/toolDefinitions.ts b/src/common/utils/tools/toolDefinitions.ts
index 25aae4d43b..54ab6f8df9 100644
--- a/src/common/utils/tools/toolDefinitions.ts
+++ b/src/common/utils/tools/toolDefinitions.ts
@@ -58,6 +58,31 @@ export const AskUserQuestionQuestionSchema = z
     }
   });
 
+const AskUserQuestionUiOnlySchema = z.object({
+  questions: z.array(AskUserQuestionQuestionSchema),
+  answers: z.record(z.string(), z.string()),
+});
+
+const ToolOutputUiOnlySchema = z.object({
+  severity: z.enum(["soft", "hard"]).optional(),
+  ask_user_question: AskUserQuestionUiOnlySchema.optional(),
+  file_edit: z
+    .object({
+      diff: z.string(),
+    })
+    .optional(),
+  notify: z
+    .object({
+      notifiedVia: z.enum(["electron", "browser"]),
+      workspaceId: z.string().optional(),
+    })
+    .optional(),
+});
+
+const ToolOutputUiOnlyFieldSchema = {
+  ui_only: ToolOutputUiOnlySchema.optional(),
+};
+
 export const AskUserQuestionToolArgsSchema = z
   .object({
     questions: z.array(AskUserQuestionQuestionSchema).min(1).max(4),
@@ -77,13 +102,24 @@ export const AskUserQuestionToolArgsSchema = z
     }
   });
 
-export const AskUserQuestionToolResultSchema = z
+const AskUserQuestionToolSummarySchema = z
+  .object({
+    summary: z.string(),
+  })
+  .extend(ToolOutputUiOnlyFieldSchema);
+
+const AskUserQuestionToolLegacySchema = z
   .object({
     questions: z.array(AskUserQuestionQuestionSchema),
     answers: z.record(z.string(), z.string()),
   })
   .strict();
 
+export const AskUserQuestionToolResultSchema = z.union([
+  AskUserQuestionToolSummarySchema,
+  AskUserQuestionToolLegacySchema,
+]);
+
 // -----------------------------------------------------------------------------
 // task (sub-workspaces as subagents)
 // -----------------------------------------------------------------------------
@@ -816,27 +852,30 @@ const TruncatedInfoSchema = z.object({
 /**
  * Bash tool result - success, background spawn, or failure.
  */
-export const BashToolResultSchema = z.union([
-  // Foreground success
-  z.object({
+const BashToolSuccessSchema = z
+  .object({
     success: z.literal(true),
     output: z.string(),
     exitCode: z.literal(0),
     wall_duration_ms: z.number(),
     note: z.string().optional(),
     truncated: TruncatedInfoSchema.optional(),
-  }),
-  // Background spawn success
-  z.object({
+  })
+  .extend(ToolOutputUiOnlyFieldSchema);
+
+const BashToolBackgroundSchema = z
+  .object({
     success: z.literal(true),
     output: z.string(),
     exitCode: z.literal(0),
     wall_duration_ms: z.number(),
     taskId: z.string(),
     backgroundProcessId: z.string(),
-  }),
-  // Failure
-  z.object({
+  })
+  .extend(ToolOutputUiOnlyFieldSchema);
+
+const BashToolFailureSchema = z
+  .object({
     success: z.literal(false),
     output: z.string().optional(),
     exitCode: z.number(),
@@ -844,7 +883,16 @@ export const BashToolResultSchema = z.union([
     wall_duration_ms: z.number(),
     note: z.string().optional(),
     truncated: TruncatedInfoSchema.optional(),
-  }),
+  })
+  .extend(ToolOutputUiOnlyFieldSchema);
+
+export const BashToolResultSchema = z.union([
+  // Foreground success
+  BashToolSuccessSchema,
+  // Background spawn success
+  BashToolBackgroundSchema,
+  // Failure
+  BashToolFailureSchema,
 ]);
 
 /**
@@ -945,33 +993,41 @@ export const AgentSkillReadFileToolResultSchema = FileReadToolResultSchema;
  * File edit insert tool result - diff or error.
  */
 export const FileEditInsertToolResultSchema = z.union([
-  z.object({
-    success: z.literal(true),
-    diff: z.string(),
-    warning: z.string().optional(),
-  }),
-  z.object({
-    success: z.literal(false),
-    error: z.string(),
-    note: z.string().optional(),
-  }),
+  z
+    .object({
+      success: z.literal(true),
+      diff: z.string(),
+      warning: z.string().optional(),
+    })
+    .extend(ToolOutputUiOnlyFieldSchema),
+  z
+    .object({
+      success: z.literal(false),
+      error: z.string(),
+      note: z.string().optional(),
+    })
+    .extend(ToolOutputUiOnlyFieldSchema),
 ]);
 
 /**
  * File edit replace string tool result - diff with edit count or error.
  */
 export const FileEditReplaceStringToolResultSchema = z.union([
-  z.object({
-    success: z.literal(true),
-    diff: z.string(),
-    edits_applied: z.number(),
-    warning: z.string().optional(),
-  }),
-  z.object({
-    success: z.literal(false),
-    error: z.string(),
-    note: z.string().optional(),
-  }),
+  z
+    .object({
+      success: z.literal(true),
+      diff: z.string(),
+      edits_applied: z.number(),
+      warning: z.string().optional(),
+    })
+    .extend(ToolOutputUiOnlyFieldSchema),
+  z
+    .object({
+      success: z.literal(false),
+      error: z.string(),
+      note: z.string().optional(),
+    })
+    .extend(ToolOutputUiOnlyFieldSchema),
 ]);
 
 /**
diff --git a/src/common/utils/tools/toolOutputUiOnly.ts b/src/common/utils/tools/toolOutputUiOnly.ts
new file mode 100644
index 0000000000..3558e7df39
--- /dev/null
+++ b/src/common/utils/tools/toolOutputUiOnly.ts
@@ -0,0 +1,157 @@
+import type {
+  AskUserQuestionUiOnlyPayload,
+  FileEditUiOnlyPayload,
+  NotifyUiOnlyPayload,
+  ToolOutputUiOnly,
+} from "@/common/types/tools";
+
+export const TOOL_OUTPUT_UI_ONLY_FIELD = "ui_only" as const;
+
+interface JsonContainer {
+  type: "json";
+  value: unknown;
+}
+
+function unwrapJsonContainer(output: unknown): { wrapped: boolean; value: unknown } {
+  if (output && typeof output === "object" && "type" in output && "value" in output) {
+    const record = output as { type?: unknown; value?: unknown };
+    if (record.type === "json") {
+      return { wrapped: true, value: record.value };
+    }
+  }
+  return { wrapped: false, value: output };
+}
+
+function rewrapJsonContainer(wrapped: boolean, value: unknown): unknown {
+  if (!wrapped) {
+    return value;
+  }
+
+  const container: JsonContainer = {
+    type: "json",
+    value,
+  };
+  return container;
+}
+
+function stripUiOnlyDeep(value: unknown): unknown {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(stripUiOnlyDeep);
+  }
+
+  const record = value as Record<string, unknown>;
+  const stripped: Record<string, unknown> = {};
+
+  for (const [key, nested] of Object.entries(record)) {
+    if (key === TOOL_OUTPUT_UI_ONLY_FIELD) {
+      continue;
+    }
+    stripped[key] = stripUiOnlyDeep(nested);
+  }
+
+  return stripped;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return Object.values(value).every((entry) => typeof entry === "string");
+}
+
+function isAskUserQuestionUiOnly(value: unknown): value is AskUserQuestionUiOnlyPayload {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  if (!Array.isArray(value.questions)) {
+    return false;
+  }
+
+  return isStringRecord(value.answers);
+}
+
+function isFileEditUiOnly(value: unknown): value is FileEditUiOnlyPayload {
+  return isRecord(value) && typeof value.diff === "string";
+}
+
+function isNotifyUiOnly(value: unknown): value is NotifyUiOnlyPayload {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  const notifiedVia = value.notifiedVia;
+  if (notifiedVia !== "electron" && notifiedVia !== "browser") {
+    return false;
+  }
+
+  if (
+    "workspaceId" in value &&
+    value.workspaceId !== undefined &&
+    typeof value.workspaceId !== "string"
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function isUiOnlyRecord(value: unknown): value is ToolOutputUiOnly {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  const record = value;
+
+  if ("severity" in record) {
+    const severity = record.severity;
+    if (severity !== undefined && severity !== "soft" && severity !== "hard") {
+      return false;
+    }
+  }
+
+  if ("ask_user_question" in record && !isAskUserQuestionUiOnly(record.ask_user_question)) {
+    return false;
+  }
+
+  if ("file_edit" in record && !isFileEditUiOnly(record.file_edit)) {
+    return false;
+  }
+
+  if ("notify" in record && !isNotifyUiOnly(record.notify)) {
+    return false;
+  }
+
+  return true;
+}
+
+export function getToolOutputUiOnly(output: unknown): ToolOutputUiOnly | undefined {
+  const unwrapped = unwrapJsonContainer(output);
+  const value = unwrapped.value;
+
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+
+  if (!(TOOL_OUTPUT_UI_ONLY_FIELD in value)) {
+    return undefined;
+  }
+
+  const uiOnly = (value as Record<string, unknown>)[TOOL_OUTPUT_UI_ONLY_FIELD];
+  return isUiOnlyRecord(uiOnly) ? uiOnly : undefined;
+}
+
+export function stripToolOutputUiOnly(output: unknown): unknown {
+  const unwrapped = unwrapJsonContainer(output);
+  const stripped = stripUiOnlyDeep(unwrapped.value);
+  return rewrapJsonContainer(unwrapped.wrapped, stripped);
+}
diff --git a/src/node/services/mock/mockAiRouter.ts b/src/node/services/mock/mockAiRouter.ts
index c4bcfce6eb..1d1e61d6c0 100644
--- a/src/node/services/mock/mockAiRouter.ts
+++ b/src/node/services/mock/mockAiRouter.ts
@@ -261,9 +261,13 @@ function buildToolNotifyReply(): MockAiRouterReply {
         },
         result: {
           success: true,
-          notifiedVia: "electron",
           title: "Task Complete",
           message: "Your requested task has been completed successfully.",
+          ui_only: {
+            notify: {
+              notifiedVia: "electron",
+            },
+          },
         },
       },
     ],
diff --git a/src/node/services/tools/ask_user_question.ts b/src/node/services/tools/ask_user_question.ts
index 3507a20332..3ff2def68d 100644
--- a/src/node/services/tools/ask_user_question.ts
+++ b/src/node/services/tools/ask_user_question.ts
@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { tool } from "ai";
 
 import type { AskUserQuestionToolResult } from "@/common/types/tools";
+import { buildAskUserQuestionSummary } from "@/common/utils/tools/askUserQuestionSummary";
 import type { ToolConfiguration, ToolFactory } from "@/common/utils/tools/tools";
 import { TOOL_DEFINITIONS } from "@/common/utils/tools/toolDefinitions";
 import { askUserQuestionManager } from "@/node/services/askUserQuestionManager";
@@ -15,7 +16,15 @@ export const createAskUserQuestionTool: ToolFactory = (config: ToolConfiguration
       // Claude Code allows passing pre-filled answers directly. If provided, we can short-circuit
       // and return immediately without prompting.
       if (args.answers && Object.keys(args.answers).length > 0) {
-        return { questions: args.questions, answers: args.answers };
+        return {
+          summary: buildAskUserQuestionSummary(args.answers),
+          ui_only: {
+            ask_user_question: {
+              questions: args.questions,
+              answers: args.answers,
+            },
+          },
+        };
       }
 
       assert(config.workspaceId, "ask_user_question requires a workspaceId");
@@ -29,7 +38,15 @@ export const createAskUserQuestionTool: ToolFactory = (config: ToolConfiguration
 
       if (!abortSignal) {
         const answers = await pendingPromise;
-        return { questions: args.questions, answers };
+        return {
+          summary: buildAskUserQuestionSummary(answers),
+          ui_only: {
+            ask_user_question: {
+              questions: args.questions,
+              answers,
+            },
+          },
+        };
       }
 
       if (abortSignal.aborted) {
@@ -60,7 +77,15 @@ export const createAskUserQuestionTool: ToolFactory = (config: ToolConfiguration
       const answers = await Promise.race([pendingPromise, abortPromise]);
       assert(answers && typeof answers === "object", "Expected answers to be an object");
 
-      return { questions: args.questions, answers };
+      return {
+        summary: buildAskUserQuestionSummary(answers),
+        ui_only: {
+          ask_user_question: {
+            questions: args.questions,
+            answers,
+          },
+        },
+      };
     },
   });
 };
diff --git a/src/node/services/tools/bash.ts b/src/node/services/tools/bash.ts
index dfa129cdb0..87b6374cfe 100644
--- a/src/node/services/tools/bash.ts
+++ b/src/node/services/tools/bash.ts
@@ -792,6 +792,9 @@ File will be automatically cleaned up when stream ends.`;
             error: output,
             exitCode: -1,
             wall_duration_ms,
+            ui_only: {
+              severity: "soft",
+            },
           };
         } catch (err) {
           // If temp file creation fails, fall back to original error
diff --git a/src/node/services/tools/file_edit_insert.ts b/src/node/services/tools/file_edit_insert.ts
index 08e772436f..40ea47d247 100644
--- a/src/node/services/tools/file_edit_insert.ts
+++ b/src/node/services/tools/file_edit_insert.ts
@@ -1,6 +1,10 @@
 import { tool } from "ai";
 import type { FileEditInsertToolArgs, FileEditInsertToolResult } from "@/common/types/tools";
-import { EDIT_FAILED_NOTE_PREFIX, NOTE_READ_FILE_RETRY } from "@/common/types/tools";
+import {
+  EDIT_FAILED_NOTE_PREFIX,
+  FILE_EDIT_DIFF_OMITTED_MESSAGE,
+  NOTE_READ_FILE_RETRY,
+} from "@/common/types/tools";
 import type { ToolConfiguration, ToolFactory } from "@/common/utils/tools/tools";
 import { TOOL_DEFINITIONS } from "@/common/utils/tools/toolDefinitions";
 import { generateDiff, validateAndCorrectPath, validatePlanModeAccess } from "./fileCommon";
@@ -98,7 +102,12 @@ export const createFileEditInsertTool: ToolFactory = (config: ToolConfiguration)
           const diff = generateDiff(resolvedPath, "", content);
           return {
             success: true,
-            diff,
+            diff: FILE_EDIT_DIFF_OMITTED_MESSAGE,
+            ui_only: {
+              file_edit: {
+                diff,
+              },
+            },
             ...(pathWarning && { warning: pathWarning }),
           };
         }
diff --git a/src/node/services/tools/file_edit_operation.ts b/src/node/services/tools/file_edit_operation.ts
index dc30dea76a..5142487b22 100644
--- a/src/node/services/tools/file_edit_operation.ts
+++ b/src/node/services/tools/file_edit_operation.ts
@@ -1,4 +1,8 @@
-import type { FileEditDiffSuccessBase, FileEditErrorResult } from "@/common/types/tools";
+import {
+  FILE_EDIT_DIFF_OMITTED_MESSAGE,
+  type FileEditDiffSuccessBase,
+  type FileEditErrorResult,
+} from "@/common/types/tools";
 import type { ToolConfiguration } from "@/common/utils/tools/tools";
 import {
   generateDiff,
@@ -143,7 +147,12 @@ export async function executeFileEditOperation<TMetadata>({
 
     return {
       success: true,
-      diff,
+      diff: FILE_EDIT_DIFF_OMITTED_MESSAGE,
+      ui_only: {
+        file_edit: {
+          diff,
+        },
+      },
       ...operationResult.metadata,
       ...(pathWarning && { warning: pathWarning }),
     };
diff --git a/src/node/services/tools/file_edit_replace_lines.ts b/src/node/services/tools/file_edit_replace_lines.ts
index 891c14b5fa..d4ec62e1fc 100644
--- a/src/node/services/tools/file_edit_replace_lines.ts
+++ b/src/node/services/tools/file_edit_replace_lines.ts
@@ -1,18 +1,20 @@
 import { tool } from "ai";
+import type { ToolOutputUiOnlyFields } from "@/common/types/tools";
 import type { ToolConfiguration, ToolFactory } from "@/common/utils/tools/tools";
 import { TOOL_DEFINITIONS } from "@/common/utils/tools/toolDefinitions";
 import { executeFileEditOperation } from "./file_edit_operation";
 import { handleLineReplace, type LineReplaceArgs } from "./file_edit_replace_shared";
 
-export interface FileEditReplaceLinesResult {
+export interface FileEditReplaceLinesResult extends ToolOutputUiOnlyFields {
   success: true;
   diff: string;
   edits_applied: number;
   lines_replaced: number;
   line_delta: number;
+  warning?: string;
 }
 
-export interface FileEditReplaceLinesError {
+export interface FileEditReplaceLinesError extends ToolOutputUiOnlyFields {
   success: false;
   error: string;
 }
@@ -43,6 +45,8 @@ export const createFileEditReplaceLinesTool: ToolFactory = (config: ToolConfigur
         return {
           success: true,
           diff: result.diff,
+          ui_only: result.ui_only,
+          warning: result.warning,
           edits_applied: result.edits_applied,
           lines_replaced: result.lines_replaced!,
           line_delta: result.line_delta!,
diff --git a/src/node/services/tools/notify.test.ts b/src/node/services/tools/notify.test.ts
index 9c3a98b335..fe6ef9d9b0 100644
--- a/src/node/services/tools/notify.test.ts
+++ b/src/node/services/tools/notify.test.ts
@@ -80,7 +80,7 @@ describe("notify tool", () => {
 
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.notifiedVia).toBe("browser");
+      expect(result.ui_only?.notify?.notifiedVia).toBe("browser");
       expect(result.title).toBe("Test Notification");
       expect(result.message).toBe("This is a test");
     }
@@ -100,7 +100,7 @@ describe("notify tool", () => {
     // In non-Electron, returns success with browser fallback
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.notifiedVia).toBe("browser");
+      expect(result.ui_only?.notify?.notifiedVia).toBe("browser");
       expect(result.title).toBe("Test Notification");
       expect(result.message).toBeUndefined();
     }
@@ -123,7 +123,7 @@ describe("notify tool", () => {
 
     expect(result.success).toBe(true);
     if (result.success) {
-      expect(result.workspaceId).toBe("test-workspace-123");
+      expect(result.ui_only?.notify?.workspaceId).toBe("test-workspace-123");
     }
   });
 });
diff --git a/src/node/services/tools/notify.ts b/src/node/services/tools/notify.ts
index 960955ebf3..222421c614 100644
--- a/src/node/services/tools/notify.ts
+++ b/src/node/services/tools/notify.ts
@@ -137,10 +137,14 @@ export const createNotifyTool: ToolFactory = (config) => {
       if (result.success) {
         return {
           success: true,
-          notifiedVia: "electron",
           title: truncatedTitle,
           message: truncatedMessage,
-          workspaceId: config.workspaceId,
+          ui_only: {
+            notify: {
+              notifiedVia: "electron",
+              workspaceId: config.workspaceId,
+            },
+          },
         };
       }
 
@@ -148,10 +152,14 @@ export const createNotifyTool: ToolFactory = (config) => {
       // This is not an error; the notification will be delivered via Web Notifications API
       return {
         success: true,
-        notifiedVia: "browser",
         title: truncatedTitle,
         message: truncatedMessage,
-        workspaceId: config.workspaceId,
+        ui_only: {
+          notify: {
+            notifiedVia: "browser",
+            workspaceId: config.workspaceId,
+          },
+        },
       };
     },
   });
diff --git a/src/node/services/workspaceService.ts b/src/node/services/workspaceService.ts
index 5801f7a904..0acd55c1ea 100644
--- a/src/node/services/workspaceService.ts
+++ b/src/node/services/workspaceService.ts
@@ -45,6 +45,7 @@ import type {
   WorkspaceActivitySnapshot,
 } from "@/common/types/workspace";
 import { isDynamicToolPart } from "@/common/types/toolParts";
+import { buildAskUserQuestionSummary } from "@/common/utils/tools/askUserQuestionSummary";
 import {
   AskUserQuestionToolArgsSchema,
   AskUserQuestionToolResultSchema,
@@ -1910,8 +1911,13 @@ export class WorkspaceService extends EventEmitter {
             }
 
             const nextOutput: AskUserQuestionToolSuccessResult = {
-              questions: parsedArgs.data.questions,
-              answers,
+              summary: buildAskUserQuestionSummary(answers),
+              ui_only: {
+                ask_user_question: {
+                  questions: parsedArgs.data.questions,
+                  answers,
+                },
+              },
             };
             output = nextOutput;
 

From d583f051f4e45062393a22764a303d6e817763c9 Mon Sep 17 00:00:00 2001
From: Ammar <ammar+ai@ammar.io>
Date: Sun, 18 Jan 2026 10:36:19 -0600
Subject: [PATCH 2/4] =?UTF-8?q?=F0=9F=A4=96=20fix:=20prefer=20ui=5Fonly=20?=
 =?UTF-8?q?diffs=20for=20compaction?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ensure edited file diff extraction prefers ui_only.file_edit.diff when present.

---

_Generated with `mux` • Model: `openai:gpt-5.2-codex` • Thinking: `xhigh` • Cost: `8.50`_
---
 .../utils/messages/extractEditedFiles.test.ts | 37 ++++++++++++++++++-
 .../utils/messages/extractEditedFiles.ts      |  9 ++++-
 2 files changed, 43 insertions(+), 3 deletions(-)

diff --git a/src/common/utils/messages/extractEditedFiles.test.ts b/src/common/utils/messages/extractEditedFiles.test.ts
index 21aeea44d8..6937083ba5 100644
--- a/src/common/utils/messages/extractEditedFiles.test.ts
+++ b/src/common/utils/messages/extractEditedFiles.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { createPatch } from "diff";
+import { FILE_EDIT_DIFF_OMITTED_MESSAGE } from "@/common/types/tools";
 import type { MuxMessage } from "@/common/types/message";
 import { extractEditedFileDiffs, extractEditedFilePaths } from "./extractEditedFiles";
 
@@ -11,6 +12,7 @@ function createAssistantMessage(
     toolName: string;
     filePath: string;
     diff: string;
+    uiOnlyDiff?: string;
     success?: boolean;
   }>
 ): MuxMessage {
@@ -23,7 +25,19 @@ function createAssistantMessage(
       toolName: tc.toolName,
       state: "output-available" as const,
       input: { file_path: tc.filePath },
-      output: { success: tc.success ?? true, diff: tc.diff },
+      output: {
+        success: tc.success ?? true,
+        diff: tc.diff,
+        ...(tc.uiOnlyDiff
+          ? {
+              ui_only: {
+                file_edit: {
+                  diff: tc.uiOnlyDiff,
+                },
+              },
+            }
+          : {}),
+      },
     })),
   };
 }
@@ -129,6 +143,27 @@ describe("extractEditedFileDiffs", () => {
     expect(result[0].diff).toBe(diff);
   });
 
+  it("should prefer ui_only diffs when present", () => {
+    const originalContent = "line1\nline2\nline3";
+    const newContent = "line1\nmodified\nline3";
+    const diff = makeDiff("/path/to/file.ts", originalContent, newContent);
+
+    const messages: MuxMessage[] = [
+      createAssistantMessage([
+        {
+          toolName: "file_edit_replace_string",
+          filePath: "/path/to/file.ts",
+          diff: FILE_EDIT_DIFF_OMITTED_MESSAGE,
+          uiOnlyDiff: diff,
+        },
+      ]),
+    ];
+
+    const result = extractEditedFileDiffs(messages);
+    expect(result).toHaveLength(1);
+    expect(result[0].diff).toBe(diff);
+  });
+
   it("should combine multiple non-overlapping diffs for the same file", () => {
     // Edit 1: change line 2
     const original = "line1\nline2\nline3\nline4\nline5";
diff --git a/src/common/utils/messages/extractEditedFiles.ts b/src/common/utils/messages/extractEditedFiles.ts
index dfc518d86e..917a6da45b 100644
--- a/src/common/utils/messages/extractEditedFiles.ts
+++ b/src/common/utils/messages/extractEditedFiles.ts
@@ -1,4 +1,5 @@
 import type { MuxMessage } from "@/common/types/message";
+import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 import { FILE_EDIT_TOOL_NAMES } from "@/common/types/tools";
 import { MAX_EDITED_FILES, MAX_FILE_CONTENT_SIZE } from "@/common/constants/attachments";
 import { applyPatch, createPatch, parsePatch } from "diff";
@@ -198,7 +199,11 @@ export function extractEditedFileDiffs(messages: MuxMessage[]): FileEditDiff[] {
       if (part.state !== "output-available") continue;
 
       const output = part.output as FileEditToolOutput | undefined;
-      if (!output?.success || !output.diff) continue;
+      if (!output?.success) continue;
+
+      const uiOnly = getToolOutputUiOnly(output);
+      const diff = uiOnly?.file_edit?.diff ?? output.diff;
+      if (!diff) continue;
 
       const input = part.input as FileEditToolInput | undefined;
       const filePath = input?.file_path;
@@ -208,7 +213,7 @@ export function extractEditedFileDiffs(messages: MuxMessage[]): FileEditDiff[] {
       if (!diffsByPath.has(filePath)) {
         diffsByPath.set(filePath, []);
       }
-      diffsByPath.get(filePath)!.push(output.diff);
+      diffsByPath.get(filePath)!.push(diff);
 
       // Update edit order (move to end if already exists)
       const idx = editOrder.indexOf(filePath);

From b8dd612e0b35088743b146e48c34ec050d7c0988 Mon Sep 17 00:00:00 2001
From: Ammar <ammar+ai@ammar.io>
Date: Wed, 21 Jan 2026 10:52:21 -0600
Subject: [PATCH 3/4] =?UTF-8?q?=F0=9F=A4=96=20fix:=20treat=20bash=20overfl?=
 =?UTF-8?q?ow=20as=20success?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/browser/components/tools/BashToolCall.tsx |   7 +-
 .../tools/shared/ToolPrimitives.tsx           |   2 +-
 src/node/services/tools/bash.test.ts          | 142 ++++++++++--------
 src/node/services/tools/bash.ts               |  13 +-
 4 files changed, 92 insertions(+), 72 deletions(-)

diff --git a/src/browser/components/tools/BashToolCall.tsx b/src/browser/components/tools/BashToolCall.tsx
index 7864d23713..7d9c9e5672 100644
--- a/src/browser/components/tools/BashToolCall.tsx
+++ b/src/browser/components/tools/BashToolCall.tsx
@@ -342,7 +342,12 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
               )}
 
               {truncatedInfo && (
-                <div className="text-muted px-2 text-[10px] italic">
+                <div
+                  className={cn(
+                    "px-2 text-[10px] italic",
+                    severity === "soft" ? "text-warning" : "text-muted"
+                  )}
+                >
                   Output truncated — reason: {truncatedInfo.reason} • totalLines:{" "}
                   {truncatedInfo.totalLines}
                 </div>
diff --git a/src/browser/components/tools/shared/ToolPrimitives.tsx b/src/browser/components/tools/shared/ToolPrimitives.tsx
index 7eeeef737a..1938e1eb59 100644
--- a/src/browser/components/tools/shared/ToolPrimitives.tsx
+++ b/src/browser/components/tools/shared/ToolPrimitives.tsx
@@ -80,7 +80,7 @@ const getStatusColor = (status: string, severity?: ToolOutputSeverity) => {
     case "executing":
       return "text-pending";
     case "completed":
-      return "text-success";
+      return severity === "soft" ? "text-warning" : "text-success";
     case "failed":
       return severity === "soft" ? "text-warning" : "text-danger";
     case "interrupted":
diff --git a/src/node/services/tools/bash.test.ts b/src/node/services/tools/bash.test.ts
index b7c012a027..933c1640c3 100644
--- a/src/node/services/tools/bash.test.ts
+++ b/src/node/services/tools/bash.test.ts
@@ -115,7 +115,7 @@ describe("bash tool", () => {
     }
   });
 
-  it("should fail when hard cap (300 lines) is exceeded", async () => {
+  it("should report overflow when hard cap (300 lines) is exceeded", async () => {
     using testEnv = createTestBashTool();
     const tool = testEnv.tool;
     const args: BashToolArgs = {
@@ -127,11 +127,12 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("Line count exceeded");
-      expect(result.error).toContain("300 lines");
-      expect(result.exitCode).toBe(-1);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.output).toContain("[OUTPUT OVERFLOW");
+      expect(result.output).toContain("Line count exceeded");
+      expect(result.output).toContain("300 lines");
+      expect(result.exitCode).toBe(0);
     }
   });
 
@@ -147,21 +148,22 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("[OUTPUT OVERFLOW");
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.output).toContain("[OUTPUT OVERFLOW");
       // Should contain specific overflow reason (one of the three types)
-      expect(result.error).toMatch(
+      expect(result.output).toMatch(
         /Line count exceeded|Total output exceeded|exceeded per-line limit/
       );
-      expect(result.error).toContain("Full output");
-      expect(result.error).toContain("lines) saved to");
-      expect(result.error).toContain("bash-");
-      expect(result.error).toContain(".txt");
-      expect(result.error).toContain("File will be automatically cleaned up when stream ends");
-
-      // Extract file path from error message (handles both "lines saved to" and "lines) saved to")
-      const match = /saved to (\/.+?\.txt)/.exec(result.error);
+      expect(result.output).toContain("Full output");
+      expect(result.output).toContain("lines) saved to");
+      expect(result.output).toContain("bash-");
+      expect(result.output).toContain(".txt");
+      expect(result.output).toContain("File will be automatically cleaned up when stream ends");
+      expect(result.exitCode).toBe(0);
+
+      // Extract file path from output message (handles both "lines saved to" and "lines) saved to")
+      const match = /saved to (\/.+?\.txt)/.exec(result.output);
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -186,13 +188,13 @@ describe("bash tool", () => {
     }
   });
 
-  it("should fail early when hard cap is reached", async () => {
+  it("should report overflow quickly when hard cap is reached", async () => {
     using testEnv = createTestBashTool();
     const tool = testEnv.tool;
     const startTime = performance.now();
 
     const args: BashToolArgs = {
-      // This will generate 500 lines quickly - should fail at 300
+      // This will generate 500 lines quickly - should report overflow at 300
       run_in_background: false,
       script: "for i in {1..500}; do echo line$i; done",
       timeout_secs: 5,
@@ -202,13 +204,14 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
     const duration = performance.now() - startTime;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
+    expect(result.success).toBe(true);
+    if (result.success) {
       // Should complete quickly since we stop at 300 lines
       expect(duration).toBeLessThan(4000);
-      expect(result.error).toContain("Line count exceeded");
-      expect(result.error).toContain("300 lines");
-      expect(result.exitCode).toBe(-1);
+      expect(result.output).toContain("[OUTPUT OVERFLOW");
+      expect(result.output).toContain("Line count exceeded");
+      expect(result.output).toContain("300 lines");
+      expect(result.exitCode).toBe(0);
     }
   });
 
@@ -350,12 +353,13 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
+    expect(result.success).toBe(true);
+    if (result.success) {
       // Should use tmpfile behavior
-      expect(result.error).toContain("[OUTPUT OVERFLOW");
-      expect(result.error).toContain("saved to");
-      expect(result.error).not.toContain("[OUTPUT TRUNCATED");
+      expect(result.output).toContain("[OUTPUT OVERFLOW");
+      expect(result.output).toContain("saved to");
+      expect(result.output).not.toContain("[OUTPUT TRUNCATED");
+      expect(result.exitCode).toBe(0);
 
       // Verify temp file was created in runtimeTempDir
       expect(fs.existsSync(tempDir.path)).toBe(true);
@@ -388,14 +392,15 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
+    expect(result.success).toBe(true);
+    if (result.success) {
       // Should hit display limit and save to temp file
-      expect(result.error).toContain("[OUTPUT OVERFLOW");
-      expect(result.error).toContain("saved to");
+      expect(result.output).toContain("[OUTPUT OVERFLOW");
+      expect(result.output).toContain("saved to");
+      expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file
-      const match = /saved to (\/.*?\.txt)/.exec(result.error);
+      const match = /saved to (\/.*?\.txt)/.exec(result.output);
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -443,13 +448,14 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
+    expect(result.success).toBe(true);
+    if (result.success) {
       // Should hit file limit
-      expect(result.error).toContain("file preservation limit");
+      expect(result.output).toContain("file preservation limit");
+      expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file
-      const match = /saved to (\/.*?\.txt)/.exec(result.error);
+      const match = /saved to (\/.*?\.txt)/.exec(result.output);
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -489,13 +495,14 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
+    expect(result.success).toBe(true);
+    if (result.success) {
       // Should hit display limit
-      expect(result.error).toContain("display limit");
+      expect(result.output).toContain("display limit");
+      expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file contains the completion marker
-      const match = /saved to (\/.*?\.txt)/.exec(result.error);
+      const match = /saved to (\/.*?\.txt)/.exec(result.output);
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -532,13 +539,14 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
+    expect(result.success).toBe(true);
+    if (result.success) {
       // Should hit per-line limit (file truncation, not display)
-      expect(result.error).toContain("per-line limit");
+      expect(result.output).toContain("per-line limit");
+      expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file does NOT contain the second echo
-      const match = /saved to (\/.*?\.txt)/.exec(result.error);
+      const match = /saved to (\/.*?\.txt)/.exec(result.output);
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -609,10 +617,12 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     // Should trigger display truncation at exactly 300 lines
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("300 lines");
-      expect(result.error).toContain("display limit");
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.output).toContain("[OUTPUT OVERFLOW");
+      expect(result.output).toContain("300 lines");
+      expect(result.output).toContain("display limit");
+      expect(result.exitCode).toBe(0);
     }
 
     tempDir[Symbol.dispose]();
@@ -908,7 +918,7 @@ describe("bash tool", () => {
     }
   });
 
-  it("should fail when line exceeds max line bytes", async () => {
+  it("should report overflow when line exceeds max line bytes", async () => {
     using testEnv = createTestBashTool();
     const tool = testEnv.tool;
     const longLine = "x".repeat(2000);
@@ -921,14 +931,14 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toMatch(/exceeded per-line limit|OUTPUT OVERFLOW/);
-      expect(result.exitCode).toBe(-1);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.output).toMatch(/exceeded per-line limit|OUTPUT OVERFLOW/);
+      expect(result.exitCode).toBe(0);
     }
   });
 
-  it("should fail when total bytes limit exceeded", async () => {
+  it("should report overflow when total bytes limit exceeded", async () => {
     using testEnv = createTestBashTool();
     const tool = testEnv.tool;
     const lineContent = "x".repeat(100);
@@ -942,14 +952,14 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
-      expect(result.exitCode).toBe(-1);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.output).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
+      expect(result.exitCode).toBe(0);
     }
   });
 
-  it("should fail early when byte limit is reached", async () => {
+  it("should report overflow when byte limit is reached", async () => {
     using testEnv = createTestBashTool();
     const tool = testEnv.tool;
     const args: BashToolArgs = {
@@ -961,10 +971,10 @@ describe("bash tool", () => {
 
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
-      expect(result.exitCode).toBe(-1);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.output).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
+      expect(result.exitCode).toBe(0);
     }
   });
 
diff --git a/src/node/services/tools/bash.ts b/src/node/services/tools/bash.ts
index 87b6374cfe..b1af9827f9 100644
--- a/src/node/services/tools/bash.ts
+++ b/src/node/services/tools/bash.ts
@@ -759,9 +759,13 @@ ${scriptWithEnv}`;
 
       // Handle tmpfile overflow policy separately (writes to file)
       if (truncated && (config.overflow_policy ?? "tmpfile") === "tmpfile") {
-        // tmpfile policy: Save overflow output to temp file instead of returning an error
+        // tmpfile policy: Save overflow output to temp file and return a successful response.
         // We don't show ANY of the actual output to avoid overwhelming context.
         // Instead, save it to a temp file and encourage the agent to use filtering tools.
+        const truncationInfo = {
+          reason: overflowReason ?? "unknown reason",
+          totalLines: lines.length,
+        };
         try {
           // Use 8 hex characters for short, memorable temp file IDs
           const fileId = Math.random().toString(16).substring(2, 10);
@@ -788,10 +792,11 @@ Use selective filtering tools (e.g. grep) to extract relevant information and co
 File will be automatically cleaned up when stream ends.`;
 
           return {
-            success: false,
-            error: output,
-            exitCode: -1,
+            success: true,
+            output,
+            exitCode: 0,
             wall_duration_ms,
+            truncated: truncationInfo,
             ui_only: {
               severity: "soft",
             },

From b8f18de7d7003e8245a2aa374eae94823924d68b Mon Sep 17 00:00:00 2001
From: Ammar <ammar+ai@ammar.io>
Date: Wed, 21 Jan 2026 11:38:25 -0600
Subject: [PATCH 4/4] =?UTF-8?q?=F0=9F=A4=96=20refactor:=20bash=20overflow?=
 =?UTF-8?q?=20returns=20success=20with=20note,=20remove=20severity?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Bash output overflow now returns success: true with exit 0
- Overflow notice text moved to 'note' field, output set to empty string
- Removed severity (soft/hard) concept from ToolOutputUiOnly and UI
- Updated UI components to use fixed status colors without severity
- GitStatusStore skips parsing when note indicates overflow
- Added createBashOverflowTool for storybook and OverflowNotice story
- Added isForegroundSuccess type guard for proper type narrowing in tests
---
 src/browser/components/tools/BashToolCall.tsx |  29 ++---
 .../tools/shared/ToolPrimitives.tsx           |  31 ++---
 .../components/tools/shared/toolUtils.tsx     |  19 +---
 src/browser/stores/GitStatusStore.ts          |   7 +-
 src/browser/stories/App.bash.stories.tsx      |  58 +++++++++-
 src/browser/stories/mockFactory.ts            |  31 +++++
 src/common/orpc/schemas/tools.ts              |   1 -
 src/common/types/tools.ts                     |   3 -
 src/common/utils/tools/toolDefinitions.ts     |   1 -
 src/common/utils/tools/toolOutputUiOnly.ts    |   7 --
 src/node/services/tools/bash.test.ts          | 107 +++++++++++-------
 src/node/services/tools/bash.ts               |   8 +-
 12 files changed, 184 insertions(+), 118 deletions(-)

diff --git a/src/browser/components/tools/BashToolCall.tsx b/src/browser/components/tools/BashToolCall.tsx
index 7d9c9e5672..a623d5eb60 100644
--- a/src/browser/components/tools/BashToolCall.tsx
+++ b/src/browser/components/tools/BashToolCall.tsx
@@ -19,7 +19,6 @@ import {
   useToolExpansion,
   getStatusDisplay,
   formatDuration,
-  getToolOutputSeverity,
   type ToolStatus,
 } from "./shared/toolUtils";
 import { cn } from "@/common/lib/utils";
@@ -196,7 +195,6 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
   const showLiveOutput =
     !isBackground && (status === "executing" || (Boolean(liveOutput) && !resultHasOutput));
 
-  const severity = getToolOutputSeverity(result);
   const canSendToBackground = Boolean(
     toolCallId && workspaceId && foregroundBashToolCallIds.has(toolCallId)
   );
@@ -207,6 +205,7 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
         }
       : undefined;
   const truncatedInfo = result && "truncated" in result ? result.truncated : undefined;
+  const note = result && "note" in result ? result.note : undefined;
 
   const handleToggle = () => {
     userToggledRef.current = true;
@@ -255,13 +254,11 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
               {result && ` • took ${formatDuration(result.wall_duration_ms)}`}
               {!result && <ElapsedTimeDisplay startedAt={startedAt} isActive={isPending} />}
             </span>
-            {result && (
-              <ExitCodeBadge exitCode={result.exitCode} className="ml-2" severity={severity} />
-            )}
+            {result && <ExitCodeBadge exitCode={result.exitCode} className="ml-2" />}
           </>
         )}
-        <StatusIndicator status={effectiveStatus} severity={severity}>
-          {getStatusDisplay(effectiveStatus, severity)}
+        <StatusIndicator status={effectiveStatus}>
+          {getStatusDisplay(effectiveStatus)}
         </StatusIndicator>
         {/* Show "Background" button when bash is executing and can be sent to background.
             Use invisible when executing but not yet confirmed as foreground to avoid layout flash. */}
@@ -334,20 +331,24 @@ export const BashToolCall: React.FC<BashToolCallProps> = ({
 
           {result && (
             <>
+              {note && (
+                <DetailSection>
+                  <DetailLabel>Notice</DetailLabel>
+                  <div className="text-muted text-[11px] break-words whitespace-pre-wrap">
+                    {note}
+                  </div>
+                </DetailSection>
+              )}
+
               {result.success === false && result.error && (
                 <DetailSection>
                   <DetailLabel>Error</DetailLabel>
-                  <ErrorBox severity={severity}>{result.error}</ErrorBox>
+                  <ErrorBox>{result.error}</ErrorBox>
                 </DetailSection>
               )}
 
               {truncatedInfo && (
-                <div
-                  className={cn(
-                    "px-2 text-[10px] italic",
-                    severity === "soft" ? "text-warning" : "text-muted"
-                  )}
-                >
+                <div className="text-muted px-2 text-[10px] italic">
                   Output truncated — reason: {truncatedInfo.reason} • totalLines:{" "}
                   {truncatedInfo.totalLines}
                 </div>
diff --git a/src/browser/components/tools/shared/ToolPrimitives.tsx b/src/browser/components/tools/shared/ToolPrimitives.tsx
index 1938e1eb59..042f2edda0 100644
--- a/src/browser/components/tools/shared/ToolPrimitives.tsx
+++ b/src/browser/components/tools/shared/ToolPrimitives.tsx
@@ -1,4 +1,3 @@
-import type { ToolOutputSeverity } from "@/common/types/tools";
 import React from "react";
 import { cn } from "@/common/lib/utils";
 import type { LucideIcon } from "lucide-react";
@@ -72,17 +71,16 @@ export const ToolName: React.FC<React.HTMLAttributes<HTMLSpanElement>> = ({
 
 interface StatusIndicatorProps extends React.HTMLAttributes<HTMLSpanElement> {
   status: string;
-  severity?: ToolOutputSeverity;
 }
 
-const getStatusColor = (status: string, severity?: ToolOutputSeverity) => {
+const getStatusColor = (status: string) => {
   switch (status) {
     case "executing":
       return "text-pending";
     case "completed":
-      return severity === "soft" ? "text-warning" : "text-success";
+      return "text-success";
     case "failed":
-      return severity === "soft" ? "text-warning" : "text-danger";
+      return "text-danger";
     case "interrupted":
       return "text-interrupted";
     case "backgrounded":
@@ -94,7 +92,6 @@ const getStatusColor = (status: string, severity?: ToolOutputSeverity) => {
 
 export const StatusIndicator: React.FC<StatusIndicatorProps> = ({
   status,
-  severity,
   className,
   children,
   ...props
@@ -103,7 +100,7 @@ export const StatusIndicator: React.FC<StatusIndicatorProps> = ({
     className={cn(
       "text-[10px] ml-auto opacity-80 whitespace-nowrap shrink-0",
       "[&_.status-text]:inline [@container(max-width:350px)]:[&_.status-text]:hidden",
-      getStatusColor(status, severity),
+      getStatusColor(status),
       className
     )}
     {...props}
@@ -233,17 +230,12 @@ export const ToolIcon: React.FC<ToolIconProps> = ({ toolName, emoji, className }
 /**
  * Error display box with danger styling
  */
-interface ErrorBoxProps extends React.HTMLAttributes<HTMLDivElement> {
-  severity?: ToolOutputSeverity;
-}
+type ErrorBoxProps = React.HTMLAttributes<HTMLDivElement>;
 
-export const ErrorBox: React.FC<ErrorBoxProps> = ({ className, severity, ...props }) => (
+export const ErrorBox: React.FC<ErrorBoxProps> = ({ className, ...props }) => (
   <div
     className={cn(
-      "rounded border-l-2 px-2 py-1.5 text-[11px]",
-      severity === "soft"
-        ? "text-warning bg-warning-overlay border-warning"
-        : "text-danger bg-danger-overlay border-danger",
+      "rounded border-l-2 px-2 py-1.5 text-[11px] text-danger bg-danger-overlay border-danger",
       className
     )}
     {...props}
@@ -256,18 +248,13 @@ export const ErrorBox: React.FC<ErrorBoxProps> = ({ className, severity, ...prop
 interface ExitCodeBadgeProps {
   exitCode: number;
   className?: string;
-  severity?: ToolOutputSeverity;
 }
 
-export const ExitCodeBadge: React.FC<ExitCodeBadgeProps> = ({ exitCode, className, severity }) => (
+export const ExitCodeBadge: React.FC<ExitCodeBadgeProps> = ({ exitCode, className }) => (
   <span
     className={cn(
       "inline-block shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium whitespace-nowrap",
-      exitCode === 0
-        ? "bg-success text-on-success"
-        : severity === "soft"
-          ? "bg-warning text-on-warning"
-          : "bg-danger text-on-danger",
+      exitCode === 0 ? "bg-success text-on-success" : "bg-danger text-on-danger",
       className
     )}
   >
diff --git a/src/browser/components/tools/shared/toolUtils.tsx b/src/browser/components/tools/shared/toolUtils.tsx
index 9402154f39..07bb089361 100644
--- a/src/browser/components/tools/shared/toolUtils.tsx
+++ b/src/browser/components/tools/shared/toolUtils.tsx
@@ -1,7 +1,6 @@
 import React, { useState } from "react";
 import { AlertTriangle, Check, CircleDot, X } from "lucide-react";
-import type { ToolErrorResult, ToolOutputSeverity } from "@/common/types/tools";
-import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
+import type { ToolErrorResult } from "@/common/types/tools";
 import { LoadingDots } from "./ToolPrimitives";
 
 /**
@@ -28,10 +27,7 @@ export function useToolExpansion(initialExpanded = false) {
 /**
  * Get display element for tool status
  */
-export function getStatusDisplay(
-  status: ToolStatus,
-  severity?: ToolOutputSeverity
-): React.ReactNode {
+export function getStatusDisplay(status: ToolStatus): React.ReactNode {
   switch (status) {
     case "executing":
       return (
@@ -47,13 +43,6 @@ export function getStatusDisplay(
         </>
       );
     case "failed":
-      if (severity === "soft") {
-        return (
-          <>
-            ⚠<span className="status-text"> warning</span>
-          </>
-        );
-      }
       return (
         <>
           <X aria-hidden="true" className="mr-1 inline-block h-3 w-3 align-[-2px]" />
@@ -104,10 +93,6 @@ export function formatDuration(ms: number): string {
   return `${Math.round(ms / 3600000)}h`;
 }
 
-export function getToolOutputSeverity(output: unknown): ToolOutputSeverity | undefined {
-  return getToolOutputUiOnly(output)?.severity;
-}
-
 /**
  * Type guard for ToolErrorResult shape: { success: false, error: string }.
  * Use this when you need type narrowing to access error.
diff --git a/src/browser/stores/GitStatusStore.ts b/src/browser/stores/GitStatusStore.ts
index a7e824d67a..834ca9d45b 100644
--- a/src/browser/stores/GitStatusStore.ts
+++ b/src/browser/stores/GitStatusStore.ts
@@ -11,7 +11,6 @@ import { STORAGE_KEYS, WORKSPACE_DEFAULTS } from "@/constants/workspaceDefaults"
 import { useSyncExternalStore } from "react";
 import { MapStore } from "./MapStore";
 import { isSSHRuntime } from "@/common/types/runtime";
-import { getToolOutputUiOnly } from "@/common/utils/tools/toolOutputUiOnly";
 import { RefreshController } from "@/browser/utils/RefreshController";
 
 /**
@@ -333,10 +332,8 @@ export class GitStatusStore {
       }
 
       if (!result.data.success) {
-        const uiOnlySeverity = getToolOutputUiOnly(result.data)?.severity;
         // Don't log output overflow errors at all (common in large repos, handled gracefully)
         if (
-          uiOnlySeverity !== "soft" &&
           !result.data.error?.includes("OUTPUT TRUNCATED") &&
           !result.data.error?.includes("OUTPUT OVERFLOW")
         ) {
@@ -345,6 +342,10 @@ export class GitStatusStore {
         return [metadata.id, null];
       }
 
+      if (result.data.note?.includes("OUTPUT OVERFLOW")) {
+        return [metadata.id, null];
+      }
+
       // Parse the output using centralized function
       const parsed = parseGitStatusScriptOutput(result.data.output);
 
diff --git a/src/browser/stories/App.bash.stories.tsx b/src/browser/stories/App.bash.stories.tsx
index 4a6dbe906a..f899049153 100644
--- a/src/browser/stories/App.bash.stories.tsx
+++ b/src/browser/stories/App.bash.stories.tsx
@@ -1,5 +1,5 @@
 /**
- * Bash tool stories - consolidated to 3 stories covering full UI complexity
+ * Bash tool stories - consolidated to a few stories covering full UI complexity
  */
 
 import { appMeta, AppWithMocks, type AppStory } from "./meta.js";
@@ -8,6 +8,7 @@ import {
   createUserMessage,
   createAssistantMessage,
   createBashTool,
+  createBashOverflowTool,
   createPendingTool,
   createBackgroundBashTool,
   createMigratedBashTool,
@@ -150,6 +151,61 @@ npm test 2>&1 | head -20`,
   },
 };
 
+/**
+ * Overflow notice: output saved to temp file with informational notice
+ */
+export const OverflowNotice: AppStory = {
+  render: () => (
+    <AppWithMocks
+      setup={() =>
+        setupSimpleChatStory({
+          workspaceId: "ws-bash-overflow",
+          messages: [
+            createUserMessage("msg-1", "Search the logs for failures", {
+              historySequence: 1,
+              timestamp: STABLE_TIMESTAMP - 140000,
+            }),
+            createAssistantMessage(
+              "msg-2",
+              "Scanning logs (output too large, saved to temp file):",
+              {
+                historySequence: 2,
+                timestamp: STABLE_TIMESTAMP - 135000,
+                toolCalls: [
+                  createBashOverflowTool(
+                    "call-1",
+                    'rg "ERROR" /var/log/app/*.log',
+                    [
+                      "[OUTPUT OVERFLOW - Total output exceeded display limit: 18432 bytes > 16384 bytes (at line 312)]",
+                      "",
+                      "Full output (1250 lines) saved to /home/user/.mux/tmp/bash-1a2b3c4d.txt",
+                      "",
+                      "Use selective filtering tools (e.g. grep) to extract relevant information and continue your task",
+                      "",
+                      "File will be automatically cleaned up when stream ends.",
+                    ].join("\n"),
+                    {
+                      reason:
+                        "Total output exceeded display limit: 18432 bytes > 16384 bytes (at line 312)",
+                      totalLines: 1250,
+                    },
+                    5,
+                    4200,
+                    "Log Scan"
+                  ),
+                ],
+              }
+            ),
+          ],
+        })
+      }
+    />
+  ),
+  play: async ({ canvasElement }: { canvasElement: HTMLElement }) => {
+    await expandAllBashTools(canvasElement);
+  },
+};
+
 /**
  * Background bash workflow: spawn, output states (running/exited/error/filtered/empty),
  * process list, and terminate
diff --git a/src/browser/stories/mockFactory.ts b/src/browser/stories/mockFactory.ts
index a3af863a41..88828d4d37 100644
--- a/src/browser/stories/mockFactory.ts
+++ b/src/browser/stories/mockFactory.ts
@@ -282,6 +282,37 @@ export function createFileEditTool(toolCallId: string, filePath: string, diff: s
   };
 }
 
+export function createBashOverflowTool(
+  toolCallId: string,
+  script: string,
+  notice: string,
+  truncated: { reason: string; totalLines: number },
+  timeoutSecs = 3,
+  durationMs = 50,
+  displayName = "Bash"
+): MuxPart {
+  return {
+    type: "dynamic-tool",
+    toolCallId,
+    toolName: "bash",
+    state: "output-available",
+    input: {
+      script,
+      run_in_background: false,
+      timeout_secs: timeoutSecs,
+      display_name: displayName,
+    },
+    output: {
+      success: true,
+      output: "",
+      note: notice,
+      exitCode: 0,
+      wall_duration_ms: durationMs,
+      truncated,
+    },
+  };
+}
+
 export function createBashTool(
   toolCallId: string,
   script: string,
diff --git a/src/common/orpc/schemas/tools.ts b/src/common/orpc/schemas/tools.ts
index 0ab37dc848..2a00c7a557 100644
--- a/src/common/orpc/schemas/tools.ts
+++ b/src/common/orpc/schemas/tools.ts
@@ -1,7 +1,6 @@
 import { z } from "zod";
 
 const ToolOutputUiOnlySchema = z.object({
-  severity: z.enum(["soft", "hard"]).optional(),
   ask_user_question: z
     .object({
       questions: z.array(z.unknown()),
diff --git a/src/common/types/tools.ts b/src/common/types/tools.ts
index 6531e3b06d..17a70b5480 100644
--- a/src/common/types/tools.ts
+++ b/src/common/types/tools.ts
@@ -54,8 +54,6 @@ export type AgentSkillReadFileToolArgs = z.infer<
 >;
 export type AgentSkillReadFileToolResult = z.infer<typeof AgentSkillReadFileToolResultSchema>;
 
-export type ToolOutputSeverity = "soft" | "hard";
-
 export interface AskUserQuestionUiOnlyPayload {
   questions: AskUserQuestionQuestion[];
   answers: Record<string, string>;
@@ -71,7 +69,6 @@ export interface NotifyUiOnlyPayload {
 }
 
 export interface ToolOutputUiOnly {
-  severity?: ToolOutputSeverity;
   ask_user_question?: AskUserQuestionUiOnlyPayload;
   file_edit?: FileEditUiOnlyPayload;
   notify?: NotifyUiOnlyPayload;
diff --git a/src/common/utils/tools/toolDefinitions.ts b/src/common/utils/tools/toolDefinitions.ts
index 54ab6f8df9..5e537c3619 100644
--- a/src/common/utils/tools/toolDefinitions.ts
+++ b/src/common/utils/tools/toolDefinitions.ts
@@ -64,7 +64,6 @@ const AskUserQuestionUiOnlySchema = z.object({
 });
 
 const ToolOutputUiOnlySchema = z.object({
-  severity: z.enum(["soft", "hard"]).optional(),
   ask_user_question: AskUserQuestionUiOnlySchema.optional(),
   file_edit: z
     .object({
diff --git a/src/common/utils/tools/toolOutputUiOnly.ts b/src/common/utils/tools/toolOutputUiOnly.ts
index 3558e7df39..5cf8c2e669 100644
--- a/src/common/utils/tools/toolOutputUiOnly.ts
+++ b/src/common/utils/tools/toolOutputUiOnly.ts
@@ -112,13 +112,6 @@ function isUiOnlyRecord(value: unknown): value is ToolOutputUiOnly {
 
   const record = value;
 
-  if ("severity" in record) {
-    const severity = record.severity;
-    if (severity !== undefined && severity !== "soft" && severity !== "hard") {
-      return false;
-    }
-  }
-
   if ("ask_user_question" in record && !isAskUserQuestionUiOnly(record.ask_user_question)) {
     return false;
   }
diff --git a/src/node/services/tools/bash.test.ts b/src/node/services/tools/bash.test.ts
index 933c1640c3..9f483b8615 100644
--- a/src/node/services/tools/bash.test.ts
+++ b/src/node/services/tools/bash.test.ts
@@ -9,6 +9,14 @@ import { TestTempDir, createTestToolConfig, getTestDeps } from "./testHelpers";
 import { createRuntime } from "@/node/runtime/runtimeFactory";
 import { sshConnectionPool } from "@/node/runtime/sshConnectionPool";
 import type { ToolCallOptions } from "ai";
+
+// Type guard to narrow foreground success result (has note, no backgroundProcessId)
+function isForegroundSuccess(
+  result: BashToolResult
+): result is BashToolResult & { success: true; note?: string } {
+  return result.success && !("backgroundProcessId" in result);
+}
+
 import { BackgroundProcessManager } from "@/node/services/backgroundProcessManager";
 
 // Mock ToolCallOptions for testing
@@ -128,10 +136,11 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.output).toContain("[OUTPUT OVERFLOW");
-      expect(result.output).toContain("Line count exceeded");
-      expect(result.output).toContain("300 lines");
+    if (isForegroundSuccess(result)) {
+      expect(result.output).toBe("");
+      expect(result.note).toContain("[OUTPUT OVERFLOW");
+      expect(result.note).toContain("Line count exceeded");
+      expect(result.note).toContain("300 lines");
       expect(result.exitCode).toBe(0);
     }
   });
@@ -149,21 +158,22 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.output).toContain("[OUTPUT OVERFLOW");
+    if (isForegroundSuccess(result)) {
+      expect(result.output).toBe("");
+      expect(result.note).toContain("[OUTPUT OVERFLOW");
       // Should contain specific overflow reason (one of the three types)
-      expect(result.output).toMatch(
+      expect(result.note).toMatch(
         /Line count exceeded|Total output exceeded|exceeded per-line limit/
       );
-      expect(result.output).toContain("Full output");
-      expect(result.output).toContain("lines) saved to");
-      expect(result.output).toContain("bash-");
-      expect(result.output).toContain(".txt");
-      expect(result.output).toContain("File will be automatically cleaned up when stream ends");
+      expect(result.note).toContain("Full output");
+      expect(result.note).toContain("lines) saved to");
+      expect(result.note).toContain("bash-");
+      expect(result.note).toContain(".txt");
+      expect(result.note).toContain("File will be automatically cleaned up when stream ends");
       expect(result.exitCode).toBe(0);
 
       // Extract file path from output message (handles both "lines saved to" and "lines) saved to")
-      const match = /saved to (\/.+?\.txt)/.exec(result.output);
+      const match = /saved to (\/.+?\.txt)/.exec(result.note ?? "");
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -205,12 +215,13 @@ describe("bash tool", () => {
     const duration = performance.now() - startTime;
 
     expect(result.success).toBe(true);
-    if (result.success) {
+    if (isForegroundSuccess(result)) {
       // Should complete quickly since we stop at 300 lines
       expect(duration).toBeLessThan(4000);
-      expect(result.output).toContain("[OUTPUT OVERFLOW");
-      expect(result.output).toContain("Line count exceeded");
-      expect(result.output).toContain("300 lines");
+      expect(result.output).toBe("");
+      expect(result.note).toContain("[OUTPUT OVERFLOW");
+      expect(result.note).toContain("Line count exceeded");
+      expect(result.note).toContain("300 lines");
       expect(result.exitCode).toBe(0);
     }
   });
@@ -354,11 +365,12 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
+    if (isForegroundSuccess(result)) {
       // Should use tmpfile behavior
-      expect(result.output).toContain("[OUTPUT OVERFLOW");
-      expect(result.output).toContain("saved to");
-      expect(result.output).not.toContain("[OUTPUT TRUNCATED");
+      expect(result.output).toBe("");
+      expect(result.note).toContain("[OUTPUT OVERFLOW");
+      expect(result.note).toContain("saved to");
+      expect(result.note).not.toContain("[OUTPUT TRUNCATED");
       expect(result.exitCode).toBe(0);
 
       // Verify temp file was created in runtimeTempDir
@@ -393,14 +405,15 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
+    if (isForegroundSuccess(result)) {
       // Should hit display limit and save to temp file
-      expect(result.output).toContain("[OUTPUT OVERFLOW");
-      expect(result.output).toContain("saved to");
+      expect(result.output).toBe("");
+      expect(result.note).toContain("[OUTPUT OVERFLOW");
+      expect(result.note).toContain("saved to");
       expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file
-      const match = /saved to (\/.*?\.txt)/.exec(result.output);
+      const match = /saved to (\/.*?\.txt)/.exec(result.note ?? "");
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -449,13 +462,14 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
+    if (isForegroundSuccess(result)) {
       // Should hit file limit
-      expect(result.output).toContain("file preservation limit");
+      expect(result.output).toBe("");
+      expect(result.note).toContain("file preservation limit");
       expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file
-      const match = /saved to (\/.*?\.txt)/.exec(result.output);
+      const match = /saved to (\/.*?\.txt)/.exec(result.note ?? "");
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -496,13 +510,13 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
+    if (isForegroundSuccess(result)) {
       // Should hit display limit
-      expect(result.output).toContain("display limit");
+      expect(result.note).toContain("display limit");
       expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file contains the completion marker
-      const match = /saved to (\/.*?\.txt)/.exec(result.output);
+      const match = /saved to (\/.*?\.txt)/.exec(result.note ?? "");
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -540,13 +554,14 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
+    if (isForegroundSuccess(result)) {
       // Should hit per-line limit (file truncation, not display)
-      expect(result.output).toContain("per-line limit");
+      expect(result.output).toBe("");
+      expect(result.note).toContain("per-line limit");
       expect(result.exitCode).toBe(0);
 
       // Extract and verify temp file does NOT contain the second echo
-      const match = /saved to (\/.*?\.txt)/.exec(result.output);
+      const match = /saved to (\/.*?\.txt)/.exec(result.note ?? "");
       expect(match).toBeDefined();
       if (match) {
         const overflowPath = match[1];
@@ -618,10 +633,11 @@ describe("bash tool", () => {
 
     // Should trigger display truncation at exactly 300 lines
     expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.output).toContain("[OUTPUT OVERFLOW");
-      expect(result.output).toContain("300 lines");
-      expect(result.output).toContain("display limit");
+    if (isForegroundSuccess(result)) {
+      expect(result.output).toBe("");
+      expect(result.note).toContain("[OUTPUT OVERFLOW");
+      expect(result.note).toContain("300 lines");
+      expect(result.note).toContain("display limit");
       expect(result.exitCode).toBe(0);
     }
 
@@ -932,8 +948,9 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.output).toMatch(/exceeded per-line limit|OUTPUT OVERFLOW/);
+    if (isForegroundSuccess(result)) {
+      expect(result.output).toBe("");
+      expect(result.note).toMatch(/exceeded per-line limit|OUTPUT OVERFLOW/);
       expect(result.exitCode).toBe(0);
     }
   });
@@ -953,8 +970,9 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.output).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
+    if (isForegroundSuccess(result)) {
+      expect(result.output).toBe("");
+      expect(result.note).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
       expect(result.exitCode).toBe(0);
     }
   });
@@ -972,8 +990,9 @@ describe("bash tool", () => {
     const result = (await tool.execute!(args, mockToolCallOptions)) as BashToolResult;
 
     expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.output).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
+    if (isForegroundSuccess(result)) {
+      expect(result.output).toBe("");
+      expect(result.note).toMatch(/Total output exceeded limit|OUTPUT OVERFLOW/);
       expect(result.exitCode).toBe(0);
     }
   });
diff --git a/src/node/services/tools/bash.ts b/src/node/services/tools/bash.ts
index b1af9827f9..ae62a75c02 100644
--- a/src/node/services/tools/bash.ts
+++ b/src/node/services/tools/bash.ts
@@ -783,7 +783,7 @@ ${scriptWithEnv}`;
           await writerInstance.write(encoder.encode(fullOutput));
           await writerInstance.close();
 
-          const output = `[OUTPUT OVERFLOW - ${overflowReason ?? "unknown reason"}]
+          const notice = `[OUTPUT OVERFLOW - ${overflowReason ?? "unknown reason"}]
 
 Full output (${lines.length} lines) saved to ${overflowPath}
 
@@ -793,13 +793,11 @@ File will be automatically cleaned up when stream ends.`;
 
           return {
             success: true,
-            output,
+            output: "",
+            note: notice,
             exitCode: 0,
             wall_duration_ms,
             truncated: truncationInfo,
-            ui_only: {
-              severity: "soft",
-            },
           };
         } catch (err) {
           // If temp file creation fails, fall back to original error