atris 3.53.0 → 3.55.0

package/lib/member-scaffold.js

@@ -0,0 +1,197 @@
+const fs = require('fs');
+const path = require('path');
+
+const MEMBER_DIRS = Object.freeze(['skills', 'tools', 'context', 'logs']);
+
+function dateStamp(now = new Date()) {
+  return [
+    now.getFullYear(),
+    String(now.getMonth() + 1).padStart(2, '0'),
+    String(now.getDate()).padStart(2, '0'),
+  ].join('-');
+}
+
+function writeIfMissing(filePath, content) {
+  if (fs.existsSync(filePath)) return false;
+  fs.writeFileSync(filePath, content, { encoding: 'utf8', flag: 'wx' });
+  return true;
+}
+
+function memberMarkdown({ name, role, description }) {
+  const title = role || 'member';
+  const mission = description || 'Define why this member exists and how it chooses goals.';
+  return `---
+name: ${name}
+role: ${title}
+description: ${mission}
+version: 1.0.0
+
+skills: []
+
+permissions:
+  can-read: true
+  can-execute: true
+  can-approve: false
+  can-accept-task: false
+  approval-required: []
+
+tools: []
+---
+
+# ${title}
+
+## Mission
+
+${mission}
+
+## Persona
+
+(Define how this member communicates, their tone, and decision-making style)
+
+## Workflow
+
+1. Understand the request.
+2. Do one bounded useful step.
+3. Leave proof another teammate can trust.
+
+## Rules
+
+1. Stay inside this member's role and proof standard.
+2. Ask when vision, taste, risk, or uncertainty matters.
+`;
+}
+
+function memberSoulMarkdown({ name, role, born }) {
+  return `---
+name: ${name}
+version: 1.0.0
+born: ${born}
+---
+
+# Soul
+
+This is who ${name} is when the rules run out.
+
+## Beliefs
+
+- Useful work leaves evidence another teammate can trust.
+- Clear limits produce better judgment than vague autonomy.
+- The mission matters more than preserving a first idea.
+
+## Values
+
+1. Truth before confidence.
+2. Useful progress before activity.
+3. Continuity before cleverness.
+
+## Lessons
+
+- Empty until this member earns lessons through experience.
+
+## Edges
+
+- **Strong:** Focused judgment within the ${role} role.
+- **Weak:** Must ask when work crosses its stated authority or proof standard.
+
+## Voice
+
+- Understand the real need, make one grounded move, and leave the trail clearer.
+`;
+}
+
+function memberMissionMarkdown({ name, role, description }) {
+  const purpose = description || `Handle ${role.toLowerCase()} work for the team.`;
+  return `# Mission
+
+<!-- Human-authored purpose file. Keep this durable; runtime state belongs in .atris/state/*.jsonl and now.md. -->
+
+## North Star
+
+${purpose}
+
+## How To Choose Goals
+
+- Use MEMBER.md to stay inside ${role}'s identity, authority, and tools.
+- Choose one useful bounded goal toward this mission.
+- Verify the work, write the receipt, and update the log.
+- Ask the human when vision, taste, risk, or uncertainty matters.
+`;
+}
+
+function emptyMemberGoals(name, now = new Date()) {
+  return {
+    schema: 'atris.member_goals.v1',
+    member: name,
+    updated_at: now.toISOString(),
+    goals: [],
+  };
+}
+
+function initialMemberLog({ name, role, description, source, now }) {
+  const stamp = now.toTimeString().slice(0, 5);
+  return [
+    `## ${stamp} · Member initialized`,
+    `- team: ${name}`,
+    `- role: ${role}`,
+    description ? `- mission: ${description}` : '',
+    `- source: ${source}`,
+    '- status: ready_for_room',
+    '',
+  ].filter(Boolean).join('\n');
+}
+
+function ensureMemberBundle(memberDir, {
+  name = path.basename(memberDir),
+  role = 'member',
+  description = 'Define why this member exists and how it chooses goals.',
+  source = 'cli',
+  memberContent,
+  now = new Date(),
+} = {}) {
+  fs.mkdirSync(memberDir, { recursive: true });
+  for (const dirName of MEMBER_DIRS) {
+    fs.mkdirSync(path.join(memberDir, dirName), { recursive: true });
+  }
+
+  const created = [];
+  const ensure = (relativePath, content) => {
+    const filePath = path.join(memberDir, relativePath);
+    if (writeIfMissing(filePath, content)) created.push(relativePath);
+    return filePath;
+  };
+
+  const memberFile = typeof memberContent === 'string'
+    ? memberContent
+    : memberMarkdown({ name, role, description });
+  ensure('MEMBER.md', memberFile);
+  ensure('SOUL.md', memberSoulMarkdown({ name, role, born: dateStamp(now) }));
+  ensure('MISSION.md', memberMissionMarkdown({ name, role, description }));
+  ensure('goals.json', `${JSON.stringify(emptyMemberGoals(name, now), null, 2)}\n`);
+  ensure('goals.md', '# Goals\n\n<!-- Generated from goals.json. Edit with `atris member goal/tick/review` when possible. -->\n\nNo goals yet.\n');
+  const logName = `logs/${dateStamp(now)}.md`;
+  const logPath = ensure(logName, initialMemberLog({ name, role, description, source, now }));
+
+  return { created, logPath };
+}
+
+function memberBundlePresent(memberDir) {
+  if (!memberDir) return false;
+  const files = ['MEMBER.md', 'SOUL.md', 'MISSION.md', 'goals.json', 'goals.md'];
+  for (const fileName of files) {
+    if (!fs.existsSync(path.join(memberDir, fileName))) return false;
+  }
+  for (const dirName of MEMBER_DIRS) {
+    try {
+      if (!fs.statSync(path.join(memberDir, dirName)).isDirectory()) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = {
+  ensureMemberBundle,
+  memberBundlePresent,
+  memberMarkdown,
+};

package/lib/mission-root.js

@@ -17,8 +17,10 @@ const { spawnSync } = require('child_process');
 // same root — previously mission used only the git toplevel, so a mission
 // started inside a bound sub-workspace split away from that workspace's task
 // state. A git worktree reports its own toplevel (its .git marker), which is
-// the correct per-worktree store, so --worktree missions are unaffected. If the
-// shared resolver can't load, fall back to the git toplevel, then to cwd.
+// the correct per-worktree store, so --worktree missions are unaffected. Walk-up
+// stops before a generic scratch root (/tmp, /private/tmp, /var/tmp), so an
+// empty folder under /tmp does not inherit /tmp's mission book. If the shared
+// resolver can't load, fall back to the git toplevel, then to cwd.
 function resolveWorkspaceRoot(cwd = process.cwd()) {
   try {
     const { workspaceRoot } = require('./task-db');

package/lib/noninteractive.js

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+ * Shared headless/agent guard. When true, commands must not open a prompt.
+ * Covers: ATRIS_NONINTERACTIVE / ATRIS_NO_INTERACTIVE, --yes/-y, --json.
+ * Non-TTY stdin alone is usually non-interactive, but callers that accept
+ * piped batch input (like `atris log`) should use isForcedNonInteractive
+ * and handle empty vs piped stdin themselves.
+ */
+function isForcedNonInteractive(args = process.argv.slice(2)) {
+  const list = Array.isArray(args) ? args : [];
+  if (process.env.ATRIS_NONINTERACTIVE === '1') return true;
+  if (process.env.ATRIS_NO_INTERACTIVE === '1') return true;
+  if (list.includes('--yes') || list.includes('-y')) return true;
+  if (list.includes('--json')) return true;
+  return false;
+}
+
+function isNonInteractive(args = process.argv.slice(2)) {
+  if (isForcedNonInteractive(args)) return true;
+  if (!process.stdin.isTTY) return true;
+  return false;
+}
+
+function wantsJson(args = process.argv.slice(2)) {
+  return Array.isArray(args) && args.includes('--json');
+}
+
+function isHelpToken(arg) {
+  return arg === '--help' || arg === '-h' || arg === 'help' || arg === '-?';
+}
+
+function argsWantHelp(args = []) {
+  const list = Array.isArray(args) ? args : [];
+  return list.some(isHelpToken);
+}
+
+function hasYesFlag(args = []) {
+  const list = Array.isArray(args) ? args : [];
+  return list.includes('--yes') || list.includes('-y');
+}
+
+/**
+ * Headless / agent sessions must not hang on interactive runners.
+ * Non-TTY, ATRIS_NONINTERACTIVE=1, and ATRIS_NO_INTERACTIVE=1 all refuse
+ * unless the caller passed an explicit proceed flag (--yes, or --once for serve).
+ */
+function refuseHeadlessUnless(args, { allowYes = true, allowOnce = false, usage = '' } = {}) {
+  const list = Array.isArray(args) ? args : [];
+  const headless = Boolean(
+    process.env.ATRIS_NONINTERACTIVE === '1'
+    || process.env.ATRIS_NO_INTERACTIVE === '1'
+    || !process.stdin.isTTY
+    || !process.stdout.isTTY
+  );
+  if (!headless) return false;
+  if (allowYes && hasYesFlag(list)) return false;
+  if (allowOnce && list.includes('--once')) return false;
+  const lines = [];
+  if (usage) lines.push(usage);
+  else lines.push('This command needs a terminal, or an explicit proceed flag.');
+  lines.push('Pass --yes to run headless' + (allowOnce ? ', or --once for a single serve op.' : '.'));
+  console.error(lines.join('\n'));
+  return true;
+}
+
+function rejectUnsupportedJson(commandName, args = process.argv.slice(2)) {
+  if (!wantsJson(args)) return false;
+  console.log(JSON.stringify({
+    ok: false,
+    error: `${commandName} does not support --json`,
+    command: commandName,
+    usage: `atris ${commandName}`,
+  }, null, 2));
+  process.exit(2);
+  return true;
+}
+
+module.exports = {
+  isForcedNonInteractive,
+  isNonInteractive,
+  wantsJson,
+  isHelpToken,
+  argsWantHelp,
+  hasYesFlag,
+  refuseHeadlessUnless,
+  rejectUnsupportedJson,
+};

package/lib/policy-lessons.js

@@ -9,6 +9,7 @@
 // differently than the last. No LLM calls; re-mining refreshes the numbers.
 const fs = require('fs');
 const path = require('path');
+const { fileAutoLessons } = require('./auto-lessons');
 const { RECEIPT_PATH_PATTERN, extractReceiptEvidence } = require('./receipt-evidence');
 const escapeRegExp = require('./escape-regexp');
 
@@ -41,11 +42,13 @@ function readJsonlFile(filePath) {
 }
 
 function loadHistory(root) {
-  return {
+  const history = {
     receipts: readJsonlFile(path.join(root, CAREER_XP_RECEIPTS_FILE)),
     episodes: readJsonlFile(path.join(root, TASK_EPISODES_FILE)),
     scorecards: readJsonlFile(path.join(root, SCORECARDS_FILE)),
   };
+  fileAutoLessons(root, { episodes: history.episodes });
+  return history;
 }
 
 function isAgentActor(actor) {

package/lib/revision-metric.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const SCHEMA = 'atris.revision_metric.v1';
+const DAILY_SCHEMA = 'atris.revision_metric.daily.v1';
+const ROLLING_DAYS = 7;
+const REVISION_WINDOW_HOURS = 72;
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const REVISION_WINDOW_MS = REVISION_WINDOW_HOURS * HOUR_MS;
+const ATRIS_TRAILER_RE = /^\s*co-authored-by\s*:.*atris-builder\[bot\]/im;
+const IGNORED_FILES = [
+  /^atris\/logs\//,
+  /^atris\/runs\//,
+  /^atris\/team\/[^/]+\/(?:logs|now\.md)/,
+  /^atris\/(?:now|thinking|TODO)\.md$/,
+  /^atris\/MAP\.md$/,
+  /^atris\/brain\//,
+  /^atris\/status\//,
+  /^test\/fast-tests\.txt$/,
+  /^\.atris\//,
+];
+
+function git(root, args) {
+  const result = spawnSync('git', args, {
+    cwd: root,
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const message = String(result.stderr || result.stdout || `git ${args[0]} exited ${result.status}`).trim();
+    const error = new Error(message);
+    error.gitFailed = true;
+    throw error;
+  }
+  return String(result.stdout || '');
+}
+
+function hasRef(root, ref) {
+  const result = spawnSync('git', ['rev-parse', '--verify', '--quiet', ref], {
+    cwd: root,
+    encoding: 'utf8',
+  });
+  return result.status === 0;
+}
+
+function resolveHistoryRef(root, requestedRef) {
+  const candidates = requestedRef ? [requestedRef] : ['origin/master', 'master', 'HEAD'];
+  const ref = candidates.find((candidate) => hasRef(root, candidate));
+  if (!ref) {
+    const error = new Error('this folder has no readable git history');
+    error.gitFailed = true;
+    throw error;
+  }
+  return ref;
+}
+
+function isAtrisAssistedBody(body) {
+  return ATRIS_TRAILER_RE.test(String(body || ''));
+}
+
+function isRevisionSignalFile(file) {
+  const name = String(file || '').trim();
+  return Boolean(name) && !IGNORED_FILES.some((pattern) => pattern.test(name));
+}
+
+function parseMainlineLog(raw) {
+  return String(raw || '')
+    .split('\x1e')
+    .map((record) => record.replace(/^\n+/, ''))
+    .filter((record) => record.trim())
+    .map((record) => {
+      const [hash, parents, at, authorName, authorEmail, subject, body] = record.split('\x1f');
+      return {
+        hash: String(hash || '').trim(),
+        parents: String(parents || '').trim().split(/\s+/).filter(Boolean),
+        at: String(at || '').trim(),
+        ms: new Date(at).getTime(),
+        authorName: String(authorName || '').trim(),
+        authorEmail: String(authorEmail || '').trim(),
+        subject: String(subject || '').trim(),
+        body: String(body || ''),
+      };
+    })
+    .filter((commit) => commit.hash && Number.isFinite(commit.ms));
+}
+
+function readMainlineCommits(root, ref, sinceIso) {
+  const raw = git(root, [
+    'log', ref, '--first-parent', '--reverse', `--since=${sinceIso}`,
+    '--date=iso-strict',
+    '--pretty=format:%H%x1f%P%x1f%aI%x1f%aN%x1f%aE%x1f%s%x1f%B%x1e',
+  ]);
+  return parseMainlineLog(raw);
+}
+
+function commitFiles(root, commit) {
+  const args = commit.parents.length
+    ? ['diff', '--name-only', commit.parents[0], commit.hash]
+    : ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', commit.hash];
+  return git(root, args).split(/\r?\n/).map((file) => file.trim()).filter(Boolean);
+}
+
+function sideParentIsAtrisAssisted(root, commit, bodyCache) {
+  if (commit.parents.length < 2) return false;
+  return commit.parents.slice(1).some((parent) => {
+    if (!bodyCache.has(parent)) bodyCache.set(parent, git(root, ['show', '-s', '--format=%B', parent]));
+    return isAtrisAssistedBody(bodyCache.get(parent));
+  });
+}
+
+function isHumanAuthor(commit) {
+  const identity = `${commit.authorName} ${commit.authorEmail}`;
+  return !/\[bot\]|(?:^|[+._-])bot@/i.test(identity);
+}
+
+function summarizeChanges(changes, nowMs, excludedLandings) {
+  const revisionCount = changes.reduce((sum, change) => sum + change.revision_count, 0);
+  const revisedChanges = changes.filter((change) => change.revision_count > 0).length;
+  const stillObserving = changes.filter((change) => nowMs - new Date(change.landed_at).getTime() < REVISION_WINDOW_MS).length;
+  const matureCleanChanges = changes.filter((change) => (
+    change.revision_count === 0
+    && nowMs - new Date(change.landed_at).getTime() >= REVISION_WINDOW_MS
+  )).length;
+  return {
+    days: ROLLING_DAYS,
+    landed_changes: changes.length,
+    revision_count: revisionCount,
+    revised_changes: revisedChanges,
+    clean_so_far: changes.length - revisedChanges,
+    mature_clean_changes: matureCleanChanges,
+    still_observing: stillObserving,
+    excluded_state_only_landings: excludedLandings,
+    target_revision_count: 0,
+  };
+}
+
+function computeRevisionMetric(root = process.cwd(), options = {}) {
+  const now = options.now == null ? new Date() : new Date(options.now);
+  const nowMs = now.getTime();
+  if (!Number.isFinite(nowMs)) throw new Error('now must be a valid date');
+  const ref = resolveHistoryRef(root, options.ref);
+  const windowStart = new Date(nowMs - ROLLING_DAYS * DAY_MS);
+  const commits = readMainlineCommits(root, ref, windowStart.toISOString())
+    .filter((commit) => commit.ms <= nowMs);
+  const bodyCache = new Map();
+  const fileCache = new Map();
+  const filesFor = (commit) => {
+    if (!fileCache.has(commit.hash)) fileCache.set(commit.hash, commitFiles(root, commit));
+    return fileCache.get(commit.hash);
+  };
+  const changes = [];
+  const latestLandingByFile = new Map();
+  let excludedLandings = 0;
+
+  for (const commit of commits) {
+    const atrisAssisted = isAtrisAssistedBody(commit.body)
+      || sideParentIsAtrisAssisted(root, commit, bodyCache);
+    const files = filesFor(commit).filter(isRevisionSignalFile);
+
+    if (atrisAssisted) {
+      if (!files.length) {
+        excludedLandings += 1;
+        continue;
+      }
+      const change = {
+        commit: commit.hash,
+        subject: commit.subject,
+        landed_at: commit.at,
+        files: [...new Set(files)].sort(),
+        revision_count: 0,
+        revisions: [],
+      };
+      const index = changes.push(change) - 1;
+      change.files.forEach((file) => latestLandingByFile.set(file, index));
+      continue;
+    }
+
+    if (commit.parents.length > 1 || !isHumanAuthor(commit) || !files.length) continue;
+    const affected = new Map();
+    for (const file of files) {
+      const landingIndex = latestLandingByFile.get(file);
+      if (landingIndex == null) continue;
+      if (!affected.has(landingIndex)) affected.set(landingIndex, []);
+      affected.get(landingIndex).push(file);
+    }
+    for (const [landingIndex, overlap] of affected) {
+      const landing = changes[landingIndex];
+      const elapsed = commit.ms - new Date(landing.landed_at).getTime();
+      if (elapsed <= 0 || elapsed > REVISION_WINDOW_MS) continue;
+      landing.revisions.push({
+        commit: commit.hash,
+        subject: commit.subject,
+        at: commit.at,
+        files: [...new Set(overlap)].sort(),
+      });
+      landing.revision_count += 1;
+    }
+  }
+
+  return {
+    schema: SCHEMA,
+    generated_at: now.toISOString(),
+    source_ref: ref,
+    window_start: windowStart.toISOString(),
+    window_end: now.toISOString(),
+    signal: {
+      kind: 'proxy',
+      source: 'git_history',
+      landing: 'an atris co-author trailer on a mainline commit or its merged side parent',
+      revision: `a later non-merge human commit touching the latest landing's files within ${REVISION_WINDOW_HOURS} hours`,
+      limitation: 'the trailer proves assistance, not automatic landing; same-file overlap does not prove why the file changed; human commits carrying the trailer cannot be separated',
+      revision_window_hours: REVISION_WINDOW_HOURS,
+    },
+    changes,
+    rolling_7_days: summarizeChanges(changes, nowMs, excludedLandings),
+  };
+}
+
+function utcDate(value) {
+  return new Date(value).toISOString().slice(0, 10);
+}
+
+function dailyRow(metric) {
+  const summary = metric.rolling_7_days;
+  return {
+    schema: DAILY_SCHEMA,
+    date: utcDate(metric.generated_at),
+    day_basis: 'utc',
+    generated_at: metric.generated_at,
+    source_ref: metric.source_ref,
+    rolling_days: summary.days,
+    revision_window_hours: metric.signal.revision_window_hours,
+    landed_changes: summary.landed_changes,
+    revision_count: summary.revision_count,
+    revised_changes: summary.revised_changes,
+    clean_so_far: summary.clean_so_far,
+    mature_clean_changes: summary.mature_clean_changes,
+    still_observing: summary.still_observing,
+    excluded_state_only_landings: summary.excluded_state_only_landings,
+    measurement_kind: metric.signal.kind,
+    signal_source: metric.signal.source,
+  };
+}
+
+function appendDailySummary(root, metric, options = {}) {
+  const file = options.file || path.join(root, '.atris', 'state', 'revision-metric.jsonl');
+  const row = dailyRow(metric);
+  let existing = [];
+  try {
+    existing = fs.readFileSync(file, 'utf8')
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => {
+        try { return JSON.parse(line); } catch { return null; }
+      })
+      .filter(Boolean);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  const sameDay = existing.find((item) => item.schema === DAILY_SCHEMA && item.date === row.date);
+  if (sameDay) {
+    return { appended: false, row: sameDay, path: path.relative(root, file) };
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify(row)}\n`, 'utf8');
+  return { appended: true, row, path: path.relative(root, file) };
+}
+
+module.exports = {
+  REVISION_WINDOW_HOURS,
+  appendDailySummary,
+  computeRevisionMetric,
+  isRevisionSignalFile,
+};

package/lib/scratch-root.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Generic scratch roots. A workspace may live here (dogfood happens), but a
+// child folder is its own room and must not inherit that parent.
+// first-minute folderName already treats these as "this folder".
+const NAMED_SCRATCH_ROOTS = ['/tmp', '/private/tmp', '/var/tmp'];
+
+function pathKey(dir) {
+  return path.resolve(dir || '.').replace(/\\/g, '/');
+}
+
+function genericScratchRoots() {
+  const keys = new Set(NAMED_SCRATCH_ROOTS.map(pathKey));
+  try {
+    keys.add(pathKey(os.tmpdir()));
+  } catch {
+    // os.tmpdir can throw in locked-down hosts.
+  }
+  const resolved = new Set(keys);
+  for (const key of keys) {
+    try {
+      resolved.add(pathKey(fs.realpathSync(key)));
+    } catch {
+      // Missing or unreadable roots stay as the unresolved key.
+    }
+  }
+  return resolved;
+}
+
+function isGenericScratchRoot(dir) {
+  if (!dir) return false;
+  const roots = genericScratchRoots();
+  const key = pathKey(dir);
+  if (roots.has(key)) return true;
+  try {
+    return roots.has(pathKey(fs.realpathSync(dir)));
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  isGenericScratchRoot,
+};