clawdex-mobile 2.0.1 → 3.0.0

package/apps/mobile/src/screens/__tests__/agentThreadDisplay.test.ts

@@ -0,0 +1,80 @@
+import type { ChatSummary } from '../../api/types';
+import {
+  buildAgentThreadDisplayState,
+  getAgentThreadAccentColor,
+} from '../agentThreadDisplay';
+
+function chat(
+  id: string,
+  partial: Partial<ChatSummary> = {}
+): ChatSummary {
+  return {
+    id,
+    title: partial.title ?? id,
+    status: partial.status ?? 'idle',
+    createdAt: partial.createdAt ?? '2026-03-20T00:00:00.000Z',
+    updatedAt: partial.updatedAt ?? '2026-03-20T00:00:00.000Z',
+    statusUpdatedAt: partial.statusUpdatedAt ?? '2026-03-20T00:00:00.000Z',
+    lastMessagePreview: partial.lastMessagePreview ?? '',
+    cwd: partial.cwd,
+    modelProvider: partial.modelProvider,
+    sourceKind: partial.sourceKind,
+    parentThreadId: partial.parentThreadId,
+    subAgentDepth: partial.subAgentDepth,
+    lastError: partial.lastError,
+  };
+}
+
+describe('agentThreadDisplay', () => {
+  it('uses live runtime activity for running child threads', () => {
+    const display = buildAgentThreadDisplayState(
+      chat('thr_worker', { status: 'idle' }),
+      {
+        activity: {
+          tone: 'running',
+          title: 'Reasoning',
+          detail: 'Inspecting files',
+        },
+        runWatchdogUntil: Date.parse('2026-03-20T10:00:30.000Z'),
+      },
+      Date.parse('2026-03-20T10:00:00.000Z')
+    );
+
+    expect(display.label).toBe('Reasoning');
+    expect(display.detail).toBe('Inspecting files');
+    expect(display.tone).toBe('running');
+  });
+
+  it('shows pending approvals as active waiting state', () => {
+    const display = buildAgentThreadDisplayState(chat('thr_worker'), {
+      pendingApproval: { id: 'appr-1' },
+      activity: {
+        tone: 'running',
+        title: 'Working',
+      },
+    });
+
+    expect(display.label).toBe('Needs approval');
+    expect(display.tone).toBe('running');
+  });
+
+  it('falls back to error details from the chat summary', () => {
+    const display = buildAgentThreadDisplayState(
+      chat('thr_worker', {
+        status: 'error',
+        lastError: 'Command exited 1',
+      }),
+      null
+    );
+
+    expect(display.label).toBe('Error');
+    expect(display.detail).toBe('Command exited 1');
+    expect(display.tone).toBe('error');
+  });
+
+  it('assigns stable accent colors per thread id', () => {
+    expect(getAgentThreadAccentColor('thr_worker')).toBe(
+      getAgentThreadAccentColor('thr_worker')
+    );
+  });
+});

package/apps/mobile/src/screens/__tests__/agentThreads.test.ts

