mindvest-atlas 0.68.3 → 0.91.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.68.3",
+  "version": "0.91.0",
   "description": "Atlas CLI \u2014 OAuth login, tool calls, and live alert/flow streaming for the Atlas trading API",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -20,6 +20,9 @@ import { screenshotCommand } from './commands/screenshot.js';
 import { runCommand } from './commands/run.js';
 import { computerUseCommand } from './commands/computer-use.js';
 import { dashboardCommand } from './commands/dashboard.js';
+import { chatSearchCommand } from './commands/chat-search.js';
+import { connectorsCommand, connectorCommand } from './commands/connectors.js';
+import { memoryCommand } from './commands/memory.js';
 import { remoteCheckCommand } from './commands/remote-check.js';
 import { shareCommand } from './commands/share.js';
 import { historicalContractCommand } from './commands/historical.js';
@@ -130,6 +133,26 @@ export async function main(rawArgs) {
       // hand (owner, 2026-09-06).
       case 'dashboard':
         return dashboardCommand(withoutCommand(args));
+      // EVERY PAST CONVERSATION ON THIS COMPUTER, read where it lies (owner,
+      // 2026-09-18: "how do I do searching so every agent can search
+      // conversations"). Local files, so no cloud tool could do it; the
+      // running Studio knows where each agent keeps its own.
+      case 'chat-search':
+      case 'chats':
+        return await chatSearchCommand(withoutCommand(args));
+      // THE CONNECTORS ON THIS COMPUTER, brokers among them (owner,
+      // 2026-09-30: "add a CLI for these tools"). Their sign-ins never leave
+      // this machine, so no cloud tool could reach them.
+      case 'connectors':
+        return await connectorsCommand(withoutCommand(args));
+      case 'connector':
+        return await connectorCommand(withoutCommand(args));
+      // WHAT ATLAS KEEPS BETWEEN CONVERSATIONS: three tiers, decayed by use,
+      // weighted 1-10 by whoever is working (owner, 2026-09-19). Local files,
+      // so no cloud tool could do it.
+      case 'memory':
+      case 'mem':
+        return await memoryCommand(withoutCommand(args));
       // Put the newest CLI on this machine.
       case 'update-cli':
       case 'self-update':

package/src/commands/chat-search.js

@@ -0,0 +1,218 @@
+// `atlas chat-search` — every past conversation on this computer, searched
+// where it lies.
+//
+// Owner, 2026-09-18: "let's say I want to continue from another agent and my
+// sessions are not linked, how do I do searching so every agent can search
+// conversations … even ask() or a normal convo can check previous convo."
+//
+// The engine is in Atlas Studio (`main/core/chat-search.ts`) because that is
+// where the stores are known: the adapters' own transcripts, the chats Studio
+// keeps for every model reached over a port or a key (LM Studio, Ollama, any
+// provider), a project's own `.chats`, and whatever its sweep has found. This
+// command is the shell's way in, for the agent that is sitting at a prompt
+// rather than inside a project script — the same road `atlas screenshot` takes
+// to the dashboard.
+//
+// A HAND-WRITTEN COMMAND, DELIBERATELY. The rule is that a verb has to earn
+// one by doing something a cloud tool call cannot (2026-09-15). This reads
+// files on THIS disk; there is no cloud tool that could.
+//
+// NOTHING IS SHORTENED ON THE WAY THROUGH (owner, 2026-09-18: "DO NOT TRUNCATE
+// OR CUT"). Whatever the engine returns is printed whole; when there is too
+// much, the engine returns FEWER WHOLE TURNS and says so, and that sentence is
+// printed too.
+import { color, println, eprintln } from '../util/ui.js';
+import { askAddress } from '../remote-control.js';
+
+function notRunning() {
+  eprintln(color.red('Atlas Studio is not running on this computer.'));
+  eprintln(color.dim('It is what knows where each agent keeps its conversations. Start it and try again.'));
+  return 1;
+}
+
+async function post(at, path, body) {
+  const res = await fetch(at.url.replace('/ask', path), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-Atlas-Token': at.token },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(180_000),
+  });
+  const out = await res.json().catch(() => ({}));
+  if (!res.ok || !out.ok) throw new Error(out.error || `Chat search failed (${res.status}).`);
+  return out;
+}
+
+function printRows(rows, agent) {
+  for (const row of rows) {
+    const who = row.kind === 'user'
+      ? 'You'
+      : row.kind === 'assistant'
+        ? (agent || 'Model')
+        : `${row.kind === 'tool_call' ? 'Tool call' : 'Tool result'}: ${row.tool || 'tool'}`;
+    println(color.dim(`--- ${who} ---`));
+    println(row.text);
+    println('');
+  }
+}
+
+export async function chatSearchCommand(args) {
+  const flags = args.flags || {};
+  const at = askAddress(flags.root);
+  if (!at) return notRunning();
+
+  const sub = String((args.positional ?? args._)?.[0] || '').trim();
+
+  // WHAT THIS COMPUTER REMEMBERS about searching: which folders hold
+  // conversations, which of them answer, and where recent answers were. Paths
+  // and counters, never a conversation (owner, 2026-09-19: "store the search
+  // path or recent important stuff, so we can read this to find info quicker
+  // next time").
+  if (sub === 'forget') {
+    try {
+      await post(at, '/chat-search/forget', {});
+      println('Forgotten. Every conversation is exactly where it was; only the shortcuts are gone.');
+      return 0;
+    } catch (err) {
+      eprintln(color.red(err.message));
+      return 1;
+    }
+  }
+  if (sub === 'memory' || sub === 'places') {
+    let mem;
+    try {
+      mem = await post(at, '/chat-search/memory', {});
+    } catch (err) {
+      eprintln(color.red(err.message));
+      return 1;
+    }
+    if (flags.json) {
+      println(JSON.stringify(mem, null, 2));
+      return 0;
+    }
+    println(color.bold(`${mem.places.length} place(s) learned, ${mem.recent.length} pointer(s) kept`));
+    for (const p of mem.places) {
+      println(`  ${p.dir}  ${color.dim(`${p.agent} · ${p.parser}${p.hits ? ` · answered ${p.hits}x` : ''}`)}`);
+    }
+    for (const r of mem.recent.slice(0, 10)) {
+      println(`  "${r.query}" -> ${r.sessionId} ${color.dim(`(${r.agent} · ${r.store})`)}`);
+    }
+    return 0;
+  }
+
+  // `chat-search show <session>` — one conversation, as deep as asked. Its own
+  // call rather than a flag, because reading a conversation whole is a
+  // different act from finding one.
+  if (sub === 'show' || flags.show) {
+    const id = String(flags.show || (args.positional ?? args._)?.[1] || '').trim();
+    if (!id) {
+      eprintln(color.red('Which conversation? `atlas chat-search show <session-id>`'));
+      return 1;
+    }
+    let out;
+    try {
+      out = await post(at, '/chat-search/show', {
+        sessionId: id,
+        file: flags.file,
+        around: flags.around == null ? undefined : Number(flags.around),
+        // `--turns 0` is the whole thing; the default keeps it to the part
+        // around the start.
+        turns: flags.turns == null ? undefined : Number(flags.turns),
+        handover: !!flags.handover,
+        discover: !!flags.discover,
+      });
+    } catch (err) {
+      eprintln(color.red(err.message));
+      return 1;
+    }
+    if (flags.json) {
+      println(JSON.stringify(out, null, 2));
+      return 0;
+    }
+    if (flags.handover) {
+      // Exactly what you paste into another model as the first message.
+      println(out.handover);
+      return 0;
+    }
+    println(color.bold(out.title));
+    println(color.dim(`${out.agent} · ${out.store} · ${out.sessionId}${out.cwd ? ` · ${out.cwd}` : ''}`));
+    println(color.dim(`Turns ${out.from}-${out.to} of ${out.total}. Nothing below is shortened.`));
+    println('');
+    printRows(out.rows, out.agent);
+    return 0;
+  }
+
+  const query = String(flags.query || flags.q || (args.positional ?? args._)?.join(' ') || '').trim();
+  if (!query) {
+    eprintln(color.red('What are you looking for? `atlas chat-search "the words you remember"`'));
+    eprintln(color.dim('Then: atlas chat-search show <session> --turns 0    (the whole conversation)'));
+    return 1;
+  }
+
+  let out;
+  try {
+    out = await post(at, '/chat-search', {
+      query,
+      turns: flags.turns == null ? undefined : Number(flags.turns),
+      limit: flags.limit == null ? undefined : Number(flags.limit),
+      maxBytes: flags.bytes == null ? undefined : Number(flags.bytes),
+      store: flags.store,
+      agent: flags.agent,
+      since: flags.since ? Date.parse(String(flags.since)) || undefined : undefined,
+      matchCase: !!flags['match-case'],
+      regex: !!flags.regex,
+      // Look for stores nobody wrote a path for, unless told not to. What it
+      // finds is remembered as a FOLDER, so the next search already knows.
+      discover: flags['no-discover'] ? false : true,
+      // The project you are in comes first; everything else still comes back.
+      project: flags.project || flags.job || process.cwd(),
+      maxMs: flags.ms == null ? undefined : Number(flags.ms),
+    });
+  } catch (err) {
+    eprintln(color.red(err.message));
+    return 1;
+  }
+
+  if (flags.json) {
+    println(JSON.stringify(out, null, 2));
+    return 0;
+  }
+
+  if (!out.hits.length) {
+    println(`Nothing on this computer says "${query}".`);
+    println(color.dim(`Looked in ${out.scanned.places} place(s), ${out.scanned.files} transcript(s).`));
+    for (const note of out.notes) println(color.dim(note));
+    return 0;
+  }
+
+  // SEEN BEFORE. Offered beside the live answer, never instead of it: a store
+  // can change under a pointer.
+  if (out.remembered?.length) {
+    println(color.dim('Seen before:'));
+    for (const r of out.remembered) {
+      println(color.dim(`  "${r.query}" -> ${r.sessionId} (${r.agent} · ${r.store})`));
+    }
+    println('');
+  }
+
+  println(color.bold(`${out.hits.length} of ${out.found} conversation(s)`));
+  println('');
+  for (const hit of out.hits) {
+    println(color.bold(hit.title));
+    println(color.dim(`${hit.agent} · ${hit.store} · ${new Date(hit.updatedAt).toLocaleString()} · ${hit.matches} match(es)`));
+    println(color.dim(`session ${hit.sessionId}${hit.cwd ? ` · ${hit.cwd}` : ''}`));
+    // The matching line verbatim — or, when that ONE line is enormous, where to
+    // find it, because showing part of it would be showing part of a value.
+    println(hit.line == null
+      ? color.dim(`  [one line of ${hit.lineIsHuge?.bytes} bytes. Read it whole: atlas chat-search show ${hit.sessionId} --turns 0]`)
+      : `  ${hit.line}`);
+    if (!flags.quiet) {
+      println('');
+      printRows(hit.rows, hit.agent);
+      if (hit.note) println(color.yellow(hit.note));
+      println(color.dim(`Turns ${hit.from}-${hit.to} of ${hit.total}. atlas chat-search show ${hit.sessionId} --turns 0 for all of it.`));
+    }
+    println('');
+  }
+  for (const note of out.notes) println(color.dim(note));
+  return 0;
+}

