@jmoyers/harness 0.1.11 → 0.1.20

package/src/services/control-plane.ts

@@ -8,13 +8,18 @@ import {
   parseSessionSummaryRecord,
 } from '../control-plane/session-summary.ts';
 import {
+  type ControlPlaneConversationRecord,
+  type ControlPlaneDirectoryGitStatusRecord,
+  type ControlPlaneDirectoryRecord,
+  type ControlPlaneRepositoryRecord,
+  type ControlPlaneTaskRecord,
   parseConversationRecord,
   parseDirectoryGitStatusRecord,
   parseDirectoryRecord,
   parseRepositoryRecord,
   parseSessionControllerRecord,
   parseTaskRecord,
-} from '../mux/live-mux/control-plane-records.ts';
+} from '../core/contracts/records.ts';
 
 interface ControlPlaneScope {
   readonly tenantId: string;
@@ -26,13 +31,6 @@ interface ControlPlaneCommandClient {
   sendCommand(command: StreamCommand): Promise<Record<string, unknown>>;
 }
 
-type ControlPlaneRepositoryRecord = NonNullable<ReturnType<typeof parseRepositoryRecord>>;
-type ControlPlaneTaskRecord = NonNullable<ReturnType<typeof parseTaskRecord>>;
-type ControlPlaneDirectoryRecord = NonNullable<ReturnType<typeof parseDirectoryRecord>>;
-type ControlPlaneConversationRecord = NonNullable<ReturnType<typeof parseConversationRecord>>;
-type ControlPlaneDirectoryGitStatusRecord = NonNullable<
-  ReturnType<typeof parseDirectoryGitStatusRecord>
->;
 type ControlPlaneSessionControllerRecord = NonNullable<
   ReturnType<typeof parseSessionControllerRecord>
 >;
@@ -267,19 +265,19 @@ export class ControlPlaneService {
     };
   }
 
-  async archiveConversation(conversationId: string): Promise<void> {
+  archiveConversation = async (conversationId: string): Promise<void> => {
     await this.client.sendCommand({
       type: 'conversation.archive',
       conversationId,
     });
-  }
+  };
 
