Improve task status reliability

Author: johannesjo

src/components/TerminalView.tsx

@@ -83,10 +83,6 @@ interface TerminalViewProps {
   isFocused?: boolean;
 }
 
-// Status parsing only needs recent output. Capping forwarded bytes avoids
-// expensive full-chunk decoding during large terminal bursts.
-const STATUS_ANALYSIS_MAX_BYTES = 8 * 1024;
-
 /** Terminal-layer bindings — filtered from resolved bindings.
  *  Called in the key handler (hot path); resolveBindings walks the full
  *  defaults list on each call, which is fine at human typing speed. */
@@ -416,11 +412,6 @@ export function TerminalView(props: TerminalViewProps) {
         }
       }
 
-      const statusPayload =
-        payload.length > STATUS_ANALYSIS_MAX_BYTES
-          ? payload.subarray(payload.length - STATUS_ANALYSIS_MAX_BYTES)
-          : payload;
-
       outputWriteInFlight = true;
       // eslint-disable-next-line solid/reactivity -- write callback is not a reactive context
       term.write(payload, () => {
@@ -436,7 +427,6 @@ export function TerminalView(props: TerminalViewProps) {
           });
         }
 
-        props.onData?.(statusPayload);
         if (outputQueue.length > 0) {
           scheduleOutputFlush();
           return;
@@ -458,6 +448,9 @@ export function TerminalView(props: TerminalViewProps) {
     }
 
     function enqueueOutput(chunk: Uint8Array) {
+      // Status analysis runs before xterm rendering/backpressure and receives
+      // full chunks so UTF-8 decoder state stays valid across PTY boundaries.
+      props.onData?.(chunk);
       outputQueue.push(chunk);
       outputQueuedBytes += chunk.length;
       watermark += chunk.length;

src/store/taskStatus.test.ts

@@ -56,6 +56,7 @@ import {
   isAutoTrustSettling,
   isAgentAskingQuestion,
   getTaskAttentionState,
+  getTaskDotStatus,
   taskNeedsAttention,
   markAgentSpawned,
   markAgentOutput,
@@ -528,12 +529,83 @@ describe('task attention state', () => {
   it('returns ready for committed clean tasks without active attention', () => {
     setMockTask('task-1', { agentIds: ['agent-1'] });
     setMockAgent('agent-1', { status: 'running' });
+    vi.setSystemTime(new Date('2026-05-10T10:00:00Z'));
     mockTaskGitStatus['task-1'] = {
       has_committed_changes: true,
       has_uncommitted_changes: false,
+      current_branch: 'task/example',
+      refreshedAt: Date.now(),
     };
 
     expect(getTaskAttentionState('task-1')).toBe('ready');
+    expect(getTaskDotStatus('task-1')).toBe('ready');
+    expect(taskNeedsAttention('task-1')).toBe(false);
+  });
+
+  it('does not report ready from a stale git status snapshot', () => {
+    setMockTask('task-1', { agentIds: ['agent-1'] });
+    setMockAgent('agent-1', { status: 'running' });
+    vi.setSystemTime(new Date('2026-05-10T10:00:00Z'));
+    mockTaskGitStatus['task-1'] = {
+      has_committed_changes: true,
+      has_uncommitted_changes: false,
+      current_branch: 'task/example',
+      refreshedAt: Date.now() - 6 * 60_000,
+    };
+
+    expect(getTaskAttentionState('task-1')).toBe('idle');
+    expect(getTaskDotStatus('task-1')).toBe('waiting');
+    expect(taskNeedsAttention('task-1')).toBe(false);
+  });
+
+  it('does not report ready from a failed git status refresh', () => {
+    setMockTask('task-1', { agentIds: ['agent-1'] });
+    setMockAgent('agent-1', { status: 'running' });
+    vi.setSystemTime(new Date('2026-05-10T10:00:00Z'));
+    mockTaskGitStatus['task-1'] = {
+      has_committed_changes: true,
+      has_uncommitted_changes: false,
+      current_branch: 'task/example',
+      refreshedAt: Date.now(),
+      error: 'worktree missing',
+    };
+
+    expect(getTaskAttentionState('task-1')).toBe('idle');
+    expect(getTaskDotStatus('task-1')).toBe('waiting');
+    expect(taskNeedsAttention('task-1')).toBe(false);
+  });
+
+  it('does not report ready while a git status refresh is pending', () => {
+    setMockTask('task-1', { agentIds: ['agent-1'] });
+    setMockAgent('agent-1', { status: 'running' });
+    vi.setSystemTime(new Date('2026-05-10T10:00:00Z'));
+    mockTaskGitStatus['task-1'] = {
+      has_committed_changes: true,
+      has_uncommitted_changes: false,
+      current_branch: 'task/example',
+      refreshedAt: Date.now(),
+      refreshing: true,
+    };
+
+    expect(getTaskAttentionState('task-1')).toBe('idle');
+    expect(getTaskDotStatus('task-1')).toBe('waiting');
+    expect(taskNeedsAttention('task-1')).toBe(false);
+  });
+
+  it('does not report ready after a git status snapshot has been marked stale', () => {
+    setMockTask('task-1', { agentIds: ['agent-1'] });
+    setMockAgent('agent-1', { status: 'running' });
+    vi.setSystemTime(new Date('2026-05-10T10:00:00Z'));
+    mockTaskGitStatus['task-1'] = {
+      has_committed_changes: true,
+      has_uncommitted_changes: false,
+      current_branch: 'task/example',
+      refreshedAt: Date.now(),
+      stale: true,
+    };
+
+    expect(getTaskAttentionState('task-1')).toBe('idle');
+    expect(getTaskDotStatus('task-1')).toBe('waiting');
     expect(taskNeedsAttention('task-1')).toBe(false);
   });
 

src/store/taskStatus.ts

@@ -3,6 +3,7 @@ import { invoke } from '../lib/ipc';
 import { IPC } from '../../electron/ipc/channels';
 import { store, setStore } from './core';
 import type { WorktreeStatus } from '../ipc/types';
+import type { TaskGitStatusSnapshot } from './types';
 import { warn as logWarn } from '../lib/log';
 
 // --- Trust-specific patterns (subset of QUESTION_PATTERNS) ---
@@ -754,7 +755,9 @@ export function clearAgentActivity(agentId: string): void {
 
 function isTaskReady(taskId: string): boolean {
   const git = store.taskGitStatus[taskId];
-  return Boolean(git?.has_committed_changes && !git?.has_uncommitted_changes);
+  return Boolean(
+    isGitStatusUsable(git) && git.has_committed_changes && !git.has_uncommitted_changes,
+  );
 }
 
 function hasTaskAgentError(taskId: string): boolean {
@@ -818,18 +821,121 @@ export function getTaskDotStatus(taskId: string): TaskDotStatus {
 
 // --- Git status polling ---
 
-async function refreshTaskGitStatus(taskId: string): Promise<void> {
+const GIT_STATUS_STALE_MS = 5 * 60_000;
+const gitRefreshVersions = new Map<string, number>();
+const gitStatusStaleTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+function gitStatusErrorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+function isGitStatusUsable(git: TaskGitStatusSnapshot | undefined): git is TaskGitStatusSnapshot {
+  return Boolean(
+    git &&
+    !git.error &&
+    !git.refreshing &&
+    !git.stale &&
+    Date.now() - git.refreshedAt <= GIT_STATUS_STALE_MS,
+  );
+}
+
+function nextGitRefreshVersion(taskId: string): number {
+  const version = (gitRefreshVersions.get(taskId) ?? 0) + 1;
+  gitRefreshVersions.set(taskId, version);
+  return version;
+}
+
+function isCurrentGitRefresh(taskId: string, version: number): boolean {
+  return gitRefreshVersions.get(taskId) === version;
+}
+
+function clearGitStatusStaleTimer(taskId: string): void {
+  const timer = gitStatusStaleTimers.get(taskId);
+  if (timer !== undefined) {
+    clearTimeout(timer);
+    gitStatusStaleTimers.delete(taskId);
+  }
+}
+
+function scheduleGitStatusStaleTimer(taskId: string, refreshedAt: number): void {
+  clearGitStatusStaleTimer(taskId);
+  const delay = Math.max(0, refreshedAt + GIT_STATUS_STALE_MS - Date.now() + 1);
+  const timer = setTimeout(() => {
+    gitStatusStaleTimers.delete(taskId);
+    const current = store.taskGitStatus[taskId];
+    if (!store.tasks[taskId] || current?.refreshedAt !== refreshedAt) return;
+    if (current.error || current.refreshing || current.stale) return;
+    setStore('taskGitStatus', taskId, { ...current, stale: true });
+  }, delay);
+  gitStatusStaleTimers.set(taskId, timer);
+}
+
+export function clearTaskGitStatusTracking(taskId: string): void {
+  clearGitStatusStaleTimer(taskId);
+  gitRefreshVersions.delete(taskId);
+}
+
+async function refreshTaskGitStatus(
+  taskId: string,
+  options: { invalidateExisting?: boolean } = {},
+): Promise<void> {
   const task = store.tasks[taskId];
   if (!task || task.gitIsolation === 'none') return;
+  const version = nextGitRefreshVersion(taskId);
+
+  if (options.invalidateExisting) {
+    clearGitStatusStaleTimer(taskId);
+    const previous = store.taskGitStatus[taskId];
+    setStore(
+      'taskGitStatus',
+      taskId,
+      previous
+        ? { ...previous, refreshing: true, stale: false }
+        : {
+            has_committed_changes: false,
+            has_uncommitted_changes: false,
+            current_branch: null,
+            refreshedAt: 0,
+            refreshing: true,
+          },
+    );
+  }
 
   try {
     const status = await invoke<WorktreeStatus>(IPC.GetWorktreeStatus, {
       worktreePath: task.worktreePath,
       baseBranch: task.baseBranch,
     });
-    setStore('taskGitStatus', taskId, status);
-  } catch {
-    // Worktree may not exist yet or was removed — ignore
+    if (!store.tasks[taskId] || !isCurrentGitRefresh(taskId, version)) return;
+    const refreshedAt = Date.now();
+    const next: TaskGitStatusSnapshot = {
+      ...status,
+      refreshedAt,
+    };
+    setStore('taskGitStatus', taskId, next);
+    scheduleGitStatusStaleTimer(taskId, refreshedAt);
+  } catch (err) {
+    if (!store.tasks[taskId] || !isCurrentGitRefresh(taskId, version)) return;
+    clearGitStatusStaleTimer(taskId);
+    const previous = store.taskGitStatus[taskId];
+    setStore(
+      'taskGitStatus',
+      taskId,
+      previous
+        ? {
+            ...previous,
+            refreshing: false,
+            error: gitStatusErrorMessage(err),
+          }
+        : {
+            has_committed_changes: false,
+            has_uncommitted_changes: false,
+            current_branch: null,
+            refreshedAt: 0,
+            refreshing: false,
+            error: gitStatusErrorMessage(err),
+          },
+    );
   }
 }
 
@@ -877,7 +983,7 @@ async function refreshActiveTaskGitStatus(): Promise<void> {
 
 /** Refresh git status for a single task (e.g. after agent exits). */
 export function refreshTaskStatus(taskId: string): void {
-  refreshTaskGitStatus(taskId);
+  refreshTaskGitStatus(taskId, { invalidateExisting: true });
 }
 
 let allTasksTimer: ReturnType<typeof setInterval> | null = null;

src/store/tasks.ts

@@ -10,6 +10,7 @@ import {
   markAgentSpawned,
   markAgentBusy,
   clearAgentActivity,
+  clearTaskGitStatusTracking,
   isAgentIdle,
   rescheduleTaskStatusPolling,
 } from './taskStatus';
@@ -360,6 +361,7 @@ function removeTaskFromStore(taskId: string, agentIds: string[]): void {
 
   // Phase 2: actually delete after animation completes
   setTimeout(() => {
+    clearTaskGitStatusTracking(taskId);
     setStore(
       produce((s) => {
         delete s.tasks[taskId];

src/store/types.ts

@@ -8,6 +8,13 @@ export type KeybindingOverride = Partial<Pick<KeyBinding, 'key' | 'modifiers'>>
 
 export type GitIsolationMode = 'worktree' | 'direct' | 'none';
 
+export interface TaskGitStatusSnapshot extends WorktreeStatus {
+  refreshedAt: number;
+  error?: string;
+  refreshing?: boolean;
+  stale?: boolean;
+}
+
 export type TaskViewportVisibility = 'visible' | 'offscreen-left' | 'offscreen-right';
 
 export interface TerminalBookmark {
@@ -200,7 +207,7 @@ export interface AppStore {
    *  flex-absorbing. */
   panelUserSize: Record<string, number>;
   globalScale: number;
-  taskGitStatus: Record<string, WorktreeStatus>;
+  taskGitStatus: Record<string, TaskGitStatusSnapshot>;
   taskViewportVisibility: Record<string, TaskViewportVisibility>;
   focusedPanel: Record<string, PanelId>;
   sidebarFocused: boolean;