@@ -0,0 +1,170 @@
+import type { ChatSummary } from '../../api/types';
+import {
+  collectLiveAgentPanelThreadIds,
+  collectRelatedAgentThreads,
+  describeAgentThreadSource,
+  findMatchingAgentThread,
+} from '../agentThreads';
+
+function chat(
+  id: string,
+  partial: Partial<ChatSummary> = {}
+): ChatSummary {
+  return {
+    id,
+    title: partial.title ?? id,
+    status: partial.status ?? 'complete',
+    createdAt: partial.createdAt ?? '2026-03-20T00:00:00.000Z',
+    updatedAt: partial.updatedAt ?? '2026-03-20T00:00:00.000Z',
+    statusUpdatedAt: partial.statusUpdatedAt ?? '2026-03-20T00:00:00.000Z',
+    lastMessagePreview: partial.lastMessagePreview ?? '',
+    cwd: partial.cwd,
+    modelProvider: partial.modelProvider,
+    agentNickname: partial.agentNickname,
+    agentRole: partial.agentRole,
+    sourceKind: partial.sourceKind,
+    parentThreadId: partial.parentThreadId,
+    subAgentDepth: partial.subAgentDepth,
+    lastError: partial.lastError,
+  };
+}
+
+describe('agentThreads', () => {
+  it('collects the full related thread tree for a spawned sub-agent', () => {
+    const root = chat('thr_root', {
+      title: 'Main task',
+      sourceKind: 'appServer',
+      updatedAt: '2026-03-20T00:00:01.000Z',
+    });
+    const child = chat('thr_child', {
+      title: 'Worker one',
+      sourceKind: 'subAgentThreadSpawn',
+      parentThreadId: 'thr_root',
+      subAgentDepth: 1,
+      status: 'running',
+      updatedAt: '2026-03-20T00:00:03.000Z',
+    });
+    const grandchild = chat('thr_grandchild', {
+      title: 'Nested worker',
+      sourceKind: 'subAgentThreadSpawn',
+      parentThreadId: 'thr_child',
+      subAgentDepth: 2,
+      updatedAt: '2026-03-20T00:00:02.000Z',
+    });
+    const unrelated = chat('thr_other', {
+      title: 'Other thread',
+      sourceKind: 'appServer',
+      updatedAt: '2026-03-20T00:00:04.000Z',
+    });
+
+    const result = collectRelatedAgentThreads(
+      [root, child, grandchild, unrelated],
+      grandchild
+    );
+
+    expect(result.rootThreadId).toBe('thr_root');
+    expect(result.threads.map((entry) => entry.id)).toEqual([
+      'thr_root',
+      'thr_child',
+      'thr_grandchild',
+    ]);
+  });
+
+  it('keeps the full related sub-agent history for the agent selector', () => {
+    const root = chat('thr_root', {
+      title: 'Main task',
+      sourceKind: 'appServer',
+      updatedAt: '2026-03-18T00:00:00.000Z',
+    });
+    const recentChild = chat('thr_recent', {
+      title: 'Recent worker',
+      sourceKind: 'subAgentThreadSpawn',
+      parentThreadId: 'thr_root',
+      subAgentDepth: 1,
+      updatedAt: '2026-03-20T11:00:00.000Z',
+    });
+    const oldRunningChild = chat('thr_running', {
+      title: 'Running worker',
+      sourceKind: 'subAgentThreadSpawn',
+      parentThreadId: 'thr_root',
+      subAgentDepth: 1,
+      status: 'running',
+      updatedAt: '2026-03-17T00:00:00.000Z',
+    });
+    const oldFocusedChild = chat('thr_focused', {
+      title: 'Focused worker',
+      sourceKind: 'subAgentThreadSpawn',
+      parentThreadId: 'thr_root',
+      subAgentDepth: 1,
+      updatedAt: '2026-03-17T00:00:00.000Z',
+    });
+    const oldCompletedChild = chat('thr_old', {
+      title: 'Old worker',
+      sourceKind: 'subAgentThreadSpawn',
+      parentThreadId: 'thr_root',
+      subAgentDepth: 1,
+      updatedAt: '2026-03-16T00:00:00.000Z',
+    });
+
+    const result = collectRelatedAgentThreads(
+      [root, recentChild, oldRunningChild, oldFocusedChild, oldCompletedChild],
+      oldFocusedChild
+    );
+
+    expect(result.threads.map((entry) => entry.id)).toEqual([
+      'thr_root',
+      'thr_running',
+      'thr_recent',
+      'thr_focused',
+      'thr_old',
+    ]);
+  });
+
+  it('matches agent threads by id, title, or preview text', () => {
+    const root = chat('thr_root', { title: 'Main task' });
+    const child = chat('thr_child', {
+      title: 'Docs worker',
+      agentNickname: 'Atlas',
+      agentRole: 'explorer',
+      lastMessagePreview: 'OpenAI docs search',
+    });
+
+    expect(findMatchingAgentThread([root, child], 'thr_child')?.id).toBe('thr_child');
+    expect(findMatchingAgentThread([root, child], 'atlas')?.id).toBe('thr_child');
+    expect(findMatchingAgentThread([root, child], 'explorer')?.id).toBe('thr_child');
+    expect(findMatchingAgentThread([root, child], 'docs worker')?.id).toBe('thr_child');
+    expect(findMatchingAgentThread([root, child], 'docs search')?.id).toBe('thr_child');
+  });
+
+  it('describes root and sub-agent source kinds for the selector', () => {
+    const root = chat('thr_root', { sourceKind: 'appServer' });
+    const review = chat('thr_review', {
+      sourceKind: 'subAgentReview',
+      parentThreadId: 'thr_root',
+    });
+
+    expect(describeAgentThreadSource(root, 'thr_root')).toBe('Main thread');
+    expect(describeAgentThreadSource(review, 'thr_root')).toBe('Review agent');
+  });
+
+  it('includes the main thread in the live agent panel when sub-agents are active', () => {
+    expect(
+      collectLiveAgentPanelThreadIds([
+        { id: 'thr_root', isRootThread: true, isActive: false },
+        { id: 'thr_child_1', isRootThread: false, isActive: true },
+        { id: 'thr_child_2', isRootThread: false, isActive: true },
+        { id: 'thr_child_3', isRootThread: false, isActive: false },
+      ])
+    ).toEqual(['thr_root', 'thr_child_1', 'thr_child_2']);
+  });
+
+  it('keeps the live agent panel hidden when no sub-agent is active', () => {
+    expect(
+      collectLiveAgentPanelThreadIds([
+        { id: 'thr_root', isRootThread: true, isActive: true },
+        { id: 'thr_child_1', isRootThread: false, isActive: false },
+        { id: 'thr_child_2', isRootThread: false, isActive: false },
+      ])
+    ).toEqual([]);
+  });
+});

