mindvest-atlas 0.68.1 → 0.68.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.68.1",
+  "version": "0.68.3",
   "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

@@ -24,6 +24,14 @@ import { remoteCheckCommand } from './commands/remote-check.js';
 import { shareCommand } from './commands/share.js';
 import { historicalContractCommand } from './commands/historical.js';
 import { callCommand } from './commands/call.js';
+// WITHOUT THESE, `atlas --version` PRINTED THE BARE NUMBER AND NOTHING ELSE.
+// They were called but never imported, and the call sits inside a try/catch
+// that swallows anything — so the ReferenceError was invisible and the detail
+// this exists to show (which atlas answered, what else is installed) never
+// appeared. That is the confusion it was written to end: owner, 2026-09-04,
+// "the atlas.cmd does not update on reinstalling, also the mindvest-atlas is
+// using a different version — this is confusing."
+import { installedClis, whichAtlas, versionDetailLines } from './cli-installs.js';
 
 /**
  * Say which Atlas answered and what else is installed.

package/src/commands/alerts.js

@@ -14,6 +14,7 @@ import { runStream } from '../util/stream-loop.js';
 import { formatAlert } from '../util/format.js';
 import { color, println, eprintln, prettyJson } from '../util/ui.js';
 import { requestJson } from '../api/client.js';
+import { moved } from './moved.js';
 import * as background from '../util/background.js';
 
 // Names the slot, the claim file and the log, and it is the command's own name
@@ -29,52 +30,16 @@ function sanitizeFilename(name) {
 // ── list / delete ────────────────────────────────────────────────────────────
 const callTool = (name, body) => requestJson(API.tool(name), { method: 'POST', body: body || {} });
 
-async function listAlerts(flags) {
-  const data = await callTool('List-Alerts', {
-    ...(flags.all ? { active_only: false } : {}),
-    ...(flags.symbol ? { symbol: String(flags.symbol).toUpperCase() } : {}),
-  });
-  if (flags.json) { println(prettyJson(data)); return 0; }
-  const list = (data && (data.alerts || data.data)) || (Array.isArray(data) ? data : []);
-  if (!list.length) { println(color.dim('No alerts.')); return 0; }
-  for (const a of list) {
-    const state = a.is_active === false ? color.dim('off') : color.green('on');
-    println(`${state}  ${color.bold(a.name || '(unnamed)')}  ${color.dim([a.symbol, a.alert_type].filter(Boolean).join(' · '))}`);
-    println(color.dim(`     ${a.id}`));
-  }
-  println('');
-  println(color.dim('Switch one off:  atlas alerts delete --id <id>'));
-  println(color.dim('Delete for good: atlas alerts delete --id <id> --purge'));
-  return 0;
-}
 
-async function deleteAlerts(args) {
-  const flags = args.flags;
-  // --id may repeat; extra positionals after the verb are ids too, so
-  // `atlas alerts delete a b c` does what it looks like it does.
-  const fromFlags = flags.id === undefined ? [] : (Array.isArray(flags.id) ? flags.id : [flags.id]);
-  const ids = [...fromFlags, ...(args._ || []).slice(1)]
-    .map((x) => String(x || '').trim())
-    .filter((x) => x && x !== 'true');
-  if (!ids.length) {
-    eprintln(color.red('Which alert? --id <id> (repeat for several), or list them: atlas alerts list'));
-    return 1;
-  }
-  const purge = !!flags.purge;
-  const data = await callTool('Delete-Alert', {
-    alert_ids: ids, purge,
-  });
-  if (data && data.error) { eprintln(color.red(String(data.error))); return 1; }
-  if (flags.json) { println(prettyJson(data)); return 0; }
-  println(data.message || (purge ? 'Deleted.' : 'Switched off.'));
-  // A purge that kept some says why, and the message already names them; this
-  // points at the way through rather than leaving the user to guess.
-  if (data.kept && Object.keys(data.kept).length) {
-    println(color.dim('Repoint those setups, or drop --purge to just switch the alert off.'));
-  }
+/** The shape of every event on the feed, as JSON Schema, so a script or a
+ *  model can read it once and rely on it. Alerts and trades share it. */
+async function schema() {
+  const data = await requestJson(`${API.alerts}/schema`);
+  println(prettyJson(data));
   return 0;
 }
 
