reslop 0.3.1 → 0.3.2

package/lib/session/branches.js

@@ -47,7 +47,7 @@ class BranchController {
     ui.refreshFromRepo({ keepEmpty: true, ...extra });
   }
 
-  async open() {
+  async open(focusTrees = false) {
     const ui = this.ui;
     const loaded = await this.loadBranches();
     if (!loaded) return;
@@ -55,9 +55,11 @@ class BranchController {
     const nav = ui.nav;
     nav.branchCursor = current < 0 ? 0 : current;
     nav.pane = 'branches';
+    nav.treeFocus = focusTrees;
     nav.resetListScroll('branches');
     ui.status = '';
     nav.clearSelection();
+    void ui.worktrees.refreshTrees();
   }
 
   runWrite(name, args, kind, done) {
@@ -76,8 +78,23 @@ class BranchController {
     ui.ops.hold(this.open());
   }
 
+  // The worktrees above the branches share the cursor keys with them: one
+  // element is selected, up from the first branch reaches the worktrees
+  moveBetweenTrees(delta) {
+    const nav = this.ui.nav;
+    if (!this.ui.worktrees.hasPanels()) return false;
+    if (nav.treeFocus) {
+      if (delta > 0) nav.treeFocus = false;
+      return true;
+    }
+    if (delta >= 0 || nav.branchCursor > 0) return false;
+    nav.treeFocus = true;
+    return true;
+  }
+
   onBranchMove(delta) {
     const nav = this.ui.nav;
+    if (this.moveBetweenTrees(delta)) return void (this.ui.status = '');
     if (!this.branches.length) {
       this.ui.status = 'nothing to review';
       return;

package/lib/session/compose.js

@@ -6,7 +6,7 @@ const { noteInnerWidth, codeInnerWidth, todoBodyWidth, activeDigits } = render;
 const { commitMessageWidth } = require('../render/commits.js');
 const { listedCommits } = require('./commit.js');
 const { Editor } = require('../input/editor.js');
-const { isTextKey } = require('../input/keys.js');
+const { isTextKey, isNewlineKey } = require('../input/keys.js');
 const files = require('../common/files.js');
 const { itemPath, isTaskItem, isTasksEntry, listPath } = files;
 const { isReadOnlyOrigin } = files;
@@ -39,10 +39,18 @@ const KIND = {
   branch: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
   npm: { enter: 'save', tab: 'insert-tab', escape: 'cancel', move: 'note' },
   package: { enter: 'save', tab: 'insert-tab', escape: 'cancel', move: 'note' },
+  worktree: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
 };
 
-const COMMAND_KINDS = ['commit', 'branch', 'npm', 'package'];
-const NOTE_VIEWS = ['feedback', 'commit', 'branch', 'npm', 'package'];
+const COMMAND_KINDS = ['commit', 'branch', 'npm', 'package', 'worktree'];
+const NOTE_VIEWS = [
+  'feedback',
+  'commit',
+  'branch',
+  'npm',
+  'package',
+  'worktree',
+];
 
 const itemNote = (item, text) => {
   const hunk = item.hunk;
@@ -674,8 +682,8 @@ class Composer {
   }
 
   handleKey(key) {
-    if (key === 'enter') {
-      const result = this.enter();
+    if (key === 'enter' || isNewlineKey(key)) {
+      const result = isNewlineKey(key) ? this.insertNewline() : this.enter();
       this.syncCodeScroll();
       return result;
     }

package/lib/session/dispatch.js

@@ -8,7 +8,7 @@ const { REPOS_ALLOWED } = actions;
 const { disabledActions, actionFromKey, confirmKey, lineHasDiff } = actions;
 const { onCommand } = require('./change-actions.js');
 const filesPane = require('./files-pane.js');
-const { handlePointer } = require('./pointer.js');
+const { handlePointer, handleContextKey } = require('./pointer.js');
 const { FIND_PANES, startFind, onFindKey } = require('./find.js');
 const { startImport, stopImport, onImportKey } = require('./import.js');
 const { unitBodyLines } = require('./view.js');
@@ -109,6 +109,7 @@ const HANDLERS = {
   packageLatest: (ui) => ui.packages.updateLatest(),
   npmLogs: (ui) => ui.npm.askLogs(),
   npmStop: (ui) => ui.npm.stop(),
+  npmSolve: (ui) => ui.npm.solve(),
   npmVerbose: (ui) => ui.npm.toggleVerbose(),
   npmRerun: (ui) => ui.npm.rerun(),
   agentModel: (ui) => ui.agents.openPick('model'),
@@ -116,10 +117,16 @@ const HANDLERS = {
   agentFast: (ui) => ui.agents.toggleFast(),
   agentContext: (ui) => ui.agents.openPick('context'),
   agentReview: (ui) => ui.agents.openPick('plan'),
-  agentContinue: (ui) => ui.agents.continueSession(),
+  agentInstall: (ui) => ui.agents.proposeInstall(),
+  agentStart: (ui) => ui.agents.startSelected(),
   agentStop: (ui) => ui.agents.stop(),
   agentRerun: (ui) => ui.agents.rerun(),
   quit: (ui) => ui.onQuit(),
+  treeLeft: (ui) => ui.worktrees.moveTree(-1),
+  treeRight: (ui) => ui.worktrees.moveTree(1),
+  worktreeNew: (ui) => ui.worktrees.onAdd(),
+  worktreeDrop: (ui) => ui.worktrees.onDrop(),
+  worktreeBranch: (ui) => ui.worktrees.onBranch(),
   repoLeft: (ui) => ui.workspace.move(-1, 0),
   repoRight: (ui) => ui.workspace.move(1, 0),
   repoUp: (ui) => ui.workspace.move(0, -1),
@@ -127,7 +134,22 @@ const HANDLERS = {
   ...DASH_HANDLERS,
 };
 
-const dispatchAction = (ui, action) => {
+// The keys of a branch do the same to the selected tile of the worktrees
+const TREE_ACTIONS = {
+  newBranch: 'worktreeNew',
+  drop: 'worktreeDrop',
+};
+const TREE_OFF = ['rebase', 'commit'];
+
+const forSelection = (ui, action) => {
+  if (!ui.worktrees.focused()) return action;
+  if (TREE_OFF.includes(action)) return null;
+  return TREE_ACTIONS[action] ?? action;
+};
+
+const dispatchAction = (ui, picked) => {
+  const action = forSelection(ui, picked);
+  if (!action) return;
   if (CONFIRM_MODE.includes(ui.mode)) return;
   if (ui.mode === 'import') stopImport(ui);
   if (action === 'lines' && (ui.pane === 'diff' || ui.pane === 'unit')) {
@@ -159,6 +181,10 @@ const CONFIRMATIONS = {
     accept: (ui) => ui.updater.accept(),
     decline: (ui) => ui.updater.decline(),
   },
+  confirmAgentInstall: {
+    confirm: (ui) => ui.agents.confirmInstall(),
+    cancel: (ui) => ui.agents.cancelInstall(),
+  },
   confirmDrop: {
     confirm: (ui) => {
       if (ui.packages.dropName) return void ui.packages.confirmDrop();
@@ -173,6 +199,14 @@ const CONFIRMATIONS = {
       ui.gitBranches.cancelDropBranch();
     },
   },
+  confirmWorktree: {
+    confirm: (ui) => ui.worktrees.confirmDrop(),
+    cancel: (ui) => ui.worktrees.cancelDrop(),
+  },
+  confirmCreateWorktree: {
+    confirm: (ui) => ui.worktrees.confirmBranch(),
+    cancel: (ui) => ui.worktrees.cancelBranch(),
+  },
   confirmPush: {
     force: (ui) => ui.gitBranches.onForcePush(),
     cancel: (ui) => ui.gitBranches.cancelPush(),
@@ -194,7 +228,10 @@ const confirmChoice = (ui, key) => {
 
 const NPM_VIEW_KEYS = {
   escape: (ui) => ui.npm.closeView(),
-  s: (ui) => ui.npm.stop(),
+  s: (ui) => {
+    if (ui.npm.viewedRunning()) ui.npm.stop();
+    else ui.npm.solve();
+  },
   r: (ui) => ui.npm.rerun(),
   v: (ui) => ui.npm.toggleVerbose(),
   e: () => {},
@@ -254,7 +291,9 @@ const planMenuKey = (ui, key) => {
 };
 
 const handleKey = (ui, key) => {
+  ui.nav.editDrag = null;
   if (CONFIRM_MODE.includes(ui.mode)) return void confirmChoice(ui, key);
+  if (handleContextKey(ui, key)) return;
   if (planMenuKey(ui, key)) return;
   if (ui.pane === 'tasks' && (key === 'ctrl-up' || key === 'ctrl-down')) {
     if (ui.mode === 'import') stopImport(ui);

package/lib/session/editor-pointer.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const { indexAtRow } = require('../term/wrap.js');
+
+const hitAt = (hits, cell) =>
+  hits.find((hit) => {
+    if (hit.y !== cell.y) return false;
+    const x0 = hit.x0 ?? hit.textX;
+    return cell.x >= x0 && (hit.x1 === undefined || cell.x < hit.x1);
+  });
+
+const offsetOf = (hit, cellX) => {
+  const col = Math.max(0, cellX - hit.textX) + (hit.scroll || 0);
+  const at = indexAtRow(hit.start || 0, hit.text, col);
+  return Math.min(at, hit.limit ?? Infinity);
+};
+
+const focusField = (ui, hit) => {
+  if (ui.composeKind !== 'npm' || !hit.field) return true;
+  if (hit.field === ui.npm.editField) return true;
+  return ui.npm.focusField(hit.field);
+};
+
+const activeEditor = (ui) => {
+  if (ui.pane === 'agents' && ui.agents.pick) return ui.agents.pick.editor;
+  if (ui.pane === 'tasks' && ui.composer.tasks.planOpen) {
+    return ui.composer.tasks.planPick.editor;
+  }
+  if (ui.mode === 'find') return ui.nav.find?.editor;
+  if (ui.mode === 'import') return ui.nav.import?.editor;
+  return ui.mode === 'compose' ? ui.editor : null;
+};
+
+const editorHits = (ui, editor) =>
+  (ui.lastFrame?.editHits ?? []).filter(
+    (hit) => (hit.editor ?? ui.editor) === editor,
+  );
+
+const revealEditor = (ui) => {
+  if (ui.mode === 'compose') ui.composer.afterEdit();
+  ui.paint();
+};
+
+const beginEditDrag = (ui, cell, extend = false) => {
+  const editor = activeEditor(ui);
+  if (!editor) return false;
+  const hit = hitAt(editorHits(ui, editor), cell);
+  if (!hit) return false;
+  if (!focusField(ui, hit)) {
+    ui.paint();
+    return true;
+  }
+  const previous = editor.anchor ?? editor.cursor;
+  const anchor = extend ? previous : offsetOf(hit, cell.x);
+  editor.place(offsetOf(hit, cell.x));
+  if (extend && anchor !== editor.cursor) editor.anchor = anchor;
+  ui.nav.clearSelection();
+  ui.nav.editDrag = { editor, anchor, field: hit.field, cell };
+  revealEditor(ui);
+  return true;
+};
+
+const moveEditDrag = (ui, cell, release = false) => {
+  const drag = ui.nav.editDrag;
+  if (!drag) return false;
+  if (release && drag.cell.x === cell.x && drag.cell.y === cell.y) {
+    ui.nav.editDrag = null;
+    return true;
+  }
+  if (activeEditor(ui) === drag.editor) {
+    const hits = editorHits(ui, drag.editor).filter(
+      (hit) => hit.field === drag.field,
+    );
+    const hit = hits.reduce((nearest, candidate) => {
+      if (!nearest) return candidate;
+      return Math.abs(candidate.y - cell.y) < Math.abs(nearest.y - cell.y)
+        ? candidate
+        : nearest;
+    }, null);
+    if (hit) {
+      const x = Math.min(cell.x, (hit.x1 ?? cell.x + 1) - 1);
+      drag.editor.place(offsetOf(hit, x));
+      if (drag.anchor !== drag.editor.cursor) drag.editor.anchor = drag.anchor;
+      drag.cell = cell;
+      revealEditor(ui);
+    }
+  }
+  if (release) ui.nav.editDrag = null;
+  return true;
+};
+
+module.exports = {
+  hitAt,
+  offsetOf,
+  focusField,
+  beginEditDrag,
+  moveEditDrag,
+};

package/lib/session/files-pane.js

@@ -107,6 +107,9 @@ const onFiles = (ui) => {
 
 const onOpenFile = (ui) => {
   if (ui.nav.pane === 'packages') return;
+  if (ui.nav.pane === 'branches' && ui.worktrees.focused()) {
+    return void ui.ops.hold(ui.worktrees.enterSelected());
+  }
   if (ui.nav.pane === 'branches') {
     return void ui.gitBranches.onCheckoutBranch();
   }

package/lib/session/lifecycle.js

@@ -6,6 +6,9 @@ const path = require('node:path');
 const { isAbort } = require('../common/process.js');
 const { tagLoaded, fetchSnapshot, fetchExtras } = require('./load.js');
 const { DiskWatcher, DEBOUNCE_MS } = require('../dashboard/watch.js');
+const { watchedBy } = require('../dashboard/worktrees.js');
+const { dirKey } = require('../git/linked.js');
+const { resolveGitDirs } = require('../git/dir.js');
 const { itemPath, REVIEW_DIR } = require('../common/files.js');
 const { relativeAge } = require('../common/format.js');
 const { MANIFEST, LOCKFILE, depFileMeta } = require('../deps/deps.js');
@@ -73,16 +76,28 @@ class Lifecycle {
   constructor(ui) {
     this.ui = ui;
     this.diskWatcher = null;
+    this.treeWatcher = null;
     this.watchRetry = null;
     this.reviewStamp = '';
     this.ignoreWatchUntil = 0;
-    this.cachedExtras = null;
+    this.extras = new Map();
   }
 
   get root() {
     return this.ui.top || this.ui.cwd;
   }
 
+  // The reports of npm are kept for each worktree: showing another one does
+  // not ask npm again, and the reports of one are never taken for another
+  get cachedExtras() {
+    return this.extras.get(this.root) ?? null;
+  }
+
+  set cachedExtras(entry) {
+    if (entry) this.extras.set(this.root, entry);
+    else this.extras.delete(this.root);
+  }
+
   loadOptions(extra = {}) {
     const ui = this.ui;
     return {
@@ -194,7 +209,9 @@ class Lifecycle {
     const here = ui.current();
     ui.top = loaded.top ?? ui.cwd;
     this.applyPrefs();
-    collection.replace(loaded.items);
+    const seen = loaded.seenEpoch;
+    const fresh = seen === undefined || seen === ui.ops.writeEpoch;
+    if (fresh) collection.replace(loaded.items);
     stampItemDates(ui.top, collection.items);
     this.applySource(loaded);
     if (!ui.review.store) ui.initReview();
@@ -242,7 +259,7 @@ class Lifecycle {
   }
 
   clearNpmExtras() {
-    this.cachedExtras = null;
+    this.extras.clear();
   }
 
   npmExtras() {
@@ -279,7 +296,8 @@ class Lifecycle {
     const next = outcome.value;
     if (!this.isWanted(gen)) return;
     if (next) {
-      this.applyLoaded(tagLoaded(next, gen));
+      const seenEpoch = loaded.seenEpoch;
+      this.applyLoaded(tagLoaded({ ...next, seenEpoch }, gen));
       this.cacheNpmExtras(next);
     } else {
       ui.loader.pendingExtras = false;
@@ -316,6 +334,17 @@ class Lifecycle {
     if (extra.afterLoad) extra.afterLoad();
   }
 
+  // Remember the write epoch so a snapshot that started before stage or
+  // unstage does not paint that older index over the optimistic items.
+  async fetchSettled() {
+    const ui = this.ui;
+    const seenEpoch = ui.ops.writeEpoch;
+    const opts = this.snapshotOpts({ signal: ui.loader.signal });
+    const loaded = await fetchSnapshot(ui.repo, ui.cwd, ui.paths, opts);
+    if (!loaded) return loaded;
+    return { ...loaded, seenEpoch };
+  }
+
   async runSnapshot(gen, kind, extra = {}) {
     const ui = this.ui;
     if (extra.quiet !== true) {
@@ -326,8 +355,7 @@ class Lifecycle {
     let loaded = null;
     const side = ui.reads.read();
     try {
-      const opts = this.snapshotOpts({ signal: ui.loader.signal });
-      loaded = await fetchSnapshot(ui.repo, ui.cwd, ui.paths, opts);
+      loaded = await this.fetchSettled();
     } catch (error) {
       if (ui.loader.isCurrent(gen)) this.failOpen(error);
     }
@@ -477,21 +505,46 @@ class Lifecycle {
   stopWatch() {
     this.clearWatchRetry();
     this.reviewStamp = '';
+    this.stopTreeWatch();
     if (!this.diskWatcher) return;
     this.diskWatcher.close();
     this.diskWatcher = null;
   }
 
+  stopTreeWatch() {
+    if (!this.treeWatcher) return;
+    this.treeWatcher.close();
+    this.treeWatcher = null;
+  }
+
+  // The other worktrees of the repository are watched for their tiles; the
+  // one that is shown is watched with everything else
+  watchTrees() {
+    this.stopTreeWatch();
+    const ui = this.ui;
+    const info = ui.treesInfo;
+    if (!info || ui.trees.rows.length < 2 || !ui.top) return;
+    const root = dirKey(info.root);
+    const paths = [];
+    for (const row of ui.trees.rows) {
+      const dirs = resolveGitDirs(row.key);
+      if (dirs) paths.push(dirKey(dirs.gitDir));
+      if (row.key !== dirKey(root)) paths.push(row.key);
+    }
+    const onPaths = (rels) => ui.trees.notePaths(rels);
+    this.treeWatcher = new DiskWatcher({ root, paths, onPaths });
+  }
+
   startWatch() {
     this.stopWatch();
     const ui = this.ui;
     if (ui.nav.pane === 'repos') {
-      const root = ui.workspaceRoot;
-      if (!root) return;
+      if (!ui.workspaceRoot) return;
+      const root = dirKey(ui.workspaceRoot);
       const info = ui.workspaceInfo;
       const repos = info ? info.repos : [];
       const paths = ['.'];
-      for (const repo of repos) paths.push(path.join(repo.name, '.git'));
+      for (const repo of repos) paths.push(...watchedBy(root, repo));
       const matchReview = (rel) => rel.includes(`/${REVIEW_DIR}/`);
       const onPaths = (rels) => ui.workspace.notePaths(rels);
       const options = { root, paths, matchReview, onPaths };
@@ -505,10 +558,14 @@ class Lifecycle {
       paths: this.ui.paths,
       onChange: () => this.onDiskChange(),
       onReview: () => this.applyReviewChange(),
-      onPaths: (paths) => this.ui.dashboard.noteDisk(paths),
+      onPaths: (paths) => {
+        this.ui.dashboard.noteDisk(paths);
+        this.ui.trees.notePaths(paths);
+      },
     });
     this.syncItemWatches();
     this.noteReviewStamp();
+    this.watchTrees();
   }
 }
 

package/lib/session/navigation.js

@@ -17,6 +17,7 @@ class Navigation {
     this.index = 0;
     this.fileCursor = 0;
     this.branchCursor = 0;
+    this.treeFocus = false;
     this.commitCursor = 0;
     this.npmCursor = 0;
     this.packagesCursor = 0;
@@ -28,9 +29,11 @@ class Navigation {
     this.unitLine = 0;
     this.selection = null;
     this.mouseAnchor = null;
+    this.editDrag = null;
     this.pendingClick = null;
     this.scrollDrag = null;
     this.lastClick = null;
+    this.contextMenu = null;
     this.tasksOpen = false;
     this.tasksFocus = 0;
     this.find = null;
@@ -99,8 +102,10 @@ class Navigation {
   clearSelection() {
     this.selection = null;
     this.mouseAnchor = null;
+    this.editDrag = null;
     this.pendingClick = null;
     this.scrollDrag = null;
+    this.contextMenu = null;
   }
 
   get listScroll() {

package/lib/session/npm/history.js

@@ -221,7 +221,8 @@ const whenLabel = (ms) => {
 };
 
 const elapsedText = (run, now) => {
-  const end = run.endedAt || now;
+  const end =
+    run.status === 'running' ? now : run.endedAt || run.startedAt || 0;
   const ms = Math.max(0, end - (run.startedAt || end));
   const sec = Math.round(ms / 1000);
   if (sec < 60) return `${sec}s`;

package/lib/session/npm/npm.js

@@ -30,6 +30,8 @@ const { historyName, historyMark, countText, elapsedText } = historyPart;
 const { whenLabel, runLabel, logBase, applyExternal } = historyPart;
 const { recordedItem, sameWindow, noteTests, filteredOutput } = historyPart;
 const { size } = require('../../common/format.js');
+const { TASKS_FILE } = require('../../common/files.js');
+const { stripAnsi } = require('../../term/ansi.js');
 
 const NAME_RE = /^[\w:.-]+$/;
 
@@ -54,11 +56,30 @@ class NpmController extends RunPanel {
     this.reset();
   }
 
+  // Runs belong to the worktree they started in and go on while another
+  // one is shown
+  get runs() {
+    let list = this.byTop.get(this.ui.top);
+    if (!list) {
+      list = [];
+      this.byTop.set(this.ui.top, list);
+    }
+    return list;
+  }
+
+  set runs(list) {
+    this.byTop.set(this.ui.top, list);
+  }
+
+  everyRun() {
+    return [...this.byTop.values()].flat();
+  }
+
   reset() {
-    for (const run of this.runs ?? []) {
+    for (const run of this.byTop ? this.everyRun() : []) {
       if (run.status === 'running' && run.child) run.child.kill();
     }
-    this.runs = [];
+    this.byTop = new Map();
     this.nextId = 1;
     this.viewId = 0;
     this.focus = 'commands';
@@ -83,7 +104,28 @@ class NpmController extends RunPanel {
   }
 
   get running() {
-    return this.runs.some((run) => run.status === 'running');
+    return this.everyRun().some((run) => run.status === 'running');
+  }
+
+  // The count of runs in work by the directory they started in
+  liveByRoot() {
+    const live = new Map();
+    for (const run of this.everyRun()) {
+      if (run.status !== 'running') continue;
+      live.set(run.top, (live.get(run.top) ?? 0) + 1);
+    }
+    return live;
+  }
+
+  // Another worktree is shown: its commands and runs replace these
+  retarget() {
+    this.viewing = false;
+    this.verbose = false;
+    this.viewId = 0;
+    this.runCursor = 0;
+    this.commands = [];
+    this.dropName = '';
+    this.logBytes = 0;
   }
 
   view(active) {
@@ -103,6 +145,7 @@ class NpmController extends RunPanel {
       npmDraftName: this.draftName,
       npmDraftCommand: this.draftCommand,
       npmRunning: this.viewedRunning(),
+      npmCanSolve: this.canSolve(),
       npmLogs: active ? this.logLabel : '',
     };
   }
@@ -173,6 +216,39 @@ class NpmController extends RunPanel {
     return Boolean(run && run.status === 'running');
   }
 
+  canSolve() {
+    const run = this.viewedRun();
+    if (!this.viewing || !run || run.status !== 'exited') return false;
+    return run.exit !== 0 && run.exit !== '0' && run.exit !== '';
+  }
+
+  solve() {
+    const ui = this.ui;
+    if (!this.canSolve() || !ui.review.store) return;
+    const run = this.viewedRun();
+    this.hydrate(run);
+    this.syncOutput(run);
+    const root = run.top ?? ui.top;
+    const output = stripAnsi(
+      run.raw
+        ? filteredOutput(run.raw, root, run.exit).output
+        : reduceOutput(run.output, root, ''),
+    ).trim();
+    const limit = 6000;
+    const shortened =
+      output.length > limit
+        ? `${output.slice(0, limit)}\n… (truncated)`
+        : output;
+    const command = run.command || run.label || runLabel(run);
+    const text = `${command} failed (exit ${run.exit})\n\n${shortened}`;
+    const task = ui.review.store.addTask(TASKS_FILE, text, false, 'bugs');
+    this.closeView();
+    const tasks = ui.composer.tasks;
+    tasks.openTasksPage();
+    tasks.followRow({ task });
+    ui.flushReview(true);
+  }
+
   historyRuns() {
     const runs = this.runs.filter((run) => !launchedReslop(run));
     return foldSteps(runs).slice(0, RUN_KEEP);
@@ -249,6 +325,7 @@ class NpmController extends RunPanel {
       logName: item.logName,
       rawName: item.rawName,
       externalId: item.externalId || '',
+      top: this.ui.top,
       result: item.result ?? null,
       progress: item.progress ?? null,
       saved: true,
@@ -508,8 +585,9 @@ class NpmController extends RunPanel {
     if (!run.stale) return false;
     run.stale = false;
     run.shownAt = Date.now();
-    noteTests(run, this.runs, run.raw);
-    run.output = filteredOutput(run.raw, this.ui.top, '').output;
+    const top = run.top ?? this.ui.top;
+    noteTests(run, this.byTop.get(top) ?? this.runs, run.raw);
+    run.output = filteredOutput(run.raw, top, '').output;
     return true;
   }
 
@@ -521,25 +599,23 @@ class NpmController extends RunPanel {
 
   async finishRun(run, entry, result) {
     const ui = this.ui;
+    const top = run.top ?? ui.top;
     const stopped = run.stopping === true;
     const raw = stopped ? withNotice(run.raw, 'terminated') : result.text;
     let slot = null;
     try {
-      slot = nextLogFile(ui.top, entry.name);
+      slot = nextLogFile(top, entry.name);
     } catch (error) {
       ui.status = error.message;
     }
     const rawFile = slot ? slot.rawName : '';
     const stoppedOutput = () => {
-      const output = withNotice(
-        reduceOutput(run.raw, ui.top, ''),
-        'terminated',
-      );
+      const output = withNotice(reduceOutput(run.raw, top, ''), 'terminated');
       return { output, log: output };
     };
     const filtered = stopped
       ? stoppedOutput()
-      : filteredOutput(result.text, ui.top, result.status, rawFile);
+      : filteredOutput(result.text, top, result.status, rawFile);
     run.raw = raw;
     run.stale = false;
     run.exit = stopped ? '' : result.status;
@@ -576,6 +652,7 @@ class NpmController extends RunPanel {
       exit: '',
       startedAt: Date.now(),
       endedAt: 0,
+      top: ui.top,
     });
     this.nextId += 1;
     this.runs.push(run);
@@ -659,7 +736,7 @@ class NpmController extends RunPanel {
   }
 
   stopAll() {
-    for (const run of this.runs) this.stop(run);
+    for (const run of this.everyRun()) this.stop(run);
   }
 
   toggleVerbose() {