Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

fix(agent-reviews): keep review cards live without locking during saves (#9571)

Wolf Mermelsteine8b711ee9655
diff --git a/apps/web/src/features/agent-reviews/primitives/review-controller.test.ts b/apps/web/src/features/agent-reviews/primitives/review-controller.test.ts
index 4320eafe9f..27ec1ed761 100644
--- a/apps/web/src/features/agent-reviews/primitives/review-controller.test.ts
+++ b/apps/web/src/features/agent-reviews/primitives/review-controller.test.ts
@@ -108,6 +108,67 @@ describe('persisted review decisions', () => {
await Promise.resolve();
expect(controller.stale()).toBe(true);
});
+ it('a poll returning its own in-flight save does not mark the review stale', async () => {
+ const [source, update] = createSignal<EmailReview>({
+ ...initial,
+ revision: 1,
+ presentedAt: 100,
+ });
+ let commit!: (record: Review) => void;
+ let started!: () => void;
+ const saving = new Promise<void>((resolve) => {
+ started = resolve;
+ });
+ const actions = {
+ reload: async (): Promise<Review> => source(),
+ decide: vi.fn(
+ () =>
+ new Promise<Review>((resolve) => {
+ commit = resolve;
+ started();
+ })
+ ),
+ };
+ const controller = createRoot((dispose) => {
+ cleanups.push(dispose);
+ return createReviewController(source, actions);
+ });
+ const edited: EmailReview = {
+ ...source(),
+ revision: 2,
+ items: [
+ {
+ ...initial.items[0],
+ draft: {
+ subject: 'Ready?',
+ body: 'Yes',
+ to: [{ email: '[email protected]' }],
+ },
+ },
+ initial.items[1],
+ ],
+ };
+ controller.edit('one', { kind: 'email', draft: edited.items[0].draft });
+ const flushed = controller.flush();
+ await saving;
+
+ update(edited);
+ expect(controller.stale()).toBe(false);
+
+ commit(edited);
+ expect(await flushed).toBe(true);
+ expect(controller.stale()).toBe(false);
+ expect(controller.record().revision).toBe(2);
+
+ update({
+ ...edited,
+ revision: 3,
+ items: edited.items.map((item) => ({ ...item, status: 'dismissed' })),
+ });
+ await Promise.resolve();
+ expect(controller.stale()).toBe(false);
+ expect(controller.record().items[0].status).toBe('dismissed');
+ });
it('saves the latest edits before sending all, using the acknowledged revision', async () => {
const { controller, actions } = setup();
controller.edit('one', {
diff --git a/apps/web/src/features/agent-reviews/primitives/review-controller.ts b/apps/web/src/features/agent-reviews/primitives/review-controller.ts
index 3e854484bf..f7e6c348b4 100644
--- a/apps/web/src/features/agent-reviews/primitives/review-controller.ts
+++ b/apps/web/src/features/agent-reviews/primitives/review-controller.ts
@@ -21,9 +21,11 @@ export function createReviewController(
const [validation, setValidation] = createSignal<string>();
const drafts = new Map<string, ReviewDraft>();
let tail: Promise<void> = Promise.resolve();
- const record = () =>
- source().revision > saved().revision ? source() : saved();
- const stale = () => source().revision > saved().revision;
+ // A poll can return the revision our in-flight save or decision already
+ // committed; only a newer revision once our writes settle is someone else's.
+ const stale = () =>
+ !saving() && !busy() && source().revision > saved().revision;
+ const record = () => (stale() ? source() : saved());
// Acknowledgments and action status can advance without changing editor data.
// Adopt those revisions only when no local edits or writes can be displaced.
createEffect(() => {
diff --git a/apps/web/src/features/agent-reviews/views/persisted-review.test.tsx b/apps/web/src/features/agent-reviews/views/persisted-review.test.tsx
index 44ed6c93fc..cb17b97873 100644
--- a/apps/web/src/features/agent-reviews/views/persisted-review.test.tsx
+++ b/apps/web/src/features/agent-reviews/views/persisted-review.test.tsx
@@ -1,21 +1,24 @@
/** @vitest-environment jsdom */
import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';
+import { createSignal } from 'solid-js';
import { afterEach, describe, expect, it, type Mock, vi } from 'vitest';
import type { Review, ReviewActions } from '../core/review';
import { PersistedReview } from './persisted-review';
const reviews = vi.hoisted(() => {
const state: {
- record: Review | undefined;
+ record: () => Review | undefined;
decide: Mock<ReviewActions['decide']>;
- } = { record: undefined, decide: vi.fn() };
+ } = { record: () => undefined, decide: vi.fn() };
return state;
});
vi.mock('../queries/reviews', () => ({
useReview: () => ({
isError: false,
isSuccess: true,
- data: reviews.record,
+ get data() {
+ return reviews.record();
+ },
refetch: vi.fn(),
}),
useReviewActions: () => ({ reload: vi.fn(), decide: reviews.decide }),
@@ -26,6 +29,9 @@ vi.mock('@core/context/user', () => ({
function Card(props: { review: Review; actions: ReviewActions }) {
return (
<>
+ <output>
+ {props.review.revision}:{props.review.items[0].status}
+ </output>
<button
type="button"
onClick={() =>
@@ -112,7 +118,7 @@ afterEach(() => {
describe('PersistedReview', () => {
it('expects no answer until an approved import settles', () => {
- reviews.record = importReview;
+ reviews.record = () => importReview;
reviews.decide.mockResolvedValue(importReview);
const onDecision = vi.fn();
render(() => (
@@ -133,7 +139,7 @@ describe('PersistedReview', () => {
});
it('expects the agent to answer an approved email stack at once', () => {
- reviews.record = emailReview;
+ reviews.record = () => emailReview;
reviews.decide.mockResolvedValue(emailReview);
const onDecision = vi.fn();
render(() => (
@@ -148,4 +154,23 @@ describe('PersistedReview', () => {
fireEvent.click(screen.getByRole('button', { name: 'Approve' }));
expect(onDecision).toHaveBeenCalledTimes(1);
});
+
+ it('passes each polled revision to the open card', () => {
+ const [record, setRecord] = createSignal<Review>(emailReview);
+ reviews.record = record;
+ render(() => (
+ <PersistedReview sessionId="session" reviewId="review" canAct />
+ ));
+ expect(screen.getByRole('status').textContent).toBe('1:pending');
+
+ setRecord({
+ ...emailReview,
+ revision: 2,
+ items: emailReview.items.map((item) => ({
+ ...item,
+ status: 'dismissed',
+ })),
+ });
+ expect(screen.getByRole('status').textContent).toBe('2:dismissed');
+ });
});
diff --git a/apps/web/src/features/agent-reviews/views/persisted-review.tsx b/apps/web/src/features/agent-reviews/views/persisted-review.tsx
index 875a59dc2c..47d1a424c2 100644
--- a/apps/web/src/features/agent-reviews/views/persisted-review.tsx
+++ b/apps/web/src/features/agent-reviews/views/persisted-review.tsx
@@ -63,20 +63,24 @@ export function PersistedReview(props: {
<Show when={query.isSuccess ? query.data : undefined}>
{(record) => {
const canAct = () => props.canAct && userId() === record().actingUser;
- // A review's kind is fixed when it is saved.
- return match(record())
- .with({ kind: 'import' }, (review) => (
- <ImportReview
- review={review}
- canAct={canAct()}
- actions={decisions('import')}
- />
+ // A review's kind is fixed when it is saved; polls keep its status live.
+ return match(record().kind)
+ .with('import', () => (
+ <Show when={importReview(record())}>
+ {(review) => (
+ <ImportReview
+ review={review()}
+ canAct={canAct()}
+ actions={decisions('import')}
+ />
+ )}
+ </Show>
))
- .with({ kind: 'email' }, { kind: 'calendar' }, (review) => (
+ .with('email', 'calendar', (kind) => (
<ReviewStack
- review={review}
+ review={record()}
canAct={canAct()}
- actions={decisions(review.kind)}
+ actions={decisions(kind)}
/>
))
.exhaustive();
@@ -85,3 +89,6 @@ export function PersistedReview(props: {
</Suspense>
);
}
+function importReview(review: Review) {
+ return review.kind === 'import' ? review : undefined;
+}
diff --git a/apps/web/src/features/email-compose/browser-test/agent-review-fixture.tsx b/apps/web/src/features/email-compose/browser-test/agent-review-fixture.tsx
new file mode 100644
index 0000000000..3c6da16bc3
--- /dev/null
+++ b/apps/web/src/features/email-compose/browser-test/agent-review-fixture.tsx
@@ -0,0 +1,67 @@
+import '@app/index.css';
+import { PersistedReview } from '@app/features/agent-reviews/views/persisted-review';
+import { AnalyticsContextProvider } from '@app/lib/analytics/analytics-context';
+import { PosthogProvider } from '@app/lib/analytics/posthog';
+import { ChannelsContextProvider } from '@core/context/channels';
+import { EmailLinksContextProvider } from '@core/context/emailLinks';
+import { QuickAccessProvider } from '@core/context/quickAccess/QuickAccessProvider';
+import { UserContextProvider } from '@core/context/user';
+import {
+ attachGlobalDOMScope,
+ registerHotkey,
+ useHotKeyRoot,
+} from '@core/hotkey/hotkeys';
+import { EntityProvider } from '@entity';
+import { queryClient } from '@queries/client';
+import { QueryClientProvider } from '@tanstack/solid-query';
+import { createSignal } from 'solid-js';
+import { render } from 'solid-js/web';
+
+/**
+ * A saved agent email review, polled from the routed review API, beside the
+ * app's global Create hotkey. Typing that escapes the draft presses `c`.
+ */
+function Fixture() {
+ useHotKeyRoot();
+ attachGlobalDOMScope(document.body);
+ const [created, setCreated] = createSignal(0);
+ registerHotkey({
+ hotkey: 'c',
+ scopeId: 'global',
+ description: 'Create',
+ keyDownHandler: () => {
+ setCreated((count) => count + 1);
+ return true;
+ },
+ });
+ return (
+ <QueryClientProvider client={queryClient}>
+ <AnalyticsContextProvider>
+ <PosthogProvider>
+ <EntityProvider>
+ <UserContextProvider>
+ <EmailLinksContextProvider>
+ <ChannelsContextProvider>
+ <QuickAccessProvider>
+ <main class="min-h-screen bg-surface p-4 text-ink">
+ <PersistedReview
+ sessionId="019a0000-0000-7000-8000-000000000001"
+ reviewId="019a0000-0000-7000-8000-000000000005"
+ canAct
+ />
+ <output data-testid="created">{created()}</output>
+ </main>
+ </QuickAccessProvider>
+ </ChannelsContextProvider>
+ </EmailLinksContextProvider>
+ </UserContextProvider>
+ </EntityProvider>
+ </PosthogProvider>
+ </AnalyticsContextProvider>
+ </QueryClientProvider>
+ );
+}
+
+const root = document.getElementById('root');
+if (!root) throw new Error('Fixture root missing');
+render(() => <Fixture />, root);
diff --git a/apps/web/src/features/email-compose/browser-test/agent-review.app.e2e.ts b/apps/web/src/features/email-compose/browser-test/agent-review.app.e2e.ts
new file mode 100644
index 0000000000..b7fd0b93c6
--- /dev/null
+++ b/apps/web/src/features/email-compose/browser-test/agent-review.app.e2e.ts
@@ -0,0 +1,215 @@
+import { expect, type Page, test } from '@playwright/test';
+
+type Item = {
+ id: string;
+ status: string;
+ error: null;
+ result: null;
+ draft: { subject: string; body: string; to: { email: string }[] };
+};
+type SavedReview = {
+ id: string;
+ sessionId: string;
+ actingUser: string;
+ executionId: string;
+ title: string;
+ revision: number;
+ updatedAt: number;
+ presentedAt: number | null;
+ decision: null;
+ kind: 'email';
+ items: Item[];
+};
+
+const initial: SavedReview = {
+ id: '019a0000-0000-7000-8000-000000000005',
+ sessionId: '019a0000-0000-7000-8000-000000000001',
+ actingUser: 'macro|[email protected]',
+ executionId: 'execution',
+ title: 'Drafts to review',
+ revision: 1,
+ updatedAt: 1,
+ presentedAt: 1,
+ decision: null,
+ kind: 'email',
+ items: [
+ {
+ id: 'first',
+ status: 'pending',
+ error: null,
+ result: null,
+ draft: {
+ subject: 'First email',
+ body: 'Hello',
+ to: [{ email: '[email protected]' }],
+ },
+ },
+ ],
+};
+
+/**
+ * Serves the review the card polls every two seconds. `onSave` decides when
+ * an edit's response is released; the edit is committed when it arrives.
+ */
+async function serveReview(
+ page: Page,
+ record: SavedReview,
+ onSave: (committed: SavedReview) => Promise<void> = async () => {}
+) {
+ const server = { record };
+ // The fixture's providers would otherwise reach the hosted dev backend.
+ await page.routeWebSocket('**', (socket) => socket.close());
+ await page.route('**/__macro_dev/**', (route) => route.abort());
+ await page.route('https://**', (route) => route.abort());
+ await page.addInitScript(() => localStorage.setItem('macro:login', 'true'));
+ await page.route('**/auth/user/legacy_user_permissions', (route) =>
+ route.fulfill({
+ json: {
+ userId: 'macro|[email protected]',
+ email: '[email protected]',
+ aiDataConsent: true,
+ hasChromeExt: false,
+ hasTrialed: false,
+ isAgent: false,
+ licenseStatus: 'active',
+ permissions: [],
+ referralCode: 'owner',
+ tutorialComplete: true,
+ },
+ })
+ );
+ await page.route('**/agent-sessions/*/reviews/*', async (route) => {
+ const request = route.request();
+ if (request.method() === 'GET') {
+ return route.fulfill({ json: server.record });
+ }
+ const decision = request.postDataJSON();
+ server.record = {
+ ...server.record,
+ revision: server.record.revision + 1,
+ items: server.record.items.map((item) =>
+ decision.action === 'edit' && item.id === decision.item
+ ? { ...item, draft: decision.draft.draft }
+ : item
+ ),
+ };
+ const committed = server.record;
+ await onSave(committed);
+ return route.fulfill({ json: committed });
+ });
+ return server;
+}
+
+test('a poll during an edit save keeps typing in the draft', async ({
+ page,
+}) => {
+ let release!: () => void;
+ const released = new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ let saving!: () => void;
+ const savingStarted = new Promise<void>((resolve) => {
+ saving = resolve;
+ });
+ await serveReview(page, initial, async () => {
+ saving();
+ await released;
+ });
+ await page.goto('/src/features/email-compose/browser-test/agent-review.html');
+ const body = page.locator('[contenteditable="true"]');
+ await body.click();
+ await page.keyboard.press('End');
+ await page.keyboard.type(' cool');
+ await savingStarted;
+
+ // The poll returns the revision the held save has already committed.
+ await page.waitForResponse(
+ async (response) =>
+ response.request().method() === 'GET' &&
+ response.url().includes('/reviews/') &&
+ (await response.json()).revision === 2
+ );
+ await page.keyboard.type(' cats', { delay: 50 });
+ await expect(body).toBeFocused();
+ release();
+
+ await expect(body).toHaveText('Hello cool cats');
+ await expect(body).toBeFocused();
+ await expect(page.getByTestId('created')).toHaveText('0');
+ await expect(
+ page.getByRole('button', { name: 'Reload saved review' })
+ ).toHaveCount(0);
+});
+
+test('a status saved elsewhere replaces the open draft card', async ({
+ page,
+}) => {
+ const server = await serveReview(page, initial);
+ // The composer saves its normalized draft once it mounts.
+ const mounted = page.waitForResponse(
+ (response) =>
+ response.request().method() === 'POST' &&
+ response.url().includes('/reviews/')
+ );
+ await page.goto('/src/features/email-compose/browser-test/agent-review.html');
+ await mounted;
+
+ server.record = {
+ ...server.record,
+ revision: server.record.revision + 1,
+ items: server.record.items.map((item) => ({
+ ...item,
+ status: 'dismissed',
+ })),
+ };
+
+ await expect(page.getByRole('status').getByText('Dismissed')).toBeVisible();
+ await expect(page.locator('[contenteditable="true"]')).toHaveCount(0);
+});
+
+test('a draft edited elsewhere offers to reload the saved review', async ({
+ page,
+}) => {
+ const server = await serveReview(page, initial);
+ // The composer saves its normalized draft once it mounts.
+ const mounted = page.waitForResponse(
+ (response) =>
+ response.request().method() === 'POST' &&
+ response.url().includes('/reviews/')
+ );
+ await page.goto('/src/features/email-compose/browser-test/agent-review.html');
+ await mounted;
+
+ server.record = {
+ ...server.record,
+ revision: server.record.revision + 1,
+ items: server.record.items.map((item) => ({
+ ...item,
+ draft: { ...item.draft, body: 'Changed by a teammate' },
+ })),
+ };
+ await expect(
+ page.getByRole('button', { name: 'Reload saved review' })
+ ).toBeVisible();
+});
+
+test('a review loaded before presentation becomes editable once presented', async ({
+ page,
+}) => {
+ const server = await serveReview(page, {
+ ...initial,
+ revision: 0,
+ presentedAt: null,
+ });
+ await page.goto('/src/features/email-compose/browser-test/agent-review.html');
+ await expect(page.getByText('Preparing saved review…')).toBeVisible();
+
+ server.record = { ...initial, revision: 1, presentedAt: 2 };
+ await expect(page.getByText('Preparing saved review…')).toHaveCount(0);
+ const body = page.locator('[contenteditable="true"]');
+ await body.click();
+ await page.keyboard.press('End');
+ await page.keyboard.type(' again');
+ await expect(body).toHaveText('Hello again');
+ await expect(page.getByTestId('created')).toHaveText('0');
+});
diff --git a/apps/web/src/features/email-compose/browser-test/agent-review.html b/apps/web/src/features/email-compose/browser-test/agent-review.html
new file mode 100644
index 0000000000..c5888e4570
--- /dev/null
+++ b/apps/web/src/features/email-compose/browser-test/agent-review.html
@@ -0,0 +1 @@
+<!doctype html><html><head><meta charset="UTF-8" /><title>Agent email review fixture</title></head><body><div id="root"></div><script type="module" src="./agent-review-fixture.tsx"></script></body></html>
diff --git a/docs/agent-guide/ai-chat.md b/docs/agent-guide/ai-chat.md
index 983d5bc956..e728fec777 100644
--- a/docs/agent-guide/ai-chat.md
+++ b/docs/agent-guide/ai-chat.md
@@ -2401,6 +2401,9 @@ draft before starting any sends/creates, and waits for attachments still
uploading in the active email.
Invalid drafts remain editable; navigation opens the first draft needing attention.
+The card polls its saved review while it is preparing or has pending drafts, so
+statuses set by the agent or another editor appear in place. A poll that returns
+the card's own in-flight save is not a conflict and leaves the editor focused.
A revision conflict or uncertain request shows **Reload saved review**. Reload
reads the saved version and discards the local edit; it never retries an external
send automatically. If the outcome is unknown, check the inbox/calendar before
@@ -2424,6 +2427,9 @@ navigation and page reload,
that a single draft has no stack controls, that a batch's picker finds drafts,
that chat remains usable, and that another account cannot submit. Sending an email or
creating an event is a real action, including from a local app connected to dev.
+The backend-free browser regression for polling, presentation, and typing during
+a save is `bunx playwright test --config src/features/email-compose/browser-test/playwright.app.config.ts agent-review`
+(from `apps/web`).
## Agent reasoning effort
Open the model selector and hover a model to choose its reasoning effort in the