agentbox-app 0.1.11 → 0.1.13

package/main/ipc.mjs

@@ -40,15 +40,16 @@ import { readDoc, writeDoc } from './doc-file.mjs';
 import { readChange } from './code-change.mjs';
 import { findFile, readCodeFile, writeCodeFile } from './code-file.mjs';
 import { readNote, writeNote } from './rail-note.mjs';
-import { addClaudeAccount, addCodexAccount, outsideAgentsMode, permissionMode, readSettings, recheckClaude, recheckCodex, setProjectSetting, setWorkspaceSetting } from './settings.mjs';
+import { addClaudeAccount, addCodexAccount, outsideAgentsMode, permissionMode, pointAtEngineBin, readSettings, recheckClaude, recheckCodex, searchForEngineBin, setProjectSetting, setWorkspaceSetting } from './settings.mjs';
 import { ICON_KINDS, clearProjectIcon, setProjectIcon, setProjectName } from './project-identity.mjs';
 import { ClaudeUsage } from './claude-usage.mjs';
 import { usageEngine } from '../shared/usage.mjs';
-import { DEFAULT_ENGINE } from '../shared/engines.mjs';
+import { DEFAULT_ENGINE, isEngine } from '../shared/engines.mjs';
 import * as agents from './agents.mjs';
 import { findAgentFolders, readAgentFiles, readFolderAgents } from './agent-files.mjs';
-import { readSessionThreads } from './agent-sessions.mjs';
 import { readCodexThreads } from './codex-threads.mjs';
+import { appSessionFolders } from './agent-homes.mjs';
+import { readImportableThreads } from './importable-threads.mjs';
 import { markImported } from '../shared/agent-import.mjs';
 import { codexIdOf, importChoice, isCodexImportRow, isNotImportedRow } from '../shared/codex-import.mjs';
 import { checkProjectFolder } from '../shared/project-folder-check.mjs';
@@ -91,6 +92,9 @@ const NO_UPDATER = {
   }),
   check: async () => NO_UPDATER.state(),
   install: () => false,
+  // Nowhere to move to and nothing to move: a copy with no updater behind it
+  // is a copy run from source (shared/where-it-runs-from.mjs).
+  move: () => ({ moved: false, error: null }),
 };
 
 export function registerIpc({ store, supervisor, config, window, analytics = NO_ANALYTICS, docGrants = null, updater = NO_UPDATER, host, team = null }) {
@@ -259,9 +263,17 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
     // while the app is running and the settings screen already promises that
     // works without a restart.
     bin: () => config.claudeBin,
+    // The account marked In use, asked each time so a switch is read at once.
+    account: () => supervisor.usageAccount(),
     onChange: push,
   });
 
+  ipcMain.handle('zero:refresh-usage', async event => {
+    if (event.senderFrame?.parent || (event.sender && event.sender !== window.webContents)) throw Error('Usage refresh is only available in the main app window.');
+    const result = await usage.refreshNow();
+    return result.reading ? { ...result, reading: { engine: DEFAULT_ENGINE, ...result.reading } } : result;
+  });
+
   // Agents this run has already counted. In memory on purpose: a fresh launch
   // seeing the same agent again is a fresh fact about the app being used.
   const seenAgents = new Set();
@@ -279,11 +291,17 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
       // send one event per agent per tick, all day. The keys are only ever
       // compared in this process; nothing about an agent is sent with the
       // count, which carries no name, no path and no title.