package/src/commands/computer-use.js

@@ -21,13 +21,14 @@
 // ONE IMPLEMENTATION, NOT TWO: every subcommand runs the SAME atlas_env function
 // a project's script would call, inside the project, so the switch, the claim,
 // the action log and standing back for a person are identically the same rules.
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import {
   workspace, workspaceRoot, venvPython, ambientPython, jobEnv, ensureProjectFiles,
   computerUseAllowed, computerClaim, releaseComputerClaim, askAddress,
+  listComputerSessions, renameComputerSession, writeReplay, reviewPrompt, askModel,
 } from '../remote-control.js';
 import { color, println, eprintln } from '../util/ui.js';
 
@@ -52,8 +53,26 @@ const HELP = `atlas computer-use <command>
   find "<what>"         where something is on screen
   window "<title>"      bring a window to the front
   cursor                where the pointer is
+  changed               did the screen move since the last look (no picture)
+  code "<python>"       run a block in the session: loops, ifs, many actions, one call
+  controls ["<window>"] the front window's buttons and fields, by name (try this before screen)
+  press "<name>"        press one of them by name or id (e7), found live [--right] [--double] [--wait <s>]
+  type-into "<name>" "<text>" [--enter]   fill a field by its name and read it back
+  wait-for "<name>" [--gone] [--timeout <s>]   until a control or text appears (or goes)
+  web-setup             fetch Playwright + Chromium once, for the web verbs
+  web-open <url>        a page in Atlas's browser; your mouse stays yours
+  web-click "<what>"    press a button or link by what it says (or a selector)
+  web-type "<what>" "<text>" [--enter]   fill a field by its label
+  web-read ["<what>"]   the page (or one part) as text
+  web-find "<what>"     where something is on the page
+  web-shot              a sharp picture of the page itself
+  web-close             close Atlas's browser (logins are kept)
   take-over             carry on after a person used it by hand
   stop                  give the computer back
+  sessions              this project's recordings, with their ids
+  rename <id> "<name>"  name a recording (an empty name takes it off)
+  replay <id>           write replay.md: every action, with the frame at that moment
+  review <id>           have the model read the replay and write review.md
 
   --job <project>       which project's log this belongs to
                         (defaults to $ATLAS_JOB, which a chat already sets)`;
