atris 3.52.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-ledger-compact.js

@@ -0,0 +1,127 @@
+'use strict';
+
+// Mission ledger compaction. Every mission save appends a full snapshot to
+// .atris/state/missions.jsonl, so a mission saved N times costs N rows and
+// every reader pays for the whole history (2,417 rows for 302 missions when
+// this shipped). Worse, old snapshots keep referencing old run receipts, so
+// the daily runs-prune can never reclaim them. Compacting to one row per
+// mission keeps exactly what every reader reconstructs anyway.
+//
+// Readers' contract (loadMissionMap in commands/mission.js): the surviving
+// row per id must carry the LATEST state but the FIRST display number ever
+// assigned, and first-appearance order must hold so numbering stays stable.
+
+const fs = require('fs');
+const path = require('path');
+const { displayNumber } = require('./short-name');
+
+const DEFAULT_MIN_ROWS = 64;
+const DEFAULT_RATIO = 4;
+
+function parseLines(text) {
+  return String(text || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    });
+}
+
+// Latest snapshot per id, first-seen order, first assigned display number.
+// Rows without an id are not mission snapshots (cloud mission receipts land
+// here as {cloud: true, ...}); they pass through untouched, in order, after
+// the compacted snapshots so latest-row readers still find them.
+function compactRows(rows) {
+  const order = [];
+  const latest = new Map();
+  const firstNumber = new Map();
+  const passthrough = [];
+  for (const row of rows) {
+    if (!row) continue;
+    if (!row.id) {
+      passthrough.push(row);
+      continue;
+    }
+    if (!latest.has(row.id)) order.push(row.id);
+    if (!firstNumber.has(row.id) && displayNumber(row.n)) firstNumber.set(row.id, displayNumber(row.n));
+    latest.set(row.id, row);
+  }
+  const compacted = order.map((id) => {
+    const row = { ...latest.get(id) };
+    if (firstNumber.has(id)) row.n = firstNumber.get(id);
+    else delete row.n;
+    return row;
+  });
+  return compacted.concat(passthrough);
+}
+
+// Compact when history outweighs live records by `ratio`, and never bother
+// below `minRows`. Returns a receipt either way; writes atomically so a
+// concurrent reader sees the old file or the new one, never a torn one.
+function compactMissionLedger(file, options = {}) {
+  const minRows = Number.isFinite(options.minRows) ? options.minRows : DEFAULT_MIN_ROWS;
+  const ratio = Number.isFinite(options.ratio) ? options.ratio : DEFAULT_RATIO;
+  // Cheap stat gate so the every-save hook does not re-read a small healthy
+  // ledger: below this size compaction cannot be worth a full read.
+  const minBytes = Number.isFinite(options.minBytes) ? options.minBytes : 262144;
+  if (options.force !== true) {
+    try {
+      if (fs.statSync(file).size < minBytes) {
+        return { compacted: false, reason: 'below_threshold', rows_before: 0, rows_after: 0 };
+      }
+    } catch {
+      return { compacted: false, reason: 'missing', rows_before: 0, rows_after: 0 };
+    }
+  }
+  let text = '';
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return { compacted: false, reason: 'missing', rows_before: 0, rows_after: 0 };
+  }
+  const rows = parseLines(text);
+  const valid = rows.filter((row) => row && row.id);
+  const uniqueIds = new Set(valid.map((row) => row.id)).size;
+  const receipt = {
+    rows_before: rows.length,
+    unique_missions: uniqueIds,
+    bytes_before: Buffer.byteLength(text),
+  };
+  const force = options.force === true;
+  if (!force && (rows.length < minRows || rows.length < uniqueIds * ratio)) {
+    return { ...receipt, compacted: false, reason: 'below_threshold', rows_after: rows.length };
+  }
+  const compacted = compactRows(rows.filter(Boolean));
+  const nextText = compacted.length
+    ? `${compacted.map((row) => JSON.stringify(row)).join('\n')}\n`
+    : '';
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(tmp, nextText, 'utf8');
+  // The rename replaces the whole file, so an append that landed after our
+  // read would be silently lost. Re-check right before the swap and stand
+  // down if anyone wrote in between; the next save retries compaction.
+  try {
+    if (fs.statSync(file).size !== receipt.bytes_before) {
+      fs.unlinkSync(tmp);
+      return { ...receipt, compacted: false, reason: 'concurrent_write', rows_after: rows.length };
+    }
+  } catch {
+    fs.unlinkSync(tmp);
+    return { ...receipt, compacted: false, reason: 'missing', rows_after: 0 };
+  }
+  fs.renameSync(tmp, file);
+  return {
+    ...receipt,
+    compacted: true,
+    rows_after: compacted.length,
+    bytes_after: Buffer.byteLength(nextText),
+  };
+}
+
+module.exports = { compactMissionLedger, compactRows };

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/mission-runtime-loop.js

