feat(frontend): inline executor failures via ExecutorCard; drop notification toast

koan_request_executor's tool result is now a JSON payload
{status, exit_code, error} (instead of a flat status string), letting
the frontend render the failing executor's terminal error directly in
the ExecutorCard tied to that tool call's call_id. The 'agent_exited
with error' notification toast is removed -- executor failures surface
inline on the card, orchestrator failures surface via agent.error in
the projection.

- ExecutorCard renderer + .ktc--executor-failed styling
- Drop projection 'agent_exited' notification append
- mcp_endpoint emits JSON status payload from request_executor
- test_projections updated to assert no notification on exit-with-error

Author: solatis

frontend/src/components/molecules/KoanToolCard.css

@@ -143,6 +143,29 @@
   color: var(--text-body);
 }
 
+/* ---- ExecutorCard ---- */
+.ktc--executor-failed {
+  border-left-color: var(--status-failed);
+}
+.ktc--executor-failed .ktc-label {
+  color: var(--status-failed);
+}
+.ktc-executor-error {
+  margin-top: 8px;
+  padding: 10px 12px;
+  background: var(--bg-thinking);
+  border-radius: var(--radius-md);
+  font-size: var(--type-prose);
+  color: var(--text-primary);
+  line-height: 1.5;
+}
+.ktc-executor-error-meta {
+  font-family: var(--font-mono);
+  font-size: var(--type-tool-path);
+  color: var(--text-muted);
+  margin-bottom: 4px;
+}
+
 /* ---- FallbackCard ---- */
 /* Muted label distinguishes fallback from first-class renderers */
 .ktc--fallback .ktc-label {

frontend/src/components/molecules/KoanToolCard.tsx

@@ -194,6 +194,39 @@ function AskQuestionCard({ toolInput, inFlight }: Omit<KoanToolCardProps, 'toolN
   )
 }
 
+// ExecutorCard renders one koan_request_executor call. Each call has its own
+// ToolKoanEntry (correlated by call_id), so concurrent executors render as
+// independent cards. The executor's terminal error -- the failing agent's last
+// message before exit -- arrives in this entry's result and is shown inline,
+// replacing the prior toast-notification path.
+function ExecutorCard({ toolInput, result, inFlight }: Omit<KoanToolCardProps, 'toolName'>) {
+  const artifacts = (toolInput?.artifacts as string[] | undefined) ?? []
+  const status = (result?.status as string | undefined) ?? null
+  const failed = status === 'failed'
+  const errorText = (result?.error as string | undefined) ?? ''
+  const exitCode = result?.exit_code as number | undefined
+  const label = inFlight ? 'Running executor' : failed ? 'Executor failed' : 'Executor done'
+  return (
+    <div className={`ktc ktc--executor${failed ? ' ktc--executor-failed' : ''}`}>
+      <div className="ktc-header">
+        <span className="ktc-indicator">
+          {inFlight ? <span className="ktc-running-dot" /> : <CheckSvg />}
+        </span>
+        <span className="ktc-label">{label}</span>
+        {artifacts.length > 0 && (
+          <span className="ktc-meta">{artifacts.length} artifact{artifacts.length === 1 ? '' : 's'}</span>
+        )}
+      </div>
+      {failed && (
+        <div className="ktc-executor-error">
+          {exitCode != null && <div className="ktc-executor-error-meta">exit {exitCode}</div>}
+          {errorText && <Md>{errorText}</Md>}
+        </div>
+      )}
+    </div>
+  )
+}
+
 // FallbackCard is NOT in TOOL_RENDERERS -- it takes its own clean prop shape
 // and is invoked directly by the dispatch else-branch. This avoids threading
 // a label through the ToolRenderer signature.
@@ -219,6 +252,7 @@ const TOOL_RENDERERS: Record<string, ToolRenderer> = {
   koan_artifact_write: ArtifactWriteCard,
   koan_yield: YieldCard,
   koan_ask_question: AskQuestionCard,
+  koan_request_executor: ExecutorCard,
 }
 
 export function KoanToolCard(props: KoanToolCardProps): ReactElement | null {

koan/projections.py

@@ -898,19 +898,10 @@ def fold(projection: Projection, event: VersionedEvent) -> Projection:
                 new_agents = dict(projection.run.agents)
                 new_agents[agent_id] = new_agent
                 new_run = projection.run.model_copy(update={"agents": new_agents})
-                new_projection = projection.model_copy(update={"run": new_run})
-
-                # Append error notification
-                if error:
-                    notif = Notification(
-                        message=f"Agent {agent_id} exited with error: {error}",
-                        level="error",
-                        timestamp_ms=int(datetime.now(timezone.utc).timestamp() * 1000),
-                    )
-                    new_projection = new_projection.model_copy(update={
-                        "notifications": [*new_projection.notifications, notif],
-                    })
-                return new_projection
+                # Executor failures surface in the orchestrator's koan_request_executor
+                # tool result (see ExecutorCard); failed agent status persists on
+                # agent.status/agent.error. No transient notification toast.
+                return projection.model_copy(update={"run": new_run})
 
             case "agent_spawn_failed":
                 notif = Notification(

koan/web/mcp_endpoint.py

@@ -1385,8 +1385,15 @@ async def koan_request_executor(
             from ..subagent import spawn_subagent
             result = await spawn_subagent(task, app_state)
 
-            status = "succeeded" if result.exit_code == 0 else f"failed (exit {result.exit_code})"
-            result_blocks = [_text_block(f"Executor {status}.")]
+            if result.exit_code == 0:
+                payload = {"status": "succeeded"}
+            else:
+                payload = {
+                    "status": "failed",
+                    "exit_code": result.exit_code,
+                    "error": result.error or "",
+                }
+            result_blocks = [_text_block(json.dumps(payload))]
             result_blocks, steer_manifest = _drain_and_append_steering(result_blocks, agent)
             _push_tool_attachments(steer_manifest, agent)
             return result_blocks

tests/test_projections.py

@@ -303,9 +303,9 @@ def test_agent_exited_with_error_sets_failed(self):
         r = fold(p, _e("agent_exited", {"exit_code": 1, "error": "boom"}, agent_id="a1"))
         assert r.run.agents["a1"].status == "failed"
         assert r.run.agents["a1"].error == "boom"
-        # Error notification appended
-        assert len(r.notifications) == 1
-        assert "boom" in r.notifications[0].message
+        # Tracked-agent error surfaces inline (executor: koan_request_executor
+        # tool result; orchestrator: agent.error). No notification toast.
+        assert r.notifications == []
 
     def test_agent_exited_accumulates_usage_into_conversation(self):
         p = _proj_with_primary("a1")