Skip to content

Self-improving AI Employees for everyone

Show live AI employee task and activity progress

trohitg3110b3a868a2
diff --git a/client/src/features/home/__tests__/employeeChat.test.tsx b/client/src/features/home/__tests__/employeeChat.test.tsx
index 5357997e..5fe80a42 100644
--- a/client/src/features/home/__tests__/employeeChat.test.tsx
+++ b/client/src/features/home/__tests__/employeeChat.test.tsx
@@ -272,6 +272,8 @@ describe('Turn on Talk', () => {
? { success: true, employee: { ...off, control: undefined, talk: { state: 'on', agent_node_id: AGENT }, revision: 9 } }
: type === 'list_employees'
? { success: true, employees: [fromDatabase] }
+ : type === 'get_employee'
+ ? { success: true, employee: fromDatabase }
: type === 'chat_subscribe'
? { success: true, hub_epoch: 'e1', active_runs: [] }
: { success: true, messages: [] },
@@ -288,7 +290,7 @@ describe('Turn on Talk', () => {
const [, payload, timeout] = sendRequest.mock.calls.find(([type]) => type === 'enable_employee_talk')!;
expect(payload).toEqual({ workflow_id: 'w1', idempotency_key: expect.any(String) });
expect(timeout).toBe(WORKFLOW_CONTROL_REQUEST_TIMEOUT);
- expect(client.getQueryState(employeeDetailKey('w1'))?.isInvalidated).toBe(true);
+ await waitFor(() => expect(client.getQueryData<EmployeeSummary>(employeeDetailKey('w1'))).toMatchObject({ revision: 10, talk: { state: 'on' } }));
await waitFor(() => expect(client.getQueryData<EmployeeSummary[]>(EMPLOYEES_QUERY_KEY)?.[0]).toMatchObject({ revision: 10, talk: { state: 'on' } }));
expect(sendRequest).toHaveBeenCalledWith('list_employees', {});
});
diff --git a/client/src/features/home/data/employees.ts b/client/src/features/home/data/employees.ts
index ef00045d..8b0376d4 100644
--- a/client/src/features/home/data/employees.ts
+++ b/client/src/features/home/data/employees.ts
@@ -18,6 +18,7 @@ import { useEffect } from 'react';
import { useQuery, useQueryClient, type QueryClient } from '@tanstack/react-query';
import { useWebSocketActions } from '@/contexts/WebSocketContext';
import { makeDebouncedInvalidator } from '@/lib/debouncedInvalidate';
+import { useNodeStatusStore } from '@/stores/nodeStatusStore';
import { parseEmployeeDetail, parseEmployees, type EmployeeDetail, type EmployeeSummary } from './schemas';
import { EMPLOYEES_QUERY_KEY, employeeDetailKey, removeEmployee } from './employeeCache';
@@ -51,8 +52,28 @@ export function useEmployeesQuery() {
});
}
-export function useEmployeeDetailQuery(workflowId: string | null) {
+export function useEmployeeDetailQuery(workflowId: string | null, options: { live?: boolean } = {}) {
const { sendRequest, isReady } = useWebSocketActions();
+ const cache = useQueryClient();
+ const live = options.live === true;
+ useEffect(() => {
+ if (!live || !isReady || !workflowId) return;
+ // A burst of tool/phase broadcasts costs at most one detail read every
+ // three seconds. Polling below also catches durable task transitions and
+ // deliveries that do not emit a node-status event.
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ const off = useNodeStatusStore.subscribe((state, previous) => {
+ if (state.allStatuses[workflowId] === previous.allStatuses[workflowId] || timer !== undefined) return;
+ timer = setTimeout(() => {
+ timer = undefined;
+ void cache.invalidateQueries({ queryKey: employeeDetailKey(workflowId), exact: true });
+ }, 3000);
+ });
+ return () => {
+ off();
+ if (timer !== undefined) clearTimeout(timer);
+ };
+ }, [cache, isReady, live, workflowId]);
return useQuery<EmployeeDetail | null, Error>({
queryKey: employeeDetailKey(workflowId ?? ''),
queryFn: async () => {
@@ -66,8 +87,15 @@ export function useEmployeeDetailQuery(workflowId: string | null) {
return parseEmployeeDetail(response?.employee);
},
enabled: isReady && Boolean(workflowId),
- staleTime: 30_000,
+ // Live observers must reconcile immediately when the socket becomes
+ // ready again, even when the retained snapshot is only seconds old.
+ staleTime: live ? 0 : 30_000,
refetchOnMount: 'always',
+ refetchInterval: !live || !isReady ? false : (query) => {
+ if (query.state.data === null) return false;
+ const progress = query.state.data?.work_progress;
+ return progress && !['idle', 'done', 'failed', 'cancelled'].includes(progress.state) ? 5000 : 15000;
+ },
});
}
diff --git a/client/src/features/home/data/schemas.ts b/client/src/features/home/data/schemas.ts
index 23fef61d..76eec77c 100644
--- a/client/src/features/home/data/schemas.ts
+++ b/client/src/features/home/data/schemas.ts
@@ -98,7 +98,28 @@ const planStepSchema = z.object({
const ruleItemSchema = z.object({ key: z.string(), label: z.string(), value: z.boolean() });
+const workStepSchema = z.object({
+ id: z.string(),
+ node_id: z.string().nullable().catch(null),
+ label: z.string(),
+ member: z.string().nullable().catch(null),
+ status: z.enum(['queued', 'waiting', 'running', 'reviewing', 'done', 'failed', 'cancelled', 'stopping']).catch('waiting'),
+ started_at: z.string().nullable().catch(null),
+ updated_at: z.string().nullable().catch(null),
+});
+
+export const workProgressSchema = z.object({
+ state: z.string(),
+ message: z.string(),
+ started_at: z.string().nullable().catch(null),
+ updated_at: z.string().nullable().catch(null),
+ steps: z.array(workStepSchema).catch([]),
+ truncated: z.boolean().catch(false),
+});
+export type WorkProgress = z.infer<typeof workProgressSchema>;
+
export const employeeDetailSchema = employeeSummarySchema.extend({
+ work_progress: workProgressSchema.nullable().catch(null),
description: z.string().catch(''),
job: z.string().catch(''),
plan: z.array(planStepSchema).catch([]),
diff --git a/client/src/features/home/employee/EmployeeChat.tsx b/client/src/features/home/employee/EmployeeChat.tsx
index d47947c9..d4eb6d34 100644
--- a/client/src/features/home/employee/EmployeeChat.tsx
+++ b/client/src/features/home/employee/EmployeeChat.tsx
@@ -39,7 +39,7 @@ import { PrimaryActionButton } from './PrimaryActionButton';
import { TurnOnTalk } from './TurnOnTalk';
import { EmployeeAccess } from './EmployeeAccess';
import { GiveTeam } from './GiveTeam';
-import { JobProgress } from './JobProgress';
+import { EmployeeWork } from './EmployeeWork';
import type { EmployeeControl } from './useEmployeeControl';
/** The agent is waiting for the owner in the browser (it called `request_user`). */
@@ -84,7 +84,7 @@ function Notices({ employee, control, queued }: { employee: EmployeeSummary; con
</Alert>
)}
{employee.pending_changes && <PendingChangesNotice employee={employee} />}
- <JobProgress key={`${employee.job_progress?.request_id || 'none'}:${employee.job_progress?.state || 'none'}`} employee={employee} />
+ <EmployeeWork key={employee.workflow_id} employee={employee} />
<GiveTeam workflowId={employee.workflow_id} available={employee.can_give_team} />
<EmployeeAccess workflowId={employee.workflow_id} name={name} pendingOnly />
{employee.browser_request && <BrowserNotice employee={employee} />}
diff --git a/client/src/features/home/employee/EmployeeWork.tsx b/client/src/features/home/employee/EmployeeWork.tsx
new file mode 100644
index 00000000..8acf88a9
--- /dev/null
+++ b/client/src/features/home/employee/EmployeeWork.tsx
@@ -0,0 +1,123 @@
+import { useEffect, useState } from 'react';
+import { Check, Circle, LoaderCircle, X } from 'lucide-react';
+import { ActionButton } from '@/components/ui/action-button';
+import { useWebSocketActions } from '@/contexts/WebSocketContext';
+import { useLaneRun } from '@/features/chat';
+import type { RunSnapshot } from '@/lib/agui/reduceRun';
+import { useEmployeeDetailQuery } from '../data/employees';
+import type { EmployeeSummary, WorkProgress } from '../data/schemas';
+import { JobProgress } from './JobProgress';
+
+const ACTIVE = new Set(['queued', 'running', 'working', 'waiting', 'reviewing', 'stopping', 'delivering']);
+const LABELS: Record<string, string> = {
+ queued: 'Queued', waiting: 'Waiting', running: 'In progress', reviewing: 'Checking the result',
+ done: 'Finished', failed: 'Needs attention', cancelled: 'Stopped', stopping: 'Stopping',
+};
+
+function age(timestamp: string | null, now: number): number | null {
+ if (!timestamp) return null;
+ const parsed = Date.parse(timestamp);
+ return Number.isFinite(parsed) ? Math.max(0, Math.floor((now - parsed) / 1000)) : null;
+}
+
+function duration(seconds: number): string {
+ if (seconds < 60) return `${seconds}s`;
+ const minutes = Math.floor(seconds / 60);
+ return minutes < 60 ? `${minutes}m ${seconds % 60}s` : `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+
+function chatProgress(lane: RunSnapshot | null): WorkProgress | null {
+ if (!lane) return null;
+ const state = lane.state === 'queued' ? 'queued' : lane.state === 'stopping' ? 'stopping' : 'running';
+ return {
+ state,
+ message: state === 'queued' ? 'Your message is saved and waiting to start.'
+ : state === 'stopping' ? 'Stopping this reply.' : 'Preparing your reply.',
+ started_at: lane.startedAt ?? lane.createdAt,
+ updated_at: null,
+ truncated: false,
+ steps: lane.steps.map((step) => ({
+ id: step.stepId, node_id: null, label: step.name, member: null,
+ status: step.state === 'skipped' ? 'cancelled' : step.state,
+ started_at: null, updated_at: null,
+ })),
+ };
+}
+
+function WorkPanel({ progress, connected, failed, refresh }: {
+ progress: WorkProgress; connected: boolean; failed: boolean; refresh: () => void;
+}) {
+ const [now, setNow] = useState(Date.now);
+ const active = ACTIVE.has(progress.state);
+ useEffect(() => {
+ if (!active || !connected) return;
+ const timer = setInterval(() => setNow(Date.now()), 1000);
+ return () => clearInterval(timer);
+ }, [active, connected]);
+ const elapsed = age(progress.started_at, now);
+ const updated = age(progress.updated_at, now);
+ const finished = progress.steps.filter((step) => step.status === 'done').length;
+ // Keep the active step visible without expanding a long history.
+ const current = progress.steps.filter((step) => ['running', 'reviewing', 'waiting', 'stopping'].includes(step.status));
+ const recent = [...current, ...progress.steps.filter((step) => !current.includes(step)).slice(-3)].slice(0, 3);
+ const renderStep = (step: WorkProgress['steps'][number]) => (
+ <li key={step.id} className="flex items-start gap-2 py-1 text-sm">
+ {['running', 'reviewing', 'stopping'].includes(step.status)
+ ? <LoaderCircle aria-hidden className="mt-0.5 size-4 shrink-0 motion-safe:animate-spin text-fg-muted" />
+ : step.status === 'done' ? <Check aria-hidden className="mt-0.5 size-4 shrink-0" />
+ : step.status === 'failed' ? <X aria-hidden className="mt-0.5 size-4 shrink-0" />
+ : <Circle aria-hidden className="mt-0.5 size-4 shrink-0 text-fg-muted" />}
+ <div className="min-w-0 flex-1 break-words">
+ <span>{step.label}</span>
+ <span className="block text-xs text-fg-muted">{step.member ? `${step.member} · ` : ''}{LABELS[step.status] ?? 'Waiting'}</span>
+ </div>
+ </li>
+ );
+ return (
+ <section aria-label="Employee work progress" className="flex max-h-64 flex-col gap-2 overflow-y-auto rounded-card border border-border-default bg-bg-panel p-4">
+ <div className="flex items-center justify-between gap-3">
+ <h2 className="m-0 text-sm font-medium">{connected ? 'Live work' : 'Last known activity'}</h2>
+ {elapsed !== null && <span className="shrink-0 text-xs text-fg-muted">{active ? 'Elapsed' : 'Started'} {duration(elapsed)}{!active && ' ago'}</span>}
+ </div>
+ <p role="status" className="m-0 break-words text-sm">{progress.message}</p>
+ {!connected && <p className="m-0 text-xs text-fg-muted">Connection lost. Updates will resume when you reconnect.</p>}
+ {connected && failed && <div className="flex flex-wrap items-center gap-2">
+ <p className="m-0 text-xs text-fg-muted">Couldn’t refresh progress. Showing the last update.</p>
+ <ActionButton intent="config" onClick={refresh}>Refresh progress</ActionButton>
+ </div>}
+ {connected && !failed && updated !== null && <p className="m-0 text-xs text-fg-muted">Last activity {updated < 5 ? 'just now' : `${duration(updated)} ago`}</p>}
+ {connected && !failed && active && !['waiting', 'queued', 'stopping'].includes(progress.state) && updated !== null && updated >= 60 &&
+ <p className="m-0 text-xs text-fg-muted">This is taking longer. The last reported step is shown below; no new activity has been reported yet.</p>}
+ {progress.steps.length > 0 && <>
+ <p className="m-0 text-xs text-fg-muted">{finished} of {progress.steps.length}{progress.truncated ? ' shown' : ''} steps finished</p>
+ <ul aria-label="Current activity" className="m-0 list-none p-0">{recent.map(renderStep)}</ul>
+ {progress.steps.length > recent.length && <details>
+ <summary className="cursor-pointer text-xs text-fg-muted">Show all activity ({progress.steps.length})</summary>
+ <ul aria-label="All activity" className="m-0 list-none p-0">{progress.steps.map(renderStep)}</ul>
+ </details>}
+ {progress.truncated && <p className="m-0 text-xs text-fg-muted">Showing the most recent activity.</p>}
+ </>}
+ </section>
+ );
+}
+
+/** Detailed work stays separate from list-owned controls and composer state. */
+export function EmployeeWork({ employee }: { employee: EmployeeSummary }) {
+ const { isReady } = useWebSocketActions();
+ const detail = useEmployeeDetailQuery(employee.workflow_id, { live: true });
+ const lane = useLaneRun(employee.workflow_id);
+ const saved = detail.data?.work_progress;
+ // A new message starts immediately; a previous completed job must not
+ // mask its live steps while the next detail snapshot is on its way.
+ const progress = saved && !(lane && ['done', 'failed', 'cancelled'].includes(saved.state)) ? saved : chatProgress(lane);
+ const job = detail.data ? detail.data.job_progress : employee.job_progress;
+ const delivery = job && ['delivery_needs_review', 'waiting_for_approval', 'failed', 'cancelled'].includes(job.state);
+ return <>
+ {progress && <WorkPanel progress={progress} connected={isReady} failed={detail.isError || progress.state === 'unavailable'} refresh={() => void detail.refetch()} />}
+ {!progress && detail.isError && <div className="flex flex-wrap items-center gap-2 text-xs text-fg-muted">
+ <span>Work progress is unavailable.</span>
+ <ActionButton intent="config" onClick={() => void detail.refetch()}>Refresh progress</ActionButton>
+ </div>}
+ {(delivery || (!progress && job)) && <JobProgress key={`${job.request_id}:${job.state}`} employee={{ ...employee, job_progress: job }} />}
+ </>;
+}
diff --git a/client/src/features/home/employee/JobProgress.tsx b/client/src/features/home/employee/JobProgress.tsx
index 8511da94..3d05b083 100644
--- a/client/src/features/home/employee/JobProgress.tsx
+++ b/client/src/features/home/employee/JobProgress.tsx
@@ -2,7 +2,7 @@ import { useMutation, useQueryClient } from '@tanstack/react-query';
import { useRef } from 'react';
import { useWebSocketActions } from '@/contexts/WebSocketContext';
import { ActionButton } from '@/components/ui/action-button';
-import { invalidateEmployees } from '../data/employees';
+import { refreshEmployee } from '../data/employees';
import type { EmployeeSummary } from '../data/schemas';
export function JobProgress({ employee }: { employee: EmployeeSummary }) {
@@ -21,7 +21,7 @@ export function JobProgress({ employee }: { employee: EmployeeSummary }) {
});
if (!response?.success) throw new Error(response?.message || 'Your delivery decision could not be saved. Try again.');
return response;
- }, onSuccess: () => invalidateEmployees(cache) });
+ }, onSuccess: () => refreshEmployee(cache, employee.workflow_id) });
if (!progress) return null;
const needsReview = progress.state === 'delivery_needs_review';
return <div className="flex flex-col gap-3 rounded-card border border-border-default bg-bg-panel p-4">
diff --git a/client/src/features/home/employee/__tests__/EmployeeWork.test.tsx b/client/src/features/home/employee/__tests__/EmployeeWork.test.tsx
new file mode 100644
index 00000000..751e9804
--- /dev/null
+++ b/client/src/features/home/employee/__tests__/EmployeeWork.test.tsx
@@ -0,0 +1,140 @@
+import { act, render, screen, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useState } from 'react';
+
+const actions = { sendRequest: vi.fn(), isReady: true };
+vi.mock('@/contexts/WebSocketContext', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/contexts/WebSocketContext')>()),
+ useWebSocketActions: () => actions,
+}));
+
+import { EmployeeWork } from '../EmployeeWork';
+import { employeeDetailKey } from '../../data/employees';
+import { parseEmployee, parseEmployeeDetail } from '../../data/schemas';
+import { emptyRun } from '@/lib/agui/reduceRun';
+import { resetChatRunStore, useChatRunStore } from '@/stores/chatRunStore';
+import { useNodeStatusStore } from '@/stores/nodeStatusStore';
+
+let cache: QueryClient;
+const now = new Date().toISOString();
+const progress = {
+ state: 'running', message: 'Research is gathering information for your request.',
+ started_at: '2026-10-06T08:57:00.000Z', updated_at: '2026-10-06T08:58:30.000Z',
+ steps: [
+ { id: 'task-1', label: 'Gather information', member: 'Research', status: 'running' },
+ { id: 'task-2', label: 'Check appointments', member: 'Appointments', status: 'done' },
+ { id: 'task-3', label: 'Check the result', member: 'Maya', status: 'waiting' },
+ ],
+};
+
+function show(extra: Record<string, unknown> = {}) {
+ const employee = parseEmployee({ workflow_id: 'w1', name: 'Maya', status: 'working', has_team: true })!;
+ const detail = parseEmployeeDetail({ ...employee, work_progress: progress, ...extra })!;
+ cache.setQueryData(employeeDetailKey('w1'), detail);
+ actions.sendRequest.mockResolvedValue({ success: true, employee: detail });
+ return render(<QueryClientProvider client={cache}><EmployeeWork employee={employee} /></QueryClientProvider>);
+}
+
+beforeEach(() => {
+ actions.isReady = true;
+ actions.sendRequest.mockReset();
+ resetChatRunStore();
+ useNodeStatusStore.setState({ allStatuses: {} });
+ cache = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+ progress.started_at = new Date(Date.now() - 180_000).toISOString();
+ progress.updated_at = new Date(Date.now() - 90_000).toISOString();
+});
+
+afterEach(() => { cache.clear(); vi.useRealTimers(); });
+
+describe('employee live work', () => {
+ it('reads detailed progress even when the employee already exists in the team list', async () => {
+ show();
+ await waitFor(() => expect(actions.sendRequest).toHaveBeenCalledWith('get_employee', { workflow_id: 'w1' }));
+ const panel = screen.getByRole('region', { name: 'Employee work progress' });
+ expect(panel).toHaveTextContent('Live work');
+ expect(panel).toHaveTextContent('Research is gathering information');
+ expect(panel).toHaveTextContent('Research · In progress');
+ expect(panel).toHaveTextContent('Appointments · Finished');
+ expect(panel).toHaveTextContent('1 of 3 steps finished');
+ expect(panel).toHaveTextContent(/Elapsed 3m \d+s/);
+ expect(panel).toHaveTextContent(/Last activity 1m \d+s ago/);
+ expect(panel).toHaveTextContent('This is taking longer');
+ });
+
+ it('shows an approval wait without labelling it as a slow task or retrying delivery', () => {
+ show({ work_progress: { ...progress, state: 'waiting', message: 'Their result is waiting for you to approve.' },
+ job_progress: { request_id: 'job-1', state: 'waiting_for_approval', message: 'Their result is ready for you to check before sending.' } });
+ expect(screen.getByRole('region', { name: 'Employee work progress' })).toHaveTextContent('waiting for you to approve');
+ expect(screen.queryByText(/This is taking longer/)).not.toBeInTheDocument();
+ expect(screen.queryByRole('button', { name: /retry/i })).not.toBeInTheDocument();
+ expect(actions.sendRequest.mock.calls.every(([type]) => type === 'get_employee')).toBe(true);
+ });
+
+ it('shows stale activity as last known when disconnected and preserves it through reconnect', async () => {
+ actions.isReady = false;
+ const view = show();
+ expect(screen.getByText('Last known activity')).toBeInTheDocument();
+ expect(screen.getByText(/Connection lost/)).toBeInTheDocument();
+ expect(screen.queryByText(/This is taking longer/)).not.toBeInTheDocument();
+ expect(actions.sendRequest).not.toHaveBeenCalled();
+ actions.isReady = true;
+ view.rerender(<QueryClientProvider client={cache}><EmployeeWork employee={parseEmployee({ workflow_id: 'w1', name: 'Maya' })!} /></QueryClientProvider>);
+ await waitFor(() => expect(actions.sendRequest).toHaveBeenCalledTimes(1));
+ expect(screen.getByText('Live work')).toBeInTheDocument();
+ expect(screen.queryByText(/Connection lost/)).not.toBeInTheDocument();
+ });
+
+ it('retains the last update and offers refresh when progress cannot be loaded', async () => {
+ show();
+ await waitFor(() => expect(actions.sendRequest).toHaveBeenCalledTimes(1));
+ actions.sendRequest.mockRejectedValue(new Error('internal execution error'));
+ await act(async () => { await cache.invalidateQueries({ queryKey: employeeDetailKey('w1'), exact: true }); });
+ expect(await screen.findByText(/Couldn’t refresh progress/)).toBeInTheDocument();
+ expect(screen.getByRole('button', { name: 'Refresh progress' })).toBeInTheDocument();
+ expect(screen.queryByText('internal execution error')).not.toBeInTheDocument();
+ expect(screen.getByText('Gather information')).toBeInTheDocument();
+ });
+
+ it('shows legacy chat tool steps immediately and changes them as the live run progresses', () => {
+ const run = { ...emptyRun('r1', 'w1'), state: 'running' as const, startedAt: now,
+ steps: [{ stepId: 'search', name: 'Searching the web', state: 'running' as const }] };
+ useChatRunStore.getState().upsertRun(run);
+ show({ work_progress: null });
+ expect(screen.getByText('Searching the web')).toBeInTheDocument();
+ act(() => useChatRunStore.getState().upsertRun({ ...run, seq: 2, steps: [{ ...run.steps[0], state: 'done' }] }));
+ expect(screen.getByText('1 of 1 steps finished')).toBeInTheDocument();
+ });
+
+ it('keeps employee progress isolated when switching conversations', async () => {
+ const a = parseEmployee({ workflow_id: 'w1', name: 'Maya' })!;
+ const b = parseEmployee({ workflow_id: 'w2', name: 'Arjun' })!;
+ cache.setQueryData(employeeDetailKey('w1'), parseEmployeeDetail({ ...a, work_progress: progress }));
+ actions.sendRequest.mockImplementation(async (_type, data) => ({ success: true, employee: { ...(data.workflow_id === 'w1' ? a : b), work_progress: data.workflow_id === 'w1' ? progress : null } }));
+ function Switch() {
+ const [employee, setEmployee] = useState(a);
+ return <><button onClick={() => setEmployee(b)}>Switch employee</button><EmployeeWork key={employee.workflow_id} employee={employee} /></>;
+ }
+ render(<QueryClientProvider client={cache}><Switch /></QueryClientProvider>);
+ expect(screen.getByText('Gather information')).toBeInTheDocument();
+ act(() => screen.getByRole('button', { name: 'Switch employee' }).click());
+ await waitFor(() => expect(actions.sendRequest).toHaveBeenCalledWith('get_employee', { workflow_id: 'w2' }));
+ expect(screen.queryByText('Gather information')).not.toBeInTheDocument();
+ });
+
+ it('shows a new live reply immediately instead of the previous completed job', () => {
+ useChatRunStore.getState().upsertRun({ ...emptyRun('new-reply', 'w1'), state: 'running', startedAt: now,
+ steps: [{ stepId: 'new-search', name: 'Searching for today’s news', state: 'running' }] });
+ show({ work_progress: { ...progress, state: 'done', message: 'The work is finished.' } });
+ expect(screen.getByText('Preparing your reply.')).toBeInTheDocument();
+ expect(screen.getByText('Searching for today’s news')).toBeInTheDocument();
+ expect(screen.queryByText('The work is finished.')).not.toBeInTheDocument();
+ });
+
+ it('offers refresh for an unavailable snapshot without leaking backend errors', () => {
+ show({ work_progress: { state: 'unavailable', message: 'Work progress could not be loaded. Try refreshing.' } });
+ expect(screen.getByRole('button', { name: 'Refresh progress' })).toBeInTheDocument();
+ expect(screen.queryByText(/This is taking longer/)).not.toBeInTheDocument();
+ });
+});
diff --git a/server/services/employees/summaries.py b/server/services/employees/summaries.py
index 4c96d574..aeb0945e 100644
--- a/server/services/employees/summaries.py
+++ b/server/services/employees/summaries.py
@@ -440,6 +440,12 @@ async def _load_one(database: Any, workflow_id: str, *, auth_service: Any) -> Op
if employee and employee.team_plan:
from services.employees.jobs import job_progress
summary["job_progress"] = await job_progress(database, workflow_id)
+ from services.employees.work_progress import work_progress
+ summary["work_progress"] = await work_progress(
+ database, workflow, control=control,
+ pending_approvals=summary["pending_approvals"], browser_request=summary["browser_request"],
+ job_status=summary.get("job_progress"),
+ )
summary["has_team"] = bool(employee and employee.team_plan)
from core.container import container
summary["can_give_team"] = bool(employee and not employee.team_plan and getattr(container.settings(), "employee_team_conversion_enabled", False)) if hasattr(container, "settings") else False
diff --git a/server/services/employees/work_progress.py b/server/services/employees/work_progress.py
new file mode 100644
index 00000000..68497ea1
--- /dev/null
+++ b/server/services/employees/work_progress.py
@@ -0,0 +1,257 @@
+"""Bounded, owner-facing work snapshots, without model or tool payloads.
+
+Read the existing ledgers and live phase cache only: polling must never
+dispatch work, reconcile Temporal, or fetch a task's execution trace.
+"""
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timedelta, timezone
+from typing import Any, Mapping
+
+from sqlalchemy import case
+from sqlmodel import select
+
+from core.logging import get_logger
+from models.chat import ChatRun, LIVE_STATES
+from models.database import AgentTeam, TeamMember, TeamTask
+from models.employees import EmployeeJob
+from services.employees.graph_index import index_graph
+
+logger = get_logger(__name__)
+MAX_STEPS = 20
+ACTIVE_TASKS = ("pending", "queued", "blocked", "running", "submitted")
+ACTIVE_JOBS = ("queued", "running", "working", "delivering", "delivery_queued")
+_STATES = {"pending": "queued", "blocked": "waiting", "submitted": "reviewing",
+ "accepted": "done", "completed": "done", "finished": "done", "success": "done",
+ "delivered": "done", "working": "running", "executing": "running",
+ "error": "failed", "stopped": "cancelled", "skipped": "cancelled",
+ "delivering": "reviewing", "delivery_queued": "queued", "retry_wait": "waiting"}
+
+
+def _state(value: str) -> str:
+ value = _STATES.get(value, value)
+ return value if value in {"queued", "running", "waiting", "reviewing", "done", "failed", "cancelled", "stopping"} else "running"
+
+
+def _moment(value: Any) -> datetime | None:
+ if isinstance(value, datetime):
+ return value.replace(tzinfo=timezone.utc) if value.tzinfo is None else value.astimezone(timezone.utc)
+ return None
+
+
+def _iso(value: Any) -> str | None:
+ moment = _moment(value)
+ return moment.isoformat() if moment else None
+
+
+def _label(value: Any, fallback: str) -> str:
+ # Labels are presentation fields, never descriptions, missions or results.
+ return " ".join(value.split())[:160] if isinstance(value, str) and value.strip() else fallback
+
+
+def _step(step_id: str, label: str, member: str, status: str, *, node_id: str | None = None,
+ started_at: Any = None, updated_at: Any = None, finished_at: Any = None) -> dict:
+ return {"id": step_id, "label": label, "member": member, "node_id": node_id,
+ "status": _state(status), "started_at": _iso(started_at), "updated_at": _iso(updated_at),
+ "finished_at": _iso(finished_at)}
+
+
+def _live_steps(workflow_id: str, graph: Mapping, now: datetime, control: Any = None) -> list[dict]:
+ from services.status_broadcaster import get_status_broadcaster
+ from services.node_registry import get_node_class, registered_node_classes
+
+ index = index_graph(graph)
+ tool_members: dict[str, set[str]] = {}
+ for edge in graph.get("edges", []):
+ if isinstance(edge, Mapping) and edge.get("target") in index.agent_ids:
+ tool_members.setdefault(edge.get("source"), set()).add(edge["target"])
+ broadcaster = get_status_broadcaster()
+ loop_time = asyncio.get_running_loop().time()
+ aliases: dict[str, list] = {}
+ for cls in registered_node_classes().values():
+ name = getattr(cls, "tool_name", None)
+ if isinstance(name, str) and name:
+ aliases.setdefault(name, []).append(cls)
+ steps = []
+ for node in graph.get("nodes", []):
+ if not isinstance(node, Mapping) or not node.get("id") or (node.get("data") or {}).get("disabled"):
+ continue
+ node_id = node["id"]
+ # Perpetual app/schedule listeners do not represent an accepted job.
+ if node_id in index.trigger_ids:
+ continue
+ cached = broadcaster.get_node_status(node_id)
+ if not isinstance(cached, Mapping) or cached.get("workflow_id") != workflow_id or cached.get("status") not in {"executing", "waiting"}:
+ continue
+ data = cached.get("data") or {}
+ if data.get("generation") is not None and getattr(control, "generation", None) is not None and data["generation"] != control.generation:
+ continue
+ phase = data.get("phase")
+ status = "waiting" if cached["status"] == "waiting" else "running"
+ if phase == "retry_wait":
+ status = "waiting"
+ member = _label(index.labels.get(node_id), "Employee") if node_id in index.agent_ids else "Employee"
+ if node_id not in index.agent_ids and len(tool_members.get(node_id, set())) == 1:
+ member = _label(index.labels.get(next(iter(tool_members[node_id]))), "Employee")
+ cls = get_node_class(index.node_types.get(node_id, ""))
+ label = _label(index.labels.get(node_id) or getattr(cls, "display_name", None), "Using a connected app")
+ if node_id in index.agent_ids:
+ label = {"invoking_llm": "Thinking through the next step", "initializing": "Getting ready",
+ "building_tools": "Getting ready", "loading_memory": "Loading saved context",
+ "compacting_context": "Organizing saved context", "retry_wait": "Waiting to try again",
+ "tool_completed": "Checking the result", "executing_tool": "Using a connected app"}.get(
+ phase, "Waiting before continuing" if status == "waiting" else "Working on the request")
+ # Resolve only known callable identities; never forward arbitrary
+ # model strings, status messages, arguments or capability payloads.
+ tool = data.get("tool_name") if phase == "executing_tool" else None
+ tool_cls = get_node_class(tool) if isinstance(tool, str) else None
+ if tool_cls is None and isinstance(tool, str) and len(aliases.get(tool, [])) == 1:
+ tool_cls = aliases[tool][0]
+ if tool_cls is not None:
+ label = "Using " + _label(getattr(tool_cls, "display_name", None), "a connected app")
+ elif node_id in index.gate_ids:
+ label = "Waiting for your approval"
+ status = "waiting"
+ stamp = cached.get("timestamp")
+ updated = now - timedelta(seconds=max(0, loop_time - stamp)) if isinstance(stamp, (int, float)) else None
+ steps.append(_step(f"node:{node_id}", label, member, status, node_id=node_id, started_at=updated, updated_at=updated))
+ if len(steps) > MAX_STEPS:
+ break
+ return steps
+
+
+async def work_progress(database: Any, workflow: Any, *, control: Any = None,
+ pending_approvals: int = 0, browser_request: dict | None = None,
+ job_status: Mapping | None = None) -> dict | None:
+ """Team jobs, legacy chat and scheduled node work through one safe view.
+
+ Select the active job before a newer completed job, and scope its tasks
+ to that exact team. Old teams must not appear in a newer job's review.
+ """
+ now = datetime.now(timezone.utc)
+ graph = getattr(workflow, "data", None) or {}
+ snapshot = getattr(control, "graph_snapshot", None)
+ if getattr(control, "status", None) in {"running", "starting", "pausing", "paused", "resuming"} and isinstance(snapshot, Mapping) and snapshot.get("nodes"):
+ graph = snapshot
+ index = index_graph(graph)
+ steps: list[dict] = []
+ starts: list[datetime] = []
+ updates: list[datetime] = []
+ state = None
+ truncated = False
+ job = None
+ chats = []
+ unavailable = False
+ try:
+ async with database.get_session() as session:
+ job = (await session.execute(select(EmployeeJob.team_id, EmployeeJob.state, EmployeeJob.updated_at).where(EmployeeJob.workflow_id == workflow.id)
+ .order_by(case((EmployeeJob.state.in_(ACTIVE_JOBS), 0), else_=1), EmployeeJob.updated_at.desc()).limit(1))).first()
+ team = None
+ if job and job.team_id:
+ team = (await session.execute(select(AgentTeam.id, AgentTeam.created_at).where(AgentTeam.id == job.team_id, AgentTeam.workflow_id == workflow.id))).first()
+ elif not job:
+ team = (await session.execute(select(AgentTeam.id, AgentTeam.created_at).where(AgentTeam.workflow_id == workflow.id, AgentTeam.status == "active")
+ .order_by(AgentTeam.created_at.desc()).limit(1))).first()
+ if job:
+ state = _state(job.state)
+ updates.append(_moment(job.updated_at))
+ if not team:
+ # Older job rows have no admission timestamp; while queued
+ # this is the persisted creation time, otherwise a lower-
+ # precision last transition time, never a fabricated date.
+ starts.append(_moment(job.updated_at))
+ if team:
+ starts.append(_moment(team.created_at))
+ members = (await session.execute(select(TeamMember.agent_node_id, TeamMember.agent_label)
+ .where(TeamMember.team_id == team.id).limit(100))).all()
+ member_labels = {member.agent_node_id: member.agent_label for member in members}
+ tasks = (await session.execute(select(TeamTask.id, TeamTask.title, TeamTask.assigned_to, TeamTask.status,
+ TeamTask.cancellation_requested, TeamTask.created_at, TeamTask.started_at, TeamTask.completed_at).where(TeamTask.team_id == team.id)
+ .where((TeamTask.workflow_id == workflow.id) | (TeamTask.workflow_id.is_(None)))
+ .order_by(case((TeamTask.status.in_(ACTIVE_TASKS), 0), else_=1), TeamTask.created_at)
+ .limit(MAX_STEPS + 1))).all()
+ truncated = len(tasks) > MAX_STEPS
+ for task in tasks[:MAX_STEPS]:
+ node_id = task.assigned_to
+ status = "stopping" if task.cancellation_requested and task.status in ACTIVE_TASKS else task.status
+ steps.append(_step(f"task:{task.id}", _label(task.title, "Assigned task"),
+ _label(index.labels.get(node_id) or member_labels.get(node_id), "Team member"), status, node_id=node_id,
+ started_at=task.started_at or task.created_at, updated_at=task.completed_at or task.started_at or task.created_at,
+ finished_at=task.completed_at))
+ updates.append(_moment(task.completed_at or task.started_at or task.created_at))
+ chats = (await session.execute(select(ChatRun.run_id, ChatRun.state, ChatRun.created_at, ChatRun.started_at, ChatRun.steps)
+ .where(ChatRun.workflow_id == workflow.id, ChatRun.state.in_(LIVE_STATES))
+ .order_by(ChatRun.created_at).limit(5))).all()
+ truncated = truncated or len(chats) > 4
+ from services.chat.hub import get_chat_hub
+ for run in chats[:4]:
+ state = _state(run.state) if state not in {"running", "waiting", "reviewing", "stopping"} else state
+ starts.append(_moment(run.started_at or run.created_at))
+ updates.append(_moment(run.started_at or run.created_at))
+ agent_id = index.talk.agent_node_id
+ member = _label(index.labels.get(agent_id), "Employee")
+ steps.append(_step(f"chat:{run.run_id}", "Answering your message" if run.state == "running" else "Waiting to answer your message",
+ member, run.state, node_id=agent_id, started_at=run.started_at or run.created_at, updated_at=run.started_at or run.created_at))
+ live = get_chat_hub().live_snapshot(run.run_id)
+ saved = live.get("steps", run.steps) if isinstance(live, Mapping) and live.get("workflow_id") == workflow.id else run.steps
+ truncated = truncated or len(saved) > MAX_STEPS
+ for tool in saved[-MAX_STEPS:]:
+ if not isinstance(tool, Mapping):
+ continue
+ steps.append(_step(f"chat:{run.run_id}:{tool.get('step_id')}", _label(tool.get("name"), "Using a connected app"), member,
+ tool.get("state", "running"), node_id=agent_id))
+ except Exception:
+ # Progress is a courtesy; unavailable ledgers must not break controls
+ # or make a saved employee look as though creation failed.
+ logger.warning("Could not read employee work progress", workflow_id=workflow.id, exc_info=True)
+ unavailable = True
+ try:
+ live_steps = [] if job and job.state in {"delivered", "failed", "cancelled"} and not chats else _live_steps(workflow.id, graph, now, control)
+ except Exception:
+ live_steps = []
+ steps = live_steps + steps
+ if live_steps:
+ state = "waiting" if all(step["status"] == "waiting" for step in live_steps) else "running"
+ if pending_approvals:
+ state = "waiting"
+ steps.insert(0, _step("approval", "Waiting for your approval", "Employee", "waiting"))
+ elif browser_request:
+ state = "waiting"
+ steps.insert(0, _step("browser", "Waiting for your help in the browser", "Employee", "waiting", node_id=browser_request.get("node_id")))
+ job_message = None
+ if job_status and job_status.get("state") in {"failed", "cancelled", "waiting_for_approval", "delivery_needs_review"}:
+ state = _state(job_status["state"]) if job_status["state"] in {"failed", "cancelled"} else "waiting"
+ job_message = job_status.get("message")
+ paused = getattr(control, "status", None) in {"paused", "pausing"} and (steps or state in {"queued", "running", "waiting", "reviewing", "stopping"})
+ if paused:
+ state = "waiting"
+ for step in steps:
+ if step["status"] in {"queued", "running", "reviewing", "stopping"}:
+ step["status"] = "waiting"
+ active = [step["status"] for step in steps if step["status"] not in {"done", "failed", "cancelled"}]
+ if not state and steps:
+ statuses = {step["status"] for step in steps}
+ state = next((candidate for candidate in ("stopping", "running", "waiting", "reviewing", "queued", "failed", "cancelled", "done") if candidate in statuses), None)
+ if state == "running" and active and all(status in {"waiting", "reviewing", "queued"} for status in active):
+ state = "reviewing" if "reviewing" in active else "waiting" if "waiting" in active else "queued"
+ elif state == "running" and active and all(status == "stopping" for status in active):
+ state = "stopping"
+ if not state and not steps and not unavailable:
+ return None
+ state = state or ("unavailable" if unavailable else "running")
+ messages = {"queued": "Your request is saved and waiting to start.", "running": "Working on your request.",
+ "waiting": "Waiting before continuing.", "reviewing": "Checking the work before sending the result.",
+ "done": "The work is finished.", "failed": "The work could not finish. Ask them to try again.",
+ "cancelled": "This work was stopped.", "stopping": "Stopping the current work.",
+ "unavailable": "Work progress could not be loaded. Try refreshing."}
+ updates.extend(datetime.fromisoformat(step["updated_at"]) for step in live_steps if step["updated_at"])
+ if not any(starts):
+ starts.extend(datetime.fromisoformat(step["started_at"]) for step in live_steps if step["started_at"])
+ return {"state": state, "message": "Work is paused. Resume when you are ready." if paused else job_message or
+ (messages["unavailable"] if unavailable and not steps else
+ "Waiting for your approval before sending." if pending_approvals else
+ "Waiting for your help in the browser." if browser_request else messages[state]),
+ "started_at": _iso(min(filter(None, starts), default=None)),
+ "updated_at": _iso(max(filter(None, updates), default=None)),
+ "steps": steps[:MAX_STEPS], "truncated": truncated or len(steps) > MAX_STEPS}
diff --git a/server/tests/services/employees/test_work_progress.py b/server/tests/services/employees/test_work_progress.py
new file mode 100644
index 00000000..707c9ec4
--- /dev/null
+++ b/server/tests/services/employees/test_work_progress.py
@@ -0,0 +1,263 @@
+"""Public work snapshots preserve task scope and never expose execution data."""
+from datetime import datetime, timedelta, timezone
+from types import SimpleNamespace
+import asyncio
+import json
+
+import pytest
+
+from models.chat import ChatRun
+from models.database import AgentTeam, TeamTask
+from models.employees import EmployeeJob
+from services.employees.work_progress import MAX_STEPS, work_progress
+from services.chat.hub import ChatRunHub, reset_chat_hub_for_tests
+
+NOW = datetime.now(timezone.utc)
+
+
+def workflow(workflow_id="employee", nodes=None):
+ return SimpleNamespace(id=workflow_id, data={"nodes": nodes or [
+ {"id": "lead", "type": "aiAgent", "data": {"label": "Maya"}},
+ {"id": "research", "type": "aiAgent", "data": {"label": "Research assistant"}},
+ ], "edges": []})
+
+
[email protected](autouse=True)
+def phase_cache(monkeypatch):
+ import services.status_broadcaster as statuses
+ cache = {}
+ monkeypatch.setattr(statuses, "get_status_broadcaster", lambda: SimpleNamespace(get_node_status=cache.get))
+ old = reset_chat_hub_for_tests(ChatRunHub(queue_size=10))
+ yield cache
+ reset_chat_hub_for_tests(old)
+
+
+async def add(database, *rows):
+ async with database.get_session() as session:
+ for row in rows:
+ session.add(row)
+ await session.commit()
+
+
+def job(job_id="job", team_id="team", **kwargs):
+ return EmployeeJob(id=job_id, workflow_id="employee", origin_execution_id=job_id, lead_node_id="lead", team_id=team_id,
+ state=kwargs.pop("state", "working"), **kwargs)
+
+
+def task(task_id="task", team_id="team", **kwargs):
+ return TeamTask(id=task_id, team_id=team_id, title="Research available options", created_by="lead", assigned_to="research",
+ workflow_id="employee", status=kwargs.pop("status", "running"), **kwargs)
+
+
+async def test_current_job_tasks_and_labels_are_scoped_and_redacted(real_database):
+ await add(real_database,
+ AgentTeam(id="team", workflow_id="employee", team_lead_node_id="lead", created_at=NOW - timedelta(minutes=5)),
+ AgentTeam(id="old", workflow_id="employee", team_lead_node_id="lead"),
+ job(mission="PRIVATE PROMPT", source={"secret": "RAW ARGS"}, result="HIDDEN REASONING"),
+ task(started_at=NOW - timedelta(minutes=3), mission="PRIVATE PROMPT", context={"tool_args": "RAW ARGS"}, error="PRIVATE FAILURE"),
+ task("old-task", "old"),
+ )
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == "running"
+ assert [step["id"] for step in result["steps"]] == ["task:task"]
+ assert result["steps"][0]["member"] == "Research assistant"
+ assert result["steps"][0]["node_id"] == "research"
+ assert datetime.fromisoformat(result["started_at"]) == NOW - timedelta(minutes=5)
+ assert datetime.fromisoformat(result["steps"][0]["started_at"]) == NOW - timedelta(minutes=3)
+ wire = json.dumps(result)
+ assert not any(secret in wire for secret in ["PRIVATE", "RAW ARGS", "HIDDEN REASONING", "old-task"])
+
+
+async def test_active_job_wins_over_newer_completed_job_and_new_job_never_reuses_old_team(real_database):
+ await add(real_database, AgentTeam(id="old", workflow_id="employee", team_lead_node_id="lead"),
+ job("working", None, updated_at=NOW - timedelta(minutes=10)),
+ job("done", "old", state="delivered", updated_at=NOW), task("old-task", "old"))
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == "running"
+ assert result["steps"] == []
+
+
+async def test_legacy_team_without_job_uses_existing_task_manager(real_database):
+ await add(real_database, AgentTeam(id="team", workflow_id="employee", team_lead_node_id="lead"),
+ task(status="blocked"))
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == "waiting"
+ assert result["steps"][0]["status"] == "waiting"
+
+
+async def test_task_results_bounded_active_first_and_submitted_is_reviewing(real_database):
+ await add(real_database, AgentTeam(id="team", workflow_id="employee", team_lead_node_id="lead"), job(),
+ *(task(f"done-{i}", status="accepted", created_at=NOW - timedelta(minutes=10)) for i in range(30)),
+ task("review", status="submitted", created_at=NOW))
+ result = await work_progress(real_database, workflow())
+ assert len(result["steps"]) == MAX_STEPS
+ assert result["truncated"]
+ assert result["state"] == "reviewing"
+ assert result["steps"][0]["id"] == "task:review"
+ assert result["steps"][0]["status"] == "reviewing"
+
+
+async def test_foreign_team_cannot_supply_tasks_even_when_job_has_wrong_team(real_database):
+ await add(real_database, AgentTeam(id="foreign", workflow_id="other", team_lead_node_id="lead"),
+ job(team_id="foreign"), task("foreign-task", "foreign"))
+ assert (await work_progress(real_database, workflow()))["steps"] == []
+
+
+async def test_scheduled_legacy_work_reads_safe_live_phase_and_monotonic_time(real_database, phase_cache):
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "timestamp": asyncio.get_running_loop().time() - 75,
+ "data": {"phase": "invoking_llm", "message": "PRIVATE THOUGHT", "prompt": "PRIVATE PROMPT", "tool_args": "RAW ARGS"}}
+ phase_cache["research"] = {"workflow_id": "other", "status": "executing", "data": {"phase": "executing_tool"}}
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == "running"
+ assert len(result["steps"]) == 1
+ assert result["steps"][0]["label"] == "Thinking through the next step"
+ age = (datetime.now(timezone.utc) - datetime.fromisoformat(result["updated_at"])).total_seconds()
+ assert 74 <= age <= 80
+ assert "PRIVATE" not in json.dumps(result) and "RAW ARGS" not in json.dumps(result)
+
+
+async def test_running_generation_nodes_survive_pending_graph_changes(real_database, phase_cache):
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "timestamp": asyncio.get_running_loop().time(), "data": {}}
+ control = SimpleNamespace(status="running", graph_snapshot=workflow().data)
+ changed = workflow(nodes=[{"id": "new", "type": "aiAgent", "data": {"label": "Replacement"}}])
+ result = await work_progress(real_database, changed, control=control)
+ assert result["steps"][0]["node_id"] == "lead"
+ assert result["steps"][0]["member"] == "Maya"
+
+
+async def test_live_chat_tool_steps_survive_reload_without_exposing_details(real_database):
+ await add(real_database, ChatRun(run_id="run", session_id="session", workflow_id="employee", state="running",
+ started_at=NOW - timedelta(minutes=2), steps=[{"step_id": "search", "name": "Searched the web", "state": "done",
+ "detail": "PRIVATE OUTPUT", "narration": "PRIVATE THOUGHT", "duration_ms": 20}], options={"prompt": "PRIVATE PROMPT"}))
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == "running"
+ assert [step["label"] for step in result["steps"]] == ["Answering your message", "Searched the web"]
+ assert result["steps"][1]["status"] == "done"
+ assert "PRIVATE" not in json.dumps(result)
+
+
+async def test_approval_and_browser_blockers_are_plain_and_idle_has_no_progress(real_database):
+ assert await work_progress(real_database, workflow()) is None
+ approval = await work_progress(real_database, workflow(), pending_approvals=1)
+ assert approval["state"] == "waiting"
+ assert approval["steps"][0]["label"] == "Waiting for your approval"
+ browser = await work_progress(real_database, workflow(), browser_request={"node_id": "browser", "reason": "RAW URL"})
+ assert browser["steps"][0]["node_id"] == "browser"
+ assert "RAW URL" not in json.dumps(browser)
+
+
+async def test_queued_job_has_persisted_elapsed_timestamp_without_team(real_database):
+ await add(real_database, job(team_id=None, state="queued", updated_at=NOW - timedelta(minutes=2)))
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == "queued"
+ assert datetime.fromisoformat(result["started_at"]) == NOW - timedelta(minutes=2)
+
+
+async def test_paused_work_does_not_look_like_a_slow_active_employee(real_database, phase_cache):
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "data": {"phase": "invoking_llm"}}
+ result = await work_progress(real_database, workflow(), control=SimpleNamespace(status="paused"))
+ assert result["state"] == "waiting"
+ assert result["message"] == "Work is paused. Resume when you are ready."
+ assert result["steps"][0]["status"] == "waiting"
+
+
+async def test_listening_triggers_do_not_count_as_current_work(real_database, phase_cache):
+ nodes = [{"id": "clock", "type": "cronScheduler", "data": {"label": "Schedule"}}]
+ phase_cache["clock"] = {"workflow_id": "employee", "status": "waiting", "data": {}}
+ assert await work_progress(real_database, workflow(nodes=nodes)) is None
+ phase_cache["clock"]["status"] = "executing"
+ assert await work_progress(real_database, workflow(nodes=nodes)) is None
+
+
[email protected]("job_state", ["failed", "cancelled", "delivered"])
+async def test_terminal_job_is_not_overwritten_by_stale_live_cache(real_database, phase_cache, job_state):
+ await add(real_database, job(state=job_state, team_id=None))
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "data": {"phase": "invoking_llm"}}
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == {"delivered": "done"}.get(job_state, job_state)
+ assert result["steps"] == []
+
+
+async def test_uncertain_delivery_remains_waiting_despite_cached_activity(real_database, phase_cache):
+ await add(real_database, job(state="delivering", team_id=None))
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "data": {}}
+ result = await work_progress(real_database, workflow(), job_status={"state": "delivery_needs_review", "message": "Check whether the result arrived."})
+ assert result["state"] == "waiting"
+ assert result["message"] == "Check whether the result arrived."
+
+
+async def test_callable_alias_resolves_only_unique_registered_tool(real_database, phase_cache, monkeypatch):
+ import services.node_registry as registry
+ tool = SimpleNamespace(tool_name="search_connected_app", display_name="Calendar")
+ monkeypatch.setattr(registry, "registered_node_classes", lambda: {"calendar": tool})
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "data": {"phase": "executing_tool", "tool_name": "search_connected_app"}}
+ result = await work_progress(real_database, workflow())
+ assert result["steps"][0]["label"] == "Using Calendar"
+ monkeypatch.setattr(registry, "registered_node_classes", lambda: {"calendar": tool, "other": tool})
+ result = await work_progress(real_database, workflow())
+ assert result["steps"][0]["label"] == "Using a connected app"
+
+
+async def test_ledger_failure_reports_unavailable_without_breaking_controls():
+ def unavailable():
+ raise RuntimeError("PRIVATE DATABASE ERROR")
+ result = await work_progress(SimpleNamespace(get_session=unavailable), workflow())
+ assert result["state"] == "unavailable"
+ assert "could not be loaded" in result["message"]
+ assert "PRIVATE" not in json.dumps(result)
+
+
+async def test_employee_detail_preserves_job_progress_and_adds_work_progress(real_database, monkeypatch):
+ from unittest.mock import AsyncMock
+ from models.employees import Employee
+ from services.employees import summaries
+ from services.employees.jobs import job_progress
+
+ wf = workflow()
+ await real_database.save_workflow(workflow_id=wf.id, name="Maya", slug="progress-maya", data=wf.data)
+ await add(real_database, Employee(id="employee-row", workflow_id=wf.id, owner_id="owner", team_plan={"version": 1}), job(team_id=None, state="queued"))
+ monkeypatch.setattr(summaries, "_summary", AsyncMock(return_value={"workflow_id": wf.id, "pending_approvals": 0, "browser_request": None}))
+ monkeypatch.setattr(summaries, "Connections", lambda _: SimpleNamespace(has_ai=AsyncMock(return_value=True)))
+ result = await summaries.get_employee_summary(real_database, wf.id, auth_service=None)
+ assert result["job_progress"] == await job_progress(real_database, wf.id)
+ assert result["work_progress"]["state"] == "queued"
+
+
+async def test_live_chat_in_progress_tool_is_visible_before_it_finishes(real_database):
+ from services.chat.hub import get_chat_hub
+ await add(real_database, ChatRun(run_id="run", session_id="session", workflow_id="employee", state="running", started_at=NOW))
+ get_chat_hub().publish(run_id="run", session_id="session", workflow_id="employee", suffix="step.started",
+ fields={"step_id": "search", "step_name": "Checking your calendar"})
+ result = await work_progress(real_database, workflow())
+ assert result["steps"][-1]["label"] == "Checking your calendar"
+ assert result["steps"][-1]["status"] == "running"
+
+
+async def test_native_member_label_and_requested_cancellation_are_preserved(real_database):
+ from models.database import TeamMember
+ await add(real_database, AgentTeam(id="team", workflow_id="employee", team_lead_node_id="lead"),
+ TeamMember(team_id="team", agent_node_id="research", agent_type="aiAgent", agent_label="Research assistant"),
+ task(cancellation_requested=True))
+ result = await work_progress(real_database, workflow(nodes=[{"id": "lead", "type": "aiAgent", "data": {"label": "Maya"}}]))
+ assert result["state"] == "stopping"
+ assert result["steps"][0]["status"] == "stopping"
+ assert result["steps"][0]["member"] == "Research assistant"
+
+
+async def test_old_generation_cache_is_not_current_activity(real_database, phase_cache):
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "data": {"generation": 1}}
+ assert await work_progress(real_database, workflow(), control=SimpleNamespace(status="running", generation=2)) is None
+
+
[email protected](("phase", "label", "status"), [
+ ("retry_wait", "Waiting to try again", "waiting"),
+ ("building_tools", "Getting ready", "running"),
+ ("loading_memory", "Loading saved context", "running"),
+ ("compacting_context", "Organizing saved context", "running"),
+])
+async def test_known_slow_phases_explain_work_without_runtime_internals(real_database, phase_cache, phase, label, status):
+ phase_cache["lead"] = {"workflow_id": "employee", "status": "executing", "data": {"phase": phase, "error": "PRIVATE ERROR"}}
+ result = await work_progress(real_database, workflow())
+ assert result["state"] == status
+ assert result["steps"][0]["label"] == label
+ assert "PRIVATE" not in json.dumps(result)