Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
fix(tasks): preserve pending creation drafts across restarts (#8503)
Peter Chinman189c7338f3dc
diff --git a/apps/web/AGENTS.md b/apps/web/AGENTS.mdindex 9c2ead38c3..e600a74aad 100644--- a/apps/web/AGENTS.md+++ b/apps/web/AGENTS.md@@ -303,6 +303,10 @@ the user's newest account for that app from the last fifteen minutes.move between inboxes).- Keep email card resize motion on its content wrapper so message and inlinereply transitions preserve the card's focus target and return to natural height.+- Task composer submissions retain an account/context-scoped local copy until+ the create response confirms success; never clear newer composer input from a+ late callback or automatically retry an uncertain create. Keep recovery copies+ through restarts and remove them on explicit logout. See the Tasks walkthrough.- Shared server-state queries and mutations live in `src/lib/queries`; keepfeature-specific query orchestration with its owning feature.- Refresh the channel list's bounded unread edge when opening a conversation,diff --git a/apps/web/src/features/block-md/component/ComposeTask.tsx b/apps/web/src/features/block-md/component/ComposeTask.tsxindex bc5634434b..6f46ff3db5 100644--- a/apps/web/src/features/block-md/component/ComposeTask.tsx+++ b/apps/web/src/features/block-md/component/ComposeTask.tsx@@ -8,10 +8,10 @@ export {TaskTitleAccessory,} from '../../task-composer/components/title-editor';-import { makePersistedState } from '@app/lib/persistence';import { useSplitLayout } from '@components/app/split-layout/layout';import { useSplitPanelOrThrow } from '@components/app/split-layout/layoutUtils';import { useMacroMentionLinkResolver } from '@components/app/split-layout/split-router/mention-links';+import { COMPOSER_STORAGE_CLEARED } from '@core/auth/clear-composer-storage';import { buildConfig } from '@core/component/LexicalMarkdown/builder/MarkdownConfigBuilder';import { MarkdownShell } from '@core/component/LexicalMarkdown/builder/MarkdownShell';import { addMediaFromFile } from '@core/component/LexicalMarkdown/plugins/media';@@ -37,6 +37,7 @@ import { queryReadyGate } from '@queries/gate';import { useUpsertToHistoryMutation } from '@queries/history/history';import { useUserTeamsQuery } from '@queries/team/teams';import { debounce } from '@solid-primitives/scheduled';+import { useQueryClient } from '@tanstack/solid-query';import { Button, EntityComposer, Scroll, ToggleSwitch, Tooltip } from '@ui';import type { LexicalEditor } from 'lexical';import {@@ -60,12 +61,21 @@ import {} from '../util/taskComposerProperties';import {clearTaskComposerDraft,+ createTaskComposerSharing,loadTaskComposerDraft,saveTaskComposerDraft,taskComposerContextStorage,} from '../util/taskComposerStorage';+import {+ clearTaskSubmission,+ createTaskSubmissionList,+ submitTaskDraft,+ taskSubmissionDraftStorage,+ taskSubmissionKey,+} from '../util/taskComposerSubmissions';import { EditorSystemMessage } from './EditorSystemMessage';import { InlinePropertyValue } from './InlinePropertyValue';+import { RecoverTaskDrafts } from './RecoverTaskDrafts';import { TaskComposerPropertyEditor } from './TaskComposerPropertyEditor';import { SimilarTasksSection } from './TaskDuplicateList';@@ -88,6 +98,8 @@ export interface ComposeTaskProps {createTask?: typeof createTaskWithProperties;onCreateTask?: (title: string, content: string) => void;onClose?: () => void;+ /** Identity of a locally retained, unconfirmed submission. */+ recoveredDraftId?: string;initialTitle?: string;initialContent?: string;placeholder?: string;@@ -119,9 +131,21 @@ export function ComposeTask(props: ComposeTaskProps) {const splitPanel = useSplitPanelOrThrow();const { popoverSplit, openWithSplit } = useSplitLayout();const currentUserId = useUserId();- const draftStorage = props.composerContext- ? taskComposerContextStorage(props.composerContext.key)- : undefined;+ const queryClient = useQueryClient();+ const draftOwner = currentUserId() ?? '';+ const submissions = createTaskSubmissionList(+ queryClient,+ draftOwner,+ props.composerContext?.key+ );+ const recovered = submissions().find(+ (draft) => draft.id === props.recoveredDraftId+ );+ const draftStorage = recovered+ ? taskSubmissionDraftStorage(draftOwner, recovered.id)+ : props.composerContext+ ? taskComposerContextStorage(props.composerContext.key)+ : undefined;const getDefaultPropertyValues = (): Record<string, PropertyApiValues> => {const ids = (() => {@@ -158,6 +182,10 @@ export function ComposeTask(props: ComposeTaskProps) {// draft init logicconst initializeFromDraft = () => {+ if (recovered) {+ const draft = loadTaskComposerDraft(draftStorage) ?? recovered.draft;+ return { ...draft, isDraftLoaded: true };+ }if (!props.initialTitle &&!props.initialContent &&@@ -200,22 +228,8 @@ export function ComposeTask(props: ComposeTaskProps) {initialState.isDraftLoaded);const [createMore, setCreateMore] = createSignal(false);- const [shareWithTeam, setShareWithTeam] = makePersistedState(- createSignal(true),- {- storages: {- restore: () => {- const stored = localStorage.getItem('task-composer-share-with-team');- return stored === 'true'- ? true- : stored === 'false'- ? false- : undefined;- },- write: (value) =>- localStorage.setItem('task-composer-share-with-team', String(value)),- },- }+ const [shareWithTeam, setShareWithTeam] = createTaskComposerSharing(+ recovered?.shareWithTeam);const [errorMessage, setErrorMessage] = createSignal<string>('');const userTeams = useUserTeamsQuery();@@ -277,11 +291,23 @@ export function ComposeTask(props: ComposeTaskProps) {// draft saving logiclet hasInitializedFromDraft = isDraftLoaded();let skipNextDraftSave = false;+ let submittedInput = false;+ let draftSessionActive = true;const debouncedSave = debounce(- (draft: Parameters<typeof saveTaskComposerDraft>[0]) =>- saveTaskComposerDraft(draft, draftStorage),+ (draft: Parameters<typeof saveTaskComposerDraft>[0]) => {+ if (draftSessionActive && currentUserId() === draftOwner)+ saveTaskComposerDraft(draft, draftStorage);+ },300);+ const retireDraftSession = () => {+ draftSessionActive = false;+ debouncedSave.clear();+ };+ window.addEventListener(COMPOSER_STORAGE_CLEARED, retireDraftSession);+ onCleanup(() =>+ window.removeEventListener(COMPOSER_STORAGE_CLEARED, retireDraftSession)+ );const draftSnapshot = () => ({title: title(),content: content(),@@ -292,7 +318,12 @@ export function ComposeTask(props: ComposeTaskProps) {onCleanup(() => {debouncedSave.clear();// Escape and backdrop dismissal bypass the close button. Flush before disposal.- if (!isCreating() && hasDraftChanges()) {+ if (+ draftSessionActive &&+ currentUserId() === draftOwner &&+ (!isCreating() || !submittedInput) &&+ hasDraftChanges()+ ) {saveTaskComposerDraft(draftSnapshot(), draftStorage);}});@@ -391,112 +422,155 @@ export function ComposeTask(props: ComposeTaskProps) {});};- // A retry keeps its host context and creation policy, not one-shot editor callbacks.- const reopenForRetry = () =>+ const recoverDraft = (id: string) => {+ if (currentUserId() !== draftOwner) return;popoverSplit({type: 'component',id: 'task-compose',params: {- createTask: props.createTask,composerContext: props.composerContext,- initialProjectId: props.initialProjectId,+ recoveredDraftId: id,},});+ };- const handleCreateTask = async () => {- if (isCreating()) return;-+ const createTask = async (inSplit: boolean) => {+ if (+ !draftSessionActive ||+ isCreating() ||+ currentUserId() !== draftOwner ||+ !draftOwner+ )+ return;const taskTitle = title().trim();const taskContent = content().trim();-- if (!taskTitle) {+ if (!inSplit && !taskTitle) {setErrorMessage('Please give this task a title');return;}+ const id = recovered?.id ?? crypto.randomUUID();+ if (+ queryClient.isMutating({ mutationKey: taskSubmissionKey(draftOwner, id) })+ )+ return;setErrorMessage('');-setIsCreating(true);-+ const keepOpen = createMore() && !inSplit && !recovered;+ submittedInput = true;const properties = structuredClone(Object.entries(unwrap(propertyValues)));- const resetTitleAndBody = () => {- clearDraft();- skipNextDraftSave = true;- setTitle('');- setContent('');- setIsDraftLoaded(false);- const ed = bodyEditor();- ed && initializeEditorEmpty(ed);- requestAnimationFrame(() => titleEditorRoot?.focus());- };-- if (!createMore()) {- // Snapshot the draft locally, then clear localStorage so a new dialog- // opened while this creation is in flight starts blank.- const snapshot = draftSnapshot();- clearDraft();- const createdTask = await (props.createTask ?? createTaskWithProperties)(- taskTitle,- taskContent,- properties,- createDefinitions(),- (params) => upsertToHistoryMutation.mutate(params),+ const definitions = createDefinitions();+ const snapshot = draftSnapshot();+ const shareWithTeam = sharesWithTeam();+ let split: ReturnType<typeof openWithSplit>['split'];+ let started = false;+ let createdTask: Awaited<ReturnType<typeof createTaskWithProperties>> =+ null;+ try {+ createdTask = await submitTaskDraft(+ queryClient,{- shareWithTeam: sharesWithTeam(),- onMutate: () => {- splitPanel.handle.close();- props.onClose?.();- props.onCreateStart?.({ title: taskTitle, content: taskContent });- },+ id,+ userId: draftOwner,+ contextKey: props.composerContext?.key,+ draft: snapshot,+ shareWithTeam,+ },+ (confirm) => {+ if (currentUserId() !== draftOwner) return Promise.resolve(null);+ started = true;+ return (props.createTask ?? createTaskWithProperties)(+ taskTitle,+ taskContent,+ properties,+ definitions,+ (params) => {+ if (currentUserId() === draftOwner)+ upsertToHistoryMutation.mutate(params);+ },+ {+ shareWithTeam,+ showFailureToast: false,+ onCreated: confirm,+ onMutate: () => {+ clearDraft();+ if (keepOpen) {+ submittedInput = false;+ skipNextDraftSave = true;+ setTitle('');+ setContent('');+ setIsDraftLoaded(false);+ const editor = bodyEditor();+ if (editor) initializeEditorEmpty(editor);+ requestAnimationFrame(() => titleEditorRoot?.focus());+ } else {+ splitPanel.handle.close();+ props.onClose?.();+ if (inSplit) {+ split = openWithSplit(+ { type: 'component', id: 'loading' },+ { referredFrom: 'launcher', preferNewSplit: true }+ ).split;+ } else {+ props.onCreateStart?.({+ title: taskTitle,+ content: taskContent,+ });+ }+ }+ },+ }+ );});-+ } catch (error) {+ Telemetry.error(error, { surface: 'compose-task' });+ } finally {setIsCreating(false);+ }- if (!createdTask) {- props.onCreateFailure?.();- // Restore the draft and re-open so the user can retry- debouncedSave.clear();- saveTaskComposerDraft(snapshot, draftStorage);- reopenForRetry();- return;- }-- const { documentId, initialSnapshot } = createdTask;- if (props.onSuccess) {- props.onSuccess({ documentId, title: taskTitle, content: taskContent });- } else {- fireAndForget(- showTaskCreatedToast(documentId, initialSnapshot),- 'compose-task'+ if (currentUserId() !== draftOwner) return;+ if (!createdTask) {+ if (!started) {+ setErrorMessage(+ 'Unable to save this draft on your device. Keep the composer open and try again.');+ return;}- props.onCreateTask?.(taskTitle, taskContent);- return;- }-- const createdTask = await (props.createTask ?? createTaskWithProperties)(- taskTitle,- taskContent,- properties,- createDefinitions(),- (params) => upsertToHistoryMutation.mutate(params),- {- shareWithTeam: sharesWithTeam(),- onMutate: () => {- resetTitleAndBody();- setIsCreating(false);- },+ if (!inSplit && !keepOpen) props.onCreateFailure?.();+ split?.goBack();+ if (currentUserId() === draftOwner) {+ toast.failure('Task creation was not confirmed', {+ subtext:+ 'Your draft is saved on this device. Check Tasks before retrying.',+ actions: [+ { label: 'Recover draft', onClick: () => recoverDraft(id) },+ ],+ });}- );-- if (!createdTask) {return;}-- // Success: clear draft and notify- clearDraft();+ if (currentUserId() !== draftOwner) return;const { documentId, initialSnapshot } = createdTask;- if (props.onSuccess) {+ if (inSplit) {+ const snapshotParams = initialSnapshot+ ? {+ params: { optimisticSnapshot: initialSnapshot },+ preserveParams: true as const,+ }+ : {};+ if (split) {+ split.replace({+ next: { type: 'task', id: documentId, ...snapshotParams },+ mergeHistory: true,+ referredFrom: 'launcher',+ });+ } else {+ openWithSplit(+ { type: 'task', id: documentId, ...snapshotParams },+ { referredFrom: 'launcher', preferNewSplit: true }+ );+ }+ } else if (props.onSuccess) {props.onSuccess({ documentId, title: taskTitle, content: taskContent });} else {fireAndForget(@@ -506,74 +580,8 @@ export function ComposeTask(props: ComposeTaskProps) {}props.onCreateTask?.(taskTitle, taskContent);};-- const handleContinueInSplit = async () => {- if (isCreating()) return;-- const taskTitle = title().trim();- const taskContent = content().trim();-- setErrorMessage('');- setIsCreating(true);-- const properties = structuredClone(Object.entries(unwrap(propertyValues)));- const snapshot = draftSnapshot();- clearDraft();-- let split: ReturnType<typeof openWithSplit>['split'];-- const createdTask = await (props.createTask ?? createTaskWithProperties)(- taskTitle,- taskContent,- properties,- createDefinitions(),- (params) => upsertToHistoryMutation.mutate(params),- {- shareWithTeam: sharesWithTeam(),- onMutate: () => {- splitPanel.handle.close();- props.onClose?.();- split = openWithSplit(- { type: 'component', id: 'loading' },- { referredFrom: 'launcher', preferNewSplit: true }- ).split;- },- }- );-- setIsCreating(false);-- if (!createdTask) {- split?.goBack();- debouncedSave.clear();- saveTaskComposerDraft(snapshot, draftStorage);- reopenForRetry();- return;- }-- const { documentId, initialSnapshot } = createdTask;- const snapshotParams = initialSnapshot- ? {- params: { optimisticSnapshot: initialSnapshot },- preserveParams: true as const,- }- : {};-- if (split) {- split.replace({- next: { type: 'task', id: documentId, ...snapshotParams },- mergeHistory: true,- referredFrom: 'launcher',- });- } else {- openWithSplit(- { type: 'task', id: documentId, ...snapshotParams },- { referredFrom: 'launcher', preferNewSplit: true }- );- }-- props.onCreateTask?.(taskTitle, taskContent);- };+ const handleCreateTask = () => createTask(false);+ const handleContinueInSplit = () => createTask(true);const handleClose = () => {splitPanel.handle.close();@@ -592,6 +600,7 @@ export function ComposeTask(props: ComposeTaskProps) {};const handleClearDraft = () => {+ if (recovered) clearTaskSubmission(draftOwner, recovered.id);clearDraft();skipNextDraftSave = true;setTitle('');@@ -715,6 +724,7 @@ export function ComposeTask(props: ComposeTaskProps) {<Show when={hasDraftChanges()}><ButtononMouseDown={handleClearDraft}+ disabled={isCreating()}tabIndex={-1}tooltip="Clear Draft"size="sm"@@ -736,6 +746,17 @@ export function ComposeTask(props: ComposeTaskProps) {</Button></Show></EntityComposer.Header>+ <RecoverTaskDrafts+ userId={draftOwner}+ drafts={submissions().filter((draft) => draft.id !== recovered?.id)}+ onOpen={recoverDraft}+ />+ <Show when={recovered}>+ <div class="border-b border-edge-muted p-3 text-sm">+ Recovered on this device. Task creation requires a connection. Check+ Tasks before retrying to avoid creating a duplicate.+ </div>+ </Show><EntityComposer.Main><EntityComposer.Title><Show when={tagLayoutMode() === 'title'}>@@ -907,6 +928,7 @@ export function ComposeTask(props: ComposeTaskProps) {<ToggleSwitchlabelClass="text-xs text-ink-muted font-normal whitespace-nowrap"onChange={setCreateMore}+ disabled={!!recovered || isCreating()}checked={createMore()}label="Create More"/>diff --git a/apps/web/src/features/block-md/component/RecoverTaskDrafts.tsx b/apps/web/src/features/block-md/component/RecoverTaskDrafts.tsxnew file mode 100644index 0000000000..bcaa4bdfd4--- /dev/null+++ b/apps/web/src/features/block-md/component/RecoverTaskDrafts.tsx@@ -0,0 +1,48 @@+import { useMutationState } from '@tanstack/solid-query';+import { Button } from '@ui';+import { For, Show } from 'solid-js';+import {+ type TaskComposerSubmission,+ taskSubmissionKey,+} from '../util/taskComposerSubmissions';++export function RecoverTaskDrafts(props: {+ userId: string;+ drafts: TaskComposerSubmission[];+ onOpen: (id: string) => void;+}) {+ const pending = useMutationState(() => ({+ filters: {+ mutationKey: taskSubmissionKey(props.userId),+ status: 'pending',+ },+ select: (mutation) => mutation.options.mutationKey?.[2],+ }));++ return (+ <Show when={props.drafts.length > 0}>+ <div class="border-b border-edge-muted p-3 text-sm">+ <p>+ Unconfirmed task drafts are saved on this device. Check Tasks before+ retrying; a request may have reached the server.+ </p>+ <For each={props.drafts}>+ {(draft) => (+ <Button+ variant="outline"+ class="mt-2 max-w-full"+ tooltip={draft.draft.title || 'Untitled task'}+ disabled={pending().includes(draft.id)}+ onClick={() => props.onOpen(draft.id)}+ >+ <span class="truncate">+ {pending().includes(draft.id) ? 'Creating: ' : 'Recover: '}+ {draft.draft.title || 'Untitled task'}+ </span>+ </Button>+ )}+ </For>+ </div>+ </Show>+ );+}diff --git a/apps/web/src/features/block-md/util/taskComposerDraftSchema.ts b/apps/web/src/features/block-md/util/taskComposerDraftSchema.tsnew file mode 100644index 0000000000..34d146dae8--- /dev/null+++ b/apps/web/src/features/block-md/util/taskComposerDraftSchema.ts@@ -0,0 +1,68 @@+import { EntityType } from '@service-properties/generated/schemas/entityType';+import { z } from 'zod';++const propertyValue = z.discriminatedUnion('valueType', [+ z.object({ valueType: z.literal('STRING'), value: z.string().nullable() }),+ z.object({ valueType: z.literal('NUMBER'), value: z.number().nullable() }),+ z.object({ valueType: z.literal('BOOLEAN'), value: z.boolean().nullable() }),+ z.object({+ valueType: z.literal('DATE'),+ value: z.iso+ .datetime()+ .transform((value) => new Date(value))+ .nullable(),+ }),+ z.object({+ valueType: z.literal('SELECT_STRING'),+ values: z.array(z.string()).nullable(),+ }),+ z.object({+ valueType: z.literal('SELECT_NUMBER'),+ values: z.array(z.string()).nullable(),+ }),+ z.object({+ valueType: z.literal('LINK'),+ values: z.array(z.string()).nullable(),+ }),+ z.object({+ valueType: z.literal('ENTITY'),+ refs: z+ .array(+ z.object({+ entity_id: z.string(),+ entity_type: z.enum(EntityType),+ specific_message_id: z.uuid().nullable().optional(),+ })+ )+ .nullable(),+ }),+]);++// Preserve each Lexical node's additional payload. Malformed editor envelopes+// fall back to the saved Markdown instead of making the draft unrecoverable.+const editorState = z.object({+ root: z.looseObject({+ type: z.literal('root'),+ version: z.number(),+ children: z.array(z.looseObject({ type: z.string(), version: z.number() })),+ direction: z.enum(['ltr', 'rtl']).nullable(),+ format: z.enum(['', 'left', 'start', 'center', 'right', 'end', 'justify']),+ indent: z.number(),+ }),+});++export const taskComposerDraftSchema = z.object({+ title: z.string(),+ content: z.string(),+ editorState: editorState.optional().catch(undefined),+ propertyValues: z.record(z.string(), propertyValue),+ visiblePropertyIds: z.array(z.string()).optional(),+});++export const taskSubmissionSchema = z.object({+ id: z.string(),+ userId: z.string(),+ contextKey: z.string().optional(),+ draft: taskComposerDraftSchema,+ shareWithTeam: z.boolean(),+});diff --git a/apps/web/src/features/block-md/util/taskComposerProperties.test.ts b/apps/web/src/features/block-md/util/taskComposerProperties.test.tsindex 5982050615..6b28e8c685 100644--- a/apps/web/src/features/block-md/util/taskComposerProperties.test.ts+++ b/apps/web/src/features/block-md/util/taskComposerProperties.test.ts@@ -106,6 +106,24 @@ it('skips the check without a project', async () => {expect(mock.properties).not.toHaveBeenCalled();});+it('confirms creation before waiting for a project membership read', async () => {+ mock.create.mockResolvedValue({ documentId: 'task' });+ const projectRead = Promise.withResolvers<[]>();+ const confirmed = Promise.withResolvers<string>();+ mock.properties.mockReturnValue(projectRead.promise);+ const creating = createTaskWithProperties(+ 'Ship it',+ '',+ [[SYSTEM_PROPERTY_IDS.PROJECT, taskComposerProjectValue('project')]],+ new Map(),+ vi.fn(),+ { onCreated: (task) => confirmed.resolve(task.documentId) }+ );+ expect(await confirmed.promise).toBe('task');+ projectRead.resolve([]);+ expect(await creating).toEqual({ documentId: 'task' });+});+import type { PropertyDefinition } from '@service-properties/generated/schemas/propertyDefinition';import {taskComposerVisiblePropertyIds,@@ -308,3 +326,15 @@ it('retains a created single-select definition when the definition query fails',dispose();}});++it('lets the composer own failed-create feedback without silencing other callers', async () => {+ mock.create.mockResolvedValue(null);+ expect(+ await createTaskWithProperties('Draft', '', [], new Map(), vi.fn(), {+ showFailureToast: false,+ })+ ).toBeNull();+ expect(mock.failure).not.toHaveBeenCalled();+ expect(await create()).toBeNull();+ expect(mock.failure).toHaveBeenCalledExactlyOnceWith('Failed to create Task');+});diff --git a/apps/web/src/features/block-md/util/taskComposerProperties.ts b/apps/web/src/features/block-md/util/taskComposerProperties.tsindex f81de56db2..0e9fe0be9b 100644--- a/apps/web/src/features/block-md/util/taskComposerProperties.ts+++ b/apps/web/src/features/block-md/util/taskComposerProperties.ts@@ -126,7 +126,15 @@ export async function createTaskWithProperties(options?: {revalidateSoup?: boolean;shareWithTeam?: boolean;+ /** Disable when the caller provides its own recovery notification. */+ showFailureToast?: boolean;onMutate?: () => void;+ /** The create response arrived, before history/project follow-up work. */+ onCreated?: (+ task: NonNullable<+ Awaited<ReturnType<typeof createTaskWithInitialSnapshot>>+ >+ ) => void;}) {options?.onMutate?.();@@ -152,10 +160,13 @@ export async function createTaskWithProperties(});if (!createdTask) {- toast.failure('Failed to create Task');+ if (options?.showFailureToast !== false)+ toast.failure('Failed to create Task');return null;}+ options?.onCreated?.(createdTask);+// createTaskWithInitialSnapshot already revalidates Soup; just update history.upsertToHistory({itemId: createdTask.documentId,diff --git a/apps/web/src/features/block-md/util/taskComposerStorage.test.ts b/apps/web/src/features/block-md/util/taskComposerStorage.test.tsindex 0e0689a2e5..8cb2218170 100644--- a/apps/web/src/features/block-md/util/taskComposerStorage.test.ts+++ b/apps/web/src/features/block-md/util/taskComposerStorage.test.ts@@ -2,9 +2,11 @@* @vitest-environment jsdom*/+import { createRoot } from 'solid-js';import { beforeEach, describe, expect, it } from 'vitest';import {clearTaskComposerDraft,+ createTaskComposerSharing,loadTaskComposerDraft,saveTaskComposerDraft,type TaskComposerDraft,@@ -123,3 +125,36 @@ describe('context drafts', () => {expect(loadTaskComposerDraft()?.title).toBe('A task');});});++it('keeps recovered sharing local while new composers remember the default', () => {+ localStorage.setItem('task-composer-share-with-team', 'true');+ createRoot((dispose) => {+ const [recovered, setRecovered] = createTaskComposerSharing(false);+ expect(recovered()).toBe(false);+ expect(localStorage.getItem('task-composer-share-with-team')).toBe('true');+ setRecovered(true);+ setRecovered(false);+ expect(localStorage.getItem('task-composer-share-with-team')).toBe('true');+ const [fresh, setFresh] = createTaskComposerSharing();+ expect(fresh()).toBe(true);+ setFresh(false);+ expect(createTaskComposerSharing()[0]()).toBe(false);+ dispose();+ });+});++it('preserves specific message references through draft recovery', () => {+ const reference = {+ entity_id: 'channel',+ entity_type: 'CHANNEL' as const,+ specific_message_id: '0195dbd0-7b5d-7000-8000-000000000001',+ };+ saveTaskComposerDraft({+ ...draft,+ propertyValues: { source: { valueType: 'ENTITY', refs: [reference] } },+ });+ expect(loadTaskComposerDraft()?.propertyValues.source).toEqual({+ valueType: 'ENTITY',+ refs: [reference],+ });+});diff --git a/apps/web/src/features/block-md/util/taskComposerStorage.ts b/apps/web/src/features/block-md/util/taskComposerStorage.tsindex 4fed5242e8..0af5be61ba 100644--- a/apps/web/src/features/block-md/util/taskComposerStorage.ts+++ b/apps/web/src/features/block-md/util/taskComposerStorage.ts@@ -1,8 +1,35 @@+import { makePersistedState } from '@app/lib/persistence';import type { PropertyApiValues } from '@property/types';import type { SerializedEditorState } from 'lexical';+import { createSignal } from 'solid-js';+import { z } from 'zod';+import { taskComposerDraftSchema } from './taskComposerDraftSchema';++const storedDraftSchema = taskComposerDraftSchema.extend({+ timestamp: z.number(),+});const STORAGE_KEY = 'task-composer-draft';+/** Recovered submissions keep their sharing choice separate from new-task defaults. */+export function createTaskComposerSharing(recoveredShare?: boolean) {+ if (recoveredShare !== undefined) return createSignal(recoveredShare);+ return makePersistedState(createSignal(true), {+ storages: {+ restore: () => {+ const stored = localStorage.getItem('task-composer-share-with-team');+ return stored === 'true'+ ? true+ : stored === 'false'+ ? false+ : undefined;+ },+ write: (value) =>+ localStorage.setItem('task-composer-share-with-team', String(value)),+ },+ });+}+/** Context drafts use their own key; the global composer retains its original key. */export function taskComposerContextStorage(key: string@@ -65,7 +92,7 @@ export function loadTaskComposerDraft(const stored = localStorage.getItem(storage?.storageKey ?? STORAGE_KEY);if (!stored) return null;- const draft: TaskComposerDraft = JSON.parse(stored);+ const draft = storedDraftSchema.parse(JSON.parse(stored));const expiryMs =storage?.expiryMs === undefined ? EXPIRY_TIME_MS : storage.expiryMs;const elapsed = Date.now() - draft.timestamp;@@ -76,7 +103,6 @@ export function loadTaskComposerDraft(return null;}- draft.propertyValues = rehydratePropertyValues(draft.propertyValues);return draft;} catch (error) {console.warn('Failed to load task composer draft:', error);@@ -85,27 +111,6 @@ export function loadTaskComposerDraft(}}-// JSON.stringify serializes Date as an ISO string, and JSON.parse won't turn-// it back into a Date. propertyApiValuesToNormalized requires `value instanceof-// Date`, so without this step DATE properties round-trip as EMPTY.-function rehydratePropertyValues(- values: Record<string, PropertyApiValues>-): Record<string, PropertyApiValues> {- const result: Record<string, PropertyApiValues> = {};- for (const [key, value] of Object.entries(values)) {- if (value.valueType === 'DATE') {- const raw = (value as { value: unknown }).value;- result[key] = {- valueType: 'DATE',- value: typeof raw === 'string' ? new Date(raw) : (raw as Date | null),- };- } else {- result[key] = value;- }- }- return result;-}-/*** Clear task composer draft from local storage*/diff --git a/apps/web/src/features/block-md/util/taskComposerSubmissions.test.ts b/apps/web/src/features/block-md/util/taskComposerSubmissions.test.tsnew file mode 100644index 0000000000..42a628cae8--- /dev/null+++ b/apps/web/src/features/block-md/util/taskComposerSubmissions.test.ts@@ -0,0 +1,208 @@+/** @vitest-environment jsdom */+import { QueryClient } from '@tanstack/solid-query';+import { createRoot } from 'solid-js';+import { afterEach, beforeEach, expect, it, vi } from 'vitest';+import {+ loadTaskComposerDraft,+ saveTaskComposerDraft,+} from './taskComposerStorage';+import {+ createTaskSubmissionList,+ loadTaskSubmissions,+ submitTaskDraft,+ type TaskComposerSubmission,+} from './taskComposerSubmissions';++let client: QueryClient;+const submission: TaskComposerSubmission = {+ id: 'first',+ userId: 'alice',+ shareWithTeam: false,+ draft: {+ title: 'Offline task',+ content: 'Keep this description',+ propertyValues: {+ due: { valueType: 'DATE', value: new Date('2026-10-22T00:00:00Z') },+ },+ visiblePropertyIds: ['due'],+ },+};++beforeEach(() => {+ localStorage.clear();+ client = new QueryClient({+ defaultOptions: { mutations: { gcTime: Infinity } },+ });+});+afterEach(() => {+ client.clear();+ vi.restoreAllMocks();+});++it('saves before sending and recovers a pending request after a restart and prolonged outage', async () => {+ const response = Promise.withResolvers<{ documentId: string } | null>();+ const pending = submitTaskDraft(client, submission, () => {+ expect(loadTaskSubmissions('alice')[0].draft.content).toBe(+ 'Keep this description'+ );+ return response.promise;+ });+ client = new QueryClient();+ vi.spyOn(Date, 'now').mockReturnValue(Date.now() + 30 * 24 * 60 * 60 * 1000);+ const recovered = loadTaskSubmissions('alice')[0];+ expect(recovered.draft.title).toBe('Offline task');+ expect(recovered.draft.visiblePropertyIds).toEqual(['due']);+ expect(recovered.draft.propertyValues.due).toEqual({+ valueType: 'DATE',+ value: new Date('2026-10-22T00:00:00Z'),+ });+ expect(recovered.shareWithTeam).toBe(false);+ expect(loadTaskSubmissions('bob')).toEqual([]);+ expect(loadTaskSubmissions('alice', 'crm:one')).toEqual([]);+ response.resolve(null);+ await pending;+ expect(loadTaskSubmissions('alice')).toHaveLength(1);+});++it('late success removes only its own submission and leaves newer composer input intact', async () => {+ const response = Promise.withResolvers<{ documentId: string }>();+ const pending = submitTaskDraft(client, submission, () => response.promise);+ await submitTaskDraft(+ client,+ {+ ...submission,+ id: 'second',+ draft: { ...submission.draft, title: 'Second task' },+ },+ async () => null+ );+ saveTaskComposerDraft({+ title: 'New input',+ content: 'New body',+ propertyValues: {},+ });+ response.resolve({ documentId: 'created' });+ await pending;+ expect(loadTaskSubmissions('alice').map((draft) => draft.id)).toEqual([+ 'second',+ ]);+ expect(loadTaskComposerDraft()?.title).toBe('New input');+});++it('retains failed input without restoring over a newer draft', async () => {+ const response = Promise.withResolvers<null>();+ const pending = submitTaskDraft(client, submission, () => response.promise);+ saveTaskComposerDraft({+ title: 'Newer input',+ content: '',+ propertyValues: {},+ });+ response.resolve(null);+ await pending;+ expect(loadTaskSubmissions('alice')).toHaveLength(1);+ expect(loadTaskComposerDraft()?.title).toBe('Newer input');+});++it('does not resend the same pending submission from another composer', async () => {+ const response = Promise.withResolvers<null>();+ const create = vi.fn(() => response.promise);+ const pending = submitTaskDraft(client, submission, create);+ expect(await submitTaskDraft(client, submission, create)).toBeNull();+ response.resolve(null);+ await pending;+ expect(create).toHaveBeenCalledTimes(1);+});++it('keeps input after a rejected request without automatically retrying', async () => {+ const create = vi.fn(async () => {+ throw new Error('Connection lost');+ });+ await expect(submitTaskDraft(client, submission, create)).rejects.toThrow(+ 'Connection lost'+ );+ expect(create).toHaveBeenCalledTimes(1);+ expect(loadTaskSubmissions('alice')).toHaveLength(1);+});++it('does not send or clear input when the durable save fails', async () => {+ const create = vi.fn(async () => ({ documentId: 'created' }));+ vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {+ throw new Error('Quota exceeded');+ });+ await expect(submitTaskDraft(client, submission, create)).rejects.toThrow(+ 'Quota exceeded'+ );+ expect(create).not.toHaveBeenCalled();+});++it('retires a confirmed create before project checks and does not turn their failure into a retry', async () => {+ const result = await submitTaskDraft(client, submission, async (confirm) => {+ confirm({ documentId: 'created' });+ expect(loadTaskSubmissions('alice')).toEqual([]);+ throw new Error('History update failed');+ });+ expect(result).toEqual({ documentId: 'created' });+});++it('preserves confirmed success when storage cleanup fails', async () => {+ vi.spyOn(Storage.prototype, 'removeItem').mockImplementation(() => {+ throw new Error('Storage unavailable');+ });+ vi.spyOn(console, 'warn').mockImplementation(() => {});+ expect(+ await submitTaskDraft(client, submission, async () => ({+ documentId: 'created',+ }))+ ).toEqual({ documentId: 'created' });+});++it('removes a completed request from a composer opened while it was pending', async () => {+ const response = Promise.withResolvers<{ documentId: string }>();+ const pending = submitTaskDraft(client, submission, () => response.promise);+ const view = createRoot((dispose) => ({+ dispose,+ drafts: createTaskSubmissionList(client, 'alice'),+ }));+ expect(view.drafts().map((draft) => draft.id)).toEqual(['first']);+ response.resolve({ documentId: 'created' });+ await pending;+ expect(view.drafts()).toEqual([]);+ view.dispose();+});++it('skips invalid persisted entries without hiding a valid draft', async () => {+ await submitTaskDraft(client, submission, async () => null);+ const valid = localStorage.getItem('task-composer-submission:alice:first');+ expect(valid).not.toBeNull();+ const raw = JSON.parse(valid!);+ for (const [id, patch] of Object.entries({+ properties: {+ draft: {+ ...raw.draft,+ propertyValues: { due: { valueType: 'DATE', value: 'invalid' } },+ },+ },+ visible: { draft: { ...raw.draft, visiblePropertyIds: 12 } },+ sharing: { shareWithTeam: 'yes' },+ })) {+ localStorage.setItem(+ `task-composer-submission:alice:${id}`,+ JSON.stringify({ ...raw, id, ...patch })+ );+ }+ localStorage.setItem('task-composer-submission:alice:broken', '{');+ expect(loadTaskSubmissions('alice').map((draft) => draft.id)).toEqual([+ 'first',+ ]);+});++it('recovers Markdown when an older editor envelope is malformed', async () => {+ await submitTaskDraft(client, submission, async () => null);+ const key = 'task-composer-submission:alice:first';+ const raw = JSON.parse(localStorage.getItem(key)!);+ raw.draft.editorState = { root: 'invalid' };+ localStorage.setItem(key, JSON.stringify(raw));+ const recovered = loadTaskSubmissions('alice')[0];+ expect(recovered.draft.editorState).toBeUndefined();+ expect(recovered.draft.content).toBe('Keep this description');+});diff --git a/apps/web/src/features/block-md/util/taskComposerSubmissions.ts b/apps/web/src/features/block-md/util/taskComposerSubmissions.tsnew file mode 100644index 0000000000..61b614f05c--- /dev/null+++ b/apps/web/src/features/block-md/util/taskComposerSubmissions.ts@@ -0,0 +1,142 @@+import { Telemetry } from '@macro-inc/observability';+import type { QueryClient } from '@tanstack/solid-query';+import { createSignal, onCleanup } from 'solid-js';+import { taskSubmissionSchema } from './taskComposerDraftSchema';+import type { TaskComposerDraft } from './taskComposerStorage';++const PREFIX = 'task-composer-submission:';++export type TaskComposerSubmission = {+ id: string;+ userId: string;+ contextKey?: string;+ draft: Omit<TaskComposerDraft, 'timestamp'>;+ shareWithTeam: boolean;+};++function storageKey(userId: string, id: string) {+ return `${PREFIX}${encodeURIComponent(userId)}:${id}`;+}++export function taskSubmissionKey(userId: string, id?: string) {+ return id+ ? ['task-composer-submission', userId, id]+ : ['task-composer-submission', userId];+}++export function taskSubmissionDraftStorage(userId: string, id: string) {+ return {+ storageKey: `${storageKey(userId, id)}:editing`,+ expiryMs: null,+ };+}++export function loadTaskSubmissions(+ userId: string,+ contextKey?: string+): TaskComposerSubmission[] {+ const prefix = `${PREFIX}${encodeURIComponent(userId)}:`;+ const submissions: TaskComposerSubmission[] = [];+ try {+ for (let i = 0; i < localStorage.length; i++) {+ const key = localStorage.key(i);+ if (!key?.startsWith(prefix) || key.endsWith(':editing')) continue;+ try {+ const parsed = taskSubmissionSchema.safeParse(+ JSON.parse(localStorage.getItem(key) ?? 'null')+ );+ if (!parsed.success) continue;+ const value = parsed.data;+ if (+ value?.userId === userId &&+ value.contextKey === contextKey &&+ key === storageKey(userId, value.id)+ ) {+ submissions.push(value);+ }+ } catch {+ // A damaged entry must not hide other recoverable drafts.+ }+ }+ } catch (error) {+ console.warn('Failed to read pending task drafts:', error);+ }+ return submissions;+}++export function clearTaskSubmission(userId: string, id: string) {+ localStorage.removeItem(storageKey(userId, id));+ localStorage.removeItem(taskSubmissionDraftStorage(userId, id).storageKey);+}++/** Other composers must observe a submission completing after its host closes. */+export function createTaskSubmissionList(+ client: QueryClient,+ userId: string,+ contextKey?: string+) {+ const [submissions, setSubmissions] = createSignal(+ loadTaskSubmissions(userId, contextKey)+ );+ onCleanup(+ client.getMutationCache().subscribe(() => {+ setSubmissions(loadTaskSubmissions(userId, contextKey));+ })+ );+ return submissions;+}++/** Persist before starting the request, and retire only the confirmed submission. */+export async function submitTaskDraft<T extends { documentId: string }>(+ client: QueryClient,+ submission: TaskComposerSubmission,+ create: (confirm: (created: T) => void) => Promise<T | null>+): Promise<T | null> {+ const mutationKey = taskSubmissionKey(submission.userId, submission.id);+ if (client.isMutating({ mutationKey })) return null;+ return Telemetry.span('task.compose.submit', async (span) => {+ span.setAttr('task.draft_id', submission.id);+ // Do not send when this fails: closing the app would otherwise lose the input.+ localStorage.setItem(+ storageKey(submission.userId, submission.id),+ JSON.stringify(submission)+ );+ let confirmed: T | undefined;+ const confirm = (created: T) => {+ confirmed = created;+ span.setAttr('document.id', created.documentId);+ span.setAttr('task.creation_confirmed', true);+ try {+ clearTaskSubmission(submission.userId, submission.id);+ } catch (error) {+ console.warn('Failed to retire confirmed task draft:', error);+ }+ };+ return client+ .getMutationCache()+ .build(client, {+ mutationKey,+ retry: false,+ gcTime: 0,+ networkMode: 'always',+ mutationFn: async () => {+ try {+ const result = await span.span('task.compose.create', () =>+ create(confirm)+ );+ if (!result && !confirmed)+ span.error('Task creation was not confirmed');+ return confirmed ?? result;+ } catch (error) {+ // History or project checks cannot undo a confirmed creation.+ if (confirmed) return confirmed;+ throw error;+ }+ },+ onSuccess: (created) => {+ if (created && !confirmed) confirm(created);+ },+ })+ .execute(undefined);+ });+}diff --git a/apps/web/src/features/crm/record-tasks-adapter.test.tsx b/apps/web/src/features/crm/record-tasks-adapter.test.tsxindex 047f60b11a..ff499c6b2f 100644--- a/apps/web/src/features/crm/record-tasks-adapter.test.tsx+++ b/apps/web/src/features/crm/record-tasks-adapter.test.tsx@@ -1,15 +1,19 @@import type { TasksViewProviderProps } from '@app/features/tasks-view/tasks-view-context';import { cleanup, fireEvent, render, screen } from '@solidjs/testing-library';-import type { ParentProps } from 'solid-js';+import type { JSX, ParentProps } from 'solid-js';import { afterEach, expect, it, vi } from 'vitest';import { CrmActivityTasks } from './activity-tasks-adapter';import type { CrmRecordScope } from './core/record';import { CrmRecordTasks } from './record-tasks-adapter';-const { openWithSplit, openTaskComposer } = vi.hoisted(() => ({- openWithSplit: vi.fn(),- openTaskComposer: vi.fn(),-}));+const { openWithSplit, popoverSplit, adaptive, openTaskComposer } = vi.hoisted(+ () => ({+ openWithSplit: vi.fn(),+ popoverSplit: vi.fn(),+ adaptive: vi.fn(() => false),+ openTaskComposer: vi.fn(),+ })+);vi.mock('./context/crm-context', () => ({useCrmContext: () => ({ openTaskComposer }),}));@@ -18,7 +22,11 @@ vi.mock('@app/features/tasks-view/tasks-content', () => ({}));vi.mock('@components/app/split-layout/layout', () => ({- useSplitLayout: () => ({ openWithSplit }),+ useSplitLayout: () => ({ openWithSplit, popoverSplit }),+}));+vi.mock('@core/constant/featureFlags', () => ({+ enableCrmActivity: 'crm',+ isFeatureEnabled: adaptive,}));vi.mock('@property/tags/tag-sets-context', () => ({TagSetsQueryProvider: (props: ParentProps) => props.children,@@ -43,8 +51,10 @@ vi.mock('@app/features/tasks-view/tasks-view-context', () => ({>Create scoped task</button>+ {!props.onCreateTask && props.children}</>),+ useTasksView: () => ({ state: { search: '' }, setState: vi.fn() }),}));vi.mock('@app/features/tasks-view/components/TasksControls', () => ({TasksControls: () => null,@@ -55,11 +65,14 @@ vi.mock('@app/features/tasks-view/components/task-list/TaskList', () => ({vi.mock('@app/features/tasks-view/queries/use-tasks-query', () => ({useTasksDataSource: vi.fn(),}));-vi.mock('@block-md/util/taskComposerProperties', () => ({- createTaskWithProperties: vi.fn(),+vi.mock('@ui', () => ({+ Button: (props: JSX.ButtonHTMLAttributes<HTMLButtonElement>) => (+ <button {...props} />+ ),+}));+vi.mock('./components/record-section', () => ({+ RecordSection: (props: { actions: JSX.Element }) => props.actions,}));-vi.mock('@ui', () => ({ Button: () => null }));-vi.mock('./components/record-section', () => ({ RecordSection: () => null }));afterEach(() => {cleanup();@@ -76,6 +89,30 @@ const scopes: CrmRecordScope[] = [{ type: 'company', id: 'company-1', domains: ['example.com'] },];+it.each([false, true])(+ 'persists the original CRM context and associations with adaptive=%s',+ (enabled) => {+ adaptive.mockReturnValue(enabled);+ render(() => <CrmRecordTasks scope={scopes[0]} />);+ fireEvent.click(screen.getByRole('button', { name: 'New task' }));+ const params = popoverSplit.mock.calls[0][0].params;+ expect(params.composerContext.key).toBe('crm:contact:contact-1');+ expect(Object.values(params.composerContext.initialPropertyValues)).toEqual(+ expect.arrayContaining([+ {+ valueType: 'ENTITY',+ refs: [{ entity_id: 'contact-1', entity_type: 'CONTACT' }],+ },+ {+ valueType: 'ENTITY',+ refs: [{ entity_id: 'company-1', entity_type: 'COMPANY' }],+ },+ ])+ );+ expect(params.createTask).toBeUndefined();+ }+);+it.each(scopes)('opens a task from a $type in the task view', (scope) => {render(() => <CrmRecordTasks scope={scope} />);fireEvent.click(screen.getByRole('button', { name: 'Open task' }));diff --git a/apps/web/src/features/crm/record-tasks-adapter.tsx b/apps/web/src/features/crm/record-tasks-adapter.tsxindex 4cd6c0dd31..4e7ca4b948 100644--- a/apps/web/src/features/crm/record-tasks-adapter.tsx+++ b/apps/web/src/features/crm/record-tasks-adapter.tsx@@ -5,7 +5,6 @@ import {TasksViewProvider,useTasksView,} from '@app/features/tasks-view/tasks-view-context';-import { createTaskWithProperties } from '@block-md/util/taskComposerProperties';import { useSplitLayout } from '@components/app/split-layout/layout';import {enableCrmActivity,@@ -70,24 +69,11 @@ function RecordTasksBody(props: { scope: CrmRecordScope }) {type: 'component',id: 'task-compose',params: {- composerContext: adaptive ? context : undefined,- // Keep the existing record associations with the standard composer.- createTask: adaptive- ? undefined- : (- ...[title, content, properties, ...rest]: Parameters<- typeof createTaskWithProperties- >- ) =>- createTaskWithProperties(- title,- content,- [- ...properties,- ...Object.entries(context.initialPropertyValues ?? {}),- ],- ...rest- ),+ // Record identity/associations must survive a restart even with the+ // standard property row; they cannot live only in a create callback.+ composerContext: adaptive+ ? context+ : { ...context, visiblePropertyIds: undefined },},});};diff --git a/apps/web/src/lib/core/auth/clear-composer-storage.test.ts b/apps/web/src/lib/core/auth/clear-composer-storage.test.tsindex ba20085232..792835b71d 100644--- a/apps/web/src/lib/core/auth/clear-composer-storage.test.ts+++ b/apps/web/src/lib/core/auth/clear-composer-storage.test.ts@@ -1,5 +1,8 @@import { beforeEach, expect, it } from 'vitest';-import { clearComposerStorage } from './clear-composer-storage';+import {+ COMPOSER_STORAGE_CLEARED,+ clearComposerStorage,+} from './clear-composer-storage';beforeEach(() => localStorage.clear());@@ -8,6 +11,8 @@ it('clears scoped and legacy drafts and attachments while retaining preferences''input-value-home-agent-conversation-persist-v0:alice','input-value-agents-new-conversation-persist-v0:bob','input-value-channel-1',+ 'task-composer-submission:alice:first',+ 'task-composer-submission:alice:first:editing','attachment-tracker-agents-new-conversation-persist-v0:alice',];for (const key of keys) localStorage.setItem(key, 'private draft');@@ -16,3 +21,19 @@ it('clears scoped and legacy drafts and attachments while retaining preferences'for (const key of keys) expect(localStorage.getItem(key)).toBeNull();expect(localStorage.getItem('macro-selected-theme')).toBe('dark');});++it('retires mounted autosavers before wiping their saved data', () => {+ const key = 'task-composer-submission:alice:first:editing';+ localStorage.setItem(key, 'draft');+ let active = true;+ let valueAtRetire: string | null | undefined;+ const retire = () => {+ valueAtRetire = localStorage.getItem(key);+ active = false;+ };+ window.addEventListener(COMPOSER_STORAGE_CLEARED, retire, { once: true });+ clearComposerStorage();+ expect(valueAtRetire).toBe('draft');+ if (active) localStorage.setItem(key, 'late cleanup');+ expect(localStorage.getItem(key)).toBeNull();+});diff --git a/apps/web/src/lib/core/auth/clear-composer-storage.ts b/apps/web/src/lib/core/auth/clear-composer-storage.tsindex fb5c51651f..c041018d04 100644--- a/apps/web/src/lib/core/auth/clear-composer-storage.ts+++ b/apps/web/src/lib/core/auth/clear-composer-storage.ts@@ -1,9 +1,14 @@+export const COMPOSER_STORAGE_CLEARED = 'macro:composer-storage-cleared';+/** Remove saved composer text and attachment references on explicit logout. */export function clearComposerStorage(): void {+ // Retire mounted autosavers before removing data; auth teardown can await I/O.+ window.dispatchEvent(new Event(COMPOSER_STORAGE_CLEARED));for (let index = localStorage.length - 1; index >= 0; index--) {const key = localStorage.key(index);if (key?.startsWith('input-value-') ||+ key?.startsWith('task-composer-submission:') ||key?.startsWith('attachment-tracker-')) {localStorage.removeItem(key);diff --git a/docs/agent-guide/tasks.md b/docs/agent-guide/tasks.mdindex 28445fe4b9..b3d1cb32fe 100644--- a/docs/agent-guide/tasks.md+++ b/docs/agent-guide/tasks.md@@ -586,7 +586,8 @@ keyboard shortcut on touch. Desktop uses the centered composer dialog.set, the task is still created and a toast says it wasn't added to the project.The `Share with <team name>` switch in the footer's left corner (hidden when youaren't on a team) defaults to on and remembers your- choice in local storage across composer openings and page reloads. Hovering it+ choice in local storage across composer openings and page reloads. Recovered+ submissions use their saved sharing choice without changing this default. Hovering itexplains whether the task will be visible to your whole team or only to you andthe people you share it with. The choice also applies to Create More, continuingin a split, and tasks created from a project.@@ -606,8 +607,8 @@ Customers supplies its preset when PostHog `enable-crm-activity` is enabled:**Companies** and **Contacts** replace Status in the initial row; Status stillstarts as Not Started on the saved task. Record-level task creation prefills thecompany or contact, including the contact's company when already loaded. With the-CRM flag off or loading, CRM supplies no preset; record-level creation still-associates the task with its record. **Add property** opens the same property+CRM flag off or loading, record-level creation uses the standard property row+while retaining its record-scoped draft and associations. **Add property** opens the same propertyeditor as the document/task side panel: search by name or type, select a propertyand enter its value, or create a property from an unmatched search. Assignmentsand values stay in the task draft until creation; opening or closing the editor@@ -618,6 +619,22 @@ restores that view's preset.Later flag, focus or record changes leave the open draft and associations intact,even between launch and mount. The next opening uses the current context.+Task creation requires a connection. Before any create request, the composer+saves a separate copy of the title, description/editor state, properties, and+sharing choice on this device. Pending submissions do not expire and survive an+app restart. Reopen the same task composer context and choose **Recover: <title>**+to continue an unconfirmed draft; **Clear Draft** discards that recovered copy.+Explicit logout removes these account-scoped copies. Recovery does not submit+anything automatically: check Tasks before retrying because a lost response may+mean the task already exists. A submission still in flight cannot be recovered+or submitted again. Recovered drafts create one task at a time.++**Create More** keeps newer input separate from its pending submission. A late+success removes only the confirmed submission; failure leaves it recoverable+without replacing newer text. Continuing in a split has the same durable save.+A confirmed create retires its saved copy before history/project follow-up work,+so a failure in that follow-up does not present an already-created task for retry.+Tasks are documents under the hood (creation hits `POST /dss/documents/create_task`), so theyalso show up in Files/`All` and in AI-chat document listings.