@agent-native/core 0.129.2 → 0.130.0

package/corpus/core/src/cli/design-connect.ts

@@ -11,6 +11,8 @@ import http, {
 import https from "node:https";
 import path from "node:path";
 
+import { injectDocumentMarkup } from "../shared/html-document.js";
+
 const DEFAULT_BRIDGE_PORT = 7331;
 const ROUTE_MANIFEST_FILE = path.join(".agent-native", "design-routes.json");
 const DEFAULT_DEV_SERVER_CANDIDATES = [
@@ -1338,13 +1340,7 @@ function injectLiveEditBridge(
     targetPath,
   );
   if (!script) return withBase;
-  if (withBase.includes("</body>")) {
-    return withBase.replace("</body>", `${script}</body>`);
-  }
-  if (withBase.includes("</html>")) {
-    return withBase.replace("</html>", `${script}</html>`);
-  }
-  return `${withBase}${script}`;
+  return injectDocumentMarkup(withBase, script);
 }
 
 /** Read the full request body as a UTF-8 string. */

package/corpus/core/src/cli/index.ts

@@ -1225,7 +1225,8 @@ Usage:
   agent-native typecheck        Run TypeScript type checking
   agent-native create [name]    Scaffold a new agent-native workspace with a
                                 multi-select template picker. Use --standalone
-                                for a single-app scaffold.
+                                for a single-app scaffold, or choose Community
+                                template to install a public GitHub repository.
   agent-native code             Launch Agent-Native Code workspace. Type a task or
                                 use goals like /migrate and /audit.
   agent-native code serve       Run the Agent-Native Code remote connector.
@@ -1310,8 +1311,9 @@ Options:
   -h, --help                    Show this help message
   -v, --version                 Show version number
   --template <names>            Comma-separated templates to pre-select
-                                (mail,calendar,analytics,...) — or
-                                github:user/repo for community templates
+                                (mail,calendar,analytics,...), or install a
+                                community repo from a plain GitHub URL or
+                                community:owner/repo[?app=id][#ref]
   --headless                    Create the primitive-first action-only scaffold
   --standalone                  Scaffold a single standalone app (no workspace)
   --emit [dir]                  With migrate, emit an own-agent dossier

package/corpus/core/src/cli/skills-content/design-visual-edit-skill.ts

@@ -33,18 +33,15 @@ host renders it. The user gets the Design canvas beside the conversation, and
 current host conversation through the standard MCP Apps message bridge. The
 host may ask the user to confirm the current conversation or choose a new one.
 
-Otherwise, after \`open-visual-edit\` returns \`openUrl\`, open that URL in the
-coding host's inline browser when one is available. This still keeps Design
-beside the conversation, but an ordinary browser page has no trusted path into
-the host's current composer. In that fallback surface, **Apply design updates**
-uses Design's local agent; use **Copy prompt to your agent** to hand the same
-structured edit batch to the coding agent.
-
-- In Codex Desktop, use the in-app Browser tool to open \`openUrl\`. The built-in
-  browser is the right surface for localhost and public pages that should stay
-  inside the app.
-- In Claude Code Desktop's Code tab, open or preview \`openUrl\` in the Browser
-  pane. Ask Claude to preview it rather than opening the system browser.
+Otherwise, \`openUrl\` is a credential-free, read-only fallback that is safe to
+show in model text or retain in logs. Do not claim that fallback is editable:
+the edit capability is intentionally available only to the host-managed MCP App
+launcher, where it is hidden from the model and redeemed once.
+
+- In Codex Desktop, prefer the rendered MCP App. Use the in-app Browser for the
+  credential-free \`openUrl\` only when a read-only fallback is acceptable.
+- In Claude Code Desktop's Code tab, prefer the rendered MCP App. Preview
+  \`openUrl\` in the Browser pane only as the read-only fallback.
 - In VS Code, use the Agent Native Design webview/deep link described below.
 - Inline browser availability is host-dependent. CLI, remote, or restricted
   sessions may not expose one. If the inline surface is unavailable or disabled,
@@ -68,24 +65,41 @@ The same action is available from Design's empty-canvas context menu.
   static DOM snapshot. Editing is direct DOM manipulation against that live
   document; the parallel \`/snapshot\` fetch feeds the editable source model only
   and must never be rendered in the frame.
-- A viewer holding the connection's \`previewToken\` gets the proxied
-  \`/live-edit\` document with editor chrome. A viewer without one — a signed-out
-  session, a public link, or an inline browser with no cookies — gets the plain
-  dev-server URL: still live, but with no editor chrome, no layers, and no
-  editing. If the canvas looks right but selection and the layers panel do
-  nothing, the frame is unbridged; sign in rather than assuming Design is broken.
+- **The \`/visual-edit\` skill needs no Design account sign-in.**
+  \`open-visual-edit\` mints a five-minute, single-use capability for the exact
+  \`/visual-edit/:designId\` local-editor route. The MCP host redeems it outside
+  model-visible text, then opens the existing editor with localhost edit access.
+  This capability is not an account session: \`/_agent-native/session\` remains
+  signed out, and account-backed save/share/generate actions remain denied.
+- The skill enters through local \`pnpm action open-visual-edit\`. When that CLI
+  has no account session, the action uses a stable, workspace-scoped local
+  principal to register the bridge, create/reuse the local design, and place
+  screens. That principal exists only inside the in-process CLI call; it is not
+  a browser login and cannot be selected by an HTTP, MCP, or tunneled caller.
+- Public links are always read-only, including on loopback. Loopback peer
+  identity is not an authentication boundary because a tunnel or reverse proxy
+  can make a remote request appear local. A bare \`/visual-edit/:designId\` or
+  \`/design/:designId\` URL carries no capability and must never release the
+  connection's \`previewToken\`.
 - The live editor is same-origin through the local bridge proxy. This boots
   CSR apps and root-relative assets, but it is still a localhost editing proxy:
   app-origin cookies, WebSockets/HMR, SSE, and non-GET app API calls may need a
   future dev-server/plugin integration for perfect parity with the app's own
   origin.
-- Interact mode renders the app's normal URL so app navigation, scrolling,
-  links, and form controls behave as they would in the browser.
+- **There are exactly two views.** The infinite canvas is where all editing
+  happens, and the responsive interactive view (Interact) is where the app runs
+  for real. There is no third "full view"/focused-edit state — clicking a screen
+  in the Screens list, or the view toggle, opens the responsive view, and
+  closing it returns to the canvas.
+- Interact keeps the left and right rails and adds a device bar above the canvas
+  (device preset, editable width/height, zoom, close). It renders the app's
+  normal URL so navigation, scrolling, links, and form controls behave as they
+  would in the browser, and the wheel scrolls the app rather than panning the
+  canvas. The canvas view is the opposite: the wheel pans and zooms it, and
+  native interaction inside the frame is suppressed.
 - While a localhost screen has pending live visual edits, do not switch back to
   Interact until the user either applies the edits to source or explicitly
   aborts/discards the preview.
-- Start in Design's screen overview mode. In overview, screens are static
-  design frames; full-screen focus is for scrolling and app interaction.
 - Alt-drag duplicates a screen. For localhost screens, duplication copies the
   iframe frame and URL metadata; change the copy's path/query for a new state.
 - Flow visualization is multiple URL states: \`/checkout?step=shipping\`,
@@ -147,18 +161,26 @@ content. For conversational resolution such as "apply the second one," call
 
 ## Account And Sharing Model
 
-- The \`/visual-edit\` entry route can open before the viewer signs in. Public
-  \`/design/:id\` editor links can also render read-only public designs without a
-  session.
+- \`/visual-edit/:id\` is the dedicated local-editor surface. The one-time
+  handoff returned by \`open-visual-edit\` opens it with edit access without a
+  Design login. A copied or bare \`/visual-edit/:id\` URL is read-only because it
+  does not carry the capability.
+- The capability permits live iframe inspection and session-local edits,
+  undo/redo, **Apply design updates** through the connected host/local agent,
+  and **Copy prompt**. Those flows hand bounded source instructions back to the
+  coding agent; they do not silently persist account-owned Design data.
+- Public \`/design/:id\` links stay read-only without a signed-in owner/editor
+  session. Never use the local capability to upgrade that ordinary sharing
+  surface.
 - Prefer links returned by Design actions or \`/_agent-native/open\` deep links.
-  Do not surface URLs with \`_session=\` tokens. Query sessions are only a
-  fallback after normal cookie resolution, so an existing browser session can
-  still open the design as a different user and show "Design not found".
-- Do not attempt anonymous write actions. Bridge registration, design creation,
-  screen placement, generation, saving, and sharing are account-backed. If a
-  signed-out visitor wants to save or share, send them through the framework
-  sign-in return flow, then save or copy the design into that account before
-  opening the share dialog.
+  Do not surface URLs with \`_session=\` tokens or hand-build capability URLs.
+- Do not attempt account-backed write actions with the browser capability. The
+  trusted local \`open-visual-edit\` CLI call may register its bridge, create or
+  reuse its workspace-owned local design, and place screens without an account.
+  Direct source-file action writes, generation, saving into an account, and
+  sharing still require an authenticated action caller. If a signed-out visitor
+  wants those durable account operations, send them through the framework
+  sign-in return flow first.
 
 ## Required Local Bridge
 
@@ -166,7 +188,7 @@ The live-edit bridge is unlocked by a shared secret (the "bridge token") that
 must match on two sides: the local bridge process, and the user's connection row
 in Design (which the browser reads to authorize \`/live-edit-bridge\`,
 \`/read-file\`, \`/write-file\`). Get them to match by letting the
-**authenticated** \`open-visual-edit\` action mint the token, then starting the
+\`open-visual-edit\` action mint the token, then starting the
 bridge with it. This is the only ordering that works for the remote-MCP flow —
 the bridge cannot push its own token to the server without a CLI auth token, so
 the server mints instead and the bridge adopts.
@@ -228,7 +250,7 @@ a timeout, check for a stale process (\`lsof -ti:7331\`) before retrying.
 
 ## Action Flow
 
-Prefer the single authenticated \`open-visual-edit\` action. It registers or
+Prefer the single \`open-visual-edit\` action. It registers or
 refreshes the localhost bridge connection, mints and stores the bridge token,
 creates or reuses a Design project, places URL-backed screens, stores the active
 visual-edit context, and navigates to overview mode in one call. This avoids
@@ -252,11 +274,13 @@ pnpm action open-visual-edit '{
 \`\`\`
 
 The action returns \`designId\`, \`connectionId\`, \`bridgeToken\`, \`screens\`,
-\`urlPath\`, and \`openUrl\`. Keep \`designId\`/\`connectionId\` in the chat context
-for follow-ups, and pass \`bridgeToken\` to \`design connect\` (step 3) to start
-the bridge. On follow-up calls reusing an existing \`connectionId\`, the same
-token is returned (it is minted once and reused), so the running bridge stays
-valid.
+\`urlPath\`, and a credential-free \`openUrl\`. Its MCP App metadata separately
+carries the one-time editor launcher so the host can redeem it without showing
+the capability to the model or retaining it in the action link. Keep
+\`designId\`/\`connectionId\` in the chat context for follow-ups, and pass
+\`bridgeToken\` to \`design connect\` (step 3) to start the bridge. On follow-up
+calls reusing an existing \`connectionId\`, the same token is returned (it is
+minted once and reused), so the running bridge stays valid.
 
 ### Desktop and mobile side by side
 
@@ -334,10 +358,11 @@ Fallback, only when \`open-visual-edit\` is unavailable:
 
 - Use the \`link\`, \`deepLink\`, or MCP App embed returned by Design actions so
   the user sees the canvas. Follow **Put Design Beside The Chat**: prefer the
-  host's inline Browser, preview, or webview panel; otherwise surface the
-  **Open design** link.
-- Return or open the \`openUrl\` / action link, not a hand-built
-  \`/design/:id?_session=...\` URL.
+  MCP App; otherwise surface the credential-free **Open design** link.
+- Return or open the MCP App first. Its host-managed launcher carries the
+  one-time local-editor capability. The credential-free \`openUrl\` / action link
+  is the safe read-only fallback; never build a capability URL yourself.
+- Never return or open a hand-built \`/design/:id?_session=...\` URL.
 - If the user is working in VS Code, the Agent Native extension can open the
   same URL via
   \`vscode://builder.agent-native/open?url=<encoded-design-url>\`. Its
@@ -407,13 +432,24 @@ the connected app's text/code files through the bridge
 - Use compiler/debug provenance (project-relative file, line, column,
   component, and runtime multiplicity) to locate React/TSX source. Treat it as
   evidence, not as permission for a generic AST structural transform.
+- Read \`positionPrecision\` on every anchor before you trust \`line\`/\`column\`.
+  \`authored\` means those are the real JSX coordinates. \`transformed\` means they
+  are the dev server's own output coordinates — React 19 removed \`_debugSource\`
+  and exposes only an owner stack, so this is the normal case on a Vite/Next
+  dev server, and the line will not match the file. \`unknown\` means no tier was
+  reported. On anything but \`authored\`, use the file and component to find the
+  element by its JSX shape and re-derive the line from the file you read; never
+  edit at the reported line.
 - A single-instance leaf text edit, literal \`className\`/\`class\` edit, or flat
   literal \`style={{ ... }}\` property may use \`apply-visual-edit\` with a
-  \`local-file\` source and exact \`target.sourceAnchor\`. Preview first (omit
-  \`persist\`), inspect \`proposedDiff\`, then call with \`persist: true\`.
+  \`local-file\` source and a complete \`target.sourceAnchor\`. Forward the
+  anchor's \`positionPrecision\` with it — the action refuses a \`transformed\`
+  anchor with \`status: "needsAgent"\` instead of seeking to a line that means
+  something else in the authored file. Preview first (omit \`persist\`), inspect
+  \`proposedDiff\`, then call with \`persist: true\`.
 - Reparenting, grouping/ungrouping, wrappers, dynamic expressions, repeated
   \`.map()\` instances, shared components, breakpoint-scoped edits, and
-  cross-file changes go through the coding agent with exact subject/target
+  cross-file changes go through the coding agent with complete subject/target
   anchors and their runtime relationship. \`apply-visual-edit\` refuses these
   with \`status: "needsAgent"\` rather than guessing.
 - Before each write, read the file and pass its exact \`versionHash\` to

package/corpus/core/src/client/AssistantChat.tsx

@@ -125,6 +125,7 @@ import {
   getLoopLimitMetadata,
   getRunErrorMetadata,
   getRequestModeMetadata,
+  runErrorKey,
   type BuilderSetupCardLayout,
   type LoopLimitInfo,
   type RunErrorInfo,
@@ -5118,7 +5119,6 @@ const AssistantChatInner = forwardRef<
     () => ({ apiUrl, devMode: cpDevMode, threadId, checkpointRunIds }),
     [apiUrl, cpDevMode, threadId, checkpointRunIds],
   );
-  const messageActionsCtx = useMemo(() => ({ onForkChat }), [onForkChat]);
   const lastMessageLoopLimit = useMemo(() => {
     const last = messages[messages.length - 1];
     if (!last || last.role !== "assistant") return null;
@@ -5133,6 +5133,20 @@ const AssistantChatInner = forwardRef<
     () => latestNonRecoveryUserMessageText(messages),
     [messages],
   );
+  const retryAfterRunError = useCallback(() => {
+    setRunErrorInfo(null);
+    addToQueue(
+      lastUserText
+        ? `Retry the previous request from a clean approach. Do not rerun the exact same failed tool input unless the failure was transient or the user explicitly asked for an exact rerun. If a provider query failed because of schema, syntax, or type mismatch, diagnose the error and adjust the query first.\n\nOriginal request:\n\n${lastUserText}`
+        : "Retry the previous request from a clean approach. Do not rerun the exact same failed tool input unless the failure was transient or the user explicitly asked for an exact rerun. If a provider query failed because of schema, syntax, or type mismatch, diagnose the error and adjust the query first.",
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      "queued",
+      "retry",
+    );
+  }, [addToQueue, lastUserText]);
   const latestMessageRole = latestMessage?.role;
   const latestAssistantWasPlan =
     latestMessageRole === "assistant" &&
@@ -5166,7 +5180,7 @@ const AssistantChatInner = forwardRef<
     : lastMessageLoopLimit;
   const visibleRunError = runErrorInfo ?? lastMessageRunError;
   const visibleRunErrorKey = visibleRunError
-    ? `${visibleRunError.runId ?? ""}:${visibleRunError.errorCode ?? ""}:${visibleRunError.message}`
+    ? runErrorKey(visibleRunError)
     : null;
   const shouldShowRunError =
     !!visibleRunError &&
@@ -5179,6 +5193,16 @@ const AssistantChatInner = forwardRef<
         !visibleRunError.runId ||
         userStoppedRunRef.current.runId === visibleRunError.runId)
     );
+  // The banner covers one run; every failed turn it does not cover keeps its own
+  // inline marker, so a failure stays visible after the next prompt.
+  const messageActionsCtx = useMemo(
+    () => ({
+      onForkChat,
+      onRetryRunError: retryAfterRunError,
+      bannerRunErrorKey: shouldShowRunError ? visibleRunErrorKey : null,
+    }),
+    [onForkChat, retryAfterRunError, shouldShowRunError, visibleRunErrorKey],
+  );
   const hasActiveChatWork =
     showRunningInUI ||
     isAutoResuming ||
@@ -5549,20 +5573,7 @@ const AssistantChatInner = forwardRef<
                                         "continue",
                                       );
                                     }}
-                                    onRetry={() => {
-                                      setRunErrorInfo(null);
-                                      addToQueue(
-                                        lastUserText
-                                          ? `Retry the previous request from a clean approach. Do not rerun the exact same failed tool input unless the failure was transient or the user explicitly asked for an exact rerun. If a provider query failed because of schema, syntax, or type mismatch, diagnose the error and adjust the query first.\n\nOriginal request:\n\n${lastUserText}`
-                                          : "Retry the previous request from a clean approach. Do not rerun the exact same failed tool input unless the failure was transient or the user explicitly asked for an exact rerun. If a provider query failed because of schema, syntax, or type mismatch, diagnose the error and adjust the query first.",
-                                        undefined,
-                                        undefined,
-                                        undefined,
-                                        undefined,
-                                        "queued",
-                                        "retry",
-                                      );
-                                    }}
+                                    onRetry={retryAfterRunError}
                                     onFork={onForkChat}
                                     onDismiss={() => {
                                       if (visibleRunErrorKey) {

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -1611,6 +1611,14 @@ export function createAgentChatAdapter(
         typeof runConfig.custom === "object" &&
         (runConfig.custom as { trackInRunsTray?: unknown }).trackInRunsTray ===
           true;
+      const queuedMessageId = (() => {
+        const raw =
+          runConfig?.custom && typeof runConfig.custom === "object"
+            ? (runConfig.custom as { agentNativeQueuedMessageId?: unknown })
+                .agentNativeQueuedMessageId
+            : undefined;
+        return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+      })();
       // Human-in-the-loop approval keys (opt-in `needsApproval` actions). When
       // the user approves a paused tool call, the turn is re-issued with the
       // approval key so the server lets that specific call run.
@@ -1753,6 +1761,12 @@ export function createAgentChatAdapter(
       let lastPreparingToolName: string | undefined;
       let repeatedActionPreparationCount = 0;
       let recoveryGaveUpOnActionPreparation = false;
+      // Set when the turn is stopped by MAX_TOTAL_TRANSIENT_CONTINUATIONS —
+      // the whole-turn continuation ceiling, not a dropped connection. This
+      // can trip on a turn that was making real progress the entire time, so
+      // it needs its own honest message instead of falling through to the
+      // generic "connection kept failing" copy below.
+      let recoveryGaveUpOnTransientBudget = false;
       const continuationHistoryFragments: string[] = [];
       const structuredContinuationFragments: AgentChatStructuredMessage[] = [];
       let visibleContinuationPrefix: ContentPart[] = [];
@@ -1832,6 +1846,9 @@ export function createAgentChatAdapter(
             : " the same action";
           return `The agent got stuck preparing${tool} input and never started the tool, so I stopped the automatic retries. Try a smaller first step or a more compact version of the request.`;
         }
+        if (recoveryGaveUpOnTransientBudget) {
+          return "This turn reached the limit on how many times it can be automatically continued, so I stopped it here. It may have still been making progress — retry as a single, narrower request so it can finish within fewer continuations.";
+        }
         if (
           content.length === 0 &&
           (reason === "run_timeout" ||
@@ -3100,6 +3117,12 @@ export function createAgentChatAdapter(
             stalledTransientContinuationAttempts = madeProgress
               ? 0
               : stalledTransientContinuationAttempts + 1;
+            if (
+              totalTransientContinuationAttempts >
+              MAX_TOTAL_TRANSIENT_CONTINUATIONS
+            ) {
+              recoveryGaveUpOnTransientBudget = true;
+            }
             if (
               stalledTransientContinuationAttempts >
                 MAX_STALLED_TRANSIENT_CONTINUATIONS ||
@@ -3190,6 +3213,7 @@ export function createAgentChatAdapter(
                 body: JSON.stringify({
                   message: currentMessageText,
                   displayMessage: userMessageText,
+                  ...(queuedMessageId ? { queuedMessageId } : {}),
                   history: currentHistory,
                   structuredHistory: currentStructuredHistory,
                   turnId,

package/corpus/core/src/client/blocks/library/wireframe-kit.tsx

@@ -1496,7 +1496,7 @@ function roundedRectPath(
   h: number,
   r: number,
 ): string {
-  const rad = Math.max(0, Math.min(r, w / 2, h / 2));
+  const rad = Math.max(0, Math.min(Number.isFinite(r) ? r : 0, w / 2, h / 2));
   return [
     `M${x + rad},${y}`,
     `H${x + w - rad}`,
@@ -1525,6 +1525,21 @@ export function hasDrawableRoughBounds(
   );
 }
 
+/** Rough.js recursively flattens paths, so every coordinate must be finite. */
+export function hasDrawableRoughGeometry(
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+  inset: number,
+): boolean {
+  return (
+    Number.isFinite(x) &&
+    Number.isFinite(y) &&
+    hasDrawableRoughBounds(width, height, inset)
+  );
+}
+
 function elementStroke(node: Element, fallback: string): string {
   const explicit = readVar(node, "--rough-stroke");
   if (explicit) return explicit;
@@ -1661,7 +1676,7 @@ function build(
     const y = (r.top - base.top) / zoom;
     const w = r.width / zoom;
     const h = r.height / zoom;
-    if (!hasDrawableRoughBounds(w, h, 1)) return;
+    if (!hasDrawableRoughGeometry(x, y, w, h, 1)) return;
     const kind = inferRoughKind(node);
     const rawStroke = elementStroke(node, sketch);
     const stroke =

package/corpus/core/src/client/chat/index.ts

@@ -101,6 +101,7 @@ export {
   ACTION_CHAT_UI_DATA_TABLE_RENDERER,
   ACTION_CHAT_UI_DATA_WIDGET_RENDERER,
   ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER,
+  ACTION_CHAT_UI_WORKSPACE_FILE_RENDERER,
   type ActionChatUIConfig,
 } from "../../action-ui.js";
 export {

package/corpus/core/src/client/chat/message-components.tsx

@@ -75,6 +75,12 @@ import {
   renderMarkdownToClipboardHtml,
 } from "./markdown-renderer.js";
 import { getAssistantRunDurationMs } from "./repo-helpers.js";
+import {
+  getRunErrorMetadata,
+  runErrorHeadline,
+  runErrorKey,
+  type RunErrorInfo,
+} from "./run-recovery.js";
 import {
   ToolCallFallback,
   ToolActivityPresentation,
@@ -82,6 +88,7 @@ import {
   ASSISTANT_VISIBLE_TOOL_CALL_LIMIT,
   ChatRunningContext,
   ChatRunDurationContext,
+  formatWorkedDuration,
   RanToolsSummary,
   ReasoningCell,
   WorkedForSummary,
@@ -294,6 +301,13 @@ export const CheckpointContext = React.createContext<{
 
 export const MessageActionsContext = React.createContext<{
   onForkChat?: () => void | boolean | Promise<void | boolean>;
+  onRetryRunError?: () => void;
+  /**
+   * Key of the run error the transient recovery banner is already showing. The
+   * turn that owns that run stays quiet so one failure is never announced
+   * twice; every other failed turn keeps its own inline marker.
+   */
+  bannerRunErrorKey?: string | null;
 } | null>(null);
 
 /**
@@ -1275,6 +1289,78 @@ function isAssistantToolSummaryPart(
     .some((candidate) => candidate.type === "tool-call");
 }
 
+export function shouldShowInlineRunError({
+  runError,
+  bannerRunErrorKey,
+}: {
+  runError: RunErrorInfo | null;
+  bannerRunErrorKey: string | null | undefined;
+}): boolean {
+  if (!runError) return false;
+  return runErrorKey(runError) !== bannerRunErrorKey;
+}
+
+export function InlineRunErrorNotice({
+  info,
+  durationMs,
+  onRetry,
+}: {
+  info: RunErrorInfo;
+  durationMs?: number | null;
+  onRetry?: (() => void) | undefined;
+}) {
+  const [open, setOpen] = useState(false);
+  const headline = runErrorHeadline(info);
+  const label =
+    durationMs != null && durationMs >= 1000
+      ? `${headline} after ${formatWorkedDuration(durationMs)}`
+      : headline;
+
+  return (
+    <div className="my-1 w-full">
+      <button
+        type="button"
+        onClick={() => setOpen((v) => !v)}
+        aria-expanded={open}
+        className="flex cursor-pointer items-center gap-1.5 py-0.5 text-[13px] text-muted-foreground transition-colors hover:text-foreground"
+      >
+        <IconAlertTriangle className="size-3.5 shrink-0 text-amber-500" />
+        <span className="truncate">{label}</span>
+        <IconChevronRight
+          className={cn(
+            "size-3.5 shrink-0 transition-transform",
+            open && "rotate-90",
+          )}
+        />
+      </button>
+      {open && (
+        <div className="mt-1 rounded-md border border-border/60 bg-background/70 p-2 text-[11px] leading-relaxed text-muted-foreground">
+          <p className="whitespace-pre-wrap break-words">{info.message}</p>
+          {info.errorCode && (
+            <div className="mt-1 font-mono">code: {info.errorCode}</div>
+          )}
+          {info.runId && <div className="font-mono">run: {info.runId}</div>}
+          {info.details && (
+            <pre className="mt-1 max-h-28 overflow-auto whitespace-pre-wrap break-words font-mono">
+              {info.details}
+            </pre>
+          )}
+          {onRetry && (
+            <button
+              type="button"
+              onClick={onRetry}
+              className="mt-2 inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md border border-border bg-background px-2.5 text-[11px] font-medium text-foreground hover:bg-accent"
+            >
+              <IconRefresh className="size-3" />
+              Retry
+            </button>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
 export function AssistantMessage() {
   const [restoreState, setRestoreState] = useState<
     "idle" | "confirming" | "restoring" | "error"
@@ -1299,6 +1385,12 @@ export function AssistantMessage() {
   );
   const hasCustomUi = assistantMessageHasCustomUi(msg.content);
   const serverRunActive = React.useContext(ServerRunActiveContext);
+  const messageRunError = getRunErrorMetadata(msg);
+  const messageActions = React.useContext(MessageActionsContext);
+  const showInlineRunError = shouldShowInlineRunError({
+    runError: messageRunError,
+    bannerRunErrorKey: messageActions?.bannerRunErrorKey,
+  });
   const showMissingFinalResponse = useSettledFlag(
     shouldShowMissingFinalResponse({
       isCurrentTurnRunning: isLast && chatRunning,
@@ -1504,7 +1596,18 @@ export function AssistantMessage() {
             }
           }}
         </MessagePrimitive.GroupedParts>
-        {showMissingFinalResponse && (
+        {showInlineRunError && messageRunError && (
+          <InlineRunErrorNotice
+            info={messageRunError}
+            durationMs={capturedDurationMs ?? persistedDurationMs}
+            onRetry={
+              isLast && messageRunError.recoverable
+                ? messageActions?.onRetryRunError
+                : undefined
+            }
+          />
+        )}
+        {showMissingFinalResponse && !showInlineRunError && (
           <p role="status" className="text-muted-foreground">
             The agent stopped without sending a final message. Ask it to
             continue or retry.

package/corpus/core/src/client/chat/run-recovery.tsx

@@ -108,6 +108,20 @@ export function getRunErrorMetadata(message: unknown): RunErrorInfo | null {
   };
 }
 
+/**
+ * Identity of one failure, shared by the banner and the inline turn marker so
+ * the same run is never announced twice.
+ */
+export function runErrorKey(info: RunErrorInfo): string {
+  return `${info.runId ?? ""}:${info.errorCode ?? ""}:${info.message}`;
+}
+
+export function runErrorHeadline(info: RunErrorInfo): string {
+  return info.recoverable === true
+    ? "The agent stopped before finishing"
+    : "The agent hit an error";
+}
+
 export function getRequestModeMetadata(
   message: unknown,
 ): "act" | "plan" | null {
@@ -610,9 +624,7 @@ export function RunErrorRecoveryCard({
         </span>
         <div className="min-w-0 flex-1">
           <div className="font-medium text-foreground">
-            {canRecover
-              ? "The agent stopped before finishing"
-              : "The agent hit an error"}
+            {runErrorHeadline(info)}
           </div>
           <p className="mt-1 text-xs leading-relaxed text-muted-foreground">
             {info.message}