@@ -61,7 +80,7 @@ const HELP = `atlas computer-use <command>
 // Each subcommand as the atlas_env call it really is, and how many values it
 // takes. Mapped rather than hand-written so this cannot invent an operation the
 // helper does not have.
-const OPS = {
+export const OPS = {
   screen: ['screen', 0],
   screens: ['screens', 0],
   'use-screen': ['use_screen', 1],
@@ -79,6 +98,16 @@ const OPS = {
   find: ['find', 1],
   window: ['focus_window', 1],
   cursor: ['get_cursor', 0],
+  changed: ['changed', 0],
+  code: ['run_code', 1],
+  'web-setup': ['web_setup', 0],
+  'web-open': ['web_open', 1],
+  'web-click': ['web_click', 1],
+  'web-type': ['web_type', -1],
+  'web-read': ['web_read', -1],
+  'web-find': ['web_find', 1],
+  'web-shot': ['web_shot', 0],
+  'web-close': ['web_close', 0],
   'take-over': ['take_over', 0],
   ready: ['computer_ready', 0],
   // WAIT ESPECIALLY. A sequence without it cannot pause for a page, which is
@@ -122,6 +151,14 @@ const OPS = {
   // ── A PAGE THAT IS TALLER THAN THE SCREEN ─────────────────────────────
   'scroll-to': ['scroll_to', 1],
   'scan-page': ['scan_page', 0],
+  // ── CONTROLS, NOT PIXELS ──────────────────────────────────────────────
+  // The app's own list of its buttons and fields, read from the system's
+  // accessibility tree: named, found again at the moment of the press, and
+  // checked afterwards. No picture to read, no coordinates to guess.
+  controls: ['controls', -1],
+  press: ['press', -1],
+  'type-into': ['type_into', -1],
+  'wait-for': ['wait_for', -1],
 };
 // Which values are numbers. Passing "840" as a string to click() would move the
 // pointer nowhere and report success. THE SAME SET THE PYTHON CLI USES: a verb
@@ -131,6 +168,14 @@ const NUMERIC = new Set(['use-screen', 'click', 'double-click', 'right-click',
   'middle-click', 'triple-click', 'move', 'drag', 'scroll', 'wait', 'region',
   'scroll-x', 'shift-scroll', 'swipe', 'zoom']);
 
+/** "Last name | Smith" -> ["Last name", "Smith"]; "Quantity 25" -> ["Quantity", "25"]. */
+export function splitTarget(text) {
+  const bar = text.indexOf('|');
+  if (bar >= 0) return [text.slice(0, bar).trim(), text.slice(bar + 1).trim()];
+  const words = text.split(/\s+/).filter(Boolean);
+  return [words[0] || '', words.slice(1).join(' ')];
+}
+
 /** This shell's holding id, made once and remembered. Shared with `atlas run`
  *  so everything typed at one prompt lands in ONE session: the log reads as a
  *  session rather than a pile of one-action folders, and the claim names
@@ -201,6 +246,17 @@ export function askServer(job, op, args, root) {
 /** Run one atlas_env call inside the project, and hand back what it said. */
 /** What using the computer needs, and what it is called when you import it. */
 const NEEDED = [['pyautogui', 'pyautogui'], ['mss', 'mss'], ['Pillow', 'PIL']];
+/** What reads an app's own buttons and fields (controls(), press()). Never a
+ *  condition of working: without it the screen and the mouse still do, so it is
+ *  fetched on its own and a failure costs nothing. Linux reads AT-SPI through
+ *  the system's python3-gi, which pip cannot put there. */
+export function controlPackages(platform = process.platform) {
+  if (platform === 'win32') return [['uiautomation', 'uiautomation']];
+  if (platform === 'darwin') {
+    return [['pyobjc-framework-ApplicationServices', 'ApplicationServices'], ['pyobjc-framework-Cocoa', 'AppKit']];
+  }
+  return [];
+}
 
 /**
  * Put what is missing into the interpreter that is ABOUT TO BE USED.
@@ -228,20 +284,44 @@ const NEEDED = [['pyautogui', 'pyautogui'], ['mss', 'mss'], ['Pillow', 'PIL']];
 const HIDDEN = { windowsHide: true };
 
 export function ensureDeps(python, cwd, env) {
-  const check = `import ${NEEDED.map(([, mod]) => mod).join(', ')}`;
-  const has = () => spawnSync(python[0], [...python.slice(1), '-c', check],
-    { cwd, env, stdio: 'ignore', ...HIDDEN }).status === 0;
-  if (has()) return true;
+  const extra = controlPackages();
+  // ONE python start answers both: 0 all here, 3 only the control reader
+  // missing, 1 the screen and mouse themselves. LOOKED UP, NOT IMPORTED:
+  // importing pyautogui on a Linux without tkinter exits the process, so the
+  // check failed on every command there and paid a pip run each time.
+  const mods = (list) => JSON.stringify(list.map(([, mod]) => mod));
+  const check = 'import importlib.util as u, sys\n'
+    + `sys.exit(1 if not all(u.find_spec(m) for m in ${mods(NEEDED)}) else 3 if not all(u.find_spec(m) for m in ${mods(extra)}) else 0)\n`;
+  const status = () => spawnSync(python[0], [...python.slice(1), '-c', check],
+    { cwd, env, stdio: 'ignore', ...HIDDEN }).status;
+  const pip = (names, timeout) => {
+    const inVenv = spawnSync(python[0],
+      [...python.slice(1), '-c', 'import sys; sys.exit(0 if sys.prefix != sys.base_prefix else 1)'],
+      { cwd, env, stdio: 'ignore', ...HIDDEN }).status === 0;
+    spawnSync(python[0], [...python.slice(1), '-m', 'pip', 'install', '--quiet', ...(inVenv ? [] : ['--user']), ...names],
+      { cwd, env, stdio: 'ignore', timeout, ...HIDDEN });
+  };
+  const first = status();
+  if (first === 0) return true;
+  if (first === 3) {
+    // Tried once a day per project, not on every command: a machine where it
+    // will not install should not pay a pip run per click.
+    const mark = path.join(cwd, '.studio', 'controls-tried');
+    let last = 0;
+    try { last = fs.statSync(mark).mtimeMs; } catch { /* never tried */ }
+    if (Date.now() - last > 24 * 3600_000) {
+      try { fs.mkdirSync(path.dirname(mark), { recursive: true }); fs.writeFileSync(mark, ''); } catch { /* best effort */ }
+      pip(extra.map(([name]) => name), 180000);
+    }
+    return true;
+  }
   println(color.dim('  Getting this computer ready (one time)…'));
-  // --user is wrong inside a venv and right outside one, so ask the interpreter
-  // which it is in rather than guessing.
-  const inVenv = spawnSync(python[0],
-    [...python.slice(1), '-c', 'import sys; sys.exit(0 if sys.prefix != sys.base_prefix else 1)'],
-    { cwd, env, stdio: 'ignore', ...HIDDEN }).status === 0;
-  const args = ['-m', 'pip', 'install', '--quiet', ...(inVenv ? [] : ['--user'])];
-  spawnSync(python[0], [...python.slice(1), ...args, ...NEEDED.map(([name]) => name)],
-    { cwd, env, stdio: 'ignore', timeout: 300000, ...HIDDEN });
-  return has();
+  // --user is wrong inside a venv and right outside one, so pip() asks the
+  // interpreter which it is in rather than guessing.
+  pip(NEEDED.map(([name]) => name), 300000);
+  if (extra.length) pip(extra.map(([name]) => name), 180000);
+  const now = status();
+  return now === 0 || now === 3;
 }
 
 export function runInProject(job, code, root) {
@@ -285,6 +365,63 @@ export function runInProject(job, code, root) {
   return out.status === null ? 1 : out.status;
 }
 
+/**
+ * Start a watch that OUTLIVES this command.
+ *
+ * A watch runs for hours by design: it looks, decides how long to wait, and
+ * looks again. Run in the foreground, a shell agent that started one would sit
+ * there until it finished — one turn, held open, with nothing to show for it.
+ * The Python CLI has detached it since 2026-09-06; this runtime ran it inline,
+ * and this runtime is the one Atlas Studio bundles, so the blocking version is
+ * the one a chat actually got (owner, 2026-09-15).
+ *
+ * Detached, with no console and no pipes: what it does is visible in the watch
+ * window and the action log, which is where somebody watching already is.
+ */
+function startWatch(job, instruction, flags) {
+  if (!String(instruction || '').trim()) {
+    eprintln(color.red('Say what to watch for.'));
+    eprintln(color.dim('  atlas computer-use watch "when SPY breaks the opening range high, buy 1 call"'));
+    return 1;
+  }
+  const { dir } = workspace(job, undefined);
+  if (!fs.existsSync(dir)) {
+    eprintln(color.red(`There is no project called ${job} on this computer.`));
+    return 1;
+  }
+  try { ensureProjectFiles(dir); } catch { /* it may already be right */ }
+  const venv = venvPython(dir);
+  const python = venv ? [String(venv)] : [...ambientPython()];
+  const env = { ...process.env, ...jobEnv(dir), ATLAS_JOB: path.basename(dir) };
+  if (!env.ATLAS_ASK_URL || !env.ATLAS_ASK_TOKEN) {
+    const at = askAddress(undefined);
+    if (at) { env.ATLAS_ASK_URL = at.url; env.ATLAS_ASK_TOKEN = at.token; }
+  }
+  if (!env.ATLAS_COMPUTER_SESSION) env.ATLAS_COMPUTER_SESSION = shellSession(undefined);
+  env.PYTHONPATH = [dir, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter);
+  ensureDeps(python, dir, env);
+  const kw = { every: Number(flags.every || 5) };
+  if (flags.most) kw.most = Number(flags.most);
+  if (flags.hours) kw.hours = Number(flags.hours);
+  const code = 'import atlas_env as e, json, sys\n'
+    + 'e.watch(json.loads(sys.argv[1]), **json.loads(sys.argv[2]))\n';
+  try {
+    const child = spawn(
+      python[0],
+      [...python.slice(1), '-c', code, JSON.stringify(String(instruction)), JSON.stringify(kw)],
+      { cwd: dir, env, stdio: 'ignore', detached: true, ...HIDDEN },
+    );
+    child.unref();
+  } catch (err) {
+    eprintln(color.red(`Could not start watching: ${err && err.message ? err.message : err}`));
+    return 1;
+  }
+  println(color.dim('Watching started. It looks, decides how long to wait, and looks again.'));
+  println(color.dim('  Follow it in the watch window, or: atlas computer-use screen'));
+  println(color.dim('  Stop ends it — the whole thing, wait included.'));
+  return 0;
+}
+
 export function computerUseCommand(args) {
   const flags = args.flags || {};
   const rest = [...(args.positional || args._ || [])];
@@ -351,6 +488,11 @@ export function computerUseCommand(args) {
     return out;
   }
 
+  // A WATCH FROM A CHAT MUST COME BACK: detached unless told otherwise.
+  if (sub === 'watch' && flags.background !== false) {
+    return startWatch(job, rest[0] || '', flags);
+  }
+
   // SEVERAL ACTIONS AND ONE PICTURE, in one process. The slow part was never
   // the clicking: it was a command and a look for every step, when four of them
   // were visible in the picture you already had.
@@ -361,6 +503,58 @@ export function computerUseCommand(args) {
   // here — from the runtime Atlas Studio bundles — so a model in a chat that
   // followed the instructions was told `There is no "do" here` (owner,
   // 2026-09-15: "see if we can unify things instead of diverging").
+  // THE RECORDINGS, AND A NAME FOR ONE (owner, 2026-09-17: "for recordings,
+  // allow the CLI the option to rename this"). The id stays what it is — the
+  // folder, the log, the parts — and the name sits beside them, the same
+  // name.json Atlas Studio's own list reads and writes.
+  if (sub === 'sessions') {
+    const rows = listComputerSessions(job);
+    if (!rows.length) { println(color.dim('No recordings for this project yet.')); return 0; }
+    for (const s of rows) {
+      const when = new Date(s.started * 1000).toLocaleString();
+      println(color.cyan(s.id) + '  ' + (s.name ? color.bold(s.name) + color.dim(' · ' + when) : when)
+        + color.dim(`  ${s.actions} action${s.actions === 1 ? '' : 's'}${s.video ? ` · ${s.parts} part${s.parts === 1 ? '' : 's'}` : ''}`));
+    }
+    return 0;
+  }
+  if (sub === 'rename') {
+    const id = String(flags.session || rest.shift() || '').trim();
+    const name = String(flags.name ?? rest.join(' ')).trim();
+    if (!id) {
+      eprintln(color.red('Which recording? `atlas computer-use rename <session-id> "<name>"` (ids: `atlas computer-use sessions`)'));
+      return 1;
+    }
+    const out = renameComputerSession(job, id, name);
+    if (!out.ok) { eprintln(color.red(out.error || 'Could not rename that.')); return 1; }
+    println(name ? `Named it "${name}".` : 'Name removed.');
+    return 0;
+  }
+
+  // A MODEL WATCHES A SESSION AS FRAMES, NOT FILM (owner, 2026-09-18: "it's
+  // just a batch of frames where actions were made"). replay.md lists
+  // every action with the picture the run took at that moment; review asks
+  // the project's model to read it, open the frames, and write review.md —
+  // what worked, what a person had to correct, rules for next time.
+  if (sub === 'replay' || sub === 'review') {
+    const id = String(flags.session || rest.shift() || '').trim();
+    if (!id) {
+      eprintln(color.red(`Which recording? \`atlas computer-use ${sub} <session-id>\` (ids: \`atlas computer-use sessions\`)`));
+      return 1;
+    }
+    const board = writeReplay(job, id);
+    if (!board.ok) { eprintln(color.red(board.error || 'Could not build the replay.')); return 1; }
+    println(color.dim(`replay: ${board.path} (${board.frames} actions, ${board.images} frames)`));
+    if (sub === 'replay') return 0;
+    return askModel(reviewPrompt(id), { job, model: String(flags.model || '') })
+      .then((text) => {
+        const said = String(text || '').trim();
+        try { fs.writeFileSync(path.join(workspace(job).dir, '.computer-use', id, 'review.md'), said + '\n'); } catch { /* the words are printed either way */ }
+        println(said);
+        return 0;
+      })
+      .catch((err) => { eprintln(color.red(`The model could not review it: ${err.message || err}`)); return 1; });
+  }
+
   if (sub === 'do') {
     if (!rest.length) {
       eprintln(color.red('What should it do? e.g. do "click 820 410" "type hello"'));
@@ -378,9 +572,13 @@ export function computerUseCommand(args) {
       const [name] = OPS[verb];
       // A quoted phrase is one value: `type "hello there"` means two words
       // typed, not a word typed twice.
-      const vals = (verb === 'type' || verb === 'note' || verb === 'find')
+      let vals = (['type', 'note', 'find', 'code', 'web-open', 'web-click', 'web-read', 'web-find',
+        'controls', 'press', 'wait-for'].includes(verb))
         ? (bits.length > 1 ? [bits.slice(1).join(' ')] : [])
         : bits.slice(1).map((v) => (NUMERIC.has(verb) ? Number(v) : v));
+      // A name can be several words, so the text comes after a "|":
+      // "type-into Last name | Smith". Without one, the first word is the name.
+      if (verb === 'type-into') vals = splitTarget(bits.slice(1).join(' '));
       steps.push([name, ...vals]);
     }
     const code = 'import atlas_env as e, json\n'
@@ -394,20 +592,62 @@ export function computerUseCommand(args) {
     return 1;
   }
   const [name, count] = OPS[sub];
+  // `press --double Save` reads "Save" as the flag's value; a switch never has
+  // one, so that word goes back where it was meant to go.
+  const on = (flag) => {
+    const v = flags[flag];
+    if (typeof v === 'string') { rest.push(v); return true; }
+    return Boolean(v);
+  };
+  const right = on('right'); const twice = on('double'); const gone = on('gone'); const enter = on('enter');
   if (count >= 0 && rest.length !== count) {
     eprintln(color.red(`${sub} takes ${count} value${count === 1 ? '' : 's'}.`));
     return 1;
   }
-  if (count === -1 && !rest.length) {
+  if (count === -1 && !rest.length && sub !== 'web-read' && sub !== 'controls') {
     eprintln(color.red(`${sub} needs at least one.`));
     return 1;
   }
-  const values = rest.map((v) => (NUMERIC.has(sub) ? Number(v) : v));
+  let values = rest.map((v) => (NUMERIC.has(sub) ? Number(v) : v));
+  // A block of code, a sentence to find, an address: the words are one value.
+  if (['code', 'note', 'find', 'type', 'web-open', 'web-click', 'web-read', 'web-find'].includes(sub) && rest.length > 1) {
+    values = [rest.join(' ')];
+  }
+  if (sub === 'press' || sub === 'wait-for' || sub === 'controls') {
+    values = rest.length ? [rest.join(' ')] : [];
+    if (sub === 'press') {
+      values.push(right ? 'right' : 'left', twice ? 2 : 1);
+      // How long it may wait for the control to appear, stop being grey, or
+      // come out from under something (default 5s).
+      if (flags.wait !== undefined) values.push(null, 1.0, Number(flags.wait));
+    }
+    if (sub === 'wait-for') {
+      values.push(gone, flags.timeout !== undefined ? Number(flags.timeout) : 10);
+    }
+  }
+  if (sub === 'type-into') {
+    if (rest.length < 2) {
+      eprintln(color.red('type-into takes the field and the text: type-into "Quantity" "25" [--enter]'));
+      return 1;
+    }
+    values = [rest[0], rest.slice(1).join(' '), enter];
+    if (flags.wait !== undefined) values.push(true, null, Number(flags.wait));
+  }
+  if (sub === 'web-type') {
+    if (rest.length < 2) {
+      eprintln(color.red('web-type takes the field and the text: web-type "Email" "me@x.com" [--enter]'));
+      return 1;
+    }
+    values = [rest[0], rest.slice(1).join(' '), Boolean(flags.enter)];
+  }
   // THE LIVE PROCESS FIRST: same function, same rules, without a python start.
   const answer = askServer(job, name, values);
   if (answer) {
     if (answer.ok) {
-      println(JSON.stringify(answer.out, null, 2));
+      // THE LIST AS LINES: one control per line is what gets read, and the
+      // same list as JSON is five times the words to read it in.
+      if (sub === 'controls' && answer.out && answer.out.summary) println(answer.out.summary);
+      else println(JSON.stringify(answer.out, null, 2));
       return 0;
     }
     eprintln(color.red(String(answer.error || 'That did not work.')));
@@ -417,6 +657,8 @@ export function computerUseCommand(args) {
   // pasting is a snippet that breaks on somebody's password.
   const code = 'import atlas_env as e, json\n'
     + `out = e.${name}(*json.loads(${JSON.stringify(JSON.stringify(values))}))\n`
-    + 'print(json.dumps(out, default=str))\n';
+    + (sub === 'controls'
+      ? 'print(out["summary"] if isinstance(out, dict) and out.get("summary") else json.dumps(out, default=str))\n'
+      : 'print(json.dumps(out, default=str))\n');
   return runInProject(job, code);
 }