+
 export async function alertsCommand(args) {
   const flags = args.flags;
   // MANAGING alerts, not watching them. A bare `atlas alerts` has meant "open
@@ -84,8 +49,14 @@ export async function alertsCommand(args) {
   // (owner, 2026-09-12: "it's hard to manage spoiled alerts without a
   // something to delete them").
   const verb = String((args._ && args._[0]) || '').toLowerCase();
-  if (verb === 'list' || verb === 'ls') return await listAlerts(flags);
-  if (verb === 'delete' || verb === 'rm' || verb === 'off') return await deleteAlerts(args);
+  // ONE NAME PER CAPABILITY. These wrapped a single tool each; the generic path
+  // reaches it by name. See commands/moved.js.
+  const rest = { _: (args._ || []).slice(1), flags };
+  if (verb === 'list' || verb === 'ls') return await moved(`alerts ${verb}`, 'list-alerts', rest);
+  if (verb === 'delete' || verb === 'rm' || verb === 'off') return await moved(`alerts ${verb}`, 'delete-alert', rest);
+  // KEPT: there is no tool behind these two. `schema` reads a public route, and
+  // a bare `atlas alerts` is the live feed — a stream is not a tool call.
+  if (verb === 'schema') return await schema();
   if (flags.stop) return background.stop(SLOT);
   if (flags.detach) return background.detach(SLOT);
   const holder = background.holdUntilStopped(SLOT);

package/src/commands/computer-use.js

@@ -351,6 +351,43 @@ export function computerUseCommand(args) {
     return out;
   }
 
+  // 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.
+  //
+  //   atlas computer-use do "click 820 410" "type hello" "key enter"
+  //
+  // This is the batching every skill tells a model to use, and it was missing
+  // 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").
+  if (sub === 'do') {
+    if (!rest.length) {
+      eprintln(color.red('What should it do? e.g. do "click 820 410" "type hello"'));
+      return 1;
+    }
+    const steps = [];
+    for (const raw of rest) {
+      const bits = String(raw).split(/\s+/).filter(Boolean);
+      if (!bits.length) continue;
+      const verb = bits[0].toLowerCase();
+      if (!OPS[verb]) {
+        eprintln(color.red(`There is no "${verb}" to do.`));
+        return 1;
+      }
+      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')
+        ? (bits.length > 1 ? [bits.slice(1).join(' ')] : [])
+        : bits.slice(1).map((v) => (NUMERIC.has(verb) ? Number(v) : v));
+      steps.push([name, ...vals]);
+    }
+    const code = 'import atlas_env as e, json\n'
+      + `print(json.dumps(e.do(*[tuple(s) for s in json.loads(${JSON.stringify(JSON.stringify(steps))})]), default=str, indent=2))\n`;
+    return runInProject(job, code);
+  }
+
   if (!OPS[sub]) {
     eprintln(color.red(`There is no "${sub}" here.`));
     println(HELP);

package/src/commands/models.js

@@ -67,9 +67,13 @@ export async function askCommand(args) {
     }
   }
   try {
+    // THE JOB IT IS RUNNING IN, unless told otherwise: a model asking from its
+    // own shell used to land in a folder called "job", in a session unrelated
+    // to the project it was working on.
     const said = await askModel(prompt, {
-      job: String(flags.job || ''),
+      job: String(flags.job || process.env.ATLAS_JOB || ''),
       model,
+      peer: String(flags.peer || '').trim(),
       timeoutMs: Number(flags.timeout || 900) * 1000,
     });
     println(typeof said === 'string' ? said : JSON.stringify(said, null, 2));

package/src/commands/moved.js

@@ -0,0 +1,32 @@
+// A VERB THAT ONLY WRAPPED A TOOL, kept working while it goes.
+//
+// Owner, 2026-09-15: "scan through all my mcp, cli, api and see if we can unify
+// things instead of diverging ... I have divergence because now I have too much
+// commands."
+//
+// Most `atlas alerts <verb>` and `atlas signals <verb>` subcommands did one
+// thing: call a single tool and print a table. The generic path reaches every
+// tool by name already — `atlas list-alerts`, `atlas signal-take` — against the
+// live catalogue, which is the one road that cannot drift because nobody
+// maintains it. A second spelling is what made the surface feel large, and it
+// was worse than redundant: eight Trade-* and Signal-* tools never got a verb,
+// so an agent that learned the verbs concluded closing a trade was impossible.
+//
+// So the verbs forward, once, with a line saying where they went. They are
+// removed in a later release; this is here so nobody's script breaks on the day
+// they update.
+import { color, eprintln } from '../util/ui.js';
+import { callCommand } from './call.js';
+
+// An ES import binding cannot be replaced from outside, so the forward goes
+// through this object: a test can swap `forwardTo.call` and assert WHERE a verb
+// went without a network round trip. The Python twin patches the module
+// attribute for the same reason.
+export const forwardTo = { call: callCommand };
+
+export async function moved(verb, slug, args) {
+  eprintln(color.dim(
+    `atlas ${verb} is now atlas ${slug} — same thing, one name. This forwards for now.`,
+  ));
+  return await forwardTo.call(slug, args);
+}

package/src/commands/signals.js

@@ -13,6 +13,7 @@
 import { API } from '../config.js';
 import { requestJson } from '../api/client.js';
 import { color, println, eprintln, prettyJson } from '../util/ui.js';
+import { moved } from './moved.js';
 
 const HELP = `${color.bold('atlas signals')} — plays: your groups, the board, and what they have made
 
@@ -140,39 +141,22 @@ export async function signalsCommand(args) {
   const groupId = flags.group || flags['group-id'] || flags.id;
 
   switch (sub) {
-    case 'groups': {
-      const data = await callTool('Signal-Groups', {});
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const list = data.groups || data.data || [];
-      if (!list.length) { println(color.dim('No groups yet. The community board is always there: atlas signals plays --board community')); return 0; }
-      for (const g of list) {
-        const bits = [g.role, g.visibility, g.signal_count != null ? `${g.signal_count} plays` : null].filter(Boolean);
-        println(`${color.bold(g.name || '(unnamed)')}  ${color.dim(bits.join(' · '))}`);
-        println(color.dim(`  ${g.id}`));
-      }
-      return 0;
-    }
-    case 'plays':
-    case 'list': {
-      const body = {};
-      if (flags.board) body.board = String(flags.board);
-      if (flags.group) body.group_id = String(flags.group);
-      if (flags.days !== undefined) body.days = num(flags.days);
-      if (flags.limit !== undefined) body.limit = num(flags.limit);
-      const data = await callTool('Signal-List', body);
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const list = rows(data.plays || data.signals || data);
-      if (!list.length) { println(color.dim('Nothing on that board in that window.')); return 0; }
-      for (const s of list) {
-        const p = s.payload || s;
-        const what = [p.side, p.symbol, p.strike ? `$${p.strike}` : null, (p.option_type || '').toUpperCase() || null,
-          p.expiration_date || p.expiry || null].filter(Boolean).join(' ');
-        println(`${color.bold(what || '(play)')}  ${color.dim(s.status || '')}`);
-        println(color.dim(`  ${s.id}${s.posted_at ? '  ' + s.posted_at : ''}`));
-      }
-      return 0;
+    // ONE NAME PER CAPABILITY (owner, 2026-09-15). Each of these wrapped a
+    // single tool and printed a table; the generic path reaches every tool by
+    // name against the live catalogue, including the eight Signal-*/Trade-*
+    // tools that never got a verb here. `post` stays — its --link/--with-*
+    // grammar for a second leg is not something a flag schema can express.
+    case 'groups': case 'plays': case 'list': case 'show': case 'take':
+    case 'performance': case 'perf': case 'delete': case 'rm':
+    case 'discover': case 'follow': case 'schema': {
+      const MOVED = {
+        groups: 'signal-groups', plays: 'signal-list', list: 'signal-list',
+        show: 'signal-show', take: 'signal-take',
+        performance: 'signal-group-performance', perf: 'signal-group-performance',
+        delete: 'signal-group-delete', rm: 'signal-group-delete',
+        discover: 'signal-discover', follow: 'signal-follow', schema: 'signal-schema',
+      };
+      return await moved(`signals ${sub}`, MOVED[sub], { _: (args._ || []).slice(1), flags });
     }
     case 'post': {
       const leg = legFrom(flags, '', null);
@@ -203,97 +187,6 @@ export async function signalsCommand(args) {
       println(data.message || (link ? 'Posted both, linked.' : 'Posted.'));
       return 0;
     }
-    case 'show': {
-      const id = flags.id || flags.play || flags.signal;
-      if (!id) { eprintln(color.red('Which play? --id <play-id>')); return 1; }
-      const data = await callTool('Signal-Show', { signal_id: String(id) });
-      if (failed(data)) return printFailure(data);
-      println(prettyJson(data));
-      return 0;
-    }
-    case 'take': {
-      const id = flags.id || flags.play || flags.signal;
-      if (!id) { eprintln(color.red('Which play? --id <play-id>')); return 1; }
-      const body = { signal_id: String(id) };
-      if (flags.contracts !== undefined) body.contracts = num(flags.contracts);
-      if (flags.account) body.account_id = String(flags.account);
-      const data = await callTool('Signal-Take', body);
-      if (failed(data)) return printFailure(data);
-      println(json ? prettyJson(data) : (data.message || 'Taken.'));
-      return 0;
-    }
-    case 'performance':
-    case 'perf': {
-      if (!groupId) { eprintln(color.red('Which group? --group <id>  (atlas signals groups)')); return 1; }
-      const data = await callTool('Signal-Group-Performance', {
-        group_id: String(groupId), mine: !!flags.mine,
-      });
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const t = data.totals || {};
-      const name = data.display_name || data.name || 'this group';
-      const whose = data.whose === 'mine' ? 'your own trades' : "the author's record";
-      println(`${color.bold(name)} ${color.dim('— ' + whose)}`);
-      println(`  Closed trades  ${(data.rows || []).length}`);
-      println(`  Win rate       ${t.win_rate ?? 0}%  ${color.dim(`(${t.win_count ?? 0} up, ${t.loss_count ?? 0} down)`)}`);
-      println(`  Total          ${money(t.total_pnl)}  ${color.dim(`${t.total_pnl_pct ?? 0}%`)}`);
-      if (data.viewer_has_rows && data.whose !== 'mine') {
-        println(color.dim('  You have taken plays here too: add --mine for your own numbers.'));
-      }
-      return 0;
-    }
-    case 'delete':
-    case 'rm': {
-      if (!groupId) { eprintln(color.red('Which group? --group <id>  (atlas signals groups)')); return 1; }
-      const stop = !!(flags['stop-subscribers'] || flags.stop);
-      const data = await callTool('Signal-Group-Delete', {
-        group_id: String(groupId), stop_subscribers: stop,
-      });
-      if (failed(data)) {
-        // THE REFUSAL WITH AN ANSWER. People are subscribed: say how many, say
-        // what stopping them costs them, and print the line that does it —
-        // rather than an error that names a screen this person is not looking at.
-        if (data.code === 'has_subscribers') {
-          const n = Number(data.subscriber_count) || 1;
-          eprintln(color.yellow(`${n} ${n === 1 ? 'person is' : 'people are'} subscribed to this group.`));
-          eprintln(color.dim('Deleting stops their billing at once, so there is no next payment, and they'
-            + ' lose the rest of the month they paid for. Anything they already traded is theirs.'));
-          eprintln('');
-          eprintln('  ' + color.cyan(`atlas signals delete --group ${groupId} --stop-subscribers`));
-          return 1;
-        }
-        return printFailure(data);
-      }
-      println(json ? prettyJson(data) : (data.message || 'Group deleted.'));
-      return 0;
-    }
-    case 'discover': {
-      const data = await callTool('Signal-Discover', {});
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const list = data.groups || [];
-      if (!list.length) { println(color.dim('No public groups yet.')); return 0; }
-      for (const g of list) {
-        println(`${color.bold(g.name || '(unnamed)')}  ${color.dim([g.owner_label, `${g.follower_count ?? 0} following`].filter(Boolean).join(' · '))}`);
-        println(color.dim(`  ${g.id}`));
-      }
-      return 0;
-    }
-    case 'follow': {
-      if (!groupId) { eprintln(color.red('Which group? --group <id>')); return 1; }
-      const data = await callTool('Signal-Follow', {
-        group_id: String(groupId), follow: flags.off ? false : flags.follow !== false,
-      });
-      if (failed(data)) return printFailure(data);
-      println(json ? prettyJson(data) : (data.message || 'Done.'));
-      return 0;
-    }
-    case 'schema': {
-      const data = await callTool('Signal-Schema', {});
-      if (failed(data)) return printFailure(data);
-      println(typeof data === 'string' ? data : prettyJson(data));
-      return 0;
-    }
     default:
       eprintln(color.red(`Unknown: atlas signals ${sub}`));
       println(HELP);

package/src/helpers/atlas_env.js

@@ -83,8 +83,27 @@ export async function atlas(tool, params = {}) {
  * words each one takes. A name it does not have is refused BY NAME rather than
  * quietly answered by the default, because a script that asked for a specific
  * model and silently got another one is worse than one that stops.
+ *
+ * PEER TO PEER. Every model you name keeps ITS OWN conversation in this job,
+ * with its own tools, its own shell and its own view of the project, and it can
+ * call ask() itself (or `atlas ask --model ...` from its shell) to talk to
+ * another one. So two models can work a problem between them, each doing its
+ * own things, and you carry the words across:
+ *
+ *     const plan = await ask("Plan the research; list the questions.", { model: "claude-opus-4-8" });
+ *     const found = await ask(`Answer these with real data:\n${plan}`, { model: "gpt-5.4" });
+ *     const call = await ask(`GPT found:\n${found}\nRevise the plan or decide.`, { model: "claude-opus-4-8" });
+ *
+ * Each call continues the conversation that model already had in this job, so
+ * the last one remembers the plan it wrote. fresh:true starts a model over.
+ *
+ * peer:"planner" names a conversation of its own on top of the model, so two
+ * ROLES on one model ("planner" and "critic", both gpt-5.4) keep separate
+ * memories. A model cannot ask itself: the bridge refuses the conversation you
+ * are already in. fanOut([...]) asks several at once (see below). A warm
+ * conversation nobody speaks to for six hours is closed and starts afresh.
  */
-export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600000, model = "", commands = true } = {}) {
+export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600000, model = "", commands = true, peer = "" } = {}) {
   const url = process.env.ATLAS_ASK_URL;
   const token = process.env.ATLAS_ASK_TOKEN;
   if (!url || !token) {
@@ -93,7 +112,10 @@ export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600
       "Connect a model in Atlas Studio, or do this step in code."
     );
   }
-  const body = { job: process.env.ATLAS_JOB || "", prompt: String(prompt), tools, fresh, commands: commands !== false };
+  const body = { job: process.env.ATLAS_JOB || "", prompt: String(prompt), tools, fresh, commands: commands !== false,
+    // Who is asking, so the bridge can refuse a model asking itself.
+    from: process.env.ATLAS_ASK_PEER || "" };
+  if (String(peer || "").trim()) body.peer = String(peer).trim();
   // Sent only when named, so a script that does not care keeps whatever is
   // connected rather than pinning itself to today's default.
   if (String(model || "").trim()) body.model = String(model).trim();
@@ -120,6 +142,31 @@ export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600
  *     const cheap = roster.find((m) => m.ready && m.id.includes("haiku"));
  *     await ask("Sector or company?", { model: cheap?.id });
  */
+/**
+ * Ask several models (or peers) AT ONCE and get every answer back, in order.
+ *
+ *     const answers = await fanOut([
+ *       { prompt: "Bull case for NVDA, 5 lines.", model: "gpt-5.4", peer: "bull" },
+ *       { prompt: "Bear case for NVDA, 5 lines.", model: "gpt-5.4", peer: "bear" },
+ *       { prompt: "Read the tape and give a number.", model: "claude-opus-4-8" },
+ *     ]);
+ *     for (const a of answers) console.log(a.peer || a.model, "->", a.ok ? a.answer : "failed: " + a.error);
+ *
+ * Each entry takes the same keys as ask(). Different peers run in parallel
+ * (each is its own session); asks of one peer queue behind each other. One
+ * failing does not stop the others: every entry comes back as
+ * { ok, answer | error, model, peer }.
+ */
+export async function fanOut(asks) {
+  const list = Array.isArray(asks) ? asks : [];
+  return Promise.all(list.map(async (spec) => {
+    const { prompt, ...rest } = spec || {};
+    const out = { ok: true, model: rest.model || "", peer: rest.peer || "" };
+    try { out.answer = await ask(prompt, rest); } catch (err) { out.ok = false; out.error = String(err && err.message || err); }
+    return out;
+  }));
+}
+
 export async function models() {
   const url = process.env.ATLAS_ASK_URL;
   const token = process.env.ATLAS_ASK_TOKEN;
@@ -145,8 +192,18 @@ function alertMatches(event, match) {
   const want = (Array.isArray(match) ? match : [match])
     .map((w) => String(w ?? "").trim().toLowerCase()).filter(Boolean);
   if (!want.length) return true;
+  const ev = event || {};
+  // A TRADE (a fill, a stop, a take-profit rung, a close, a draft signal)
+  // answers only to "trade", "trade:SPY" or its trigger id: "*" and a bare
+  // symbol keep meaning "my alerts", as they always have.
+  if (String(ev.name ?? "").trim().toLowerCase() === "trade") {
+    const sym = String(ev.symbol ?? "").trim().toLowerCase();
+    const tid = String(ev.id ?? "").trim().toLowerCase();
+    const wanted = new Set(["trade", sym ? `trade:${sym}` : "", tid].filter(Boolean));
+    return want.some((w) => wanted.has(w));
+  }
   const facets = ["label", "id", "symbol", "name", "alert_type"]
-    .map((k) => String((event || {})[k] ?? "").trim().toLowerCase()).filter(Boolean);
+    .map((k) => String(ev[k] ?? "").trim().toLowerCase()).filter(Boolean);
   return want.some((w) => w === "*" || facets.includes(w));
 }
 
@@ -414,6 +471,11 @@ export const computer = {
   ready: () => useComputer("computer_ready"),
   screen: () => useComputer("screen"),
   region: (x, y, w, h) => useComputer("region", [x, y, w, h]),
+  /** A close-up around one spot, x3, with a ruler every 20 desktop pixels and a
+   *  crosshair on the spot: read the click off THIS before a small target.
+   *     const look = await computer.lookAt(850, 450);   // -> { path, grid: 20, ... }
+   *     await computer.click(858, 446); */
+  lookAt: (x, y, opts = {}) => useComputer("look_at", [x, y], opts),
   screens: () => useComputer("screens"),
   useScreen: (n) => useComputer("use_screen", [n]),
   /**

package/src/helpers/atlas_env.py

@@ -54,7 +54,7 @@ def atlas(tool, **params):
         raise RuntimeError("Atlas %s failed (%d): %s" % (tool, e.code, body))
 
 
-def ask(prompt, tools=True, fresh=False, timeout=600, model="", commands=True):
+def ask(prompt, tools=True, fresh=False, timeout=600, model="", commands=True, peer=""):
     """Ask YOUR OWN model, the way you would in the chat, and get its answer back.
 
     IT IS A CHAT SESSION, NOT A TEXT BOX (owner, 2026-09-11). The model runs on
@@ -99,6 +99,31 @@ def ask(prompt, tools=True, fresh=False, timeout=600, model="", commands=True):
     does not have is refused by name rather than quietly answered by the
     default, because a script that asked for a specific model and silently got
     another one is worse than one that stops.
+
+    PEER TO PEER. Every model you name keeps ITS OWN conversation in this job,
+    with its own tools, its own shell and its own view of the project, and it
+    can call ask() itself (or `atlas ask --model ...` from its shell) to talk
+    to another one. So two models can work a problem between them, each doing
+    its own things, and you carry the words across:
+
+        plan = ask("Plan the research; list the questions.", model="claude-opus-4-8")
+        found = ask("Answer these with real data:\n" + plan, model="gpt-5.4")
+        call = ask("GPT found:\n" + found + "\nRevise the plan or decide.", model="claude-opus-4-8")
+
+    Each of those three continues the conversation that model already had in
+    this job, so the last call remembers the plan it wrote. fresh=True starts a
+    model over. A model that should answer only from what you gave it takes
+    commands=False and does no work of its own.
+
+    peer="planner" names a conversation of its own on top of the model, so two
+    ROLES on one model ("planner" and "critic", both gpt-5.4) keep separate
+    memories. A model cannot ask itself: the bridge refuses the conversation
+    you are already in and says to name another model or peer.
+
+    FAN OUT with fan_out([...]) to ask several at once: each peer is its own
+    session, so they run in parallel; two asks of the SAME peer queue, one
+    after the other, and never mix their answers. A warm conversation that
+    nobody speaks to for six hours is closed; the next ask starts it afresh.
     """
     import json as _json
     import urllib.error
@@ -112,7 +137,11 @@ def ask(prompt, tools=True, fresh=False, timeout=600, model="", commands=True):
             "Connect a model in Atlas Studio, or do this step in code."
         )
     body = {"job": os.environ.get("ATLAS_JOB", ""), "prompt": str(prompt),
-            "tools": bool(tools), "fresh": bool(fresh), "commands": bool(commands)}
+            "tools": bool(tools), "fresh": bool(fresh), "commands": bool(commands),
+            # Who is asking, so the bridge can refuse a model asking itself.
+            "from": os.environ.get("ATLAS_ASK_PEER", "")}
+    if str(peer or "").strip():
+        body["peer"] = str(peer).strip()
     # Sent only when named, so a script that does not care keeps whatever is
     # connected rather than pinning itself to today's default.
     if str(model or "").strip():
@@ -137,6 +166,42 @@ def ask(prompt, tools=True, fresh=False, timeout=600, model="", commands=True):
     return out.get("answer") or ""
 
 
+def fan_out(asks, workers=4):
+    """Ask several models (or peers) AT ONCE and get every answer back, in order.
+
+        answers = fan_out([
+            {"prompt": "Bull case for NVDA, 5 lines.", "model": "gpt-5.4", "peer": "bull"},
+            {"prompt": "Bear case for NVDA, 5 lines.", "model": "gpt-5.4", "peer": "bear"},
+            {"prompt": "Read the tape and give a number.", "model": "claude-opus-4-8"},
+        ])
+        for a in answers:
+            print(a["peer"] or a["model"], "->", a["answer"] if a["ok"] else "failed: " + a["error"])
+
+    Each entry takes the same keys as ask(). Different peers run in parallel
+    (each is its own session); asks of one peer queue behind each other. One
+    failing does not stop the others: every entry comes back as
+    {"ok", "answer" or "error", "model", "peer"} so you can decide what to do
+    with a missing voice. `workers` caps how many run at once.
+    """
+    from concurrent.futures import ThreadPoolExecutor
+    asks = list(asks or [])
+
+    def one(spec):
+        spec = dict(spec or {})
+        prompt = spec.pop("prompt", "")
+        out = {"ok": True, "model": spec.get("model", ""), "peer": spec.get("peer", "")}
+        try:
+            out["answer"] = ask(prompt, **spec)
+        except Exception as err:
+            out.update(ok=False, error=str(err))
+        return out
+
+    if not asks:
+        return []
+    with ThreadPoolExecutor(max_workers=max(1, min(int(workers), len(asks)))) as pool:
+        return list(pool.map(one, asks))
+
+
 def models():
     """Every model this computer can reach, newest answer from the app itself.
 
@@ -178,7 +243,16 @@ def _alert_matches(event, match):
     want = [str(w or "").strip().lower() for w in want if str(w or "").strip()]
     if not want:
         return True
-    facets = [str((event or {}).get(k) or "").strip().lower()
+    ev = event or {}
+    # A TRADE (a fill, a stop, a take-profit rung, a close, a draft signal)
+    # answers only to "trade", "trade:SPY" or its trigger id: "*" and a bare
+    # symbol keep meaning "my alerts", as they always have.
+    if str(ev.get("name") or "").strip().lower() == "trade":
+        sym = str(ev.get("symbol") or "").strip().lower()
+        tid = str(ev.get("id") or "").strip().lower()
+        wanted = {"trade", "trade:%s" % sym if sym else "", tid} - {""}
+        return any(w in wanted for w in want)
+    facets = [str(ev.get(k) or "").strip().lower()
               for k in ("label", "id", "symbol", "name", "alert_type")]
     facets = [f for f in facets if f]
     return any(w == "*" or w in facets for w in want)
@@ -1226,9 +1300,12 @@ def _grab(m):
     except ImportError:
         pass
     # WITHOUT mss, STILL THE RIGHT SCREEN. pyautogui grabs a region of the
-    # virtual desktop, which is all this ever needed; mss is only faster.
+    # virtual desktop, which is all this ever needed; mss is only faster. It
+    # is asked in POINTER steps (a Retina Mac's real pixels would put the
+    # region twice as far out and twice as large).
+    pb = _pointer_box(m)
     try:
-        img = _gui().screenshot(region=(box["left"], box["top"], box["width"], box["height"]))
+        img = _gui().screenshot(region=(int(pb["x"]), int(pb["y"]), int(pb["width"]), int(pb["height"])))
     except Exception as err:
         # Some platforms cannot reach a monitor left of the origin, where x is
         # negative. Say so rather than handing back the primary and letting
@@ -1249,7 +1326,7 @@ def _grid_step(w, h):
     return 100 if big <= 1400 else (200 if big <= 3000 else 400)
 
 
-def _draw_grid(img, ox, oy, unit=1.0):
+def _draw_grid(img, ox, oy, unit=1.0, step=None):
     """A ruler, in the numbers you would actually click.
 
     Reading a position off a picture by eye is the one thing a model is poor at,
@@ -1273,7 +1350,7 @@ def _draw_grid(img, ox, oy, unit=1.0):
     # numbers and then converted, never the other way round: the label has to be
     # a number that can be clicked.
     unit = float(unit) or 1.0
-    step = _grid_step(int(w / unit), int(h / unit))
+    step = int(step) if step else _grid_step(int(w / unit), int(h / unit))
     try:
         d = ImageDraw.Draw(img)
     except Exception:
@@ -1679,11 +1756,15 @@ def serve(idle_s=SERVE_IDLE_S):
         pass
 
     last = [_time.time()]
+    busy = [False]
 
     def reap():
         while True:
             _time.sleep(5)
-            if _time.time() - last[0] > idle_s:
+            # Idle means NOTHING IN FLIGHT and nothing for a while: a wait()
+            # or a slow page past the quarter hour used to take the process
+            # down mid-command, with the caller left holding a dead socket.
+            if not busy[0] and _time.time() - last[0] > idle_s:
                 try:
                     os.remove(_serve_note())
                 except OSError:
@@ -1722,6 +1803,7 @@ def serve(idle_s=SERVE_IDLE_S):
                 if not callable(fn):
                     reply = {"ok": False, "error": 'no "%s" here' % req.get("op")}
                 else:
+                    busy[0] = True
                     try:
                         out = fn(*(req.get("args") or []), **(req.get("kwargs") or {}))
                         reply = {"ok": True, "out": out}
@@ -1730,6 +1812,9 @@ def serve(idle_s=SERVE_IDLE_S):
                         # somebody, and every refusal here is written to say
                         # what to do next.
                         reply = {"ok": False, "error": str(err)}
+                    finally:
+                        busy[0] = False
+                        last[0] = _time.time()
             conn.sendall((_json.dumps(reply, default=str) + "\n").encode("utf-8"))
         except Exception:
             # One bad connection is not a reason to stop serving the rest.
@@ -1964,6 +2049,29 @@ def do(*steps, **kw):
     return out
 
 
+def _arrive(g, x, y):
+    """Put the pointer on the spot and let the app see it there before a press.
+
+    A pointer that appears on a button and presses in the same instant is a
+    press some apps never see: Chromium and Electron surfaces want the hover
+    before the button, a menu item highlights on arrival, and a drag that
+    starts before the source is hovered picks up nothing (owner, 2026-09-14:
+    "the clicking is sloppy"). pyautogui already waits its own 20ms after the
+    move; ATLAS_COMPUTER_HOVER_MS (default 60, 0 for none, at most 500) is the
+    only thing added on top, and it is the same for every kind of press.
+    """
+    mv = getattr(g, "moveTo", None)
+    if not callable(mv):
+        return
+    mv(x, y)
+    try:
+        pause = float(os.environ.get("ATLAS_COMPUTER_HOVER_MS", "60")) / 1000.0
+    except ValueError:
+        pause = 0.06
+    if pause > 0:
+        __import__("time").sleep(min(pause, 0.5))
+
+
 def click(x, y, button="left", clicks=1, what=""):
     """Press something. SAY WHAT IT IS if you know.
 
@@ -1976,21 +2084,35 @@ def click(x, y, button="left", clicks=1, what=""):
     screen or out of find(); the log is the only place that knowledge can
     survive the click.
     """
-    return _do("click", lambda: _gui().click(x=x, y=y, button=button, clicks=clicks),
+    def go():
+        g = _gui()
+        # ARRIVE, THEN PRESS (see _arrive). The press itself names no point:
+        # the pointer is already there, and naming it again is a second move.
+        _arrive(g, x, y)
+        g.click(button=button, clicks=clicks)
+    return _do("click", go,
                {"x": x, "y": y, "button": button, "clicks": clicks,
                 "what": str(what)[:80], "screen": _SESSION_SCREEN["index"]},
                points=[(x, y)])
 
 
 def double_click(x, y, what=""):
-    return _do("double_click", lambda: _gui().doubleClick(x=x, y=y),
+    def go():
+        g = _gui()
+        _arrive(g, x, y)
+        g.doubleClick()
+    return _do("double_click", go,
                {"x": x, "y": y, "what": str(what)[:80],
                 "screen": _SESSION_SCREEN["index"]},
                points=[(x, y)])
 
 
 def right_click(x, y, what=""):
-    return _do("right_click", lambda: _gui().rightClick(x=x, y=y),
+    def go():
+        g = _gui()
+        _arrive(g, x, y)
+        g.rightClick()
+    return _do("right_click", go,
                {"x": x, "y": y, "what": str(what)[:80],
                 "screen": _SESSION_SCREEN["index"]},
                points=[(x, y)])
@@ -2003,7 +2125,8 @@ def move(x, y):
 def drag(from_x, from_y, to_x, to_y, duration=0.3):
     def go():
         g = _gui()
-        g.moveTo(from_x, from_y)
+        # Hovered before the button goes down, or the drag picks up nothing.
+        _arrive(g, from_x, from_y)
         g.dragTo(to_x, to_y, duration=duration, button="left")
     # BOTH ends: a drag that starts here and finishes on the other monitor is
     # the same mistake, made slowly.
@@ -3364,12 +3487,109 @@ def region(x, y, width, height, path=None):
     """
     def take():
         shot = _gui().screenshot(region=(int(x), int(y), int(width), int(height)))
+        # POINTER SPACE, like screen() and look_at(). A Retina Mac hands back
+        # twice the pixels asked for; left at that size, a position read off
+        # the patch was half of where it should be.
+        sc = _capture_scale()
+        if sc > 1.01:
+            try:
+                shot = shot.resize((max(1, int(round(shot.width / sc))), max(1, int(round(shot.height / sc)))))
+            except Exception:
+                pass
         out = path or os.path.join(_session_dir(), "region-%d.png" % int(__import__("time").time() * 1000))
         shot.save(out)
         return out
     return _do("region", take, {"x": x, "y": y, "width": width, "height": height})
 
 
+def look_at(x, y, radius=100, zoom=3, path=None):
+    """A CLOSE LOOK at one spot before pressing it, with the same ruler.
+
+    The ruler on a whole-screen picture is 100 or 200 desktop pixels apart, and
+    a position judged by eye between two labels is off by ten or twenty: enough
+    to miss a menu item, a checkbox or a small icon (owner, 2026-09-14: "the
+    clicking is sloppy"). This photographs the patch around your guess at
+    `zoom` times its size, with a ruler every 20 desktop pixels and a gold
+    crosshair on the guess itself, so the second reading is a number you count
+    to rather than one you estimate.
+
+        look_at(850, 450)                    # 200x200 around the guess, x3
+        click(858, 446, what="Sign in")      # what the close-up says
+
+    Same numbers in, same numbers on the ruler, as screen() and click(): desktop
+    coordinates, nothing to add. The crosshair is where you SAID. The pointer is
+    drawn too (a cyan ring) when it is inside the patch, so move(x, y) then
+    look_at(x, y) shows exactly where a click would land before it does.
+
+    Returns {"path", "x", "y", "left", "top", "width", "height", "zoom",
+    "grid": 20, "note"}. `radius` is in desktop pixels; the patch is clipped to
+    the screen, so a corner gives a smaller picture rather than a refusal.
+    """
+    x, y = int(x), int(y)
+    # A patch no bigger than a screen's quarter at no more than 5x: the ruler
+    # needs exact picture pixels per desktop step, so the size cap that keeps
+    # a whole-screen picture small cannot apply here, and this is the limit
+    # instead.
+    radius = max(20, min(int(radius), 400))
+    zoom = max(1, min(int(zoom), 5))
+    geo = {}
+
+    def take():
+        from PIL import Image as _Im, ImageDraw as _Dr
+        # AFTER the policy checks in _do (the switch, the claim, the strip, the
+        # screen), so a refusal is the right refusal and is logged like any
+        # other action.
+        m = _current_screen()
+        box = _pointer_box(m)
+        left = max(int(box["x"]), x - radius)
+        top = max(int(box["y"]), y - radius)
+        right = min(int(box["x"]) + int(box["width"]), x + radius)
+        bottom = min(int(box["y"]) + int(box["height"]), y + radius)
+        w, h = right - left, bottom - top
+        if w < 1 or h < 1:
+            raise RuntimeError("this computer did not report its screens, so there is nothing to look at")
+        geo.update({"left": left, "top": top, "width": w, "height": h})
+        hide_consoles()
+        img, _raw = _grab(m)
+        sc = _capture_scale()
+        # The grab is in the display's real pixels; the patch was measured in
+        # pointer steps, and so is `box` (a Retina second monitor starts at
+        # 1440 in pointer steps and 2880 in real pixels). Crop in real pixels
+        # from the POINTER origin, then bring it to `zoom` picture pixels per
+        # pointer step, so the ruler's unit is exact.
+        crop = img.crop((int(round((left - box["x"]) * sc)), int(round((top - box["y"]) * sc)),
+                         int(round((right - box["x"]) * sc)), int(round((bottom - box["y"]) * sc))))
+        img = crop.resize((w * zoom, h * zoom), _Im.LANCZOS)
+        img = _draw_grid(img, left, top, unit=float(zoom), step=20)
+        d = _Dr.Draw(img)
+        cx, cy = (x - left) * zoom, (y - top) * zoom
+        gold = (255, 215, 0)
+        gap = 4 * zoom
+        d.line([(cx, 0), (cx, cy - gap)], fill=gold, width=1)
+        d.line([(cx, cy + gap), (cx, img.height)], fill=gold, width=1)
+        d.line([(0, cy), (cx - gap, cy)], fill=gold, width=1)
+        d.line([(cx + gap, cy), (img.width, cy)], fill=gold, width=1)
+        try:
+            px, py = get_cursor()
+            if left <= int(px) < right and top <= int(py) < bottom:
+                qx, qy = (int(px) - left) * zoom, (int(py) - top) * zoom
+                r = 3 * zoom
+                d.ellipse([qx - r, qy - r, qx + r, qy + r], outline=(0, 230, 255), width=2)
+        except Exception:
+            pass
+        out = path or os.path.join(_session_dir(), "look-%d.png" % int(__import__("time").time() * 1000))
+        _save_shot(img, out)
+        return out
+
+    out = _do("look_at", take, {"x": x, "y": y, "radius": radius, "zoom": zoom}, points=[(x, y)])
+    return {"path": out, "x": x, "y": y, "left": geo.get("left"), "top": geo.get("top"),
+            "width": geo.get("width"), "height": geo.get("height"),
+            "zoom": zoom, "grid": 20,
+            "note": ("a close-up around %d, %d at %dx: the ruler is labelled in DESKTOP "
+                     "coordinates every 20 pixels - click what it says; the gold crosshair "
+                     "is the point you asked about") % (x, y, zoom)}
+
+
 def find(image, confidence=0.9):
     """Where something LOOKS like `image` on screen, as (x, y) of its middle.
 

package/src/remote-control.js

@@ -525,6 +525,16 @@ export function readAlertTriggers(dir) {
 /** Does a fired alert (the /api/v1/alerts event) match a project's on_alert list? */
 export function alertMatches(triggers, event) {
   if (!triggers || !triggers.length || !event || typeof event !== 'object') return false;
+  // A TRADE on the feed (a fill, a stop, a take-profit rung, a close, a draft
+  // signal) is reached only by asking for it: "trade", "trade:SPY", or the
+  // trigger's id. Never by "*" or a bare symbol, which every project listening
+  // before trades joined the feed already uses to mean "my alerts" (2026-09-14).
+  if (String(event.name || '').trim().toLowerCase() === 'trade') {
+    const sym = String(event.symbol || '').trim().toLowerCase();
+    const tid = String(event.id || '').trim().toLowerCase();
+    const wanted = new Set(['trade', sym ? `trade:${sym}` : '', tid].filter(Boolean));
+    return triggers.some((t) => wanted.has(t));
+  }
   const facets = [event.label, event.id, event.symbol, event.name, event.alert_type]
     .map((v) => String(v || '').trim().toLowerCase()).filter(Boolean);
   return triggers.some((t) => t === '*' || facets.includes(t));
@@ -1395,7 +1405,7 @@ export async function askModel(
   // named model in one runtime and quietly used the default in the other. That
   // is the shape of bug where an orchestrator believes it asked three models and
   // asked one three times.
-  { job = '', tools = true, fresh = false, timeoutMs = 900000, model = '' } = {},
+  { job = '', tools = true, fresh = false, timeoutMs = 900000, model = '', peer = '' } = {},
 ) {
   const url = process.env.ATLAS_ASK_URL;
   const token = process.env.ATLAS_ASK_TOKEN;
@@ -1408,7 +1418,12 @@ export async function askModel(
   const res = await fetch(url, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json', 'X-Atlas-Token': token },
-    body: JSON.stringify({ job, prompt: String(prompt), tools, fresh, ...(model ? { model } : {}) }),
+    body: JSON.stringify({
+      job: job || process.env.ATLAS_JOB || '', prompt: String(prompt), tools, fresh,
+      ...(model ? { model } : {}), ...(peer ? { peer } : {}),
+      // Who is asking, so the bridge can refuse a model asking itself.
+      from: process.env.ATLAS_ASK_PEER || '',
+    }),
     signal: AbortSignal.timeout(timeoutMs),
   });
   const out = await res.json().catch(() => ({}));

package/src/util/help.js

@@ -28,16 +28,12 @@ export function printRootHelp() {
   println('        [--no-greeks] [--json]');
   println();
   println(c.bold('PLAYS (SIGNALS)'));
-  println('  signals groups                                     Groups you post to, and the ones you follow');
-  println('  signals plays [--board community|private]          The plays [--days N] [--limit N]');
-  println('  signals performance --group <id> [--mine]          A group\'s closed trades and win rate');
-  println('  signals delete --group <id> [--stop-subscribers]   Delete a group (stops subscriptions first)');
-  println('  signals take --id <play> [--contracts N]           Place a play in your account');
-  println('  signals <discover|follow|show|schema>              ' + c.dim('atlas signals help for all of it'));
+  println('  signals post --symbol SPY ...                      Post a play (--link oco|oeo for a second leg)');
+  println('  signal-groups · signal-list · signal-take          ' + c.dim('every Signal-* and Trade-* tool, by name'));
   println();
   println(c.bold('STREAMS'));
-  println('  alerts list [--all] [--symbol SPY]                 Your alerts, with their ids');
-  println('  alerts delete --id <id> [--id <id2>] [--purge]     Switch alerts off, or delete for good');
+  println('  alerts schema                                      The shape of every feed event (JSON Schema)');
+  println('  list-alerts · delete-alert --alert-ids <id>        ' + c.dim('your alerts, and clearing spoiled ones'));
   println('  alerts [--symbol SPY] [--name greek_exposure]      Live alert feed (SSE)');
   println('         [--save-charts <dir>] [--no-chart] [--json]');
   println('         [--detach] [--stop]                        Stream in the background, or stop it');
@@ -63,14 +59,12 @@ export function printRootHelp() {
   println(c.dim('  atlas options-chain --symbol SPY --expiration 2026-06-20'));
   println(c.dim('  atlas historical-contract --symbol NVDA --expiry 2026-07-13 --strike 205 --side call --from 2026-07-06 --to 2026-07-10'));
   println(c.dim('  atlas update-alert --alert-id <id> --updates.is-active true   # nested via a dotted flag'));
-  println(c.dim('  atlas create-task --name "Close SPY 3:55" --instruction "Close my SPY position" --schedule-times 15:55'));
-  println(c.dim('  atlas run-task --task-id <id>'));
   println(c.dim('  atlas workflow-create --name "GEX signal" --schedule "30 9 * * 1-5" --tools Stock-Quote --instruction "…"'));
   println(c.dim('  atlas workflow-create --name "FOMC day" --run-once-at "2026-09-17 14:00" --tools Stock-Quote --instruction "…"   # once, at specific dates/times; --trigger-source manual = Run now only'));
   println(c.dim('  atlas alerts --symbol SPY --name greek_exposure --save-charts ./charts'));
   println(c.dim('  atlas flow stream --symbol NVDA'));
-  println(c.dim('  atlas signals performance --group <id>'));
-  println(c.dim('  atlas signals delete --group <id> --stop-subscribers'));
+  println(c.dim('  atlas signal-group-performance --group-id <id>'));
+  println(c.dim('  atlas signal-group-delete --group-id <id> --stop-subscribers'));
 }
 
 // Parse the `Args:` block of a tool docstring into { paramName: description }.