atris 3.74.3 → 3.74.5

package/lib/ninety-nine.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const LENGTHS = { focus: [25, 50, 90], meditate: [10, 20, 30] };
+const SOURCES = ['cli', 'mac', 'ios'];
+const PAUSE_LIMIT_MS = 30 * 60000;
+const HEALTH_FIELDS = ['sleep_min', 'steps', 'workout_min', 'mindful_min'];
+
+function lineIdentity(record) {
+  return `${record.type}|${record.type === 'health_day' ? record.date : record.id}|${record.at}|${record.source}`;
+}
+
+function uniqueLines(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = lineIdentity(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function validLength(kind, minutes) {
+  return Object.hasOwn(LENGTHS, kind) && LENGTHS[kind].includes(minutes);
+}
+
+function parseSessionLog(text) {
+  return text.split('\n').flatMap((line, index) => {
+    if (!line.trim()) return [];
+    let record;
+    try { record = JSON.parse(line); } catch { /* Report the line below. */ }
+    const common = record && record.v === 1 && SOURCES.includes(record.source)
+      && typeof record.at === 'string' && Number.isFinite(Date.parse(record.at));
+    const session = typeof record?.id === 'string' && record.id;
+    const start = record?.type === 'start' && validLength(record.kind, record.planned_min);
+    const end = record?.type === 'end' && ['done', 'partial'].includes(record.status)
+      && (record.inferred === undefined || typeof record.inferred === 'boolean')
+      && (record.note === undefined || (typeof record.note === 'string' && !/[\r\n\u2028\u2029]/.test(record.note)));
+    const pause = ['pause', 'resume'].includes(record?.type);
+    const health = record?.type === 'health_day' && typeof record.date === 'string'
+      && /^\d{4}-\d{2}-\d{2}$/.test(record.date)
+      && Number.isFinite(Date.parse(record.date))
+      && new Date(record.date).toISOString().slice(0, 10) === record.date
+      && HEALTH_FIELDS.every((field) => record[field] === undefined
+        || (Number.isFinite(record[field]) && record[field] >= 0));
+    if (!common || (!health && !(session && (start || end || pause)))) {
+      throw new Error(`session log has an invalid record on line ${index + 1}; nothing was written`);
+    }
+    return [record];
+  });
+}
+
+// records -> sessions -> overdue ends -> the requested action
+function foldSessions(records) {
+  const sessions = new Map();
+  const events = new Map();
+  const ends = new Map();
+  // Stable sort preserves append order when timestamps tie, without rewriting the log.
+  for (const record of uniqueLines(records).sort((a, b) => Date.parse(a.at) - Date.parse(b.at))) {
+    if (record.type === 'health_day') continue;
+    if (record.type === 'start') {
+      if (sessions.has(record.id)) throw new Error('session log repeats a start; nothing was written');
+      sessions.set(record.id, {
+        id: record.id,
+        kind: record.kind,
+        planned_min: record.planned_min,
+        started_at: record.at,
+        planned_end_at: new Date(Date.parse(record.at) + record.planned_min * 60000).toISOString(),
+        ended_at: null,
+        status: 'running',
+      });
+      events.set(record.id, []);
+    } else {
+      const session = sessions.get(record.id);
+      if (!session) throw new Error(`session log has an ${record.type} without a start; nothing was written`);
+      if (record.type !== 'end') {
+        events.get(record.id).push(record);
+        continue;
+      }
+      const previous = ends.get(record.id);
+      // A person's end wins over an automatic observation, in either log order.
+      if (!previous || (previous.inferred === true && record.inferred !== true)
+        || ((previous.inferred === true) === (record.inferred === true)
+          && Date.parse(record.at) < Date.parse(previous.at))) {
+        ends.set(record.id, record);
+      }
+    }
+  }
+  for (const session of sessions.values()) {
+    const end = ends.get(session.id);
+    const timeline = events.get(session.id).sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+    for (const event of timeline) {
+      const at = Date.parse(event.at);
+      if (end && at > Date.parse(end.at)) break;
+      if (session.status === 'running') {
+        // A late pause cannot interrupt an already completed active stretch.
+        if (at >= Date.parse(session.planned_end_at)) break;
+        if (event.type !== 'pause') continue;
+        session.status = 'paused';
+        session.paused_at = event.at;
+        session.paused_ms = session.paused_ms || 0;
+      } else if (event.type === 'resume') {
+        const duration = at - Date.parse(session.paused_at);
+        if (duration > PAUSE_LIMIT_MS) {
+          session.pause_expired_at = session.paused_at;
+          break;
+        }
+        session.paused_ms += duration;
+        session.planned_end_at = new Date(Date.parse(session.planned_end_at) + duration).toISOString();
+        session.paused_at = null;
+        session.status = 'running';
+      }
+    }
+    if (end) {
+      session.ended_at = end.at;
+      session.status = end.status;
+      if (end.note !== undefined) session.note = end.note;
+      if (end.inferred === true) session.inferred = true;
+    }
+  }
+  return [...sessions.values()];
+}
+
+function runningSession(sessions, now) {
+  const running = sessions.filter((session) => ['running', 'paused'].includes(session.status)
+    && !automaticEndRecord(session, now));
+  if (running.length > 1) throw new Error('session log has more than one running session; nothing was written');
+  return running[0] || null;
+}
+
+function startRecord(kind, plannedMin, now, id) {
+  if (!validLength(kind, plannedMin)) throw new Error('choose a supported session length');
+  return { v: 1, type: 'start', id, kind, planned_min: plannedMin, at: now.toISOString(), source: 'cli' };
+}
+
+function endRecord(session, now, note = '') {
+  const done = session.status !== 'paused' && now.getTime() >= Date.parse(session.planned_end_at);
+  const record = {
+    v: 1,
+    type: 'end',
+    id: session.id,
+    status: done ? 'done' : 'partial',
+    at: done ? session.planned_end_at : now.toISOString(),
+    source: 'cli',
+  };
+  const oneLine = String(note).replace(/\s+/g, ' ').trim();
+  if (oneLine) record.note = oneLine;
+  return record;
+}
+
+function automaticEndRecord(session, now) {
+  if (!['running', 'paused'].includes(session.status)) return null;
+  const expired = session.pause_expired_at || (session.status === 'paused'
+    && now.getTime() - Date.parse(session.paused_at) > PAUSE_LIMIT_MS ? session.paused_at : null);
+  if (expired) {
+    return { v: 1, type: 'end', id: session.id, status: 'partial', at: expired, source: 'cli', inferred: true };
+  }
+  if (session.status === 'running' && now.getTime() >= Date.parse(session.planned_end_at)) {
+    return { ...endRecord(session, now), inferred: true };
+  }
+  return null;
+}
+
+function pauseRecord(session, now) {
+  if (!session || automaticEndRecord(session, now)) throw new Error('nothing running');
+  if (session.status === 'paused') throw new Error('session is already paused; use atris 99 resume');
+  if (session.status !== 'running') throw new Error('nothing running');
+  return { v: 1, type: 'pause', id: session.id, at: now.toISOString(), source: 'cli' };
+}
+
+function resumeRecord(session, now) {
+  if (!session || automaticEndRecord(session, now)) throw new Error('nothing paused');
+  if (session.status !== 'paused') throw new Error('session is not paused');
+  return { v: 1, type: 'resume', id: session.id, at: now.toISOString(), source: 'cli' };
+}
+
+function activeMilliseconds(session, now) {
+  const end = session.ended_at ? Date.parse(session.ended_at) : now.getTime();
+  const until = session.paused_at ? Math.min(end, Date.parse(session.paused_at)) : end;
+  return Math.max(0, until - Date.parse(session.started_at) - (session.paused_ms || 0));
+}
+
+function sessionStatus(session, now) {
+  return {
+    running: session ? {
+      ...session,
+      remaining_seconds: Math.max(0, Math.ceil((session.planned_min * 60000 - activeMilliseconds(session, now)) / 1000)),
+    } : null,
+  };
+}
+
+function localDate(date) {
+  return [date.getFullYear(), String(date.getMonth() + 1).padStart(2, '0'), String(date.getDate()).padStart(2, '0')].join('-');
+}
+
+function sessionsToday(sessions, now) {
+  const date = localDate(now);
+  const done = sessions.filter((session) => session.status === 'done'
+    && localDate(new Date(session.ended_at)) === date);
+  return {
+    date,
+    sessions: sessions.filter((session) => localDate(new Date(session.started_at)) === date
+      || (session.ended_at && localDate(new Date(session.ended_at)) === date)),
+    finished_minutes: done.reduce((minutes, session) => minutes + session.planned_min, 0),
+    counts: {
+      focus: done.filter((session) => session.kind === 'focus').length,
+      meditate: done.filter((session) => session.kind === 'meditate').length,
+    },
+  };
+}
+
+function healthToday(records, now) {
+  const date = localDate(now);
+  let latest;
+  for (const record of records) {
+    if (record.type === 'health_day' && record.date === date
+      && (!latest || Date.parse(record.at) >= Date.parse(latest.at))) latest = record;
+  }
+  return latest;
+}
+
+function healthSummary(record) {
+  const parts = [];
+  if (record.sleep_min !== undefined) parts.push(`sleep ${Math.floor(record.sleep_min / 60)}h ${record.sleep_min % 60}m`);
+  if (record.steps !== undefined) parts.push(`${record.steps.toLocaleString('en-US')} steps`);
+  if (record.workout_min !== undefined) parts.push(`workout ${record.workout_min} min`);
+  if (record.mindful_min !== undefined) parts.push(`mindful ${record.mindful_min} min`);
+  return `Health: ${parts.join(', ') || 'unknown'}`;
+}
+
+module.exports = {
+  validLength,
+  parseSessionLog,
+  foldSessions,
+  runningSession,
+  startRecord,
+  endRecord,
+  automaticEndRecord,
+  pauseRecord,
+  resumeRecord,
+  activeMilliseconds,
+  sessionStatus,
+  sessionsToday,
+  healthToday,
+  healthSummary,
+  lineIdentity,
+  uniqueLines,
+};

package/lib/opening-lines.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+
+const AGENTS_START = '<!-- ATRIS_OPERATING_RULES:START -->';
+const AGENTS_END = '<!-- ATRIS_OPERATING_RULES:END -->';
+
+// The first run of bold-lead bullets (`- **Word.** ...`) under
+// `## operating rules` in atris.md. Adapters (AGENTS.md, CLAUDE.md) carry a
+// copy so tools that never open atris.md still see them; atris.md stays the
+// one source. An older atris.md has only plain checklist bullets there, so it
+// yields nothing and the caller falls back to the package copy.
+function extractOpeningLines(content) {
+  const lines = String(content || '').split(/\r?\n/);
+  const start = lines.findIndex((line) => /^## operating rules\s*$/i.test(line));
+  if (start === -1) return '';
+  const bullets = [];
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (/^##\s+/.test(line)) break;
+    if (/^- \*\*[^*]+\.\*\* /.test(line)) bullets.push(line);
+    else if (bullets.length && line.trim()) break;
+  }
+  return bullets.join('\n');
+}
+
+function readOpeningLines(root) {
+  for (const file of [path.join(root, 'atris.md'), path.join(root, 'atris', 'atris.md')]) {
+    if (!fs.existsSync(file)) continue;
+    const found = extractOpeningLines(fs.readFileSync(file, 'utf8'));
+    if (found) return found;
+  }
+  return '';
+}
+
+function openingLinesForRoot(root = process.cwd()) {
+  return readOpeningLines(root) || readOpeningLines(PACKAGE_ROOT);
+}
+
+function renderOpeningLinesBlock(bullets, adapter) {
+  if (!bullets) return '';
+  return `## Operating rules
+
+${bullets}
+
+Canonical source: \`atris/atris.md\` \`## operating rules\`. This is a copy for tools that only read \`${adapter}\`; if they differ, atris.md wins.`;
+}
+
+function renderAgentsOpeningBlock(bullets) {
+  const block = renderOpeningLinesBlock(bullets, 'AGENTS.md');
+  return block ? `${AGENTS_START}\n${block}\n${AGENTS_END}` : '';
+}
+
+// Existing AGENTS.md files predate the copy. Replace a marked copy in place;
+// otherwise put it right before `## You translate` (the atris-written layout),
+// before the brain compile block, or at the end.
+function upsertAgentsOpeningLines(filePath, bullets, options = {}) {
+  const block = renderAgentsOpeningBlock(bullets);
+  const source = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+  if (!block) return { action: 'unchanged', content: source };
+  let content;
+  const start = source.indexOf(AGENTS_START);
+  const end = source.indexOf(AGENTS_END, start + AGENTS_START.length);
+  if (start !== -1 && end !== -1) {
+    content = `${source.slice(0, start)}${block}${source.slice(end + AGENTS_END.length)}`;
+  } else {
+    const anchor = ['\n## You translate', '\n<!-- ATRIS_BRAIN_COMPILE:START -->']
+      .map((marker) => source.indexOf(marker))
+      .find((index) => index !== -1);
+    if (anchor !== undefined) {
+      content = `${source.slice(0, anchor).trimEnd()}\n\n${block}\n${source.slice(anchor)}`;
+    } else {
+      const prefix = source.trimEnd() || '# AGENTS';
+      content = `${prefix}\n\n${block}\n`;
+    }
+  }
+  const changed = content !== source;
+  if (changed && !options.dryRun) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf8');
+  }
+  return { action: source ? (changed ? 'updated' : 'unchanged') : 'created', content };
+}
+
+module.exports = {
+  extractOpeningLines,
+  openingLinesForRoot,
+  renderAgentsOpeningBlock,
+  renderOpeningLinesBlock,
+  upsertAgentsOpeningLines,
+};

package/lib/roster-markdown.js

@@ -29,12 +29,14 @@ function stripInlineComments(text) {
 
 // Sections: anything under a top heading, "## jobs", or "## roster" holds
 // one-line job lines; "## team" holds member lines; any other heading is a
-// job whose "- " lines are its workers. Other lines under a job heading are
+// job whose "- " lines are its workers. "## picks" holds the owner's short
+// list of models, one "- tool · model" per line. Other lines under a job heading are
 // free notes that are never read as picks.
 function sectionForHeading(level, title) {
   const name = String(title || '').trim().toLowerCase();
   if (level === 1) return 'jobs';
   if (name === 'team') return 'team';
+  if (name === 'picks') return 'picks';
   if (name === 'jobs' || name === 'roster') return 'jobs';
   return 'job';
 }
@@ -77,6 +79,12 @@ function scanRosterMarkdown(text) {
       entries.push({ index, lineNumber: index + 1, section, raw: line, name: '', value: body, heading: heading.title, headingIndex: heading.index, dashed, malformed: false });
       return;
     }
+    // Under picks, each "- " line is one model on the owner's short list;
+    // other lines there are notes.
+    if (section === 'picks') {
+      if (dashed) entries.push({ index, lineNumber: index + 1, section, raw: line, name: '', value: body, dashed, malformed: false });
+      return;
+    }
     // A "- " bullet under the jobs heading is a note; under team it is a
     // member line.
     if (dashed && section !== 'team') return;
@@ -194,6 +202,35 @@ function rewriteRosterValues(text, rewrite) {
   return joinLines(trimTrailingBlank(lines), scan.newline);
 }
 
+// Set one member's line under "## team" to "- member: value": the member's
+// first line is replaced in place (indent and an end note kept); a member
+// with no line is added after the last team line, or under the team heading,
+// or in a new team section at the end. Every other line stays as written.
+function replaceTeamLine(text, member, value) {
+  const base = String(text || '').trim() ? String(text) : ROSTER_MARKDOWN_TEMPLATE.join('\n');
+  const scan = scanRosterMarkdown(base);
+  const lines = [...scan.lines];
+  const name = String(member || '').trim().toLowerCase();
+  const line = `- ${name}: ${value}`;
+  const team = scan.entries.filter((entry) => entry.section === 'team' && !entry.malformed);
+  const mine = team.find((entry) => entry.name.trim().toLowerCase() === name);
+  if (mine) {
+    const indent = /^\s*/.exec(lines[mine.index])[0];
+    const note = /\s*(<!--.*?-->)\s*$/.exec(mine.raw);
+    lines[mine.index] = `${indent}${line}${note ? ` ${note[1]}` : ''}`;
+    return joinLines(trimTrailingBlank(lines), scan.newline);
+  }
+  const heading = scan.headings.find((entry) => entry.section === 'team');
+  if (heading) {
+    const next = scan.headings.find((entry) => entry.index > heading.index);
+    const under = team.filter((entry) => entry.index > heading.index && (!next || entry.index < next.index));
+    lines.splice(under.length ? under[under.length - 1].index + 1 : heading.index + 1, 0, line);
+    return joinLines(trimTrailingBlank(lines), scan.newline);
+  }
+  const trimmed = trimTrailingBlank(lines);
+  return joinLines([...trimmed, ...(trimmed.length ? [''] : []), '## team', line], scan.newline);
+}
+
 module.exports = {
   OLD_ROSTER_NOTE,
   ROSTER_NOTE,
@@ -201,6 +238,7 @@ module.exports = {
   scanRosterMarkdown,
   jobSections,
   replaceJobSection,
+  replaceTeamLine,
   rewriteRosterValues,
   joinLines,
 };

package/lib/roster-models.js

@@ -124,7 +124,7 @@ function runsDetail(view) {
 // keeps a cache of the models it can run; claude takes the names atris knows;
 // every other engine lists its seed models.
 
-const KNOWN_CLAUDE_MODELS = Object.freeze(['opus 5.5', 'opus 5', 'sonnet 5', 'haiku 5.5', 'fable 5.1']);
+const KNOWN_CLAUDE_MODELS = Object.freeze(['fable 5.1', 'opus 5.5', 'sonnet 5.5', 'haiku 5.5']);
 
 // ~/.codex/models_cache.json unless a path is given. Test runs never read the
 // real file unless they point at one on purpose.