mindvest-atlas 0.100.0 → 0.100.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.100.0",
+  "version": "0.100.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/remote-control.js

@@ -1033,6 +1033,21 @@ function startLocalRequests(root, timeoutMs) {
  * alone, so with Studio closed a "weekdays 8:30" check never ran.
  */
 const checksSeen = new Map();
+/** Check times that are not a valid schedule, said once each (they never run). */
+const checksWarned = new Set();
+
+/** Say once why a checks schedule, or one check's own time, never runs. */
+function warnCheckTimes(slug, when) {
+  const times = [['schedule', when.schedule], ...Object.entries(when.each || {}).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))];
+  for (const [label, sched] of times) {
+    if (!sched?.error) continue;
+    const key = `${slug}/${label}/${sched.expr}`;
+    if (checksWarned.has(key)) continue;
+    checksWarned.add(key);
+    const who = label === 'schedule' ? 'checks schedule' : `check "${label}"`;
+    eprintln(color.yellow(`· ${slug}, ${who}: ${sched.error}`));
+  }
+}
 /** When a project's checks last ended here: what a run writes is not a change. */
 export const checksEndedAt = new Map();
 const SETTLE_MS = 10_000;
@@ -1046,6 +1061,7 @@ export function checksTick(root, nowMs = Date.now(), spawn = spawnJob) {
     const dir = path.join(base, slug);
     if (!fs.existsSync(path.join(dir, 'checks.py'))) continue;
     const when = checksWhen(dir);
+    warnCheckTimes(slug, when);
     const prints = projectPrints(dir);
     const off = checksOff(dir);
     let s = checksSeen.get(slug);

package/src/config.js

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

@@ -416,26 +416,51 @@ export async function mcpTools({ server = "", search = "" } = {}) {
  * the payload (see phonePress()). `done: true` finishes a card that is up. At
  * most 30 new ones an hour, so say what matters, not every step.
  *
+ * A tap on it opens this project in Local Mode, on this computer. `view` picks
+ * its tab (files, checks, dashboard, chats, computer). `open` sends the tap
+ * anywhere else on the dashboard instead: a name such as notifications,
+ * alerts, workflow:<id>:performance or project:<folder>:checks, or a path
+ * starting /atlas/dashboard?. The answer's `opens` says where it will go.
+ *
  *     await notify("Backtest done", { body: "SPY: 61% win\n214 trades", key: "backtest" });
  *     await notify("Backtest running", { key: "backtest", progress: 0.4 });
  *     await notify("Backtest done", { key: "backtest", button: "Run on QQQ" });
+ *     await notify("Charts ready", { key: "charts", view: "dashboard" });
+ *     await notify("Alert fired", { open: "alerts" });
  *
  * Returns the tool's answer. `sent` is 0 when the owner switched these off
  * (Profile, Manage notifications, Studio); that is their choice, not an error.
  */
-export async function notify(title, { body = "", key = "", progress = null, button = "", done = false } = {}) {
+export async function notify(title, { body = "", key = "", progress = null, button = "", done = false, open = "", view = "" } = {}) {
   const params = { title, body: body || "" };
   if (key) params.key = key;
   if (progress !== null && progress !== undefined) params.progress = progress;
-  if (button) {
-    params.button = button;
-    // The project the button starts: this one.
-    params.project = process.env.ATLAS_JOB || "";
-  }
+  if (button) params.button = button;
   if (done) params.done = true;
+  // This project: the one the button starts, and where a tap opens.
+  const job = process.env.ATLAS_JOB || "";
+  if (job || button) params.project = job;
+  if (job) {
+    const machine = machineHere();
+    if (machine) params.machine = machine;
+    if (view) params.view = view;
+  }
+  if (open) params.open = open;
   return atlas("phone-notify", params);
 }
 
+/** This computer's id, as the atlas command line keeps it ("" if none). */
+function machineHere() {
+  let found = (process.env.ATLAS_MACHINE || "").trim();
+  if (!found) {
+    const dir = process.env.ATLAS_CONFIG_DIR
+      || (process.env.XDG_CONFIG_HOME ? path.join(process.env.XDG_CONFIG_HOME, "atlas") : path.join(os_.homedir(), ".config", "atlas"));
+    try { found = fs.readFileSync(path.join(dir, "machine-id"), "utf8").trim(); } catch { found = ""; }
+  }
+  found = found.slice(0, 64);
+  return /^[\w-]+$/.test(found) ? found : "";
+}
+
 /**
  * The button press this is about, or null.
  *

package/src/helpers/atlas_env.py

@@ -568,7 +568,24 @@ def mcp_tools(server="", search=""):
     return atlas("mcp-tools", server=server or "", search=search or "")
 
 
-def notify(title, body="", key="", progress=None, button="", done=False):
+def _machine_here():
+    """This computer's id, as the atlas command line keeps it ('' if none)."""
+    if os.environ.get("ATLAS_MACHINE"):
+        found = os.environ["ATLAS_MACHINE"].strip()
+    else:
+        base = os.environ.get("ATLAS_CONFIG_DIR") or (
+            os.path.join(os.environ["XDG_CONFIG_HOME"], "atlas") if os.environ.get("XDG_CONFIG_HOME")
+            else os.path.join(os.path.expanduser("~"), ".config", "atlas"))
+        try:
+            with open(os.path.join(base, "machine-id"), encoding="utf-8") as f:
+                found = f.read().strip()
+        except Exception:
+            found = ""
+    found = found[:64]
+    return found if found and all(c.isascii() and (c.isalnum() or c in "_-") for c in found) else ""
+
+
+def notify(title, body="", key="", progress=None, button="", done=False, open="", view=""):
     """Tell the owner's PHONE (the MindVest Atlas app). A fixed layout you fill in.
 
     A title (cut at 40 characters) and up to two short lines; plain words. The
@@ -578,9 +595,17 @@ def notify(title, body="", key="", progress=None, button="", done=False):
     in the payload (see phone_press()). `done=True` finishes a card that is up.
     At most 30 new ones an hour, so say what matters, not every step.
 
+    A tap on it opens this project in Local Mode, on this computer. `view`
+    picks its tab (files, checks, dashboard, chats, computer). `open` sends the
+    tap anywhere else on the dashboard instead: a name such as notifications,
+    alerts, workflow:<id>:performance or project:<folder>:checks, or a path
+    starting /atlas/dashboard?. The answer's `opens` says where it will go.
+
         notify("Backtest done", "SPY: 61% win\n214 trades", key="backtest")
         notify("Backtest running", key="backtest", progress=0.4)
         notify("Backtest done", "Run it on QQQ too?", key="backtest", button="Run on QQQ")
+        notify("Charts ready", key="charts", view="dashboard")
+        notify("Alert fired", open="alerts")
 
     Returns the tool's answer. `sent` is 0 when the owner switched these off
     (Profile, Manage notifications, Studio); that is their choice, not an error.
@@ -592,10 +617,20 @@ def notify(title, body="", key="", progress=None, button="", done=False):
         params["progress"] = progress
     if button:
         params["button"] = button
-        # The project the button starts: this one.
-        params["project"] = os.environ.get("ATLAS_JOB", "")
     if done:
         params["done"] = True
+    # This project: the one the button starts, and where a tap opens.
+    job = os.environ.get("ATLAS_JOB", "")
+    if job or button:
+        params["project"] = job
+    if job:
+        machine = _machine_here()
+        if machine:
+            params["machine"] = machine
+        if view:
+            params["view"] = view
+    if open:
+        params["open"] = open
     return atlas("phone-notify", **params)
 
 
@@ -1144,12 +1179,13 @@ class _CheckRun:
         data["running"] = None
         data["last_run"] = {"id": self.id, "at": _time.strftime("%Y-%m-%dT%H:%M:%S", _time.localtime()),
                             "took_s": round(_time.time() - self.started, 1), "replay_of": self.replay_of,
-                            "model": self.model, "error": msg}
+                            "model": self.model, "error": msg,
+                            "only": self.only or None, "skip": self._skipped()}
         _write_json(path, data)
         _history_add({
             "kind": "run", "id": self.id, "at": data["last_run"]["at"], "why": self.why,
             "replay_of": self.replay_of, "model": self.model, "took_s": data["last_run"]["took_s"],
-            "error": msg, "only": self.only or None, "checks": self._results,
+            "error": msg, "only": self.only or None, "skip": self._skipped(), "checks": self._results,
         })
         if self.why in _UNATTENDED:
             conf = _notify_conf()
@@ -1179,6 +1215,10 @@ class _CheckRun:
             "id": self.id,
             "replay_of": self.replay_of,
             "only": self.only or None,
+            # WHAT THIS RUN COVERS (2026-10-17): a run on the project's
+            # schedule leaves out the checks whose own time it is not, so the
+            # screens show only the others running.
+            "skip": self._skipped(),
             "step": self._current[0] if self._current else "Starting",
             "done": len(steps),
             "total": self._total,
@@ -1322,6 +1362,11 @@ class _CheckRun:
         except Exception:
             return ""
 
+    def _skipped(self):
+        """The checks this run leaves out (a run with `only` names what it
+        covers instead), or None."""
+        return (list(self.skip) or None) if not self.only else None
+
     # ── results ──
     def wants(self, check_id):
         """False for a check this run was not asked for (Recheck of one, or a
@@ -1413,7 +1458,7 @@ class _CheckRun:
         data = _read_json(path, {})
         data["last_run"] = {"id": self.id, "at": _time.strftime("%Y-%m-%dT%H:%M:%S", _time.localtime()),
                             "took_s": round(_time.time() - self.started, 1), "replay_of": self.replay_of,
-                            "model": self.model}
+                            "model": self.model, "only": self.only or None, "skip": self._skipped()}
         data["running"] = None
         _write_json(path, data)
         self._finished = True
@@ -1421,7 +1466,7 @@ class _CheckRun:
         _history_add({
             "kind": "run", "id": self.id, "at": data["last_run"]["at"], "why": self.why,
             "replay_of": self.replay_of, "model": self.model, "took_s": data["last_run"]["took_s"],
-            "checks": self._results,
+            "only": self.only or None, "skip": self._skipped(), "checks": self._results,
         })
         # NOBODY WAS WATCHING (its schedule, a change, a fix): what the
         # project's Notifications tab asks for goes to the person's phone, per
@@ -1507,7 +1552,8 @@ def _checks_notify(conf, told, line, why, project):
     title = template.replace("{project}", project).replace("{count}", str(len(told))).replace("{what}", what)
     when = "%s, %s" % (_WHY_WORDS.get(why, "Ran"), _time.strftime("%H:%M"))
     try:
-        notify(title[:40], "%s\n%s" % (line, when), key="checks-%s" % project)
+        # A tap opens this project's Checks, on this computer.
+        notify(title[:40], "%s\n%s" % (line, when), key="checks-%s" % project, view="checks")
     except Exception:
         pass
 

package/src/remote-control.js

@@ -261,39 +261,121 @@ export function readManifest(dir) {
 // ticker writes a "Computer was off" row for any gap it finds when it wakes.
 
 const CRON_RANGES = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 7]];
+const CRON_FIELD_WORDS = ['minutes', 'hours', 'days of the month', 'months', 'days of the week'];
+const MONTH_NAMES = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+const DAY_NAMES = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+/** The most days each month can have (February: 29, in a leap year). */
+const MONTH_DAYS = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+export const CRON_MACROS = {
+  '@yearly': '0 0 1 1 *', '@annually': '0 0 1 1 *', '@monthly': '0 0 1 * *', '@weekly': '0 0 * * 0',
+  '@daily': '0 0 * * *', '@midnight': '0 0 * * *', '@hourly': '0 * * * *',
+};
 
-/**
- * Parse a five-field cron line into sets, or null when it is not one.
- *
- * Supports what people actually write: `*`, `n`, `a-b`, `* /n` (no space),
- * `a-b/n` and comma lists. Day-of-week 7 is Sunday like 0. No names.
- */
-export function parseCron(expr) {
-  const parts = String(expr || '').trim().split(/\s+/);
-  if (parts.length !== 5) return null;
-  const fields = [];
-  for (let i = 0; i < 5; i += 1) {
-    const set = new Set();
-    for (const piece of parts[i].split(',')) {
-      const m = /^(\*|\d+(?:-\d+)?)(?:\/(\d+))?$/.exec(piece);
-      if (!m) return null;
-      let [lo, hi] = CRON_RANGES[i];
-      if (m[1] !== '*') {
-        const [a, b] = m[1].split('-').map(Number);
-        lo = a; hi = b === undefined ? a : b;
-      }
-      const step = m[2] ? Number(m[2]) : 1;
-      if (!(step > 0) || lo < CRON_RANGES[i][0] || hi > CRON_RANGES[i][1] || lo > hi) return null;
-      for (let v = lo; v <= hi; v += step) set.add(i === 4 && v === 7 ? 0 : v);
+function cronValue(v, i, rangeEnd) {
+  if (/^\d{1,2}$/.test(v)) {
+    const n = Number(v);
+    return n >= CRON_RANGES[i][0] && n <= CRON_RANGES[i][1] ? n : null;
+  }
+  const name = v.toLowerCase();
+  if (i === 3 && MONTH_NAMES.includes(name)) return MONTH_NAMES.indexOf(name) + 1;
+  // SUN closing a range is the week's last day (FRI-SUN), else its first.
+  if (i === 4 && DAY_NAMES.includes(name)) return name === 'sun' && rangeEnd ? 7 : DAY_NAMES.indexOf(name);
+  return null;
+}
+
+/** One field as its sorted values, or why it is not one (a string). */
+function cronField(text, i) {
+  const [lo, hi] = CRON_RANGES[i];
+  const what = CRON_FIELD_WORDS[i];
+  const out = new Set();
+  for (const piece of text.split(',')) {
+    const m = /^(\*|\?|[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?)(?:\/(\d+))?$/.exec(piece);
+    if (!m) return `"${piece}" is not one of the ${what}.`;
+    if (m[1] === '?' && i !== 2 && i !== 4) return `"?" only stands in a day field, not in the ${what}.`;
+    let a = lo;
+    let b = hi;
+    if (m[1] !== '*' && m[1] !== '?') {
+      const [x, y] = m[1].split('-');
+      const va = cronValue(x, i, false);
+      if (va === null) return `"${x}" is not one of the ${what} (${lo} to ${hi}).`;
+      const vb = y === undefined ? null : cronValue(y, i, true);
+      if (y !== undefined && vb === null) return `"${y}" is not one of the ${what} (${lo} to ${hi}).`;
+      a = va;
+      b = vb ?? (m[2] ? hi : va);
+      if (a > b) return `"${piece}" runs backwards: write the smaller first.`;
     }
-    fields.push(set);
+    const step = m[2] === undefined ? 1 : Number(m[2]);
+    if (!(step >= 1 && step <= hi)) return `A step of ${m[2]} does not fit the ${what} (1 to ${hi}).`;
+    for (let v = a; v <= b; v += step) out.add(v);
+  }
+  return [...out].sort((x, y) => x - y);
+}
+
+/**
+ * READ A CRON LINE: `{ cron }` as sets, or `{ why }` in a sentence an agent
+ * can act on. The ONE reading, shared word for word with Atlas Studio and the
+ * web (their @shared/checks readCron) and line for line with the python
+ * runner's read_cron (owner, 2026-10-17: "the AI stores in cron, so you need to
+ * parse really well"):
+ *
+ * - five fields: minute 0-59, hour 0-23, day of the month 1-31, month 1-12 or
+ *   JAN-DEC, day of the week 0-7 or SUN-SAT (0 and 7 are Sunday);
+ * - `*`, a number or name, `a-b`, `* /n` (no space), `a-b/n`, `a/n` (a to the
+ *   field's end) and comma lists of those; `?` is `*` in the two day fields; a
+ *   range ending in SUN ends on Sunday (FRI-SUN);
+ * - @hourly, @daily (@midnight), @weekly, @monthly, @yearly (@annually);
+ * - BOTH DAY FIELDS LIMITED (neither covers every day): a day matching either
+ *   runs, the standard cron rule;
+ * - refused: six or seven fields, out of range, backwards, a step of 0 or past
+ *   the field's end, L / W / #, @reboot, a day that never comes in its months.
+ */
+export function readCron(expr) {
+  let line = String(expr ?? '').trim();
+  if (!line) return { cron: null, why: 'It is empty.' };
+  if (line.startsWith('@')) {
+    const m = CRON_MACROS[line.toLowerCase()];
+    if (!m) {
+      return { cron: null, why: line.toLowerCase() === '@reboot' ? '@reboot runs at start-up, not at a time.'
+        : `${line} is not one of @hourly, @daily, @weekly, @monthly or @yearly.` };
+    }
+    line = m;
+  }
+  const parts = line.split(/\s+/);
+  if (parts.length !== 5) {
+    return { cron: null, why: `It has ${parts.length} ${parts.length === 1 ? 'part' : 'parts'}; a schedule has 5: minute, hour, day of the month, month, day of the week${parts.length > 5 ? ' (no seconds, no year)' : ''}.` };
+  }
+  const sets = [];
+  for (let i = 0; i < 5; i += 1) {
+    const r = cronField(parts[i], i);
+    if (typeof r === 'string') return { cron: null, why: r };
+    sets.push(r);
+  }
+  const [minutes, hours, days, months, week] = sets;
+  const weekdays = [...new Set(week.map((d) => d % 7))].sort((a, b) => a - b);
+  const domStar = days.length === 31;
+  const dowStar = weekdays.length === 7;
+  if (dowStar && !domStar && !months.some((mo) => days.some((d) => d <= MONTH_DAYS[mo]))) {
+    return { cron: null, why: 'That day never comes in those months.' };
   }
   return {
-    minute: fields[0], hour: fields[1], dom: fields[2], month: fields[3], dow: fields[4],
-    domStar: parts[2] === '*', dowStar: parts[4] === '*',
+    cron: {
+      minute: new Set(minutes), hour: new Set(hours), dom: new Set(days), month: new Set(months), dow: new Set(weekdays),
+      domStar, dowStar,
+    },
+    why: null,
   };
 }
 
+/** A five-field cron line (or an @word) as sets, or null when it is not one (readCron says why). */
+export function parseCron(expr) {
+  return readCron(expr).cron;
+}
+
+/** Why a cron line is not a schedule, or null when it is one. */
+export function cronProblem(expr) {
+  return readCron(expr).why;
+}
+
 const DOW = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
 
 /** The wall-clock fields of a moment in a time zone (or this machine's). */
@@ -563,7 +645,7 @@ export function readSchedule(dir) {
     if (once) { lines.push({ kind: 'once', once, text: line }); continue; }
     const cron = parseCron(line);
     if (cron) { lines.push({ kind: 'cron', cron, text: line }); continue; }
-    bad = bad || `schedule "${line}" is not something I understand - use a cron `
+    bad = bad || `schedule "${line}" is not something I understand (${cronProblem(line)}) - use a cron `
       + 'line like "*/5 9-16 * * 1-5" or "once 2026-09-15 09:30"';
   }
   if (!lines.length && !bad) bad = `schedule "${expr}" has nothing in it`;
@@ -699,14 +781,19 @@ export function checksWhen(dir) {
   // The zone it is read in: the checks' own, else the project's, else UTC like
   // every schedule (Atlas Studio and the web say it in these words too).
   const tz = String([o.timezone, m.timezone].find((z) => typeof z === 'string' && z.trim()) || '').trim();
+  // A line that is not a valid cron is KEPT, with why: it never runs (the
+  // screens say "Not a valid schedule"), and the runner says why once.
   const sched = (raw) => {
     const expr = typeof raw === 'string' ? raw.trim() : '';
-    const cron = expr ? parseCron(expr) : null;
-    return cron ? { expr, lines: [{ kind: 'cron', cron, text: expr }], tz, error: null, cron } : null;
+    if (!expr) return null;
+    const { cron, why } = readCron(expr);
+    return cron ? { expr, lines: [{ kind: 'cron', cron, text: expr }], tz, error: null, cron }
+      : { expr, lines: [], tz, error: `"${expr}" is not a valid schedule: ${why}`, cron: null };
   };
   // A TIME PER CHECK (owner, 2026-10-16: "for each checks, let this be here"):
   // "each": {"<check id>": "<five-field cron>"}, read in the same zone. A check
-  // with no entry (or one that is not a cron) keeps the project's schedule.
+  // with no entry keeps the project's schedule; one whose entry is not a valid
+  // cron runs on no time at all.
   const each = {};
   const e = o.each && typeof o.each === 'object' && !Array.isArray(o.each) ? o.each : {};
   for (const [id, raw] of Object.entries(e).slice(0, 200)) {