mindvest-atlas 0.99.0 → 0.100.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.99.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,
@@ -910,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;
@@ -1054,20 +1054,24 @@ export function checksTick(root, nowMs = Date.now(), spawn = spawnJob) {
     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;
-    const results = readJsonFile(path.join(dir, 'checks.json'));
-    const rows = Array.isArray(results?.checks) ? results.checks : [];
     // 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.
@@ -1228,16 +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 asked = (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) : '';
@@ -1247,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);

package/src/config.js

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

@@ -1065,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))
@@ -1321,9 +1324,11 @@ class _CheckRun:
 
     # ── results ──
     def wants(self, check_id):
-        """False for a check this run was not asked for (Recheck of one), and
-        for one the person paused or deleted."""
-        if _check_id(check_id) in self.off:
+        """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
 

package/src/remote-control.js

@@ -695,17 +695,53 @@ export function checksWhen(dir) {
   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) : [];
   // 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 = [o.timezone, m.timezone].find((z) => typeof z === 'string' && z.trim()) || '';
-  return {
-    schedule: cron ? { expr, lines: [{ kind: 'cron', cron, text: expr }], tz: String(tz).trim(), error: null, cron } : null,
-    files: on.includes('files'),
-    data: on.includes('data'),
+  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. */
@@ -1456,8 +1492,11 @@ 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. Nothing else is sent
- * as bytes: a .doc or a zip is not drawn there, so it is not carried.
+ * 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',
@@ -1466,6 +1505,10 @@ export const DOC_TYPES = {
   '.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. */
@@ -1478,6 +1521,11 @@ export function docType(name) {
   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`;
@@ -1499,6 +1547,13 @@ export function readJobFile(job, rel, root) {
       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.' };
     }
@@ -1850,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}` };
@@ -1894,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 });
     }
   }