@jmoyers/harness 0.1.11 → 0.1.20

package/src/mux/live-mux/command-menu-open-in.ts

@@ -0,0 +1,280 @@
+import {
+  HARNESS_MUX_OPEN_IN_TARGET_IDS,
+  type HarnessMuxOpenInTargetId,
+  type HarnessMuxOpenInTargetOverrideConfig,
+} from '../../config/config-core.ts';
+import type { RegisteredCommandMenuAction } from './command-menu.ts';
+
+interface OpenInTargetDefaults {
+  readonly title: string;
+  readonly aliases: readonly string[];
+  readonly keywords: readonly string[];
+  readonly macAppName: string | null;
+  readonly launchCommand: string | null;
+}
+
+const OPEN_IN_TARGET_DEFAULTS: Readonly<Record<HarnessMuxOpenInTargetId, OpenInTargetDefaults>> = {
+  iterm2: {
+    title: 'iTerm2',
+    aliases: ['iterm2', 'terminal'],
+    keywords: ['iterm', 'terminal'],
+    macAppName: 'iTerm',
+    launchCommand: 'iterm2',
+  },
+  ghostty: {
+    title: 'Ghostty',
+    aliases: ['ghostty', 'terminal'],
+    keywords: ['ghostty', 'terminal'],
+    macAppName: 'Ghostty',
+    launchCommand: 'ghostty',
+  },
+  zed: {
+    title: 'Zed',
+    aliases: ['zed', 'editor'],
+    keywords: ['zed', 'editor'],
+    macAppName: 'Zed',
+    launchCommand: 'zed',
+  },
+  cursor: {
+    title: 'Cursor',
+    aliases: ['cursor', 'cursor ide', 'editor'],
+    keywords: ['cursor', 'editor', 'ide'],
+    macAppName: 'Cursor',
+    launchCommand: 'cursor',
+  },
+  vscode: {
+    title: 'VSCode',
+    aliases: ['vscode', 'vs code', 'code', 'editor'],
+    keywords: ['vscode', 'editor', 'ide'],
+    macAppName: 'Visual Studio Code',
+    launchCommand: 'code',
+  },
+  warp: {
+    title: 'Warp',
+    aliases: ['warp', 'terminal'],
+    keywords: ['warp', 'terminal'],
+    macAppName: 'Warp',
+    launchCommand: 'warp',
+  },
+  finder: {
+    title: 'Finder',
+    aliases: ['finder', 'file manager'],
+    keywords: ['finder', 'files'],
+    macAppName: 'Finder',
+    launchCommand: null,
+  },
+};
+
+function normalizedCommandPart(part: string): string {
+  return part.trim();
+}
+
+function normalizeLaunchCommandOverride(
+  value: readonly string[] | undefined,
+): readonly string[] | null {
+  if (value === undefined) {
+    return null;
+  }
+  const normalized = value.map(normalizedCommandPart).filter((part) => part.length > 0);
+  return normalized.length > 0 ? normalized : [];
+}
+
+function defaultLaunchCommand(
+  platform: NodeJS.Platform,
+  defaults: OpenInTargetDefaults,
+  appName: string | null,
+): readonly string[] {
+  if (platform === 'darwin' && appName !== null) {
+    return ['open', '-a', appName, '{path}'];
+  }
+  if (defaults.launchCommand === null) {
+    return [];
+  }
+  return [defaults.launchCommand, '{path}'];
+}
+
+function defaultDetectCommand(
+  platform: NodeJS.Platform,
+  defaults: OpenInTargetDefaults,
+): string | null {
+  if (platform === 'darwin') {
+    return null;
+  }
+  return defaults.launchCommand;
+}
+
+function isAutoDetectedTargetAvailable(options: {
+  platform: NodeJS.Platform;
+  appName: string | null;
+  detectCommand: string | null;
+  isMacApplicationInstalled: (appName: string) => boolean;
+  isCommandAvailable: (command: string) => boolean;
+}): boolean {
+  if (options.platform === 'darwin' && options.appName !== null) {
+    return options.isMacApplicationInstalled(options.appName);
+  }
+  if (options.detectCommand === null) {
+    return false;
+  }
+  return options.isCommandAvailable(options.detectCommand);
+}
+
+export interface ResolvedCommandMenuOpenInTarget {
+  readonly id: HarnessMuxOpenInTargetId;
+  readonly title: string;
+  readonly aliases: readonly string[];
+  readonly keywords: readonly string[];
+  readonly launchCommand: readonly string[];
+}
+
+export function resolveCommandMenuOpenInTargets(options: {
+  platform: NodeJS.Platform;
+  overrides: Readonly<
+    Partial<Record<HarnessMuxOpenInTargetId, HarnessMuxOpenInTargetOverrideConfig>>
+  >;
+  isCommandAvailable: (command: string) => boolean;
+  isMacApplicationInstalled: (appName: string) => boolean;
+}): readonly ResolvedCommandMenuOpenInTarget[] {
+  const resolved: ResolvedCommandMenuOpenInTarget[] = [];
+  for (const targetId of HARNESS_MUX_OPEN_IN_TARGET_IDS) {
+    const defaults = OPEN_IN_TARGET_DEFAULTS[targetId];
+    const override = options.overrides[targetId];
+    if (override?.enabled === false) {
+      continue;
+    }
+    const appName =
+      override?.appName === undefined || override.appName.trim().length === 0
+        ? defaults.macAppName
+        : override.appName.trim();
+    const detectCommand =
+      override?.detectCommand === undefined
+        ? defaultDetectCommand(options.platform, defaults)
+        : override.detectCommand === null || override.detectCommand.trim().length === 0
+          ? null
+          : override.detectCommand.trim();
+    const overrideLaunchCommand = normalizeLaunchCommandOverride(override?.launchCommand);
+    const launchCommand =
+      overrideLaunchCommand === null
+        ? defaultLaunchCommand(options.platform, defaults, appName)
+        : overrideLaunchCommand;
+    if (launchCommand.length === 0) {
+      continue;
+    }
+    const available =
+      override?.enabled === true
+        ? true
+        : isAutoDetectedTargetAvailable({
+            platform: options.platform,
+            appName,
+            detectCommand,
+            isCommandAvailable: options.isCommandAvailable,
+            isMacApplicationInstalled: options.isMacApplicationInstalled,
+          });
+    if (!available) {
+      continue;
+    }
+    resolved.push({
+      id: targetId,
+      title: defaults.title,
+      aliases: defaults.aliases,
+      keywords: defaults.keywords,
+      launchCommand,
+    });
+  }
+  return resolved;
+}
+
+export function resolveCommandMenuOpenInCommand(
+  target: ResolvedCommandMenuOpenInTarget,
+  directoryPath: string,
+): { command: string; args: readonly string[] } | null {
+  const command = target.launchCommand[0]?.trim() ?? '';
+  if (command.length === 0) {
+    return null;
+  }
+  let pathInjected = false;
+  const args = target.launchCommand.slice(1).map((part) => {
+    if (part === '{path}') {
+      pathInjected = true;
+      return directoryPath;
+    }
+    return part;
+  });
+  if (!pathInjected) {
+    args.push(directoryPath);
+  }
+  return {
+    command,
+    args,
+  };
+}
+
+interface CommandMenuOpenInProviderDirectory {
+  readonly directoryId: string;
+  readonly path: string;
+}
+
+interface CommandMenuOpenInProviderOptions<TContext> {
+  readonly registerProvider: (
+    providerId: string,
+    provider: (context: TContext) => readonly RegisteredCommandMenuAction<TContext>[],
+  ) => () => void;
+  readonly providerId?: string;
+  readonly resolveDirectories: (context: TContext) => readonly CommandMenuOpenInProviderDirectory[];
+  readonly resolveTargets: () => readonly ResolvedCommandMenuOpenInTarget[];
+  readonly projectPathTail: (directoryPath: string) => string;
+  readonly openInTarget: (
+    target: ResolvedCommandMenuOpenInTarget,
+    directoryPath: string,
+  ) => boolean;
+  readonly copyPath: (directoryPath: string) => boolean;
+  readonly setNotice: (message: string) => void;
+}
+
+export function registerCommandMenuOpenInProvider<TContext>(
+  options: CommandMenuOpenInProviderOptions<TContext>,
+): () => void {
+  const providerId = options.providerId ?? 'project.open-in';
+  return options.registerProvider(providerId, (context) => {
+    const actions: RegisteredCommandMenuAction<TContext>[] = [];
+    const targets = options.resolveTargets();
+    for (const directory of options.resolveDirectories(context)) {
+      const projectLabel = options.projectPathTail(directory.path);
+      for (const target of targets) {
+        actions.push({
+          id: `project.open-in.${target.id}.${directory.directoryId}`,
+          title: `Open in ${target.title}: ${projectLabel}`,
+          aliases: [
+            ...target.aliases,
+            'open project in',
+            `open in ${target.title.toLowerCase()}`,
+            directory.path,
+            projectLabel,
+          ],
+          keywords: ['open', 'project', 'directory', 'path', ...target.keywords],
+          detail: directory.path,
+          run: () => {
+            const opened = options.openInTarget(target, directory.path);
+            options.setNotice(
+              opened
+                ? `opened ${projectLabel} in ${target.title}`
+                : `failed to open ${projectLabel} in ${target.title}`,
+            );
+          },
+        });
+      }
+      actions.push({
+        id: `project.copy-path.${directory.directoryId}`,
+        title: `Copy Path: ${projectLabel}`,
+        aliases: ['copy path', 'copy project path', directory.path, projectLabel],
+        keywords: ['copy', 'path', 'clipboard', 'project', 'directory'],
+        detail: directory.path,
+        run: () => {
+          const copied = options.copyPath(directory.path);
+          options.setNotice(copied ? `copied path: ${directory.path}` : 'failed to copy path');
+        },
+      });
+    }
+    return actions;
+  });
+}

