atris 3.58.6 → 3.58.7

package/lib/apply-gate.js

@@ -26,6 +26,17 @@ function isFilledApply(fields) {
   return !empty(fields.change) && !empty(fields.receipt);
 }
 
+function isLearnerKeepApply(fields) {
+  const change = String((fields && fields.change) || '');
+  const receipt = String((fields && fields.receipt) || '');
+  return /^apply\s+atris\/experiments\//i.test(change)
+    || /keep only if measure\.py moves 0/.test(receipt);
+}
+
+function isFilledHumanApply(fields) {
+  return isFilledApply(fields) && !isLearnerKeepApply(fields);
+}
+
 function applySlug(text) {
   const slug = String(text || '')
     .toLowerCase()
@@ -46,7 +57,7 @@ function readApplyReceipt({ cwd, rel } = {}) {
   return { rel, text: fs.readFileSync(abs, 'utf8') };
 }
 
-function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine } = {}) {
+function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine, force } = {}) {
   try {
     if (!rel || !cwd) return null;
     const wikiDir = path.join(cwd, 'atris', 'wiki');
@@ -56,7 +67,7 @@ function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine }
     fs.mkdirSync(path.dirname(abs), { recursive: true });
     const changeText = change || 'fill this';
     const receiptText = receipt || 'fill this';
-    let shouldWrite = !fs.existsSync(abs);
+    let shouldWrite = force === true || !fs.existsSync(abs);
     if (!shouldWrite && change && receipt) {
       shouldWrite = !isFilledApply(parseApplyFields(fs.readFileSync(abs, 'utf8')));
     }
@@ -86,11 +97,16 @@ function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine }
 
 function ensureApply({
   cwd, source, rel, now, output, incompleteMessage, required = true, change, receipt, journalLine,
+  human = false,
 } = {}) {
   const print = typeof output === 'function' ? output : (line = '') => console.error(line);
   const existing = readApplyReceipt({ cwd, rel });
-  if (existing && isFilledApply(parseApplyFields(existing.text))) return 0;
-  if (!(required && existing)) writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine });
+  const fields = existing ? parseApplyFields(existing.text) : null;
+  const keepSidecar = Boolean(human && fields && isLearnerKeepApply(fields));
+  if (existing && isFilledApply(fields) && !keepSidecar) return 0;
+  if (!(required && existing) || keepSidecar) {
+    writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine, force: keepSidecar });
+  }
   print(incompleteMessage);
   return required ? 2 : 0;
 }
@@ -112,4 +128,6 @@ module.exports = {
   ensureApply,
   ephemeralApplyMessage,
   hintEphemeralApply,
+  isFilledHumanApply,
+  isLearnerKeepApply,
 };

package/lib/daily-log.js

@@ -0,0 +1,88 @@
+'use strict';
+
+// Two-level daily logging. Member logs (atris/team/<member>/logs/<date>.md)
+// keep the detailed workstream: claims, notes, result receipts, completions.
+// The master journal (atris/logs/<YYYY>/<date>.md) stays curated and receives
+// only consequential entries: terminal task events and explicitly major
+// updates such as decisions, handoffs, and shipped work.
+
+const fs = require('fs');
+const path = require('path');
+
+function todayLogName(now = new Date()) {
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}.md`;
+}
+
+function logStamp(now = new Date()) {
+  return now.toTimeString().slice(0, 5);
+}
+
+function compactLogText(value, max = 240) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 3)).trim()}...` : text;
+}
+
+function logFieldRows(fields) {
+  return Object.entries(fields)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `- ${key}: ${compactLogText(value, 500)}`);
+}
+
+function appendDailyEntry(logPath, title, fields) {
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, [
+    `## ${logStamp()} · ${title}`,
+    ...logFieldRows(fields),
+    '',
+  ].join('\n'), 'utf8');
+  return logPath;
+}
+
+function memberSlug(root, member) {
+  const slug = String(member || '').trim();
+  if (!/^[A-Za-z0-9._-]+$/.test(slug)) return null;
+  if (!fs.existsSync(path.join(root, 'atris', 'team', slug, 'MEMBER.md'))) return null;
+  return slug;
+}
+
+function appendMemberDailyEntry(root, member, title, fields) {
+  const slug = memberSlug(root, member);
+  if (!slug || !fs.existsSync(path.join(root, 'atris'))) return null;
+  const logPath = path.join(root, 'atris', 'team', slug, 'logs', todayLogName());
+  appendDailyEntry(logPath, title, { ...fields, member: slug });
+  return logPath;
+}
+
+function appendMasterDailyEntry(root, title, fields) {
+  if (!fs.existsSync(path.join(root, 'atris'))) return null;
+  const logName = todayLogName();
+  const logPath = path.join(root, 'atris', 'logs', logName.slice(0, 4), logName);
+  appendDailyEntry(logPath, title, fields);
+  return logPath;
+}
+
+// Notes a person deliberately escalates to the day record. Anything else stays
+// in the member's own log so the master journal does not become a transcript.
+const MASTER_NOTE = /^(decision|decided|milestone|handoff|shipped|launched|landed|blocked)\b\s*[:\-]/i;
+
+function noteTitle(content) {
+  const key = String(content || '').trim().match(/^([a-z]+)\s*[:\-]/i);
+  const word = key ? key[1].toLowerCase() : '';
+  if (word === 'decision' || word === 'decided') return 'Task decision';
+  if (word === 'handoff') return 'Task handoff';
+  if (word === 'shipped' || word === 'launched' || word === 'landed') return 'Task shipped';
+  if (word === 'blocked') return 'Task blocked';
+  if (word === 'milestone') return 'Task milestone';
+  return 'Task update';
+}
+
+module.exports = {
+  todayLogName,
+  compactLogText,
+  memberSlug,
+  appendMemberDailyEntry,
+  appendMasterDailyEntry,
+  MASTER_NOTE,
+  noteTitle,
+};

