atris 3.52.0 → 3.53.0

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-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/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/runner-command.js

@@ -67,10 +67,10 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     model: 'grok-4.6',
     commandTemplate: '{bin} --always-approve -p {prompt}',
   }),
-  droid: Object.freeze({
-    bin: 'droid',
-    model: '',
-    commandTemplate: '{bin} exec {prompt}',
+  agy: Object.freeze({
+    bin: 'agy',
+    model: 'gemini-3.7-flash-high',
+    commandTemplate: '{bin} --mode accept-edits {modelFlag} -p {prompt}',
   }),
 });
 
@@ -80,6 +80,7 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
 const RUNNER_PROFILE_ALIASES = Object.freeze({
   'atris2-fast': 'atris-fast',
   'atris-2-fast': 'atris-fast',
+  antigravity: 'agy',
 });
 
 // Back-compat surface: RUNNER_PROFILES still resolves every accepted name

package/lib/task-db.js

@@ -1965,11 +1965,17 @@ function selectProjectionRows(rows, { taskId, includeHistory, doneLimit }) {
     return {
       visibleRows: rows,
       hiddenDoneCount: 0,
+      hiddenArchivedCount: 0,
     };
   }
   const visibleRows = [];
   let shownDone = 0;
   let hiddenDoneCount = 0;
+  // Archived rows get the same recency cap as done rows. Without it the
+  // projection carries every archived task forever (full events/messages) and
+  // the file balloons; `--history` or a taskId still returns everything.
+  let shownArchived = 0;
+  let hiddenArchivedCount = 0;
   for (const row of rows) {
     if (row.status === 'done') {
       if (shownDone < doneLimit) {
@@ -1980,9 +1986,18 @@ function selectProjectionRows(rows, { taskId, includeHistory, doneLimit }) {
       }
       continue;
     }
+    if (row.status === 'archived') {
+      if (shownArchived < doneLimit) {
+        visibleRows.push(row);
+        shownArchived += 1;
+      } else {
+        hiddenArchivedCount += 1;
+      }
+      continue;
+    }
     visibleRows.push(row);
   }
-  return { visibleRows, hiddenDoneCount };
+  return { visibleRows, hiddenDoneCount, hiddenArchivedCount };
 }
 
 function taskProjection(db, {
@@ -2004,7 +2019,7 @@ function taskProjection(db, {
     display_id: row.display_id,
     legacy_ref: row.legacy_ref,
   }]));
-  const { visibleRows, hiddenDoneCount } = selectProjectionRows(rows, {
+  const { visibleRows, hiddenDoneCount, hiddenArchivedCount } = selectProjectionRows(rows, {
     taskId,
     includeHistory,
     doneLimit: Math.max(0, Number(doneLimit) || 0),
@@ -2028,6 +2043,7 @@ function taskProjection(db, {
       full_task_count: rows.length,
       visible_task_count: visibleRows.length,
       hidden_done_count: hiddenDoneCount,
+      hidden_archived_count: hiddenArchivedCount,
       done_limit: includeHistory ? null : Math.max(0, Number(doneLimit) || 0),
       event_limit: includeHistory ? null : Math.max(0, Number(eventLimit) || 0),
       message_limit: includeHistory ? null : Math.max(0, Number(messageLimit) || 0),

package/lib/task-proof.js

@@ -80,7 +80,11 @@ function taskProofLooksExecuted(proof) {
 function tailText(text, max = 400) {
   const trimmed = String(text || '').trim();
   if (trimmed.length <= max) return trimmed;
-  return `...${trimmed.slice(-max)}`;
+  // Keep the head as well as the tail: failures name their cause in the first
+  // lines (missing dependency, bad import), which a tail-only cut always loses.
+  const head = Math.floor(max / 2);
+  const tail = max - head;
+  return `${trimmed.slice(0, head)}\n...\n${trimmed.slice(-tail)}`;
 }
 
 // Run a verifier command and turn its real result into proof. This is the
@@ -112,6 +116,7 @@ function buildVerifiedProof(verifyCmd, baseProof = '', runner, options = {}) {
 }
 
 module.exports = {
+  tailText,
   taskProofLooksMeaningful,
   taskProofLooksExecuted,
   taskProofState,

package/lib/task-receipt.js

@@ -14,7 +14,11 @@ const { spawnSync } = require('child_process');
 function tailText(text, max = 400) {
   const trimmed = String(text || '').trim();
   if (trimmed.length <= max) return trimmed;
-  return `...${trimmed.slice(-max)}`;
+  // Keep the head as well as the tail: failures name their cause in the first
+  // lines (missing dependency, bad import), which a tail-only cut always loses.
+  const head = Math.floor(max / 2);
+  const tail = max - head;
+  return `${trimmed.slice(0, head)}\n...\n${trimmed.slice(-tail)}`;
 }
 
 function gitCommitHash(root) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.52.0",
+  "version": "3.53.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -13,6 +13,7 @@
     "cli/*.py",
     "commands/",
     "decks/",
+    "scripts/outbound-artifact-gate.js",
     "scripts/agent_worktree.py",
     "scripts/det/",
     "utils/",