+      //
+      // AND WHICH ENGINE IT WAS (w-1116fbb68a, 2026-10-08). This list is Claude
+      // Code processes and only ever has been; a Codex conversation has no
+      // process to find and is counted from main/codex-watch.mjs instead. The
+      // engine is what lets the two be read apart, and without it on this side
+      // the Codex count would look like a drop in the Claude one.
       for (const agent of live) {
         const key = agentKey(agent);
         if (!key || seenAgents.has(key)) continue;
         seenAgents.add(key);
-        analytics.track('agent_seen');
+        analytics.track('agent_seen', { engine: 'claude' });
       }
       return live;
     } catch {
@@ -341,13 +359,13 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
   });
   ipcMain.handle('zero:terminal',(_event,payload={})=>{
     if(_event.senderFrame?.parent || (_event.sender && _event.sender!==window.webContents)) throw Error('Terminal is only available in the main app window.');
-    const {product,id,action,data,cols,rows,offset}=payload;
+    const {product,id,action,data,cols,rows,offset,wait}=payload;
     if(typeof product!=='string'||typeof id!=='string'||!id||id.length>300)throw Error('Invalid task.');
     const key=JSON.stringify({product,id});
     if(product==='@agent-update')return agentUpdates.terminal(id,payload);
     switch(action){
       case 'open':return terminals.open(key);
-      case 'read':return terminals.read(key,offset);
+      case 'read':return terminals.read(key,offset,wait);
       case 'write':terminals.write(key,data);return true;
       case 'resize':terminals.resize(key,cols,rows);return true;
       case 'close':terminals.close(key);return true;
@@ -360,6 +378,21 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
   ipcMain.handle('zero:older-items', (_e, { offset = 0, limit = 50 } = {}) =>
     store.listOlderItems({ offset: Number(offset) || 0, limit: Math.min(Number(limit) || 50, 200) }));
 
+  // IS ANYBODY ACTUALLY USING A SCREEN READER. Asked by the terminal pane
+  // before it builds an xterm, because xterm's accessibility tree is what
+  // `screenReaderMode` turns on and we used to turn it on for everybody.
+  // Electron's own words beside this property: "Rendering accessibility tree
+  // can significantly affect the performance of your app. It should not be
+  // enabled by default." It also carried xterm's 'invalid range' bug to an
+  // install that had no use for it (one crash report, 2026-10-08).
+  //
+  // Absent on Linux and before `ready`, where absent means no, and reading it
+  // may not throw: this is on the path that opens a terminal, and a terminal
+  // that cannot ask the question still has to open.
+  ipcMain.handle('zero:assistiveTech', () => {
+    try { return !!host.app?.accessibilitySupportEnabled; } catch { return false; }
+  });
+
   ipcMain.handle('zero:snapshot', () => {
     const now = Date.now();
     const items = store.listItems(now);
@@ -379,7 +412,8 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
     const reading = usageFor === DEFAULT_ENGINE ? usage.read() : supervisor.codexUsage();
     return {
       products: store.listProducts(),
-      items,
+      // Each with the place she dragged it to, if she did (w-6e5b532a95).
+      items: supervisor.withPlaces(items),
       // THE TEAM: who is signed in, their team and its people, and the
       // title-free activity of their private work. Null on a build with no
       // team cloud, which is the single-person app.
@@ -400,6 +434,17 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
       // coding agent this is one entry and an empty map, and nothing anywhere
       // draws anything new.
       engines,
+      // WHETHER THIS MAC WAS ALREADY SIGNED INTO SOMETHING (w-e217e577e5,
+      // 2026-10-07), so the walk can say so once. A new user ran an agent and
+      // could not tell where the tokens were coming from, because the app finds
+      // whichever sign-in is already on the Mac and spends it in silence.
+      //
+      // It rides the snapshot rather than the settings model because the WALK
+      // reads it, and the settings model is only fetched while the settings
+      // screen is open. It costs no file read per tick: `main/runs-on.mjs`
+      // caches on the login files' own modification times, so this re-parses
+      // only after a sign-in or a profile refetch.
+      runsOn: supervisor.runsOnAccount(engines.workspace),
       // Whether this process is still the app on disk. It rides the snapshot
       // rather than boot-info because the staleness DEVELOPS while the app
       // runs: the case that cost her three times was a process left up for days
@@ -469,7 +514,19 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
       // it and the user's own sentence never reached the card: the row went on
       // saying only what the session was started with days before. This is the
       // only process that knows the user said it, so this is where it is written.
-      if (out?.ok && out.key) agentSchedule.replied(out.key, out.at ?? Date.now(), Date.now(), String(text ?? ''));
+      //
+      // AND IT IS A REPLY, SO IT IS COUNTED (w-1116fbb68a, 2026-10-08). A reply
+      // on a task has always sent `reply_sent`; one typed into a live session
+      // sent nothing at all, and activation is read as three real replies to
+      // agents in the first day, so the people who talk to their own sessions
+      // rather than through a row were missing from it. `kind` says which of
+      // the two this was. It waits on the same delivery the mark does, and for
+      // the same reason: a count for words that never arrived would read as
+      // activation nobody had.
+      if (out?.ok) {
+        if (out.key) agentSchedule.replied(out.key, out.at ?? Date.now(), Date.now(), String(text ?? ''));
+        analytics.track('reply_sent', { kind: 'agent' });
+      }
       push();
       return out;
     } catch {
@@ -535,6 +592,12 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
 
   ipcMain.handle('zero:answer', async (_e, { product, id, answer, status, priority, permissionMode, model, effort, now, inReplyTo }) => {
     if (isAgentRow(id)) return { ok: false };
+    // A level picked from ⌘K arrives here with no words, and gives way the
+    // same as one picked on the summary (zero:thread-edit). A reply that
+    // happens to carry its row's level does not.
+    if (priority != null && !answer && id) supervisor.setThreadPlaces({ [id]: null });
+    // CLOSING A THREAD IS THE END OF WHAT IT WAS PINNED FOR (w-20323283e6).
+    if (id && status === 'done') supervisor.setThreadPins({ [id]: null });
     // A REPLY IN A THREAD (w-920461cbe6) only means something in a conversation
     // between people, which is the only place a thread is drawn and the only
     // record the mark crosses to a teammate in (shared/team-rules.mjs). Anywhere
@@ -553,7 +616,10 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
         if (choice) {
           let thread = null;
           if (choice === 'yes') {
-            try { thread = readCodexThreads({}).threads.find((t) => t.id === codexIdOf(row)) ?? null; } catch { thread = null; }
+            try {
+              const { codexDirs } = appSessionFolders({ config, supervisor });
+              thread = readCodexThreads({ codexDirs }).threads.find((t) => t.id === codexIdOf(row)) ?? null;
+            } catch { thread = null; }
           }
           const out = store.answerCodexImport(product, id, choice, { thread });
           push();
@@ -599,6 +665,21 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
     return supervisor.status();
   });
 
+  // A THREAD DRAGGED TO A PLACE OF ITS OWN in the list (w-6e5b532a95): the
+  // places the drop worked out (`dropPlaces`, shared/rank.mjs), id to number.
+  ipcMain.handle('zero:set-thread-places', (_e, { places }) => {
+    supervisor.setThreadPlaces(places);
+    push();
+    return { ok: true };
+  });
+
+  // PINNED THREADS (w-20323283e6): id to true, or null to unpin.
+  ipcMain.handle('zero:set-thread-pins', (_e, { pins }) => {
+    supervisor.setThreadPins(pins);
+    push();
+    return { ok: true };
+  });
+
   // Hidden from the composer's picker and nothing else: a hidden product still
   // ranks, still spawns workers, and its work still reaches the inbox.
   ipcMain.handle('zero:set-product-hidden', (_e, { product, hidden }) => {
@@ -685,6 +766,9 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
   ipcMain.handle('zero:thread-edit', (_e, { product, id, patch }) => {
     try {
       store.threadEdit(product, id, patch);
+      // PICKING A LEVEL IS THE NEWER WORD on where a thread goes, so a place
+      // it was dragged to gives way and it sorts by its level again.
+      if (patch?.priority != null) supervisor.setThreadPlaces({ [id]: null });
       push();
       return { ok: true };
     } catch (err) {
@@ -851,6 +935,14 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
     return store.scheduleItem(product, id, runAt);
   });
 
+  // Snooze changes when a person sees the thread, never what an agent does.
+  ipcMain.handle('zero:snooze', (_e, { product, id, snoozedUntil }) => {
+    if (isAgentRow(id)) return { ok: false };
+    const item = store.snoozeItem(product, id, snoozedUntil);
+    push();
+    return item;
+  });
+
   // said about an agent instead of about a task. The row it moves stands for
   // somebody's terminal, so this writes to no ledger, sends no message and
   // stops no process: it records the moment her inbox should raise the agent
@@ -919,11 +1011,18 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
   // an archive, so it does not collide with what done means on a work item.
   ipcMain.handle('zero:end-repeat', (_e, { product, id }) => store.endRepeat(product, id));
 
-  ipcMain.handle('zero:create-product', (_e, { name, repoPath }) => {
+  ipcMain.handle('zero:create-product', (_e, { name, repoPath, ofMany }) => {
     const out = store.createProduct({ name, repoPath });
     // (privacy page 5.1). The count is the whole payload; the path it was
     // connected to never leaves.
-    if (typeof repoPath === 'string' && repoPath.trim()) analytics.track('repo_connected');
+    //
+    // AND A PRESS THAT CONNECTS NINE FOLDERS IS ONE THING SOMEBODY DID, NOT
+    // NINE (w-1116fbb68a, 2026-10-08). The import makes a project per folder,
+    // so this handler fired nine times for one press and nine events read as
+    // nine separate connections to anybody looking at them as activity rather
+    // than as a funnel step. `ofMany` is the caller saying it will count the
+    // press itself, once, with how many folders it connected.
+    if (!ofMany && typeof repoPath === 'string' && repoPath.trim()) analytics.track('repo_connected');
     return out;
   });
 
@@ -1063,13 +1162,10 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
   // 'codex'`, land under the project whose folder they ran in exactly as the
   // Claude Code ones do, and the ones the user said not now to are here too, so
   // there is a way back to them.
-  const readAllThreads = () => {
-    let claude = [];
-    let codex = [];
-    try { ({ threads: claude } = readSessionThreads({})); } catch { claude = []; }
-    try { ({ threads: codex } = readCodexThreads({})); } catch { codex = []; }
-    return [...claude, ...codex].sort((a, b) => (b.when ?? 0) - (a.when ?? 0));
-  };
+  // EVERY FOLDER EITHER TOOL KEEPS SESSIONS IN (main/agent-homes.mjs), not only
+  // ~/.claude and ~/.codex, which is where the import used to look and nothing
+  // else (w-e46f2e9cea).
+  const readAllThreads = () => readImportableThreads({ config, supervisor });
   ipcMain.handle('zero:agent-threads', () => {
     const threads = readAllThreads();
     lastThreads = threads;
@@ -1296,15 +1392,64 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
     }
   });
 
+  /*
+   * AND WHEN NEITHER BUTTON CAN FIND IT: POINT AT THE FILE YOURSELF
+   * (w-ce8c1a9275). The search asks the login shell first now, which covers
+   * every installer a person's own PATH knows about -- but a wrapper script
+   * somewhere nobody would guess, a tool on a volume, or a machine whose login
+   * shell will not start at all still used to mean a path WE ship and a release
+   * THEY wait for. This is the half that ends that.
+   *
+   * ONE ROUND TRIP, like `zero:project-icon` below and for the same reason: the
+   * panel opens in this process and the choice is applied in the same call, so
+   * the only path that ever reaches `pointAtEngineBin` is one the open panel
+   * itself produced. The window says WHICH coding agent it is asking about and
+   * nothing else, which is the whole of what it is trusted with -- `codexBin`
+   * is a path that gets spawned, and every worker on this machine has a broad
+   * Bash allow (tests/where-codex-runs-from-is-not-a-file-a-worker-can-write).
+   *
+   * THE REFUSAL IS A SENTENCE AND NOT AN ERROR. Picking a folder, or a file
+   * that cannot be run, is an ordinary mistake at a file panel; it comes back
+   * as words the row prints, the way `zero:choose-folder` already does.
+   */
+  ipcMain.handle('zero:engine-bin', async (_e, { engine, action } = {}) => {
+    if (engine !== 'claude' && engine !== 'codex') return { ok: false, error: 'Unknown coding agent.' };
+    try {
+      // Handing the choice back needs no panel: it is the row saying "look for
+      // it again", and the search takes over from there.
+      if (action === 'search') {
+        const gave = searchForEngineBin(config, engine);
+        if (!gave.ok) return { ok: false, refused: gave.say };
+        return { ok: true, ...readSettings({ config, supervisor, store }) };
+      }
+      const { dialog } = await import('electron');
+      const r = await dialog.showOpenDialog(window, {
+        title: engine === 'codex' ? 'Where is Codex?' : 'Where is Claude Code?',
+        buttonLabel: 'Use this one',
+        properties: ['openFile', 'showHiddenFiles', 'treatPackageAsDirectory'],
+      });
+      // Cancelling is not a failure and must not draw one. `ok` with nothing
+      // changed is the honest answer: they opened the panel and closed it again.
+      if (r.canceled || !r.filePaths?.length) return { ok: true, canceled: true };
+      const took = pointAtEngineBin(config, engine, r.filePaths[0]);
+      if (!took.ok) return { ok: false, refused: took.say };
+      return { ok: true, ...readSettings({ config, supervisor, store }) };
+    } catch (err) {
+      return { ok: false, error: String(err.message) };
+    }
+  });
+
   // SETTING UP THEIR PLAN FOR THEM (w-9f6975906c). The walk asks which plan
   // they pay for and this installs the tool and starts its own sign-in. The
   // finder is the recheck, so what gets installed lands on the config and the
   // rest of the app runs on it without a restart.
   const engineSetup = createEngineSetup({
     find: (engine) => {
-      if (engine === 'claude') { const s = recheckClaude(config); return { found: s.claudeFound, path: s.claudeBin }; }
-      const s = recheckCodex(config);
-      return { found: s.found, path: s.bin };
+      const finders = {
+        claude: () => { const s = recheckClaude(config); return { found: s.claudeFound, path: s.claudeBin }; },
+        codex: () => { const s = recheckCodex(config); return { found: s.found, path: s.bin }; },
+      };
+      return finders[engine]?.() ?? { found: false, path: null };
     },
     // WHICH ONE IS SIGNED IN, kept on the config for the run that reads it
     // (`Supervisor#_enginesFound`) and never saved: it changes outside the app.
@@ -1323,7 +1468,7 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
   // A sign-in left waiting on the browser is not left running after the app.
   app.on('will-quit', () => { engineSetup.cancel('claude'); engineSetup.cancel('codex'); });
   ipcMain.handle('zero:engine-setup', async (_e, { action, engine } = {}) => {
-    if (engine !== 'claude' && engine !== 'codex') return { ok: false, error: 'Unknown coding agent.' };
+    if (!isEngine(engine)) return { ok: false, error: 'Unknown coding agent.' };
     try {
       if (action === 'ready') return { ok: true, ...(await engineSetup.readiness(engine)) };
       if (action === 'start') return { ok: true, ...engineSetup.start(engine) };
@@ -1823,6 +1968,14 @@ export function registerIpc({ store, supervisor, config, window, analytics = NO_
   // to decide is when the app is allowed to disappear and come back.
   ipcMain.handle('zero:update-check', async () => updater.check({ manual: true }));
   ipcMain.handle('zero:update-install', () => ({ started: updater.install() }));
+  // AND A THIRD, for the copy that cannot update itself from where it is: move
+  // the app into Applications (shared/where-it-runs-from.mjs). It is a door of
+  // its own rather than part of the install, because it is the opposite
+  // decision — nothing has been downloaded and nothing will be until the app
+  // is somewhere macOS lets it write.
+  // A copy run from source answers no to it rather than throwing: there is no
+  // bundle to move (main/source-updater.mjs).
+  ipcMain.handle('zero:update-move', () => updater.move?.() ?? { moved: false, error: null });
 
   // Handed back so the Cmd+Y/Cmd+N chord answers through the same door the
   // buttons do, rather than reaching past it into approvals.answer.

package/main/local-app-frames.mjs

@@ -0,0 +1,82 @@
+// A LOCAL APP SHOWS IN THE PANE AND STAYS SIGNED IN.
+//
+// The pane draws an address like http://localhost:3006 in a frame, because a
+// frame keeps every shortcut the app answers from inside a page (the
+// before-input-event handler in main.mjs hears a frame; it would not hear a
+// webview's guest). Two things a local app commonly sends broke that frame:
+//
+//   X-Frame-Options / CSP frame-ancestors   Chromium refuses to draw the page
+//                                           at all, so the pane sat blank.
+//                                           Next.js apps send both.
+//   a SameSite=Lax sign-in cookie            the window is a file:// page, so
+//                                           the app in it is cross-site and the
+//                                           cookie is refused: sign-in loops.
+//
+// Both are rewritten here, below the page, for local addresses only and only
+// inside the app's own window. Framing protection exists to stop another site
+// drawing yours under a stranger's pointer; the app drawing her own dev server
+// for her is not that. tests/a-local-app-shows-in-the-pane-and-stays-signed-in.test.mjs
+
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+
+export function isLocalAddress(url) {
+  try {
+    const u = new URL(url);
+    return (u.protocol === 'http:' || u.protocol === 'https:') && LOCAL_HOSTS.has(u.hostname);
+  } catch { return false; }
+}
+
+const keyOf = (headers, name) => Object.keys(headers).find((k) => k.toLowerCase() === name);
+
+function withoutFrameAncestors(policy) {
+  return policy.split(';').map((d) => d.trim()).filter((d) => d && !/^frame-ancestors(\s|$)/i.test(d)).join('; ');
+}
+
+// SameSite=None needs Secure, and Chromium takes Secure from http://localhost
+// because it counts loopback as a secure origin.
+function sentInsideTheWindow(cookie) {
+  const parts = cookie.split(';').map((p) => p.trim());
+  if (parts.some((p) => /^samesite\s*=\s*none$/i.test(p))) return cookie;
+  const kept = parts.filter((p) => !/^samesite\s*=/i.test(p));
+  if (!kept.some((p) => /^secure$/i.test(p))) kept.push('SameSite=None', 'Secure');
+  else kept.push('SameSite=None');
+  return kept.join('; ');
+}
+
+/**
+ * The headers a local app's response should carry inside the pane, or null
+ * when nothing changes. `details` is Electron's onHeadersReceived details.
+ */
+export function localAppHeaders({ url, resourceType, responseHeaders }) {
+  if (!responseHeaders || resourceType === 'mainFrame' || !isLocalAddress(url)) return null;
+  const out = { ...responseHeaders };
+  let changed = false;
+  if (resourceType === 'subFrame') {
+    const xfo = keyOf(out, 'x-frame-options');
+    if (xfo) { delete out[xfo]; changed = true; }
+    const csp = keyOf(out, 'content-security-policy');
+    if (csp) {
+      const policies = out[csp].map(withoutFrameAncestors).filter(Boolean);
+      if (policies.join() !== out[csp].join()) {
+        changed = true;
+        if (policies.length) out[csp] = policies; else delete out[csp];
+      }
+    }
+  }
+  const cookies = keyOf(out, 'set-cookie');
+  if (cookies) {
+    const next = out[cookies].map(sentInsideTheWindow);
+    if (next.join('\n') !== out[cookies].join('\n')) { out[cookies] = next; changed = true; }
+  }
+  return changed ? out : null;
+}
+
+/** Wire it to the window's own session, for that window's requests only. */
+export function letLocalAppsShowInThePane(contents) {
+  const filter = { urls: ['*://localhost/*', '*://127.0.0.1/*', '*://[::1]/*'] };
+  contents.session.webRequest.onHeadersReceived(filter, (details, callback) => {
+    const ours = details.webContentsId === contents.id;
+    const responseHeaders = ours ? localAppHeaders(details) : null;
+    callback(responseHeaders ? { responseHeaders } : {});
+  });
+}

package/main/machine.mjs

@@ -156,5 +156,5 @@ export function perAccountAgents(total, accounts) {
 export function machineNote({ slots, memGb, cores, known = true }, at = 0) {
   if (!known) return null;
   if (at && at <= slots) return null;
-  return `This Mac has ${memGb} GB and ${cores} cores, so we suggest ${slots} at once. Go higher if you want to.`;
+  return `This computer has ${memGb} GB and ${cores} cores, so we suggest ${slots} at once. Go higher if you want to.`;
 }