reslop 0.2.6 → 0.3.0

package/lib/session/dashboard.js

@@ -1,29 +1,26 @@
 'use strict';
 
-const files = require('../files.js');
-const { fileEntries, fileTotals } = files;
-const review = require('../review.js');
-const { noteCounts } = review;
-const runs = require('../runs.js');
-const { readRuns, settleRecord, isRunsRel } = runs;
-const tree = require('../dashboard/tree.js');
-const { FileIndex, HEAT_MS } = tree;
-const gitInfo = require('../dashboard/git.js');
-const { readGitSummary } = gitInfo;
-const npmInfo = require('../dashboard/npm.js');
-const { readNpmSummary } = npmInfo;
+const { fileEntries, fileTotals } = require('../common/files.js');
+const { noteCounts } = require('../review/review.js');
+const { readRuns, settleRecord, isRunsRel } = require('../runs/runs.js');
+const { FileIndex, HEAT_MS } = require('../dashboard/tree.js');
+const { readGitSummary } = require('../dashboard/git.js');
+const { readNpmSummary } = require('../dashboard/npm.js');
 const model = require('../dashboard/model.js');
-const { buildModel } = model;
+const { buildModel, minuteOf, MINUTE_MS, npmModel } = model;
 const filesPane = require('./files-pane.js');
-const watch = require('./watch.js');
-const { UNKNOWN_PATH, MODULES_STAMP } = watch;
+const { UNKNOWN_PATH, MODULES_STAMP } = require('../dashboard/watch.js');
 
 const TICK_ID = 'dashboard';
 const HEAT_TIMER = 'dashboard-heat';
 const AGE_TIMER = 'dashboard-age';
-const SAMPLES = 40;
+const MINUTE_TIMER = 'dashboard-minute';
+const BLINK_TIMER = 'dashboard-blink';
+const BLINK_MS = 3000;
+const MINUTE_KEEP = 360;
 const SWITCHES = 4;
