@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/task-pane-selection-actions.ts

@@ -9,7 +9,7 @@ interface RepositoryRecordLike {
   readonly archivedAt: string | null;
 }
 
-interface TaskPaneSelectionActionsOptions<TTaskRecord extends TaskRecordLike> {
+export interface TaskPaneSelectionActionsOptions<TTaskRecord extends TaskRecordLike> {
   readonly workspace: WorkspaceModel;
   readonly taskRecordById: (taskId: string) => TTaskRecord | undefined;
   readonly hasTask: (taskId: string) => boolean;
@@ -21,133 +21,150 @@ interface TaskPaneSelectionActionsOptions<TTaskRecord extends TaskRecordLike> {
   readonly markDirty: () => void;
 }
 
-export class TaskPaneSelectionActions<TTaskRecord extends TaskRecordLike> {
-  constructor(private readonly options: TaskPaneSelectionActionsOptions<TTaskRecord>) {}
+export interface TaskPaneSelectionActions {
+  syncTaskPaneSelectionFocus(): void;
+  syncTaskPaneSelection(): void;
+  syncTaskPaneRepositorySelection(): void;
+  focusDraftComposer(): void;
+  focusTaskComposer(taskId: string): void;
+  selectTaskById(taskId: string): void;
+  selectRepositoryById(repositoryId: string): void;
+}
 
-  syncTaskPaneSelectionFocus(): void {
+export function createTaskPaneSelectionActions<TTaskRecord extends TaskRecordLike>(
+  options: TaskPaneSelectionActionsOptions<TTaskRecord>,
+): TaskPaneSelectionActions {
+  function syncTaskPaneSelectionFocus(): void {
     const hasTaskSelection =
-      this.options.workspace.taskPaneSelectedTaskId !== null &&
-      this.options.hasTask(this.options.workspace.taskPaneSelectedTaskId);
+      options.workspace.taskPaneSelectedTaskId !== null &&
+      options.hasTask(options.workspace.taskPaneSelectedTaskId);
     const hasRepositorySelection =
-      this.options.workspace.taskPaneSelectedRepositoryId !== null &&
-      this.options.hasRepository(this.options.workspace.taskPaneSelectedRepositoryId);
-    if (this.options.workspace.taskPaneSelectionFocus === 'task' && hasTaskSelection) {
+      options.workspace.taskPaneSelectedRepositoryId !== null &&
+      options.hasRepository(options.workspace.taskPaneSelectedRepositoryId);
+    if (options.workspace.taskPaneSelectionFocus === 'task' && hasTaskSelection) {
       return;
     }
-    if (this.options.workspace.taskPaneSelectionFocus === 'repository' && hasRepositorySelection) {
+    if (options.workspace.taskPaneSelectionFocus === 'repository' && hasRepositorySelection) {
       return;
     }
     if (hasTaskSelection) {
-      this.options.workspace.taskPaneSelectionFocus = 'task';
+      options.workspace.taskPaneSelectionFocus = 'task';
       return;
     }
     if (hasRepositorySelection) {
-      this.options.workspace.taskPaneSelectionFocus = 'repository';
+      options.workspace.taskPaneSelectionFocus = 'repository';
       return;
     }
-    this.options.workspace.taskPaneSelectionFocus = 'task';
+    options.workspace.taskPaneSelectionFocus = 'task';
   }
 
-  syncTaskPaneSelection(): void {
-    const scopedTaskIds = new Set(
-      this.options.selectedRepositoryTasks().map((task) => task.taskId),
-    );
+  function syncTaskPaneSelection(): void {
+    const scopedTaskIds = new Set(options.selectedRepositoryTasks().map((task) => task.taskId));
     if (
-      this.options.workspace.taskPaneSelectedTaskId !== null &&
-      !scopedTaskIds.has(this.options.workspace.taskPaneSelectedTaskId)
+      options.workspace.taskPaneSelectedTaskId !== null &&
+      !scopedTaskIds.has(options.workspace.taskPaneSelectedTaskId)
     ) {
-      this.options.workspace.taskPaneSelectedTaskId = null;
+      options.workspace.taskPaneSelectedTaskId = null;
     }
-    if (this.options.workspace.taskPaneSelectedTaskId === null) {
-      const scopedTasks = this.options.selectedRepositoryTasks();
-      this.options.workspace.taskPaneSelectedTaskId = scopedTasks[0]?.taskId ?? null;
+    if (options.workspace.taskPaneSelectedTaskId === null) {
+      const scopedTasks = options.selectedRepositoryTasks();
+      options.workspace.taskPaneSelectedTaskId = scopedTasks[0]?.taskId ?? null;
     }
-    this.syncTaskPaneSelectionFocus();
+    syncTaskPaneSelectionFocus();
     if (
-      this.options.workspace.taskEditorTarget.kind === 'task' &&
-      !scopedTaskIds.has(this.options.workspace.taskEditorTarget.taskId)
+      options.workspace.taskEditorTarget.kind === 'task' &&
+      !scopedTaskIds.has(options.workspace.taskEditorTarget.taskId)
     ) {
-      this.focusDraftComposer();
+      focusDraftComposer();
     }
   }
 
-  syncTaskPaneRepositorySelection(): void {
-    if (this.options.workspace.taskPaneSelectedRepositoryId !== null) {
-      const selectedRepository = this.options.repositoryById(
-        this.options.workspace.taskPaneSelectedRepositoryId,
+  function syncTaskPaneRepositorySelection(): void {
+    if (options.workspace.taskPaneSelectedRepositoryId !== null) {
+      const selectedRepository = options.repositoryById(
+        options.workspace.taskPaneSelectedRepositoryId,
       );
       if (selectedRepository === undefined || selectedRepository.archivedAt !== null) {
-        this.options.workspace.taskPaneSelectedRepositoryId = null;
+        options.workspace.taskPaneSelectedRepositoryId = null;
       }
     }
-    if (this.options.workspace.taskPaneSelectedRepositoryId === null) {
-      this.options.workspace.taskPaneSelectedRepositoryId =
-        this.options.activeRepositoryIds()[0] ?? null;
+    if (options.workspace.taskPaneSelectedRepositoryId === null) {
+      options.workspace.taskPaneSelectedRepositoryId = options.activeRepositoryIds()[0] ?? null;
     }
-    this.options.workspace.taskRepositoryDropdownOpen = false;
-    this.syncTaskPaneSelectionFocus();
-    this.syncTaskPaneSelection();
+    options.workspace.taskRepositoryDropdownOpen = false;
+    syncTaskPaneSelectionFocus();
+    syncTaskPaneSelection();
   }
 
-  focusDraftComposer(): void {
-    if (this.options.workspace.taskEditorTarget.kind === 'task') {
-      this.options.flushTaskComposerPersist(this.options.workspace.taskEditorTarget.taskId);
+  function focusDraftComposer(): void {
+    if (options.workspace.taskEditorTarget.kind === 'task') {
+      options.flushTaskComposerPersist(options.workspace.taskEditorTarget.taskId);
     }
-    this.options.workspace.taskEditorTarget = {
+    options.workspace.taskEditorTarget = {
       kind: 'draft',
     };
-    this.options.workspace.taskPaneSelectionFocus = 'task';
-    this.options.markDirty();
+    options.workspace.taskPaneSelectionFocus = 'task';
+    options.markDirty();
   }
 
-  focusTaskComposer(taskId: string): void {
-    if (!this.options.hasTask(taskId)) {
+  function focusTaskComposer(taskId: string): void {
+    if (!options.hasTask(taskId)) {
       return;
     }
     if (
-      this.options.workspace.taskEditorTarget.kind === 'task' &&
-      this.options.workspace.taskEditorTarget.taskId !== taskId
+      options.workspace.taskEditorTarget.kind === 'task' &&
+      options.workspace.taskEditorTarget.taskId !== taskId
     ) {
-      this.options.flushTaskComposerPersist(this.options.workspace.taskEditorTarget.taskId);
+      options.flushTaskComposerPersist(options.workspace.taskEditorTarget.taskId);
     }
-    this.options.workspace.taskEditorTarget = {
+    options.workspace.taskEditorTarget = {
       kind: 'task',
       taskId,
     };
-    this.options.workspace.taskPaneSelectedTaskId = taskId;
-    this.options.workspace.taskPaneSelectionFocus = 'task';
-    this.options.workspace.taskPaneNotice = null;
-    this.options.markDirty();
+    options.workspace.taskPaneSelectedTaskId = taskId;
+    options.workspace.taskPaneSelectionFocus = 'task';
+    options.workspace.taskPaneNotice = null;
+    options.markDirty();
   }
 
-  selectTaskById(taskId: string): void {
-    const taskRecord = this.options.taskRecordById(taskId);
+  function selectTaskById(taskId: string): void {
+    const taskRecord = options.taskRecordById(taskId);
     if (taskRecord === undefined) {
       return;
     }
-    this.options.workspace.taskPaneSelectedTaskId = taskId;
-    this.options.workspace.taskPaneSelectionFocus = 'task';
-    if (taskRecord.repositoryId !== null && this.options.hasRepository(taskRecord.repositoryId)) {
-      this.options.workspace.taskPaneSelectedRepositoryId = taskRecord.repositoryId;
+    options.workspace.taskPaneSelectedTaskId = taskId;
+    options.workspace.taskPaneSelectionFocus = 'task';
+    if (taskRecord.repositoryId !== null && options.hasRepository(taskRecord.repositoryId)) {
+      options.workspace.taskPaneSelectedRepositoryId = taskRecord.repositoryId;
     }
-    this.focusTaskComposer(taskId);
+    focusTaskComposer(taskId);
   }
 
-  selectRepositoryById(repositoryId: string): void {
-    if (!this.options.hasRepository(repositoryId)) {
+  function selectRepositoryById(repositoryId: string): void {
+    if (!options.hasRepository(repositoryId)) {
       return;
     }
-    if (this.options.workspace.taskEditorTarget.kind === 'task') {
-      this.options.flushTaskComposerPersist(this.options.workspace.taskEditorTarget.taskId);
+    if (options.workspace.taskEditorTarget.kind === 'task') {
+      options.flushTaskComposerPersist(options.workspace.taskEditorTarget.taskId);
     }
-    this.options.workspace.taskPaneSelectedRepositoryId = repositoryId;
-    this.options.workspace.taskRepositoryDropdownOpen = false;
-    this.options.workspace.taskPaneSelectionFocus = 'repository';
-    this.options.workspace.taskEditorTarget = {
+    options.workspace.taskPaneSelectedRepositoryId = repositoryId;
+    options.workspace.taskRepositoryDropdownOpen = false;
+    options.workspace.taskPaneSelectionFocus = 'repository';
+    options.workspace.taskEditorTarget = {
       kind: 'draft',
     };
-    this.syncTaskPaneSelection();
-    this.options.workspace.taskPaneNotice = null;
-    this.options.markDirty();
+    syncTaskPaneSelection();
+    options.workspace.taskPaneNotice = null;
+    options.markDirty();
   }
+
+  return {
+    syncTaskPaneSelectionFocus,
+    syncTaskPaneSelection,
+    syncTaskPaneRepositorySelection,
+    focusDraftComposer,
+    focusTaskComposer,
+    selectTaskById,
+    selectRepositoryById,
+  };
 }

package/src/services/task-planning-hydration.ts

@@ -14,7 +14,7 @@ interface TaskPlanningHydrationServiceControlPlane<
   listTasks(limit: number): Promise<readonly TTaskRecord[]>;
 }
 
-interface TaskPlanningHydrationServiceOptions<
+export interface TaskPlanningHydrationServiceOptions<
   TRepositoryRecord extends RepositoryRecordLike,
   TTaskRecord extends TaskRecordLike,
 > {
@@ -32,27 +32,33 @@ interface TaskPlanningHydrationServiceOptions<
   readonly taskLimit: number;
 }
 
-export class TaskPlanningHydrationService<
+export interface TaskPlanningHydrationService {
+  hydrate(): Promise<void>;
+}
+
+export function createTaskPlanningHydrationService<
   TRepositoryRecord extends RepositoryRecordLike,
   TTaskRecord extends TaskRecordLike,
-> {
-  constructor(
-    private readonly options: TaskPlanningHydrationServiceOptions<TRepositoryRecord, TTaskRecord>,
-  ) {}
-
-  async hydrate(): Promise<void> {
-    this.options.clearRepositories();
-    for (const repository of await this.options.controlPlaneService.listRepositories()) {
-      this.options.setRepository(repository);
+>(
+  options: TaskPlanningHydrationServiceOptions<TRepositoryRecord, TTaskRecord>,
+): TaskPlanningHydrationService {
+  async function hydrate(): Promise<void> {
+    options.clearRepositories();
+    for (const repository of await options.controlPlaneService.listRepositories()) {
+      options.setRepository(repository);
     }
-    this.options.syncTaskPaneRepositorySelection();
+    options.syncTaskPaneRepositorySelection();
 
-    this.options.clearTasks();
-    for (const task of await this.options.controlPlaneService.listTasks(this.options.taskLimit)) {
-      this.options.setTask(task);
+    options.clearTasks();
+    for (const task of await options.controlPlaneService.listTasks(options.taskLimit)) {
+      options.setTask(task);
     }
-    this.options.syncTaskPaneSelection();
-    this.options.syncTaskPaneRepositorySelection();
-    this.options.markDirty();
+    options.syncTaskPaneSelection();
+    options.syncTaskPaneRepositorySelection();
+    options.markDirty();
   }
+
+  return {
+    hydrate,
+  };
 }

package/src/services/task-planning-observed-events.ts

@@ -1,5 +1,3 @@
-import type { StreamObservedEvent } from '../control-plane/stream-protocol.ts';
-
 interface RepositoryRecordLike {
   readonly repositoryId: string;
   readonly archivedAt: string | null;
@@ -9,13 +7,29 @@ interface TaskRecordLike {
   readonly taskId: string;
 }
 
-interface TaskPlanningObservedEventsOptions<
+interface TaskPlanningSyncedProjectionState<
+  TRepositoryRecord extends RepositoryRecordLike,
+  TTaskRecord extends TaskRecordLike,
+> {
+  readonly repositoriesById: Readonly<Record<string, TRepositoryRecord>>;
+  readonly tasksById: Readonly<Record<string, TTaskRecord>>;
+}
+
+interface TaskPlanningSyncedProjectionInput<
+  TRepositoryRecord extends RepositoryRecordLike,
+  TTaskRecord extends TaskRecordLike,
+> {
+  readonly changed: boolean;
+  readonly state: TaskPlanningSyncedProjectionState<TRepositoryRecord, TTaskRecord>;
+  readonly removedTaskIds: readonly string[];
+  readonly upsertedRepositoryIds: readonly string[];
+  readonly upsertedTaskIds: readonly string[];
+}
+
+interface TaskPlanningSyncedProjectionOptions<
   TRepositoryRecord extends RepositoryRecordLike,
   TTaskRecord extends TaskRecordLike,
 > {
-  readonly parseRepositoryRecord: (value: unknown) => TRepositoryRecord | null;
-  readonly parseTaskRecord: (value: unknown) => TTaskRecord | null;
-  readonly getRepository: (repositoryId: string) => TRepositoryRecord | undefined;
   readonly setRepository: (repositoryId: string, repository: TRepositoryRecord) => void;
   readonly setTask: (task: TTaskRecord) => void;
   readonly deleteTask: (taskId: string) => boolean;
@@ -24,66 +38,50 @@ interface TaskPlanningObservedEventsOptions<
   readonly markDirty: () => void;
 }
 
-export class TaskPlanningObservedEvents<
+export class TaskPlanningSyncedProjection<
   TRepositoryRecord extends RepositoryRecordLike,
   TTaskRecord extends TaskRecordLike,
 > {
   constructor(
-    private readonly options: TaskPlanningObservedEventsOptions<TRepositoryRecord, TTaskRecord>,
+    private readonly options: TaskPlanningSyncedProjectionOptions<TRepositoryRecord, TTaskRecord>,
   ) {}
 
-  apply(observed: StreamObservedEvent): void {
-    if (observed.type === 'repository-upserted' || observed.type === 'repository-updated') {
-      const repository = this.options.parseRepositoryRecord(observed.repository);
-      if (repository !== null) {
-        this.options.setRepository(repository.repositoryId, repository);
-        this.options.syncTaskPaneRepositorySelection();
-        this.options.markDirty();
-      }
+  apply(reduction: TaskPlanningSyncedProjectionInput<TRepositoryRecord, TTaskRecord>): void {
+    if (!reduction.changed) {
       return;
     }
-    if (observed.type === 'repository-archived') {
-      const repository = this.options.getRepository(observed.repositoryId);
-      if (repository !== undefined) {
-        this.options.setRepository(observed.repositoryId, {
-          ...repository,
-          archivedAt: observed.ts,
-        });
-        this.options.syncTaskPaneRepositorySelection();
-        this.options.markDirty();
+
+    let repositoriesChanged = false;
+    for (const repositoryId of reduction.upsertedRepositoryIds) {
+      const repository = reduction.state.repositoriesById[repositoryId];
+      if (repository === undefined) {
+        continue;
       }
-      return;
+      this.options.setRepository(repositoryId, repository);
+      repositoriesChanged = true;
     }
-    if (observed.type === 'task-created' || observed.type === 'task-updated') {
-      const task = this.options.parseTaskRecord(observed.task);
-      if (task !== null) {
-        this.options.setTask(task);
-        this.options.syncTaskPaneSelection();
-        this.options.markDirty();
-      }
-      return;
+    if (repositoriesChanged) {
+      this.options.syncTaskPaneRepositorySelection();
+      this.options.markDirty();
     }
-    if (observed.type === 'task-deleted') {
-      if (this.options.deleteTask(observed.taskId)) {
-        this.options.syncTaskPaneSelection();
-        this.options.markDirty();
+
+    let tasksChanged = false;
+    for (const taskId of reduction.removedTaskIds) {
+      if (this.options.deleteTask(taskId)) {
+        tasksChanged = true;
       }
-      return;
     }
-    if (observed.type === 'task-reordered') {
-      let changed = false;
-      for (const value of observed.tasks) {
-        const task = this.options.parseTaskRecord(value);
-        if (task === null) {
-          continue;
-        }
-        this.options.setTask(task);
-        changed = true;
-      }
-      if (changed) {
-        this.options.syncTaskPaneSelection();
-        this.options.markDirty();
+    for (const taskId of reduction.upsertedTaskIds) {
+      const task = reduction.state.tasksById[taskId];
+      if (task === undefined) {
+        continue;
       }
+      this.options.setTask(task);
+      tasksChanged = true;
+    }
+    if (tasksChanged) {
+      this.options.syncTaskPaneSelection();
+      this.options.markDirty();
     }
   }
 }

package/src/services/workspace-observed-events.ts

@@ -1,5 +1,3 @@
-import type { StreamObservedEvent } from '../control-plane/stream-protocol.ts';
-
 interface DirectoryRecordLike {
   readonly directoryId: string;
 }
@@ -15,99 +13,104 @@ interface WorkspaceObservedApplyResult {
   readonly removedDirectoryIds: readonly string[];
 }
 
-interface WorkspaceObservedEventsOptions<
+interface WorkspaceSyncedProjectionState<
+  TDirectoryRecord extends DirectoryRecordLike,
+  TConversationRecord extends ConversationRecordLike,
+> {
+  readonly directoriesById: Readonly<Record<string, TDirectoryRecord>>;
+  readonly conversationsById: Readonly<Record<string, TConversationRecord>>;
+}
+
+interface WorkspaceSyncedProjectionInput<
+  TDirectoryRecord extends DirectoryRecordLike,
+  TConversationRecord extends ConversationRecordLike,
+> {
+  readonly changed: boolean;
+  readonly state: WorkspaceSyncedProjectionState<TDirectoryRecord, TConversationRecord>;
+  readonly removedConversationIds: readonly string[];
+  readonly removedDirectoryIds: readonly string[];
+  readonly upsertedDirectoryIds: readonly string[];
+  readonly upsertedConversationIds: readonly string[];
+}
+
+interface WorkspaceSyncedProjectionOptions<
   TDirectoryRecord extends DirectoryRecordLike,
   TConversationRecord extends ConversationRecordLike,
 > {
-  readonly parseDirectoryRecord: (value: unknown) => TDirectoryRecord | null;
-  readonly parseConversationRecord: (value: unknown) => TConversationRecord | null;
   readonly setDirectory: (directoryId: string, directory: TDirectoryRecord) => void;
   readonly deleteDirectory: (directoryId: string) => boolean;
   readonly deleteDirectoryGitState: (directoryId: string) => void;
   readonly syncGitStateWithDirectories: () => void;
   readonly upsertConversationFromPersistedRecord: (record: TConversationRecord) => void;
   readonly removeConversation: (sessionId: string) => boolean;
-  readonly orderedConversationIds: () => readonly string[];
-  readonly conversationDirectoryId: (sessionId: string) => string | null;
 }
 
-export class WorkspaceObservedEvents<
+export class WorkspaceSyncedProjection<
   TDirectoryRecord extends DirectoryRecordLike,
   TConversationRecord extends ConversationRecordLike,
 > {
   constructor(
-    private readonly options: WorkspaceObservedEventsOptions<TDirectoryRecord, TConversationRecord>,
+    private readonly options: WorkspaceSyncedProjectionOptions<
+      TDirectoryRecord,
+      TConversationRecord
+    >,
   ) {}
 
-  apply(observed: StreamObservedEvent): WorkspaceObservedApplyResult {
-    if (observed.type === 'directory-upserted') {
-      const directory = this.options.parseDirectoryRecord(observed.directory);
-      if (directory === null) {
-        return {
-          changed: false,
-          removedConversationIds: [],
-          removedDirectoryIds: [],
-        };
-      }
-      this.options.setDirectory(directory.directoryId, directory);
-      this.options.syncGitStateWithDirectories();
+  apply(
+    reduction: WorkspaceSyncedProjectionInput<TDirectoryRecord, TConversationRecord>,
+  ): WorkspaceObservedApplyResult {
+    if (!reduction.changed) {
       return {
-        changed: true,
+        changed: false,
         removedConversationIds: [],
         removedDirectoryIds: [],
       };
     }
 
-    if (observed.type === 'directory-archived') {
-      const removedConversationIds: string[] = [];
-      for (const sessionId of this.options.orderedConversationIds()) {
-        if (this.options.conversationDirectoryId(sessionId) !== observed.directoryId) {
-          continue;
-        }
-        if (this.options.removeConversation(sessionId)) {
-          removedConversationIds.push(sessionId);
-        }
+    let changed = false;
+    const removedConversationIds: string[] = [];
+    const removedDirectoryIds: string[] = [];
+
+    for (const directoryId of reduction.upsertedDirectoryIds) {
+      const directory = reduction.state.directoriesById[directoryId];
+      if (directory === undefined) {
+        continue;
       }
-      const removedDirectory = this.options.deleteDirectory(observed.directoryId);
-      this.options.deleteDirectoryGitState(observed.directoryId);
-      this.options.syncGitStateWithDirectories();
-      return {
-        changed: removedDirectory || removedConversationIds.length > 0,
-        removedConversationIds,
-        removedDirectoryIds: removedDirectory ? [observed.directoryId] : [],
-      };
+      this.options.setDirectory(directoryId, directory);
+      changed = true;
     }
-
-    if (observed.type === 'conversation-created' || observed.type === 'conversation-updated') {
-      const conversation = this.options.parseConversationRecord(observed.conversation);
-      if (conversation === null) {
-        return {
-          changed: false,
-          removedConversationIds: [],
-          removedDirectoryIds: [],
-        };
+    for (const conversationId of reduction.upsertedConversationIds) {
+      const conversation = reduction.state.conversationsById[conversationId];
+      if (conversation === undefined) {
+        continue;
       }
       this.options.upsertConversationFromPersistedRecord(conversation);
-      return {
-        changed: true,
-        removedConversationIds: [],
-        removedDirectoryIds: [],
-      };
+      changed = true;
     }
 
-    if (observed.type === 'conversation-archived' || observed.type === 'conversation-deleted') {
-      const removed = this.options.removeConversation(observed.conversationId);
-      return {
-        changed: removed,
-        removedConversationIds: removed ? [observed.conversationId] : [],
-        removedDirectoryIds: [],
-      };
+    for (const sessionId of reduction.removedConversationIds) {
+      if (!this.options.removeConversation(sessionId)) {
+        continue;
+      }
+      removedConversationIds.push(sessionId);
+      changed = true;
+    }
+
+    for (const directoryId of reduction.removedDirectoryIds) {
+      if (this.options.deleteDirectory(directoryId)) {
+        removedDirectoryIds.push(directoryId);
+        changed = true;
+      }
+      this.options.deleteDirectoryGitState(directoryId);
+    }
+    if (reduction.upsertedDirectoryIds.length > 0 || reduction.removedDirectoryIds.length > 0) {
+      this.options.syncGitStateWithDirectories();
     }
 
     return {
-      changed: false,
-      removedConversationIds: [],
-      removedDirectoryIds: [],
+      changed,
+      removedConversationIds,
+      removedDirectoryIds,
     };
   }
 }