mindvest-atlas 0.68.0 → 0.68.2

package/package.json

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

package/src/commands/alerts.js

@@ -48,6 +48,14 @@ async function listAlerts(flags) {
   return 0;
 }
 
+/** 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;
+}
+
 async function deleteAlerts(args) {
   const flags = args.flags;
   // --id may repeat; extra positionals after the verb are ids too, so
@@ -86,6 +94,7 @@ export async function alertsCommand(args) {
   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);
+  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/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/signals.js

@@ -22,6 +22,7 @@ ${color.bold('USAGE')}
 ${color.bold('COMMANDS')}
   groups                              The groups you can post to, and the ones you follow
   plays [--board community|private]   The plays themselves  [--days N] [--limit N]
+  post --symbol SPY ...               Post a play, on its own or as a LINKED pair
   show --id <play>                    One play, as a card
   take --id <play> [--contracts N]    Place a play in YOUR account  [--account <id>]
   performance --group <id> [--mine]   Closed trades and the win rate for a group
@@ -31,11 +32,27 @@ ${color.bold('COMMANDS')}
   follow --group <id> [--off]         Follow a public group, or stop
   schema                              What a play is made of — read before posting
 
+${color.bold('POSTING')}
+  --symbol SPY --call|--put --strike 765 --expiry 2026-09-14
+  --entry 765 [--entry-unit price|contract] [--target N ...] [--stop N]
+  [--group <id>]         a group of yours; left out, it goes to the community board
+  [--reason "..."] [--score 8] [--contracts 2] [--take-it-myself]
+
+  A LINKED PAIR — the second trade rides the same flags prefixed with-, and
+  anything you leave out is taken from the first leg:
+  --link oco   whichever fills first cancels the other
+  --link oeo   the second starts only once the first fills
+  --with-put --with-strike 760 --with-entry 759 --with-target 758 --with-stop 761
+
 ${color.bold('EXAMPLES')}
   atlas signals groups
   atlas signals plays --board community --days 1
   atlas signals performance --group <id>
   atlas signals delete --group <id> --stop-subscribers
+  atlas signals post --symbol SPY --call --strike 765 --expiry 2026-09-14 \\
+    --entry 765 --target 765.5 --target 766.1 --stop 764 --group <id>
+  atlas signals post --symbol SPY --call --strike 765 --expiry 2026-09-14 --entry 765 \\
+    --link oco --with-put --with-strike 760 --with-entry 759
 `;
 
 const callTool = (name, body) => requestJson(API.tool(name), { method: 'POST', body: body || {} });
@@ -60,6 +77,61 @@ function rows(list) {
   return Array.isArray(list) ? list : (list && Array.isArray(list.signals) ? list.signals : []);
 }
 
+// One play's fields, from flags. `pre` is '' for the first leg and 'with-' for
+// the linked one, so the two are described the same way and the second only has
+// to say what DIFFERS — everything else falls back to the first leg.
+export function legFrom(flags, pre, base) {
+  const f = (name) => flags[`${pre}${name}`];
+  const pick = (name, fallback) => {
+    const v = f(name);
+    return v === undefined || v === true ? fallback : v;
+  };
+  const call = f('call') === true || String(pick('option', '')).toLowerCase() === 'call';
+  const put = f('put') === true || String(pick('option', '')).toLowerCase() === 'put';
+  const targets = []
+    .concat(f('target') === undefined ? [] : f('target'))
+    .concat(f('targets') === undefined ? [] : f('targets'))
+    .filter((t) => t !== true)
+    .map((t) => num(t))
+    .filter((t) => t !== null);
+  const leg = {
+    symbol: String(pick('symbol', base?.symbol || '')).toUpperCase(),
+    side: String(pick('side', base?.side || 'buy')).toLowerCase(),
+  };
+  const assetFlag = String(pick('asset-class', '')).toLowerCase();
+  const isOption = call || put || assetFlag === 'option'
+    || (!assetFlag && base ? base.asset_class === 'option' : false)
+    || (!assetFlag && !base && (f('strike') !== undefined || f('expiry') !== undefined));
+  leg.asset_class = isOption ? 'option' : (assetFlag || 'stock');
+  if (isOption) {
+    leg.option_type = call ? 'call' : put ? 'put' : (base?.option_type || 'call');
+    const strike = num(pick('strike', null));
+    if (strike !== null) leg.strike = strike;
+    const exp = pick('expiry', pick('expiration', base?.expiration_date));
+    if (exp) leg.expiration_date = String(exp);
+  }
+  const entry = num(pick('entry', null));
+  if (entry !== null) leg.entry = entry;
+  const eu = pick('entry-unit', base?.entry_unit);
+  if (eu) leg.entry_unit = String(eu);
+  const eop = pick('entry-operator', null);
+  if (eop) leg.entry_operator = String(eop);
+  if (targets.length) leg.targets = targets;
+  const tu = pick('tp-unit', base?.tp_unit);
+  if (tu) leg.tp_unit = String(tu);
+  const stop = num(pick('stop', null));
+  if (stop !== null) leg.stop = stop;
+  const su = pick('stop-unit', base?.stop_unit);
+  if (su) leg.stop_unit = String(su);
+  const contracts = num(pick('contracts', null));
+  if (contracts !== null) leg.contracts = contracts;
+  const reason = pick('reason', null);
+  if (reason) leg.reason = String(reason);
+  const score = num(pick('score', null));
+  if (score !== null) leg.score = score;
+  return leg;
+}
+
 export async function signalsCommand(args) {
   const flags = args.flags || {};
   const sub = String(args._[0] || 'groups').toLowerCase();
@@ -102,6 +174,35 @@ export async function signalsCommand(args) {
       }
       return 0;
     }
+    case 'post': {
+      const leg = legFrom(flags, '', null);
+      if (!leg.symbol) { eprintln(color.red('Which stock? --symbol SPY')); return 1; }
+      const body = { ...leg };
+      if (flags.group) body.group_id = String(flags.group);
+      if (flags['take-it-myself'] || flags['trade-for-me']) body.trade_for_me = true;
+      if (flags.account) body.snaptrade_account_id = String(flags.account);
+      // A LINKED PAIR, from the CLI (owner, 2026-09-12). The tool has taken a
+      // second leg since linked plays shipped; what did not exist was a way to
+      // say it in flags, so anyone at a terminal had to hand-write JSON — and
+      // an agent reading the CLI concluded a linked pair could not be posted
+      // directly at all.
+      const link = String(flags.link || flags['link-mode'] || '').toLowerCase();
+      if (link) {
+        if (link !== 'oco' && link !== 'oeo') {
+          eprintln(color.red('--link is oco (whichever fills first cancels the other) or oeo (the second starts once the first fills).'));
+          return 1;
+        }
+        const second = legFrom(flags, 'with-', leg);
+        if (!second.symbol) { eprintln(color.red('The linked trade needs a stock: --with-symbol, or it takes the first leg\'s.')); return 1; }
+        body.second_leg = second;
+        body.link_mode = link;
+      }
+      const data = await callTool('Signal-Post', body);
+      if (failed(data)) return printFailure(data);
+      if (json) { println(prettyJson(data)); return 0; }
+      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; }

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.68.0';
+export const VERSION = '0.68.1';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';

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

@@ -37,6 +37,7 @@ export function printRootHelp() {
   println();
   println(c.bold('STREAMS'));
   println('  alerts list [--all] [--symbol SPY]                 Your alerts, with their ids');
+  println('  alerts schema                                      The shape of every feed event (JSON Schema)');
   println('  alerts delete --id <id> [--id <id2>] [--purge]     Switch alerts off, or delete for good');
   println('  alerts [--symbol SPY] [--name greek_exposure]      Live alert feed (SSE)');
   println('         [--save-charts <dir>] [--no-chart] [--json]');