-const GIT_NAMES = new Set([
+const RUN_MARK = { failed: 'fail', passed: 'pass', aborted: 'abort' };
+const GIT_NAMES = [
   'HEAD',
   'packed-refs',
   'FETCH_HEAD',
@@ -32,8 +29,8 @@ const GIT_NAMES = new Set([
   'logs',
   'rebase-merge',
   'rebase-apply',
-]);
-const NPM_FILES = new Set(['package.json', 'package-lock.json', MODULES_STAMP]);
+];
+const NPM_FILES = ['package.json', 'package-lock.json', MODULES_STAMP];
 const AGE_FAST_MS = 1000;
 const AGE_MID_MS = 30000;
 const AGE_SLOW_MS = 600000;
@@ -81,11 +78,12 @@ const classify = (paths) => {
     if (rel === UNKNOWN_PATH) {
       found.all = true;
     } else if (rel.startsWith('.git/')) {
-      if (GIT_NAMES.has(rel.split('/')[1])) found.git = true;
+      const gitName = rel.split('/')[1];
+      if (GIT_NAMES.includes(gitName)) found.git = true;
     } else if (isRunsRel(rel)) {
       found.runs = true;
     } else {
-      if (NPM_FILES.has(rel)) found.npm = true;
+      if (NPM_FILES.includes(rel)) found.npm = true;
       found.files.push(rel);
     }
   }
@@ -124,7 +122,9 @@ class Dashboard {
     this.totals = null;
     this.totalsKey = '';
     this.diffDelta = null;
-    this.samples = [];
+    this.minutes = new Map();
+    this.activityAt = 0;
+    this.rebaseOn = false;
     this.switches = [];
     this.branchAt = new Map();
     this.branchSha = new Map();
@@ -177,6 +177,101 @@ class Dashboard {
     progress.stop(TICK_ID);
     term.cancel(HEAT_TIMER);
     term.cancel(AGE_TIMER);
+    term.cancel(MINUTE_TIMER);
+    term.cancel(BLINK_TIMER);
+  }
+
+  bucket(at) {
+    const minute = minuteOf(at);
+    let newest = minute;
+    for (const key of this.minutes.keys()) {
+      if (key > newest) newest = key;
+    }
+    if (minute < newest - MINUTE_KEEP) return null;
+    let row = this.minutes.get(minute);
+    if (!row) {
+      row = { level: 0, added: 0, removed: 0, marks: [] };
+      this.minutes.set(minute, row);
+    }
+    const oldest = newest - MINUTE_KEEP;
+    for (const key of this.minutes.keys()) {
+      if (key < oldest) this.minutes.delete(key);
+    }
+    return row;
+  }
+
+  touchActivity(at) {
+    if (at > this.activityAt) this.activityAt = at;
+  }
+
+  heat(at, added, removed = 0) {
+    const plus = Math.max(0, added || 0);
+    const minus = Math.max(0, removed || 0);
+    if (!at || plus + minus <= 0) return;
+    const row = this.bucket(at);
+    if (!row) return;
+    row.added += plus;
+    row.removed += minus;
+    row.level += plus + minus;
+    this.touchActivity(at);
+  }
+
+  mark(at, kind) {
+    if (!at || !kind) return;
+    const row = this.bucket(at);
+    if (!row || row.marks.includes(kind)) return;
+    row.marks.push(kind);
+    this.touchActivity(at);
+  }
+
+  noteCommits(next) {
+    const recent = next.commits.recent;
+    for (const entry of recent) this.mark(entry.at, 'commit');
+  }
+
+  noteRebase(next, now) {
+    const rebasing = Boolean(next.rebase);
+    if (rebasing && !this.rebaseOn) this.mark(now, 'rebase');
+    this.rebaseOn = rebasing;
+  }
+
+  noteRuns(runs) {
+    for (const run of runs) {
+      const kind = RUN_MARK[run.status];
+      if (kind) this.mark(run.endedAt || run.startedAt, kind);
+    }
+  }
+
+  isRunLive() {
+    for (const run of this.liveRuns()) {
+      if (run.status === 'running') return true;
+    }
+    const npm = this.ui.npm.lastRun;
+    return Boolean(npm && npm.running);
+  }
+
+  isBusy() {
+    if (this.git && this.git.rebase) return true;
+    return this.isRunLive();
+  }
+
+  liveActivity(now) {
+    if (this.isBusy()) return true;
+    return now - this.activityAt < BLINK_MS;
+  }
+
+  activityView(now) {
+    const minutes = [];
+    for (const [at, row] of this.minutes) {
+      minutes.push({
+        at,
+        level: row.level,
+        added: row.added,
+        removed: row.removed,
+        marks: row.marks.slice(),
+      });
+    }
+    return { minutes, live: this.liveActivity(now) };
   }
 
   afterDraw() {
@@ -184,17 +279,21 @@ class Dashboard {
     if (!this.visible()) return void this.cancelTimers();
     const { progress, term } = this.ui;
     const now = Date.now();
+    if (this.isBusy()) this.touchActivity(now);
     const until = this.hotUntil();
     const hot = now < until;
-    const runs = this.liveRuns();
-    const running = runs.some((run) => run.status === 'running');
-    if (running || hot) progress.start(TICK_ID);
+    const live = this.liveActivity(now);
+    if (live || hot) progress.start(TICK_ID);
     else progress.stop(TICK_ID);
     const repaint = () => this.paintIfVisible();
     if (hot) term.later(HEAT_TIMER, repaint, until - now + 20);
-    const at = this.youngest(runs);
+    const at = this.youngest(this.liveRuns());
     const delay = at ? ageDelay(now - at) : AGE_SLOW_MS;
     term.later(AGE_TIMER, repaint, delay);
+    const minuteLeft = MINUTE_MS - (now % MINUTE_MS) + 20;
+    term.later(MINUTE_TIMER, repaint, minuteLeft);
+    const blinkLeft = this.activityAt + BLINK_MS - now;
+    if (blinkLeft > 0) term.later(BLINK_TIMER, repaint, blinkLeft + 20);
   }
 
   async runFiles() {
@@ -209,7 +308,12 @@ class Dashboard {
     const after = index.summary().total;
     const lines = after.lines - before.lines;
     const bytes = after.bytes - before.bytes;
-    if (lines || bytes) this.fileDelta = { lines, at: Date.now() };
+    if (!lines && !bytes) return;
+    const at = Date.now();
+    this.fileDelta = { lines, at };
+    const plus = lines > 0 ? lines : 0;
+    const minus = lines < 0 ? -lines : 0;
+    this.heat(at, plus || (minus ? 0 : 1), minus);
   }
 
   noteShas(next, now) {
@@ -243,9 +347,12 @@ class Dashboard {
     const moved = this.noteShas(next, now);
     const switched = this.noteSwitch(next, now);
     if (moved || switched) this.marks.branches = now;
+    if (switched) this.mark(now, 'branch');
     const sha = next.commits.last ? next.commits.last.sha : '';
     if (this.lastSha && sha !== this.lastSha) this.marks.commit = now;
     this.lastSha = sha;
+    this.noteCommits(next);
+    this.noteRebase(next, now);
     this.git = next;
   }
 
@@ -259,12 +366,17 @@ class Dashboard {
       (prev.deps !== next.deps ||
         prev.dev !== next.dev ||
         prev.modules.stamp !== next.modules.stamp);
-    if (changed) this.marks.npm = Date.now();
+    if (changed) {
+      const now = Date.now();
+      this.marks.npm = now;
+      this.mark(now, 'npm');
+    }
     this.npm = next;
   }
 
   runRuns() {
     this.runs = readRuns(this.root());
+    this.noteRuns(this.runs);
   }
 
   noteLoaded() {
@@ -276,12 +388,14 @@ class Dashboard {
     if (prev) {
       const added = totals.added - prev.added;
       const removed = totals.removed - prev.removed;
-      this.diffDelta = { added, removed, at: Date.now() };
+      const at = Date.now();
+      this.diffDelta = { added, removed, at };
+      const plus = Math.max(0, added);
+      const minus = Math.max(0, removed);
+      this.heat(at, plus || (minus ? 0 : 1), minus);
     }
     this.totals = totals;
     this.totalsKey = key;
-    this.samples.push(totals.added + totals.removed);
-    if (this.samples.length > SAMPLES) this.samples.shift();
   }
 
   requestAll() {
@@ -290,8 +404,12 @@ class Dashboard {
   }
 
   noteDisk(paths) {
-    if (!this.active) return;
     const found = classify(paths);
+    const npm = this.ui.npm;
+    if ((found.runs || found.all) && npm && npm.refreshRecorded) {
+      npm.refreshRecorded();
+    }
+    if (!this.active) return;
     if (found.all) return void this.requestAll();
     const tasks = this.tasks;
     if (found.files.length) {
@@ -325,17 +443,18 @@ class Dashboard {
 
   view() {
     const ui = this.ui;
+    const now = Date.now();
     const entries = fileEntries(ui.items);
     const store = ui.review.store;
     return buildModel({
-      now: Date.now(),
+      now,
       frame: ui.progressFrame,
       busy: ui.ops.busy,
       index: this.index,
       fileDelta: this.fileDelta,
       entries,
       totals: this.totals ?? fileTotals(entries),
-      samples: this.samples,
+      activity: this.activityView(now),
       diffDelta: this.diffDelta,
       git: this.git,
       switches: this.switches,
@@ -344,17 +463,43 @@ class Dashboard {
       npm: this.npm,
       npmExtras: ui.lifecycle.npmExtras(),
       npmRun: ui.npm.lastRun,
+      npmRuns: ui.npm.dashboardRuns(),
       runs: this.liveRuns(),
       notes: noteCounts(store),
       store,
+      agents: ui.agents.summary(),
     });
   }
 
+  packagesView() {
+    return npmModel({
+      npm: this.npm,
+      npmExtras: this.ui.lifecycle.npmExtras(),
+      npmRun: this.ui.npm.lastRun,
+    });
+  }
+
+  packageCount() {
+    const data = this.packagesView();
+    if (!data.ready || !data.hasManifest) return 1;
+    const listed = data.modules && data.modules.packages;
+    return listed ? listed.length : 0;
+  }
+
+  openPackages() {
+    const ui = this.ui;
+    ui.nav.pane = 'packages';
+    ui.nav.packagesCursor = 0;
+    ui.nav.resetListScroll('packages');
+    ui.nav.clearSelection();
+    ui.status = '';
+  }
+
   showFiles(scope) {
     const ui = this.ui;
     ui.showFiles();
-    if (scope === 'file') filesPane.onFileScope(ui);
-    else filesPane.onDiffScope(ui);
+    if (scope === 'file') filesPane.onFileScope(ui, true);
+    else filesPane.onDiffScope(ui, true);
     ui.status = '';
   }
 
@@ -365,9 +510,10 @@ class Dashboard {
       diffs: () => this.showFiles('diff'),
       commits: () => ui.commits.onCommit(),
       branches: () => ui.gitBranches.onBranch(),
-      npm: () => ui.npm.open(),
+      npm: () => this.openPackages(),
       run: () => ui.npm.open(),
       tasks: () => ui.composer.tasks.openTasksPage(),
+      agents: () => ui.agents.open(),
     };
     const opener = openers[id];
     if (!opener || ui.mode !== 'review') return;

package/lib/session/dispatch.js

@@ -1,28 +1,35 @@
 'use strict';
 
-const compose = require('./compose.js');
-const { COMPOSE_LEAVE } = compose;
-const commit = require('./commit.js');
-const { hasStagedChanges, listedCommits } = commit;
-const actions = require('./actions.js');
+const { COMPOSE_LEAVE } = require('./compose.js');
+const { listedCommits } = require('./commit.js');
+const actions = require('../input/actions.js');
 const { LIST_PANES, DASH_BLOCKS, DASH_ALLOWED, CONFIRM_MODE } = actions;
-const { disabledActions, actionFromKey, confirmKey } = actions;
-const changeActions = require('./change-actions.js');
-const { onCommand } = changeActions;
+const { REPOS_ALLOWED } = actions;
+const { disabledActions, actionFromKey, confirmKey, lineHasDiff } = actions;
+const { onCommand } = require('./change-actions.js');
 const filesPane = require('./files-pane.js');
-const pointer = require('./pointer.js');
-const { handlePointer } = pointer;
+const { handlePointer } = require('./pointer.js');
+const { FIND_PANES, startFind, onFindKey } = require('./find.js');
+const { startImport, stopImport, onImportKey } = require('./import.js');
+const { unitBodyLines } = require('./view.js');
 
 const currentTarget = (ui) => {
   if (ui.pane === 'files') return ui.fileCursorEntry();
   if (ui.pane === 'branches') return ui.branches[ui.branchCursor];
   if (ui.pane === 'commits') {
     const entry = listedCommits(ui.commits.commits)[ui.commitCursor];
-    const canCommit = hasStagedChanges(ui);
+    const canCommit = ui.commits.staged;
     const unstagedCurrent = !ui.rev && !ui.revShort;
     return { ...entry, canCommit, unstagedCurrent };
   }
-  return ui.current();
+  if (ui.pane !== 'unit') return ui.current();
+  const item = ui.current();
+  const lines = unitBodyLines(ui);
+  if (!lines.length) return item;
+  const line = lines[ui.nav.unitLine] ?? null;
+  const lineDiff = lineHasDiff(line);
+  if (!item) return { lineDiff };
+  return { ...item, lineDiff };
 };
 
 const scrollBy = (fraction) => (ui) =>
@@ -43,9 +50,13 @@ const HANDLERS = {
   next: filesPane.onNext,
   prev: filesPane.onPrev,
   layout: filesPane.onLayout,
+  lines: filesPane.onLineNumbers,
   theme: filesPane.onTheme,
   files: filesPane.onFiles,
-  open: filesPane.onOpenFile,
+  open: (ui) => {
+    if (ui.pane === 'repos') return void ui.workspace.openSelected();
+    filesPane.onOpenFile(ui);
+  },
   file: filesPane.onFileScope,
   diff: filesPane.onDiffScope,
   back: filesPane.onEscape,
@@ -63,10 +74,12 @@ const HANDLERS = {
   check: (ui) => ui.composer.tasks.toggleFocusedTask(),
   removeTask: (ui) => {
     if (ui.pane === 'npm') return void ui.npm.askDrop();
+    if (ui.pane === 'packages') return;
     ui.composer.tasks.removeFocusedTask();
   },
   reload: (ui) => ui.lifecycle.onReload(),
   commit: (ui) => ui.commits.onCommit(),
+  newCommit: (ui) => ui.commits.onInsert(),
   amend: (ui) => ui.commits.onAmend(),
   reword: (ui) => ui.commits.onReword(),
   apply: (ui) => ui.commits.onApply(),
@@ -82,26 +95,51 @@ const HANDLERS = {
     if (ui.pane === 'tasks') return void ui.composer.tasks.removeFocusedTask();
     ui.gitBranches.onDropBranch();
   },
+  taskUp: (ui) => ui.composer.tasks.moveIssue(-1),
+  taskDown: (ui) => ui.composer.tasks.moveIssue(1),
+  plan: (ui) => ui.composer.tasks.togglePlanMenu(),
+  import: (ui) => startImport(ui),
   npm: (ui) => ui.npm.open(),
   npmEdit: (ui) => ui.npm.edit(),
   npmNew: (ui) => ui.npm.create(),
   npmDrop: (ui) => ui.npm.askDrop(),
+  packageNew: (ui) => ui.packages.create(),
+  packageDrop: (ui) => ui.packages.askDrop(),
+  packageWanted: (ui) => ui.packages.updateWanted(),
+  packageLatest: (ui) => ui.packages.updateLatest(),
   npmLogs: (ui) => ui.npm.askLogs(),
-  npmStop: (ui) => ui.npm.closeView(),
+  npmStop: (ui) => ui.npm.stop(),
   npmVerbose: (ui) => ui.npm.toggleVerbose(),
   npmRerun: (ui) => ui.npm.rerun(),
+  agentModel: (ui) => ui.agents.openPick('model'),
+  agentEffort: (ui) => ui.agents.openPick('effort'),
+  agentFast: (ui) => ui.agents.toggleFast(),
+  agentContext: (ui) => ui.agents.openPick('context'),
+  agentReview: (ui) => ui.agents.openPick('plan'),
+  agentStop: (ui) => ui.agents.stop(),
+  agentRerun: (ui) => ui.agents.rerun(),
   quit: (ui) => ui.onQuit(),
+  repoLeft: (ui) => ui.workspace.move(-1, 0),
+  repoRight: (ui) => ui.workspace.move(1, 0),
+  repoUp: (ui) => ui.workspace.move(0, -1),
+  repoDown: (ui) => ui.workspace.move(0, 1),
   ...DASH_HANDLERS,
 };
 
 const dispatchAction = (ui, action) => {
   if (CONFIRM_MODE.includes(ui.mode)) return;
+  if (ui.mode === 'import') stopImport(ui);
+  if (action === 'lines' && (ui.pane === 'diff' || ui.pane === 'unit')) {
+    return void filesPane.onLineNumbers(ui);
+  }
   if (ui.mode === 'compose') {
     if (!COMPOSE_LEAVE.includes(action)) return;
-    const result = ui.composer.saveCompose();
-    if (result && result.kind === 'error') return;
+    const after = () => dispatchAction(ui, action);
+    const result = ui.composer.saveCompose({ after });
+    if (result.kind === 'saving') return;
   }
   const pane = ui.pane;
+  if (pane === 'repos' && !REPOS_ALLOWED.includes(action)) return;
   if (pane === 'dashboard' && !DASH_ALLOWED.includes(action)) return;
   if (LIST_PANES.includes(pane) && (action === 'next' || action === 'prev')) {
     return void filesPane.onScroll(ui, action === 'next' ? 1 : -1);
@@ -113,8 +151,7 @@ const dispatchAction = (ui, action) => {
 
 const CONFIRMATIONS = {
   confirmQuit: {
-    ready: (ui) => ui.finishQuit('ready'),
-    editing: (ui) => ui.finishQuit('editing'),
+    confirm: (ui) => ui.confirmQuit(),
     cancel: (ui) => ui.cancelQuit(),
   },
   confirmUpdate: {
@@ -123,11 +160,13 @@ const CONFIRMATIONS = {
   },
   confirmDrop: {
     confirm: (ui) => {
+      if (ui.packages.dropName) return void ui.packages.confirmDrop();
       if (ui.npm.dropName) return void ui.npm.confirmDrop();
       if (ui.commits.dropName) return void ui.commits.confirmDropCommit();
       ui.gitBranches.confirmDropBranch();
     },
     cancel: (ui) => {
+      if (ui.packages.dropName) return void ui.packages.cancelDrop();
       if (ui.npm.dropName) return void ui.npm.cancelDrop();
       if (ui.commits.dropName) return void ui.commits.cancelDropCommit();
       ui.gitBranches.cancelDropBranch();
@@ -137,6 +176,13 @@ const CONFIRMATIONS = {
     force: (ui) => ui.gitBranches.onForcePush(),
     cancel: (ui) => ui.gitBranches.cancelPush(),
   },
+  confirmCommit: {
+    update: (ui) => ui.commits.chooseCommit('update'),
+    commit: (ui) => ui.commits.chooseCommit('commit'),
+    amend: (ui) => ui.commits.chooseCommit('amend'),
+    fixup: (ui) => ui.commits.chooseCommit('fixup'),
+    cancel: (ui) => ui.commits.cancelCommitChoice(),
+  },
 };
 
 const confirmChoice = (ui, key) => {
@@ -147,6 +193,7 @@ const confirmChoice = (ui, key) => {
 
 const NPM_VIEW_KEYS = {
   escape: (ui) => ui.npm.closeView(),
+  s: (ui) => ui.npm.stop(),
   r: (ui) => ui.npm.rerun(),
   v: (ui) => ui.npm.toggleVerbose(),
   e: () => {},
@@ -158,29 +205,80 @@ const NPM_LIST_KEYS = {
   'ctrl-down': (ui) => ui.npm.reorder(1),
   up: (ui) => ui.npm.move(-1),
   down: (ui) => ui.npm.move(1),
+  right: (ui) => ui.npm.focusRuns(),
+  left: (ui) => ui.npm.focusCommands(),
+  tab: (ui) => ui.npm.toggleFocus(),
+  'shift-tab': (ui) => ui.npm.toggleFocus(),
+};
+
+const AGENT_VIEW_KEYS = {
+  escape: (ui) => ui.agents.closeView(),
+  s: (ui) => ui.agents.stop(),
+  r: (ui) => ui.agents.rerun(),
+  e: () => {},
+  m: () => {},
+  a: () => {},
+  t: () => {},
+  f: () => {},
+};
+
+const AGENT_LIST_KEYS = {
+  right: (ui) => ui.agents.focusRuns(),
+  left: (ui) => ui.agents.focusCli(),
+  tab: (ui) => ui.agents.toggleFocus(),
+  'shift-tab': (ui) => ui.agents.toggleFocus(),
 };
 
 const npmKey = (ui, key) => {
   if (ui.pane !== 'npm') return null;
-  if (ui.npm.viewing && Object.hasOwn(NPM_VIEW_KEYS, key)) {
-    return NPM_VIEW_KEYS[key];
+  if (ui.npm.viewing) {
+    if (Object.hasOwn(NPM_VIEW_KEYS, key)) return NPM_VIEW_KEYS[key];
+    if (key === 'up' || key === 'down') return NPM_LIST_KEYS[key];
+    return null;
   }
   return Object.hasOwn(NPM_LIST_KEYS, key) ? NPM_LIST_KEYS[key] : null;
 };
 
+const agentKey = (ui, key) => {
+  if (ui.pane !== 'agents') return null;
+  if (ui.agents.pick) return () => ui.agents.onPickKey(key);
+  const keys = ui.agents.viewing ? AGENT_VIEW_KEYS : AGENT_LIST_KEYS;
+  return Object.hasOwn(keys, key) ? keys[key] : null;
+};
+
+const planMenuKey = (ui, key) => {
+  if (!ui.composer.tasks.planOpen || ui.pane !== 'tasks') return false;
+  ui.composer.tasks.onPlanKey(key);
+  return true;
+};
+
 const handleKey = (ui, key) => {
   if (CONFIRM_MODE.includes(ui.mode)) return void confirmChoice(ui, key);
+  if (planMenuKey(ui, key)) return;
+  if (ui.pane === 'tasks' && (key === 'ctrl-up' || key === 'ctrl-down')) {
+    if (ui.mode === 'import') stopImport(ui);
+    const delta = key === 'ctrl-up' ? -1 : 1;
+    return void ui.composer.tasks.moveIssue(delta);
+  }
+  if (key === 'ctrl-l' && (ui.pane === 'diff' || ui.pane === 'unit')) {
+    return void filesPane.onLineNumbers(ui);
+  }
   if (ui.mode === 'compose') {
     return void ui.runComposeCommand(ui.composer.handleKey(key));
   }
+  if (ui.mode === 'find') return void onFindKey(ui, key);
+  if (ui.mode === 'import') return void onImportKey(ui, key);
+  if (key === '/' && FIND_PANES.includes(ui.pane)) return void startFind(ui);
   const onNpmKey = npmKey(ui, key);
   if (onNpmKey) return void onNpmKey(ui);
+  const onAgentKey = agentKey(ui, key);
+  if (onAgentKey) return void onAgentKey(ui);
   if (key === 'escape') return void filesPane.onEscape(ui);
   const tasks = ui.composer.tasks;
-  const toggle = key === 'x' || key === ' ';
+  const toggle = key === ' ';
   if (toggle && tasks.toggleFocusedTask()) return;
   if (tasks.typeIntoTask(key)) return;
-  const action = actionFromKey(key, ui.pane, ui.fileScope);
+  const action = actionFromKey(key, ui.pane);
   if (action) ui.dispatch(action);
 };