mindvest-atlas 0.41.0 → 0.43.0

package/package.json

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

package/src/commands/computer-use.js

@@ -119,7 +119,10 @@ export function runInProject(job, code, root) {
   // THE SAME HOLDER FOR EVERY COMMAND in this shell, and no process behind the
   // claim: each of these exits, and a claim needing a live process would be
   // gone before the next one ran.
-  env.ATLAS_COMPUTER_SESSION = shellSession(root);
+  // INHERITED FIRST: Atlas hands the chat's own session down, so each
+  // conversation and each ask() gets its OWN recording. The shell id is the
+  // fallback for a bare terminal Atlas did not start.
+  if (!env.ATLAS_COMPUTER_SESSION) env.ATLAS_COMPUTER_SESSION = shellSession(root);
   env.ATLAS_COMPUTER_PID = '0';
   env.PYTHONPATH = [dir, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter);
   const out = spawnSync(python[0], [...python.slice(1), '-c', code], {

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.41.0';
+export const VERSION = '0.43.0';
 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.py

@@ -998,6 +998,44 @@ def _primary_index(mons):
 _SESSION_SCREEN = {"index": None}
 
 
+def _screen_note():
+    """Where the chosen screen is remembered, BETWEEN COMMANDS.
+
+    THIS IS WHY CAPTURES CAME BACK FROM SCREEN 1. Working the computer from a
+    shell means one short-lived process per action, and module state does not
+    survive that: use_screen(2) set a number in a process that then exited, and
+    the next command started fresh, found nothing, and fell back to the primary.
+    So a run said "work on screen 2", was told it had, and then every picture it
+    took was of screen 1 while it clicked coordinates measured on screen 2
+    (owner, 2026-09-06: "the capture keeps returning screen-1 content even after
+    switching to screen 2").
+
+    Beside the actions, because it is a fact about this session like they are.
+    """
+    return os.path.join(_session_dir(), "screen.json")
+
+
+def _remember_screen(index):
+    import json as _json
+    try:
+        with open(_screen_note(), "w", encoding="utf-8") as fh:
+            _json.dump({"index": int(index)}, fh)
+    except (OSError, TypeError, ValueError):
+        # A choice we cannot write down still holds for THIS process, which is
+        # the whole of a script's run.
+        pass
+
+
+def _recall_screen():
+    import json as _json
+    try:
+        with open(_screen_note(), encoding="utf-8") as fh:
+            want = _json.load(fh).get("index")
+        return int(want) if want else None
+    except Exception:
+        return None
+
+
 def _chosen_screen():
     """Which screen this computer has been told to work on, or None for any."""
     import json as _json
@@ -1026,6 +1064,7 @@ def use_screen(index=None):
             % (want, len(mons), "is" if len(mons) == 1 else "are")
         )
     _SESSION_SCREEN["index"] = want
+    _remember_screen(want)
     _log_action("use_screen", {"monitor": want, "x": found["x"], "y": found["y"],
                                "width": found["width"], "height": found["height"]})
     return found
@@ -1036,6 +1075,10 @@ def _current_screen():
     has said. Returns the whole entry, so callers have its bounds."""
     mons = screens()
     want = _SESSION_SCREEN["index"]
+    if want is None:
+        # WHAT THIS SESSION LAST CHOSE, before anything else. A command that did
+        # not itself call use_screen is still part of the run that did.
+        want = _recall_screen()
     if want is None:
         # THE ONE THE PERSON CHOSE, if they chose one. Defaulting to the primary
         # is right on one screen and wrong on three: somebody with a spare
@@ -1146,6 +1189,37 @@ def screen(path=None):
                     % (m["x"], m["y"])}
 
 
+def _screen_changed(path):
+    """True when this picture differs from the one before it.
+
+    Compared by content, not by time: a screen that is still is genuinely
+    unchanged, and telling a reader so saves it opening an image to discover
+    nothing moved. Kept in the session folder, so it works across the separate
+    processes a shell run is made of.
+    """
+    import hashlib
+    if not path:
+        return True
+    try:
+        with open(path, "rb") as fh:
+            now = hashlib.md5(fh.read()).hexdigest()
+    except OSError:
+        return True
+    mark = os.path.join(_session_dir(), "last-screen.txt")
+    was = None
+    try:
+        with open(mark, encoding="utf-8") as fh:
+            was = fh.read().strip()
+    except OSError:
+        pass
+    try:
+        with open(mark, "w", encoding="utf-8") as fh:
+            fh.write(now)
+    except OSError:
+        pass
+    return was != now
+
+
 def do(*steps, **kw):
     """Do several things, then look ONCE. The fast loop.
 
@@ -1198,6 +1272,11 @@ def do(*steps, **kw):
         _time.sleep(settle)
     shot = screen()
     out = {"did": did}
+    # DID ANYTHING ACTUALLY CHANGE? A picture that is byte-for-byte the last one
+    # is a wasted look: the reader spends a turn opening it to find out nothing
+    # happened, which is the slowest possible way to learn that. Said in words
+    # instead, and the picture is still there for when it did.
+    out["changed"] = _screen_changed(shot if isinstance(shot, str) else shot.get("path"))
     # screen() answers a bare path on one monitor and a dict on several. Both
     # travel, because the offset is the thing a reader needs next.
     if isinstance(shot, dict):
@@ -1261,13 +1340,27 @@ def type(text, interval=0.01):  # noqa: A001  (the name people expect)
                {"chars": len(str(text))})
 
 
-def key(keys):
-    """One key, or several together: key("enter"), key(["mod", "c"]).
+def key(*keys):
+    """One key, or several together.
+
+        key("enter")
+        key("ctrl", "a")          # and key(["ctrl", "a"]) still works
+        key("mod", "c")
+
+    BOTH SHAPES, because everything that calls this assumed the first one and it
+    only accepted the second. `atlas computer-use key ctrl a`, the guidance, and
+    every combination anybody wrote all raised "key() takes 1 positional
+    argument", so no chord worked ANYWHERE while single keys did (owner,
+    2026-09-06, after a run could not minimise a window with win+down and
+    concluded the CLI only takes one token). A signature that only its author
+    calls correctly is a broken signature.
 
     "mod" is control on Windows and Linux and command on a Mac, so one script
     works on all three. Anything else is passed through as written.
     """
-    names = _keys([keys] if isinstance(keys, str) else list(keys))
+    if len(keys) == 1 and not isinstance(keys[0], str):
+        keys = tuple(keys[0])
+    names = _keys(list(keys))
     return _do("key", lambda: (_gui().hotkey(*names) if len(names) > 1 else _gui().press(names[0])),
                {"keys": names})