package/src/mux/live-mux/command-menu.ts

@@ -1,6 +1,18 @@
-export const COMMAND_MENU_MAX_RESULTS = 8;
-
-type CommandMenuScope = 'all' | 'thread-start' | 'theme-select';
+const COMMAND_MENU_MAX_RESULTS = 8;
+const THREAD_ACTION_ID_PATTERN = /^thread\.(?:start|install)\.([a-z0-9-]+)$/u;
+const TASK_SUMMARY_MAX_CHARS = 96;
+const DEFAULT_TASK_SUMMARY = 'untitled task';
+
+type CommandMenuScope = 'all' | 'thread-start' | 'theme-select' | 'shortcuts';
+type CommandMenuInitialGroup = 'agent-types' | 'actions';
+
+const COMMAND_MENU_AGENT_TYPE_ORDER: Readonly<Record<string, number>> = {
+  codex: 0,
+  claude: 1,
+  cursor: 2,
+  terminal: 3,
+  critique: 4,
+};
 
 export interface CommandMenuState {
   readonly scope: CommandMenuScope;
@@ -14,6 +26,10 @@ export interface CommandMenuActionDescriptor {
   readonly aliases?: readonly string[];
   readonly keywords?: readonly string[];
   readonly detail?: string;
+  readonly screenLabel?: string;
+  readonly sectionLabel?: string;
+  readonly bindingHint?: string;
+  readonly priority?: number;
 }
 
 export function filterThemePresetActionsForScope<TAction extends CommandMenuActionDescriptor>(
@@ -27,6 +43,27 @@ export function filterThemePresetActionsForScope<TAction extends CommandMenuActi
   return actions.filter((action) => !action.id.startsWith(themeActionIdPrefix));
 }
 
+export function filterCommandMenuActionsForScope<TAction extends CommandMenuActionDescriptor>(
+  actions: readonly TAction[],
+  scope: CommandMenuScope,
+  options: {
+    readonly themeActionIdPrefix: string;
+    readonly shortcutsActionIdPrefix: string;
+  },
+): readonly TAction[] {
+  const { themeActionIdPrefix, shortcutsActionIdPrefix } = options;
+  if (scope === 'theme-select') {
+    return actions.filter((action) => action.id.startsWith(themeActionIdPrefix));
+  }
+  if (scope === 'shortcuts') {
+    return actions.filter((action) => action.id.startsWith(shortcutsActionIdPrefix));
+  }
+  return actions.filter(
+    (action) =>
+      !action.id.startsWith(themeActionIdPrefix) && !action.id.startsWith(shortcutsActionIdPrefix),
+  );
+}
+
 export interface RegisteredCommandMenuAction<TContext> extends CommandMenuActionDescriptor {
   readonly when?: (context: TContext) => boolean;
   readonly run: (context: TContext) => Promise<void> | void;
@@ -37,6 +74,20 @@ interface CommandMenuMatch<TAction extends CommandMenuActionDescriptor> {
   readonly score: number;
 }
 
+interface CommandMenuDisplayEntry<TAction extends CommandMenuActionDescriptor> {
+  readonly absoluteIndex: number;
+  readonly action: TAction;
+  readonly score: number;
+}
+
+interface CommandMenuPage<TAction extends CommandMenuActionDescriptor> {
+  readonly matches: readonly CommandMenuMatch<TAction>[];
+  readonly selectedIndex: number;
+  readonly pageStart: number;
+  readonly visibleMatches: readonly CommandMenuMatch<TAction>[];
+  readonly displayEntries: readonly CommandMenuDisplayEntry<TAction>[];
+}
+
 type CommandMenuActionProvider<TContext> = (
   context: TContext,
 ) => readonly RegisteredCommandMenuAction<TContext>[];
@@ -50,6 +101,29 @@ function normalizeQuery(value: string): string {
   return value.trim().toLowerCase().replace(/\s+/g, ' ');
 }
 
+function truncateCommandMenuSummary(value: string, maxChars: number): string {
+  if (value.length <= maxChars) {
+    return value;
+  }
+  if (maxChars <= 3) {
+    return value.slice(0, Math.max(1, maxChars));
+  }
+  return `${value.slice(0, maxChars - 3)}...`;
+}
+
+export function summarizeTaskForCommandMenu(body: string, title: string): string {
+  const bodyLines = body.split('\n').map((line) => line.trim());
+  const firstBodyLine = bodyLines.find((line) => line.length > 0) ?? '';
+  const fallbackTitle = title.trim();
+  const summarySource =
+    firstBodyLine.length > 0
+      ? firstBodyLine
+      : fallbackTitle.length > 0
+        ? fallbackTitle
+        : DEFAULT_TASK_SUMMARY;
+  return truncateCommandMenuSummary(summarySource, TASK_SUMMARY_MAX_CHARS);
+}
+
 function normalizedTokens(query: string): readonly string[] {
   const normalized = normalizeQuery(query);
   if (normalized.length === 0) {
@@ -79,6 +153,46 @@ function searchableParts(action: CommandMenuActionDescriptor): readonly string[]
   return parts;
 }
 
+function threadAgentTypeFromActionId(actionId: string): string | null {
+  const match = THREAD_ACTION_ID_PATTERN.exec(actionId);
+  if (match === null) {
+    return null;
+  }
+  const value = (match[1] ?? '').trim().toLowerCase();
+  return value.length > 0 ? value : null;
+}
+
+function initialGroupForAction(action: CommandMenuActionDescriptor): CommandMenuInitialGroup {
+  return threadAgentTypeFromActionId(action.id) === null ? 'actions' : 'agent-types';
+}
+
+function initialGroupRank(action: CommandMenuActionDescriptor): number {
+  return initialGroupForAction(action) === 'agent-types' ? 0 : 1;
+}
+
+function initialAgentTypeRank(action: CommandMenuActionDescriptor): number {
+  const agentType = threadAgentTypeFromActionId(action.id);
+  if (agentType === null) {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  return COMMAND_MENU_AGENT_TYPE_ORDER[agentType] ?? 100;
+}
+
+function usesInitialTypeSort(query: string): boolean {
+  return normalizedTokens(query).length === 0;
+}
+
+function buildCommandMenuDisplayEntries<TAction extends CommandMenuActionDescriptor>(
+  visibleMatches: readonly CommandMenuMatch<TAction>[],
+  pageStart: number,
+): readonly CommandMenuDisplayEntry<TAction>[] {
+  return visibleMatches.map((match, index) => ({
+    absoluteIndex: pageStart + index,
+    action: match.action,
+    score: match.score,
+  }));
+}
+
 function actionScore(action: CommandMenuActionDescriptor, query: string): number | null {
   const tokens = normalizedTokens(query);
   if (tokens.length === 0) {
@@ -136,7 +250,11 @@ function clampSelectedIndex(selectedIndex: number, resultCount: number): number
   return selectedIndex;
 }
 
-function moveSelectionByDelta(selectedIndex: number, resultCount: number, delta: number): number {
+export function moveSelectionByDelta(
+  selectedIndex: number,
+  resultCount: number,
+  delta: number,
+): number {
   if (resultCount <= 0) {
     return 0;
   }
@@ -183,15 +301,39 @@ export function resolveCommandMenuMatches<TAction extends CommandMenuActionDescr
   query: string,
   limit: number | null = COMMAND_MENU_MAX_RESULTS,
 ): readonly CommandMenuMatch<TAction>[] {
+  const useInitialSort = usesInitialTypeSort(query);
   const scored = actions
     .flatMap((action) => {
       const score = actionScore(action, query);
       return score === null ? [] : [{ action, score }];
     })
     .sort((left, right) => {
+      const priorityDelta = (right.action.priority ?? 0) - (left.action.priority ?? 0);
+      if (priorityDelta !== 0) {
+        return priorityDelta;
+      }
+      if (useInitialSort) {
+        const groupCompare = initialGroupRank(left.action) - initialGroupRank(right.action);
+        if (groupCompare !== 0) {
+          return groupCompare;
+        }
+        const leftGroup = initialGroupForAction(left.action);
+        if (leftGroup === 'agent-types') {
+          const agentCompare =
+            initialAgentTypeRank(left.action) - initialAgentTypeRank(right.action);
+          if (agentCompare !== 0) {
+            return agentCompare;
+          }
+        }
+        return left.action.title.localeCompare(right.action.title);
+      }
       if (left.score !== right.score) {
         return left.score - right.score;
       }
+      const groupCompare = initialGroupRank(left.action) - initialGroupRank(right.action);
+      if (groupCompare !== 0) {
+        return groupCompare;
+      }
       return left.action.title.localeCompare(right.action.title);
     });
   if (limit === null) {
@@ -200,6 +342,27 @@ export function resolveCommandMenuMatches<TAction extends CommandMenuActionDescr
   return scored.slice(0, Math.max(0, limit));
 }
 
+export function resolveCommandMenuPage<TAction extends CommandMenuActionDescriptor>(
+  actions: readonly TAction[],
+  menu: CommandMenuState,
+): CommandMenuPage<TAction> {
+  const matches = resolveCommandMenuMatches(actions, menu.query, null);
+  const selectedIndex = clampSelectedIndex(menu.selectedIndex, matches.length);
+  const pageStart =
+    matches.length === 0
+      ? 0
+      : Math.floor(selectedIndex / COMMAND_MENU_MAX_RESULTS) * COMMAND_MENU_MAX_RESULTS;
+  const visibleMatches = matches.slice(pageStart, pageStart + COMMAND_MENU_MAX_RESULTS);
+  const displayEntries = buildCommandMenuDisplayEntries(visibleMatches, pageStart);
+  return {
+    matches,
+    selectedIndex,
+    pageStart,
+    visibleMatches,
+    displayEntries,
+  };
+}
+
 export function resolveSelectedCommandMenuActionId<TAction extends CommandMenuActionDescriptor>(
   actions: readonly TAction[],
   menu: CommandMenuState | null,

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

@@ -187,3 +187,16 @@ export function debugFooterForConversation(conversation: ConversationState): str
       : compactDebugText(conversation.launchCommand);
   return `[dbg] ${launchCommand}`;
 }
+
+export function composeDebugStatusFooter(
+  showDebugBar: boolean,
+  githubDebugTokens: string,
+  conversation: ConversationState,
+): string {
+  if (!showDebugBar) {
+    return '';
+  }
+  const githubPrefix = githubDebugTokens.trim();
+  const debugFooter = debugFooterForConversation(conversation);
+  return githubPrefix.length === 0 ? debugFooter : `${githubPrefix} ${debugFooter}`;
+}

package/src/mux/live-mux/directory-resolution.ts

@@ -3,7 +3,7 @@ interface ResolveDirectoryForActionConversationState {
 }
 
 interface ResolveDirectoryForActionOptions {
-  mainPaneMode: 'conversation' | 'project' | 'home';
+  mainPaneMode: 'conversation' | 'project' | 'home' | 'nim';
   activeDirectoryId: string | null;
   activeConversationId: string | null;
   conversations: ReadonlyMap<string, ResolveDirectoryForActionConversationState>;

package/src/mux/live-mux/git-snapshot.ts

@@ -1,4 +1,6 @@
 import { execFile } from 'node:child_process';
+import { basename } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { promisify } from 'node:util';
 import {
   normalizeGitHubRemoteUrl,
@@ -120,6 +122,24 @@ export async function runGitCommand(
   }
 }
 
+function normalizeLocalRepositoryLocator(pathValue: string): string | null {
+  const trimmed = pathValue.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  return pathToFileURL(trimmed).toString();
+}
+
+function repositoryNameFromRepositoryLocator(locator: string): string | null {
+  const normalizedGitHub = normalizeGitHubRemoteUrl(locator);
+  if (normalizedGitHub !== null) {
+    return repositoryNameFromGitHubRemoteUrl(normalizedGitHub);
+  }
+  const resolvedPath = fileURLToPath(locator);
+  const inferred = basename(resolvedPath.trim());
+  return inferred.length > 0 ? inferred : null;
+}
+
 async function readNormalizedGitHubRemoteUrl(
   cwd: string,
   runCommand: GitCommandRunner,
@@ -146,6 +166,17 @@ async function readNormalizedGitHubRemoteUrl(
   return null;
 }
 
+async function readRepositoryLocator(
+  cwd: string,
+  runCommand: GitCommandRunner,
+): Promise<string | null> {
+  const normalizedGitHubRemoteUrl = await readNormalizedGitHubRemoteUrl(cwd, runCommand);
+  if (normalizedGitHubRemoteUrl !== null) {
+    return normalizedGitHubRemoteUrl;
+  }
+  return normalizeLocalRepositoryLocator(await runCommand(cwd, ['rev-parse', '--show-toplevel']));
+}
+
 export async function readGitDirectorySnapshot(
   cwd: string,
   runCommand: GitCommandRunner = runGitCommand,
@@ -162,7 +193,7 @@ export async function readGitDirectorySnapshot(
   const statusOutputPromise = runCommand(cwd, ['status', '--porcelain=1', '--branch']);
   const unstagedShortstatPromise = runCommand(cwd, ['diff', '--shortstat']);
   const stagedShortstatPromise = runCommand(cwd, ['diff', '--cached', '--shortstat']);
-  const remoteUrlPromise = readNormalizedGitHubRemoteUrl(cwd, runCommand);
+  const remoteUrlPromise = readRepositoryLocator(cwd, runCommand);
   const lastCommitPromise = runCommand(cwd, ['log', '-1', '--format=%ct %h']);
   const commitCountPromise =
     options.includeCommitCount === false
@@ -209,7 +240,7 @@ export async function readGitDirectorySnapshot(
       inferredName:
         normalizedRemoteUrl === null
           ? null
-          : repositoryNameFromGitHubRemoteUrl(normalizedRemoteUrl),
+          : repositoryNameFromRepositoryLocator(normalizedRemoteUrl),
       defaultBranch: branch === '(detached)' ? null : branch,
     },
   };

package/src/mux/live-mux/global-shortcut-handlers.ts

@@ -6,6 +6,7 @@ interface HandleGlobalShortcutOptions {
   resolveDirectoryForAction: () => string | null;
   openNewThreadPrompt: (directoryId: string) => void;
   toggleCommandMenu: () => void;
+  toggleDebugBar: () => void;
   openOrCreateCritiqueConversationInDirectory: (directoryId: string) => Promise<void>;
   toggleGatewayProfile: () => Promise<void>;
   toggleGatewayStatusTimeline: () => Promise<void>;
@@ -30,6 +31,7 @@ export function handleGlobalShortcut(options: HandleGlobalShortcutOptions): bool
     resolveDirectoryForAction,
     openNewThreadPrompt,
     toggleCommandMenu,
+    toggleDebugBar,
     openOrCreateCritiqueConversationInDirectory,
     toggleGatewayProfile,
     toggleGatewayStatusTimeline,
@@ -64,6 +66,10 @@ export function handleGlobalShortcut(options: HandleGlobalShortcutOptions): bool
     toggleCommandMenu();
     return true;
   }
+  if (shortcut === 'mux.debug-bar.toggle') {
+    toggleDebugBar();
+    return true;
+  }
   if (shortcut === 'mux.conversation.critique.open-or-create') {
     const targetDirectoryId = resolveDirectoryForAction();
     if (targetDirectoryId !== null) {

package/src/mux/live-mux/home-pane-drop.ts

@@ -9,7 +9,7 @@ interface HomePaneDragState {
 interface HandleHomePaneDragReleaseOptions {
   homePaneDragState: HomePaneDragState | null;
   isMouseRelease: boolean;
-  mainPaneMode: 'conversation' | 'project' | 'home';
+  mainPaneMode: 'conversation' | 'project' | 'home' | 'nim';
   target: string;
   rowIndex: number;
   taskIdAtRow: (rowIndex: number) => string | null;

package/src/mux/live-mux/home-pane-pointer.ts

@@ -30,6 +30,7 @@ interface HandleHomePanePointerClickOptions {
   setTaskRepositoryDropdownOpen: (open: boolean) => void;
   taskIdAtRow: (rowIndex: number) => string | null;
   repositoryIdAtRow: (rowIndex: number) => string | null;
+  rowTextAtRow?: (rowIndex: number) => string | null;
   selectTaskById: (taskId: string) => void;
   selectRepositoryById: (repositoryId: string) => void;
   runTaskPaneAction: (action: 'task.ready' | 'task.draft' | 'task.complete') => void;
@@ -55,6 +56,15 @@ export function handleHomePanePointerClick(options: HandleHomePanePointerClickOp
     0,
     Math.min(options.rightCols - 1, options.pointerCol - options.rightStartCol),
   );
+  const rowText = options.rowTextAtRow?.(rowIndex) ?? null;
+  const isTaskEditorContentRow =
+    options.taskIdAtRow(rowIndex) !== null &&
+    rowText !== null &&
+    rowText.trimEnd().startsWith(' │') &&
+    rowText.trimEnd().includes('│');
+  if (isTaskEditorContentRow) {
+    return false;
+  }
   const action = options.actionAtCell(rowIndex, colIndex) ?? options.actionAtRow(rowIndex);
   if (
     handleHomePaneActionClick({