feat(chat): highlight suspicious failure phrases in Activity thinking

- Add parseThinkingSegments() to detect auth/error phrases in agent thinking
- Render thinking text with suspicious segments highlighted (amber mark + tooltip)
- Apply in Activity block (past reasoning) and Response block (streaming)
- Unit tests for patterns and sidebar highlight; bump version to 1.6.3

Author: vyakymenko

apps/chat/src/app/agent-thinking-sidebar.spec.tsx

@@ -120,6 +120,25 @@ describe('AgentThinkingSidebar', () => {
     expect(screen.getByText('npm install')).toBeTruthy();
   });
 
+  it('highlights suspicious failure phrases in reasoning activity block', () => {
+    const storyItems = [
+      { id: '1', type: 'stream_start', message: 'Started', timestamp: new Date().toISOString() },
+      {
+        id: '2',
+        type: 'reasoning_start',
+        message: '',
+        timestamp: new Date().toISOString(),
+        details: 'But authentication fails. Trying fallback.',
+      },
+    ];
+    render(
+      <AgentThinkingSidebar isCollapsed={false} onToggle={vi.fn()} storyItems={storyItems} />
+    );
+    const mark = document.querySelector('mark[title="Possible failure — check token or access"]');
+    expect(mark).toBeTruthy();
+    expect(mark?.textContent).toContain('authentication fails');
+  });
+
   it('strips leading "Ran " from tool_call when only message is set', () => {
     const storyItems = [
       {

apps/chat/src/app/agent-thinking-sidebar.tsx

@@ -19,6 +19,10 @@ import {
   toTimestampMs,
   type StoryEntry,
 } from './agent-thinking-utils';
+import {
+  parseThinkingSegments,
+  SUSPICIOUS_TOOLTIP,
+} from './thinking-failure-patterns';
 import {
   ACTIVITY_BLOCK_BASE,
   ACTIVITY_BLOCK_VARIANTS,
@@ -152,6 +156,37 @@ const BRAIN_COMPLETE_TO_IDLE_MS = 7_000;
 
 const SINGLE_ROW_TYPES = new Set(['stream_start', 'step', 'tool_call', 'file_created']);
 
+const SUSPICIOUS_SEGMENT_CLASS =
+  'bg-amber-500/25 text-amber-200 border-b border-amber-500/50 rounded-sm px-0.5';
+
+const ThinkingTextWithHighlights = memo(function ThinkingTextWithHighlights({
+  text,
+  className,
+}: {
+  text: string;
+  className?: string;
+}) {
+  const segments = useMemo(() => parseThinkingSegments(text), [text]);
+  if (segments.length === 0) return null;
+  return (
+    <span className={className}>
+      {segments.map((seg, i) =>
+        seg.suspicious ? (
+          <mark
+            key={i}
+            className={SUSPICIOUS_SEGMENT_CLASS}
+            title={SUSPICIOUS_TOOLTIP}
+          >
+            {seg.text}
+          </mark>
+        ) : (
+          <span key={i}>{seg.text}</span>
+        )
+      )}
+    </span>
+  );
+});
+
 const ActivityBlock = memo(function ActivityBlock({
   entry,
   isStreaming,
@@ -230,7 +265,9 @@ const ActivityBlock = memo(function ActivityBlock({
       </div>
       {isThinkingBlock ? (
         <div className="mt-0.5 rounded-md bg-background/40 px-2 py-1.5 max-h-32 overflow-y-auto">
-          <p className={`text-[11px] ${ACTIVITY_MONO}`}>{entry.details}</p>
+          <p className={`text-[11px] ${ACTIVITY_MONO}`}>
+            <ThinkingTextWithHighlights text={entry.details ?? ''} />
+          </p>
         </div>
       ) : (
         <div className="mt-0.5">
@@ -840,7 +877,9 @@ export function AgentThinkingSidebar({
                   Response
                 </p>
                 <div className={`${ACTIVITY_MONO} flex-1 min-h-0 overflow-y-auto`}>
-                  {displayThinkingText || (isStreaming ? '…' : '')}
+                  <ThinkingTextWithHighlights
+                    text={displayThinkingText || (isStreaming ? '…' : '')}
+                  />
                   <span
                     ref={thinkingScrollRef}
                     className="inline-block min-h-0"

apps/chat/src/app/thinking-failure-patterns.test.ts

@@ -0,0 +1,58 @@
+import { parseThinkingSegments, SUSPICIOUS_TOOLTIP } from './thinking-failure-patterns';
+
+describe('parseThinkingSegments', () => {
+  it('returns single non-suspicious segment when no patterns match', () => {
+    const out = parseThinkingSegments('User wants to get Github username.');
+    expect(out).toEqual([{ text: 'User wants to get Github username.', suspicious: false }]);
+  });
+
+  it('marks "but ... fails" as suspicious', () => {
+    const out = parseThinkingSegments(
+      'User wants to get GIthub username... But authentication fails… Let me try.'
+    );
+    const suspicious = out.filter((s) => s.suspicious);
+    expect(suspicious.length).toBeGreaterThan(0);
+    expect(suspicious.some((s) => s.text.toLowerCase().includes('authentication fails'))).toBe(true);
+  });
+
+  it('marks "error" as suspicious', () => {
+    const out = parseThinkingSegments('Something went wrong. Error connecting.');
+    expect(out.some((s) => s.suspicious && s.text.toLowerCase().includes('error'))).toBe(true);
+  });
+
+  it('marks 401 and 403 as suspicious', () => {
+    const out = parseThinkingSegments('Got 401 then 403.');
+    expect(out.filter((s) => s.suspicious).map((s) => s.text)).toContain('401');
+    expect(out.filter((s) => s.suspicious).map((s) => s.text)).toContain('403');
+  });
+
+  it('marks permission denied and access denied as suspicious', () => {
+    const out = parseThinkingSegments('Permission denied. Access denied.');
+    expect(out.some((s) => s.suspicious && s.text.includes('Permission denied'))).toBe(true);
+    expect(out.some((s) => s.suspicious && s.text.includes('Access denied'))).toBe(true);
+  });
+
+  it('returns non-suspicious leading and trailing segments around one match', () => {
+    const out = parseThinkingSegments('Before. authentication fails After.');
+    expect(out[0]).toEqual({ text: 'Before. ', suspicious: false });
+    expect(out[1]).toEqual({ text: 'authentication fails', suspicious: true });
+    expect(out[2]).toEqual({ text: ' After.', suspicious: false });
+  });
+
+  it('returns empty array for empty or whitespace input', () => {
+    expect(parseThinkingSegments('')).toEqual([]);
+    expect(parseThinkingSegments('   ')).toEqual([]);
+  });
+
+  it('returns empty array for null or undefined input', () => {
+    expect(parseThinkingSegments(null as unknown as string)).toEqual([]);
+    expect(parseThinkingSegments(undefined as unknown as string)).toEqual([]);
+  });
+});
+
+describe('SUSPICIOUS_TOOLTIP', () => {
+  it('is a non-empty string', () => {
+    expect(typeof SUSPICIOUS_TOOLTIP).toBe('string');
+    expect(SUSPICIOUS_TOOLTIP.length).toBeGreaterThan(0);
+  });
+});

apps/chat/src/app/thinking-failure-patterns.ts

@@ -0,0 +1,60 @@
+/**
+ * Detects phrases in agent thinking that suggest failure (e.g. auth, errors).
+ * Used to highlight suspicious segments in the Activity tab so the user can act (e.g. check token).
+ */
+
+export type ThinkingSegment = { text: string; suspicious: boolean };
+
+const SUSPICIOUS_PATTERNS: RegExp[] = [
+  /\b(but\s+[\w\s]+?\s+fails?)\b/gi,
+  /\b(authentication\s+fails?|auth\s+fails?)\b/gi,
+  /\b(failed|fails?)\b/gi,
+  /\b(error|errors?)\b/gi,
+  /\b(couldn't|could not|can't|cannot)\s+(\w[\w\s]*?)(?=[.!]|$)/gi,
+  /\b(unable to\s+\w[\w\s]*?)(?=[.!]|$)/gi,
+  /\b(permission denied|access denied|not authenticated)\b/gi,
+  /\b(invalid token|token expired|token invalid)\b/gi,
+  /\b(401|403)\b/g,
+];
+
+function collectRanges(text: string): { start: number; end: number }[] {
+  const ranges: { start: number; end: number }[] = [];
+  for (const re of SUSPICIOUS_PATTERNS) {
+    const copy = new RegExp(re.source, re.flags);
+    let m: RegExpExecArray | null;
+    while ((m = copy.exec(text)) !== null) {
+      const start = m.index;
+      const end = start + m[0].length;
+      if (!ranges.some((r) => start < r.end && end > r.start)) ranges.push({ start, end });
+    }
+  }
+  ranges.sort((a, b) => a.start - b.start);
+  const merged: { start: number; end: number }[] = [];
+  for (const r of ranges) {
+    const last = merged[merged.length - 1];
+    if (last && r.start <= last.end) last.end = Math.max(last.end, r.end);
+    else merged.push({ start: r.start, end: r.end });
+  }
+  return merged;
+}
+
+export function parseThinkingSegments(text: string): ThinkingSegment[] {
+  if (typeof text !== 'string') return [];
+  const trimmed = text.trim();
+  if (!trimmed) return [];
+
+  const ranges = collectRanges(trimmed);
+  if (ranges.length === 0) return [{ text: trimmed, suspicious: false }];
+
+  const segments: ThinkingSegment[] = [];
+  let pos = 0;
+  for (const { start, end } of ranges) {
+    if (start > pos) segments.push({ text: trimmed.slice(pos, start), suspicious: false });
+    segments.push({ text: trimmed.slice(start, end), suspicious: true });
+    pos = end;
+  }
+  if (pos < trimmed.length) segments.push({ text: trimmed.slice(pos), suspicious: false });
+  return segments;
+}
+
+export const SUSPICIOUS_TOOLTIP = 'Possible failure — check token or access';

package.json

@@ -1,6 +1,6 @@
 {
   "name": "phoenix-chat",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "license": "MIT",
   "packageManager": "bun@1.3.10",
   "scripts": {