@@ -121,7 +121,34 @@ function runCliJsonStreaming(cliPath, args, options = {}) {
         ...(options.env || {}),
       },
       stdio: ['ignore', 'pipe', 'pipe'],
+      // Own process group so a timeout can kill the whole tree: the tick
+      // spawns engine workers through a shell, and killing only the direct
+      // child leaves them running (and billing) for hours after the timeout.
+      detached: process.platform !== 'win32',
     });
+    const killTree = (signal) => {
+      try {
+        if (process.platform !== 'win32' && proc.pid) process.kill(-proc.pid, signal);
+        else proc.kill(signal);
+      } catch {
+        try { proc.kill(signal); } catch {}
+      }
+    };
+    // Detached children survive the operator's Ctrl-C (they left our process
+    // group), so relay the signal to the whole tree ourselves, then let the
+    // default exit happen by re-raising after removing our handler.
+    const relaySignal = (signal) => {
+      killTree('SIGTERM');
+      setTimeout(() => killTree('SIGKILL'), 2000).unref();
+      process.removeListener(signal, relaySignal);
+      process.kill(process.pid, signal);
+    };
+    process.once('SIGINT', relaySignal);
+    process.once('SIGTERM', relaySignal);
+    const detachSignalRelay = () => {
+      process.removeListener('SIGINT', relaySignal);
+      process.removeListener('SIGTERM', relaySignal);
+    };
     let stdout = '';
     let stderr = '';
     let done = false;
