@jmoyers/harness 0.1.0

package/src/mux/live-mux/actions-conversation.ts

@@ -0,0 +1,344 @@
+interface ConversationStateLike {
+  readonly directoryId: string | null;
+  readonly live: boolean;
+}
+
+interface OpenNewThreadPromptOptions<TNewThreadPromptState> {
+  directoryId: string;
+  directoriesHas: (directoryId: string) => boolean;
+  clearAddDirectoryPrompt: () => void;
+  clearRepositoryPrompt: () => void;
+  hasConversationTitleEdit: boolean;
+  stopConversationTitleEdit: () => void;
+  clearConversationTitleEditClickState: () => void;
+  createNewThreadPromptState: (directoryId: string) => TNewThreadPromptState;
+  setNewThreadPrompt: (prompt: TNewThreadPromptState) => void;
+  markDirty: () => void;
+}
+
+export function openNewThreadPrompt<TNewThreadPromptState>(
+  options: OpenNewThreadPromptOptions<TNewThreadPromptState>,
+): void {
+  if (!options.directoriesHas(options.directoryId)) {
+    return;
+  }
+  options.clearAddDirectoryPrompt();
+  options.clearRepositoryPrompt();
+  if (options.hasConversationTitleEdit) {
+    options.stopConversationTitleEdit();
+  }
+  options.clearConversationTitleEditClickState();
+  options.setNewThreadPrompt(options.createNewThreadPromptState(options.directoryId));
+  options.markDirty();
+}
+
+interface CreateAndActivateConversationInDirectoryOptions<TAgentType> {
+  directoryId: string;
+  agentType: TAgentType;
+  createConversationId: () => string;
+  createConversationRecord: (
+    sessionId: string,
+    directoryId: string,
+    agentType: TAgentType,
+  ) => Promise<void>;
+  ensureConversation: (
+    sessionId: string,
+    seed: {
+      directoryId: string;
+      title: string;
+      agentType: string;
+      adapterState: Record<string, unknown>;
+    },
+  ) => void;
+  noteGitActivity: (directoryId: string) => void;
+  startConversation: (sessionId: string) => Promise<unknown>;
+  activateConversation: (sessionId: string) => Promise<unknown>;
+}
+
+export async function createAndActivateConversationInDirectory<TAgentType>(
+  options: CreateAndActivateConversationInDirectoryOptions<TAgentType>,
+): Promise<void> {
+  const sessionId = options.createConversationId();
+  const title = '';
+  await options.createConversationRecord(sessionId, options.directoryId, options.agentType);
+  options.ensureConversation(sessionId, {
+    directoryId: options.directoryId,
+    title,
+    agentType: String(options.agentType),
+    adapterState: {},
+  });
+  options.noteGitActivity(options.directoryId);
+  await options.startConversation(sessionId);
+  await options.activateConversation(sessionId);
+}
+
+interface OpenOrCreateCritiqueConversationInDirectoryOptions {
+  directoryId: string;
+  orderedConversationIds: () => readonly string[];
+  conversationById: (sessionId: string) => {
+    readonly directoryId: string | null;
+    readonly agentType: string;
+  } | null;
+  activateConversation: (sessionId: string) => Promise<unknown>;
+  createAndActivateCritiqueConversationInDirectory: (directoryId: string) => Promise<unknown>;
+}
+
+function isCritiqueAgentType(agentType: string): boolean {
+  return agentType.trim().toLowerCase() === 'critique';
+}
+
+export async function openOrCreateCritiqueConversationInDirectory(
+  options: OpenOrCreateCritiqueConversationInDirectoryOptions,
+): Promise<void> {
+  const existingConversationId =
+    options.orderedConversationIds().find((sessionId) => {
+      const conversation = options.conversationById(sessionId);
+      if (conversation === null) {
+        return false;
+      }
+      return (
+        conversation.directoryId === options.directoryId &&
+        isCritiqueAgentType(conversation.agentType)
+      );
+    }) ?? null;
+  if (existingConversationId !== null) {
+    await options.activateConversation(existingConversationId);
+    return;
+  }
+  await options.createAndActivateCritiqueConversationInDirectory(options.directoryId);
+}
+
+interface ArchiveConversationOptions {
+  sessionId: string;
+  conversations: ReadonlyMap<string, ConversationStateLike>;
+  closePtySession: (sessionId: string) => Promise<void>;
+  removeSession: (sessionId: string) => Promise<void>;
+  isSessionNotFoundError: (error: unknown) => boolean;
+  archiveConversationRecord: (sessionId: string) => Promise<void>;
+  isConversationNotFoundError: (error: unknown) => boolean;
+  unsubscribeConversationEvents: (sessionId: string) => Promise<void>;
+  removeConversationState: (sessionId: string) => void;
+  activeConversationId: string | null;
+  setActiveConversationId: (sessionId: string | null) => void;
+  orderedConversationIds: () => readonly string[];
+  conversationDirectoryId: (sessionId: string) => string | null;
+  resolveActiveDirectoryId: () => string | null;
+  enterProjectPane: (directoryId: string) => void;
+  activateConversation: (sessionId: string) => Promise<unknown>;
+  markDirty: () => void;
+}
+
+export async function archiveConversation(options: ArchiveConversationOptions): Promise<void> {
+  const target = options.conversations.get(options.sessionId);
+  if (target === undefined) {
+    return;
+  }
+  if (target.live) {
+    try {
+      await options.closePtySession(options.sessionId);
+    } catch {
+      // Best-effort close only.
+    }
+  }
+
+  try {
+    await options.removeSession(options.sessionId);
+  } catch (error: unknown) {
+    if (!options.isSessionNotFoundError(error)) {
+      throw error;
+    }
+  }
+
+  try {
+    await options.archiveConversationRecord(options.sessionId);
+  } catch (error: unknown) {
+    if (!options.isConversationNotFoundError(error)) {
+      throw error;
+    }
+  }
+  await options.unsubscribeConversationEvents(options.sessionId);
+  options.removeConversationState(options.sessionId);
+
+  if (options.activeConversationId === options.sessionId) {
+    const archivedDirectoryId = target.directoryId;
+    const ordered = options.orderedConversationIds();
+    const sameDirectoryConversationId =
+      ordered.find(
+        (candidateId) => options.conversationDirectoryId(candidateId) === archivedDirectoryId,
+      ) ?? null;
+    options.setActiveConversationId(null);
+    if (sameDirectoryConversationId !== null) {
+      await options.activateConversation(sameDirectoryConversationId);
+      return;
+    }
+    const fallbackDirectoryId = archivedDirectoryId ?? options.resolveActiveDirectoryId();
+    if (fallbackDirectoryId !== null) {
+      options.enterProjectPane(fallbackDirectoryId);
+      options.markDirty();
+      return;
+    }
+    options.markDirty();
+    return;
+  }
+
+  options.markDirty();
+}
+
+interface TakeoverConversationOptions<TControllerRecord> {
+  sessionId: string;
+  conversationsHas: (sessionId: string) => boolean;
+  claimSession: (sessionId: string) => Promise<TControllerRecord | null>;
+  applyController: (sessionId: string, controller: TControllerRecord) => void;
+  setLastEventNow: (sessionId: string) => void;
+  markDirty: () => void;
+}
+
+export async function takeoverConversation<TControllerRecord>(
+  options: TakeoverConversationOptions<TControllerRecord>,
+): Promise<void> {
+  if (!options.conversationsHas(options.sessionId)) {
+    return;
+  }
+  const controller = await options.claimSession(options.sessionId);
+  if (controller !== null) {
+    options.applyController(options.sessionId, controller);
+  }
+  options.setLastEventNow(options.sessionId);
+  options.markDirty();
+}
+
+interface AddDirectoryByPathOptions<TDirectoryRecord extends { directoryId: string }> {
+  rawPath: string;
+  resolveWorkspacePathForMux: (rawPath: string) => string;
+  upsertDirectory: (path: string) => Promise<TDirectoryRecord | null>;
+  setDirectory: (directory: TDirectoryRecord) => void;
+  directoryIdOf: (directory: TDirectoryRecord) => string;
+  setActiveDirectoryId: (directoryId: string) => void;
+  syncGitStateWithDirectories: () => void;
+  noteGitActivity: (directoryId: string) => void;
+  hydratePersistedConversationsForDirectory: (directoryId: string) => Promise<unknown>;
+  findConversationIdByDirectory: (directoryId: string) => string | null;
+  activateConversation: (sessionId: string) => Promise<unknown>;
+  enterProjectPane: (directoryId: string) => void;
+  markDirty: () => void;
+}
+
+export async function addDirectoryByPath<TDirectoryRecord extends { directoryId: string }>(
+  options: AddDirectoryByPathOptions<TDirectoryRecord>,
+): Promise<void> {
+  const normalizedPath = options.resolveWorkspacePathForMux(options.rawPath);
+  const directory = await options.upsertDirectory(normalizedPath);
+  if (directory === null) {
+    throw new Error('control-plane directory.upsert returned malformed directory record');
+  }
+  options.setDirectory(directory);
+  const directoryId = options.directoryIdOf(directory);
+  options.setActiveDirectoryId(directoryId);
+  options.syncGitStateWithDirectories();
+  options.noteGitActivity(directoryId);
+  await options.hydratePersistedConversationsForDirectory(directoryId);
+  const targetConversationId = options.findConversationIdByDirectory(directoryId);
+  if (targetConversationId !== null) {
+    await options.activateConversation(targetConversationId);
+    return;
+  }
+  options.enterProjectPane(directoryId);
+  options.markDirty();
+}
+
+interface CloseDirectoryOptions {
+  directoryId: string;
+  directoriesHas: (directoryId: string) => boolean;
+  orderedConversationIds: () => readonly string[];
+  conversationDirectoryId: (sessionId: string) => string | null;
+  conversationLive: (sessionId: string) => boolean;
+  closePtySession: (sessionId: string) => Promise<void>;
+  archiveConversationRecord: (sessionId: string) => Promise<void>;
+  unsubscribeConversationEvents: (sessionId: string) => Promise<void>;
+  removeConversationState: (sessionId: string) => void;
+  activeConversationId: string | null;
+  setActiveConversationId: (sessionId: string | null) => void;
+  archiveDirectory: (directoryId: string) => Promise<void>;
+  deleteDirectory: (directoryId: string) => void;
+  deleteDirectoryGitState: (directoryId: string) => void;
+  projectPaneSnapshotDirectoryId: string | null;
+  clearProjectPaneSnapshot: () => void;
+  directoriesSize: () => number;
+  addDirectoryByPath: (path: string) => Promise<void>;
+  invocationDirectory: string;
+  activeDirectoryId: string | null;
+  setActiveDirectoryId: (directoryId: string | null) => void;
+  firstDirectoryId: () => string | null;
+  noteGitActivity: (directoryId: string) => void;
+  resolveActiveDirectoryId: () => string | null;
+  activateConversation: (sessionId: string) => Promise<unknown>;
+  enterProjectPane: (directoryId: string) => void;
+  markDirty: () => void;
+}
+
+export async function closeDirectory(options: CloseDirectoryOptions): Promise<void> {
+  if (!options.directoriesHas(options.directoryId)) {
+    return;
+  }
+  const sessionIds = options
+    .orderedConversationIds()
+    .filter((sessionId) => options.conversationDirectoryId(sessionId) === options.directoryId);
+
+  for (const sessionId of sessionIds) {
+    if (options.conversationLive(sessionId)) {
+      try {
+        await options.closePtySession(sessionId);
+      } catch {
+        // Best-effort close only.
+      }
+    }
+    await options.archiveConversationRecord(sessionId);
+    await options.unsubscribeConversationEvents(sessionId);
+    options.removeConversationState(sessionId);
+    if (options.activeConversationId === sessionId) {
+      options.setActiveConversationId(null);
+    }
+  }
+
+  await options.archiveDirectory(options.directoryId);
+  options.deleteDirectory(options.directoryId);
+  options.deleteDirectoryGitState(options.directoryId);
+  if (options.projectPaneSnapshotDirectoryId === options.directoryId) {
+    options.clearProjectPaneSnapshot();
+  }
+
+  if (options.directoriesSize() === 0) {
+    await options.addDirectoryByPath(options.invocationDirectory);
+    return;
+  }
+
+  if (
+    options.activeDirectoryId === options.directoryId ||
+    options.activeDirectoryId === null ||
+    !options.directoriesHas(options.activeDirectoryId)
+  ) {
+    options.setActiveDirectoryId(options.firstDirectoryId());
+  }
+  if (options.activeDirectoryId !== null) {
+    options.noteGitActivity(options.activeDirectoryId);
+  }
+
+  const fallbackDirectoryId = options.resolveActiveDirectoryId();
+  const fallbackConversationId =
+    options
+      .orderedConversationIds()
+      .find((sessionId) => options.conversationDirectoryId(sessionId) === fallbackDirectoryId) ??
+    options.orderedConversationIds()[0] ??
+    null;
+  if (fallbackConversationId !== null) {
+    await options.activateConversation(fallbackConversationId);
+    return;
+  }
+  if (fallbackDirectoryId !== null) {
+    options.enterProjectPane(fallbackDirectoryId);
+    options.markDirty();
+    return;
+  }
+
+  options.markDirty();
+}

