atris 3.53.0 → 3.55.0

package/lib/auto-accept-certified.js

@@ -8,6 +8,7 @@ const { extractReceiptEvidence } = require('./receipt-evidence');
 const reviewIntegrity = require('./review-integrity');
 const { computeTrustTier } = require('./trust-tiers');
 const { policyLessonsForFiles, readPolicyLessons } = require('./policy-lessons');
+const { skillEvalGate } = require('./skill-eval-gate');
 
 const AGENT_CERTIFICATION_REVIEW_PASSES = 2;
 // Kept for compat with older callers/tests; the pass-count landing lane it
@@ -575,6 +576,11 @@ const repoHygieneCache = new Map();
 
 function repoHygieneGate(workspaceRoot) {
   const root = path.resolve(workspaceRoot || process.cwd());
+  // Skill receipts are mutable workspace state, so recompute this gate before
+  // consulting the repo-wide dead-code cache. A new receipt can unblock a
+  // landing, while a later SKILL.md edit must make an older receipt stale.
+  const skillEval = skillEvalGate(root);
+  if (!skillEval.ok) return skillEval;
   if (repoHygieneCache.has(root)) return repoHygieneCache.get(root);
   let result = { ok: true, skipped: true };
   if (fs.existsSync(path.join(root, 'test', 'repo-hygiene.test.js'))) {
@@ -617,7 +623,8 @@ function hygieneBlockResult(task, ref) {
     reason: hygiene.reason,
     message: hygiene.message,
     offenders: hygiene.offenders,
-    next_action: 'run `node --test test/repo-hygiene.test.js` in the workspace, delete what it names, then re-certify',
+    next_action: hygiene.next_action
+      || 'run `node --test test/repo-hygiene.test.js` in the workspace, delete what it names, then re-certify',
   };
 }
 

package/lib/auto-lessons.js

@@ -0,0 +1,186 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
+const TYPED_LESSONS_FILE = path.join('atris', 'lessons.json');
+const REPEAT_THRESHOLD = 2;
+const DETECTOR = 'repeated_human_revision_note';
+
+class AutoLessonsError extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = 'AutoLessonsError';
+    this.code = 'AUTO_LESSONS_ERROR';
+  }
+}
+
+function compactText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function normalizeCorrection(value) {
+  return compactText(value)
+    .normalize('NFKC')
+    .toLowerCase()
+    .replace(/[.!?]+$/, '');
+}
+
+function lessonSlug(value) {
+  const normalized = normalizeCorrection(value);
+  const slug = normalized
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (!slug) {
+    return `correction-${crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 12)}`;
+  }
+  if (slug.length <= 80) return slug;
+  const suffix = crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 8);
+  return `${slug.slice(0, 71).replace(/-+$/g, '')}-${suffix}`;
+}
+
+function revisionNote(episode) {
+  if (!episode || typeof episode !== 'object') return '';
+  if (episode.action?.event_type !== 'revision_requested') return '';
+  if (!['rework_requested', 'revised'].includes(episode.rl?.label)) return '';
+  return compactText(episode.human_feedback?.human_revision_note);
+}
+
+function detectRepeatSignals(episodes, options = {}) {
+  const threshold = Number.isInteger(options.threshold) && options.threshold > 1
+    ? options.threshold
+    : REPEAT_THRESHOLD;
+  const groups = new Map();
+  const seenEpisodes = new Set();
+
+  for (const [index, episode] of (Array.isArray(episodes) ? episodes : []).entries()) {
+    const note = revisionNote(episode);
+    if (!note) continue;
+    const episodeId = compactText(episode.episode_id);
+    if (episodeId && seenEpisodes.has(episodeId)) continue;
+    if (episodeId) seenEpisodes.add(episodeId);
+
+    const normalized = normalizeCorrection(note);
+    const slug = lessonSlug(normalized);
+    if (!groups.has(slug)) {
+      groups.set(slug, {
+        slug,
+        note,
+        normalized,
+        occurrences: [],
+      });
+    }
+    groups.get(slug).occurrences.push({
+      episode_id: episodeId || null,
+      task_id: compactText(episode.task_id) || null,
+      created_at: compactText(episode.created_at) || null,
+      row: index + 1,
+    });
+  }
+
+  return [...groups.values()].filter((signal) => signal.occurrences.length >= threshold);
+}
+
+function readJsonl(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return [];
+    throw new AutoLessonsError(`cannot read automatic lesson signals from ${filePath}: ${error.message}`, error);
+  }
+  return raw.split('\n').map((line) => {
+    const text = line.trim();
+    if (!text) return null;
+    try { return JSON.parse(text); } catch { return null; }
+  }).filter(Boolean);
+}
+
+function readTypedLessons(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return {};
+    throw new AutoLessonsError(`cannot read ${filePath}: ${error.message}`, error);
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new AutoLessonsError(`cannot file automatic lessons because ${filePath} contains malformed JSON: ${error.message}`, error);
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new AutoLessonsError(`cannot file automatic lessons because ${filePath} must contain a JSON object`);
+  }
+  return parsed;
+}
+
+function writeJsonAtomic(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const temporaryPath = `${filePath}.auto-lessons-${process.pid}-${Date.now()}`;
+  try {
+    fs.writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    fs.renameSync(temporaryPath, filePath);
+  } catch (error) {
+    try { fs.rmSync(temporaryPath, { force: true }); } catch {}
+    throw new AutoLessonsError(`cannot write automatic lessons to ${filePath}: ${error.message}`, error);
+  }
+}
+
+function isoDate(now) {
+  const date = now instanceof Date ? now : new Date(now || Date.now());
+  if (Number.isNaN(date.getTime())) throw new AutoLessonsError('cannot file automatic lessons with an invalid date');
+  return date.toISOString().slice(0, 10);
+}
+
+function typedLesson(signal, options = {}) {
+  const taskIds = [...new Set(signal.occurrences.map((item) => item.task_id).filter(Boolean))];
+  const episodeIds = [...new Set(signal.occurrences.map((item) => item.episode_id).filter(Boolean))];
+  return {
+    name: signal.note,
+    date: isoDate(options.now),
+    scope: compactText(options.scope) || 'workspace',
+    rule: signal.note,
+    detector: DETECTOR,
+    source_signal: {
+      type: DETECTOR,
+      path: TASK_EPISODES_FILE,
+      normalized_correction: signal.normalized,
+      occurrences: signal.occurrences.length,
+      task_ids: taskIds,
+      episode_ids: episodeIds,
+    },
+    status: 'observed',
+    last_detected: isoDate(options.now),
+  };
+}
+
+function fileAutoLessons(root, options = {}) {
+  const episodes = Array.isArray(options.episodes)
+    ? options.episodes
+    : readJsonl(path.join(root, TASK_EPISODES_FILE));
+  const signals = detectRepeatSignals(episodes, options);
+  if (!signals.length) return { added: [], detected: [] };
+
+  const lessonsPath = path.join(root, TYPED_LESSONS_FILE);
+  const lessons = readTypedLessons(lessonsPath);
+  const added = [];
+  for (const signal of signals) {
+    if (Object.prototype.hasOwnProperty.call(lessons, signal.slug)) continue;
+    lessons[signal.slug] = typedLesson(signal, options);
+    added.push(signal.slug);
+  }
+  if (added.length) writeJsonAtomic(lessonsPath, lessons);
+  return { added, detected: signals.map((signal) => signal.slug) };
+}
+
+module.exports = {
+  TASK_EPISODES_FILE,
+  TYPED_LESSONS_FILE,
+  fileAutoLessons,
+  lessonSlug,
+};