package/apps/mobile/src/screens/__tests__/planCardState.test.ts

@@ -0,0 +1,88 @@
+import {
+  hasStructuredPlanCardContent,
+  resolveWorkflowCardMode,
+} from '../planCardState';
+
+describe('planCardState', () => {
+  it('hides the plan card when only raw delta text exists', () => {
+    expect(
+      hasStructuredPlanCardContent({
+        explanation: null,
+        steps: [],
+      })
+    ).toBe(false);
+  });
+
+  it('shows the plan card when an explanation exists', () => {
+    expect(
+      hasStructuredPlanCardContent({
+        explanation: 'Tighten the release flow before implementation.',
+        steps: [],
+      })
+    ).toBe(true);
+  });
+
+  it('shows the plan card when structured steps exist', () => {
+    expect(
+      hasStructuredPlanCardContent({
+        explanation: null,
+        steps: [
+          {
+            step: 'Audit the current dependency set',
+            status: 'pending',
+          },
+        ],
+      })
+    ).toBe(true);
+  });
+
+  it('prefers approval mode when plan approval is pending', () => {
+    expect(
+      resolveWorkflowCardMode({
+        collaborationMode: 'plan',
+        hasStructuredPlan: true,
+        hasPlanApprovalPrompt: true,
+      })
+    ).toBe('approval');
+  });
+
+  it('uses execution mode after leaving plan mode with a structured plan', () => {
+    expect(
+      resolveWorkflowCardMode({
+        collaborationMode: 'default',
+        hasStructuredPlan: true,
+        hasPlanApprovalPrompt: false,
+      })
+    ).toBe('execution');
+  });
+
+  it('hides the top workflow card when only queued execution exists', () => {
+    expect(
+      resolveWorkflowCardMode({
+        collaborationMode: 'plan',
+        hasStructuredPlan: false,
+        hasPlanApprovalPrompt: false,
+      })
+    ).toBeNull();
+  });
+
+  it('uses execution mode when queued execution exists alongside a structured plan', () => {
+    expect(
+      resolveWorkflowCardMode({
+        collaborationMode: 'default',
+        hasStructuredPlan: true,
+        hasPlanApprovalPrompt: false,
+      })
+    ).toBe('execution');
+  });
+
+  it('uses plan mode for structured plans before implementation', () => {
+    expect(
+      resolveWorkflowCardMode({
+        collaborationMode: 'plan',
+        hasStructuredPlan: true,
+        hasPlanApprovalPrompt: false,
+      })
+    ).toBe('plan');
+  });
+});

