mindvest-atlas 0.99.0 → 0.100.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.99.0",
+  "version": "0.100.1",
   "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;
@@ -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);
@@ -1054,20 +1070,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 +1248,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 +1272,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.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.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))
@@ -1141,12 +1144,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()
@@ -1176,6 +1180,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,
@@ -1319,11 +1327,18 @@ 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), 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
 
@@ -1408,7 +1423,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
@@ -1416,7 +1431,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

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`;
@@ -695,17 +777,58 @@ 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();
+  // 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() : '';
+    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 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)) {
+    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 +1579,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 +1592,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 +1608,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 +1634,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 +1992,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 +2036,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 });
     }
   }