mindvest-atlas 0.98.0 → 0.100.0

package/package.json

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

@@ -27,7 +27,7 @@ import {
   computerUseAllowed, listComputerSessions, readComputerActions, listComputerVideo, readComputerVideoPart,
   sessionReplay, venvPython, ambientPython,
   readSchedule, cronMatches, dueMinutes, scheduleMatches, scheduleDueMinutes, writeNext,
-  SCRIPTS_DIR, projectsForAlert, readMode, checksWhen, projectPrints,
+  SCRIPTS_DIR, projectsForAlert, readMode, checksWhen, checksDue, projectPrints,
   streamStudioFrames,
   localBrokers, localBrokerCall,
   localMemory,
@@ -283,6 +283,8 @@ async function handleAsk(ask, root) {
   // results are read like any file (op 'read' on checks.json and checks/).
   if (ask.op === 'checks') return answer(ask.request_id, startChecks({ ...ask, why: 'web' }, root));
   if (ask.op === 'checks_auto') return answer(ask.request_id, setCheckAuto(ask, root));
+  // Pause, resume or delete one check (owner, 2026-10-15), in checks/settings.json.
+  if (ask.op === 'checks_state') return answer(ask.request_id, setCheckState(ask, root));
   // ── Sharing a project ────────────────────────────────────────────────
   // Not awaited: a pack, an upload and a download are seconds to minutes on a
   // home connection, and the ask loop has the run queue, the schedule and every
@@ -908,12 +910,12 @@ const REQUEST_TICK_MS = 1000;
  */
 export function requestTick(root, timeoutMs, spawn = spawnJob, stop = stopRun, nowMs = Date.now()) {
   const acted = [];
-  for (const { dir, op, only, replay, why, assume } of takeRequests(root, nowMs)) {
+  for (const { dir, op, only, skip, replay, why, assume } of takeRequests(root, nowMs)) {
     const slug = path.basename(dir);
     // Atlas Studio's Run checks / Recheck: the same road a check run from the
     // web takes, so it runs exactly as the project's own run does.
     if (op === 'checks') {
-      const r = startChecks({ job: slug, only, replay, why, assume }, root, spawn);
+      const r = startChecks({ job: slug, only, skip, replay, why, assume }, root, spawn);
       if (r.ok) eprintln(color.dim(`· ${slug} — checks asked for here`));
       acted.push([slug, 'checks']);
       continue;
@@ -1045,27 +1047,37 @@ export function checksTick(root, nowMs = Date.now(), spawn = spawnJob) {
     if (!fs.existsSync(path.join(dir, 'checks.py'))) continue;
     const when = checksWhen(dir);
     const prints = projectPrints(dir);
+    const off = checksOff(dir);
     let s = checksSeen.get(slug);
     if (!s) { checksSeen.set(slug, { at: nowMs, ...prints, filesAt: 0, dataAt: 0, fixed: new Set() }); continue; }
     const busy = running.has(`${slug}:checks`) || starting.has(`${slug}:checks`) || nowMs - (checksEndedAt.get(slug) ?? 0) < 30_000;
     if (busy) { Object.assign(s, prints, { filesAt: 0, dataAt: 0, at: nowMs }); continue; }
     if (prints.files !== s.files) { s.files = prints.files; s.filesAt = nowMs; }
     if (prints.data !== s.data) { s.data = prints.data; s.dataAt = nowMs; }
+    const results = readJsonFile(path.join(dir, 'checks.json'));
+    const rows = Array.isArray(results?.checks) ? results.checks : [];
+    // ON THEIR TIMES: each check's own (atlas.json "checks"."each"), and the
+    // project's for every check without one; one run for all that are due.
+    const due = checksDue(when, rows.map((c) => String(c?.id)), off, s.at / 1000, nowMs / 1000);
     let why = null;
-    if (when.schedule && scheduleDueMinutes(when.schedule, s.at / 1000, nowMs / 1000).length) why = 'schedule';
+    if (due) why = 'schedule';
     else if (when.files && s.filesAt && nowMs - s.filesAt >= SETTLE_MS) why = 'files';
     else if (when.data && s.dataAt && nowMs - s.dataAt >= SETTLE_MS) why = 'data';
     s.at = nowMs;
+    // EVERY CHECK PAUSED OR DELETED: nothing to run by itself (atlas_env would
+    // skip each one anyway, after fetching its data for nothing).
+    if (why && rows.length && rows.every((c) => off.has(String(c?.id)))) { s.filesAt = 0; s.dataAt = 0; continue; }
     if (why) {
       s.filesAt = 0; s.dataAt = 0;
-      const r = startChecks({ job: slug, why }, root, spawn);
-      if (r.ok) { started.push([slug, why]); eprintln(color.dim(`· ${slug} — checks (${why})`)); }
+      const r = startChecks({ job: slug, why, ...(due ? due : {}) }, root, spawn);
+      const which = due?.only.length ? `: ${due.only.join(', ')}` : '';
+      if (r.ok) { started.push([slug, why]); eprintln(color.dim(`· ${slug} — checks (${why}${which})`)); }
       continue;
     }
     // A FIX THAT NOTHING HAS RUN SINCE: that check again, fresh.
-    const results = readJsonFile(path.join(dir, 'checks.json'));
     const fixes = readJsonFile(path.join(dir, 'checks', 'resolutions.json'));
-    for (const c of Array.isArray(results?.checks) ? results.checks : []) {
+    for (const c of rows) {
+      if (off.has(String(c?.id))) continue;
       const f = fixes && fixes[c?.id];
       if (!f || f.ok === false || c.status === 'pass' || s.fixed.has(`${c.id}@${f.at}`)) continue;
       if (Date.parse(f.at) <= Date.parse(c.ran_at || '')) continue;
@@ -1220,12 +1232,21 @@ export async function remoteControlCommand(args) {
 /** For the tests: the one road every run takes. */
 export const runJobForTests = (job, root, timeoutMs) => runJob(job, root, timeoutMs);
 
+const CHECK_ID_RE = /^[A-Za-z0-9_-]{1,80}$/;
+
 /** Start a project's checks.py through the ordinary run (plan check included). */
 export function startChecks(ask, root, spawn = spawnJob) {
   const job = String(ask?.job || '');
   const { dir } = workspace(job, root);
   if (!job || !fs.existsSync(path.join(dir, 'checks.py'))) return { ok: false, error: 'This project has no checks yet.' };
-  const only = (Array.isArray(ask.only) ? ask.only : []).map(String).filter((x) => /^[A-Za-z0-9_-]{1,80}$/.test(x));
+  const asked = (Array.isArray(ask.only) ? ask.only : []).map(String).filter((x) => CHECK_ID_RE.test(x));
+  // A paused or deleted check is never run, not even when named.
+  const off = checksOff(dir);
+  const only = asked.filter((x) => !off.has(x));
+  if (asked.length && !only.length) return { ok: false, error: 'That check is paused. Resume it to run it.' };
+  // Not due on this minute: a check whose own time did not come round, in a
+  // run the project's schedule started (atlas_env's wants() says no).
+  const skip = (Array.isArray(ask.skip) ? ask.skip : []).map(String).filter((x) => CHECK_ID_RE.test(x)).slice(0, 200);
   const replay = /^\d{8}-\d{6}$/.test(String(ask.replay || '')) ? String(ask.replay) : '';
   // What started it, for the run's history line (a word, or nothing).
   const why = /^[a-z]{1,20}$/.test(String(ask.why || '')) ? String(ask.why) : '';
@@ -1235,6 +1256,7 @@ export function startChecks(ask, root, spawn = spawnJob) {
     automation_id: job, name: job, source: 'local', file: 'checks.py',
     env: {
       ATLAS_CHECK_ONLY: only.join(','), ATLAS_CHECK_REPLAY: replay, ...(why ? { ATLAS_CHECK_WHY: why } : {}),
+      ...(skip.length && !only.length ? { ATLAS_CHECK_SKIP: skip.join(',') } : {}),
       ...(assume ? { ATLAS_CHECK_ASSUME: assume } : {}),
     },
   }, root, CHECKS_TIMEOUT_MS);
@@ -1264,6 +1286,59 @@ export function cleanAssume(raw) {
   return Object.keys(out).length ? JSON.stringify(out) : '';
 }
 
+/** The checks the person paused or deleted (checks/settings.json), by id. */
+export function checksOff(dir) {
+  const d = readJsonFile(path.join(dir, 'checks', 'settings.json')) || {};
+  const paused = d.paused && typeof d.paused === 'object' ? d.paused : {};
+  const deleted = d.deleted && typeof d.deleted === 'object' ? d.deleted : {};
+  return new Set([...Object.keys(paused).filter((k) => paused[k]), ...Object.keys(deleted)]);
+}
+
+/**
+ * PAUSE, RESUME OR DELETE ONE CHECK (owner, 2026-10-15: "I can pause and
+ * delete checks ... a button to pause checks so it never runs"), from the web
+ * or a phone. checks/settings.json, which Atlas Studio writes the same way
+ * and atlas_env reads at every run: a paused check never runs; a deleted one
+ * also leaves the results and is not written back.
+ */
+export function setCheckState(ask, root) {
+  const id = String(ask?.id || '');
+  const action = String(ask?.action || '');
+  if (!/^[A-Za-z0-9_-]{1,80}$/.test(id)) return { ok: false, error: 'That is not a check.' };
+  if (!['pause', 'resume', 'delete'].includes(action)) return { ok: false, error: 'Pause, resume or delete.' };
+  const { dir } = workspace(String(ask?.job || ''), root);
+  if (!fs.existsSync(dir)) return { ok: false, error: 'There is no such project on this computer.' };
+  const file = path.join(dir, 'checks', 'settings.json');
+  const d = readJsonFile(file) || {};
+  const paused = d.paused && typeof d.paused === 'object' ? d.paused : {};
+  const deleted = d.deleted && typeof d.deleted === 'object' ? d.deleted : {};
+  if (action === 'pause') paused[id] = true;
+  else delete paused[id];
+  if (action === 'delete') {
+    deleted[id] = new Date().toISOString();
+    if (d.auto_resolve && typeof d.auto_resolve === 'object') delete d.auto_resolve[id];
+  }
+  d.paused = paused;
+  d.deleted = deleted;
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(`${file}.tmp`, JSON.stringify(d, null, 2));
+    fs.renameSync(`${file}.tmp`, file);
+  } catch {
+    return { ok: false, error: 'That could not be saved.' };
+  }
+  if (action === 'delete') {
+    // Its row leaves the results; its history stays (the person's record).
+    const res = path.join(dir, 'checks.json');
+    const r = readJsonFile(res);
+    if (r && Array.isArray(r.checks) && r.checks.some((c) => c?.id === id)) {
+      r.checks = r.checks.filter((c) => c?.id !== id);
+      try { fs.writeFileSync(`${res}.tmp`, JSON.stringify(r, null, 2)); fs.renameSync(`${res}.tmp`, res); } catch { /* the settings already hide it */ }
+    }
+  }
+  return { ok: true };
+}
+
 /** One check's auto-resolve switch, in checks/settings.json (Atlas Studio reads it too). */
 export function setCheckAuto(ask, root) {
   const id = String(ask?.id || '');

package/src/config.js

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

@@ -1030,6 +1030,23 @@ def _read_json(path, default):
         return default
 
 
+def _check_id(value):
+    return "".join(c if c.isalnum() or c in "-_" else "-" for c in str(value))[:80] or "check"
+
+
+def _checks_off():
+    """THE CHECKS THE PERSON PAUSED OR DELETED (owner, 2026-10-15: "a button to
+    pause checks so it never runs"). Kept in checks/settings.json beside the
+    auto-fix switches, by Atlas Studio, the web (through the runner) and
+    restore_check(). A paused or deleted check never runs: wants() says no and
+    result() keeps nothing, whatever started the run (its schedule, a change,
+    Run all, an agent building)."""
+    d = _read_json(os.path.join(_checks_dir(), "checks", "settings.json"), {})
+    paused = d.get("paused") if isinstance(d.get("paused"), dict) else {}
+    deleted = d.get("deleted") if isinstance(d.get("deleted"), dict) else {}
+    return {str(k) for k, v in paused.items() if v} | {str(k) for k in deleted}
+
+
 def _library_versions():
     try:
         from importlib import metadata as _md
@@ -1048,6 +1065,9 @@ class _CheckRun:
         import time as _time
         self.dir = _checks_dir()
         self.only = [x for x in (os.environ.get("ATLAS_CHECK_ONLY") or "").split(",") if x]
+        # A run its project's schedule started, minus the checks that keep a
+        # time of their own which is not now (atlas.json "checks"."each").
+        self.skip = [x for x in (os.environ.get("ATLAS_CHECK_SKIP") or "").split(",") if x]
         self.replay_of = (os.environ.get("ATLAS_CHECK_REPLAY") or "").strip() or None
         self.started = _time.time()
         self.id = _time.strftime("%Y%m%d-%H%M%S", _time.localtime(self.started))
@@ -1069,6 +1089,8 @@ class _CheckRun:
         # per check): what assume() handed out, per check, in order.
         self._assumed = {}
         self._mine_cache = None
+        # Paused or deleted by the person: never run, never recorded.
+        self.off = _checks_off()
         self._watch_the_end()
         # THE ONE MODEL THAT RUNS THESE CHECKS (owner, 2026-10-15: "what model
         # performed the test"): the project's atlas.json "checks": {"model"},
@@ -1302,7 +1324,12 @@ class _CheckRun:
 
     # ── results ──
     def wants(self, check_id):
-        """False for a check this run was not asked for (Recheck of one)."""
+        """False for a check this run was not asked for (Recheck of one, or a
+        run on the times of a few checks), for one whose own time is not now
+        in a run on the project's schedule, and for one the person paused or
+        deleted."""
+        if _check_id(check_id) in self.off or check_id in self.skip:
+            return False
         return not self.only or check_id in self.only
 
     def result(self, check_id, status, title, summary="", fixed=None, report=None,
@@ -1316,7 +1343,11 @@ class _CheckRun:
         agent is asked when the person presses Resolve."""
         import time as _time
         status = status if status in _CHECK_STATUSES else "warn"
-        cid = "".join(c if c.isalnum() or c in "-_" else "-" for c in str(check_id))[:80] or "check"
+        cid = _check_id(check_id)
+        # Paused or deleted: nothing of it is kept, even from a checks.py that
+        # did not ask wants() first.
+        if cid in self.off:
+            return
         report_rel = None
         if report:
             text = str(report)
@@ -1583,6 +1614,18 @@ def checks():
     return _CheckRun()
 
 
+def restore_check(check_id):
+    """Bring back a check the person deleted (or paused), ONLY when they ask
+    for it back: it runs again from the next run."""
+    cid = _check_id(check_id)
+    path = os.path.join(_checks_dir(), "checks", "settings.json")
+    data = _read_json(path, {})
+    for key in ("paused", "deleted"):
+        if isinstance(data.get(key), dict):
+            data[key].pop(cid, None)
+    _write_json(path, data)
+
+
 def progress(step="", done=None, total=None, message="", **extra):
     """Say where you are, so the dashboard can draw it.
 

package/src/remote-control.js

@@ -689,19 +689,59 @@ export function checksCommand(dir) {
 
 /**
  * When a project's checks run by themselves: atlas.json "checks": {"schedule":
- * "30 8 * * 1-5", "on": ["files", "data"]} (local time, like Atlas Studio).
+ * "30 8 * * 1-5", "on": ["files", "data"], "timezone": "America/New_York"}.
  */
 export function checksWhen(dir) {
-  const c = readManifest(dir).checks;
+  const m = readManifest(dir);
+  const c = m.checks;
   const o = c && typeof c === 'object' ? c : {};
-  const expr = typeof o.schedule === 'string' ? o.schedule.trim() : '';
-  const cron = expr ? parseCron(expr) : null;
   const on = Array.isArray(o.on) ? o.on.map(String) : [];
-  return {
-    schedule: cron ? { expr, lines: [{ kind: 'cron', cron, text: expr }], tz: '', error: null, cron } : null,
-    files: on.includes('files'),
-    data: on.includes('data'),
+  // 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();
+  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;
   };
+  // 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.
+  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)) {
+    if (!CHECK_ID.test(id)) continue;
+    const s = sched(raw);
+    if (s) each[id] = s;
+  }
+  return { schedule: sched(o.schedule), each, files: on.includes('files'), data: on.includes('data') };
+}
+
+const CHECK_ID = /^[A-Za-z0-9_-]{1,80}$/;
+
+/**
+ * WHICH CHECKS ARE DUE between two moments (from, to], or null for none: the
+ * checks whose own time ("each") came round, and, when the project's schedule
+ * came round, every check without a time of its own. One answer, so two
+ * schedules on the same minute start ONE run. `known` is the ids checks.json
+ * holds, `off` the paused and deleted.
+ *   {only: [...]} : just these checks (only their own times came round);
+ *   {only: [], skip: [...]} : all of them but these (their own time did not).
+ * The python runner's checks_due is the same, line for line.
+ */
+export function checksDue(when, known, off, fromEpoch, toEpoch) {
+  const own = Object.keys(when?.each || {}).filter((id) => !off.has(id)).sort();
+  const ownDue = own.filter((id) => scheduleDueMinutes(when.each[id], fromEpoch, toEpoch).length);
+  const projectDue = !!(when?.schedule && scheduleDueMinutes(when.schedule, fromEpoch, toEpoch).length);
+  if (projectDue) {
+    const skip = own.filter((id) => !ownDue.includes(id));
+    // Nothing left to run: every check it knows is paused, deleted, or keeps
+    // a time of its own that is not now.
+    const left = known.filter((id) => !off.has(id) && !skip.includes(id));
+    if (known.length && !left.length) return null;
+    return { only: [], skip };
+  }
+  return ownDue.length ? { only: ownDue, skip: [] } : null;
 }
 
 /** What a folder holds, as one string that changes when anything in it does. */
@@ -1448,12 +1488,72 @@ export function readJobTable(job, rel, root) {
   }
 }
 
+/**
+ * A PDF, Word or PowerPoint file goes to the web as its bytes, like a picture
+ * (owner, 2026-10-15: "pdf file support, word docs ... for everything"): the
+ * website draws it (its components/files/DocView.tsx). Read as text it was a
+ * screenful of bytes, or refused past the text ceiling. Since 2026-10-16 the
+ * old Office files (.doc, .ppt, .xls) and Parquet too (owner: "yes for
+ * parquet ... yes for old office files"): the website reads their words or
+ * their first rows itself. Nothing else is sent as bytes: a zip or an
+ * OpenDocument file is not drawn there, so it is not carried.
+ */
+export const DOC_TYPES = {
+  '.pdf': 'application/pdf',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.docm': 'application/vnd.ms-word.document.macroEnabled.12',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.pptm': 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
+  '.ppsx': 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
+  '.doc': 'application/msword',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.xls': 'application/vnd.ms-excel',
+  '.parquet': 'application/vnd.apache.parquet',
+};
+
+/** The relay's ceiling for a document: a picture's. Atlas's server holds it too. */
+export const MAX_DOC_BYTES = MAX_IMAGE_BYTES;
+
+/** The content type for a document's name, or '' if it is not one. */
+export function docType(name) {
+  const n = String(name).toLowerCase();
+  const dot = n.lastIndexOf('.');
+  return dot >= 0 ? (DOC_TYPES[n.slice(dot)] || '') : '';
+}
+
+/** A Jupyter notebook: JSON text with its outputs' pictures inside. */
+export function isNotebook(name) {
+  return String(name).toLowerCase().endsWith('.ipynb');
+}
+
+/** "12.4 MB", the website's words (lib/doc-view.ts sizeWords). */
+function sizeWords(bytes) {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
 export function readJobFile(job, rel, root) {
   const where = jobTarget(job, rel, root);
   if (!where.ok) return where;
   const { target } = where;
   const mime = imageType(path.basename(target));
+  const doc = docType(path.basename(target));
   try {
+    if (doc) {
+      const size = fs.statSync(target).size;
+      // Worded as the website's viewer words it, which tells it apart from a
+      // computer from before (that one refused a document as too long a text).
+      if (size > MAX_DOC_BYTES) return { ok: false, error: `This file is ${sizeWords(size)}, too large to show here.` };
+      return { ok: true, mime: doc, b64: fs.readFileSync(target).toString('base64') };
+    }
+    // A JUPYTER NOTEBOOK (2026-10-16) is text, but its pictures are inside it:
+    // it may be as large as a document, and past that it is worded the same.
+    if (isNotebook(target)) {
+      const size = fs.statSync(target).size;
+      if (size > MAX_DOC_BYTES) return { ok: false, error: `This file is ${sizeWords(size)}, too large to show here.` };
+      return { ok: true, text: fs.readFileSync(target, 'utf8') };
+    }
     if (fs.statSync(target).size > (mime ? MAX_IMAGE_BYTES : MAX_VIEW_BYTES)) {
       return { ok: false, error: 'That file is too large to show here.' };
     }
@@ -1805,7 +1905,7 @@ export function writeRequest(job, op, root, extra = {}) {
   try {
     fs.mkdirSync(dir, { recursive: true });
     // A checks request says which checks and which run it repeats.
-    const more = want === 'checks' ? { only: extra.only, replay: extra.replay, why: extra.why, assume: extra.assume } : {};
+    const more = want === 'checks' ? { only: extra.only, skip: extra.skip, replay: extra.replay, why: extra.why, assume: extra.assume } : {};
     fs.writeFileSync(path.join(dir, `${at}-${want}.json`), JSON.stringify({ op: want, at: at / 1000, ...more }), 'utf8');
   } catch (err) {
     return { ok: false, error: `Could not leave the request: ${err.message}` };
@@ -1849,7 +1949,7 @@ export function takeRequests(root, nowMs = Date.now()) {
       if (Number.isFinite(body.at) && nowMs - body.at * 1000 > REQUEST_TTL_MS) continue;
       // A checks request carries which checks and which run it repeats.
       out.push(op === 'checks'
-        ? { dir: path.join(base, slug), op, only: body.only, replay: body.replay, why: body.why, assume: body.assume }
+        ? { dir: path.join(base, slug), op, only: body.only, skip: body.skip, replay: body.replay, why: body.why, assume: body.assume }
         : { dir: path.join(base, slug), op });
     }
   }