{activeMembers.map((member) => {
+ const spawnEntry = memberSpawnStatuses?.get(member.name);
+ const runtimeEntry = memberRuntimeEntries?.get(member.name);
const currentTaskCandidate =
member.currentTaskId && taskMap ? (taskMap.get(member.currentTaskId) ?? null) : null;
- const currentTask = isDisplayableCurrentTask(currentTaskCandidate)
- ? currentTaskCandidate
- : null;
+ const currentTask =
+ isDisplayableCurrentTask(currentTaskCandidate) &&
+ shouldDisplayMemberCurrentTask({
+ member,
+ isTeamAlive,
+ spawnStatus: spawnEntry?.status,
+ spawnLaunchState: spawnEntry?.launchState,
+ spawnRuntimeAlive: spawnEntry?.runtimeAlive,
+ runtimeEntry,
+ })
+ ? currentTaskCandidate
+ : null;
const reviewCandidate = reviewTaskByMember.get(member.name) ?? null;
const reviewTask =
reviewCandidate && reviewCandidate.id !== currentTask?.id ? reviewCandidate : null;
- const spawnEntry = memberSpawnStatuses?.get(member.name);
- const runtimeEntry = memberRuntimeEntries?.get(member.name);
+ const activityTimerRunning = isMemberActivityTimerRunning(spawnEntry, runtimeEntry);
+ const currentTaskTimer = withActivityTimerRunId(
+ currentTask
+ ? deriveWorkActivityTimerAnchor(currentTask, {
+ teamName,
+ memberName: member.name,
+ })
+ : null,
+ activityTimerRunning
+ );
+ const reviewTaskTimer = withActivityTimerRunId(
+ reviewTask
+ ? deriveReviewActivityTimerAnchor(reviewTask, {
+ teamName,
+ memberName: member.name,
+ })
+ : null,
+ activityTimerRunning
+ );
return (
; // key = "teamName/taskId"
@@ -116,9 +117,12 @@ export function getSnapshot(): ReadState {
* Mark specific comment IDs as read for a given team/task.
*/
export function markCommentsRead(teamName: string, taskId: string, commentIds: string[]): void {
- if (commentIds.length === 0) return;
const key = `${teamName}/${taskId}`;
const prev = cache[key];
+ if (commentIds.length === 0) {
+ if (prev?.manualUnread) clearTaskManualUnread(teamName, taskId);
+ return;
+ }
const prevSet = new Set(prev?.readIds ?? []);
let changed = false;
for (const id of commentIds) {
@@ -127,7 +131,7 @@ export function markCommentsRead(teamName: string, taskId: string, commentIds: s
changed = true;
}
}
- if (!changed) return;
+ if (!changed && !prev?.manualUnread) return;
cache = {
...cache,
[key]: {
@@ -148,7 +152,7 @@ export function markAsRead(teamName: string, taskId: string, latestTimestamp: nu
const prev = cache[key];
// Update lastUpdated to at least this timestamp (for legacy migration support)
const prevLastUpdated = prev?.lastUpdated ?? 0;
- if (latestTimestamp <= prevLastUpdated && prev) return;
+ if (latestTimestamp <= prevLastUpdated && prev && !prev.manualUnread) return;
cache = {
...cache,
[key]: {
@@ -160,6 +164,43 @@ export function markAsRead(teamName: string, taskId: string, latestTimestamp: nu
scheduleSave();
}
+/**
+ * Manually mark a task as unread even when it has no unread comments.
+ */
+export function markTaskUnread(teamName: string, taskId: string): void {
+ const key = `${teamName}/${taskId}`;
+ const prev = cache[key];
+ if (prev?.manualUnread) return;
+ cache = {
+ ...cache,
+ [key]: {
+ readIds: prev?.readIds ?? [],
+ lastUpdated: Date.now(),
+ manualUnread: true,
+ },
+ };
+ notify();
+ scheduleSave();
+}
+
+/**
+ * Clear only the manual unread marker. Comment read state is preserved.
+ */
+export function clearTaskManualUnread(teamName: string, taskId: string): void {
+ const key = `${teamName}/${taskId}`;
+ const prev = cache[key];
+ if (!prev?.manualUnread) return;
+ cache = {
+ ...cache,
+ [key]: {
+ readIds: prev.readIds,
+ lastUpdated: Date.now(),
+ },
+ };
+ notify();
+ scheduleSave();
+}
+
/**
* Count unread comments for a task.
* A comment is unread if its ID is NOT in the readIds set.
@@ -177,9 +218,9 @@ export function getUnreadCount(
taskId: string,
comments: { id?: string; createdAt: string }[]
): number {
- if (!comments || comments.length === 0) return 0;
const key = `${teamName}/${taskId}`;
const entry = readState[key];
+ if (!comments || comments.length === 0) return entry?.manualUnread ? 1 : 0;
if (!entry) return comments.length;
const readSet = new Set(entry.readIds);
@@ -200,7 +241,7 @@ export function getUnreadCount(
// Otherwise → unread
count++;
}
- return count;
+ return entry.manualUnread && count === 0 ? 1 : count;
}
/**
@@ -272,6 +313,7 @@ async function load(): Promise {
merged[k] = {
readIds: Array.from(mergedIds),
lastUpdated: Math.max(prev.lastUpdated, entry.lastUpdated),
+ ...(prev.manualUnread || entry.manualUnread ? { manualUnread: true } : {}),
};
}
}
@@ -290,6 +332,7 @@ async function load(): Promise {
merged[k] = {
readIds: [...new Set([...merged[k].readIds, ...v.readIds])],
lastUpdated: Math.max(merged[k].lastUpdated, v.lastUpdated),
+ ...(merged[k].manualUnread || v.manualUnread ? { manualUnread: true } : {}),
};
}
}
diff --git a/src/renderer/store/index.ts b/src/renderer/store/index.ts
index 8d7fa9d9..e57fea10 100644
--- a/src/renderer/store/index.ts
+++ b/src/renderer/store/index.ts
@@ -80,6 +80,7 @@ import type {
} from '@shared/types';
const ENABLE_AUTO_TEAM_CHANGE_PRESENCE_TRACKING = false;
+const ENABLE_IN_PROGRESS_CHANGE_PRESENCE_BACKGROUND_POLL = false;
const IN_PROGRESS_CHANGE_PRESENCE_POLL_MS = 10_000;
const FINISHED_TOOL_DISPLAY_MS = 1_500;
const MAX_TOOL_HISTORY_PER_MEMBER = 6;
@@ -257,14 +258,20 @@ export function initializeNotificationListeners(): () => void {
cleanupFns.push(() => {
if (cliStatusTimer) clearTimeout(cliStatusTimer);
});
- // This lightweight renderer-side poll keeps visible in-progress task badges fresh.
- // It is intentionally independent from the backend log-source tracking feature flag below.
- const inProgressChangePresencePollTimer = setInterval(() => {
- void pollVisibleTeamInProgressChangePresence();
- }, IN_PROGRESS_CHANGE_PRESENCE_POLL_MS);
- cleanupFns.push(() => {
- clearInterval(inProgressChangePresencePollTimer);
- });
+ // TODO(task-change-presence): re-enable this only after the board uses a bounded
+ // batch/priority presence pipeline. The old one-task-per-tick poll was accurate
+ // only after enough time or after opening a task popup, while still doing periodic
+ // summary extraction work in the background. The replacement should check visible
+ // tasks first, dedupe in-flight requests, keep popup/full diff requests higher
+ // priority, and never render "unknown" as "no_changes".
+ if (ENABLE_IN_PROGRESS_CHANGE_PRESENCE_BACKGROUND_POLL) {
+ const inProgressChangePresencePollTimer = setInterval(() => {
+ void pollVisibleTeamInProgressChangePresence();
+ }, IN_PROGRESS_CHANGE_PRESENCE_POLL_MS);
+ cleanupFns.push(() => {
+ clearInterval(inProgressChangePresencePollTimer);
+ });
+ }
const pendingSessionRefreshTimers = new Map>();
const pendingProjectRefreshTimers = new Map>();
const teamLastRelevantActivityAt = new Map();
diff --git a/src/renderer/utils/__tests__/teamModelAvailability.codexCatalog.test.ts b/src/renderer/utils/__tests__/teamModelAvailability.codexCatalog.test.ts
index 555233f9..a579f5cc 100644
--- a/src/renderer/utils/__tests__/teamModelAvailability.codexCatalog.test.ts
+++ b/src/renderer/utils/__tests__/teamModelAvailability.codexCatalog.test.ts
@@ -116,7 +116,7 @@ function createAnthropicProviderStatus(
}
describe('team model availability Codex catalog integration', () => {
- it('uses app-server catalog models even when the static Codex list has not learned a new model yet', () => {
+ it('uses app-server catalog models with runtime-backed labels', () => {
const providerStatus = createCodexProviderStatus(
[
{
@@ -171,12 +171,62 @@ describe('team model availability Codex catalog integration', () => {
expect(getAvailableTeamProviderModelOptions('codex', providerStatus)[1]).toMatchObject({
value: 'gpt-5.5',
label: '5.5',
- badgeLabel: 'New',
availabilityStatus: 'available',
});
expect(getTeamModelSelectionError('codex', 'gpt-5.5', providerStatus)).toBeNull();
});
+ it('orders GPT-5.5 first after the virtual default option', () => {
+ const providerStatus = createCodexProviderStatus([
+ {
+ id: 'gpt-5.4',
+ launchModel: 'gpt-5.4',
+ displayName: 'GPT-5.4',
+ hidden: false,
+ supportedReasoningEfforts: ['low', 'medium', 'high'],
+ defaultReasoningEffort: 'medium',
+ inputModalities: ['text', 'image'],
+ supportsPersonality: false,
+ isDefault: true,
+ upgrade: false,
+ source: 'app-server',
+ badgeLabel: '5.4',
+ },
+ {
+ id: 'gpt-5.5',
+ launchModel: 'gpt-5.5',
+ displayName: 'GPT-5.5',
+ hidden: false,
+ supportedReasoningEfforts: ['low', 'medium', 'high', 'xhigh'],
+ defaultReasoningEffort: 'high',
+ inputModalities: ['text', 'image'],
+ supportsPersonality: false,
+ isDefault: false,
+ upgrade: false,
+ source: 'app-server',
+ badgeLabel: '5.5',
+ },
+ {
+ id: 'gpt-5.2',
+ launchModel: 'gpt-5.2',
+ displayName: 'GPT-5.2',
+ hidden: false,
+ supportedReasoningEfforts: ['low', 'medium', 'high'],
+ defaultReasoningEffort: 'medium',
+ inputModalities: ['text', 'image'],
+ supportsPersonality: false,
+ isDefault: false,
+ upgrade: false,
+ source: 'app-server',
+ badgeLabel: '5.2',
+ },
+ ]);
+
+ expect(
+ getAvailableTeamProviderModelOptions('codex', providerStatus).map((model) => model.value)
+ ).toEqual(['', 'gpt-5.5', 'gpt-5.4', 'gpt-5.2']);
+ });
+
it('keeps existing disabled model policy on top of the dynamic catalog', () => {
const providerStatus = createCodexProviderStatus([
{
diff --git a/src/renderer/utils/memberActivityTimer.ts b/src/renderer/utils/memberActivityTimer.ts
new file mode 100644
index 00000000..d52f5c43
--- /dev/null
+++ b/src/renderer/utils/memberActivityTimer.ts
@@ -0,0 +1,374 @@
+import { isTeamTaskActivelyWorked } from '@shared/utils/teamTaskState';
+
+import type { TeamTaskWithKanban } from '@shared/types';
+
+export type MemberActivityPhase = 'work' | 'review';
+
+export interface MemberActivityTimerAnchor {
+ timerId: string;
+ startedAt: string;
+ startedAtMs: number;
+ baseElapsedMs: number;
+ runId?: string | null;
+}
+
+interface StoredActivityTimer {
+ version: 1;
+ startedAtMs: number;
+ baseElapsedMs: number;
+ elapsedMs: number;
+ updatedAtMs: number;
+ running: boolean;
+ runId?: string | null;
+}
+
+const STORAGE_PREFIX = 'member-activity-timer:';
+const MAX_UNOBSERVED_RUN_TRANSITION_MS = 5_000;
+const timers = new Map();
+
+function parseIsoMs(value: string | null | undefined): number {
+ if (!value) return 0;
+ const parsed = Date.parse(value);
+ return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function normalizeMemberName(value: string | null | undefined): string {
+ return typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : '';
+}
+
+function safeStorageGet(key: string): string | null {
+ try {
+ return globalThis.localStorage?.getItem(key) ?? null;
+ } catch {
+ return null;
+ }
+}
+
+function safeStorageSet(key: string, value: string): void {
+ try {
+ globalThis.localStorage?.setItem(key, value);
+ } catch {
+ // localStorage can be unavailable in tests or restricted browser contexts.
+ }
+}
+
+function storageKey(timerId: string): string {
+ return `${STORAGE_PREFIX}${timerId}`;
+}
+
+function isStoredTimer(value: unknown): value is StoredActivityTimer {
+ if (!value || typeof value !== 'object') return false;
+ const row = value as Partial;
+ return (
+ row.version === 1 &&
+ typeof row.startedAtMs === 'number' &&
+ Number.isFinite(row.startedAtMs) &&
+ (row.baseElapsedMs === undefined ||
+ (typeof row.baseElapsedMs === 'number' && Number.isFinite(row.baseElapsedMs))) &&
+ typeof row.elapsedMs === 'number' &&
+ Number.isFinite(row.elapsedMs) &&
+ typeof row.updatedAtMs === 'number' &&
+ Number.isFinite(row.updatedAtMs) &&
+ typeof row.running === 'boolean' &&
+ (row.runId === undefined || row.runId === null || typeof row.runId === 'string')
+ );
+}
+
+function readStoredTimer(
+ timerId: string,
+ startedAtMs: number,
+ baseElapsedMs: number
+): StoredActivityTimer | null {
+ const cached = timers.get(timerId);
+ if (cached?.startedAtMs === startedAtMs) {
+ return cached.baseElapsedMs === baseElapsedMs
+ ? cached
+ : { ...cached, baseElapsedMs, elapsedMs: Math.max(baseElapsedMs, cached.elapsedMs) };
+ }
+
+ const raw = safeStorageGet(storageKey(timerId));
+ if (!raw) return null;
+
+ try {
+ const parsed = JSON.parse(raw) as unknown;
+ if (!isStoredTimer(parsed) || parsed.startedAtMs !== startedAtMs) return null;
+ const sanitized: StoredActivityTimer = {
+ version: 1,
+ startedAtMs: parsed.startedAtMs,
+ baseElapsedMs,
+ elapsedMs: Math.max(baseElapsedMs, parsed.elapsedMs),
+ updatedAtMs: Math.max(parsed.startedAtMs, parsed.updatedAtMs),
+ running: parsed.running,
+ runId: parsed.runId ?? null,
+ };
+ timers.set(timerId, sanitized);
+ return sanitized;
+ } catch {
+ return null;
+ }
+}
+
+function writeStoredTimer(timerId: string, timer: StoredActivityTimer): void {
+ timers.set(timerId, timer);
+ safeStorageSet(storageKey(timerId), JSON.stringify(timer));
+}
+
+function createInitialTimer(
+ startedAtMs: number,
+ baseElapsedMs: number,
+ running: boolean,
+ nowMs: number,
+ runId: string | null | undefined
+): StoredActivityTimer {
+ if (running) {
+ return {
+ version: 1,
+ startedAtMs,
+ baseElapsedMs,
+ elapsedMs: baseElapsedMs,
+ updatedAtMs: startedAtMs,
+ running: true,
+ runId,
+ };
+ }
+
+ return {
+ version: 1,
+ startedAtMs,
+ baseElapsedMs,
+ elapsedMs: baseElapsedMs,
+ updatedAtMs: nowMs,
+ running: false,
+ runId,
+ };
+}
+
+function materializeElapsed(
+ timer: StoredActivityTimer,
+ nowMs: number,
+ runId: string | null | undefined
+): number {
+ const baseElapsedMs = Math.max(0, timer.baseElapsedMs);
+ if (!timer.running) return Math.max(baseElapsedMs, timer.elapsedMs);
+
+ const rawGapMs = Math.max(0, nowMs - timer.updatedAtMs);
+ const sameRun = (timer.runId ?? null) === (runId ?? null);
+ const gapMs = sameRun ? rawGapMs : Math.min(rawGapMs, MAX_UNOBSERVED_RUN_TRANSITION_MS);
+ return Math.max(baseElapsedMs, timer.elapsedMs + gapMs);
+}
+
+export function createMemberActivityTimerId({
+ teamName,
+ memberName,
+ phase,
+ taskId,
+ startedAt,
+}: {
+ teamName: string;
+ memberName: string;
+ phase: MemberActivityPhase;
+ taskId: string;
+ startedAt: string;
+}): string {
+ return [teamName, normalizeMemberName(memberName), phase, taskId, startedAt].join('\u0000');
+}
+
+export function syncMemberActivityTimer({
+ timerId,
+ startedAtMs,
+ baseElapsedMs = 0,
+ running,
+ runId,
+ nowMs = Date.now(),
+}: {
+ timerId: string;
+ startedAtMs: number;
+ baseElapsedMs?: number;
+ running: boolean;
+ runId?: string | null;
+ nowMs?: number;
+}): number {
+ const existing =
+ readStoredTimer(timerId, startedAtMs, baseElapsedMs) ??
+ createInitialTimer(startedAtMs, baseElapsedMs, running, nowMs, runId);
+ const elapsedMs = materializeElapsed(existing, nowMs, runId);
+ const next: StoredActivityTimer = {
+ version: 1,
+ startedAtMs,
+ baseElapsedMs,
+ elapsedMs,
+ updatedAtMs: nowMs,
+ running,
+ runId,
+ };
+ writeStoredTimer(timerId, next);
+ return elapsedMs;
+}
+
+export function readMemberActivityTimerElapsed({
+ timerId,
+ startedAtMs,
+ baseElapsedMs = 0,
+ running,
+ runId,
+ nowMs = Date.now(),
+}: {
+ timerId: string;
+ startedAtMs: number;
+ baseElapsedMs?: number;
+ running: boolean;
+ runId?: string | null;
+ nowMs?: number;
+}): number {
+ const timer =
+ readStoredTimer(timerId, startedAtMs, baseElapsedMs) ??
+ createInitialTimer(startedAtMs, baseElapsedMs, running, nowMs, runId);
+ return materializeElapsed(timer, nowMs, runId);
+}
+
+export function formatMemberActivityElapsed(elapsedMs: number): string {
+ const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
+ if (totalSeconds < 60) {
+ return `${totalSeconds}s`;
+ }
+ const totalMinutes = Math.floor(totalSeconds / 60);
+ const seconds = totalSeconds % 60;
+ if (totalMinutes < 60) {
+ return `${totalMinutes}m ${String(seconds).padStart(2, '0')}s`;
+ }
+ const hours = Math.floor(totalMinutes / 60);
+ const minutes = totalMinutes % 60;
+ return `${hours}h ${String(minutes).padStart(2, '0')}m`;
+}
+
+export function deriveWorkActivityTimerAnchor(
+ task: TeamTaskWithKanban,
+ params: {
+ teamName: string;
+ memberName: string;
+ }
+): MemberActivityTimerAnchor | null {
+ if (!isTeamTaskActivelyWorked(task)) return null;
+
+ const intervals = Array.isArray(task.workIntervals) ? task.workIntervals : [];
+ let baseElapsedMs = 0;
+ for (let index = intervals.length - 1; index >= 0; index -= 1) {
+ const interval = intervals[index];
+ const startedAtMs = parseIsoMs(interval?.startedAt);
+ if (startedAtMs > 0 && !interval?.completedAt) {
+ for (let previousIndex = 0; previousIndex < index; previousIndex += 1) {
+ const previous = intervals[previousIndex];
+ const previousStartedAtMs = parseIsoMs(previous?.startedAt);
+ const previousCompletedAtMs = parseIsoMs(previous?.completedAt);
+ if (previousStartedAtMs > 0 && previousCompletedAtMs > previousStartedAtMs) {
+ baseElapsedMs += previousCompletedAtMs - previousStartedAtMs;
+ }
+ }
+ return {
+ startedAt: interval.startedAt,
+ startedAtMs,
+ baseElapsedMs,
+ timerId: createMemberActivityTimerId({
+ teamName: params.teamName,
+ memberName: params.memberName,
+ phase: 'work',
+ taskId: task.id,
+ startedAt: interval.startedAt,
+ }),
+ };
+ }
+ }
+ if (intervals.length > 0) return null;
+
+ const events = Array.isArray(task.historyEvents) ? task.historyEvents : [];
+ for (let index = events.length - 1; index >= 0; index -= 1) {
+ const event = events[index];
+ if (event.type === 'status_changed' && event.to === 'in_progress') {
+ const startedAtMs = parseIsoMs(event.timestamp);
+ if (startedAtMs > 0) {
+ return {
+ startedAt: event.timestamp,
+ startedAtMs,
+ baseElapsedMs: 0,
+ timerId: createMemberActivityTimerId({
+ teamName: params.teamName,
+ memberName: params.memberName,
+ phase: 'work',
+ taskId: task.id,
+ startedAt: event.timestamp,
+ }),
+ };
+ }
+ }
+ if (event.type === 'task_created' && event.status === 'in_progress') {
+ const startedAtMs = parseIsoMs(event.timestamp);
+ if (startedAtMs > 0) {
+ return {
+ startedAt: event.timestamp,
+ startedAtMs,
+ baseElapsedMs: 0,
+ timerId: createMemberActivityTimerId({
+ teamName: params.teamName,
+ memberName: params.memberName,
+ phase: 'work',
+ taskId: task.id,
+ startedAt: event.timestamp,
+ }),
+ };
+ }
+ }
+ }
+
+ return null;
+}
+
+export function deriveReviewActivityTimerAnchor(
+ task: TeamTaskWithKanban,
+ params: {
+ teamName: string;
+ memberName: string;
+ }
+): MemberActivityTimerAnchor | null {
+ const memberKey = normalizeMemberName(params.memberName);
+ if (!memberKey) return null;
+
+ const events = Array.isArray(task.historyEvents) ? task.historyEvents : [];
+ for (let index = events.length - 1; index >= 0; index -= 1) {
+ const event = events[index];
+ if (event.type === 'review_started') {
+ if (normalizeMemberName(event.actor) !== memberKey) {
+ return null;
+ }
+ const startedAtMs = parseIsoMs(event.timestamp);
+ if (startedAtMs <= 0) return null;
+ return {
+ startedAt: event.timestamp,
+ startedAtMs,
+ baseElapsedMs: 0,
+ timerId: createMemberActivityTimerId({
+ teamName: params.teamName,
+ memberName: params.memberName,
+ phase: 'review',
+ taskId: task.id,
+ startedAt: event.timestamp,
+ }),
+ };
+ }
+
+ if (
+ event.type === 'review_approved' ||
+ event.type === 'review_changes_requested' ||
+ event.type === 'task_created' ||
+ (event.type === 'status_changed' &&
+ (event.to === 'in_progress' || event.to === 'pending' || event.to === 'deleted'))
+ ) {
+ return null;
+ }
+ }
+
+ return null;
+}
+
+export function resetMemberActivityTimerStoreForTests(): void {
+ timers.clear();
+}
diff --git a/src/renderer/utils/memberHelpers.ts b/src/renderer/utils/memberHelpers.ts
index 4c43e506..54caff24 100644
--- a/src/renderer/utils/memberHelpers.ts
+++ b/src/renderer/utils/memberHelpers.ts
@@ -711,6 +711,54 @@ function getLaunchVisualStateDotClass(visualState: MemberLaunchVisualState): str
}
}
+export function shouldDisplayMemberCurrentTask({
+ member,
+ isTeamAlive,
+ spawnStatus,
+ spawnLaunchState,
+ spawnRuntimeAlive,
+ runtimeEntry,
+}: {
+ member: ResolvedTeamMember;
+ isTeamAlive?: boolean;
+ spawnStatus?: MemberSpawnStatus;
+ spawnLaunchState?: MemberLaunchState;
+ spawnRuntimeAlive?: boolean;
+ runtimeEntry?: TeamAgentRuntimeEntry;
+}): boolean {
+ if (member.removedAt || member.status === 'terminated') {
+ return false;
+ }
+ if (isTeamAlive === false) {
+ return false;
+ }
+ if (spawnStatus === 'offline' || spawnStatus === 'error' || spawnStatus === 'skipped') {
+ return false;
+ }
+ if (
+ spawnLaunchState === 'failed_to_start' ||
+ spawnLaunchState === 'skipped_for_launch' ||
+ spawnLaunchState === 'runtime_pending_permission'
+ ) {
+ return false;
+ }
+ if (
+ runtimeEntry?.livenessKind === 'shell_only' ||
+ runtimeEntry?.livenessKind === 'registered_only' ||
+ runtimeEntry?.livenessKind === 'stale_metadata' ||
+ runtimeEntry?.livenessKind === 'not_found'
+ ) {
+ return false;
+ }
+ if (runtimeEntry?.alive === false && spawnStatus !== 'online') {
+ return false;
+ }
+ if (spawnRuntimeAlive === false && spawnStatus !== 'online') {
+ return false;
+ }
+ return true;
+}
+
function isQueuedOpenCodeLaunch(
member: ResolvedTeamMember,
spawnStatus: MemberSpawnStatus | undefined,
diff --git a/src/renderer/utils/teamModelCatalog.ts b/src/renderer/utils/teamModelCatalog.ts
index da480b2c..eb31e052 100644
--- a/src/renderer/utils/teamModelCatalog.ts
+++ b/src/renderer/utils/teamModelCatalog.ts
@@ -84,6 +84,7 @@ const TEAM_MODEL_LABEL_OVERRIDES: Record = {
'claude-haiku-4-5': 'Haiku 4.5',
'claude-haiku-4-5-20251001': 'Haiku 4.5',
'gpt-5.4': 'GPT-5.4',
+ 'gpt-5.5': 'GPT-5.5',
'gpt-5.4-mini': 'GPT-5.4 Mini',
'gpt-5.3-codex': 'GPT-5.3 Codex',
'gpt-5.3-codex-spark': 'GPT-5.3 Codex Spark',
@@ -107,6 +108,7 @@ const TEAM_PROVIDER_MODEL_OPTIONS: Record {
expect(fakeSession.request).toHaveBeenCalledTimes(1);
expect(openExternalMock).toHaveBeenCalledTimes(1);
expect(manager.getState().status).toBe('pending');
+ expect(manager.getState().authUrl).toBe('https://chatgpt.com/auth');
});
it('cancels a login cleanly while the app-server session is still starting', async () => {
@@ -135,6 +136,7 @@ describe('CodexLoginSessionManager', () => {
status: 'cancelled',
error: null,
startedAt: null,
+ authUrl: null,
});
});
@@ -170,6 +172,7 @@ describe('CodexLoginSessionManager', () => {
status: 'idle',
error: null,
startedAt: null,
+ authUrl: null,
});
});
diff --git a/test/features/codex-account/main/createCodexAccountFeature.test.ts b/test/features/codex-account/main/createCodexAccountFeature.test.ts
index 4d4b802e..3e2d3a44 100644
--- a/test/features/codex-account/main/createCodexAccountFeature.test.ts
+++ b/test/features/codex-account/main/createCodexAccountFeature.test.ts
@@ -40,6 +40,7 @@ const {
status: 'idle' as CodexAccountLoginStatus,
error: null as string | null,
startedAt: null as string | null,
+ authUrl: null as string | null,
},
},
loginStateListeners: new Set<() => void>(),
@@ -857,6 +858,7 @@ describe('createCodexAccountFeature', () => {
status: 'pending',
error: null,
startedAt: '2026-04-20T12:00:00.000Z',
+ authUrl: 'https://chatgpt.com/auth',
});
});
@@ -872,6 +874,7 @@ describe('createCodexAccountFeature', () => {
expect(pendingSnapshot.login).toMatchObject({
status: 'pending',
startedAt: '2026-04-20T12:00:00.000Z',
+ authUrl: 'https://chatgpt.com/auth',
});
expect(loginStartMock).toHaveBeenCalledTimes(1);
} finally {
@@ -893,12 +896,14 @@ describe('createCodexAccountFeature', () => {
status: 'pending',
error: null,
startedAt: '2026-04-20T12:00:00.000Z',
+ authUrl: 'https://chatgpt.com/auth',
});
loginCancelMock.mockImplementation(() => {
emitLoginState({
status: 'cancelled',
error: null,
startedAt: null,
+ authUrl: null,
});
for (const listener of loginSettledListeners) {
listener();
diff --git a/test/renderer/components/team/members/CurrentTaskIndicator.test.tsx b/test/renderer/components/team/members/CurrentTaskIndicator.test.tsx
new file mode 100644
index 00000000..ade3735e
--- /dev/null
+++ b/test/renderer/components/team/members/CurrentTaskIndicator.test.tsx
@@ -0,0 +1,68 @@
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { CurrentTaskIndicator } from '@renderer/components/team/members/CurrentTaskIndicator';
+import {
+ createMemberActivityTimerId,
+ resetMemberActivityTimerStoreForTests,
+} from '@renderer/utils/memberActivityTimer';
+
+import type { TeamTaskWithKanban } from '@shared/types';
+
+const task: TeamTaskWithKanban = {
+ id: 'task-1',
+ displayId: 'abc12345',
+ subject: 'Build feature',
+ status: 'in_progress',
+};
+
+describe('CurrentTaskIndicator', () => {
+ afterEach(() => {
+ vi.useRealTimers();
+ vi.unstubAllGlobals();
+ resetMemberActivityTimerStoreForTests();
+ globalThis.localStorage?.clear();
+ document.body.innerHTML = '';
+ });
+
+ it('renders a compact activity timer from the persisted task start anchor', async () => {
+ vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date('2026-05-07T09:01:05.000Z'));
+ const startedAt = '2026-05-07T09:00:00.000Z';
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const root = createRoot(host);
+
+ await act(async () => {
+ root.render(
+
+ );
+ await Promise.resolve();
+ });
+
+ expect(host.textContent).toContain('1m 05s');
+
+ await act(async () => {
+ root.unmount();
+ await Promise.resolve();
+ });
+ });
+});
diff --git a/test/renderer/components/team/members/MemberHoverCard.test.ts b/test/renderer/components/team/members/MemberHoverCard.test.ts
index 09153c73..2bb73ef2 100644
--- a/test/renderer/components/team/members/MemberHoverCard.test.ts
+++ b/test/renderer/components/team/members/MemberHoverCard.test.ts
@@ -2,7 +2,7 @@ import React, { act } from 'react';
import { createRoot } from 'react-dom/client';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { ResolvedTeamMember } from '@shared/types';
+import type { ResolvedTeamMember, TeamTaskWithKanban } from '@shared/types';
const member: ResolvedTeamMember = {
name: 'alice',
@@ -22,7 +22,7 @@ const storeState = {
selectedTeamData: {
members: [member],
isAlive: true,
- tasks: [],
+ tasks: [] as TeamTaskWithKanban[],
},
selectedTeamName: 'northstar-core',
progress: null as Record | null,
@@ -118,7 +118,18 @@ vi.mock('@renderer/components/ui/tooltip', () => ({
}));
vi.mock('@renderer/components/team/members/CurrentTaskIndicator', () => ({
- CurrentTaskIndicator: () => null,
+ CurrentTaskIndicator: ({
+ task,
+ activityLabel,
+ }: {
+ task: TeamTaskWithKanban;
+ activityLabel?: string;
+ }) =>
+ React.createElement(
+ 'span',
+ { 'data-testid': 'hover-current-task' },
+ `${activityLabel ?? 'task'} ${task.id}`
+ ),
}));
import { MemberHoverCard } from '@renderer/components/team/members/MemberHoverCard';
@@ -307,6 +318,45 @@ describe('MemberHoverCard spawn-aware presence', () => {
});
});
+ it('does not show a working-on task when the member is offline', async () => {
+ vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+ const task: TeamTaskWithKanban = {
+ id: 'task-active',
+ subject: 'Active work',
+ status: 'in_progress',
+ };
+ storeState.selectedTeamData.members = [{ ...member, currentTaskId: task.id }];
+ storeState.selectedTeamData.tasks = [task];
+ storeState.memberSpawnStatusesByTeam['northstar-core'].alice = {
+ status: 'offline',
+ launchState: 'confirmed_alive',
+ updatedAt: '2026-04-09T10:00:00.000Z',
+ runtimeAlive: false,
+ };
+
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const root = createRoot(host);
+
+ await act(async () => {
+ root.render(
+ React.createElement(MemberHoverCard, {
+ name: 'alice',
+ children: React.createElement('button', { type: 'button' }, 'alice'),
+ })
+ );
+ await Promise.resolve();
+ });
+
+ expect(host.querySelector('[data-testid="hover-current-task"]')).toBeNull();
+ expect(host.textContent).not.toContain('working on');
+
+ await act(async () => {
+ root.unmount();
+ await Promise.resolve();
+ });
+ });
+
it('copies launch diagnostics with the active runtime run id only for launch errors', async () => {
vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
const writeText = vi.fn().mockResolvedValue(undefined);
diff --git a/test/renderer/components/team/members/MemberList.test.ts b/test/renderer/components/team/members/MemberList.test.ts
index b5880a44..83665994 100644
--- a/test/renderer/components/team/members/MemberList.test.ts
+++ b/test/renderer/components/team/members/MemberList.test.ts
@@ -89,6 +89,24 @@ function failedSpawnStatus(reason: string): MemberSpawnStatusEntry {
};
}
+function offlineSpawnStatus(): MemberSpawnStatusEntry {
+ return {
+ status: 'offline',
+ launchState: 'confirmed_alive',
+ updatedAt: '2026-04-23T10:00:00.000Z',
+ runtimeAlive: false,
+ bootstrapConfirmed: false,
+ };
+}
+
+function activeTask(id = 'task-active'): TeamTaskWithKanban {
+ return {
+ id,
+ subject: 'Active task',
+ status: 'in_progress',
+ };
+}
+
describe('MemberList spawn-status memoization', () => {
beforeEach(() => {
vi.stubGlobal(
@@ -240,6 +258,61 @@ describe('MemberList spawn-status memoization', () => {
});
});
+ it('does not pass active current tasks to cards while the whole team is offline', async () => {
+ vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const root = createRoot(host);
+ const task = activeTask();
+ const members: ResolvedTeamMember[] = [{ ...member, currentTaskId: task.id }];
+
+ await act(async () => {
+ root.render(
+ React.createElement(MemberList, {
+ members,
+ isTeamAlive: false,
+ taskMap: new Map([[task.id, task]]),
+ })
+ );
+ await Promise.resolve();
+ });
+
+ expect(host.querySelector('[data-testid="current-bob"]')).toBeNull();
+
+ await act(async () => {
+ root.unmount();
+ await Promise.resolve();
+ });
+ });
+
+ it('does not pass active current tasks to cards for individually offline members', async () => {
+ vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const root = createRoot(host);
+ const task = activeTask();
+ const members: ResolvedTeamMember[] = [{ ...member, currentTaskId: task.id }];
+
+ await act(async () => {
+ root.render(
+ React.createElement(MemberList, {
+ members,
+ isTeamAlive: true,
+ taskMap: new Map([[task.id, task]]),
+ memberSpawnStatuses: new Map([['bob', offlineSpawnStatus()]]),
+ })
+ );
+ await Promise.resolve();
+ });
+
+ expect(host.querySelector('[data-testid="current-bob"]')).toBeNull();
+
+ await act(async () => {
+ root.unmount();
+ await Promise.resolve();
+ });
+ });
+
it('passes skip callbacks to failed member cards and rerenders when the callback changes', async () => {
vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
const host = document.createElement('div');
diff --git a/test/renderer/features/agent-graph/GraphMemberLogPreviewHud.test.tsx b/test/renderer/features/agent-graph/GraphMemberLogPreviewHud.test.tsx
index c75c49a1..a438bf52 100644
--- a/test/renderer/features/agent-graph/GraphMemberLogPreviewHud.test.tsx
+++ b/test/renderer/features/agent-graph/GraphMemberLogPreviewHud.test.tsx
@@ -6,7 +6,7 @@ import { GraphMemberLogPreviewHud } from '@features/agent-graph/renderer/ui/Grap
import type { GraphNode } from '@claude-teams/agent-graph';
-const previewsByMember = new Map([
+const basePreviewsByMember = new Map([
[
'team-lead',
{
@@ -43,6 +43,24 @@ const previewsByMember = new Map([
preview: 'pnpm test',
tone: 'warning' as const,
},
+ {
+ id: 'preview-2',
+ kind: 'tool_result' as const,
+ provider: 'opencode_runtime' as const,
+ timestamp: '2026-04-03T00:00:30.000Z',
+ title: 'Send message error',
+ preview: 'OpenCode tool failed without output',
+ tone: 'error' as const,
+ },
+ {
+ id: 'preview-3',
+ kind: 'tool_result' as const,
+ provider: 'opencode_runtime' as const,
+ timestamp: '2026-04-03T00:00:40.000Z',
+ title: 'Bash result',
+ preview: 'Tests passed',
+ tone: 'success' as const,
+ },
],
coverage: [{ provider: 'claude_transcript' as const, status: 'included' as const }],
warnings: [],
@@ -52,11 +70,12 @@ const previewsByMember = new Map([
},
],
]);
+let mockedPreviewsByMember = basePreviewsByMember;
vi.mock('@features/agent-graph/renderer/hooks/useGraphMemberLogPreviews', () => ({
buildGraphLogPreviewLaneIdsByMember: () => ({ alice: 'secondary:opencode:alice' }),
useGraphMemberLogPreviews: () => ({
- previewsByMember,
+ previewsByMember: mockedPreviewsByMember,
loading: false,
error: null,
reload: vi.fn(),
@@ -93,6 +112,7 @@ describe('GraphMemberLogPreviewHud', () => {
vi.stubGlobal('cancelAnimationFrame', vi.fn());
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-04-03T00:01:00.000Z'));
+ mockedPreviewsByMember = basePreviewsByMember;
});
afterEach(() => {
@@ -141,6 +161,20 @@ describe('GraphMemberLogPreviewHud', () => {
button.textContent?.includes('pnpm test')
);
expect(row).not.toBeUndefined();
+ expect(row?.querySelector('.float-left')).not.toBeNull();
+ expect(row?.querySelector('.line-clamp-3')).toBeNull();
+ expect(row?.textContent).toContain('pnpm test');
+
+ const errorRow = Array.from(host.querySelectorAll('button')).find((button) =>
+ button.textContent?.includes('OpenCode tool failed')
+ );
+ expect(errorRow?.querySelector('svg.text-rose-300')).not.toBeNull();
+
+ const resultRow = Array.from(host.querySelectorAll('button')).find((button) =>
+ button.textContent?.includes('Tests passed')
+ );
+ expect(resultRow?.textContent).toContain('Bash');
+ expect(resultRow?.textContent).not.toContain('Bash result');
await act(async () => {
row?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
@@ -166,6 +200,83 @@ describe('GraphMemberLogPreviewHud', () => {
});
});
+ it('briefly highlights a newly appeared preview row', async () => {
+ const node: GraphNode = {
+ id: 'member:alpha-team:alice',
+ kind: 'member',
+ label: 'alice',
+ state: 'active',
+ domainRef: { kind: 'member', teamName: 'alpha-team', memberName: 'alice' },
+ };
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const root = createRoot(host);
+ const renderHud = (): void => {
+ root.render(
+ ({
+ left: 40,
+ top: 80,
+ right: 300,
+ bottom: 372,
+ width: 260,
+ height: 292,
+ })}
+ getCameraZoom={() => 1}
+ worldToScreen={(x, y) => ({ x, y })}
+ getViewportSize={() => ({ width: 1200, height: 800 })}
+ focusNodeIds={null}
+ />
+ );
+ };
+
+ await act(async () => {
+ renderHud();
+ await Promise.resolve();
+ });
+
+ const alicePreview = basePreviewsByMember.get('alice')!;
+ mockedPreviewsByMember = new Map(basePreviewsByMember);
+ mockedPreviewsByMember.set('alice', {
+ ...alicePreview,
+ items: [
+ {
+ id: 'preview-new',
+ kind: 'text' as const,
+ provider: 'claude_transcript' as const,
+ timestamp: '2026-04-03T00:01:00.000Z',
+ title: 'Assistant',
+ preview: 'new compact log',
+ tone: 'neutral' as const,
+ },
+ ...alicePreview.items,
+ ],
+ });
+
+ await act(async () => {
+ renderHud();
+ await Promise.resolve();
+ });
+
+ const newRow = Array.from(host.querySelectorAll('button')).find((button) =>
+ button.textContent?.includes('new compact log')
+ );
+ expect(newRow?.className).toContain('border-sky-300/70');
+
+ await act(async () => {
+ vi.advanceTimersByTime(1_000);
+ await Promise.resolve();
+ });
+
+ expect(newRow?.className).not.toContain('border-sky-300/70');
+
+ act(() => {
+ root.unmount();
+ });
+ });
+
it('renders lead log previews and opens the lead profile logs tab', async () => {
const leadNode: GraphNode = {
id: 'lead:alpha-team',
diff --git a/test/renderer/features/agent-graph/useGraphSimulation.test.ts b/test/renderer/features/agent-graph/useGraphSimulation.test.ts
index 5cb11542..a921e312 100644
--- a/test/renderer/features/agent-graph/useGraphSimulation.test.ts
+++ b/test/renderer/features/agent-graph/useGraphSimulation.test.ts
@@ -11,7 +11,10 @@ import {
validateStableSlotLayout,
} from '../../../../packages/agent-graph/src/layout/stableSlots';
import { KanbanLayoutEngine } from '../../../../packages/agent-graph/src/layout/kanbanLayout';
-import { TASK_PILL } from '../../../../packages/agent-graph/src/constants/canvas-constants';
+import {
+ KANBAN_ZONE,
+ TASK_PILL,
+} from '../../../../packages/agent-graph/src/constants/canvas-constants';
import { ACTIVITY_LANE } from '../../../../packages/agent-graph/src/layout/activityLane';
import {
STABLE_SLOT_GEOMETRY,
@@ -171,7 +174,10 @@ describe('stable slot layout planner', () => {
expect(frame).toBeDefined();
expect(frame?.boardBandRect.top).toBe(frame?.activityColumnRect.top);
expect(frame?.boardBandRect.top).toBe(frame?.logColumnRect.top);
- expect(frame?.boardBandRect.top).toBe(frame?.kanbanBandRect.top);
+ const expectedKanbanTopInset =
+ ACTIVITY_LANE.headerHeight + 4 - (KANBAN_ZONE.headerHeight - TASK_PILL.height / 2);
+ expect(frame?.kanbanBandRect.top).toBe(frame!.boardBandRect.top + expectedKanbanTopInset);
+ expect(frame?.kanbanBandRect.bottom).toBeLessThanOrEqual(frame!.boardBandRect.bottom);
expect(frame?.activityColumnRect.left).toBe(frame?.boardBandRect.left);
expect(frame?.logColumnRect.left).toBeGreaterThan(frame?.activityColumnRect.right ?? 0);
expect(frame?.kanbanBandRect.left).toBeGreaterThan(frame?.logColumnRect.right ?? 0);
diff --git a/test/renderer/utils/memberActivityTimer.test.ts b/test/renderer/utils/memberActivityTimer.test.ts
new file mode 100644
index 00000000..b5f824ee
--- /dev/null
+++ b/test/renderer/utils/memberActivityTimer.test.ts
@@ -0,0 +1,284 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+ createMemberActivityTimerId,
+ deriveReviewActivityTimerAnchor,
+ deriveWorkActivityTimerAnchor,
+ formatMemberActivityElapsed,
+ readMemberActivityTimerElapsed,
+ resetMemberActivityTimerStoreForTests,
+ syncMemberActivityTimer,
+} from '@renderer/utils/memberActivityTimer';
+
+import type { TeamTaskWithKanban } from '@shared/types';
+
+const baseTask: TeamTaskWithKanban = {
+ id: 'task-1',
+ displayId: 'abc12345',
+ subject: 'Build feature',
+ status: 'in_progress',
+ createdAt: '2026-05-07T09:00:00.000Z',
+ reviewState: 'none',
+};
+
+describe('memberActivityTimer', () => {
+ afterEach(() => {
+ vi.useRealTimers();
+ resetMemberActivityTimerStoreForTests();
+ globalThis.localStorage?.clear();
+ });
+
+ it('anchors work timers to the active work interval', () => {
+ const task: TeamTaskWithKanban = {
+ ...baseTask,
+ workIntervals: [
+ {
+ startedAt: '2026-05-07T09:10:00.000Z',
+ completedAt: '2026-05-07T09:15:00.000Z',
+ },
+ { startedAt: '2026-05-07T09:20:00.000Z' },
+ ],
+ };
+
+ const anchor = deriveWorkActivityTimerAnchor(task, {
+ teamName: 'alpha',
+ memberName: 'bob',
+ });
+
+ expect(anchor?.startedAt).toBe('2026-05-07T09:20:00.000Z');
+ expect(anchor?.baseElapsedMs).toBe(300_000);
+ expect(anchor?.timerId).toContain('task-1');
+ });
+
+ it('adds completed work intervals to the active timer elapsed value', () => {
+ const task: TeamTaskWithKanban = {
+ ...baseTask,
+ workIntervals: [
+ {
+ startedAt: '2026-05-07T09:10:00.000Z',
+ completedAt: '2026-05-07T09:15:00.000Z',
+ },
+ { startedAt: '2026-05-07T09:20:00.000Z' },
+ ],
+ };
+ const anchor = deriveWorkActivityTimerAnchor(task, {
+ teamName: 'alpha',
+ memberName: 'bob',
+ });
+ expect(anchor).not.toBeNull();
+
+ expect(
+ readMemberActivityTimerElapsed({
+ timerId: anchor!.timerId,
+ startedAtMs: anchor!.startedAtMs,
+ baseElapsedMs: anchor!.baseElapsedMs,
+ running: true,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:21:00.000Z'),
+ })
+ ).toBe(360_000);
+ });
+
+ it('does not invent a work timer when task start evidence is missing', () => {
+ expect(
+ deriveWorkActivityTimerAnchor(baseTask, {
+ teamName: 'alpha',
+ memberName: 'bob',
+ })
+ ).toBeNull();
+ });
+
+ it('treats closed work intervals without an active interval as paused', () => {
+ const task: TeamTaskWithKanban = {
+ ...baseTask,
+ workIntervals: [
+ {
+ startedAt: '2026-05-07T09:10:00.000Z',
+ completedAt: '2026-05-07T09:15:00.000Z',
+ },
+ ],
+ historyEvents: [
+ {
+ id: 'evt-1',
+ type: 'status_changed',
+ from: 'pending',
+ to: 'in_progress',
+ timestamp: '2026-05-07T09:10:00.000Z',
+ },
+ ],
+ };
+
+ expect(
+ deriveWorkActivityTimerAnchor(task, {
+ teamName: 'alpha',
+ memberName: 'bob',
+ })
+ ).toBeNull();
+ });
+
+ it('anchors review timers only after the reviewer actually starts review', () => {
+ const assignedOnly: TeamTaskWithKanban = {
+ ...baseTask,
+ status: 'completed',
+ reviewState: 'review',
+ kanbanColumn: 'review',
+ reviewer: 'alice',
+ historyEvents: [
+ {
+ id: 'evt-1',
+ type: 'review_requested',
+ from: 'none',
+ to: 'review',
+ reviewer: 'alice',
+ timestamp: '2026-05-07T09:30:00.000Z',
+ },
+ ],
+ };
+
+ expect(
+ deriveReviewActivityTimerAnchor(assignedOnly, {
+ teamName: 'alpha',
+ memberName: 'alice',
+ })
+ ).toBeNull();
+
+ const started: TeamTaskWithKanban = {
+ ...assignedOnly,
+ historyEvents: [
+ ...(assignedOnly.historyEvents ?? []),
+ {
+ id: 'evt-2',
+ type: 'review_started',
+ from: 'review',
+ to: 'review',
+ actor: 'alice',
+ timestamp: '2026-05-07T09:35:00.000Z',
+ },
+ ],
+ };
+
+ expect(
+ deriveReviewActivityTimerAnchor(started, {
+ teamName: 'alpha',
+ memberName: 'alice',
+ })?.startedAt
+ ).toBe('2026-05-07T09:35:00.000Z');
+ });
+
+ it('pauses elapsed time while the activity is not running and resumes from the frozen value', () => {
+ const timerId = createMemberActivityTimerId({
+ teamName: 'alpha',
+ memberName: 'bob',
+ phase: 'work',
+ taskId: 'task-1',
+ startedAt: '2026-05-07T09:00:00.000Z',
+ });
+ const startedAtMs = Date.parse('2026-05-07T09:00:00.000Z');
+
+ syncMemberActivityTimer({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: true,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:01:00.000Z'),
+ });
+
+ expect(
+ readMemberActivityTimerElapsed({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: true,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:02:00.000Z'),
+ })
+ ).toBe(120_000);
+
+ syncMemberActivityTimer({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: false,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:02:00.000Z'),
+ });
+
+ expect(
+ readMemberActivityTimerElapsed({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: false,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:05:00.000Z'),
+ })
+ ).toBe(120_000);
+
+ syncMemberActivityTimer({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: true,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:05:00.000Z'),
+ });
+
+ expect(
+ readMemberActivityTimerElapsed({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: true,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:06:00.000Z'),
+ })
+ ).toBe(180_000);
+ });
+
+ it('caps elapsed time across unobserved runtime run transitions', () => {
+ const timerId = createMemberActivityTimerId({
+ teamName: 'alpha',
+ memberName: 'bob',
+ phase: 'work',
+ taskId: 'task-1',
+ startedAt: '2026-05-07T09:00:00.000Z',
+ });
+ const startedAtMs = Date.parse('2026-05-07T09:00:00.000Z');
+
+ syncMemberActivityTimer({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: true,
+ runId: 'run-1',
+ nowMs: Date.parse('2026-05-07T09:01:00.000Z'),
+ });
+
+ syncMemberActivityTimer({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: true,
+ runId: 'run-2',
+ nowMs: Date.parse('2026-05-07T10:00:00.000Z'),
+ });
+
+ expect(
+ readMemberActivityTimerElapsed({
+ timerId,
+ startedAtMs,
+ baseElapsedMs: 0,
+ running: true,
+ runId: 'run-2',
+ nowMs: Date.parse('2026-05-07T10:00:00.000Z'),
+ })
+ ).toBe(65_000);
+ });
+
+ it('formats seconds, minutes, and hours compactly', () => {
+ expect(formatMemberActivityElapsed(9_000)).toBe('9s');
+ expect(formatMemberActivityElapsed(65_000)).toBe('1m 05s');
+ expect(formatMemberActivityElapsed(3_780_000)).toBe('1h 03m');
+ });
+});
diff --git a/test/renderer/utils/memberHelpers.test.ts b/test/renderer/utils/memberHelpers.test.ts
index 7c0e1ea5..7395d715 100644
--- a/test/renderer/utils/memberHelpers.test.ts
+++ b/test/renderer/utils/memberHelpers.test.ts
@@ -8,6 +8,7 @@ import {
getMemberRuntimeAdvisoryTitle,
getMemberRuntimeAdvisoryTone,
isOpenCodeRelaunchActionable,
+ shouldDisplayMemberCurrentTask,
} from '@renderer/utils/memberHelpers';
import type { ResolvedTeamMember } from '@shared/types';
@@ -27,6 +28,73 @@ const member: ResolvedTeamMember = {
};
describe('memberHelpers spawn-aware presence', () => {
+ it('does not display current task labels for offline or terminal launch states', () => {
+ expect(
+ shouldDisplayMemberCurrentTask({
+ member: { ...member, currentTaskId: 'task-1' },
+ isTeamAlive: false,
+ })
+ ).toBe(false);
+
+ expect(
+ shouldDisplayMemberCurrentTask({
+ member: { ...member, currentTaskId: 'task-1' },
+ isTeamAlive: true,
+ spawnStatus: 'offline',
+ spawnLaunchState: 'confirmed_alive',
+ spawnRuntimeAlive: false,
+ })
+ ).toBe(false);
+
+ expect(
+ shouldDisplayMemberCurrentTask({
+ member: { ...member, currentTaskId: 'task-1' },
+ isTeamAlive: true,
+ spawnStatus: 'error',
+ spawnLaunchState: 'failed_to_start',
+ })
+ ).toBe(false);
+ });
+
+ it('does not display current task labels for runtime entries without a live agent runtime', () => {
+ expect(
+ shouldDisplayMemberCurrentTask({
+ member: { ...member, currentTaskId: 'task-1' },
+ isTeamAlive: true,
+ spawnStatus: 'online',
+ spawnLaunchState: 'confirmed_alive',
+ runtimeEntry: {
+ memberName: 'alice',
+ alive: false,
+ restartable: true,
+ providerId: 'opencode',
+ livenessKind: 'stale_metadata',
+ updatedAt: '2026-04-24T12:00:00.000Z',
+ },
+ })
+ ).toBe(false);
+ });
+
+ it('keeps current task labels for confirmed online members', () => {
+ expect(
+ shouldDisplayMemberCurrentTask({
+ member: { ...member, currentTaskId: 'task-1' },
+ isTeamAlive: true,
+ spawnStatus: 'online',
+ spawnLaunchState: 'confirmed_alive',
+ spawnRuntimeAlive: true,
+ runtimeEntry: {
+ memberName: 'alice',
+ alive: true,
+ restartable: true,
+ providerId: 'gemini',
+ livenessKind: 'confirmed_bootstrap',
+ updatedAt: '2026-04-24T12:00:00.000Z',
+ },
+ })
+ ).toBe(true);
+ });
+
it('shows process-online teammates as online with a green dot', () => {
expect(
getSpawnAwarePresenceLabel(