atris 3.51.0 → 3.53.0

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.51.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/",

package/scripts/outbound-artifact-gate.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+
+const HTML_TAG_RE = /<!doctype\s+html|<\/?(?:html|head|body|div|section|article|main|table|thead|tbody|tr|td|th|p|br|span|h[1-6]|ul|ol|li|style|script|a|img|strong|em)\b[^>]*>/i;
+const ENCODED_HTML_RE = /&lt;\/?(?:html|head|body|div|table|tr|td|p|span|h[1-6]|ul|ol|li|style|script|svg)\b/i;
+const RENDERED_SOURCE_FENCE_RE = /```\s*(?:html|xml|jsx|tsx|css|svg|mermaid)\b/i;
+const COACH_INTERNAL_RE = /(?:\b(?:CLI|WEB|BE)-\d+\b|\b[0-9A-HJKMNP-TV-Z]{26}\b|\bmission-[a-z0-9-]+|(?:^|\s)--[a-z][a-z-]*\b|(?:^|\s)(?:\.atris|atris\/runs)\/|(?:^|\s)\/(?:Users|home|workspace|tmp)\/\S+)/im;
+const COACH_PRESSURE_RE = /\b(?:asap|urgent|time-sensitive|immediately|friendly reminder|just checking in|you still haven'?t|don'?t forget|why haven'?t you|you need to|productive day|great work|nice work|good job|keep the streak)\b/i;
+
+const SLOP_RULES = [
+  {
+    id: 'copy-slop-corporate-filler',
+    re: /\b(?:revolutionary|game[- ]changing|cutting[- ]edge|seamlessly|effortlessly|robust|powerful|comprehensive|leverage|utilize|facilitate|synergy|holistic|pivotal|crucial|unlock|supercharge)\b/i,
+    message: 'copy contains corporate filler or hype',
+  },
+  {
+    id: 'copy-slop-ai-tell',
+    re: /\b(?:it'?s worth noting that|as you can see|in order to|at the end of the day|great question|absolutely)\b/i,
+    message: 'copy contains an AI-tell phrase',
+  },
+  {
+    id: 'copy-slop-punctuation',
+    re: /[\u2014\u2728\u{1F680}\u{1F4A1}\u{1F3AF}]/u,
+    message: 'copy contains punctuation or decorative symbols blocked by the anti-slop gate',
+  },
+];
+
+const VALID_FORMATS = new Set(['plain', 'html', 'markdown', 'visual', 'source']);
+const VALID_COACH_SURFACES = new Set(['morning', 'evening', 'warm-ping']);
+
+function usage() {
+  return [
+    'Usage:',
+    '  node scripts/outbound-artifact-gate.js --channel email --format plain --body-file body.txt',
+    '  node scripts/outbound-artifact-gate.js --channel email --format html --body-file body.html --proof-file render.txt',
+    '',
+    'Options:',
+    '  --channel <email|slack|doc|deck|web|other>',
+    '  --format <plain|html|markdown|visual|source>',
+    '  --body <text>',
+    '  --body-file <path>',
+    '  --proof-file <path>   Required for html and visual formats',
+    '  --coach-surface <morning|evening|warm-ping>',
+    '  --signal-proof <path> Required for a warm-ping coach surface',
+    '  --visual              Require visual proof even when format is not visual',
+    '  --allow-slop          Skip anti-slop copy checks',
+  ].join('\n');
+}
+
+function parseArgs(argv) {
+  const options = {
+    channel: 'other',
+    format: 'plain',
+    body: '',
+    bodyFile: null,
+    proofFile: null,
+    coachSurface: null,
+    signalProof: null,
+    visual: false,
+    allowSlop: false,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+
+    const eq = arg.indexOf('=');
+    const key = (eq === -1 ? arg.slice(2) : arg.slice(2, eq)).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const inlineValue = eq === -1 ? null : arg.slice(eq + 1);
+
+    if (key === 'help') {
+      options.help = true;
+      continue;
+    }
+    if (key === 'visual' || key === 'allowSlop') {
+      options[key] = true;
+      continue;
+    }
+
+    const value = inlineValue !== null ? inlineValue : argv[i + 1];
+    if (value === undefined || value.startsWith('--')) {
+      throw new Error(`Missing value for --${arg.slice(2)}`);
+    }
+    i += inlineValue === null ? 1 : 0;
+
+    if (!Object.prototype.hasOwnProperty.call(options, key)) {
+      throw new Error(`Unknown option: --${arg.slice(2)}`);
+    }
+    options[key] = value;
+  }
+
+  return options;
+}
+
+function readBody(options) {
+  if (options.bodyFile) {
+    return fs.readFileSync(options.bodyFile, 'utf8');
+  }
+  return String(options.body || '');
+}
+
+function proofExists(proofFile) {
+  if (!proofFile) return false;
+  try {
+    fs.statSync(proofFile);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+function addError(errors, id, message) {
+  errors.push({ id, message });
+}
+
+function scanOutboundArtifact(options, body) {
+  const errors = [];
+  const format = String(options.format || 'plain').toLowerCase();
+  const channel = String(options.channel || 'other').toLowerCase();
+  const coachSurface = options.coachSurface ? String(options.coachSurface).toLowerCase() : null;
+
+  if (!VALID_FORMATS.has(format)) {
+    addError(errors, 'invalid-format', `format must be one of ${Array.from(VALID_FORMATS).join(', ')}`);
+    return errors;
+  }
+
+  if (coachSurface && !VALID_COACH_SURFACES.has(coachSurface)) {
+    addError(errors, 'invalid-coach-surface', `coach surface must be one of ${Array.from(VALID_COACH_SURFACES).join(', ')}`);
+  }
+
+  const sendsSource = format === 'source';
+  const needsRenderProof = format === 'html' || format === 'visual' || options.visual;
+
+  if (format === 'plain' && (HTML_TAG_RE.test(body) || ENCODED_HTML_RE.test(body))) {
+    addError(errors, 'raw-html-in-plain-body', 'plain body contains HTML source; send rendered HTML or rewrite as plain text');
+  }
+
+  if (!sendsSource && RENDERED_SOURCE_FENCE_RE.test(body)) {
+    addError(errors, 'rendered-source-fence', 'body contains source that should be rendered before sending');
+  }
+
+  if (channel === 'email' && format === 'markdown' && RENDERED_SOURCE_FENCE_RE.test(body)) {
+    addError(errors, 'markdown-email-source', 'email body contains fenced rendered source; attach source intentionally or render it first');
+  }
+
+  if (needsRenderProof && !proofExists(options.proofFile)) {
+    addError(errors, 'render-proof-missing', 'HTML or visual sends need --proof-file with preview, screenshot, PDF, or rendered-email receipt');
+  }
+
+  if (coachSurface) {
+    if (COACH_INTERNAL_RE.test(body)) {
+      addError(errors, 'coach-internal-language', 'coach copy contains an internal id, flag, or path');
+    }
+    if (COACH_PRESSURE_RE.test(body)) {
+      addError(errors, 'coach-pressure-language', 'coach copy contains urgency, guilt, nagging, or generic productivity praise');
+    }
+    if (coachSurface === 'warm-ping' && !proofExists(options.signalProof)) {
+      addError(errors, 'coach-signal-proof-missing', 'warm pings need --signal-proof for the fresh human event');
+    }
+  }
+
+  if (!options.allowSlop) {
+    for (const rule of SLOP_RULES) {
+      if (rule.re.test(body)) {
+        addError(errors, rule.id, rule.message);
+      }
+    }
+  }
+
+  return errors;
+}
+
+function main() {
+  let options;
+  try {
+    options = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    console.error(err.message);
+    console.error(usage());
+    process.exitCode = 2;
+    return;
+  }
+
+  if (options.help) {
+    console.log(usage());
+    return;
+  }
+
+  let body;
+  try {
+    body = readBody(options);
+  } catch (err) {
+    console.error(`failed to read body: ${err.message}`);
+    process.exitCode = 2;
+    return;
+  }
+
+  const errors = scanOutboundArtifact(options, body);
+  if (errors.length) {
+    console.error('outbound artifact gate failed');
+    for (const error of errors) {
+      console.error(`- ${error.id}: ${error.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('outbound artifact gate passed');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  HTML_TAG_RE,
+  RENDERED_SOURCE_FENCE_RE,
+  SLOP_RULES,
+  COACH_INTERNAL_RE,
+  COACH_PRESSURE_RE,
+  parseArgs,
+  scanOutboundArtifact,
+};