package/apps/mobile/src/screens/__tests__/subAgentTranscript.test.ts

@@ -0,0 +1,102 @@
+import type { ChatMessage } from '../../api/types';
+import { trimInheritedParentMessages } from '../subAgentTranscript';
+
+function message(
+  id: string,
+  role: ChatMessage['role'],
+  content: string,
+  options?: {
+    systemKind?: ChatMessage['systemKind'];
+    subAgentMeta?: ChatMessage['subAgentMeta'];
+  }
+): ChatMessage {
+  return {
+    id,
+    role,
+    content,
+    systemKind: options?.systemKind,
+    subAgentMeta: options?.subAgentMeta,
+    createdAt: '2026-03-20T00:00:00.000Z',
+  };
+}
+
+describe('trimInheritedParentMessages', () => {
+  it('anchors a spawned sub-agent transcript at the child prompt', () => {
+    const parentMessages = [
+      message('m1', 'user', 'Parent question'),
+      message('m2', 'assistant', 'Parent answer'),
+      message('m3', 'system', '• Spawned sub-agent', {
+        systemKind: 'subAgent',
+        subAgentMeta: {
+          tool: 'spawn_agent',
+          prompt: 'Inspect the settings architecture',
+          receiverThreadIds: ['child-thread'],
+        },
+      }),
+    ];
+    const childMessages = [
+      message('c1', 'user', 'Parent question'),
+      message('c2', 'assistant', 'Parent answer'),
+      message('c3', 'user', 'Inspect the settings architecture'),
+      message('c4', 'assistant', 'The setting should live in App.tsx.'),
+    ];
+
+    expect(trimInheritedParentMessages(parentMessages, childMessages, 'child-thread')).toEqual({
+      messages: childMessages.slice(2),
+      hiddenInheritedMessageCount: 2,
+    });
+  });
+
+  it('matches spawned prompts even when the child message includes attachment markers', () => {
+    const parentMessages = [
+      message('m1', 'system', '• Spawned sub-agent', {
+        systemKind: 'subAgent',
+        subAgentMeta: {
+          tool: 'spawn_agent',
+          prompt: 'Review the websocket implementation',
+          receiverThreadIds: ['child-thread'],
+        },
+      }),
+    ];
+    const childMessages = [
+      message('c1', 'assistant', 'Older inherited answer'),
+      message(
+        'c2',
+        'user',
+        'Review the websocket implementation\n[file: apps/mobile/src/api/ws.ts]'
+      ),
+      message('c3', 'assistant', 'Here is the websocket review.'),
+    ];
+
+    expect(trimInheritedParentMessages(parentMessages, childMessages, 'child-thread')).toEqual({
+      messages: childMessages.slice(1),
+      hiddenInheritedMessageCount: 1,
+    });
+  });
+
+  it('falls back to shared-prefix trimming when no spawn prompt metadata is available', () => {
+    const parentMessages = [message('m1', 'user', 'Parent question')];
+    const childMessages = [
+      message('m1-copy', 'user', 'Parent question'),
+      message('m2', 'user', 'Child-only question'),
+    ];
+
+    expect(trimInheritedParentMessages(parentMessages, childMessages)).toEqual({
+      messages: childMessages.slice(1),
+      hiddenInheritedMessageCount: 1,
+    });
+  });
+
+  it('does not hide the entire child transcript when every message matches', () => {
+    const parentMessages = [
+      message('m1', 'user', 'Shared prompt'),
+      message('m2', 'assistant', 'Shared answer'),
+    ];
+    const childMessages = [...parentMessages];
+
+    expect(trimInheritedParentMessages(parentMessages, childMessages)).toEqual({
+      messages: childMessages,
+      hiddenInheritedMessageCount: 0,
+    });
+  });
+});