package/src/mux/live-mux/actions-repository.ts

@@ -0,0 +1,246 @@
+interface RepositoryRecordWithMetadata {
+  readonly repositoryId: string;
+  readonly remoteUrl: string;
+  readonly metadata: Record<string, unknown>;
+}
+
+interface RepositoryPromptState {
+  readonly mode: 'add' | 'edit';
+  readonly repositoryId: string | null;
+  readonly value: string;
+  readonly error: string | null;
+}
+
+interface OpenRepositoryPromptForCreateOptions {
+  clearNewThreadPrompt: () => void;
+  clearAddDirectoryPrompt: () => void;
+  hasConversationTitleEdit: boolean;
+  stopConversationTitleEdit: () => void;
+  clearConversationTitleEditClickState: () => void;
+  setRepositoryPrompt: (prompt: RepositoryPromptState) => void;
+  markDirty: () => void;
+}
+
+export function openRepositoryPromptForCreate(options: OpenRepositoryPromptForCreateOptions): void {
+  options.clearNewThreadPrompt();
+  options.clearAddDirectoryPrompt();
+  if (options.hasConversationTitleEdit) {
+    options.stopConversationTitleEdit();
+  }
+  options.clearConversationTitleEditClickState();
+  options.setRepositoryPrompt({
+    mode: 'add',
+    repositoryId: null,
+    value: '',
+    error: null,
+  });
+  options.markDirty();
+}
+
+interface OpenRepositoryPromptForEditOptions {
+  repositoryId: string;
+  repositories: ReadonlyMap<string, RepositoryRecordWithMetadata>;
+  clearNewThreadPrompt: () => void;
+  clearAddDirectoryPrompt: () => void;
+  hasConversationTitleEdit: boolean;
+  stopConversationTitleEdit: () => void;
+  clearConversationTitleEditClickState: () => void;
+  setRepositoryPrompt: (prompt: RepositoryPromptState) => void;
+  setTaskPaneSelectionFocusRepository: () => void;
+  markDirty: () => void;
+}
+
+export function openRepositoryPromptForEdit(options: OpenRepositoryPromptForEditOptions): void {
+  const repository = options.repositories.get(options.repositoryId);
+  if (repository === undefined) {
+    return;
+  }
+  options.clearNewThreadPrompt();
+  options.clearAddDirectoryPrompt();
+  if (options.hasConversationTitleEdit) {
+    options.stopConversationTitleEdit();
+  }
+  options.clearConversationTitleEditClickState();
+  options.setRepositoryPrompt({
+    mode: 'edit',
+    repositoryId: options.repositoryId,
+    value: repository.remoteUrl,
+    error: null,
+  });
+  options.setTaskPaneSelectionFocusRepository();
+  options.markDirty();
+}
+
+function repositoryHomePriority(repository: RepositoryRecordWithMetadata): number | null {
+  const raw = repository.metadata['homePriority'];
+  if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+    return null;
+  }
+  if (!Number.isInteger(raw) || raw < 0) {
+    return null;
+  }
+  return raw;
+}
+
+interface QueueRepositoryPriorityOrderOptions<TRepository extends RepositoryRecordWithMetadata> {
+  orderedRepositoryIds: readonly string[];
+  repositories: ReadonlyMap<string, TRepository>;
+  queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  updateRepositoryMetadata: (
+    repositoryId: string,
+    metadata: Record<string, unknown>,
+  ) => Promise<TRepository>;
+  upsertRepository: (repository: TRepository) => void;
+  syncTaskPaneRepositorySelection: () => void;
+  markDirty: () => void;
+  label: string;
+}
+
+export function queueRepositoryPriorityOrder<TRepository extends RepositoryRecordWithMetadata>(
+  options: QueueRepositoryPriorityOrderOptions<TRepository>,
+): void {
+  const updates: Array<{ repositoryId: string; metadata: Record<string, unknown> }> = [];
+  for (let index = 0; index < options.orderedRepositoryIds.length; index += 1) {
+    const repositoryId = options.orderedRepositoryIds[index]!;
+    const repository = options.repositories.get(repositoryId);
+    if (repository === undefined) {
+      continue;
+    }
+    if (repositoryHomePriority(repository) === index) {
+      continue;
+    }
+    updates.push({
+      repositoryId,
+      metadata: {
+        ...repository.metadata,
+        homePriority: index,
+      },
+    });
+  }
+  if (updates.length === 0) {
+    return;
+  }
+  options.queueControlPlaneOp(async () => {
+    for (const update of updates) {
+      const repository = await options.updateRepositoryMetadata(
+        update.repositoryId,
+        update.metadata,
+      );
+      options.upsertRepository(repository);
+    }
+    options.syncTaskPaneRepositorySelection();
+    options.markDirty();
+  }, options.label);
+}
+
+interface ReorderRepositoryByDropOptions {
+  draggedRepositoryId: string;
+  targetRepositoryId: string;
+  orderedRepositoryIds: readonly string[];
+  reorderIdsByMove: (
+    ids: readonly string[],
+    draggedId: string,
+    targetId: string,
+  ) => readonly string[] | null;
+  queueRepositoryPriorityOrder: (orderedRepositoryIds: readonly string[], label: string) => void;
+}
+
+export function reorderRepositoryByDrop(options: ReorderRepositoryByDropOptions): void {
+  const reordered = options.reorderIdsByMove(
+    options.orderedRepositoryIds,
+    options.draggedRepositoryId,
+    options.targetRepositoryId,
+  );
+  if (reordered === null) {
+    return;
+  }
+  options.queueRepositoryPriorityOrder(reordered, 'repositories-reorder-drag');
+}
+
+interface UpsertRepositoryByRemoteUrlScope {
+  readonly tenantId: string;
+  readonly userId: string;
+  readonly workspaceId: string;
+}
+
+interface UpsertRepositoryByRemoteUrlOptions<TRepository extends RepositoryRecordWithMetadata> {
+  remoteUrl: string;
+  existingRepositoryId: string | null;
+  normalizeGitHubRemoteUrl: (value: string) => string | null;
+  repositoryNameFromGitHubRemoteUrl: (value: string) => string;
+  createRepositoryId: () => string;
+  scope: UpsertRepositoryByRemoteUrlScope;
+  createRepository: (payload: {
+    repositoryId: string;
+    tenantId: string;
+    userId: string;
+    workspaceId: string;
+    name: string;
+    remoteUrl: string;
+    defaultBranch: string;
+    metadata: Record<string, unknown>;
+  }) => Promise<Record<string, unknown>>;
+  updateRepository: (payload: {
+    repositoryId: string;
+    name: string;
+    remoteUrl: string;
+  }) => Promise<Record<string, unknown>>;
+  parseRepositoryRecord: (value: unknown) => TRepository | null;
+  upsertRepository: (repository: TRepository) => void;
+  syncRepositoryAssociationsWithDirectorySnapshots: () => void;
+  syncTaskPaneRepositorySelection: () => void;
+  markDirty: () => void;
+}
+
+export async function upsertRepositoryByRemoteUrl<TRepository extends RepositoryRecordWithMetadata>(
+  options: UpsertRepositoryByRemoteUrlOptions<TRepository>,
+): Promise<void> {
+  const normalizedRemoteUrl = options.normalizeGitHubRemoteUrl(options.remoteUrl);
+  if (normalizedRemoteUrl === null) {
+    throw new Error('github url required');
+  }
+  const result =
+    options.existingRepositoryId === null
+      ? await options.createRepository({
+          repositoryId: options.createRepositoryId(),
+          tenantId: options.scope.tenantId,
+          userId: options.scope.userId,
+          workspaceId: options.scope.workspaceId,
+          name: options.repositoryNameFromGitHubRemoteUrl(normalizedRemoteUrl),
+          remoteUrl: normalizedRemoteUrl,
+          defaultBranch: 'main',
+          metadata: {
+            source: 'mux-manual',
+          },
+        })
+      : await options.updateRepository({
+          repositoryId: options.existingRepositoryId,
+          name: options.repositoryNameFromGitHubRemoteUrl(normalizedRemoteUrl),
+          remoteUrl: normalizedRemoteUrl,
+        });
+  const repository = options.parseRepositoryRecord(result['repository']);
+  if (repository === null) {
+    throw new Error('control-plane repository command returned malformed repository record');
+  }
+  options.upsertRepository(repository);
+  options.syncRepositoryAssociationsWithDirectorySnapshots();
+  options.syncTaskPaneRepositorySelection();
+  options.markDirty();
+}
+
+interface ArchiveRepositoryByIdOptions {
+  repositoryId: string;
+  archiveRepository: (repositoryId: string) => Promise<unknown>;
+  deleteRepository: (repositoryId: string) => void;
+  syncRepositoryAssociationsWithDirectorySnapshots: () => void;
+  syncTaskPaneRepositorySelection: () => void;
+  markDirty: () => void;
+}
+
+export async function archiveRepositoryById(options: ArchiveRepositoryByIdOptions): Promise<void> {
+  await options.archiveRepository(options.repositoryId);
+  options.deleteRepository(options.repositoryId);
+  options.syncRepositoryAssociationsWithDirectorySnapshots();
+  options.syncTaskPaneRepositorySelection();
+  options.markDirty();
+}