package/lib/design-api.js

@@ -0,0 +1,130 @@
+'use strict';
+
+// Shared client for the Atris design API. Used by `atris design` and the
+// `atris mcp` stdio server so both resolve keys and bill the same way.
+//
+// Key resolution order:
+//   1. ATRIS_API_KEY env var
+//   2. login credentials token (atris login)
+//   3. ~/.atris/design-api-key file (raw key text, saved by hand)
+//
+// Endpoints (see https://api.atris.ai/llms.txt):
+//   POST /design/extractions {"url"}            -> job; poll GET /design/extractions/{id}
+//   POST /design/adherence  {source, reference} -> job; poll GET /design/adherence/{id}
+//   POST /design/search     {"query", "limit"}  -> sync result
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { getApiBaseUrl, httpRequest } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+
+const DESIGN_KEY_FILE = path.join(os.homedir(), '.atris', 'design-api-key');
+
+const POLL_INTERVAL_MS = 3000;
+const POLL_TIMEOUT_MS = 3 * 60 * 1000;
+
+function readKeyFile(file = DESIGN_KEY_FILE) {
+  try {
+    const text = fs.readFileSync(file, 'utf8').trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+
+// Returns the bearer token for design calls, or null when nothing is set up.
+function resolveDesignKey(env = process.env, deps = {}) {
+  const fromEnv = env.ATRIS_API_KEY && env.ATRIS_API_KEY.trim();
+  if (fromEnv) return fromEnv;
+  const load = deps.loadCredentials || loadCredentials;
+  const creds = load();
+  const token = creds && typeof creds.token === 'string' ? creds.token.trim() : '';
+  if (token) return token;
+  return (deps.readKeyFile || readKeyFile)();
+}
+
+// One JSON call against the design API. Returns { ok, status, data, error }.
+async function designRequest(pathname, options = {}) {
+  const key = options.key;
+  const url = `${getApiBaseUrl()}${pathname.startsWith('/') ? pathname : `/${pathname}`}`;
+  const headers = {
+    'Authorization': `Bearer ${key}`,
+    'Accept': 'application/json',
+    ...(options.headers || {}),
+  };
+  let body;
+  if (options.body !== undefined && options.body !== null) {
+    body = JSON.stringify(options.body);
+    headers['Content-Type'] = 'application/json';
+  }
+  const res = await httpRequest(url, {
+    method: options.method || 'GET',
+    headers,
+    body,
+    timeoutMs: options.timeoutMs != null ? options.timeoutMs : 30000,
+  });
+  const text = res.body.toString('utf8');
+  let data = null;
+  try { data = text ? JSON.parse(text) : null; } catch { data = null; }
+  const ok = res.status >= 200 && res.status < 300;
+  const error = !ok
+    ? (data && typeof data === 'object' && (data.detail || data.error || data.message)) || text.slice(0, 200) || `http ${res.status}`
+    : undefined;
+  return { ok, status: res.status, data, error };
+}
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+// Poll a design job until it finishes. `fetchJob` returns the parsed job
+// object; `onTick` fires once per wait so callers can draw a spinner.
+// Resolves { ok, job, timedOut } and never throws on a bad status.
+async function pollDesignJob(fetchJob, options = {}) {
+  const intervalMs = options.intervalMs != null ? options.intervalMs : POLL_INTERVAL_MS;
+  const timeoutMs = options.timeoutMs != null ? options.timeoutMs : POLL_TIMEOUT_MS;
+  const wait = options.sleep || sleep;
+  const onTick = typeof options.onTick === 'function' ? options.onTick : null;
+  const start = Date.now();
+  let job = await fetchJob();
+  while (job && job.status && !isTerminalStatus(job.status)) {
+    if (Date.now() - start >= timeoutMs) return { ok: false, job, timedOut: true };
+    if (onTick) onTick(Date.now() - start, job);
+    await wait(intervalMs);
+    job = await fetchJob();
+  }
+  const ok = Boolean(job) && job.status === 'completed' && !job.error;
+  return { ok, job, timedOut: false };
+}
+
+function isTerminalStatus(status) {
+  const s = String(status || '').toLowerCase();
+  return s === 'completed' || s === 'failed' || s === 'error' || s === 'succeeded';
+}
+
+// Pull the billing block off any design response. Top-level credits_charged on
+// jobs is the job's price; atris.credits_charged is what this call billed.
+function billingOf(data = {}) {
+  const raw = data && typeof data === 'object' ? data : {};
+  const atris = raw.atris && typeof raw.atris === 'object' ? raw.atris : {};
+  const charged = Number(atris.credits_charged != null ? atris.credits_charged : raw.credits_charged);
+  const balance = Number(atris.balance_remaining_usd);
+  return {
+    credits: Number.isFinite(charged) ? charged : null,
+    balanceUsd: Number.isFinite(balance) ? balance : null,
+  };
+}
+
+function creditLine(data) {
+  const bill = billingOf(data);
+  const charged = bill.credits == null ? '?' : `${bill.credits} credit${bill.credits === 1 ? '' : 's'}`;
+  const left = bill.balanceUsd == null ? '' : ` $${bill.balanceUsd.toFixed(2)} left.`;
+  return `${charged} charged.${left}`;
+}
+
+module.exports = {
+  resolveDesignKey,
+  designRequest,
+  pollDesignJob,
+  billingOf,
+  creditLine,
+};

package/lib/engine-ask.js

@@ -283,7 +283,7 @@ function buildReadOnlyEngineInvocation(engineName, prompt, modelName = '', {
   if (engine === 'opencode') {
     // `run` with a message is headless print mode; the built-in plan agent
     // keeps the ask read-only (verified live 2026-08-21, ~7s per lookup).
-    return { engine, bin: profile.bin, args: ['--agent', 'plan', ...(model ? ['-m', model] : []), request] };
+    return { engine, bin: profile.bin, args: ['run', '--agent', 'plan', ...(model ? ['-m', model] : []), request] };
   }
   throw new Error(`engine ask has no read-only command for ${engine}`);
 }

package/lib/first-minute.js

@@ -168,12 +168,7 @@ function titlesFromTodoSection(root, section) {
     if (!match) return null;
     const body = String(match[1] || '').trim();
     if (!body || /\(empty|\(see /i.test(body)) return [];
-    return body
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => /^-\s+/.test(line) && !/\(empty/i.test(line))
-      .map((line) => line.replace(/^-+\s*/, '').trim())
-      .filter(Boolean);
+    return require('./todo-fallback').parseSection(text, section).map(task => task.title);
   } catch {
     return null;
   }

package/lib/known-commands.js

@@ -1,11 +1,11 @@
 'use strict';
 
-const knownCommands = ['init', 'guide', 'doctor', 'install', 'workspace', 'log', 'logs', 'later', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
-                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'api-key', 'topup', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
-                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'playbook', 'feed', 'brief', 'social', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join'];
+                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'api-key', 'topup', 'design', 'mcp', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
+                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'playbook', 'feed', 'brief', 'social', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an
 // adjacent transposition (e.g. "taks" -> "task") as a single edit, since

package/lib/member-context.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MEMBER_PROCESS_PATH = 'atris/team/MEMBER_PROCESS.md';
+const MAX_MEMBER_PROCESS_BYTES = 32 * 1024;
+
+// Read from the executing workspace only. Never fall back to the launcher,
+// an ancestor workspace, or a bundled policy belonging to another owner.
+function memberProcessPrompt(cwd = process.cwd()) {
+  const file = path.join(cwd, MEMBER_PROCESS_PATH);
+  let fd;
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile()) throw new Error('expected a regular file');
+    fd = fs.openSync(file, 'r');
+    const buffer = Buffer.alloc(MAX_MEMBER_PROCESS_BYTES + 1);
+    const count = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    if (count > MAX_MEMBER_PROCESS_BYTES) {
+      throw new Error(`keep the shared process within ${MAX_MEMBER_PROCESS_BYTES} bytes`);
+    }
+    const body = buffer.subarray(0, count).toString('utf8').trim();
+    if (!body) return '';
+    return [
+      '## Shared member process',
+      `Source: ${MEMBER_PROCESS_PATH} in this execution workspace.`,
+      'Apply these defaults alongside the member identity. They do not expand role permissions or override operator direction, task scope, output format, or frozen mission constraints.',
+      '',
+      body,
+      '',
+      'End of shared member process. The current task and its constraints follow.',
+    ].join('\n');
+  } catch (error) {
+    if (error.code === 'ENOENT') return '';
+    throw new Error(`Cannot load ${MEMBER_PROCESS_PATH}: ${error.message}`);
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+module.exports = { memberProcessPrompt, MEMBER_PROCESS_PATH, MAX_MEMBER_PROCESS_BYTES };