@@ -130,6 +157,7 @@ function runCliJsonStreaming(cliPath, args, options = {}) {
     const finish = (status) => {
       if (done) return;
       done = true;
+      detachSignalRelay();
       clearTimeout(timer);
       if (progressTimer) clearInterval(progressTimer);
       let payload = null;
@@ -146,8 +174,8 @@ function runCliJsonStreaming(cliPath, args, options = {}) {
     };
     const timer = setTimeout(() => {
       killedByTimeout = true;
-      try { proc.kill('SIGTERM'); } catch {}
-      setTimeout(() => { try { proc.kill('SIGKILL'); } catch {} }, 3000).unref();
+      killTree('SIGTERM');
+      setTimeout(() => killTree('SIGKILL'), 3000).unref();
     }, options.timeoutMs || 660000);
     progressTimer = options.onProgress
       ? setInterval(() => {

package/lib/next-moves.js

@@ -120,12 +120,17 @@ function readRoadmapOpenItems(root) {
     }));
 }
 
-function readActiveTasks(root) {
+// One parse of tasks.projection.json, shared by every reader that needs the
+// task list, so a single nextMoves() call does not re-read the same big file.
+function readTasksProjection(root) {
   const text = safeRead(path.join(root, '.atris', 'state', 'tasks.projection.json'));
   if (!text) return [];
   let proj;
   try { proj = JSON.parse(text); } catch { return []; }
-  const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+  return Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+}
+
+function readActiveTasks(root, tasks = readTasksProjection(root)) {
   return tasks
     .filter((t) => t && t.title && ['open', 'claimed'].includes(String(t.status || '').toLowerCase()))
     .filter((t) => !isInternalNextMoveTask(t))
@@ -147,12 +152,7 @@ function isInternalNextMoveTask(task) {
   return tags.includes('agent-xp') || /^mission xp\s*:/i.test(title);
 }
 
-function readHandledTaskTitles(root) {
-  const text = safeRead(path.join(root, '.atris', 'state', 'tasks.projection.json'));
-  if (!text) return [];
-  let proj;
-  try { proj = JSON.parse(text); } catch { return []; }
-  const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+function readHandledTaskTitles(root, tasks = readTasksProjection(root)) {
   return tasks
     .filter((t) => t && t.title && ['review', 'done'].includes(String(t.status || '').toLowerCase()))
     .map((t) => String(t.title).trim())
@@ -297,8 +297,8 @@ function missionShortLabel(mission) {
   return shortRecordLabel(mission, missionVisibleTitle(mission), { wordLimit: 3 });
 }
 
-function readActionableMissionCards(root) {
-  return Array.from(latestMissionRecords(root).values())
+function readActionableMissionCards(root, missions = latestMissionRecords(root)) {
+  return Array.from(missions.values())
     .filter((mission) => {
       const status = String(mission?.status || '').toLowerCase();
       if (['complete', 'completed', 'stopped', 'paused'].includes(status)) return false;
@@ -324,8 +324,8 @@ function readActionableMissionCards(root) {
     });
 }
 
-function readActiveMissions(root) {
-  return Array.from(latestMissionRecords(root).values())
+function readActiveMissions(root, missions = latestMissionRecords(root)) {
+  return Array.from(missions.values())
     .filter((m) => m && missionVisibleTitle(m) && !['complete', 'stopped', 'paused'].includes(String(m.status || '').toLowerCase()))
     .map((m) => ({
       title: missionVisibleTitle(m),
@@ -397,9 +397,8 @@ function wishHasReview(wish) {
   return Boolean(wish && (wish.reviewed || (Array.isArray(wish.reviews) && wish.reviews.length)));
 }
 
-function readUnreviewedShippedWishCards(root) {
+function readUnreviewedShippedWishCards(root, missions = latestMissionRecords(root)) {
   const latest = latestWishEventMap(root);
-  const missions = latestMissionRecords(root);
   return readWishes(root)
     .filter((wish) => {
       if (!wish || !wish.id || wishHasReview(wish)) return false;
@@ -430,12 +429,7 @@ function readUnreviewedShippedWishCards(root) {
     });
 }
 
-function activeEndgameTaskCount(root) {
-  const text = safeRead(path.join(root, '.atris', 'state', 'tasks.projection.json'));
-  if (!text) return 0;
-  let proj;
-  try { proj = JSON.parse(text); } catch { return 0; }
-  const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+function activeEndgameTaskCount(root, tasks = readTasksProjection(root)) {
   return tasks.filter((t) => {
     if (!t) return false;
     const status = String(t.status || '').toLowerCase();
@@ -444,10 +438,10 @@ function activeEndgameTaskCount(root) {
   }).length;
 }
 
-function todoKeepsEndgameActive(root) {
+function todoKeepsEndgameActive(root, tasks = readTasksProjection(root)) {
   const text = safeRead(path.join(root, 'atris', 'TODO.md'));
   if (!text) return true;
-  if (activeEndgameTaskCount(root) > 0) return true;
+  if (activeEndgameTaskCount(root, tasks) > 0) return true;
 
   let sawEndgameHeader = false;
   let section = '';
@@ -464,8 +458,8 @@ function todoKeepsEndgameActive(root) {
   return !sawEndgameHeader;
 }
 
-function readEndgameMove(root) {
-  if (!todoKeepsEndgameActive(root)) return [];
+function readEndgameMove(root, tasks = readTasksProjection(root)) {
+  if (!todoKeepsEndgameActive(root, tasks)) return [];
   let state = null;
   try { state = JSON.parse(safeRead(path.join(root, 'atris', 'brain', 'state.json'))); } catch { state = null; }
   const horizon = String(state?.endgame?.horizon || '').trim();
@@ -508,17 +502,21 @@ function todayInboxItems(root) {
   return inboxItemsFrom(safeRead(file));
 }
 
-function gatherCandidates(root = process.cwd()) {
+// Parse each shared big file (tasks projection, missions log) exactly once per
+// call and thread the result to every reader that needs it.
+function gatherCandidates(root = process.cwd(), shared = {}) {
+  const tasks = shared.tasks || readTasksProjection(root);
+  const missions = shared.missions || latestMissionRecords(root);
   return [
     ...readWaitingWishCards(root),
-    ...readActionableMissionCards(root),
+    ...readActionableMissionCards(root, missions),
     ...readDreamCards(root),
     ...readRoadmapOpenItems(root),
-    ...readActiveMissions(root),
-    ...readEndgameMove(root),
-    ...readActiveTasks(root),
+    ...readActiveMissions(root, missions),
+    ...readEndgameMove(root, tasks),
+    ...readActiveTasks(root, tasks),
     ...latestInboxItems(root),
-    ...readUnreviewedShippedWishCards(root),
+    ...readUnreviewedShippedWishCards(root, missions),
   ];
 }
 
@@ -595,10 +593,11 @@ function parkNextCard(root, card, stamp) {
 
 function nextCards(root = process.cwd(), limit = 1, options = {}) {
   const { killedIds, killedTitles, approvedIds, approvedTitles } = readDecisions(root);
-  const handledTaskTitles = readHandledTaskTitles(root);
+  const tasks = readTasksProjection(root);
+  const handledTaskTitles = readHandledTaskTitles(root, tasks);
   const parkedIds = options.includeParked ? [] : parkedNextIds(root);
   const skipIds = Array.isArray(options.skipIds) ? options.skipIds : [];
-  return pickNextMoves(gatherCandidates(root), {
+  return pickNextMoves(gatherCandidates(root, { tasks }), {
     limit,
     killedIds: [...killedIds, ...parkedIds, ...skipIds],
     killedTitles,
@@ -836,8 +835,9 @@ function pickRoadmapSeed(root = process.cwd()) {
 // so the ranking inputs live in one place.
 function nextMoves(root = process.cwd(), limit = 3) {
   const { killedIds, killedTitles, approvedIds, approvedTitles } = readDecisions(root);
-  const handledTaskTitles = readHandledTaskTitles(root);
-  const picked = pickNextMoves(gatherCandidates(root), { limit, killedIds, killedTitles, approvedIds, approvedTitles, handledTaskTitles });
+  const tasks = readTasksProjection(root);
+  const handledTaskTitles = readHandledTaskTitles(root, tasks);
+  const picked = pickNextMoves(gatherCandidates(root, { tasks }), { limit, killedIds, killedTitles, approvedIds, approvedTitles, handledTaskTitles });
   return addMissionOnlyFallback(picked, limit, root);
 }
 

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/permission-grants.js

@@ -119,7 +119,15 @@ function addGrant({ command, workspaceRoot, createdVia = 'cli', expiresInDays =
 
 function revokeGrant(grantId, file) {
   const store = loadGrants(file);
-  const grant = store.grants.find(g => g.grant_id === grantId || String(g.grant_id).startsWith(String(grantId)));
+  const ref = String(grantId || '');
+  let grant = store.grants.find(g => g.grant_id === ref);
+  if (!grant && ref) {
+    // Prefix refs are a convenience, but an ambiguous prefix must never
+    // revoke an arbitrary grant — require exactly one match.
+    const matches = store.grants.filter(g => String(g.grant_id).startsWith(ref));
+    if (matches.length > 1) return { ok: false, reason: `"${ref}" matches ${matches.length} grants; use more characters` };
+    grant = matches[0];
+  }
   if (!grant) return { ok: false, reason: 'grant not found' };
   grant.status = 'revoked';
   grant.sync = { ...(grant.sync || {}), revoked_at: new Date().toISOString() };
@@ -283,5 +291,6 @@ module.exports = {
   revokeGrant,
   matchGrant,
   recordUse,
+  commandIsGrantable,
   syncGrants,
 };

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) {