Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
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.tsxindex 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.tsindex 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.tsindex 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.tsxindex 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.tsxnew file mode 100644index 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.tsxindex 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.tsxnew file mode 100644index 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.pyindex 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) -> Opif employee and employee.team_plan:from services.employees.jobs import job_progresssummary["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 containersummary["can_give_team"] = bool(employee and not employee.team_plan and getattr(container.settings(), "employee_team_conversion_enabled", False)) if hasattr(container, "settings") else Falsediff --git a/server/services/employees/work_progress.py b/server/services/employees/work_progress.pynew file mode 100644index 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.pynew file mode 100644index 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)