package/src/mux/live-mux/actions-task.ts

@@ -0,0 +1,115 @@
+import type { TaskPaneAction } from '../harness-core-ui.ts';
+
+interface TaskRecordActionState {
+  readonly taskId: string;
+  readonly status: string;
+}
+
+interface RunTaskPaneActionOptions {
+  action: TaskPaneAction;
+  openTaskCreatePrompt: () => void;
+  openRepositoryPromptForCreate: () => void;
+  selectedRepositoryId: string | null;
+  repositoryExists: (repositoryId: string) => boolean;
+  setTaskPaneNotice: (notice: string | null) => void;
+  markDirty: () => void;
+  setTaskPaneSelectionFocus: (focus: 'task' | 'repository') => void;
+  openRepositoryPromptForEdit: (repositoryId: string) => void;
+  queueArchiveRepository: (repositoryId: string) => void;
+  selectedTask: TaskRecordActionState | null;
+  openTaskEditPrompt: (taskId: string) => void;
+  queueDeleteTask: (taskId: string) => void;
+  queueTaskReady: (taskId: string) => void;
+  queueTaskDraft: (taskId: string) => void;
+  queueTaskComplete: (taskId: string) => void;
+  orderedTaskRecords: () => readonly TaskRecordActionState[];
+  queueTaskReorderByIds: (orderedTaskIds: readonly string[], label: string) => void;
+}
+
+export function runTaskPaneAction(options: RunTaskPaneActionOptions): void {
+  if (options.action === 'task.create') {
+    options.openTaskCreatePrompt();
+    return;
+  }
+  if (options.action === 'repository.create') {
+    options.setTaskPaneNotice(null);
+    options.openRepositoryPromptForCreate();
+    return;
+  }
+  if (options.action === 'repository.edit') {
+    const selectedRepositoryId = options.selectedRepositoryId;
+    if (selectedRepositoryId === null || !options.repositoryExists(selectedRepositoryId)) {
+      options.setTaskPaneNotice('select a repository first');
+      options.markDirty();
+      return;
+    }
+    options.setTaskPaneSelectionFocus('repository');
+    options.setTaskPaneNotice(null);
+    options.openRepositoryPromptForEdit(selectedRepositoryId);
+    return;
+  }
+  if (options.action === 'repository.archive') {
+    const selectedRepositoryId = options.selectedRepositoryId;
+    if (selectedRepositoryId === null || !options.repositoryExists(selectedRepositoryId)) {
+      options.setTaskPaneNotice('select a repository first');
+      options.markDirty();
+      return;
+    }
+    options.setTaskPaneSelectionFocus('repository');
+    options.queueArchiveRepository(selectedRepositoryId);
+    return;
+  }
+  const selected = options.selectedTask;
+  if (selected === null) {
+    options.setTaskPaneNotice('select a task first');
+    options.markDirty();
+    return;
+  }
+  if (options.action === 'task.edit') {
+    options.setTaskPaneSelectionFocus('task');
+    options.openTaskEditPrompt(selected.taskId);
+    return;
+  }
+  if (options.action === 'task.delete') {
+    options.setTaskPaneSelectionFocus('task');
+    options.queueDeleteTask(selected.taskId);
+    return;
+  }
+  if (options.action === 'task.ready') {
+    options.setTaskPaneSelectionFocus('task');
+    options.queueTaskReady(selected.taskId);
+    return;
+  }
+  if (options.action === 'task.draft') {
+    options.setTaskPaneSelectionFocus('task');
+    options.queueTaskDraft(selected.taskId);
+    return;
+  }
+  if (options.action === 'task.complete') {
+    options.setTaskPaneSelectionFocus('task');
+    options.queueTaskComplete(selected.taskId);
+    return;
+  }
+  if (options.action === 'task.reorder-up' || options.action === 'task.reorder-down') {
+    const activeTasks = options.orderedTaskRecords().filter((task) => task.status !== 'completed');
+    const selectedIndex = activeTasks.findIndex((task) => task.taskId === selected.taskId);
+    if (selectedIndex < 0) {
+      options.setTaskPaneNotice('cannot reorder completed tasks');
+      options.markDirty();
+      return;
+    }
+    const swapIndex = options.action === 'task.reorder-up' ? selectedIndex - 1 : selectedIndex + 1;
+    if (swapIndex < 0 || swapIndex >= activeTasks.length) {
+      return;
+    }
+    const reordered = [...activeTasks];
+    const currentTask = reordered[selectedIndex]!;
+    reordered[selectedIndex] = reordered[swapIndex]!;
+    reordered[swapIndex] = currentTask;
+    options.setTaskPaneSelectionFocus('task');
+    options.queueTaskReorderByIds(
+      reordered.map((task) => task.taskId),
+      options.action === 'task.reorder-up' ? 'tasks-reorder-up' : 'tasks-reorder-down',
+    );
+  }
+}