package/lib/autoland.js

@@ -430,7 +430,7 @@ function hasAgentJargon(text) {
   return AGENT_JARGON.test(String(text || ''));
 }
 
-function explainResult(text) {
+function explainResult(text, options = {}) {
   const raw = String(text || '');
   const value = raw.replace(/\s+/g, ' ').trim();
   if (!value) return { ok: false, reason: 'result must say what someone can do now and why it matters.' };
@@ -443,7 +443,9 @@ function explainResult(text) {
   if (RESULT_ULID.test(value)) return { ok: false, reason: 'result should explain the gain, not include database ids.' };
   if (RESULT_TICKET.test(value)) return { ok: false, reason: 'result should not include ticket ids.' };
   if (RESULT_FILE_PATH.test(value)) return { ok: false, reason: 'result should not include file paths.' };
-  if (RESULT_COMMAND.test(value)) return { ok: false, reason: 'result should not include command syntax or flags.' };
+  if (!options.allowCommandMention && RESULT_COMMAND.test(value)) {
+    return { ok: false, reason: 'result should not include command syntax or flags.' };
+  }
   const finalWord = (value.replace(/[.!?]+$/g, '').match(/[A-Za-z]+$/) || [''])[0].toLowerCase();
   if (TRAILING_FRAGMENT_WORDS.has(finalWord) && !COMPLETE_TRAILING_PHRASE.test(value)) {
     return { ok: false, reason: 'result ends mid-thought; finish the sentence with the actual human gain.' };

package/lib/chat-log-scan.js

@@ -68,12 +68,14 @@ function cursorTranscriptRoots(cwd = process.cwd()) {
   return roots;
 }
 
-function axLogDirs(cwd = process.cwd()) {
+function axLogDirs(cwd = process.cwd(), options = {}) {
   const dirs = [];
   const local = path.join(cwd, 'atris', 'runs');
-  const home = path.join(os.homedir(), '.atris', 'runs');
   if (fs.existsSync(local)) dirs.push(local);
-  if (fs.existsSync(home) && home !== local) dirs.push(home);
+  if (options.global) {
+    const home = path.join(os.homedir(), '.atris', 'runs');
+    if (fs.existsSync(home) && home !== local) dirs.push(home);
+  }
   return dirs;
 }
 
@@ -276,7 +278,7 @@ function scanChatLogs(options = {}) {
   const maxAgeMs = maxAgeHours * 3600000;
   const sessions = [];
 
-  for (const dir of axLogDirs(cwd)) {
+  for (const dir of axLogDirs(cwd, { global: options.global === true })) {
     for (const file of listRecentFiles(dir, { pattern: /^ax-.*\.log$/, limit, maxAgeMs })) {
       const text = safeRead(file.path);
       if (!text) continue;
@@ -304,6 +306,7 @@ function scanChatLogs(options = {}) {
     schema: SCHEMA,
     scanned_at: new Date().toISOString(),
     cwd,
+    scope: options.global === true ? 'global' : 'workspace',
     window_hours: maxAgeHours,
     sources: {
       ax_dirs: axLogDirs(cwd),

package/lib/cli-json.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs = require('fs');
+
+/**
+ * Compact --json helpers for headless agents.
+ * Default payloads stay tiny; --full dumps the full object.
+ */
+
+function writeStdout(text) {
+  const buffer = Buffer.from(`${String(text).replace(/\n?$/, '\n')}`, 'utf8');
+  const retryWait = new Int32Array(new SharedArrayBuffer(4));
+  let offset = 0;
+  while (offset < buffer.length) {
+    try {
+      offset += fs.writeSync(process.stdout.fd, buffer, offset, buffer.length - offset);
+    } catch (err) {
+      if (err && err.code === 'EAGAIN') {
+        Atomics.wait(retryWait, 0, 0, 10);
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+
+function wantsJson(args = []) {
+  return Array.isArray(args) && args.includes('--json');
+}
+
+function wantsFull(args = []) {
+  return Array.isArray(args) && (args.includes('--full') || args.includes('--verbose'));
+}
+
+function compactErrorPayload({
+  reason = 'error',
+  detail = null,
+  selected_ref = null,
+  next_command = null,
+} = {}) {
+  return {
+    ok: false,
+    reason: String(reason || 'error'),
+    detail: detail == null ? null : String(detail),
+    selected_ref: selected_ref == null ? null : String(selected_ref),
+    next_command: next_command == null ? null : String(next_command),
+  };
+}
+
+function compactSuccessPayload({
+  action,
+  ids = {},
+  next_command = null,
+} = {}) {
+  const payload = { ok: true, action: String(action || 'ok') };
+  for (const [key, value] of Object.entries(ids || {})) {
+    if (value == null || value === '') continue;
+    payload[key] = value;
+  }
+  if (next_command != null && next_command !== '') {
+    payload.next_command = String(next_command);
+  }
+  return payload;
+}
+
+function printCliJson(fullPayload, compactPayload, args = [], print = writeStdout) {
+  const body = wantsFull(args) ? fullPayload : compactPayload;
+  print(JSON.stringify(body, null, 2));
+  return body;
+}
+
+module.exports = {
+  wantsJson,
+  compactErrorPayload,
+  compactSuccessPayload,
+  printCliJson,
+};

package/lib/cli-scope.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const path = require('path');
+
+function parseScopeFlag(args = []) {
+  const list = Array.isArray(args) ? args : [];
+  const global = list.includes('--global') || list.includes('-g');
+  return {
+    kind: global ? 'global' : 'workspace',
+    global,
+    args: list.filter((arg) => arg !== '--global' && arg !== '-g'),
+  };
+}
+
+function pathUnderRoot(candidate, root) {
+  if (!candidate || !root) return false;
+  const resolvedCandidate = path.resolve(String(candidate));
+  const resolvedRoot = path.resolve(String(root));
+  return resolvedCandidate === resolvedRoot
+    || resolvedCandidate.startsWith(`${resolvedRoot}${path.sep}`);
+}
+
+module.exports = {
+  parseScopeFlag,
+  pathUnderRoot,
+};

package/lib/codex-flight.js

@@ -57,6 +57,7 @@ function buildPrompt({ worktreePath, branch, brief, verifyCmd }) {
     '',
     'Instructions:',
     `- First run: atris worktree guard`,
+    '- Keep one concern per PR; split anything larger into separate PRs because git history guides future agents and small PRs are cheap to revert and bisect.',
     `- Verify with this bare command and use its real exit code: ${verify}`,
     '- Stage and commit only files you changed.',
     `- Commit with a plain-English message and include this trailer: ${COAUTHOR}`,

package/lib/conductor-artifacts.js

@@ -6,7 +6,7 @@
 // this list; keeping it in one place is what stops an engine from being blocked
 // by its own prompt file.
 const CONDUCTOR_UNTRACKED_PATTERN =
-  /^\.atris\/(?:agent-worktree\.json|fleet-prompt-[^/]+\.md|codex-watchdog-[^/]+\.json|runtime-tmp(?:\/.*)?|state\/briefs\.jsonl)$/;
+  /^\.atris\/(?:agent-worktree\.json|fleet-prompt-[^/]+\.md|codex-watchdog\.js|codex-watchdog-[^/]+\.json|runtime-tmp(?:\/.*)?|state\/briefs\.jsonl)$/;
 
 function isConductorArtifact(file) {
   return CONDUCTOR_UNTRACKED_PATTERN.test(String(file || ''));

package/lib/context-gatherer.js

@@ -45,6 +45,15 @@ function inferDomain(answer) {
   return 'general';
 }
 
+function isFlagLikeAnswer(answer) {
+  const tokens = String(answer || '').trim().split(/\s+/).filter(Boolean);
+  if (!tokens.length) return true;
+  const helpFlag = (token) => token === '--help' || token === '-h' || token === '-?';
+  if (tokens.some(helpFlag)) return true;
+  if (tokens.length === 1 && (tokens[0] === 'help' || tokens[0].startsWith('-'))) return true;
+  return tokens.every((token) => token.startsWith('-') || token === 'help');
+}
+
 function starterTaskTitle(answer) {
   const summary = compactText(answer, 80) || 'first useful path';
   return `First useful step: ${summary}`;
@@ -69,6 +78,7 @@ function saveContextProfile(root, answer, { source = 'first_contact' } = {}) {
 }
 
 function createStarterTask(root, answer) {
+  if (isFlagLikeAnswer(answer)) return null;
   const atrisDir = path.join(root, 'atris');
   if (!fs.existsSync(atrisDir)) return null;
   try {
@@ -180,4 +190,5 @@ module.exports = {
   starterTaskTitle,
   inferDomain,
   isAtrisMetaQuestion,
+  isFlagLikeAnswer,
 };

package/lib/developer-api.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const ROLLOUT_MESSAGE = 'backend rolling out, try again shortly';
+const NOT_LOGGED_IN = 'not logged in. run: atris login';
+
+function wantsJson(args = []) {
+  return Array.isArray(args) && args.includes('--json');
+}
+
+function wantsHelp(args = []) {
+  if (!Array.isArray(args) || args.length === 0) return false;
+  return args.includes('--help') || args.includes('-h') || args[0] === 'help';
+}
+
+function tokenFrom(creds) {
+  if (!creds || typeof creds !== 'object') return '';
+  const token = typeof creds.token === 'string' ? creds.token.trim() : '';
+  return token;
+}
+
+function isNotFound(result) {
+  return Boolean(result && Number(result.status) === 404);
+}
+
+function oneLine(value) {
+  if (value && typeof value === 'object') {
+    const detail = value.detail || value.error || value.message;
+    if (detail) return oneLine(detail);
+    try {
+      return JSON.stringify(value).replace(/\s+/g, ' ').trim();
+    } catch {
+      return 'request failed';
+    }
+  }
+  const text = String(value == null ? '' : value).replace(/\s+/g, ' ').trim();
+  return text || 'request failed';
+}
+
+function printResult(result, io = {}) {
+  const log = io.log || console.log;
+  const err = io.err || console.error;
+  if (result.json) {
+    const payload = result.payload != null
+      ? result.payload
+      : { ok: false, error: result.error || result.text || 'request failed' };
+    log(JSON.stringify(payload));
+    return;
+  }
+  if (result.ok) log(result.text);
+  else err(result.error || result.text || 'request failed');
+}
+
+function creditsToDollars(credits) {
+  const n = Number(credits);
+  if (!Number.isFinite(n)) return 0;
+  return Math.round(n) / 100;
+}
+
+function formatDollars(amount) {
+  const n = Number(amount);
+  if (!Number.isFinite(n)) return '$0.00';
+  return `$${n.toFixed(2)}`;
+}
+
+function normalizeBalance(data = {}) {
+  const raw = data && typeof data === 'object' ? data : {};
+  const credits = Number(raw.balance != null ? raw.balance : raw.credits);
+  const safeCredits = Number.isFinite(credits) ? credits : 0;
+  const usd = Number(raw.balance_usd);
+  const dollars = Number.isFinite(usd) ? usd : creditsToDollars(safeCredits);
+  return {
+    dollars,
+    credits: safeCredits,
+    balance_usd: dollars,
+    balance: safeCredits,
+    lifetime_purchased: raw.lifetime_purchased != null ? raw.lifetime_purchased : null,
+    lifetime_spent: raw.lifetime_spent != null ? raw.lifetime_spent : null,
+  };
+}
+
+function checkoutUrl(data = {}) {
+  const raw = data && typeof data === 'object' ? data : {};
+  return String(raw.checkout_url || raw.url || raw.checkoutUrl || '').trim();
+}
+
+function parseAmountUsd(args = [], fallback = 10) {
+  const values = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = String(args[i]);
+    if (arg === '--json' || arg === '--help' || arg === '-h' || arg === 'help') continue;
+    if (arg.startsWith('--')) continue;
+    values.push(arg);
+  }
+  if (values.length === 0) return { ok: true, amount: fallback };
+  const raw = String(values[0]).replace(/^\$/, '');
+  const amount = Number(raw);
+  if (!Number.isInteger(amount) || amount < 5 || amount > 500) {
+    return { ok: false, error: 'amount must be a whole dollar from 5 to 500' };
+  }
+  return { ok: true, amount };
+}
+
+module.exports = {
+  ROLLOUT_MESSAGE,
+  NOT_LOGGED_IN,
+  wantsJson,
+  wantsHelp,
+  tokenFrom,
+  isNotFound,
+  oneLine,
+  printResult,
+  formatDollars,
+  normalizeBalance,
+  checkoutUrl,
+  parseAmountUsd,
+};