-  async archiveDirectory(directoryId: string): Promise<void> {
+  archiveDirectory = async (directoryId: string): Promise<void> => {
     await this.client.sendCommand({
       type: 'directory.archive',
       directoryId,
     });
-  }
+  };
 
   async attachPty(input: { sessionId: string; sinceCursor: number }): Promise<void> {
     await this.client.sendCommand({
@@ -349,12 +347,12 @@ export class ControlPlaneService {
     await this.client.sendCommand(command);
   }
 
-  async closePtySession(sessionId: string): Promise<void> {
+  closePtySession = async (sessionId: string): Promise<void> => {
     await this.client.sendCommand({
       type: 'pty.close',
       sessionId,
     });
-  }
+  };
 
   async getSessionStatus(sessionId: string): Promise<ControlPlaneSessionSummary | null> {
     const result = await this.client.sendCommand({
@@ -384,12 +382,12 @@ export class ControlPlaneService {
     return parseSessionSummaryList(result['sessions']);
   }
 
-  async removeSession(sessionId: string): Promise<void> {
+  removeSession = async (sessionId: string): Promise<void> => {
     await this.client.sendCommand({
       type: 'session.remove',
       sessionId,
     });
-  }
+  };
 
   async claimSession(input: {
     sessionId: string;
@@ -461,19 +459,28 @@ export class ControlPlaneService {
   }
 
   async createTask(input: {
-    repositoryId: string;
-    title: string;
-    description: string;
+    repositoryId?: string;
+    projectId?: string;
+    title?: string | null;
+    body: string;
   }): Promise<ControlPlaneTaskRecord> {
-    const result = await this.client.sendCommand({
+    const command: StreamCommand = {
       type: 'task.create',
       tenantId: this.scope.tenantId,
       userId: this.scope.userId,
       workspaceId: this.scope.workspaceId,
-      repositoryId: input.repositoryId,
-      title: input.title,
-      description: input.description,
-    });
+      body: input.body,
+    };
+    if (input.repositoryId !== undefined) {
+      command.repositoryId = input.repositoryId;
+    }
+    if (input.projectId !== undefined) {
+      command.projectId = input.projectId;
+    }
+    if (input.title !== undefined) {
+      command.title = input.title;
+    }
+    const result = await this.client.sendCommand(command);
     return this.parseTaskFromResult(
       result,
       'control-plane task.create returned malformed task record',
@@ -482,17 +489,28 @@ export class ControlPlaneService {
 
   async updateTask(input: {
     taskId: string;
-    repositoryId: string | null;
-    title: string;
-    description: string;
+    repositoryId?: string | null;
+    projectId?: string | null;
+    title?: string | null;
+    body?: string;
   }): Promise<ControlPlaneTaskRecord> {
-    const result = await this.client.sendCommand({
+    const command: StreamCommand = {
       type: 'task.update',
       taskId: input.taskId,
-      repositoryId: input.repositoryId,
-      title: input.title,
-      description: input.description,
-    });
+    };
+    if (input.repositoryId !== undefined) {
+      command.repositoryId = input.repositoryId;
+    }
+    if (input.projectId !== undefined) {
+      command.projectId = input.projectId;
+    }
+    if (input.title !== undefined) {
+      command.title = input.title;
+    }
+    if (input.body !== undefined) {
+      command.body = input.body;
+    }
+    const result = await this.client.sendCommand(command);
     return this.parseTaskFromResult(
       result,
       'control-plane task.update returned malformed task record',

package/src/services/conversation-lifecycle.ts

@@ -1,36 +1,41 @@
 import {
-  ConversationStartupHydrationService,
+  createConversationStartupHydrationService,
+  type ConversationStartupHydrationService,
   type ConversationStartupHydrationServiceOptions,
   type SessionSummaryLike,
 } from './conversation-startup-hydration.ts';
 import {
-  RuntimeConversationStarter,
+  createRuntimeConversationStarter,
+  type RuntimeConversationStarter,
   type RuntimeConversationStarterConversationRecord,
   type RuntimeConversationStarterOptions,
 } from './runtime-conversation-starter.ts';
 import {
-  RuntimeConversationActivation,
+  createRuntimeConversationActivation,
+  type RuntimeConversationActivation,
   type RuntimeConversationActivationOptions,
 } from './runtime-conversation-activation.ts';
 import {
-  RuntimeConversationActions,
+  createRuntimeConversationActions,
+  type RuntimeConversationActions,
   type RuntimeConversationActionsOptions,
 } from './runtime-conversation-actions.ts';
 import {
-  RuntimeConversationTitleEditService,
+  createRuntimeConversationTitleEditService,
   type RuntimeConversationTitleEditServiceOptions,
 } from './runtime-conversation-title-edit.ts';
 import {
-  RuntimeStreamSubscriptions,
+  createRuntimeStreamSubscriptions,
   type RuntimeStreamSubscriptionsOptions,
 } from './runtime-stream-subscriptions.ts';
 import {
-  StartupPersistedConversationQueueService,
+  createStartupPersistedConversationQueueService,
+  type StartupPersistedConversationQueueService,
   type StartupPersistedConversationQueueServiceOptions,
   type StartupQueueConversationRecord,
 } from './startup-persisted-conversation-queue.ts';
 
-interface ConversationLifecycleOptions<
+export interface ConversationLifecycleOptions<
   TConversation extends RuntimeConversationStarterConversationRecord &
     StartupQueueConversationRecord & { title: string },
   TSessionSummary extends SessionSummaryLike,
@@ -57,120 +62,146 @@ interface ConversationLifecycleOptions<
   readonly titleEdit: RuntimeConversationTitleEditServiceOptions<TConversation>;
 }
 
-export class ConversationLifecycle<
+export interface ConversationLifecycle<TConversation> {
+  subscribeConversationEvents(sessionId: string): Promise<void>;
+  unsubscribeConversationEvents(sessionId: string): Promise<void>;
+  subscribeTaskPlanningEvents(afterCursor: number | null): Promise<void>;
+  unsubscribeTaskPlanningEvents(): Promise<void>;
+  startConversation(sessionId: string): Promise<TConversation>;
+  activateConversation(
+    sessionId: string,
+    options?: { readonly signal?: AbortSignal },
+  ): Promise<void>;
+  createAndActivateConversationInDirectory(directoryId: string, agentType: string): Promise<void>;
+  openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void>;
+  takeoverConversation(sessionId: string): Promise<void>;
+  scheduleConversationTitlePersist(): void;
+  stopConversationTitleEdit(persistPending: boolean): void;
+  beginConversationTitleEdit(conversationId: string): void;
+  clearConversationTitleEditTimer(): void;
+  hydrateConversationList(): Promise<void>;
+  queuePersistedConversationsInBackground(activeSessionId: string | null): number;
+}
+
+export function createConversationLifecycle<
   TConversation extends RuntimeConversationStarterConversationRecord &
     StartupQueueConversationRecord & { title: string },
   TSessionSummary extends SessionSummaryLike,
   TControllerRecord,
-> {
-  private readonly streamSubscriptions: RuntimeStreamSubscriptions;
-  private readonly starter: RuntimeConversationStarter<TConversation, TSessionSummary>;
-  private readonly startupHydration: ConversationStartupHydrationService<TSessionSummary>;
-  private readonly startupQueue: StartupPersistedConversationQueueService<TConversation>;
-  private readonly activation: RuntimeConversationActivation;
-  private readonly actions: RuntimeConversationActions<TControllerRecord>;
-  private readonly titleEdit: RuntimeConversationTitleEditService<TConversation>;
-
-  constructor(
-    options: ConversationLifecycleOptions<TConversation, TSessionSummary, TControllerRecord>,
-  ) {
-    this.streamSubscriptions = new RuntimeStreamSubscriptions(options.streamSubscriptions);
-    this.starter = new RuntimeConversationStarter({
-      ...options.starter,
-      subscribeConversationEvents: async (sessionId) => {
-        await this.subscribeConversationEvents(sessionId);
-      },
-    });
-    this.startupHydration = new ConversationStartupHydrationService({
-      ...options.startupHydration,
-      subscribeConversationEvents: async (sessionId) => {
-        await this.subscribeConversationEvents(sessionId);
-      },
-    });
-    this.startupQueue = new StartupPersistedConversationQueueService({
-      ...options.startupQueue,
-      startConversation: async (sessionId) => {
-        await this.startConversation(sessionId);
-      },
-    });
-    this.activation = new RuntimeConversationActivation({
-      ...options.activation,
-      startConversation: async (sessionId) => {
-        await this.startConversation(sessionId);
-      },
-    });
-    this.actions = new RuntimeConversationActions({
-      ...options.actions,
-      startConversation: async (sessionId) => {
-        await this.startConversation(sessionId);
-      },
-      activateConversation: async (sessionId) => {
-        await this.activateConversation(sessionId);
-      },
-    });
-    this.titleEdit = new RuntimeConversationTitleEditService(options.titleEdit);
-  }
+>(
+  options: ConversationLifecycleOptions<TConversation, TSessionSummary, TControllerRecord>,
+): ConversationLifecycle<TConversation> {
+  const streamSubscriptions = createRuntimeStreamSubscriptions(options.streamSubscriptions);
+  let starter: RuntimeConversationStarter<TConversation>;
+  let activation: RuntimeConversationActivation;
+  let startupHydration: ConversationStartupHydrationService;
+  let startupQueue: StartupPersistedConversationQueueService;
+  let actions: RuntimeConversationActions;
+  const titleEdit = createRuntimeConversationTitleEditService(options.titleEdit);
 
-  async subscribeConversationEvents(sessionId: string): Promise<void> {
-    await this.streamSubscriptions.subscribeConversationEvents(sessionId);
+  async function subscribeConversationEvents(sessionId: string): Promise<void> {
+    await streamSubscriptions.subscribeConversationEvents(sessionId);
   }
 
-  async unsubscribeConversationEvents(sessionId: string): Promise<void> {
-    await this.streamSubscriptions.unsubscribeConversationEvents(sessionId);
+  async function unsubscribeConversationEvents(sessionId: string): Promise<void> {
+    await streamSubscriptions.unsubscribeConversationEvents(sessionId);
   }
 
-  async subscribeTaskPlanningEvents(afterCursor: number | null): Promise<void> {
-    await this.streamSubscriptions.subscribeTaskPlanningEvents(afterCursor);
+  async function subscribeTaskPlanningEvents(afterCursor: number | null): Promise<void> {
+    await streamSubscriptions.subscribeTaskPlanningEvents(afterCursor);
   }
 
-  async unsubscribeTaskPlanningEvents(): Promise<void> {
-    await this.streamSubscriptions.unsubscribeTaskPlanningEvents();
+  async function unsubscribeTaskPlanningEvents(): Promise<void> {
+    await streamSubscriptions.unsubscribeTaskPlanningEvents();
   }
 
-  async startConversation(sessionId: string): Promise<TConversation> {
-    return await this.starter.startConversation(sessionId);
+  async function startConversation(sessionId: string): Promise<TConversation> {
+    return await starter.startConversation(sessionId);
   }
 
-  async activateConversation(sessionId: string): Promise<void> {
-    await this.activation.activateConversation(sessionId);
+  async function activateConversation(
+    sessionId: string,
+    activateOptions: { readonly signal?: AbortSignal } = {},
+  ): Promise<void> {
+    await activation.activateConversation(sessionId, activateOptions);
   }
 
-  async createAndActivateConversationInDirectory(
+  async function createAndActivateConversationInDirectory(
     directoryId: string,
     agentType: string,
   ): Promise<void> {
-    await this.actions.createAndActivateConversationInDirectory(directoryId, agentType);
+    await actions.createAndActivateConversationInDirectory(directoryId, agentType);
   }
 
-  async openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void> {
-    await this.actions.openOrCreateCritiqueConversationInDirectory(directoryId);
+  async function openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void> {
+    await actions.openOrCreateCritiqueConversationInDirectory(directoryId);
   }
 
-  async takeoverConversation(sessionId: string): Promise<void> {
-    await this.actions.takeoverConversation(sessionId);
+  async function takeoverConversation(sessionId: string): Promise<void> {
+    await actions.takeoverConversation(sessionId);
   }
 
-  scheduleConversationTitlePersist(): void {
-    this.titleEdit.schedulePersist();
+  function scheduleConversationTitlePersist(): void {
+    titleEdit.schedulePersist();
   }
 
-  stopConversationTitleEdit(persistPending: boolean): void {
-    this.titleEdit.stop(persistPending);
+  function stopConversationTitleEdit(persistPending: boolean): void {
+    titleEdit.stop(persistPending);
   }
 
-  beginConversationTitleEdit(conversationId: string): void {
-    this.titleEdit.begin(conversationId);
+  function beginConversationTitleEdit(conversationId: string): void {
+    titleEdit.begin(conversationId);
   }
 
-  clearConversationTitleEditTimer(): void {
-    this.titleEdit.clearCurrentTimer();
+  function clearConversationTitleEditTimer(): void {
+    titleEdit.clearCurrentTimer();
   }
 
-  async hydrateConversationList(): Promise<void> {
-    await this.startupHydration.hydrateConversationList();
+  async function hydrateConversationList(): Promise<void> {
+    await startupHydration.hydrateConversationList();
   }
 
-  queuePersistedConversationsInBackground(activeSessionId: string | null): number {
-    return this.startupQueue.queuePersistedConversationsInBackground(activeSessionId);
+  function queuePersistedConversationsInBackground(activeSessionId: string | null): number {
+    return startupQueue.queuePersistedConversationsInBackground(activeSessionId);
   }
+
+  starter = createRuntimeConversationStarter({
+    ...options.starter,
+    subscribeConversationEvents,
+  });
+  startupHydration = createConversationStartupHydrationService({
+    ...options.startupHydration,
+    subscribeConversationEvents,
+  });
+  startupQueue = createStartupPersistedConversationQueueService({
+    ...options.startupQueue,
+    startConversation,
+  });
+  activation = createRuntimeConversationActivation({
+    ...options.activation,
+    startConversation,
+  });
+  actions = createRuntimeConversationActions({
+    ...options.actions,
+    startConversation,
+    activateConversation,
+  });
+
+  return {
+    subscribeConversationEvents,
+    unsubscribeConversationEvents,
+    subscribeTaskPlanningEvents,
+    unsubscribeTaskPlanningEvents,
+    startConversation,
+    activateConversation,
+    createAndActivateConversationInDirectory,
+    openOrCreateCritiqueConversationInDirectory,
+    takeoverConversation,
+    scheduleConversationTitlePersist,
+    stopConversationTitleEdit,
+    beginConversationTitleEdit,
+    clearConversationTitleEditTimer,
+    hydrateConversationList,
+    queuePersistedConversationsInBackground,
+  };
 }

package/src/services/conversation-startup-hydration.ts

@@ -19,24 +19,28 @@ export interface ConversationStartupHydrationServiceOptions<
   readonly subscribeConversationEvents: (sessionId: string) => Promise<void>;
 }
 
-export class ConversationStartupHydrationService<TSessionSummary extends SessionSummaryLike> {
-  constructor(
-    private readonly options: ConversationStartupHydrationServiceOptions<TSessionSummary>,
-  ) {}
+export interface ConversationStartupHydrationService {
+  hydrateConversationList(): Promise<void>;
+}
 
-  async hydrateConversationList(): Promise<void> {
-    const hydrateSpan = this.options.startHydrationSpan();
-    await this.options.hydrateDirectoryList();
+export function createConversationStartupHydrationService<
+  TSessionSummary extends SessionSummaryLike,
+>(
+  options: ConversationStartupHydrationServiceOptions<TSessionSummary>,
+): ConversationStartupHydrationService {
+  async function hydrateConversationList(): Promise<void> {
+    const hydrateSpan = options.startHydrationSpan();
+    await options.hydrateDirectoryList();
     let persistedCount = 0;
-    for (const directoryId of this.options.directoryIds()) {
-      persistedCount += await this.options.hydratePersistedConversationsForDirectory(directoryId);
+    for (const directoryId of options.directoryIds()) {
+      persistedCount += await options.hydratePersistedConversationsForDirectory(directoryId);
     }
 
-    const summaries = await this.options.listSessions();
+    const summaries = await options.listSessions();
     for (const summary of summaries) {
-      this.options.upsertFromSessionSummary(summary);
+      options.upsertFromSessionSummary(summary);
       if (summary.live) {
-        await this.options.subscribeConversationEvents(summary.sessionId);
+        await options.subscribeConversationEvents(summary.sessionId);
       }
     }
     hydrateSpan.end({
@@ -44,4 +48,8 @@ export class ConversationStartupHydrationService<TSessionSummary extends Session
       live: summaries.length,
     });
   }
+
+  return {
+    hydrateConversationList,
+  };
 }

package/src/services/directory-hydration.ts

@@ -8,7 +8,7 @@ interface DirectoryHydrationControlPlane<TDirectoryRecord extends DirectoryRecor
   upsertDirectory(input: { directoryId: string; path: string }): Promise<TDirectoryRecord>;
 }
 
-interface DirectoryHydrationServiceOptions<TDirectoryRecord extends DirectoryRecordLike> {
+export interface DirectoryHydrationServiceOptions<TDirectoryRecord extends DirectoryRecordLike> {
   readonly controlPlaneService: DirectoryHydrationControlPlane<TDirectoryRecord>;
   readonly resolveWorkspacePathForMux: (rawPath: string) => string;
   readonly clearDirectories: () => void;
@@ -18,32 +18,37 @@ interface DirectoryHydrationServiceOptions<TDirectoryRecord extends DirectoryRec
   readonly resolveActiveDirectoryId: () => string | null;
 }
 
-export class DirectoryHydrationService<TDirectoryRecord extends DirectoryRecordLike> {
-  constructor(private readonly options: DirectoryHydrationServiceOptions<TDirectoryRecord>) {}
+export interface DirectoryHydrationService {
+  hydrate(): Promise<void>;
+}
 
-  async hydrate(): Promise<void> {
-    const rows = await this.options.controlPlaneService.listDirectories();
-    this.options.clearDirectories();
+export function createDirectoryHydrationService<TDirectoryRecord extends DirectoryRecordLike>(
+  options: DirectoryHydrationServiceOptions<TDirectoryRecord>,
+): DirectoryHydrationService {
+  async function hydrate(): Promise<void> {
+    const rows = await options.controlPlaneService.listDirectories();
+    options.clearDirectories();
     for (const row of rows) {
-      const normalizedPath = this.options.resolveWorkspacePathForMux(row.path);
+      const normalizedPath = options.resolveWorkspacePathForMux(row.path);
       if (normalizedPath !== row.path) {
-        const repairedRecord = await this.options.controlPlaneService.upsertDirectory({
+        const repairedRecord = await options.controlPlaneService.upsertDirectory({
           directoryId: row.directoryId,
           path: normalizedPath,
         });
-        this.options.setDirectory(row.directoryId, repairedRecord);
+        options.setDirectory(row.directoryId, repairedRecord);
         continue;
       }
-      this.options.setDirectory(row.directoryId, row);
+      options.setDirectory(row.directoryId, row);
     }
-    if (!this.options.hasDirectory(this.options.persistedDirectory.directoryId)) {
-      this.options.setDirectory(
-        this.options.persistedDirectory.directoryId,
-        this.options.persistedDirectory,
-      );
+    if (!options.hasDirectory(options.persistedDirectory.directoryId)) {
+      options.setDirectory(options.persistedDirectory.directoryId, options.persistedDirectory);
     }
-    if (this.options.resolveActiveDirectoryId() === null) {
+    if (options.resolveActiveDirectoryId() === null) {
       throw new Error('no active directory available after hydrate');
     }
   }
+
+  return {
+    hydrate,
+  };
 }

package/src/services/event-persistence.ts

@@ -23,6 +23,10 @@ interface EventPersistenceOptions {
 const DEFAULT_FLUSH_DELAY_MS = 12;
 const DEFAULT_FLUSH_MAX_BATCH = 64;
 
+function shouldPersistEvent(event: NormalizedEventEnvelope): boolean {
+  return !(event.source === 'provider' && event.type === 'provider-text-delta');
+}
+
 export class EventPersistence {
   private readonly flushDelayMs: number;
   private readonly flushMaxBatch: number;
@@ -46,6 +50,9 @@ export class EventPersistence {
   }
 
   enqueue(event: NormalizedEventEnvelope): void {
+    if (!shouldPersistEvent(event)) {
+      return;
+    }
     this.pendingEvents.push(event);
     if (this.pendingEvents.length >= this.flushMaxBatch) {
       this.flush('immediate');