package/apps/mobile/src/screens/__tests__/transcriptMessages.test.ts

@@ -0,0 +1,97 @@
+import type { ChatMessage } from '../../api/types';
+import {
+  getVisibleTranscriptMessages,
+  syncVisibleSubAgentStatuses,
+} from '../transcriptMessages';
+
+function message(
+  id: string,
+  role: ChatMessage['role'],
+  content: string,
+  extras?: Partial<ChatMessage>
+): ChatMessage {
+  return {
+    id,
+    role,
+    content,
+    createdAt: '2026-03-19T00:00:00.000Z',
+    ...extras,
+  };
+}
+
+describe('getVisibleTranscriptMessages', () => {
+  it('hides system timeline rows when tool calls are disabled', () => {
+    const messages = [
+      message('u1', 'user', 'Investigate this bug'),
+      message('s1', 'system', '• Searched web for "react native flatlist"'),
+      message('a1', 'assistant', 'Found the issue.'),
+    ];
+
+    expect(getVisibleTranscriptMessages(messages, false).map((entry) => entry.id)).toEqual([
+      'u1',
+      'a1',
+    ]);
+  });
+
+  it('shows system timeline rows when tool calls are enabled', () => {
+    const messages = [
+      message('u1', 'user', 'Investigate this bug'),
+      message('s1', 'system', '• Searched web for "react native flatlist"'),
+      message('s2', 'system', '• Called tool `openaiDeveloperDocs / search_openai_docs`'),
+      message('a1', 'assistant', 'Found the issue.'),
+    ];
+
+    expect(getVisibleTranscriptMessages(messages, true).map((entry) => entry.id)).toEqual([
+      'u1',
+      's1',
+      's2',
+      'a1',
+    ]);
+  });
+
+  it('keeps sub-agent system rows visible when tool calls are disabled', () => {
+    const messages = [
+      message('u1', 'user', 'Review this repository'),
+      message('s1', 'system', '• Spawned sub-agent\n  Prompt: Review the mobile app', {
+        systemKind: 'subAgent',
+      }),
+      message('a1', 'assistant', 'Done.'),
+    ];
+
+    expect(getVisibleTranscriptMessages(messages, false).map((entry) => entry.id)).toEqual([
+      'u1',
+      's1',
+      'a1',
+    ]);
+  });
+
+  it('keeps only the last message in a consecutive assistant run', () => {
+    const messages = [
+      message('u1', 'user', 'Answer this'),
+      message('a1', 'assistant', 'Working...'),
+      message('a2', 'assistant', 'Final answer'),
+    ];
+
+    expect(getVisibleTranscriptMessages(messages, false).map((entry) => entry.id)).toEqual([
+      'u1',
+      'a2',
+    ]);
+  });
+
+  it('replaces stale sub-agent status lines with the latest thread status', () => {
+    const messages = [
+      message('s1', 'system', '• Spawned sub-agent\n  Thread: child\n  Status: running', {
+        systemKind: 'subAgent',
+        subAgentMeta: {
+          receiverThreadIds: ['child'],
+          agentStatus: 'running',
+        },
+      }),
+    ];
+
+    const synced = syncVisibleSubAgentStatuses(messages, new Map([['child', 'complete']]));
+
+    expect(synced[0]?.content).toContain('Status: complete');
+    expect(synced[0]?.subAgentMeta?.agentStatus).toBe('complete');
+  });
+});